vérifier si le drapeau de report est activé

L'aide d'assembleur en ligne [gcc, intel, c], comment faire pour vérifier si la retenue est fixé après une opération?

10

Conditionnelle des sauts jc (saut si carry) ou jnc (saut si pas de portage).

Ou vous pouvez stocker le drapeau de portage,
```
;; Intel syntax
mov eax, 0
adc eax, 0 ; add with carry
```
14

sbb %eax,%eax va stocker -1 eax si le porte drapeau est réglé, 0 si elle est claire. Il n'y a pas besoin de pré-claire eax à 0; en soustrayant eax de lui-même, le fait pour vous. Cette technique peut être très puissant puisque vous pouvez utiliser le résultat comme un masque de bits pour modifier les résultats de calculs à la place de l'aide conditionnelle sauts.

Vous devez être conscient qu'il n'est valable que pour tester le drapeau de portage si elle a été fixée par l'arithmétique effectuée à l'INTÉRIEUR de l'asm inline block. Vous ne pouvez pas tester de réaliser un calcul qui a été réalisée dans le code C, parce qu'il y a toutes sortes de façons, le compilateur peut optimiser/réorganiser les choses qui pourraient tabasser le porte drapeau.

Cependant l'assembleur x86 hes dédié rapide ALU drapeau instructions de test nommé SETcc où cc est souhaitée ALU drapeau. Vous pouvez donc écrire:

setc    AL                           //will set AL register to 1 or clear to 0 depend on carry flag

or

setc    byte ptr [edx]               //will set memory byte on location edx depend on carry flag

or even

setc    byte ptr [CarryFlagTestByte]  //will set memory variable on location CarryFlagTestByte depend on carry flag

Avec SETcc d'instructions, vous pouvez tester des drapeaux comme porter, zéro, de signer, de débordement ou de la parité, certains SETcc instructions permettent de tester les deux drapeaux à la fois.

EDIT:
Ajoutée simple test fait en Delphi à disparaître un doute sur le terme rapide

procedure TfrmTest.ButtonTestClick(Sender: TObject);
  function GetCPUTimeStamp: int64;
  asm
    rdtsc
  end;
var
 ii, i: int64;
begin
  i := GetCPUTimeStamp;
  asm
    mov   ecx, 1000000
@repeat:
    mov   al, 0
    adc   al, 0
    mov   al, 0
    adc   al, 0
    mov   al, 0
    adc   al, 0
    mov   al, 0
    adc   al, 0
    loop  @repeat
  end;
  i := GetCPUTimeStamp - i;

  ii := GetCPUTimeStamp;
  asm
    mov   ecx, 1000000
@repeat:
    setc  al
    setc  al
    setc  al
    setc  al
    loop  @repeat
  end;
  ii := GetCPUTimeStamp - ii;
  caption := IntToStr(i) + '  ' +  IntToStr(ii));
end;

La boucle (1M itérations) qui l'aide de l'instruction setc est plus de 5 fois plus rapide que la boucle avec adc instriuction.

EDIT: Ajout de la deuxième test résultat du test stockées dans le registre AL comulative dans le registre CL d'être plus réaliste.

procedure TfrmTestOtlContainers.Button1Click(Sender: TObject);
  function GetCPUTimeStamp: int64;
  asm
    rdtsc
  end;

var
 ii, i: int64;
begin
  i := GetCPUTimeStamp;
  asm
    xor   ecx, ecx
    mov   edx, $AAAAAAAA

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

    shl   edx, 1
    mov   al, 0
    adc   al, 0
    add   cl, al

  end;
  i := GetCPUTimeStamp - i;

  ii := GetCPUTimeStamp;
  asm
    xor   ecx, ecx
    mov   edx, $AAAAAAAA

    shl   edx, 1
    setc  al
    add   cl, al

    shl   edx, 1
    setc  al
    add   cl, al

    shl   edx, 1
    setc  al
    add   cl, al

    shl   edx, 1
    setc  al
    add   cl, al

    shl   edx, 1
    setc  al
    add   cl, al

    shl   edx, 1
    setc  al
    add   cl, al

    shl   edx, 1
    setc  al
    add   cl, al

    shl   edx, 1
    setc  al
    add   cl, al

  end;
  ii := GetCPUTimeStamp - ii;
  caption := IntToStr(i) + '  ' +  IntToStr(ii);
end;

Rutine partie avec SETcc instruction est encore plus rapide pour environ 20%.

La première fonction effectue unsigned plus, puis les tests de débordement à l'aide de la retenue (CF). La volatilité de la de la doit demeurer. Sinon, l'optimiseur de réorganiser les instructions, qui assez bien assure un résultat incorrect. J'ai vu l'optimiseur de changer le jnc à un jae (qui est également basée sur la FC).

/* Performs r = a + b, returns 1 if the result is safe (no overflow), 0 otherwise */
int add_u32(uint32_t a, uint32_t b, uint32_t* r)
{
    volatile int no_carry = 1;
    volatile uint32_t result = a + b;

    asm volatile
    (
     "jnc 1f          ;"
     "movl $0, %[xc]  ;"
     "1:              ;"
     : [xc] "=m" (no_carry)
     );

    if(r)
        *r = result;

    return no_carry;
}

La fonction suivante est pour la signature de l'ints. Même l'utilisation de la volatilité s'applique. Notez que entier signé de mathématiques sauts sur DE drapeau via jno. J'ai vu l'optimiseur de le changer pour un jnb (qui est également basée sur DES).

/* Performs r = a + b, returns 1 if the result is safe (no overflow), 0 otherwise */
int add_i32(int32_t a, int32_t b, int32_t* r)
{   
    volatile int no_overflow = 1;
    volatile int32_t result = a + b;

    asm volatile
    (
     "jno 1f          ;"
     "movl $0, %[xo]  ;"
     "1:              ;"
     : [xo] "=m" (no_overflow)
     );

    if(r)
        *r = result;

    return no_overflow;
}

Dans la grande image, vous pouvez utiliser les fonctions comme suit. Dans le même tableau, beaucoup de gens ne sera probablement rejeter le travail supplémentaire et de l'esthétique de la non-beauté jusqu'pwn en un débordement/wrap/underflow

int r, a, b;
...

if(!add_i32(a, b, &r))
    abort(); //Integer overflow!!!

...

La ligne de GCC de l'assemblée est disponible dans GCC 3.1 et au-dessus. Voir Les Instructions de l'assembleur, le C de l'Expression des Opérandesou de la recherche pour "GCC Étendue de l'Assemblée'.

Enfin, même dans Visual Studio serait comme suit (pas beaucoup de différence dans la génération de code), mais la syntaxe est beaucoup plus facile depuis MASM permet de sauter à une étiquette C:

/* Performs r = a + b, returns 1 if the result is safe (no overflow), 0 otherwise */
int add_i32(__int32 a, __int32 b, __int32* r)
{   
    volatile int no_overflow = 1;
    volatile __int32 result = a + b;

    __asm
    {
        jno NO_OVERFLOW;
        mov no_overflow, 0;
    NO_OVERFLOW:
    }

    if(r)
        *r = result;

    return no_overflow;
}

Sur le mauvais côté, au-dessus de MASM code n'est applicable que pour les architectures x86 assemblée. Pour x64 assemblée, il n'y a pas d'inlining de sorte que vous aurez à code dans de l'assemblée (dans un fichier séparé) et utiliser MASM64 à compiler.

Vous devez vous connecter pour publier un commentaire.