identifier

C++的前端对identifier做了扩展，在每个identifier中还包含了两个cxx_binding字段：namespace_bindings和bindings。当通过字符串找到一个identifier的时候，同时顺带获得了两个binding信息。

/* Language-dependent contents of an identifier.  */

struct GTY(()) lang_identifier {
  struct c_common_identifier c_common;
  cxx_binding *namespace_bindings;
  cxx_binding *bindings;
  tree class_template_info;
  tree label_value;
};

事实上，在LANG_HOOKS_INITIALIZER的定义中，第一个字段是语言的名字，而第二个字段就是语言中identifier的大小，可以这个结构还是相当重要的？

/* The whole thing.  The structure is defined in langhooks.h.  */
#define LANG_HOOKS_INITIALIZER { \
  LANG_HOOKS_NAME, \
  LANG_HOOKS_IDENTIFIER_SIZE, \
  LANG_HOOKS_FREE_LANG_DATA, \
  LANG_HOOKS_TREE_SIZE, \

bingding

在cxx_binding结构中，有value和type两个字段，注释也比较贴心，就是这个标识符的类型和值信息。

由于同一个identifier在不同的scope中可能有不同的意义，所以结构中还包含了previous字段将所有scope中同名的标识符串在一起放在链表中。

struct cxx_binding {
  /* Link to chain together various bindings for this name.  */
  cxx_binding *previous;
  /* The non-type entity this name is bound to.  */
  tree value;
  /* The type entity this name is bound to.  */
  tree type;
  /* The scope at which this binding was made.  */
  cp_binding_level *scope;
  unsigned value_is_inherited : 1;
  unsigned is_local : 1;
};

创建

当语法分析到一个变量/类型/函数等声明的时候，会为这个标识符创建一个对应的binding。在push_binding函数中会记录这个标识符的声明(decl)，并把它放在链表的最开始(And put it on the front of the list of bindings for ID)。

/* Make DECL the innermost binding for ID.  The LEVEL is the binding
   level at which this declaration is being bound.  */

void
push_binding (tree id, tree decl, cp_binding_level* level)
{
  cxx_binding *binding;

  if (level != class_binding_level)
    {
      binding = cxx_binding_make (decl, NULL_TREE);
      binding->scope = level;
    }
  else
    binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);

  /* Now, fill in the binding information.  */
  binding->previous = IDENTIFIER_BINDING (id);
  INHERITED_VALUE_BINDING_P (binding) = 0;
  LOCAL_BINDING_P (binding) = (level != class_binding_level);

  /* And put it on the front of the list of bindings for ID.  */
  IDENTIFIER_BINDING (id) = binding;
}

查找

在语法解析的时候，如果遇到一个新的标识符，首先会根据这个标识符的字符串找到对应的结构，然后从当前scope逐层向外搜索这个标识符的信息。 实现上看主要就是从查找到的identifier的binding信息逐层向外找到最近的标识符声明。

/* Look up NAME in the current binding level and its superiors in the
   namespace of variables, functions and typedefs.  Return a ..._DECL
   node of some kind representing its definition if there is only one
   such declaration, or return a TREE_LIST with all the overloaded
   definitions if there are many, or return 0 if it is undefined.
   Hidden name, either friend declaration or built-in function, are
   not ignored.

   If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
   If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
   Otherwise we prefer non-TYPE_DECLs.

   If NONCLASS is nonzero, bindings in class scopes are ignored.  If
   BLOCK_P is false, bindings in block scopes are ignored.  */

static tree
lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
		    int namespaces_only, int flags)
{
///...
  if (block_p || !nonclass)
    for (iter = outer_binding (name, NULL, !nonclass);
	 iter;
	 iter = outer_binding (name, iter, !nonclass))
      {
	tree binding;

	/* Skip entities we don't want.  */
	if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
	  continue;

	/* If this is the kind of thing we're looking for, we're done.  */
	if (qualify_lookup (iter->value, flags))
	  binding = iter->value;
	else if ((flags & LOOKUP_PREFER_TYPES)
		 && qualify_lookup (iter->type, flags))
	  binding = iter->type;
	else
	  binding = NULL_TREE;

	if (binding)
	  {
	    if (hidden_name_p (binding))
	      {
		/* A non namespace-scope binding can only be hidden in the
		   presence of a local class, due to friend declarations.

		   In particular, consider:

		   struct C;
		   void f() {
		     struct A {
		       friend struct B;
		       friend struct C;
		       void g() {
		         B* b; // error: B is hidden
			 C* c; // OK, finds ::C
		       } 
		     };
		     B *b;  // error: B is hidden
		     C *c;  // OK, finds ::C
		     struct B {};
		     B *bb; // OK
		   }

		   The standard says that "B" is a local class in "f"
		   (but not nested within "A") -- but that name lookup
		   for "B" does not find this declaration until it is
		   declared directly with "f".

		   In particular:

		   [class.friend]

		   If a friend declaration appears in a local class and
		   the name specified is an unqualified name, a prior
		   declaration is looked up without considering scopes
		   that are outside the innermost enclosing non-class
		   scope. For a friend function declaration, if there is
		   no prior declaration, the program is ill-formed. For a
		   friend class declaration, if there is no prior
		   declaration, the class that is specified belongs to the
		   innermost enclosing non-class scope, but if it is
		   subsequently referenced, its name is not found by name
		   lookup until a matching declaration is provided in the
		   innermost enclosing nonclass scope.

		   So just keep looking for a non-hidden binding.
		*/
		gcc_assert (TREE_CODE (binding) == TYPE_DECL);
		continue;
	      }
	    val = binding;
	    break;
	  }
      }
///...
}
/* Return the innermost non-namespace binding for NAME from a scope
   containing BINDING, or, if BINDING is NULL, the current scope.
   Please note that for a given template, the template parameters are
   considered to be in the scope containing the current scope.
   If CLASS_P is false, then class bindings are ignored.  */

cxx_binding *
outer_binding (tree name,
	       cxx_binding *binding,
	       bool class_p)
{
  cxx_binding *outer;
  cp_binding_level *scope;
  cp_binding_level *outer_scope;

  if (binding)
    {
      scope = binding->scope->level_chain;
      outer = binding->previous;
    }
  else
    {
      scope = current_binding_level;
      outer = IDENTIFIER_BINDING (name);
    }
    ///...
}

生效

以C++最为关心的struct/class为例，在解析完成类似于struct Tsecer;这样合法的结构之后，会立即调用xref_tag来创建一个对于这个类型的前置声明。这种实现感觉也是crtp的一个实现基础：在派生类的名字解析完成之后，派生类的tag已经可用，此时可以在基类中把该类型作为模板参数使用。

/* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
   Define the tag as a forward-reference if it is not defined.

   If a declaration is given, process it here, and report an error if
   multiple declarations are not identical.

   SCOPE is TS_CURRENT when this is also a definition.  Only look in
   the current frame for the name (since C++ allows new names in any
   scope.)  It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
   declaration.  Only look beginning from the current scope outward up
   till the nearest non-class scope.  Otherwise it is TS_GLOBAL.

   TEMPLATE_HEADER_P is true when this declaration is preceded by
   a set of template parameters.  */

static tree
xref_tag_1 (enum tag_types tag_code, tree name,
            tag_scope orig_scope, bool template_header_p)
{
///...
	  t = make_class_type (code);
	  TYPE_CONTEXT (t) = context;
	  if (orig_scope == ts_lambda)
	    /* Remember that we're declaring a lambda to avoid bogus errors
	       in push_template_decl.  */
	    CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node;
	  t = pushtag (name, t, scope);
///...
}

构造函数

在cp_finish_decl==>>check_initializer函数中，如果一个变量声明时有Init初始化内容，则会判断是否需要调用构造函数。

/* Verify INIT (the initializer for DECL), and record the
   initialization in DECL_INITIAL, if appropriate.  CLEANUP is as for
   grok_reference_init.

   If the return value is non-NULL, it is an expression that must be
   evaluated dynamically to initialize DECL.  */

static tree
check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups)
{
///...
      if (((type_build_ctor_call (type) || CLASS_TYPE_P (type))
	   && !(flags & LOOKUP_ALREADY_DIGESTED)
	   && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
		&& CP_AGGREGATE_TYPE_P (type)
		&& (CLASS_TYPE_P (type)
		    || !TYPE_NEEDS_CONSTRUCTING (type)
		    || type_has_extended_temps (type))))
	  || (DECL_DECOMPOSITION_P (decl) && TREE_CODE (type) == ARRAY_TYPE))
	{
	  init_code = build_aggr_init_full_exprs (decl, init, flags);

	  /* A constructor call is a non-trivial initializer even if
	     it isn't explicitly written.  */
	  if (TREE_SIDE_EFFECTS (init_code))
	    DECL_NONTRIVIALLY_INITIALIZED_P (decl) = true;
	  ///...
}

check_initializer>>build_aggr_init_full_exprs >>build_aggr_init>>expand_aggr_init_1>>expand_default_init==>>build_special_member_call最终会触发对于构造函数的调用。

static void
expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
                     tsubst_flags_t complain)
{
///...
      if (true_exp == exp)
	ctor_name = complete_ctor_identifier;
      else
	ctor_name = base_ctor_identifier;
      rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
					complain);
///...
}

结论

• 构造和赋值

构造函数会在变量定义的时候判断是否是需要执行构造函数。同样一个对象，在声明时和之后赋值虽然都是用赋值，但是在此处有不同的语义。
在下面代码中，第19行的内容除了和18行开始的声明不一样之外，赋值符号左右的内容都是相同的，但是因为一个是声明上下文，一个是赋值上下文，编译器执行的动作也大相径庭：一个是拷贝构造，一个赋值。

tsecer@harry: cat -n context.cpp                         
     1  #include <stdio.h>
     2  struct Tsecer
     3  {
     4      Tsecer() = default;
     5
     6      Tsecer(const Tsecer &t)
     7      {
     8          printf("copy constructor\n");
     9      }
    10      Tsecer& operator = (const Tsecer &t)
    11      {
    12          printf("assign operator\n");
    13      }
    14  };
    15
    16  int main(int argc, const char *argv[])
    17  {
    18      Tsecer t1 = Tsecer();
    19      t1 = Tsecer();
    20      return 0;
    21  }
    22
tsecer@harry: g++ -fno-elide-constructors context.cpp            
tsecer@harry: ./a.out 
copy constructor
assign operator
tsecer@harry: 

• 标识符

gcc对于字符串形式的identifier在不同的scope中具体代表什么意义的实现比较巧妙，但也还算比较直观，只是稍微有一点绕，如果不了解这个实现机制，有些地方代码阅读的时候可能会觉得不容易理解。