GCC-3.4.6源代码学习笔记（5）

1.2.2. 内建类型的树节点

对于语言中的内建类型，例如，C/C++中的int，unsigned short等，编译器在启动时便会为这些类型创建节点。
1.2.2.1. 初始化临时的size_t节点
在创建内建类型的节点前，先要创建临时的size_t节点（一个用作size_t，另一个用作bitsize_t。size_t是sizeof的返回类型，bitsize_t由前端使用），它们将被用于内建类型节点的构建。在C++前端中，节点创建的次序如下所示。

build_common_tree_nodes

4840 initialize_sizetypes (); in tree.c
4841
4842 /* Define both `signed char' and `unsigned char'. */
4843 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4844 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);

这里signed_char_type_node和unsigned_char_type_node都是一个全局数组的成员。这个全局数组在下面章节中描述。
1.2.2.1.1. 整型类型的节点
对于C++，整型是语言基础而重要的部分。它们的使用频率（事实上出现在每个程序中），使得对这些节点的访问必须尽可能有效。因此，这些节点放在下面的全局数组中，而不像其它类型节点被放在哈希表里（hash-table）。

2001 extern GTY(()) tree integer_types[itk_none]; in tree.h
2002
2003 #define char_type_node integer_types[itk_char]
2004 #define signed_char_type_node integer_types[itk_signed_char]
2005 #define unsigned_char_type_node integer_types[itk_unsigned_char]
2006 #define short_integer_type_node integer_types[itk_short]
2007 #define short_unsigned_type_node integer_types[itk_unsigned_short]
2008 #define integer_type_node integer_types[itk_int]
2009 #define unsigned_type_node integer_types[itk_unsigned_int]
2010 #define long_integer_type_node integer_types[itk_long]
2011 #define long_unsigned_type_node integer_types[itk_unsigned_long]
2012 #define long_long_integer_type_node integer_types[itk_long_long]
2013 #define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]
1.2.2.1.2. 创建临时的size_t节点
事实上，在GCC中有关size_t的节点也是放在下面的全局数组中。

2427 extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST]; n tree.h
2428
2429 #define sizetype sizetype_tab[(int) SIZETYPE]
2430 #define bitsizetype sizetype_tab[(int) BITSIZETYPE]
2431 #define ssizetype sizetype_tab[(int) SSIZETYPE]
2432 #define usizetype sizetype_tab[(int) USIZETYPE]
2433 #define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
2434 #define ubitsizetype sizetype_tab[(int) UBITSIZETYPE]

上面的这些节点分别表示，该size_t类型：以字节衡量的一般表示方式大小，以比特衡量的一般表示方式大小；以字节衡量的有符号表示方式大小，以比特衡量的有符号表示方式大小；以字节衡量的无符号表示方式大小，以比特衡量的无符号表示方式大小。（这3组数据主要为了满足不同目标机器的要求）。
最开始，只有临时的sizetype和bitsizetype节点被函数initialize_sizetypes创建。

1849 void
1850 initialize_sizetypes (void) in stor-layout.c
1851 {
1852 tree t = make_node (INTEGER_TYPE);
1853
1854 /* Set this so we do something reasonable for the build_int_2 calls
1855 below. */
1856 integer_type_node = t;
1857
1858 TYPE_MODE (t) = SImode;
1859 TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
1860 TYPE_USER_ALIGN (t) = 0;
1861 TYPE_SIZE (t) = build_int_2 (GET_MODE_BITSIZE (SImode), 0);
1862 TYPE_SIZE_UNIT (t) = build_int_2 (GET_MODE_SIZE (SImode), 0);
1863 TREE_UNSIGNED (t) = 1;
1864 TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode);
1865 TYPE_MIN_VALUE (t) = build_int_2 (0, 0);
1866 TYPE_IS_SIZETYPE (t) = 1;
1867
1868 /* 1000 avoids problems with possible overflow and is certainly
1869 larger than any size value we'd want to be storing. */
1870 TYPE_MAX_VALUE (t) = build_int_2 (1000, 0);
1871
1872 /* These two must be different nodes because of the caching done in
1873 size_int_wide. */
1874 sizetype = t;
1875 bitsizetype = copy_node (t);
1876 integer_type_node = 0;
1877 }

首先在1852行，创建临时的integer_type_node。从1858行到1864行，相应的有关模式的数据，由后端的genmodes工具从文件machmode.def生成，类型节点对应的域根据这些数据来设置。随后的build_int_2则构建了整型常量0和1000，作为临时size_t的取值范围。而这个临时的integer_type_node 被作为这些常量的类型值（tree_type）。注意，在1874行，临时的integer_type_node 被同时用作sizetype和bitsizetype的类型。 不过，这些size_t节点在内建的整型类型节点被创建后，就会被更新。
1.2.2.1.3. 创建整型的类型节点
我们仅以有符号整数类型作为例子。无符号整数类型的过程与这里看到的十分相似。

1822 tree
1823 make_signed_type (int precision) in stor-layout.c
1824 {
1825 tree type = make_node (INTEGER_TYPE);
1826
1827 TYPE_PRECISION (type) = precision;
1828
1829 fixup_signed_type (type);
1830 return type;
1831 }

TYPE_PRECISION是用于表达该类型的比特数，它是一个unsigned int。（注意通常它的值不同于TYPE_SIZE。比如有一个24位的整型，但ABI（抽象2进制接口）要求32位的对齐量。这样，TYPE_SIZE将是一个值为32的INTEGER_CST，而TYPE_PRECISION则是24）。

2014 void
2015 fixup_signed_type (tree type) in stor-layout.c
2016 {
2017 int precision = TYPE_PRECISION (type);
2018
2019 /* We can not represent properly constants greater then
2020 2 * HOST_BITS_PER_WIDE_INT, still we need the types
2021 as they are used by i386 vector extensions and friends. */
2022 if (precision > HOST_BITS_PER_WIDE_INT * 2)
2023 precision = HOST_BITS_PER_WIDE_INT * 2;
2024
2025 set_min_and_max_values_for_integral_type (type, precision,
2026 /*is_unsigned=*/false);
2027
2028 /* Lay out the type: set its alignment, size, etc. */
2029 layout_type (type);
2030 }
1.2.2.1.4. 确定取值范围
每个整型类型都有所能表达的数值范围，超出这个范围即发生溢出。因此，对每个整数类型节点，要设定其表达范围，以方便检查溢出情况。在为类型所创建的tree_type节点中，域TYPE_MIN_VALUE及TYPE_MAX_VALUE保存了取值范围的上下边界。这些域都是tree_int_cst，包含有整型常量。

682 struct tree_int_cst GTY(()) in tree.h
683 {
684 struct tree_common common;
685 /* A sub-struct is necessary here because the function `const_hash'
686 wants to scan both words as a unit and taking the address of the
687 sub-struct yields the properly inclusive bounded pointer. */
688 struct tree_int_cst_lowhi {
689 unsigned HOST_WIDE_INT low;
690 HOST_WIDE_INT high;
691 } int_cst;
692 };

在上面688行，在结构tree_int_cst_lowhi中，low部分和high部分构成了完整的表达值（注意可表达值可以是128位）。其取值范围由其精度通过下面的函数set_min_and_max_values_for_integral_type确定。

1965 void
1966 set_min_and_max_values_for_integral_type (tree type, in stor-layout.c
1967 int precision,
1968 bool is_unsigned)
1969 {
1970 tree min_value;
1971 tree max_value;
1972
1973 if (is_unsigned)
1974 {
1975 min_value = build_int_2 (0, 0);
1976 max_value
1977 = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0
1978 ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
1979 precision - HOST_BITS_PER_WIDE_INT > 0
1980 ? ((unsigned HOST_WIDE_INT) ~0
1981 >> (HOST_BITS_PER_WIDE_INT
1982 - (precision - HOST_BITS_PER_WIDE_INT)))
1983 : 0);
1984 }
1985 else
1986 {
1987 min_value
1988 = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1989 ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1990 (((HOST_WIDE_INT) (-1)
1991 << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1992 ? precision - HOST_BITS_PER_WIDE_INT - 1
1993 : 0))));
1994 max_value
1995 = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1996 ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1997 (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1998 ? (((HOST_WIDE_INT) 1
1999 << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
2000 : 0));
2001 }
2002
2003 TREE_TYPE (min_value) = type;
2004 TREE_TYPE (max_value) = type;
2005 TYPE_MIN_VALUE (type) = min_value;
2006 TYPE_MAX_VALUE (type) = max_value;
2007 }

上面的build_int_2将创建一个INTEGER_CST的节点。注意对有符号数与无符号数取值范围的确定方法。
1.2.2.1.5. 整型类型的布局
在创建了这个节点后，它需要被正确地填充。这是函数layout_type的工作。这个函数是创建类型节点的最后一步。在节点被这个函数处理前，它的TYPE_SIZE一直是NULL，而这个域将被layout_type设置。为了避免重复对节点布局，如果TYPE_SIZE不是NULL，函数既在1524行退出。

1516 void
1517 layout_type (tree type) in stor_layout.c
1518 {
1519 if (type == 0)
1520 abort ();
1521
1522 /* Do nothing if type has been laid out before. */
1523 if (TYPE_SIZE (type))
1524 return;
1525
1526 switch (TREE_CODE (type))
1527 {
1528 case LANG_TYPE:
1529 /* This kind of type is the responsibility
1530 of the language-specific code. */
1531 abort ();
1532
1533 case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */
1534 if (TYPE_PRECISION (type) == 0)
1535 TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */
1536
1537 /* ... fall through ... */
1538
1539 case INTEGER_TYPE:
1540 case ENUMERAL_TYPE:
1541 case CHAR_TYPE:
1542 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1543 && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
1544 TREE_UNSIGNED (type) = 1;
1545
1546 TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
1547 MODE_INT);
1548 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
1549 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
1550 break;
1.2.2.1.5.1. 整型的类型信息
在上面，那些名字以TYPE开头的宏访问的是，由它名字剩余部分所指示的tree_type中的域。而那些以TREE开头的宏则访问tree_common.的域。
1.2.2.1.5.1.1. 确定类型的符号
类型的符号是重要的信息。在tree_common节点中，域TREE_UNSIGNED被用于表示类型的符号。而确定类型的符号，则通过以下简单的方法。

3337 int
3338 tree_int_cst_sgn (tree t) in tree.c
3339 {
3340 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3341 return 0;
3342 else if (TREE_UNSIGNED (TREE_TYPE (t)))
3343 return 1;
3344 else if (TREE_INT_CST_HIGH (t) < 0)
3345 return -1;
3346 else
3347 return 1;
3348 }
1.2.2.1.5.1.2. 确定机器模式
在GCC的代码中，机器模式实际上作为数组索引。要描述类型的组别（比如，不同尺寸的整型），代码中有数组mode_class。描述类型的大小，则有数组mode_size，mode_nunits，mode_precision。而描述同一组别，不同模式间的关系，有数组mode_wider。另外，还有其他用于模式的数组。在当前版本的GCC中，有关目标机器的可用模式的信息都是通过后端工具genmodes产生。
在上面1547行，我们已知模式的类别，通过已知的精度我们可找到最合适的模式。

247 enum machine_mode
248 smallest_mode_for_size (unsigned int size, enum mode_class class) in stor-layout.c
249 {
250 enum machine_mode mode;
251
252 /* Get the first mode which has at least this size, in the
253 specified class. */
254 for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
255 mode = GET_MODE_WIDER_MODE (mode))
256 if (GET_MODE_PRECISION (mode) >= size)
257 return mode;
258
259 abort ();
260 }

GET_CLASS_NARROWEST_MODE为指定类别返回最小的可行的模式，例如，这里的MODE_INT类别。数组class_narrowest_mode同样是genmodes产生的记录了模式类别中的最小的模式。

150 #define GET_CLASS_NARROWEST_MODE(CLASS) class_narrowest_mode[CLASS]

同样，mode_wider也是由genmodes产生，它由MODE索引，对应于模式在同一类别中的下一个更大的模式。

116 #define GET_MODE_WIDER_MODE(MODE) mode_wider[MODE]

还是由genmodes生成，mode_precision记录了模式中的有意义的比特数（精度）。

87 #define GET_MODE_PRECISION(MODE) mode_precision[MODE]

因此smallest_mode_for_size将找出属于class类别，能容纳size位大小数据的，最小的模式。有了这样的数据，通过下面的宏我们可以找出类型确切的大小。

#define GET_MODE_SIZE(MODE) ((unsigned short) mode_size[MODE]) in machmode.h
#define GET_MODE_BITSIZE(MODE) ((unsigned short) (GET_MODE_SIZE (MODE) * BITS_PER_UNIT))

当在聚合类型中布置具有该类型的数据成员时，这些信息非常重要。
1.2.2.1.5.1.3. 确定类型大小
在layout_type的1548和1549行，bitsize_int和size_int为类型节点构建了记录了类型尺寸信息的节点。这2个函数需要sizetype和bitsizetype这样的类型信息。这也是为什么首先要创建临时的sizetype和bitsizetype节点。
处理bitsize_int和size_int，这个系列的宏还有：

2441 #define size_int_type(L, T) size_int_type_wide ((HOST_WIDE_INT) (L), T)
2442 #define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), SIZETYPE)
2443 #define ssize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SSIZETYPE)
2444 #define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), BITSIZETYPE)
2445 #define sbitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SBITSIZETYPE)

参数L代表类型的长度。

1544 tree
1545 size_int_wide (HOST_WIDE_INT number, enum size_type_kind kind) in fold-const.c
1546 {
1547 return size_int_type_wide (number, sizetype_tab[(int) kind]);
1548 }

注意到size_int_type_wide的参数tree是临时的sizetype节点。

1552 static GTY (()) tree new_const;
1553 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node))) in fold-const.c
1554 htab_t size_htab;
1555
1556 tree
1557 size_int_type_wide (HOST_WIDE_INT number, tree type)
1558 {
1559 void **slot;
1560
1561 if (size_htab == 0)
1562 {
1563 size_htab = htab_create_ggc (1024, size_htab_hash, size_htab_eq, NULL);
1564 new_const = make_node (INTEGER_CST);
1565 }
1566
1567 /* Adjust NEW_CONST to be the constant we want. If it's already in the
1568 hash table, we return the value from the hash table. Otherwise, we
1569 place that in the hash table and make a new node for the next time. */
1570 TREE_INT_CST_LOW (new_const) = number;
1571 TREE_INT_CST_HIGH (new_const) = number < 0 ? -1 : 0;
1572 TREE_TYPE (new_const) = type;
1573 TREE_OVERFLOW (new_const) = TREE_CONSTANT_OVERFLOW (new_const)
1574 = force_fit_type (new_const, 0);
1575
1576 slot = htab_find_slot (size_htab, new_const, INSERT);
1577 if (*slot == 0)
1578 {
1579 tree t = new_const;
1580
1581 *slot = new_const;
1582 new_const = make_node (INTEGER_CST);
1583 return t;
1584 }
1585 else
1586 return (tree) *slot;
1587 }

函数size_int_type_wide同样被用于创建其他大小的整形类型节点。这些节点代表的类型信息同样也是系统内唯一，而且经常被访问，因此它们被存放在哈希表中。注意到代表这些内建整形类型的尺寸的节点亦保持在另一哈希表内。正如我们在tree_int_cst中看到的，域 int_cst实际上是128位的。很明显在绝大数情况下，常量都不会使用所有的比特，因此这些常量需要被位扩展以使用所有的比特位（就像类型转换至128位的类型）。

181 int
182 force_fit_type (tree t, int overflow) in fold-const.c
183 {
184 unsigned HOST_WIDE_INT low;
185 HOST_WIDE_INT high;
186 unsigned int prec;
187
188 if (TREE_CODE (t) == REAL_CST)
189 {
190 /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
191 Consider doing it via real_convert now. */
192 return overflow;
193 }
194
195 else if (TREE_CODE (t) != INTEGER_CST)
196 return overflow;
197
198 low = TREE_INT_CST_LOW (t);
199 high = TREE_INT_CST_HIGH (t);
200
201 if (POINTER_TYPE_P (TREE_TYPE (t))
202 || TREE_CODE (TREE_TYPE (t)) == OFFSET_TYPE)
203 prec = POINTER_SIZE;
204 else
205 prec = TYPE_PRECISION (TREE_TYPE (t));
206
207 /* First clear all bits that are beyond the type's precision. */
208
209 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
210 ;
211 else if (prec > HOST_BITS_PER_WIDE_INT)
212 TREE_INT_CST_HIGH (t)
213 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
214 else
215 {
216 TREE_INT_CST_HIGH (t) = 0;
217 if (prec < HOST_BITS_PER_WIDE_INT)
218 TREE_INT_CST_LOW (t) &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
219 }
220
221 /* Unsigned types do not suffer sign extension or overflow unless they
222 are a sizetype. */
223 if (TREE_UNSIGNED (TREE_TYPE (t))
224 && ! (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
225 && TYPE_IS_SIZETYPE (TREE_TYPE (t))))
226 return overflow;
227
228 /* If the value's sign bit is set, extend the sign. */
229 if (prec != 2 * HOST_BITS_PER_WIDE_INT
230 && (prec > HOST_BITS_PER_WIDE_INT
231 ? 0 != (TREE_INT_CST_HIGH (t)
232 & ((HOST_WIDE_INT) 1
233 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
234 : 0 != (TREE_INT_CST_LOW (t)
235 & ((unsigned HOST_WIDE_INT) 1 << (prec - 1)))))
236 {
237 /* Value is negative:
238 set to 1 all the bits that are outside this type's precision. */
239 if (prec > HOST_BITS_PER_WIDE_INT)
240 TREE_INT_CST_HIGH (t)
241 |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
242 else
243 {
244 TREE_INT_CST_HIGH (t) = -1;
245 if (prec < HOST_BITS_PER_WIDE_INT)
246 TREE_INT_CST_LOW (t) |= ((unsigned HOST_WIDE_INT) (-1) << prec);
247 }
248 }
249
250 /* Return nonzero if signed overflow occurred. */
251 return
252 ((overflow | (low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t)))
253 != 0);
254 }

注意负数采用了2进制补码。函数force_fit_type用于检查在常量折叠中（一种优化方法，比如，将加法表达式中的多个常量操作数，用其和来取代它们），整形常量是否溢出。
对于有符号整形，如果符号发生改变，表明发生了溢出。假定对于char类型，执行127+1，其保持在tree_int_cst中的值从0…01111111B改变至0…1000000B，force_fit_type将这个值保存在域high和low，然后清除多余位，再按符号位扩展它们。因此我们得到1…10000000B，low ^ TREE_INT_CST_LOW (t)将会返回非零值。而如果没有溢出发生，high和low部分在252行的操作都应该得到0.
1.2.2.1.5.2. 完成布局

Layout_t (continued)

1798 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
1799 records and unions, finish_record_layout already called this
1800 function. */
1801 if (TREE_CODE (type) != RECORD_TYPE
1802 && TREE_CODE (type) != UNION_TYPE
1803 && TREE_CODE (type) != QUAL_UNION_TYPE)
1804 finalize_type_size (type);
1805
1806 /* If this type is created before sizetype has been permanently set,
1807 record it so set_sizetype can fix it up. */
1808 if (! sizetype_set)
1809 early_type_list = tree_cons (NULL_TREE, type, early_type_list);
1810
1811 /* If an alias set has been set for this aggregate when it was incomplete,
1812 force it into alias set 0.
1813 This is too conservative, but we cannot call record_component_aliases
1814 here because some frontends still change the aggregates after
1815 layout_type. */
1816 if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type))
1817 TYPE_ALIAS_SET (type) = 0;
1818 }

上面1804行的finalize_type_size在类型完成布局后，为其计算尺寸和对齐量。注意在1808行，现阶段，标识sizetype_size仍未设置，表明size_t is的节点还没有准备好（仍是还是临时的）。这样，我们需要把这些在size_t正式节点被创建前的节点，保存到early_type_list中。因为它们用到了size_t，在正式的size_t节点创建好后，我们需要用这个节点来替换那个临时的size_t。
1.2.2.2. size_t的正式的节点
在临时size_t节点的帮助下，编译器为内建的整型类型创建了节点，接着它可以确定正式的size_t节点。在当前的GCC中，由如下代码片段实现。

c_common_nodes_and_builtins

3172 size_type_node = in c-common.c
3173 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3174 signed_size_type_node = c_common_signed_type (size_type_node);
3175 set_sizetype (size_type_node);

上面的size_type_node在C/C++中代表size_t。SIZE_TYPE则指明size_t类型，在x86/Linux中，它是unsigned int。

1882 void
1883 set_sizetype (tree type) in stor-layout.c
1884 {
1885 int oprecision = TYPE_PRECISION (type);
1886 /* The *bitsizetype types use a precision that avoids overflows when
1887 calculating signed sizes / offsets in bits. However, when
1888 cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit
1889 precision. */
1890 int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1,
1891 2 * HOST_BITS_PER_WIDE_INT);
1892 unsigned int i;
1893 tree t;
1894
1895 if (sizetype_set)
1896 abort ();
1897
1898 /* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */
1899 sizetype = copy_node (type);
1900 TYPE_DOMAIN (sizetype) = type;
1901 TYPE_IS_SIZETYPE (sizetype) = 1;
1902 bitsizetype = make_node (INTEGER_TYPE);
1903 TYPE_NAME (bitsizetype) = TYPE_NAME (type);
1904 TYPE_PRECISION (bitsizetype) = precision;
1905 TYPE_IS_SIZETYPE (bitsizetype) = 1;
1906
1907 if (TREE_UNSIGNED (type))
1908 fixup_unsigned_type (bitsizetype);
1909 else
1910 fixup_signed_type (bitsizetype);
1911
1912 layout_type (bitsizetype);
1913
1914 if (TREE_UNSIGNED (type))
1915 {
1916 usizetype = sizetype;
1917 ubitsizetype = bitsizetype;
1918 ssizetype = copy_node (make_signed_type (oprecision));
1919 sbitsizetype = copy_node (make_signed_type (precision));
1920 }
1921 else
1922 {
1923 ssizetype = sizetype;
1924 sbitsizetype = bitsizetype;
1925 usizetype = copy_node (make_unsigned_type (oprecision));
1926 ubitsizetype = copy_node (make_unsigned_type (precision));
1927 }
1928
1929 TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type");
1930
1931 /* Show is a sizetype, is a main type, and has no pointers to it. */
1932 for (i = 0; i < ARRAY_SIZE (sizetype_tab); i++)
1933 {
1934 TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1;
1935 TYPE_MAIN_VARIANT (sizetype_tab[i]) = sizetype_tab[i];
1936 TYPE_NEXT_VARIANT (sizetype_tab[i]) = 0;
1937 TYPE_POINTER_TO (sizetype_tab[i]) = 0;
1938 TYPE_REFERENCE_TO (sizetype_tab[i]) = 0;
1939 }
1940
1941 /* Go down each of the types we already made and set the proper type
1942 for the sizes in them. */
1943 for (t = early_type_list; t != 0; t = TREE_CHAIN (t))
1944 {
1945 if (TREE_CODE (TREE_VALUE (t)) != INTEGER_TYPE
1946 && TREE_CODE (TREE_VALUE (t)) != BOOLEAN_TYPE)
1947 abort ();
1948
1949 TREE_TYPE (TYPE_SIZE (TREE_VALUE (t))) = bitsizetype;
1950 TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t))) = sizetype;
1951 }
1952
1953 early_type_list = 0;
1954 sizetype_set = 1;
1955 }

在1890行，对于x86/Linux oprecision是32。而BITS_PER_UNIT_LOG则定义如下：

2456 #define BITS_PER_UNIT_LOG / in tree.h
2457 ((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) /
2458 + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) /
2459 + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))

在x86/Linux下，BITS_PER_UNIT是8（比特的大小），因此BITS_PER_UNIT_LOG返回3。
前面在使用临时的sizetype和bitsizetype创建内建的整型类型节点，这些节点由early_type_list串在一起。现在size_t的正式节点已经就绪，临时的size_t节点可以被替代了。

1.2.2.3. 创建整型常量节点

我们已经看到，在GCC中，整型常量由tree_int_cst节点表示。GCC使用build_int_2来创建这些节点，build_int_2是一个宏，它接着调用build_int_2_wide。

2107 #define build_int_2(LO, HI) / in tree.h
2108 build_int_2_wide ((unsigned HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))

build_int_2_wide根据参数low和hi创建INTEGER_CST节点。

403 tree
404 build_int_2_wide (unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi) in tree.c
405 {
406 tree t = make_node (INTEGER_CST);
407
408 TREE_INT_CST_LOW (t) = low;
409 TREE_INT_CST_HIGH (t) = hi;
410 TREE_TYPE (t) = integer_type_node;
411 return t;
412 }