Studying note of GCC-3.4.6 source (166)

5.13.5.1.3.        Prepare alias set

However, the entry point for creating alias set is get_alias_set below. Both node of type and node of declaration can claim for alias analysis, but declaration’s alias set is determined by the alias set of underlying type. Condition at line 467 selects out the node of declaration. In C++ front-end, hook get_alias_set at line 475 points to cxx_get_alias_set . However, the function majorly handles node of type definition, we leave the function for the moment.

 

449  HOST_WIDE_INT

450  get_alias_set (tree t)                                                                                    in alias.c

451  {

452    HOST_WIDE_INT set;

453 

454    /* If we're not doing any alias analysis, just assume everything

455      aliases everything else. Also return 0 if this or its type is

456      an error.  */

457    if (! flag_strict_aliasing || t == error_mark_node

458        || (! TYPE_P (t)

459          && (TREE_TYPE (t) == 0 || TREE_TYPE (t) == error_mark_node)))

460      return 0;

461 

462    /* We can be passed either an expression or a type. This and the

463      language-specific routine may make mutually-recursive calls to each other

464      to figure out what to do. At each juncture, we see if this is a tree

465      that the language may need to handle specially. First handle things that

466      aren't types.  */

467    if (! TYPE_P (t))

468    {

469      tree inner = t;

470      tree placeholder_ptr = 0;

471 

472      /* Remove any nops, then give the language a chance to do

473         something with this tree before we look at it.  */

474      STRIP_NOPS (t);

475      set = (*lang_hooks . get_alias_set ) (t);

476      if (set != -1)

477        return set;

478 

479      /* First see if the actual object referenced is an INDIRECT_REF from a

480          restrict-qualified pointer or a "void *". Replace

481         PLACEHOLDER_EXPRs.  */

482      while (TREE_CODE (inner) == PLACEHOLDER_EXPR

483            || handled_component_p (inner))

484      {

485        if (TREE_CODE (inner) == PLACEHOLDER_EXPR)

486           inner = find_placeholder (inner, &placeholder_ptr);

487        else

488           inner = TREE_OPERAND (inner, 0);

489 

490        STRIP_NOPS (inner);

491      }

492 

493      /* Check for accesses through restrict-qualified pointers.  */

494      if (TREE_CODE (inner) == INDIRECT_REF)

495      {

496        tree decl = find_base_decl (TREE_OPERAND (inner, 0));

497 

498        if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))

499        {

500          /* If we haven't computed the actual alias set, do it now.  */

501          if (DECL_POINTER_ALIAS_SET (decl) == -2)

502          {

503            tree pointed_to_type = TREE_TYPE (TREE_TYPE (decl));

504 

505            /* No two restricted pointers can point at the same thing.

506                However, a restricted pointer can point at the same thing

507               as an unrestricted pointer, if that unrestricted pointer

508               is based on the restricted pointer. So, we make the

509               alias set for the restricted pointer a subset of the

510               alias set for the type pointed to by the type of the

511               decl.  */

512            HOST_WIDE_INT pointed_to_alias_set

513                = get_alias_set (pointed_to_type);

514 

515            if (pointed_to_alias_set == 0)

516              /* It's not legal to make a subset of alias set zero.  */

517              DECL_POINTER_ALIAS_SET (decl) = 0;

518            else if (AGGREGATE_TYPE_P (pointed_to_type))

519              /* For an aggregate, we must treat the restricted

520                 pointer the same as an ordinary pointer. If we

521                 were to make the type pointed to by the

522                 restricted pointer a subset of the pointed-to

523                 type, then we would believe that other subsets

524                 of the pointed-to type (such as fields of that

525                 type) do not conflict with the type pointed to

526                 by the restricted pointer.   */

527              DECL_POINTER_ALIAS_SET (decl)

528                   = pointed_to_alias_set;

529            else

530            {

531              DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();

532              record_alias_subset (pointed_to_alias_set,

533                               DECL_POINTER_ALIAS_SET (decl));

534            }

535          }

536 

537           /* We use the alias set indicated in the declaration.  */

538          return DECL_POINTER_ALIAS_SET (decl);

539        }

540 

541         /* If we have an INDIRECT_REF via a void pointer, we don't

542           know anything about what that might alias.  */

543        else if (TREE_CODE (TREE_TYPE (inner)) == VOID_TYPE)

544          return 0;

545      }

546 

547      /* Otherwise, pick up the outermost object that we could have a pointer

548         to, processing conversion and PLACEHOLDER_EXPR as above.  */

549      placeholder_ptr = 0;

550      while (TREE_CODE (t) == PLACEHOLDER_EXPR

551            || (handled_component_p (t) && ! can_address_p (t)))

552      {

553        if (TREE_CODE (t) == PLACEHOLDER_EXPR)

554          t = find_placeholder (t, &placeholder_ptr);

555        else

556          t = TREE_OPERAND (t, 0);

557 

558        STRIP_NOPS (t);

559      }

560 

561       /* If we've already determined the alias set for a decl, just return

562         it. This is necessary for C++ anonymous unions, whose component

563         variables don't look like union members (boo!).  */

564      if (TREE_CODE (t) == VAR_DECL

565         && DECL_RTL_SET_P (t) && GET_CODE (DECL_RTL (t)) == MEM)

566        return MEM_ALIAS_SET (DECL_RTL (t));

567 

568      /* Now all we care about is the type.  */

569      t = TREE_TYPE (t);

570    }

 

Above node of INDIRECT_REF in C++ language stands for an expression for a pointer or reference (for example, char *p;), clearly the alias set of the object referred is what we want. Thus find_base_decl finds the DECL on which this expression is based (For example, in `a[i]' this would be `a'). And if there is no such DECL, or a unique DECL cannot be determined, NULL_TREE is returned.

 

361  static tree

362  find_base_decl (tree t)                                                                                in alias.c

363  {

364    tree d0, d1, d2;

365 

366    if (t == 0 || t == error_mark_node || ! POINTER_TYPE_P (TREE_TYPE (t)))

367      return 0;

368 

369    /* If this is a declaration, return it.  */

370    if (TREE_CODE_CLASS (TREE_CODE (t)) == 'd')

371      return t;

372 

373    /* Handle general expressions. It would be nice to deal with

374      COMPONENT_REFs here. If we could tell that `a' and `b' were the

375      same, then `a->f' and `b->f' are also the same.  */

376    switch (TREE_CODE_CLASS (TREE_CODE (t)))

377    {

378      case '1':

379        return find_base_decl (TREE_OPERAND (t, 0));

380 

381      case '2':

382         /* Return 0 if found in neither or both are the same.  */

383        d0 = find_base_decl (TREE_OPERAND (t, 0));

384        d1 = find_base_decl (TREE_OPERAND (t, 1));

385        if (d0 == d1)

386          return d0;

387        else if (d0 == 0)

388          return d1;

389        else if (d1 == 0)

390          return d0;

391        else

392          return 0;

393 

394      case '3':

395        d0 = find_base_decl (TREE_OPERAND (t, 0));

396        d1 = find_base_decl (TREE_OPERAND (t, 1));

397        d2 = find_base_decl (TREE_OPERAND (t, 2));

398 

399        /* Set any nonzero values from the last, then from the first.  */

400        if (d1 == 0) d1 = d2;

401        if (d0 == 0) d0 = d1;

402        if (d1 == 0) d1 = d0;

403        if (d2 == 0) d2 = d1;

404 

405        /* At this point all are nonzero or all are zero. If all three are the

406          same, return it. Otherwise, return zero.  */

407        return (d0 == d1 && d1 == d2) ? d0 : 0;

408 

409      default :

410        return 0;

411    }

412  }

 

If we find the based DECL, back get_alias_set at line 498, if DECL_POINTER_ALIAS_SET doesn’t set with -1, DECL_POINTER_ALIAS_SET_KNOWN_P is true (-1 means the alias set for the declaration has not been yet computed). Further if DECL_POINTER_ALIAS_SET returns -2, it indicates that we need to make a unique alias set for this pointer (it is only applied to case of using GNU extension keyword restrict to restrict pointer alias, see c_apply_type_quals_to_decl ). It needs some special treatement.

The restrict pointer qualifier can be applied to a data pointer to indicate that, during the scope of that pointer declaration, all data accessed through it will be accessed only through that pointer but not through any other pointer. The __restrict__ keyword thus enables the compiler to perform certain optimizations based on the premise that a given object cannot be changed through another pointer. For example, declaration “int  f ( int  * restrict  x,  int  * restrict  y)” means changing the content of address pointed by pointer x can only via this pointer. So it is safe to compute alias set as below.

Then at line 503 in get_alias_set , here decl is the based DECL, it must have type of indirect type (pointer or reference), so pointed_to_type holds the type the indirect type refers to. Next get_alias_set invoked at line 512 recursively works out the alias set for the type. So at line 518, if pointed_to_type points to aggregate type, the alias set for this type should have been computed in the invocation at line 512, uses this alias set for the pointer (computing alias set for aggregate type is done by record_component_aliases , we will see it soon).

While if the pointer is not of aggregate type, it enters block at line 529 in get_alias_set , to be conservative but correct, combines all declarations pointed by pointer of this type into the same tree of alias set rooted by the pointer type (but note that the alias set of decl aliases nothing but it self, since it is delcared as “restrict”).

Then if it comes at line 549 in get_alias_set , because either inner is not INDIRECT_REF or its alias set is unknown. For the case, we get the alias set from its type.

Node of WITH_RECORD_EXPR and PLACEHOLDER_EXPR are used in languages that have types where some field in an object of the type contains a value that is used in the computation of another field's offset or size and/or the size of the type. The positions and/or sizes of fields can vary from object to object of the same type or even for one and the same object within its scope. Record types with discriminants in Ada or schema types in Pascal are examples of such types. For C++ front-end, we don’t need worry about these nodes.

 

get_alias_set (continue)

 

572    /* Variant qualifiers don't affect the alias set, so get the main

573      variant. If this is a type with a known alias set, return it.  */

574    t = TYPE_MAIN_VARIANT (t);

575    if (TYPE_ALIAS_SET_KNOWN_P (t))

576       return TYPE_ALIAS_SET (t);

577 

578    /* See if the language has special handling for this type.  */

579    set = (*lang_hooks . get_alias_set ) (t);

580    if (set != -1)

581      return set;

582 

583    /* There are no objects of FUNCTION_TYPE, so there's no point in

584      using up an alias set for them. (There are, of course, pointers

585      and references to functions, but that's different.)  */

586    else if (TREE_CODE (t) == FUNCTION_TYPE)

587      set = 0;

588 

589    /* Unless the language specifies otherwise, let vector types alias

590      their components. This avoids some nasty type punning issues in

591      normal usage. And indeed lets vectors be treated more like an

592      array slice.  */

593    else if (TREE_CODE (t) == VECTOR_TYPE)

594      set = get_alias_set (TREE_TYPE (t));

595 

596    else

597      /* Otherwise make a new alias set for this type.  */

598      set = new_alias_set ();

599 

600    TYPE_ALIAS_SET (t) = set;

601 

602    /* If this is an aggregate type, we must record any component aliasing

603      information.  */

604    if (AGGREGATE_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)

605      record_component_aliases (t);

606 

607    return set;

608  }

 

First, it sees if there is any suggestion from the language. Hook get_alias_set refers to cxx_get_alias_set below for C++.

Recall that for non-POD class, CLASSTYPE_AS_BASE is an RECORD_TYPE node with virtual bases stripped and its TYPE_CONTEXT refers to the RECORD_TYPE of the class, so predicate “CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t” is true if t is the node of CLASSTYPE_AS_BASE of non-POD class (while for POD class, CLASSTYPE_AS_BASE is the RECORD_TYPE of the class, so the mentioned predicate is false).

So condition at line 295 tells that t is enclosed within a class, and it is the base part of enclosing class.

 

292  static HOST_WIDE_INT

293  cxx_get_alias_set (tree t)                                                                            in cp-lang.c

294  {

295    if (TREE_CODE (t) == RECORD_TYPE

296        && TYPE_CONTEXT (t) && CLASS_TYPE_P (TYPE_CONTEXT (t))

297        && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)

298      /* The base variant of a type must be in the same alias set as the

299        complete type.  */

300      return get_alias_set (TYPE_CONTEXT (t));

301   

302    if (/* It's not yet safe to use alias sets for some classes in C++.  */

303      !ok_to_generate_alias_set_for_type (t)

304        /* Nor is it safe to use alias sets for pointers-to-member

305         functions, due to the fact that there may be more than one

306         RECORD_TYPE type corresponding to the same pointer-to-member

307         type.  */

308       || TYPE_PTRMEMFUNC_P (t))

309      return 0;

310 

311    return c_common_get_alias_set (t);

312  }

 

Then for the cases come at line 302, ok_to_generate_alias_set_for_type checks if the type is safe for aliasing.

First, class having virtual base is unsafe for aliasing. For example :

class A { ... };

class B : public virtual A { ... } ;

class C : public virtual A { ... } ;

class D : public B, C { ... } ;

Though D derives from B, in D the base B has different layout than class B even if B is empty class. Remember predicate CLASS_TYPE_P at line 250 is false for CLASSTYPE_AS_BASE of non-POD class.

Similarly, if a class contains a field of another class containing virtual base, it is unsafe to alias this type (both cases considered as may-alias).

 

239  static bool

240  ok_to_generate_alias_set_for_type (tree t)                                                    in cp-lang.c

241  {

242    if (TYPE_PTRMEMFUNC_P (t))

243      return true;

244    if (AGGREGATE_TYPE_P (t))

245    {

246      if ((TREE_CODE (t) == RECORD_TYPE) || (TREE_CODE (t) == UNION_TYPE))

247      {

248        tree fields;

249        /* Backend-created structs are safe.  */

250        if (! CLASS_TYPE_P (t))

251          return true;

252         /* PODs are safe.  */

253         if (! CLASSTYPE_NON_POD_P(t))

254          return true;

255         /* Classes with virtual baseclasses are not.  */

256        if (TYPE_USES_VIRTUAL_BASECLASSES (t))

257          return false;

258        /* Recursively check the base classes.  */

259        if (TYPE_BINFO (t) != NULL && TYPE_BINFO_BASETYPES (t) != NULL)

260        {

261          int i;

262          for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (t)); i++)

263          {

264            tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), i);

265            if (!ok_to_generate_alias_set_for_type (BINFO_TYPE (binfo)))

266              return false;

267          }

268        }

269        /* Check all the fields.  */

270        for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))

271        {

272          if (TREE_CODE (fields) != FIELD_DECL)

273             continue ;

274          if (! ok_to_generate_alias_set_for_type (TREE_TYPE (fields)))

275            return false;

276        }

277        return true;

278      }

279      else if (TREE_CODE (t) == ARRAY_TYPE)

280        return ok_to_generate_alias_set_for_type (TREE_TYPE (t));

281      else

282        /* This should never happen, we dealt with all the aggregate

283          types that can appear in C++ above.  */

284        abort ();

285    }

286    else

287      return true;

288  }

 

Further considering following example:

extern "C" int printf(const char *,...);

class A {

protected  : int i ;

    public :

void f1 () { printf ("%d/n", i); }

        A () : i (0) {}

};

class B : public A {

    public :

void f1 () { printf ("%d/n", i); }

        B () { i = 2 ; }

};

int main () {

    void (A::*pf1) () = &A::f1;

    B b;

    (b.*pf1)();              // output “2”

    A a ;

    (a.*pf1)() ;      // output “0”

    return 0;

}

It prints out “2, 0”, no doubt pf1 accesses different objects in both times. So be careful in treating alias set for member pointer. Here such pointer is regarded as may-alias (line 308 in cxx_get_alias_set ).

Except the treatment of class, C++ front-end shares following routine with C front-end to handle types also available in C. First for direct accessing of union member, it aliases to the other members of the union. The comment of the case says that setting the field via taking address is not permitted in C standard and it has implementation-defined behave, [6] also gives an explaination.

-fstrict-aliasing ²        Allows the compiler to assume the strictest aliasing rules applicable to the language being compiled. For C (and C ++ ), this activates optimizations based on the type of expressions. In particular, an object of one type is assumed never to reside at the same address as an object of a different type, unless the types are almost the same. For example, an unsigned int can alias an int , but not a void* or a double . A character type may alias any other type. Pay special attention to code like this: union a_union { int i; double d; }; int f() { a_union t; t.d = 3.0; return t.i; } The practice of reading from a different union member than the one most recently written to (called “type-punning”) is common. Even with ‘ -fstrict-aliasing ’, type-punning is allowed, provided the memory is accessed through the union type. So, the code above will work as expected. However, this code might not: int f() { a_union t; int* ip; t.d = 3.0; ip = &t.i; return *ip; } Similarly, access by taking the address, casting the resulting pointer and dereferencing the result has undefined behavior, even if the cast uses a union type, e.g.: int f() { double d = 3.0; return ((union a_union *) &d)->i; } The ‘ -fstrict-aliasing ’ option is enabled at levels ‘ -O2 ’, ‘ -O3 ’, ‘ -Os ’.

Immediately in below, we will see an example of incorrect code generated out of type-punning. And that example can explain well why there may be undefined behavior. However, GCC give NO warning if we behave badly as above. Except this case, t of non-type is kicked off.

 

2848 HOST_WIDE_INT

2849 c_common_get_alias_set (tree t)                                                          n c-common.c

2850 {

2851   tree u;

2852

2853   /* Permit type-punning when accessing a union, provided the access

2854     is directly through the union. For example, this code does not

2855     permit taking the address of a union member and then storing

2856     through it. Even the type-punning allowed here is a GCC

2857     extension, albeit a common and useful one; the C standard says

2858     that such accesses have implementation-defined behavior.  */

2859   for (u = t;

2860        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;

2861        u = TREE_OPERAND (u, 0))

2862     if (TREE_CODE (u) == COMPONENT_REF

2863        && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)

2864       return 0;

2865

2866   /* That's all the expressions we handle specially.  */

2867   if (! TYPE_P (t))

2868     return -1;

2869

2870   /* The C standard guarantees that any object may be accessed via an

2871     lvalue that has character type.  */

2872   if (t == char_type_node

2873       || t == signed_char_type_node

2874       || t == unsigned_char_type_node)

2875     return 0;

2876

2877   /* If it has the may_alias attribute, it can alias anything.  */

2878   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))

2879     return 0;

2880

2881   /* The C standard specifically allows aliasing between signed and

2882     unsigned variants of the same type. We treat the signed

2883     variant as canonical.  */

2884   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))

2885   {

2886     tree t1 = c_common_signed_type (t);

2887

2888     /* t1 == t can happen for boolean nodes which are always unsigned.  */

2889     if (t1 != t)

2890       return get_alias_set (t1);

2891   }

2892   else if (POINTER_TYPE_P (t))

2893   {

2894     tree t1;

2895

2896      /* Unfortunately, there is no canonical form of a pointer type.

2897       I n particular, if we have `typedef int I', then `int *', and

2898       `I *' are different types. So, we have to pick a canonical

2899       representative. We do this below.

2900

2901       Technically, this approach is actually more conservative that

2902       it needs to be. In particular, `const int *' and `int *'

2903       should be in different alias sets, according to the C and C++

2904       standard, since their types are not the same, and so,

2905       technically, an `int **' and `const int **' cannot point at

2906       the same thing.

2907

2908        But, the standard is wrong. In particular, this code is

2909       legal C++:

2910

2911          int *ip;

2912          int **ipp = &ip;

2913          const int* const* cipp = &ipp;

2914

2915       And, it doesn't make sense for that to be legal unless you

2916       can dereference IPP and CIPP. So, we ignore cv-qualifiers on

2917       the pointed-to types. This issue has been reported to the

2918       C++ committee.  */

2919     t1 = build_type_no_quals (t);

2920     if (t1 != t)

2921       return get_alias_set (t1);

2922   }

2923

2924   return -1;

2925 }

 

Above at line 2872, there are two case in fact would be covered. That is declaration like : char c; and char *pc; for the former case, c can’t alias other and no need create alias set (and consider the case of short type, it a group of 2 bytes, thus these two bytes can alias short type and must have alias set within the alias set of short, the front-end must prepare an alias set for this type as we see in the code), while rear one aliases any object that can be accessed via a lvalue. But for rear case, every time it points to specific object, it will get its alias set through block at line 494 in get_alias_set , and mayn’t be zero any more (it returns 0 for c style type cast).

At here, it is clear that declarations other than indirect reference (those pointer type or reference type) will share the alias set of their based type. For example : “short j , k, l; ”, in this statement, variables j, k, and l will have the same alias set of type short. However, the alias set will be ignored as these variables can’t alias each other. Now if we change the statement as : “short j, k, l, *p;”, now j, k, l and pointer p will share the alias set of short. So the front-end can know that p may alias to j, k or l.

Next consider statement “short j, k; char *p;”, j and k share the same alias set of short, but now p hasn’t alias set because get_alias_set (more precisely c_common_get_alias_set ) returns 0 for it. For this statement alone, the front-end won’t alias p to j or k. If we add a statement : “p = &j;”, in C++, it will trigger implicit conversion error. Then if we add instead a statement: “p = (char*)&j;”, alias set of p and j will be checked for intersection by front-end. It will pass since p has a superset of 0 (keep in mind there is no real superset of 0 created), and generate code for the conversion. However, the alias set of p always keeps as 0, which means it may-alias to everything can be accessed via lvalue. This assumption prevents compiler from taking error-prone too aggressive optimization. But it also a point as further improvement to discriminate alias set finer.

And at line 2884 above, integer types with difference signed also shares the same alias set.

Line 2878 mentions an interesting GNU C++ attribution “may_alias”. [6] gives a detail.

may_alias ²        Accesses through pointers to types with this attribute are NOT subject to type based alias analysis, but are instead assumed to be able to alias any other type of objects. In the context of 6.5/7 an lvalue expression dereferencing such a pointer is treated like having a character type. See ‘-fstrict-aliasing’ for more information on aliasing issues. This extension exists to support some vector APIs, in which pointers to one vector type are permitted to alias pointers to a different vector type. Note that an object of a type with this attribute does not have any special semantics. Example of use: typedef short __attribute__ ((__may_alias__ )) short_a; int main (void) { int a = 0x12345678; short_a *b = (short_a *) &a; b[1] = 0; if (a == 0x12345678) abort(); exit(0); } If you replaced short_a with short in the variable declaration, the above program would abort when compiled with ‘-fstrict-aliasing’, which is on by default at ‘-O2’ or above in recent GCC versions.

In above example, in other words, replacing short_a with short generates incorrect code. However you can use –Wstrict-aliasing to find out pointer that may break the alias. For example, here with the option, the compiler gives a warning as : “test2.cpp:4: warning: dereferencing type-punned pointer will break strict-aliasing rules ”.

Then, if cxx_get_alias_set returns value other than -1, either the alias set is found, or the object can alias nothing (i.e, char type). Otherwise, it needs go ahead. See that at line 598 in get_alias_set , the type is assigned with unique alias set and will be shared by declarations of the type. And for aggregate type or type containing more than 1 component, the alias set should contain alias sets of its fields. Below function record_omponent_aliases builds the alias tree in this way. Predicate TYPE_NONALIASED_COMPONENT at line 709 if true, indicates that it is not permitted to take the address of a component of the type.

 

697  void

698  record_component_aliases (tree type)                                                           in alias.c

699  {

700    HOST_WIDE_INT superset = get_alias_set (type);

701    tree field;

702 

703    if (superset == 0)

704      return ;

705 

706    switch (TREE_CODE (type))

707    {

708      case ARRAY_TYPE:

709        if (! TYPE_NONALIASED_COMPONENT (type))

710          record_alias_subset (superset, get_alias_set (TREE_TYPE (type)));

711        break ;

712 

713      case RECORD_TYPE:

714      case UNION_TYPE:

715      case QUAL_UNION_TYPE:

716        /* Recursively record aliases for the base classes, if there are any.  */

717        if (TYPE_BINFO (type) != NULL && TYPE_BINFO_BASETYPES (type) != NULL)

718        {

719          int i;

720          for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); i++)

721          {

722            tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);

723            record_alias_subset (superset,

724                             get_alias_set (BINFO_TYPE (binfo)));

725          }

726        }

727        for (field = TYPE_FIELDS (type); field != 0; field = TREE_CHAIN (field))

728          if (TREE_CODE (field) == FIELD_DECL && ! DECL_NONADDRESSABLE_P (field))

729            record_alias_subset (superset, get_alias_set (TREE_TYPE (field)));

730        break ;

731 

732      case COMPLEX_TYPE:

733         record_alias_subset (superset, get_alias_set (TREE_TYPE (type)));

734        break ;

735 

736      default :

737        break ;

738    }

739  }

 

Notice that in the aggregate type, for example, field of type of short will use alias set of type short, which means it will share this alias set with other declarations of this type. By this way, if there is a pointer of short type, the compiler can tell that the pointer may alias to this field and other declarations, and prevent too heavy optimization.