 | This articlerelies excessively onreferences toprimary sources. Please improve this article by addingsecondary or tertiary sources. Find sources: "GNU Compiler Collection" – news ·newspapers ·books ·scholar ·JSTOR(January 2022) (Learn how and when to remove this message) |
 | |
 Screenshot of GCC 10.2 compiling its own source code | |
| Original author(s) | Richard Stallman |
|---|---|
| Developer(s) | GNU Project |
| Initial release | March 22, 1987; 38 years ago (1987-03-22)[1] |
| Stable release | 14.2.0[2]  / 1 August 2024 |
| Repository | |
| Written in | C,C++[3] |
| Operating system | Cross-platform |
| Platform | GNU and many others |
| Size | ~15 millionLOC[4] |
| Available in | English |
| Type | Compiler |
| License | GPLv3+ with GCC Runtime Library Exception[5] |
| Website | gcc |
TheGNU Compiler Collection (GCC) is a collection ofcompilers from theGNU Project that support variousprogramming languages,hardware architectures andoperating systems. TheFree Software Foundation (FSF) distributes GCC asfree software under theGNU General Public License (GNU GPL). GCC is a key component of theGNU toolchain which is used for most projects related toGNU and theLinux kernel. With roughly 15 million lines of code in 2019, GCC is one of the largest free programs in existence.[4] It has played an important role in the growth offree software, as both a tool and an example.
When it was first released in 1987 byRichard Stallman, GCC 1.0 was named theGNU C Compiler since it only handled theC programming language.[1] It was extended to compileC++ in December of that year.Front ends were later developed forObjective-C,Objective-C++,Fortran,Ada,Go,D,Modula-2,COBOL andRust among others.[6] TheOpenMP andOpenACC specifications are also supported in the C and C++ compilers.[7][8]
GCC has beenported to more platforms andinstruction set architectures than any other compiler, and is widely deployed as a tool in the development of both free andproprietary software. GCC is also available for manyembedded systems, includingARM-based andPower ISA-based chips.
As well as being the official compiler of theGNU operating system, GCC has been adopted as the standard compiler by many other modernUnix-like computeroperating systems, including mostLinux distributions. MostBSD family operating systems also switched to GCC shortly after its release, although since then,FreeBSD andApple macOS have moved to theClang compiler,[9] largely due to licensing reasons.[10][11][12] GCC can also compile code forWindows,Android,iOS,Solaris,HP-UX,AIX andDOS.[13]
In late 1983, in an effort tobootstrap theGNU operating system,Richard Stallman askedAndrew S. Tanenbaum, the author of theAmsterdam Compiler Kit (also known as theFree UniversityCompiler Kit) for permission to use that software for GNU. When Tanenbaum advised him that the compiler was not free, and that only the university was free, Stallman decided to work on a different compiler.[14] His initial plan was to rewrite an existing compiler fromLawrence Livermore National Laboratory fromPastel to C with some help fromLen Tower and others.[15][16] Stallman wrote a new C front end for the Livermore compiler, but then realized that it required megabytes of stack space, an impossibility on a68000 Unix system with only 64 KB, and concluded he would have to write a new compiler from scratch.[15] None of the Pastel compiler code ended up in GCC, though Stallman did use the C front end he had written.[15][17]
GCC was first released March 22, 1987, available byFTP fromMIT.[18] Stallman was listed as the author but cited others for their contributions, including Tower for "parts of the parser, RTL generator, RTL definitions, and of the Vax machine description", Jack Davidson andChristopher W. Fraser for the idea of usingRTL as an intermediate language, and Paul Rubin for writing most of the preprocessor.[19] Described as the "first free software hit" byPeter H. Salus, the GNU compiler arrived just at the time whenSun Microsystems was unbundling its development tools fromits operating system, selling them separately at a higher combined price than the previous bundle, which led many of Sun's users to buy or download GCC instead of the vendor's tools.[20] While Stallman consideredGNU Emacs as his main project, by 1990 GCC supported thirteen computer architectures, was outperforming several vendor compilers, and was used commercially by several companies.[21]
As GCC was licensed under the GPL, programmers wanting to work in other directions—particularly those writing interfaces for languages other than C—were free to develop their ownfork of the compiler, provided they meet the GPL's terms, including its requirements to distributesource code. Multiple forks proved inefficient and unwieldy, however, and the difficulty in getting work accepted by the official GCC project was greatly frustrating for many, as the project favored stability over new features.[22] The FSF kept such close control on what was added to the official version of GCC 2.x (developed since 1992) that GCC was used as one example of the "cathedral" development model inEric S. Raymond's essayThe Cathedral and the Bazaar.
In 1997, a group of developers formed theExperimental/Enhanced GNU Compiler System (EGCS) to merge several experimental forks into a single project.[22][17] The basis of the merger was a development snapshot of GCC (taken around the 2.7.2 and later followed up to 2.8.1 release). Mergers included g77 (Fortran), PGCC (P5Pentium-optimized GCC),[17] many C++ improvements, and many new architectures andoperating system variants.[23]
While both projects followed each other's changes closely, EGCS development proved considerably more vigorous, so much so that the FSF officially halted development on their GCC 2.x compiler, blessed EGCS as the official version of GCC, and appointed the EGCS project as the GCC maintainers in April 1999. With the release of GCC 2.95 in July 1999 the two projects were once again united.[24][17] GCC has since been maintained by a varied group of programmers from around the world under the direction of a steering committee.[25]
GCC 3 (2002) removed a front-end forCHILL due to a lack of maintenance.[26]
Before version 4.0 the Fortran front end wasg77, which only supportedFORTRAN 77, but later was dropped in favor of the newGNU Fortran front end that supportsFortran 95 and large parts ofFortran 2003 andFortran 2008 as well.[27][28]
As of version 4.8, GCC is implemented in C++.[29]
Support forCilk Plus existed from GCC 5 to GCC 7.[30][31]
GCC has beenported to a wide variety ofinstruction set architectures, and is widely deployed as a tool in the development of both free andproprietary software. GCC is also available for manyembedded systems, includingSymbian (calledgcce),[32]ARM-based, andPower ISA-based chips.[33] The compiler can target a wide variety of platforms, includingvideo game consoles such as thePlayStation 2,[34] Cell SPE of PlayStation 3,[35] andDreamcast.[36] It has been ported to more kinds ofprocessors and operating systems than any other compiler.[37][self-published source?][better source needed]
As of the 15.1 release,[update] GCC includes front ends forC (gcc),C++ (g++),Objective-C,Objective-C++,Fortran (gfortran),Ada (GNAT),Go (gccgo),D (gdc, since 9.1),[38][39],Modula-2 (gm2, since 13.1),[40][41]COBOL (gcobol, since 15.1) andRust (gccrs, since 15.1) programming languages,[42] with theOpenMP andOpenACC parallel language extensions being supported since GCC 5.1.[8][43] Versions prior to GCC 7 also supportedJava (gcj), allowing compilation of Java to native machine code.[44]
Third-party front ends exist for many languages, such asALGOL 68,[45]Pascal (gpc),Mercury,Modula-3,VHDL (GHDL) andPL/I.[42] A few experimental branches exist to support additional languages, such as the GCCUPC compiler forUnified Parallel C[46].[47][better source needed]
Regarding language version support for C++ and C, since GCC 11.1 the default target isgnu++17, a superset ofC++17, andgnu11, a superset ofC11, with strict standard support also available. GCC also provides experimental support forC++20 andC++23.[48]
GCC's external interface followsUnix conventions. Users invoke a language-specific driver program (gcc for C,g++ for C++, etc.), which interpretscommand arguments, calls the actual compiler, runs theassembler on the output, and then optionally runs thelinker to produce a completeexecutable binary.
Each of the language compilers is a separate program that reads source code and outputsmachine code. All have a common internal structure. A per-language front endparses the source code in that language and produces anabstract syntax tree ("tree" for short).
These are, if necessary, converted to the middle end's input representation, calledGENERIC form; the middle end then gradually transforms the program towards its final form.Compiler optimizations andstatic code analysis techniques (such as FORTIFY_SOURCE,[49] a compiler directive that attempts to discover somebuffer overflows) are applied to the code. These work on multiple representations, mostly the architecture-independent GIMPLE representation and the architecture-dependentRTL representation. Finally,machine code is produced using architecture-specificpattern matching originally based on an algorithm of Jack Davidson and Chris Fraser.
GCC was written primarily inC except for parts of theAda front end. The distribution includes the standard libraries for Ada andC++ whose code is mostly written in those languages.[50][needs update] On some platforms, the distribution also includes a low-level runtime library,libgcc, written in a combination of machine-independent C and processor-specificmachine code, designed primarily to handle arithmetic operations that the target processor cannot perform directly.[51]
GCC uses many additional tools in its build, many of which are installed by default by many Unix and Linux distributions (but which, normally, aren't present in Windows installations), includingPerl,[further explanation needed]Flex,Bison, and other common tools. In addition, it currently requires three additional libraries to be present in order to build:GMP,MPC, andMPFR.[52]
In May 2010, the GCC steering committee decided to allow use of aC++ compiler to compile GCC.[53] The compiler was intended to be written mostly in C plus a subset of features from C++. In particular, this was decided so that GCC's developers could use thedestructors andgenerics features of C++.[54]
In August 2012, the GCC steering committee announced that GCC now uses C++ as its implementation language.[55] This means that to build GCC from sources, a C++ compiler is required that understandsISO/IEC C++03 standard.
On May 18, 2020, GCC moved away fromISO/IEC C++03 standard toISO/IEC C++11 standard (i.e. needed to compile, bootstrap, the compiler itself; by default it however compiles later versions of C++).[56]
Eachfront end uses a parser to produce theabstract syntax tree of a givensource file. Due to the syntax tree abstraction, source files of any of the different supported languages can be processed by the sameback end. GCC started out usingLALR parsers generated withBison, but gradually switched to hand-writtenrecursive-descent parsers for C++ in 2004,[57] and for C and Objective-C in 2006.[58] As of 2021 all front ends use hand-written recursive-descent parsers.
Until GCC 4.0 the tree representation of the program was not fully independent of the processor being targeted. The meaning of a tree was somewhat different for different language front ends, and front ends could provide their own tree codes. This was simplified with the introduction of GENERIC and GIMPLE, two new forms of language-independent trees that were introduced with the advent of GCC 4.0. GENERIC is more complex, based on the GCC 3.x Java front end's intermediate representation. GIMPLE is a simplified GENERIC, in which various constructs arelowered to multiple GIMPLE instructions. TheC,C++, andJava front ends produce GENERIC directly in the front end. Other front ends instead have different intermediate representations after parsing and convert these to GENERIC.
In either case, the so-called "gimplifier" then converts this more complex form into the simplerSSA-based GIMPLE form that is the common language for a large number of language- and architecture-independent global (function scope) optimizations.
GENERIC is anintermediate representation language used as a "middle end" while compiling source code intoexecutable binaries. A subset, calledGIMPLE, is targeted by all the front ends of GCC.
The middle stage of GCC does all of the code analysis andoptimization, working independently of both the compiled language and the target architecture, starting from the GENERIC[59] representation and expanding it toregister transfer language (RTL). The GENERIC representation contains only the subset of the imperativeprogramming constructs optimized by the middle end.
In transforming the source code to GIMPLE,[60] complexexpressions are split into athree-address code usingtemporary variables. This representation was inspired by the SIMPLE representation proposed in the McCAT compiler[61] by Laurie J. Hendren[62] for simplifying the analysis andoptimization ofimperative programs.
Optimization can occur during any phase of compilation; however, the bulk of optimizations are performed after the syntax andsemantic analysis of the front end and before thecode generation of the back end; thus a common, though somewhat self-contradictory, name for this part of the compiler is the "middle end."
The exact set of GCC optimizations varies from release to release as it develops, but includes the standard algorithms, such asloop optimization,jump threading,common subexpression elimination,instruction scheduling, and so forth. TheRTL optimizations are of less importance with the addition of global SSA-based optimizations onGIMPLE trees,[63] as RTL optimizations have a much more limited scope, and have less high-level information.
Some of these optimizations performed at this level includedead-code elimination,partial-redundancy elimination,global value numbering,sparse conditional constant propagation, andscalar replacement of aggregates. Array dependence based optimizations such asautomatic vectorization andautomatic parallelization are also performed.Profile-guided optimization is also possible.[64]
The GCC project includes an implementation of theC++ Standard Library called libstdc++,[65] licensed under the GPLv3 License with an exception to link non-GPL applications when sources are built with GCC.[66]
Some features of GCC include:
-fgnu-tm.[7][71]
The primary supported (and best tested) processor families are 64- and 32-bit ARM, 64- and 32-bitx86 64 andx86 and 64-bitPowerPC andSPARC.[75]
GCC target processor families as of version 11.1 include:[76]
Lesser-known target processors supported in the standard release have included:
Additional processors have been supported by GCC versions maintained separately from the FSF version:
TheGCJ Java compiler can target either a native machine language architecture or theJava virtual machine'sJava bytecode.[79] Whenretargeting GCC to a new platform,bootstrapping is often used. Motorola 68000, Zilog Z80, and other processors are also targeted in the GCC versions developed for various Texas Instruments, Hewlett Packard, Sharp, and Casio programmable graphing calculators.[80]
GCC is licensed under theGNU General Public License version 3.[81] TheGCC runtime exception permits compilation of proprietary programs (in addition to free software) with GCC headers and runtime libraries. This does not impact the license terms of GCC source code.[82]
So he wrote to VUCK's author asking if GNU could use it. Evidently, VUCK's developer was uncooperative, responding that the university was free but that the compiler was not.
The GCC has been ported to (i.e., modified to run on) more than 60 platforms, which is more than for any other compiler.
{{cite web}}: CS1 maint: bot: original URL status unknown (link)
| General | |||
|---|---|---|---|
| Software packages | |||
| Community | |||
| Organisations | |||
| Licenses |
| ||
| Challenges | |||
| Related topics | |||
| Authority control databases: National |
|---|
