Studying note of GCC-3.4.6 source (146)

5.13.1.1.2.

Case
of user defined conversion sequence

If standard
conversion can’t work, conv

at line 1107 in implicit_conversion

would be NULL. It will
see if there is any user-defined conversion applicable. It involves the
procedure of resolving overload as [3], clause 13.3 “overload resolution”
defines:

1. Overload resolution is a mechanism for selecting the best function to call given a list of expressions that are to be the arguments of the call and a set of candidate functions that can be called based on the context of the call. The selection criteria for the best function are the number of arguments, how well the arguments match the types of the parameters of the candidate function, how well (for nonstatic member functions) the object matches the implied object parameter, and certain other properties of the candidate function. [Note: the function selected by overload resolution is not guaranteed to be appropriate for the context. Other restrictions, such as the accessibility of the function, can make its use in the calling context ill-formed. ] 2. Overload resolution selects the function to call in seven distinct contexts within the language: — invocation of a function named in the function call syntax (13.3.1.1.1); — invocation of a function call operator, a pointer-to-function conversion function, a reference-to-pointerto-function conversion function, or a reference-to-function conversion function on a class object named in the function call syntax (13.3.1.1.2); — invocation of the operator referenced in an expression (13.3.1.2); — invocation of a constructor for direct-initialization (8.5) of a class object (13.3.1.3); — invocation of a user-defined conversion for copy-initialization (8.5) of a class object (13.3.1.4); — invocation of a conversion function for initialization of an object of a nonclass type from an expression of class type (13.3.1.5); and — invocation of a conversion function for conversion to an lvalue to which a reference (8.5.3) will be directly bound (13.3.1.6). 3. Each of these contexts defines the set of candidate functions and the list of arguments in its own unique way. But, once the candidate functions and argument lists have been identified, the selection of the best function is the same in all cases: — First, a subset of the candidate functions—those that have the proper number of arguments and meet certain other conditions—is selected to form a set of viable functions (13.3.2). — Then the best viable function is selected based on the implicit conversion sequences (13.3.3.1) needed to match each argument to the corresponding parameter of each viable function. 4. If a best viable function exists and is unique, overload resolution succeeds and produces it as the result. Otherwise overload resolution fails and the invocation is ill-formed. When overload resolution succeeds, and the best viable function is not accessible (clause 11) in the context in which it is used, the program is ill-formed.

Here we are within the
context of “
invocation of a function
call operator, a pointer-to-function conversion function, a
reference-to-pointerto-function conversion function, or a reference-to-function
conversion function on a class object named in the function call syntax (13.3.1.1.2);

”. Anyway,
the resolving is the same for all the context.

5.13.1.1.2.1.

Collect
candidates

C++ allows user to define conversion operators within class; further
constructor having single argument without “explicit” at head can also be used
as conversion from type of its argument to the class type.

[3], clause 13.3.3.1.2
“User-defined conversion sequences” gives the formal definition as below.

1. A user-defined conversion sequence consists of an initial standard conversion sequence followed by a user-defined conversion (12.3) followed by a second standard conversion sequence. If the user-defined conversion is specified by a constructor (12.3.1), the initial standard conversion sequence converts the source type to the type required by the argument of the constructor. If the user-defined conversion is specified by a conversion function (12.3.2), the initial standard conversion sequence converts the source type to the implicit object parameter of the conversion function. 2. The second standard conversion sequence converts the result of the user-defined conversion to the target type for the sequence. Since an implicit conversion sequence is an initialization, the special rules for initialization by user-defined conversion apply when selecting the best user-defined conversion for a user-defined conversion sequence (see 13.3.3 and 13.3.3.1). 3. If the user-defined conversion is specified by a template conversion function, the second standard conversion sequence must have exact match rank. 4. A conversion of an expression of class type to the same class type is given Exact Match rank, and a conversion of an expression of class type to a base class of that type is given Conversion rank, in spite of the fact that a copy constructor (i.e., a user-defined conversion function) is called for those cases.

2355

static
struct
z_candidate *

2356

build_user_type_conversion_1

(tree totype, tree expr, int flags)
in call.c

2357

{

2358

struct
z_candidate *candidates, *cand;

2359

tree fromtype = TREE_TYPE
(expr);

2360

tree ctors = NULL_TREE,
convs = NULL_TREE;

2361

tree args = NULL_TREE;

2362

bool any_viable_p;

2363

2364

/*
We represent conversion within a hierarchy using RVALUE_CONV and

2365

BASE_CONV, as specified by [over.best.ics];
these become plain

2366

constructor calls, as specified in [dcl.init].
*/

2367

my_friendly_assert
(!IS_AGGR_TYPE (fromtype) || !IS_AGGR_TYPE (totype)

2368

||
!DERIVED_FROM_P (totype, fromtype), 20011226);

2369

2370

if (IS_AGGR_TYPE (totype))

2371

ctors = lookup_fnfields
(TYPE_BINFO (totype),

2372

complete_ctor_identifier

,

2373

0);

2374

2375

if (IS_AGGR_TYPE (fromtype))

2376

convs = lookup_conversions
(fromtype);

So if the target type is class, it collects all constructors defined
as constructor can be used as convertion function too. And if the source type
is class, user-defined conversion operators are considered as candidates, which
are collected by below function.

2421

tree

2422

lookup_conversions

(tree type)
in
search.c

2423

{

2424

tree t;

2425

tree conversions =
NULL_TREE;

2426

2427

complete_type
(type);

2428

bfs_walk
(TYPE_BINFO (type), add_conversions
, 0,
&conversions);

2429

2430

for
(t = conversions; t; t = TREE_CHAIN (t))

2431

IDENTIFIER_MARKED (DECL_NAME (OVL_CURRENT
(TREE_VALUE (t)))) = 0;

2432

2433

return
conversions;

2434

}

In lookup_conversions

,
fn

in
bfs_walk

is add_conversions

,
which always returns NULL and forces the full traversal of the tree. See
parameter data

is used to hold all qualified candidates; and for conversion operators that
converting to the same type, only the first found will be recorded.

2365

static
tree

2366

add_conversions

(tree binfo, void *data)
in
search.c

2367

{

2368

int i;

2369

tree method_vec =
CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo));

2370

tree *conversions = (tree *)
data;

2371

2372

/*
Some builtin types have no method vector, not even an empty one.
*/

2373

if (!method_vec)

2374

return
NULL_TREE;

2375

2376

for
(i = 2; i < TREE_VEC_LENGTH (method_vec); ++i)

2377

{

2378

tree tmp = TREE_VEC_ELT
(method_vec, i);

2379

tree name;

2380

2381

if (!tmp || !
DECL_CONV_FN_P (OVL_CURRENT (tmp)))

2382

break
;

2383

2384

name = DECL_NAME
(OVL_CURRENT (tmp));

2385

2386

/*
Make sure we don't already have this conversion.
*/

2387

if (! IDENTIFIER_MARKED
(name))

2388

{

2389

tree t;

2390

2391

/*
Make sure that we do not already have a conversion

2392

operator for this type. Merely checking
the NAME is not

2393

enough because two conversion operators to
the same type

2394

may
not have the same NAME.

*/

2395

for
(t = *conversions; t; t = TREE_CHAIN (t))

2396

{

2397

tree fn;

2398

for
(fn = TREE_VALUE (t); fn; fn = OVL_NEXT (fn))

2399

if (same_type_p
(TREE_TYPE (name),

2400

DECL_CONV_FN_TYPE (OVL_CURRENT
(fn))))

2401

break
;

2402

if (fn)

2403

break
;

2404

}

2405

if (!t)

2406

{

2407

*conversions =
tree_cons (binfo, tmp, *conversions);

2408

IDENTIFIER_MARKED
(name) = 1;

2409

}

2410

}

2411

}

2412

return
NULL_TREE;

2413

}

In section about member lookup, we see that method has been looked
up would have BASELINK built. Remember for non-static method, the first
argument should be the implicit ‘this’ pointer, and for constructor, ‘this’
pointer is not created yet which should only be ready after the constructor
executing. So for constructor, it just builds a NULL ‘this’ pointer for this
first implicit argument.

build_user_type_conversion_1 (continue)

2378

candidates = 0;

2379

flags |=
LOOKUP_NO_CONVERSION;

2380

2381

if (ctors)

2382

{

2383

tree t;

2384

2385

ctors = BASELINK_FUNCTIONS
(ctors);

2386

2387

t = build_int_2
(0, 0);

2388

TREE_TYPE (t) = build_pointer_type
(totype);

2389

args = build_tree_list
(NULL_TREE, expr);

2390

/*
We should never try to call the abstract or base constructor

2391

from
here.
*/

2392

my_friendly_assert (!DECL_HAS_IN_CHARGE_PARM_P
(OVL_CURRENT (ctors))

2393

&&
!DECL_HAS_VTT_PARM_P (OVL_CURRENT (ctors)),

2394

20011226);

2395

args = tree_cons
(NULL_TREE, t, args);

2396

}

2397

for
(; ctors; ctors = OVL_NEXT (ctors))

2398

{

2399

tree ctor = OVL_CURRENT
(ctors);

2400

if (DECL_NONCONVERTING_P
(ctor))

2401

continue
;

2402

2403

if (TREE_CODE (ctor) ==
TEMPLATE_DECL)

2404

cand = add_template_candidate
(&candidates,
ctor, totype,

2405

NULL_TREE,
args, NULL_TREE,

2406

TYPE_BINFO
(totype),

2407

TYPE_BINFO
(totype),

2408

flags,

2409

DEDUCE_CALL);

2410

else

2411

cand = add_function_candidate
(&candidates,
ctor, totype,

2412

args,
TYPE_BINFO (totype),

2413

TYPE_BINFO
(totype),

2414

flags);

2415

2416

if (cand)

2417

cand->second_conv = build1
(IDENTITY_CONV, totype, NULL_TREE);

2418

}

5.13.1.1.2.1.1.

Add normal function

If the constructors can be used as convertion function
(DECL_NONCONVERTING_P can tell out), they are included as candidates. And
remember if it is a class template, then its constructors will be TEMPLATE_DECL
too. Such node is added by add_template_candidate

, which we have to skip
now due to the complexity. Then for non-template method, add_function_candidate

is called.

1164

static
struct
z_candidate
*

1165

add_function_candidate

(struct
z_candidate **candidates,
in call.c

1166

tree fn,
tree ctype, tree arglist,

1167

tree
access_path, tree conversion_path,

1168

int
flags)

1169

{

1170

tree parmlist =
TYPE_ARG_TYPES (TREE_TYPE (fn));

1171

int i, len;

1172

tree convs;

1173

tree parmnode, argnode;

1174

tree orig_arglist;

1175

int viable = 1;

1176

1177

/* Built-in functions that haven't been
declared don't really

1178

exist.

*/

1179

if (DECL_ANTICIPATED (fn))

1180

return
NULL;

1181

1182

/*
The `this', `in_chrg' and VTT arguments to constructors are not

1183

considered in overload resolution.
*/

1184

if (DECL_CONSTRUCTOR_P (fn))

1185

{

1186

parmlist = skip_artificial_parms_for
(fn, parmlist);

1187

orig_arglist = arglist;

1188

arglist = skip_artificial_parms_for
(fn, arglist);

1189

}

1190

else

1191

orig_arglist = arglist;

1192

1193

len = list_length (arglist);

1194

convs = make_tree_vec (len);

1195

1196

/*
13.3.2 - Viable functions
[over.match.viable]

1197

First,
to be a viable function, a candidate function shall have enough

1198

parameters to agree in number with the
arguments in the list.

1199

1200

We need
to check this first; otherwise, checking the ICSes might cause

1201

us to
produce an ill-formed template instantiation.

*/

1202

1203

parmnode = parmlist;

1204

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

1205

{

1206

if (parmnode == NULL_TREE
|| parmnode == void_list_node)

1207

break
;

1208

parmnode = TREE_CHAIN
(parmnode);

1209

}

1210

1211

if (i < len &&
parmnode)

1212

viable = 0;

1213

1214

/*
Make sure there are default args for the rest of the parms.
*/

1215

else if (!sufficient_parms_p
(parmnode))

1216

viable = 0;

1217

1218

if (! viable)

1219

goto
out;

1220

1221

/*
Second, for F to be a viable function, there shall exist for each

1222

argument an implicit conversion sequence that
converts that argument

1223

to the
corresponding parameter of F.
*/

1224

1225

parmnode = parmlist;

1226

argnode = arglist;

To be a candidate, it must be able to form a viable function
invocation. As we have seen before, constructor may include more than 1
artificial argument, and the number depends on the definition of the class
(whether it has VTT, virtual base).

1655

tree

1656

lvalue_type

(tree arg)
in
tree.c

1657

{

1658

tree type = TREE_TYPE (arg);

1659

return
type;

1660

}

From view-point of function, arguments are lvalue which can be
manipulated within the function. Above lvalue_type

returns the type of arg

when
used as an lvalue. It is possible that type of argument and type of
corresponding parameter are not the same; however, they must be able to be
matched by implicit conversion.

And if it encounters ellipsis parameter, ELSE
block at line 1264 is executed; see that it needs still create
IDENTITY_CONV for the argument, but with flag ICS_ELLIPSIS_FLAG set to indicate
the IDENTITY_CONV is of ellipsis conversion.

add_function_candidate (continue)

1228

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

1229

{

1230

tree arg = TREE_VALUE
(argnode);

1231

tree argtype = lvalue_type
(arg);

1232

tree t;

1233

int is_this;

1234

1235

if (parmnode ==
void_list_node)

1236

break
;

1237

1238

is_this = (i == 0
&& DECL_NONSTATIC_MEMBER_FUNCTION_P (fn)

1239

&& !
DECL_CONSTRUCTOR_P (fn));

1240

1241

if (parmnode)

1242

{

1243

tree parmtype =
TREE_VALUE (parmnode);

1244

1245

/*
The type of the implicit object parameter ('this') for

1246

overload resolution is not always the
same as for the

1247

function itself; conversion functions
are considered to

1248

be members of the class being converted,
and functions

1249

introduced by a using-declaration are
considered to be

1250

members of the class that uses them.

1251

1252

Since build_over_call ignores the ICS
for the `this'

1253

parameter, we can just change the parm
type.
*/

1254

if (ctype &&
is_this)

1255

{

1256

parmtype

1257

= build_qualified_type
(ctype,

1258

TYPE_QUALS
(TREE_TYPE (parmtype)));

1259

parmtype =
build_pointer_type

(parmtype);

1260

}

1261

1262

t =
implicit_conversion

(parmtype, argtype, arg, flags);

1263

}

1264

else

1265

{

1266

t = build1
(IDENTITY_CONV, argtype, arg);

1267

ICS_ELLIPSIS_FLAG (t) =
1;

1268

}

1269

1270

if (t && is_this)

1271

ICS_THIS_FLAG (t) = 1;

1272

1273

TREE_VEC_ELT (convs, i) =
t;

1274

if (! t)

1275

{

1276

viable = 0;

1277

break
;

1278

}

1279

1280

if (ICS_BAD_FLAG (t))

1281

viable = -1;

1282

1283

if (parmnode)

1284

parmnode = TREE_CHAIN
(parmnode);

1285

argnode = TREE_CHAIN
(argnode);

1286

}

1287

1288

out:

1289

return
add_candidate
(candidates, fn, orig_arglist,
convs, access_path,

1290

conversion_path, viable);

1291

}

All candidates are chained tegother into list, which node of z_candidate

is used to store relavant information.

312

struct
z_candidate
GTY(()) {
in
call.c

313

/* The
FUNCTION_DECL that will be called if this candidate is

314

selected by
overload resolution.
*/

315

tree fn;

316

/* The arguments to
use when calling this function.
*/

317

tree args;

318

/* The implicit
conversion sequences for each of the arguments to

319

FN.
*/

320

tree convs;

321

/* If FN is a
user-defined conversion, the standard conversion

322

sequence from the
type returned by FN to the desired destination

323

type.
*/

324

tree second_conv;

325

int viable;

326

/* If FN is a
member function, the binfo indicating the path used to

327

qualify the name
of FN at the call site. This path is used to

328

determine whether
or not FN is accessible if it is selected by

329

overload
resolution. The DECL_CONTEXT of FN will always be a

330

(possibly
improper) base of this binfo.
*/

331

tree access_path;

332

/* If FN is a
non-static member function, the binfo indicating the

333

subobject to
which the `this' pointer should be converted if FN

334

is selected by
overload resolution. The type pointed to the by

335

the `this'
pointer must correspond to the most derived class

336

indicated by the
CONVERSION_PATH.
*/

337

tree conversion_path;

338

tree template;

339

tree warnings;

340

struct
z_candidate
*next;

341

};

Pay attention to conversion_path

and access_path

passed in, for
constructor they are both the binfo of the target class.

1138

static
struct
z_candidate
*

1139

add_candidate

(struct
z_candidate **candidates,
in
call.c

1140

tree fn, tree
args, tree convs, tree access_path,

1141

tree
conversion_path, int viable)

1142

{

1143

struct
z_candidate *cand = ggc_alloc_cleared (sizeof
(struct
z_candidate));

1144

1145

cand->fn = fn;

1146

cand->args = args;

1147

cand->convs = convs;

1148

cand->access_path =
access_path;

1149

cand->conversion_path =
conversion_path;

1150

cand->viable = viable;

1151

cand->next = *candidates;

1152

*candidates = cand;

1153

1154

return
cand;

1155

}

For conversion operator other than constructor, again see that conversion_path

passed to add_function_candidate

is binfo gotten at line 2426 which is set in add_conversions

at line 2407,
and is the binfo of the class that defining the method.