4.12.2 Use the --no_bad_aliases Option to Indicate That These Techniques Are Not Used

The --no_bad_aliases option informs the compiler that it can make certain assumptions about how aliases are used in your code. These assumptions allow the compiler to improve optimization. The --no_bad_aliases option also specifies that loop-invariant counter increments and decrements are non-zero. Loop invariant means the value of an expression does not change within the loop.

The --no_bad_aliases option indicates that your code does not use the aliasing technique described in Section 4.12.1. If your code uses that technique, do not use the --no_bad_aliases option. You must compile with the --aliased_variables option.

Do not use the --aliased_variables option with the --no_bad_aliases option. If you do, the --no_bad_aliases option overrides the --aliased_variables option.

The --no_bad_aliases option indicates that a pointer to a character type does not alias (point to) an object of another type. That is, the special exception to the general aliasing rule for these types given in Section 3.3 of the ISO specification is ignored. If you have code similar to the following example, do not use the --no_bad_aliases option:

    {
        long  l;
        char *p = (char *) &l;

        p[2] = 5;
    }

The --no_bad_aliases option indicates that indirect references on two pointers, P and Q, are not aliases if P and Q are distinct parameters of the same function activated by the same call at run time. If you have code similar to the following example, do not use the --no_bad_aliases option:

    g(int j)
    {

        int a[20];

        f(&a, &a)         /* Bad */
        f(&a+42, &a+j)    /* Also Bad */
    }

    f(int *ptr1, int *ptr2)
    {
       ...
    }

The --no_bad_aliases option indicates that each subscript expression in an array reference A[E1]..[En] evaluates to a nonnegative value that is less than the corresponding declared array bound. Do not use --no_bad_aliases if you have code similar to the following example:

    static int ary[20][20];

    int g()
    {
        return f(5, -4); /* -4 is a negative index */
        return f(0, 96); /* 96 exceeds 20 as an index */
        return f(4, 16); /* This one is OK */
    }

    int f(int I, int j)
    {
        return ary[i][j];
    }

In this example, ary[5][-4], ary[0][96], and ary[4][16] access the same memory location. Only the reference ary[4][16] is acceptable with the --no_bad_aliases option because both of its indices are within the bounds (0..19).

The --no_bad_aliases option indicates that loop-invariant counter increments and decrements of loop counters are non-zero. Loop invariant means an expression value does not change within the loop.

If your code does not contain any of the aliasing techniques described above, you should use the --no_bad_aliases option to improve the optimization of your code. However, you must use discretion with the --no_bad_aliases option; unexpected results may occur if these aliasing techniques appear in your code and the --no_bad_aliases option is used.