Studying note of GCC-3.4.6 source (132)

5.12.5.2.2.2.1.2.    Create the VAR_DECL

Next in cp_parser_simple_declaration , cp_parser_init_declarator is invoked to parse the declarator part. With call-stack of cp_parser_declarator à cp_parser_direct_declarator à cp_parser_declarator_id à cp_parser_id_expression à cp_parser_unqualified_id à cp_parser_identifier , it creates an IDENTIFIER_NODE for “object_”. Then continue in cp_parser_init_declarator following code snippet would be executed.

 

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_” is a variable declaration. A new tree node needs be created to stand for this entity in the intermediate tree. At this invocation, argument intialized is false, attributes and prefix_attributes both are 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;

 

Being a kind of declaration, ceratin DECL node is expected, so grokdeclarator analyses the part of decl-specifiers and declaractor to form this node.

 

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   }

 

In above code, it is very clearly that code of WHILE block at line 6525 verifies the declarator part; and code of FOR block at line 6844 verifies and retrieves the corresponding type-specifier. Note that at line 6941, type refers to the RECORD_TYPE created in last section.

Next type and declarator should be combined to form the VAR_DECL by grokvardecl . Note that for our case, during invocation, argument scope is NULL, constp is false, initialized is false, and specbits_in contains 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   }

 

After this step, we get following VAR_DECL as below figure. Note that context field of the node is NULL as we are not within class scope.

(Click here for open )

 

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   }

 

Being a VAR_DECL node containing context field of NULL, maybe_push_decl invokes pushdecl for decl . And for our case, start_decl_1 at line 3852 does nothing.

 

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   }

 

We have seen pushdecl many times; again we just put the executed code of the function in above. Note that maybe_register_incomplete_var at line 1006 does nothing for non-external VAR_DECL. At the exit of start_decl we get following intermediate tree.

( Click here for open )

 

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 }

 

Notice that after creating the nodes for template-id and VAR_DECL, it is time to perform the deferred access checking for the related declarator and decl-specifier. See that error in access checking will not stop the parser.