on x86 how are doubles passed to a function - c++

Question

I have the following function that takes 3 double arguments. Inside my debugger when a break on this function is reached. Inspecting the arguments to the function I don't see the 3 double arguments.
On an x86 platform are double arguments to a function stored on the stack?
Below is the function and disassembly in windbg. Why don't I see the values passed in to the function as Args to Child in windbg?
vector<double> calculate_quadratic(double a, double b, double c)
{
double discriminant = (b * b) - 4 * a * c;
vector<double>result;
try
{
if (discriminant < 0)
throw Bad_Value{};
else
{
double d = sqrt(discriminant);
double px = (-b + d) / (2 * a);
double nx = (-b - d) / (2 * a);
result.push_back(px);
result.push_back(nx);
}
}
catch (Bad_Value)
{
cerr << "invalid value" << endl;
}
return result;
}
0:000> kb
# ChildEBP RetAddr Args to Child
00 003dfd2c 0126ad86 003dfe30 00000000 3ff00000 quadratic!calculate_quadratic
01 003dfe84 0126ba6e 00000001 0043d080 0043dd18 quadratic!main+0xc6
02 003dfe98 0126b8d0 ac1dec02 00000000 00000000 quadratic!invoke_main+0x1e
03 003dfef0 0126b76d 003dff00 0126ba88 003dff0c quadratic!__scrt_common_main_seh+0x150
04 003dfef8 0126ba88 003dff0c 772c336a 7efde000 quadratic!__scrt_common_main+0xd
05 003dff00 772c336a 7efde000 003dff4c 777f9f72 quadratic!mainCRTStartup+0x8
06 003dff0c 777f9f72 7efde000 77465726 00000000 kernel32!BaseThreadInitThunk+0xe
07 003dff4c 777f9f45 01261127 7efde000 00000000 ntdll!__RtlUserThreadStart+0x70
08 003dff64 00000000 01261127 7efde000 00000000 ntdll!_RtlUserThreadStart+0x1b
0:000> r
eax=003dfe30 ebx=003dfd48 ecx=acd07c23 edx=582e27d8 esi=003dfd50 edi=003dfd4c
eip=01268f70 esp=003dfd30 ebp=003dfe84 iopl=0 nv up ei pl nz ac po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000212
quadratic!calculate_quadratic:
01268f70 push ebp
0:000> dv /t /v
003dfd38 double a = 1
003dfd40 double b = -3
003dfd48 double c = 2
003dfd0c double discriminant = 1.7499487580265442e+127
003dfcf4 struct Vector<double> result = struct Vector<double>
Dumping the ChildEBP of the top frame I can now see the arguments on the stack in reverse order - In this case i used 10 three times which is represented as 4024000000000000
0:000> kb
# ChildEBP RetAddr Args to Child
00 004cfac4 0017ad86 004cfbc8 00000000 40240000 quadratic!calculate_quadratic
0:000> dd 004cfac4
004cfac4 5a23da80 0017ad86 004cfbc8 00000000
004cfad4 40240000 00000000 40240000 00000000
004cfae4 40240000 ed0a64cf 00000000 00000000
0:000> .formats 4024000000000000
Evaluate expression:
Hex: 40240000`00000000
Decimal: 4621819117588971520
Octal: 0400440000000000000000
Binary: 01000000 00100100 00000000 00000000 00000000 00000000 00000000 00000000
Chars: #$......
Time: Fri Dec 18 11:22:38.897 16246 (UTC - 5:00)
Float: low 0 high 2.5625
Double: 10

Answer 1

The default calling convention for C/C++ is cdecl. In this calling convention, when building for x86, arguments are passed on the stack in reverse order. Compiler options or function decorations can override this behaviour, of course.
Looking at your WinDBG output, the first three stack entries (args to child) are :
003dfe30 00000000 3ff00000
Since a double is 64 bits wide you're only looking at one and a half of your arguments. The first entry looks to be the contents of EAX...perhaps a compiler optimization has pushed EAX to the stack at the point your breakpoint hit? The next value is 00000000 3ff00000, which is LE of 3ff0000000000000 = 1(IEEE754), the leftmost argument and the last to be passed to the stack in cdecl.

Answer 2

How arguments are passed is compiler dependent and can often be changed by options or compiler directives.
Most x86 compilers will use either the x87 FPU stack (ST0-ST7 registers) or the SSE registers (XMM0-XMM7) if for passing floating point arguments. On MSVC, this is controlled by the /arch and /fp options.