Return value const& and const assignment - dissassembly

Question

Lately I've been analyzing some parts of an older code where in some cases value returned from function was assigned to const variable and sometimes to const&. Out of curiousity I've switched to the dissasembly to see the differences. But before getting to the point let me draw a simple example to have some code to refer to:

struct Data
{
    int chunk[1024];
};

Data getData()
{
    return Data();
}

int main()
{
    const std::string varInit{ "abc" }; // 1
    const std::string varVal = "abc"; // 2
    const std::string& varRef = "abc"; // 3

    const Data dataVal = getData(); // 4
    const Data& dataRef = getData(); // 5

    return 0;
}

The following disassembly of the above code was acquired with VS2015 with optimizations disabled.

I'm no asm specialist but at first glance I'd say that for (1) and (2) there are similar operations performed. Nevertheless, I'm surprised that (3) carries two additional operations (lea and mov) comparing to previous versions where the const& was not used during variable value assignment.

Same can be observed when the data is returned from a function by value. (5) carries two more operations in relation to (4).

The questions are quite narrow:

• Where do these additional operations come from and what is their purpose here? Not in general like here: What's the purpose of the LEA instruction but in the presented context.
• Can this influence the performance at least for objects for which the underlaying data size is negligible? (in contrast to Data struct used in the example)
• Would this have any impact when the optimization is turned on? (for release builds)

By the way, I've already read Why not always assign return values to const reference? about pros and cons of using const and const& when assigning values which can be somewhat related but is not a part of the question.

Answer 1

in case (3) compiler create 'hidden' local var 'std::string' at [ebp-84] let name it _84 and do code like this

const std::string _84 = "abc"; 
const std::string& varRef = _84;// lea + move (by sense varRef = &_84)

the X& v - by sense and binary code same as X* v - v is actually pointer to X in both case, simply different syntax used

the same and in case (5)

const Data _20a0 = getData(); 
const Data& dataRef = _20a0; // by sense dataRef = &_20a0, but by syntax dataRef = _20a0

or say if you instead line

const Data& dataRef = getData();

write line

const Data& dataRef = dataVal;

you view that this line take exactly 2 asm instructions:

lea eax,[dataVal]
mov [dataRef],eax

code (4,5) and Data getData() signature is absolute nightmare, no words

---

for more clarity about return structs 'by value' - function can return only register as result (al, ax, eax and rax in x64) or 2 registers - edx:eax (8 byte, edx in high) or rdx:rax (16 byte in x64)

in case Data getData() - impossible return Data as is. how ?!?

so really your function is transformed to

Data* getData(Data* p)
{
    Data x;
    memcpy(p, &x, sizeof(Data));
    return p;
}

and code to

//const Data dataVal = getData(); 
Data _41A0, _3198, dataVal;
memcpy(&_3198, getData(&_41A0), sizeof(Data));
memcpy(&dataVal, &_3198, sizeof(Data));

//const Data& dataRef = getData(); 
Data _41A0, _3198, _20a0, &dataRef;
memcpy(&_51a8, getData(&_61b0), sizeof(Data));
memcpy(&_20a0, &_51a8, sizeof(Data));
dataRef = &_20a0;// very small influence compare all other

try calc how many senseless memcpy do compiler ?

need write code like this

void InitData(Data* p);

Data dataVal;
InitData(&dataVal);