![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to init.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to init.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 ! root 1: /* Handle initialization things in C++. ! 2: Copyright (C) 1987, 1989, 1992, 1993, 1994 Free Software Foundation, Inc. ! 3: Contributed by Michael Tiemann ([email protected]) ! 4: ! 5: This file is part of GNU CC. ! 6: ! 7: GNU CC is free software; you can redistribute it and/or modify ! 8: it under the terms of the GNU General Public License as published by ! 9: the Free Software Foundation; either version 2, or (at your option) ! 10: any later version. ! 11: ! 12: GNU CC is distributed in the hope that it will be useful, ! 13: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 15: GNU General Public License for more details. ! 16: ! 17: You should have received a copy of the GNU General Public License ! 18: along with GNU CC; see the file COPYING. If not, write to ! 19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 20: ! 21: ! 22: /* High-level class interface. */ ! 23: ! 24: #include "config.h" ! 25: #include "tree.h" ! 26: #include "rtl.h" ! 27: #include "cp-tree.h" ! 28: #include "flags.h" ! 29: ! 30: #undef NULL ! 31: #define NULL 0 ! 32: ! 33: /* In C++, structures with well-defined constructors are initialized by ! 34: those constructors, unasked. CURRENT_BASE_INIT_LIST ! 35: holds a list of stmts for a BASE_INIT term in the grammar. ! 36: This list has one element for each base class which must be ! 37: initialized. The list elements are [basename, init], with ! 38: type basetype. This allows the possibly anachronistic form ! 39: (assuming d : a, b, c) "d (int a) : c(a+5), b (a-4), a (a+3)" ! 40: where each successive term can be handed down the constructor ! 41: line. Perhaps this was not intended. */ ! 42: tree current_base_init_list, current_member_init_list; ! 43: ! 44: void emit_base_init (); ! 45: void check_base_init (); ! 46: static void expand_aggr_vbase_init (); ! 47: void expand_member_init (); ! 48: void expand_aggr_init (); ! 49: ! 50: static void expand_aggr_init_1 (); ! 51: static void expand_recursive_init_1 (); ! 52: static void expand_recursive_init (); ! 53: static void expand_virtual_init PROTO((tree, tree)); ! 54: tree expand_vec_init (); ! 55: ! 56: static void add_friend (), add_friends (); ! 57: ! 58: /* Cache _builtin_new and _builtin_delete exprs. */ ! 59: static tree BIN, BID, BIVN, BIVD; ! 60: ! 61: /* Cache the identifier nodes for the two magic field of a new cookie. */ ! 62: static tree nc_nelts_field_id; ! 63: #if 0 ! 64: static tree nc_ptr_2comp_field_id; ! 65: #endif ! 66: ! 67: static tree minus_one; ! 68: ! 69: /* Set up local variable for this file. MUST BE CALLED AFTER ! 70: INIT_DECL_PROCESSING. */ ! 71: ! 72: tree BI_header_type, BI_header_size; ! 73: ! 74: void init_init_processing () ! 75: { ! 76: tree fields[1]; ! 77: ! 78: /* Define implicit `operator new' and `operator delete' functions. */ ! 79: BIN = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) NEW_EXPR]))); ! 80: TREE_USED (TREE_OPERAND (BIN, 0)) = 0; ! 81: BID = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) DELETE_EXPR]))); ! 82: TREE_USED (TREE_OPERAND (BID, 0)) = 0; ! 83: BIVN = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) VEC_NEW_EXPR]))); ! 84: TREE_USED (TREE_OPERAND (BIVN, 0)) = 0; ! 85: BIVD = default_conversion (get_first_fn (IDENTIFIER_GLOBAL_VALUE (ansi_opname[(int) VEC_DELETE_EXPR]))); ! 86: TREE_USED (TREE_OPERAND (BIVD, 0)) = 0; ! 87: minus_one = build_int_2 (-1, -1); ! 88: ! 89: /* Define the structure that holds header information for ! 90: arrays allocated via operator new. */ ! 91: BI_header_type = make_lang_type (RECORD_TYPE); ! 92: nc_nelts_field_id = get_identifier ("nelts"); ! 93: fields[0] = build_lang_field_decl (FIELD_DECL, nc_nelts_field_id, sizetype); ! 94: finish_builtin_type (BI_header_type, "__new_cookie", fields, ! 95: 0, double_type_node); ! 96: BI_header_size = size_in_bytes (BI_header_type); ! 97: } ! 98: ! 99: /* Subroutine of emit_base_init. For BINFO, initialize all the ! 100: virtual function table pointers, except those that come from ! 101: virtual base classes. Initialize binfo's vtable pointer, if ! 102: INIT_SELF is true. CAN_ELIDE is true when we know that all virtual ! 103: function table pointers in all bases have been initialized already, ! 104: probably because their constructors have just be run. ADDR is the ! 105: pointer to the object whos vtables we are going to initialize. ! 106: ! 107: REAL_BINFO is usually the same as BINFO, except when addr is not of ! 108: pointer to the type of the real derived type that we want to ! 109: initialize for. This is the case when addr is a pointer to a sub ! 110: object of a complete object, and we only want to do part of the ! 111: complete object's initiailzation of vtable pointers. This is done ! 112: for all virtual table pointers in virtual base classes. REAL_BINFO ! 113: is used to find the BINFO_VTABLE that we initialize with. BINFO is ! 114: used for conversions of addr to subobjects. ! 115: ! 116: BINFO_TYPE (real_binfo) must be BINFO_TYPE (binfo). ! 117: ! 118: Relies upon binfo being inside TYPE_BINFO (TREE_TYPE (TREE_TYPE ! 119: (addr))). */ ! 120: void ! 121: expand_direct_vtbls_init (real_binfo, binfo, init_self, can_elide, addr) ! 122: tree real_binfo, binfo, addr; ! 123: int init_self, can_elide; ! 124: { ! 125: tree real_binfos = BINFO_BASETYPES (real_binfo); ! 126: tree binfos = BINFO_BASETYPES (binfo); ! 127: int i, n_baselinks = real_binfos ? TREE_VEC_LENGTH (real_binfos) : 0; ! 128: ! 129: for (i = 0; i < n_baselinks; i++) ! 130: { ! 131: tree real_base_binfo = TREE_VEC_ELT (real_binfos, i); ! 132: tree base_binfo = TREE_VEC_ELT (binfos, i); ! 133: int is_not_base_vtable = ! 134: i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo)); ! 135: if (! TREE_VIA_VIRTUAL (real_base_binfo)) ! 136: expand_direct_vtbls_init (real_base_binfo, base_binfo, ! 137: is_not_base_vtable, can_elide, addr); ! 138: } ! 139: #if 0 ! 140: /* Before turning this on, make sure it is correct. */ ! 141: if (can_elide && ! BINFO_MODIFIED (binfo)) ! 142: return; ! 143: #endif ! 144: /* Should we use something besides CLASSTYPE_VFIELDS? */ ! 145: if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo))) ! 146: { ! 147: tree base_ptr = convert_pointer_to_real (binfo, addr); ! 148: expand_virtual_init (real_binfo, base_ptr); ! 149: } ! 150: } ! 151: ! 152: /* 348 - 351 */ ! 153: /* Subroutine of emit_base_init. */ ! 154: static void ! 155: perform_member_init (member, name, init, explicit) ! 156: tree member, name, init; ! 157: int explicit; ! 158: { ! 159: tree decl; ! 160: tree type = TREE_TYPE (member); ! 161: ! 162: if (TYPE_NEEDS_CONSTRUCTING (type) ! 163: || (init && TYPE_HAS_CONSTRUCTOR (type))) ! 164: { ! 165: /* Since `init' is already a TREE_LIST on the current_member_init_list, ! 166: only build it into one if we aren't already a list. */ ! 167: if (init != NULL_TREE && TREE_CODE (init) != TREE_LIST) ! 168: init = build_tree_list (NULL_TREE, init); ! 169: ! 170: decl = build_component_ref (C_C_D, name, 0, explicit); ! 171: ! 172: if (explicit ! 173: && TREE_CODE (type) == ARRAY_TYPE ! 174: && init != NULL_TREE ! 175: && TREE_CHAIN (init) == NULL_TREE ! 176: && TREE_CODE (TREE_TYPE (TREE_VALUE (init))) == ARRAY_TYPE) ! 177: { ! 178: /* Initialization of one array from another. */ ! 179: expand_vec_init (TREE_OPERAND (decl, 1), decl, ! 180: array_type_nelts (type), TREE_VALUE (init), 1); ! 181: } ! 182: else ! 183: expand_aggr_init (decl, init, 0); ! 184: } ! 185: else ! 186: { ! 187: if (init == NULL_TREE) ! 188: { ! 189: if (explicit) ! 190: { ! 191: cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor", ! 192: member, current_class_type); ! 193: init = error_mark_node; ! 194: } ! 195: /* member traversal: note it leaves init NULL */ ! 196: else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE) ! 197: cp_pedwarn ("uninitialized reference member `%D'", member); ! 198: } ! 199: else if (TREE_CODE (init) == TREE_LIST) ! 200: { ! 201: /* There was an explicit member initialization. Do some ! 202: work in that case. */ ! 203: if (TREE_CHAIN (init)) ! 204: { ! 205: warning ("initializer list treated as compound expression"); ! 206: init = build_compound_expr (init); ! 207: } ! 208: else ! 209: init = TREE_VALUE (init); ! 210: } ! 211: ! 212: /* We only build this with a null init if we got it from the ! 213: current_member_init_list. */ ! 214: if (init || explicit) ! 215: { ! 216: decl = build_component_ref (C_C_D, name, 0, explicit); ! 217: expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init)); ! 218: } ! 219: } ! 220: expand_cleanups_to (NULL_TREE); ! 221: if (flag_handle_exceptions && TYPE_NEEDS_DESTRUCTOR (type)) ! 222: cp_warning ("caution, member `%D' may not be destroyed in the presense of an exception during construction", member); ! 223: } ! 224: ! 225: /* Subroutine of emit_member_init. */ ! 226: static tree ! 227: sort_member_init (t) ! 228: tree t; ! 229: { ! 230: extern int warn_reorder; ! 231: tree x, member, name, field, init; ! 232: tree init_list = NULL_TREE; ! 233: tree fields_to_unmark = NULL_TREE; ! 234: int found; ! 235: int last_pos = 0; ! 236: tree last_field; ! 237: ! 238: for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member)) ! 239: { ! 240: int pos; ! 241: found = 0; ! 242: for (x = current_member_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos) ! 243: { ! 244: /* If we cleared this out, then pay no attention to it. */ ! 245: if (TREE_PURPOSE (x) == NULL_TREE) ! 246: continue; ! 247: name = TREE_PURPOSE (x); ! 248: ! 249: #if 0 ! 250: field = (TREE_CODE (name) == COMPONENT_REF ! 251: ? TREE_OPERAND (name, 1) : IDENTIFIER_CLASS_VALUE (name)); ! 252: #else ! 253: /* Let's find out when this happens. */ ! 254: my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 348); ! 255: field = IDENTIFIER_CLASS_VALUE (name); ! 256: #endif ! 257: ! 258: /* If one member shadows another, get the outermost one. */ ! 259: if (TREE_CODE (field) == TREE_LIST) ! 260: field = TREE_VALUE (field); ! 261: ! 262: if (field == member) ! 263: { ! 264: /* See if we already found an initializer for this field. */ ! 265: if (found) ! 266: { ! 267: if (DECL_NAME (field)) ! 268: cp_error ("multiple initializations given for member `%D'", ! 269: field); ! 270: continue; ! 271: } ! 272: else ! 273: { ! 274: if (pos < last_pos && warn_reorder) ! 275: { ! 276: cp_warning_at ("member initializers for `%#D'", last_field); ! 277: cp_warning_at (" and `%#D'", field); ! 278: warning (" will be re-ordered to match declaration order"); ! 279: } ! 280: last_pos = pos; ! 281: last_field = field; ! 282: } ! 283: ! 284: init_list = chainon (init_list, ! 285: build_tree_list (name, TREE_VALUE (x))); ! 286: /* Make sure we won't try to work on this init again. */ ! 287: TREE_PURPOSE (x) = NULL_TREE; ! 288: found = 1; ! 289: break; ! 290: } ! 291: } ! 292: ! 293: /* If we didn't find MEMBER in the list, create a dummy entry ! 294: so the two lists (INIT_LIST and the list of members) will be ! 295: symmetrical. */ ! 296: if (! found) ! 297: init_list = chainon (init_list, build_tree_list (NULL_TREE, NULL_TREE)); ! 298: } ! 299: ! 300: for (x = current_member_init_list ; x ; x = TREE_CHAIN (x)) ! 301: { ! 302: if (TREE_PURPOSE (x)) ! 303: { ! 304: name = TREE_PURPOSE (x); ! 305: init = TREE_VALUE (x); ! 306: /* XXX: this may need the COMPONENT_REF operand 0 check if ! 307: it turns out we actually get them. */ ! 308: field = IDENTIFIER_CLASS_VALUE (name); ! 309: ! 310: /* If one member shadows another, get the outermost one. */ ! 311: if (TREE_CODE (field) == TREE_LIST) ! 312: { ! 313: field = TREE_VALUE (field); ! 314: if (decl_type_context (field) != current_class_type) ! 315: cp_error ("field `%D' not in immediate context", field); ! 316: } ! 317: ! 318: #if 0 ! 319: /* It turns out if you have an anonymous union in the ! 320: class, a member from it can end up not being on the ! 321: list of fields (rather, the type is), and therefore ! 322: won't be seen by the for loop above. */ ! 323: ! 324: /* The code in this for loop is derived from a general loop ! 325: which had this check in it. Theoretically, we've hit ! 326: every initialization for the list of members in T, so ! 327: we shouldn't have anything but these left in this list. */ ! 328: my_friendly_assert (DECL_FIELD_CONTEXT (field) != t, 351); ! 329: #endif ! 330: ! 331: if (TREE_HAS_CONSTRUCTOR (field)) ! 332: { ! 333: if (DECL_NAME (field)) ! 334: error ("multiple initializations given for member `%s'", ! 335: IDENTIFIER_POINTER (DECL_NAME (field))); ! 336: continue; ! 337: } ! 338: ! 339: TREE_HAS_CONSTRUCTOR (field) = 1; ! 340: fields_to_unmark = tree_cons (NULL_TREE, field, fields_to_unmark); ! 341: ! 342: perform_member_init (field, name, init, 1); ! 343: TREE_PURPOSE (x) = NULL_TREE; ! 344: } ! 345: } ! 346: ! 347: /* Unmark fields which are initialized for the base class. */ ! 348: while (fields_to_unmark) ! 349: { ! 350: TREE_HAS_CONSTRUCTOR (TREE_VALUE (fields_to_unmark)) = 0; ! 351: /* XXX is this a memory leak? */ ! 352: fields_to_unmark = TREE_CHAIN (fields_to_unmark); ! 353: } ! 354: ! 355: return init_list; ! 356: } ! 357: ! 358: /* Perform whatever initializations have yet to be done on the base ! 359: class of the class variable. These actions are in the global ! 360: variable CURRENT_BASE_INIT_LIST. Such an action could be ! 361: NULL_TREE, meaning that the user has explicitly called the base ! 362: class constructor with no arguments. ! 363: ! 364: If there is a need for a call to a constructor, we must surround ! 365: that call with a pushlevel/poplevel pair, since we are technically ! 366: at the PARM level of scope. ! 367: ! 368: Argument IMMEDIATELY, if zero, forces a new sequence to be ! 369: generated to contain these new insns, so it can be emitted later. ! 370: This sequence is saved in the global variable BASE_INIT_INSNS. ! 371: Otherwise, the insns are emitted into the current sequence. ! 372: ! 373: Note that emit_base_init does *not* initialize virtual base ! 374: classes. That is done specially, elsewhere. */ ! 375: ! 376: void ! 377: emit_base_init (t, immediately) ! 378: tree t; ! 379: int immediately; ! 380: { ! 381: extern tree in_charge_identifier; ! 382: ! 383: tree member, vbases; ! 384: tree init_list; ! 385: int pass, start; ! 386: tree t_binfo = TYPE_BINFO (t); ! 387: tree binfos = BINFO_BASETYPES (t_binfo); ! 388: int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; ! 389: int have_init_list = 0, from_init_list; ! 390: ! 391: if (! immediately) ! 392: { ! 393: do_pending_stack_adjust (); ! 394: start_sequence (); ! 395: } ! 396: ! 397: if (write_symbols == NO_DEBUG) ! 398: /* As a matter of principle, `start_sequence' should do this. */ ! 399: emit_note (0, -1); ! 400: else ! 401: /* Always emit a line number note so we can step into constructors. */ ! 402: emit_line_note_force (DECL_SOURCE_FILE (current_function_decl), ! 403: DECL_SOURCE_LINE (current_function_decl)); ! 404: ! 405: start = ! TYPE_USES_VIRTUAL_BASECLASSES (t); ! 406: for (pass = start; pass < 2; pass++) ! 407: { ! 408: tree vbase_init_list = NULL_TREE; ! 409: ! 410: for (init_list = current_base_init_list; init_list; ! 411: init_list = TREE_CHAIN (init_list)) ! 412: { ! 413: tree basename = TREE_PURPOSE (init_list); ! 414: tree binfo; ! 415: tree init = TREE_VALUE (init_list); ! 416: ! 417: if (basename == NULL_TREE) ! 418: { ! 419: /* Initializer for single base class. Must not ! 420: use multiple inheritance or this is ambiguous. */ ! 421: switch (n_baseclasses) ! 422: { ! 423: case 0: ! 424: error ("type `%s' does not have a base class to initialize", ! 425: IDENTIFIER_POINTER (current_class_name)); ! 426: return; ! 427: case 1: ! 428: break; ! 429: default: ! 430: error ("unnamed initializer ambiguous for type `%s' which uses multiple inheritance", IDENTIFIER_POINTER (current_class_name)); ! 431: return; ! 432: } ! 433: binfo = TREE_VEC_ELT (binfos, 0); ! 434: } ! 435: else if (is_aggr_typedef (basename, 1)) ! 436: { ! 437: binfo = binfo_or_else (IDENTIFIER_TYPE_VALUE (basename), t); ! 438: if (binfo == NULL_TREE) ! 439: continue; ! 440: ! 441: /* Virtual base classes are special cases. Their initializers ! 442: are recorded with this constructor, and they are used when ! 443: this constructor is the top-level constructor called. */ ! 444: if (! TREE_VIA_VIRTUAL (binfo)) ! 445: { ! 446: /* Otherwise, if it is not an immediate base class, complain. */ ! 447: for (i = n_baseclasses-1; i >= 0; i--) ! 448: if (BINFO_TYPE (binfo) == BINFO_TYPE (TREE_VEC_ELT (binfos, i))) ! 449: break; ! 450: if (i < 0) ! 451: { ! 452: error ("type `%s' is not an immediate base class of type `%s'", ! 453: IDENTIFIER_POINTER (basename), ! 454: IDENTIFIER_POINTER (current_class_name)); ! 455: continue; ! 456: } ! 457: } ! 458: } ! 459: else ! 460: continue; ! 461: ! 462: /* The base initialization list goes up to the first ! 463: base class which can actually use it. */ ! 464: ! 465: if (pass == start) ! 466: { ! 467: char *msgp = (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo))) ! 468: ? "cannot pass initialization up to class `%s'" : 0; ! 469: ! 470: while (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo)) ! 471: && BINFO_BASETYPES (binfo) != NULL_TREE ! 472: && TREE_VEC_LENGTH (BINFO_BASETYPES (binfo)) == 1) ! 473: { ! 474: /* ?? This should be fixed in RENO by forcing ! 475: default constructors to exist. */ ! 476: SET_BINFO_BASEINIT_MARKED (binfo); ! 477: binfo = BINFO_BASETYPE (binfo, 0); ! 478: } ! 479: ! 480: /* We used to give an error if this wasn't true, saying that ! 481: there's no constructor for the initialization of basename. ! 482: This turned out to be incorrect---it should use the ! 483: default constructor, since a user could try to initialize ! 484: the class in a derived class's base initializer list. */ ! 485: if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (binfo))) ! 486: { ! 487: if (msgp) ! 488: { ! 489: if (pedantic) ! 490: error_with_aggr_type (binfo, msgp); ! 491: else ! 492: msgp = NULL; ! 493: } ! 494: } ! 495: ! 496: if (BINFO_BASEINIT_MARKED (binfo)) ! 497: { ! 498: msgp = "class `%s' initializer already specified"; ! 499: error (msgp, IDENTIFIER_POINTER (basename)); ! 500: } ! 501: ! 502: if (msgp) ! 503: continue; ! 504: ! 505: SET_BINFO_BASEINIT_MARKED (binfo); ! 506: if (TREE_VIA_VIRTUAL (binfo)) ! 507: { ! 508: vbase_init_list = tree_cons (init, BINFO_TYPE (binfo), ! 509: vbase_init_list); ! 510: continue; ! 511: } ! 512: if (pass == 0) ! 513: continue; ! 514: } ! 515: else if (TREE_VIA_VIRTUAL (binfo)) ! 516: continue; ! 517: ! 518: member = convert_pointer_to (binfo, current_class_decl); ! 519: expand_aggr_init_1 (binfo, 0, ! 520: build_indirect_ref (member, NULL_PTR), init, ! 521: BINFO_OFFSET_ZEROP (binfo), LOOKUP_NORMAL); ! 522: expand_cleanups_to (NULL_TREE); ! 523: } ! 524: ! 525: if (pass == 0) ! 526: { ! 527: tree first_arg = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)); ! 528: tree vbases; ! 529: ! 530: if (DECL_NAME (current_function_decl) == NULL_TREE ! 531: && TREE_CHAIN (first_arg) != NULL_TREE) ! 532: { ! 533: /* If there are virtual baseclasses without initialization ! 534: specified, and this is a default X(X&) constructor, ! 535: build the initialization list so that each virtual baseclass ! 536: of the new object is initialized from the virtual baseclass ! 537: of the incoming arg. */ ! 538: tree init_arg = build_unary_op (ADDR_EXPR, TREE_CHAIN (first_arg), 0); ! 539: for (vbases = CLASSTYPE_VBASECLASSES (t); ! 540: vbases; vbases = TREE_CHAIN (vbases)) ! 541: { ! 542: if (BINFO_BASEINIT_MARKED (vbases) == 0) ! 543: { ! 544: member = convert_pointer_to (vbases, init_arg); ! 545: if (member == init_arg) ! 546: member = TREE_CHAIN (first_arg); ! 547: else ! 548: TREE_TYPE (member) = build_reference_type (BINFO_TYPE (vbases)); ! 549: vbase_init_list = tree_cons (convert_from_reference (member), ! 550: vbases, vbase_init_list); ! 551: SET_BINFO_BASEINIT_MARKED (vbases); ! 552: } ! 553: } ! 554: } ! 555: expand_start_cond (first_arg, 0); ! 556: expand_aggr_vbase_init (t_binfo, C_C_D, current_class_decl, ! 557: vbase_init_list); ! 558: expand_end_cond (); ! 559: } ! 560: } ! 561: current_base_init_list = NULL_TREE; ! 562: ! 563: /* Now, perform default initialization of all base classes which ! 564: have not yet been initialized, and unmark baseclasses which ! 565: have been initialized. */ ! 566: for (i = 0; i < n_baseclasses; i++) ! 567: { ! 568: tree base = current_class_decl; ! 569: tree base_binfo = TREE_VEC_ELT (binfos, i); ! 570: ! 571: if (TYPE_NEEDS_CONSTRUCTING (BINFO_TYPE (base_binfo))) ! 572: { ! 573: if (! TREE_VIA_VIRTUAL (base_binfo) ! 574: && ! BINFO_BASEINIT_MARKED (base_binfo)) ! 575: { ! 576: tree ref; ! 577: ! 578: if (BINFO_OFFSET_ZEROP (base_binfo)) ! 579: base = build1 (NOP_EXPR, ! 580: TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), ! 581: current_class_decl); ! 582: else ! 583: base = build (PLUS_EXPR, ! 584: TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), ! 585: current_class_decl, BINFO_OFFSET (base_binfo)); ! 586: ! 587: ref = build_indirect_ref (base, NULL_PTR); ! 588: expand_aggr_init_1 (base_binfo, 0, ref, NULL_TREE, ! 589: BINFO_OFFSET_ZEROP (base_binfo), ! 590: LOOKUP_NORMAL); ! 591: expand_cleanups_to (NULL_TREE); ! 592: } ! 593: } ! 594: CLEAR_BINFO_BASEINIT_MARKED (base_binfo); ! 595: ! 596: if (! TYPE_USES_VIRTUAL_BASECLASSES (t)) ! 597: { ! 598: while (! TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo)) ! 599: && BINFO_BASETYPES (base_binfo) != NULL_TREE ! 600: && TREE_VEC_LENGTH (BINFO_BASETYPES (base_binfo)) == 1) ! 601: { ! 602: /* ?? This should be fixed in RENO by forcing ! 603: default constructors to exist. It is needed for symmetry ! 604: with code above. */ ! 605: base_binfo = BINFO_BASETYPE (base_binfo, 0); ! 606: CLEAR_BINFO_BASEINIT_MARKED (base_binfo); ! 607: } ! 608: } ! 609: } ! 610: ! 611: /* Initialize all the virtual function table fields that ! 612: do come from virtual base classes. */ ! 613: if (TYPE_USES_VIRTUAL_BASECLASSES (t)) ! 614: expand_indirect_vtbls_init (t_binfo, C_C_D, current_class_decl, 0); ! 615: for (vbases = CLASSTYPE_VBASECLASSES (t); vbases; vbases = TREE_CHAIN (vbases)) ! 616: CLEAR_BINFO_BASEINIT_MARKED (vbases); ! 617: ! 618: /* Initialize all the virtual function table fields that ! 619: do not come from virtual base classes. */ ! 620: expand_direct_vtbls_init (t_binfo, t_binfo, 1, 1, current_class_decl); ! 621: ! 622: if (current_member_init_list) ! 623: { ! 624: init_list = sort_member_init (t); ! 625: have_init_list = 1; ! 626: } ! 627: ! 628: for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member)) ! 629: { ! 630: tree init, name; ! 631: from_init_list = 0; ! 632: ! 633: /* See if we had a user-specified member initialization. */ ! 634: if (have_init_list) ! 635: { ! 636: if (TREE_PURPOSE (init_list)) ! 637: { ! 638: name = TREE_PURPOSE (init_list); ! 639: init = TREE_VALUE (init_list); ! 640: from_init_list = 1; ! 641: ! 642: if (TREE_STATIC (member)) ! 643: { ! 644: error_with_aggr_type (DECL_FIELD_CONTEXT (member), ! 645: "field `%s::%s' is static; only point of initialization is its declaration", ! 646: IDENTIFIER_POINTER (TREE_PURPOSE (init_list))); ! 647: continue; ! 648: } ! 649: ! 650: /* Also see if it's ever a COMPONENT_REF here. If it is, we ! 651: need to do `expand_assignment (name, init, 0, 0);' and ! 652: a continue. */ ! 653: my_friendly_assert (TREE_CODE (name) != COMPONENT_REF, 349); ! 654: } ! 655: ! 656: init_list = TREE_CHAIN (init_list); ! 657: } ! 658: ! 659: if (! from_init_list) ! 660: { ! 661: /* member could be, for example, a CONST_DECL for an enumerated ! 662: tag; we don't want to try to initialize that, since it already ! 663: has a value. */ ! 664: if (TREE_CODE (member) != FIELD_DECL || !DECL_NAME (member)) ! 665: continue; ! 666: ! 667: name = DECL_NAME (member); ! 668: init = DECL_INITIAL (member); ! 669: } ! 670: ! 671: perform_member_init (member, name, init, from_init_list); ! 672: } ! 673: ! 674: current_member_init_list = NULL_TREE; ! 675: ! 676: if (! immediately) ! 677: { ! 678: extern rtx base_init_insns; ! 679: ! 680: do_pending_stack_adjust (); ! 681: my_friendly_assert (base_init_insns == 0, 207); ! 682: base_init_insns = get_insns (); ! 683: end_sequence (); ! 684: } ! 685: ! 686: /* All the implicit try blocks we built up will be zapped ! 687: when we come to a real binding contour boundary. */ ! 688: } ! 689: ! 690: /* Check that all fields are properly initialized after ! 691: an assignment to `this'. */ ! 692: void ! 693: check_base_init (t) ! 694: tree t; ! 695: { ! 696: tree member; ! 697: for (member = TYPE_FIELDS (t); member; member = TREE_CHAIN (member)) ! 698: if (DECL_NAME (member) && TREE_USED (member)) ! 699: cp_error ("field `%D' used before initialized (after assignment to `this')", ! 700: member); ! 701: } ! 702: ! 703: /* This code sets up the virtual function tables appropriate for ! 704: the pointer DECL. It is a one-ply initialization. ! 705: ! 706: BINFO is the exact type that DECL is supposed to be. In ! 707: multiple inheritance, this might mean "C's A" if C : A, B. */ ! 708: static void ! 709: expand_virtual_init (binfo, decl) ! 710: tree binfo, decl; ! 711: { ! 712: tree type = BINFO_TYPE (binfo); ! 713: tree vtbl, vtbl_ptr; ! 714: tree vtype, vtype_binfo; ! 715: ! 716: /* This code is crusty. Should be simple, like: ! 717: vtbl = BINFO_VTABLE (binfo); ! 718: */ ! 719: vtype = DECL_CONTEXT (CLASSTYPE_VFIELD (type)); ! 720: vtype_binfo = get_binfo (vtype, TREE_TYPE (TREE_TYPE (decl)), 0); ! 721: vtbl = BINFO_VTABLE (binfo_value (DECL_FIELD_CONTEXT (CLASSTYPE_VFIELD (type)), binfo)); ! 722: if (!flag_vtable_thunks) ! 723: assemble_external (vtbl); ! 724: TREE_USED (vtbl) = 1; ! 725: vtbl = build1 (ADDR_EXPR, TYPE_POINTER_TO (TREE_TYPE (vtbl)), vtbl); ! 726: decl = convert_pointer_to_real (vtype_binfo, decl); ! 727: vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL_PTR), vtype); ! 728: if (vtbl_ptr == error_mark_node) ! 729: return; ! 730: ! 731: /* Have to convert VTBL since array sizes may be different. */ ! 732: vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl); ! 733: expand_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl)); ! 734: } ! 735: ! 736: /* Subroutine of `expand_aggr_vbase_init'. ! 737: BINFO is the binfo of the type that is being initialized. ! 738: INIT_LIST is the list of initializers for the virtual baseclass. */ ! 739: static void ! 740: expand_aggr_vbase_init_1 (binfo, exp, addr, init_list) ! 741: tree binfo, exp, addr, init_list; ! 742: { ! 743: tree init = value_member (BINFO_TYPE (binfo), init_list); ! 744: tree ref = build_indirect_ref (addr, NULL_PTR); ! 745: if (init) ! 746: init = TREE_PURPOSE (init); ! 747: /* Call constructors, but don't set up vtables. */ ! 748: expand_aggr_init_1 (binfo, exp, ref, init, 0, ! 749: LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY); ! 750: expand_cleanups_to (NULL_TREE); ! 751: CLEAR_BINFO_VBASE_INIT_MARKED (binfo); ! 752: } ! 753: ! 754: /* Initialize this object's virtual base class pointers. This must be ! 755: done only at the top-level of the object being constructed. ! 756: ! 757: INIT_LIST is list of initialization for constructor to perform. */ ! 758: static void ! 759: expand_aggr_vbase_init (binfo, exp, addr, init_list) ! 760: tree binfo; ! 761: tree exp; ! 762: tree addr; ! 763: tree init_list; ! 764: { ! 765: tree type = BINFO_TYPE (binfo); ! 766: ! 767: if (TYPE_USES_VIRTUAL_BASECLASSES (type)) ! 768: { ! 769: tree result = init_vbase_pointers (type, addr); ! 770: tree vbases; ! 771: ! 772: if (result) ! 773: expand_expr_stmt (build_compound_expr (result)); ! 774: ! 775: /* Mark everything as having an initializer ! 776: (either explicit or default). */ ! 777: for (vbases = CLASSTYPE_VBASECLASSES (type); ! 778: vbases; vbases = TREE_CHAIN (vbases)) ! 779: SET_BINFO_VBASE_INIT_MARKED (vbases); ! 780: ! 781: /* First, initialize baseclasses which could be baseclasses ! 782: for other virtual baseclasses. */ ! 783: for (vbases = CLASSTYPE_VBASECLASSES (type); ! 784: vbases; vbases = TREE_CHAIN (vbases)) ! 785: /* Don't initialize twice. */ ! 786: if (BINFO_VBASE_INIT_MARKED (vbases)) ! 787: { ! 788: tree tmp = result; ! 789: ! 790: while (BINFO_TYPE (vbases) != BINFO_TYPE (TREE_PURPOSE (tmp))) ! 791: tmp = TREE_CHAIN (tmp); ! 792: expand_aggr_vbase_init_1 (vbases, exp, ! 793: TREE_OPERAND (TREE_VALUE (tmp), 0), ! 794: init_list); ! 795: } ! 796: ! 797: /* Now initialize the baseclasses which don't have virtual baseclasses. */ ! 798: for (; result; result = TREE_CHAIN (result)) ! 799: /* Don't initialize twice. */ ! 800: if (BINFO_VBASE_INIT_MARKED (TREE_PURPOSE (result))) ! 801: { ! 802: my_friendly_abort (47); ! 803: expand_aggr_vbase_init_1 (TREE_PURPOSE (result), exp, ! 804: TREE_OPERAND (TREE_VALUE (result), 0), ! 805: init_list); ! 806: } ! 807: } ! 808: } ! 809: ! 810: /* Subroutine to perform parser actions for member initialization. ! 811: S_ID is the scoped identifier. ! 812: NAME is the name of the member. ! 813: INIT is the initializer, or `void_type_node' if none. */ ! 814: void ! 815: do_member_init (s_id, name, init) ! 816: tree s_id, name, init; ! 817: { ! 818: tree binfo, base; ! 819: ! 820: if (current_class_type == NULL_TREE ! 821: || ! is_aggr_typedef (s_id, 1)) ! 822: return; ! 823: binfo = get_binfo (IDENTIFIER_TYPE_VALUE (s_id), ! 824: current_class_type, 1); ! 825: if (binfo == error_mark_node) ! 826: return; ! 827: if (binfo == 0) ! 828: { ! 829: error_not_base_type (IDENTIFIER_TYPE_VALUE (s_id), current_class_type); ! 830: return; ! 831: } ! 832: ! 833: base = convert_pointer_to (binfo, current_class_decl); ! 834: expand_member_init (build_indirect_ref (base, NULL_PTR), name, init); ! 835: } ! 836: ! 837: /* Function to give error message if member initialization specification ! 838: is erroneous. FIELD is the member we decided to initialize. ! 839: TYPE is the type for which the initialization is being performed. ! 840: FIELD must be a member of TYPE, or the base type from which FIELD ! 841: comes must not need a constructor. ! 842: ! 843: MEMBER_NAME is the name of the member. */ ! 844: ! 845: static int ! 846: member_init_ok_or_else (field, type, member_name) ! 847: tree field; ! 848: tree type; ! 849: char *member_name; ! 850: { ! 851: if (field == error_mark_node) ! 852: return 0; ! 853: if (field == NULL_TREE) ! 854: { ! 855: cp_error ("class `%T' does not have any field named `%s'", type, ! 856: member_name); ! 857: return 0; ! 858: } ! 859: if (DECL_CONTEXT (field) != type ! 860: && TYPE_NEEDS_CONSTRUCTING (DECL_CONTEXT (field))) ! 861: { ! 862: cp_error ("member `%D' comes from base class needing constructor", ! 863: field); ! 864: return 0; ! 865: } ! 866: return 1; ! 867: } ! 868: ! 869: /* If NAME is a viable field name for the aggregate DECL, ! 870: and PARMS is a viable parameter list, then expand an _EXPR ! 871: which describes this initialization. ! 872: ! 873: Note that we do not need to chase through the class's base classes ! 874: to look for NAME, because if it's in that list, it will be handled ! 875: by the constructor for that base class. ! 876: ! 877: We do not yet have a fixed-point finder to instantiate types ! 878: being fed to overloaded constructors. If there is a unique ! 879: constructor, then argument types can be got from that one. ! 880: ! 881: If INIT is non-NULL, then it the initialization should ! 882: be placed in `current_base_init_list', where it will be processed ! 883: by `emit_base_init'. */ ! 884: void ! 885: expand_member_init (exp, name, init) ! 886: tree exp, name, init; ! 887: { ! 888: extern tree ptr_type_node; /* should be in tree.h */ ! 889: ! 890: tree basetype = NULL_TREE, field; ! 891: tree parm; ! 892: tree rval, type; ! 893: tree actual_name; ! 894: ! 895: if (exp == NULL_TREE) ! 896: return; /* complain about this later */ ! 897: ! 898: type = TYPE_MAIN_VARIANT (TREE_TYPE (exp)); ! 899: ! 900: if (name == NULL_TREE && IS_AGGR_TYPE (type)) ! 901: switch (CLASSTYPE_N_BASECLASSES (type)) ! 902: { ! 903: case 0: ! 904: error ("base class initializer specified, but no base class to initialize"); ! 905: return; ! 906: case 1: ! 907: basetype = TYPE_BINFO_BASETYPE (type, 0); ! 908: break; ! 909: default: ! 910: error ("initializer for unnamed base class ambiguous"); ! 911: cp_error ("(type `%T' uses multiple inheritance)", type); ! 912: return; ! 913: } ! 914: ! 915: if (init) ! 916: { ! 917: /* The grammar should not allow fields which have names ! 918: that are TYPENAMEs. Therefore, if the field has ! 919: a non-NULL TREE_TYPE, we may assume that this is an ! 920: attempt to initialize a base class member of the current ! 921: type. Otherwise, it is an attempt to initialize a ! 922: member field. */ ! 923: ! 924: if (init == void_type_node) ! 925: init = NULL_TREE; ! 926: ! 927: if (name == NULL_TREE || IDENTIFIER_HAS_TYPE_VALUE (name)) ! 928: { ! 929: tree base_init; ! 930: ! 931: if (name == NULL_TREE) ! 932: { ! 933: /* ! 934: if (basetype) ! 935: name = TYPE_IDENTIFIER (basetype); ! 936: else ! 937: { ! 938: error ("no base class to initialize"); ! 939: return; ! 940: } ! 941: */ ! 942: } ! 943: else ! 944: { ! 945: basetype = IDENTIFIER_TYPE_VALUE (name); ! 946: if (basetype != type ! 947: && ! binfo_member (basetype, TYPE_BINFO (type)) ! 948: && ! binfo_member (basetype, CLASSTYPE_VBASECLASSES (type))) ! 949: { ! 950: if (IDENTIFIER_CLASS_VALUE (name)) ! 951: goto try_member; ! 952: if (TYPE_USES_VIRTUAL_BASECLASSES (type)) ! 953: error ("type `%s' is not an immediate or virtual basetype for `%s'", ! 954: IDENTIFIER_POINTER (name), ! 955: TYPE_NAME_STRING (type)); ! 956: else ! 957: error ("type `%s' is not an immediate basetype for `%s'", ! 958: IDENTIFIER_POINTER (name), ! 959: TYPE_NAME_STRING (type)); ! 960: return; ! 961: } ! 962: } ! 963: ! 964: if (purpose_member (name, current_base_init_list)) ! 965: { ! 966: error ("base class `%s' already initialized", ! 967: IDENTIFIER_POINTER (name)); ! 968: return; ! 969: } ! 970: ! 971: base_init = build_tree_list (name, init); ! 972: TREE_TYPE (base_init) = basetype; ! 973: current_base_init_list = chainon (current_base_init_list, base_init); ! 974: } ! 975: else ! 976: { ! 977: tree member_init; ! 978: ! 979: try_member: ! 980: field = lookup_field (type, name, 1, 0); ! 981: ! 982: if (! member_init_ok_or_else (field, type, IDENTIFIER_POINTER (name))) ! 983: return; ! 984: ! 985: if (purpose_member (name, current_member_init_list)) ! 986: { ! 987: error ("field `%s' already initialized", IDENTIFIER_POINTER (name)); ! 988: return; ! 989: } ! 990: ! 991: member_init = build_tree_list (name, init); ! 992: TREE_TYPE (member_init) = TREE_TYPE (field); ! 993: current_member_init_list = chainon (current_member_init_list, member_init); ! 994: } ! 995: return; ! 996: } ! 997: else if (name == NULL_TREE) ! 998: { ! 999: compiler_error ("expand_member_init: name == NULL_TREE"); ! 1000: return; ! 1001: } ! 1002: ! 1003: basetype = type; ! 1004: field = lookup_field (basetype, name, 0, 0); ! 1005: ! 1006: if (! member_init_ok_or_else (field, basetype, IDENTIFIER_POINTER (name))) ! 1007: return; ! 1008: ! 1009: /* now see if there is a constructor for this type ! 1010: which will take these args. */ ! 1011: ! 1012: if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (field))) ! 1013: { ! 1014: tree parmtypes, fndecl; ! 1015: ! 1016: if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL) ! 1017: { ! 1018: /* just know that we've seen something for this node */ ! 1019: DECL_INITIAL (exp) = error_mark_node; ! 1020: TREE_USED (exp) = 1; ! 1021: } ! 1022: type = TYPE_MAIN_VARIANT (TREE_TYPE (field)); ! 1023: actual_name = TYPE_IDENTIFIER (type); ! 1024: parm = build_component_ref (exp, name, 0, 0); ! 1025: ! 1026: /* Now get to the constructor. */ ! 1027: fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0); ! 1028: /* Get past destructor, if any. */ ! 1029: if (TYPE_HAS_DESTRUCTOR (type)) ! 1030: fndecl = DECL_CHAIN (fndecl); ! 1031: ! 1032: if (fndecl) ! 1033: my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 209); ! 1034: ! 1035: /* If the field is unique, we can use the parameter ! 1036: types to guide possible type instantiation. */ ! 1037: if (DECL_CHAIN (fndecl) == NULL_TREE) ! 1038: { ! 1039: /* There was a confusion here between ! 1040: FIELD and FNDECL. The following code ! 1041: should be correct, but abort is here ! 1042: to make sure. */ ! 1043: my_friendly_abort (48); ! 1044: parmtypes = FUNCTION_ARG_CHAIN (fndecl); ! 1045: } ! 1046: else ! 1047: { ! 1048: parmtypes = NULL_TREE; ! 1049: fndecl = NULL_TREE; ! 1050: } ! 1051: ! 1052: init = convert_arguments (parm, parmtypes, NULL_TREE, fndecl, LOOKUP_NORMAL); ! 1053: if (init == NULL_TREE || TREE_TYPE (init) != error_mark_node) ! 1054: rval = build_method_call (NULL_TREE, actual_name, init, NULL_TREE, LOOKUP_NORMAL); ! 1055: else ! 1056: return; ! 1057: ! 1058: if (rval != error_mark_node) ! 1059: { ! 1060: /* Now, fill in the first parm with our guy */ ! 1061: TREE_VALUE (TREE_OPERAND (rval, 1)) ! 1062: = build_unary_op (ADDR_EXPR, parm, 0); ! 1063: TREE_TYPE (rval) = ptr_type_node; ! 1064: TREE_SIDE_EFFECTS (rval) = 1; ! 1065: } ! 1066: } ! 1067: else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field))) ! 1068: { ! 1069: parm = build_component_ref (exp, name, 0, 0); ! 1070: expand_aggr_init (parm, NULL_TREE, 0); ! 1071: rval = error_mark_node; ! 1072: } ! 1073: ! 1074: /* Now initialize the member. It does not have to ! 1075: be of aggregate type to receive initialization. */ ! 1076: if (rval != error_mark_node) ! 1077: expand_expr_stmt (rval); ! 1078: } ! 1079: ! 1080: /* This is like `expand_member_init', only it stores one aggregate ! 1081: value into another. ! 1082: ! 1083: INIT comes in two flavors: it is either a value which ! 1084: is to be stored in EXP, or it is a parameter list ! 1085: to go to a constructor, which will operate on EXP. ! 1086: If `init' is a CONSTRUCTOR, then we emit a warning message, ! 1087: explaining that such initializations are illegal. ! 1088: ! 1089: ALIAS_THIS is nonzero iff we are initializing something which is ! 1090: essentially an alias for C_C_D. In this case, the base constructor ! 1091: may move it on us, and we must keep track of such deviations. ! 1092: ! 1093: If INIT resolves to a CALL_EXPR which happens to return ! 1094: something of the type we are looking for, then we know ! 1095: that we can safely use that call to perform the ! 1096: initialization. ! 1097: ! 1098: The virtual function table pointer cannot be set up here, because ! 1099: we do not really know its type. ! 1100: ! 1101: Virtual baseclass pointers are also set up here. ! 1102: ! 1103: This never calls operator=(). ! 1104: ! 1105: When initializing, nothing is CONST. ! 1106: ! 1107: A default copy constructor may have to be used to perform the ! 1108: initialization. ! 1109: ! 1110: A constructor or a conversion operator may have to be used to ! 1111: perform the initialization, but not both, as it would be ambiguous. ! 1112: */ ! 1113: ! 1114: void ! 1115: expand_aggr_init (exp, init, alias_this) ! 1116: tree exp, init; ! 1117: int alias_this; ! 1118: { ! 1119: tree type = TREE_TYPE (exp); ! 1120: int was_const = TREE_READONLY (exp); ! 1121: ! 1122: if (init == error_mark_node) ! 1123: return; ! 1124: ! 1125: TREE_READONLY (exp) = 0; ! 1126: ! 1127: if (TREE_CODE (type) == ARRAY_TYPE) ! 1128: { ! 1129: /* Must arrange to initialize each element of EXP ! 1130: from elements of INIT. */ ! 1131: int was_const_elts = TYPE_READONLY (TREE_TYPE (type)); ! 1132: tree itype = init ? TREE_TYPE (init) : NULL_TREE; ! 1133: if (was_const_elts) ! 1134: { ! 1135: TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type); ! 1136: if (init) ! 1137: TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype); ! 1138: } ! 1139: if (init && TREE_TYPE (init) == NULL_TREE) ! 1140: { ! 1141: /* Handle bad initializers like: ! 1142: class COMPLEX { ! 1143: public: ! 1144: double re, im; ! 1145: COMPLEX(double r = 0.0, double i = 0.0) {re = r; im = i;}; ! 1146: ~COMPLEX() {}; ! 1147: }; ! 1148: ! 1149: int main(int argc, char **argv) { ! 1150: COMPLEX zees(1.0, 0.0)[10]; ! 1151: } ! 1152: */ ! 1153: error ("bad array initializer"); ! 1154: return; ! 1155: } ! 1156: expand_vec_init (exp, exp, array_type_nelts (type), init, ! 1157: init && comptypes (TREE_TYPE (init), TREE_TYPE (exp), 1)); ! 1158: TREE_READONLY (exp) = was_const; ! 1159: TREE_TYPE (exp) = type; ! 1160: if (init) ! 1161: TREE_TYPE (init) = itype; ! 1162: return; ! 1163: } ! 1164: ! 1165: if (TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == PARM_DECL) ! 1166: /* just know that we've seen something for this node */ ! 1167: TREE_USED (exp) = 1; ! 1168: ! 1169: #if 0 ! 1170: /* If initializing from a GNU C CONSTRUCTOR, consider the elts in the ! 1171: constructor as parameters to an implicit GNU C++ constructor. */ ! 1172: if (init && TREE_CODE (init) == CONSTRUCTOR ! 1173: && TYPE_HAS_CONSTRUCTOR (type) ! 1174: && TREE_TYPE (init) == type) ! 1175: init = CONSTRUCTOR_ELTS (init); ! 1176: #endif ! 1177: expand_aggr_init_1 (TYPE_BINFO (type), exp, exp, ! 1178: init, alias_this, LOOKUP_NORMAL); ! 1179: TREE_READONLY (exp) = was_const; ! 1180: } ! 1181: ! 1182: static void ! 1183: expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags) ! 1184: tree binfo; ! 1185: tree true_exp, exp; ! 1186: tree type; ! 1187: tree init; ! 1188: int alias_this; ! 1189: int flags; ! 1190: { ! 1191: /* It fails because there may not be a constructor which takes ! 1192: its own type as the first (or only parameter), but which does ! 1193: take other types via a conversion. So, if the thing initializing ! 1194: the expression is a unit element of type X, first try X(X&), ! 1195: followed by initialization by X. If neither of these work ! 1196: out, then look hard. */ ! 1197: tree rval; ! 1198: tree parms; ! 1199: int xxref_init_possible; ! 1200: ! 1201: if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST) ! 1202: { ! 1203: parms = init; ! 1204: if (parms) init = TREE_VALUE (parms); ! 1205: } ! 1206: else if (TREE_CODE (init) == INDIRECT_REF && TREE_HAS_CONSTRUCTOR (init)) ! 1207: { ! 1208: rval = convert_for_initialization (exp, type, init, 0, 0, 0, 0); ! 1209: TREE_USED (rval) = 1; ! 1210: expand_expr_stmt (rval); ! 1211: return; ! 1212: } ! 1213: else ! 1214: parms = build_tree_list (NULL_TREE, init); ! 1215: ! 1216: if (TYPE_HAS_INIT_REF (type) ! 1217: || init == NULL_TREE ! 1218: || TREE_CHAIN (parms) != NULL_TREE) ! 1219: xxref_init_possible = 0; ! 1220: else ! 1221: { ! 1222: xxref_init_possible = LOOKUP_SPECULATIVELY; ! 1223: flags &= ~LOOKUP_COMPLAIN; ! 1224: } ! 1225: ! 1226: if (TYPE_USES_VIRTUAL_BASECLASSES (type)) ! 1227: { ! 1228: if (true_exp == exp) ! 1229: parms = tree_cons (NULL_TREE, integer_one_node, parms); ! 1230: else ! 1231: parms = tree_cons (NULL_TREE, integer_zero_node, parms); ! 1232: flags |= LOOKUP_HAS_IN_CHARGE; ! 1233: } ! 1234: ! 1235: rval = build_method_call (exp, constructor_name_full (type), ! 1236: parms, binfo, flags|xxref_init_possible); ! 1237: if (rval == NULL_TREE && xxref_init_possible) ! 1238: { ! 1239: /* It is an error to implement a default copy constructor if ! 1240: (see ARM 12.8 for details) ... one case being if another ! 1241: copy constructor already exists. */ ! 1242: tree init_type = TREE_TYPE (init); ! 1243: if (TREE_CODE (init_type) == REFERENCE_TYPE) ! 1244: init_type = TREE_TYPE (init_type); ! 1245: if (TYPE_MAIN_VARIANT (init_type) == TYPE_MAIN_VARIANT (type) ! 1246: || (IS_AGGR_TYPE (init_type) ! 1247: && UNIQUELY_DERIVED_FROM_P (type, init_type))) ! 1248: { ! 1249: if (type == BINFO_TYPE (binfo) ! 1250: && TYPE_USES_VIRTUAL_BASECLASSES (type)) ! 1251: { ! 1252: tree addr = build_unary_op (ADDR_EXPR, exp, 0); ! 1253: expand_aggr_vbase_init (binfo, exp, addr, NULL_TREE); ! 1254: ! 1255: expand_indirect_vtbls_init (binfo, exp, addr, 1); ! 1256: } ! 1257: expand_expr_stmt (build_modify_expr (exp, INIT_EXPR, init)); ! 1258: return; ! 1259: } ! 1260: else ! 1261: rval = build_method_call (exp, constructor_name_full (type), parms, ! 1262: binfo, flags); ! 1263: } ! 1264: ! 1265: /* Private, protected, or otherwise unavailable. */ ! 1266: if (rval == error_mark_node && (flags&LOOKUP_COMPLAIN)) ! 1267: cp_error ("in base initialization for class `%T'", binfo); ! 1268: /* A valid initialization using constructor. */ ! 1269: else if (rval != error_mark_node && rval != NULL_TREE) ! 1270: { ! 1271: /* p. 222: if the base class assigns to `this', then that ! 1272: value is used in the derived class. */ ! 1273: if ((flag_this_is_variable & 1) && alias_this) ! 1274: { ! 1275: TREE_TYPE (rval) = TREE_TYPE (current_class_decl); ! 1276: expand_assignment (current_class_decl, rval, 0, 0); ! 1277: } ! 1278: else ! 1279: expand_expr_stmt (rval); ! 1280: } ! 1281: else if (parms && TREE_CHAIN (parms) == NULL_TREE) ! 1282: { ! 1283: /* If we are initializing one aggregate value ! 1284: from another, and though there are constructors, ! 1285: and none accept the initializer, just do a bitwise ! 1286: copy. ! 1287: ! 1288: The above sounds wrong, ``If a class has any copy ! 1289: constructor defined, the default copy constructor will ! 1290: not be generated.'' 12.8 Copying Class Objects (mrs) ! 1291: ! 1292: @@ This should reject initializer which a constructor ! 1293: @@ rejected on access gounds, but there is ! 1294: @@ no way right now to recognize that case with ! 1295: @@ just `error_mark_node'. */ ! 1296: tree itype; ! 1297: init = TREE_VALUE (parms); ! 1298: itype = TREE_TYPE (init); ! 1299: if (TREE_CODE (itype) == REFERENCE_TYPE) ! 1300: { ! 1301: init = convert_from_reference (init); ! 1302: itype = TREE_TYPE (init); ! 1303: } ! 1304: itype = TYPE_MAIN_VARIANT (itype); ! 1305: ! 1306: /* This is currently how the default X(X&) constructor ! 1307: is implemented. */ ! 1308: if (comptypes (TYPE_MAIN_VARIANT (type), itype, 0)) ! 1309: { ! 1310: #if 0 ! 1311: warning ("bitwise copy in initialization of type `%s'", ! 1312: TYPE_NAME_STRING (type)); ! 1313: #endif ! 1314: rval = build (INIT_EXPR, type, exp, init); ! 1315: expand_expr_stmt (rval); ! 1316: } ! 1317: else ! 1318: { ! 1319: cp_error ("in base initialization for class `%T',", binfo); ! 1320: cp_error ("invalid initializer to constructor for type `%T'", type); ! 1321: return; ! 1322: } ! 1323: } ! 1324: else ! 1325: { ! 1326: if (init == NULL_TREE) ! 1327: my_friendly_assert (parms == NULL_TREE, 210); ! 1328: if (parms == NULL_TREE && TREE_VIA_VIRTUAL (binfo)) ! 1329: cp_error ("virtual baseclass `%T' does not have default initializer", binfo); ! 1330: else ! 1331: { ! 1332: cp_error ("in base initialization for class `%T',", binfo); ! 1333: /* This will make an error message for us. */ ! 1334: build_method_call (exp, constructor_name_full (type), parms, binfo, ! 1335: (TYPE_USES_VIRTUAL_BASECLASSES (type) ! 1336: ? LOOKUP_NORMAL|LOOKUP_HAS_IN_CHARGE ! 1337: : LOOKUP_NORMAL)); ! 1338: } ! 1339: return; ! 1340: } ! 1341: /* Constructor has been called, but vtables may be for TYPE ! 1342: rather than for FOR_TYPE. */ ! 1343: } ! 1344: ! 1345: /* This function is responsible for initializing EXP with INIT ! 1346: (if any). ! 1347: ! 1348: BINFO is the binfo of the type for who we are performing the ! 1349: initialization. For example, if W is a virtual base class of A and B, ! 1350: and C : A, B. ! 1351: If we are initializing B, then W must contain B's W vtable, whereas ! 1352: were we initializing C, W must contain C's W vtable. ! 1353: ! 1354: TRUE_EXP is nonzero if it is the true expression being initialized. ! 1355: In this case, it may be EXP, or may just contain EXP. The reason we ! 1356: need this is because if EXP is a base element of TRUE_EXP, we ! 1357: don't necessarily know by looking at EXP where its virtual ! 1358: baseclass fields should really be pointing. But we do know ! 1359: from TRUE_EXP. In constructors, we don't know anything about ! 1360: the value being initialized. ! 1361: ! 1362: ALIAS_THIS serves the same purpose it serves for expand_aggr_init. ! 1363: ! 1364: FLAGS is just passes to `build_method_call'. See that function for ! 1365: its description. */ ! 1366: ! 1367: static void ! 1368: expand_aggr_init_1 (binfo, true_exp, exp, init, alias_this, flags) ! 1369: tree binfo; ! 1370: tree true_exp, exp; ! 1371: tree init; ! 1372: int alias_this; ! 1373: int flags; ! 1374: { ! 1375: tree type = TREE_TYPE (exp); ! 1376: tree init_type = NULL_TREE; ! 1377: ! 1378: my_friendly_assert (init != error_mark_node && type != error_mark_node, 211); ! 1379: ! 1380: /* Use a function returning the desired type to initialize EXP for us. ! 1381: If the function is a constructor, and its first argument is ! 1382: NULL_TREE, know that it was meant for us--just slide exp on ! 1383: in and expand the constructor. Constructors now come ! 1384: as TARGET_EXPRs. */ ! 1385: if (init) ! 1386: { ! 1387: tree init_list = NULL_TREE; ! 1388: ! 1389: if (TREE_CODE (init) == TREE_LIST) ! 1390: { ! 1391: init_list = init; ! 1392: if (TREE_CHAIN (init) == NULL_TREE) ! 1393: init = TREE_VALUE (init); ! 1394: } ! 1395: ! 1396: init_type = TREE_TYPE (init); ! 1397: ! 1398: if (TREE_CODE (init) != TREE_LIST) ! 1399: { ! 1400: if (TREE_CODE (init_type) == ERROR_MARK) ! 1401: return; ! 1402: ! 1403: #if 0 ! 1404: /* These lines are found troublesome 5/11/89. */ ! 1405: if (TREE_CODE (init_type) == REFERENCE_TYPE) ! 1406: init_type = TREE_TYPE (init_type); ! 1407: #endif ! 1408: ! 1409: /* This happens when we use C++'s functional cast notation. ! 1410: If the types match, then just use the TARGET_EXPR ! 1411: directly. Otherwise, we need to create the initializer ! 1412: separately from the object being initialized. */ ! 1413: if (TREE_CODE (init) == TARGET_EXPR) ! 1414: { ! 1415: if (TYPE_MAIN_VARIANT (init_type) == TYPE_MAIN_VARIANT (type)) ! 1416: { ! 1417: if (TREE_CODE (exp) == VAR_DECL ! 1418: || TREE_CODE (exp) == RESULT_DECL) ! 1419: /* Unify the initialization targets. */ ! 1420: DECL_RTL (TREE_OPERAND (init, 0)) = DECL_RTL (exp); ! 1421: else ! 1422: DECL_RTL (TREE_OPERAND (init, 0)) = expand_expr (exp, NULL_RTX, 0, 0); ! 1423: ! 1424: expand_expr_stmt (init); ! 1425: return; ! 1426: } ! 1427: else ! 1428: { ! 1429: init = TREE_OPERAND (init, 1); ! 1430: init = build (CALL_EXPR, init_type, ! 1431: TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), 0); ! 1432: TREE_SIDE_EFFECTS (init) = 1; ! 1433: #if 0 ! 1434: TREE_RAISES (init) = ?? ! 1435: #endif ! 1436: if (init_list) ! 1437: TREE_VALUE (init_list) = init; ! 1438: } ! 1439: } ! 1440: ! 1441: if (init_type == type && TREE_CODE (init) == CALL_EXPR ! 1442: #if 0 ! 1443: /* It is legal to directly initialize from a CALL_EXPR ! 1444: without going through X(X&), apparently. */ ! 1445: && ! TYPE_GETS_INIT_REF (type) ! 1446: #endif ! 1447: ) ! 1448: { ! 1449: /* A CALL_EXPR is a legitimate form of initialization, so ! 1450: we should not print this warning message. */ ! 1451: #if 0 ! 1452: /* Should have gone away due to 5/11/89 change. */ ! 1453: if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE) ! 1454: init = convert_from_reference (init); ! 1455: #endif ! 1456: expand_assignment (exp, init, 0, 0); ! 1457: if (exp == DECL_RESULT (current_function_decl)) ! 1458: { ! 1459: /* Failing this assertion means that the return value ! 1460: from receives multiple initializations. */ ! 1461: my_friendly_assert (DECL_INITIAL (exp) == NULL_TREE ! 1462: || DECL_INITIAL (exp) == error_mark_node, ! 1463: 212); ! 1464: DECL_INITIAL (exp) = init; ! 1465: } ! 1466: return; ! 1467: } ! 1468: else if (init_type == type ! 1469: && TREE_CODE (init) == COND_EXPR) ! 1470: { ! 1471: /* Push value to be initialized into the cond, where possible. ! 1472: Avoid spurious warning messages when initializing the ! 1473: result of this function. */ ! 1474: TREE_OPERAND (init, 1) ! 1475: = build_modify_expr (exp, INIT_EXPR, TREE_OPERAND (init, 1)); ! 1476: if (exp == DECL_RESULT (current_function_decl)) ! 1477: DECL_INITIAL (exp) = NULL_TREE; ! 1478: TREE_OPERAND (init, 2) ! 1479: = build_modify_expr (exp, INIT_EXPR, TREE_OPERAND (init, 2)); ! 1480: if (exp == DECL_RESULT (current_function_decl)) ! 1481: DECL_INITIAL (exp) = init; ! 1482: TREE_SIDE_EFFECTS (init) = 1; ! 1483: expand_expr (init, const0_rtx, VOIDmode, 0); ! 1484: free_temp_slots (); ! 1485: return; ! 1486: } ! 1487: } ! 1488: ! 1489: /* We did not know what we were initializing before. Now we do. */ ! 1490: if (TREE_CODE (init) == TARGET_EXPR) ! 1491: { ! 1492: tree tmp = TREE_OPERAND (TREE_OPERAND (init, 1), 1); ! 1493: ! 1494: if (TREE_CODE (TREE_VALUE (tmp)) == NOP_EXPR ! 1495: && TREE_OPERAND (TREE_VALUE (tmp), 0) == integer_zero_node) ! 1496: { ! 1497: /* In order for this to work for RESULT_DECLs, if their ! 1498: type has a constructor, then they must be BLKmode ! 1499: so that they will be meaningfully addressable. */ ! 1500: tree arg = build_unary_op (ADDR_EXPR, exp, 0); ! 1501: init = TREE_OPERAND (init, 1); ! 1502: init = build (CALL_EXPR, build_pointer_type (TREE_TYPE (init)), ! 1503: TREE_OPERAND (init, 0), TREE_OPERAND (init, 1), 0); ! 1504: TREE_SIDE_EFFECTS (init) = 1; ! 1505: #if 0 ! 1506: TREE_RAISES (init) = ?? ! 1507: #endif ! 1508: TREE_VALUE (TREE_OPERAND (init, 1)) ! 1509: = convert_pointer_to (TREE_TYPE (TREE_TYPE (TREE_VALUE (tmp))), arg); ! 1510: ! 1511: if (alias_this) ! 1512: { ! 1513: expand_assignment (current_function_decl, init, 0, 0); ! 1514: return; ! 1515: } ! 1516: if (exp == DECL_RESULT (current_function_decl)) ! 1517: { ! 1518: if (DECL_INITIAL (DECL_RESULT (current_function_decl))) ! 1519: fatal ("return value from function receives multiple initializations"); ! 1520: DECL_INITIAL (exp) = init; ! 1521: } ! 1522: expand_expr_stmt (init); ! 1523: return; ! 1524: } ! 1525: } ! 1526: ! 1527: if (TREE_CODE (exp) == VAR_DECL ! 1528: && TREE_CODE (init) == CONSTRUCTOR ! 1529: && TREE_HAS_CONSTRUCTOR (init)) ! 1530: { ! 1531: tree t = store_init_value (exp, init); ! 1532: if (!t) ! 1533: { ! 1534: expand_decl_init (exp); ! 1535: return; ! 1536: } ! 1537: t = build (INIT_EXPR, type, exp, init); ! 1538: TREE_SIDE_EFFECTS (t) = 1; ! 1539: expand_expr_stmt (t); ! 1540: return; ! 1541: } ! 1542: ! 1543: /* Handle this case: when calling a constructor: xyzzy foo(bar); ! 1544: which really means: xyzzy foo = bar; Ugh! ! 1545: ! 1546: More useful for this case: xyzzy *foo = new xyzzy (bar); */ ! 1547: ! 1548: if (! TYPE_NEEDS_CONSTRUCTING (type) && ! IS_AGGR_TYPE (type)) ! 1549: { ! 1550: if (init_list && TREE_CHAIN (init_list)) ! 1551: { ! 1552: warning ("initializer list being treated as compound expression"); ! 1553: init = convert (type, build_compound_expr (init_list)); ! 1554: if (init == error_mark_node) ! 1555: return; ! 1556: } ! 1557: ! 1558: expand_assignment (exp, init, 0, 0); ! 1559: ! 1560: return; ! 1561: } ! 1562: /* See whether we can go through a type conversion operator. ! 1563: This wins over going through a non-existent constructor. If ! 1564: there is a constructor, it is ambiguous. */ ! 1565: if (TREE_CODE (init) != TREE_LIST) ! 1566: { ! 1567: tree ttype = TREE_CODE (init_type) == REFERENCE_TYPE ! 1568: ? TREE_TYPE (init_type) : init_type; ! 1569: ! 1570: if (ttype != type && IS_AGGR_TYPE (ttype)) ! 1571: { ! 1572: tree rval = build_type_conversion (CONVERT_EXPR, type, init, 0); ! 1573: ! 1574: if (rval) ! 1575: { ! 1576: /* See if there is a constructor for``type'' that takes a ! 1577: ``ttype''-typed object. */ ! 1578: tree parms = build_tree_list (NULL_TREE, init); ! 1579: tree as_cons = NULL_TREE; ! 1580: if (TYPE_HAS_CONSTRUCTOR (type)) ! 1581: as_cons = build_method_call (exp, constructor_name_full (type), ! 1582: parms, binfo, ! 1583: LOOKUP_SPECULATIVELY|LOOKUP_NO_CONVERSION); ! 1584: if (as_cons != NULL_TREE && as_cons != error_mark_node) ! 1585: /* ANSI C++ June 5 1992 WP 12.3.2.6.1 */ ! 1586: cp_error ("ambiguity between conversion to `%T' and constructor", ! 1587: type); ! 1588: else ! 1589: expand_assignment (exp, rval, 0, 0); ! 1590: return; ! 1591: } ! 1592: } ! 1593: } ! 1594: } ! 1595: ! 1596: /* Handle default copy constructors here, does not matter if there is ! 1597: a constructor or not. */ ! 1598: if (type == init_type && IS_AGGR_TYPE (type) ! 1599: && init && TREE_CODE (init) != TREE_LIST) ! 1600: expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags); ! 1601: /* Not sure why this is here... */ ! 1602: else if (TYPE_HAS_CONSTRUCTOR (type)) ! 1603: expand_default_init (binfo, true_exp, exp, type, init, alias_this, flags); ! 1604: else if (TREE_CODE (type) == ARRAY_TYPE) ! 1605: { ! 1606: if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type))) ! 1607: expand_vec_init (exp, exp, array_type_nelts (type), init, 0); ! 1608: else if (TYPE_VIRTUAL_P (TREE_TYPE (type))) ! 1609: sorry ("arrays of objects with virtual functions but no constructors"); ! 1610: } ! 1611: else ! 1612: expand_recursive_init (binfo, true_exp, exp, init, ! 1613: CLASSTYPE_BASE_INIT_LIST (type), alias_this); ! 1614: } ! 1615: ! 1616: /* A pointer which holds the initializer. First call to ! 1617: expand_aggr_init gets this value pointed to, and sets it to init_null. */ ! 1618: static tree *init_ptr, init_null; ! 1619: ! 1620: /* Subroutine of expand_recursive_init: ! 1621: ! 1622: ADDR is the address of the expression being initialized. ! 1623: INIT_LIST is the cons-list of initializations to be performed. ! 1624: ALIAS_THIS is its same, lovable self. */ ! 1625: static void ! 1626: expand_recursive_init_1 (binfo, true_exp, addr, init_list, alias_this) ! 1627: tree binfo, true_exp, addr; ! 1628: tree init_list; ! 1629: int alias_this; ! 1630: { ! 1631: while (init_list) ! 1632: { ! 1633: if (TREE_PURPOSE (init_list)) ! 1634: { ! 1635: if (TREE_CODE (TREE_PURPOSE (init_list)) == FIELD_DECL) ! 1636: { ! 1637: tree member = TREE_PURPOSE (init_list); ! 1638: tree subexp = build_indirect_ref (convert_pointer_to (TREE_VALUE (init_list), addr), NULL_PTR); ! 1639: tree member_base = build (COMPONENT_REF, TREE_TYPE (member), subexp, member); ! 1640: if (IS_AGGR_TYPE (TREE_TYPE (member))) ! 1641: expand_aggr_init (member_base, DECL_INITIAL (member), 0); ! 1642: else if (TREE_CODE (TREE_TYPE (member)) == ARRAY_TYPE ! 1643: && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (member))) ! 1644: { ! 1645: member_base = save_expr (default_conversion (member_base)); ! 1646: expand_vec_init (member, member_base, ! 1647: array_type_nelts (TREE_TYPE (member)), ! 1648: DECL_INITIAL (member), 0); ! 1649: } ! 1650: else ! 1651: expand_expr_stmt (build_modify_expr (member_base, INIT_EXPR, DECL_INITIAL (member))); ! 1652: } ! 1653: else if (TREE_CODE (TREE_PURPOSE (init_list)) == TREE_LIST) ! 1654: { ! 1655: expand_recursive_init_1 (binfo, true_exp, addr, TREE_PURPOSE (init_list), alias_this); ! 1656: expand_recursive_init_1 (binfo, true_exp, addr, TREE_VALUE (init_list), alias_this); ! 1657: } ! 1658: else if (TREE_CODE (TREE_PURPOSE (init_list)) == ERROR_MARK) ! 1659: { ! 1660: /* Only initialize the virtual function tables if we ! 1661: are initializing the ultimate users of those vtables. */ ! 1662: if (TREE_VALUE (init_list)) ! 1663: { ! 1664: /* We have to ensure that the first argment to ! 1665: expand_virtual_init is in binfo's hierarchy. */ ! 1666: /* Is it the case that this is exactly the right binfo? */ ! 1667: /* If it is ok, then fixup expand_virtual_init, to make ! 1668: it much simpler. */ ! 1669: expand_virtual_init (get_binfo (TREE_VALUE (init_list), binfo, 0), ! 1670: addr); ! 1671: if (TREE_VALUE (init_list) == binfo ! 1672: && TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))) ! 1673: expand_indirect_vtbls_init (binfo, true_exp, addr, 1); ! 1674: } ! 1675: } ! 1676: else ! 1677: my_friendly_abort (49); ! 1678: } ! 1679: else if (TREE_VALUE (init_list) ! 1680: && TREE_CODE (TREE_VALUE (init_list)) == TREE_VEC) ! 1681: { ! 1682: tree subexp = build_indirect_ref (convert_pointer_to (TREE_VALUE (init_list), addr), NULL_PTR); ! 1683: expand_aggr_init_1 (binfo, true_exp, subexp, *init_ptr, ! 1684: alias_this && BINFO_OFFSET_ZEROP (TREE_VALUE (init_list)), ! 1685: LOOKUP_COMPLAIN); ! 1686: ! 1687: /* INIT_PTR is used up. */ ! 1688: init_ptr = &init_null; ! 1689: } ! 1690: else ! 1691: my_friendly_abort (50); ! 1692: init_list = TREE_CHAIN (init_list); ! 1693: } ! 1694: } ! 1695: ! 1696: /* Initialize EXP with INIT. Type EXP does not have a constructor, ! 1697: but it has a baseclass with a constructor or a virtual function ! 1698: table which needs initializing. ! 1699: ! 1700: INIT_LIST is a cons-list describing what parts of EXP actually ! 1701: need to be initialized. INIT is given to the *unique*, first ! 1702: constructor within INIT_LIST. If there are multiple first ! 1703: constructors, such as with multiple inheritance, INIT must ! 1704: be zero or an ambiguity error is reported. ! 1705: ! 1706: ALIAS_THIS is passed from `expand_aggr_init'. See comments ! 1707: there. */ ! 1708: ! 1709: static void ! 1710: expand_recursive_init (binfo, true_exp, exp, init, init_list, alias_this) ! 1711: tree binfo, true_exp, exp, init; ! 1712: tree init_list; ! 1713: int alias_this; ! 1714: { ! 1715: tree *old_init_ptr = init_ptr; ! 1716: tree addr = build_unary_op (ADDR_EXPR, exp, 0); ! 1717: init_ptr = &init; ! 1718: ! 1719: if (true_exp == exp && TYPE_USES_VIRTUAL_BASECLASSES (BINFO_TYPE (binfo))) ! 1720: { ! 1721: expand_aggr_vbase_init (binfo, exp, addr, init_list); ! 1722: expand_indirect_vtbls_init (binfo, true_exp, addr, 1); ! 1723: } ! 1724: expand_recursive_init_1 (binfo, true_exp, addr, init_list, alias_this); ! 1725: ! 1726: if (*init_ptr) ! 1727: { ! 1728: tree type = TREE_TYPE (exp); ! 1729: ! 1730: if (TREE_CODE (type) == REFERENCE_TYPE) ! 1731: type = TREE_TYPE (type); ! 1732: if (IS_AGGR_TYPE (type)) ! 1733: cp_error ("unexpected argument to constructor `%T'", type); ! 1734: else ! 1735: error ("unexpected argument to constructor"); ! 1736: } ! 1737: init_ptr = old_init_ptr; ! 1738: } ! 1739: ! 1740: /* Report an error if NAME is not the name of a user-defined, ! 1741: aggregate type. If OR_ELSE is nonzero, give an error message. */ ! 1742: int ! 1743: is_aggr_typedef (name, or_else) ! 1744: tree name; ! 1745: int or_else; ! 1746: { ! 1747: tree type; ! 1748: ! 1749: if (name == error_mark_node) ! 1750: return 0; ! 1751: ! 1752: if (IDENTIFIER_HAS_TYPE_VALUE (name)) ! 1753: type = IDENTIFIER_TYPE_VALUE (name); ! 1754: else ! 1755: { ! 1756: if (or_else) ! 1757: cp_error ("`%T' is not an aggregate typedef", name); ! 1758: return 0; ! 1759: } ! 1760: ! 1761: if (! IS_AGGR_TYPE (type) ! 1762: && TREE_CODE (type) != TEMPLATE_TYPE_PARM) ! 1763: { ! 1764: if (or_else) ! 1765: cp_error ("`%T' is not an aggregate type", type); ! 1766: return 0; ! 1767: } ! 1768: return 1; ! 1769: } ! 1770: ! 1771: /* Like is_aggr_typedef, but returns typedef if successful. */ ! 1772: tree ! 1773: get_aggr_from_typedef (name, or_else) ! 1774: tree name; ! 1775: int or_else; ! 1776: { ! 1777: tree type; ! 1778: ! 1779: if (name == error_mark_node) ! 1780: return NULL_TREE; ! 1781: ! 1782: if (IDENTIFIER_HAS_TYPE_VALUE (name)) ! 1783: type = IDENTIFIER_TYPE_VALUE (name); ! 1784: else ! 1785: { ! 1786: if (or_else) ! 1787: cp_error ("`%T' fails to be an aggregate typedef", name); ! 1788: return NULL_TREE; ! 1789: } ! 1790: ! 1791: if (! IS_AGGR_TYPE (type) ! 1792: && TREE_CODE (type) != TEMPLATE_TYPE_PARM) ! 1793: { ! 1794: if (or_else) ! 1795: cp_error ("type `%T' is of non-aggregate type", type); ! 1796: return NULL_TREE; ! 1797: } ! 1798: return type; ! 1799: } ! 1800: ! 1801: tree ! 1802: get_type_value (name) ! 1803: tree name; ! 1804: { ! 1805: if (name == error_mark_node) ! 1806: return NULL_TREE; ! 1807: ! 1808: if (IDENTIFIER_HAS_TYPE_VALUE (name)) ! 1809: return IDENTIFIER_TYPE_VALUE (name); ! 1810: else ! 1811: return NULL_TREE; ! 1812: } ! 1813: ! 1814: ! 1815: /* This code could just as well go in `class.c', but is placed here for ! 1816: modularity. */ ! 1817: ! 1818: /* For an expression of the form CNAME :: NAME (PARMLIST), build ! 1819: the appropriate function call. */ ! 1820: tree ! 1821: build_member_call (cname, name, parmlist) ! 1822: tree cname, name, parmlist; ! 1823: { ! 1824: tree type, t; ! 1825: tree method_name = name; ! 1826: int dtor = 0; ! 1827: int dont_use_this = 0; ! 1828: tree basetype_path, decl; ! 1829: ! 1830: if (TREE_CODE (method_name) == BIT_NOT_EXPR) ! 1831: { ! 1832: method_name = TREE_OPERAND (method_name, 0); ! 1833: dtor = 1; ! 1834: } ! 1835: ! 1836: if (TREE_CODE (cname) == SCOPE_REF) ! 1837: cname = resolve_scope_to_name (NULL_TREE, cname); ! 1838: ! 1839: if (cname == NULL_TREE || ! (type = get_aggr_from_typedef (cname, 1))) ! 1840: return error_mark_node; ! 1841: ! 1842: /* An operator we did not like. */ ! 1843: if (name == NULL_TREE) ! 1844: return error_mark_node; ! 1845: ! 1846: if (dtor) ! 1847: { ! 1848: #if 0 ! 1849: /* Everything can explicitly call a destructor; see 12.4 */ ! 1850: if (! TYPE_HAS_DESTRUCTOR (type)) ! 1851: cp_error ("type `%#T' does not have a destructor", type); ! 1852: else ! 1853: #endif ! 1854: cp_error ("cannot call destructor `%T::~%T' without object", type, ! 1855: method_name); ! 1856: return error_mark_node; ! 1857: } ! 1858: ! 1859: /* No object? Then just fake one up, and let build_method_call ! 1860: figure out what to do. */ ! 1861: if (current_class_type == 0 ! 1862: || get_base_distance (type, current_class_type, 0, &basetype_path) == -1) ! 1863: dont_use_this = 1; ! 1864: ! 1865: if (dont_use_this) ! 1866: { ! 1867: basetype_path = TYPE_BINFO (type); ! 1868: decl = build1 (NOP_EXPR, TYPE_POINTER_TO (type), error_mark_node); ! 1869: } ! 1870: else if (current_class_decl == 0) ! 1871: { ! 1872: dont_use_this = 1; ! 1873: decl = build1 (NOP_EXPR, TYPE_POINTER_TO (type), error_mark_node); ! 1874: } ! 1875: else ! 1876: { ! 1877: tree olddecl = current_class_decl; ! 1878: tree oldtype = TREE_TYPE (TREE_TYPE (olddecl)); ! 1879: if (oldtype != type) ! 1880: { ! 1881: tree newtype = build_type_variant (type, TYPE_READONLY (oldtype), ! 1882: TYPE_VOLATILE (oldtype)); ! 1883: decl = convert_force (build_pointer_type (newtype), olddecl); ! 1884: } ! 1885: else ! 1886: decl = olddecl; ! 1887: } ! 1888: ! 1889: decl = build_indirect_ref (decl, NULL_PTR); ! 1890: ! 1891: if (t = lookup_fnfields (basetype_path, method_name, 0)) ! 1892: return build_method_call (decl, method_name, parmlist, basetype_path, ! 1893: LOOKUP_NORMAL|LOOKUP_NONVIRTUAL); ! 1894: if (TREE_CODE (name) == IDENTIFIER_NODE ! 1895: && ((t = lookup_field (TYPE_BINFO (type), name, 1, 0)))) ! 1896: { ! 1897: if (t == error_mark_node) ! 1898: return error_mark_node; ! 1899: if (TREE_CODE (t) == FIELD_DECL) ! 1900: { ! 1901: if (dont_use_this) ! 1902: { ! 1903: cp_error ("invalid use of non-static field `%D'", t); ! 1904: return error_mark_node; ! 1905: } ! 1906: decl = build (COMPONENT_REF, TREE_TYPE (t), decl, t); ! 1907: } ! 1908: else if (TREE_CODE (t) == VAR_DECL) ! 1909: decl = t; ! 1910: else ! 1911: { ! 1912: cp_error ("invalid use of member `%D'", t); ! 1913: return error_mark_node; ! 1914: } ! 1915: if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl)) ! 1916: && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (decl))) ! 1917: return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl, parmlist, NULL_TREE); ! 1918: return build_function_call (decl, parmlist); ! 1919: } ! 1920: else ! 1921: { ! 1922: cp_error ("no method `%T::%D'", type, name); ! 1923: return error_mark_node; ! 1924: } ! 1925: } ! 1926: ! 1927: /* Build a reference to a member of an aggregate. This is not a ! 1928: C++ `&', but really something which can have its address taken, ! 1929: and then act as a pointer to member, for example CNAME :: FIELD ! 1930: can have its address taken by saying & CNAME :: FIELD. ! 1931: ! 1932: @@ Prints out lousy diagnostics for operator <typename> ! 1933: @@ fields. ! 1934: ! 1935: @@ This function should be rewritten and placed in search.c. */ ! 1936: tree ! 1937: build_offset_ref (cname, name) ! 1938: tree cname, name; ! 1939: { ! 1940: tree decl, type, fnfields, fields, t = error_mark_node; ! 1941: tree basetypes = NULL_TREE; ! 1942: int dtor = 0; ! 1943: ! 1944: if (TREE_CODE (cname) == SCOPE_REF) ! 1945: cname = resolve_scope_to_name (NULL_TREE, cname); ! 1946: ! 1947: if (cname == NULL_TREE || ! is_aggr_typedef (cname, 1)) ! 1948: return error_mark_node; ! 1949: ! 1950: type = IDENTIFIER_TYPE_VALUE (cname); ! 1951: ! 1952: if (TREE_CODE (name) == BIT_NOT_EXPR) ! 1953: { ! 1954: dtor = 1; ! 1955: name = TREE_OPERAND (name, 0); ! 1956: } ! 1957: ! 1958: if (TYPE_SIZE (type) == 0) ! 1959: { ! 1960: t = IDENTIFIER_CLASS_VALUE (name); ! 1961: if (t == 0) ! 1962: { ! 1963: cp_error ("incomplete type `%T' does not have member `%D'", type, ! 1964: name); ! 1965: return error_mark_node; ! 1966: } ! 1967: if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == VAR_DECL ! 1968: || TREE_CODE (t) == CONST_DECL) ! 1969: { ! 1970: TREE_USED (t) = 1; ! 1971: return t; ! 1972: } ! 1973: if (TREE_CODE (t) == FIELD_DECL) ! 1974: sorry ("use of member in incomplete aggregate type"); ! 1975: else if (TREE_CODE (t) == FUNCTION_DECL) ! 1976: sorry ("use of member function in incomplete aggregate type"); ! 1977: else ! 1978: my_friendly_abort (52); ! 1979: return error_mark_node; ! 1980: } ! 1981: ! 1982: #if 0 ! 1983: if (TREE_CODE (name) == TYPE_EXPR) ! 1984: /* Pass a TYPE_DECL to build_component_type_expr. */ ! 1985: return build_component_type_expr (TYPE_NAME (TREE_TYPE (cname)), ! 1986: name, NULL_TREE, 1); ! 1987: #endif ! 1988: ! 1989: if (current_class_type == 0 ! 1990: || get_base_distance (type, current_class_type, 0, &basetypes) == -1) ! 1991: { ! 1992: basetypes = TYPE_BINFO (type); ! 1993: decl = build1 (NOP_EXPR, ! 1994: IDENTIFIER_TYPE_VALUE (cname), ! 1995: error_mark_node); ! 1996: } ! 1997: else if (current_class_decl == 0) ! 1998: decl = build1 (NOP_EXPR, IDENTIFIER_TYPE_VALUE (cname), ! 1999: error_mark_node); ! 2000: else ! 2001: decl = C_C_D; ! 2002: ! 2003: fnfields = lookup_fnfields (basetypes, name, 1); ! 2004: fields = lookup_field (basetypes, name, 0, 0); ! 2005: ! 2006: if (fields == error_mark_node || fnfields == error_mark_node) ! 2007: return error_mark_node; ! 2008: ! 2009: /* A lot of this logic is now handled in lookup_field and ! 2010: lookup_fnfield. */ ! 2011: if (fnfields) ! 2012: { ! 2013: basetypes = TREE_PURPOSE (fnfields); ! 2014: ! 2015: /* Go from the TREE_BASELINK to the member function info. */ ! 2016: t = TREE_VALUE (fnfields); ! 2017: ! 2018: if (fields) ! 2019: { ! 2020: if (DECL_FIELD_CONTEXT (fields) == DECL_FIELD_CONTEXT (t)) ! 2021: { ! 2022: error ("ambiguous member reference: member `%s' defined as both field and function", ! 2023: IDENTIFIER_POINTER (name)); ! 2024: return error_mark_node; ! 2025: } ! 2026: if (UNIQUELY_DERIVED_FROM_P (DECL_FIELD_CONTEXT (fields), DECL_FIELD_CONTEXT (t))) ! 2027: ; ! 2028: else if (UNIQUELY_DERIVED_FROM_P (DECL_FIELD_CONTEXT (t), DECL_FIELD_CONTEXT (fields))) ! 2029: t = fields; ! 2030: else ! 2031: { ! 2032: error ("ambiguous member reference: member `%s' derives from distinct classes in multiple inheritance lattice"); ! 2033: return error_mark_node; ! 2034: } ! 2035: } ! 2036: ! 2037: if (t == TREE_VALUE (fnfields)) ! 2038: { ! 2039: extern int flag_save_memoized_contexts; ! 2040: ! 2041: if (DECL_CHAIN (t) == NULL_TREE || dtor) ! 2042: { ! 2043: enum access_type access; ! 2044: ! 2045: /* unique functions are handled easily. */ ! 2046: unique: ! 2047: access = compute_access (basetypes, t); ! 2048: if (access == access_protected) ! 2049: { ! 2050: cp_error_at ("member function `%#D' is protected", t); ! 2051: error ("in this context"); ! 2052: return error_mark_node; ! 2053: } ! 2054: if (access == access_private) ! 2055: { ! 2056: cp_error_at ("member function `%#D' is private", t); ! 2057: error ("in this context"); ! 2058: return error_mark_node; ! 2059: } ! 2060: assemble_external (t); ! 2061: return build (OFFSET_REF, TREE_TYPE (t), decl, t); ! 2062: } ! 2063: ! 2064: /* overloaded functions may need more work. */ ! 2065: if (cname == name) ! 2066: { ! 2067: if (TYPE_HAS_DESTRUCTOR (type) ! 2068: && DECL_CHAIN (DECL_CHAIN (t)) == NULL_TREE) ! 2069: { ! 2070: t = DECL_CHAIN (t); ! 2071: goto unique; ! 2072: } ! 2073: } ! 2074: /* FNFIELDS is most likely allocated on the search_obstack, ! 2075: which will go away after this class scope. If we need ! 2076: to save this value for later (either for memoization ! 2077: or for use as an initializer for a static variable), then ! 2078: do so here. ! 2079: ! 2080: ??? The smart thing to do for the case of saving initializers ! 2081: is to resolve them before we're done with this scope. */ ! 2082: if (!TREE_PERMANENT (fnfields) ! 2083: && ((flag_save_memoized_contexts && global_bindings_p ()) ! 2084: || ! allocation_temporary_p ())) ! 2085: fnfields = copy_list (fnfields); ! 2086: t = build_tree_list (error_mark_node, fnfields); ! 2087: TREE_TYPE (t) = build_offset_type (type, unknown_type_node); ! 2088: return t; ! 2089: } ! 2090: } ! 2091: ! 2092: /* Now that we know we are looking for a field, see if we ! 2093: have access to that field. Lookup_field will give us the ! 2094: error message. */ ! 2095: ! 2096: t = lookup_field (basetypes, name, 1, 0); ! 2097: ! 2098: if (t == error_mark_node) ! 2099: return error_mark_node; ! 2100: ! 2101: if (t == NULL_TREE) ! 2102: { ! 2103: cp_error ("`%D' is not a member of type `%T'", name, type); ! 2104: return error_mark_node; ! 2105: } ! 2106: ! 2107: if (TREE_CODE (t) == TYPE_DECL) ! 2108: { ! 2109: TREE_USED (t) = 1; ! 2110: return t; ! 2111: } ! 2112: /* static class members and class-specific enum ! 2113: values can be returned without further ado. */ ! 2114: if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == CONST_DECL) ! 2115: { ! 2116: assemble_external (t); ! 2117: TREE_USED (t) = 1; ! 2118: return t; ! 2119: } ! 2120: ! 2121: /* static class functions too. */ ! 2122: if (TREE_CODE (t) == FUNCTION_DECL && TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE) ! 2123: my_friendly_abort (53); ! 2124: ! 2125: /* In member functions, the form `cname::name' is no longer ! 2126: equivalent to `this->cname::name'. */ ! 2127: return build (OFFSET_REF, build_offset_type (type, TREE_TYPE (t)), decl, t); ! 2128: } ! 2129: ! 2130: /* Given an object EXP and a member function reference MEMBER, ! 2131: return the address of the actual member function. */ ! 2132: tree ! 2133: get_member_function (exp_addr_ptr, exp, member) ! 2134: tree *exp_addr_ptr; ! 2135: tree exp, member; ! 2136: { ! 2137: tree ctype = TREE_TYPE (exp); ! 2138: tree function = save_expr (build_unary_op (ADDR_EXPR, member, 0)); ! 2139: ! 2140: if (TYPE_VIRTUAL_P (ctype) ! 2141: || (flag_all_virtual == 1 && TYPE_OVERLOADS_METHOD_CALL_EXPR (ctype))) ! 2142: { ! 2143: tree e0, e1, e3; ! 2144: tree exp_addr; ! 2145: ! 2146: /* Save away the unadulterated `this' pointer. */ ! 2147: exp_addr = save_expr (*exp_addr_ptr); ! 2148: ! 2149: /* Cast function to signed integer. */ ! 2150: e0 = build1 (NOP_EXPR, integer_type_node, function); ! 2151: ! 2152: /* There is a hack here that takes advantage of ! 2153: twos complement arithmetic, and the fact that ! 2154: there are more than one UNITS to the WORD. ! 2155: If the high bit is set for the `function', ! 2156: then we pretend it is a virtual function, ! 2157: and the array indexing will knock this bit ! 2158: out the top, leaving a valid index. */ ! 2159: if (UNITS_PER_WORD <= 1) ! 2160: my_friendly_abort (54); ! 2161: ! 2162: e1 = build (GT_EXPR, integer_type_node, e0, integer_zero_node); ! 2163: e1 = build_compound_expr (tree_cons (NULL_TREE, exp_addr, ! 2164: build_tree_list (NULL_TREE, e1))); ! 2165: e1 = save_expr (e1); ! 2166: ! 2167: if (TREE_SIDE_EFFECTS (*exp_addr_ptr)) ! 2168: { ! 2169: exp = build_indirect_ref (exp_addr, NULL_PTR); ! 2170: *exp_addr_ptr = exp_addr; ! 2171: } ! 2172: ! 2173: /* This is really hairy: if the function pointer is a pointer ! 2174: to a non-virtual member function, then we can't go mucking ! 2175: with the `this' pointer (any more than we already have to ! 2176: this point). If it is a pointer to a virtual member function, ! 2177: then we have to adjust the `this' pointer according to ! 2178: what the virtual function table tells us. */ ! 2179: ! 2180: e3 = build_vfn_ref (exp_addr_ptr, exp, e0); ! 2181: my_friendly_assert (e3 != error_mark_node, 213); ! 2182: ! 2183: /* Change this pointer type from `void *' to the ! 2184: type it is really supposed to be. */ ! 2185: TREE_TYPE (e3) = TREE_TYPE (function); ! 2186: ! 2187: /* If non-virtual, use what we had originally. Otherwise, ! 2188: use the value we get from the virtual function table. */ ! 2189: *exp_addr_ptr = build_conditional_expr (e1, exp_addr, *exp_addr_ptr); ! 2190: ! 2191: function = build_conditional_expr (e1, function, e3); ! 2192: } ! 2193: return build_indirect_ref (function, NULL_PTR); ! 2194: } ! 2195: ! 2196: /* If a OFFSET_REF made it through to here, then it did ! 2197: not have its address taken. */ ! 2198: ! 2199: tree ! 2200: resolve_offset_ref (exp) ! 2201: tree exp; ! 2202: { ! 2203: tree type = TREE_TYPE (exp); ! 2204: tree base = NULL_TREE; ! 2205: tree member; ! 2206: tree basetype, addr; ! 2207: ! 2208: if (TREE_CODE (exp) == TREE_LIST) ! 2209: return build_unary_op (ADDR_EXPR, exp, 0); ! 2210: ! 2211: if (TREE_CODE (exp) != OFFSET_REF) ! 2212: { ! 2213: my_friendly_assert (TREE_CODE (type) == OFFSET_TYPE, 214); ! 2214: if (TYPE_OFFSET_BASETYPE (type) != current_class_type) ! 2215: { ! 2216: error ("object missing in use of pointer-to-member construct"); ! 2217: return error_mark_node; ! 2218: } ! 2219: member = exp; ! 2220: type = TREE_TYPE (type); ! 2221: base = C_C_D; ! 2222: } ! 2223: else ! 2224: { ! 2225: member = TREE_OPERAND (exp, 1); ! 2226: base = TREE_OPERAND (exp, 0); ! 2227: } ! 2228: ! 2229: if ((TREE_CODE (member) == VAR_DECL ! 2230: && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (member))) ! 2231: || TREE_CODE (TREE_TYPE (member)) == FUNCTION_TYPE) ! 2232: { ! 2233: /* These were static members. */ ! 2234: if (mark_addressable (member) == 0) ! 2235: return error_mark_node; ! 2236: return member; ! 2237: } ! 2238: ! 2239: /* Syntax error can cause a member which should ! 2240: have been seen as static to be grok'd as non-static. */ ! 2241: if (TREE_CODE (member) == FIELD_DECL && C_C_D == NULL_TREE) ! 2242: { ! 2243: if (TREE_ADDRESSABLE (member) == 0) ! 2244: { ! 2245: cp_error_at ("member `%D' is non-static in static member function context", member); ! 2246: error ("at this point in file"); ! 2247: TREE_ADDRESSABLE (member) = 1; ! 2248: } ! 2249: return error_mark_node; ! 2250: } ! 2251: ! 2252: /* The first case is really just a reference to a member of `this'. */ ! 2253: if (TREE_CODE (member) == FIELD_DECL ! 2254: && (base == C_C_D ! 2255: || (TREE_CODE (base) == NOP_EXPR ! 2256: && TREE_OPERAND (base, 0) == error_mark_node))) ! 2257: { ! 2258: tree basetype_path; ! 2259: enum access_type access; ! 2260: ! 2261: if (TREE_CODE (exp) == OFFSET_REF && TREE_CODE (type) == OFFSET_TYPE) ! 2262: basetype = TYPE_OFFSET_BASETYPE (type); ! 2263: else ! 2264: basetype = DECL_CONTEXT (member); ! 2265: ! 2266: base = current_class_decl; ! 2267: ! 2268: if (get_base_distance (basetype, TREE_TYPE (TREE_TYPE (base)), 0, &basetype_path) < 0) ! 2269: { ! 2270: error_not_base_type (basetype, TREE_TYPE (TREE_TYPE (base))); ! 2271: return error_mark_node; ! 2272: } ! 2273: addr = convert_pointer_to (basetype, base); ! 2274: access = compute_access (basetype_path, member); ! 2275: if (access == access_public) ! 2276: return build (COMPONENT_REF, TREE_TYPE (member), ! 2277: build_indirect_ref (addr, NULL_PTR), member); ! 2278: if (access == access_protected) ! 2279: { ! 2280: cp_error_at ("member `%D' is protected", member); ! 2281: error ("in this context"); ! 2282: return error_mark_node; ! 2283: } ! 2284: if (access == access_private) ! 2285: { ! 2286: cp_error_at ("member `%D' is private", member); ! 2287: error ("in this context"); ! 2288: return error_mark_node; ! 2289: } ! 2290: my_friendly_abort (55); ! 2291: } ! 2292: ! 2293: /* If this is a reference to a member function, then return ! 2294: the address of the member function (which may involve going ! 2295: through the object's vtable), otherwise, return an expression ! 2296: for the dereferenced pointer-to-member construct. */ ! 2297: addr = build_unary_op (ADDR_EXPR, base, 0); ! 2298: ! 2299: if (TREE_CODE (TREE_TYPE (member)) == METHOD_TYPE) ! 2300: { ! 2301: basetype = DECL_CLASS_CONTEXT (member); ! 2302: addr = convert_pointer_to (basetype, addr); ! 2303: return build_unary_op (ADDR_EXPR, get_member_function (&addr, build_indirect_ref (addr, NULL_PTR), member), 0); ! 2304: } ! 2305: else if (TREE_CODE (TREE_TYPE (member)) == OFFSET_TYPE) ! 2306: { ! 2307: basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (member)); ! 2308: addr = convert_pointer_to (basetype, addr); ! 2309: member = convert (ptrdiff_type_node, ! 2310: build_unary_op (ADDR_EXPR, member, 0)); ! 2311: return build1 (INDIRECT_REF, type, ! 2312: build (PLUS_EXPR, build_pointer_type (type), ! 2313: addr, member)); ! 2314: } ! 2315: else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member))) ! 2316: { ! 2317: return get_member_function_from_ptrfunc (&addr, base, member); ! 2318: } ! 2319: my_friendly_abort (56); ! 2320: /* NOTREACHED */ ! 2321: return NULL_TREE; ! 2322: } ! 2323: ! 2324: /* Return either DECL or its known constant value (if it has one). */ ! 2325: ! 2326: tree ! 2327: decl_constant_value (decl) ! 2328: tree decl; ! 2329: { ! 2330: if (! TREE_THIS_VOLATILE (decl) ! 2331: #if 0 ! 2332: /* These may be necessary for C, but they break C++. */ ! 2333: ! TREE_PUBLIC (decl) ! 2334: /* Don't change a variable array bound or initial value to a constant ! 2335: in a place where a variable is invalid. */ ! 2336: && ! pedantic ! 2337: #endif /* 0 */ ! 2338: && DECL_INITIAL (decl) != 0 ! 2339: && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK ! 2340: /* This is invalid if initial value is not constant. ! 2341: If it has either a function call, a memory reference, ! 2342: or a variable, then re-evaluating it could give different results. */ ! 2343: && TREE_CONSTANT (DECL_INITIAL (decl)) ! 2344: /* Check for cases where this is sub-optimal, even though valid. */ ! 2345: && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR ! 2346: #if 0 ! 2347: /* We must allow this to work outside of functions so that ! 2348: static constants can be used for array sizes. */ ! 2349: && current_function_decl != 0 ! 2350: && DECL_MODE (decl) != BLKmode ! 2351: #endif ! 2352: ) ! 2353: return DECL_INITIAL (decl); ! 2354: return decl; ! 2355: } ! 2356: ! 2357: /* Friend handling routines. */ ! 2358: /* Friend data structures: ! 2359: ! 2360: Lists of friend functions come from TYPE_DECL nodes. Since all ! 2361: aggregate types are automatically typedef'd, these nodes are guaranteed ! 2362: to exist. ! 2363: ! 2364: The TREE_PURPOSE of a friend list is the name of the friend, ! 2365: and its TREE_VALUE is another list. ! 2366: ! 2367: For each element of that list, either the TREE_VALUE or the TREE_PURPOSE ! 2368: will be filled in, but not both. The TREE_VALUE of that list is an ! 2369: individual function which is a friend. The TREE_PURPOSE of that list ! 2370: indicates a type in which all functions by that name are friends. ! 2371: ! 2372: Lists of friend classes come from _TYPE nodes. Love that consistency ! 2373: thang. */ ! 2374: ! 2375: int ! 2376: is_friend_type (type1, type2) ! 2377: tree type1, type2; ! 2378: { ! 2379: return is_friend (type1, type2); ! 2380: } ! 2381: ! 2382: int ! 2383: is_friend (type, supplicant) ! 2384: tree type, supplicant; ! 2385: { ! 2386: int declp; ! 2387: register tree list; ! 2388: ! 2389: if (supplicant == NULL_TREE || type == NULL_TREE) ! 2390: return 0; ! 2391: ! 2392: declp = (TREE_CODE_CLASS (TREE_CODE (supplicant)) == 'd'); ! 2393: ! 2394: if (declp) ! 2395: /* It's a function decl. */ ! 2396: { ! 2397: tree list = DECL_FRIENDLIST (TYPE_NAME (type)); ! 2398: tree name = DECL_NAME (supplicant); ! 2399: tree ctype = DECL_CLASS_CONTEXT (supplicant); ! 2400: for (; list ; list = TREE_CHAIN (list)) ! 2401: { ! 2402: if (name == TREE_PURPOSE (list)) ! 2403: { ! 2404: tree friends = TREE_VALUE (list); ! 2405: name = DECL_ASSEMBLER_NAME (supplicant); ! 2406: for (; friends ; friends = TREE_CHAIN (friends)) ! 2407: { ! 2408: if (ctype == TREE_PURPOSE (friends)) ! 2409: return 1; ! 2410: if (name == DECL_ASSEMBLER_NAME (TREE_VALUE (friends))) ! 2411: return 1; ! 2412: } ! 2413: break; ! 2414: } ! 2415: } ! 2416: } ! 2417: else ! 2418: /* It's a type. */ ! 2419: { ! 2420: if (type == supplicant) ! 2421: return 1; ! 2422: ! 2423: list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_NAME (type))); ! 2424: for (; list ; list = TREE_CHAIN (list)) ! 2425: if (supplicant == TREE_VALUE (list)) ! 2426: return 1; ! 2427: } ! 2428: ! 2429: { ! 2430: tree context = declp ? DECL_CLASS_CONTEXT (supplicant) ! 2431: : DECL_CONTEXT (TYPE_NAME (supplicant)); ! 2432: ! 2433: if (context) ! 2434: return is_friend (type, context); ! 2435: } ! 2436: ! 2437: return 0; ! 2438: } ! 2439: ! 2440: /* Add a new friend to the friends of the aggregate type TYPE. ! 2441: DECL is the FUNCTION_DECL of the friend being added. */ ! 2442: static void ! 2443: add_friend (type, decl) ! 2444: tree type, decl; ! 2445: { ! 2446: tree typedecl = TYPE_NAME (type); ! 2447: tree list = DECL_FRIENDLIST (typedecl); ! 2448: tree name = DECL_NAME (decl); ! 2449: ! 2450: while (list) ! 2451: { ! 2452: if (name == TREE_PURPOSE (list)) ! 2453: { ! 2454: tree friends = TREE_VALUE (list); ! 2455: for (; friends ; friends = TREE_CHAIN (friends)) ! 2456: { ! 2457: if (decl == TREE_VALUE (friends)) ! 2458: { ! 2459: cp_pedwarn ("`%D' is already a friend of class `%T'", ! 2460: decl, type); ! 2461: cp_pedwarn_at ("previous friend declaration of `%D'", ! 2462: TREE_VALUE (friends)); ! 2463: return; ! 2464: } ! 2465: } ! 2466: TREE_VALUE (list) = tree_cons (error_mark_node, decl, ! 2467: TREE_VALUE (list)); ! 2468: return; ! 2469: } ! 2470: list = TREE_CHAIN (list); ! 2471: } ! 2472: DECL_FRIENDLIST (typedecl) ! 2473: = tree_cons (DECL_NAME (decl), build_tree_list (error_mark_node, decl), ! 2474: DECL_FRIENDLIST (typedecl)); ! 2475: if (DECL_NAME (decl) == ansi_opname[(int) MODIFY_EXPR]) ! 2476: { ! 2477: tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (decl)); ! 2478: TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1; ! 2479: if (parmtypes && TREE_CHAIN (parmtypes)) ! 2480: { ! 2481: tree parmtype = TREE_VALUE (TREE_CHAIN (parmtypes)); ! 2482: if (TREE_CODE (parmtype) == REFERENCE_TYPE ! 2483: && TREE_TYPE (parmtypes) == TREE_TYPE (typedecl)) ! 2484: TYPE_HAS_ASSIGN_REF (TREE_TYPE (typedecl)) = 1; ! 2485: } ! 2486: } ! 2487: } ! 2488: ! 2489: /* Declare that every member function NAME in FRIEND_TYPE ! 2490: (which may be NULL_TREE) is a friend of type TYPE. */ ! 2491: static void ! 2492: add_friends (type, name, friend_type) ! 2493: tree type, name, friend_type; ! 2494: { ! 2495: tree typedecl = TYPE_NAME (type); ! 2496: tree list = DECL_FRIENDLIST (typedecl); ! 2497: ! 2498: while (list) ! 2499: { ! 2500: if (name == TREE_PURPOSE (list)) ! 2501: { ! 2502: tree friends = TREE_VALUE (list); ! 2503: while (friends && TREE_PURPOSE (friends) != friend_type) ! 2504: friends = TREE_CHAIN (friends); ! 2505: if (friends) ! 2506: if (friend_type) ! 2507: warning ("method `%s::%s' is already a friend of class", ! 2508: TYPE_NAME_STRING (friend_type), ! 2509: IDENTIFIER_POINTER (name)); ! 2510: else ! 2511: warning ("function `%s' is already a friend of class `%s'", ! 2512: IDENTIFIER_POINTER (name), ! 2513: IDENTIFIER_POINTER (DECL_NAME (typedecl))); ! 2514: else ! 2515: TREE_VALUE (list) = tree_cons (friend_type, NULL_TREE, ! 2516: TREE_VALUE (list)); ! 2517: return; ! 2518: } ! 2519: list = TREE_CHAIN (list); ! 2520: } ! 2521: DECL_FRIENDLIST (typedecl) = ! 2522: tree_cons (name, ! 2523: build_tree_list (friend_type, NULL_TREE), ! 2524: DECL_FRIENDLIST (typedecl)); ! 2525: if (! strncmp (IDENTIFIER_POINTER (name), ! 2526: IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR]), ! 2527: strlen (IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR])))) ! 2528: { ! 2529: TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1; ! 2530: sorry ("declaring \"friend operator =\" will not find \"operator = (X&)\" if it exists"); ! 2531: } ! 2532: } ! 2533: ! 2534: /* Set up a cross reference so that type TYPE will make member function ! 2535: CTYPE::DECL a friend when CTYPE is finally defined. For more than ! 2536: one, set up a cross reference so that functions with the name DECL ! 2537: and type CTYPE know that they are friends of TYPE. */ ! 2538: static void ! 2539: xref_friend (type, decl, ctype) ! 2540: tree type, decl, ctype; ! 2541: { ! 2542: tree friend_decl = TYPE_NAME (ctype); ! 2543: #if 0 ! 2544: tree typedecl = TYPE_NAME (type); ! 2545: tree t = tree_cons (NULL_TREE, ctype, DECL_UNDEFINED_FRIENDS (typedecl)); ! 2546: ! 2547: DECL_UNDEFINED_FRIENDS (typedecl) = t; ! 2548: #else ! 2549: tree t = 0; ! 2550: #endif ! 2551: SET_DECL_WAITING_FRIENDS (friend_decl, ! 2552: tree_cons (type, t, ! 2553: DECL_WAITING_FRIENDS (friend_decl))); ! 2554: TREE_TYPE (DECL_WAITING_FRIENDS (friend_decl)) = decl; ! 2555: } ! 2556: ! 2557: /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already ! 2558: been defined, we make all of its member functions friends of ! 2559: TYPE. If not, we make it a pending friend, which can later be added ! 2560: when its definition is seen. If a type is defined, then its TYPE_DECL's ! 2561: DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend ! 2562: classes that are not defined. If a type has not yet been defined, ! 2563: then the DECL_WAITING_FRIENDS contains a list of types ! 2564: waiting to make it their friend. Note that these two can both ! 2565: be in use at the same time! */ ! 2566: void ! 2567: make_friend_class (type, friend_type) ! 2568: tree type, friend_type; ! 2569: { ! 2570: tree classes; ! 2571: ! 2572: if (IS_SIGNATURE (type)) ! 2573: { ! 2574: error ("`friend' declaration in signature definition"); ! 2575: return; ! 2576: } ! 2577: if (IS_SIGNATURE (friend_type)) ! 2578: { ! 2579: error ("signature type `%s' declared `friend'", ! 2580: IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (friend_type)))); ! 2581: return; ! 2582: } ! 2583: if (type == friend_type) ! 2584: { ! 2585: warning ("class `%s' is implicitly friends with itself", ! 2586: TYPE_NAME_STRING (type)); ! 2587: return; ! 2588: } ! 2589: ! 2590: GNU_xref_hier (TYPE_NAME_STRING (type), ! 2591: TYPE_NAME_STRING (friend_type), 0, 0, 1); ! 2592: ! 2593: classes = CLASSTYPE_FRIEND_CLASSES (type); ! 2594: while (classes && TREE_VALUE (classes) != friend_type) ! 2595: classes = TREE_CHAIN (classes); ! 2596: if (classes) ! 2597: warning ("class `%s' is already friends with class `%s'", ! 2598: TYPE_NAME_STRING (TREE_VALUE (classes)), TYPE_NAME_STRING (type)); ! 2599: else ! 2600: { ! 2601: CLASSTYPE_FRIEND_CLASSES (type) ! 2602: = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type)); ! 2603: } ! 2604: } ! 2605: ! 2606: /* Main friend processor. This is large, and for modularity purposes, ! 2607: has been removed from grokdeclarator. It returns `void_type_node' ! 2608: to indicate that something happened, though a FIELD_DECL is ! 2609: not returned. ! 2610: ! 2611: CTYPE is the class this friend belongs to. ! 2612: ! 2613: DECLARATOR is the name of the friend. ! 2614: ! 2615: DECL is the FUNCTION_DECL that the friend is. ! 2616: ! 2617: In case we are parsing a friend which is part of an inline ! 2618: definition, we will need to store PARM_DECL chain that comes ! 2619: with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL. ! 2620: ! 2621: FLAGS is just used for `grokclassfn'. ! 2622: ! 2623: QUALS say what special qualifies should apply to the object ! 2624: pointed to by `this'. */ ! 2625: tree ! 2626: do_friend (ctype, declarator, decl, parmdecls, flags, quals) ! 2627: tree ctype, declarator, decl, parmdecls; ! 2628: enum overload_flags flags; ! 2629: tree quals; ! 2630: { ! 2631: /* Every decl that gets here is a friend of something. */ ! 2632: DECL_FRIEND_P (decl) = 1; ! 2633: ! 2634: if (ctype) ! 2635: { ! 2636: tree cname = TYPE_NAME (ctype); ! 2637: if (TREE_CODE (cname) == TYPE_DECL) ! 2638: cname = DECL_NAME (cname); ! 2639: ! 2640: /* A method friend. */ ! 2641: if (TREE_CODE (decl) == FUNCTION_DECL) ! 2642: { ! 2643: if (flags == NO_SPECIAL && ctype && declarator == cname) ! 2644: DECL_CONSTRUCTOR_P (decl) = 1; ! 2645: ! 2646: /* This will set up DECL_ARGUMENTS for us. */ ! 2647: grokclassfn (ctype, cname, decl, flags, quals); ! 2648: if (TYPE_SIZE (ctype) != 0) ! 2649: check_classfn (ctype, cname, decl); ! 2650: ! 2651: if (TREE_TYPE (decl) != error_mark_node) ! 2652: { ! 2653: if (TYPE_SIZE (ctype)) ! 2654: { ! 2655: /* We don't call pushdecl here yet, or ever on this ! 2656: actual FUNCTION_DECL. We must preserve its TREE_CHAIN ! 2657: until the end. */ ! 2658: make_decl_rtl (decl, NULL_PTR, 1); ! 2659: add_friend (current_class_type, decl); ! 2660: } ! 2661: else ! 2662: { ! 2663: register char *classname ! 2664: = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (ctype))); ! 2665: ! 2666: error ("member declared as friend before type `%s' defined", ! 2667: classname); ! 2668: } ! 2669: } ! 2670: } ! 2671: else ! 2672: { ! 2673: /* Possibly a bunch of method friends. */ ! 2674: ! 2675: /* Get the class they belong to. */ ! 2676: tree ctype = IDENTIFIER_TYPE_VALUE (cname); ! 2677: ! 2678: /* This class is defined, use its methods now. */ ! 2679: if (TYPE_SIZE (ctype)) ! 2680: { ! 2681: tree fields = lookup_fnfields (TYPE_BINFO (ctype), declarator, 0); ! 2682: if (fields) ! 2683: add_friends (current_class_type, declarator, ctype); ! 2684: else ! 2685: error ("method `%s' is not a member of class `%s'", ! 2686: IDENTIFIER_POINTER (declarator), ! 2687: IDENTIFIER_POINTER (cname)); ! 2688: } ! 2689: else ! 2690: /* Note: DECLARATOR actually has more than one; in this ! 2691: case, we're making sure that fns with the name DECLARATOR ! 2692: and type CTYPE know they are friends of the current ! 2693: class type. */ ! 2694: xref_friend (current_class_type, declarator, ctype); ! 2695: decl = void_type_node; ! 2696: } ! 2697: } ! 2698: else if (TREE_CODE (decl) == FUNCTION_DECL ! 2699: && ((IDENTIFIER_LENGTH (declarator) == 4 ! 2700: && IDENTIFIER_POINTER (declarator)[0] == 'm' ! 2701: && ! strcmp (IDENTIFIER_POINTER (declarator), "main")) ! 2702: || (IDENTIFIER_LENGTH (declarator) > 10 ! 2703: && IDENTIFIER_POINTER (declarator)[0] == '_' ! 2704: && IDENTIFIER_POINTER (declarator)[1] == '_' ! 2705: && strncmp (IDENTIFIER_POINTER (declarator)+2, ! 2706: "builtin_", 8) == 0))) ! 2707: { ! 2708: /* raw "main", and builtin functions never gets overloaded, ! 2709: but they can become friends. */ ! 2710: TREE_PUBLIC (decl) = 1; ! 2711: add_friend (current_class_type, decl); ! 2712: DECL_FRIEND_P (decl) = 1; ! 2713: decl = void_type_node; ! 2714: } ! 2715: /* A global friend. ! 2716: @@ or possibly a friend from a base class ?!? */ ! 2717: else if (TREE_CODE (decl) == FUNCTION_DECL) ! 2718: { ! 2719: /* Friends must all go through the overload machinery, ! 2720: even though they may not technically be overloaded. ! 2721: ! 2722: Note that because classes all wind up being top-level ! 2723: in their scope, their friend wind up in top-level scope as well. */ ! 2724: DECL_ASSEMBLER_NAME (decl) ! 2725: = build_decl_overload (declarator, TYPE_ARG_TYPES (TREE_TYPE (decl)), ! 2726: TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE); ! 2727: DECL_ARGUMENTS (decl) = parmdecls; ! 2728: DECL_CLASS_CONTEXT (decl) = current_class_type; ! 2729: ! 2730: /* We can call pushdecl here, because the TREE_CHAIN of this ! 2731: FUNCTION_DECL is not needed for other purposes. */ ! 2732: decl = pushdecl (decl); ! 2733: ! 2734: make_decl_rtl (decl, NULL_PTR, 1); ! 2735: add_friend (current_class_type, decl); ! 2736: ! 2737: DECL_FRIEND_P (decl) = 1; ! 2738: #if 0 ! 2739: TREE_OVERLOADED (declarator) = 1; ! 2740: #endif ! 2741: } ! 2742: else ! 2743: { ! 2744: /* @@ Should be able to ingest later definitions of this function ! 2745: before use. */ ! 2746: tree decl = lookup_name_nonclass (declarator); ! 2747: if (decl == NULL_TREE) ! 2748: { ! 2749: warning ("implicitly declaring `%s' as struct", ! 2750: IDENTIFIER_POINTER (declarator)); ! 2751: decl = xref_tag (record_type_node, declarator, NULL_TREE, 1); ! 2752: decl = TYPE_NAME (decl); ! 2753: } ! 2754: ! 2755: /* Allow abbreviated declarations of overloaded functions, ! 2756: but not if those functions are really class names. */ ! 2757: if (TREE_CODE (decl) == TREE_LIST && TREE_TYPE (TREE_PURPOSE (decl))) ! 2758: { ! 2759: warning ("`friend %s' archaic, use `friend class %s' instead", ! 2760: IDENTIFIER_POINTER (declarator), ! 2761: IDENTIFIER_POINTER (declarator)); ! 2762: decl = TREE_TYPE (TREE_PURPOSE (decl)); ! 2763: } ! 2764: ! 2765: if (TREE_CODE (decl) == TREE_LIST) ! 2766: add_friends (current_class_type, TREE_PURPOSE (decl), NULL_TREE); ! 2767: else ! 2768: make_friend_class (current_class_type, TREE_TYPE (decl)); ! 2769: decl = void_type_node; ! 2770: } ! 2771: return decl; ! 2772: } ! 2773: ! 2774: /* TYPE has now been defined. It may, however, have a number of things ! 2775: waiting make make it their friend. We resolve these references ! 2776: here. */ ! 2777: void ! 2778: embrace_waiting_friends (type) ! 2779: tree type; ! 2780: { ! 2781: tree decl = TYPE_NAME (type); ! 2782: tree waiters; ! 2783: ! 2784: if (TREE_CODE (decl) != TYPE_DECL) ! 2785: return; ! 2786: ! 2787: for (waiters = DECL_WAITING_FRIENDS (decl); waiters; ! 2788: waiters = TREE_CHAIN (waiters)) ! 2789: { ! 2790: tree waiter = TREE_PURPOSE (waiters); ! 2791: #if 0 ! 2792: tree waiter_prev = TREE_VALUE (waiters); ! 2793: #endif ! 2794: tree decl = TREE_TYPE (waiters); ! 2795: tree name = decl ? (TREE_CODE (decl) == IDENTIFIER_NODE ! 2796: ? decl : DECL_NAME (decl)) : NULL_TREE; ! 2797: if (name) ! 2798: { ! 2799: /* @@ There may be work to be done since we have not verified ! 2800: @@ consistency between original and friend declarations ! 2801: @@ of the functions waiting to become friends. */ ! 2802: tree field = lookup_fnfields (TYPE_BINFO (type), name, 0); ! 2803: if (field) ! 2804: if (decl == name) ! 2805: add_friends (waiter, name, type); ! 2806: else ! 2807: add_friend (waiter, decl); ! 2808: else ! 2809: error_with_file_and_line (DECL_SOURCE_FILE (TYPE_NAME (waiter)), ! 2810: DECL_SOURCE_LINE (TYPE_NAME (waiter)), ! 2811: "no method `%s' defined in class `%s' to be friend", ! 2812: IDENTIFIER_POINTER (DECL_NAME (TREE_TYPE (waiters))), ! 2813: TYPE_NAME_STRING (type)); ! 2814: } ! 2815: else ! 2816: make_friend_class (type, waiter); ! 2817: ! 2818: #if 0 ! 2819: if (TREE_CHAIN (waiter_prev)) ! 2820: TREE_CHAIN (waiter_prev) = TREE_CHAIN (TREE_CHAIN (waiter_prev)); ! 2821: else ! 2822: DECL_UNDEFINED_FRIENDS (TYPE_NAME (waiter)) = NULL_TREE; ! 2823: #endif ! 2824: } ! 2825: } ! 2826: ! 2827: /* Common subroutines of build_new and build_vec_delete. */ ! 2828: ! 2829: /* Common interface for calling "builtin" functions that are not ! 2830: really builtin. */ ! 2831: ! 2832: tree ! 2833: build_builtin_call (type, node, arglist) ! 2834: tree type; ! 2835: tree node; ! 2836: tree arglist; ! 2837: { ! 2838: tree rval = build (CALL_EXPR, type, node, arglist, 0); ! 2839: TREE_SIDE_EFFECTS (rval) = 1; ! 2840: assemble_external (TREE_OPERAND (node, 0)); ! 2841: TREE_USED (TREE_OPERAND (node, 0)) = 1; ! 2842: return rval; ! 2843: } ! 2844: ! 2845: /* Generate a C++ "new" expression. DECL is either a TREE_LIST ! 2846: (which needs to go through some sort of groktypename) or it ! 2847: is the name of the class we are newing. INIT is an initialization value. ! 2848: It is either an EXPRLIST, an EXPR_NO_COMMAS, or something in braces. ! 2849: If INIT is void_type_node, it means do *not* call a constructor ! 2850: for this instance. ! 2851: ! 2852: For types with constructors, the data returned is initialized ! 2853: by the appropriate constructor. ! 2854: ! 2855: Whether the type has a constructor or not, if it has a pointer ! 2856: to a virtual function table, then that pointer is set up ! 2857: here. ! 2858: ! 2859: Unless I am mistaken, a call to new () will return initialized ! 2860: data regardless of whether the constructor itself is private or ! 2861: not. NOPE; new fails if the constructor is private (jcm). ! 2862: ! 2863: Note that build_new does nothing to assure that any special ! 2864: alignment requirements of the type are met. Rather, it leaves ! 2865: it up to malloc to do the right thing. Otherwise, folding to ! 2866: the right alignment cal cause problems if the user tries to later ! 2867: free the memory returned by `new'. ! 2868: ! 2869: PLACEMENT is the `placement' list for user-defined operator new (). */ ! 2870: ! 2871: tree ! 2872: build_new (placement, decl, init, use_global_new) ! 2873: tree placement; ! 2874: tree decl, init; ! 2875: int use_global_new; ! 2876: { ! 2877: tree type, true_type, size, rval; ! 2878: tree nelts; ! 2879: int has_array = 0; ! 2880: enum tree_code code = NEW_EXPR; ! 2881: ! 2882: tree pending_sizes = NULL_TREE; ! 2883: ! 2884: if (decl == error_mark_node) ! 2885: return error_mark_node; ! 2886: ! 2887: if (TREE_CODE (decl) == TREE_LIST) ! 2888: { ! 2889: tree absdcl = TREE_VALUE (decl); ! 2890: tree last_absdcl = NULL_TREE; ! 2891: int old_immediate_size_expand; ! 2892: ! 2893: if (current_function_decl ! 2894: && DECL_CONSTRUCTOR_P (current_function_decl)) ! 2895: { ! 2896: old_immediate_size_expand = immediate_size_expand; ! 2897: immediate_size_expand = 0; ! 2898: } ! 2899: ! 2900: nelts = integer_one_node; ! 2901: ! 2902: if (absdcl && TREE_CODE (absdcl) == CALL_EXPR) ! 2903: my_friendly_abort (215); ! 2904: while (absdcl && TREE_CODE (absdcl) == INDIRECT_REF) ! 2905: { ! 2906: last_absdcl = absdcl; ! 2907: absdcl = TREE_OPERAND (absdcl, 0); ! 2908: } ! 2909: ! 2910: if (absdcl && TREE_CODE (absdcl) == ARRAY_REF) ! 2911: { ! 2912: /* probably meant to be a vec new */ ! 2913: tree this_nelts; ! 2914: ! 2915: while (TREE_OPERAND (absdcl, 0) ! 2916: && TREE_CODE (TREE_OPERAND (absdcl, 0)) == ARRAY_REF) ! 2917: { ! 2918: last_absdcl = absdcl; ! 2919: absdcl = TREE_OPERAND (absdcl, 0); ! 2920: } ! 2921: ! 2922: has_array = 1; ! 2923: this_nelts = TREE_OPERAND (absdcl, 1); ! 2924: if (this_nelts != error_mark_node) ! 2925: { ! 2926: if (this_nelts == NULL_TREE) ! 2927: error ("new of array type fails to specify size"); ! 2928: else ! 2929: { ! 2930: this_nelts = save_expr (convert (sizetype, this_nelts)); ! 2931: absdcl = TREE_OPERAND (absdcl, 0); ! 2932: if (this_nelts == integer_zero_node) ! 2933: { ! 2934: warning ("zero size array reserves no space"); ! 2935: nelts = integer_zero_node; ! 2936: } ! 2937: else ! 2938: nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1); ! 2939: } ! 2940: } ! 2941: else ! 2942: nelts = integer_zero_node; ! 2943: } ! 2944: ! 2945: if (last_absdcl) ! 2946: TREE_OPERAND (last_absdcl, 0) = absdcl; ! 2947: else ! 2948: TREE_VALUE (decl) = absdcl; ! 2949: ! 2950: type = true_type = groktypename (decl); ! 2951: if (! type || type == error_mark_node) ! 2952: { ! 2953: immediate_size_expand = old_immediate_size_expand; ! 2954: return error_mark_node; ! 2955: } ! 2956: ! 2957: if (current_function_decl ! 2958: && DECL_CONSTRUCTOR_P (current_function_decl)) ! 2959: { ! 2960: pending_sizes = get_pending_sizes (); ! 2961: immediate_size_expand = old_immediate_size_expand; ! 2962: } ! 2963: } ! 2964: else if (TREE_CODE (decl) == IDENTIFIER_NODE) ! 2965: { ! 2966: if (IDENTIFIER_HAS_TYPE_VALUE (decl)) ! 2967: { ! 2968: /* An aggregate type. */ ! 2969: type = IDENTIFIER_TYPE_VALUE (decl); ! 2970: decl = TYPE_NAME (type); ! 2971: } ! 2972: else ! 2973: { ! 2974: /* A builtin type. */ ! 2975: decl = lookup_name (decl, 1); ! 2976: my_friendly_assert (TREE_CODE (decl) == TYPE_DECL, 215); ! 2977: type = TREE_TYPE (decl); ! 2978: } ! 2979: true_type = type; ! 2980: } ! 2981: else if (TREE_CODE (decl) == TYPE_DECL) ! 2982: { ! 2983: type = TREE_TYPE (decl); ! 2984: true_type = type; ! 2985: } ! 2986: else ! 2987: { ! 2988: type = decl; ! 2989: true_type = type; ! 2990: decl = TYPE_NAME (type); ! 2991: } ! 2992: ! 2993: /* ``A reference cannot be created by the new operator. A reference ! 2994: is not an object (8.2.2, 8.4.3), so a pointer to it could not be ! 2995: returned by new.'' ARM 5.3.3 */ ! 2996: if (TREE_CODE (type) == REFERENCE_TYPE) ! 2997: { ! 2998: error ("new cannot be applied to a reference type"); ! 2999: type = true_type = TREE_TYPE (type); ! 3000: } ! 3001: ! 3002: /* When the object being created is an array, the new-expression yields a ! 3003: pointer to the initial element (if any) of the array. For example, ! 3004: both new int and new int[10] return an int*. 5.3.4. */ ! 3005: if (TREE_CODE (type) == ARRAY_TYPE && has_array == 0) ! 3006: { ! 3007: nelts = array_type_nelts_top (type); ! 3008: has_array = 1; ! 3009: type = true_type = TREE_TYPE (type); ! 3010: } ! 3011: ! 3012: if (TYPE_READONLY (type) || TYPE_VOLATILE (type)) ! 3013: { ! 3014: pedwarn ("const and volatile types cannot be created with operator new"); ! 3015: type = true_type = TYPE_MAIN_VARIANT (type); ! 3016: } ! 3017: ! 3018: /* If our base type is an array, then make sure we know how many elements ! 3019: it has. */ ! 3020: while (TREE_CODE (true_type) == ARRAY_TYPE) ! 3021: { ! 3022: tree this_nelts = array_type_nelts_top (true_type); ! 3023: nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1); ! 3024: true_type = TREE_TYPE (true_type); ! 3025: } ! 3026: if (has_array) ! 3027: size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type), ! 3028: nelts, 1)); ! 3029: else ! 3030: size = size_in_bytes (type); ! 3031: ! 3032: if (TYPE_SIZE (true_type) == 0) ! 3033: { ! 3034: if (true_type == void_type_node) ! 3035: error ("invalid type for new: `void'"); ! 3036: else ! 3037: incomplete_type_error (0, true_type); ! 3038: return error_mark_node; ! 3039: } ! 3040: ! 3041: if (TYPE_LANG_SPECIFIC (true_type) ! 3042: && CLASSTYPE_ABSTRACT_VIRTUALS (true_type)) ! 3043: { ! 3044: abstract_virtuals_error (NULL_TREE, true_type); ! 3045: return error_mark_node; ! 3046: } ! 3047: ! 3048: if (TYPE_LANG_SPECIFIC (true_type) && IS_SIGNATURE (true_type)) ! 3049: { ! 3050: signature_error (NULL_TREE, true_type); ! 3051: return error_mark_node; ! 3052: } ! 3053: ! 3054: /* Get a little extra space to store a couple of things before the new'ed ! 3055: array. */ ! 3056: if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)) ! 3057: { ! 3058: tree extra = BI_header_size; ! 3059: ! 3060: size = size_binop (PLUS_EXPR, size, extra); ! 3061: } ! 3062: ! 3063: if (has_array) ! 3064: code = VEC_NEW_EXPR; ! 3065: ! 3066: /* Allocate the object. */ ! 3067: if (! use_global_new && TYPE_LANG_SPECIFIC (true_type) ! 3068: && (TYPE_GETS_NEW (true_type) & (1 << has_array))) ! 3069: rval = build_opfncall (code, LOOKUP_NORMAL, ! 3070: TYPE_POINTER_TO (true_type), size, placement); ! 3071: else if (placement) ! 3072: { ! 3073: rval = build_opfncall (code, LOOKUP_GLOBAL|LOOKUP_COMPLAIN, ! 3074: ptr_type_node, size, placement); ! 3075: rval = convert (TYPE_POINTER_TO (true_type), rval); ! 3076: } ! 3077: else if (! has_array && flag_this_is_variable > 0 ! 3078: && TYPE_HAS_CONSTRUCTOR (true_type) && init != void_type_node) ! 3079: { ! 3080: if (init == NULL_TREE || TREE_CODE (init) == TREE_LIST) ! 3081: rval = NULL_TREE; ! 3082: else ! 3083: { ! 3084: error ("constructors take parameter lists"); ! 3085: return error_mark_node; ! 3086: } ! 3087: } ! 3088: else ! 3089: { ! 3090: rval = build_builtin_call (build_pointer_type (true_type), ! 3091: has_array ? BIVN : BIN, ! 3092: build_tree_list (NULL_TREE, size)); ! 3093: #if 0 ! 3094: /* See comment above as to why this is disabled. */ ! 3095: if (alignment) ! 3096: { ! 3097: rval = build (PLUS_EXPR, TYPE_POINTER_TO (true_type), rval, ! 3098: alignment); ! 3099: rval = build (BIT_AND_EXPR, TYPE_POINTER_TO (true_type), ! 3100: rval, build1 (BIT_NOT_EXPR, integer_type_node, ! 3101: alignment)); ! 3102: } ! 3103: #endif ! 3104: TREE_CALLS_NEW (rval) = 1; ! 3105: } ! 3106: ! 3107: /* if rval is NULL_TREE I don't have to allocate it, but are we totally ! 3108: sure we have some extra bytes in that case for the BI_header_size ! 3109: cookies? And how does that interact with the code below? (mrs) */ ! 3110: /* Finish up some magic for new'ed arrays */ ! 3111: if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type) && rval != NULL_TREE) ! 3112: { ! 3113: tree extra = BI_header_size; ! 3114: tree cookie, exp1; ! 3115: rval = convert (ptr_type_node, rval); /* convert to void * first */ ! 3116: rval = convert (string_type_node, rval); /* lets not add void* and ints */ ! 3117: rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra, 1)); ! 3118: /* Store header info. */ ! 3119: cookie = build_indirect_ref (build (MINUS_EXPR, TYPE_POINTER_TO (BI_header_type), ! 3120: rval, extra), NULL_PTR); ! 3121: exp1 = build (MODIFY_EXPR, void_type_node, ! 3122: build_component_ref (cookie, nc_nelts_field_id, 0, 0), ! 3123: nelts); ! 3124: TREE_SIDE_EFFECTS (exp1) = 1; ! 3125: rval = convert (build_pointer_type (true_type), rval); ! 3126: TREE_CALLS_NEW (rval) = 1; ! 3127: TREE_SIDE_EFFECTS (rval) = 1; ! 3128: rval = build_compound_expr (tree_cons (NULL_TREE, exp1, ! 3129: build_tree_list (NULL_TREE, rval))); ! 3130: } ! 3131: ! 3132: /* We've figured out where the allocation is to go. ! 3133: If we're not eliding constructors, then if a constructor ! 3134: is defined, we must go through it. */ ! 3135: if (!has_array && (rval == NULL_TREE || !flag_elide_constructors) ! 3136: && TYPE_HAS_CONSTRUCTOR (true_type) && init != void_type_node) ! 3137: { ! 3138: tree newrval; ! 3139: /* Constructors are never virtual. If it has an initialization, we ! 3140: need to complain if we aren't allowed to use the ctor that took ! 3141: that argument. */ ! 3142: int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_COMPLAIN; ! 3143: ! 3144: /* If a copy constructor might work, set things up so that we can ! 3145: try that after this. We deliberately don't clear LOOKUP_COMPLAIN ! 3146: any more, since that would make it impossible to rationally use ! 3147: the access of a constructor that matches perfectly. */ ! 3148: #if 0 ! 3149: if (rval != NULL_TREE) ! 3150: flags |= LOOKUP_SPECULATIVELY; ! 3151: #endif ! 3152: ! 3153: if (rval && TYPE_USES_VIRTUAL_BASECLASSES (true_type)) ! 3154: { ! 3155: init = tree_cons (NULL_TREE, integer_one_node, init); ! 3156: flags |= LOOKUP_HAS_IN_CHARGE; ! 3157: } ! 3158: ! 3159: { ! 3160: tree tmp = rval; ! 3161: ! 3162: if (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE) ! 3163: tmp = build_indirect_ref (tmp, NULL_PTR); ! 3164: ! 3165: newrval = build_method_call (tmp, constructor_name_full (true_type), ! 3166: init, NULL_TREE, flags); ! 3167: } ! 3168: ! 3169: if (newrval) ! 3170: { ! 3171: rval = newrval; ! 3172: TREE_HAS_CONSTRUCTOR (rval) = 1; ! 3173: } ! 3174: else ! 3175: rval = error_mark_node; ! 3176: goto done; ! 3177: } ! 3178: ! 3179: if (rval == error_mark_node) ! 3180: return error_mark_node; ! 3181: rval = save_expr (rval); ! 3182: TREE_HAS_CONSTRUCTOR (rval) = 1; ! 3183: ! 3184: /* Don't call any constructors or do any initialization. */ ! 3185: if (init == void_type_node) ! 3186: goto done; ! 3187: ! 3188: if (TYPE_NEEDS_CONSTRUCTING (type) || init) ! 3189: { ! 3190: if (! TYPE_NEEDS_CONSTRUCTING (type) && ! IS_AGGR_TYPE (type)) ! 3191: { ! 3192: /* New 2.0 interpretation: `new int (10)' means ! 3193: allocate an int, and initialize it with 10. */ ! 3194: ! 3195: init = build_c_cast (type, init); ! 3196: rval = build (COMPOUND_EXPR, TREE_TYPE (rval), ! 3197: build_modify_expr (build_indirect_ref (rval, NULL_PTR), ! 3198: NOP_EXPR, init), ! 3199: rval); ! 3200: TREE_SIDE_EFFECTS (rval) = 1; ! 3201: TREE_CALLS_NEW (rval) = 1; ! 3202: } ! 3203: else if (current_function_decl == NULL_TREE) ! 3204: { ! 3205: extern tree static_aggregates; ! 3206: ! 3207: /* In case of static initialization, SAVE_EXPR is good enough. */ ! 3208: init = copy_to_permanent (init); ! 3209: rval = copy_to_permanent (rval); ! 3210: static_aggregates = perm_tree_cons (init, rval, static_aggregates); ! 3211: } ! 3212: else ! 3213: { ! 3214: /* Have to wrap this in RTL_EXPR for two cases: ! 3215: in base or member initialization and if we ! 3216: are a branch of a ?: operator. Since we ! 3217: can't easily know the latter, just do it always. */ ! 3218: tree xval = make_node (RTL_EXPR); ! 3219: ! 3220: TREE_TYPE (xval) = TREE_TYPE (rval); ! 3221: do_pending_stack_adjust (); ! 3222: start_sequence_for_rtl_expr (xval); ! 3223: ! 3224: /* As a matter of principle, `start_sequence' should do this. */ ! 3225: emit_note (0, -1); ! 3226: ! 3227: if (has_array) ! 3228: rval = expand_vec_init (decl, rval, ! 3229: build_binary_op (MINUS_EXPR, nelts, integer_one_node, 1), ! 3230: init, 0); ! 3231: else ! 3232: expand_aggr_init (build_indirect_ref (rval, NULL_PTR), init, 0); ! 3233: ! 3234: do_pending_stack_adjust (); ! 3235: ! 3236: TREE_SIDE_EFFECTS (xval) = 1; ! 3237: TREE_CALLS_NEW (xval) = 1; ! 3238: RTL_EXPR_SEQUENCE (xval) = get_insns (); ! 3239: end_sequence (); ! 3240: ! 3241: if (TREE_CODE (rval) == SAVE_EXPR) ! 3242: { ! 3243: /* Errors may cause this to not get evaluated. */ ! 3244: if (SAVE_EXPR_RTL (rval) == 0) ! 3245: SAVE_EXPR_RTL (rval) = const0_rtx; ! 3246: RTL_EXPR_RTL (xval) = SAVE_EXPR_RTL (rval); ! 3247: } ! 3248: else ! 3249: { ! 3250: my_friendly_assert (TREE_CODE (rval) == VAR_DECL, 217); ! 3251: RTL_EXPR_RTL (xval) = DECL_RTL (rval); ! 3252: } ! 3253: rval = xval; ! 3254: } ! 3255: } ! 3256: done: ! 3257: if (rval && TREE_TYPE (rval) != build_pointer_type (type)) ! 3258: { ! 3259: /* The type of new int [3][3] is not int *, but int [3] * */ ! 3260: rval = build_c_cast (build_pointer_type (type), rval); ! 3261: } ! 3262: ! 3263: if (pending_sizes) ! 3264: rval = build_compound_expr (chainon (pending_sizes, ! 3265: build_tree_list (NULL_TREE, rval))); ! 3266: ! 3267: if (flag_gc) ! 3268: { ! 3269: extern tree gc_visible; ! 3270: tree objbits; ! 3271: tree update_expr; ! 3272: ! 3273: rval = save_expr (rval); ! 3274: /* We don't need a `headof' operation to do this because ! 3275: we know where the object starts. */ ! 3276: objbits = build1 (INDIRECT_REF, unsigned_type_node, ! 3277: build (MINUS_EXPR, ptr_type_node, ! 3278: rval, c_sizeof_nowarn (unsigned_type_node))); ! 3279: update_expr = build_modify_expr (objbits, BIT_IOR_EXPR, gc_visible); ! 3280: rval = build_compound_expr (tree_cons (NULL_TREE, rval, ! 3281: tree_cons (NULL_TREE, update_expr, ! 3282: build_tree_list (NULL_TREE, rval)))); ! 3283: } ! 3284: ! 3285: return rval; ! 3286: } ! 3287: ! 3288: /* `expand_vec_init' performs initialization of a vector of aggregate ! 3289: types. ! 3290: ! 3291: DECL is passed only for error reporting, and provides line number ! 3292: and source file name information. ! 3293: BASE is the space where the vector will be. ! 3294: MAXINDEX is the maximum index of the array (one less than the ! 3295: number of elements). ! 3296: INIT is the (possibly NULL) initializer. ! 3297: ! 3298: FROM_ARRAY is 0 if we should init everything with INIT ! 3299: (i.e., every element initialized from INIT). ! 3300: FROM_ARRAY is 1 if we should index into INIT in parallel ! 3301: with initialization of DECL. ! 3302: FROM_ARRAY is 2 if we should index into INIT in parallel, ! 3303: but use assignment instead of initialization. */ ! 3304: ! 3305: tree ! 3306: expand_vec_init (decl, base, maxindex, init, from_array) ! 3307: tree decl, base, maxindex, init; ! 3308: int from_array; ! 3309: { ! 3310: tree rval; ! 3311: tree iterator, base2 = NULL_TREE; ! 3312: tree type = TREE_TYPE (TREE_TYPE (base)); ! 3313: tree size; ! 3314: ! 3315: maxindex = convert (integer_type_node, maxindex); ! 3316: if (maxindex == error_mark_node) ! 3317: return error_mark_node; ! 3318: ! 3319: if (current_function_decl == NULL_TREE) ! 3320: { ! 3321: rval = make_tree_vec (3); ! 3322: TREE_VEC_ELT (rval, 0) = base; ! 3323: TREE_VEC_ELT (rval, 1) = maxindex; ! 3324: TREE_VEC_ELT (rval, 2) = init; ! 3325: return rval; ! 3326: } ! 3327: ! 3328: size = size_in_bytes (type); ! 3329: ! 3330: /* Set to zero in case size is <= 0. Optimizer will delete this if ! 3331: it is not needed. */ ! 3332: rval = get_temp_regvar (TYPE_POINTER_TO (type), ! 3333: convert (TYPE_POINTER_TO (type), null_pointer_node)); ! 3334: base = default_conversion (base); ! 3335: base = convert (TYPE_POINTER_TO (type), base); ! 3336: expand_assignment (rval, base, 0, 0); ! 3337: base = get_temp_regvar (TYPE_POINTER_TO (type), base); ! 3338: ! 3339: if (init != NULL_TREE ! 3340: && TREE_CODE (init) == CONSTRUCTOR ! 3341: && TREE_TYPE (init) == TREE_TYPE (decl)) ! 3342: { ! 3343: /* Initialization of array from {...}. */ ! 3344: tree elts = CONSTRUCTOR_ELTS (init); ! 3345: tree baseref = build1 (INDIRECT_REF, type, base); ! 3346: tree baseinc = build (PLUS_EXPR, TYPE_POINTER_TO (type), base, size); ! 3347: int host_i = TREE_INT_CST_LOW (maxindex); ! 3348: ! 3349: if (IS_AGGR_TYPE (type)) ! 3350: { ! 3351: while (elts) ! 3352: { ! 3353: host_i -= 1; ! 3354: expand_aggr_init (baseref, TREE_VALUE (elts), 0); ! 3355: ! 3356: expand_assignment (base, baseinc, 0, 0); ! 3357: elts = TREE_CHAIN (elts); ! 3358: } ! 3359: /* Initialize any elements by default if possible. */ ! 3360: if (host_i >= 0) ! 3361: { ! 3362: if (TYPE_NEEDS_CONSTRUCTING (type) == 0) ! 3363: { ! 3364: if (obey_regdecls) ! 3365: use_variable (DECL_RTL (base)); ! 3366: goto done_init; ! 3367: } ! 3368: ! 3369: iterator = get_temp_regvar (integer_type_node, ! 3370: build_int_2 (host_i, 0)); ! 3371: init = NULL_TREE; ! 3372: goto init_by_default; ! 3373: } ! 3374: } ! 3375: else ! 3376: while (elts) ! 3377: { ! 3378: expand_assignment (baseref, TREE_VALUE (elts), 0, 0); ! 3379: ! 3380: expand_assignment (base, baseinc, 0, 0); ! 3381: elts = TREE_CHAIN (elts); ! 3382: } ! 3383: ! 3384: if (obey_regdecls) ! 3385: use_variable (DECL_RTL (base)); ! 3386: } ! 3387: else ! 3388: { ! 3389: tree itype; ! 3390: ! 3391: iterator = get_temp_regvar (integer_type_node, maxindex); ! 3392: ! 3393: init_by_default: ! 3394: ! 3395: /* If initializing one array from another, ! 3396: initialize element by element. */ ! 3397: if (from_array) ! 3398: { ! 3399: /* We rely upon the below calls the do argument checking */ ! 3400: if (decl == NULL_TREE) ! 3401: { ! 3402: sorry ("initialization of array from dissimilar array type"); ! 3403: return error_mark_node; ! 3404: } ! 3405: if (init) ! 3406: { ! 3407: base2 = default_conversion (init); ! 3408: itype = TREE_TYPE (base2); ! 3409: base2 = get_temp_regvar (itype, base2); ! 3410: itype = TREE_TYPE (itype); ! 3411: } ! 3412: else if (TYPE_LANG_SPECIFIC (type) ! 3413: && TYPE_NEEDS_CONSTRUCTING (type) ! 3414: && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) ! 3415: { ! 3416: error ("initializer ends prematurely"); ! 3417: return error_mark_node; ! 3418: } ! 3419: } ! 3420: ! 3421: expand_start_cond (build (GE_EXPR, integer_type_node, ! 3422: iterator, integer_zero_node), 0); ! 3423: expand_start_loop_continue_elsewhere (1); ! 3424: ! 3425: if (from_array) ! 3426: { ! 3427: tree to = build1 (INDIRECT_REF, type, base); ! 3428: tree from; ! 3429: ! 3430: if (base2) ! 3431: from = build1 (INDIRECT_REF, itype, base2); ! 3432: else ! 3433: from = NULL_TREE; ! 3434: ! 3435: if (from_array == 2) ! 3436: expand_expr_stmt (build_modify_expr (to, NOP_EXPR, from)); ! 3437: else if (TYPE_NEEDS_CONSTRUCTING (type)) ! 3438: expand_aggr_init (to, from, 0); ! 3439: else if (from) ! 3440: expand_assignment (to, from, 0, 0); ! 3441: else ! 3442: my_friendly_abort (57); ! 3443: } ! 3444: else if (TREE_CODE (type) == ARRAY_TYPE) ! 3445: { ! 3446: if (init != 0) ! 3447: sorry ("cannot initialize multi-dimensional array with initializer"); ! 3448: expand_vec_init (decl, build1 (NOP_EXPR, TYPE_POINTER_TO (TREE_TYPE (type)), base), ! 3449: array_type_nelts (type), 0, 0); ! 3450: } ! 3451: else ! 3452: expand_aggr_init (build1 (INDIRECT_REF, type, base), init, 0); ! 3453: ! 3454: expand_assignment (base, ! 3455: build (PLUS_EXPR, TYPE_POINTER_TO (type), base, size), ! 3456: 0, 0); ! 3457: if (base2) ! 3458: expand_assignment (base2, ! 3459: build (PLUS_EXPR, TYPE_POINTER_TO (type), base2, size), 0, 0); ! 3460: expand_loop_continue_here (); ! 3461: expand_exit_loop_if_false (0, build (NE_EXPR, integer_type_node, ! 3462: build (PREDECREMENT_EXPR, integer_type_node, iterator, integer_one_node), minus_one)); ! 3463: ! 3464: if (obey_regdecls) ! 3465: { ! 3466: use_variable (DECL_RTL (base)); ! 3467: if (base2) ! 3468: use_variable (DECL_RTL (base2)); ! 3469: } ! 3470: expand_end_loop (); ! 3471: expand_end_cond (); ! 3472: if (obey_regdecls) ! 3473: use_variable (DECL_RTL (iterator)); ! 3474: } ! 3475: done_init: ! 3476: ! 3477: if (obey_regdecls) ! 3478: use_variable (DECL_RTL (rval)); ! 3479: return rval; ! 3480: } ! 3481: ! 3482: /* Free up storage of type TYPE, at address ADDR. ! 3483: ! 3484: TYPE is a POINTER_TYPE and can be ptr_type_node for no special type ! 3485: of pointer. ! 3486: ! 3487: VIRTUAL_SIZE is the amount of storage that was allocated, and is ! 3488: used as the second argument to operator delete. It can include ! 3489: things like padding and magic size cookies. It has virtual in it, ! 3490: because if you have a base pointer and you delete through a virtual ! 3491: destructor, it should be the size of the dynamic object, not the ! 3492: static object, see Free Store 12.5 ANSI C++ WP. ! 3493: ! 3494: This does not call any destructors. */ ! 3495: tree ! 3496: build_x_delete (type, addr, which_delete, virtual_size) ! 3497: tree type, addr; ! 3498: int which_delete; ! 3499: tree virtual_size; ! 3500: { ! 3501: int use_global_delete = which_delete & 1; ! 3502: int use_vec_delete = !!(which_delete & 2); ! 3503: tree rval; ! 3504: enum tree_code code = use_vec_delete ? VEC_DELETE_EXPR : DELETE_EXPR; ! 3505: ! 3506: if (! use_global_delete && TYPE_LANG_SPECIFIC (TREE_TYPE (type)) ! 3507: && (TYPE_GETS_DELETE (TREE_TYPE (type)) & (1 << use_vec_delete))) ! 3508: rval = build_opfncall (code, LOOKUP_NORMAL, addr, virtual_size, NULL_TREE); ! 3509: else ! 3510: rval = build_builtin_call (void_type_node, use_vec_delete ? BIVD : BID, ! 3511: build_tree_list (NULL_TREE, addr)); ! 3512: return rval; ! 3513: } ! 3514: ! 3515: /* Generate a call to a destructor. TYPE is the type to cast ADDR to. ! 3516: ADDR is an expression which yields the store to be destroyed. ! 3517: AUTO_DELETE is nonzero if a call to DELETE should be made or not. ! 3518: If in the program, (AUTO_DELETE & 2) is non-zero, we tear down the ! 3519: virtual baseclasses. ! 3520: If in the program, (AUTO_DELETE & 1) is non-zero, then we deallocate. ! 3521: ! 3522: FLAGS is the logical disjunction of zero or more LOOKUP_ ! 3523: flags. See cp-tree.h for more info. ! 3524: ! 3525: This function does not delete an object's virtual base classes. */ ! 3526: tree ! 3527: build_delete (type, addr, auto_delete, flags, use_global_delete) ! 3528: tree type, addr; ! 3529: tree auto_delete; ! 3530: int flags; ! 3531: int use_global_delete; ! 3532: { ! 3533: tree function, parms; ! 3534: tree member; ! 3535: tree expr; ! 3536: tree ref; ! 3537: int ptr; ! 3538: ! 3539: if (addr == error_mark_node) ! 3540: return error_mark_node; ! 3541: ! 3542: /* Can happen when CURRENT_EXCEPTION_OBJECT gets its type ! 3543: set to `error_mark_node' before it gets properly cleaned up. */ ! 3544: if (type == error_mark_node) ! 3545: return error_mark_node; ! 3546: ! 3547: type = TYPE_MAIN_VARIANT (type); ! 3548: ! 3549: if (TREE_CODE (type) == POINTER_TYPE) ! 3550: { ! 3551: type = TYPE_MAIN_VARIANT (TREE_TYPE (type)); ! 3552: if (TYPE_SIZE (type) == 0) ! 3553: { ! 3554: incomplete_type_error (0, type); ! 3555: return error_mark_node; ! 3556: } ! 3557: if (TREE_CODE (type) == ARRAY_TYPE) ! 3558: goto handle_array; ! 3559: if (! IS_AGGR_TYPE (type)) ! 3560: { ! 3561: /* Call the builtin operator delete. */ ! 3562: return build_builtin_call (void_type_node, BID, ! 3563: build_tree_list (NULL_TREE, addr)); ! 3564: } ! 3565: if (TREE_SIDE_EFFECTS (addr)) ! 3566: addr = save_expr (addr); ! 3567: ! 3568: /* throw away const and volatile on target type of addr */ ! 3569: addr = convert_force (build_pointer_type (type), addr); ! 3570: ref = build_indirect_ref (addr, NULL_PTR); ! 3571: ptr = 1; ! 3572: } ! 3573: else if (TREE_CODE (type) == ARRAY_TYPE) ! 3574: { ! 3575: handle_array: ! 3576: if (TREE_SIDE_EFFECTS (addr)) ! 3577: addr = save_expr (addr); ! 3578: return build_vec_delete (addr, array_type_nelts (type), ! 3579: c_sizeof_nowarn (TREE_TYPE (type)), ! 3580: auto_delete, integer_two_node, ! 3581: use_global_delete); ! 3582: } ! 3583: else ! 3584: { ! 3585: /* Don't check PROTECT here; leave that decision to the ! 3586: destructor. If the destructor is accessible, call it, ! 3587: else report error. */ ! 3588: addr = build_unary_op (ADDR_EXPR, addr, 0); ! 3589: if (TREE_SIDE_EFFECTS (addr)) ! 3590: addr = save_expr (addr); ! 3591: ! 3592: if (TREE_CONSTANT (addr)) ! 3593: addr = convert_pointer_to (type, addr); ! 3594: else ! 3595: addr = convert_force (build_pointer_type (type), addr); ! 3596: ! 3597: if (TREE_CODE (addr) == NOP_EXPR ! 3598: && TREE_OPERAND (addr, 0) == current_class_decl) ! 3599: ref = C_C_D; ! 3600: else ! 3601: ref = build_indirect_ref (addr, NULL_PTR); ! 3602: ptr = 0; ! 3603: } ! 3604: ! 3605: my_friendly_assert (IS_AGGR_TYPE (type), 220); ! 3606: ! 3607: if (! TYPE_NEEDS_DESTRUCTOR (type)) ! 3608: { ! 3609: if (auto_delete == integer_zero_node) ! 3610: return void_zero_node; ! 3611: ! 3612: /* Pass the size of the object down to the operator delete() in ! 3613: addition to the ADDR. */ ! 3614: if (TYPE_GETS_REG_DELETE (type) && !use_global_delete) ! 3615: { ! 3616: tree virtual_size = c_sizeof_nowarn (type); ! 3617: return build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr, ! 3618: virtual_size, NULL_TREE); ! 3619: } ! 3620: ! 3621: /* Call the builtin operator delete. */ ! 3622: return build_builtin_call (void_type_node, BID, ! 3623: build_tree_list (NULL_TREE, addr)); ! 3624: } ! 3625: parms = build_tree_list (NULL_TREE, addr); ! 3626: ! 3627: /* Below, we will reverse the order in which these calls are made. ! 3628: If we have a destructor, then that destructor will take care ! 3629: of the base classes; otherwise, we must do that here. */ ! 3630: if (TYPE_HAS_DESTRUCTOR (type)) ! 3631: { ! 3632: tree dtor = DECL_MAIN_VARIANT (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type), 0)); ! 3633: tree basetypes = TYPE_BINFO (type); ! 3634: tree passed_auto_delete; ! 3635: tree do_delete = NULL_TREE; ! 3636: ! 3637: if (use_global_delete) ! 3638: { ! 3639: tree cond = fold (build (BIT_AND_EXPR, integer_type_node, ! 3640: auto_delete, integer_one_node)); ! 3641: tree call = build_builtin_call ! 3642: (void_type_node, BID, build_tree_list (NULL_TREE, addr)); ! 3643: ! 3644: cond = fold (build (COND_EXPR, void_type_node, cond, ! 3645: call, void_zero_node)); ! 3646: if (cond != void_zero_node) ! 3647: do_delete = cond; ! 3648: ! 3649: passed_auto_delete = fold (build (BIT_AND_EXPR, integer_type_node, ! 3650: auto_delete, integer_two_node)); ! 3651: } ! 3652: else ! 3653: passed_auto_delete = auto_delete; ! 3654: ! 3655: if (flags & LOOKUP_PROTECT) ! 3656: { ! 3657: enum access_type access = compute_access (basetypes, dtor); ! 3658: ! 3659: if (access == access_private) ! 3660: { ! 3661: if (flags & LOOKUP_COMPLAIN) ! 3662: cp_error ("destructor for type `%T' is private in this scope", type); ! 3663: return error_mark_node; ! 3664: } ! 3665: else if (access == access_protected) ! 3666: { ! 3667: if (flags & LOOKUP_COMPLAIN) ! 3668: cp_error ("destructor for type `%T' is protected in this scope", type); ! 3669: return error_mark_node; ! 3670: } ! 3671: } ! 3672: ! 3673: /* Once we are in a destructor, try not going through ! 3674: the virtual function table to find the next destructor. */ ! 3675: if (DECL_VINDEX (dtor) ! 3676: && ! (flags & LOOKUP_NONVIRTUAL) ! 3677: && TREE_CODE (auto_delete) != PARM_DECL ! 3678: && (ptr == 1 || ! resolves_to_fixed_type_p (ref, 0))) ! 3679: { ! 3680: tree binfo, basetype; ! 3681: /* The code below is probably all broken. See call.c for the ! 3682: complete right way to do this. this offsets may not be right ! 3683: in the below. (mrs) */ ! 3684: /* This destructor must be called via virtual function table. */ ! 3685: dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (DECL_CONTEXT (dtor)), 0); ! 3686: basetype = DECL_CLASS_CONTEXT (dtor); ! 3687: binfo = get_binfo (basetype, ! 3688: TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))), ! 3689: 0); ! 3690: expr = convert_pointer_to_real (binfo, TREE_VALUE (parms)); ! 3691: if (expr != TREE_VALUE (parms)) ! 3692: { ! 3693: expr = fold (expr); ! 3694: ref = build_indirect_ref (expr, NULL_PTR); ! 3695: TREE_VALUE (parms) = expr; ! 3696: } ! 3697: function = build_vfn_ref (&TREE_VALUE (parms), ref, DECL_VINDEX (dtor)); ! 3698: if (function == error_mark_node) ! 3699: return error_mark_node; ! 3700: TREE_TYPE (function) = build_pointer_type (TREE_TYPE (dtor)); ! 3701: TREE_CHAIN (parms) = build_tree_list (NULL_TREE, passed_auto_delete); ! 3702: expr = build_function_call (function, parms); ! 3703: if (do_delete) ! 3704: expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete); ! 3705: if (ptr && (flags & LOOKUP_DESTRUCTOR) == 0) ! 3706: { ! 3707: /* Handle the case where a virtual destructor is ! 3708: being called on an item that is 0. ! 3709: ! 3710: @@ Does this really need to be done? */ ! 3711: tree ifexp = build_binary_op(NE_EXPR, addr, integer_zero_node,1); ! 3712: #if 0 ! 3713: if (TREE_CODE (ref) == VAR_DECL ! 3714: || TREE_CODE (ref) == COMPONENT_REF) ! 3715: warning ("losing in build_delete"); ! 3716: #endif ! 3717: expr = build (COND_EXPR, void_type_node, ! 3718: ifexp, expr, void_zero_node); ! 3719: } ! 3720: } ! 3721: else ! 3722: { ! 3723: tree ifexp; ! 3724: ! 3725: if ((flags & LOOKUP_DESTRUCTOR) ! 3726: || TREE_CODE (ref) == VAR_DECL ! 3727: || TREE_CODE (ref) == PARM_DECL ! 3728: || TREE_CODE (ref) == COMPONENT_REF ! 3729: || TREE_CODE (ref) == ARRAY_REF) ! 3730: /* These can't be 0. */ ! 3731: ifexp = integer_one_node; ! 3732: else ! 3733: /* Handle the case where a non-virtual destructor is ! 3734: being called on an item that is 0. */ ! 3735: ifexp = build_binary_op (NE_EXPR, addr, integer_zero_node, 1); ! 3736: ! 3737: /* Used to mean that this destructor was known to be empty, ! 3738: but that's now obsolete. */ ! 3739: my_friendly_assert (DECL_INITIAL (dtor) != void_type_node, 221); ! 3740: ! 3741: TREE_CHAIN (parms) = build_tree_list (NULL_TREE, passed_auto_delete); ! 3742: expr = build_function_call (dtor, parms); ! 3743: if (do_delete) ! 3744: expr = build (COMPOUND_EXPR, void_type_node, expr, do_delete); ! 3745: ! 3746: if (ifexp != integer_one_node) ! 3747: expr = build (COND_EXPR, void_type_node, ! 3748: ifexp, expr, void_zero_node); ! 3749: } ! 3750: return expr; ! 3751: } ! 3752: else ! 3753: { ! 3754: /* This can get visibilities wrong. */ ! 3755: tree binfos = BINFO_BASETYPES (TYPE_BINFO (type)); ! 3756: int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; ! 3757: tree base_binfo = n_baseclasses > 0 ? TREE_VEC_ELT (binfos, 0) : NULL_TREE; ! 3758: tree exprstmt = NULL_TREE; ! 3759: tree parent_auto_delete = auto_delete; ! 3760: tree cond; ! 3761: ! 3762: /* If this type does not have a destructor, but does have ! 3763: operator delete, call the parent parent destructor (if any), ! 3764: but let this node do the deleting. Otherwise, it is ok ! 3765: to let the parent destructor do the deleting. */ ! 3766: if (TYPE_GETS_REG_DELETE (type) && !use_global_delete) ! 3767: { ! 3768: parent_auto_delete = integer_zero_node; ! 3769: if (auto_delete == integer_zero_node) ! 3770: cond = NULL_TREE; ! 3771: else ! 3772: { ! 3773: tree virtual_size; ! 3774: ! 3775: /* This is probably wrong. It should be the size of the ! 3776: virtual object being deleted. */ ! 3777: virtual_size = c_sizeof_nowarn (type); ! 3778: ! 3779: expr = build_opfncall (DELETE_EXPR, LOOKUP_NORMAL, addr, ! 3780: virtual_size, NULL_TREE); ! 3781: if (expr == error_mark_node) ! 3782: return error_mark_node; ! 3783: if (auto_delete != integer_one_node) ! 3784: cond = build (COND_EXPR, void_type_node, ! 3785: build (BIT_AND_EXPR, integer_type_node, ! 3786: auto_delete, integer_one_node), ! 3787: expr, void_zero_node); ! 3788: else ! 3789: cond = expr; ! 3790: } ! 3791: } ! 3792: else if (base_binfo == NULL_TREE ! 3793: || (TREE_VIA_VIRTUAL (base_binfo) == 0 ! 3794: && ! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)))) ! 3795: { ! 3796: tree virtual_size; ! 3797: ! 3798: /* This is probably wrong. It should be the size of the virtual ! 3799: object being deleted. */ ! 3800: virtual_size = c_sizeof_nowarn (type); ! 3801: ! 3802: cond = build (COND_EXPR, void_type_node, ! 3803: build (BIT_AND_EXPR, integer_type_node, auto_delete, integer_one_node), ! 3804: build_builtin_call (void_type_node, BID, ! 3805: build_tree_list (NULL_TREE, addr)), ! 3806: void_zero_node); ! 3807: } ! 3808: else ! 3809: cond = NULL_TREE; ! 3810: ! 3811: if (cond) ! 3812: exprstmt = build_tree_list (NULL_TREE, cond); ! 3813: ! 3814: if (base_binfo ! 3815: && ! TREE_VIA_VIRTUAL (base_binfo) ! 3816: && TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo))) ! 3817: { ! 3818: tree this_auto_delete; ! 3819: ! 3820: if (BINFO_OFFSET_ZEROP (base_binfo)) ! 3821: this_auto_delete = parent_auto_delete; ! 3822: else ! 3823: this_auto_delete = integer_zero_node; ! 3824: ! 3825: expr = build_delete (TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), addr, ! 3826: this_auto_delete, flags, 0); ! 3827: exprstmt = tree_cons (NULL_TREE, expr, exprstmt); ! 3828: } ! 3829: ! 3830: /* Take care of the remaining baseclasses. */ ! 3831: for (i = 1; i < n_baseclasses; i++) ! 3832: { ! 3833: base_binfo = TREE_VEC_ELT (binfos, i); ! 3834: if (! TYPE_NEEDS_DESTRUCTOR (BINFO_TYPE (base_binfo)) ! 3835: || TREE_VIA_VIRTUAL (base_binfo)) ! 3836: continue; ! 3837: ! 3838: /* May be zero offset if other baseclasses are virtual. */ ! 3839: expr = fold (build (PLUS_EXPR, TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), ! 3840: addr, BINFO_OFFSET (base_binfo))); ! 3841: ! 3842: expr = build_delete (TYPE_POINTER_TO (BINFO_TYPE (base_binfo)), expr, ! 3843: integer_zero_node, ! 3844: flags, 0); ! 3845: ! 3846: exprstmt = tree_cons (NULL_TREE, expr, exprstmt); ! 3847: } ! 3848: ! 3849: for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) ! 3850: { ! 3851: if (TREE_CODE (member) != FIELD_DECL) ! 3852: continue; ! 3853: if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (member))) ! 3854: { ! 3855: tree this_member = build_component_ref (ref, DECL_NAME (member), 0, 0); ! 3856: tree this_type = TREE_TYPE (member); ! 3857: expr = build_delete (this_type, this_member, integer_two_node, flags, 0); ! 3858: exprstmt = tree_cons (NULL_TREE, expr, exprstmt); ! 3859: } ! 3860: } ! 3861: ! 3862: if (exprstmt) ! 3863: return build_compound_expr (exprstmt); ! 3864: /* Virtual base classes make this function do nothing. */ ! 3865: return void_zero_node; ! 3866: } ! 3867: } ! 3868: ! 3869: /* For type TYPE, delete the virtual baseclass objects of DECL. */ ! 3870: ! 3871: tree ! 3872: build_vbase_delete (type, decl) ! 3873: tree type, decl; ! 3874: { ! 3875: tree vbases = CLASSTYPE_VBASECLASSES (type); ! 3876: tree result = NULL_TREE; ! 3877: tree addr = build_unary_op (ADDR_EXPR, decl, 0); ! 3878: ! 3879: my_friendly_assert (addr != error_mark_node, 222); ! 3880: ! 3881: while (vbases) ! 3882: { ! 3883: tree this_addr = convert_force (TYPE_POINTER_TO (BINFO_TYPE (vbases)), ! 3884: addr); ! 3885: result = tree_cons (NULL_TREE, ! 3886: build_delete (TREE_TYPE (this_addr), this_addr, ! 3887: integer_zero_node, ! 3888: LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0), ! 3889: result); ! 3890: vbases = TREE_CHAIN (vbases); ! 3891: } ! 3892: return build_compound_expr (nreverse (result)); ! 3893: } ! 3894: ! 3895: /* Build a C++ vector delete expression. ! 3896: MAXINDEX is the number of elements to be deleted. ! 3897: ELT_SIZE is the nominal size of each element in the vector. ! 3898: BASE is the expression that should yield the store to be deleted. ! 3899: This function expands (or synthesizes) these calls itself. ! 3900: AUTO_DELETE_VEC says whether the container (vector) should be deallocated. ! 3901: AUTO_DELETE say whether each item in the container should be deallocated. ! 3902: ! 3903: This also calls delete for virtual baseclasses of elements of the vector. ! 3904: ! 3905: Update: MAXINDEX is no longer needed. The size can be extracted from the ! 3906: start of the vector for pointers, and from the type for arrays. We still ! 3907: use MAXINDEX for arrays because it happens to already have one of the ! 3908: values we'd have to extract. (We could use MAXINDEX with pointers to ! 3909: confirm the size, and trap if the numbers differ; not clear that it'd ! 3910: be worth bothering.) */ ! 3911: tree ! 3912: build_vec_delete (base, maxindex, elt_size, auto_delete_vec, auto_delete, ! 3913: use_global_delete) ! 3914: tree base, maxindex, elt_size; ! 3915: tree auto_delete_vec, auto_delete; ! 3916: int use_global_delete; ! 3917: { ! 3918: tree ptype = TREE_TYPE (base); ! 3919: tree type; ! 3920: tree virtual_size; ! 3921: /* Temporary variables used by the loop. */ ! 3922: tree tbase, size_exp, tbase_init; ! 3923: ! 3924: /* This is the body of the loop that implements the deletion of a ! 3925: single element, and moves temp variables to next elements. */ ! 3926: tree body; ! 3927: ! 3928: /* This is the LOOP_EXPR that governs the deletion of the elements. */ ! 3929: tree loop; ! 3930: ! 3931: /* This is the thing that governs what to do after the loop has run. */ ! 3932: tree deallocate_expr = 0; ! 3933: ! 3934: /* This is the BIND_EXPR which holds the outermost iterator of the ! 3935: loop. It is convenient to set this variable up and test it before ! 3936: executing any other code in the loop. ! 3937: This is also the containing expression returned by this function. */ ! 3938: tree controller = NULL_TREE; ! 3939: ! 3940: /* This is the BLOCK to record the symbol binding for debugging. */ ! 3941: tree block; ! 3942: ! 3943: base = stabilize_reference (base); ! 3944: ! 3945: /* Since we can use base many times, save_expr it. */ ! 3946: if (TREE_SIDE_EFFECTS (base)) ! 3947: base = save_expr (base); ! 3948: ! 3949: if (TREE_CODE (ptype) == POINTER_TYPE) ! 3950: { ! 3951: /* Step back one from start of vector, and read dimension. */ ! 3952: tree cookie_addr = build (MINUS_EXPR, TYPE_POINTER_TO (BI_header_type), ! 3953: base, BI_header_size); ! 3954: tree cookie = build_indirect_ref (cookie_addr, NULL_PTR); ! 3955: maxindex = build_component_ref (cookie, nc_nelts_field_id, 0, 0); ! 3956: do ! 3957: ptype = TREE_TYPE (ptype); ! 3958: while (TREE_CODE (ptype) == ARRAY_TYPE); ! 3959: } ! 3960: else if (TREE_CODE (ptype) == ARRAY_TYPE) ! 3961: { ! 3962: /* get the total number of things in the array, maxindex is a bad name */ ! 3963: maxindex = array_type_nelts_total (ptype); ! 3964: while (TREE_CODE (ptype) == ARRAY_TYPE) ! 3965: ptype = TREE_TYPE (ptype); ! 3966: base = build_unary_op (ADDR_EXPR, base, 1); ! 3967: } ! 3968: else ! 3969: { ! 3970: error ("type to vector delete is neither pointer or array type"); ! 3971: return error_mark_node; ! 3972: } ! 3973: type = ptype; ! 3974: ptype = TYPE_POINTER_TO (type); ! 3975: ! 3976: size_exp = size_in_bytes (type); ! 3977: ! 3978: if (! IS_AGGR_TYPE (type) || ! TYPE_NEEDS_DESTRUCTOR (type)) ! 3979: { ! 3980: loop = integer_zero_node; ! 3981: goto no_destructor; ! 3982: } ! 3983: ! 3984: /* The below is short by BI_header_size */ ! 3985: virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex)); ! 3986: ! 3987: tbase = build_decl (VAR_DECL, NULL_TREE, ptype); ! 3988: tbase_init = build_modify_expr (tbase, NOP_EXPR, ! 3989: fold (build (PLUS_EXPR, ptype, ! 3990: base, ! 3991: virtual_size))); ! 3992: DECL_REGISTER (tbase) = 1; ! 3993: controller = build (BIND_EXPR, void_type_node, tbase, 0, 0); ! 3994: TREE_SIDE_EFFECTS (controller) = 1; ! 3995: block = build_block (tbase, 0, 0, 0, 0); ! 3996: add_block_current_level (block); ! 3997: ! 3998: if (auto_delete != integer_zero_node ! 3999: && auto_delete != integer_two_node) ! 4000: { ! 4001: tree base_tbd = convert (ptype, ! 4002: build_binary_op (MINUS_EXPR, ! 4003: convert (ptr_type_node, base), ! 4004: BI_header_size, ! 4005: 1)); ! 4006: /* This is the real size */ ! 4007: virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size); ! 4008: body = build_tree_list (NULL_TREE, ! 4009: build_x_delete (ptype, base_tbd, ! 4010: 2 | use_global_delete, ! 4011: virtual_size)); ! 4012: body = build (COND_EXPR, void_type_node, ! 4013: build (BIT_AND_EXPR, integer_type_node, ! 4014: auto_delete, integer_one_node), ! 4015: body, integer_zero_node); ! 4016: } ! 4017: else ! 4018: body = NULL_TREE; ! 4019: ! 4020: body = tree_cons (NULL_TREE, ! 4021: build_delete (ptype, tbase, auto_delete, ! 4022: LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1), ! 4023: body); ! 4024: ! 4025: body = tree_cons (NULL_TREE, ! 4026: build_modify_expr (tbase, NOP_EXPR, build (MINUS_EXPR, ptype, tbase, size_exp)), ! 4027: body); ! 4028: ! 4029: body = tree_cons (NULL_TREE, ! 4030: build (EXIT_EXPR, void_type_node, ! 4031: build (EQ_EXPR, integer_type_node, base, tbase)), ! 4032: body); ! 4033: ! 4034: loop = build (LOOP_EXPR, void_type_node, build_compound_expr (body)); ! 4035: ! 4036: loop = tree_cons (NULL_TREE, tbase_init, ! 4037: tree_cons (NULL_TREE, loop, NULL_TREE)); ! 4038: loop = build_compound_expr (loop); ! 4039: ! 4040: no_destructor: ! 4041: /* If the delete flag is one, or anything else with the low bit set, ! 4042: delete the storage. */ ! 4043: if (auto_delete_vec == integer_zero_node ! 4044: || auto_delete_vec == integer_two_node) ! 4045: deallocate_expr = integer_zero_node; ! 4046: else ! 4047: { ! 4048: tree base_tbd; ! 4049: ! 4050: /* The below is short by BI_header_size */ ! 4051: virtual_size = fold (size_binop (MULT_EXPR, size_exp, maxindex)); ! 4052: ! 4053: if (! TYPE_VEC_NEW_USES_COOKIE (type)) ! 4054: /* no header */ ! 4055: base_tbd = base; ! 4056: else ! 4057: { ! 4058: base_tbd = convert (ptype, ! 4059: build_binary_op (MINUS_EXPR, ! 4060: convert (string_type_node, base), ! 4061: BI_header_size, ! 4062: 1)); ! 4063: /* True size with header. */ ! 4064: virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size); ! 4065: } ! 4066: deallocate_expr = build_x_delete (ptype, base_tbd, ! 4067: 2 | use_global_delete, ! 4068: virtual_size); ! 4069: if (auto_delete_vec != integer_one_node) ! 4070: deallocate_expr = build (COND_EXPR, void_type_node, ! 4071: build (BIT_AND_EXPR, integer_type_node, ! 4072: auto_delete_vec, integer_one_node), ! 4073: deallocate_expr, integer_zero_node); ! 4074: } ! 4075: ! 4076: if (loop && deallocate_expr != integer_zero_node) ! 4077: { ! 4078: body = tree_cons (NULL_TREE, loop, ! 4079: tree_cons (NULL_TREE, deallocate_expr, NULL_TREE)); ! 4080: body = build_compound_expr (body); ! 4081: } ! 4082: else ! 4083: body = loop; ! 4084: ! 4085: /* Outermost wrapper: If pointer is null, punt. */ ! 4086: body = build (COND_EXPR, void_type_node, ! 4087: build (NE_EXPR, integer_type_node, base, integer_zero_node), ! 4088: body, integer_zero_node); ! 4089: body = build1 (NOP_EXPR, void_type_node, body); ! 4090: ! 4091: if (controller) ! 4092: { ! 4093: TREE_OPERAND (controller, 1) = body; ! 4094: return controller; ! 4095: } ! 4096: else ! 4097: return convert (void_type_node, body); ! 4098: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.