Hi all,

  is there any reason why the access attribute is not used as hints to the
optimizer?

If we take this ancient example:

void foo(const int *);

int bar(void)
{
    int x = 0;
    int y = 0;

    for (int i = 0; i < 10; i++) {
        foo(&x);
        y += x;  // this load not optimized out
    }
    return y;
}

The load of X is not optimized out in the loop since the compiler does not
know if the external function foo() will cast away the const internally.
However changing the x variable to const as in:

void foo(const int *);

int bar(void)
{
    const int x = 0;
    int y = 0;

    for (int i = 0; i < 10; i++) {
        foo(&x);
        y += x;  // this load is now optimized out
    }
    return y;
}

The load of x is now optimized out since it is undefined behaviour if bar()
casts the const away when x is declared to be const.

Now what strikes me as odd however is that declaring the function access
attribute to read_only does not hint the compiler to optimize out the load
of x even though read_only is defined as being stronger than const ("The
mode implies a stronger guarantee than the const qualifier which, when cast
away from a pointer, does not prevent the pointed-to object from being
modified."), so in the following code:

__attribute__ ((access (read_only, 1))) void foo(const int *);

int bar(void)
{
    int x = 0;
    int y = 0;

    for (int i = 0; i < 10; i++) {
        foo(&x);
        y += x;  // this load not optimized out even though we have set the
access to read_only
    }
    return y;
}

The load of x should really be optimized out but isn't. So is this an
oversight in gcc or is the access attribute completely ignored by the
optimizer for some good reason?

If there is no good reason for this then changing this to hint the
optimizer should enable some nice optimizations of external functions where
const in the declaration is not cast away.

Regards,
  Henrik Holst