Studying note of GCC-3.4.6 source (133)

5.12.5.2.2.2.1.3.    Generate RECORD_TYPE for the instantiation

At last, at line 10181 in cp_parser_init_declarator , cp_finish_decl closes the declaration. As it is the declaration within a function, a new DECL_STMT is inserted into the stmt-tree at line 4957 below, and after that we gets following intermediate tree.

(Click here for open )

 

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

 

Next it needs complete the definition of the type and the declaration as layout_var_decl in below.

 

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   }

 

At here, type is the RECORD_TYPE just created above, and decl is a non-external declaration. So type is already defined within this translation-unit, and can be completed now.

 

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    }

 

For template definition, a new type is generated at point of instantiation. And the new type’s definition is completed at that point too (it is a incomplete type because its TREE_SIZE field is 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;

 

Note that at line 5320 above, pattern refers to the RECORD_TYPE of the most general template (i.e., “SmallObject” in the template definition), its TYPE_SIZE field is initialized as bitsize_zero_node and size_zero_node in finish_struct for class template definition. At line 5299, most_specialized_class returns the matching most specialized defintion, and in case of no matching or no defining specialization returns NULL.

Though in therory the level of instantiation depth is unlimited, but in implementation it must prevent infinite template instantiation due to mistaken in program or implementation. This instantiation level must be restricted. In GCC, version 3.4.6, global variable max_tinst_depth holds this limitation. Its value now is 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   }

 

Above at line 4872, tree node of EXPR_WITH_FILE_LOCATION is generated to record the file and the line number at point of instantiation. And this node is chained into the global list current_tinst_level for diagnosis purpose.

 

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

 

Note that above pattern refers to the RECORD_TYPE generated from the template defintion, while type points to the RECORD_TYPE created at instantiation. Then during instantiation, we need enter the scope the class and its bases (if there is any), which will change the current scope. So at first step, we need return back to the top level of binding scope – global namespace (push_to_top_level at line 5339) and cache the current scope. In below, push_scope and pushclass will build appropriate context for us (see that context of type and pattern are both NAMESPACE_DECL of “Loki” – every instantiation is regarded as a variant within the same context).

 

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     }