реализовать функцию c в сборке, которая возвращает разницу между наибольшим и наименьшим числами

Question

я новичок в ассемблере, и я пытаюсь написать ассемблерную функцию, которая реализует самую большую функцию dif в этом фрагменте кода c (она получает 3 целых числа в качестве аргументов).По сути, ему нужно найти минимум и максимум из 3 аргументов и затем вернуть вычитание между максимумом и минимумом:

#include <stdio.h>
extern int largestdif( int n1, int n2, int n3 );
int main( ) {
printf( "largestdif: %d\n", largestdif( 100, 30, 10 ) );
printf( "largestdif: %d\n", largestdif( 0, -1, 1 ) );
return 0;
}

Вот мой кусок кода в сборке, выглядит немного странно, но я надеюсь, что вы можете сказать,мне, что не так с этим, поскольку его ошибка ошибки сегментации представления.Я действительно понятия не имею, что делать, должно быть, это связано с тем, что регистры недостаточно вызываются.Кажется, я не могу понять ответ, так что я надеюсь, что кто-нибудь может мне помочь.заранее спасибо.

.global largestdif
.text
largestdif:
push %ebp
mov %esp, %ebp
mov 8(%ebp), %ebx
push %ebx
mov 12(%ebp), %ecx
push %ecx
mov 16(%ebp), %edx
push %edx

#compare n1 and n2 to find the largest number
cmp %edx, %ecx
jl n1_menor_n2
    #block else
    cmp %edx, %ebx #compare first and third numbers
    jl firstlower
        #bloco else
        mov %edx, %eax #already have largest number
        jmp continue
    firstlower:
        mov %ebx, %eax #already have largest number
        jmp continue
n1_menor_n2:
    cmp %ecx, %ebx #compare second and third numbers
    jl secondlower
        #block else
        mov %ecx, %eax # already have largest
        jmp continue
    secondlower:
        mov %ebx, %eax # already have largest
        jmp continue


continue: 
#compare n1 and n2 to find the largest number
cmp %edx, %ecx
jg n1_maior_n2
    #block else
    cmp %edx, %ebx
    jg firstlarger
        #block else
        sub %edx, %eax
        jmp continue2
    firstlarger:
        sub %ebx, %eax
        jmp continue2

n1_maior_n2:
    cmp %ecx, %ebx
    jg secondlarger
        #block else
        sub %ecx, %eax
        jmp continue2

    secondlarger:
        sub %ebx, %eax #already have the subtraction 
        jmp continue2

continue2:
    pop %edx
    pop %ecx
    pop %ebx
    mov %ebp, %esp
    pop %ebp
    ret

Answer 1

Что делает ваш код:

if (n2 < n1) {
    if (n3 < n2) min = n3;
    else         min = n2;
} else {
    if (n3 < n1) min = n3;
    else         min = n1;
}

if (n2 > n1) {
    if (n3 > n2) return min - n3;
    else         return min - n2;
} else {
    if (n3 > n1) return min - n3;
    else         return min - n1;
}

Как вы, вероятно, поняли, этот подход излишне сложен в x86 ASM, независимо от используемого вами синтаксиса. Код C даже показывает это!

Вместо этого более эффективно использовать значения по умолчанию для min и max и сравнивать значения не по умолчанию с min и max, а затем возвращать результат вычитания:

int min = n1, max = n3;

if (min > n2) min = n2;
if (min > n3) min = n3;

if (max < n1) max = n1;
if (max < n2) max = n2;

return max - min;

То же количество обязательных сравнений, но обратите внимание на исключение ветвей else, что упрощает код. В переводе на простой код сборки:

    .text
    .globl largestdif
largestdif:
    pushl %ebp
    movl %esp, %ebp

    movl 16(%ebp), %edx  # d = n1, min = n1
    movl 12(%ebp), %ecx  # c = n2
    movl 8(%ebp), %eax   # a = n3, max = n3

# Find min.
    cmpl %ecx, %edx      # if (n1 <= n2) {}
    jle .min_not_n2      # else
    xchgl %ecx, %edx     #   swap(&n1, &n2) // n1 < n2 is true after this
.min_not_n2:
    cmpl %eax, %edx      # if (n1 <= n3) {}
    jle .min_not_n3      # else
    xchgl %eax, %edx     #   swap(&n1, &n3) // n1 < n3 is true after this
.min_not_n3:

# Find max.
    cmpl %ecx, %eax      # if (n3 >= n2) {}
    jge .max_not_n2      # else
    xchgl %ecx, %eax     #   swap(&n2, &n3) // n3 > n2 is true after this
.max_not_n2:

    # n1 > n3 is absolutely false at this point.
    # The swaps above ordered things into the relation
    # n1 <= n2 <= n3 (%edx <= %ecx <= %eax),
    # so n1 <= n3 must be true.

# Return max - min.
    subl %edx, %eax

    movl %ebp, %esp
    popl %ebp
    ret

Я приложил все усилия, чтобы оптимизировать его, но я признаю, что почти наверняка возможно еще больше оптимизировать этот код.

Answer 2

Здесь нет ошибки сегментации. Я предполагаю, что главная ошибка не состоит в том, чтобы соблюдать соглашение о вызовах. Программа по сути является C-программой. Таким образом, вы должны следовать соглашению о вызовах C "cdecl" . Функция largestdif должна возвращать регистры EBX, ESI, EDI, EBP без изменений . Если вы используете эти регистры в функции, вы должны сохранить их перед изменением и восстановить их перед выходом из функции.

Вы не сохранили EBX до его изменения. Изменение

...
mov 8(%ebp), %ebx
push %ebx
...

до

...
push %ebx
mov 8(%ebp), %ebx
...