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

4.3.1.7.5.3.      其他内建类型节点

c_common_nodes_and_builtins接下来的代码如下：

 

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.              常用常量的节点

在编译器内部，常量如：0，1，3等也必须是树节点形式（在前端为前端树的形式，在后端为rtx节点）。因此，编译器将创建相应的，唯一的节点。现在，整型类型节点已经好了，具有这些类型的常用的常量的节点就可以创建了。注意size_NUM_node表示NUM字节的大小，而bitsize_NUM_node表示NUM比特的大小。

 

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

 

null_pointer_node的创建很有意思。首先创建一个由0填充的integer_type_node节点，它的type被设置为void_type_node的指针类型——这等同于(void*)0。对于void*是ptr_type_node，而对于const void*是const_ptr_type_node，通过build_type_variant，从ptr_type_node创建出来。

 

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

 

注意到把2306及2307行接起来的操作符是“|”，这表示const和volatile可以一起用。

 

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   }

 

cv-qualified和cv-unqualified类型被链接在一起，并且cv-unqualified类型位于链表头。在创建cv-qualified类型之前，我们要确认其尚未被创建。

 

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   }

 

为了创建cv-qualified类型，我们采用类型拷贝，不过pointer_to及reference_to域都不做拷贝，要在相应的指针及引用类型构建出来后，它们才能得到填充。

 

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   }

 

然后cv-qualifier的信息被存入创建的节点。

 

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   }

 

接下来，浮点及复数类型节点的创建与整型类型没有什么不同。浮点数的细节，参考创建浮点常量节点。

 

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

 

4942~4945行还准备了指针类型的节点。

4.3.1.7.5.3.2.              va_list类型节点

在C/C++中，当在函数中使用“…”作为参数时，需要一个特别的对象va_list，如下例。

 

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是一个特殊的类型，它被传递给va_start，va_arg及va_end，这个类型由编译器负责创建。这在接下来的build_common_tree_nodes_2中。

 

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     }

 

显然，va_list的实际类型取决于机器（这进一步确定其所在的库），不同的机器架构会有不同的方案。对于x86机器，build_builtin_va_list实际引用x86_build_builtin_va_list。

 

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   }

 

对于32位的x86机器，va_list实际上是char*。而对于64位x86机器，va_list是一个名为__va_list_tag的结构体（这里省略了这部分代码）。

4.3.1.7.5.3.3.              Vector类型节点

在图形、视频这样的多媒体应用中，大量使用了矩阵运算。作为一种优化，例如，32位x86体系的CPU中引入了128位的寄存器，这样一个寄存器就可以存放4个长整形数或单精度浮点数，配合专门的指令（如SSE1，SSE2指令集，具体寄存器的类型、数量，参见初始化寄存器集），可以大大加快多媒体的处理。这样一个寄存器中存放多个数值的形式，称为vector，以区别于数组。

在下面，模式名开头的V[num]指出了该vector包含了num个数值，而这些数值的模式是XXmode（那么vector的长度是：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   }

 

函数make_vector专用于创建vector类型的节点。对于x86机器，没有别的地方使用它。

 

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   }

 

Vector类型的另一种表示形式是RECORD_TYPE，例如，对于V16QI_type_node，其另一种表示形式就像：

RECORD_TYPE {

        Field:

               QI/*array_type*/ f [15/*index_type*/]

}

章节创建索引节点及创建数组类型节点描述了ARRAY_TYPE和数组索引的过程。

 

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   }

 

在c_common_nodes_and_builtins中接下来的节点是为Fortran创建的，我们跳过这些代码。之后，在3249行，创建了void类型，3251行为((void) 0)节点，而void_list_node是2个void_type_node组成的链表。下面的char_array_type_node及wchar_array_type_node，只用在lexer中，来临时区分传入字符串为wchar_t抑或char。而int_array_type_node 则尚无用处。

 

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     }

 

在3308行的default_function_type代表C中的隐式声明的函数类型 “int ()()”。而3314行的__builtin_va_list则是内建的（即编译器自带）va_list类型声明（类似typedef），同样还有__builtin_ptrdiff_t及 __builtin_size_t。