Studying note of GCC-3.4.6 source (57)

4.3.1.7.5.3. Nodes of other builtin types
Next part of c_common_nodes_and_builtins is given below:

c_common_nodes_and_builtins (continue)

3177 build_common_tree_nodes_2 (flag_short_double);
3178
3179 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3180 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3181 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3182
3183 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3184 get_identifier ("complex int"),
3185 complex_integer_type_node));
3186 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3187 get_identifier ("complex float"),
3188 complex_float_type_node));
3189 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3190 get_identifier ("complex double"),
3191 complex_double_type_node));
3192 (*lang_hooks.decls.pushdecl)
3193 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3194 complex_long_double_type_node));
4.3.1.7.5.3.1. Nodes of commonly used constants
In the compiler, constants like: 0, 1, 3 etc., must be in form of tree node (in front-end, it is the node of intermediate tree, in back-end it is a rtx node). Thus, the compiler will create corresponding and unique nodes. Now nodes of integer types are ready, nodes of constants of these type commonly in used can be created. Below size_NUM_node presents size of NUM bytes, and bitsize_NUM_node stands for size of NUM bits.

4894 void
4895 build_common_tree_nodes_2 (int short_double) in tree.c
4896 {
4897 /* Define these next since types below may used them. */
4898 integer_zero_node = build_int_2 (0, 0);
4899 integer_one_node = build_int_2 (1, 0);
4900 integer_minus_one_node = build_int_2 (-1, -1);
4901
4902 size_zero_node = size_int (0);
4903 size_one_node = size_int (1);
4904 bitsize_zero_node = bitsize_int (0);
4905 bitsize_one_node = bitsize_int (1);
4906 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
4907
4908 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
4909 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
4910
4911 void_type_node = make_node (VOID_TYPE);
4912 layout_type (void_type_node);
4913
4914 /* We are not going to have real types in C with less than byte alignment,
4915 so we might as well not have any types that claim to have it. */
4916 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
4917 TYPE_USER_ALIGN (void_type_node) = 0;
4918
4919 null_pointer_node = build_int_2 (0, 0);
4920 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4921 layout_type (TREE_TYPE (null_pointer_node));
4922
4923 ptr_type_node = build_pointer_type (void_type_node);
4924 const_ptr_type_node
4925 = build_pointer_type (build_type_variant (void_type_node, 1, 0));

The creation of null_pointer_node is interesting. It is first created as 0 filled integer_type_node, its type then is set as pointer of void_type_node – it is the same as (void*)0. For void* is ptr_type_node, and for const void* is const_ptr_type_node created out of ptr_type_node by build_type_variant.

2304 #define build_type_variant(TYPE, CONST_P, VOLATILE_P) / in tree.h
2305 build_qualified_type ((TYPE), /
2306 ((CONST_P) ? TYPE_QUAL_CONST : 0) /
2307 | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))

Notice that operator to join line 2306 and 2307 is “|”, const and volatile can come tegother.

2908 tree
2909 build_qualified_type (tree type, int type_quals) in tree.c
2910 {
2911 tree t;
2912
2913 /* See if we already have the appropriate qualified variant. */
2914 t = get_qualified_type (type, type_quals);
2915
2916 /* If not, build it. */
2917 if (!t)
2918 {
2919 t = build_type_copy (type);
2920 set_type_quals (t, type_quals);
2921 }
2922
2923 return t;
2924 }

Types cv-qualified and cv-unqualified are linked tegother with the cv-unqualified type at head, we need first ensure the requested cv-qualified type has not been created.

2888 tree
2889 get_qualified_type (tree type, int type_quals) in tree.c
2890 {
2891 tree t;
2892
2893 /* Search the chain of variants to see if there is already one there just
2894 like the one we need to have. If so, use that existing one. We must
2895 preserve the TYPE_NAME, since there is code that depends on this. */
2896 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2897 if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type)
2898 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2899 && attribute_list_equal (TYPE_ATTRIBUTES (t), TYPE_ATTRIBUTES (type)))
2900 return t;
2901
2902 return NULL_TREE;
2903 }

To create the cv-qualified type, we just copy type, but pointer_to and reference_to fields are set as 0, as they will be filled until the corresponding pointer and reference types are constructed.

2929 tree
2930 build_type_copy (tree type) in tree.c
2931 {
2932 tree t, m = TYPE_MAIN_VARIANT (type);
2933
2934 t = copy_node (type);
2935
2936 TYPE_POINTER_TO (t) = 0;
2937 TYPE_REFERENCE_TO (t) = 0;
2938
2939 /* Add this type to the chain of variants of TYPE. */
2940 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
2941 TYPE_NEXT_VARIANT (m) = t;
2942
2943 return t;
2944 }

Then information about cv-qualifier can be saved into the tree node created.

2876 static void
2877 set_type_quals (tree type, int type_quals) in tree.c
2878 {
2879 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
2880 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
2881 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
2882 }

Next, creating floating and complex types is not different from integer type. Refers to Create node for real constant for details of floating point number.

build_common_tree_nodes_2 (continue)

4927 float_type_node = make_node (REAL_TYPE);
4928 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4929 layout_type (float_type_node);
4930
4931 double_type_node = make_node (REAL_TYPE);
4932 if (short_double)
4933 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4934 else
4935 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4936 layout_type (double_type_node);
4937
4938 long_double_type_node = make_node (REAL_TYPE);
4939 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4940 layout_type (long_double_type_node);
4941
4942 float_ptr_type_node = build_pointer_type (float_type_node);
4943 double_ptr_type_node = build_pointer_type (double_type_node);
4944 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
4945 integer_ptr_type_node = build_pointer_type (integer_type_node);
4946
4947 complex_integer_type_node = make_node (COMPLEX_TYPE);
4948 TREE_TYPE (complex_integer_type_node) = integer_type_node;
4949 layout_type (complex_integer_type_node);
4950
4951 complex_float_type_node = make_node (COMPLEX_TYPE);
4952 TREE_TYPE (complex_float_type_node) = float_type_node;
4953 layout_type (complex_float_type_node);
4954
4955 complex_double_type_node = make_node (COMPLEX_TYPE);
4956 TREE_TYPE (complex_double_type_node) = double_type_node;
4957 layout_type (complex_double_type_node);
4958
4959 complex_long_double_type_node = make_node (COMPLEX_TYPE);
4960 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
4961 layout_type (complex_long_double_type_node);

Line 4942 ~ 4945 also prepare nodes of the pointer types.
4.3.1.7.5.3.2. Node of va_list
In C/C++, when using “…” as parameter in function, special object va_list is needed as below example.

int average( int first,int second, ... )
{
int count = 0, sum = 0,
i = first; //i=2
va_list marker;
va_start( marker, second ); // Initialize variable arguments.
i = va_arg( marker, int);
va_end( marker ); /* Reset variable arguments. */
return( sum ? (sum / count) : 0 );
}

va_list is a special type passed to va_start, va_arg and va_end, it is responsibility of compiler to create the type, which is within build_common_tree_nodes_2 as below.

build_common_tree_nodes_2 (continue)

4963 {
4964 tree t = (*targetm.build_builtin_va_list) ();
4965
4966 /* Many back-ends define record types without setting TYPE_NAME.
4967 If we copied the record type here, we'd keep the original
4968 record type without a name. This breaks name mangling. So,
4969 don't copy record types and let c_common_nodes_and_builtins()
4970 declare the type to be __builtin_va_list. */
4971 if (TREE_CODE (t) != RECORD_TYPE)
4972 t = build_type_copy (t);
4973
4974 va_list_type_node = t;
4975 }

Obviously, va_list depends on machine (it further determines the library it belongs to), different architecture may have different solution. build_builtin_va_list points to x86_build_builtin_va_list for x86 machine.

2968 static tree
2969 ix86_build_builtin_va_list (void) in i386.c
2970 {
2971 tree f_gpr, f_fpr, f_ovf, f_sav, record, type_decl;
2972
2973 /* For i386 we use plain pointer to argument area. */
2974 if (!TARGET_64BIT)
2975 return build_pointer_type (char_type_node);
…
3005 }

For 32 bits x86 machine, va_list in fact is char*. While for 64 bits x86 machine, va_list is a struct named __va_list_tag (the code is not shown here).
4.3.1.7.5.3.3. Nodes of vector types
In multimedia application, like photo, vedio, matrix operation is everywhere. Being a kind of optimization, for example, in CPU of 32 bits x86 system, 128 bits registers are introduced, thus 4 long integers or single floating number can be placed within a single register, co-operated with specialized instructions (for instance, instruciton sets of SSE1, SSE2, refers to Initialize registers sets, for an example of register sets), it accelates the multimedia operation greatly. The form placing mulitply values within a register, is called vector to distiguished from array.
Below, the mode name beginning V[num] points out the number of values the vector contains, and the values are of mode XXmode (then the lengthe of the vector is: num*sizeof(XXmode) ).

build_common_tree_nodes_2 (continue)

4977 unsigned_V4SI_type_node
4978 = make_vector (V4SImode, unsigned_intSI_type_node, 1);
4979 unsigned_V2HI_type_node
4980 = make_vector (V2HImode, unsigned_intHI_type_node, 1);
4981 unsigned_V2SI_type_node
4982 = make_vector (V2SImode, unsigned_intSI_type_node, 1);
4983 unsigned_V2DI_type_node
4984 = make_vector (V2DImode, unsigned_intDI_type_node, 1);
4985 unsigned_V4HI_type_node
4986 = make_vector (V4HImode, unsigned_intHI_type_node, 1);
4987 unsigned_V8QI_type_node
4988 = make_vector (V8QImode, unsigned_intQI_type_node, 1);
4989 unsigned_V8HI_type_node
4990 = make_vector (V8HImode, unsigned_intHI_type_node, 1);
4991 unsigned_V16QI_type_node
4992 = make_vector (V16QImode, unsigned_intQI_type_node, 1);
4993 unsigned_V1DI_type_node
4994 = make_vector (V1DImode, unsigned_intDI_type_node, 1);
4995
4996 V16SF_type_node = make_vector (V16SFmode, float_type_node, 0);
4997 V4SF_type_node = make_vector (V4SFmode, float_type_node, 0);
4998 V4SI_type_node = make_vector (V4SImode, intSI_type_node, 0);
4999 V2HI_type_node = make_vector (V2HImode, intHI_type_node, 0);
5000 V2SI_type_node = make_vector (V2SImode, intSI_type_node, 0);
5001 V2DI_type_node = make_vector (V2DImode, intDI_type_node, 0);
5002 V4HI_type_node = make_vector (V4HImode, intHI_type_node, 0);
5003 V8QI_type_node = make_vector (V8QImode, intQI_type_node, 0);
5004 V8HI_type_node = make_vector (V8HImode, intHI_type_node, 0);
5005 V2SF_type_node = make_vector (V2SFmode, float_type_node, 0);
5006 V2DF_type_node = make_vector (V2DFmode, double_type_node, 0);
5007 V16QI_type_node = make_vector (V16QImode, intQI_type_node, 0);
5008 V1DI_type_node = make_vector (V1DImode, intDI_type_node, 0);
5009 V4DF_type_node = make_vector (V4DFmode, double_type_node, 0);
5010 }

Function make_vector specially creates node for vector types. It will not be used in other place for x86 machine.

5061 tree
5062 make_vector (enum machine_mode mode, tree innertype, int unsignedp) in tree.c
5063 {
5064 tree t;
5065
5066 t = make_node (VECTOR_TYPE);
5067 TREE_TYPE (t) = innertype;
5068 TYPE_MODE (t) = mode;
5069 TREE_UNSIGNED (TREE_TYPE (t)) = unsignedp;
5070 finish_vector_type (t);
5071
5072 return t;
5073 }

The alternative representation of vector type is the form of RECORD_TYPE, for example, for V16QI_type_node, the alternative representation will like:
RECORD_TYPE {
Field:
QI/*array_type*/ f [15/*index_type*/]
}
Sections Create node for index and Create node for array type describe the creation of ARRAY_TYPE and the array index.

4786 static void
4787 finish_vector_type (tree t) in tree.c
4788 {
4789 layout_type (t);
4790
4791 {
4792 tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
4793 tree array = build_array_type (TREE_TYPE (t),
4794 build_index_type (index));
4795 tree rt = make_node (RECORD_TYPE);
4796
4797 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
4798 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
4799 layout_type (rt);
4800 TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
4801 /* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output
4802 the representation type, and we want to find that die when looking up
4803 the vector type. This is most easily achieved by making the TYPE_UID
4804 numbers equal. */
4805 TYPE_UID (rt) = TYPE_UID (t);
4806 }
4807 }

Following nodes created in c_common_nodes_and_builtins are for Fortran, we just skip the code. After that, at line 3249, void type is created, and line 3251 generates node of “((void) 0)”. Then node void_list_node is a chain of 2 void_type_node. Next char_array_type_node and wchar_array_type_node only would be used in lexer, to distinguish whether put in string is of wchar_t or char. But int_array_type_node is still useless.

c_common_nodes_and_builtins (continue)

3249 record_builtin_type (RID_VOID, NULL, void_type_node);
3250
3251 void_zero_node = build_int_2 (0, 0);
3252 TREE_TYPE (void_zero_node) = void_type_node;
3253
3254 void_list_node = build_void_list_node ();
3255
3256 /* Make a type to be the domain of a few array types
3257 whose domains don't really matter.
3258 200 is small enough that it always fits in size_t
3259 and large enough that it can hold most function names for the
3260 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
3261 array_domain_type = build_index_type (size_int (200));
3262
3263 /* Make a type for arrays of characters.
3264 With luck nothing will ever really depend on the length of this
3265 array type. */
3266 char_array_type_node
3267 = build_array_type (char_type_node, array_domain_type);
3268
3269 /* Likewise for arrays of ints. */
3270 int_array_type_node
3271 = build_array_type (integer_type_node, array_domain_type);
3272
3273 string_type_node = build_array_type (char_type_node);
3274 const_string_type_node
3275 = build_array_type (build_qualified_type
3276 (char_type_node, TYPE_QUAL_CONST));
3277
3278 /* This is special for C++ so functions can be overloaded. */
3279 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3280 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3281 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3282 if (c_dialect_cxx ())
3283 {
3284 if (TREE_UNSIGNED (wchar_type_node))
3285 wchar_type_node = make_unsigned_type (wchar_type_size);
3286 else
3287 wchar_type_node = make_signed_type (wchar_type_size);
3288 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3289 }
3290 else
3291 {
3292 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3293 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3294 }
3295
3296 /* This is for wide string constants. */
3297 wchar_array_type_node
3298 = build_array_type (wchar_type_node, array_domain_type);
3299
3300 wint_type_node =
3301 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3302
3303 intmax_type_node =
3304 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3305 uintmax_type_node =
3306 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3307
3308 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3309 ptrdiff_type_node
3310 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3311 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3312
3313 (*lang_hooks.decls.pushdecl)
3314 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3315 va_list_type_node));
3316
3317 (*lang_hooks.decls.pushdecl)
3318 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3319 ptrdiff_type_node));
3320
3321 (*lang_hooks.decls.pushdecl)
3322 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3323 sizetype));
3324
3325 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3326 {
3327 va_list_arg_type_node = va_list_ref_type_node =
3328 build_pointer_type (TREE_TYPE (va_list_type_node));
3329 }
3330 else
3331 {
3332 va_list_arg_type_node = va_list_type_node;
3333 va_list_ref_type_node = build_reference_type (va_list_type_node);
3334 }

At line 3308, default_function_type stands for C’s assuming implicit declared function of type int ()(). And at line 3314, __builtin_va_list is the builtin (that is the self-defined by compiler) type declaraton of va_list (via the way similar with typedef), similarly are __builtin_ptrdiff_t and __builtin_size_t.