Intel 8086 Insertion Trier: numéros Skipping dans le tableau

Question

Nous sommes en train d'étudier Intel 8086 Code d'insertion Trier que notre professeur nous a montré. Il voulait que nous comprenions pourquoi le code ignorait le 0ème élément du tableau et le 3ème élément du tableau à partir d'un code qu'il avait pris sur le web.

; void isort(int *a, int n) 
; sorts the first n elements of a 
; 
; Parameters 
; a - pointer to the array 
; n - number of elements to sorts 

%define a [ebp + 8] 
%define n [ebp + 12] 
isort: 
    enter 0, 0 
    pusha 

    mov ecx, 1 
    for: 
    mov ebx, ecx 
    imul ebx, 4 
    add ebx, a 
    mov ebx, [ebx] 

    mov edx, ecx 
    dec edx 

    while: 
     cmp edx, 0 
     jl while_quit 

     mov eax, edx 
     imul eax, 4 
     add eax, a 

     cmp ebx, [eax] 
     jge while_quit 

     mov esi, [eax] 

     mov dword [eax + 4], esi 

     dec edx 
     jmp while 
    while_quit: 

    mov [eax], ebx 

    inc ecx 
    cmp ecx, n 
    jl for 

    popa 
    leave 
    ret 

Et le tableau d'échantillons était {5, 8, 12, 2, 1, 7}. C'est plus pour comprendre la langue 8086 depuis que nous venons de commencer il y a quelques jours, et je me demandais si quelqu'un pouvait expliquer comment et ce qui pourrait mal se passer.

Answer 1

Tenir compte ce que le code fera quand ECX est 1:

• La boucle while sera entrée avec EBX=8 et EDX=0.
• Le jl while_quit ne sera pas prise, car EDX est 0.
• EBX est comparé à [EAX]. C'est; 8 est comparé à a[0], ce qui est 5, donc le jge while_quit est pris.
• mov [eax], ebx magasins 8 à a[0], de sorte que votre tableau contient maintenant {8,8,12,2,1,7}. Clairement pas ce que vous voulez, puisque vous avez perdu l'un des éléments d'origine.

---

En dehors de défaut logique du code, ces imul instructions sont complètement inutiles puisque vous pouvez utiliser des indices mis à l'échelle sur le x86. Ainsi, le code de tri peut être simplifié à ce (je l'ai vérifié qu'il trie le tableau correctement):

mov ecx, 1 
for_: 
    ; esi = &a[holePos] 
    lea esi,[a + ecx*4] 
    ; valueToInsert = a[holePos] 
    mov ebx, [esi] 

    while_: 
    ; Did we reach the beginning of the array? 
    cmp esi, OFFSET a 
    jle while_quit 

    ; valueToInsert < a[holePos-1] ? 
    cmp ebx, [esi-4] 
    jge while_quit 

    ; a[holePos] = a[holePos-1] 
    mov eax, [esi-4] 
    mov [esi], eax 

    ; esi = &a[holePos-1] 
    sub esi,4 
    jmp while_ 
    while_quit: 

    ; a[holePos] = valueToInsert 
    mov [esi], ebx 

    inc ecx 
    cmp ecx, 6 
    jl for_ 

J'utilise la syntaxe MASM, mais vous voyez l'idée.