Displaying hexadecimal contents in assembly language

Question

Hey guys I'm not sure if I'm going about all this the right way. I need the first 12 numbers of Fibonacci sequence to calculate which its doing already I'm pretty sure. But now I need to display the hexadecimal contents of (Fibonacci) in my program using dumpMem. I need to be getting a print out of : 01 01 02 03 05 08 0D 15 22 37 59 90

But I'm only getting: 01 01 00 00 00 00 00 00 00 00 00 00

Any tips or help is much much appreciated.

 INCLUDE Irvine32.inc
.data

reg DWORD -1,1,0                    ; Initializes a DOUBLEWORD array, giving it the values of -1, 1, and 0
array DWORD 48 DUP(?)
Fibonacci BYTE 1, 1, 10 DUP (?) 



.code
main PROC
       mov array, 1
       mov esi,OFFSET array ; or should this be Fibonacci?
       mov ecx,12
       add esi, 4


    L1:
        mov edx, [reg]
        mov ebx, [reg+4]
        mov [reg+8], edx
        add [reg+8], ebx                    ; Adds the value of the EBX and 'temp(8)' together and stores it as temp(8) 
        mov eax, [reg+8]                    ; Moves the value of 'temp(8)' into the EAX register        
        mov [esi], eax                      ; Moves the value of EAX into the offset of array
        mov [reg], ebx                      ; Moves the value of the EBX register to 'temp(0)' 
        mov [reg+4], eax                    ; Moves the value of the EAX register to 'temp(4)
        add esi, 4

       ; call DumpRegs
        call WriteInt
        loop L1

        ;mov ebx, offset array
        ;mov ecx, 12

        ;L2: 
        ;mov eax, [esi]
        ;add esi, 4
        ;call WriteInt
        ;loop L2

  ;Below will show hexadecimal contents of string target-----------------
   mov   esi, OFFSET Fibonacci      ; offset the variables
   mov   ebx,1                      ; byte format
   mov   ecx, SIZEOF Fibonacci      ; counter
   call  dumpMem 


exit
main ENDP

END main

Answer 1

It seems to me that the problem here is with computing the Fibonacci sequence. Your code for that leaves me somewhat...puzzled. You have a bunch of "stuff" there, that seems to have nothing to do with computing Fibonacci numbers (e.g., reg), and others that could, but it seems you don't really know what you're trying to do with them.

Looking at your loop to compute the sequence, the first thing that practically jumps out at me is that you're using memory a lot. One of the first (and most important) things when you're writing assembly language is to maximize your use of registers and minimize your use of memory.

As a hint, I think if you read anything from memory in the course if computing the sequence, you're probably making a mistake. You should be able to do all the computation in registers, so the only memory references will be writing results. Since you're (apparently) producing only byte-sized results, you should need only one array of the proper number of bytes to hold the results (i.e., one byte per number you're going to generate).

I'm tempted to write a little routine showing how neatly this can be adapted to assembly language, but I suppose I probably shouldn't do that...

Answer 2

Your call to dumpMem is correct, but your program is not storing the results of your calculations at the correct location: the region you call "Fibonacci" remains initialized to 1, 1, and ten zeros. You need to make sure that your loop starts writing at the offset of Fibonacci plus 2, and moves ten times in one-byte increments (ten, not twelve, because you provided the two initial items in the initializer).

I'm sorry, I cannot be any more specific, as any question containing the word "Fibonacci" inevitably turns out to be someone's homework :-)