Studying note of GCC-3.4.6 source (162 - continue)

At line 5350 current_class_ptr

is the PARM_DECL for the `this'
pointer, when we're processing a member function. See that in below only the type
of instance

can be known for sure it returns non-null. Compared with condition at line
5281, which indicates a pointer, and in C++, it can be variant types in the
class hierarchy to support polymorphism. So it has to return NULL_TREE as
result.

5275

static
tree

5276

fixed_type_or_null

(tree instance, int*
nonnull, int* cdtorp)
in
class.c

5277

{

5278

switch
(TREE_CODE (instance))

5279

{

5280

case
INDIRECT_REF:

5281

if (POINTER_TYPE_P (TREE_TYPE (instance)))

5282

return
NULL_TREE;

5283

else

5284

return
fixed_type_or_null
(TREE_OPERAND
(instance, 0),

5285

nonnull, cdtorp);

5286

5287

case
CALL_EXPR:

5288

/* This is a
call to a constructor, hence it's never zero.

*/

5289

if (TREE_HAS_CONSTRUCTOR (instance))

5290

{

5291

if (nonnull)

5292

*nonnull = 1;

5293

return
TREE_TYPE (instance);

5294

}

5295

return
NULL_TREE;

5296

5297

case
SAVE_EXPR:

5298

/* This is a
call to a constructor, hence it's never zero.

*/

5299

if (TREE_HAS_CONSTRUCTOR (instance))

5300

{

5301

if (nonnull)

5302

*nonnull = 1;

5303

return
TREE_TYPE (instance);

5304

}

5305

return
fixed_type_or_null
(TREE_OPERAND (instance, 0),
nonnull, cdtorp);

5306

5307

case
RTL_EXPR:

5308

return
NULL_TREE;

5309

5310

case
PLUS_EXPR:

5311

case
MINUS_EXPR:

5312

if (TREE_CODE (TREE_OPERAND (instance,
0)) == ADDR_EXPR)

5313

return
fixed_type_or_null
(TREE_OPERAND
(instance, 0), nonnull, cdtorp);

5314

if (TREE_CODE (TREE_OPERAND (instance,
1)) == INTEGER_CST)

5315

/* Propagate
nonnull.
*/

5316

return
fixed_type_or_null
(TREE_OPERAND
(instance, 0), nonnull, cdtorp);

5317

return
NULL_TREE;

5318

5319

case
NOP_EXPR:

5320

case
CONVERT_EXPR:

5321

return
fixed_type_or_null
(TREE_OPERAND (instance, 0),
nonnull, cdtorp);

5322

5323

case
ADDR_EXPR:

5324

if (nonnull)

5325

*nonnull = 1;

5326

return
fixed_type_or_null
(TREE_OPERAND (instance, 0),
nonnull, cdtorp);

5327

5328

case
COMPONENT_REF:

5329

return
fixed_type_or_null
(TREE_OPERAND (instance, 1),
nonnull, cdtorp);

5330

5331

case
VAR_DECL:

5332

case
FIELD_DECL:

5333

if (TREE_CODE (TREE_TYPE (instance)) ==
ARRAY_TYPE

5334

&& IS_AGGR_TYPE (TREE_TYPE
(TREE_TYPE (instance))))

5335

{

5336

if (nonnull)

5337

*nonnull = 1;

5338

return
TREE_TYPE (TREE_TYPE (instance));

5339

}

5340

/* fall through...
*/

5341

case
TARGET_EXPR:

5342

case
PARM_DECL:

5343

case
RESULT_DECL:

5344

if (IS_AGGR_TYPE (TREE_TYPE (instance)))

5345

{

5346

if (nonnull)

5347

*nonnull = 1;

5348

return
TREE_TYPE (instance);

5349

}

5350

else if (instance == current_class_ptr

)

5351

{

5352

if (nonnull)

5353

*nonnull = 1;

5354

5355

/* if we're in a ctor or dtor, we know our
type.
*/

5356

if (DECL_LANG_SPECIFIC (current_function_decl

)

5357

&& (DECL_CONSTRUCTOR_P (current_function_decl

)

5358

|| DECL_DESTRUCTOR_P (current_function_decl

)))

5359

{

5360

if (cdtorp)

5361

*cdtorp = 1;

5362

return
TREE_TYPE (TREE_TYPE (instance));

5363

}

5364

}

5365

else if (TREE_CODE (TREE_TYPE (instance))
== REFERENCE_TYPE)

5366

{

5367

/* Reference
variables should be references to objects.

*/

5368

if (nonnull)

5369

*nonnull = 1;

5370

5371

/*
DECL_VAR_MARKED_P is used to prevent recursion; a

5372

variable's initializer
may refer to the variable

5373

itself.
*/

5374

if (TREE_CODE (instance) == VAR_DECL

5375

&& DECL_INITIAL (instance)

5376

&& !DECL_VAR_MARKED_P
(instance))

5377

{

5378

tree type;

5379

DECL_VAR_MARKED_P (instance) = 1;

5380

type = fixed_type_or_null
(DECL_INITIAL (instance),

5381

nonnull,
cdtorp);

5382

DECL_VAR_MARKED_P (instance) = 0;

5383

return
type;

5384

}

5385

}

5386

return
NULL_TREE;

5387

5388

default
:

5389

return
NULL_TREE;

5390

}

5391

}

Arriving here, fixed_type_p

is 0 if type of expr

is unknown for certainty
(polymorphism may be in used), or is -1 if expr

is constructor or destructor, otherwise is 1
as type is known for certainty. And v_binfo

is not NULL if there is virtual base involved.

build_base_path (continue)

293

if (want_pointer && !nonnull)

294

null_test = build (EQ_EXPR,
boolean_type_node, expr, integer_zero_node);

295

296

offset = BINFO_OFFSET (binfo);

If no vritual base found, offset

gotten at line 296 is all wanted. Code in
below then generates the expression (taking example 4 as instance in pseudo
code):

*(&b +
offset (A));

And if b

originally is a pointer, it will generate code to guard NULL
pointer too as below (taking example 5 as instance):

pa? (pa +
offset (A)) : 0;

build_base_path (continue)

350

target_type = code == PLUS_EXPR ?
BINFO_TYPE (binfo) : BINFO_TYPE (d_binfo);

351

352

target_type = cp_build_qualified_type

353

(target_type, cp_type_quals (TREE_TYPE
(TREE_TYPE (expr))));

354

ptr_target_type = build_pointer_type
(target_type);

355

if (want_pointer)

356

target_type = ptr_target_type;

357

358

expr = build1
(NOP_EXPR, ptr_target_type, expr);

359

360

if (!integer_zerop (offset))

361

expr = build
(code,
ptr_target_type, expr, offset);

362

else

363

null_test = NULL;

364

365

if (!want_pointer)

366

expr = build_indirect_ref
(expr, NULL);

367

368

if (null_test)

369

expr = build
(COND_EXPR, target_type, null_test,

370

build1
(NOP_EXPR, target_type, integer_zero_node),

371

expr);

372

373

return
expr;

374

}

However, if the conversion involves virtual base and expr

’s
dynamic type isn’t the same as static type, offset

gotten at line 296 is just the beginning.

build_base_path (continue)

298

if (v_binfo && fixed_type_p <= 0)

299

{

300

/* Going via
virtual base V_BINFO. We need the static offset

301

from V_BINFO to
BINFO, and the dynamic offset from D_BINFO to

302

V_BINFO. That
offset is an entry in D_BINFO's vtable.

*/

303

tree v_offset;

304

305

if (fixed_type_p < 0 && in_base_initializer

)

306

{

307

/* In a base
member initializer, we cannot rely on

308

the vtable
being set up. We have to use the vtt_parm.

*/

309

tree derived = BINFO_INHERITANCE_CHAIN
(v_binfo);

310

311

v_offset = build
(PLUS_EXPR, TREE_TYPE (current_vtt_parm

),

312

current_vtt_parm

, BINFO_VPTR_INDEX
(derived));

313

314

v_offset = build1
(INDIRECT_REF,

315

TREE_TYPE (TYPE_VFIELD
(BINFO_TYPE (derived))),

316

v_offset);

317

318

}

319

else

320

v_offset = build_vfield_ref
(build_indirect_ref (expr, NULL),

321

TREE_TYPE
(TREE_TYPE (expr)));

322

323

v_offset = build
(PLUS_EXPR, TREE_TYPE (v_offset),

324

v_offset,
BINFO_VPTR_FIELD (v_binfo));

325

v_offset = build1
(NOP_EXPR,

326

build_pointer_type (ptrdiff_type_node

),

327

v_offset);

328

v_offset = build_indirect_ref

(v_offset, NULL);

329

330

offset = convert_to_integer (ptrdiff_type_node

,

331

size_diffop (offset,

332

BINFO_OFFSET (v_binfo)));

333

334

if (!integer_zerop (offset))

335

v_offset = build
(code, ptrdiff_type_node

,
v_offset, offset);

336

337

if (fixed_type_p < 0)

338

/* Negative
fixed_type_p means this is a constructor or destructor;

339

virtual base layout is fixed in in-charge
[cd]tors, but not in

340

base
[cd]tors.
*/

341

offset = build

(COND_EXPR, ptrdiff_type_node

,

342

build

(EQ_EXPR, boolean_type_node,

343

current_in_charge_parm

, integer_zero_node),

344

v_offset,

345

BINFO_OFFSET (binfo));

346

else

347

offset = v_offset;

348

}

If there is virtual base between and it must use vtable to do the
conversion between the derived and the base, above at line 305 in

_base_initializer

is nonzero if it
is handling a base initializer, for which case vtable is not created. So it
needs use the placeholder current_vtt_parm

to indicate to involvement of
the vtable.

Function build_indirect_ref

builds INDIRECT_REF for
pointer type or reference type. For example, if p

is a pointer, then the
INDIRECT_REF node stands for the expression “*p”.

2028

tree

2029

build_indirect_ref
(tree ptr, const
char *errorstring)
in typeck.c

2030

{

2031

tree pointer, type;

2032

2033

if (ptr == error_mark_node)

2034

return
error_mark_node;

2035

2036

if (ptr == current_class_ptr

)

2037

return
current_class_ref

;

2038

2039

pointer = (TREE_CODE (TREE_TYPE (ptr)) ==
REFERENCE_TYPE

2040

? ptr : decay_conversion (ptr));

2041

type = TREE_TYPE (pointer);

2042

2043

if (TYPE_PTR_P (type) || TREE_CODE (type) ==
REFERENCE_TYPE)

2044

{

2045

/* [expr.unary.op]

2046

2047

If the type of the
expression is "pointer to T," the type

2048

of the result is
"T."

2049

2050

We must use the canonical
variant because certain parts of

2051

the back end, like fold, do
pointer comparisons between

2052

types.
*/

2053

tree t = canonical_type_variant (TREE_TYPE
(type));

2054

2055

if (VOID_TYPE_P (t))

2056

{

2057

/* A pointer to
incomplete type (other than cv void) can be

2058

dereferenced
[expr.unary.op]/1
*/

2059

error ("`%T' is not a
pointer-to-object type", type);

2060

return
error_mark_node;

2061

}

2062

else if (TREE_CODE (pointer) == ADDR_EXPR

2063

&& same_type_p (t, TREE_TYPE
(TREE_OPERAND (pointer, 0))))

2064

/* The POINTER
was something like `&x'.
We simplify
`*&x' to

2065

`x'.
*/

2066

return
TREE_OPERAND (pointer, 0);

2067

else

2068

{

2069

tree ref = build1
(INDIRECT_REF, t, pointer);

2070

2071

/* We *must*
set TREE_READONLY when dereferencing a pointer to const,

2072

so that we get the proper
error message if the result is used

2073

to assign to. Also, &*
is supposed to be a no-op.
*/

2074

TREE_READONLY (ref) = CP_TYPE_CONST_P
(t);

2075

TREE_THIS_VOLATILE (ref) =
CP_TYPE_VOLATILE_P (t);

2076

TREE_SIDE_EFFECTS (ref)

2077

= (TREE_THIS_VOLATILE (ref) ||
TREE_SIDE_EFFECTS (pointer));

2078

return
ref;

2079

}

2080

}

2081

/* `pointer' won't
be an error_mark_node if we were given a

2082

pointer to member, so it's
cool to check for this here.
*/

2083

else if (TYPE_PTR_TO_MEMBER_P (type))

2084

error ("invalid use of `%s' on pointer
to member", errorstring);

2085

else if (pointer != error_mark_node)

2086

{

2087

if (errorstring)

2088

error ("invalid type argument of
`%s'", errorstring);

2089

else

2090

error ("invalid type argument");

2091

}

2092

return
error_mark_node;

2093

}

As we have seen TYPE_VFIELD is the artificial field generated by the
compiler for class containing vtable. Now it also acts as a placeholder, it
will be replaced with the real address of vtable later.

115

tree

116

build_vfield_ref

(tree datum, tree type)

in
call.c

117

{

118

if (datum == error_mark_node)

119

return
error_mark_node;

120

121

if (TREE_CODE (TREE_TYPE (datum)) ==
REFERENCE_TYPE)

122

datum = convert_from_reference (datum);

123

124

if (TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type)

125

&&
!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (datum), type))

126

datum = convert_to_base (datum, type, /*check_access=*/
false);

127

128

return
build

(COMPONENT_REF, TREE_TYPE (TYPE_VFIELD (type)),

129

datum, TYPE_VFIELD (type));

130

}

Remember BINFO_VPTR_FIELD at line 324 is set for virtual base, in
which is an INTEGER_CST indicating the index of the entry in the vtable
recording the offset of the virtual base from the base of the derived (why not
BINFO_OFFSET (vbase)? because C++ standard requires accessing virtual base by
help of BINFO_VPTR_FIELD).

Note that if binfo

is
derived by v_binfo

,
then offset

at line 330 gets the relative offset between these two bases as indicated by
below figure (the red
arrow
is the offset

gotten at line 330).



Then line 334 introduces a minor optimizaton, note that code

of
MINUS_EXPR with v_binfo

not NULL is not allowed and error message is given at line 280. So at line 335, v_offset

at right hand side refers to the binfo of the virtual base via vtable, and plus
offset

gotten at line 330, v_offset

at left hand side then points to the
binfo in interesting. Following offset

is updated accordingly to record the
offset into the most derived class.

For our example 5, expr

generated finally would be:

(pa + offset
(A))? (pa + offset (A)): 0;

Back into get_member_function_from_ptrfunc

,
instance_ptr

is now the above statement returned by build_base_path

. Consider following example,
it gives output “C::f” (note that in class C, vtable entry of f of B1, B2, and
A are all overrided as C::f with appropriate thunk, which give us promise
here):

class
A { public
:

example
- 6

virtual
A*
f () { printf ("A::f/n"); return
0; }

virtual
A*
f1 () { printf ("A::f1/n"); return
0;
}

virtual
~A() {}

};

class
B1 : virtual
public
A { public
:
virtual
B1* f1 () { printf
("B1::f1/n"); return
0; } };

class
B2 : virtual
public
A {};

class
C: public
B1, public
B2 { public
:
virtual C* f () { printf ("C::f/n"); return
0; } };

int main() {

B2 *pc = new
C; // no matter declare
pc as A*, B1*, B2*, or C*, get same result, as // they all derive from A, and
pfn is declared as within A

A* (A::*pfn) () = &B2::f; // same result, use either B1, B2, A, or C at rhs

(pc->*pfn)();

delete
pc;

return
0;

}

For this example, instance_ptr

holds the statement to adjust pa

from B2* to A* (“B2 *pc = new C;” carries a
pointer converted from C* to B2* already); and delta

below gotten at line 2357
records the offset determined by statement “A* (A::*pfn) () = &B2::f;”
(it is 0 because the statement indicate a
meaningless adjustment from A to A). Then by expression: “instance_ptr +
delta”, it locates the base that defining the function specified by the pointer
to method; then idx is the index into the vtable for the virtual function (or
function address converting in type of vtable for non-virtual function).

get_member_function_from_ptrfunc
(continue)

2383

/* ...and then
the delta in the PMF.
*/

2384

instance_ptr =
build

(PLUS_EXPR, TREE_TYPE (instance_ptr),

2385

instance_ptr, delta);

2386

2387

/* Hand back the
adjusted 'this' argument to our caller.

*/

2388

*instance_ptrptr = instance_ptr;

2389

2390

/* Next extract
the vtable pointer from the object.
*/

2391

vtbl = build1
(NOP_EXPR, build_pointer_type
(vtbl_ptr_type_node),

2392

instance_ptr);

2393

vtbl = build_indirect_ref
(vtbl, NULL);

2394

2395

/* Finally,
extract the function pointer from the vtable.

*/

2396

e2 = fold (build

(PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx));

2397

e2 = build_indirect_ref
(e2, NULL);

2398

TREE_CONSTANT (e2) = 1;

2399

2400

/* When using
function descriptors, the address of the

2401

vtable entry is treated as a
function pointer.
*/

2402

if (TARGET_VTABLE_USES_DESCRIPTORS)

2403

e2 = build1
(NOP_EXPR, TREE_TYPE (e2),

2404

build_unary_op (ADDR_EXPR, e2, /*noconvert=*/
1));

2405

2406

TREE_TYPE (e2) = TREE_TYPE (e3);

2407

e1 = build_conditional_expr (e1, e2, e3);

2408

2409

/* Make sure this
doesn't get evaluated first inside one of the

2410

branches of the
COND_EXPR.
*/

2411

if (instance_save_expr)

2412

e1 = build

(COMPOUND_EXPR, TREE_TYPE (e1),

2413

instance_save_expr, e1);

2414

2415

function = e1;

2416

}

2417

return
function;

2418

}

In section of class
layout, we have seen that vptr is always placed at the beginning of the class.
So the code snippet generated would be like below for example 5:

idx =
(vtable_index_type) pfn;
// pfn returned by PFN_FROM_PTRMEMFUNC

instance_ptr
= instance_ptr? instance_ptr + offset (A): 0;

(idx
& 1)? *(((vtbl_ptr_type_node) instance_ptr) + (idx-1)): pfn;

At this point, for a
pointer-to-method, we have known which function is expected, and expression to
locate the location of the function is ready and returned to build_addr_func

,
then immediately to build_function_call

. Note that function

below now holds the expression for locating the function and its type is the
pointer of the function.

build_function_call (continue)

2464

if (function == error_mark_node)

2465

return
error_mark_node;

2466

2467

fntype = TREE_TYPE (function);

2468

2469

if (TYPE_PTRMEMFUNC_P (fntype))

2470

{

2471

error ("must use .* or ->* to call
pointer-to-member function in `%E (...)'",

2472

original);

2473

return
error_mark_node;

2474

}

2475

2476

is_method = (TREE_CODE (fntype) == POINTER_TYPE

2477

&& TREE_CODE (TREE_TYPE
(fntype)) == METHOD_TYPE);

2478

2479

if (!((TREE_CODE (fntype) == POINTER_TYPE

2480

&& TREE_CODE (TREE_TYPE
(fntype)) == FUNCTION_TYPE)

2481

|| is_method

2482

|| TREE_CODE (function) == TEMPLATE_ID_EXPR))

2483

{

2484

error ("`%E' cannot be used as a
function", original);

2485

return
error_mark_node;

2486

}

2487

2488

/* fntype now gets
the type of function pointed to.
*/

2489

fntype = TREE_TYPE (fntype);

2490

2491

/* Convert the
parameters to the types declared in the

2492

function prototype, or apply
default promotions.
*/

2493

2494

coerced_params = convert_arguments
(TYPE_ARG_TYPES (fntype),

2495

params,
fndecl, LOOKUP_NORMAL);

2496

if (coerced_params == error_mark_node)

2497

return
error_mark_node;

2498

2499

/* Check for errors
in format strings.
*/

2500

2501

if (warn_format

)

2502

check_function_format (NULL,
TYPE_ATTRIBUTES (fntype), coerced_params);

2503

2504

/* Recognize
certain built-in functions so we can make tree-codes

2505

other than CALL_EXPR. We do
this when it enables fold-const.c

2506

to do something useful.
*/

2507

2508

if (TREE_CODE (function) == ADDR_EXPR

2509

&& TREE_CODE (TREE_OPERAND
(function, 0)) == FUNCTION_DECL

2510

&& DECL_BUILT_IN (TREE_OPERAND
(function, 0)))

2511

{

2512

result = expand_tree_builtin (TREE_OPERAND
(function, 0),

2513

params,
coerced_params);

2514

if (result)

2515

return
result;

2516

}

2517

2518

return
build_cxx_call
(function, params, coerced_params);

2519

}

So fntype

at line 2489 refers to the type of the function in used. Then it needs do
conversion for the arguments according to the parameters declaration.