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

5.12.5.2.2.2.1.3.    为具现构建 RECORD_TYPE

最后，在 cp_parser_init_declarator 的 10181 行， cp_finish_decl 完成这个声明。因为它是在一个函数中的声明，在下面 4957 行，一个新的 DECL_STMT 被插入到对应的 stmt-tree ，之后我们得到如下的中间树。

（ 点此打开 ）

 

4786   void

4787   cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)                           in decl.c

4788   {

4789     tree type;

4790     tree ttype = NULL_TREE;

4791     tree cleanup;

4792     const char *asmspec = NULL;

4793     int was_readonly = 0;

4794     bool var_definition_p = false;

4795  

4796     if (decl == error_mark_node)

4797       return ;

4798     else if (! decl)

4799     {

4800       if (init)

4801         error ("assignment (not initialization) in declaration");

4802       return ;

4803     }

4804  

4805     my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619);

        …

4821     type = TREE_TYPE (decl);

        …

4844     /* Parameters are handled by store_parm_decls, not cp_finish_decl.  */

4845     my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);

        …

4953     /* Add this declaration to the statement-tree. This needs to happen

4954       after the call to check_initializer so that the DECL_STMT for a

4955       reference temp is added before the DECL_STMT for the reference itself.  */

4956     if (at_function_scope_p ())

4957       add_decl_stmt (decl);

4958  

4959     if (TREE_CODE (decl) == VAR_DECL)

4960       layout_var_decl (decl);

 

接下来需要由下面的 layout_var_decl 来完成该类型的定义。

 

4043   static void

4044   layout_var_decl (tree decl)                                                                                     in decl.c

4045   {

4046     tree type = TREE_TYPE (decl);

4047   #if 0

4048     tree ttype = target_type (type);

4049   #endif

4050  

4051     /* If we haven't already layed out this declaration, do so now.

4052        Note that we must not call complete type for an external object

4053        because it's type might involve templates that we are not

4054        supposed to instantiate yet.  (And it's perfectly valid to say

4055        `extern X x' for some incomplete type `X'.)  */

4056     if (!DECL_EXTERNAL (decl))

4057       complete_type (type);

4058     if (!DECL_SIZE (decl)

4059         && TREE_TYPE (decl) != error_mark_node

4060         && (COMPLETE_TYPE_P (type)

4061             || (TREE_CODE (type) == ARRAY_TYPE

4062               && !TYPE_DOMAIN (type)

4063               && COMPLETE_TYPE_P (TREE_TYPE (type)))))

4064       layout_decl (decl, 0);

4065  

4066     if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)

4067     {

4068       /* An automatic variable with an incomplete type: that is an error.

4069         Don't talk about array types here, since we took care of that

4070         message in grokdeclarator.  */

4071       error ("storage size of `%D' isn't known", decl);

4072       TREE_TYPE (decl) = error_mark_node;

4073     }

4074   #if 0

       …

4084   #endif

4085  

4086     if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))

4087         && DECL_SIZE (decl) != NULL_TREE

4088         && ! TREE_CONSTANT (DECL_SIZE (decl)))

4089     {

4090       if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)

4091         constant_expression_warning (DECL_SIZE (decl));

4092       else

4093         error ("storage size of `%D' isn't constant", decl);

4094     }

4095  

4096     if (TREE_STATIC (decl)

4097         && !DECL_ARTIFICIAL (decl)

4098         && current_function_decl

4099         && DECL_CONTEXT (decl) == current_function_decl )

4100       push_local_name (decl);

4101   }

 

在这里， type 是刚创建的 RECORD_TYPE ，而 decl 是一个非外部声明（ non-external declaration ）。因此 type 应该已经在这个编译单元中定义，现在可以完成其定义了。

 

116     tree

117     complete_type (tree type)                                                                         in typeck.c

118     {

119       if (type == NULL_TREE)

120        /* Rather than crash, we return something sure to cause an error

121          at some point.  */

122        return error_mark_node;

123   

124      if (type == error_mark_node || COMPLETE_TYPE_P (type))

125        ;

126      else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))

127      {

128        tree t = complete_type (TREE_TYPE (type));

129        if (COMPLETE_TYPE_P (t) && !dependent_type_p (type))

130          layout_type (type);

131        TYPE_NEEDS_CONSTRUCTING (type)

132           = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));

133        TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)

134           = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (t));

135      }

136      else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INSTANTIATION (type))

137        instantiate_class_template (TYPE_MAIN_VARIANT (type));

138   

139      return type;

140    }

 

对于模板定义，在具现点生成一个新类型。该新类型的定义也在该点完毕（因为其 TREE_SIZE 域是 NULL ，这是一个不完整的类型）。

 

5274   tree

5275   instantiate_class_template (tree type)                                                                in pt.c

5276   {

5277     tree template, args, pattern, t, member;

5278     tree typedecl;

5279     tree pbinfo;

5280    

5281     if (type == error_mark_node)

5282       return error_mark_node;

5283  

5284     if (TYPE_BEING_DEFINED (type)

5285         || COMPLETE_TYPE_P (type)

5286         || dependent_type_p (type))

5287       return type;

5288  

5289     /* Figure out which template is being instantiated.  */

5290     template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));

5291     my_friendly_assert (TREE_CODE (template) == TEMPLATE_DECL, 279);

5292  

5293     /* Figure out which arguments are being used to do the

5294       instantiation.  */

5295     args = CLASSTYPE_TI_ARGS (type);

5296  

5297     /* Determine what specialization of the original template to

5298       instantiate.  */

5299     t = most_specialized_class (template, args);

5300     if (t == error_mark_node)

5301     {

          …

5315     }

5316  

5317     if (t)

5318       pattern = TREE_TYPE (t);

5319     else

5320       pattern = TREE_TYPE (template);

5321  

5322     /* If the template we're instantiating is incomplete, then clearly

5323       there's nothing we can do.  */

5324     if (!COMPLETE_TYPE_P (pattern))

5325       return type;

5326  

5327     /* If we've recursively instantiated too many templates, stop.  */

5328     if (! push_tinst_level (type))

5329       return type;

5330  

5331     /* Now we're really doing the instantiation. Mark the type as in

5332       the process of being defined.  */

5333     TYPE_BEING_DEFINED (type) = 1;

 

注意到在上面的 5320 行， pattern 指向最泛化模板所对应的 RECORD_TYPE （也即模板定义中出现的“ SmallObject ”），其 TYPE_SIZE 域在 finish_struct 中被初始化为 bitsize_zero_node 及 size_zero_node 。 5299 行的 most_specialized_class 返回匹配的特化程度最高的定义，找不到或没有特化的定义则返回 NULL 。

虽然在理论上具现的层数是没有限制的，但是在实现中必须防止由于编程或者实现的失误而导致的无限模板具现。这样具现的层数必须是有限制的。在 GCC ，版本 3.4.6 中，全局变量 max_tinst_depth 保存这个限制。其值现在是 500 。

 

4850   int

4851   push_tinst_level (tree d)                                                                                  in pt.c

4852   {

4853     tree new;

4854  

4855     if (tinst_depth >= max_tinst_depth )

4856     {

4857       /* If the instantiation in question still has unbound template parms,

4858         we don't really care if we can't instantiate it, so just return.

4859         This happens with base instantiation for implicit `typename'.  */

4860       if (uses_template_parms (d))

4861         return 0;

4862  

4863       last_template_error_tick = tinst_level_tick ;

4864       error ("template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'",

4865              max_tinst_depth , d);

4866  

4867       print_instantiation_context ();

4868  

4869       return 0;

4870     }

4871  

4872     new = build_expr_wfl (d, input_filename, input_line, 0);

4873     TREE_CHAIN (new) = current_tinst_level ;

4874     current_tinst_level = new;

4875  

4876     ++tinst_depth ;

4877   #ifdef GATHER_STATISTICS

4878     if (tinst_depth > depth_reached )

4879       depth_reached = tinst_depth ;

4880   #endif

4881  

4882     ++tinst_level_tick ;

4883     return 1;

4884   }

 

上面在 4872 行，节点 EXPR_WITH_FILE_LOCATION 被构建来记录具现所在的文件及行数。并且这个节点被串接入全局链表 current_tinst_level 用于诊断的目的。

 

instantiate_class_template (continue)

 

5335     /* We may be in the middle of deferred access check. Disable

5336       it now.  */

5337     push_deferring_access_checks (dk_no_deferred);

5338  

5339     push_to_top_level ();

5340  

5341     if (t)

5342     {

          …

5367     }

5368  

5369     SET_CLASSTYPE_INTERFACE_UNKNOWN (type);

5370  

5371     /* Set the input location to the template definition. This is needed

5372       if tsubsting causes an error.  */

5373     input_location = DECL_SOURCE_LOCATION (TYPE_NAME (pattern));

5374  

5375     TYPE_HAS_CONSTRUCTOR (type) = TYPE_HAS_CONSTRUCTOR (pattern);

5376     TYPE_HAS_DESTRUCTOR (type) = TYPE_HAS_DESTRUCTOR (pattern);

5377     TYPE_HAS_NEW_OPERATOR (type) = TYPE_HAS_NEW_OPERATOR (pattern);

5378     TYPE_HAS_ARRAY_NEW_OPERATOR (type) = TYPE_HAS_ARRAY_NEW_OPERATOR (pattern);

5379     TYPE_GETS_DELETE (type) = TYPE_GETS_DELETE (pattern);

5380     TYPE_HAS_ASSIGN_REF (type) = TYPE_HAS_ASSIGN_REF (pattern);

5381     TYPE_HAS_CONST_ASSIGN_REF (type) = TYPE_HAS_CONST_ASSIGN_REF (pattern);

5382     TYPE_HAS_ABSTRACT_ASSIGN_REF (type) = TYPE_HAS_ABSTRACT_ASSIGN_REF (pattern);

5383     TYPE_HAS_INIT_REF (type) = TYPE_HAS_INIT_REF (pattern);

5384     TYPE_HAS_CONST_INIT_REF (type) = TYPE_HAS_CONST_INIT_REF (pattern);

5385     TYPE_HAS_DEFAULT_CONSTRUCTOR (type) = TYPE_HAS_DEFAULT_CONSTRUCTOR (pattern);

5386     TYPE_HAS_CONVERSION (type) = TYPE_HAS_CONVERSION (pattern);

5387     TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)

5388       = TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (pattern);

5389     TYPE_USES_MULTIPLE_INHERITANCE (type)

5390       = TYPE_USES_MULTIPLE_INHERITANCE (pattern);

5391     TYPE_USES_VIRTUAL_BASECLASSES (type)

5392       = TYPE_USES_VIRTUAL_BASECLASSES (pattern);

5393     TYPE_PACKED (type) = TYPE_PACKED (pattern);

5394     TYPE_ALIGN (type) = TYPE_ALIGN (pattern);

5395     TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (pattern);

5396     TYPE_FOR_JAVA (type) = TYPE_FOR_JAVA (pattern); /* For libjava's JArray<T> */

5397     if (ANON_AGGR_TYPE_P (pattern))

5398       SET_ANON_AGGR_TYPE_P (type);

 

注意上面的 pattern 对应着模板定义中的 RECORD_TYPE ，而 type 对应具现时刻产生的 RECORD_TYPE 。在具现的过程中，我们需要进入具现类型及其子类（如果有子类的话）的作用域，这将改变当前的作用域。因此在第一步，我们需要跑到绑定域的顶层——全局名字空间（ 5339 行的 push_to_top_level ），并缓存当前的作用域层次，由下面的 push_scope 及 pushclass 为我们构建合适的上下文（注意这里的 type 及 pattern 的 context 都是“ Loki ”的 NAMESPACE_DECL ——具现的类型被视为在同一作用域下不同的变种）。

 

instantiate_class_template (continue)

 

5400     pbinfo = TYPE_BINFO (pattern);

5401  

5402   #ifdef ENABLE_CHECKING

5403     if (DECL_CLASS_SCOPE_P (TYPE_MAIN_DECL (pattern))

5404         && ! COMPLETE_TYPE_P (TYPE_CONTEXT (type))

5405          && ! TYPE_BEING_DEFINED (TYPE_CONTEXT (type)))

5406       /* We should never instantiate a nested class before its enclosing

5407         class; we need to look up the nested class by name before we can

5408         instantiate it, and that lookup should instantiate the enclosing

5409         class.  */

5410       abort ();

5411   #endif

5412  

5413     if (BINFO_BASETYPES (pbinfo))

5414     {

5415       tree base_list = NULL_TREE;

5416       tree pbases = BINFO_BASETYPES (pbinfo);

5417       tree paccesses = BINFO_BASEACCESSES (pbinfo);

5418       tree context = TYPE_CONTEXT (type);

5419       bool pop_p;

5420       int i;

5421  

5422       /* We must enter the scope containing the type, as that is where

5423         the accessibility of types named in dependent bases are

5424         looked up from.  */

5425       pop_p = push_scope (context ? context : global_namespace );

5426    

5427       /* Substitute into each of the bases to determine the actual

5428         basetypes.  */

5429       for (i = 0; i < TREE_VEC_LENGTH (pbases); ++i)

5430       {

5431         tree base;

5432         tree access;

5433         tree pbase;

5434  

5435         pbase = TREE_VEC_ELT (pbases, i);

5436         access = TREE_VEC_ELT (paccesses, i);

5437  

5438         /* Substitute to figure out the base class.  */

5439         base = tsubst (BINFO_TYPE (pbase), args, tf_error, NULL_TREE);

5440         if (base == error_mark_node)

5441           continue ;

5442     

5443         base_list = tree_cons (access, base, base_list);

5444         TREE_VIA_VIRTUAL (base_list) = TREE_VIA_VIRTUAL (pbase);

5445       }

5446  

5447       /* The list is now in reverse order; correct that.  */

5448       base_list = nreverse (base_list);

5449  

5450       /* Now call xref_basetypes to set up all the base-class

5451         information.  */

5452       xref_basetypes (type, base_list);

5453  

5454       if (pop_p)

5455         pop_scope (context ? context : global_namespace );

5456     }