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

5.12.3.2.1.1.2.1. 构建对自己的引用
在2082行，根据ISO-IEC-14882-2003的要求，函数build_self_reference构建了一个对自己的伪引用，使得Derived::Base（及A::A）能够工作
“类名亦加入类作用域本身。出于访问检查的目的，加入的类名被视为公有成员名。”

6290 void
6291 build_self_reference (void) in class.c
6292 {
6293 tree name = constructor_name (current_class_type);
6294 tree value = build_lang_decl (TYPE_DECL, name, current_class_type);
6295 tree saved_cas;
6296
6297 DECL_NONLOCAL (value) = 1;
6298 DECL_CONTEXT (value) = current_class_type;
6299 DECL_ARTIFICIAL (value) = 1;
6300 SET_DECL_SELF_REFERENCE_P (value);
6301
6302 if (processing_template_decl)
6303 value = push_template_decl (value);
6304
6305 saved_cas = current_access_specifier;
6306 current_access_specifier = access_public_node;
6307 finish_member_declaration (value);
6308 current_access_specifier = saved_cas;
6309 }

constructor_name负责为类获取正确的名字。它需要考虑模板特化的命名。

1792 tree
1793 constructor_name (tree type) in name-lookup.c
1794 {
1795 tree name;
1796 name = constructor_name_full (type);
1797 if (IDENTIFIER_TEMPLATE (name))
1798 name = IDENTIFIER_TEMPLATE (name);
1799 return name;
1800 }

这里我们把名字“SingleThreaded”给予这个类，constructor_name_full把对应的标识符节点返回给我们。

1777 tree
1778 constructor_name_full (tree type) in name-lookup.c
1779 {
1780 type = TYPE_MAIN_VARIANT (type);
1781 if (CLASS_TYPE_P (type) && TYPE_WAS_ANONYMOUS (type)
1782 && TYPE_HAS_CONSTRUCTOR (type))
1783 return DECL_NAME (OVL_CURRENT (CLASSTYPE_CONSTRUCTORS (type)));
1784 else
1785 return TYPE_IDENTIFIER (type);
1786 }

看到在上面6306行，公有的访问属性被赋予了这个引用，然后它被作为类成员加入。注意到参数decl包含了build_lang_decl由分配的lang_specific节点，这使得DECL_LANG_SPECIFIC返回非空值。而它的DECL_CONTEXT域表示其声明所在的作用域。这里在6298行，这是它自己本身。
5.12.3.2.1.1.2.2. 为自己的引用构建TEMPLATE_DECL
作为一个模板类，在build_self_reference的6302行，processing_template_parms是非0值，表示模板声明尚未结束。

3048 tree
3049 push_template_decl (tree decl) in pt.c
3050 {
3051 return push_template_decl_real (decl, 0);
3052 }

这次当进入push_template_decl_real时，下面获取的ctx是类模板的RECORD_TYPE，它在build_self_reference中被设为该TYPE_DECL的上下文。 而现在current_binding_level 指向类的作用域，因而下面的primary是0。

2770 tree
2771 push_template_decl_real (tree decl, int is_friend) in pt.c
2772 {
2773 tree tmpl;
2774 tree args;
2775 tree info;
2776 tree ctx;
2777 int primary;
2778 int is_partial;
2779 int new_template_p = 0;
2780
2781 /* See if this is a partial specialization. */
2782 is_partial = (DECL_IMPLICIT_TYPEDEF_P (decl)
2783 && TREE_CODE (TREE_TYPE (decl)) != ENUMERAL_TYPE
2784 && CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (decl)));
2785
2786 is_friend |= (TREE_CODE (decl) == FUNCTION_DECL && DECL_FRIEND_P (decl));
2787
2788 if (is_friend)
2789 /* For a friend, we want the context of the friend function, not
2790 the type of which it is a friend. */
2791 ctx = DECL_CONTEXT (decl);
2792 else if (CP_DECL_CONTEXT (decl)
2793 && TREE_CODE (CP_DECL_CONTEXT (decl)) != NAMESPACE_DECL)
2794 /* In the case of a virtual function, we want the class in which
2795 it is defined. */
2796 ctx = CP_DECL_CONTEXT (decl);
2797 else
2798 /* Otherwise, if we're currently defining some class, the DECL
2799 is assumed to be a member of the class. */
2800 ctx = current_scope ();
2801
2802 if (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
2803 ctx = NULL_TREE;
2804
2805 if (!DECL_CONTEXT (decl))
2806 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2807
2808 /* See if this is a primary template. */
2809 primary = template_parm_scope_p ();
2810
2811 if (primary)
2812 {
…
2852 }
2853
2854 /* Check to see that the rules regarding the use of default
2855 arguments are not being violated. */
2856 check_default_tmpl_args (decl, current_template_parms,
2857 primary, is_partial);
2858
2859 if (is_partial)
2860 return process_partial_specialization (decl);
2861
2862 args = current_template_args ();
2863
2864 if (!ctx
2865 || TREE_CODE (ctx) == FUNCTION_DECL
2866 || (CLASS_TYPE_P (ctx) && TYPE_BEING_DEFINED (ctx))
2867 || (is_friend && !DECL_TEMPLATE_INFO (decl)))
2868 {
2869 if (DECL_LANG_SPECIFIC (decl)
2870 && DECL_TEMPLATE_INFO (decl)
2871 && DECL_TI_TEMPLATE (decl))
2872 tmpl = DECL_TI_TEMPLATE (decl);
2873 /* If DECL is a TYPE_DECL for a class-template, then there won't
2874 be DECL_LANG_SPECIFIC. The information equivalent to
2875 DECL_TEMPLATE_INFO is found in TYPE_TEMPLATE_INFO instead. */
2876 else if (DECL_IMPLICIT_TYPEDEF_P (decl)
2877 && TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2878 && TYPE_TI_TEMPLATE (TREE_TYPE (decl)))
2879 {
…
2888 }
2889 else
2890 {
2891 tmpl = build_template_decl (decl, current_template_parms);
2892 new_template_p = 1;
2893
2894 if (DECL_LANG_SPECIFIC (decl)
2895 && DECL_TEMPLATE_SPECIALIZATION (decl))
2896 {
…
2902 }
2903 }
2904 }
…
2997 DECL_TEMPLATE_RESULT (tmpl) = decl;
2998 TREE_TYPE (tmpl) = TREE_TYPE (decl);
…
3031 info = tree_cons (tmpl, args, NULL_TREE);
3032
3033 if (DECL_IMPLICIT_TYPEDEF_P (decl))
3034 {
…
3041 }
3042 else if (DECL_LANG_SPECIFIC (decl))
3043 DECL_TEMPLATE_INFO (decl) = info;
3044
3045 return DECL_TEMPLATE_RESULT (tmpl);
3046 }

该类的定义正在被处理，因此上面2866行的条件满足；但因为decl是新创建的，其DECL_TEMPLATE_INFO及DECL_IMPLICIT_TYPEDEF_P项还没设置，在2889行的ELSE 块被执行以创建另一个TEMPLATE_DECL。

（点此打开）
图60：创建对自己的引用—第一步
5.12.3.2.1.1.2.3. 作为成员加入类域
作为最后一步，这个对自己的引用被加入为类成员，成员与类之间的关系将被设立。

2089 void
2090 finish_member_declaration (tree decl) in semantics.c
2091 {
…
2103 /* Set up access control for DECL. */
2104 TREE_PRIVATE (decl)
2105 = (current_access_specifier == access_private_node);
2106 TREE_PROTECTED (decl)
2107 = (current_access_specifier == access_protected_node);
2108 if (TREE_CODE (decl) == TEMPLATE_DECL)
2109 {
2110 TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
2111 TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
2112 }
2113
2114 /* Mark the DECL as a member of the current class. */
2115 DECL_CONTEXT (decl) = current_class_type;
2116
2117 /* [dcl.link]
2118
2119 A C language linkage is ignored for the names of class members
2120 and the member function type of class member functions. */
2121 if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
2122 SET_DECL_LANGUAGE (decl, lang_cplusplus);
2123
2124 /* Put functions on the TYPE_METHODS list and everything else on the
2125 TYPE_FIELDS list. Note that these are built up in reverse order.
2126 We reverse them (to obtain declaration order) in finish_struct. */
2127 if (TREE_CODE (decl) == FUNCTION_DECL
2128 || DECL_FUNCTION_TEMPLATE_P (decl))
2129 {
…
2139 }
2140 /* Enter the DECL into the scope of the class. */
2141 else if ((TREE_CODE (decl) == USING_DECL && TREE_TYPE (decl))
2142 || pushdecl_class_level (decl))
2143 {
2144 /* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
2145 go at the beginning. The reason is that lookup_field_1
2146 searches the list in order, and we want a field name to
2147 override a type name so that the "struct stat hack" will
2148 work. In particular:
2149
2150 struct S { enum E { }; int E } s;
2151 s.E = 3;
2152
2153 is valid. In addition, the FIELD_DECLs must be maintained in
2154 declaration order so that class layout works as expected.
2155 However, we don't need that order until class layout, so we
2156 save a little time by putting FIELD_DECLs on in reverse order
2157 here, and then reversing them in finish_struct_1. (We could
2158 also keep a pointer to the correct insertion points in the
2159 list.) */
2160
2161 if (TREE_CODE (decl) == TYPE_DECL)
2162 TYPE_FIELDS (current_class_type)
2163 = chainon (TYPE_FIELDS (current_class_type), decl);
2164 else
2165 {
2166 TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
2167 TYPE_FIELDS (current_class_type) = decl;
2168 }
2169
2170 maybe_add_class_template_decl_list (current_class_type, decl,
2171 /*friend_p=*/0);
2172 }
2173 }

对自己的引用不是一个方法的声明，也不是using声明，因此它需要由在2142行的pushdecl_class_level加入为成员。在2748到2763之间的代码处理匿名union，根据ISO-IEC-14882-2003，应该遵从以下规则：

一个union具有形式 union { member-specification } ; 它定义了一个匿名类型的匿名对象。一个匿名union的member-specification只能定义非静态数据成员（嵌套类型及函数不能被声明在一个匿名union里）。一个匿名union里的成员的名字，必须区别于该匿名union声明所在作用域中的，其他项的名字。出于名字查找的目的，在匿名union的定义后，该匿名union的成员被视为定义在该匿名union声明所在作用域中。例如： void f() { union { int a; char* p; }; a = 1; // ... p = "Jennifer"; // ... } 在这里a及p就像普通（非成员）变量那样使用，不过因为它们是union的成员，它们拥有相同的地址。 声明在一个具名名字空间或全局名字空间的匿名union，应该被声明为静态。声明在一个块作用域（block scope）的匿名union应该被声明具有，作为一个块局部变量所允许的，储存类别（storage class），或不指定储存类别。在一个类域中声明的匿名union不允许使用存储类别。一个匿名union不能具有private或protected成员（条款11）。一个匿名union也不能具有函数成员。

2729 bool
2730 pushdecl_class_level (tree x) in name-lookup.c
2731 {
2732 tree name;
2733 bool is_valid = true;
2734
2735 timevar_push (TV_NAME_LOOKUP);
2736 /* Get the name of X. */
2737 if (TREE_CODE (x) == OVERLOAD)
2738 name = DECL_NAME (get_first_fn (x));
2739 else
2740 name = DECL_NAME (x);
2741
2742 if (name)
2743 {
2744 is_valid = push_class_level_binding (name, x);
2745 if (TREE_CODE (x) == TYPE_DECL)
2746 set_identifier_type_value (name, x);
2747 }
2748 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2749 {
…
2763 }
2764 timevar_pop (TV_NAME_LOOKUP);
2765
2766 return is_valid;
2767 }

使用下面的函数，我们尝试把具有名字name的声明x加入当前类域中。这里x及name都来自对自己的引用所生成的TYPE_DECL节点。

2772 bool
2773 push_class_level_binding (tree name, tree x) in name-lookup.c
2774 {
2775 cxx_binding *binding;
2776
2777 timevar_push (TV_NAME_LOOKUP);
2778 /* The class_binding_level will be NULL if x is a template
2779 parameter name in a member template. */
2780 if (!class_binding_level)
2781 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2782
2783 /* Make sure that this new member does not have the same name
2784 as a template parameter. */
2785 if (TYPE_BEING_DEFINED (current_class_type))
2786 check_template_shadow (x);
2787
2788 /* [class.mem]
2789
2790 If T is the name of a class, then each of the following shall
2791 have a name different from T:
2792
2793 -- every static data member of class T;
2794
2795 -- every member of class T that is itself a type;
2796
2797 -- every enumerator of every member of class T that is an
2798 enumerated type;
2799
2800 -- every member of every anonymous union that is a member of
2801 class T.
2802
2803 (Non-static data members were also forbidden to have the same
2804 name as T until TC1.) */
2805 if ((TREE_CODE (x) == VAR_DECL
2806 || TREE_CODE (x) == CONST_DECL
2807 || (TREE_CODE (x) == TYPE_DECL
2808 && !DECL_SELF_REFERENCE_P (x))
2809 || DECL_CLASS_TEMPLATE_P (x)
2810 /* A data member of an anonymous union. */
2811 || (TREE_CODE (x) == FIELD_DECL
2812 && DECL_CONTEXT (x) != current_class_type))
2813 && DECL_NAME (x) == constructor_name (current_class_type))
2814 {
…
2822 }

作为一个模板类，其类定义绑定在作用域sk_template_parms中（在图SingleThreaded作为当前作用域，我们可以看到类域的对象的level_chain指向sk_template_parms，不过sk_template_parms的names域并不像通常的作用域，它没有包括该类的定义，这体现了模板参数与类定义间的特殊关系）。在sk_template_parms作用域内，是模板参数；显然，如果在类中我们声明一个同名的成员，它将屏蔽相应的模板参数。
语法规定，模板参数不能在其作用域内被重新声明（包括嵌套作用域中）。函数check_template_shadow检查是否有这个错误。

2063 void
2064 check_template_shadow (tree decl) in pt.c
2065 {
2066 tree olddecl;
2067
2068 /* If we're not in a template, we can't possibly shadow a template
2069 parameter. */
2070 if (!current_template_parms)
2071 return;
2072
2073 /* Figure out what we're shadowing. */
2074 if (TREE_CODE (decl) == OVERLOAD)
2075 decl = OVL_CURRENT (decl);
2076 olddecl = IDENTIFIER_VALUE (DECL_NAME (decl));
2077
2078 /* If there's no previous binding for this name, we're not shadowing
2079 anything, let alone a template parameter. */
2080 if (!olddecl)
2081 return;
2082
2083 /* If we're not shadowing a template parameter, we're done. Note
2084 that OLDDECL might be an OVERLOAD (or perhaps even an
2085 ERROR_MARK), so we can't just blithely assume it to be a _DECL
2086 node. */
2087 if (!DECL_P (olddecl) || !DECL_TEMPLATE_PARM_P (olddecl))
2088 return;
2089
2090 /* We check for decl != olddecl to avoid bogus errors for using a
2091 name inside a class. We check TPFI to avoid duplicate errors for
2092 inline member templates. */
2093 if (decl == olddecl
2094 || TEMPLATE_PARMS_FOR_INLINE (current_template_parms))
2095 return;
2096
2097 cp_error_at ("declaration of `%#D'", decl);
2098 cp_error_at (" shadows template parm `%#D'", olddecl);
2099 }

这里类的标识符节点还没有设定其bindings域，因此在2076行的IDENTIFIER_VALUE返回NULL。

push_class_level_binding (continue)

2824 /* If this declaration shadows a declaration from an enclosing
2825 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
2826 we leave this class. Record the shadowed declaration here. */
2827 binding = IDENTIFIER_BINDING (name);
2828 if (binding && binding->value)
2829 {
…
2878 }
2879
2880 /* If we didn't replace an existing binding, put the binding on the
2881 stack of bindings for the identifier, and update the shadowed list. */
2882 if (push_class_binding (name, x))
2883 {
2884 class_binding_level->class_shadowed
2885 = tree_cons (name, NULL,
2886 class_binding_level->class_shadowed);
2887 /* Record the value we are binding NAME to so that we can know
2888 what to pop later. */
2889 TREE_TYPE (class_binding_level->class_shadowed) = x;
2890 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2891 }
2892
2893 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2894 }

因为IDENTIFIER_VALUE在这里返回NULL，在上面就跳到2882行执行push_class_binding。

2657 int
2658 push_class_binding (tree id, tree decl) in name-lookup.c
2659 {
2660 int result = 1;
2661 cxx_binding *binding = IDENTIFIER_BINDING (id);
2662 tree context;
2663
2664 timevar_push (TV_NAME_LOOKUP);
2665 /* Note that we declared this value so that we can issue an error if
2666 this is an invalid redeclaration of a name already used for some
2667 other purpose. */
2668 note_name_declared_in_class (id, decl);
2669
2670 if (binding && binding->scope == class_binding_level)
2671 /* Supplement the existing binding. */
2672 result = supplement_binding (IDENTIFIER_BINDING (id), decl);
2673 else
2674 /* Create a new binding. */
2675 push_binding (id, decl, class_binding_level);

对于每个缓存的项，都需要检查是否是有效的声明。而对于每个类，都有一个伴随的splay树来记录在该类中使用过的名字。

6415 void
6416 note_name_declared_in_class (tree name, tree decl) in class.c
6417 {
6418 splay_tree names_used;
6419 splay_tree_node n;
6420
6421 /* Look to see if we ever used this name. */
6422 names_used
6423 = current_class_stack[current_class_depth - 1].names_used;
6424 if (!names_used)
6425 return;
6426
6427 n = splay_tree_lookup (names_used, (splay_tree_key) name);
6428 if (n)
6429 {
6430 /* [basic.scope.class]
6431
6432 A name N used in a class S shall refer to the same declaration
6433 in its context and when re-evaluated in the completed scope of
6434 S. */
6435 error ("declaration of `%#D'", decl);
6436 cp_error_at ("changes meaning of `%D' from `%+#D'",
6437 DECL_NAME (OVL_CURRENT (decl)),
6438 (tree) n->value);
6439 }
6440 }

上面current_class_stack的names_used域是splay树的根节点，用于记录每个类的域声明。在插入新域之前，要通过上面的这个函数来确认相同的名字之前没有被使用过。【3】给出了例子：
typedef int c;
enum { i = 1 };
class X {
char v[i]; // error: i refers to ::i but when reevaluated is X::i
int f() { return sizeof(c); } // OK: X::c
char c;
enum { i = 2 };
};
上面的声明char v[i]将被note_name_declared_in_class作为错误捕捉。这是因为，类数据成员的解析处理是顺序进行的，假若调换声明char v[i]及enum { i=2 }，char v[i]的含义就不同了。【3】把这种情况定义为病态程序。而对类内联方法的分析，是在解析完类声明结尾的“};”后，才进行。因此上面的“f()”方法的不受影响。
而上面2670行的条件则是检查重复声明的情况。对于新的定义，一个cxx_binding记录了这个绑定信息。

358 static void
359 push_binding (tree id, tree decl, cxx_scope* level) in name-lookup.c
360 {
361 cxx_binding *binding = cxx_binding_make (decl, NULL);
362
363 /* Now, fill in the binding information. */
364 binding->previous = IDENTIFIER_BINDING (id);
365 binding->scope = level;
366 INHERITED_VALUE_BINDING_P (binding) = 0;
367 LOCAL_BINDING_P (binding) = (level != class_binding_level);
368
369 /* And put it on the front of the list of bindings for ID. */
370 IDENTIFIER_BINDING (id) = binding;
371 }

如果非空，域IDENTIFIER_CLASS_VALUE是一个tree_list，它记录了类中所声明的所有成员。不过在push_binding中所构建的cxx_binding的value域是空的（因为它不是重载方法），因此下面的代码不作任何事，返回result 1。

push_class_binding (continue)

2677 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
2678 class-level declaration. Note that we do not use DECL here
2679 because of the possibility of the `struct stat' hack; if DECL is
2680 a class-name or enum-name we might prefer a field-name, or some
2681 such. */
2682 IDENTIFIER_CLASS_VALUE (id) = IDENTIFIER_BINDING (id)->value;
2683
2684 /* If this is a binding from a base class, mark it as such. */
2685 binding = IDENTIFIER_BINDING (id);
2686 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2687 {
2688 if (TREE_CODE (decl) == OVERLOAD)
2689 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2690 else
2691 {
2692 my_friendly_assert (DECL_P (decl), 0);
2693 context = context_for_name_lookup (decl);
2694 }
2695
2696 if (is_properly_derived_from (current_class_type, context))
2697 INHERITED_VALUE_BINDING_P (binding) = 1;
2698 else
2699 INHERITED_VALUE_BINDING_P (binding) = 0;
2700 }
2701 else if (binding->value == decl)
2702 /* We only encounter a TREE_LIST when push_class_decls detects an
2703 ambiguity. Such an ambiguity can be overridden by a definition
2704 in this class. */
2705 INHERITED_VALUE_BINDING_P (binding) = 1;
2706
2707 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result);
2708 }

因为push_class_binding在的2882行返回1，该成员被串入class_shadowed链表，该链表保存该类所声明的成员。最后push_class_level_binding返回true。
返回pushdecl_class_level的2744行，变量x是一个TYPE_DECL（参考build_lang_decl），进一步的绑定结构由set_identifier_type_value构建。在这一步，标识符节点的type域被更新为指向类的RECORD_TYPE节点，同时type域的原始值（global_type_node）被保存在相应的cxx_binding节点的type_shadowed域里。

（点此打开）
图61：创建对自己的引用—第二步
注意IDENTIFIER_NODE和“SingleThreaded”的cxx_scope对象的变化是相配合的。在pushdecl_class_level向finish_member_declaration返回1后，这个对自己的引用被串接入类的域声明链表（即RECORD_TYPE的values域）的末尾。
接着maybe_add_class_template_decl_list被执行。对于类模板，CLASSTYPE_DECL_LIST是一个依声明次序用于所有数据成员，函数及友元的tree_list。其中的每个节点的TREE_PURPOSE，对于友元是NULL_TREE，而对于类模板则是其RECORD_TYPE。

2583 void
2584 maybe_add_class_template_decl_list (tree type, tree t, int friend_p) in class.c
2585 {
2586 /* Save some memory by not creating TREE_LIST if TYPE is not template. */
2587 if (CLASSTYPE_TEMPLATE_INFO (type))
2588 CLASSTYPE_DECL_LIST (type)
2589 = tree_cons (friend_p ? NULL_TREE : type,
2590 t, CLASSTYPE_DECL_LIST (type));
2591 }

（点此打开）
图62：创建对自己的引用—第三步