GCC-3.4.6源代码学习笔记（152）

5.12.5.2.2.2.2.

缺省实参

如果耗尽了
arg

，但
parm

还没有，
parm

必然包含了缺省实参，该形参列表应该以特殊节点
void_list_node

来结尾。那么在对应的节点中，
TREE_VALUE
保存了该类型，而
TREE_PURPOSE
是缺省实参的表达式。

4258

tree

4259

convert_default_arg

(tree type, tree arg, tree fn, int parmnum)
in call.c

4260

{

4261

/*
If the ARG is an unparsed default argument expression, the

4262

conversion cannot be performed.
*/

4263

if (TREE_CODE (arg) ==
DEFAULT_ARG)

4264

{

4265

error ("the default
argument for parameter %d of `%D' has "

4266

"not yet been
parsed",

4267

parmnum, fn);

4268

return
error_mark_node;

4269

}

4270

4271

if (fn &&
DECL_TEMPLATE_INFO (fn))

4272

arg =
tsubst_default_argument (fn, type, arg);

4273

4274

arg = break_out_target_exprs
(arg);

4275

4276

if (TREE_CODE (arg) ==
CONSTRUCTOR)

4277

{

4278

arg = digest_init
(type, arg, 0);

4279

arg =
convert_for_initialization (0, type, arg, LOOKUP_NORMAL,

4280

"default
argument", fn, parmnum);

4281

}

4282

else

4283

{

4284

/*
This could get clobbered by the following call.

*/

4285

if (TREE_HAS_CONSTRUCTOR
(arg))

4286

arg = copy_node (arg);

4287

4288

arg =
convert_for_initialization (0, type, arg, LOOKUP_NORMAL,

4289

"default
argument", fn, parmnum);

4290

arg = convert_for_arg_passing
(type, arg);

4291

}

4292

4293

return
arg;

4294

}

节点
DEFAULT_ARG
是为未解析的缺省实参所构建的。记得在解析类定义的过程中，缺省实参被
DEFAULT_ARG
所缓存，它将在该解析结束后才解析。因此在这里不应该出现
DEFAULT_ARG
（如果是这样，这可能是在类定义中缺少了“
};
”），而且在这一点上，前端不知道如何处理这种节点。

那么在
4274
传递给下面函数的
arg

，是由该函数所有调用所共享的缺省实参。不过，正如【
3
】所定义的，“每次调用该函数都要评估缺省实参
”，因此在真正评估这个缺省实参之前，需要
准备合适的
arg

的拷贝（我们不能直接改变
arg

），并如下所示地更新这个局部临时对象。

1259

tree

1260

break_out_target_exprs

(tree t)
in
cp/tree.c

1261

{

1262

static
int target_remap_count;

1263

static
splay_tree target_remap;

1264

1265

if (!target_remap_count++)

1266

target_remap =
splay_tree_new (splay_tree_compare_pointers,

1267

/*splay_tree_delete_key_fn=*/
NULL,

1268

/*splay_tree_delete_value_fn=*/
NULL);

1269

walk_tree
(&t, bot_manip
, target_remap, NULL);

1270

walk_tree
(&t, bot_replace
, target_remap, NULL);

1271

1272

if (!--target_remap_count)

1273

{

1274

splay_tree_delete
(target_remap);

1275

target_remap = NULL;

1276

}

1277

1278

return
t;

1279

}

上面，
walk_tree

遍历以
t

为根的子树，并在以
t

的编码所选出的节点上执行给定的函数。在第一次遍历中，使用下面的函数。注意该函数总是返回
NULL
（下面的
copy_tree_r

返回
NULL
）来强制
walk_tree

执行深度优先的完整遍历（即，
tp

可能是一个
tree_list
，其中的节点可以包含操作数，它们依次亦可能是
tree_list
，等等，访问将从底部开始向上）；不过是否进入子树（即操作数）由局部变量
walk_subtrees

来控制（它在下面的函数中作为实参
walk_subtrees

传入）。在使用指定的函数处理树节点前，
walk_subtrees

被设置为
1
；是指定的函数来决定该节点是否是感兴趣的，并且需要进入。

1182

static
tree

1183

bot_manip

(tree* tp, int* walk_subtrees, void* data)
in cp/tree.c

1184

{

1185

splay_tree target_remap =
((splay_tree) data);

1186

tree t = *tp;

1187

1188

if (TREE_CONSTANT (t))

1189

{

1190

/*
There can't be any TARGET_EXPRs or their slot variables below

1191

this
point. We used to check !TREE_SIDE_EFFECTS, but then we

1192

failed to copy an ADDR_EXPR of the slot
VAR_DECL.
*/

1193

*walk_subtrees = 0;

1194

return
NULL_TREE;

1195

}

1196

if (TREE_CODE (t) ==
TARGET_EXPR)

1197

{

1198

tree u;

1199

1200

if (TREE_CODE
(TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)

1201

{

1202

mark_used
(TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 1), 0), 0));

1203

u = build_cplus_new

1204

(TREE_TYPE (t),
break_out_target_exprs (TREE_OPERAND (t, 1)));

1205

}

1206

else

1207

{

1208

u = build_target_expr_with_type

1209

(break_out_target_exprs
(TREE_OPERAND (t,
1)), TREE_TYPE (t));

1210

}

1211

1212

/* Map the old variable to the new one.
*/

1213

splay_tree_insert
(target_remap,

1214

(splay_tree_key)
TREE_OPERAND (t, 0),

1215

(splay_tree_value)
TREE_OPERAND (u, 0));

1216

1217

/*
Replace the old expression with the new version.
*/

1218

*tp = u;

1219

/*
We don't have to go below this point; the recursive call to

1220

break_out_target_exprs will have handled
anything below this

1221

point.

*/

1222

*walk_subtrees = 0;

1223

return
NULL_TREE;

1224

}

1225

else if (TREE_CODE (t) ==
CALL_EXPR)

1226

mark_used
(TREE_OPERAND (TREE_OPERAND (t, 0), 0));

1227

1228

/*
Make a copy of this node.
*/

1229

return
copy_tree_r
(tp, walk_subtrees, NULL);

1230

}

对于常量或
TRAGET_EXPR
以外的节点，
copy_tree_r

拷贝这个节点，如果它是
*_CST
（看到它其实被上面的
TREE_CONSTANT
滤掉了），或表达式，或
TREE_LIST
，或
TREE_VEC
，或
OVERLOAD
（由下面的
C++
的钩子
tree_chain_matters_p

来辨别，并注意到在这里
walk_subtrees

没有改变，
walk_tree

将进入该节点的子节点，并继续拷贝其结构）。

1966

tree

1967

copy_tree_r

(tree *tp, int
*walk_subtrees, void *data ATTRIBUTE_UNUSED)

in tree-inline.c

1968

{

1969

enum
tree_code code = TREE_CODE (*tp);

1970

1971

/* We make copies of most nodes.
*/

1972

if (IS_EXPR_CODE_CLASS
(TREE_CODE_CLASS (code))

1973

|| TREE_CODE_CLASS
(code) == 'c'

1974

|| code == TREE_LIST

1975

|| code == TREE_VEC

1976

|| (*lang_hooks

.tree_inlining.tree_chain_matters_p)
(*tp))

1977

{

1978

/* Because the chain gets clobbered when we
make a copy, we save it

1979

here.
*/

1980

tree chain = TREE_CHAIN
(*tp);

1981

1982

/*
Copy the node.
*/

1983

*tp = copy_node (*tp);

1984

1985

/*
Now, restore the chain, if appropriate. That will cause

1986

walk_tree to walk into the chain as
well.
*/

1987

if (code == PARM_DECL ||
code == TREE_LIST

1988

#ifndef
INLINER_FOR_JAVA

1989

|| (*lang_hooks

.tree_inlining.tree_chain_matters_p)
(*tp)

1990

|| STATEMENT_CODE_P (code))

1991

TREE_CHAIN (*tp) = chain;

1992

1993

/* For now, we don't update BLOCKs when we
make copies. So, we

1994

have
to nullify all scope-statements.
*/

1995

if (TREE_CODE (*tp) ==
SCOPE_STMT)

1996

SCOPE_STMT_BLOCK (*tp) =
NULL_TREE;

1997

#else

/* INLINER_FOR_JAVA */

1998

|| (*lang_hooks

.tree_inlining.tree_chain_matters_p)
(*tp))

1999

TREE_CHAIN (*tp) =
chain;

2000

#endif
/*
INLINER_FOR_JAVA */

2001

}

2002

else if (TREE_CODE_CLASS
(code) == 't')

2003

*walk_subtrees = 0;

2004

2005

return

NULL_TREE;

2006

}

一个
TARGET_EXPR
代表一个临时对象。其第一个操作数是表示这个临时对象的一个
VAR_DECL
。其第二个操作数是该临时对象的初始值。该初始值被评估，然后拷贝入这个临时对象。

一个
AGGR_INIT_EXPR
代表，作为一个函数调用返回值，或一个构造函数结果的初始化。一个
AGGR_INIT_EXPR
将仅出现作为一个
TARGET_EXPR
的第二个操作数。该
AGGR_INIT_EXPR
的第一个操作数是所调用函数的地址，就像在一个
CALL_EXPR
那样。第二个操作数是以一个
TREE_LIST
形式传递给该函数的实参，同样类似于在一个
CALL_EXPR
里那样。这个表达式的值由这个函数返回。

那么如果
AGGR_INIT_EXPR
被用于
TRAGET_EXPR
里，递归
break_out_target_exprs

来拷贝这个节点。对于这个拷贝过来的表达式，
build_cplus_new

为其初始化产生了代码。

2007

tree

2008

build_cplus_new

(tree type, tree init)
in
cp/tree.c

2009

{

2010

tree fn;

2011

tree slot;

2012

tree rval;

2013

int is_ctor;

2014

2015

/*
Make sure that we're not trying to create an instance of an

2016

abstract class.
*/

2017

abstract_virtuals_error
(NULL_TREE, type);

2018

2019

if (TREE_CODE (init) != CALL_EXPR &&
TREE_CODE (init) != AGGR_INIT_EXPR)

2020

return
convert (type, init);

2021

2022

fn = TREE_OPERAND (init, 0);

2023

is_ctor = (TREE_CODE (fn) ==
ADDR_EXPR

2024

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

2025

&& DECL_CONSTRUCTOR_P
(TREE_OPERAND (fn, 0)));

2026

2027

slot = build_local_temp
(type);

2028

2029

/*
We split the CALL_EXPR into its function and its arguments here.

2030

Then,
in expand_expr, we put them back together. The reason for

2031

this
is that this expression might be a default argument

2032

expression. In that case, we need a new
temporary every time the

2033

expression is used. That's what
break_out_target_exprs does; it

2034

replaces every AGGR_INIT_EXPR with a copy
that uses a fresh

2035

temporary slot. Then, expand_expr builds up
a call-expression

2036

using
the new slot.
*/

2037

2038

/*
If we don't need to use a constructor to create an object of this

2039

type,
don't mess with AGGR_INIT_EXPR.
*/

2040

if (is_ctor ||
TREE_ADDRESSABLE (type))

2041

{

2042

rval = build
(AGGR_INIT_EXPR, type, fn, TREE_OPERAND (init, 1), slot);

2043

TREE_SIDE_EFFECTS (rval) =
1;

2044

AGGR_INIT_VIA_CTOR_P
(rval) = is_ctor;

2045

}

2046

else

2047

rval = init;

2048

2049

rval = build_target_expr
(slot, rval);

2050

2051

return
rval;

2052

}

现在需要更新在
TARGET_EXPR
中的临时对象，因为我们不是在产生原始的
TARGET_EXPR
的上下文中。看到这个临时对象成为了局部的，其
DECL_CONTEXT
被强制设置为
current_function_decl

。

253

static
tree

254

build_local_temp

(tree type)
in
cp/tree.c

255

{

256

tree slot = build_decl
(VAR_DECL, NULL_TREE, type);

257

DECL_ARTIFICIAL (slot) = 1;

258

DECL_CONTEXT (slot) = current_function_decl

;

259

layout_decl
(slot,
0);

260

return
slot;

261

}

注意如果对于这个
AGGR_INIT_EXPR
，
AGGR_INIT_VIA_CTOR_P
成立，表示这个初始化是通过一个构造函数调用实现。在
2042
行所构建的
AGGR_INIT_EXPR
，其第三个操作数是这个临时对象，它总是一个
VAR_DECL
。而
init

是原来
TARGET_EXPR
中的
AGGR_INIT_EXPR
（这个
AGGR_INIT_EXPR
的第三个操作数的地址被提取，并替换实参列表中的值。这个情况下，该表达式的值是提供给这个
AGGR_INIT_EXPR
的
VAR_DECL
；构造函数不返回值）。

最后，这个新构建的
TARGET_EXPR
被
build_cplus_new

返回。

而对于
TARGET_EXPR
的第二个操作数不是
AGGR_INIT_EXPR
的情况，该操作数由
build_target_expr_with_type

来处理。这里如果
init

是
TARGET_EXPR
，它必定是由在
bot_manip

中
1209
行的
break_out_target_exprs

所构建的，这个节点正是我们期望的。

320

tree

321

build_target_expr_with_type

(tree init,
tree type)
in
cp/tree.c

322

{

323

tree slot;

324

325

if (TREE_CODE (init) == TARGET_EXPR)

326

return
init;

327

else if (CLASS_TYPE_P (type) &&
!TYPE_HAS_TRIVIAL_INIT_REF (type)

328

&& TREE_CODE (init) !=
COND_EXPR

329

&& TREE_CODE (init) !=
CONSTRUCTOR

330

&& TREE_CODE (init) !=
VA_ARG_EXPR)

331

/* We need to
build up a copy constructor call. COND_EXPR is a special

332

case because we
already have copies on the arms and we don't want

333

another one
here. A CONSTRUCTOR is aggregate initialization, which

334

is handled
separately. A VA_ARG_EXPR is magic creation of an

335

aggregate; there's no additional work to be
done.
*/

336

return
force_rvalue
(init);

337

338

slot = build_local_temp
(type);

339

return
build_target_expr
(slot, init);

340

}

上面，如果
TYPE_HAS_TRIVIAL_INIT_REF
不是
0
，表示该拷贝初始化可以使用按位拷贝。对于这样的情形，可以简单地构建
TARGET_EXPR
；否则，需要执行一个左值到右值的转换，包括如下所示的拷贝构造函数调用。

590

tree

591

force_rvalue

(tree expr)
in
cvt.c

592

{

593

if (IS_AGGR_TYPE (TREE_TYPE
(expr)) && TREE_CODE (expr) != TARGET_EXPR)

594

expr = ocp_convert (TREE_TYPE (expr), expr,

595

CONV_IMPLICIT|CONV_FORCE_TEMP, LOOKUP_NORMAL);

596

else

597

expr = decay_conversion
(expr);

598

599

return
expr;

600

}

不久之后我们将看到
ocp_convert

的细节。在这里总而言之，该函数将产生调用合适的拷贝构造函数代码，然后调用
build_cplus_new

来产生构建这个临时对象及其初始化。在离开
bot_manip

之前，看一下
build_target_expr

。

234

static
tree

235

build_target_expr

(tree decl, tree
value)
in
cp/tree.c

236

{

237

tree t;

238

239

t = build
(TARGET_EXPR,
TREE_TYPE (decl), decl, value,

240

cxx_maybe_build_cleanup
(decl), NULL_TREE);

241

/* We always set
TREE_SIDE_EFFECTS so that expand_expr does not

242

ignore the
TARGET_EXPR. If there really turn out to be no

243

side-effects,
then the optimizer should be able to get rid of

244

whatever code is
generated anyhow.
*/

245

TREE_SIDE_EFFECTS (t) = 1;

246

247

return
t;

248

}

对于具有非平凡析构函数的临时对象，编译器需要产生代码，在其越出其作用域时，通过调用这个析构函数摧毁这个临时对象。因此在
240
行，
cxx_maybe_build_cleanup

产生这些代码，如果需要的话。

现在在
bot_manip

的
1213
行，
u

是对应于
t

的
TARGET_EXPR
。它把新旧版本的临时对象映射起来。然后，我们立即用新版本取代了旧版本。不过，在由
break_out_target_exprs

处理的节点的某些子节点中，可能仍然保留了这个旧版本的引用，它们需要如下的更新。

1236

static
tree

1237

bot_replace

(tree* t,
in
cp/tree.c

1238

int* walk_subtrees
ATTRIBUTE_UNUSED ,

1239

void* data)

1240

{

1241

splay_tree target_remap =
((splay_tree) data);

1242

1243

if (TREE_CODE (*t) ==
VAR_DECL)

1244

{

1245

splay_tree_node n =
splay_tree_lookup (target_remap,

1246

(splay_tree_key)
*t);

1247

if (n)

1248

*t = (tree) n->value;

1249

}

1250

1251

return
NULL_TREE;

1252

}

回到
convert_default_arg

，在
4274
行从
break_out_target_exprs

得到这个更新的
arg

，然后接下来的函数用于产生初始化代码。

5.12.5.2.2.2.3.

省略实参

最后一个的可能就是省略实参，注意到省略实参与缺省实参不可共存。在前端中，为了识别包含了省略实参的函数声明，形参列表由
NULL
，而不是
void_list_node

来结尾。

4161

tree

4162

convert_arg_to_ellipsis

(tree arg)
in
call.c

4163

{

4164

/*
[expr.call]

4165

4166

The
lvalue-to-rvalue, array-to-pointer, and function-to-pointer

4167

standard conversions are performed.
*/

4168

arg = decay_conversion
(arg);

4169

/* [expr.call]

4170

4171

If the
argument has integral or enumeration type that is subject

4172

to the
integral promotions (_conv.prom_), or a floating point

4173

type
that is subject to the floating point promotion

4174

(_conv.fpprom_), the value of the argument
is converted to the

4175

promoted type before the call.
*/

4176

if (TREE_CODE (TREE_TYPE
(arg)) == REAL_TYPE

4177

&&
(TYPE_PRECISION (TREE_TYPE (arg))

4178

< TYPE_PRECISION
(double_type_node)))

4179

arg = convert_to_real
(double_type_node, arg);

4180

else if (INTEGRAL_OR_ENUMERATION_TYPE_P
(TREE_TYPE (arg)))

4181

arg =
perform_integral_promotions (arg);

4182

4183

arg = require_complete_type
(arg);

4184

4185

if (arg != error_mark_node

4186

&& !pod_type_p
(TREE_TYPE (arg)))

4187

{

4188

/*
Undefined behavior [expr.call] 5.2.2/7. We used
to just warn

4189

here
and do a bitwise copy, but now cp_expr_size will abort if we

4190

try
to do that.

4191

If
the call appears in the context of a sizeof expression,

4192

there is no need to emit a warning, since
the expression won't be

4193

evaluated. We keep the builtin_trap just
as a safety check.
*/

4194

if (!skip_evaluation

)

4195

warning ("cannot
pass objects of non-POD type `%#T' through `...'; "

4196

"call will
abort at runtime", TREE_TYPE (arg));

4197

arg = call_builtin_trap
();

4198

arg = build
(COMPOUND_EXPR, integer_type_node, arg,

4199

integer_zero_node);

4200

}

4201

4202

return
arg;

4203

}

【
3
】的条文
5.2.2
“函数调用”，条款
7
如下定义了编译器在省略实参上的行为。

7. 当一个给定的实参没有对应的形参，该实参被以这样的方式传入——接受函数可以通过调用 va_arg （ 18.7 ）来得到该实参值。左值到右值（ 4.1 ），数组到指针（ 4.2 ），及函数到指针（ 4.3 ）标准转换在该实参表达式上执行。在这些转换之后，如果该实参不是数字，枚举值，指针，成员的指针，或类类型，该程序非法。如果该实参具有一个 non-POD 类类型（条文 9 ），其行为是未定义的。如果该实参具有适用于整型提升（ 4.5 ）的整型或枚举类型，或适用于浮点提升（ 4.6 ）的浮点类型，在该调用之前，该实参的值被转换到提升后的类型。这些提升被称为缺省实参提升 。

函数
decay_conversion

执行在
exp

中的转换，它应用在当一个左值出现在一个右值上下文中时候。包括左值到右值，数组到指针，及函数到指针的转换。

1335

tree

1336

decay_conversion

(tree exp)
n
typeck.c

1337

{

1338

tree type;

1339

enum
tree_code code;

1340

1341

type = TREE_TYPE (exp);

1342

code = TREE_CODE (type);

1343

1344

if (code == REFERENCE_TYPE)

1345

{

1346

exp = convert_from_reference
(exp);

1347

type = TREE_TYPE (exp);

1348

code = TREE_CODE (type);

1349

}

1350

1351

if (type == error_mark_node)

1352

return
error_mark_node;

1353

1354

if (type_unknown_p (exp))

1355

{

1356

cxx_incomplete_type_error
(exp, TREE_TYPE (exp));

1357

return
error_mark_node;

1358

}

1359

1360

/*
Constants can be used directly unless they're not loadable.
*/

1361

if (TREE_CODE (exp) ==
CONST_DECL)

1362

exp = DECL_INITIAL (exp);

1363

/*
Replace a nonvolatile const static variable with its value. We

1364

don't
do this for arrays, though; we want the address of the

1365

first
element of the array, not the address of the first element

1366

of its
initializing constant.
*/

1367

else if (code != ARRAY_TYPE)

1368

{

1369

exp = decl_constant_value
(exp);

1370

type = TREE_TYPE (exp);

1371

}

1372

1373

/* build_c_cast puts on a NOP_EXPR to make the
result not an lvalue.

1374

Leave
such NOP_EXPRs, since RHS is being used in non-lvalue context.
*/

1375

1376

if (code == VOID_TYPE)

1377

{

1378

error ("void value
not ignored as it ought to be");

1379

return
error_mark_node;

1380

}

1381

if
(invalid_nonstatic_memfn_p (exp))

1382

return
error_mark_node;

1383

if (code == FUNCTION_TYPE ||
is_overloaded_fn
(exp))

1384

return
build_unary_op (ADDR_EXPR, exp, 0);

1385

if (code == ARRAY_TYPE)

1386

{

1387

tree adr;

1388

tree ptrtype;

1389

1390

if (TREE_CODE (exp) ==
INDIRECT_REF)

1391

return
build_nop (build_pointer_type
(TREE_TYPE
(type)),

1392

TREE_OPERAND (exp, 0));

1393

1394

if (TREE_CODE (exp) ==
COMPOUND_EXPR)

1395

{

1396

tree op1 = decay_conversion
(TREE_OPERAND (exp, 1));

1397

return
build
(COMPOUND_EXPR, TREE_TYPE (op1),

1398

TREE_OPERAND
(exp, 0), op1);

1399

}

1400

1401

if (!lvalue_p (exp)

1402

&& ! (TREE_CODE
(exp) == CONSTRUCTOR && TREE_STATIC (exp)))

1403

{

1404

error ("invalid use
of non-lvalue array");

1405

return
error_mark_node;

1406

}

1407

1408

ptrtype = build_pointer_type
(TREE_TYPE (type));

1409

1410

if (TREE_CODE (exp) ==
VAR_DECL)

1411

{

1412

if
(!cxx_mark_addressable (exp))

1413

return
error_mark_node;

1414

adr = build_nop
(ptrtype, build_address
(exp));

1415

TREE_SIDE_EFFECTS (adr)
= 0;
/*
Default would be, same as EXP.
*/

1416

return
adr;

1417

}

1418

/*
This way is better for a COMPONENT_REF since it can

1419

simplify the offset for a component.
*/

1420

adr = build_unary_op
(ADDR_EXPR, exp, 1);

1421

return
cp_convert (ptrtype, adr);

1422

}

1423

1424

/*
[basic.lval]: Class rvalues can have cv-qualified types; non-class

1425

rvalues always have cv-unqualified
types.
*/

1426

if (! CLASS_TYPE_P (type))

1427

exp = cp_convert
(TYPE_MAIN_VARIANT (type), exp);

1428

1429

return
exp;

1430

}

首先对于
REFERENCE_TYPE
，它是一个左值，要把它转换为右值，就应该使用被引用的值，而不再保存引用。在前端中，
INDIRECT_REF
为这个目标而构建（这是因为引用总是传入其地址就像指针那样；而在编译器中，引用的模式（
mode
）与指针的相同，都是
ptr_mode

，参见
build_reference_type

）。

566

tree

567

convert_from_reference

(tree val)

in cvt.c

568

{

569

if (TREE_CODE (TREE_TYPE (val)) ==
REFERENCE_TYPE)

570

return
build_indirect_ref
(val, NULL);

571

return
val;

572

}

记得指针是右值。当处理
ARRAY_TYPE
时，如果我们正在使用形如：
int *a[i]
（
a
是维度大于
1
的数组，例如，
int
A[2][2]
）的表达式，满足
1390
行的条件，
因此构建了形如：
int**
的类型，并且看到转换指针“
int
*a[i]
”到“
int**
”不需要产生任何代码，因而为这个转换构建了
NOP_EXPR
。

而如果
exp

只是一个数组的声明，例如：
int a[8]
，这个声明的右值是“
int*
”。可以直接构建这个右值。不过，对于其他的情形，例如：“
tempA.a
”（这是一棵以
SCOPE_REF
为根节点的树），就没有可以直接使用的简单规则，因此调用
build_unary_op

及
cp_convert

来执行合适的转换。

正如在
convert_arg_to_ellipsis

的
4188
行的注释所提到的，对于对应于
non-POD
类类型的未定义行为，
GCC
以前使用按位拷贝，不过在当前版本中，这个行为在后面对
cp_expr_size

的调用将导致异常终止。这个终止由下面“
__builtin_trap
”的调用触发，在
4198
行它成为了
COMPOUND_EXPR
形式的
arg

的一部分。

4148

c
tree

4149

call_builtin_trap

(void)
in
call.c

4150

{

4151

tree fn = IDENTIFIER_GLOBAL_VALUE
(get_identifier ("__builtin_trap"));

4152

4153

my_friendly_assert (fn !=
NULL, 20030927);

4154

fn = build_call (fn,
NULL_TREE);

4155

return
fn;

4156

}

内建陷阱的行为是：如果目标机器定义了陷阱指令，就使用它；否则编译器将调用
abort

()
（参考
expand_builtin_trap

）。

下面是对
non-POD
类类型省略实参的一个有趣的测试：

#include
<stdarg.h>

class
A {

public
: virtual
void func() {}

};

int func (int
a, ...) {

va_list ap;

va_start(ap, a)
;

va_arg(ap, A);

va_end(ap);

return
1;

}

int main() {

A a;

func (1, a);
// sizeof (func (1, a))

}

编译器将给出以下警告：

test2.cpp: In function ‘int func(int, ...)’:

test2.cpp:11: warning: cannot receive objects of
non-POD type ‘class A’ through ‘...’; call will abort at runtime

test2.cpp: In function ‘int main()’:

test2.cpp:19: warning: cannot pass objects of non-POD
type ‘class A’ through ’...’; call will abort at runtime

当执行这个程序时，得到错误：
Illegal instruction.

不过，如果我们使用注释中的语句，编译器将给出警告：

test2.cpp: In function ‘int func(int, ...)’:

test2.cpp:11: warning: cannot receive objects of
non-POD type ‘class A’ through ‘...’; call will abort at runtime

而在执行时，没有产生错误，因为
func(1, a)
没有被评估，除了其返回值。