Het definiëren van __asm blokken als C-macro's

Microsoft-specifieke

C-macro's bieden een handige manier om assemblycode in uw broncode in te voegen, maar ze vragen extra zorg omdat een macro uitbreidt tot één logische regel. Volg deze regels om probleemloze macro's te maken:

• Plaats het __asm blok tussen haakjes.

• Plaats het __asm trefwoord vóór elke assembly-instructie.

• Gebruik opmerkingen in oude stijl C (/* comment */) in plaats van opmerkingen in assemblystijl (; comment) of opmerkingen met één regel C (// comment).

Ter illustratie definieert het volgende voorbeeld een eenvoudige macro:

#define PORTIO __asm      \
/* Port output */         \
{                         \
   __asm mov al, 2        \
   __asm mov dx, 0xD007   \
   __asm out dx, al       \
}

Op het eerste gezicht lijken de laatste drie __asm trefwoorden overbodig. Ze zijn echter nodig omdat de macro wordt uitgevouwen tot één regel:

__asm /* Port output */ { __asm mov al, 2  __asm mov dx, 0xD007 __asm out dx, al }

De derde en vierde __asm trefwoorden zijn nodig als scheidingstekens voor uitspraken. De enige instructiescheidingstekens die in __asm blokken worden herkend, zijn het regeleinde en het __asm sleutelwoord. Omdat een blok dat is gedefinieerd als een macro één logische regel is, moet u elke instructie scheiden met __asm.

De haakjes zijn ook essentieel. Als u ze weglaat, kan de compiler worden verward door C- of C++-instructies op dezelfde regel rechts van de macro-aanroep. Zonder de sluitende accolade kan de compiler niet zien waar de assemblycode stopt, en ziet het de C- of C++-instructies na het __asm blok, als assemblerinstructies.

Opmerkingen in assemblystijl die beginnen met een puntkomma (;) gaan door naar het einde van de regel. Dit veroorzaakt problemen in macro's omdat de compiler alles na de opmerking negeert, helemaal tot aan het einde van de logische regel. Hetzelfde geldt voor opmerkingen met één regel C of C++ (// comment). Als u fouten wilt voorkomen, gebruikt u C-opmerkingen in oude stijl (/* comment */) in __asm blokken die zijn gedefinieerd als macro's.

Een __asm blok dat is geschreven als een C-macro kan argumenten aannemen. In tegenstelling tot een gewone C-macro kan een __asm macro echter geen waarde retourneren. U kunt dergelijke macro's dus niet gebruiken in C- of C++-expressies.

Wees voorzichtig met het zonder onderscheid aanroepen van macro's van dit type. Als u bijvoorbeeld een assemblytaalmacro aanroept in een functie die is gedeclareerd met de __fastcall conventie, kan dit onverwachte resultaten veroorzaken. (Zie Registers gebruiken en behouden in inline assembly.)

Microsoft-specifieke beëindigen

Zie ook

Inline-assembler