Originally posted by: Visda
So many times we get clients complaining to us that their code used to work on an older release but it's broken using the new release of the compiler. After closer look at the sample test case provided, we find out they have been lucky to have a working copy of the code. You see, the breakage is expected because they have broken the ansi-aliasing rules.
Not many of us follow the rules defined in C and C++ standards^1^ religiously. Although, the aliasing rules encourage accessing an object by lvalues of types compatible, we often have to break this rule in order to make the code "work".
By default, the xlc on z/Os compiles with
ANSIALIAS. Based on the assumption that pointers in the source file access objects of the same type, the compiler determines storage locations that is accessed in two or more ways, i.e. aliased. If, for example, we have a
struct s with two members
s1 and
s2, the storage for
s overlaps with storage for both
s.s1 and
s.s2. But the storage of the
s.s1 and
s.s2 don't overlap. This knowledge is critical to aggressive compiler optimization. It allows some loads to move up and stores to move down. The rearrangements in the sequence of execution is desirable and increases executing more of the code in parallel.
Casting a pointer to point to a different object is a common C practice. For each type mismatch, xlc generates a warning and/or an informational message, which you may not notice if you have set the level of diagnostic messages to error or higher,
-qflag=E, S, or U, or if you are redirecting all compiler messages to a hardly-ever-looked-at log file. Often the first time you notice a problem is when you execute the code and get an incorrect result.
You have broken the rules, now what?You can compile routines that are not ansi alias compilant with low levels of optimization,
e.g. at OPT0. The higher the level, the more aggressive the optimizations based on aliasing information. You can turn off optimization per routine, by
#pragma option_override(func,"OPt(LEVEL,0)").
You can use
-qnoansialias compile option or use
cc utility which passes
noansialias to the compiler by default. This may not be desirable because it usually results in significant performance degradation,
e.g. gcc compiled at -O3 with -qnoansialias runs 20% slower. You can fix the non-compliance in your source code.
1ISO/IEC 14882:1998(E), Section 3.10, Paragraph 15 states:If a program attempts to access the stored value of an object through an lvalue of other than one of the following types thebehaviour is undefined:
- the dynamic type of the object
- a cv-qualified version of the dynamic type of the object
- a type that is signed or unsigned type corresponding to the dynamic type of the object
- a type that is the signed or unsigned type corresponding to a cv-qualified version of the dynamic type of the object
- an aggregate or union type that includes one of the aforementioned type among its members (including, recursively, a member of a subaggregate or contained union)
- a type that is a (possibly cv-qualified) base class type of the dynamic type of the object
- a char or unsigned char type
Example:
/*alias.c*/
int foo(char *c)
{
char a[100];
char *cptr = a;
*(int *)cptr = *(int*)c;
return 0;
}
xlc -c alias.c -O3 -qlist=./ -qflag=i -qinfo
INFORMATIONAL CCN3495 ./alias.c:5 Pointer type conversion found.
INFORMATIONAL CCN3374 ./alias.c:5 Pointer types "int*" and "char*" are not compatible.
INFORMATIONAL CCN3495 ./alias.c:5 Pointer type conversion found.
INFORMATIONAL CCN3374 ./alias.c:5 Pointer types "int*" and "char*" are not compatible.
INFORMATIONAL CCN3415 ./alias.c:7 The external function definition "foo" is never referenced.