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

In TYPE_FIELDS of class node, a FIELD_DECL is used to represent a
non-static data member, a VAR_DECL is used to represent a static data member,
and a TYPE_DECL is used to represent a type. The CONST_DECL for an enumeration
constant will appear on TYPE_FIELDS list, if the enumeration type was declared
in the class.

So entities other than non-static member are handled by code from
line 4691 to 4707. Notice hat type of static member can be imcomplete in the
class definition as it doesn’t occupy space of the object of the class. It
shows the philosophy of C++ language – gives flexiblilty as possible.

layout_class_type (continue)

4683

Layout the non-static data members.
*/

4684

for
(field =
non_static_data_members; field; field = TREE_CHAIN (field))

4685

{

4686

tree type;

4687

tree padding;

4688

4689

/* We still pass things that aren't non-static
data members to

4690

the back-end, in case it
wants to do something with them.
*/

4691

if (TREE_CODE (field) != FIELD_DECL)

4692

{

4693

place_field (rli, field);

4694

/* If the static
data member has incomplete type, keep track

4695

of it so that it can be
completed later. (The handling

4696

of pending statics in
finish_record_layout is

4697

insufficient; consider:

4698

4699

struct S1;

4700

struct S2 { static S1 s1;
};

4701

4702

At this point,
finish_record_layout will be called, but

4703

S1 is still
incomplete.)
*/

4704

if (TREE_CODE (field) == VAR_DECL)

4705

maybe_register_incomplete_var (field);

4706

continue
;

4707

}

4708

4709

type = TREE_TYPE (field);

4710

4711

padding = NULL_TREE;

4712

4713

/* If this field
is a bit-field whose width is greater than its

4714

type, then there are some
special rules for allocating

4715

it.
*/

4716

if (DECL_C_BIT_FIELD (field)

4717

&& INT_CST_LT (TYPE_SIZE (type),
DECL_SIZE (field)))

4718

{

4719

integer_type_kind itk;

4720

tree integer_type;

4721

bool was_unnamed_p = false;

4722

/* We must
allocate the bits as if suitably aligned for the

4723

longest integer type that
fits in this many bits. type

4724

of the field. Then, we are
supposed to use the left over

4725

bits as additional
padding.
*/

4726

for
(itk
= itk_char; itk != itk_none; ++itk)

4727

if (INT_CST_LT (DECL_SIZE (field),

4728

TYPE_SIZE
(integer_types[itk])))

4729

break
;

4730

4731

/* ITK now
indicates a type that is too large for the

4732

field. We have to back up
by one to find the largest

4733

type that fits.
*/

4734

integer_type = integer_types[itk - 1];

4735

4736

/* Figure out
how much additional padding is required. GCC

4737

3.2 always created a
padding field, even if it had zero

4738

width.
*/

4739

if (!abi_version_at_least (2)

4740

|| INT_CST_LT (TYPE_SIZE
(integer_type), DECL_SIZE (field)))

4741

{

4742

if (abi_version_at_least (2) &&
TREE_CODE (t) == UNION_TYPE)

4743

/* In a
union, the padding field must have the full width

4744

of the bit-field; all
fields start at offset zero.
*/

4745

padding = DECL_SIZE (field);

4746

else

4747

{

4748

if (warn_abi

&& TREE_CODE (t)
== UNION_TYPE)

4749

warning ("size assigned to
`%T' may not be "

4750

"ABI-compliant and may
change in a future "

4751

"version of GCC",

4752

t);

4753

padding = size_binop (MINUS_EXPR,
DECL_SIZE (field),

4754

TYPE_SIZE
(integer_type));

4755

}

4756

}

4757

#ifdef
PCC_BITFIELD_TYPE_MATTERS

4758

/* An unnamed
bitfield does not normally affect the

4759

alignment of the
containing class on a target where

4760

PCC_BITFIELD_TYPE_MATTERS.
But, the C++ ABI does not

4761

make any exceptions for
unnamed bitfields when the

4762

bitfields are longer than
their types. Therefore, we

4763

temporarily give the field a name.
*/

4764

if (PCC_BITFIELD_TYPE_MATTERS &&
!DECL_NAME (field))

4765

{

4766

was_unnamed_p = true;

4767

DECL_NAME (field) = make_anon_name ();

4768

}

4769

#endif

4770

DECL_SIZE (field) = TYPE_SIZE
(integer_type);

4771

DECL_ALIGN (field) = TYPE_ALIGN
(integer_type);

4772

DECL_USER_ALIGN (field) = TYPE_USER_ALIGN
(integer_type);

4773

layout_nonempty_base_or_field
(rli, field, NULL_TREE,

4774

empty_base_offsets);

4775

if (was_unnamed_p)

4776

DECL_NAME (field) = NULL_TREE;

4777

/* Now that layout has been performed, set the
size of the

4778

field to the size of its
declared type; the rest of the

4779

field is effectively
invisible.
*/

4780

DECL_SIZE (field) = TYPE_SIZE (type);

4781

/* We must also
reset the DECL_MODE of the field.
*/

4782

if (abi_version_at_least (2))

4783

DECL_MODE (field) = TYPE_MODE (type);

4784

else if (warn_abi

4785

&& DECL_MODE (field) !=
TYPE_MODE (type))

4786

/* Versions
of G++ before G++ 3.4 did not reset the

4787

DECL_MODE.
*/

4788

warning ("the offset of `%D' may
not be ABI-compliant and may "

4789

"change in a future
version of GCC", field);

4790

}

4791

else

4792

layout_nonempty_base_or_field
(rli, field, NULL_TREE,

4793

empty_base_offsets);

4794

4795

/* Remember the location of any empty classes
in FIELD.
*/

4796

if (abi_version_at_least (2))

4797

record_subobject_offsets
(TREE_TYPE (field),

4798

byte_position(field),

4799

empty_base_offsets,

4800

/*vbases_p=*/
1);

See that see data members are processed by layout_nonempty_base_or_field

as previous section. But for statement like: “char i: 16;” which declares a
width larger than its type size, the compiler needs promote its type
automatically. However, the compiler selects the type that just inferior to the
one larger than the requested size and left the leaving bits as padding which
will be added later, in order to use as small space as possible. As in place_field

,
now this bit-field will be aligned to the boundary of the alignment of this new
type by default.

layout_class_type (continue)

4802

/*
If a bit-field does not immediately follow another bit-field,

4803

and
yet it starts in the middle of a byte, we have failed to

4804

comply with the ABI.
*/

4805

if (warn_abi

4806

&&
DECL_C_BIT_FIELD (field)

4807

&& !last_field_was_bitfield

4808

&&
!integer_zerop (size_binop (TRUNC_MOD_EXPR,

4809

DECL_FIELD_BIT_OFFSET
(field),

4810

bitsize_unit_node)))

4811

cp_warning_at
("offset of `%D' is not ABI-compliant and may change in a future version
of GCC",

4812

field);

4813

4814

/* G++ used to use DECL_FIELD_OFFSET as if it
were the byte

4815

offset of the field.
*/

4816

if (warn_abi

4817

&&
!tree_int_cst_equal (DECL_FIELD_OFFSET (field),

4818

byte_position
(field))

4819

&&
contains_empty_class_p (TREE_TYPE (field)))

4820

cp_warning_at
("`%D' contains empty classes which may cause base "

4821

"classes to be placed
at different locations in a "

4822

"future version of
GCC",

4823

field);

4824

4825

/*
If we needed additional padding after this field, add it

4826

now.

*/

4827

if (padding)

4828

{

4829

tree padding_field;

4830

4831

padding_field = build_decl
(FIELD_DECL,

4832

NULL_TREE,

4833

char_type_node);

4834

DECL_BIT_FIELD (padding_field) = 1;

4835

DECL_SIZE (padding_field) = padding;

4836

DECL_CONTEXT (padding_field) = t;

4837

DECL_ARTIFICIAL (padding_field) = 1;

4838

layout_nonempty_base_or_field
(rli, padding_field,

4839

NULL_TREE,

4840

empty_base_offsets);

4841

}

4842

4843

last_field_was_bitfield = DECL_C_BIT_FIELD
(field);

4844

}

Above padding

is the left bits, which is created as bit-field of char which will be aligned
at byte boundary, so it can catch up the former part of the bit-field well.

layout_class_type (continue)

4846

if (abi_version_at_least (2) &&
!integer_zerop (rli->bitpos))

4847

{

4848

/* Make sure that
we are on a byte boundary so that the size of

4849

the class without virtual
bases will always be a round number

4850

of bytes.
*/

4851

rli->bitpos = round_up
(rli->bitpos, BITS_PER_UNIT);

4852

normalize_rli
(rli);

4853

}

4854

4855

/* G++ 3.2 does not
allow virtual bases to be overlaid with tail

4856

padding.
*/

4857

if (!abi_version_at_least (2))

4858

include_empty_classes
(rli);

4859

4860

/* Delete all
zero-width bit-fields from the list of fields. Now

4861

that the type is laid out they
are no longer important.
*/

4862

remove_zero_width_bit_fields
(t);

At this point, all fields have been laid out except non-primary
vritual bases, first we round up the size of the class to bytes boundary, and
remove empty bit-fields (only bit-field, not field of empty base).

4070

static
void

4071

remove_zero_width_bit_fields

(tree t)
in
class.c

4072

{

4073

tree *fieldsp;

4074

4075

fieldsp = &TYPE_FIELDS (t);

4076

while
(*fieldsp)

4077

{

4078

if (TREE_CODE (*fieldsp) == FIELD_DECL

4079

&& DECL_C_BIT_FIELD (*fieldsp)

4080

&& DECL_INITIAL (*fieldsp))

4081

*fieldsp = TREE_CHAIN (*fieldsp);

4082

else

4083

fieldsp = &TREE_CHAIN (*fieldsp);

4084

}

4085

}

Now it is to create node for CLASSTYPE_AS_BASE which excludes
virtual base classes. And this node will be used to create associated
FIELD_DECL in the class. When the class used as base, this type is the
representive of the class (that is why virtual bases to be excluded, as they
are shared among the hierarchy tree).

Notice that it uses make_node

to create the node instead of make_aggr_type

,
so predicate CLASS_TYPE_P will fail, when this base part used as base class and
inserted as FIELD_DECL in deriving type, abstract_virtuals_error

in check_field_decl

will be skipped. The reason to do so is deliberate,
considering an abstract base, it can be used as a base, but not allowed as a
field in a class. Both forms will have FIELD_DECL generated but with different
type node associated; for the later one, the regular RECORD_TYPE node is used
and runs abstract_virtuals_error

in check_field_decl

.

layout_class_type (continue)

4864

/* Create the
version of T used for virtual bases. We do not use

4865

make_aggr_type for this
version; this is an artificial type. For

4866

a POD type, we just reuse T.
*/

4867

if (CLASSTYPE_NON_POD_P (t) ||
CLASSTYPE_EMPTY_P (t))

4868

{

4869

base_t =
make_node

(TREE_CODE (t));

4870

4871

/* Set the size
and alignment for the new type. In G++ 3.2, all

4872

empty classes were
considered to have size zero when used as

4873

base classes.
*/

4874

if (!abi_version_at_least (2) &&
CLASSTYPE_EMPTY_P (t))

4875

{

4876

TYPE_SIZE (base_t) = bitsize_zero_node;

4877

TYPE_SIZE_UNIT (base_t) = size_zero_node;

4878

if (warn_abi

&& !integer_zerop (rli_size_unit_so_far
(rli)))

4879

warning ("layout of classes
derived from empty class `%T' "

4880

"may change in a future version of
GCC",

4881

t);

4882

}

4883

else

4884

{

4885

tree eoc;

4886

4887

/* If the ABI
version is not at least two, and the last

4888

field was a bit-field, RLI
may not be on a byte

4889

boundary. In particular,
rli_size_unit_so_far might

4890

indicate the last complete
byte, while rli_size_so_far

4891

indicates the total number
of bits used. Therefore,

4892

rli_size_so_far, rather
than rli_size_unit_so_far, is

4893

used to compute
TYPE_SIZE_UNIT.
*/

4894

eoc = end_of_class
(t, /*include_virtuals_p=*/
0);

4895

TYPE_SIZE_UNIT (base_t)

4896

= size_binop (MAX_EXPR,

4897

convert (sizetype,

4898

size_binop
(CEIL_DIV_EXPR,

4899

rli_size_so_far
(rli),

4900

bitsize_int
(BITS_PER_UNIT))),

4901

eoc);

4902

TYPE_SIZE (base_t)

4903

= size_binop (MAX_EXPR,

4904

rli_size_so_far
(rli),

4905

size_binop (MULT_EXPR,

4906

convert (bitsizetype,
eoc),

4907

bitsize_int
(BITS_PER_UNIT)));

4908

}

4909

TYPE_ALIGN (base_t) = rli->record_align;

4910

TYPE_USER_ALIGN (base_t) = TYPE_USER_ALIGN (t);

4911

4912

/* Copy the
fields from T.
*/

4913

next_field = &TYPE_FIELDS (base_t);

4914

for
(field
= TYPE_FIELDS (t); field; field = TREE_CHAIN (field))

4915

if (TREE_CODE (field) == FIELD_DECL)

4916

{

4917

*next_field = build_decl
(FIELD_DECL,

4918

DECL_NAME (field),

4919

TREE_TYPE
(field));

4920

DECL_CONTEXT (*next_field) = base_t;

4921

DECL_FIELD_OFFSET (*next_field) =
DECL_FIELD_OFFSET (field);

4922

DECL_FIELD_BIT_OFFSET (*next_field)

4923

= DECL_FIELD_BIT_OFFSET (field);

4924

DECL_SIZE (*next_field) = DECL_SIZE
(field);

4925

DECL_MODE (*next_field) = DECL_MODE
(field);

4926

next_field = &TREE_CHAIN
(*next_field);

4927

}

4928

4929

/* Record the base version of the type.

*/

4930

CLASSTYPE_AS_BASE (t) = base_t;

4931

TYPE_CONTEXT (base_t) = t;

4932

}

4933

else

4934

CLASSTYPE_AS_BASE (t) = t;

Routine end_of_class

returns the offset of the byte
just past the end of the base class with the highest offset in t

. If
argument include_virtuals_p

is zero, then only non-virtual bases are included. See that for empty class, end_of_class

now returns size_zero_node

for it.

4503

static
tree

4504

end_of_class

(tree t, int
include_virtuals_p)
in
class.c

4505

{

4506

tree result = size_zero_node;

4507

tree binfo;

4508

tree offset;

4509

int i;

4510

4511

for
(i = 0; i < CLASSTYPE_N_BASECLASSES (t); ++i)

4512

{

4513

binfo = BINFO_BASETYPE
(TYPE_BINFO (t),
i);

4514

4515

if (!include_virtuals_p

4516

&& TREE_VIA_VIRTUAL (binfo)

4517

&& BINFO_PRIMARY_BASE_OF (binfo)
!= TYPE_BINFO (t))

4518

continue
;

4519

4520

offset = end_of_base
(binfo);

4521

if (INT_CST_LT_UNSIGNED (result, offset))

4522

result = offset;

4523

}

4524

4525

/* G++ 3.2 did not
check indirect virtual bases.
*/

4526

if (abi_version_at_least (2) &&
include_virtuals_p)

4527

for
(binfo
= CLASSTYPE_VBASECLASSES (t);

4528

binfo;

4529

binfo = TREE_CHAIN (binfo))

4530

{

4531

offset = end_of_base
(TREE_VALUE (binfo));

4532

if (INT_CST_LT_UNSIGNED (result, offset))

4533

result = offset;

4534

}

4535

4536

return
result;

4537

}

Routine end_of_base

returns the offset of the byte
just past the end of the base class binfo

.

4483

static
tree

4484

end_of_base

(tree binfo)
in
class.c

4485

{

4486

tree size;

4487

4488

if (is_empty_class (BINFO_TYPE (binfo)))

4489

/* An empty class
has zero CLASSTYPE_SIZE_UNIT, but we need to

4490

allocate some space for it.
It cannot have virtual bases, so

4491

TYPE_SIZE_UNIT is fine.
*/

4492

size = TYPE_SIZE_UNIT (BINFO_TYPE (binfo));

4493

else

4494

size = CLASSTYPE_SIZE_UNIT (BINFO_TYPE
(binfo));

4495

4496

return
size_binop (PLUS_EXPR, BINFO_OFFSET (binfo), size);

4497

}

Above TYPE_SIZE_UNIT returns the size of type in byte. And even
emtpy class will occupy 1 byte which can be see later in layout_class_type

. While
CLASSTYPE_SIZE_UNIT asks for TYPE_SIZE_UNIT of CLASSTYPE_AS_BASE of binfo

,
which excludes virtual bases.

layout_class_type (continue)

4936

/* Every empty
class contains an empty class.
*/

4937

if (CLASSTYPE_EMPTY_P (t))

4938

CLASSTYPE_CONTAINS_EMPTY_CLASS_P (t) = 1;

4939

4940

/* Set the TYPE_DECL
for this type to contain the right

4941

value for DECL_OFFSET, so that
we can use it as part

4942

of a COMPONENT_REF for
multiple inheritance.
*/

4943

layout_decl
(TYPE_MAIN_DECL (t), 0);

4944

4945

/* Now fix up any
virtual base class types that we left lying

4946

around. We must get these done
before we try to lay out the

4947

virtual function table. As a
side-effect, this will remove the

4948

base subobject fields.
*/

4949

layout_virtual_bases
(rli, empty_base_offsets);

4950

4951

/* Make sure that
empty classes are reflected in RLI at this

4952

point.
*/

4953

include_empty_classes
(rli);

4954

4955

/* Make sure not to
create any structures with zero size.
*/

4956

if (integer_zerop
(rli_size_unit_so_far
(rli)) &&
CLASSTYPE_EMPTY_P (t))

4957

place_field
(rli,

4958

build_decl
(FIELD_DECL, NULL_TREE, char_type_node));

4959

4960

/* Let the back-end
lay out the type.
*/

4961

finish_record_layout
(rli, /*free_p=*/
true);

4962

4963

/* Warn about bases
that can't be talked about due to ambiguity.

*/

4964

warn_about_ambiguous_bases
(t);

4965

4966

/* Clean up.
*/

4967

splay_tree_delete (empty_base_offsets);

4968

}

Remember that we always lay out CLASSTYPE_AS_BASE of direct and
indirect bases, which exclude virtual bases contained. Now it is time to lay
out all the virutal direct or indirect bases except that uses as primary base.

4408

static
void

4409

layout_virtual_bases

(record_layout_info
rli, splay_tree offsets)
in
class.c

4410

{

4411

tree vbase;

4412

tree t = rli->t;

4413

bool first_vbase = true;

4414

tree *next_field;

4415

4416

if (CLASSTYPE_N_BASECLASSES (t) == 0)

4417

return
;

4418

4419

if (!abi_version_at_least(2))

4420

{

4421

/* In G++ 3.2, we incorrectly rounded the size
before laying out

4422

the virtual bases.
*/

4423

finish_record_layout
(rli, /*free_p=*/
false);

4424

#ifdef
STRUCTURE_SIZE_BOUNDARY

4425

/* Packed
structures don't need to have minimum size.

*/

4426

if (! TYPE_PACKED (t))

4427

TYPE_ALIGN (t) = MAX
(TYPE_ALIGN (t), (unsigned) STRUCTURE_SIZE_BOUNDARY);

4428

#endif

4429

rli->offset = TYPE_SIZE_UNIT (t);

4430

rli->bitpos = bitsize_zero_node;

4431

rli->record_align = TYPE_ALIGN (t);

4432

}

4433

4434

/* Find the last
field. The artificial fields created for virtual

4435

bases will go after the last
extant field to date.
*/

4436

next_field = &TYPE_FIELDS (t);

4437

while
(*next_field)

4438

next_field = &TREE_CHAIN (*next_field);

4439

4440

/* Go through the
virtual bases, allocating space for each virtual

4441

base that is not already a
primary base class. These are

4442

allocated in inheritance graph
order.
*/

4443

for
(vbase =
TYPE_BINFO (t); vbase; vbase = TREE_CHAIN (vbase))

4444

{

4445

if (!TREE_VIA_VIRTUAL (vbase))

4446

continue
;

4447

4448

if (!BINFO_PRIMARY_P (vbase))

4449

{

4450

tree basetype = TREE_TYPE (vbase);

4451

4452

/* This virtual base is not a primary base of
any class in the

4453

hierarchy, so we have to
add space for it.
*/

4454

next_field = build_base_field
(rli, vbase,

4455

offsets,
next_field);

4456

4457

/* If the first virtual base might have been
placed at a

4458

lower address, had we
started from CLASSTYPE_SIZE, rather

4459

than TYPE_SIZE, issue a
warning. There can be both false

4460

positives and false
negatives from this warning in rare

4461

cases; to deal with all
the possibilities would probably

4462

require performing both
layout algorithms and comparing

4463

the results which is not
particularly tractable.
*/

4464

if (warn_abi

4465

&& first_vbase

4466

&& (tree_int_cst_lt

4467

(size_binop (CEIL_DIV_EXPR,

4468

round_up
(CLASSTYPE_SIZE (t),

4469

CLASSTYPE_ALIGN (basetype)),

4470

bitsize_unit_node),

4471

BINFO_OFFSET (vbase))))

4472

warning ("offset of virtual base
`%T' is not ABI-compliant and may change in a future version of GCC",

4473

basetype);

4474

4475

first_vbase = false;

4476

}

4477

}

4478

}

As we are to lay out direct or indirect virtual bases, we need
transverse the hierarchy tree to visit all these bases. Also such bases need
FIELD_DECL built in build_base_field

. It shows that lay-out of
virtual base is the same as non-virtual base indeed. Notice that The FIELD_DECL
of the virtual base is also contain the part without virtual base of it.

In build_base_field

,
we can see that the layout of empty base is only reflected by BINFO_OFFSET in
type, which is propagated to bases affected by propagate_binfo_offsets

. But
rli

–
the data keeps the track of layout doesn’t know it. All it needs be done now,
is update the size information in rli

to accommodate these empty types.

4591

static
void

4592

include_empty_classes

(record_layout_info rli)

in class.c

4593

{

4594

tree eoc;

4595

tree rli_size;

4596

4597

/* It might be the
case that we grew the class to allocate a

4598

zero-sized base class. That
won't be reflected in RLI, yet,

4599

because we are willing to
overlay multiple bases at the same

4600

offset. However, now we need
to make sure that RLI is big enough

4601

to reflect the entire
class.
*/

4602

eoc = end_of_class
(rli->t,

4603

CLASSTYPE_AS_BASE (rli->t) !=
NULL_TREE);

4604

rli_size = rli_size_unit_so_far
(rli);

4605

if (TREE_CODE (rli_size) == INTEGER_CST

4606

&& INT_CST_LT_UNSIGNED (rli_size,
eoc))

4607

{

4608

if (!abi_version_at_least (2))

4609

/* In version 1
of the ABI, the size of a class that ends with

4610

a bitfield was not rounded up to a whole multiple of a

4611

byte. Because rli_size_unit_so_far returns
only the number

4612

of fully allocated bytes, any extra bits
were not included

4613

i
n the size.
*/

4614

rli->bitpos = round_down
(rli->bitpos, BITS_PER_UNIT);

4615

else

4616

/* The size
should have been rounded to a whole byte.

*/

4617

my_friendly_assert (tree_int_cst_equal
(rli->bitpos,

4618

round_down
(rli->bitpos,

4619

BITS_PER_UNIT)),

4620

20030903);

4621

rli->bitpos

4622

= size_binop (PLUS_EXPR,

4623

rli->bitpos,

4624

size_binop (MULT_EXPR,

4625

convert (bitsizetype,

4626

size_binop (MINUS_EXPR,

4627

eoc, rli_size)),

4628

bitsize_int
(BITS_PER_UNIT)));

4629

normalize_rli
(rli);

4630

}

4631

}

Next, we can see that if current class is emtpy, it needs be
inserted an annoymous char type field to make it not of zero size. Then finish_record_layout

fills up the related fields of the type node with help of rli

which we have seen before.

4549

static
void

4550

warn_about_ambiguous_bases

(tree t)

in class.c

4551

{

4552

int i;

4553

tree vbases;

4554

tree basetype;

4555

4556

/* Check direct
bases.
*/

4557

for
(i = 0; i
< CLASSTYPE_N_BASECLASSES (t); ++i)

4558

{

4559

basetype = TYPE_BINFO_BASETYPE (t, i);

4560

4561

if (!lookup_base
(t, basetype, ba_ignore | ba_quiet, NULL))

4562

warning ("direct base `%T'
inaccessible in `%T' due to ambiguity",

4563

basetype, t);

4564

}

4565

4566

/* Check for
ambiguous virtual bases.
*/

4567

if (extra_warnings

)

4568

for (vbases = CLASSTYPE_VBASECLASSES (t);

4569

vbases;

4570

vbases = TREE_CHAIN (vbases))

4571

{

4572

basetype = BINFO_TYPE (TREE_VALUE
(vbases));

4573

4574

if (!lookup_base
(t, basetype, ba_ignore | ba_quiet, NULL))

4575

warning ("virtual base `%T' inaccessible
in `%T' due to ambiguity",

4576

basetype, t);

4577

}

4578

}

Further, warn_about_ambiguous_bases

gives warning
message about the ambiguity of base. For example:

struct
S {};

struct
T : public
S {};

struct
U : public
S, public
T {};

Base S in U is ambiguous.

As the last step, it can delete the splay tree because layout is
finished now.

Exiting from layout_class_type

, we back finish_struct_1

and determine the machine mode for the part used as base for the class if it is
not the same of the class itself.