Studying note of GCC-3.4.6 source (168)

5.13.5.2.2.1.

The initializer

Here on our target Linux/x86, the output file would be of format
ELF. ELF is the format supports relocatable and PIC (position independent
code). Chapter 3 of [10] gives a good description about ELF. As summeray gotten
from [10], we find:

ELF files come in three
slightly different flavors: relocatable, executable, and shared object.
Relocatable files are created by compilers and assemblers but need to be
processed by the linker before running. Executable files have all relocation
done and all symbols resolved except perhaps shared library symbols to be
resolved at runtime. Shared objects are shared libraries, containing both
symbol information for the linker and directly runnable code for runtime.

ELF files have an unusual
dual nature. Compilers, assemblers, and linkers treat the file as a set of
logical sections described by a section header table, while the system loader
treats the file as a set of segments described by a program header table. A
single segment will usually consist of several sections. For example, a
‘‘loadable read-only’’ segment could contain sections for executable code,
read-only data, and symbols for the dynamic linker. Relocatable files have
section tables, executable files have program header tables, and shared objects
have both. The sections are intended for further processing by a linker, while
the segments are intended to be mapped into memory.

assemble_variable (continue)

1460

/* Output any data that we will need to use the address
of.
*/

1461

if (DECL_INITIAL (decl) == error_mark_node)

1462

reloc = contains_pointers_p
(TREE_TYPE (decl)) ? 3 : 0;

1463

else if (DECL_INITIAL (decl))

1464

{

1465

reloc = compute_reloc_for_constant
(DECL_INITIAL
(decl));

1466

output_addressed_constants
(DECL_INITIAL (decl));

1467

}

1468

resolve_unique_section
(decl, reloc, flag_data_sections

);

Field DECL_INITIAL if is NULL, means decl

hasn’t initializer; and if is error_mark_node

,
means decl

has initializer but it hasn’t been seen yet. If the initializer unknown, it
needs be conservative. At line 1462, reloc

would hold a value that will be compared with
flag_pic

to select the section the code will be placed. And as we have seen in before
chapter, flag_pic

if is 1 means doing small PIC, and if is 2 means doing big PIC. Later we will
see the effect of these value.

It sets reloc

as 3 if the type of decl

contains pointer (or
reference) which told by below function. This value indicates that uses big PIC
as possible, otherwise tries small PIC.

1561

static
int

1562

contains_pointers_p

(tree type)

in varasm.c

1563

{

1564

switch
(TREE_CODE (type))

1565

{

1566

case
POINTER_TYPE:

1567

case
REFERENCE_TYPE:

1568

/* I'm not sure
whether OFFSET_TYPE needs this treatment,

1569

so I'll play safe and return 1.
*/

1570

case
OFFSET_TYPE:

1571

return
1;

1572

1573

case
RECORD_TYPE:

1574

case
UNION_TYPE:

1575

case
QUAL_UNION_TYPE:

1576

{

1577

tree fields;

1578

/* For a type
that has fields, see if the fields have pointers.
*/

1579

for
(fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))

1580

if (TREE_CODE (fields) == FIELD_DECL

1581

&& contains_pointers_p
(TREE_TYPE (fields)))

1582

return
1;

1583

return
0;

1584

}

1585

1586

case
ARRAY_TYPE:

1587

/* An array
type contains pointers if its element type does.
*/

1588

return
contains_pointers_p (TREE_TYPE (type));

1589

1590

default
:

1591

return
0;

1592

}

1593

}

If the initializer is known, it needs to see what kind of
relocations it may need. If the initializer contains address expression, ELF
code of PIC requires the accessing of the refferred object should via a GOT, below
function searches addressed object within the initializer. If there is no usage
of object address in the initializer, the function will return 0.

The C++ front-end hook expand_constant

bound with function cplus_expand_constant

,
it replaces PTRMEM_CST (the pointer-to-member constants) either with PLUS_EXPR
(case for referring to data member) or with more appropriate PTRMEM_CST (case
for referring to method of base from derived).

3383

int

3384

compute_reloc_for_constant

(tree exp)

in varasm.c

3385

{

3386

int reloc = 0, reloc2;

3387

tree tem;

3388

3389

/* Give the
front-end a chance to convert VALUE to something that

3390

looks more like a constant to the
back-end.
*/

3391

exp = (*lang_hooks

.expand_constant) (exp);

3392

3393

switch
(TREE_CODE (exp))

3394

{

3395

case
ADDR_EXPR:

3396

case
FDESC_EXPR:

3397

/* Go inside
any operations that get_inner_reference can handle and see

3398

if what's inside is a constant: no need
to do anything here for

3399

addresses of variables or
functions.
*/

3400

for
(tem
= TREE_OPERAND (exp, 0); handled_component_p
(tem);

3401

tem = TREE_OPERAND (tem, 0))

3402

;

3403

3404

if (TREE_PUBLIC (tem))

3405

reloc |= 2;

3406

else

3407

reloc |= 1;

3408

break
;

3409

3410

case
PLUS_EXPR:

3411

reloc = compute_reloc_for_constant
(TREE_OPERAND (exp, 0));

3412

reloc |= compute_reloc_for_constant
(TREE_OPERAND (exp, 1));

3413

break
;

3414

3415

case
MINUS_EXPR:

3416

reloc = compute_reloc_for_constant
(TREE_OPERAND (exp, 0));

3417

reloc2 = compute_reloc_for_constant
(TREE_OPERAND (exp, 1));

3418

/* The
difference of two local labels is computable at link time.
*/

3419

if (reloc == 1 && reloc2 == 1)

3420

reloc = 0;

3421

else

3422

reloc |= reloc2;

3423

break
;

3424

3425

case
NOP_EXPR:

3426

case
CONVERT_EXPR:

3427

case
NON_LVALUE_EXPR:

3428

reloc = compute_reloc_for_constant
(TREE_OPERAND (exp, 0));

3429

break
;

3430

3431

case
CONSTRUCTOR:

3432

for
(tem
= CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))

3433

if (TREE_VALUE (tem) != 0)

3434

reloc |= compute_reloc_for_constant
(TREE_VALUE (tem));

3435

3436

break
;

3437

3438

default
:

3439

break
;

3440

}

3441

return
reloc;

3442

}

For non-static data member of class or elment of array, their
address is given in offset from the base address. They also need relocation at
time of loading. Further TREE_PUBLIC in a VAR_DECL or FUNCTION_DECL, if is nonzero
means name is to be accessible from outside this module; in an IDENTIFIER_NODE,
if is nonzero means an external declaration accessible from outside this module
was previously seen for this name in an inner scope. So set reloc

accordingly as line 3404 to 3407 does.

Below function is inovked at line 3400 above, it finds out the
object that gets referred.

5620

int

5621

handled_component_p

(tree t)

in expr.c

5622

{

5623

switch
(TREE_CODE (t))

5624

{

5625

case
BIT_FIELD_REF:

5626

case
COMPONENT_REF:

5627

case
ARRAY_REF:

5628

case
ARRAY_RANGE_REF:

5629

case
NON_LVALUE_EXPR:

5630

case
VIEW_CONVERT_EXPR:

5631

return
1;

5632

5633

/* ??? Sure they
are handled, but get_inner_reference may return

5634

a different PBITSIZE, depending upon whether the expression
is

5635

wrapped up in a NOP_EXPR or not, e.g. for
bitfields.
*/

5636

case
NOP_EXPR:

5637

case
CONVERT_EXPR:

5638

return
(TYPE_MODE (TREE_TYPE (t))

5639

== TYPE_MODE (TREE_TYPE
(TREE_OPERAND (t, 0))));

5640

5641

default
:

5642

return
0;

5643

}

5644

}

5.13.5.2.2.1.1.

Output constant referred

Then at line 1466 in
assemble_variable

,
in the invocation of output_addressed_constants

, its argument is
this initializer. Similiarly, this function searches address used in exp

.

3448

static
void

3449

output_addressed_constants

(tree exp)

in varasm.c

3450

{

3451

tree tem;

3452

3453

/* Give the
front-end a chance to convert VALUE to something that

3454

looks more like a constant to the
back-end.
*/

3455

exp = (*lang_hooks

.expand_constant) (exp);

3456

3457

switch
(TREE_CODE (exp))

3458

{

3459

case
ADDR_EXPR:

3460

case
FDESC_EXPR:

3461

/* Go inside
any operations that get_inner_reference can handle and see

3462

if what's inside is a constant: no need
to do anything here for

3463

addresses of variables or
functions.
*/

3464

for
(tem
= TREE_OPERAND (exp, 0); handled_component_p
(tem);

3465

tem = TREE_OPERAND (tem, 0))

3466

;

3467

3468

if (TREE_CODE_CLASS (TREE_CODE (tem)) ==
'c'

3469

|| TREE_CODE (tem) == CONSTRUCTOR)

3470

output_constant_def

(tem, 0);

3471

break
;

3472

3473

case
PLUS_EXPR:

3474

case
MINUS_EXPR:

3475

output_addressed_constants (TREE_OPERAND
(exp, 1));

3476

/* Fall
through.
*/

3477

3478

case
NOP_EXPR:

3479

case
CONVERT_EXPR:

3480

case
NON_LVALUE_EXPR:

3481

output_addressed_constants (TREE_OPERAND
(exp, 0));

3482

break
;

3483

3484

case
CONSTRUCTOR:

3485

for
(tem
= CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))

3486

if (TREE_VALUE (tem) != 0)

3487

output_addressed_constants
(TREE_VALUE (tem));

3488

3489

break
;

3490

3491

default
:

3492

break
;

3493

}

3494

}

Condition at line 3468 if satisfied, means object upon this address
is constant. And condition at line 3469 if satisfied, represents the
brace-enclosed initializers for a structure or array, which may be read-only.
The front-end uses data structure constant_descriptor_tree to describe these
nodes for (maybe) constant.

2062

struct
constant_descriptor_tree
GTY(())

in varasm.c

2063

{

2064

/* A MEM for the
constant.
*/

2065

rtx rtl;

2066

2067

/* The value of the
constant.
*/

2068

tree value;

2069

};

Every constant is a singleton at least within the translation-unit.
We have seen that in the front-end, tree node for constant is cached within the
hash table. Now for constant descriptor node, it is the same.

2484

rtx

2485

output_constant_def

(tree exp, int
defer)

in varasm.c

2486

{

2487

struct
constant_descriptor_tree
*desc;

2488

struct
constant_descriptor_tree key;

2489

void **loc;

2490

2491

/* Look up EXP in
the table of constant descriptors. If we didn't find

2492

it, create a new one.
*/

2493

key.value = exp;

2494

loc = htab_find_slot (const_desc_htab

, &key, INSERT);

2495

2496

desc = *loc;

2497

if (desc == 0)

2498

{

2499

desc = build_constant_desc
(exp);

2500

*loc = desc;

2501

}

2502

2503

maybe_output_constant_def_contents
(desc, defer);

2504

return
desc->rtl;

2505

}

If the constant descriptor is not found within const_desc_htab

(see that the tree
node of this constant is used as the key, and const_desc_hash

is called to
compare nodes’ content), build_constant_desc

comes to help. Below at
line 2441, copy_constant

copies the tree node of the constants within exp

, as below we may modify the
node’s content, we need own a copy.

2431

static
struct
constant_descriptor_tree *

2432

build_constant_desc

(tree exp)

in varasm.c

2433

{

2434

rtx symbol;

2435

rtx rtl;

2436

char label[256];

2437

int labelno;

2438

struct
constant_descriptor_tree *desc;

2439

2440

desc = ggc_alloc (sizeof
(*desc));

2441

desc->value = copy_constant (exp);

2442

2443

/* Create a string
containing the label name, in LABEL.
*/

2444

labelno = const_labelno

++;

2445

ASM_GENERATE_INTERNAL_LABEL (label,
"LC", labelno);

2446

2447

/* We have a symbol
name; construct the SYMBOL_REF and the MEM.

*/

2448

symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));

2449

SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;

2450

SYMBOL_REF_DECL (symbol) = desc->value;

2451

TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;

2452

2453

rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE
(exp)), symbol);

2454

set_mem_attributes
(rtl, exp, 1);

2455

set_mem_alias_set (rtl, 0);

2456

set_mem_alias_set (rtl, const_alias_set

);

2457

2458

/* Set flags or add
text to the name to record information, such as

2459

that it is a local symbol. If the name is
changed, the macro

2460

ASM_OUTPUT_LABELREF will have to know how
to strip this

2461

information. This call might invalidate our
local variable

2462

SYMBOL; we can't use it afterward.
*/

2463

2464

(*targetm

.encode_section_info) (exp, rtl, true);

2465

2466

desc->rtl = rtl;

2467

2468

return
desc;

2469

}

To visit these constants in a unified way in assemble, the front-end
labels these constants; so the visit can be done via referring the associated
label. It is the so-called internal label. Under our assuming platform and
machine, ASM_GENERATE_INTERNAL_LABEL is defined as below. The label will
contain string like: “*LC1”,
“*LC2”, and so on, according to
the number of constant label generated.

722

#undef
ASM_GENERATE_INTERNAL_LABEL

in darwin.h

723

#define
ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)
/

724

sprintf (LABEL, "*%s%ld", PREFIX, (long)(NUM))

Next we make this label into SYMBOL_REF, and build MEM node for it .
Then, according to the property of this (maybe) constant, set memory
attributions.

5.13.5.2.2.1.1.1.


Set
memory attributions


In below function, parameter objectp

if nonzero, means we are making a new MEM
for the type. And if bitpos

is nonzero, it is an offset outstanding on
parameter t
that will be applied
later.

1787

void

1788

set_mem_attributes

(rtx ref, tree t, int
objectp)

in emit-rtl.c

1789

{

1790

set_mem_attributes_minus_bitpos
(ref, t, objectp, 0);

1791

}

Below code between line 1566 and 1569 extracts the content of corresponding
fields of the MEM node. The function is also used to modify already existing
MEM node. Note the caculation of alias set of t

at line 1593, it overwrites the
result at line 1566 anyhow.

1562

void

1563

set_mem_attributes_minus_bitpos

(rtx ref, tree t, int objectp,

in emit-rtl.c

1564

HOST_WIDE_INT
bitpos)

1565

{

1566

HOST_WIDE_INT alias = MEM_ALIAS_SET (ref);

1567

tree expr = MEM_EXPR (ref);

1568

rtx offset = MEM_OFFSET (ref);

1569

rtx size = MEM_SIZE (ref);

1570

unsigned int align = MEM_ALIGN (ref);

1571

HOST_WIDE_INT apply_bitpos = 0;

1572

tree type;

1573

1574

/* It can happen
that type_for_mode was given a mode for which there

1575

is no language-level type. In which case it
returns NULL, which

1576

we can see here.
*/

1577

if (t == NULL_TREE)

1578

return
;

1579

1580

type = TYPE_P (t) ? t : TREE_TYPE (t);

1581

if (type == error_mark_node)

1582

return
;

1583

1584

/* If we have
already set DECL_RTL = ref, get_alias_set will get the

1585

wrong answer, as it assumes that DECL_RTL
already has the right alias

1586

info. Callers should not set DECL_RTL until
after the call to

1587

set_mem_attributes.
*/

1588

if (DECL_P (t) && ref ==
DECL_RTL_IF_SET (t))

1589

abort ();

1590

1591

/* Get the alias
set from the expression or type (perhaps using a

1592

front-end routine) and use it.
*/

1593

alias = get_alias_set
(t);

Remember ref

is the MEM node, and type

is the node of type of
argument t

(usually it is a DECL, but it still can be a type node). Below at line 1598 honor_readonly

in the hook is false for all front-end in GCC current version.

set_mem_attributes_minus_bitpos
(continue)

1595

MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);

1596

MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P
(type);

1597

RTX_UNCHANGING_P (ref)

1598

|= ((lang_hooks

.honor_readonly

1599

&& (TYPE_READONLY (type) ||
TREE_READONLY (t)))

1600

|| (! TYPE_P (t) && TREE_CONSTANT (t)));

1601

1602

/* If we are making
an object of this type, or if this is a DECL, we know

1603

that it is a scalar if the type is not an
aggregate.
*/

1604

if ((objectp || DECL_P (t)) && !
AGGREGATE_TYPE_P (type))

1605

MEM_SCALAR_P (ref) = 1;

1606

1607

/* We can set the
alignment from the type if we are making an object,

1608

this is an INDIRECT_REF, or if
TYPE_ALIGN_OK.
*/

1609

if (objectp || TREE_CODE (t) == INDIRECT_REF
|| TYPE_ALIGN_OK (type))

1610

align = MAX (align, TYPE_ALIGN (type));

1611

1612

/* If the size is
known, we can set that.
*/

1613

if (TYPE_SIZE_UNIT (type) &&
host_integerp (TYPE_SIZE_UNIT (type), 1))

1614

size = GEN_INT (tree_low_cst
(TYPE_SIZE_UNIT (type), 1));

1615

1616

/* If T is not a
type, we may be able to deduce some more information about

1617

the expression.
*/

1618

if (! TYPE_P (t))

1619

{

1620

maybe_set_unchanging
(ref, t);

1621

if (TREE_THIS_VOLATILE (t))

1622

MEM_VOLATILE_P (ref) = 1;

1623

1624

/* Now remove any conversions: they don't
change what the underlying

1625

object is. Likewise for SAVE_EXPR.

*/

1626

while
(TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) ==
CONVERT_EXPR

1627

|| TREE_CODE (t) == NON_LVALUE_EXPR

1628

|| TREE_CODE (t) == VIEW_CONVERT_EXPR

1629

|| TREE_CODE (t) == SAVE_EXPR)

1630

t = TREE_OPERAND (t, 0);

1631

1632

/* If this
expression can't be addressed (e.g., it contains a reference

1633

to a non-addressable field), show we
don't change its alias set.
*/

1634

if (! can_address_p (t))

1635

MEM_KEEP_ALIAS_SET_P (ref) = 1;

1636

1637

/* If this is a
decl, set the attributes of the MEM from it.

*/

1638

if (DECL_P (t))

1639

{

1640

expr = t;

1641

offset = const0_rtx;

1642

apply_bitpos = bitpos;

1643

size = (DECL_SIZE_UNIT (t)

1644

&& host_integerp
(DECL_SIZE_UNIT (t), 1)

1645

? GEN_INT (tree_low_cst
(DECL_SIZE_UNIT (t), 1)) : 0);

1646

align = DECL_ALIGN (t);

1647

}

1648

1649

/* If this is a
constant, we know the alignment.
*/

1650

else if (TREE_CODE_CLASS (TREE_CODE (t)) ==
'c')

1651

{

1652

align = TYPE_ALIGN (type);

1653

#ifdef

CONSTANT_ALIGNMENT

1654

align = CONSTANT_ALIGNMENT (t, align);

1655

#endif

1656

}

1657

1658

/* If this is a
field reference and not a bit-field, record it.

*/

1659

/* ??? There is some information that can
be gleened from bit-fields,

1660

such as the word offset in the structure
that might be modified.

1661

But skip it for now.
*/

1662

else if (TREE_CODE (t) == COMPONENT_REF

1663

&& ! DECL_BIT_FIELD
(TREE_OPERAND (t, 1)))

1664

{

1665

expr = component_ref_for_mem_expr
(t);

1666

offset = const0_rtx;

1667

apply_bitpos = bitpos;

1668

/* ??? Any
reason the field size would be different than

1669

the size we got from the type?
*/

1670

}

RTL node also needs be told if its content is unchangable
(constant), RTX_UNCHANGING_P is the tag for the purpose. If above honor_readonly

in the hook is true, it means setting RTX_UNCHANGING_P if TREE_READONLY or
TYPE_READONLY hold. Pay attention to statement at line 1600, if t’s value is
constant, setting RTX_UNCHANGING_P. Besides, if t satisfies condition at line
602 below, setting RTX_UNCHANGING_P too. See that these two conditions are not
overlapped.

594

void

595

maybe_set_unchanging

(rtx ref, tree t)

in explow.c

596

{

597

/* We can set RTX_UNCHANGING_P from
TREE_READONLY for decls whose

598

initialization is only executed once, or
whose initializer always

599

has the same value. Currently we simplify
this to PARM_DECLs in the

600

first case, and decls with TREE_CONSTANT
initializers in the second.
*/

601

602

if ((TREE_READONLY (t) && DECL_P (t)

603

&& (DECL_EXTERNAL (t)

604

|| TREE_CODE (t) == PARM_DECL

605

|| (DECL_INITIAL (t) &&
TREE_CONSTANT (DECL_INITIAL (t)))))

606

|| TREE_CODE_CLASS (TREE_CODE (t)) == 'c')

607

RTX_UNCHANGING_P (ref) = 1;

608

}

In previous, we have seen the process of conversion in front-end, in
C/C++, conversion only changes the representation of object, but does not
change the property of the memory, such as size, position occupied. The
representation of object only means to semantic and syntax checking done in
front-end, the back-end doesn’t care what the object looks like, but what it is
in memory. So WHILE loop at line 1626 strips these enclosings useless in
back-end.

Next, for constant of specified type, target platform may have
specific alignment requirement, at line 1653 macro CONSTANT_ALIGNMENT is
defined as ix86_constant_alignment

for x86/Linux target. The function does necessary adjustment upon alignment.

Similarly, in COMPONENT_REF node, the front-end, out of purpose of
maintaining the consistency of semanteme and syntax, may encapsulate it several
times. Below function reveals these meaningless encapsulations.

1489

static
tree

1490

component_ref_for_mem_expr

(tree ref)

in emit-rtl.c

1491

{

1492

tree inner = TREE_OPERAND (ref, 0);

1493

1494

if (TREE_CODE (inner) == COMPONENT_REF)

1495

inner = component_ref_for_mem_expr (inner);

1496

else

1497

{

1498

tree placeholder_ptr = 0;

1499

1500

/* Now remove any
conversions: they don't change what the underlying

1501

object is. Likewise for SAVE_EXPR. Also
handle PLACEHOLDER_EXPR.
*/

1502

while
(TREE_CODE (inner) == NOP_EXPR || TREE_CODE (inner) == CONVERT_EXPR

1503

|| TREE_CODE (inner) == NON_LVALUE_EXPR

1504

|| TREE_CODE (inner) ==
VIEW_CONVERT_EXPR

1505

|| TREE_CODE (inner) == SAVE_EXPR

1506

|| TREE_CODE (inner) ==
PLACEHOLDER_EXPR)

1507

if (TREE_CODE (inner) ==
PLACEHOLDER_EXPR)

1508

inner = find_placeholder (inner, &placeholder_ptr);

1509

else

1510

inner = TREE_OPERAND (inner, 0);

1511

1512

if (! DECL_P (inner))

1513

inner = NULL_TREE;

1514

}

1515

1516

if (inner == TREE_OPERAND (ref, 0))

1517

return
ref;

1518

else

1519

return
build (COMPONENT_REF, TREE_TYPE (ref), inner,

1520

TREE_OPERAND (ref, 1));

1521

}

Below ARRAY_REF stands for array accesses; first operand is the
array, the second is the index. So DO WHILE loop at line works out the offset
from the element accessed to the head of the array. This offset is saved in off_tree

below. Note at line 1722, because it uses binary complement code, it gets the
lowest bit of 1 in ioff

,
that is the boundary the accessed element aligns.

set_mem_attributes_minus_bitpos
(continue)

1672

/* If this is an
array reference, look for an outer field reference.
*/

1673

else if (TREE_CODE (t) == ARRAY_REF)

1674

{

1675

tree off_tree = size_zero_node;

1676

/* We can't
modify t, because we use it at the end of the

1677

function.
*/

1678

tree t2 = t;

1679

1680

do

1681

{

1682

tree index = TREE_OPERAND (t2, 1);

1683

tree array = TREE_OPERAND (t2, 0);

1684

tree domain = TYPE_DOMAIN (TREE_TYPE
(array));

1685

tree low_bound = (domain ?
TYPE_MIN_VALUE (domain) : 0);

1686

tree unit_size = TYPE_SIZE_UNIT
(TREE_TYPE (TREE_TYPE (array)));

1687

1688

/* We assume
all arrays have sizes that are a multiple of a byte.

1689

First subtract the lower bound, if
any, in the type of the

1690

index, then convert to sizetype and
multiply by the size of the

1691

array element.
*/

1692

if (low_bound != 0 && ! integer_zerop
(low_bound))

1693

index = fold (build (MINUS_EXPR,
TREE_TYPE (index),

1694

index, low_bound));

1695

1696

/* If the
index has a self-referential type, pass it to a

1697

WITH_RECORD_EXPR; if the component
size is, pass our

1698

component to one.
*/

1699

if (CONTAINS_PLACEHOLDER_P (index))

1700

index = build (WITH_RECORD_EXPR,
TREE_TYPE (index), index, t2);

1701

if (CONTAINS_PLACEHOLDER_P (unit_size))

1702

unit_size = build (WITH_RECORD_EXPR,
sizetype,

1703

unit_size, array);

1704

1705

off_tree

1706

= fold (build (PLUS_EXPR, sizetype,

1707

fold (build (MULT_EXPR,
sizetype,

1708

index,

1709

unit_size)),

1710

off_tree));

1711

t2 = TREE_OPERAND (t2, 0);

1712

}

1713

while
(TREE_CODE (t2) == ARRAY_REF);

1714

1715

if (DECL_P (t2))

1716

{

1717

expr = t2;

1718

offset = NULL;

1719

if (host_integerp (off_tree, 1))

1720

{

1721

HOST_WIDE_INT ioff = tree_low_cst
(off_tree, 1);

1722

HOST_WIDE_INT aoff = (ioff &
-ioff) * BITS_PER_UNIT;

1723

align = DECL_ALIGN (t2);

1724

if (aoff && (unsigned
HOST_WIDE_INT) aoff < align)

1725

align = aoff;

1726

offset = GEN_INT (ioff);

1727

apply_bitpos = bitpos;

1728

}

1729

}

1730

else if (TREE_CODE (t2) == COMPONENT_REF)

1731

{

1732

expr = component_ref_for_mem_expr (t2);

1733

if (host_integerp (off_tree, 1))

1734

{

1735

offset = GEN_INT (tree_low_cst
(off_tree, 1));

1736

apply_bitpos = bitpos;

1737

}

1738

/* ??? Any
reason the field size would be different than

1739

the size we got from the type?
*/

1740

}

1741

else if (flag_argument_noalias

> 1

1742

&& TREE_CODE (t2) ==
INDIRECT_REF

1743

&& TREE_CODE (TREE_OPERAND
(t2, 0)) == PARM_DECL)

1744

{

1745

expr = t2;

1746

offset = NULL;

1747

}

1748

}

1749

1750

/* If this is a
Fortran indirect argument reference, record the

1751

parameter decl.
*/

1752

else if (flag_argument_noalias

> 1

1753

&& TREE_CODE (t) ==
INDIRECT_REF

1754

&& TREE_CODE (TREE_OPERAND
(t, 0)) == PARM_DECL)

1755

{

1756

expr = t;

1757

offset = NULL;

1758

}

1759

}

1760

1761

/* If we modified
OFFSET based on T, then subtract the outstanding

1762

bit position offset. Similarly, increase
the size of the accessed

1763

object to contain the negative offset.
*/

1764

if (apply_bitpos)

1765

{

1766

offset = plus_constant (offset,
-(apply_bitpos / BITS_PER_UNIT));

1767

if (size)

1768

size = plus_constant (size, apply_bitpos
/ BITS_PER_UNIT);

1769

}

1770

1771

/* Now set the
attributes we computed above.
*/

1772

MEM_ATTRS (ref)

1773

= get_mem_attrs (alias, expr, offset, size,
align, GET_MODE (ref));

1774

1775

/* If this is
already known to be a scalar or aggregate, we are done.
*/

1776

if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P
(ref))

1777

return
;

1778

1779

/* If it is a
reference into an aggregate, this is part of an aggregate.

1780

Otherwise we don't know.
*/

1781

else if (TREE_CODE (t) == COMPONENT_REF ||
TREE_CODE (t) == ARRAY_REF

1782

|| TREE_CODE (t) == ARRAY_RANGE_REF

1783

|| TREE_CODE (t) == BIT_FIELD_REF)

1784

MEM_IN_STRUCT_P (ref) = 1;

1785

}

Above flag flag_argument_noalias

, if is 0, pointer arguments
may alias each other (true in C); if is 1, pointer arguments may not alias each
other but may alias global variables; if is 2, pointer arguments may not alias
each other and may not alias global variables (true in Fortran).

Back build_constant_desc

, it should not assign
alias set of the type to the constant, as it can’t be changed. Front-end
prepares const_alias_set

specially for constants. The first call of set_mem_alias_set

at line 2455, sets the
alias set of RTL node of constant into 0, to bypass the checking for alias set
confliction.

1806

void

1807

set_mem_alias_set

(rtx mem,
HOST_WIDE_INT set)

in emit-rtl.c

1808

{

1809

#ifdef
ENABLE_CHECKING

1810

/* If the new and
old alias sets don't conflict, something is wrong.
*/

1811

if (!alias_sets_conflict_p
(set, MEM_ALIAS_SET (mem)))

1812

abort ();

1813

#endif

1814

1815

MEM_ATTRS (mem) = get_mem_attrs
(set, MEM_EXPR (mem), MEM_OFFSET (mem),

1816

MEM_SIZE (mem), MEM_ALIGN (mem),

1817

GET_MODE (mem));

1818

}

Then at line 2464, refers to section Create
RTX object for builtin
for the detail of target platform hook encode_section_info,
the function sets SYMBOL_REF_FLAGS field for the RTL node.