1

my project I'm supposed to create a program that fills an array with an x number of fibbonacci numbers. In this case it's 47. I've got the programming set to get it the numbers etc, I just can't seem to get them into my array. Any help would be great as I'm sure i'm just off on my syntax. I'm debugging it in visual studio, so I guess that's masm? Thanks in advance.

.386
.model flat,stdcall
.stack 4096
ExitProcess proto,dwExitCode:dword

.data
fibba DWORD 47 DUP(?)

.code
main proc       

mov eax,1                               ;current number
mov ebx,0                               ;last number in array
mov edi,0                               ;array location
mov ecx,LENGTHOF fibba                  ;how many loops

    L1:
    mov [fibba+edi] ,eax                ;move current into array
    push eax                            ;move current into stack
    add eax, ebx                        ;adding previous to current
    pop ebx                             ;pulling last number used off stack
    inc edi                             ;incrementing array location
    loop L1


    invoke ExitProcess,0
main endp
end main
Hooch
  • 33
  • 8
  • Use `[fibba+edi*4]` or increment `edi` by 4 (the width of a dword). Related: [my answer on Assembly Language (x86): How to create a loop to calculate Fibonacci sequence](https://stackoverflow.com/questions/32659715/assembly-language-x86-how-to-create-a-loop-to-calculate-fibonacci-sequence). Using `push eax`/`pop ebx` is a novel way to solve the problem. It's not the most efficient, but it should work. Neat idea. Also [the `loop` instruction is slow](https://stackoverflow.com/questions/35742570/why-is-the-loop-instruction-slow-couldnt-intel-have-implemented-it-efficiently), use dec/jnz. – Peter Cordes Oct 15 '17 at 04:10
  • OK, that was a huge hep! Thank you! Last question. Am I technically defining fibba as a word or as a double word? I should be using a doubleword. But at that point push pop wont work will it because push/pop is limited to 4 bytes.. Yeah? – Hooch Oct 15 '17 at 06:31
  • You're awesome! I'm all set! How do I set your answer as the solution now!> LOL – Hooch Oct 15 '17 at 06:57
  • I intended to just leave a quick comment and then maybe find a duplicate question to close this as (you're certainly not the first person to increment a pointer by 1 byte instead of 1 element). But I ended up writing enough for an answer in comments, when I should have just posted an answer. Corrected that, so you can mark it accepted. – Peter Cordes Oct 15 '17 at 07:08

1 Answers1

3

Use [fibba+edi*4] or increment edi by 4 (the width of a dword). You're currently doing 4B stores that overlap by 3B.

Related: my answer on Assembly Language (x86): How to create a loop to calculate Fibonacci sequence.

Using push eax/pop ebx is a novel way to solve the problem. It's not the most efficient, but it should work. Neat idea. Also, the loop instruction is slow, use dec ecx/jnz (or a different loop condition, like cmp edi, fibba+47*4) instead.

(in a comment)

Am I technically defining fibba as a word or as a double word? I should be using a doubleword. But at that point push pop wont work will it because push/pop is limited to 4 bytes.. Yeah?

You're reserving 47 * 4 bytes, with the fibba label marking the start of it. A DWORD is 32 bits (4 bytes). In x86 asm terminology, a "word" is only 16 bits, because of its 16-bit heritage.

On most CPUs, the "natural" size of an integer is a word (e.g. 32 bits on MIPS, ARM, etc.), but not on x86. The "natural" size of an integer on x86 is 4 bytes / 32-bits, but it's called a dword (double-word). Anyway, you're not pushing/popping in fibba, you're using it to save/restore the full width of a register (which is also 4 bytes).

Microsoft's assembler has some "magic" where it looks at what directives you use after a label to imply an operand size for something like mov [fibba], 0, but other assemblers require an explicit size because neither operand is a register. IMO this is a better way to think about it: memory doesn't inherently have any types, it's just a bag of bytes, and it's up to you as the asm programmer to get it right. That's why you didn't get any warnings for doing overlapping 4-byte stores offset by only 1 byte, you just got bogus data in memory.

Community
  • 1
  • 1
Peter Cordes
  • 328,167
  • 45
  • 605
  • 847