Understanding GCC’s floating point constants in assembly listing output

by

But how, exactly? …

Yes, this is an integer representation of the IEEE754 binary64 (aka double) bit pattern. GCC always prints FP constant this way because they are sometimes the result of constant-propagation, not FP literals that appear in the source. (Also it avoids any dependence on FP rounding in the assembler.)

gcc always uses decimal for integer constants in its asm output, which is pretty inconvenient for humans. (On the Godbolt compiler explorer, use the mouseover tooltip to get hex for any number.)

Clang’s asm output is nicer, and includes a comment with the decimal value of the number:

    .quad   -4605718748921121997    # double -5.2999999999999998

In what order?

x86’s float endianness matches its integer endianness: both are little-endian. (It’s possible for this not to be the case, but all the modern mainstream architectures use the same endianness for integer and float, either big or little. Floating point Endianness?. And Endianness for floating point.)

So when loaded as a 64-bit IEEE-754 double, the low 32 bits in memory are the low 32 bits of the double.

As @MichaelPetch explains in comments, the first/low dword is 0x33333333, and the second/high dword is 0xC0153333. Thus the entire double has a bit-pattern of C015333333333333

For single-precision float, there’s https://www.h-schmidt.net/FloatConverter/IEEE754.html. (It’s pretty nice, it breaks down the bits into binary with checkboxes, as well as hex bit-pattern and decimal fraction. Great for learning about how FP exponent / significand works.)

For double-precision as well, see https://babbage.cs.qc.cuny.edu/IEEE-754.old/64bit.html. You can put in a bit-pattern and see the hex value.

More Related Contents:

  1. Why doesn’t GCC optimize a*a*a*a*a*a to (a*a*a)*(a*a*a)?
  2. The advantages of using 32bit registers/instructions in x86-64
  3. How to load address of function or label into register
  4. Why does the x86-64 System V calling convention pass args in registers instead of just the stack?
  5. Why did GCC generate mov %eax,%eax and what does it mean?
  6. clang (LLVM) inline assembly – multiple constraints with useless spills / reloads
  7. x86_64: Is it possible to “in-line substitute” PLT/GOT references?
  8. Why does GCC use multiplication by a strange number in implementing integer division?
  9. Why doesn’t GCC use partial registers?
  10. Why doesn’t gcc resolve _mm256_loadu_pd as single vmovupd?
  11. Why does GCC allocate more space than necessary on the stack, beyond what’s needed for alignment?
  12. Printing floating point numbers from x86-64 seems to require %rbp to be saved
  13. Vectorizing with unaligned buffers: using VMASKMOVPS: generating a mask from a misalignment count? Or not using that insn at all
  14. Why is %eax zeroed before a call to printf?
  15. Calling printf in x86_64 using GNU assembler
  16. Calling printf in extended inline ASM
  17. Prefetching Examples?
  18. Why does the x86-64 GCC function prologue allocate less stack than the local variables?
  19. How can I multiply 64 bit operands and get 128 bit result portably?
  20. Number of executed Instructions different for Hello World program Nasm Assembly and C
  21. Does a compiler always produce an assembly code?
  22. How to set gcc or clang to use Intel syntax permanently for inline asm() statements?
  23. x86_64 : is stack frame pointer almost useless?
  24. Linux process stack overrun by local variables (stack guarding)
  25. Why do the addresses in my assembler dump differ from the addresses of registers?
  26. How to use AVX/pclmulqdq on Mac OS X
  27. How to convert Linux 32-bit gcc inline assembly to 64-bit code? [closed]
  28. x64 nasm: pushing memory addresses onto the stack & call function
  29. what is the order of source operands in AT&T syntax compared to Intel syntax?
  30. How to force GCC to assume that a floating-point expression is non-negative?

Leave a Comment