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.
