어셈블리 언어 및 인쇄 결과. Fibbonacci 시퀀스

Question

Intel 8086 용 명령어와 함께 x86 Linux에서 Assembly를 사용합니다. 필자의 프로그램에 문제가있어 Fibbonacci 시퀀스의 요소를 계산해야합니다. 예를 들어 대한

내가 인수와 함께 실행이 프로그램 :

./fibb 1 2 3,

무엇을 의미 : 우리가 원하는 시퀀스의 첫 번째 요소는 2ST 요소는 2, 및 제 3을 얻으십시오. 그리고 그 예를 잘 작동하지만, 내가 좋아하는 실행하려고하면

./fibb 1 2 4

, 그럼 좀 정크 있어요. 도와주세요. 나는 회의에서 새로 왔어. 그래서 내가 뭘 잘못하고 있는지 분명히 설명해 줘.

가

.intel_syntax noprefix 
    .global _start 

    .data 
var1: 
    .ascii "To few args\n" 
    .equ len1, $-var1 
var2: 
    .ascii "Wrong data\n" 
    .equ len2, $-var2 
var3: 
    .ascii "wrong element of the sequence\n" 
    .equ len3, $-var3 
var4: 
    .ascii "element of the sequence is higher than 255\n" 
    .equ len4, $-var4 
var5: 
    .ascii "result: " 
    .equ len5, $-var5 
var6: 
    .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 
var7: 
    .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 
var8: 
    .byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 

    .text 
_start: 


    jmp  ety5 

ety1: 
    mov bh, 48 
ety2: 
    cmp [eax], bh 
    jz ety3 
    inc bh 
    cmp bh, 58 
    jnz ety2 
ety3: 
    cmp bh, 58 
    jnz ety4 
    inc  bl 
ety4: 
    inc eax 
    cmp [eax], byte ptr 0 
    jnz  ety1 
    ret 
ety5: 

    jmp  ety10 

invert: 
    xor  ecx, ecx 
ety6: 
    inc  ebx 
    inc  ecx 
    cmp  [ebx], byte ptr 0 
    jnz  ety6 
ety7: 
    dec ecx 
    cmp ecx, 0 
    jz ety8 
    mov [ebx], byte ptr 0 
    dec  ebx 
    cmp [ebx], byte ptr 48 
    jz ety7 
    inc ebx 
ety8: 
    inc  ecx 
    push ecx 
    xor  ecx, ecx 
ety9: 
    add  ecx, 2 
    push ecx 
    dec  ebx 
    mov  cl, [eax] 
    mov  ch, [ebx] 
    mov  [eax], ch 
    mov  [ebx], cl 
    inc  eax 
    pop  ecx 
    cmp  ecx, [ebp-8] 
    jb ety9 
    pop  ecx 
    ret 
ety10: 

    jmp ety18 

ety11: 
    mov cl, [eax] 
    cmp cl, 0 
    jz ety12 
    sub cl, 48 
ety12: 
    mov ch, [ebx] 
    sub ch, 48 
    add  cl, dh 
    xor dh, dh 
    add cl, ch 
    cmp cl, 10 
    jb ety13 
    inc  dh 
    sub  cl, 10 
ety13: 
    add cl, 48 
    mov  [eax], cl 
    inc eax 
    inc ebx 
    cmp [ebx], byte ptr 0 
    jnz ety11 
ety14: 
    cmp [eax], byte ptr 0 
    jz ety16 
    mov cl, [eax] 
    sub cl, 48 
    add cl, dh 
    xor dh, dh 
    cmp cl, 10 
    jb ety15 
    sub cl, 10 
    inc dh 
ety15: 
    add cl, 48 
    mov [eax], cl 
    inc eax 
    jmp ety14 
ety16: 
    cmp dh, 0 
    jz ety17 
    add dh, 48 
    mov [eax], dh 
ety17: 
    ret 
ety18: 

    jmp ety22 
ety19: 
    mov esi, 3 
    mov  dl, [ecx] 
    sub  dl, 48 
    loop_mul: 
    add dl, dl 
    dec esi 
    cmp esi,0 
    jnz loop_mul 
    add dl, dh 
    xor dh, dh 
    cmp dl, 10 
    jb ety20 
    sub dl,10 
    inc dh 
ety20: 
    add  dl, 48 
    mov  [ebx], dl 
    inc ebx 
    inc ecx 
    cmp [ecx], byte ptr 0 
    jnz  ety19 
    cmp dh, 0 
    jz ety21 
    add dh, 48 
    mov [ebx], dh 
ety21: 
    mov ebx, offset var8 
    ret 
ety22: 

    mov  ebp, esp 

    mov eax, [ebp+8] 
    cmp eax, 0 
    jnz ety23 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var1 
    mov  edx, offset len1 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 
ety23: 
    mov eax, [ebp+12] 
    cmp eax, 0 
    jnz ety24 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var1 
    mov  edx, offset len1 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 
ety24: 
    mov eax, [ebp+16] 
    cmp eax, 0 
    jnz ety25 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var1 
    mov  edx, offset len1 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 
ety25: 

    xor bl, bl 
    mov eax, [ebp+8] 
    call ety1 
    mov eax, [ebp+12] 
    call ety1 
    cmp  bl, 0 
    jz ety26 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var2 
    mov  edx, offset len2 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 
ety26: 

    mov eax, [ebp+16] 
    call ety1 
    cmp  bl, 0 
    jz ety27 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var3 
    mov  edx, offset len3 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 
ety27: 


    xor  ebx, ebx; 
    mov eax, [ebp+16] 
    mov ecx, [ebp+16] 

ety28: 
    cmp [eax], byte ptr 0 
    jnz ety29 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var3 
    mov  edx, offset len3 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 
ety29: 
    cmp [eax], byte ptr 48 
    jnz ety30 
    inc eax 
    inc ecx 
    jmp  ety28 

ety30: 
    inc ecx 
    cmp [ecx], byte ptr 0 
    jz ety35 
    inc ecx 
    cmp [ecx], byte ptr 0 
    jz ety33 
    inc ecx 
    cmp [ecx], byte ptr 0 
    jz ety31 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var4 
    mov  edx, offset len4 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 

ety31: 
    mov cl, [eax] 
    inc  eax 
    sub cl, 48 
ety32: 
    add ebx, 100 
    dec  cl 
    cmp  cl, 0 
    jnz  ety32 
ety33: 
    mov cl, [eax] 
    inc  eax 
    sub cl, 48 
    cmp  cl, 0 
    jz ety35 
ety34: 
    add ebx, 10 
    dec  cl 
    cmp  cl, 0 
    jnz  ety34 
ety35: 
    mov cl, [eax] 
    sub cl, 48 
    cmp  cl, 0 
    jz ety37 
ety36: 
    inc ebx 
    dec  cl 
    cmp  cl, 0 
    jnz  ety36 
ety37: 

    cmp  ebx, 256 
    jb ety38 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var4 
    mov  edx, offset len4 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 
ety38: 

    xor dl, dl 
ety39: 
    dec ebx 
    inc  dl 
    cmp ebx,0 
    jnz ety39 

    mov eax, [ebp+12] 
    mov ebx, offset var7 
    xor dh, dh 
ety40: 
    inc  eax 
    inc dh 
    cmp [eax], byte ptr 0 
    jnz ety40 
    xor ch, ch 
ety41: 
    dec eax 
    dec dh 
    mov cl, [eax] 
    mov [ebx], cl 
    inc ebx 
    cmp dh, 0 
    jnz ety41 

    mov eax, [ebp+8] 
    mov ebx, offset var6 
ety42: 
    inc  eax 
    inc dh 
    cmp [eax], byte ptr 0 
    jnz ety42 
ety43: 
    dec eax 
    dec dh 
    mov cl, [eax] 
    mov [ebx], cl 
    inc ebx 
    cmp dh, 0 
    jnz ety43 


    cmp  dl, 1 
    jnz ety44 
    jmp ety46 
ety44: 

    dec dl 
    cmp  dl, 1 
    jnz ety45 
    jmp ety47 


ety45: 
    dec  dl 

    cmp dl, 0 
    jz ety47 
    push edx 
    xor dh, dh 
    mov  eax, offset var6 
    mov  ebx, offset var8 
    mov  ecx, offset var7 
    call ety19 
    xor dh, dh 
    call ety11 
    pop edx 
    dec  dl 
    cmp dl, 0 
    jz ety46 
    push edx 
    xor dh, dh 
    mov  eax, offset var7 
    mov  ebx, offset var8 
    mov  ecx, offset var6 
    call ety19 
    xor dh, dh 
    call ety11 
    pop edx 
    jmp  ety45 

ety46: 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var5 
    mov  edx, offset len5 
    int  0x80 
    mov  eax, offset var6 
    mov  ebx, offset var6 
    call invert 
    mov  eax, 4 
    mov ebx, 1 
    mov  edx, ecx 
    mov ecx, offset var6 
    int  0x80 
    mov  eax, 4 
    mov ebx, 1 
    mov [ecx], byte ptr 10 
    mov  edx, 1 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 

ety47: 
    mov  eax, 4 
    mov ebx, 1 
    mov ecx, offset var5 
    mov  edx, offset len5 
    int  0x80 
    mov  eax, offset var7 
    mov  ebx, offset var7 
    call invert 
    mov  eax, 4 
    mov ebx, 1 
    mov  edx, ecx 
    mov ecx, offset var7 
    int  0x80 
    mov  eax, 4 
    mov ebx, 1 
    mov [ecx], byte ptr 10 
    mov  edx, 1 
    int  0x80 
    mov  eax, 1 
    mov ebx, 0 
    int  0x80 

    int  0x80 

Answer 1

이 코드는 아마도 최초의 파라미터 (번호가 아니라 어드레스)와 EAX 채우고 : 여기에 내 코드이다.

mov eax, [ebp+8] 
call ety1 

그러나 ety1이 코드에서

는 BH와 주소 EAX에서 바이트를 비교합니다.

ety1: 
mov bh, 48 
ety2: 
cmp [eax], bh 
jz ety3 

어떻게 작동할까요?

나는 완전히이 실제로 응용 프로그램뿐 아니라 일부 서브 루틴 것을 잊고 점프의 터무니없이 긴 캐스케이드를 통해이 프로그램의 실제 진입 점에 도달하는 시간으로 편집

. 따라서 매개 변수는 내 대답 렌더링을 렌더링하는 주소입니다!

EDIT2

DS 레지스터가 제대로 초기화 되었습니까?