Studying note of GCC-3.4.6 source (152)

5.12.5.2.2.2.2.          Default arguments

If arg exhausted, but parm doesn’t, parm must contain default arguments, for which the list should be terminated by the special void_list_node . Then in corresponding node, TREE_VALUE holds the type, and TREE_PURPOSE is the expression of the default argument.

 

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 }

 

Node of DEFAULT_ARG is created for unparsed default argument. Remember during parsing class definition, any default argument is cached by DEFAULT_ARG, which will be parsed after the parsing. So DEFAULT_ARG should not be present here (if so, it may be missing “};” in the class definition), and at this point, the front-end doesn’t know how to handle node of this kind.

Then arg passed for below function at line 4274, is the default argument shared by all invocations of the function. However, as [3] defines, “ Default arguments are evaluated each time the function is called ”, so before really evaluate the expression of the default argument, it needs prepare appropriate copy of arg and update this local temparories acclaimed as below.

 

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 }

 

Above walk_tree traverses the subtree rooted by t and executes provided function upon nodes selected by the code of t . In first traversal, below function is used. Note that the function always returns NULL (copy_tree_r below returns NULL) to force walk_tree to do full traversal with depth first (i.e. tp maybe a tree_list, in which node can contain operands which in turn can be tree_list again and so on, the visit should be from bottom up); however whether stepping into the sub-tree (i.e. operand) is controlled by local variable walk_subtrees (which is passes as argument walk_subtrees in below function). Before processing the tree node with the specified function, walk_subtrees is set as 1; it is the specified function to decide whether the node is of interesting and needs to be stepped into if no result gotten.

 

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 }

 

For node other than constant or TRAGET_EXPR, copy_tree_r copies the node if it is either *_CST (see it is filtered out by TREE_CONSTANT above) or expression or TREE_LIST or TREE_VEC or OVERLOAD (told by C++ hook of tree_chain_matters_p below, and note that walk_subtrees is unchanged here, walk_tree will step into the sub-nodes of the node and continues copying the structure accordingly).

 

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 }

 

A TARGET_EXPR represents a temporary object. The first operand is a VAR_DECL for the temporary variable. The second operand is the initializer for the temporary. The initializer is evaluated, and copied (bitwise) into the temporary.

An AGGR_INIT_EXPR represents the initialization as the return value of a function call, or as the result of a constructor. An AGGR_INIT_EXPR will only appear as the second operand of a TARGET_EXPR. The first operand to the AGGR_INIT_EXPR is the address of a function to call, just as in a CALL_EXPR. The second operand are the arguments to pass that function, as a TREE_LIST, again in a manner similar to that of a CALL_EXPR. The value of the expression is that returned by the function.

Then if AGGR_INIT_EXPR is used in TRAGET_EXPR, it recurses break_out_target_exprs to copy this node. With the copied expression, build_cplus_new generates code for the initialization.

 

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 }

 

Now it needs update the temporary in the TARGET_EXPR, as we are not within the context generating the original TARGET_EXPR. See it makes the temporary as local by forcing its DECL_CONTEXT by 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    }

 

Note if AGGR_INIT_VIA_CTOR_P holds for the AGGR_INIT_EXPR, then the initialization is via a constructor call. AGGR_INIT_EXPR constructed at line 2042 will have this temporary as its third operand, which is always a VAR_DECL. And init is the AGGR_INIT_EXPR in the original TARGET_EXPR (the address of the third operand of the AGGR_INIT_EXPR is taken, and this value replaces the first argument in the argument list. In this case, the value of the expression is the VAR_DECL given by the third operand to the AGGR_INIT_EXPR; constructors do not return a value).

Finally, this new generated TARGET_EXPR is retuned by build_cplus_new .

While for second operand in TARGET_EXPR other than AGGR_INIT_EXPR, the operand is handled by build_target_expr_with_type instead. Here if init is TARGET_EXPR, it must be one that built by break_out_target_exprs at line 1209 in bot_manip , which is the node we expect.

 

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    }

 

Above if TYPE_HAS_TRIVIAL_INIT_REF is nonzero, it means that copy initialization of the type can use a bitwise copy. For which case, it can simply build TARGET_EXPR; otherwise, it needs perform an lvalue-to-rvalue conversion, including invoking the copy ctor as below.

 

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    }

 

We will see the detail of ocp_convert in short later. As summary here, the function will generate code for invoking the appropriate copy ctor and then invoking build_cplus_new to create the temporary with its initialization. Before leaving bot_manip , it worthes a look of 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    }

 

For temporary with non-trivial destructor, the compiler needs generate code to destory the temporary at exitting its scope by invoking the destructor. So at line 240, cxx_maybe_build_cleanup generates this code if necessary.

Now at line 1213 in bot_manip , u is the TARGET_EXPR built corresponding to t . It maps the new version temporary with the old one. Then, we immediately replace the old one with it. However, it is possible some sub-nodes within node handled by break_out_target_exprs , still hold the reference to this old version, which needs be updated as below.

 

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 }

 

Back convert_default_arg , it gets the updated arg at line 4274 from break_out_target_exprs , then the following functions are used to generate code for the initialization.

5.12.5.2.2.2.3.          Ellipsis arguments

The last possibility is the ellipsis arguments, note that ellipsis argument can’t coexist with default argument. In front-end to tell out function declaration containing ellipsis arguments, the list of parameters is terminated by NULL instead of 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], clause 5.2.2 “Function call”, terms 7 defines the behavior of compiler upon ellipsis argument as below.

7.  When there is no parameter for a given argument, the argument is passed in such a way that the receiving function can obtain the value of the argument by invoking va_arg (18.7). The lvalue-to-rvalue (4.1), array-to-pointer (4.2), and function-to-pointer (4.3) standard conversions are performed on the argument expression. After these conversions, if the argument does not have arithmetic, enumeration, pointer, pointer to member, or class type, the program is ill-formed. If the argument has a non-POD class type (clause 9), the behavior is undefined. If the argument has integral or enumeration type that is subject to the integral promotions (4.5), or a floating point type that is subject to the floating point promotion (4.6), the value of the argument is converted to the promoted type before the call. These promotions are referred to as the default argument promotions .

Function decay_conversion performs the conversions in exp, which are used when an lvalue appears in an rvalue context, and include lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversion.

 

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 }

 

First for REFERENCE_TYPE, it is a lvalue, to change it to rvalue, it should uses the value referred instead of holding reference any more. In front-end, INDIRECT_REF is built for the purpose (it because reference always has its address passed just like pointer, and in compiler, the mode of reference is the same as pointer, both are ptr_mode , see 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    }

 

Remember pointer is rvalue. When handling ARRAY_TYPE, condition at line 1390 is satisfied, if we are using expression like: int *a[i] (a is array having dimensions more than 1, for example, int A[2][2]), so it builds type like: int**, and see converting pointer of “int *a[i]” to “int**” needesn’t generate any code, NOP_EXPR is built for such conversion.

Further if exp simply is a declaration of an array, for exmaple: int a[8], rvalue of this declaration is just “int*”. It can build this rvalue directly. However, for other cases, for example: tempA.a (it is a tree rooted by SCOPE_REF), it is not a simple rule we can use directly, so it asks build_unary_op and cp_convert to do the appropriate conversion.

As comment at line 4188 in convert_arg_to_ellipsis mentions, for the undefined behavior of non-POD class type, GCC once uses bitwise copy, but this behavior will cause later invocation of cp_expr_size triggering abort in current version. This abort is triggered by below invocation of “__builtin_trap”, which is included in arg of COMPOUND_EXPR at line 4198.

 

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 }

 

The behavior of the builtin trap will use trap if the target machine defines it; otherwise the compiler will call abort () (see expand_builtin_trap ).

Below is an interesting test for the behavior of non-POD class type:

#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))

}

The compiler will give out following warning:

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

When execute the program, it gets error: Illegal instruction.

However, if we use statement in comment instead, the compiler then gives warning as:

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

And at execution, no error will be output, as func(1, a) will not be evaluated except its returned value.