REPNZ SCAS Instructions de Montage Détails

Je vais essayer de l'expliquer en inversant le code en C.

Intel Jeu d'Instructions de Référence (Volume 2 de Manuel de développement logiciel) est indispensable pour ce type de rétro-ingénierie.

REPNE SCASB

La logique de REPNE et SCASB combiné:

while (ecx != 0) {
    temp = al - *(BYTE *)edi;
    SetStatusFlags(temp);
    if (DF == 0)   //DF = Direction Flag
        edi = edi + 1;
    else
        edi = edi - 1;
    ecx = ecx - 1;
    if (ZF == 1) break;
}

Ou plus simplement:

while (ecx != 0) {
    ZF = (al == *(BYTE *)edi);
    if (DF == 0)
        edi++;
    else
        edi--;
    ecx--;
    if (ZF) break;
}

La Longueur De La Chaîne

Cependant, le ci-dessus est insuffisante pour expliquer comment il calcule la longueur d'une chaîne. Basé sur la présence de la not ecx dans votre question, je suis en supposant que le fragment appartient à cet idiome (ou similaire) pour le calcul de la longueur de la chaîne à l'aide de REPNE SCASB:

sub ecx, ecx
sub al, al
not ecx
cld
repne scasb
not ecx
dec ecx

La traduction à C et à l'aide de notre logique à partir de la section précédente, nous obtenons:

ecx = (unsigned)-1;
al = 0;
DF = 0;
while (ecx != 0) {
    ZF = (al == *(BYTE *)edi);
    if (DF == 0)
        edi++;
    else
        edi--;
    ecx--;
    if (ZF) break;
}
ecx = ~ecx;
ecx--;

Simplifiant à l'aide de al = 0 et DF = 0:

ecx = (unsigned)-1;
while (ecx != 0) {
    ZF = (0 == *(BYTE *)edi);
    edi++;
    ecx--;
    if (ZF) break;
}
ecx = ~ecx;
ecx--;

Choses à noter:

• dans la notation en complément à deux, en retournant les morceaux de ecx est équivalent à -1 - ecx.
• dans la boucle, ecx est décrémenté avant la boucle des pauses, de sorte qu'il décrémente par length(edi) + 1 au total.
• ecx ne peut jamais être nulle dans la boucle, depuis la chaîne devrait occuper la totalité de l'espace d'adressage.

Donc après la boucle ci-dessus, ecx contient -1 - (length(edi) + 1) qui est le même que -(length(edi) + 2), qui nous retourner les bits de donner length(edi) + 1, et enfin de décrémentation pour donner length(edi).

Ou du réaménagement de la boucle et la simplification:

const char *s = edi;
size_t c = (size_t)-1;      //c == -1
while (*s++ != '
const char *s = edi;
size_t c = (size_t)-1;      //c == -1
while (*s++ != '\0') c--;   //c == -1 - length(s)
c = ~c;                     //c == length(s)
') c--;   //c == -1 - length(s)
c = ~c;                     //c == length(s)

Et d'inverser le comte:

size_t c = 0;
while (*s++ != '
size_t c = 0;
while (*s++ != '\0') c++;
') c++;

qui est le strlen fonction de C:

size_t strlen(const char *s) {
    size_t c = 0;
    while (*s++ != '
size_t strlen(const char *s) {
size_t c = 0;
while (*s++ != '\0') c++;
return c;
}
') c++;
    return c;
}

Il compare l'octet à es:[edi] à ce que dans al est et répéter cette étape jusqu'à ce que soit ecx est à zéro ou à la valeur à es:[edi] correspond à la valeur dans al. Après chaque étape, edi est incrémenté de sorte qu'il pointe vers le prochain octet en mémoire.
Le programme s'applique not au compteur (ecx) par la suite, basé sur l'instruction suivante.

repnz signifie "répéter jusqu'à ce qu'indicateur de zéro n'est pas définie et cx n'est pas égal à zéro". Chaque itération décrémente ecx.
scas ou plus précisément scasb compare la valeur dans al à la mémoire de l'opérande (toujours es:[edi] ou es:[di] en fonction de l'adresse de la taille), puis définit les drapeaux en conséquence (indicateur de zéro sera fixé si les deux valeurs sont égales) et incrémente (ou décrémente, basé sur l'indicateur de direction) edi.