Studying note of GCC-3.4.6 source (5)

1.2.2. Create node for internal types

For internal types of the language, for example, int, unsigned short in C/C++, the compiler will create nodes for these types first when it starts up.
1.2.2.1. Initialize temperary nodes for size_t
To create nodes for internal types, temprary nodes for size_t (one for size_t, the other for bitsize_t. size_t is the returned type of sizeof, and bitsize_t is only used by internal) should be first created, as they will be used in layout internal types. Normally, the invocation sequence is like:

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);

Above signed_char_type_node and unsigned_char_type_node are alias for certain elements of a global array which described in below section.
1.2.2.1.1. Node for integer types
Integer types are very important and basic part of the language. They are used so heavily (appear in every program in fact), to make the accession as efficient as possible, GCC instead of placing them into hash-table as other types, uses global array to hold them.

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. Create temparory node for size_t
The sizes of internal types are another extensively used data in the compiler. So GCC also saves them into a global array.

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]

Above nodes mean, normal representation of sizes in bytes; normal representation of sizes in bits; signed representation of sizes in bytes; unsigned representation of sizes in bytes; signed representation of sizes in bits; unsigned representation of sizes in bits; in turn (these 3 groups data aim to satisfy different requirement from different target machine).
Originally, only temperary sizetype and bitsizetype are created. The procedure is quite simple.

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 }

First at line 1852 a temperary nteger_type_node created. From line 1858 to 1864, data relate to mode is generated by back-end tool genmodes from machmode.def, which is used to fill toye node here. Following, build_int_2 will build node for integer constant of 0 and 1000 as the range of the value these temparory size_t can get. And the temparory integer_type_node is used as type of these constants. Note at line 1874, integer_type_node is also used as the type of sizetype and bitsizetype. However, this sizetype will be abandoned after internal integer type created.
1.2.2.1.3. Create node for integer type
We just take signed integer type as example. For unsigned type, the procedure is very similar with that we see here.

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 }

The `TYPE_PRECISION' is the number of bits used in the representation, represented as an `unsigned int'. (Note that in the general case this is not the same value as `TYPE_SIZE'; suppose that there were a 24-bit integer type, but that alignment requirements for the ABI required 32-bit alignment. Then, `TYPE_SIZE' would be an `INTEGER_CST' for 32, while `TYPE_PRECISION' would be 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. Determine the range of value
Every integer type has its own ability to present certain range of values. For the tree_type nodes created for the types, fields TYPE_MIN_VALUE and TYPE_MAX_VALUE save the low and up boundary of the range. As integer constant, these two fields are 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 };

And above at line 688, in tree_int_cst_lowhi, the low part and the high part construct an intact value presented (note that the value represented can be up to 128 bits long). The range is determined according to the precision of the type by set_min_and_max_values_for_integral_type below.

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 }

Above build_int_2 will create node of INTEGER_CST (detail in T.3 Creates Node of Intege Constant - build_int_2). Notice that min_value and max_value of the type should also contain the same type information.
1.2.2.1.5. Layout integer types
After creating the node, it should make sure it is correctly filled up. It is the work of layout_type. This function is always invoked as last step in creating node for types. Before the nodes handled by this funciton, TYPE_SIZE field will always be NULL, and this field will be set in layout_type. To avoid duplicate layout, so if TYPE_SIZE is not NULL, the function will exit at line 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. Information of integer type
Above, macros having name beginning with TYPE just access the corresponding field of tree_type as indicated by the rest part of the name. And those beginning with TREE just access that of tree_common.
1.2.2.1.5.1.1. Determine the sign of type
Sign of the type is the key information. In tree_common node, field TREE_UNSIGNED is used to indicate the type’s sign if appropriate. Find out the sign for integer is very simple as following.

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. Determine the machine mode
In GCC source code, mode just serves as an index. To describe the type groups (for example, integer type of different size), there is mode_class array, and to describe the size, there are mode_size, mode_nunits, mode_precision arrays. And to describe the relation between modes belonging to the same group, there are mode_wider array. Also there are arrays for other purpose for mode. For current version, the information about available modes for the target platform are generated by tool genmodes (Back-end 7. Tool of genmodes).
At line 1547 above, as we know the group, we can find out the fittest mode with the precision in hand.

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 returns the narrowest mode of the class, for example, INT class here. class_narrowest_mode is also generated by genmodes and records narrowest mode for the class.

150 #define GET_CLASS_NARROWEST_MODE(CLASS) class_narrowest_mode[CLASS]

Again, mode_wider is generated by genmodes which is indexed by MODE (which is enum value) and contains next wider mode in the position.

116 #define GET_MODE_WIDER_MODE(MODE) mode_wider[MODE]

mode_precision, generated by genmodes too, records the number of significant bits of the mode.

87 #define GET_MODE_PRECISION(MODE) mode_precision[MODE]

So smallest_mode_for_size just finds out the narrowest mode belonging to the class and capable to hold size bits data. With that information we can find out the exact size for the type as following.

#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))

These information are important when a field of the type is laid out without aggregate type.
1.2.2.1.5.1.3. Determine the size of type
At line 1548 and 1549 in layout_type, bitsize_int and size_int create nodes record size information for the type. These functions will need sizetype and bitsizetype as type information for the nodes created. That is why temperary sizetype and bitsizetype must be created first.
Besides bitsize_int and size_int, there are series macros defined.

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)

Parameter L stands for the length of the type.

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 }

Notice that parameter tree of size_int_type_wide is the temperary 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 will also be invoked to create nodes for size of other integer type, these sizes information are also system wide unique, and will be accessed frequently, so they are worth to be put into hashtable. Notice that size nodes of internal integer types are also saved in another hashtable. As we have seen, in tree_int_cst, field int_cst is in fact 128 bits in size. It is obviously in most cases the constant will not occupy the whole bits. So the constant needs be extended to all bits (just regards it as type cast to the version of 128 bits).

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 }

Notice that negative number is represented by 2 complement presentation. And force_fit_type also is used to check if certain integer constant is overflowed during constant folding (a kind of optimization – for example, sums the values of constants in the same expression).
Just see the way to check overflow. For signed integer type, if overflow, the signed field changes. Assuming 127+1 for char type, the value changes from 0…01111111B to 0…1000000B, force_fit_type saves this value into high and low, then cleans the extra bits and extend these bits according to the signed bit again, and we get 1…10000000B, low ^ TREE_INT_CST_LOW (t) will return nonzero. And if no overflow occurs, it will be zero for high and low parts at line 252.
1.2.2.1.5.4. Finish layout

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 }

finalize_type_size at line 1804 above, computes size and alignment for the type again after is is laid out. Notice that at line 1808, now at this stage, flag sizetype_size is still not set which means nodes for size_t is not ready yet (still temperary ones). Then we save these nodes before real node of size_t is ready into early_type_list. Since they use size_t, when real node of size_t is ready, we need use it to replace with that temparory one.
1.2.2.2. The real node for size_t
After the compiler has nodes for internal integer types created with aid of node of temperary size_t, it can settle down the real size_t. In current GCC, it lies in following code snippet.

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);

Above size_type_node is the node present size_t in C/C++. SIZE_TYPE indicates the type of size_t, in x86 Linux, it is 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 }

Notice that at line 1890, oprecision is 32 for x86/Linux. And BITS_PER_UNIT_LOG is defined as following.

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))

In x86/Linux, BITS_PER_UNIT is 8 (size of byte), so BITS_PER_UNIT_LOG returns 3.
Remember that, when using temperary sizetype and bitsizetype to create nodes for internal integer types, all these nodes are chained tegother with early_type_list. Now as regular nodes for size_t are ready, the temperary size_t nodes can be replaced.

1.2.2.3. Create node for integer constant

As we have seen, in GCC, integer constant is presented by nodes of tree_int_cst. To create nodes of this kind, GCC uses build_int_2, which is a macro invoking build_int_2_wide inside.

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 constructs INTEGER_CST node from its parameters low and hi.

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 }