OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [cp/] [init.c] - Blame information for rev 333

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 283 jeremybenn
/* Handle initialization things in C++.
2
   Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
   Contributed by Michael Tiemann (tiemann@cygnus.com)
6
 
7
This file is part of GCC.
8
 
9
GCC is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 3, or (at your option)
12
any later version.
13
 
14
GCC is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
GNU General Public License for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with GCC; see the file COPYING3.  If not see
21
<http://www.gnu.org/licenses/>.  */
22
 
23
/* High-level class interface.  */
24
 
25
#include "config.h"
26
#include "system.h"
27
#include "coretypes.h"
28
#include "tm.h"
29
#include "tree.h"
30
#include "rtl.h"
31
#include "expr.h"
32
#include "cp-tree.h"
33
#include "flags.h"
34
#include "output.h"
35
#include "except.h"
36
#include "toplev.h"
37
#include "target.h"
38
 
39
static bool begin_init_stmts (tree *, tree *);
40
static tree finish_init_stmts (bool, tree, tree);
41
static void construct_virtual_base (tree, tree);
42
static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t);
43
static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t);
44
static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int);
45
static void perform_member_init (tree, tree);
46
static tree build_builtin_delete_call (tree);
47
static int member_init_ok_or_else (tree, tree, tree);
48
static void expand_virtual_init (tree, tree);
49
static tree sort_mem_initializers (tree, tree);
50
static tree initializing_context (tree);
51
static void expand_cleanup_for_base (tree, tree);
52
static tree get_temp_regvar (tree, tree);
53
static tree dfs_initialize_vtbl_ptrs (tree, void *);
54
static tree build_dtor_call (tree, special_function_kind, int);
55
static tree build_field_list (tree, tree, int *);
56
static tree build_vtbl_address (tree);
57
 
58
/* We are about to generate some complex initialization code.
59
   Conceptually, it is all a single expression.  However, we may want
60
   to include conditionals, loops, and other such statement-level
61
   constructs.  Therefore, we build the initialization code inside a
62
   statement-expression.  This function starts such an expression.
63
   STMT_EXPR_P and COMPOUND_STMT_P are filled in by this function;
64
   pass them back to finish_init_stmts when the expression is
65
   complete.  */
66
 
67
static bool
68
begin_init_stmts (tree *stmt_expr_p, tree *compound_stmt_p)
69
{
70
  bool is_global = !building_stmt_tree ();
71
 
72
  *stmt_expr_p = begin_stmt_expr ();
73
  *compound_stmt_p = begin_compound_stmt (BCS_NO_SCOPE);
74
 
75
  return is_global;
76
}
77
 
78
/* Finish out the statement-expression begun by the previous call to
79
   begin_init_stmts.  Returns the statement-expression itself.  */
80
 
81
static tree
82
finish_init_stmts (bool is_global, tree stmt_expr, tree compound_stmt)
83
{
84
  finish_compound_stmt (compound_stmt);
85
 
86
  stmt_expr = finish_stmt_expr (stmt_expr, true);
87
 
88
  gcc_assert (!building_stmt_tree () == is_global);
89
 
90
  return stmt_expr;
91
}
92
 
93
/* Constructors */
94
 
95
/* Called from initialize_vtbl_ptrs via dfs_walk.  BINFO is the base
96
   which we want to initialize the vtable pointer for, DATA is
97
   TREE_LIST whose TREE_VALUE is the this ptr expression.  */
98
 
99
static tree
100
dfs_initialize_vtbl_ptrs (tree binfo, void *data)
101
{
102
  if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
103
    return dfs_skip_bases;
104
 
105
  if (!BINFO_PRIMARY_P (binfo) || BINFO_VIRTUAL_P (binfo))
106
    {
107
      tree base_ptr = TREE_VALUE ((tree) data);
108
 
109
      base_ptr = build_base_path (PLUS_EXPR, base_ptr, binfo, /*nonnull=*/1);
110
 
111
      expand_virtual_init (binfo, base_ptr);
112
    }
113
 
114
  return NULL_TREE;
115
}
116
 
117
/* Initialize all the vtable pointers in the object pointed to by
118
   ADDR.  */
119
 
120
void
121
initialize_vtbl_ptrs (tree addr)
122
{
123
  tree list;
124
  tree type;
125
 
126
  type = TREE_TYPE (TREE_TYPE (addr));
127
  list = build_tree_list (type, addr);
128
 
129
  /* Walk through the hierarchy, initializing the vptr in each base
130
     class.  We do these in pre-order because we can't find the virtual
131
     bases for a class until we've initialized the vtbl for that
132
     class.  */
133
  dfs_walk_once (TYPE_BINFO (type), dfs_initialize_vtbl_ptrs, NULL, list);
134
}
135
 
136
/* Return an expression for the zero-initialization of an object with
137
   type T.  This expression will either be a constant (in the case
138
   that T is a scalar), or a CONSTRUCTOR (in the case that T is an
139
   aggregate), or NULL (in the case that T does not require
140
   initialization).  In either case, the value can be used as
141
   DECL_INITIAL for a decl of the indicated TYPE; it is a valid static
142
   initializer. If NELTS is non-NULL, and TYPE is an ARRAY_TYPE, NELTS
143
   is the number of elements in the array.  If STATIC_STORAGE_P is
144
   TRUE, initializers are only generated for entities for which
145
   zero-initialization does not simply mean filling the storage with
146
   zero bytes.  */
147
 
148
tree
149
build_zero_init (tree type, tree nelts, bool static_storage_p)
150
{
151
  tree init = NULL_TREE;
152
 
153
  /* [dcl.init]
154
 
155
     To zero-initialize an object of type T means:
156
 
157
     -- if T is a scalar type, the storage is set to the value of zero
158
        converted to T.
159
 
160
     -- if T is a non-union class type, the storage for each nonstatic
161
        data member and each base-class subobject is zero-initialized.
162
 
163
     -- if T is a union type, the storage for its first data member is
164
        zero-initialized.
165
 
166
     -- if T is an array type, the storage for each element is
167
        zero-initialized.
168
 
169
     -- if T is a reference type, no initialization is performed.  */
170
 
171
  gcc_assert (nelts == NULL_TREE || TREE_CODE (nelts) == INTEGER_CST);
172
 
173
  if (type == error_mark_node)
174
    ;
175
  else if (static_storage_p && zero_init_p (type))
176
    /* In order to save space, we do not explicitly build initializers
177
       for items that do not need them.  GCC's semantics are that
178
       items with static storage duration that are not otherwise
179
       initialized are initialized to zero.  */
180
    ;
181
  else if (SCALAR_TYPE_P (type))
182
    init = convert (type, integer_zero_node);
183
  else if (CLASS_TYPE_P (type))
184
    {
185
      tree field;
186
      VEC(constructor_elt,gc) *v = NULL;
187
 
188
      /* Iterate over the fields, building initializations.  */
189
      for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
190
        {
191
          if (TREE_CODE (field) != FIELD_DECL)
192
            continue;
193
 
194
          /* Note that for class types there will be FIELD_DECLs
195
             corresponding to base classes as well.  Thus, iterating
196
             over TYPE_FIELDs will result in correct initialization of
197
             all of the subobjects.  */
198
          if (!static_storage_p || !zero_init_p (TREE_TYPE (field)))
199
            {
200
              tree value = build_zero_init (TREE_TYPE (field),
201
                                            /*nelts=*/NULL_TREE,
202
                                            static_storage_p);
203
              if (value)
204
                CONSTRUCTOR_APPEND_ELT(v, field, value);
205
            }
206
 
207
          /* For unions, only the first field is initialized.  */
208
          if (TREE_CODE (type) == UNION_TYPE)
209
            break;
210
        }
211
 
212
      /* Build a constructor to contain the initializations.  */
213
      init = build_constructor (type, v);
214
    }
215
  else if (TREE_CODE (type) == ARRAY_TYPE)
216
    {
217
      tree max_index;
218
      VEC(constructor_elt,gc) *v = NULL;
219
 
220
      /* Iterate over the array elements, building initializations.  */
221
      if (nelts)
222
        max_index = fold_build2_loc (input_location,
223
                                 MINUS_EXPR, TREE_TYPE (nelts),
224
                                 nelts, integer_one_node);
225
      else
226
        max_index = array_type_nelts (type);
227
 
228
      /* If we have an error_mark here, we should just return error mark
229
         as we don't know the size of the array yet.  */
230
      if (max_index == error_mark_node)
231
        return error_mark_node;
232
      gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
233
 
234
      /* A zero-sized array, which is accepted as an extension, will
235
         have an upper bound of -1.  */
236
      if (!tree_int_cst_equal (max_index, integer_minus_one_node))
237
        {
238
          constructor_elt *ce;
239
 
240
          v = VEC_alloc (constructor_elt, gc, 1);
241
          ce = VEC_quick_push (constructor_elt, v, NULL);
242
 
243
          /* If this is a one element array, we just use a regular init.  */
244
          if (tree_int_cst_equal (size_zero_node, max_index))
245
            ce->index = size_zero_node;
246
          else
247
            ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
248
                                max_index);
249
 
250
          ce->value = build_zero_init (TREE_TYPE (type),
251
                                       /*nelts=*/NULL_TREE,
252
                                       static_storage_p);
253
        }
254
 
255
      /* Build a constructor to contain the initializations.  */
256
      init = build_constructor (type, v);
257
    }
258
  else if (TREE_CODE (type) == VECTOR_TYPE)
259
    init = fold_convert (type, integer_zero_node);
260
  else
261
    gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
262
 
263
  /* In all cases, the initializer is a constant.  */
264
  if (init)
265
    TREE_CONSTANT (init) = 1;
266
 
267
  return init;
268
}
269
 
270
/* Return a suitable initializer for value-initializing an object of type
271
   TYPE, as described in [dcl.init].  */
272
 
273
tree
274
build_value_init (tree type)
275
{
276
  /* [dcl.init]
277
 
278
     To value-initialize an object of type T means:
279
 
280
     - if T is a class type (clause 9) with a user-provided constructor
281
       (12.1), then the default constructor for T is called (and the
282
       initialization is ill-formed if T has no accessible default
283
       constructor);
284
 
285
     - if T is a non-union class type without a user-provided constructor,
286
       then every non-static data member and base-class component of T is
287
       value-initialized;92)
288
 
289
     - if T is an array type, then each element is value-initialized;
290
 
291
     - otherwise, the object is zero-initialized.
292
 
293
     A program that calls for default-initialization or
294
     value-initialization of an entity of reference type is ill-formed.
295
 
296
     92) Value-initialization for such a class object may be implemented by
297
     zero-initializing the object and then calling the default
298
     constructor.  */
299
 
300
  if (CLASS_TYPE_P (type))
301
    {
302
      if (type_has_user_provided_constructor (type))
303
        return build_aggr_init_expr
304
          (type,
305
           build_special_member_call (NULL_TREE, complete_ctor_identifier,
306
                                      NULL, type, LOOKUP_NORMAL,
307
                                      tf_warning_or_error));
308
      else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
309
        {
310
          /* This is a class that needs constructing, but doesn't have
311
             a user-provided constructor.  So we need to zero-initialize
312
             the object and then call the implicitly defined ctor.
313
             This will be handled in simplify_aggr_init_expr.  */
314
          tree ctor = build_special_member_call
315
            (NULL_TREE, complete_ctor_identifier,
316
             NULL, type, LOOKUP_NORMAL, tf_warning_or_error);
317
 
318
          ctor = build_aggr_init_expr (type, ctor);
319
          AGGR_INIT_ZERO_FIRST (ctor) = 1;
320
          return ctor;
321
        }
322
    }
323
  return build_value_init_noctor (type);
324
}
325
 
326
/* Like build_value_init, but don't call the constructor for TYPE.  Used
327
   for base initializers.  */
328
 
329
tree
330
build_value_init_noctor (tree type)
331
{
332
  if (CLASS_TYPE_P (type))
333
    {
334
      gcc_assert (!TYPE_NEEDS_CONSTRUCTING (type));
335
 
336
      if (TREE_CODE (type) != UNION_TYPE)
337
        {
338
          tree field;
339
          VEC(constructor_elt,gc) *v = NULL;
340
 
341
          /* Iterate over the fields, building initializations.  */
342
          for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
343
            {
344
              tree ftype, value;
345
 
346
              if (TREE_CODE (field) != FIELD_DECL)
347
                continue;
348
 
349
              ftype = TREE_TYPE (field);
350
 
351
              if (TREE_CODE (ftype) == REFERENCE_TYPE)
352
                error ("value-initialization of reference");
353
 
354
              /* We could skip vfields and fields of types with
355
                 user-defined constructors, but I think that won't improve
356
                 performance at all; it should be simpler in general just
357
                 to zero out the entire object than try to only zero the
358
                 bits that actually need it.  */
359
 
360
              /* Note that for class types there will be FIELD_DECLs
361
                 corresponding to base classes as well.  Thus, iterating
362
                 over TYPE_FIELDs will result in correct initialization of
363
                 all of the subobjects.  */
364
              value = build_value_init (ftype);
365
 
366
              if (value)
367
                CONSTRUCTOR_APPEND_ELT(v, field, value);
368
            }
369
 
370
          /* Build a constructor to contain the zero- initializations.  */
371
          return build_constructor (type, v);
372
        }
373
    }
374
  else if (TREE_CODE (type) == ARRAY_TYPE)
375
    {
376
      VEC(constructor_elt,gc) *v = NULL;
377
 
378
      /* Iterate over the array elements, building initializations.  */
379
      tree max_index = array_type_nelts (type);
380
 
381
      /* If we have an error_mark here, we should just return error mark
382
         as we don't know the size of the array yet.  */
383
      if (max_index == error_mark_node)
384
        return error_mark_node;
385
      gcc_assert (TREE_CODE (max_index) == INTEGER_CST);
386
 
387
      /* A zero-sized array, which is accepted as an extension, will
388
         have an upper bound of -1.  */
389
      if (!tree_int_cst_equal (max_index, integer_minus_one_node))
390
        {
391
          constructor_elt *ce;
392
 
393
          v = VEC_alloc (constructor_elt, gc, 1);
394
          ce = VEC_quick_push (constructor_elt, v, NULL);
395
 
396
          /* If this is a one element array, we just use a regular init.  */
397
          if (tree_int_cst_equal (size_zero_node, max_index))
398
            ce->index = size_zero_node;
399
          else
400
            ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
401
                                max_index);
402
 
403
          ce->value = build_value_init (TREE_TYPE (type));
404
 
405
          /* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs.  */
406
          gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
407
                      && TREE_CODE (ce->value) != AGGR_INIT_EXPR);
408
        }
409
 
410
      /* Build a constructor to contain the initializations.  */
411
      return build_constructor (type, v);
412
    }
413
 
414
  return build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
415
}
416
 
417
/* Initialize MEMBER, a FIELD_DECL, with INIT, a TREE_LIST of
418
   arguments.  If TREE_LIST is void_type_node, an empty initializer
419
   list was given; if NULL_TREE no initializer was given.  */
420
 
421
static void
422
perform_member_init (tree member, tree init)
423
{
424
  tree decl;
425
  tree type = TREE_TYPE (member);
426
 
427
  /* Effective C++ rule 12 requires that all data members be
428
     initialized.  */
429
  if (warn_ecpp && init == NULL_TREE && TREE_CODE (type) != ARRAY_TYPE)
430
    warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Weffc__,
431
                "%qD should be initialized in the member initialization list",
432
                member);
433
 
434
  /* Get an lvalue for the data member.  */
435
  decl = build_class_member_access_expr (current_class_ref, member,
436
                                         /*access_path=*/NULL_TREE,
437
                                         /*preserve_reference=*/true,
438
                                         tf_warning_or_error);
439
  if (decl == error_mark_node)
440
    return;
441
 
442
  if (init == void_type_node)
443
    {
444
      /* mem() means value-initialization.  */
445
      if (TREE_CODE (type) == ARRAY_TYPE)
446
        {
447
          init = build_vec_init (decl, NULL_TREE, NULL_TREE,
448
                                 /*explicit_value_init_p=*/true,
449
                                 /* from_array=*/0,
450
                                 tf_warning_or_error);
451
          finish_expr_stmt (init);
452
        }
453
      else
454
        {
455
          if (TREE_CODE (type) == REFERENCE_TYPE)
456
            permerror (DECL_SOURCE_LOCATION (current_function_decl),
457
                       "value-initialization of %q#D, which has reference type",
458
                       member);
459
          else
460
            {
461
              init = build2 (INIT_EXPR, type, decl, build_value_init (type));
462
              finish_expr_stmt (init);
463
            }
464
        }
465
    }
466
  /* Deal with this here, as we will get confused if we try to call the
467
     assignment op for an anonymous union.  This can happen in a
468
     synthesized copy constructor.  */
469
  else if (ANON_AGGR_TYPE_P (type))
470
    {
471
      if (init)
472
        {
473
          init = build2 (INIT_EXPR, type, decl, TREE_VALUE (init));
474
          finish_expr_stmt (init);
475
        }
476
    }
477
  else if (TYPE_NEEDS_CONSTRUCTING (type))
478
    {
479
      if (init != NULL_TREE
480
          && TREE_CODE (type) == ARRAY_TYPE
481
          && TREE_CHAIN (init) == NULL_TREE
482
          && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE)
483
        {
484
          /* Initialization of one array from another.  */
485
          finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init),
486
                                            /*explicit_value_init_p=*/false,
487
                                            /* from_array=*/1,
488
                                            tf_warning_or_error));
489
        }
490
      else
491
        {
492
          if (CP_TYPE_CONST_P (type)
493
              && init == NULL_TREE
494
              && !type_has_user_provided_default_constructor (type))
495
            /* TYPE_NEEDS_CONSTRUCTING can be set just because we have a
496
               vtable; still give this diagnostic.  */
497
            permerror (DECL_SOURCE_LOCATION (current_function_decl),
498
                       "uninitialized member %qD with %<const%> type %qT",
499
                       member, type);
500
          finish_expr_stmt (build_aggr_init (decl, init, 0,
501
                                             tf_warning_or_error));
502
        }
503
    }
504
  else
505
    {
506
      if (init == NULL_TREE)
507
        {
508
          /* member traversal: note it leaves init NULL */
509
          if (TREE_CODE (type) == REFERENCE_TYPE)
510
            permerror (DECL_SOURCE_LOCATION (current_function_decl),
511
                       "uninitialized reference member %qD",
512
                       member);
513
          else if (CP_TYPE_CONST_P (type))
514
            permerror (DECL_SOURCE_LOCATION (current_function_decl),
515
                       "uninitialized member %qD with %<const%> type %qT",
516
                       member, type);
517
        }
518
      else if (TREE_CODE (init) == TREE_LIST)
519
        /* There was an explicit member initialization.  Do some work
520
           in that case.  */
521
        init = build_x_compound_expr_from_list (init, "member initializer");
522
 
523
      if (init)
524
        finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
525
                                                tf_warning_or_error));
526
    }
527
 
528
  if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
529
    {
530
      tree expr;
531
 
532
      expr = build_class_member_access_expr (current_class_ref, member,
533
                                             /*access_path=*/NULL_TREE,
534
                                             /*preserve_reference=*/false,
535
                                             tf_warning_or_error);
536
      expr = build_delete (type, expr, sfk_complete_destructor,
537
                           LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
538
 
539
      if (expr != error_mark_node)
540
        finish_eh_cleanup (expr);
541
    }
542
}
543
 
544
/* Returns a TREE_LIST containing (as the TREE_PURPOSE of each node) all
545
   the FIELD_DECLs on the TYPE_FIELDS list for T, in reverse order.  */
546
 
547
static tree
548
build_field_list (tree t, tree list, int *uses_unions_p)
549
{
550
  tree fields;
551
 
552
  *uses_unions_p = 0;
553
 
554
  /* Note whether or not T is a union.  */
555
  if (TREE_CODE (t) == UNION_TYPE)
556
    *uses_unions_p = 1;
557
 
558
  for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))
559
    {
560
      /* Skip CONST_DECLs for enumeration constants and so forth.  */
561
      if (TREE_CODE (fields) != FIELD_DECL || DECL_ARTIFICIAL (fields))
562
        continue;
563
 
564
      /* Keep track of whether or not any fields are unions.  */
565
      if (TREE_CODE (TREE_TYPE (fields)) == UNION_TYPE)
566
        *uses_unions_p = 1;
567
 
568
      /* For an anonymous struct or union, we must recursively
569
         consider the fields of the anonymous type.  They can be
570
         directly initialized from the constructor.  */
571
      if (ANON_AGGR_TYPE_P (TREE_TYPE (fields)))
572
        {
573
          /* Add this field itself.  Synthesized copy constructors
574
             initialize the entire aggregate.  */
575
          list = tree_cons (fields, NULL_TREE, list);
576
          /* And now add the fields in the anonymous aggregate.  */
577
          list = build_field_list (TREE_TYPE (fields), list,
578
                                   uses_unions_p);
579
        }
580
      /* Add this field.  */
581
      else if (DECL_NAME (fields))
582
        list = tree_cons (fields, NULL_TREE, list);
583
    }
584
 
585
  return list;
586
}
587
 
588
/* The MEM_INITS are a TREE_LIST.  The TREE_PURPOSE of each list gives
589
   a FIELD_DECL or BINFO in T that needs initialization.  The
590
   TREE_VALUE gives the initializer, or list of initializer arguments.
591
 
592
   Return a TREE_LIST containing all of the initializations required
593
   for T, in the order in which they should be performed.  The output
594
   list has the same format as the input.  */
595
 
596
static tree
597
sort_mem_initializers (tree t, tree mem_inits)
598
{
599
  tree init;
600
  tree base, binfo, base_binfo;
601
  tree sorted_inits;
602
  tree next_subobject;
603
  VEC(tree,gc) *vbases;
604
  int i;
605
  int uses_unions_p;
606
 
607
  /* Build up a list of initializations.  The TREE_PURPOSE of entry
608
     will be the subobject (a FIELD_DECL or BINFO) to initialize.  The
609
     TREE_VALUE will be the constructor arguments, or NULL if no
610
     explicit initialization was provided.  */
611
  sorted_inits = NULL_TREE;
612
 
613
  /* Process the virtual bases.  */
614
  for (vbases = CLASSTYPE_VBASECLASSES (t), i = 0;
615
       VEC_iterate (tree, vbases, i, base); i++)
616
    sorted_inits = tree_cons (base, NULL_TREE, sorted_inits);
617
 
618
  /* Process the direct bases.  */
619
  for (binfo = TYPE_BINFO (t), i = 0;
620
       BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i)
621
    if (!BINFO_VIRTUAL_P (base_binfo))
622
      sorted_inits = tree_cons (base_binfo, NULL_TREE, sorted_inits);
623
 
624
  /* Process the non-static data members.  */
625
  sorted_inits = build_field_list (t, sorted_inits, &uses_unions_p);
626
  /* Reverse the entire list of initializations, so that they are in
627
     the order that they will actually be performed.  */
628
  sorted_inits = nreverse (sorted_inits);
629
 
630
  /* If the user presented the initializers in an order different from
631
     that in which they will actually occur, we issue a warning.  Keep
632
     track of the next subobject which can be explicitly initialized
633
     without issuing a warning.  */
634
  next_subobject = sorted_inits;
635
 
636
  /* Go through the explicit initializers, filling in TREE_PURPOSE in
637
     the SORTED_INITS.  */
638
  for (init = mem_inits; init; init = TREE_CHAIN (init))
639
    {
640
      tree subobject;
641
      tree subobject_init;
642
 
643
      subobject = TREE_PURPOSE (init);
644
 
645
      /* If the explicit initializers are in sorted order, then
646
         SUBOBJECT will be NEXT_SUBOBJECT, or something following
647
         it.  */
648
      for (subobject_init = next_subobject;
649
           subobject_init;
650
           subobject_init = TREE_CHAIN (subobject_init))
651
        if (TREE_PURPOSE (subobject_init) == subobject)
652
          break;
653
 
654
      /* Issue a warning if the explicit initializer order does not
655
         match that which will actually occur.
656
         ??? Are all these on the correct lines?  */
657
      if (warn_reorder && !subobject_init)
658
        {
659
          if (TREE_CODE (TREE_PURPOSE (next_subobject)) == FIELD_DECL)
660
            warning (OPT_Wreorder, "%q+D will be initialized after",
661
                     TREE_PURPOSE (next_subobject));
662
          else
663
            warning (OPT_Wreorder, "base %qT will be initialized after",
664
                     TREE_PURPOSE (next_subobject));
665
          if (TREE_CODE (subobject) == FIELD_DECL)
666
            warning (OPT_Wreorder, "  %q+#D", subobject);
667
          else
668
            warning (OPT_Wreorder, "  base %qT", subobject);
669
          warning_at (DECL_SOURCE_LOCATION (current_function_decl),
670
                      OPT_Wreorder, "  when initialized here");
671
        }
672
 
673
      /* Look again, from the beginning of the list.  */
674
      if (!subobject_init)
675
        {
676
          subobject_init = sorted_inits;
677
          while (TREE_PURPOSE (subobject_init) != subobject)
678
            subobject_init = TREE_CHAIN (subobject_init);
679
        }
680
 
681
      /* It is invalid to initialize the same subobject more than
682
         once.  */
683
      if (TREE_VALUE (subobject_init))
684
        {
685
          if (TREE_CODE (subobject) == FIELD_DECL)
686
            error_at (DECL_SOURCE_LOCATION (current_function_decl),
687
                      "multiple initializations given for %qD",
688
                      subobject);
689
          else
690
            error_at (DECL_SOURCE_LOCATION (current_function_decl),
691
                      "multiple initializations given for base %qT",
692
                      subobject);
693
        }
694
 
695
      /* Record the initialization.  */
696
      TREE_VALUE (subobject_init) = TREE_VALUE (init);
697
      next_subobject = subobject_init;
698
    }
699
 
700
  /* [class.base.init]
701
 
702
     If a ctor-initializer specifies more than one mem-initializer for
703
     multiple members of the same union (including members of
704
     anonymous unions), the ctor-initializer is ill-formed.  */
705
  if (uses_unions_p)
706
    {
707
      tree last_field = NULL_TREE;
708
      for (init = sorted_inits; init; init = TREE_CHAIN (init))
709
        {
710
          tree field;
711
          tree field_type;
712
          int done;
713
 
714
          /* Skip uninitialized members and base classes.  */
715
          if (!TREE_VALUE (init)
716
              || TREE_CODE (TREE_PURPOSE (init)) != FIELD_DECL)
717
            continue;
718
          /* See if this field is a member of a union, or a member of a
719
             structure contained in a union, etc.  */
720
          field = TREE_PURPOSE (init);
721
          for (field_type = DECL_CONTEXT (field);
722
               !same_type_p (field_type, t);
723
               field_type = TYPE_CONTEXT (field_type))
724
            if (TREE_CODE (field_type) == UNION_TYPE)
725
              break;
726
          /* If this field is not a member of a union, skip it.  */
727
          if (TREE_CODE (field_type) != UNION_TYPE)
728
            continue;
729
 
730
          /* It's only an error if we have two initializers for the same
731
             union type.  */
732
          if (!last_field)
733
            {
734
              last_field = field;
735
              continue;
736
            }
737
 
738
          /* See if LAST_FIELD and the field initialized by INIT are
739
             members of the same union.  If so, there's a problem,
740
             unless they're actually members of the same structure
741
             which is itself a member of a union.  For example, given:
742
 
743
               union { struct { int i; int j; }; };
744
 
745
             initializing both `i' and `j' makes sense.  */
746
          field_type = DECL_CONTEXT (field);
747
          done = 0;
748
          do
749
            {
750
              tree last_field_type;
751
 
752
              last_field_type = DECL_CONTEXT (last_field);
753
              while (1)
754
                {
755
                  if (same_type_p (last_field_type, field_type))
756
                    {
757
                      if (TREE_CODE (field_type) == UNION_TYPE)
758
                        error_at (DECL_SOURCE_LOCATION (current_function_decl),
759
                                  "initializations for multiple members of %qT",
760
                                  last_field_type);
761
                      done = 1;
762
                      break;
763
                    }
764
 
765
                  if (same_type_p (last_field_type, t))
766
                    break;
767
 
768
                  last_field_type = TYPE_CONTEXT (last_field_type);
769
                }
770
 
771
              /* If we've reached the outermost class, then we're
772
                 done.  */
773
              if (same_type_p (field_type, t))
774
                break;
775
 
776
              field_type = TYPE_CONTEXT (field_type);
777
            }
778
          while (!done);
779
 
780
          last_field = field;
781
        }
782
    }
783
 
784
  return sorted_inits;
785
}
786
 
787
/* Initialize all bases and members of CURRENT_CLASS_TYPE.  MEM_INITS
788
   is a TREE_LIST giving the explicit mem-initializer-list for the
789
   constructor.  The TREE_PURPOSE of each entry is a subobject (a
790
   FIELD_DECL or a BINFO) of the CURRENT_CLASS_TYPE.  The TREE_VALUE
791
   is a TREE_LIST giving the arguments to the constructor or
792
   void_type_node for an empty list of arguments.  */
793
 
794
void
795
emit_mem_initializers (tree mem_inits)
796
{
797
  /* We will already have issued an error message about the fact that
798
     the type is incomplete.  */
799
  if (!COMPLETE_TYPE_P (current_class_type))
800
    return;
801
 
802
  /* Sort the mem-initializers into the order in which the
803
     initializations should be performed.  */
804
  mem_inits = sort_mem_initializers (current_class_type, mem_inits);
805
 
806
  in_base_initializer = 1;
807
 
808
  /* Initialize base classes.  */
809
  while (mem_inits
810
         && TREE_CODE (TREE_PURPOSE (mem_inits)) != FIELD_DECL)
811
    {
812
      tree subobject = TREE_PURPOSE (mem_inits);
813
      tree arguments = TREE_VALUE (mem_inits);
814
 
815
      /* If these initializations are taking place in a copy constructor,
816
         the base class should probably be explicitly initialized if there
817
         is a user-defined constructor in the base class (other than the
818
         default constructor, which will be called anyway).  */
819
      if (extra_warnings && !arguments
820
          && DECL_COPY_CONSTRUCTOR_P (current_function_decl)
821
          && type_has_user_nondefault_constructor (BINFO_TYPE (subobject)))
822
        warning_at (DECL_SOURCE_LOCATION (current_function_decl), OPT_Wextra,
823
                    "base class %q#T should be explicitly initialized in the "
824
                    "copy constructor",
825
                    BINFO_TYPE (subobject));
826
 
827
      /* Initialize the base.  */
828
      if (BINFO_VIRTUAL_P (subobject))
829
        construct_virtual_base (subobject, arguments);
830
      else
831
        {
832
          tree base_addr;
833
 
834
          base_addr = build_base_path (PLUS_EXPR, current_class_ptr,
835
                                       subobject, 1);
836
          expand_aggr_init_1 (subobject, NULL_TREE,
837
                              cp_build_indirect_ref (base_addr, RO_NULL,
838
                                                     tf_warning_or_error),
839
                              arguments,
840
                              LOOKUP_NORMAL,
841
                              tf_warning_or_error);
842
          expand_cleanup_for_base (subobject, NULL_TREE);
843
        }
844
 
845
      mem_inits = TREE_CHAIN (mem_inits);
846
    }
847
  in_base_initializer = 0;
848
 
849
  /* Initialize the vptrs.  */
850
  initialize_vtbl_ptrs (current_class_ptr);
851
 
852
  /* Initialize the data members.  */
853
  while (mem_inits)
854
    {
855
      perform_member_init (TREE_PURPOSE (mem_inits),
856
                           TREE_VALUE (mem_inits));
857
      mem_inits = TREE_CHAIN (mem_inits);
858
    }
859
}
860
 
861
/* Returns the address of the vtable (i.e., the value that should be
862
   assigned to the vptr) for BINFO.  */
863
 
864
static tree
865
build_vtbl_address (tree binfo)
866
{
867
  tree binfo_for = binfo;
868
  tree vtbl;
869
 
870
  if (BINFO_VPTR_INDEX (binfo) && BINFO_VIRTUAL_P (binfo))
871
    /* If this is a virtual primary base, then the vtable we want to store
872
       is that for the base this is being used as the primary base of.  We
873
       can't simply skip the initialization, because we may be expanding the
874
       inits of a subobject constructor where the virtual base layout
875
       can be different.  */
876
    while (BINFO_PRIMARY_P (binfo_for))
877
      binfo_for = BINFO_INHERITANCE_CHAIN (binfo_for);
878
 
879
  /* Figure out what vtable BINFO's vtable is based on, and mark it as
880
     used.  */
881
  vtbl = get_vtbl_decl_for_binfo (binfo_for);
882
  TREE_USED (vtbl) = 1;
883
 
884
  /* Now compute the address to use when initializing the vptr.  */
885
  vtbl = unshare_expr (BINFO_VTABLE (binfo_for));
886
  if (TREE_CODE (vtbl) == VAR_DECL)
887
    vtbl = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (vtbl)), vtbl);
888
 
889
  return vtbl;
890
}
891
 
892
/* This code sets up the virtual function tables appropriate for
893
   the pointer DECL.  It is a one-ply initialization.
894
 
895
   BINFO is the exact type that DECL is supposed to be.  In
896
   multiple inheritance, this might mean "C's A" if C : A, B.  */
897
 
898
static void
899
expand_virtual_init (tree binfo, tree decl)
900
{
901
  tree vtbl, vtbl_ptr;
902
  tree vtt_index;
903
 
904
  /* Compute the initializer for vptr.  */
905
  vtbl = build_vtbl_address (binfo);
906
 
907
  /* We may get this vptr from a VTT, if this is a subobject
908
     constructor or subobject destructor.  */
909
  vtt_index = BINFO_VPTR_INDEX (binfo);
910
  if (vtt_index)
911
    {
912
      tree vtbl2;
913
      tree vtt_parm;
914
 
915
      /* Compute the value to use, when there's a VTT.  */
916
      vtt_parm = current_vtt_parm;
917
      vtbl2 = build2 (POINTER_PLUS_EXPR,
918
                      TREE_TYPE (vtt_parm),
919
                      vtt_parm,
920
                      vtt_index);
921
      vtbl2 = cp_build_indirect_ref (vtbl2, RO_NULL, tf_warning_or_error);
922
      vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
923
 
924
      /* The actual initializer is the VTT value only in the subobject
925
         constructor.  In maybe_clone_body we'll substitute NULL for
926
         the vtt_parm in the case of the non-subobject constructor.  */
927
      vtbl = build3 (COND_EXPR,
928
                     TREE_TYPE (vtbl),
929
                     build2 (EQ_EXPR, boolean_type_node,
930
                             current_in_charge_parm, integer_zero_node),
931
                     vtbl2,
932
                     vtbl);
933
    }
934
 
935
  /* Compute the location of the vtpr.  */
936
  vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, RO_NULL,
937
                                                      tf_warning_or_error),
938
                               TREE_TYPE (binfo));
939
  gcc_assert (vtbl_ptr != error_mark_node);
940
 
941
  /* Assign the vtable to the vptr.  */
942
  vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0);
943
  finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl,
944
                                          tf_warning_or_error));
945
}
946
 
947
/* If an exception is thrown in a constructor, those base classes already
948
   constructed must be destroyed.  This function creates the cleanup
949
   for BINFO, which has just been constructed.  If FLAG is non-NULL,
950
   it is a DECL which is nonzero when this base needs to be
951
   destroyed.  */
952
 
953
static void
954
expand_cleanup_for_base (tree binfo, tree flag)
955
{
956
  tree expr;
957
 
958
  if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (binfo)))
959
    return;
960
 
961
  /* Call the destructor.  */
962
  expr = build_special_member_call (current_class_ref,
963
                                    base_dtor_identifier,
964
                                    NULL,
965
                                    binfo,
966
                                    LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
967
                                    tf_warning_or_error);
968
  if (flag)
969
    expr = fold_build3_loc (input_location,
970
                        COND_EXPR, void_type_node,
971
                        c_common_truthvalue_conversion (input_location, flag),
972
                        expr, integer_zero_node);
973
 
974
  finish_eh_cleanup (expr);
975
}
976
 
977
/* Construct the virtual base-class VBASE passing the ARGUMENTS to its
978
   constructor.  */
979
 
980
static void
981
construct_virtual_base (tree vbase, tree arguments)
982
{
983
  tree inner_if_stmt;
984
  tree exp;
985
  tree flag;
986
 
987
  /* If there are virtual base classes with destructors, we need to
988
     emit cleanups to destroy them if an exception is thrown during
989
     the construction process.  These exception regions (i.e., the
990
     period during which the cleanups must occur) begin from the time
991
     the construction is complete to the end of the function.  If we
992
     create a conditional block in which to initialize the
993
     base-classes, then the cleanup region for the virtual base begins
994
     inside a block, and ends outside of that block.  This situation
995
     confuses the sjlj exception-handling code.  Therefore, we do not
996
     create a single conditional block, but one for each
997
     initialization.  (That way the cleanup regions always begin
998
     in the outer block.)  We trust the back end to figure out
999
     that the FLAG will not change across initializations, and
1000
     avoid doing multiple tests.  */
1001
  flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
1002
  inner_if_stmt = begin_if_stmt ();
1003
  finish_if_stmt_cond (flag, inner_if_stmt);
1004
 
1005
  /* Compute the location of the virtual base.  If we're
1006
     constructing virtual bases, then we must be the most derived
1007
     class.  Therefore, we don't have to look up the virtual base;
1008
     we already know where it is.  */
1009
  exp = convert_to_base_statically (current_class_ref, vbase);
1010
 
1011
  expand_aggr_init_1 (vbase, current_class_ref, exp, arguments,
1012
                      LOOKUP_COMPLAIN, tf_warning_or_error);
1013
  finish_then_clause (inner_if_stmt);
1014
  finish_if_stmt (inner_if_stmt);
1015
 
1016
  expand_cleanup_for_base (vbase, flag);
1017
}
1018
 
1019
/* Find the context in which this FIELD can be initialized.  */
1020
 
1021
static tree
1022
initializing_context (tree field)
1023
{
1024
  tree t = DECL_CONTEXT (field);
1025
 
1026
  /* Anonymous union members can be initialized in the first enclosing
1027
     non-anonymous union context.  */
1028
  while (t && ANON_AGGR_TYPE_P (t))
1029
    t = TYPE_CONTEXT (t);
1030
  return t;
1031
}
1032
 
1033
/* Function to give error message if member initialization specification
1034
   is erroneous.  FIELD is the member we decided to initialize.
1035
   TYPE is the type for which the initialization is being performed.
1036
   FIELD must be a member of TYPE.
1037
 
1038
   MEMBER_NAME is the name of the member.  */
1039
 
1040
static int
1041
member_init_ok_or_else (tree field, tree type, tree member_name)
1042
{
1043
  if (field == error_mark_node)
1044
    return 0;
1045
  if (!field)
1046
    {
1047
      error ("class %qT does not have any field named %qD", type,
1048
             member_name);
1049
      return 0;
1050
    }
1051
  if (TREE_CODE (field) == VAR_DECL)
1052
    {
1053
      error ("%q#D is a static data member; it can only be "
1054
             "initialized at its definition",
1055
             field);
1056
      return 0;
1057
    }
1058
  if (TREE_CODE (field) != FIELD_DECL)
1059
    {
1060
      error ("%q#D is not a non-static data member of %qT",
1061
             field, type);
1062
      return 0;
1063
    }
1064
  if (initializing_context (field) != type)
1065
    {
1066
      error ("class %qT does not have any field named %qD", type,
1067
                member_name);
1068
      return 0;
1069
    }
1070
 
1071
  return 1;
1072
}
1073
 
1074
/* NAME is a FIELD_DECL, an IDENTIFIER_NODE which names a field, or it
1075
   is a _TYPE node or TYPE_DECL which names a base for that type.
1076
   Check the validity of NAME, and return either the base _TYPE, base
1077
   binfo, or the FIELD_DECL of the member.  If NAME is invalid, return
1078
   NULL_TREE and issue a diagnostic.
1079
 
1080
   An old style unnamed direct single base construction is permitted,
1081
   where NAME is NULL.  */
1082
 
1083
tree
1084
expand_member_init (tree name)
1085
{
1086
  tree basetype;
1087
  tree field;
1088
 
1089
  if (!current_class_ref)
1090
    return NULL_TREE;
1091
 
1092
  if (!name)
1093
    {
1094
      /* This is an obsolete unnamed base class initializer.  The
1095
         parser will already have warned about its use.  */
1096
      switch (BINFO_N_BASE_BINFOS (TYPE_BINFO (current_class_type)))
1097
        {
1098
        case 0:
1099
          error ("unnamed initializer for %qT, which has no base classes",
1100
                 current_class_type);
1101
          return NULL_TREE;
1102
        case 1:
1103
          basetype = BINFO_TYPE
1104
            (BINFO_BASE_BINFO (TYPE_BINFO (current_class_type), 0));
1105
          break;
1106
        default:
1107
          error ("unnamed initializer for %qT, which uses multiple inheritance",
1108
                 current_class_type);
1109
          return NULL_TREE;
1110
      }
1111
    }
1112
  else if (TYPE_P (name))
1113
    {
1114
      basetype = TYPE_MAIN_VARIANT (name);
1115
      name = TYPE_NAME (name);
1116
    }
1117
  else if (TREE_CODE (name) == TYPE_DECL)
1118
    basetype = TYPE_MAIN_VARIANT (TREE_TYPE (name));
1119
  else
1120
    basetype = NULL_TREE;
1121
 
1122
  if (basetype)
1123
    {
1124
      tree class_binfo;
1125
      tree direct_binfo;
1126
      tree virtual_binfo;
1127
      int i;
1128
 
1129
      if (current_template_parms)
1130
        return basetype;
1131
 
1132
      class_binfo = TYPE_BINFO (current_class_type);
1133
      direct_binfo = NULL_TREE;
1134
      virtual_binfo = NULL_TREE;
1135
 
1136
      /* Look for a direct base.  */
1137
      for (i = 0; BINFO_BASE_ITERATE (class_binfo, i, direct_binfo); ++i)
1138
        if (SAME_BINFO_TYPE_P (BINFO_TYPE (direct_binfo), basetype))
1139
          break;
1140
 
1141
      /* Look for a virtual base -- unless the direct base is itself
1142
         virtual.  */
1143
      if (!direct_binfo || !BINFO_VIRTUAL_P (direct_binfo))
1144
        virtual_binfo = binfo_for_vbase (basetype, current_class_type);
1145
 
1146
      /* [class.base.init]
1147
 
1148
         If a mem-initializer-id is ambiguous because it designates
1149
         both a direct non-virtual base class and an inherited virtual
1150
         base class, the mem-initializer is ill-formed.  */
1151
      if (direct_binfo && virtual_binfo)
1152
        {
1153
          error ("%qD is both a direct base and an indirect virtual base",
1154
                 basetype);
1155
          return NULL_TREE;
1156
        }
1157
 
1158
      if (!direct_binfo && !virtual_binfo)
1159
        {
1160
          if (CLASSTYPE_VBASECLASSES (current_class_type))
1161
            error ("type %qT is not a direct or virtual base of %qT",
1162
                   basetype, current_class_type);
1163
          else
1164
            error ("type %qT is not a direct base of %qT",
1165
                   basetype, current_class_type);
1166
          return NULL_TREE;
1167
        }
1168
 
1169
      return direct_binfo ? direct_binfo : virtual_binfo;
1170
    }
1171
  else
1172
    {
1173
      if (TREE_CODE (name) == IDENTIFIER_NODE)
1174
        field = lookup_field (current_class_type, name, 1, false);
1175
      else
1176
        field = name;
1177
 
1178
      if (member_init_ok_or_else (field, current_class_type, name))
1179
        return field;
1180
    }
1181
 
1182
  return NULL_TREE;
1183
}
1184
 
1185
/* This is like `expand_member_init', only it stores one aggregate
1186
   value into another.
1187
 
1188
   INIT comes in two flavors: it is either a value which
1189
   is to be stored in EXP, or it is a parameter list
1190
   to go to a constructor, which will operate on EXP.
1191
   If INIT is not a parameter list for a constructor, then set
1192
   LOOKUP_ONLYCONVERTING.
1193
   If FLAGS is LOOKUP_ONLYCONVERTING then it is the = init form of
1194
   the initializer, if FLAGS is 0, then it is the (init) form.
1195
   If `init' is a CONSTRUCTOR, then we emit a warning message,
1196
   explaining that such initializations are invalid.
1197
 
1198
   If INIT resolves to a CALL_EXPR which happens to return
1199
   something of the type we are looking for, then we know
1200
   that we can safely use that call to perform the
1201
   initialization.
1202
 
1203
   The virtual function table pointer cannot be set up here, because
1204
   we do not really know its type.
1205
 
1206
   This never calls operator=().
1207
 
1208
   When initializing, nothing is CONST.
1209
 
1210
   A default copy constructor may have to be used to perform the
1211
   initialization.
1212
 
1213
   A constructor or a conversion operator may have to be used to
1214
   perform the initialization, but not both, as it would be ambiguous.  */
1215
 
1216
tree
1217
build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain)
1218
{
1219
  tree stmt_expr;
1220
  tree compound_stmt;
1221
  int destroy_temps;
1222
  tree type = TREE_TYPE (exp);
1223
  int was_const = TREE_READONLY (exp);
1224
  int was_volatile = TREE_THIS_VOLATILE (exp);
1225
  int is_global;
1226
 
1227
  if (init == error_mark_node)
1228
    return error_mark_node;
1229
 
1230
  TREE_READONLY (exp) = 0;
1231
  TREE_THIS_VOLATILE (exp) = 0;
1232
 
1233
  if (init && TREE_CODE (init) != TREE_LIST
1234
      && !(BRACE_ENCLOSED_INITIALIZER_P (init)
1235
           && CONSTRUCTOR_IS_DIRECT_INIT (init)))
1236
    flags |= LOOKUP_ONLYCONVERTING;
1237
 
1238
  if (TREE_CODE (type) == ARRAY_TYPE)
1239
    {
1240
      tree itype;
1241
 
1242
      /* An array may not be initialized use the parenthesized
1243
         initialization form -- unless the initializer is "()".  */
1244
      if (init && TREE_CODE (init) == TREE_LIST)
1245
        {
1246
          if (complain & tf_error)
1247
            error ("bad array initializer");
1248
          return error_mark_node;
1249
        }
1250
      /* Must arrange to initialize each element of EXP
1251
         from elements of INIT.  */
1252
      itype = init ? TREE_TYPE (init) : NULL_TREE;
1253
      if (cv_qualified_p (type))
1254
        TREE_TYPE (exp) = cv_unqualified (type);
1255
      if (itype && cv_qualified_p (itype))
1256
        TREE_TYPE (init) = cv_unqualified (itype);
1257
      stmt_expr = build_vec_init (exp, NULL_TREE, init,
1258
                                  /*explicit_value_init_p=*/false,
1259
                                  itype && same_type_p (TREE_TYPE (init),
1260
                                                        TREE_TYPE (exp)),
1261
                                  complain);
1262
      TREE_READONLY (exp) = was_const;
1263
      TREE_THIS_VOLATILE (exp) = was_volatile;
1264
      TREE_TYPE (exp) = type;
1265
      if (init)
1266
        TREE_TYPE (init) = itype;
1267
      return stmt_expr;
1268
    }
1269
 
1270
  if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL)
1271
    /* Just know that we've seen something for this node.  */
1272
    TREE_USED (exp) = 1;
1273
 
1274
  is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
1275
  destroy_temps = stmts_are_full_exprs_p ();
1276
  current_stmt_tree ()->stmts_are_full_exprs_p = 0;
1277
  expand_aggr_init_1 (TYPE_BINFO (type), exp, exp,
1278
                      init, LOOKUP_NORMAL|flags, complain);
1279
  stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
1280
  current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
1281
  TREE_READONLY (exp) = was_const;
1282
  TREE_THIS_VOLATILE (exp) = was_volatile;
1283
 
1284
  return stmt_expr;
1285
}
1286
 
1287
static void
1288
expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags,
1289
                     tsubst_flags_t complain)
1290
{
1291
  tree type = TREE_TYPE (exp);
1292
  tree ctor_name;
1293
 
1294
  /* It fails because there may not be a constructor which takes
1295
     its own type as the first (or only parameter), but which does
1296
     take other types via a conversion.  So, if the thing initializing
1297
     the expression is a unit element of type X, first try X(X&),
1298
     followed by initialization by X.  If neither of these work
1299
     out, then look hard.  */
1300
  tree rval;
1301
  VEC(tree,gc) *parms;
1302
 
1303
  if (init && TREE_CODE (init) != TREE_LIST
1304
      && (flags & LOOKUP_ONLYCONVERTING))
1305
    {
1306
      /* Base subobjects should only get direct-initialization.  */
1307
      gcc_assert (true_exp == exp);
1308
 
1309
      if (flags & DIRECT_BIND)
1310
        /* Do nothing.  We hit this in two cases:  Reference initialization,
1311
           where we aren't initializing a real variable, so we don't want
1312
           to run a new constructor; and catching an exception, where we
1313
           have already built up the constructor call so we could wrap it
1314
           in an exception region.  */;
1315
      else if (BRACE_ENCLOSED_INITIALIZER_P (init)
1316
               && CP_AGGREGATE_TYPE_P (type))
1317
        {
1318
          /* A brace-enclosed initializer for an aggregate.  */
1319
          init = digest_init (type, init);
1320
        }
1321
      else
1322
        init = ocp_convert (type, init, CONV_IMPLICIT|CONV_FORCE_TEMP, flags);
1323
 
1324
      if (TREE_CODE (init) == MUST_NOT_THROW_EXPR)
1325
        /* We need to protect the initialization of a catch parm with a
1326
           call to terminate(), which shows up as a MUST_NOT_THROW_EXPR
1327
           around the TARGET_EXPR for the copy constructor.  See
1328
           initialize_handler_parm.  */
1329
        {
1330
          TREE_OPERAND (init, 0) = build2 (INIT_EXPR, TREE_TYPE (exp), exp,
1331
                                           TREE_OPERAND (init, 0));
1332
          TREE_TYPE (init) = void_type_node;
1333
        }
1334
      else
1335
        init = build2 (INIT_EXPR, TREE_TYPE (exp), exp, init);
1336
      TREE_SIDE_EFFECTS (init) = 1;
1337
      finish_expr_stmt (init);
1338
      return;
1339
    }
1340
 
1341
  if (init == NULL_TREE)
1342
    parms = NULL;
1343
  else if (TREE_CODE (init) == TREE_LIST && !TREE_TYPE (init))
1344
    {
1345
      parms = make_tree_vector ();
1346
      for (; init != NULL_TREE; init = TREE_CHAIN (init))
1347
        VEC_safe_push (tree, gc, parms, TREE_VALUE (init));
1348
    }
1349
  else
1350
    parms = make_tree_vector_single (init);
1351
 
1352
  if (true_exp == exp)
1353
    ctor_name = complete_ctor_identifier;
1354
  else
1355
    ctor_name = base_ctor_identifier;
1356
 
1357
  rval = build_special_member_call (exp, ctor_name, &parms, binfo, flags,
1358
                                    complain);
1359
 
1360
  if (parms != NULL)
1361
    release_tree_vector (parms);
1362
 
1363
  if (TREE_SIDE_EFFECTS (rval))
1364
    finish_expr_stmt (convert_to_void (rval, NULL, complain));
1365
}
1366
 
1367
/* This function is responsible for initializing EXP with INIT
1368
   (if any).
1369
 
1370
   BINFO is the binfo of the type for who we are performing the
1371
   initialization.  For example, if W is a virtual base class of A and B,
1372
   and C : A, B.
1373
   If we are initializing B, then W must contain B's W vtable, whereas
1374
   were we initializing C, W must contain C's W vtable.
1375
 
1376
   TRUE_EXP is nonzero if it is the true expression being initialized.
1377
   In this case, it may be EXP, or may just contain EXP.  The reason we
1378
   need this is because if EXP is a base element of TRUE_EXP, we
1379
   don't necessarily know by looking at EXP where its virtual
1380
   baseclass fields should really be pointing.  But we do know
1381
   from TRUE_EXP.  In constructors, we don't know anything about
1382
   the value being initialized.
1383
 
1384
   FLAGS is just passed to `build_new_method_call'.  See that function
1385
   for its description.  */
1386
 
1387
static void
1388
expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags,
1389
                    tsubst_flags_t complain)
1390
{
1391
  tree type = TREE_TYPE (exp);
1392
 
1393
  gcc_assert (init != error_mark_node && type != error_mark_node);
1394
  gcc_assert (building_stmt_tree ());
1395
 
1396
  /* Use a function returning the desired type to initialize EXP for us.
1397
     If the function is a constructor, and its first argument is
1398
     NULL_TREE, know that it was meant for us--just slide exp on
1399
     in and expand the constructor.  Constructors now come
1400
     as TARGET_EXPRs.  */
1401
 
1402
  if (init && TREE_CODE (exp) == VAR_DECL
1403
      && COMPOUND_LITERAL_P (init))
1404
    {
1405
      /* If store_init_value returns NULL_TREE, the INIT has been
1406
         recorded as the DECL_INITIAL for EXP.  That means there's
1407
         nothing more we have to do.  */
1408
      init = store_init_value (exp, init, flags);
1409
      if (init)
1410
        finish_expr_stmt (init);
1411
      return;
1412
    }
1413
 
1414
  /* If an explicit -- but empty -- initializer list was present,
1415
     that's value-initialization.  */
1416
  if (init == void_type_node)
1417
    {
1418
      /* If there's a user-provided constructor, we just call that.  */
1419
      if (type_has_user_provided_constructor (type))
1420
        /* Fall through.  */;
1421
      /* If there isn't, but we still need to call the constructor,
1422
         zero out the object first.  */
1423
      else if (TYPE_NEEDS_CONSTRUCTING (type))
1424
        {
1425
          init = build_zero_init (type, NULL_TREE, /*static_storage_p=*/false);
1426
          init = build2 (INIT_EXPR, type, exp, init);
1427
          finish_expr_stmt (init);
1428
          /* And then call the constructor.  */
1429
        }
1430
      /* If we don't need to mess with the constructor at all,
1431
         then just zero out the object and we're done.  */
1432
      else
1433
        {
1434
          init = build2 (INIT_EXPR, type, exp, build_value_init_noctor (type));
1435
          finish_expr_stmt (init);
1436
          return;
1437
        }
1438
      init = NULL_TREE;
1439
    }
1440
 
1441
  /* We know that expand_default_init can handle everything we want
1442
     at this point.  */
1443
  expand_default_init (binfo, true_exp, exp, init, flags, complain);
1444
}
1445
 
1446
/* Report an error if TYPE is not a user-defined, class type.  If
1447
   OR_ELSE is nonzero, give an error message.  */
1448
 
1449
int
1450
is_class_type (tree type, int or_else)
1451
{
1452
  if (type == error_mark_node)
1453
    return 0;
1454
 
1455
  if (! CLASS_TYPE_P (type))
1456
    {
1457
      if (or_else)
1458
        error ("%qT is not a class type", type);
1459
      return 0;
1460
    }
1461
  return 1;
1462
}
1463
 
1464
tree
1465
get_type_value (tree name)
1466
{
1467
  if (name == error_mark_node)
1468
    return NULL_TREE;
1469
 
1470
  if (IDENTIFIER_HAS_TYPE_VALUE (name))
1471
    return IDENTIFIER_TYPE_VALUE (name);
1472
  else
1473
    return NULL_TREE;
1474
}
1475
 
1476
/* Build a reference to a member of an aggregate.  This is not a C++
1477
   `&', but really something which can have its address taken, and
1478
   then act as a pointer to member, for example TYPE :: FIELD can have
1479
   its address taken by saying & TYPE :: FIELD.  ADDRESS_P is true if
1480
   this expression is the operand of "&".
1481
 
1482
   @@ Prints out lousy diagnostics for operator <typename>
1483
   @@ fields.
1484
 
1485
   @@ This function should be rewritten and placed in search.c.  */
1486
 
1487
tree
1488
build_offset_ref (tree type, tree member, bool address_p)
1489
{
1490
  tree decl;
1491
  tree basebinfo = NULL_TREE;
1492
 
1493
  /* class templates can come in as TEMPLATE_DECLs here.  */
1494
  if (TREE_CODE (member) == TEMPLATE_DECL)
1495
    return member;
1496
 
1497
  if (dependent_type_p (type) || type_dependent_expression_p (member))
1498
    return build_qualified_name (NULL_TREE, type, member,
1499
                                 /*template_p=*/false);
1500
 
1501
  gcc_assert (TYPE_P (type));
1502
  if (! is_class_type (type, 1))
1503
    return error_mark_node;
1504
 
1505
  gcc_assert (DECL_P (member) || BASELINK_P (member));
1506
  /* Callers should call mark_used before this point.  */
1507
  gcc_assert (!DECL_P (member) || TREE_USED (member));
1508
 
1509
  if (!COMPLETE_TYPE_P (complete_type (type))
1510
      && !TYPE_BEING_DEFINED (type))
1511
    {
1512
      error ("incomplete type %qT does not have member %qD", type, member);
1513
      return error_mark_node;
1514
    }
1515
 
1516
  /* Entities other than non-static members need no further
1517
     processing.  */
1518
  if (TREE_CODE (member) == TYPE_DECL)
1519
    return member;
1520
  if (TREE_CODE (member) == VAR_DECL || TREE_CODE (member) == CONST_DECL)
1521
    return convert_from_reference (member);
1522
 
1523
  if (TREE_CODE (member) == FIELD_DECL && DECL_C_BIT_FIELD (member))
1524
    {
1525
      error ("invalid pointer to bit-field %qD", member);
1526
      return error_mark_node;
1527
    }
1528
 
1529
  /* Set up BASEBINFO for member lookup.  */
1530
  decl = maybe_dummy_object (type, &basebinfo);
1531
 
1532
  /* A lot of this logic is now handled in lookup_member.  */
1533
  if (BASELINK_P (member))
1534
    {
1535
      /* Go from the TREE_BASELINK to the member function info.  */
1536
      tree t = BASELINK_FUNCTIONS (member);
1537
 
1538
      if (TREE_CODE (t) != TEMPLATE_ID_EXPR && !really_overloaded_fn (t))
1539
        {
1540
          /* Get rid of a potential OVERLOAD around it.  */
1541
          t = OVL_CURRENT (t);
1542
 
1543
          /* Unique functions are handled easily.  */
1544
 
1545
          /* For non-static member of base class, we need a special rule
1546
             for access checking [class.protected]:
1547
 
1548
               If the access is to form a pointer to member, the
1549
               nested-name-specifier shall name the derived class
1550
               (or any class derived from that class).  */
1551
          if (address_p && DECL_P (t)
1552
              && DECL_NONSTATIC_MEMBER_P (t))
1553
            perform_or_defer_access_check (TYPE_BINFO (type), t, t);
1554
          else
1555
            perform_or_defer_access_check (basebinfo, t, t);
1556
 
1557
          if (DECL_STATIC_FUNCTION_P (t))
1558
            return t;
1559
          member = t;
1560
        }
1561
      else
1562
        TREE_TYPE (member) = unknown_type_node;
1563
    }
1564
  else if (address_p && TREE_CODE (member) == FIELD_DECL)
1565
    /* We need additional test besides the one in
1566
       check_accessibility_of_qualified_id in case it is
1567
       a pointer to non-static member.  */
1568
    perform_or_defer_access_check (TYPE_BINFO (type), member, member);
1569
 
1570
  if (!address_p)
1571
    {
1572
      /* If MEMBER is non-static, then the program has fallen afoul of
1573
         [expr.prim]:
1574
 
1575
           An id-expression that denotes a nonstatic data member or
1576
           nonstatic member function of a class can only be used:
1577
 
1578
           -- as part of a class member access (_expr.ref_) in which the
1579
           object-expression refers to the member's class or a class
1580
           derived from that class, or
1581
 
1582
           -- to form a pointer to member (_expr.unary.op_), or
1583
 
1584
           -- in the body of a nonstatic member function of that class or
1585
           of a class derived from that class (_class.mfct.nonstatic_), or
1586
 
1587
           -- in a mem-initializer for a constructor for that class or for
1588
           a class derived from that class (_class.base.init_).  */
1589
      if (DECL_NONSTATIC_MEMBER_FUNCTION_P (member))
1590
        {
1591
          /* Build a representation of the qualified name suitable
1592
             for use as the operand to "&" -- even though the "&" is
1593
             not actually present.  */
1594
          member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1595
          /* In Microsoft mode, treat a non-static member function as if
1596
             it were a pointer-to-member.  */
1597
          if (flag_ms_extensions)
1598
            {
1599
              PTRMEM_OK_P (member) = 1;
1600
              return cp_build_unary_op (ADDR_EXPR, member, 0,
1601
                                        tf_warning_or_error);
1602
            }
1603
          error ("invalid use of non-static member function %qD",
1604
                 TREE_OPERAND (member, 1));
1605
          return error_mark_node;
1606
        }
1607
      else if (TREE_CODE (member) == FIELD_DECL)
1608
        {
1609
          error ("invalid use of non-static data member %qD", member);
1610
          return error_mark_node;
1611
        }
1612
      return member;
1613
    }
1614
 
1615
  member = build2 (OFFSET_REF, TREE_TYPE (member), decl, member);
1616
  PTRMEM_OK_P (member) = 1;
1617
  return member;
1618
}
1619
 
1620
/* If DECL is a scalar enumeration constant or variable with a
1621
   constant initializer, return the initializer (or, its initializers,
1622
   recursively); otherwise, return DECL.  If INTEGRAL_P, the
1623
   initializer is only returned if DECL is an integral
1624
   constant-expression.  */
1625
 
1626
static tree
1627
constant_value_1 (tree decl, bool integral_p)
1628
{
1629
  while (TREE_CODE (decl) == CONST_DECL
1630
         || (integral_p
1631
             ? DECL_INTEGRAL_CONSTANT_VAR_P (decl)
1632
             : (TREE_CODE (decl) == VAR_DECL
1633
                && CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))))
1634
    {
1635
      tree init;
1636
      /* Static data members in template classes may have
1637
         non-dependent initializers.  References to such non-static
1638
         data members are not value-dependent, so we must retrieve the
1639
         initializer here.  The DECL_INITIAL will have the right type,
1640
         but will not have been folded because that would prevent us
1641
         from performing all appropriate semantic checks at
1642
         instantiation time.  */
1643
      if (DECL_CLASS_SCOPE_P (decl)
1644
          && CLASSTYPE_TEMPLATE_INFO (DECL_CONTEXT (decl))
1645
          && uses_template_parms (CLASSTYPE_TI_ARGS
1646
                                  (DECL_CONTEXT (decl))))
1647
        {
1648
          ++processing_template_decl;
1649
          init = fold_non_dependent_expr (DECL_INITIAL (decl));
1650
          --processing_template_decl;
1651
        }
1652
      else
1653
        {
1654
          /* If DECL is a static data member in a template
1655
             specialization, we must instantiate it here.  The
1656
             initializer for the static data member is not processed
1657
             until needed; we need it now.  */
1658
          mark_used (decl);
1659
          init = DECL_INITIAL (decl);
1660
        }
1661
      if (init == error_mark_node)
1662
        return decl;
1663
      /* Initializers in templates are generally expanded during
1664
         instantiation, so before that for const int i(2)
1665
         INIT is a TREE_LIST with the actual initializer as
1666
         TREE_VALUE.  */
1667
      if (processing_template_decl
1668
          && init
1669
          && TREE_CODE (init) == TREE_LIST
1670
          && TREE_CHAIN (init) == NULL_TREE)
1671
        init = TREE_VALUE (init);
1672
      if (!init
1673
          || !TREE_TYPE (init)
1674
          || (integral_p
1675
              ? !INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (init))
1676
              : (!TREE_CONSTANT (init)
1677
                 /* Do not return an aggregate constant (of which
1678
                    string literals are a special case), as we do not
1679
                    want to make inadvertent copies of such entities,
1680
                    and we must be sure that their addresses are the
1681
                    same everywhere.  */
1682
                 || TREE_CODE (init) == CONSTRUCTOR
1683
                 || TREE_CODE (init) == STRING_CST)))
1684
        break;
1685
      decl = unshare_expr (init);
1686
    }
1687
  return decl;
1688
}
1689
 
1690
/* If DECL is a CONST_DECL, or a constant VAR_DECL initialized by
1691
   constant of integral or enumeration type, then return that value.
1692
   These are those variables permitted in constant expressions by
1693
   [5.19/1].  */
1694
 
1695
tree
1696
integral_constant_value (tree decl)
1697
{
1698
  return constant_value_1 (decl, /*integral_p=*/true);
1699
}
1700
 
1701
/* A more relaxed version of integral_constant_value, used by the
1702
   common C/C++ code and by the C++ front end for optimization
1703
   purposes.  */
1704
 
1705
tree
1706
decl_constant_value (tree decl)
1707
{
1708
  return constant_value_1 (decl,
1709
                           /*integral_p=*/processing_template_decl);
1710
}
1711
 
1712
/* Common subroutines of build_new and build_vec_delete.  */
1713
 
1714
/* Call the global __builtin_delete to delete ADDR.  */
1715
 
1716
static tree
1717
build_builtin_delete_call (tree addr)
1718
{
1719
  mark_used (global_delete_fndecl);
1720
  return build_call_n (global_delete_fndecl, 1, addr);
1721
}
1722
 
1723
/* Build and return a NEW_EXPR.  If NELTS is non-NULL, TYPE[NELTS] is
1724
   the type of the object being allocated; otherwise, it's just TYPE.
1725
   INIT is the initializer, if any.  USE_GLOBAL_NEW is true if the
1726
   user explicitly wrote "::operator new".  PLACEMENT, if non-NULL, is
1727
   a vector of arguments to be provided as arguments to a placement
1728
   new operator.  This routine performs no semantic checks; it just
1729
   creates and returns a NEW_EXPR.  */
1730
 
1731
static tree
1732
build_raw_new_expr (VEC(tree,gc) *placement, tree type, tree nelts,
1733
                    VEC(tree,gc) *init, int use_global_new)
1734
{
1735
  tree init_list;
1736
  tree new_expr;
1737
 
1738
  /* If INIT is NULL, the we want to store NULL_TREE in the NEW_EXPR.
1739
     If INIT is not NULL, then we want to store VOID_ZERO_NODE.  This
1740
     permits us to distinguish the case of a missing initializer "new
1741
     int" from an empty initializer "new int()".  */
1742
  if (init == NULL)
1743
    init_list = NULL_TREE;
1744
  else if (VEC_empty (tree, init))
1745
    init_list = void_zero_node;
1746
  else
1747
    init_list = build_tree_list_vec (init);
1748
 
1749
  new_expr = build4 (NEW_EXPR, build_pointer_type (type),
1750
                     build_tree_list_vec (placement), type, nelts,
1751
                     init_list);
1752
  NEW_EXPR_USE_GLOBAL (new_expr) = use_global_new;
1753
  TREE_SIDE_EFFECTS (new_expr) = 1;
1754
 
1755
  return new_expr;
1756
}
1757
 
1758
/* Generate code for a new-expression, including calling the "operator
1759
   new" function, initializing the object, and, if an exception occurs
1760
   during construction, cleaning up.  The arguments are as for
1761
   build_raw_new_expr.  This may change PLACEMENT and INIT.  */
1762
 
1763
static tree
1764
build_new_1 (VEC(tree,gc) **placement, tree type, tree nelts,
1765
             VEC(tree,gc) **init, bool globally_qualified_p,
1766
             tsubst_flags_t complain)
1767
{
1768
  tree size, rval;
1769
  /* True iff this is a call to "operator new[]" instead of just
1770
     "operator new".  */
1771
  bool array_p = false;
1772
  /* If ARRAY_P is true, the element type of the array.  This is never
1773
     an ARRAY_TYPE; for something like "new int[3][4]", the
1774
     ELT_TYPE is "int".  If ARRAY_P is false, this is the same type as
1775
     TYPE.  */
1776
  tree elt_type;
1777
  /* The type of the new-expression.  (This type is always a pointer
1778
     type.)  */
1779
  tree pointer_type;
1780
  tree non_const_pointer_type;
1781
  tree outer_nelts = NULL_TREE;
1782
  tree alloc_call, alloc_expr;
1783
  /* The address returned by the call to "operator new".  This node is
1784
     a VAR_DECL and is therefore reusable.  */
1785
  tree alloc_node;
1786
  tree alloc_fn;
1787
  tree cookie_expr, init_expr;
1788
  int nothrow, check_new;
1789
  int use_java_new = 0;
1790
  /* If non-NULL, the number of extra bytes to allocate at the
1791
     beginning of the storage allocated for an array-new expression in
1792
     order to store the number of elements.  */
1793
  tree cookie_size = NULL_TREE;
1794
  tree placement_first;
1795
  tree placement_expr = NULL_TREE;
1796
  /* True if the function we are calling is a placement allocation
1797
     function.  */
1798
  bool placement_allocation_fn_p;
1799
  /* True if the storage must be initialized, either by a constructor
1800
     or due to an explicit new-initializer.  */
1801
  bool is_initialized;
1802
  /* The address of the thing allocated, not including any cookie.  In
1803
     particular, if an array cookie is in use, DATA_ADDR is the
1804
     address of the first array element.  This node is a VAR_DECL, and
1805
     is therefore reusable.  */
1806
  tree data_addr;
1807
  tree init_preeval_expr = NULL_TREE;
1808
 
1809
  if (nelts)
1810
    {
1811
      outer_nelts = nelts;
1812
      array_p = true;
1813
    }
1814
  else if (TREE_CODE (type) == ARRAY_TYPE)
1815
    {
1816
      array_p = true;
1817
      nelts = array_type_nelts_top (type);
1818
      outer_nelts = nelts;
1819
      type = TREE_TYPE (type);
1820
    }
1821
 
1822
  /* If our base type is an array, then make sure we know how many elements
1823
     it has.  */
1824
  for (elt_type = type;
1825
       TREE_CODE (elt_type) == ARRAY_TYPE;
1826
       elt_type = TREE_TYPE (elt_type))
1827
    nelts = cp_build_binary_op (input_location,
1828
                                MULT_EXPR, nelts,
1829
                                array_type_nelts_top (elt_type),
1830
                                complain);
1831
 
1832
  if (TREE_CODE (elt_type) == VOID_TYPE)
1833
    {
1834
      if (complain & tf_error)
1835
        error ("invalid type %<void%> for new");
1836
      return error_mark_node;
1837
    }
1838
 
1839
  if (abstract_virtuals_error (NULL_TREE, elt_type))
1840
    return error_mark_node;
1841
 
1842
  is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || *init != NULL);
1843
 
1844
  if (CP_TYPE_CONST_P (elt_type) && *init == NULL
1845
      && !type_has_user_provided_default_constructor (elt_type))
1846
    {
1847
      if (complain & tf_error)
1848
        error ("uninitialized const in %<new%> of %q#T", elt_type);
1849
      return error_mark_node;
1850
    }
1851
 
1852
  size = size_in_bytes (elt_type);
1853
  if (array_p)
1854
    size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
1855
 
1856
  alloc_fn = NULL_TREE;
1857
 
1858
  /* If PLACEMENT is a single simple pointer type not passed by
1859
     reference, prepare to capture it in a temporary variable.  Do
1860
     this now, since PLACEMENT will change in the calls below.  */
1861
  placement_first = NULL_TREE;
1862
  if (VEC_length (tree, *placement) == 1
1863
      && (TREE_CODE (TREE_TYPE (VEC_index (tree, *placement, 0)))
1864
          == POINTER_TYPE))
1865
    placement_first = VEC_index (tree, *placement, 0);
1866
 
1867
  /* Allocate the object.  */
1868
  if (VEC_empty (tree, *placement) && TYPE_FOR_JAVA (elt_type))
1869
    {
1870
      tree class_addr;
1871
      tree class_decl = build_java_class_ref (elt_type);
1872
      static const char alloc_name[] = "_Jv_AllocObject";
1873
 
1874
      if (class_decl == error_mark_node)
1875
        return error_mark_node;
1876
 
1877
      use_java_new = 1;
1878
      if (!get_global_value_if_present (get_identifier (alloc_name),
1879
                                        &alloc_fn))
1880
        {
1881
          if (complain & tf_error)
1882
            error ("call to Java constructor with %qs undefined", alloc_name);
1883
          return error_mark_node;
1884
        }
1885
      else if (really_overloaded_fn (alloc_fn))
1886
        {
1887
          if (complain & tf_error)
1888
            error ("%qD should never be overloaded", alloc_fn);
1889
          return error_mark_node;
1890
        }
1891
      alloc_fn = OVL_CURRENT (alloc_fn);
1892
      class_addr = build1 (ADDR_EXPR, jclass_node, class_decl);
1893
      alloc_call = (cp_build_function_call
1894
                    (alloc_fn,
1895
                     build_tree_list (NULL_TREE, class_addr),
1896
                     complain));
1897
    }
1898
  else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type))
1899
    {
1900
      error ("Java class %q#T object allocated using placement new", elt_type);
1901
      return error_mark_node;
1902
    }
1903
  else
1904
    {
1905
      tree fnname;
1906
      tree fns;
1907
 
1908
      fnname = ansi_opname (array_p ? VEC_NEW_EXPR : NEW_EXPR);
1909
 
1910
      if (!globally_qualified_p
1911
          && CLASS_TYPE_P (elt_type)
1912
          && (array_p
1913
              ? TYPE_HAS_ARRAY_NEW_OPERATOR (elt_type)
1914
              : TYPE_HAS_NEW_OPERATOR (elt_type)))
1915
        {
1916
          /* Use a class-specific operator new.  */
1917
          /* If a cookie is required, add some extra space.  */
1918
          if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1919
            {
1920
              cookie_size = targetm.cxx.get_cookie_size (elt_type);
1921
              size = size_binop (PLUS_EXPR, size, cookie_size);
1922
            }
1923
          /* Create the argument list.  */
1924
          VEC_safe_insert (tree, gc, *placement, 0, size);
1925
          /* Do name-lookup to find the appropriate operator.  */
1926
          fns = lookup_fnfields (elt_type, fnname, /*protect=*/2);
1927
          if (fns == NULL_TREE)
1928
            {
1929
              if (complain & tf_error)
1930
                error ("no suitable %qD found in class %qT", fnname, elt_type);
1931
              return error_mark_node;
1932
            }
1933
          if (TREE_CODE (fns) == TREE_LIST)
1934
            {
1935
              if (complain & tf_error)
1936
                {
1937
                  error ("request for member %qD is ambiguous", fnname);
1938
                  print_candidates (fns);
1939
                }
1940
              return error_mark_node;
1941
            }
1942
          alloc_call = build_new_method_call (build_dummy_object (elt_type),
1943
                                              fns, placement,
1944
                                              /*conversion_path=*/NULL_TREE,
1945
                                              LOOKUP_NORMAL,
1946
                                              &alloc_fn,
1947
                                              complain);
1948
        }
1949
      else
1950
        {
1951
          /* Use a global operator new.  */
1952
          /* See if a cookie might be required.  */
1953
          if (array_p && TYPE_VEC_NEW_USES_COOKIE (elt_type))
1954
            cookie_size = targetm.cxx.get_cookie_size (elt_type);
1955
          else
1956
            cookie_size = NULL_TREE;
1957
 
1958
          alloc_call = build_operator_new_call (fnname, placement,
1959
                                                &size, &cookie_size,
1960
                                                &alloc_fn);
1961
        }
1962
    }
1963
 
1964
  if (alloc_call == error_mark_node)
1965
    return error_mark_node;
1966
 
1967
  gcc_assert (alloc_fn != NULL_TREE);
1968
 
1969
  /* If we found a simple case of PLACEMENT_EXPR above, then copy it
1970
     into a temporary variable.  */
1971
  if (!processing_template_decl
1972
      && placement_first != NULL_TREE
1973
      && TREE_CODE (alloc_call) == CALL_EXPR
1974
      && call_expr_nargs (alloc_call) == 2
1975
      && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 0))) == INTEGER_TYPE
1976
      && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (alloc_call, 1))) == POINTER_TYPE)
1977
    {
1978
      tree placement_arg = CALL_EXPR_ARG (alloc_call, 1);
1979
 
1980
      if (INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg)))
1981
          || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (placement_arg))))
1982
        {
1983
          placement_expr = get_target_expr (placement_first);
1984
          CALL_EXPR_ARG (alloc_call, 1)
1985
            = convert (TREE_TYPE (placement_arg), placement_expr);
1986
        }
1987
    }
1988
 
1989
  /* In the simple case, we can stop now.  */
1990
  pointer_type = build_pointer_type (type);
1991
  if (!cookie_size && !is_initialized)
1992
    return build_nop (pointer_type, alloc_call);
1993
 
1994
  /* Store the result of the allocation call in a variable so that we can
1995
     use it more than once.  */
1996
  alloc_expr = get_target_expr (alloc_call);
1997
  alloc_node = TARGET_EXPR_SLOT (alloc_expr);
1998
 
1999
  /* Strip any COMPOUND_EXPRs from ALLOC_CALL.  */
2000
  while (TREE_CODE (alloc_call) == COMPOUND_EXPR)
2001
    alloc_call = TREE_OPERAND (alloc_call, 1);
2002
 
2003
  /* Now, check to see if this function is actually a placement
2004
     allocation function.  This can happen even when PLACEMENT is NULL
2005
     because we might have something like:
2006
 
2007
       struct S { void* operator new (size_t, int i = 0); };
2008
 
2009
     A call to `new S' will get this allocation function, even though
2010
     there is no explicit placement argument.  If there is more than
2011
     one argument, or there are variable arguments, then this is a
2012
     placement allocation function.  */
2013
  placement_allocation_fn_p
2014
    = (type_num_arguments (TREE_TYPE (alloc_fn)) > 1
2015
       || varargs_function_p (alloc_fn));
2016
 
2017
  /* Preevaluate the placement args so that we don't reevaluate them for a
2018
     placement delete.  */
2019
  if (placement_allocation_fn_p)
2020
    {
2021
      tree inits;
2022
      stabilize_call (alloc_call, &inits);
2023
      if (inits)
2024
        alloc_expr = build2 (COMPOUND_EXPR, TREE_TYPE (alloc_expr), inits,
2025
                             alloc_expr);
2026
    }
2027
 
2028
  /*        unless an allocation function is declared with an empty  excep-
2029
     tion-specification  (_except.spec_),  throw(), it indicates failure to
2030
     allocate storage by throwing a bad_alloc exception  (clause  _except_,
2031
     _lib.bad.alloc_); it returns a non-null pointer otherwise If the allo-
2032
     cation function is declared  with  an  empty  exception-specification,
2033
     throw(), it returns null to indicate failure to allocate storage and a
2034
     non-null pointer otherwise.
2035
 
2036
     So check for a null exception spec on the op new we just called.  */
2037
 
2038
  nothrow = TYPE_NOTHROW_P (TREE_TYPE (alloc_fn));
2039
  check_new = (flag_check_new || nothrow) && ! use_java_new;
2040
 
2041
  if (cookie_size)
2042
    {
2043
      tree cookie;
2044
      tree cookie_ptr;
2045
      tree size_ptr_type;
2046
 
2047
      /* Adjust so we're pointing to the start of the object.  */
2048
      data_addr = build2 (POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2049
                          alloc_node, cookie_size);
2050
 
2051
      /* Store the number of bytes allocated so that we can know how
2052
         many elements to destroy later.  We use the last sizeof
2053
         (size_t) bytes to store the number of elements.  */
2054
      cookie_ptr = size_binop (MINUS_EXPR, cookie_size, size_in_bytes (sizetype));
2055
      cookie_ptr = fold_build2_loc (input_location,
2056
                                POINTER_PLUS_EXPR, TREE_TYPE (alloc_node),
2057
                                alloc_node, cookie_ptr);
2058
      size_ptr_type = build_pointer_type (sizetype);
2059
      cookie_ptr = fold_convert (size_ptr_type, cookie_ptr);
2060
      cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2061
 
2062
      cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts);
2063
 
2064
      if (targetm.cxx.cookie_has_size ())
2065
        {
2066
          /* Also store the element size.  */
2067
          cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, cookie_ptr,
2068
                               fold_build1_loc (input_location,
2069
                                            NEGATE_EXPR, sizetype,
2070
                                            size_in_bytes (sizetype)));
2071
 
2072
          cookie = cp_build_indirect_ref (cookie_ptr, RO_NULL, complain);
2073
          cookie = build2 (MODIFY_EXPR, sizetype, cookie,
2074
                           size_in_bytes (elt_type));
2075
          cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr),
2076
                                cookie, cookie_expr);
2077
        }
2078
    }
2079
  else
2080
    {
2081
      cookie_expr = NULL_TREE;
2082
      data_addr = alloc_node;
2083
    }
2084
 
2085
  /* Now use a pointer to the type we've actually allocated.  */
2086
 
2087
  /* But we want to operate on a non-const version to start with,
2088
     since we'll be modifying the elements.  */
2089
  non_const_pointer_type = build_pointer_type
2090
    (cp_build_qualified_type (type, TYPE_QUALS (type) & ~TYPE_QUAL_CONST));
2091
 
2092
  data_addr = fold_convert (non_const_pointer_type, data_addr);
2093
  /* Any further uses of alloc_node will want this type, too.  */
2094
  alloc_node = fold_convert (non_const_pointer_type, alloc_node);
2095
 
2096
  /* Now initialize the allocated object.  Note that we preevaluate the
2097
     initialization expression, apart from the actual constructor call or
2098
     assignment--we do this because we want to delay the allocation as long
2099
     as possible in order to minimize the size of the exception region for
2100
     placement delete.  */
2101
  if (is_initialized)
2102
    {
2103
      bool stable;
2104
      bool explicit_value_init_p = false;
2105
 
2106
      if (*init != NULL && VEC_empty (tree, *init))
2107
        {
2108
          *init = NULL;
2109
          explicit_value_init_p = true;
2110
        }
2111
 
2112
      if (array_p)
2113
        {
2114
          tree vecinit = NULL_TREE;
2115
          if (*init && VEC_length (tree, *init) == 1
2116
              && BRACE_ENCLOSED_INITIALIZER_P (VEC_index (tree, *init, 0))
2117
              && CONSTRUCTOR_IS_DIRECT_INIT (VEC_index (tree, *init, 0)))
2118
            {
2119
              tree arraytype, domain;
2120
              vecinit = VEC_index (tree, *init, 0);
2121
              if (TREE_CONSTANT (nelts))
2122
                domain = compute_array_index_type (NULL_TREE, nelts);
2123
              else
2124
                {
2125
                  domain = NULL_TREE;
2126
                  if (CONSTRUCTOR_NELTS (vecinit) > 0)
2127
                    warning (0, "non-constant array size in new, unable to "
2128
                             "verify length of initializer-list");
2129
                }
2130
              arraytype = build_cplus_array_type (type, domain);
2131
              vecinit = digest_init (arraytype, vecinit);
2132
            }
2133
          else if (*init)
2134
            {
2135
              if (complain & tf_error)
2136
                permerror (input_location, "ISO C++ forbids initialization in array new");
2137
              else
2138
                return error_mark_node;
2139
              vecinit = build_tree_list_vec (*init);
2140
            }
2141
          init_expr
2142
            = build_vec_init (data_addr,
2143
                              cp_build_binary_op (input_location,
2144
                                                  MINUS_EXPR, outer_nelts,
2145
                                                  integer_one_node,
2146
                                                  complain),
2147
                              vecinit,
2148
                              explicit_value_init_p,
2149
                              /*from_array=*/0,
2150
                              complain);
2151
 
2152
          /* An array initialization is stable because the initialization
2153
             of each element is a full-expression, so the temporaries don't
2154
             leak out.  */
2155
          stable = true;
2156
        }
2157
      else
2158
        {
2159
          init_expr = cp_build_indirect_ref (data_addr, RO_NULL, complain);
2160
 
2161
          if (TYPE_NEEDS_CONSTRUCTING (type) && !explicit_value_init_p)
2162
            {
2163
              init_expr = build_special_member_call (init_expr,
2164
                                                     complete_ctor_identifier,
2165
                                                     init, elt_type,
2166
                                                     LOOKUP_NORMAL,
2167
                                                     complain);
2168
            }
2169
          else if (explicit_value_init_p)
2170
            {
2171
              /* Something like `new int()'.  */
2172
              init_expr = build2 (INIT_EXPR, type,
2173
                                  init_expr, build_value_init (type));
2174
            }
2175
          else
2176
            {
2177
              tree ie;
2178
 
2179
              /* We are processing something like `new int (10)', which
2180
                 means allocate an int, and initialize it with 10.  */
2181
 
2182
              ie = build_x_compound_expr_from_vec (*init, "new initializer");
2183
              init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, ie,
2184
                                                complain);
2185
            }
2186
          stable = stabilize_init (init_expr, &init_preeval_expr);
2187
        }
2188
 
2189
      if (init_expr == error_mark_node)
2190
        return error_mark_node;
2191
 
2192
      /* If any part of the object initialization terminates by throwing an
2193
         exception and a suitable deallocation function can be found, the
2194
         deallocation function is called to free the memory in which the
2195
         object was being constructed, after which the exception continues
2196
         to propagate in the context of the new-expression. If no
2197
         unambiguous matching deallocation function can be found,
2198
         propagating the exception does not cause the object's memory to be
2199
         freed.  */
2200
      if (flag_exceptions && ! use_java_new)
2201
        {
2202
          enum tree_code dcode = array_p ? VEC_DELETE_EXPR : DELETE_EXPR;
2203
          tree cleanup;
2204
 
2205
          /* The Standard is unclear here, but the right thing to do
2206
             is to use the same method for finding deallocation
2207
             functions that we use for finding allocation functions.  */
2208
          cleanup = (build_op_delete_call
2209
                     (dcode,
2210
                      alloc_node,
2211
                      size,
2212
                      globally_qualified_p,
2213
                      placement_allocation_fn_p ? alloc_call : NULL_TREE,
2214
                      alloc_fn));
2215
 
2216
          if (!cleanup)
2217
            /* We're done.  */;
2218
          else if (stable)
2219
            /* This is much simpler if we were able to preevaluate all of
2220
               the arguments to the constructor call.  */
2221
            {
2222
              /* CLEANUP is compiler-generated, so no diagnostics.  */
2223
              TREE_NO_WARNING (cleanup) = true;
2224
              init_expr = build2 (TRY_CATCH_EXPR, void_type_node,
2225
                                  init_expr, cleanup);
2226
              /* Likewise, this try-catch is compiler-generated.  */
2227
              TREE_NO_WARNING (init_expr) = true;
2228
            }
2229
          else
2230
            /* Ack!  First we allocate the memory.  Then we set our sentry
2231
               variable to true, and expand a cleanup that deletes the
2232
               memory if sentry is true.  Then we run the constructor, and
2233
               finally clear the sentry.
2234
 
2235
               We need to do this because we allocate the space first, so
2236
               if there are any temporaries with cleanups in the
2237
               constructor args and we weren't able to preevaluate them, we
2238
               need this EH region to extend until end of full-expression
2239
               to preserve nesting.  */
2240
            {
2241
              tree end, sentry, begin;
2242
 
2243
              begin = get_target_expr (boolean_true_node);
2244
              CLEANUP_EH_ONLY (begin) = 1;
2245
 
2246
              sentry = TARGET_EXPR_SLOT (begin);
2247
 
2248
              /* CLEANUP is compiler-generated, so no diagnostics.  */
2249
              TREE_NO_WARNING (cleanup) = true;
2250
 
2251
              TARGET_EXPR_CLEANUP (begin)
2252
                = build3 (COND_EXPR, void_type_node, sentry,
2253
                          cleanup, void_zero_node);
2254
 
2255
              end = build2 (MODIFY_EXPR, TREE_TYPE (sentry),
2256
                            sentry, boolean_false_node);
2257
 
2258
              init_expr
2259
                = build2 (COMPOUND_EXPR, void_type_node, begin,
2260
                          build2 (COMPOUND_EXPR, void_type_node, init_expr,
2261
                                  end));
2262
              /* Likewise, this is compiler-generated.  */
2263
              TREE_NO_WARNING (init_expr) = true;
2264
            }
2265
        }
2266
    }
2267
  else
2268
    init_expr = NULL_TREE;
2269
 
2270
  /* Now build up the return value in reverse order.  */
2271
 
2272
  rval = data_addr;
2273
 
2274
  if (init_expr)
2275
    rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_expr, rval);
2276
  if (cookie_expr)
2277
    rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), cookie_expr, rval);
2278
 
2279
  if (rval == data_addr)
2280
    /* If we don't have an initializer or a cookie, strip the TARGET_EXPR
2281
       and return the call (which doesn't need to be adjusted).  */
2282
    rval = TARGET_EXPR_INITIAL (alloc_expr);
2283
  else
2284
    {
2285
      if (check_new)
2286
        {
2287
          tree ifexp = cp_build_binary_op (input_location,
2288
                                           NE_EXPR, alloc_node,
2289
                                           integer_zero_node,
2290
                                           complain);
2291
          rval = build_conditional_expr (ifexp, rval, alloc_node,
2292
                                         complain);
2293
        }
2294
 
2295
      /* Perform the allocation before anything else, so that ALLOC_NODE
2296
         has been initialized before we start using it.  */
2297
      rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), alloc_expr, rval);
2298
    }
2299
 
2300
  if (init_preeval_expr)
2301
    rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), init_preeval_expr, rval);
2302
 
2303
  /* A new-expression is never an lvalue.  */
2304
  gcc_assert (!lvalue_p (rval));
2305
 
2306
  return convert (pointer_type, rval);
2307
}
2308
 
2309
/* Generate a representation for a C++ "new" expression.  *PLACEMENT
2310
   is a vector of placement-new arguments (or NULL if none).  If NELTS
2311
   is NULL, TYPE is the type of the storage to be allocated.  If NELTS
2312
   is not NULL, then this is an array-new allocation; TYPE is the type
2313
   of the elements in the array and NELTS is the number of elements in
2314
   the array.  *INIT, if non-NULL, is the initializer for the new
2315
   object, or an empty vector to indicate an initializer of "()".  If
2316
   USE_GLOBAL_NEW is true, then the user explicitly wrote "::new"
2317
   rather than just "new".  This may change PLACEMENT and INIT.  */
2318
 
2319
tree
2320
build_new (VEC(tree,gc) **placement, tree type, tree nelts,
2321
           VEC(tree,gc) **init, int use_global_new, tsubst_flags_t complain)
2322
{
2323
  tree rval;
2324
  VEC(tree,gc) *orig_placement = NULL;
2325
  tree orig_nelts = NULL_TREE;
2326
  VEC(tree,gc) *orig_init = NULL;
2327
 
2328
  if (type == error_mark_node)
2329
    return error_mark_node;
2330
 
2331
  if (nelts == NULL_TREE && VEC_length (tree, *init) == 1)
2332
    {
2333
      tree auto_node = type_uses_auto (type);
2334
      if (auto_node && describable_type (VEC_index (tree, *init, 0)))
2335
        type = do_auto_deduction (type, VEC_index (tree, *init, 0), auto_node);
2336
    }
2337
 
2338
  if (processing_template_decl)
2339
    {
2340
      if (dependent_type_p (type)
2341
          || any_type_dependent_arguments_p (*placement)
2342
          || (nelts && type_dependent_expression_p (nelts))
2343
          || any_type_dependent_arguments_p (*init))
2344
        return build_raw_new_expr (*placement, type, nelts, *init,
2345
                                   use_global_new);
2346
 
2347
      orig_placement = make_tree_vector_copy (*placement);
2348
      orig_nelts = nelts;
2349
      orig_init = make_tree_vector_copy (*init);
2350
 
2351
      make_args_non_dependent (*placement);
2352
      if (nelts)
2353
        nelts = build_non_dependent_expr (nelts);
2354
      make_args_non_dependent (*init);
2355
    }
2356
 
2357
  if (nelts)
2358
    {
2359
      if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false))
2360
        {
2361
          if (complain & tf_error)
2362
            permerror (input_location, "size in array new must have integral type");
2363
          else
2364
            return error_mark_node;
2365
        }
2366
      nelts = cp_save_expr (cp_convert (sizetype, nelts));
2367
    }
2368
 
2369
  /* ``A reference cannot be created by the new operator.  A reference
2370
     is not an object (8.2.2, 8.4.3), so a pointer to it could not be
2371
     returned by new.'' ARM 5.3.3 */
2372
  if (TREE_CODE (type) == REFERENCE_TYPE)
2373
    {
2374
      if (complain & tf_error)
2375
        error ("new cannot be applied to a reference type");
2376
      else
2377
        return error_mark_node;
2378
      type = TREE_TYPE (type);
2379
    }
2380
 
2381
  if (TREE_CODE (type) == FUNCTION_TYPE)
2382
    {
2383
      if (complain & tf_error)
2384
        error ("new cannot be applied to a function type");
2385
      return error_mark_node;
2386
    }
2387
 
2388
  /* The type allocated must be complete.  If the new-type-id was
2389
     "T[N]" then we are just checking that "T" is complete here, but
2390
     that is equivalent, since the value of "N" doesn't matter.  */
2391
  if (!complete_type_or_else (type, NULL_TREE))
2392
    return error_mark_node;
2393
 
2394
  rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
2395
  if (rval == error_mark_node)
2396
    return error_mark_node;
2397
 
2398
  if (processing_template_decl)
2399
    {
2400
      tree ret = build_raw_new_expr (orig_placement, type, orig_nelts,
2401
                                     orig_init, use_global_new);
2402
      release_tree_vector (orig_placement);
2403
      release_tree_vector (orig_init);
2404
      return ret;
2405
    }
2406
 
2407
  /* Wrap it in a NOP_EXPR so warn_if_unused_value doesn't complain.  */
2408
  rval = build1 (NOP_EXPR, TREE_TYPE (rval), rval);
2409
  TREE_NO_WARNING (rval) = 1;
2410
 
2411
  return rval;
2412
}
2413
 
2414
/* Given a Java class, return a decl for the corresponding java.lang.Class.  */
2415
 
2416
tree
2417
build_java_class_ref (tree type)
2418
{
2419
  tree name = NULL_TREE, class_decl;
2420
  static tree CL_suffix = NULL_TREE;
2421
  if (CL_suffix == NULL_TREE)
2422
    CL_suffix = get_identifier("class$");
2423
  if (jclass_node == NULL_TREE)
2424
    {
2425
      jclass_node = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
2426
      if (jclass_node == NULL_TREE)
2427
        {
2428
          error ("call to Java constructor, while %<jclass%> undefined");
2429
          return error_mark_node;
2430
        }
2431
      jclass_node = TREE_TYPE (jclass_node);
2432
    }
2433
 
2434
  /* Mangle the class$ field.  */
2435
  {
2436
    tree field;
2437
    for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2438
      if (DECL_NAME (field) == CL_suffix)
2439
        {
2440
          mangle_decl (field);
2441
          name = DECL_ASSEMBLER_NAME (field);
2442
          break;
2443
        }
2444
    if (!field)
2445
      {
2446
        error ("can't find %<class$%> in %qT", type);
2447
        return error_mark_node;
2448
      }
2449
  }
2450
 
2451
  class_decl = IDENTIFIER_GLOBAL_VALUE (name);
2452
  if (class_decl == NULL_TREE)
2453
    {
2454
      class_decl = build_decl (input_location,
2455
                               VAR_DECL, name, TREE_TYPE (jclass_node));
2456
      TREE_STATIC (class_decl) = 1;
2457
      DECL_EXTERNAL (class_decl) = 1;
2458
      TREE_PUBLIC (class_decl) = 1;
2459
      DECL_ARTIFICIAL (class_decl) = 1;
2460
      DECL_IGNORED_P (class_decl) = 1;
2461
      pushdecl_top_level (class_decl);
2462
      make_decl_rtl (class_decl);
2463
    }
2464
  return class_decl;
2465
}
2466
 
2467
static tree
2468
build_vec_delete_1 (tree base, tree maxindex, tree type,
2469
    special_function_kind auto_delete_vec, int use_global_delete)
2470
{
2471
  tree virtual_size;
2472
  tree ptype = build_pointer_type (type = complete_type (type));
2473
  tree size_exp = size_in_bytes (type);
2474
 
2475
  /* Temporary variables used by the loop.  */
2476
  tree tbase, tbase_init;
2477
 
2478
  /* This is the body of the loop that implements the deletion of a
2479
     single element, and moves temp variables to next elements.  */
2480
  tree body;
2481
 
2482
  /* This is the LOOP_EXPR that governs the deletion of the elements.  */
2483
  tree loop = 0;
2484
 
2485
  /* This is the thing that governs what to do after the loop has run.  */
2486
  tree deallocate_expr = 0;
2487
 
2488
  /* This is the BIND_EXPR which holds the outermost iterator of the
2489
     loop.  It is convenient to set this variable up and test it before
2490
     executing any other code in the loop.
2491
     This is also the containing expression returned by this function.  */
2492
  tree controller = NULL_TREE;
2493
  tree tmp;
2494
 
2495
  /* We should only have 1-D arrays here.  */
2496
  gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
2497
 
2498
  if (! MAYBE_CLASS_TYPE_P (type) || TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
2499
    goto no_destructor;
2500
 
2501
  /* The below is short by the cookie size.  */
2502
  virtual_size = size_binop (MULT_EXPR, size_exp,
2503
                             convert (sizetype, maxindex));
2504
 
2505
  tbase = create_temporary_var (ptype);
2506
  tbase_init = cp_build_modify_expr (tbase, NOP_EXPR,
2507
                                     fold_build2_loc (input_location,
2508
                                                  POINTER_PLUS_EXPR, ptype,
2509
                                                  fold_convert (ptype, base),
2510
                                                  virtual_size),
2511
                                     tf_warning_or_error);
2512
  controller = build3 (BIND_EXPR, void_type_node, tbase,
2513
                       NULL_TREE, NULL_TREE);
2514
  TREE_SIDE_EFFECTS (controller) = 1;
2515
 
2516
  body = build1 (EXIT_EXPR, void_type_node,
2517
                 build2 (EQ_EXPR, boolean_type_node, tbase,
2518
                         fold_convert (ptype, base)));
2519
  tmp = fold_build1_loc (input_location, NEGATE_EXPR, sizetype, size_exp);
2520
  body = build_compound_expr
2521
    (input_location,
2522
     body, cp_build_modify_expr (tbase, NOP_EXPR,
2523
                                 build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp),
2524
                                 tf_warning_or_error));
2525
  body = build_compound_expr
2526
    (input_location,
2527
     body, build_delete (ptype, tbase, sfk_complete_destructor,
2528
                         LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1));
2529
 
2530
  loop = build1 (LOOP_EXPR, void_type_node, body);
2531
  loop = build_compound_expr (input_location, tbase_init, loop);
2532
 
2533
 no_destructor:
2534
  /* If the delete flag is one, or anything else with the low bit set,
2535
     delete the storage.  */
2536
  if (auto_delete_vec != sfk_base_destructor)
2537
    {
2538
      tree base_tbd;
2539
 
2540
      /* The below is short by the cookie size.  */
2541
      virtual_size = size_binop (MULT_EXPR, size_exp,
2542
                                 convert (sizetype, maxindex));
2543
 
2544
      if (! TYPE_VEC_NEW_USES_COOKIE (type))
2545
        /* no header */
2546
        base_tbd = base;
2547
      else
2548
        {
2549
          tree cookie_size;
2550
 
2551
          cookie_size = targetm.cxx.get_cookie_size (type);
2552
          base_tbd
2553
            = cp_convert (ptype,
2554
                          cp_build_binary_op (input_location,
2555
                                              MINUS_EXPR,
2556
                                              cp_convert (string_type_node,
2557
                                                          base),
2558
                                              cookie_size,
2559
                                              tf_warning_or_error));
2560
          /* True size with header.  */
2561
          virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
2562
        }
2563
 
2564
      if (auto_delete_vec == sfk_deleting_destructor)
2565
        deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR,
2566
                                                base_tbd, virtual_size,
2567
                                                use_global_delete & 1,
2568
                                                /*placement=*/NULL_TREE,
2569
                                                /*alloc_fn=*/NULL_TREE);
2570
    }
2571
 
2572
  body = loop;
2573
  if (!deallocate_expr)
2574
    ;
2575
  else if (!body)
2576
    body = deallocate_expr;
2577
  else
2578
    body = build_compound_expr (input_location, body, deallocate_expr);
2579
 
2580
  if (!body)
2581
    body = integer_zero_node;
2582
 
2583
  /* Outermost wrapper: If pointer is null, punt.  */
2584
  body = fold_build3_loc (input_location, COND_EXPR, void_type_node,
2585
                      fold_build2_loc (input_location,
2586
                                   NE_EXPR, boolean_type_node, base,
2587
                                   convert (TREE_TYPE (base),
2588
                                            integer_zero_node)),
2589
                      body, integer_zero_node);
2590
  body = build1 (NOP_EXPR, void_type_node, body);
2591
 
2592
  if (controller)
2593
    {
2594
      TREE_OPERAND (controller, 1) = body;
2595
      body = controller;
2596
    }
2597
 
2598
  if (TREE_CODE (base) == SAVE_EXPR)
2599
    /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR.  */
2600
    body = build2 (COMPOUND_EXPR, void_type_node, base, body);
2601
 
2602
  return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error);
2603
}
2604
 
2605
/* Create an unnamed variable of the indicated TYPE.  */
2606
 
2607
tree
2608
create_temporary_var (tree type)
2609
{
2610
  tree decl;
2611
 
2612
  decl = build_decl (input_location,
2613
                     VAR_DECL, NULL_TREE, type);
2614
  TREE_USED (decl) = 1;
2615
  DECL_ARTIFICIAL (decl) = 1;
2616
  DECL_IGNORED_P (decl) = 1;
2617
  DECL_CONTEXT (decl) = current_function_decl;
2618
 
2619
  return decl;
2620
}
2621
 
2622
/* Create a new temporary variable of the indicated TYPE, initialized
2623
   to INIT.
2624
 
2625
   It is not entered into current_binding_level, because that breaks
2626
   things when it comes time to do final cleanups (which take place
2627
   "outside" the binding contour of the function).  */
2628
 
2629
static tree
2630
get_temp_regvar (tree type, tree init)
2631
{
2632
  tree decl;
2633
 
2634
  decl = create_temporary_var (type);
2635
  add_decl_expr (decl);
2636
 
2637
  finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init,
2638
                                          tf_warning_or_error));
2639
 
2640
  return decl;
2641
}
2642
 
2643
/* `build_vec_init' returns tree structure that performs
2644
   initialization of a vector of aggregate types.
2645
 
2646
   BASE is a reference to the vector, of ARRAY_TYPE, or a pointer
2647
     to the first element, of POINTER_TYPE.
2648
   MAXINDEX is the maximum index of the array (one less than the
2649
     number of elements).  It is only used if BASE is a pointer or
2650
     TYPE_DOMAIN (TREE_TYPE (BASE)) == NULL_TREE.
2651
 
2652
   INIT is the (possibly NULL) initializer.
2653
 
2654
   If EXPLICIT_VALUE_INIT_P is true, then INIT must be NULL.  All
2655
   elements in the array are value-initialized.
2656
 
2657
   FROM_ARRAY is 0 if we should init everything with INIT
2658
   (i.e., every element initialized from INIT).
2659
   FROM_ARRAY is 1 if we should index into INIT in parallel
2660
   with initialization of DECL.
2661
   FROM_ARRAY is 2 if we should index into INIT in parallel,
2662
   but use assignment instead of initialization.  */
2663
 
2664
tree
2665
build_vec_init (tree base, tree maxindex, tree init,
2666
                bool explicit_value_init_p,
2667
                int from_array, tsubst_flags_t complain)
2668
{
2669
  tree rval;
2670
  tree base2 = NULL_TREE;
2671
  tree itype = NULL_TREE;
2672
  tree iterator;
2673
  /* The type of BASE.  */
2674
  tree atype = TREE_TYPE (base);
2675
  /* The type of an element in the array.  */
2676
  tree type = TREE_TYPE (atype);
2677
  /* The element type reached after removing all outer array
2678
     types.  */
2679
  tree inner_elt_type;
2680
  /* The type of a pointer to an element in the array.  */
2681
  tree ptype;
2682
  tree stmt_expr;
2683
  tree compound_stmt;
2684
  int destroy_temps;
2685
  tree try_block = NULL_TREE;
2686
  int num_initialized_elts = 0;
2687
  bool is_global;
2688
 
2689
  if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype))
2690
    maxindex = array_type_nelts (atype);
2691
 
2692
  if (maxindex == NULL_TREE || maxindex == error_mark_node)
2693
    return error_mark_node;
2694
 
2695
  if (explicit_value_init_p)
2696
    gcc_assert (!init);
2697
 
2698
  inner_elt_type = strip_array_types (type);
2699
 
2700
  /* Look through the TARGET_EXPR around a compound literal.  */
2701
  if (init && TREE_CODE (init) == TARGET_EXPR
2702
      && TREE_CODE (TARGET_EXPR_INITIAL (init)) == CONSTRUCTOR
2703
      && from_array != 2)
2704
    init = TARGET_EXPR_INITIAL (init);
2705
 
2706
  if (init
2707
      && TREE_CODE (atype) == ARRAY_TYPE
2708
      && (from_array == 2
2709
          ? (!CLASS_TYPE_P (inner_elt_type)
2710
             || !TYPE_HAS_COMPLEX_ASSIGN_REF (inner_elt_type))
2711
          : !TYPE_NEEDS_CONSTRUCTING (type))
2712
      && ((TREE_CODE (init) == CONSTRUCTOR
2713
           /* Don't do this if the CONSTRUCTOR might contain something
2714
              that might throw and require us to clean up.  */
2715
           && (VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (init))
2716
               || ! TYPE_HAS_NONTRIVIAL_DESTRUCTOR (inner_elt_type)))
2717
          || from_array))
2718
    {
2719
      /* Do non-default initialization of trivial arrays resulting from
2720
         brace-enclosed initializers.  In this case, digest_init and
2721
         store_constructor will handle the semantics for us.  */
2722
 
2723
      stmt_expr = build2 (INIT_EXPR, atype, base, init);
2724
      return stmt_expr;
2725
    }
2726
 
2727
  maxindex = cp_convert (ptrdiff_type_node, maxindex);
2728
  if (TREE_CODE (atype) == ARRAY_TYPE)
2729
    {
2730
      ptype = build_pointer_type (type);
2731
      base = cp_convert (ptype, decay_conversion (base));
2732
    }
2733
  else
2734
    ptype = atype;
2735
 
2736
  /* The code we are generating looks like:
2737
     ({
2738
       T* t1 = (T*) base;
2739
       T* rval = t1;
2740
       ptrdiff_t iterator = maxindex;
2741
       try {
2742
         for (; iterator != -1; --iterator) {
2743
           ... initialize *t1 ...
2744
           ++t1;
2745
         }
2746
       } catch (...) {
2747
         ... destroy elements that were constructed ...
2748
       }
2749
       rval;
2750
     })
2751
 
2752
     We can omit the try and catch blocks if we know that the
2753
     initialization will never throw an exception, or if the array
2754
     elements do not have destructors.  We can omit the loop completely if
2755
     the elements of the array do not have constructors.
2756
 
2757
     We actually wrap the entire body of the above in a STMT_EXPR, for
2758
     tidiness.
2759
 
2760
     When copying from array to another, when the array elements have
2761
     only trivial copy constructors, we should use __builtin_memcpy
2762
     rather than generating a loop.  That way, we could take advantage
2763
     of whatever cleverness the back end has for dealing with copies
2764
     of blocks of memory.  */
2765
 
2766
  is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
2767
  destroy_temps = stmts_are_full_exprs_p ();
2768
  current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2769
  rval = get_temp_regvar (ptype, base);
2770
  base = get_temp_regvar (ptype, rval);
2771
  iterator = get_temp_regvar (ptrdiff_type_node, maxindex);
2772
 
2773
  /* If initializing one array from another, initialize element by
2774
     element.  We rely upon the below calls to do the argument
2775
     checking.  Evaluate the initializer before entering the try block.  */
2776
  if (from_array && init && TREE_CODE (init) != CONSTRUCTOR)
2777
    {
2778
      base2 = decay_conversion (init);
2779
      itype = TREE_TYPE (base2);
2780
      base2 = get_temp_regvar (itype, base2);
2781
      itype = TREE_TYPE (itype);
2782
    }
2783
 
2784
  /* Protect the entire array initialization so that we can destroy
2785
     the partially constructed array if an exception is thrown.
2786
     But don't do this if we're assigning.  */
2787
  if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2788
      && from_array != 2)
2789
    {
2790
      try_block = begin_try_block ();
2791
    }
2792
 
2793
  if (init != NULL_TREE && TREE_CODE (init) == CONSTRUCTOR)
2794
    {
2795
      /* Do non-default initialization of non-trivial arrays resulting from
2796
         brace-enclosed initializers.  */
2797
      unsigned HOST_WIDE_INT idx;
2798
      tree elt;
2799
      from_array = 0;
2800
 
2801
      FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
2802
        {
2803
          tree baseref = build1 (INDIRECT_REF, type, base);
2804
 
2805
          num_initialized_elts++;
2806
 
2807
          current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2808
          if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
2809
            finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain));
2810
          else
2811
            finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR,
2812
                                                    elt, complain));
2813
          current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2814
 
2815
          finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2816
                                               complain));
2817
          finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2818
                                               complain));
2819
        }
2820
 
2821
      /* Clear out INIT so that we don't get confused below.  */
2822
      init = NULL_TREE;
2823
    }
2824
  else if (from_array)
2825
    {
2826
      if (init)
2827
        /* OK, we set base2 above.  */;
2828
      else if (TYPE_LANG_SPECIFIC (type)
2829
               && TYPE_NEEDS_CONSTRUCTING (type)
2830
               && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
2831
        {
2832
          if (complain & tf_error)
2833
            error ("initializer ends prematurely");
2834
          return error_mark_node;
2835
        }
2836
    }
2837
 
2838
  /* Now, default-initialize any remaining elements.  We don't need to
2839
     do that if a) the type does not need constructing, or b) we've
2840
     already initialized all the elements.
2841
 
2842
     We do need to keep going if we're copying an array.  */
2843
 
2844
  if (from_array
2845
      || ((TYPE_NEEDS_CONSTRUCTING (type) || explicit_value_init_p)
2846
          && ! (host_integerp (maxindex, 0)
2847
                && (num_initialized_elts
2848
                    == tree_low_cst (maxindex, 0) + 1))))
2849
    {
2850
      /* If the ITERATOR is equal to -1, then we don't have to loop;
2851
         we've already initialized all the elements.  */
2852
      tree for_stmt;
2853
      tree elt_init;
2854
      tree to;
2855
 
2856
      for_stmt = begin_for_stmt ();
2857
      finish_for_init_stmt (for_stmt);
2858
      finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator,
2859
                               build_int_cst (TREE_TYPE (iterator), -1)),
2860
                       for_stmt);
2861
      finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0,
2862
                                          complain),
2863
                       for_stmt);
2864
 
2865
      to = build1 (INDIRECT_REF, type, base);
2866
 
2867
      if (from_array)
2868
        {
2869
          tree from;
2870
 
2871
          if (base2)
2872
            from = build1 (INDIRECT_REF, itype, base2);
2873
          else
2874
            from = NULL_TREE;
2875
 
2876
          if (from_array == 2)
2877
            elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2878
                                             complain);
2879
          else if (TYPE_NEEDS_CONSTRUCTING (type))
2880
            elt_init = build_aggr_init (to, from, 0, complain);
2881
          else if (from)
2882
            elt_init = cp_build_modify_expr (to, NOP_EXPR, from,
2883
                                             complain);
2884
          else
2885
            gcc_unreachable ();
2886
        }
2887
      else if (TREE_CODE (type) == ARRAY_TYPE)
2888
        {
2889
          if (init != 0)
2890
            sorry
2891
              ("cannot initialize multi-dimensional array with initializer");
2892
          elt_init = build_vec_init (build1 (INDIRECT_REF, type, base),
2893
                                     0, 0,
2894
                                     explicit_value_init_p,
2895
                                     0, complain);
2896
        }
2897
      else if (explicit_value_init_p)
2898
        elt_init = build2 (INIT_EXPR, type, to,
2899
                           build_value_init (type));
2900
      else
2901
        {
2902
          gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
2903
          elt_init = build_aggr_init (to, init, 0, complain);
2904
        }
2905
 
2906
      current_stmt_tree ()->stmts_are_full_exprs_p = 1;
2907
      finish_expr_stmt (elt_init);
2908
      current_stmt_tree ()->stmts_are_full_exprs_p = 0;
2909
 
2910
      finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0,
2911
                                           complain));
2912
      if (base2)
2913
        finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0,
2914
                                             complain));
2915
 
2916
      finish_for_stmt (for_stmt);
2917
    }
2918
 
2919
  /* Make sure to cleanup any partially constructed elements.  */
2920
  if (flag_exceptions && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
2921
      && from_array != 2)
2922
    {
2923
      tree e;
2924
      tree m = cp_build_binary_op (input_location,
2925
                                   MINUS_EXPR, maxindex, iterator,
2926
                                   complain);
2927
 
2928
      /* Flatten multi-dimensional array since build_vec_delete only
2929
         expects one-dimensional array.  */
2930
      if (TREE_CODE (type) == ARRAY_TYPE)
2931
        m = cp_build_binary_op (input_location,
2932
                                MULT_EXPR, m,
2933
                                array_type_nelts_total (type),
2934
                                complain);
2935
 
2936
      finish_cleanup_try_block (try_block);
2937
      e = build_vec_delete_1 (rval, m,
2938
                              inner_elt_type, sfk_base_destructor,
2939
                              /*use_global_delete=*/0);
2940
      finish_cleanup (e, try_block);
2941
    }
2942
 
2943
  /* The value of the array initialization is the array itself, RVAL
2944
     is a pointer to the first element.  */
2945
  finish_stmt_expr_expr (rval, stmt_expr);
2946
 
2947
  stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
2948
 
2949
  /* Now make the result have the correct type.  */
2950
  if (TREE_CODE (atype) == ARRAY_TYPE)
2951
    {
2952
      atype = build_pointer_type (atype);
2953
      stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
2954
      stmt_expr = cp_build_indirect_ref (stmt_expr, RO_NULL, complain);
2955
      TREE_NO_WARNING (stmt_expr) = 1;
2956
    }
2957
 
2958
  current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps;
2959
  return stmt_expr;
2960
}
2961
 
2962
/* Call the DTOR_KIND destructor for EXP.  FLAGS are as for
2963
   build_delete.  */
2964
 
2965
static tree
2966
build_dtor_call (tree exp, special_function_kind dtor_kind, int flags)
2967
{
2968
  tree name;
2969
  tree fn;
2970
  switch (dtor_kind)
2971
    {
2972
    case sfk_complete_destructor:
2973
      name = complete_dtor_identifier;
2974
      break;
2975
 
2976
    case sfk_base_destructor:
2977
      name = base_dtor_identifier;
2978
      break;
2979
 
2980
    case sfk_deleting_destructor:
2981
      name = deleting_dtor_identifier;
2982
      break;
2983
 
2984
    default:
2985
      gcc_unreachable ();
2986
    }
2987
  fn = lookup_fnfields (TREE_TYPE (exp), name, /*protect=*/2);
2988
  return build_new_method_call (exp, fn,
2989
                                /*args=*/NULL,
2990
                                /*conversion_path=*/NULL_TREE,
2991
                                flags,
2992
                                /*fn_p=*/NULL,
2993
                                tf_warning_or_error);
2994
}
2995
 
2996
/* Generate a call to a destructor. TYPE is the type to cast ADDR to.
2997
   ADDR is an expression which yields the store to be destroyed.
2998
   AUTO_DELETE is the name of the destructor to call, i.e., either
2999
   sfk_complete_destructor, sfk_base_destructor, or
3000
   sfk_deleting_destructor.
3001
 
3002
   FLAGS is the logical disjunction of zero or more LOOKUP_
3003
   flags.  See cp-tree.h for more info.  */
3004
 
3005
tree
3006
build_delete (tree type, tree addr, special_function_kind auto_delete,
3007
    int flags, int use_global_delete)
3008
{
3009
  tree expr;
3010
 
3011
  if (addr == error_mark_node)
3012
    return error_mark_node;
3013
 
3014
  /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type
3015
     set to `error_mark_node' before it gets properly cleaned up.  */
3016
  if (type == error_mark_node)
3017
    return error_mark_node;
3018
 
3019
  type = TYPE_MAIN_VARIANT (type);
3020
 
3021
  if (TREE_CODE (type) == POINTER_TYPE)
3022
    {
3023
      bool complete_p = true;
3024
 
3025
      type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
3026
      if (TREE_CODE (type) == ARRAY_TYPE)
3027
        goto handle_array;
3028
 
3029
      /* We don't want to warn about delete of void*, only other
3030
          incomplete types.  Deleting other incomplete types
3031
          invokes undefined behavior, but it is not ill-formed, so
3032
          compile to something that would even do The Right Thing
3033
          (TM) should the type have a trivial dtor and no delete
3034
          operator.  */
3035
      if (!VOID_TYPE_P (type))
3036
        {
3037
          complete_type (type);
3038
          if (!COMPLETE_TYPE_P (type))
3039
            {
3040
              if (warning (0, "possible problem detected in invocation of "
3041
                           "delete operator:"))
3042
                {
3043
                  cxx_incomplete_type_diagnostic (addr, type, DK_WARNING);
3044
                  inform (input_location, "neither the destructor nor the class-specific "
3045
                          "operator delete will be called, even if they are "
3046
                          "declared when the class is defined.");
3047
                }
3048
              complete_p = false;
3049
            }
3050
        }
3051
      if (VOID_TYPE_P (type) || !complete_p || !MAYBE_CLASS_TYPE_P (type))
3052
        /* Call the builtin operator delete.  */
3053
        return build_builtin_delete_call (addr);
3054
      if (TREE_SIDE_EFFECTS (addr))
3055
        addr = save_expr (addr);
3056
 
3057
      /* Throw away const and volatile on target type of addr.  */
3058
      addr = convert_force (build_pointer_type (type), addr, 0);
3059
    }
3060
  else if (TREE_CODE (type) == ARRAY_TYPE)
3061
    {
3062
    handle_array:
3063
 
3064
      if (TYPE_DOMAIN (type) == NULL_TREE)
3065
        {
3066
          error ("unknown array size in delete");
3067
          return error_mark_node;
3068
        }
3069
      return build_vec_delete (addr, array_type_nelts (type),
3070
                               auto_delete, use_global_delete);
3071
    }
3072
  else
3073
    {
3074
      /* Don't check PROTECT here; leave that decision to the
3075
         destructor.  If the destructor is accessible, call it,
3076
         else report error.  */
3077
      addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error);
3078
      if (TREE_SIDE_EFFECTS (addr))
3079
        addr = save_expr (addr);
3080
 
3081
      addr = convert_force (build_pointer_type (type), addr, 0);
3082
    }
3083
 
3084
  gcc_assert (MAYBE_CLASS_TYPE_P (type));
3085
 
3086
  if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
3087
    {
3088
      if (auto_delete != sfk_deleting_destructor)
3089
        return void_zero_node;
3090
 
3091
      return build_op_delete_call (DELETE_EXPR, addr,
3092
                                   cxx_sizeof_nowarn (type),
3093
                                   use_global_delete,
3094
                                   /*placement=*/NULL_TREE,
3095
                                   /*alloc_fn=*/NULL_TREE);
3096
    }
3097
  else
3098
    {
3099
      tree head = NULL_TREE;
3100
      tree do_delete = NULL_TREE;
3101
      tree ifexp;
3102
 
3103
      if (CLASSTYPE_LAZY_DESTRUCTOR (type))
3104
        lazily_declare_fn (sfk_destructor, type);
3105
 
3106
      /* For `::delete x', we must not use the deleting destructor
3107
         since then we would not be sure to get the global `operator
3108
         delete'.  */
3109
      if (use_global_delete && auto_delete == sfk_deleting_destructor)
3110
        {
3111
          /* We will use ADDR multiple times so we must save it.  */
3112
          addr = save_expr (addr);
3113
          head = get_target_expr (build_headof (addr));
3114
          /* Delete the object.  */
3115
          do_delete = build_builtin_delete_call (head);
3116
          /* Otherwise, treat this like a complete object destructor
3117
             call.  */
3118
          auto_delete = sfk_complete_destructor;
3119
        }
3120
      /* If the destructor is non-virtual, there is no deleting
3121
         variant.  Instead, we must explicitly call the appropriate
3122
         `operator delete' here.  */
3123
      else if (!DECL_VIRTUAL_P (CLASSTYPE_DESTRUCTORS (type))
3124
               && auto_delete == sfk_deleting_destructor)
3125
        {
3126
          /* We will use ADDR multiple times so we must save it.  */
3127
          addr = save_expr (addr);
3128
          /* Build the call.  */
3129
          do_delete = build_op_delete_call (DELETE_EXPR,
3130
                                            addr,
3131
                                            cxx_sizeof_nowarn (type),
3132
                                            /*global_p=*/false,
3133
                                            /*placement=*/NULL_TREE,
3134
                                            /*alloc_fn=*/NULL_TREE);
3135
          /* Call the complete object destructor.  */
3136
          auto_delete = sfk_complete_destructor;
3137
        }
3138
      else if (auto_delete == sfk_deleting_destructor
3139
               && TYPE_GETS_REG_DELETE (type))
3140
        {
3141
          /* Make sure we have access to the member op delete, even though
3142
             we'll actually be calling it from the destructor.  */
3143
          build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type),
3144
                                /*global_p=*/false,
3145
                                /*placement=*/NULL_TREE,
3146
                                /*alloc_fn=*/NULL_TREE);
3147
        }
3148
 
3149
      expr = build_dtor_call (cp_build_indirect_ref (addr, RO_NULL,
3150
                                                     tf_warning_or_error),
3151
                              auto_delete, flags);
3152
      if (do_delete)
3153
        expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete);
3154
 
3155
      /* We need to calculate this before the dtor changes the vptr.  */
3156
      if (head)
3157
        expr = build2 (COMPOUND_EXPR, void_type_node, head, expr);
3158
 
3159
      if (flags & LOOKUP_DESTRUCTOR)
3160
        /* Explicit destructor call; don't check for null pointer.  */
3161
        ifexp = integer_one_node;
3162
      else
3163
        /* Handle deleting a null pointer.  */
3164
        ifexp = fold (cp_build_binary_op (input_location,
3165
                                          NE_EXPR, addr, integer_zero_node,
3166
                                          tf_warning_or_error));
3167
 
3168
      if (ifexp != integer_one_node)
3169
        expr = build3 (COND_EXPR, void_type_node,
3170
                       ifexp, expr, void_zero_node);
3171
 
3172
      return expr;
3173
    }
3174
}
3175
 
3176
/* At the beginning of a destructor, push cleanups that will call the
3177
   destructors for our base classes and members.
3178
 
3179
   Called from begin_destructor_body.  */
3180
 
3181
void
3182
push_base_cleanups (void)
3183
{
3184
  tree binfo, base_binfo;
3185
  int i;
3186
  tree member;
3187
  tree expr;
3188
  VEC(tree,gc) *vbases;
3189
 
3190
  /* Run destructors for all virtual baseclasses.  */
3191
  if (CLASSTYPE_VBASECLASSES (current_class_type))
3192
    {
3193
      tree cond = (condition_conversion
3194
                   (build2 (BIT_AND_EXPR, integer_type_node,
3195
                            current_in_charge_parm,
3196
                            integer_two_node)));
3197
 
3198
      /* The CLASSTYPE_VBASECLASSES vector is in initialization
3199
         order, which is also the right order for pushing cleanups.  */
3200
      for (vbases = CLASSTYPE_VBASECLASSES (current_class_type), i = 0;
3201
           VEC_iterate (tree, vbases, i, base_binfo); i++)
3202
        {
3203
          if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo)))
3204
            {
3205
              expr = build_special_member_call (current_class_ref,
3206
                                                base_dtor_identifier,
3207
                                                NULL,
3208
                                                base_binfo,
3209
                                                (LOOKUP_NORMAL
3210
                                                 | LOOKUP_NONVIRTUAL),
3211
                                                tf_warning_or_error);
3212
              expr = build3 (COND_EXPR, void_type_node, cond,
3213
                             expr, void_zero_node);
3214
              finish_decl_cleanup (NULL_TREE, expr);
3215
            }
3216
        }
3217
    }
3218
 
3219
  /* Take care of the remaining baseclasses.  */
3220
  for (binfo = TYPE_BINFO (current_class_type), i = 0;
3221
       BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3222
    {
3223
      if (TYPE_HAS_TRIVIAL_DESTRUCTOR (BINFO_TYPE (base_binfo))
3224
          || BINFO_VIRTUAL_P (base_binfo))
3225
        continue;
3226
 
3227
      expr = build_special_member_call (current_class_ref,
3228
                                        base_dtor_identifier,
3229
                                        NULL, base_binfo,
3230
                                        LOOKUP_NORMAL | LOOKUP_NONVIRTUAL,
3231
                                        tf_warning_or_error);
3232
      finish_decl_cleanup (NULL_TREE, expr);
3233
    }
3234
 
3235
  for (member = TYPE_FIELDS (current_class_type); member;
3236
       member = TREE_CHAIN (member))
3237
    {
3238
      if (TREE_TYPE (member) == error_mark_node
3239
          || TREE_CODE (member) != FIELD_DECL
3240
          || DECL_ARTIFICIAL (member))
3241
        continue;
3242
      if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (member)))
3243
        {
3244
          tree this_member = (build_class_member_access_expr
3245
                              (current_class_ref, member,
3246
                               /*access_path=*/NULL_TREE,
3247
                               /*preserve_reference=*/false,
3248
                               tf_warning_or_error));
3249
          tree this_type = TREE_TYPE (member);
3250
          expr = build_delete (this_type, this_member,
3251
                               sfk_complete_destructor,
3252
                               LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR|LOOKUP_NORMAL,
3253
                               0);
3254
          finish_decl_cleanup (NULL_TREE, expr);
3255
        }
3256
    }
3257
}
3258
 
3259
/* Build a C++ vector delete expression.
3260
   MAXINDEX is the number of elements to be deleted.
3261
   ELT_SIZE is the nominal size of each element in the vector.
3262
   BASE is the expression that should yield the store to be deleted.
3263
   This function expands (or synthesizes) these calls itself.
3264
   AUTO_DELETE_VEC says whether the container (vector) should be deallocated.
3265
 
3266
   This also calls delete for virtual baseclasses of elements of the vector.
3267
 
3268
   Update: MAXINDEX is no longer needed.  The size can be extracted from the
3269
   start of the vector for pointers, and from the type for arrays.  We still
3270
   use MAXINDEX for arrays because it happens to already have one of the
3271
   values we'd have to extract.  (We could use MAXINDEX with pointers to
3272
   confirm the size, and trap if the numbers differ; not clear that it'd
3273
   be worth bothering.)  */
3274
 
3275
tree
3276
build_vec_delete (tree base, tree maxindex,
3277
    special_function_kind auto_delete_vec, int use_global_delete)
3278
{
3279
  tree type;
3280
  tree rval;
3281
  tree base_init = NULL_TREE;
3282
 
3283
  type = TREE_TYPE (base);
3284
 
3285
  if (TREE_CODE (type) == POINTER_TYPE)
3286
    {
3287
      /* Step back one from start of vector, and read dimension.  */
3288
      tree cookie_addr;
3289
      tree size_ptr_type = build_pointer_type (sizetype);
3290
 
3291
      if (TREE_SIDE_EFFECTS (base))
3292
        {
3293
          base_init = get_target_expr (base);
3294
          base = TARGET_EXPR_SLOT (base_init);
3295
        }
3296
      type = strip_array_types (TREE_TYPE (type));
3297
      cookie_addr = fold_build1_loc (input_location, NEGATE_EXPR,
3298
                                 sizetype, TYPE_SIZE_UNIT (sizetype));
3299
      cookie_addr = build2 (POINTER_PLUS_EXPR,
3300
                            size_ptr_type,
3301
                            fold_convert (size_ptr_type, base),
3302
                            cookie_addr);
3303
      maxindex = cp_build_indirect_ref (cookie_addr, RO_NULL, tf_warning_or_error);
3304
    }
3305
  else if (TREE_CODE (type) == ARRAY_TYPE)
3306
    {
3307
      /* Get the total number of things in the array, maxindex is a
3308
         bad name.  */
3309
      maxindex = array_type_nelts_total (type);
3310
      type = strip_array_types (type);
3311
      base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error);
3312
      if (TREE_SIDE_EFFECTS (base))
3313
        {
3314
          base_init = get_target_expr (base);
3315
          base = TARGET_EXPR_SLOT (base_init);
3316
        }
3317
    }
3318
  else
3319
    {
3320
      if (base != error_mark_node)
3321
        error ("type to vector delete is neither pointer or array type");
3322
      return error_mark_node;
3323
    }
3324
 
3325
  rval = build_vec_delete_1 (base, maxindex, type, auto_delete_vec,
3326
                             use_global_delete);
3327
  if (base_init)
3328
    rval = build2 (COMPOUND_EXPR, TREE_TYPE (rval), base_init, rval);
3329
 
3330
  return rval;
3331
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.