Compileren
previous.png
Cursus Linux       Advanced       Compileren en Make       Compileren   


up.png Compileren, gcc leren gebruiken down.png

In dit lesonderdeel wordt het hanteren van de gcc compiler aangeleerd. We compileren onder andere, verschillende c-programma's, een statische library, een een dynamische library, get equivalent van .dll bestanden onder windows.

Wat leren we in dit hoofdstuk ?

up.png 1 De gcc compiler down.png

UNIX en zeker Linux is volledig ontwikkeld in C. De C-taal is in de loop der jaren de standaard geworden voor alles wat onder UNIX / Linux geprogrammeerd wordt. Onder Linux is de gcc compiler de meest ontwikkelde compiler die onder andere de c-taal ondersteund.

De compiler 'gcc' is één van de meest ontwikkelde compilers die er bestaan. gcc ondersteund alle c standaarden die momenteel in gebruik zijn, bv. de ANSI C standaard, alsook vele add-ons en extra standaarden door gcc zelf gedefinieerd.

gcc is ook en C++ compiler. Voor diegenen die liever in een object oriented programmeer taal werken, ondersteund gcc de C++ taal met alle daaraan verbonden stijlen en technieken. gcc levert voor zowel C als voor C++ de nodige class libraries. Behalve gcc bestaat er ook nog gcj, dewelke java code compileert.

In de volgende paragrafen wordt gcc gebruikt om c programma's onder Linux te compileren.

up.png 1.1 gcc installeren down.png

Ubuntu
  1. Synaptic Package Manager
  2. Zoeken naar gcc
  3. Markeren voor install
  4. Installeren
SuSe SLES
  1. YaST -> Software Beheer
  2. zoeken naar gcc
  3. gcc aanklikken
  4. accepteren -> doorgaan
Fedora 7

Meestal is gcc standaard geïnstalleerd.

up.png 1.2 Project directory down.png

Omdat we in de komende paragrafen enkele c-programma's en een make-bestand gaan aanmaken, maken we eerst een subdirectory in onze home directory. Gebruik de opdracht mkdir ~/project om onze 'project' directory aan te maken.
Plaats jezelf in deze sub-directory, doe dit in het vervolg altijd als je aan het project werkt.

up.png 1.3 Source code editors down.png

Met behulp van 'vi' kan men in iedere UNIX / Linux omgeving ASCII bestanden editeren. Natuurlijk bestaan er hiervoor toch wel ietwat andere editors die misschien een voordeel t.o.v. 'vi' geven.
Met bijvoorbeeld de GNOME 'gedit' ASCII editor kan men werken in een GUI met alle bijbehorende voordelen, zoals bv. een menu. Maar het belangrijkste voordeel is natuurlijk de syntax highlighting die hier automatisch, dankzij de .c extensie, voor de c-code ingesteld wordt. Ook KDE levert een goede ASCII editor die kate wordt genoemd. Voor onze doeleinden in deze cursus is 'vi' genoeg, alhoewel de syntax highlighting van gedit of kate toch wel leuk zijn, de keuze is aan de student.

Voor diegene die nog verder wil gaan, zijn er natuurlijk verschillende IDE (Integrated Development Environment), vanuit Linux zelf is er Kdevelop (KDE omgeving), vanuit de java omgeving is er bv. Eclipse, maar ook JEDIT.
Voor deze laatste IDE's vindt men al het nodige terug op het internet.
Een dergelijk IDE leren gebruiken voor de hooguit 20 lijntjes source code die we hier gaan gebruiken is sterk overdreven, de info is gegeven as such.

up.png 2 Compileer je eerste programma down.png

up.png 2.1 Je eerste C programma down.png

Voor dit eerste voorbeeld start vi en vul de tekst van de source code zoals het screen shot hieronder toont in.
Sla het bestand op als hello.c.

src01.png

up.png 2.2 Je eerste compilatie down.png

Om een C programma, het source code bestand is herkenbaar aan de extensie .c, te compileren tot een uitvoerbaar programma, gebruik de opdracht
      gcc -o hello hello.c
Deze opdracht produceert een uitvoerbaar bestand genaamd 'hello' vanuit het source bestand hello.c. Vervolgens kan je je eerste programma testen met de opdracht
      ./hello.

Uiteraard is dit programma werkzaam vanaf de eerste keer. Maar in de achtergrond heeft gcc toch enige dingen bewerkstelligd.

  1. gcc heeft het source bestand hello.c gecompileerd naar een object bestand hello.o
  2. gcc heeft het object bestand hello.o gelinkt t.ov. de stdio library (libc) teneinde de functie printf te kunnen linken
  3. de output van het linking process is in het bestand hello opgeslagen zoals gevraagd was met de optie -o

Men kan de opdracht
      ldd hello
kan men zien naar welke library's gcc links gelegd heeft.

up.png 3 Werken met meerdere source bestanden down.png

Als men werkelijk begint met programmeren zal men al gauw een programma van enkele honderden lijnen beginnen te produceren. Het wordt op dat ogenblik interessant om sommige delen van het programma in functie vorm te gaan schrijven, omwille van allerlei redenen, hier dieper op ingaan valt buiten het bestek van de cursus.

up.png 3.1 Meerdere source bestanden compileren down.png

Bij het schrijven van grotere programma's zal het gezond verstand weldra verlangen dat je het programma opdeelt in functies. Het volgende voorbeeld demonstreerd hoe men met verschillende source bestanden, 1 functie per source bestand, 1 programma maakt.

Voer de 3 source bestanden in met behulp van een ASCII editor. De volgende screen-shots toont hun inhoud.

src02.png

src03.png

src04.png

Om het programma nu te compileren tot een werkend programma gebruik de opdracht:
       gcc -o hello2 hello2.c greetings.c personal.c
In de achtergrond verricht gcc precies dezelfde taken als in het eerste voorbeeld, en produceert het werkzame programma hello2, dat met de gelijknamige opdracht ./hello2 kan uitgevoerd worden.

up.png 3.2 Werken met een statische library down.png

Behalve werken zoals in het voorgaande voorbeeld kan men de object bestanden die vanaf de source bestanden aangemaakt worden apart verzamelen in een zogenaamde statische bibliotheek. Op dat moment is het niet langer nodig om tijdens het compileren van een programma alle source bestanden met daarin functies apart te compileren, ze zijn immers al gecompileerd aanwezig in een library. Het volstaat om het programma te linken met de betreffende library.
Maak nog een source bestand genaamd: inlib.c, de screen shot toont de inhoud.

src05.png

In een library heeft het alleen maar zin om object (.o) bestanden op te slaan.

Om de functies opgenomen in een library kenbaar te maken aan de linker moet men ze opnemen in een zogenaamd include bestand. Dit bestand wordt libstuff.h genoemd.

src06.png
De inhoud van libstuff.h.

Op het moment dat men een programma schrijft dat gebruik maakt van de functies opgeslagen in libstuff.a, voorziet men in dit programma een include statement waarmee men naar de include file van library verwijst.
Vervolgens kan men in het programma zelf, gebruik maken van de library functies. Zie de volgende screen-shot.

src07.png
hello3.c maakt gebruik van functies opgeslagen in libstuff.a.

Vervolgens kan men het programma compileren met de opdracht:
       gcc -L. -I. -o hello3 hello3.c libstuff.a

Zowel de nadelen (de library moet op het systeem aanwezig zijn) als de voordelen spreken voor zich. Kijk eens naar de grote van het hello3 programma tegenover de grote van het hello2 programma. Hello2 is een stuk groter in omvang dan hello3 ondanks dat hello3 meer doet.

up.png 3.3 Een static linked programma compileren down.png

Een static linked programma neemt vanuit de library de nodige functies en bouwt deze intern in het programma in. Dit betekent dat men na het compileren de library niet langer nodig heeft. Maak het volgende programma hello4 dat voor dit doel gebruikt kan worden.

src08.png

Door het programma te compileren met de optie -static worden alle library functies in het programma zelf gekopieerd, hierdoor wordt het programma groot in omvang, maar wel onafhankelijk van enige bibliotheek. De volledige opdracht voor hello4.c luidt:
       gcc -L. -I. -o hello4 hello4.c -static libstuff.a

up.png 3.4 Werken met een shared library down.png

Het verschil van een shared library tegenover een statische library is dat de functies in de shared library shared zijn tegenover alle processen op het systeem. Anders gezegd de shared functies draaien in shared memory ieder nieuw proces dat geladen wordt en de shared functies gebruikt hoeft ze niet opnieuw te laden, maar kan ze rechtstreeks in het geheugen aanspreken. Dit spaart het geheugen gebruik.
De volgende screen shot toont een functie die speciaal voor dit doel geschreven is:

src09.png
Een functie die speciaal geschreven is om als shared functie te dienen.

Om de source bestanden te compileren als shared object bestanden is de opdracht
       gcc -c -fpic greetings.c personal.c inlib2.c
Om de shared library aan te maken is de opdracht
       gcc -shared -o ./libstuff.so greetings.o personal.o inlib2.o
Het library bestand libstuff.so is nu aangemaakt.
Onderstaande screen-shot toont de inhoud van een demonstratie programma om gebruik te maken van de shared library.

src10.png
Een programma dat gebruik maakt van de functies in de shared library.

Het programma wordt gecompileerd met de opdracht
       gcc -L. -I. -o hello5 hello5.c -lstuff.
Het programma wordt netjes gecompileerd en gelinkt tegenover de libstuff.so shared library.

src11.png
Het programma 'hello5' kan niet draaien omdat de library libstuff.so niet geïnstalleerd is.

up.png 3.5 Een shared library installeren down.png

Alvorens een programma kan gebruik maken van de shared functies uit een library moet deze library in het systeem geïnstalleerd worden.
Dit bereikt men door simpelweg het library bestand in de juiste directory te copiŽren.
Gebruik hiervoor de opdracht:
       cp libstuff.so /usr/lib

Dit is een vrij simpele noodoplossing ten behoeve van deze les,
zie http://www.linux.org/docs/ldp/howto/Program-Library-HOWTO/shared-libraries.html
voor het werken met shared libraries.

up.png Samenvatting down.png

In dit lesonderdeel hebben we leren werken met gcc, en hebben we geleerd hoe c programma's in elkaar zitten. Tevens hebben we geleerd hoe men gebruik kan maken van libraries, zowel de statische vorm als de dynamische vorm.

up.png Literatuur down.png



previous.png
Cursus Linux       Advanced       Compileren en Make       Compileren   
Last modified: Thu Feb 12 13:31:49 2015Thu Feb 12 13:31:49 2015