1

If a function parameter is annotated const int &x and I try to do x++ in the function body, I get a compile time error for modifying a read-only reference. But if I use the __restrict__ modifier like so:

void foo(int & __restrict__ a, int & __restrict__ b) {
    if (a == 1)
        b = 2;
    if (a == 2)
        b = 3;
}

int main() {
    int x = 1;
    foo(x, x); // should be illegal?
    cout << x;
}

...I do not get a compile time error. If I run this code unoptimized the output is 3, but if I run it with -O1 or higher the output is 2. It seems like detecting x to be passed twice would be straightforward and easy to disallow. Why does C++ protect against bad use of const but not bad use of __restrict__?

springworks00
  • 104
  • 15

3 Answers3

3

In the very general case it is impossible to diagnose it at compile-time. Just as one trivial counter example, consider:

 void foo(int* __restrict__ a, int * __restrict__ b);

 int x;
 int y;
 std::cin >> x >> y;
 int* a = (x%2) ? &x : &y;
 int* b = (y%2) ? &x : &y;
 foo(a,b);

No way the compiler can know if a and b will point to the same int. Actually if the compiler could do such analysis, there would be no need for the __restrict__ qualifier, because then the compiler could by itself figure out if two pointers are used to access same memory.

463035818_is_not_an_ai
  • 109,796
  • 11
  • 89
  • 185
3

You are looking at __restrict__ backwards.

__restrict__ is an implementation extension that the programmer can use to signal intent, to maximise generated code quality and performance ("optimisations").

It is not a check, or an added constraint on the program.

It is not part of the type system, so it's not part of the function's type, so it cannot be enforced at callsites (in general).

It is like some other extensions (such as __builtin_unreachable), that you use to tell the compiler something.

In this case, you're telling it "I am not referring to the pointee via any other pointer".

You're not asking it "please stop me from referring to the pointee via any other pointer".

C and C++ compilers already perform strong "aliasing" checks where they can. The __restrict__ keyword is a way for you to tell it "I am sure about this", in cases where the automatic aliasing detection cannot work (due to, for example, translation unit boundaries). Because the automatic aliasing detection cannot work, __restrict__ cannot be enforced.

And, even if it could be, that would be the opposite of the purpose of the modifier.

Asteroids With Wings
  • 17,071
  • 2
  • 21
  • 35
2

It is not that easy to detect restrict violation in general. Suppose you have a function

void bar(int* p1, int* p2) {
    foo(*p1, *p2);
}

What should a compiler do in this case?

In some cases (like in your example), restrict violation can be detected and is detected by some compilers. For example, GCC with -Wrestrict produces a warning:

warning: passing argument 1 to restrict-qualified parameter aliases with argument 2

GCC documentation on -Wrestrict reads:

Warn when an object referenced by a restrict-qualified parameter (or, in C++, a __restrict-qualified parameter) is aliased by another argument, or when copies between such objects overlap.

You can turn this warning into an error using with -Werror=restrict option.

Evg
  • 25,259
  • 5
  • 41
  • 83