In C++, can I declare a reference so as to indicate that nothing will ever modify it?

Question

If I do

typedef void Cb();

int foo(int const& a, Cb cb) {
  int x = a;
  cb();
  return x - a;
}

and compile with g++ -O3 -save-temps -c foo.cpp, I see that the subtraction is preserved, whereas if cb(); is commented out, the entire function optimizes to

xorl    %eax, %eax

Is there something I can do to the specification of the parameter a so that the subtraction will be optimized out regardless of the call to cb(), and without forcing a to be a unique reference (ie, that it may be referred to elsewhere, but that via none of those references will it be modified)?

Answer 1

Doing the suggested optimization would be incorrect because the rest of the code might be:

static int var;

void func()
{
    var++;
}

// ...
foo(var, func);

I'm not aware of any compiler-specific attribute you can set to say that cb() will not modify a.

Answer 2

There's the __restrict extension, you can try this on gcc.godbolt.org:

typedef void Cb();

int foo(const int & __restrict a, Cb cb) {
  int x = a;
  cb();
  return x - a;
}

Curiously, only clang does the optimization, gcc doesn't do it.

---

Notice that restrict-like aliasing is being considered to be part of the C++ standard:

• N3988: Towards restrict-like aliasing semantics—Finkel, Tong, Carruth, Nelson, Vandevoorde, Wong

Maybe in the future you can do it by the standard.

Answer 3

Why don't you just move the int x = a; line below the function call?

If cb() influences neither x nor a, you should be fine doing that, and I think the compiler will optimize the call again, because x cannot change between the two calls. If there is a reason why you cannot reorder these two calls, you can probably not optimize it in the first place.

This is not something you can hint the compiler to do though, since there is no way to guarantee that neither x nor a have changed after the call to cb().

Think about this as an order of read/write accesses. If no read or write access to a and x happens during cb(), you can do a manual reordering of the function-call.

If a or x is written, you cannot reorder, and the optimization would not be correct.

If x is read, you cannot reorder the function call, but if x truly is only read, you could read from a instead, and define x only after the call since it will have the same value as a, had you declared it before the call.

Answer 4

You could use the C restrict on the reference, if your compiler supports that extension.
(Some compiler allow __restrict or __restrict__, which are part of the implementations namespace.)

That's a promise from you to the compiler that the object is not aliased anywhere, and it can thus optimize it.
If you lied to the compiler, well, you get the broken code you deserve.

Answer 5

__attribute__((const)) is enough

As documented at: https://gcc.gnu.org/onlinedocs/gcc-5.1.0/gcc/Function-Attributes.html , it tells the compiler that the given function does not modify globals (although it can read them).

There is also the pure subset of const, which also forbids global reads.

Consider the following simplified example:

int __attribute__((const)) g();

int f(int a) {
  int x = a;
  g();
  return x - a;
}

On g++ 4.8 x86_64 -O3, it compiles to:

• xor %eax,%eax with const
• a large function that does not suppose a is not modified without const

There seems to be no finer grained attribute that says that a function does not modify a given variable as you require.

Can __attribute__((const)) be applied to function pointers?

Let's try:

int f(int& a, void __attribute__((const)) (*g)(void)) {
    int x = a;
    (*g)();
    return x - a;
}

Once again, it compiles to xor %eax,%eax, and to a large function without const, so the answer is yes.

This syntax was asked at: Function pointer to __attribute__((const)) function?

It also appeared in 2011 on the mailing list at: http://comments.gmane.org/gmane.comp.gcc.help/38052 At the time at least, it only worked for some attributes.

Can __attribute__((const)) be added to the typedef?

This works:

typedef void __attribute__((const)) (*g_t)(void);

int f(int& a, g_t g) {
    int x = a;
    (*g)();
    return x - a;
}

or:

typedef void (g_t)(void);

int f(int& a, g_t __attribute__((const)) g) {
    int x = a;
    g();
    return x - a;
}

But I couldn't find a way to both put the attribute on the typedef and pass a function, not a pointer, like:

typedef void __attribute__((const)) (g_t)(void);

GCC gives a warning saying the attribute was ignored in this case.