ASM, declaring float variables

Question

I'm trying to store four 32-bit float variables into a 128-bit float variable, here is the asm code:

; function signature is:
; int findMin()

section .data

fa:     dd      10.0
fb:     dd      20.0
fc:     dd      12.0
fd:     dd      9.0

section .bss

fl_var:   reso    1

section .text

global findMin

findMin:


            ; -------------------------------------------
            ; Entrace sequence
            ; -------------------------------------------
            push    ebp         ; save base pointer
            mov     ebp, esp    ; point to current stack frame 
            push    ebx         ; save general registers
            push    ecx
            push    edx
            push    esi         
            push    edi

            fld     dword [fa]
            fstp    dword [fl_var]

            fld     dword [fb]
            fstp    dword [fl_var + 4]

            fld     dword [fc]
            fstp    dword [fl_var + 8]

            fld     dword [fd]
            fstp    dword [fl_var + 12]


            mov eax, 0
            ; ------------------------------------------
            ; Exit sequence
            ; ------------------------------------------ 
            pop     edi
            pop     esi
            pop     edx
            pop     ecx
            pop     ebx
            mov     esp, ebp
            pop     ebp
            ret

For each fn float variable, I use the st0 register to move it into the fl_var, usign a proper offset.

The code doesn't work, and the problem is in the declaration of the fn float variables. If I try to print them using the gdb I get this:

f/fh &fa   //print a 32-bit float
0x804a020 <fa>: 0

The same happen for the others fn variables.

If write:

f/fw &fa  //print a 64-bit float
0x804a020 <fa>: 10

It print the right value! The same happen for the others fn variables. So, even if I declare fa to be a dd (4 bytes), it creates a dq (8 bytes). There is a way to declare a 32-bit float in asm? I've found the type real4, but the compiler complains.

EDIT Another question regarding the gdb and the way it prints variables. Look at this code:

;int findMin(float a, float b, float c, float d)
section .bss

int_var:    reso 2

section .text
global findMin

findMin:

fld     qword [ebp + 8]
fstp    qword [int_var]

fld     qword [ebp + 16]
fstp    qword [int_var + 8]

fld     qword [ebp + 24]
fstp    qword [int_var + 16]

fld     qword [ebp + 32]
fstp    qword [int_var + 24]

I call it from a C piece of code, because of the C calling conventions, float are passed as 64-bit values. So I take each argument moving 8 bytes each time from the stack. When I enter the gdb and print the value of int_var, I get the correct result using:

x/4fw &int_var

If I write

x/4fg &int_var

I don't get the numbers passed to the function, but inconsistent values. Why it is printing correctly using the w letter (32-bit)?