assembly nasm, compute sum of an array of real integers(floats)

the logic of this make sense to me, however it's still giving a segfault any ideas are appreciated...

addarray:
    push ebx
    push ebp
    push edi
    push ecx
    push esi
    mov edi, 0      ;initialize counter to 0
    mov esi, 0      ;initialize accum to 0
    mov ecx, 0      ;zero out ecx and edx
    mov edx, 0

    mov ebx, [ebp]  ;moves starting locati开发者_如何学Goon of array1 into ebx
    mov edi, [ebp+12]   ;moves array size
add_loop:
    mov ecx, [ebx]  ;mov higher order
    mov edx, [ebx+4]    ;mov lower order

    push ecx
    push edx

    fld     qword [ebx]                    ;The second input is now in a floating point register, specifically st0.
    pop     dword ebp 
    pop     dword ebp                      ;The first input is now on top of the system stack (the stack addressed by bytes)

    fadd    qword [ebx]                    ;The first input is added to the second input and the sum
                                           ;replaces the second input in st0

    add ebx,8
    inc edi

    cmp esi, edi
    jz  add_done
    jmp add_loop
add_done:
    mov     eax, summessage                ;Setup to display a message
    call    print_string                   ;Dr. Carter's library
    push    dword 0                        ;Make space on sytem stack for the sum value
    push    dword 0                        ;Ditto
    fst     qword [ebx]                    ;Copy contents of st0 to space currently on top of the system stack
    pop     ecx                            ;Copy 4 MSBs to ecx
    pop     edx                            ;Copy 4 LSBs to ecx
    call    writedouble                    ;Show the 8-byte value
    call    print_nl                       ;Newline

    pop esi
    pop ecx
    pop edi
    pop ebp
    pop ebx
    ret

For starters, you are comparing edi to 0:

mov esi, 0      ;initialize accum to 0
...
inc edi
cmp esi, edi

The basic idea would be:

    fldz                       ;Load zero into ST0
    mov esi,<address_of_array>
    mov ecx,<number_of_entries>
.next:
    fadd dword [esi]           ;Add float (not double!) to ST0
    add esi,4                  ;esi = address of next float in array
    loop .next

For improved accuracy, you might want to sort the array and/or do the additions in order of smallest to largest.

• Brendan

addarray: pusha mov edi, 0 ;initialize counter to 0 mov esi, 0 ;initialize accum to 0 mov ecx, 0 ;zero out ecx and edx mov edx, 0

mov ebx, [ebp]  ;moves starting location of array1 into ebx
mov edi, [ebp+12]   ;move quantity into edi 
fld qword [ebx]

add_loop: add ebx,8 fld qword [ebx] ;The second input is now in a floating point register, specifically st0.

fadd                 ;The first input is added to the second input and the sum
                     ;replaces the second input in st0
inc esi     ;increment counter

cmp edi, esi    ;compare to see if all values have been added
jz  add_done
jmp add_loop

add_done: call print_nl mov eax, summessage ;Setup to display a message call print_string ;Dr. Carter's library

add ebx, 8        ;increment to not overwrite any values
    fstp    qword [ebx]       ;Copy contents of st0 to space currently on top of the system stack
mov ecx, [ebx]
mov edx, [ebx+4]