编译器对float与double的解释及内存表示，附PIC汇编实操示例

Great question—let’s break this down step by step, starting from how compilers handle floating-point types, their memory representation, and finally a hands-on PIC assembly example to see how this works at the hardware level.

1. How Compilers Interpret float and double #

In C, float and double follow the IEEE 754 floating-point standard, which defines their structure and behavior:

• float is a 32-bit single-precision type: 1 sign bit, 8 exponent bits, and 23 mantissa (fraction) bits.
• double is a 64-bit double-precision type: 1 sign bit, 11 exponent bits, and 52 mantissa bits.

When you write code like float x = 1.375;, the compiler first converts the decimal constant into its IEEE 754 binary equivalent. It then allocates the right amount of memory (4 bytes for float, 8 for double) in the initialized data segment (.data) and writes the binary representation into that memory location.

2. Memory Representation of float x = 1.375 #

Let’s convert 1.375 to IEEE 754 single-precision manually to see how it maps to memory:

1. Convert 1.375 to binary: 1.011 (since 0.375 = 0.25 + 0.125 = 2⁻² + 2⁻³).
2. Normalize the binary: 1.011 × 2⁰ (the leading 1 is implicit in IEEE 754, so we only store the fraction part).
3. Calculate the exponent: IEEE 754 uses a biased exponent—for single-precision, the bias is 127. So exponent = 0 + 127 = 127 (binary 01111111).
4. Assemble the 32-bit value:
   • Sign bit (0 for positive): 0
   • Exponent bits: 01111111
   • Mantissa bits (fraction part 011 padded to 23 bits): 01100000000000000000000
   • Combined: 00111111011000000000000000000000 → hex 0x3F580000.

In memory, this 32-bit value is stored as 4 consecutive bytes. The byte order depends on the CPU’s endianness:

• Little-endian (most x86 systems): 0x00 0x58 0x3F 0x00 (least significant byte first)
• Big-endian (some embedded systems): 0x3F 0x58 0x00 0x00 (most significant byte first)

3. From C to Assembly: Mapping float x = 1.375 to Memory #

When you compile the C line float x = 1.375;, the compiler generates assembly that:

1. Reserves 4 bytes in the .data section for x.
2. Writes the hex value 0x3F580000 into those bytes.

For example, in x86 assembly this might look like:

.data
x:  .long 0x3F580000  ; Initialize x with the IEEE 754 representation of 1.375

But let’s jump to your request for a PIC assembly example to see hardware-level floating-point handling.

4. PIC Assembly Example: Floating-Point Addition & Memory Storage #

We’ll use a PIC32MX microcontroller (which has a hardware floating-point unit, FPU) for this example. Let’s implement a simple operation: float a = 1.375; float b = 2.5; float c = a + b;, then store c in memory.

Here’s the assembly code with explanations:

; PIC32MX Assembly: Float Addition & Memory Storage
    .equ    RESULT_ADDR, 0x80000000  ; Data memory address to store the result (KSEG0)

    .text
    .global _main
_main:
    ; Load float a = 1.375 into floating-point register $f0
    li.s    $f0, 1.375

    ; Load float b = 2.5 into floating-point register $f1
    li.s    $f1, 2.5

    ; Perform single-precision addition: $f2 = $f0 + $f1
    add.s   $f2, $f0, $f1

    ; Store the result from $f2 into RESULT_ADDR in data memory
    s.s     $f2, RESULT_ADDR

loop:
    j       loop  ; Infinite loop to keep the program running

What’s happening here: #

• li.s: Loads a single-precision float constant directly into a floating-point register (the assembler handles converting the decimal value to IEEE 754 binary).
• add.s: Uses the PIC32’s FPU to perform a hardware-accelerated single-precision addition.
• s.s: Stores the 32-bit IEEE 754 result from the floating-point register into the specified memory address.

The result of 1.375 + 2.5 = 3.875 has an IEEE 754 single-precision representation of 0x40780000. In PIC32’s little-endian memory, this will be stored as 0x00 0x78 0x40 0x00 at RESULT_ADDR.

If you were using a PIC without a hardware FPU (like older PIC18 models), the compiler would generate software-emulated floating-point operations—this involves a series of integer arithmetic instructions to mimic IEEE 754 calculations, which is much slower than hardware acceleration.

内容的提问来源于stack exchange，提问作者Riolite