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

4.3.1.7.8.            完成初始化

下面的 abort_fndecl 代表函数 abort ，而函数 build_library_fn_ptr 与 build_library_fn 相仿，不过它接受字符串作为名字，而不是标识符节点。

 

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.  初始化类处理参数

在处理类声明时， GCC 使用以下的全局变量来控制其处理过程。其中 current_class_depth 表示当前类的嵌套深度，这些嵌套的类毫无疑问构成了一个栈，这就是 current_class_stack ，而 current_class_stack_size 就是栈的当前大小。 GNU C++ 有一个扩展，允许在函数体中定义类，当然这个类只能在该函数体内可见，为了与其他类区别，它们被保存在 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   }

 

而下面所初始化的 search_obstack 在当前版本中已没有用处，在 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.      运行时类型识别 RTTI

4.3.1.7.8.2.1.              构建 TYPE_DECL 节点

运行时类型识别（ runtime type identification ， RTTI ）允许操纵基类的指针或引用对象，来获取该指针或引用对象的实际派生类型。为了支持 RTTI ， GCC 提供了 2 个操作符： typeid 和 dynamic_cast 。 typeid 的返回类型是 type_info ，而 type_info 的定义是依赖于实现的。在这里对 RTTI 的初始化中，不像 std::bad_alloc ，必须创建完整的定义，因为这个类是运行时环境所需要使用的。

 

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    }

 

这儿 xref_tag 尝试获取具有 name 名字的 struct ， enum 或 union （ tag_code 告知是哪个）。如果该类型还没定义，把标签（ tag ）定义为前向引用。

如果参数 globalize 是 false ，表示标识符 name 是一个定义。在 C++ 中，首先，它允许在不同绑定域（即作用域）中定义同名的类型；其次，在同一绑定域中，同名的不同类型是一个语法错误，除非它们的定义是相同的。在 9476 行， lookup_tag 尝试，在由 b 提交的绑定域中，找出由 code 和 name 指定的类型定义。我们在后面来看这个函数的定义。

而如果 globalize 是 true ，则 name 只是一个类型声明。在 C++ 中，我们可以仅声明一个用户定义类型，然后使用其指针（只要不解引用）。例如，

class A;

A* pa = NULL;

在 GCC 内部，当它发现找不到任何东西时，它将创建一个伪类型（记得 std::bad_alloc ？），然后为它声明一个隐式的 typedef ，并且将由这个隐式 typedef 所构建的 TYPE_DECL 节点加入指定的绑定域。那么前向声明实际上就是引用这个 TYPE_DECL ，随后当遇到真正的定义时，对应的类型节点（类型 RECORD_TYPE ，或 UNION_TYPE ，或 ENUMERAL_TYPE ）进行相应地更新。而当 GCC 找到存在的类型声明（不是伪类型），而且该声明与泛型编程相关，则需要特殊的处理，我们不久将看到这一点。

 

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

      

这里 globalize 是 true ，使用 lookup_name 来类型声明，因为其第二个参数表示抛弃非类型声明。 lookup_name 是一个复杂的函数，为了不使这里的过程太漫长，我们暂时跳过它。对于我们这里的情形， lookup_name 应该返回 NULL ，因为这必须是第一次声明这个类型。

 

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   }

 

因为在 9480 行，没有标签（ tag ）被 lookup_name 所找出，那么将为之创建一个节点。并且由于参数 tag_code 是 class_type ，这个节点应该是 RECORD_TYPE ，而且它的上下文首先被设置为空（参见 9450 行的 NULL_TREE ）。

 

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 首先把类型定义加入当前名字空间。我们已经看到，在一个绑定域中的用户定义类型，被保存在相应的 cp_binding_level 结构的 type_decls 域中。下面的 binding_table_insert 提供了这个处理。

 

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    }

 

注意到 type_decls 实际上是一个哈希表，所有具有同一哈希值的类型定义被链接在一起。为了控制链表的长度，如果链表的数目（域 chain_count ）与表项数（ entry_count ）具有如下关系时： 3*table->chain_count < 5*table->entry_count ， binding_table_expand 将链表数目加倍，并重新哈希及链接已记录的类型。

 

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      }

 

在上面是 binding_entry_make 中，虽然标识符与类型定义通过 binding_entry 实例关联起来了，但标识符节点还没有与 TYPE_DECL 节点绑定。因此在下面， IDENTIFIER_TYPE_VALUE 返回 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 只是 identifier_type_value 的一个直接的封装。在这里，在我们的情形下， REAL_IDENTIFIER_TYPE_VALUE 应该返回 NULL_TREE ，而下面 4622 行的 type 则是刚创建的 RECORD_TYPE 节点。

 

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

 

回忆这个类型的上下文是 NULL ，因而在 4630 行， current_scope 被调用。这是一个宏，视情况在 current_function_decl 和 current_class_type 中选择，对于名字空间作用域，它永远返回 NULL 。那么因为我们在 std 名字空间中，在 4641 行，类型上下文被设为当前名字空间作用域。

接着在 4651 行，由 create_implicit_typedef 为类型构建了一个 TYPE_DECL 节点。然后在 set_identifier_type_value_with_scope 里，这个 TYPE_DECL 节点（注意不是类型定义）将被记录入标识符节点的 namespace_bindings 域中。

 

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   }

 

在上面 1754 行的赋值操作设置了该标识符目前对应的声明（这是个类型声明）。自此，在当前作用域，该标识符就表示该类型。

 

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   }

 

现在我们已经把类型定义（ RECORD_TYPE 节点）加入到了绑定域中，还把对应的 TYPE_DECL 节点加入到标识符节点的绑定链里。下面的 1960 行， pushdecl 只是调用 add_decl_to_level 把 TYPE_DECL 节点加入对应 cxx_scope 的 names 域。

 

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 实际上是一个类型系列，编译器根据类的结构选择其一，结构相同的类所选用的 type_info 是一样的，但是不同的实例。因此，编译器在遇到使用 type_info 的地方，并不急着构建实例，而是在前端最后完成这个编译单元时，集中地构建。这些 type_info 所需要的缓存就是在 init_rtti_processing 的 130 行的 unemitted_tinfo_decls 。