Ugrás a tartalomhoz

Tiny C Compiler

Ellenőrzött
A Wikipédiából, a szabad enciklopédiából
Tiny C Compiler
FejlesztőFabrice Bellard(wd)
Legfrissebb stabil kiadás0.9.27
Programozási nyelvC
Operációs rendszerplatformfüggetlen
Platform
Kategóriafordítóprogram
LicencLGPLv2.1(wd)
A Tiny C Compiler weboldala

A Tiny C Compiler (más néven TCC, tCc vagy TinyCC) egy x86, X86-64 és ARM processzoros C fordító, amelyet eredetileg Fabrice Bellard(wd) írt.[1] Úgy tervezték, hogy lassú számítógépeken, kevés lemezhelyen (pl. mentőlemezeken) működjön. A Windows operációs rendszer támogatását a 0.9.23-as verzióban (2005. június 17.) adta hozzá. A TCC-t a GNU Lesser General Public License alatt terjesztik.

A TCC azt állítja, hogy az ANSI C (C89/C90) teljes egészét[2], a C99(wd) ISO szabvány nagy részét[3], és számos GNU C kiterjesztést, beleértve az inline assembly-t is, megvalósítja.

Jellemzők

[szerkesztés]

A TCC számos olyan tulajdonsággal rendelkezik, amelyek megkülönböztetik a többi jelenlegi C fordítótól:

  • Kis fájlmérete (kb. 100 KB az x86-os TCC futtatható állománya esetében) és memóriaigénye(wd) lehetővé teszi, hogy közvetlenül egyetlen 1,44 M-es floppylemezről, például egy mentőlemezről lehessen használni.
  • A TCC célja, hogy nagyon gyorsan készítsen natív x86, x86-64 és ARM kódot; Bellard szerint körülbelül kilencszer gyorsabban fordít, assemblál és linkel, mint a GCC.[4] 2023-tól a „mob” fejlesztői ág tartalmazza a RISC-V és a TMS320C67xx(wd) (egy DSP chip) támogatását is.
  • A TCC számos fordítóspecifikus nyelvi jellemzővel rendelkezik, amelyek célja a gyakorlati megvalósíthatóság javítása, mint például egy opcionális memória- és kötésellenőrző, a jobb kódstabilitás érdekében.
  • A TCC lehetővé teszi a programok automatikus futtatását fordításkor egy parancssori kapcsoló(wd) segítségével. Ez lehetővé teszi a programok shell scriptként(wd) történő futtatását olyan Unix-szerű rendszereken, amelyek támogatják a shebang interpreter direktíva(wd) szintaxisát.

Az összeállított program teljesítménye

[szerkesztés]

Általánosságban elmondható, hogy a TCC megvalósítása az optimális teljesítményű eredmények helyett a kicsiségre (a futtatható kód kis méretére) helyezi a hangsúlyt. A TCC egyetlen menetben generálja a kódot, és nem végzi el a más fordítóprogramok által végzett optimalizálások többségét. A TCC minden utasítást külön-külön fordít le, és minden utasítás végén a regiszterértékek visszaíródnak a veremre, és újra kell őket olvasni, még akkor is, ha a következő sor a regiszterekben lévő értékeket használja (ami felesleges mentési/betöltési (push/pop) párokat hoz létre az utasítások között). A TCC a rendelkezésre álló regiszterek közül csak néhányat használ (pl. x86-on soha nem használja az ebx, esi vagy edi értékeket[5], mert ezeket a függvényhívások között meg kell őrizni).[6]

A TCC néhány optimalizálást(wd) hajt végre, mint például a konstansok szaporítása(wd) minden művelet esetében, a szorzások és osztások adott esetben eltolásokra optimalizálódnak, és az összehasonlító operátorok speciálisan optimalizáltak (a processzor jelzőinek(wd) speciális gyorsítótár fenntartásával). Emellett néhány egyszerű regiszterkiosztást(wd) is végez, ami megakadályozza, hogy egyetlen utasításon belül sok felesleges mentés/betöltés pár legyen.

Íme két benchmark példa:

  1. Egy rekurzív Fibonacci-algoritmus(wd) egy 1,8 GHz-es Intel Centrino laptopon 512 MB RAM-mal észrevehető különbséget eredményez a Microsoft Visual C++(wd) compiler 13.10.3052 és a TCC között. A 49. Fibonacci-szám kiszámításához az MS Visual C++ programnak körülbelül 18%-kal több időre volt szüksége, mint a TCC által lefordított programnak.
  2. Egy teszt során különböző C-fordítókat hasonlítottak össze úgy, hogy magát a GNU C Compilert (GCC) fordították le velük, majd az így kapott fordítókkal újra lefordították a GCC-t. A GCC 3.4.2-es verziójához képest a GCC fordításához módosított TCC tízszer gyorsabban tudta lefordítani a fordítót, de az általa előállított .exe 57%-kal nagyobb volt, és sokkal lassabb, 2,2-szer annyi időbe telt, mint a GCC újbóli lefordítása.[7]

    Az eredmények a következők voltak: A cc1 (a GCC C fordító) futtatása önmagában 518 másodpercet vett igénybe, amikor a GCC 3.4.2-vel fordították, 545 másodpercet a Microsoft C fordítóval, és 1145 másodpercet a TCC-vel. Ahhoz, hogy ezeket a fordítókat egyáltalán elkészítsük, a GCC (3.4.2) fordítása 744 másodpercet vett igénybe, míg a TCC csak 73 másodpercet. Az optimalizálási szint mindegyik fordítóban -O1 vagy hasonló volt.

Felhasználások

[szerkesztés]
  • TCCBOOT[8], egy olyan hack, ahol a TCC kb. 10 másodperc alatt betölt és elindít egy Linux kernelt a forrásból. Vagyis egy „bootloader”, amely beolvassa a Linux kernel forráskódját a lemezről, futtatható utasításokat ír a memóriába, és elkezdi azt futtatni. Ehhez változtatásokra volt szükség a Linux építési folyamatában.
  • A TCC-t használták a GCC fordítására, bár különböző javításokra volt szükség ahhoz, hogy ez működjön.[9]
  • A TCC-t a backdoor támadás elleni védelem bemutatására használták.[10] A GNU Guix(wd)[11] is használja, hogy a disztribúciót bináris program használata nélkül bootstrapelhetővé[12] tegye.[13]
  • A Cinpy[14] egy Python-könyvtár, amely lehetővé teszi a C-alapú függvények implementálását Python-modulokban. A függvények futásidőben TCC-vel kerülnek lefordításra. Az eredményeket a ctypes(wd) könyvtáron keresztül Pythonban hívhatóvá teszik.
  • JavaScript Linuxra telepítve[15] (szintén Bellard).
  • A Super Micro-Max sakkprogram forráskódjának fordított változatához referenciaként használták.[16]

Története

[szerkesztés]

A TCC eredete az Obfuscated Tiny C Compiler (OTCC)[17], egy program, amelyet Bellard írt, hogy megnyerje a Nemzetközi Obfuscated C Kódversenyt(wd) (IOCCC) 2001-ben. Ezt követően Bellard kibővítette és deobfuszkálta (visszakódolta olvashatóvá) a programot, hogy elkészüljön a tcc.[17]

2012. február 4. előtt valamikor Fabrice Bellard frissítette a projekt hivatalos weboldalát, hogy bejelentse, már nem dolgozik a TCC-n.[18]

Mióta Bellard elhagyta a projektet, különböző emberek és csoportok terjesztettek foltokat, vagy karbantartottak elágazásokat a TCC-hez, hogy a TCC-re építsenek, vagy javítsák a TCC-vel kapcsolatos problémákat. Ezek közé tartozik Dave Dodge nem hivatalos tcc foltok gyűjteménye[19], a Debian és a kfreebsd downstream(wd) foltjai[20], és grischka gcc foltjai.[7] Grischka egy nyilvános Git-tárat(wd) is létrehozott a projekthez[21], amely tartalmaz egy mob ágat[22], ahol számos hozzájárulást, többek között egy megosztott buildet, keresztfordítókat(wd) és SELinux-kompatibilitást(wd) adtak hozzá. Grischka GIT-tárából később a hivatalos TCC-tár lett (amelyre Fabrice Bellard Savannah projektoldalán[23] van hivatkozás).

Jelenlegi állapot

[szerkesztés]

2017 decemberében mind a hivatalos TCC levelezési lista[24], mind a hivatalos Git tároló (Fabrice Bellard Savannah projekt oldalán[25] érhető el) aktív vitát és fejlesztést mutat számos fejlesztő és érdeklődő felhasználó részéről. 2017 decemberében grischka a levelezési listán bejelentette, hogy a TCC 0.9.27-es verziója megjelent.[26]

Lásd még

[szerkesztés]

Jegyzetek

[szerkesztés]
  1. ↑ Fabrice Bellard (született 1972-ben) francia számítógépes programozó, aki az FFmpeg(wd), a QEMU(wd) és a Tiny C Compiler megírásáról ismert.
  2. ↑ Tiny C Compiler Reference Documentation accessed on 2008-08-07
  3. ↑ According to the project's TODO list complex types are the only missing C99 feature. Variable Length Arrays have been added in TCC 0.9.26
  4. ↑ TCC : Tiny C Compiler. bellard.org . (Hozzáférés: 2023. március 27.)
  5. ↑ A processzor regisztereinek a mnemonikja; az ebx adatregiszter, az esi forrásregiszter, az edi célregiszter.
  6. ↑ Glöckner, Daniel. Re: Tinycc-devel (no subject), 8 September 2006.
  7. ↑ a b grischka, GCC by TCC (some fixes), 29 September 2005
  8. ↑ TCCBOOT: TinyCC Boot Loader. bellard.org . (Hozzáférés: 2023. március 27.)
  9. ↑ tinycc-devel (thread). lists.gnu.org . (Hozzáférés: 2023. március 27.)
  10. ↑ Wheeler, David A. Countering Trusting Trust through Diverse Double-Compiling. ACSAC.
  11. ↑ Guix Further Reduces Bootstrap Seed to 25% — 2020 — Blog — GNU Guix
  12. ↑ A bootstrappable builds, olyan szoftverek fordítási folyamata, amelyek nem függenek olyan (fordító)binárisoktól, amelyeket nem ez a folyamat épít fel forrásból.
  13. ↑ Bootstrappable builds. bootstrappable.org . (Hozzáférés: 2023. március 29.)
  14. ↑ Cinpy. [2008. november 20-i dátummal az eredetiből archiválva]. (Hozzáférés: 2023. március 27.)
  15. ↑ JSLinux. bellard.org . (Hozzáférés: 2023. március 27.)
  16. ↑ Super Micro Chess. SourceForge . (Hozzáférés: 2023. március 27.)
  17. ↑ a b Bellard, Fabrice. Obfuscated Tiny C Compiler, winning entry of IOCCC 2001. https://bellard.org/otcc/ and at the Internet Archive at https://web.archive.org/web/20130721162702/http://www.ioccc.org/2001/
  18. ↑ TCC : Tiny C Compiler, 2012. február 4. [2012. február 4-i dátummal az eredetiből archiválva]. (Hozzáférés: 2023. március 27.)
  19. ↑ Unofficial tcc Patches. www.dododge.net . [2007. március 31-i dátummal az eredetiből archiválva]. (Hozzáférés: 2023. március 27.)
  20. ↑ Debian -- Details of package tcc in sid. packages.debian.org . (Hozzáférés: 2023. március 27.)
  21. ↑ grischka, Public Git Hosting for tcc
  22. ↑ grischka, mob branch for tcc
  23. ↑ Tiny C Compiler - Summary [Savannah]. savannah.nongnu.org . (Hozzáférés: 2023. március 27.)
  24. ↑ tinycc-devel Archives. lists.gnu.org . (Hozzáférés: 2023. március 27.)
  25. ↑ Public Git Hosting - tinycc.git/summary. repo.or.cz . (Hozzáférés: 2023. március 27.)
  26. ↑ [Tinycc-devel TCC version 0.9.27 is out]. lists.nongnu.org . (Hozzáférés: 2023. március 27.)

További információk

[szerkesztés]

Fordítás

[szerkesztés]
  • Ez a szócikk részben vagy egészben a Tiny C Compiler című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

A lap eredeti címe: „https://hu.wikipedia.org/w/index.php?title=Tiny_C_Compiler&oldid=27455795”