Studying note of GCC-3.4.6 source (64)

4.3.1.7.8.            Finish initialization

Below abort_fndecl represents function abort, and function build_library_fn_ptr like build_library_fn, but takes a C string instead of an IDENTIFIER_NODE.

 

cxx_init_decl_processing (continue)

 

3115     abort_fndecl

3116       = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);

3117

3118     /* Perform other language dependent initializations.  */

3119     init_class_processing ();

3120     init_search_processing ();

3121     init_rtti_processing ();

3122  

3123     if (flag_exceptions)

3124       init_exception_processing ();

3125  

3126     if (! supports_one_only ())

3127       flag_weak = 0;

3128  

3129     make_fname_decl = cp_make_fname_decl;

3130     start_fname_decls ();

3131  

3132     /* Show we use EH for cleanups.  */

3133     using_eh_for_cleanups ();

3134  

3135     /* Maintain consistency. Perhaps we should just complain if they

3136     say -fwritable-strings?  */

3137     if (flag_writable_strings)

3138       flag_const_strings = 0;

3139   }

4.3.1.7.8.1.      Initialize class processing

During handling class declaration, GCC uses following global variables to control the process. Among them, current_class_depth indicates the level of the nesting, and the classes nesting form a stack current_class_stack, which uses current_class_stack_size to tell the size. GNU C++ has an extension, allows class being defined within function body, which can only be visible there. To discriminate the class from others, the class is saved by local_classes.

 

5424   void

5425   init_class_processing (void)                                                                      in class.c

5426   {

5427     current_class_depth = 0;

5428     current_class_stack_size = 10;

5429     current_class_stack

5430       = xmalloc (current_class_stack_size * sizeof (struct class_stack_node));

5431     VARRAY_TREE_INIT (local_classes, 8, "local_classes");

5432  

5433     ridpointers[(int) RID_PUBLIC] = access_public_node;

5434     ridpointers[(int) RID_PRIVATE] = access_private_node;

5435     ridpointers[(int) RID_PROTECTED] = access_protected_node;

5436   }

 

And search_obstack initialized below is useless in current version, and has been removed in V4.

 

2346   void

2347   init_search_processing (void)                                                                   in search.c

2348   {

2349     gcc_obstack_init (&search_obstack);

2350   }

4.3.1.7.8.2.      Runtime type identification (RTTI)

4.3.1.7.8.2.1.              Create TYPE_DECL

To support RTTI (runtime type identification) which allows programs that manipulate objects as pointers or references to base classes to retrieve the actual derived types of the objects to which these pointers or references refer, GCC offers two operators: dynamic_cast and typeid. The returned type of typeid is type_info, and the definition of type_info is implement dependent. Here in the initialization of RTTI, unlike std::bad_alloc, full definition will be created as this type is expected by runtime environment.

 

115     void

116     init_rtti_processing (void)                                                                               in rtti.c

117     {

118       tree const_type_info_type;

119    

120      push_namespace (std_identifier);

121      type_info_type_node

122        = xref_tag (class_type, get_identifier ("type_info"),

123                 true, false);

124      pop_namespace ();

125      const_type_info_type = build_qualified_type (type_info_type_node,

126                                            TYPE_QUAL_CONST);

127      type_info_ptr_type = build_pointer_type (const_type_info_type);

128      type_info_ref_type = build_reference_type (const_type_info_type);

129   

130      VARRAY_TREE_INIT (unemitted_tinfo_decls, 10, "RTTI decls");

131   

132      create_tinfo_types ();

133    }

 

Now xref_tag tries to get the struct, enum or union (tag_code says which) with name. Defines the tag as a forward-reference if it is not defined.

If argument globalize is false, it means the identifier name is a definition. In C++, it first allows to define types of same name in different binding scope; second, in the same binding scope, different types of same name is an error unless the definitions are identical. At line 9476, lookup_tag tries to find out the type definition specified by code and name within binding scope referred by b. We will see the detail of the function later.

While if globalize is true, the tag is just type declaration. In C++, we can use the reference of an undefined user defining types restrictly by just declare it. For example,

class A;

A* pa = NULL;

Within GCC, when it finds that nothing can be found, it will create a fake type (remember std::bad_alloc), then declares implicit typedef for it and pushes TYPE_DECL created by implicit typedef within specified binding scope. Thus the forward declaration in fact refers to this TYPE_DECL, then later when the real definition encountered, the corresponding type node (of RECORD_TYPE/UNION_TYPE/ ENUMERAL_TYPE) is updated accordingly. And while GCC finds existing type declaration (no fake type), special handling is needed when the declaration relates to generic programing, we will see it shortly.

 

9443   tree

9444   xref_tag (enum tag_types tag_code, tree name,                                                         in decl.c

9445          bool globalize, bool template_header_p)

9446   {

9447     enum tree_code code;

9448     tree t;

9449     struct cp_binding_level *b = current_binding_level;

9450     tree context = NULL_TREE;

9451  

9452     timevar_push (TV_NAME_LOOKUP);

9453  

9454     my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);

9455  

9456     switch (tag_code)

9457     {

9458       case record_type:

9459       case class_type:

9460         code = RECORD_TYPE;

9461         break;

9462       case union_type:

9463         code = UNION_TYPE;

9464         break;

9465       case enum_type:

9466         code = ENUMERAL_TYPE;

9467         break;

9468       default:

9469         abort ();

9470     }

9471  

9472     if (! globalize)

9473     {

9474       /* If we know we are defining this tag, only look it up in

9475         this scope and don't try to find it as a type.  */

9476       t = lookup_tag (code, name, b, 1);

9477     }

9478     else

9479     {

9480       tree decl = lookup_name (name, 2);

 

Here globalize is true, it uses lookup_name to find out the type declaration as the second argument indicates to reject non-type declarations. lookup_name is a complex function, we skip it here temporary to not to make the procedure too long. For out case here, lookup_name should returns NULL as it must be the first to declare this type.

 

xref_tag (continue)

 

9558     if (! t)

9559     {

9560       /* If no such tag is yet defined, create a forward-reference node

9561         and record it as the "definition".

9562         When a real declaration of this type is found,

9563         the forward-reference will be altered into a real type.  */

9564       if (code == ENUMERAL_TYPE)

9565       {

9566         error ("use of enum `%#D' without previous declaration", name);

9567         POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);

9568       }

9569       else

9570       {

9571         t = make_aggr_type (code);

9572         TYPE_CONTEXT (t) = context;

9573         pushtag (name, t, globalize);

9574       }

9575     }

9576    else

9577     {

          ...

9587     }

9588  

9589     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);

9590   }

 

As the tag should not be found by lookup_name at line 9480, a node will be created for it. And as argument tag_code is class_type, the node should be RECORD_TYPE, and its context is first set as empty (see NULL_TREE at line 9450).

 

4589   void

4590   pushtag (tree name, tree type, int globalize)                                        in name-lookup.c

4591   {

4592     struct cp_binding_level *b;

4593  

4594     timevar_push (TV_NAME_LOOKUP);

4595     b = current_binding_level;

4596     while (/* Cleanup scopes are not scopes from the point of view of

4597             the language.  */

4598       b->kind == sk_cleanup

4599       /* Neither are the scopes used to hold template parameters

4600         for an explicit specialization. For an ordinary template

4601         declaration, these scopes are not scopes from the point of

4602         view of the language -- but we need a place to stash

4603         things that will go in the containing namespace when the

4604         template is instantiated.  */

4605       || (b->kind == sk_template_parms && b->explicit_spec_p)

4606       || (b->kind == sk_class

4607         && (globalize

4608           /* We may be defining a new type in the initializer

4609             of a static member variable. We allow this when

4610             not pedantic, and it is particularly useful for

4611             type punning via an anonymous union.  */

4612           || COMPLETE_TYPE_P (b->this_entity))))

4613       b = b->level_chain;

4614  

4615     if (b->type_decls == NULL)

4616       b->type_decls = binding_table_new (SCOPE_DEFAULT_HT_SIZE);

4617     binding_table_insert (b->type_decls, name, type);

 

pushtag first pushes type definition into current namespace. As we have seen, user defined type definition within a binding scope, is kept at field type_decls of the corresponding cp_binding_level. Below binding_table_insert handles the detail.

 

190    static void

191    binding_table_insert (binding_table table, tree name, tree type)             in name-lookup.c

192    {

193      const unsigned int hash = IDENTIFIER_HASH_VALUE (name);

194      const size_t i = ENTRY_INDEX (hash, table->chain_count);

195      binding_entry entry = binding_entry_make (name, type);

196   

197      entry->chain = table->chain[i];

198      table->chain[i] = entry;

199      ++table->entry_count;

200   

201      if (3 * table->chain_count < 5 * table->entry_count)

202        binding_table_expand (table);

203    }

 

Notice that type_decls in fact is a hashtable, all type definitions have the same hash value will be linked tegother. To control the length of the list, if the number of lists (field chain_count) has following relation with number of entries (field entry_count): 3*table->chain_count < 5*table->entry_count, binding_table_expand will expand the number of lists by double and rehash and relink types recorded.

 

67      static inline binding_entry

68      binding_entry_make (tree name, tree type)                                                 in name-lookup.c

69      {

70        binding_entry entry;

71     

72        if (free_binding_entry)

73        {

74          entry = free_binding_entry;

75          free_binding_entry = entry->chain;

76        }

77        else

78          entry = ggc_alloc (sizeof (struct binding_entry_s));

79     

80        entry->name = name;

81        entry->type = type;

82        entry->chain = NULL;

83     

84        return entry;

85      }

 

In above binding_entry_make, though the identifier is associated with the type definition within an instance of binding_entry, however the node of identifier has not bound with TYPE_DECL, so in below IDENTIFIER_TYPE_VALUE returns NULL.

 

1700   tree

1701   identifier_type_value (tree id)                                                           in name-lookup.c

1702   {

1703     timevar_push (TV_NAME_LOOKUP);

1704     /* There is no type with that name, anywhere.  */

1705     if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)

1706       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);

1707     /* This is not the type marker, but the real thing.  */

1708     if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)

1709       POP_TIMEVAR_AND_RETURN(TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));

1710    /* Have to search for it. It must be on the global level, now.

1711       Ask lookup_name not to return non-types.  */

1712     id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);

1713     if (id)

1714       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));

1715     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);

1716   }

 

IDENTIFIER_TYPE_VALUE is just another name of identifier_type_value. Here in our case, REAL_IDENTIFIER_TYPE_VALUE should return NULL_TREE while type at line 4622 below is the RECORD_TYPE node just generated.

 

pushtag (continue)

 

4619     if (name)

4620     {

4621       /* Do C++ gratuitous typedefing.  */

4622      if (IDENTIFIER_TYPE_VALUE (name) != type)

4623       {

4624         tree d = NULL_TREE;

4625         int in_class = 0;

4626         tree context = TYPE_CONTEXT (type);

4627  

4628         if (! context)

4629         {

4630           tree cs = current_scope ();

4631  

4632           if (! globalize)

4633            context = cs;

4634           else if (cs != NULL_TREE && TYPE_P (cs))

4635             /* When declaring a friend class of a local class, we want

4636               to inject the newly named class into the scope

4637               containing the local class, not the namespace scope.  */

4638             context = decl_function_context (get_type_decl (cs));

4639         }

4640         if (!context)

4641           context = current_namespace;

4642  

4643         if (b->kind == sk_class

4644            || (b->kind == sk_template_parms

4645              && b->level_chain->kind == sk_class))

4646           in_class = 1;

4647  

4648         if (current_lang_name == lang_name_java)

4649           TYPE_FOR_JAVA (type) = 1;

4650  

4651         d = create_implicit_typedef (name, type);

4652         DECL_CONTEXT (d) = FROB_CONTEXT (context);

4653         if (! in_class)

4654           set_identifier_type_value_with_scope (name, d, b);

 

Remember that the type context is NULL, so at line 4630, current_scope is invoked. It is a macro selects between current_function_decl and current_class_type accordingly, which always returns NULL for namespace scope. Then as we are within std namespace, it sets the context with current namespace scope at line 4641.

Next at line 4651, a TYPE_DECL node is created for the type by create_implicit_typedef. Then in set_identifier_type_value_with_scope, this TYPE_DECL node (not type definition) will be recorded into field namespace_bindings of the node of identifier.

 

1731   static void

1732   set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)        in name-lookup.c

1733   {

1734     tree type;

1735  

1736     if (b->kind != sk_namespace)

1737     {

1738       /* Shadow the marker, not the real thing, so that the marker

1739         gets restored later.  */

1740       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);

1741       b->type_shadowed

1742          = tree_cons (id, old_type_value, b->type_shadowed);

1743       type = decl ? TREE_TYPE (decl) : NULL_TREE;

1744     }

1745     else

1746     {

1747       cxx_binding *binding =

1748           binding_for_name (NAMESPACE_LEVEL (current_namespace), id);

1749       if (decl)

1750       {

1751         if (binding->value)

1752           supplement_binding (binding, decl);

1753         else

1754           binding->value = decl;

1755       }

1756       else

1757         abort ();

1758       /* Store marker instead of real type.  */

1759       type = global_type_node;

1760     }

1761     SET_IDENTIFIER_TYPE_VALUE (id, type);

1762   }

 

Above the assignment operation at line 1754, sets the declaration (it’s a type declaratoin) for the identifier currently matching. From then no, in current scope, the identifier stands for this type.

 

pushtag (continue)

 

4656         d = maybe_process_template_type_declaration (type,

4657                                                globalize, b);

4658  

4659         if (b->kind == sk_class)

4660         {

4661           if (!PROCESSING_REAL_TEMPLATE_DECL_P ())

4662             /* Put this TYPE_DECL on the TYPE_FIELDS list for the

4663               class. But if it's a member template class, we

4664               want the TEMPLATE_DECL, not the TYPE_DECL, so this

4665               is done later.  */

4666             finish_member_declaration (d);

4667           else

4668             pushdecl_class_level (d);

4669         }

4670         else

4671           d = pushdecl_with_scope (d, b);

4672  

4673         /* FIXME what if it gets a name from typedef?  */

4674         if (ANON_AGGRNAME_P (name))

4675           DECL_IGNORED_P (d) = 1;

4676  

4677         TYPE_CONTEXT (type) = DECL_CONTEXT (d);

4678  

4679         /* If this is a local class, keep track of it. We need this

4680           information for name-mangling, and so that it is possible to find

4681           all function definitions in a translation unit in a convenient

4682           way. (It's otherwise tricky to find a member function definition

4683           it's only pointed to from within a local class.)  */

4684         if (TYPE_CONTEXT (type)

4685            && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL

4686            && !processing_template_decl)

4687           VARRAY_PUSH_TREE (local_classes, type);

4688       }

4689       if (b->kind == sk_class

4690           && !COMPLETE_TYPE_P (current_class_type))

4691       {

4692         maybe_add_class_template_decl_list (current_class_type,

4693                                        type, /*friend_p=*/0);

4694         CLASSTYPE_NESTED_UTDS (current_class_type) = b->type_decls;

4695       }

4696     }

4697  

4698     if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)

4699       /* Use the canonical TYPE_DECL for this node.  */

4700       TYPE_STUB_DECL (type) = TYPE_NAME (type);

4701     else

4702     {

4703       /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE

4704         will be the tagged type we just added to the current

4705         binding level. This fake NULL-named TYPE_DECL node helps

4706         dwarfout.c to know when it needs to output a

4707         representation of a tagged type, and it also gives us a

4708         convenient place to record the "scope start" address for

4709         the tagged type.  */

4710  

4711       tree d = build_decl (TYPE_DECL, NULL_TREE, type);

4712       TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);

4713     }

4714     timevar_pop (TV_NAME_LOOKUP);

4715   }

 

Now we have already inserted the type definition (RECORD_TYPE node) into the binding scope, tegother with the corresponding TYPE_DECL node inserted into the binding list of identifier. Below at line 1960, pushdecl just invokes add_decl_to_level to add the TYPE_DECL into names field of the cxx_scope.

 

1941   tree

1942   pushdecl_with_scope (tree x, cxx_scope *level)                                   in name-lookup.c

1943   {

1944     struct cp_binding_level *b;

1945     tree function_decl = current_function_decl;

1946  

1947     timevar_push (TV_NAME_LOOKUP);

1948     current_function_decl = NULL_TREE;

1949     if (level->kind == sk_class)

1950     {

1951       b = class_binding_level;

1952       class_binding_level = level;

1953       pushdecl_class_level (x);

1954       class_binding_level = b;

1955     }

1956     else

1957     {

1958      b = current_binding_level;

1959       current_binding_level = level;

1960       x = pushdecl (x);

1961       current_binding_level = b;

1962     }

1963     current_function_decl = function_decl;

1964     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);

1965   }

 

type_info in fact is a type series, in which compiler selects according to the class structure. And classes of the same structure would use the same type_info type, but different instances. Thus when encountering type_info usage, the compiler won’t urgently construct the instance but postpone till the front-end finally finish this compilation-unit and construct with batch. The cache for these type_infos is unemitted_tinfo_decls at line 130 in init_rtti_processing