Studying note of GCC-3.4.6 source (141 - cont 2)

Then check_initializer is invoked to verify the initializers. Here argument flags is 0.

 

4463   static tree

4464   check_initializer (tree decl, tree init, int flags, tree *cleanup)                               in decl.c

4465   {

4466     tree type = TREE_TYPE (decl);

4467     tree init_code = NULL;

4468  

4469     /* If `start_decl' didn't like having an initialization, ignore it now.  */

4470     if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)

4471       init = NULL_TREE;

4472  

4473     /* If an initializer is present, DECL_INITIAL has been

4474       error_mark_node, to indicate that an as-of-yet unevaluated

4475       initialization will occur. From now on, DECL_INITIAL reflects

4476       the static initialization -- if any -- of DECL.  */

4477     DECL_INITIAL (decl) = NULL_TREE;

4478  

4479     /* Things that are going to be initialized need to have complete

4480       type.  */

4481     TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));

4482  

4483     if (type == error_mark_node)

4484       /* We will have already complained.  */

4485       init = NULL_TREE;

4486     else if (init && COMPLETE_TYPE_P (type)

4487            && !TREE_CONSTANT (TYPE_SIZE (type)))

4488     {

4489       error ("variable-sized object `%D' may not be initialized", decl);

4490       init = NULL_TREE;

4491     }

4492     else if (TREE_CODE (type) == ARRAY_TYPE

4493            && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))

4494     {

4495       error ("elements of array `%#D' have incomplete type", decl);

4496       init = NULL_TREE;

4497     }

4498     else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))

4499     {

4500       error ("`%D' has incomplete type", decl);

4501       TREE_TYPE (decl) = error_mark_node;

4502       init = NULL_TREE;

4503     }

4504  

4505     if (TREE_CODE (decl) == CONST_DECL)

4506     {

4507       my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);

4508  

4509       DECL_INITIAL (decl) = init;

4510  

4511       my_friendly_assert (init != NULL_TREE, 149);

4512       init = NULL_TREE;

4513     }

4514     else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)

4515       init = grok_reference_init (decl, type, init, cleanup);

4516     else if (init)

4517     {

4518       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))

4519       {

4520           /* [dcl.init] paragraph 13,

4521            If T is a scalar type, then a declaration of the form

4522            T x = { a };

4523            is equivalent to

4524            T x = a;

4525       

4526            reshape_init will complain about the extra braces,

4527            and doesn't do anything useful in the case where TYPE is

4528            scalar, so just don't call it.  */

4529          if (CP_AGGREGATE_TYPE_P (type))

4530            init = reshape_init (type, &init);

4531  

4532          if ((*targetm .vector_opaque_p) (type))

4533          {

4534            error ("opaque vector types cannot be initialized");

4535            init = error_mark_node;

4536          }

4537       }

 

One of clause of [dcl.init.aggr] of C++ standard specifies that:

All implicit type conversions (clause 4) are considered when initializing the aggregate member with an initializer from an initializer-list. If the initializer can initialize a member, the member is initialized. Otherwise, if the member is itself a non-empty subaggregate, brace elision is assumed and the initializer is considered for the initialization of the first member of the subaggregate. For example:

struct A {

int i;

operator int();

};

struct B {

A a1, a2;

int z;

};

A a;

B b = { 4, a, a };

Braces are elided around the initializer for b.a1.i. b.a1.i is initialized with 4, b.a2 is initialized with a, b.z is initialized with whatever a.operator int() returns.

Routine reshape_init is invoked to transform the initializers list in form of {4, a, a } into the form of { {4, a}, a}. The rear one is what expected by the front-end.

Here for our example, the VAR_DECL is the array of vtable_entry_type and initp refers to the CONSTRUCTOR node for the initializers, which is deliberately created with empty type. So code in block at line 4289 is executed. CONSTRUCTOR_ELTS returns the inits generated in above. These initializers are treated as if enclosed by braces.

 

4267   static tree

4268   reshape_init (tree type, tree *initp)                                                                    in decl.c

4269   {

4270     tree inits;

4271     tree old_init;

4272     tree old_init_value;

4273     tree new_init;

4274     bool brace_enclosed_p;

4275     bool string_init_p;

4276  

4277     old_init = *initp;

4278     old_init_value = (TREE_CODE (*initp) == TREE_LIST

4279                    ? TREE_VALUE (*initp) : old_init);

4280  

4281     my_friendly_assert (old_init_value, 20030723);

4282  

4283     /* If the initializer is brace-enclosed, pull initializers from the

4284       enclosed elements. Advance past the brace-enclosed initializer

4285       now.  */

4286     if (TREE_CODE (old_init_value) == CONSTRUCTOR

4287        && TREE_TYPE (old_init_value) == NULL_TREE

4288        && TREE_HAS_CONSTRUCTOR (old_init_value))

4289     {

4290       *initp = TREE_CHAIN (old_init);

4291       TREE_CHAIN (old_init) = NULL_TREE;

4292       inits = CONSTRUCTOR_ELTS (old_init_value);

4293       initp = &inits;

4294       brace_enclosed_p = true;

4295     }

4296     else

4297     {

4298       inits = NULL_TREE;

4299       brace_enclosed_p = false;

4300     }

4301  

4302     /* A non-aggregate type is always initialized with a single

4303       initializer.  */

4304     if (!CP_AGGREGATE_TYPE_P (type))

4305     {

4306       *initp = TREE_CHAIN (old_init);

4307       TREE_CHAIN (old_init) = NULL_TREE;

4308       /* It is invalid to initialize a non-aggregate type with a

4309         brace-enclosed initializer.  */

4310       if (brace_enclosed_p)

4311       {

4312         error ("brace-enclosed initializer used to initialize `%T'",

4313               type);

4314         if (TREE_CODE (old_init) == TREE_LIST)

4315           TREE_VALUE (old_init) = error_mark_node;

4316         else

4317           old_init = error_mark_node;

4318       }

4319       

4320       return old_init;

4321     }

4322  

4323     /* [dcl.init.aggr]

4324  

4325       All implicit type conversions (clause _conv_) are considered when

4326       initializing the aggregate member with an initializer from an

4327       initializer-list. If the initializer can initialize a member,

4328       the member is initialized. Otherwise, if the member is itself a

4329       non-empty subaggregate, brace elision is assumed and the

4330       initializer is considered for the initialization of the first

4331       member of the subaggregate.  */

4332     if (!brace_enclosed_p

4333        && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))

4334     {

4335       *initp = TREE_CHAIN (old_init);

4336       TREE_CHAIN (old_init) = NULL_TREE;

4337       return old_init;

4338     }

4339  

4340     string_init_p = false;

4341     if (TREE_CODE (old_init_value) == STRING_CST

4342        && TREE_CODE (type) == ARRAY_TYPE

4343        && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))

4344     {

          …

4356     }

4357     else

4358     {

4359       /* Build a CONSTRUCTOR to hold the contents of the aggregate.  */ 

4360       new_init = build_constructor (type, NULL_TREE);

4361       TREE_HAS_CONSTRUCTOR (new_init) = 1;

4362  

4363       if (CLASS_TYPE_P (type))

4364       {

            …

4419       }

4420       else if ((TREE_CODE (type) == ARRAY_TYPE)|| (TREE_CODE (type) == VECTOR_TYPE))

4421       {

4422          tree max_index;

4423  

4424          /* If the bound of the array is known, take no more initializers

4425            than are allowed.  */

4426          max_index = ((TYPE_DOMAIN (type) && (TREE_CODE (type) == ARRAY_TYPE))

4427                      ? array_type_nelts (type) : NULL_TREE);

4428          if (!reshape_init_array (TREE_TYPE (type), max_index,

4429                              initp, new_init))

4430            return error_mark_node;

4431       }

4432       else

4433         abort ();

4434  

4435       /* The initializers were placed in reverse order in the

4436          CONSTRUCTOR.  */

4437       CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));

4438  

4439       if (TREE_CODE (old_init) == TREE_LIST)

4440         new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);

4441     }

4442  

4443     /* If there are more initializers than necessary, issue a

4444       diagnostic.  */ 

4445     if (*initp)

4446     {

4447       if (brace_enclosed_p)

4448         error ("too many initializers for `%T'", type);

4449       else if (warn_missing_braces && !string_init_p)

4450         warning ("missing braces around initializer");

4451     }

4452  

4453     return new_init;

4454   }

 

See for aggregate member, line 4333 verifies that type of the initializer can be converted to that of member. For array, below reshape_init_array iterates every element by reshape_init to verify and reshape the initializer. For non-aggregate member, the initializer is just returned.

 

4203   static bool

4204   reshape_init_array (tree elt_type, tree max_index,                                              in decl.c

4205                   tree *initp, tree new_init)

4206   {

4207     bool sized_array_p = (max_index != NULL_TREE);

4208     unsigned HOST_WIDE_INT max_index_cst = 0;

4209     unsigned HOST_WIDE_INT index;

4210  

4211     if (sized_array_p)

4212     {

4213       if (host_integerp (max_index, 1))

4214         max_index_cst = tree_low_cst (max_index, 1);

4215        /* sizetype is sign extended, not zero extended.  */

4216       else

4217         max_index_cst = tree_low_cst (convert (size_type_node, max_index), 1);

4218     }

4219  

4220     /* Loop until there are no more initializers.  */

4221     for (index = 0;

4222         *initp && (!sized_array_p || index <= max_index_cst);

4223         ++index)

4224     {

4225       tree element_init;

4226       tree designated_index;

4227  

4228       element_init = reshape_init (elt_type, initp);

4229       if (element_init == error_mark_node)

4230         return false;

4231       TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);

4232       CONSTRUCTOR_ELTS (new_init) = element_init;

4233       designated_index = TREE_PURPOSE (element_init);

4234       if (designated_index)

4235       {

4236          /* Handle array designated initializers (GNU extension).  */

4237         if (TREE_CODE (designated_index) == IDENTIFIER_NODE)

4238         {

4239           error ("name `%D' used in a GNU-style designated "

4240                "initializer for an array", designated_index);

4241           TREE_PURPOSE (element_init) = NULL_TREE;

4242         }

4243         else

4244           abort ();

4245       }

4246     }

4247  

4248     return true;

4259   }

 

Here TREE_PURPOSE of every initializer of our example is empty (TREE_PURPOSE is used for designated initializer, IBM’s XL C supports this feature, detail see here . See that the new CONSTRUCTOR generated has type assigned when compared with former one.

Then in check_initializer at line 4532, under x86 machine, vector_opaque_p hook in targetm always returns false. And below maybe_deduce_size_from_array_init sets the size field in the node of array, for example: int a[] = { 1, 2, 3}; the function should set the size of 3 into the node.

 

check_initializer (continue)

 

4539       /* If DECL has an array type without a specific bound, deduce the

4540          array size from the initializer.  */

4541       maybe_deduce_size_from_array_init (decl, init);

4542       type = TREE_TYPE (decl);

4543       if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))

4544         TREE_TYPE (init) = type;

4545  

4546       if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))

4547       {

            …

4579       }

4580       else

4581       {

4582   dont_use_constructor:

4583          if (TREE_CODE (init) != TREE_VEC)

4584          {

4585            init_code = store_init_value (decl, init);

4586            init = NULL;

4587          }

4588       }

4589     }

4590     else if (DECL_EXTERNAL (decl))

4591       ;

4592     else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))

4593       goto initialize_aggr;

4594     else if (IS_AGGR_TYPE (type))

4595     {

4596       tree core_type = strip_array_types (type);

4597  

4598       if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))

4599         error ("structure `%D' with uninitialized const members", decl);

4600       if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))

4601         error ("structure `%D' with uninitialized reference members",

4602               decl);

4603  

4604       check_for_uninitialized_const_var (decl);

4605     }

4606     else

4607       check_for_uninitialized_const_var (decl);

4608  

4609     if (init && init != error_mark_node)

4610       init_code = build (INIT_EXPR, type, decl, init);

4611  

4612     return init_code;

4613   }

 

Type of decl is vtbl_type_node which is ARRAY_TYPE of vtable_entry_type which in turn is a pointer of certain function type; of course no constructor is defined for this ARRAY_TYPE. So condition at line 4546 is false for type .

 

410    tree

411     store_init_value (tree decl, tree init)                                                           in typeck2.c

412    {

413      tree value, type;

414   

415      /* If variable's type was invalidly declared, just ignore it.  */

416   

417      type = TREE_TYPE (decl);

418      if (TREE_CODE (type) == ERROR_MARK)

419        return NULL_TREE;

420   

421      if (IS_AGGR_TYPE (type))

422      {

          …

432      }

433      else if (TREE_CODE (init) == TREE_LIST

434            && TREE_TYPE (init) != unknown_type_node)

435      {

          …

448      }

449   

450      /* Digest the specified initializer into an expression.  */

451      value = digest_init (type, init, (tree *) 0);

452      /* If the initializer is not a constant, fill in DECL_INITIAL with

453        the bits that are constant, and then return an expression that

454        will perform the dynamic initialization.  */

455      if (value != error_mark_node

456         && (! TREE_CONSTANT (value)

457              || ! initializer_constant_valid_p (value, TREE_TYPE (value))))

458        return split_nonconstant_init (decl, value);

459      /* If the value is a constant, just put it in DECL_INITIAL. If DECL

460        is an automatic variable, the middle end will turn this into a

461        dynamic initialization later.  */

462      DECL_INITIAL (decl) = value;

463      return NULL_TREE;

464    }

 

Here argument type is the type of the VAR_DECL. Initializers needsn’t be the same type as corresponding member as long as appropriate convertor is found. The purpose of digest_init is to find the applicable convertor and generate necessary code for this conversion, if type and init can’t match exactly.

 

476    tree

477    digest_init (tree type, tree init, tree* tail)                                                    in typeck2.c

478    {

479      enum tree_code code = TREE_CODE (type);

480      tree element = NULL_TREE;

481      tree old_tail_contents = NULL_TREE;

482      /* Nonzero if INIT is a braced grouping.  */

483      int raw_constructor;

484   

485      /* By default, assume we use one element from a list.

486        We correct this later in the sole case where it is not true.  */

487   

488      if (tail)

489      {

490        old_tail_contents = *tail;

491        *tail = TREE_CHAIN (*tail);

492      }

493   

494      if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST

495                               && TREE_VALUE (init) == error_mark_node))

496        return error_mark_node;

497   

498      if (TREE_CODE (init) == ERROR_MARK)

499        /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside

500          a template function. This gets substituted during instantiation.  */

501        return init;

502   

503      /* We must strip the outermost array type when completing the type,

504        because the its bounds might be incomplete at the moment.  */

505      if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE

506                             ? TREE_TYPE (type) : type, NULL_TREE))

507        return error_mark_node;

508     

509      /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */

510      if (TREE_CODE (init) == NON_LVALUE_EXPR)

511         init = TREE_OPERAND (init, 0);

512   

513      raw_constructor = (TREE_CODE (init) == CONSTRUCTOR

514                        && TREE_HAS_CONSTRUCTOR (init));

515   

516      if (raw_constructor

517          && CONSTRUCTOR_ELTS (init) != 0

518          && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0)

519      {

520        element = TREE_VALUE (CONSTRUCTOR_ELTS (init));

521         /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */

522        if (element && TREE_CODE (element) == NON_LVALUE_EXPR)

523          element = TREE_OPERAND (element, 0);

524        if (element == error_mark_node)

525          return element;

526      }

527   

528      /* Initialization of an array of chars from a string constant

529        optionally enclosed in braces.  */

530   

531      if (code == ARRAY_TYPE)

532      {

533        tree typ1;

534   

535        if (TREE_CODE (init) == TREE_LIST)

536        {

537          error ("initializing array with parameter list");

538          return error_mark_node;

539        }

540   

541        typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));

542        if (char_type_p (typ1)

543           && ((init && TREE_CODE (init) == STRING_CST)

544                || (element && TREE_CODE (element) == STRING_CST)))

545        {

            …

577        }

578      }

579   

580      /* Handle scalar types, including conversions,

581        and signature pointers and references.  */

582   

583      if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE

584           || code == ENUMERAL_TYPE || code == REFERENCE_TYPE

585          || code == BOOLEAN_TYPE || code == COMPLEX_TYPE

586          || TYPE_PTR_TO_MEMBER_P (type))

587      {

588        if (raw_constructor)

589        {

590          if (element == 0)

591          {

592            error ("initializer for scalar variable requires one element");

593            return error_mark_node;

594          }

595          init = element;

596        }

597        while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))

598        {

599          pedwarn ("braces around scalar initializer for `%T'", type);

600          init = CONSTRUCTOR_ELTS (init);

601          if (TREE_CHAIN (init))

602            pedwarn ("ignoring extra initializers for `%T'", type);

603          init = TREE_VALUE (init);

604        }

605   

606        return convert_for_initialization (0, type, init, LOOKUP_NORMAL,

607                                   "initialization", NULL_TREE, 0);

608      }

609   

610      /* Come here only for records and arrays (and unions with constructors).  */

611    

612      if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type)))

613      {

614        error ("variable-sized object of type `%T' may not be initialized",

615              type);

616        return error_mark_node;

617      }

618   

619      if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code))

620      {

621        if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type)

622           && TREE_HAS_CONSTRUCTOR (init))

623        {

624          error ("subobject of type `%T' must be initialized by constructor, not by `%E'",

625                type, init);

626          return error_mark_node;

627        }

628        else if (raw_constructor)

629          return process_init_constructor (type, init, (tree *)0);

          …

649      }

650   

651      error ("invalid initializer");

652      return error_mark_node;

653    }

 

For the initializers of our example, at line 513, raw_constructor is nonzero; and code is ARRAY_TYPE. Then argument init is passed to process_init_constructor for handling.

 

670    static tree

671    process_init_constructor (tree type, tree init, tree* elts)                               in typeck2.c

672    {

673      tree tail;

674      /* List of the elements of the result constructor,

675        i n reverse order.  */

676      tree members = NULL;

677      tree next1;

678      tree result;

679      int allconstant = 1;

680      int allsimple = 1;

681      int erroneous = 0;

682   

683      /* Make TAIL be the list of elements to use for the initialization,

684        no matter how the data was given to us.  */

685   

686      if (elts)

687      {

688        if (warn_missing_braces )

689           warning ("aggregate has a partly bracketed initializer");

690        tail = *elts;

691      }

692      else

693        tail = CONSTRUCTOR_ELTS (init);

694   

695      /* Gobble as many elements as needed, and make a constructor or initial value

696        for each element of this aggregate. Chain them together in result.

697        If there are too few, use 0 for each scalar ultimate component.  */

698   

699      if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE)

700      {

701        long len;

702        int i;

703   

704        if (TREE_CODE (type) == ARRAY_TYPE)

705        {

706          tree domain = TYPE_DOMAIN (type);

707          if (domain)

708            len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain))

709                  - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain))

710                   + 1);

711           else

712            len = -1;  /* Take as many as there are.  */

713        }

714        else

715        {

716          /* Vectors are like simple fixed-size arrays.  */

717          len = TYPE_VECTOR_SUBPARTS (type);

718        }

719   

720        for (i = 0; len < 0 || i < len; i++)

721        {

722          if (tail)

723          {

724            if (TREE_PURPOSE (tail)

725              && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST

726                   || compare_tree_int (TREE_PURPOSE (tail), i) != 0))

727              sorry ("non-trivial labeled initializers");

728   

729            if (TREE_VALUE (tail) != 0)

730            {

731              tree tail1 = tail;

732              next1 = digest_init (TREE_TYPE (type),

733                              TREE_VALUE (tail), &tail1);

734              if (next1 == error_mark_node)

735                return next1;

736              my_friendly_assert

737                   (same_type_ignoring_top_level_qualifiers_p

738                         (TREE_TYPE (type), TREE_TYPE (next1)),

739                         981123);

740              my_friendly_assert (tail1 == 0

741                               || TREE_CODE (tail1) == TREE_LIST, 319);

742              if (tail == tail1 && len < 0)

743              {

744                error ("non-empty initializer for array of empty elements");

745                /* Just ignore what we were supposed to use.  */

746                tail1 = NULL_TREE;

747              }

748              tail = tail1;

749            }

750            else

751            {

752              next1 = error_mark_node;

753              tail = TREE_CHAIN (tail);

754            }

755          }

756          else if (len < 0)

757            /* We're done.  */

758            break ;

759          else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))

760          {

              …

771          }

772           else if (! zero_init_p (TREE_TYPE (type)))

773            next1 = build_zero_init (TREE_TYPE (type),

774                                /*nelts=*/ NULL_TREE,

775                                /*static_storage_p=*/ false);

776          else

777            /* The default zero-initialization is fine for us; don't

778              add anything to the CONSTRUCTOR.  */

779            break ;

780   

781          if (next1 == error_mark_node)

782            erroneous = 1;

783          else if (!TREE_CONSTANT (next1))

784            allconstant = 0;

785          else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1)))

786            allsimple = 0;

787          members = tree_cons (size_int (i), next1, members);

788        }

789      }

790      else if (TREE_CODE (type) == RECORD_TYPE)

791      {

          …

908      }

909      else if (TREE_CODE (type) == UNION_TYPE

910            /* If the initializer was empty, use default zero initialization.  */

911             && tail)

912      {

          …

977      }

978   

979      /* If arguments were specified as a list, just remove the ones we used.   */

980      if (elts)

981        *elts = tail;

982      /* If arguments were specified as a constructor,

983        complain unless we used all the elements of the constructor.  */

984      else if (tail)

985        pedwarn ("excess elements in aggregate initializer");

986   

987      if (erroneous)

988        return error_mark_node;

989   

990      result = build_constructor (type, nreverse (members));

991      if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE)

992        complete_array_type (type, result, /*do_default=*/ 0);

993      if (init)

994        TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init);

995      if (allconstant) TREE_CONSTANT (result) = 1;

996      if (allconstant && allsimple) TREE_STATIC (result) = 1;

997      return result;

998    }

 

Not surprising, for each element of ARRAY_TYPE, digest_init is recursed. Note that in this invocation, argument tail is the initializers. If digest_init can process part of initializers successfully. This part will be removed from the list of initializers. At line 606, convert_for_initialization is invoked to do the possible conversion. Here in our example, no conversion is expected as we prepare init of type vtable_entry_type before hand. As a result, the function returns init as returned value.

Exitting convert_for_initialization gets out of digest_init immediately, which means this (part) initializer is verified. At line 787, this returned value is chained into members . Next at line 990, new version CONSTRUCTOR is created. See that all elements of vtable should be constant. And this CONSTRUCTOR allocates static storage (i.e, initializes static member). Then at line 4902 in cp_finish_decl , store_init_value returns NULL

 

cp_finish_decl (continue)

 

4953     /* Add this declaration to the statement-tree. This needs to happen

4954       after the call to check_initializer so that the DECL_STMT for a

4955       reference temp is added before the DECL_STMT for the reference itself.  */

4956     if (at_function_scope_p ())

4957       add_decl_stmt (decl);

4958  

4959     if (TREE_CODE (decl) == VAR_DECL)

4960       layout_var_decl (decl);

4961  

4962     /* Output the assembler code and/or RTL code for variables and functions,

4963       unless the type is an undefined structure or union.

4964       If not, it will get done when the type is completed.  */

4965     if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)

4966     {

4967       if (TREE_CODE (decl) == VAR_DECL)

4968         maybe_commonize_var (decl);

4969  

4970       make_rtl_for_nonlocal_decl (decl, init, asmspec);

4971  

4972       if (TREE_CODE (type) == FUNCTION_TYPE

4973           || TREE_CODE (type) == METHOD_TYPE)

4974         abstract_virtuals_error (decl,

4975                              strip_array_types (TREE_TYPE (type)));

4976       else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)

4977       {

4978         /* If it's either a pointer or an array type, strip through all

4979            of them but the last one. If the last is an array type, issue

4980            an error if the element type is abstract.  */

4981         while (POINTER_TYPE_P (TREE_TYPE (type))

4982                || TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)

4983            type = TREE_TYPE (type);

4984         if (TREE_CODE (type) == ARRAY_TYPE)

4985            abstract_virtuals_error (decl, TREE_TYPE (type));

4986       }

4987       else

4988         abstract_virtuals_error (decl, type);

4989  

4990       if (TREE_CODE (decl) == FUNCTION_DECL

4991           || TREE_TYPE (decl) == error_mark_node)

4992         /* No initialization required.  */

4993         ;

4994       else if (DECL_EXTERNAL (decl)

4995              && ! (DECL_LANG_SPECIFIC (decl)

4996                    && DECL_NOT_REALLY_EXTERN (decl)))

4997       {

4998          if (init)

4999            DECL_INITIAL (decl) = init;

5000       }

5001       else

5002       {

5003          /* A variable definition.  */

5004          if (DECL_FUNCTION_SCOPE_P (decl))

5005          {

5006            /* This is a local declaration.  */

5007              maybe_inject_for_scope_var (decl);

5008            /* Initialize the local variable.  */

5009            if (processing_template_decl )

5010           {

5011              if (init || DECL_INITIAL (decl) == error_mark_node)

5012                DECL_INITIAL (decl) = init;

5013           }

5014            else if (!TREE_STATIC (decl))

5015             initialize_local_var (decl, init);

5016          }

5017  

5018          /* If a variable is defined, and then a subsequent

5019             definintion with external linkage is encountered, we will

5020             get here twice for the same variable. We want to avoid

5021             calling expand_static_init more than once. For variables

5022             that are not static data members, we can call

5023             expand_static_init only when we actually process the

5024             initializer. It is not legal to redeclare a static data

5025             member, so this issue does not arise in that case.  */

5026          if (var_definition_p && TREE_STATIC (decl))

5027            expand_static_init (decl, init);

5028       }

5029   finish_end0:

5030  

5031        /* Undo call to `pushclass' that was done in `start_decl'

5032          due to initialization of qualified member variable.

5033         I.e., Foo::x = 10;  */

5034       {

5035         tree context = CP_DECL_CONTEXT (decl);

5036         if (context

5037             && TYPE_P (context)

5038             && (TREE_CODE (decl) == VAR_DECL

5039                /* We also have a pushclass done that we need to undo here

5040                   if we're at top level and declare a method.  */

5041                || TREE_CODE (decl) == FUNCTION_DECL)

5042             /* If size hasn't been set, we're still defining it,

5043               and therefore inside the class body; don't pop

5044                  the binding level..  */

5045               && COMPLETE_TYPE_P (context)

5046               && context == current_class_type )

5047             pop_nested_class ();

5048       }

5049     }

5050  

5051     /* If a CLEANUP_STMT was created to destroy a temporary bound to a

5052       reference, insert it in the statement-tree now.  */

5053     if (cleanup)

5054       add_stmt (cleanup);

5055  

5056   finish_end:

5057  

5058     if (was_readonly)

5059       TREE_READONLY (decl) = 1;

5060  

5061     /* If this was marked 'used', be sure it will be output.  */

5062     if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))

5063       mark_referenced (DECL_ASSEMBLER_NAME (decl));

5064   }

 

As in initialize_array at line 6809, context of decl is temperarily cleaned, at_function_scope_p at line 4956 returns false. Then maybe_commonize_var at line 4968 handles the situation in which a local static variable is declared in an inline function, or we have a weak definition, for which the compile must endeavor to create only one instance of the variable at link-time.

Then back cp_finish_decl , at line 4970, within make_rtl_for_nonlocal_decl , the local variable defer_p is set as true at line 4658 as this VAR_DECL has flag DECL_VIRTUAL_P set; further at invocation, asmspec is NULL. So nothing non-trivial is done in this function.

Next, as var_definition_p is true at line 5026, expand_static_init is invoked, however, as the ARRAY_TYPE of the vtable hasn’t flag TYPE_NEEDS_CONSTRUCTING set, the function exits immediately.

At last, cleanup at line 5053 may be not NULL if we are handling referecne (here it is NULL). Exitting from cp_finish_decl , we go back finish_struct_1 in below.