指令集如何区分参考值

Question

Let's look at this code:

int main ()
{
    int a = 5;
    int&b = a;

    cout << a << endl;  // 5 is displayed
    cout << b << endl;  // 5 is also displayed

    return 0;
}

This is the behavior I saw in my debugger.

int a = 5 will assign value 5 in memory address -0x14(%rbp)

int& b = a will assign value -0x14(%rbp) in memory address -0x8(%rbp)

When I do cout << a << endl the value in the address of a (ie -0x14(%rbp)) will be displayed.

But somehow when I do cout << b << endl the value in the address of b (ie -0x8(%rbp) ) is determined to be an address then the value of that address ( -0x14(%rbp) ) is displayed.

This is the assembly for the std::cout calls:

20                  cout << a << endl;
0000000000401506:   mov -0xc(%rbp),%eax
0000000000401509:   mov %eax,%edx
000000000040150b:   lea 0x6f8c9c6e(%rip),%rcx        # 0x6fccb180 <libstdc++-6!_ZSt4cout>
0000000000401512:   callq 0x4015f8 <_ZNSolsEi>
0000000000401517:   lea 0xe2(%rip),%rdx        # 0x401600 <_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_>
000000000040151e:   mov %rax,%rcx
0000000000401521:   callq 0x401608 <_ZNSolsEPFRSoS_E>
21                  cout << b << endl;
0000000000401526:   mov -0x8(%rbp),%rax
000000000040152a:   mov (%rax),%eax
000000000040152c:   mov %eax,%edx
000000000040152e:   lea 0x6f8c9c4b(%rip),%rcx        # 0x6fccb180 <libstdc++-6!_ZSt4cout>
0000000000401535:   callq 0x4015f8 <_ZNSolsEi>
000000000040153a:   lea 0xbf(%rip),%rdx        # 0x401600 <_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_>
0000000000401541:   mov %rax,%rcx
0000000000401544:   callq 0x401608 <_ZNSolsEPFRSoS_E>
24                  return 0;

Question:

Both std::cout instructions are very similar, How is a treated differently from b ?

Answer 1

In short: it does not.

CPU itself doesn't care about which type is stored where, it just executes instructions generated by compiler.

Compiler knows that b is a reference, not an int . So it instructs CPU to treat b as a pointer.

If you look at the assembly code for your program, you'll see that the instructions for accessing a and b are different: the part for b contains an extra instruction

mov (%rax),%eax

which is the dereferencing step. (In this assembly notation, parentheses mean dereferencing, so this instruction means something like eax = *rax).

Answer 2

I presume you've requested absolutely no optimization. Although even then, I would have expected accessing a and accessing b to generate exactly the same code (in this case, at least).

With regards to how the compiler knows: a and b have different types, so the compiler knows to do different things with them. The standard has been designed so that replacing int& with int* const , and then automatically dereferencing on each access (except the initialization) will result in a conforming implementation; it looks like this is what your compiler is doing.