Question

I have a simple function that takes two variables by reference:

void foo(int*& it2,
         bit_reader<big_endian_tag>& reader2)
{
    for(/* ... */)
    {
        *it2++ = boo(reader2.next());
        // it2++ => 0x14001d890 add qword ptr [r12], 0x4
    }
}

The problem here is that for it2 and reader2 the optimizer makes the computer write to memory instead of registers during the loop.

However, the following code puts the variables properly into registers during the loop, but has an extra overhead in the form of unnecessary copies, before and after the loop:

void foo2(int*& it2,
         bit_reader<big_endian_tag>& reader2)
{
    auto reader = reader2;
    auto it     = it2;

    for(/* ... */)
    {
        *it++ = boo(reader.next());
        // it++ => 0x14001d890 add r15, 0x4
    }

    reader2 = reader;
    it2 = it;
}

e.g.

How can I make the first example generate the same code as the second example but without the extra copies?

Answer 1

The problem is that the compiler cannot prove it2 does not change within the function. (Well, it could, but that’s vastly beyond the intended capabilities of a normal C++ compiler.)

How does it know boo(reader2.next()); doesn’t change the value? Consider:

int* i = 0;

struct foo
{
    int myInt;
    int blah() { i = &myInt; return 5; }
};

void bar(int*& ptr, const foo& f)
{
    *ptr = f.blah(); // changes value of ptr!
}

int otherInt;
i = &otherInt;

bar(i, foo());

This does not assign anything to otherInt, whereas after your transformation it would:

void bar(int*& ptr, const foo& f)
{
    int* ptrCopy = ptr;
    *ptrCopy = f.blah(); // changes ptr, but not ptrCopy
}

So unless the compiler can prove the behavior is the same, it cannot make the optimization.

C99 solves this problem with the restrict keyword, but C++ has no equivalent. There are extensions that exist in most C++ compilers though, such as __restrict__ or __restrict.

To do it in standard C++, you just have to be explicit and make the copy yourself