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