5.13.5.2.2.1. 初始值
这里在我们的目标 Linux/x86 ，输出文件将具有格式 ELF 。 ELF 是支持重定位及 PIC （位置无关代码）的格式。【 10 】的第三章给出了关于 ELF 的一个很好的解释。从【 10 】的总结中，我们得到：
ELF 文件有 3 种稍有不同的风格的形式：可重定位（ relocatable ），可执行（ executable ）及共享对象。可重定位文件由编译器及汇编器创建，但在运行前需要链接器的处理。可执行文件已完成所有的重定位及确定了所有的符号，除了在运行时确定的共享库符号。共享对象是共享库，包含了用于链接器的符号信息及用于运行时的直接可运行代码。
ELF 文件不寻常的二重性。编译器，汇编器，及链接器把这种文件处理作由一个节头表（ section header table ）所描述的一组逻辑节（ logical section ），而系统加载器（ system loader ）把这种文件处理作由一个程序头表（ program header table ）所描述的一组段（ segment ）。一个单段通常由几个节构成。例如，一个“可加载只读”段可以包含对应于可执行代码，只读数据，及用于动态链接器符号的节。可重定位文件具有多个节表（ section table ），可执行文件具有多个程序头表（ program header table ），而共享对象同时具有两者。节用于链接器进一步处理的目的，而段用于映射入内存。
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 );
域 DECL_INITIAL 如果是 NULL ，表示 decl 没有初始值；而如果是 error_mark_node ，则表示 decl 具有初始值，但我们现在还没看到它。如果这个初始值还未知，就需要保守些。在 1462 行， reloc 将保存一个值，这个值被将用来与 flag_pic 比较，来选定代码所要放置的节。正如我们在前面的章节中所见， flag_pic 如果是 1 ，表示制作小 PIC ，而如果是 2 ，表示制作大 PIC 。后面我们会看到这些值的作用。
如果 decl 的类型包含指针（或引用）——由下面的函数判断，把 reloc 设置为 3 。这个值表示尽可能使用大 PIC ，不行就尝试小 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 }
如果初始值是已知的，则需要看它可能需要何种重定位。如果其中包含了地址表达式， ELF 的 PIC 编码要求对其中所援引的对象访问需要通过 GOT ，下面的函数在这个初始值中查找对象地址。如果初始值没有使用对象的地址，就会返回 0 。
C++ 前端钩子 expand_constant 被绑定在 cplus_expand_constant 上，这个函数把 PTRMEM_CST （成员指针常量）或者替换为 PLUS_EXPR （引用数据成员的情形），或替换为更合适的 PTRMEM_CST （从派生类引用基类方法的情形）。
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 }
对于类的非静态数据成员或者数组的元素，它们的地址以基址加上偏移的形式给出（即 PLUS_EXPR 或 MINUS_EXPR ）。另外， TREE_PUBLIC ，在一个 FUNCTION_DECL 或 VAR_DECL 中，如果非 0 ，表示该名字从这个模块外访问；在一个 IDENTIFIER_NODE 中，如果非 0 ，表示从这个模块外访问的一个外部声明，该声明的名字在一个内部域中先前已见。因此 3404 到 3407 行相应地设置 reloc 。
下面的函数在上面的 3400 行调用，它找出被援引的对象。
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. 输出引用的常量
那么在上面 assemble_variable 的 1466 行，在对 output_addressed_constants 的调用中，其参数就是这个初始值。同样，这个函数查找 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 }
3468 行的条件若满足，表示即找出该地址上的对象是一个常量。而 3469 行的条件若满足，则表明是一个由大括号对包括的初始值，它可以是类或数组的初始值，这个初始值有可能是只读的。对于这些（可能是）常量的节点，前端使用一个数据结构 constant_descriptor_tree 来描述之。
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 };
每个常量至少在当前编译单元中是一个单件。我们已经看到在前端中，用于常量的树节点被缓存在哈希表中。现在对于常量描述符节点（ constant descriptor node ），也是一样的。
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 }
如果在 const_desc_htab 里找不到这个常量描述符（注意使用该常量的树节点作为键值，通过 const_desc_hash 来比较节点的相同内容），就需要调用 build_constant_desc 来构建之。在下面 2441 行， copy_constant 拷贝 exp 中常量的树节点，因为下面可能改变这个节点，我们需要一份单独的拷贝。
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 }
为了在生成汇编代码时，以统一的方式引用这些常量，前端给这些常量做标记；因而对其访问可以通过引用关联的标记（ label ）来实现访问。这是所谓的内部标记。在我们假定的平台及机器下， ASM_GENERATE_INTERNAL_LABEL 具有下面的定义。这个标记将包含字符串：“ *LC1 ”，“ *LC2 ”，并根据所产生的常量标记的数目以此类推。
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))
接着我们把这个标记构建成符号引用（ SYMBOL_REF ），并为之构建 MEM 节点。然后，根据（可能）常量的属性如下地设置内存属性。
5.13.5.2.2.1.1.1. 设置内存属性
在下面的函数中，参数 objectp 如果不是 0 ，表示我们正在构建一个新的 MEM 节点。而如果参数 bitpos 不是 0 ，则代表一个要应用在参数 t 上的未实现的偏移。
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 }
下面 1566 至 1569 行的宏提取 MEM 节点中相应域的内容。这个函数也会用于修改已存在的 MEM 节点。注意在 1593 行对 t 别名集的计算，无论如何它都将覆盖 1566 行的结果。
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);
记住 ref 是 MEM 节点， type 是参数 t （通常它是一个 DECL 节点，不过它仍然可以是一个类型节点）的类型节点。下面在 1598 行，钩子中的 honor_readonly 在当前 GCC 版本中的所有前端里都是 false 。
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 节点也需要标识其中的对象是否是不变的（常量）， RTX_UNCHANGING_P 就是这个标记。如果上面钩子中的 honor_readonly 是 true ，表示如果 TREE_READONLY 或 TYPE_READONLY 成立，设置 RTX_UNCHANGING_P 。注意 1600 行的语句，如果 t 的值是常量，设置 RTX_UNCHANGING_P 。另外如果 t 满足以下 602 行的条件，也要设置 RTX_UNCHANGING_P 。注意这两个条件不重复。
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 }
前面我们看过了前端对转换的处理，在 C/C++ 中，转换只改变对象的表达形式，而不改变其所占内存的大小、位置等属性。而且对象的表达形式，只对前端执行语法、语义检查具有意义，后端不在乎对象看起来像什么，而在乎对象在内存中是什么。因此， 1626 行的 WHILE 循环剥除这些对后端不起作用的封装。
另外，对于特定类型的常量，目标平台会有特定的对齐要求， 1653 行的宏 CONSTANT_ALIGNMENT ，对于 x86/Linux 平台，定义为 ix86_constant_alignment 。该函数对对齐量进行必要的调整。
同样，对于 COMPONENT_REF 节点，前端出于维护语法、语义一致性的需要，在所引用的对象节点上可能进行了多次转换的封装。下面的函数剥除了这些对后端无意义的封装。
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 }
下面的 ARRAY_REF 节点代表对数组的访问，其第一个操作数是这个数组，第二个操作数是访问索引。那么 1680 行的 DO WHILE 循环计算出所访问元素到数组开头的偏移。这个偏移保存在下面的 off_tree 中。注意在 1722 行，因为使用 2 进制补码，得到的是 ioff 中为 1 的最低位，也就是所访问元素地址所对齐的边界。
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 }
上面的标记 flag_argument_noalias ，如果是 0 ，指针实参可能互为别名（这是 C 的情形）；如果是 1 ，指针实参不可能互为别名，但可能是全局变量的别名；如果是 2 ，指针实参不可能互为别名，也不可能是全局变量的别名（ Fortran 的情况）。
回到 build_constant_desc ，对于常量不应该赋予其类型关联的别名集，因为它不能改变。前端专门为常量准备了别名集 const_alias_set 。在 2455 行对 set_mem_alias_set 的第一次调用，把常量 RTL 节点的别名集设置为 0 ，是为了绕过该函数中对别名集冲突的检查。
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 }
而在 2464 行，目标平台钩子 encode_section_info 的细节参考 为内建函数创建 RTX对象 一节，这个函数设置了 RTL 节点的 SYMBOL_REF_FLAGS 域。
3565
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
