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.