Kodovani P°edchozφ Nßsledujφcφ Obsah

---

9. Roz╣φ°enφ jazyka GNU C

Jazyk GNU C mß n∞kterΘ u╛iteΦnΘ ro╣φ°enφ oproti Ansi C, kterΘ se hodφ hlavn∞, kdy╛ chcete mφt program hodn∞ rychl², a prßv∞ o nich se tu m∙╛ete n∞co doΦφst. O roz╣φ°enφch G++ oproti C++ se tu zmi≥ovat nebudu.

9.1 Inline funkce versus built-in

Jazyk C se kompiluje jen do malΘ podmno╛iny instrukcφ poΦφtaΦe. Standard °φkß, ╛e ostatnφ (jako t°eba in, out, cli apod.) jsou p°φli╣ zßvislΘ na architektu°e, ne╛ aby se dßvaly do jazyka a jedinß sprßvnß cesta je volat je z knihovnφch funkcφ, kterΘ jsou psanΘ v assembleru.

Bohu╛el Φasto se tyto funkce pou╛φvajφ ke zrychlenφ v²sledku. Existuje nap°φklad mnoho chytr²ch cest, jak kopφrovat pam∞╗ (rep movsb na xt a 286, po 32bitov²ch blocφch na 386 a 486, p°es koprocesor na pentiu..), kterΘ ani ten nejchyt°ej╣φ p°ekladaΦ z jednoduchΘho for cyklu nevymyslφ. Nebo jsou situace, kdy takovΘ instrukce musφte pou╛φvat Φasto (t°eba out a in v hardwarov²ch driverech) a jejich volßnφ jako funkcφ zdr╛uje, zv∞t╣uje k≤d a p°inß╣φ dal╣φ potφ╛e.

Jedna odpov∞∩ na to je built-in. Do p°ekladaΦe se zaintegrujφ nejΦast∞j╣φ takovΘ p°φpady (jako je memset, outb apod.) a ten potom umφ sßm generovat optφmßlnφ k≤d. Takov²ch funkci je hodn∞ (podφvejte se do string.h a math.h nap°φklad sin, cos, abs, fabs, strcpy, strdup, memcpy, memmove a takhle bych mohl pokraΦovat je╣t∞ hodn∞ dlouho) °ßdov∞ se to pohybuje podle mΘho nßzoru ve stovkßch. JednotlivΘ p°ekladaΦe se Φasto triumfujφ v tom, kdo mß vφce takov²ch funkcφ integrovan²ch, a n∞kterΘ - jako t°eba Watcom C - jich umφ opravdu hodn∞.

Na druhou stranu je to jenom jakßsi o╣klivß v²pomoc, kterß funguje jen v nejΦast∞j╣φch p°ipadech. P°edstavte si t°eba, ╛e jste vymysleli bezvadnou cestu jak implementovat nßsobenφ ve fixedpointu a chcete to pou╛φt ve sv²ch programech. V knihovn∞ takovß funkce ale nenφ a tak ani compiler ji nemß jako builtin. A mßte sm∙lu. Takov²ch p°φpad∙ jsou doslova tisφce - nap°φklad memset pro 16ti a 32 bitovß Φφsla, kter² se hodφ pro truecolor apod. Navφc se to rozchßzφ s filozofiφ C jako minimßlnφho ale maximßln∞ rychlΘho jazyka.

V GCC v²vojß°i zvolili jinou cestu. Builtin je opravdu jenom n∞kolik zßkladnφch funkcφ (abort, abs, alloca, cos, exit, fabs, ffs, labs, memcmp, memcpy, sin, sqrt, strcmp, strcpy, strlen) a to hlavn∞ proto, ╛e jsou natolik ΦastΘ, ╛e je t°eba nejenom generovat optimßlnφ k≤d bez volßnφ funkce ale t°eba i p°edpoΦφtßvat jejich v²sledek pro konstantu a d∞lat dal╣φ podobnΘ optimalizace specifickΘ pro danou funkci. Mφsto toho ale do GCC p°idali n∞kolik roz╣φ°enφ tak, aby b∞╛n² programßtor, ani╛ by m∞nil p°ekladaΦ, si mohl vytvo°it svoje vlatsnφ funkce, kterΘ se chovajφ podobn∞ jako built-in. Tyto roz╣φ°enφ se navφc pou╛φvajφ i v mnoha jin²ch p°φpadech. Je to:

• Roz╣φ°enß syntaxe asm
• extern inline funkce, kterΘ jsou stejn∞ rychlΘ jako makra
• __builtin_constant_p
• atributy funkcφ

9.2 Roz╣φ╛enφ ╣ikovnß hlavn∞ pro optimalizaci

Mezi nejzajφmav∞j╣φ roz╣φ°enφ pro optimalizaci pat°φ:

• Roz╣φ°enφ (nejenom) pro psanφ maker
  • Statements ve v²razech
  • typeof
  • lokßlnφ labely
  • Makra s prom∞nn²m poΦtem parametr∙
• Explicitnφ urΦovßnφ regitr∙ pro prom∞nΘ

9.3 Ostatnφ

Gcc mß mnoho dal╣φch roz╣φ╛enφ jako je nap°φklad:

• Pou╛φvßnφ label∙ jako hodnot (ukazatel = &&label, goto *ukazatel)
• aritmetika s labely a ukazately na funkce
• aritmetika s ukazately typu void (fungujφ podobn∞ jako char *)
• intervaly pro case (case 1 ... 9:)
• long long (64 bit integer)
• long double (jako extended v Pascalu)
• vno°enΘ funkce (jako v Pascalu)
• atributy pro prom∞nΘ a typy urΦujφcφ zarovnßvßnφ, pakovßnφ struktur apod.
• konstrukce volßnφ funkce parametr po parametru
• Pojmenovßvßnφ typ∙ v²razu (typedef cislo = (1/2))
• Roz╣φ°enΘ lvalues ((a ? b : c) = 5)
• Contitionals (x ? : y je stejnΘ jako x ? x : y)
• Pole s pron∞nou velikostφ (urΦenou nap°φklad parametrem funkce)
• Pole s nulovou velikostφ (hodφ se nap°φklad jako odrß╛ka ve struktu°e)
• Roz╣φ°enß inicialializace polφ (int a[6]={ [4] 29, [2] 15};)
• P°etypovßvßnφ na typ union (u = (union foo) x == u.i = x;)
• Pou╛φvßnφ jmen funkcφ jako string∙ (__FUNCTION__)
• Roz╣φ°enφ p°ejatß z C++
  • Jedno°ßdkovΘ komentß°e
  • Nekonstantnφ inicializace (int a[2]={p - q,p + q})

Toto nenφ ale kompletnφ seznam. GNU C obsahuje i dal╣φ vφce Φi mΘn∞ u╛iteΦnΘ roz╣φ°enφ. Rßd bych vφce popsal ty podle mΘho nßzoru nejzajφmav∞j╣φ.

9.4 Roz╣φ°enß syntax asm

Jako skoro ka╛d² p°ekladaΦ C i GCC mß mo╛nost vklßdßnφ inline assembleru. V GCC to je ale °e╣eno o dost odli╣n∞. V∞t╣ina lidφ se toho d∞sφ a ptß se, proΦ to u GNU neud∞lali normßln∞. Nev∞dφ ale, ╛e to bylo takto vymy╣leno pro jejich dobro. ╪e╣enφ v GCC mß toti╛ n∞kolik v²hod.

Na prvnφ pohled ka╛dΘho p°ekvapφ zm∞n∞nß syntax. Nejjednodu╣╣φ pou╛itφ ASM vypadß asi takto:

GCC: asm("cli");
BC:  asm { cli }

Dal╣φm rozdφlem je to, ╛e GCC pou╛φvß AT&T syntax assembleru. To samo osob∞ nep°inß╣φ ╛ßdnou v²hodu ale ani nev²hodu. GCC funguje tak, ╛e cel² °et∞zec v asm prost∞ po╣le dßl assembleru a tak v∙bec nic o assembleru v∞d∞t nemusφ. To mß tu v²hodu, ╛e nap°φklad m∙╛ete pou╛φt MMX instrukce, pokud je umφ assembler a nemusφte kv∙li tomu shßn∞t novou verzi GCC, kterß by pro MMX m∞la n∞jakou specißlnφ podporu.

Navφc jsou programßto°i, (jako jß) kte°φ pova╛ujφ AT&T syntax za normßlnφ a nechßpou jak mohli intelovΘ tu jejich tak zkazit.

Nejd∙le╛it∞j╣φ rozdφl ale je v optimalizaci. Pokud p°ekladaΦ uvidφ jednoduch² zßpis:

asm {
    mov ex,16
    mov cx,si
    int 17
}

Ale ani u jednodu╣╣φch p°φklad∙ si nem∙╛e b²t jist. Nem∙╛e znßt celou instrukΦnφ sadu (proto╛e se stßle objevujφ novΘ procesory a klony s nov²mi instrukcemi - viz MMX), v╣echny vedlej╣φ uΦφnky, chyby v procesoru apod. a tak jednodu╣╣e nem∙╛e nic po°ßdnΘho o takovΘm kusu assembleru p°edpoklßdat. A to ani o samotnΘ instrukci cli v minulΘm prφpad∞. P°edstavte si, ╛e pφ╣ete program, kter² Φasto zapφna a v²pφnß interrupty, ud∞lßte si tedy inline funkce pro cli a sti:

static inline cli(void) { asm {cli}}
static inline sti(void) { asm {sti}}

GCC je na tom lΘpe. Pokud u asm explicitn∞ ne°eknete, ╛e n∞co m∞nφ, p°edpoklßdß se, ╛e nem∞nφ nic. To jde tak daleko, ╛e u funkcφ:

static inline cli(void) { asm("cli");}
static inline sti(void) { asm("sti");}

static inline cli(void) { asm volatile ("cli");}
static inline sti(void) { asm volatile ("sti");}

Ale po°ßd to nenφ ono - optimalizace jde pou╛φvat jen u n∞kter²ch hodn∞ hloup²ch funkcφ jako je cli, kterΘ nic nem∞nφ (ani registry) a nic neΦtou (proto╛e optimizer m∙╛e usoudit, ╛e se mu hodφ vß╣ assembler provΘdst jindy a funkci m∙╛e celou p°ehßzet). proto ani nem∙╛ete p°edpoklßdat, ╛e u╛ v╣echno co jste napsali p°ed asm je u╛ hotovΘ.

A proto mß asm dal╣φ ro╣φ°enφ. Za samotn²m stringem m∙╛ete napsat : a zadat, jakΘ mß funkce v²stupy, jakΘ vstupy a co modifikuje. To dß optimizeru p∞kn² obrßzek o tom, co vlastn∞ vß╣ program d∞lß a m∙╛e provßd∞t dal╣φ optimalizace.

Vstupnφ a v²stupnφ parametry jsou v assembleru potom p°φstupnΘ jako %0, %1 atd. (vstupy nap°ed, v²stupy potom.) p°i kompilaci GCC potom projde string s assemblerem na % kombinace a nahradφ je prav²m umφst∞nφm prom∞nΘ. Aby ale nedochßzelo ke kolizφm z oΦφslovan²mi registry, je nutnΘ u asm ze vstupy a v²stupy psßt dv∞ % u registr∙, tedy %%eax mφsto %eax. Nap°φklad:

asm volatile ("outb %1, %0"
    :
    : "d" (port),
      "a" (data));

• g - cokoliv (konstanta, registr, pam∞╗)
• r - libovolnß hodnota v registru
• m - hodnota musφ b²t v pam∞ti
• i - hodnota musφ b²t ,,immediate'' tedy konstanta znßmß p°i kompilaci
• registry: a - eax, d - edx, c - ecx, d - edx, D - edi, S - esi
• q - a, b, c nebo d
• f - floating point registr
• t - prvnφ fp registr (top of stack)
• s - druh² fp registr (second)

Tento formßt vychßzφ ze zp∙sobu, jak²m GCC uchovßvß RTL instrukce a machine description (popis architektury).

Funkce out fungujφcφ i pro konstantφ port je tedy:

       asm volatile ("outb %1, %0"
          :
          : "Nd" (port),
            "a" (data));

• k - celΘ slovo (eax)
• b - byte (al)
• h - hornφ byta (ah)
• w - word (ax)

Za prvnφ dvojteΦku se pφ╣e v²stup - to je parametr, kter² musφ b²t lvalue. GCC poΦφtß s tφm, ╛e jeho hodnota se pouze zapisuje ale neΦte. U t°φdy je nutnΘ psßt '=':

asm volatile ("inb %1, %0"
    : "=a" (rv)
    : "Nd" (port));

Pokud chcete vstupn∞ v²stupnφ prom∞nΘ, m∙╛ete pou╛φt nßsledujφcφ konstrukci:

asm ("incl %0": "=g" (i): "0" (i));

asm (
      "movw %w1, %%fs
       .byte 0x64
       movb (%2, %3), %b0"
   : "=&q" (result)               /* v²stup in al, bl, cl, nebo dl */
   : "rm" (seg),                  /* segment selector v reg, nepo pam∞ti */
     "r" (pos),                   /* zaΦßtek °ßdky*/
     "r" (x)                      /* pozice na °ßdce*/
   );

Nap°φklad nßsledujφcφ k≤d funguje jako memcpy a kopφruje n byt∙ ze src do dest (toto je ale jen ukßzkov² p°φklad a cesta p°es rep movsb je velmi pomalß):

asm volatile (
  "cld
   rep
   movsb"
   :                               /*bez v²stupnφch prom∞n²ch*/
   :"c" (n),"S" (src),"D" (dest)   /*do cx poΦet, do si zdroj, di cφl*/
   :"cx","si","di","memory","cc"); /*modifikovanΘ registry, pam∞╗ a flagy*/

Nakonec jedno velkΘ varovßnφ. nauΦte se po°ßdn∞ tuto syntax, ne╛ zaΦnete programovat. Je zdrojem Φast²ch chyb. Zapomenete na n∞jakou drobnost - t°eba uvΘdst volatile a ono to fungovat m∙╛e a nemusφ. TakΘ se m∙╛e dost dob°e stßt, ╛e to funguje ale jen 999 z tisφce pokus∙, nebo tak, ╛e to je nakonec pomalej╣φ, ne╛ kdybyste to napsali v C. NejΦast∞j╣φ chyby jsou:

• pou╛ijete 'g' a p°edpoklßdßte, ╛e to je registr
• pou╛ijete globßlnφ nßv∞╣tφ, kterΘ pak koliduje. Skoky se d∞lajφ zßsadn∞:

           1:
           ...
           jne 1b
  

  tedy aby assembler v∞d∞l, ╛e se odkazujete na nejbli╛╣φ nßv∞╣tφ jmΘnem 1 dozadu (nebo 1f pro dop°edu)
• zapomenete uvΘdst modifikovanΘ registry
• zapomenete uvΘdst, ╛e modifikuje flagy
• neuvedete "memory"
• neuvedete volatile, kde je t°eba
• pou╛ijete 'r' nebo 'g' ale p°edpoklßdßte, ╛e to nebude v n∞jakΘm registru (t°eba eax)
• uvedete p°φli╣ omezujφcφ podmφnky, kterΘ pak zbyteΦn∞ zpomalujφ k≤d.

Nakonec jenom n∞kolik chyb²ch a neefektivnφch funkcφ, kterΘ jsem p°i psanφ tohoto Φlßnku nßhodou objevil v r∙zn²ch zdrojßcφch. Nalezenφ nedostatk∙ ponechßm Φtenß°i jako jednoduchΘ cviΦenφ. Jak vidφte i velcφ mist°i se obΦas utnou (a obΦas jim to i projde).

extern inline void * memmove(void * dest,const void * src, size_t n)
{
register void *tmp = (void *)dest;
if (dest<src)
__asm__ __volatile__ (
        "cld\n\t"
        "rep\n\t"
        "movsb"
        : /* no output */
        :"c" (n),"S" (src),"D" (tmp)
        :"cx","si","di");
else
__asm__ __volatile__ (
        "std\n\t"
        "rep\n\t"
        "movsb\n\t"
        "cld\n\t"
        : /* no output */
        :"c" (n), "S" (n-1+(const char *)src), "D" (n-1+(char *)tmp)
        :"cx","si","di","memory");
return dest;
}
                   -- linux kernel, linux/include/asm/string-486.h
extern __inline__ void
outportb (unsigned short _port, unsigned char _data)
{
  __asm__ __volatile__ ("outb %1, %0"
          :
          : "d" (_port),
            "a" (_data));
}
                   -- djgpp, include/inline/pc.h
        int i = 0;
        __asm__("
          pushl %%eax\n
          movl %0, %%eax\n
          addl $1, %%eax\n
          movl %%eax, %0\n
          popl %%eax"
          :
          : "g" (i)
        );
          /* i++; */
                     -- tutorißl k assembleru djasm.html

9.5 extern inline

Konstrukce extern inline konstrukce umo╛≥uje ud∞lat rychlΘ nßhra╛ky knihovnφch funkcφ. Pokud je zapnutß optimalizace a p°ekladaΦ narazφ na funkci deklarovanou jako extern inline, v╣echny dal╣φ volßnφ se inlinujφ. Pokud je ale optimalizace vyplß, funkce se ignoruje a volß se standardnφ. Proto do header∙ m∙╛ete sepsat svoje nejoblφben∞j╣φ funkce, kterΘ by m∞ly b²t rychlΘ a takov² header pak volat v╣ude, kde je t°eba. Takovß b∞╛nß extern inline funkce je:

extern inline void
outportb (unsigned short _port, unsigned char _data)
{
  asm volatile ("outb %1, %0"
          :
          : "d" (_port),
            "a" (_data));
}

9.6 __builtin_constant_p

P°edstavte si, ╛e chcete implementovat optimßlnφ memset. To jde ud∞lat nap°φklad:

extern inline void * memset(void * s, char c,size_t count)
{
asm volatile(
       "cld
        rep
        stosb"
        : /* no output */
        :"a" (c),"D" (s),"c" (count)
        :"cx","di","memory","cc");
return s;
}

extern inline void * memset(void * s, char c,size_t count)
{
asm volatile (
       "cld
        rep
        stosl"
        : /* no output */
        :"a" (c+(c<<8)+(c<<16)+(c<<24)),"D" (s),"c" (count/4)
        :"cx","di","memory","cc");
return s;
}

extern inline void * memset(void * s, unsigned long pattern, size_t count)
{
        pattern=((unsigned char)patter) * 0x01010101;
        switch (count) {
                case 0:
                        return s;
                case 1:
                        *(unsigned char *)s = pattern;
                        return s;
                case 2:
                        *(unsigned short *)s = pattern;
                        return s;
                case 3:
                        *(unsigned short *)s = pattern;
                        *(2+(unsigned char *)s) = pattern;
                        return s;
                case 4:
                        *(unsigned long *)s = pattern;
                        return s;
        }
##define COMMON(x) \
asm ("cld; rep ; stosl" \
        x \
        : /* no outputs */ \
        : "a" (pattern),"c" (count/4),"D" ((long) s) \
        : "cx","di","memory","cc")

        switch (count % 4) {
                case 0: COMMON(""); return s;
                case 1: COMMON("\n\tstosb"); return s;
                case 2: COMMON("\n\tstosw"); return s;
                case 3: COMMON("\n\tstosw\n\tstosb"); return s;
        }

}

Jedin² problΘm je, ╛e bychom pot°ebovali memset pro konstantnφ parametry a memset pro nekonstantnφ a nutit programßtora, aby sßm dßval pozor na to, co je konstanta a co nenφ (n∞kdy to v∙bec nenφ jednoduchΘ, hlavn∞ kdy╛ parametr je sice prom∞nß, ale je mo╛nΘ p°edpoΦφtat jejφ hodnotu)

K tomu slou╛φ prßv∞ __builtin_constant_p. Ta vrßtφ 1, pokud parametr je konstanta a jinak 0. M∙╛eme tedy napsat memset pro konstantnφ a nekonstantnφ parametry a potom vybrat ten sprßvn² pomocφ:

#define __constant_c_x_memset(s, c, count) \
(__builtin_constant_p(count) ? \
 __constant_c_and_count_memset((s),(c),(count)) : \
 __constant_c_memset((s),(c),(count)))

#define __memset(s, c, count) \
(__builtin_constant_p(count) ? \
 __constant_count_memset((s),(c),(count)) : \
 __memset_generic((s),(c),(count)))

#define memset(s, c, count) \
(__builtin_constant_p(c) ? \
 __constant_c_x_memset((s),c,(count)) : \
 __memset((s),(c),(count)))

main()
{
   int a = 1;
   __builtin_constant_p(a++);
   __builtin_constant_p(a++);
   printf("%i\n", a);
}

Je nutnΘ poznamenat, ╛e __builtin_constant_p nepat°φ zrovna k nejspolehliv∞j╣φm. Jejφ hodnota se urΦuje p°ed propagacφ konstant (v tΘ dob∞ je u╛ nutnΘ v∞d∞t, kudy se program vydß) a tak i v p°edchozφm p°φpad∞ bude vracet 0, proto╛e parametrem je prom∞nß (p°esto, ╛e p°i propagaci konstant se p°ijde na to, ╛e jejφ hodnota je 1). Z toho d∙vodu nemß smysl pou╛φvat tuto funkci na parametry inline funkcφ a je nutnΘ psßt makra. Proto pou╛φvejte tutu metodu jen pokud to je nutnrΘ.

9.7 Attributy funkcφ

K optimalizaci se hodφ jakßkoliv informace. V n∞kter²ch p°φpadech je celkem t∞╛kΘ, aby optimizer zjistil n∞kterΘ speciality a proto mnoho p°ekladaΦ∙ mß mo╛nost p°idat k deklaracφm funkce i n∞kterΘ p°φdavnΘ attributy - nap°φklad to, ╛e funkce se nikdy nevrßtφ (exit) a tak nenφ t°eba po jejφm volßnφ dßle p°eklßdat. V∞t╣ina z nich to ale °e╣φ pomocφ konstrukce #pragma. To p°inß╣φ ΦastΘ potφ╛e s preprocesorem - nejde zahrnovat do maker apod. Proto╛e je #pragma neportabilnφ nelze tudφ╛ tyto v∞ci elegantn∞ p°idat do portabilnφch program∙.

GCC mß pon∞kud jinΘ °e╣enφ - pomocφ __attribute__, kter² se pφ╣e za deklaraci funkce. Nastavenφ takovΘho attributu potom vypadß:

void ahoj(void) __attribute__(const);

#ifdef __GCC__
# define CONST(f) f __attribute__const
#else
# define CONST(f) f
#endif

void CONST(ahoj(void));

noreturn

°φkß, ╛e funkce se nikdy nevrßtφ - jako nap°. exit.

const

funkce ned∞lß nic jinΘho, ne╛ ╛e se koukne na svΘ parametry a z nich vyvodφ v²sledek, bez dal╣φch vedlej╣φch efekt∙, nebo prohlφ╛enφ pam∞ti. Compiler potom d∞lß stejnΘ optimalizace jako na operßtor. P°φkladem takovych funkcφ je nap°φklad abs, sin, cos apod. Nap°φklad funkce rand to u╛ nenφ.

regparm(poΦet)

Prvnφch poΦet parametr∙ se bude p°edßvat v registru. To urychlφ volßnφ funkce. GCC umφ p°edßvat v registrech i defaultn∞, je ale nutnΘ pro to p°ekompilovat knihovny.

constructor

funkce se zavolß p°ed provedenφm main.

destructor

funkce se zavolß p°ed skonΦenφm programu.

stdcall

funkce bude pou╛φvat pascalßckΘ volacφ konvence.

cdecl

pou╛ijφ se C konvence, pokud pascalßckΘ volßnφ je jako default.

format(typ,format,odkud)

Funkce typu printf a scanf nemajφ ╛ßdnou kontrolu typ∙. To je zdrojem Φast²ch chyb a proto GCC umφ tyto typy kontrolovat. Pokud uvedete tento attribut u svΘ funkce, kterß mß stejnΘ konvence, GCC to bude kontrolovat i tam. Typ m∙╛e b²t printf nebo scanf.

unused

Compiler nebude vypisovat warning, kdyz funkce je neppou╛ita.

weak

Weak je n∞co jako static nebo global. Pokud v knihovn∞ ud∞lßte globßlnφ prom∞nou, je vid∞t zvenku a aplikace ji m∙╛e omylem p°epsat. Pokud je ale weak, je lokßlnφ pro danou knihovnu.

alias(fce)

Funkce je pouze alias pro funkci fce

section(jmeno)

Funkce se ulo╛φ do jinΘ sekce - linker potom m∙╛e tyto sekci dßt do jinΘ Φßsti v²sledku a tak jdou d∞lat v∞ci jako, ╛e na konci je inicializaΦnφ k≤d, kter² se po startu uvolnφ z pam∞ti.

9.8 N∞kterß roz╣φ°enφ ╣ikovnß (nejenom) pro psanφ maker

Celkem Φastno se stßvß, ╛e chcete napsat makro, kterΘ jde napsat na mφsto funkce, ale pot°ebujete tam prom∞nou, nebo smyΦku apod. a proto jako v²raz napsat nejde. Proto mß GCC {( )}, co╛ je konstrukce, kterß p°evede libovoln² blok do v²razu. Jeho hodnota je potom hodnota poslednφho vyhodnocenΘho v²razu. Proto jde napsat makro MAX tak, aby se parametry vyhodnocovaly jen jednou:

#define MAX(a,b) ({int _a=(a), _b=(b); _a > _b ? _a : _b })

TΘto konstrukce lze takΘ z v²hodou vu╛φt v kombinaci s asm:

#define plus(a,b) ({int _a=(a) _b=(b), asm("add %0 %1":"=g" (_a):\
                   "0" (_a):"g" (_b):"cc");_a}

#define MAX(a,b) ({typeof _ta=(a), _tb=(b); \
                         _ta _a=(a); _tb _b(b); \
                         _a > _b ? _a : _b })

#define eprintf(f,a ...) fprintf(stderr, f, ## a);

9.9 Explicitnφ urΦovßnφ registr∙ pro prom∞nΘ

N∞kterΘ p°ekladaΦe umo╛≥ujφ urΦit registr pro prom∞nou tak, ╛e ji pojmenujete nap°φklad __ax. To ale p°inß╣φ problΘmy s portabilitou. Pokud chcete, aby na jednΘ architektu°e byla prom∞na v registru ax a na jinΘ v r1, musφte ji poka╛dΘ pojmenovat jinak. TakΘ hrozφ mo╛nost nßhodnΘ kolize.

GCC mß op∞t jin² p°φstup k v∞ci. Pokud chcete ulo╛it prom∞nou do registru napφ╣ete nap°φklad:

      register int ahoj asm("ax");