Code factoring in GCC on different intermediate languages

Csaba Nagy, Gábor Lóki, A. Beszédes, T. Gyimóthy

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Today as handheld devices (smart phones, PDAs, etc.) are coming to be increasingly popular, the storage capacity becomes more and more important. One way to increase capacity is to optimize static executables on the device. This resulted that code-size optimization gets bigger attention nowadays and new techniques are observed, like code factoring which is still under research. GNU GCC as the most common compiler in the open source community has many implemented algorithms for code-size optimization, but currently the compiler is still weak in these methods, which can be turned on using the '-Os' flag. In this article we would like to give an overview about implementing different code factoring algorithms (local factoring, sequence abstraction, interprocedural abstraction) on the IPA, Tree, Tree SSA and RTL passes of GCC. The correctness of the implementation has been checked, and the results were measured on different architectures with GCC's official Code-Size Benchmark Environment (CSiBE) as real-world system. These results showed that on the ARM architecture we could achieve maximum 61.53% and 2.58% average extra code-size saving compared to the '-Os' flag of GCC.

Original languageEnglish
Title of host publicationProceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007
PublisherEotvos Lorand University
Pages81-95
Number of pages15
ISBN (Print)9789634639251
Publication statusPublished - 2007
Event10th Symposium on Programming Languages and Software Tools, SPLST 2007 - Dobogoko, Hungary
Duration: Jun 14 2007Jun 16 2007

Other

Other10th Symposium on Programming Languages and Software Tools, SPLST 2007
CountryHungary
CityDobogoko
Period6/14/076/16/07

Fingerprint

Personal digital assistants

ASJC Scopus subject areas

  • Software

Cite this

Nagy, C., Lóki, G., Beszédes, A., & Gyimóthy, T. (2007). Code factoring in GCC on different intermediate languages. In Proceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007 (pp. 81-95). Eotvos Lorand University.

Code factoring in GCC on different intermediate languages. / Nagy, Csaba; Lóki, Gábor; Beszédes, A.; Gyimóthy, T.

Proceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007. Eotvos Lorand University, 2007. p. 81-95.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Nagy, C, Lóki, G, Beszédes, A & Gyimóthy, T 2007, Code factoring in GCC on different intermediate languages. in Proceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007. Eotvos Lorand University, pp. 81-95, 10th Symposium on Programming Languages and Software Tools, SPLST 2007, Dobogoko, Hungary, 6/14/07.
Nagy C, Lóki G, Beszédes A, Gyimóthy T. Code factoring in GCC on different intermediate languages. In Proceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007. Eotvos Lorand University. 2007. p. 81-95
Nagy, Csaba ; Lóki, Gábor ; Beszédes, A. ; Gyimóthy, T. / Code factoring in GCC on different intermediate languages. Proceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007. Eotvos Lorand University, 2007. pp. 81-95
@inproceedings{e48d9e8ed18d4fcc8583509f5475773d,
title = "Code factoring in GCC on different intermediate languages",
abstract = "Today as handheld devices (smart phones, PDAs, etc.) are coming to be increasingly popular, the storage capacity becomes more and more important. One way to increase capacity is to optimize static executables on the device. This resulted that code-size optimization gets bigger attention nowadays and new techniques are observed, like code factoring which is still under research. GNU GCC as the most common compiler in the open source community has many implemented algorithms for code-size optimization, but currently the compiler is still weak in these methods, which can be turned on using the '-Os' flag. In this article we would like to give an overview about implementing different code factoring algorithms (local factoring, sequence abstraction, interprocedural abstraction) on the IPA, Tree, Tree SSA and RTL passes of GCC. The correctness of the implementation has been checked, and the results were measured on different architectures with GCC's official Code-Size Benchmark Environment (CSiBE) as real-world system. These results showed that on the ARM architecture we could achieve maximum 61.53{\%} and 2.58{\%} average extra code-size saving compared to the '-Os' flag of GCC.",
author = "Csaba Nagy and G{\'a}bor L{\'o}ki and A. Besz{\'e}des and T. Gyim{\'o}thy",
year = "2007",
language = "English",
isbn = "9789634639251",
pages = "81--95",
booktitle = "Proceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007",
publisher = "Eotvos Lorand University",

}

TY - GEN

T1 - Code factoring in GCC on different intermediate languages

AU - Nagy, Csaba

AU - Lóki, Gábor

AU - Beszédes, A.

AU - Gyimóthy, T.

PY - 2007

Y1 - 2007

N2 - Today as handheld devices (smart phones, PDAs, etc.) are coming to be increasingly popular, the storage capacity becomes more and more important. One way to increase capacity is to optimize static executables on the device. This resulted that code-size optimization gets bigger attention nowadays and new techniques are observed, like code factoring which is still under research. GNU GCC as the most common compiler in the open source community has many implemented algorithms for code-size optimization, but currently the compiler is still weak in these methods, which can be turned on using the '-Os' flag. In this article we would like to give an overview about implementing different code factoring algorithms (local factoring, sequence abstraction, interprocedural abstraction) on the IPA, Tree, Tree SSA and RTL passes of GCC. The correctness of the implementation has been checked, and the results were measured on different architectures with GCC's official Code-Size Benchmark Environment (CSiBE) as real-world system. These results showed that on the ARM architecture we could achieve maximum 61.53% and 2.58% average extra code-size saving compared to the '-Os' flag of GCC.

AB - Today as handheld devices (smart phones, PDAs, etc.) are coming to be increasingly popular, the storage capacity becomes more and more important. One way to increase capacity is to optimize static executables on the device. This resulted that code-size optimization gets bigger attention nowadays and new techniques are observed, like code factoring which is still under research. GNU GCC as the most common compiler in the open source community has many implemented algorithms for code-size optimization, but currently the compiler is still weak in these methods, which can be turned on using the '-Os' flag. In this article we would like to give an overview about implementing different code factoring algorithms (local factoring, sequence abstraction, interprocedural abstraction) on the IPA, Tree, Tree SSA and RTL passes of GCC. The correctness of the implementation has been checked, and the results were measured on different architectures with GCC's official Code-Size Benchmark Environment (CSiBE) as real-world system. These results showed that on the ARM architecture we could achieve maximum 61.53% and 2.58% average extra code-size saving compared to the '-Os' flag of GCC.

UR - http://www.scopus.com/inward/record.url?scp=84901999839&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=84901999839&partnerID=8YFLogxK

M3 - Conference contribution

SN - 9789634639251

SP - 81

EP - 95

BT - Proceedings of the 10th Symposium on Programming Languages and Software Tools, SPLST 2007

PB - Eotvos Lorand University

ER -