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

5.12.5.2.2.2.1.2.    构建 VAR_DECL

接下来在 cp_parser_simple_declaration 中，调用 cp_parser_init_declarator 来解析声明符部分。调用栈 cp_parser_declarator à cp_parser_direct_declarator à cp_parser_declarator_id à cp_parser_id_expression à cp_parser_unqualified_id à cp_parser_identifier ，为“ object_ ”构建了一个 IDENTIFIER_NODE 。接着在 cp_parser_init_declarator 中，以下代码片段将被执行。

 

cp_parser_init_declarator (continue)

 

10095   /* Enter the newly declared entry in the symbol table. If we're

10096     processing a declaration in a class-specifier, we wait until

10097     after processing the initializer.  */

10098   if (!member_p)

10099   {

10100     if (parser->in_unbraced_linkage_specification_p)

10101     {

10102       decl_specifiers = tree_cons (error_mark_node,

10103                              get_identifier ("extern"),

10104                              decl_specifiers);

10105       have_extern_spec = false;

10106     }

10107     decl = start_decl (declarator, decl_specifiers,

10108                    is_initialized, attributes, prefix_attributes);

10109   }

 

“ SmallObject<> object_ ”是一个变量声明。一个新的树节点需要在中间树中创建来代表这个实体。在这次调用中，实参 intialized 是 false ， attributes 及 prefix_attributes 都是 NULL 。

 

3670   tree

3671   start_decl (tree declarator,                                                                               in decl.c

3672            tree declspecs,

3673            int initialized,

3674            tree attributes,

3675            tree prefix_attributes)

3676   {

3677     tree decl;

3678     tree type, tem;

3679     tree context;

3680  

3681     /* This should only be done once on the top most decl.  */

3682     if (have_extern_spec )

3683     {

3684       declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),

3685                         declspecs);

3686       have_extern_spec = false;

3687     }

3688  

3689     /* An object declared as __attribute__((deprecated)) suppresses

3690       warnings of uses of other deprecated items.  */

3691     if (lookup_attribute ("deprecated", attributes))

3692       deprecated_state = DEPRECATED_SUPPRESS;

3693  

3694     attributes = chainon (attributes, prefix_attributes);

3695  

3696     decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,

3697                         &attributes);

3698  

3699     deprecated_state = DEPRECATED_NORMAL;

3700  

3701     if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)

3702       return error_mark_node;

3703  

3704     type = TREE_TYPE (decl);

3705  

3706     if (type == error_mark_node)

3707       return error_mark_node;

3708  

3709     context = DECL_CONTEXT (decl);

3710  

3711     if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL

3712        && context != current_namespace && TREE_CODE (decl) == VAR_DECL)

3713     {

3714        /* When parsing the initializer, lookup should use the object's

3715         namespace.  */

3716       push_decl_namespace (context);

3717     }

3718  

3719     /* We are only interested in class contexts, later.  */

3720     if (context && TREE_CODE (context) == NAMESPACE_DECL)

3721       context = NULL_TREE;

 

作为声明的一种，期望的是某种 DECL 节点，因此需要 grokdeclarator 分析 decl-specifiers 及声明符部分来构成这个节点。

 

6462   tree

6463   grokdeclarator (tree declarator,                                                                        in decl.c

6464                tree declspecs,

6465                enum decl_context decl_context,

6466                int initialized,

6467                tree* attrlist)

6468   {

6469     RID_BIT_TYPE specbits;

6470     int nclasses = 0;

6471     tree spec;

6472     tree type = NULL_TREE;

6473     int longlong = 0;

6474     int type_quals;

6475     int virtualp, explicitp, friendp, inlinep, staticp;

6476     int explicit_int = 0;

6477     int explicit_char = 0;

6478     int defaulted_int = 0;

6479     int extern_langp = 0;

6480     tree dependant_name = NULL_TREE;

6481    

6482     tree typedef_decl = NULL_TREE;

6483     const char *name;

6484     tree typedef_type = NULL_TREE;

6485     int funcdef_flag = 0;

6486     enum tree_code innermost_code = ERROR_MARK;

6487     int bitfield = 0;

6488   #if 0

6489     /* See the code below that used this.  */

6490     tree decl_attr = NULL_TREE;

6491   #endif

6492  

6493     /* Keep track of what sort of function is being processed

6494       so that we can warn about default return values, or explicit

6495       return values which do not match prescribed defaults.  */

6496     special_function_kind sfk = sfk_none;

6497  

6498     tree dname = NULL_TREE;

6499     tree ctype = current_class_type;

6500     tree ctor_return_type = NULL_TREE;

6501     enum overload_flags flags = NO_SPECIAL;

6502     tree quals = NULL_TREE;

6503     tree raises = NULL_TREE;

6504     int template_count = 0;

6505     tree in_namespace = NULL_TREE;

6506     tree returned_attrs = NULL_TREE;

6507     tree scope = NULL_TREE;

6508     tree parms = NULL_TREE;

6509  

6510     RIDBIT_RESET_ALL (specbits);

6511     if (decl_context == FUNCDEF)

6512       funcdef_flag = 1, decl_context = NORMAL;

6513     else if (decl_context == MEMFUNCDEF)

6514       funcdef_flag = -1, decl_context = FIELD;

6515     else if (decl_context == BITFIELD)

6516       bitfield = 1, decl_context = FIELD;

6517  

6518     /* Look inside a declarator for the name being declared

6519       and get it as a string, for an error message.  */

6520     {

6521       tree *next = &declarator;

6522       tree decl;

6523       name = NULL;

6524  

6525       while (next && *next)

6526       {

6527          decl = *next;

6528          switch (TREE_CODE (decl))

6529          {

               …

6629            case IDENTIFIER_NODE:

6630                if (TREE_CODE (decl) == IDENTIFIER_NODE)

6631                  dname = decl;

6632  

6633                next = 0;

6634  

6635                if (C_IS_RESERVED_WORD (dname))

6636                {

                     …

6640               }

6641              else if (!IDENTIFIER_TYPENAME_P (dname))

6642                  name = IDENTIFIER_POINTER (dname);

                …

6654               break ;

6655      

6656           }

6657       }

6658     }

         …

6828     /* Look through the decl specs and record which ones appear.

6829       Some typespecs are defined as built-in typenames.

6830       Others, the ones that are modifiers of other types,

6831       are represented by bits in SPECBITS: set the bits for

6832       the modifiers that appear. Storage class keywords are also in SPECBITS.

6833  

6834       If there is a typedef name or a type, store the type in TYPE.

6835       This includes builtin typedefs such as `int'.

6836  

6837       Set EXPLICIT_INT if the type is `int' or `char' and did not

6838       come from a user typedef.

6839  

6840       Set LONGLONG if `long' is mentioned twice.

6841  

6842       For C++, constructors and destructors have their own fast treatment.  */

6843  

6844     for (spec = declspecs; spec; spec = TREE_CHAIN (spec))

6845     {

6846       int i;

6847       tree id;

6848  

6849       /* Certain parse errors slip through. For example,

6850         `int class;' is not caught by the parser. Try

6851         weakly to recover here.  */

6852       if (TREE_CODE (spec) != TREE_LIST)

6853         return 0;

6854  

6855       id = TREE_VALUE (spec);

6856  

6857       /* If the entire declaration is itself tagged as deprecated then

6858         suppress reports of deprecated items.  */

6859       if (!adding_implicit_members && id && TREE_DEPRECATED (id))

6860       {

6861         if (deprecated_state != DEPRECATED_SUPPRESS)

6862           warn_deprecated_use (id);

6863       }

6864  

6865       if (TREE_CODE (id) == IDENTIFIER_NODE)

6866       {

            …

6933       }

6934       else if (TREE_CODE (id) == TYPE_DECL)

6935       {

6936         if (type)

6937           error ("multiple declarations `%T' and `%T'", type,

6938                 TREE_TYPE (id));

6939         else

6940         {

6941           type = TREE_TYPE (id);

6942           TREE_VALUE (spec) = type;

6943           typedef_decl = id;

6944         }

6945         goto found;

6946       }

6947       if (type)

6948         error ("two or more data types in declaration of `%s'", name);

6949       else if (TREE_CODE (id) == IDENTIFIER_NODE)

6950       {

            …

6960       }

6961       else if (id != error_mark_node)

6962         /* Can't change CLASS nodes into RECORD nodes here!  */

6963         type = id;

6964  

6965   found: ;

6966     }

6967  

6968   #if 0

6969     /* See the code below that used this.  */

6970     if (typedef_decl)

6971       decl_attr = DECL_ATTRIBUTES (typedef_decl);

6972   #endif

6973     typedef_type = type;

        …

7019     ctype = NULL_TREE;

        …

7337     scope = get_scope_of_declarator (declarator);

7338  

7339     /* Now figure out the structure of the declarator proper.

7340       Descend through it, creating more complex types, until we reach

7341       the declared identifier (or NULL_TREE, in an abstract declarator).  */

7342  

7343     while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE

7344           && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)

7345     {

          …

7840     }

        …

8163     {

8164       tree decl;

8165  

8166       if (decl_context == PARM)

8167       {

            …

8172       }

8173       else if (decl_context == FIELD)

8174       {

            …

8427       }

8428       else if (TREE_CODE (type) == FUNCTION_TYPE

8429             || TREE_CODE (type) == METHOD_TYPE)

8430       {

            …

8514       }

8515       else

8516       {

8517         /* It's a variable.  */

8518  

8519         /* An uninitialized decl with `extern' is a reference.  */

8520         decl = grokvardecl (type, declarator, &specbits,

8521                         initialized,

8522                         (type_quals & TYPE_QUAL_CONST) != 0,

8523                         ctype ? ctype : in_namespace);

8524         bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,

8525                      inlinep, friendp, raises != NULL_TREE);

8526  

8527         if (ctype)

8528         {

              …

8547         }

8548       }

8549  

8550       my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);

8551  

8552       /* Record `register' declaration for warnings on &

8553         and in case doing stupid register allocation.  */

8554  

8555       if (RIDBIT_SETP (RID_REGISTER, specbits))

8556         DECL_REGISTER (decl) = 1;

8557  

8558       if (RIDBIT_SETP (RID_EXTERN, specbits))

8559         DECL_THIS_EXTERN (decl) = 1;

8560  

8561       if (RIDBIT_SETP (RID_STATIC, specbits))

8562         DECL_THIS_STATIC (decl) = 1;

8563  

8564       /* Record constancy and volatility. There's no need to do this

8565         when processing a template; we'll do this for the instantiated

8566         declaration based on the type of DECL.  */

8567       if (!processing_template_decl)

8568         c_apply_type_quals_to_decl (type_quals, decl);

8569  

8570       return decl;

8571     }

8572   }

 

在上面的代码中，显然 6525 行的 WHILE 块验证声明符部分；而 6844 行的 FOR 块验证并提前对应的 type-specifier 。注意到在 6941 行， type 指向上一节中所构建的 RECORD_TYPE 。

接着 type 及 declarator 将被组合起来由 grokvardecl 来构成期望的 VAR_DECL 。注意到对于我们的情形，在调用期间，参数 scope 是 NULL ， constp 是 false ， initialized 是 false ，而 specbits_in 包含了 0 。

 

5885   static tree

5886   grokvardecl (tree type,                                                                                    in decl.c

5887              tree name,

5888              RID_BIT_TYPE * specbits_in,

5889              int initialized,

5890               int constp,

5891              tree scope)

5892   {

5893     tree decl;

5894     tree explicit_scope;

5895     RID_BIT_TYPE specbits;

5896  

5897     my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,

5898                      20020808);

5899  

5900     specbits = *specbits_in;

5901  

5902     /* Compute the scope in which to place the variable, but remember

5903       whether or not that scope was explicitly specified by the user.  */

5904     explicit_scope = scope;

5905     if (!scope)

5906     {

5907       /* An explicit "extern" specifier indicates a namespace-scope

5908         variable.  */

5909       if (RIDBIT_SETP (RID_EXTERN, specbits))

5910         scope = current_namespace;

5911       else if (!at_function_scope_p ())

5912       {

5913         scope = current_scope ();

5914         if (!scope)

5915           scope = current_namespace;

5916       }

5917     }

5918  

5919     if (scope

5920        && (/* If the variable is a namespace-scope variable declared in a

5921              template, we need DECL_LANG_SPECIFIC.  */

5922              (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)

5923              /* Similarly for namespace-scope variables with language linkage

5924                other than C++.  */

5925              || (TREE_CODE (scope) == NAMESPACE_DECL

5926                 && current_lang_name != lang_name_cplusplus)

5927             /* Similarly for static data members.  */

5928             || TYPE_P (scope)))

5929       decl = build_lang_decl (VAR_DECL, name, type);

5930     else

5931       decl = build_decl (VAR_DECL, name, type);

5932  

5933     if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)

5934       set_decl_namespace (decl, explicit_scope, 0);

5935     else

5936       DECL_CONTEXT (decl) = scope;

5937  

5938     if (name && scope && current_lang_name != lang_name_c)

5939        /* We can't mangle lazily here because we don't have any

5940         way to recover whether or not a variable was `extern

5941         "C"' later.  */

5942       mangle_decl (decl);

5943  

5944     if (RIDBIT_SETP (RID_EXTERN, specbits))

5945     {

5946       DECL_THIS_EXTERN (decl) = 1;

5947       DECL_EXTERNAL (decl) = !initialized;

5948     }

5949  

5950     /* In class context, static means one per class,

5951       public access, and static storage.  */

5952     if (DECL_CLASS_SCOPE_P (decl))

5953     {

5954       TREE_PUBLIC (decl) = 1;

5955       TREE_STATIC (decl) = 1;

5956       DECL_EXTERNAL (decl) = 0;

5957     }

5958     /* At top level, either `static' or no s.c. makes a definition

5959       (perhaps tentative), and absence of `static' makes it public.  */

5960     else if (toplevel_bindings_p ())

5961     {

5962       TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)

5963                            && (DECL_THIS_EXTERN (decl) || ! constp));

5964       TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);

5965     }

5966     /* Not at top level, only `static' makes a static definition.  */

5967     else

5968     {

5969       TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);

5970       TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);

5971     }

5972  

5973     if (RIDBIT_SETP (RID_THREAD, specbits))

5974     {

5975       if (targetm .have_tls)

5976         DECL_THREAD_LOCAL (decl) = 1;

5977       else

5978         /* A mere warning is sure to result in improper semantics

5979           at runtime. Don't bother to allow this to compile.  */

5980         error ("thread-local storage not supported for this target");

5981     }

5982  

5983     if (TREE_PUBLIC (decl))

5984     {

5985       /* [basic.link]: A name with no linkage (notably, the name of a class

5986         or enumeration declared in a local scope) shall not be used to

5987         declare an entity with linkage.

5988  

5989         Only check this for public decls for now.  */

5990       tree t = no_linkage_check (TREE_TYPE (decl));

5991       if (t)

5992       {

5993         if (TYPE_ANONYMOUS_P (t))

5994           /* Ignore for now; `enum { foo } e' is pretty common.  */;

5995         else

5996           pedwarn ("non-local variable `%#D' uses local type `%T'",

5997                    decl, t);

5998       }

5999     }

6000  

6001     return decl;

6002   }

 

在这一步之后，我们得到下图中的 VAR_DECL 。看到该节点的 context 域是 NULL ，因为我们不在类作用域中。

（ 点此打开 ）

 

start_decl (continue)

 

3832     /* Enter this declaration into the symbol table.  */

3833     tem = maybe_push_decl (decl);

3834  

3835     if (processing_template_decl)

3836       tem = push_template_decl (tem);

3837     if (tem == error_mark_node)

3838       return error_mark_node;

3839  

3840   #if ! defined ( ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)

3841     /* Tell the back-end to use or not use .common as appropriate. If we say

3842       -fconserve-space, we want this to save .data space, at the expense of

3843       wrong semantics. If we say -fno-conserve-space, we want this to

3844       produce errors about redefs; to do this we force variables into the

3845       data segment.  */

3846     DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL

3847                              || !DECL_THREAD_LOCAL (tem))

3848                            && (flag_conserve_space || ! TREE_PUBLIC (tem)));

3849   #endif

3850  

3851     if (! processing_template_decl)

3852       start_decl_1 (tem);

3853  

3854     return tem;

3855   }

 

作为一个 context 域为 NULL 的 VAR_DECL 节点， maybe_push_decl 为 decl 调用 pushdecl 。而对于我们的例子，在 3852 行的 start_decl_1 不做任何事。

 

566    tree

567    pushdecl (tree x)                                                                               in name-lookup.c

568    {

569      tree t;

570      tree name;

571      int need_new_binding;

572   

573      timevar_push (TV_NAME_LOOKUP);

574   

575      need_new_binding = 1;

576   

577      if (DECL_TEMPLATE_PARM_P (x))

578        /* Template parameters have no context; they are not X::T even

579          when declared within a class or namespace.  */

580        ;

581      else

582      {

583        if (current_function_decl && x != current_function_decl

584           /* A local declaration for a function doesn't constitute

585             nesting.  */

586           && TREE_CODE (x) != FUNCTION_DECL

587           /* A local declaration for an `extern' variable is in the

588             scope of the current namespace, not the current

589             function.  */

590           && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))

591           && !DECL_CONTEXT (x))

592          DECL_CONTEXT (x) = current_function_decl ;

          …

602      }

603   

604      name = DECL_NAME (x);

605      if (name)

606      {

607        int different_binding_level = 0;

          …

615        /* In case this decl was explicitly namespace-qualified, look it

616          up in its namespace context.  */

617        if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())

618          t = namespace_binding (name, DECL_CONTEXT (x));

619        else

620          t = lookup_name_current_level (name);

          …

828        /* This name is new in its binding level.

829          Install the new declaration and return it.  */

830        if (namespace_bindings_p ())

831        {

            …

872        }

873        else

874        {

875          /* Here to install a non-global value.  */

876          tree oldlocal = IDENTIFIER_VALUE (name);

877          tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);

878   

879          if (need_new_binding)

880          {

881            push_local_binding (name, x, 0);

882            /* Because push_local_binding will hook X on to the

883              current_binding_level's name list, we don't want to

884              do that again below.  */

885            need_new_binding = 0;

886          }

            …

1003       }

1004  

1005       if (TREE_CODE (x) == VAR_DECL)

1006          maybe_register_incomplete_var (x);

1007     }

        …

1015     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);

1016   }

 

我们已经多次看过 pushdecl ；再次我们在上面给出该函数得到执行部分的代码。看到在 1006 行的 maybe_register_incomplete_var 对非外部的 VAR_DECL 不做处理。在退出 start_decl 时，我们得到如下的中间树。

（ 点此打开 ）

 

cp_parser_init_declarator (continue)

 

10111   /* Enter the SCOPE. That way unqualified names appearing in the

10112     initializer will be looked up in SCOPE.  */

10113   if (scope)

10114     pop_p = push_scope (scope);

10115

10116   /* Perform deferred access control checks, now that we know in which

10117     SCOPE the declared entity resides.  */

10118   if (!member_p && decl)

10119   {

10120     tree saved_current_function_decl = NULL_TREE;

10121

10122     /* If the entity being declared is a function, pretend that we

10123       are in its scope. If it is a `friend', it may have access to

10124       things that would not otherwise be accessible.  */

10125     if (TREE_CODE (decl) == FUNCTION_DECL)

10126     {

10127       saved_current_function_decl = current_function_decl ;

10128       current_function_decl = decl;

10129     }

10130     

10131     /* Perform the access control checks for the declarator and the

10132       the decl-specifiers.  */

10133     perform_deferred_access_checks ();

10134

10135     /* Restore the saved value.  */

10136     if (TREE_CODE (decl) == FUNCTION_DECL)

10137       current_function_decl = saved_current_function_decl;

10138   }

10139

10140   /* Parse the initializer.  */

10141   if (is_initialized)

10142     initializer = cp_parser_initializer (parser,

10143                                 &is_parenthesized_init,

10144                                 &is_non_constant_init);

10145   else

10146   {

10147     initializer = NULL_TREE;

10148     is_parenthesized_init = false;

10149     is_non_constant_init = true;

10150   }

          …

10178   /* Finish processing the declaration. But, skip friend

10179     declarations.  */

10180   if (!friend_p && decl)

10181     cp_finish_decl (decl,

10182                  initializer,

10183                  asm_specification,

10184                     /* If the initializer is in parentheses, then this is

10185                     a direct-initialization, which means that an

10186                     `explicit' constructor is OK. Otherwise, an

10187                     `explicit' constructor cannot be used.  */

10188                  ((is_parenthesized_init || !is_initialized)

10189                  ? 0 : LOOKUP_ONLYCONVERTING));

10190

10191   /* Remember whether or not variables were initialized by

10192     constant-expressions.  */

10193   if (decl && TREE_CODE (decl) == VAR_DECL

10194       && is_initialized && !is_non_constant_init)

10195     DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;

10196

10197   return decl;

10198 }

 

注意到在为 template-id 及 VAR_DECL 构建了节点之后，正是为相关声明符及 decl-specifier 执行延迟访问检查的时机。看到访问控制检查失败不会停止解析器。