![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to call.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to call.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 ! root 1: /* Functions related to invoking methods and overloaded functions. ! 2: Copyright (C) 1987, 1992, 1993 Free Software Foundation, Inc. ! 3: Contributed by Michael Tiemann ([email protected]) and ! 4: hacked by Brendan Kehoe ([email protected]). ! 5: ! 6: This file is part of GNU CC. ! 7: ! 8: GNU CC is free software; you can redistribute it and/or modify ! 9: it under the terms of the GNU General Public License as published by ! 10: the Free Software Foundation; either version 2, or (at your option) ! 11: any later version. ! 12: ! 13: GNU CC is distributed in the hope that it will be useful, ! 14: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 16: GNU General Public License for more details. ! 17: ! 18: You should have received a copy of the GNU General Public License ! 19: along with GNU CC; see the file COPYING. If not, write to ! 20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 21: ! 22: ! 23: /* High-level class interface. */ ! 24: ! 25: #include "config.h" ! 26: #include "tree.h" ! 27: #include <stdio.h> ! 28: #include "cp-tree.h" ! 29: #include "class.h" ! 30: #include "flags.h" ! 31: ! 32: #include "obstack.h" ! 33: #define obstack_chunk_alloc xmalloc ! 34: #define obstack_chunk_free free ! 35: ! 36: extern void sorry (); ! 37: ! 38: extern int inhibit_warnings; ! 39: extern int flag_assume_nonnull_objects; ! 40: extern tree ctor_label, dtor_label; ! 41: ! 42: /* From typeck.c: */ ! 43: extern tree unary_complex_lvalue (); ! 44: ! 45: /* Compute the ease with which a conversion can be performed ! 46: between an expected and the given type. */ ! 47: static struct harshness_code convert_harshness (); ! 48: ! 49: #define EVIL_RETURN(ARG) ((ARG).code = EVIL_CODE, (ARG)) ! 50: #define QUAL_RETURN(ARG) ((ARG).code = QUAL_CODE, (ARG)) ! 51: #define TRIVIAL_RETURN(ARG) ((ARG).code = TRIVIAL_CODE, (ARG)) ! 52: #define ZERO_RETURN(ARG) ((ARG).code = 0, (ARG)) ! 53: ! 54: /* Ordering function for overload resolution. Compare two candidates ! 55: by gross quality. */ ! 56: int ! 57: rank_for_overload (x, y) ! 58: struct candidate *x, *y; ! 59: { ! 60: if (y->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE)) ! 61: return y->h.code - x->h.code; ! 62: if (x->h.code & (EVIL_CODE|ELLIPSIS_CODE|USER_CODE)) ! 63: return -1; ! 64: ! 65: /* This is set by compute_conversion_costs, for calling a non-const ! 66: member function from a const member function. */ ! 67: if ((y->harshness[0].code & CONST_CODE) ^ (x->harshness[0].code & CONST_CODE)) ! 68: return y->harshness[0].code - x->harshness[0].code; ! 69: ! 70: if (y->h.code & STD_CODE) ! 71: { ! 72: if (x->h.code & STD_CODE) ! 73: return y->h.distance - x->h.distance; ! 74: return 1; ! 75: } ! 76: if (x->h.code & STD_CODE) ! 77: return -1; ! 78: ! 79: return y->h.code - x->h.code; ! 80: } ! 81: ! 82: /* Compare two candidates, argument by argument. */ ! 83: int ! 84: rank_for_ideal (x, y) ! 85: struct candidate *x, *y; ! 86: { ! 87: int i; ! 88: ! 89: if (x->h_len != y->h_len) ! 90: abort (); ! 91: ! 92: for (i = 0; i < x->h_len; i++) ! 93: { ! 94: if (y->harshness[i].code - x->harshness[i].code) ! 95: return y->harshness[i].code - x->harshness[i].code; ! 96: if ((y->harshness[i].code & STD_CODE) ! 97: && (y->harshness[i].distance - x->harshness[i].distance)) ! 98: return y->harshness[i].distance - x->harshness[i].distance; ! 99: ! 100: /* They're both the same code. Now see if we're dealing with an ! 101: integral promotion that needs a finer grain of accuracy. */ ! 102: if (y->harshness[0].code & PROMO_CODE ! 103: && (y->harshness[i].int_penalty ^ x->harshness[i].int_penalty)) ! 104: return y->harshness[i].int_penalty - x->harshness[i].int_penalty; ! 105: } ! 106: return 0; ! 107: } ! 108: ! 109: /* TYPE is the type we wish to convert to. PARM is the parameter ! 110: we have to work with. We use a somewhat arbitrary cost function ! 111: to measure this conversion. */ ! 112: static struct harshness_code ! 113: convert_harshness (type, parmtype, parm) ! 114: register tree type, parmtype; ! 115: tree parm; ! 116: { ! 117: struct harshness_code h; ! 118: register enum tree_code codel; ! 119: register enum tree_code coder; ! 120: ! 121: h.code = 0; ! 122: h.distance = 0; ! 123: h.int_penalty = 0; ! 124: ! 125: #ifdef GATHER_STATISTICS ! 126: n_convert_harshness++; ! 127: #endif ! 128: ! 129: if (TYPE_PTRMEMFUNC_P (type)) ! 130: type = TYPE_PTRMEMFUNC_FN_TYPE (type); ! 131: if (TYPE_PTRMEMFUNC_P (parmtype)) ! 132: parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype); ! 133: ! 134: if (TREE_CODE (parmtype) == REFERENCE_TYPE) ! 135: { ! 136: if (parm) ! 137: parm = convert_from_reference (parm); ! 138: parmtype = TREE_TYPE (parmtype); ! 139: } ! 140: ! 141: codel = TREE_CODE (type); ! 142: coder = TREE_CODE (parmtype); ! 143: ! 144: if (TYPE_MAIN_VARIANT (parmtype) == TYPE_MAIN_VARIANT (type)) ! 145: return ZERO_RETURN (h); ! 146: ! 147: if (coder == ERROR_MARK) ! 148: return EVIL_RETURN (h); ! 149: ! 150: if (codel == POINTER_TYPE && fntype_p (parmtype)) ! 151: { ! 152: tree p1, p2; ! 153: struct harshness_code h1, h2; ! 154: ! 155: /* Get to the METHOD_TYPE or FUNCTION_TYPE that this might be. */ ! 156: type = TREE_TYPE (type); ! 157: ! 158: if (coder == POINTER_TYPE) ! 159: { ! 160: parmtype = TREE_TYPE (parmtype); ! 161: coder = TREE_CODE (parmtype); ! 162: } ! 163: ! 164: if (coder != TREE_CODE (type)) ! 165: return EVIL_RETURN (h); ! 166: ! 167: /* We allow the default conversion between function type ! 168: and pointer-to-function type for free. */ ! 169: if (type == parmtype) ! 170: return ZERO_RETURN (h); ! 171: ! 172: /* Compare return types. */ ! 173: p1 = TREE_TYPE (type); ! 174: p2 = TREE_TYPE (parmtype); ! 175: h2 = convert_harshness (p1, p2, NULL_TREE); ! 176: if (h2.code & EVIL_CODE) ! 177: return h2; ! 178: ! 179: h1.code = TRIVIAL_CODE; ! 180: h1.distance = 0; ! 181: ! 182: if (h2.distance != 0) ! 183: { ! 184: tree binfo; ! 185: ! 186: /* This only works for pointers. */ ! 187: if (TREE_CODE (p1) != POINTER_TYPE ! 188: && TREE_CODE (p1) != REFERENCE_TYPE) ! 189: return EVIL_RETURN (h); ! 190: ! 191: p1 = TREE_TYPE (p1); ! 192: p2 = TREE_TYPE (p2); ! 193: /* Don't die if we happen to be dealing with void*. */ ! 194: if (!IS_AGGR_TYPE (p1) || !IS_AGGR_TYPE (p2)) ! 195: return EVIL_RETURN (h); ! 196: if (h2.distance < 0) ! 197: binfo = get_binfo (p2, p1, 0); ! 198: else ! 199: binfo = get_binfo (p1, p2, 0); ! 200: ! 201: if (! BINFO_OFFSET_ZEROP (binfo)) ! 202: { ! 203: static int explained = 0; ! 204: if (h2.distance < 0) ! 205: message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p2, p1); ! 206: else ! 207: message_2_types (sorry, "cannot cast `%d' to `%d' at function call site", p1, p2); ! 208: ! 209: if (! explained++) ! 210: sorry ("(because pointer values change during conversion)"); ! 211: return EVIL_RETURN (h); ! 212: } ! 213: } ! 214: ! 215: h1.code |= h2.code; ! 216: if (h2.distance > h1.distance) ! 217: h1.distance = h2.distance; ! 218: ! 219: p1 = TYPE_ARG_TYPES (type); ! 220: p2 = TYPE_ARG_TYPES (parmtype); ! 221: while (p1 && TREE_VALUE (p1) != void_type_node ! 222: && p2 && TREE_VALUE (p2) != void_type_node) ! 223: { ! 224: h2 = convert_harshness (TREE_VALUE (p1), TREE_VALUE (p2), ! 225: NULL_TREE); ! 226: if (h2.code & EVIL_CODE) ! 227: return h2; ! 228: ! 229: if (h2.distance) ! 230: { ! 231: /* This only works for pointers and references. */ ! 232: if (TREE_CODE (TREE_VALUE (p1)) != POINTER_TYPE ! 233: && TREE_CODE (TREE_VALUE (p1)) != REFERENCE_TYPE) ! 234: return EVIL_RETURN (h); ! 235: h2.distance = - h2.distance; ! 236: } ! 237: ! 238: h1.code |= h2.code; ! 239: if (h2.distance > h1.distance) ! 240: h1.distance = h2.distance; ! 241: p1 = TREE_CHAIN (p1); ! 242: p2 = TREE_CHAIN (p2); ! 243: } ! 244: if (p1 == p2) ! 245: return h1; ! 246: if (p2) ! 247: { ! 248: if (p1) ! 249: return EVIL_RETURN (h); ! 250: h1.code |= ELLIPSIS_CODE; ! 251: return h1; ! 252: } ! 253: if (p1) ! 254: { ! 255: if (TREE_PURPOSE (p1) == NULL_TREE) ! 256: h1.code |= EVIL_CODE; ! 257: return h1; ! 258: } ! 259: } ! 260: else if (codel == POINTER_TYPE && coder == OFFSET_TYPE) ! 261: { ! 262: /* Get to the OFFSET_TYPE that this might be. */ ! 263: type = TREE_TYPE (type); ! 264: ! 265: if (coder != TREE_CODE (type)) ! 266: return EVIL_RETURN (h); ! 267: ! 268: if (TYPE_OFFSET_BASETYPE (type) == TYPE_OFFSET_BASETYPE (parmtype)) ! 269: h.code = 0; ! 270: else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (type), ! 271: TYPE_OFFSET_BASETYPE (parmtype))) ! 272: { ! 273: h.code = STD_CODE; ! 274: h.distance = 1; ! 275: } ! 276: else if (UNIQUELY_DERIVED_FROM_P (TYPE_OFFSET_BASETYPE (parmtype), ! 277: TYPE_OFFSET_BASETYPE (type))) ! 278: { ! 279: h.code = STD_CODE; ! 280: h.distance = -1; ! 281: } ! 282: else ! 283: return EVIL_RETURN (h); ! 284: /* Now test the OFFSET_TYPE's target compatibility. */ ! 285: type = TREE_TYPE (type); ! 286: parmtype = TREE_TYPE (parmtype); ! 287: } ! 288: ! 289: if (coder == UNKNOWN_TYPE) ! 290: { ! 291: if (codel == FUNCTION_TYPE ! 292: || codel == METHOD_TYPE ! 293: || (codel == POINTER_TYPE ! 294: && (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE ! 295: || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))) ! 296: return TRIVIAL_RETURN (h); ! 297: return EVIL_RETURN (h); ! 298: } ! 299: ! 300: if (coder == VOID_TYPE) ! 301: return EVIL_RETURN (h); ! 302: ! 303: if (INTEGRAL_CODE_P (codel)) ! 304: { ! 305: /* Control equivalence of ints an enums. */ ! 306: ! 307: if (codel == ENUMERAL_TYPE ! 308: && flag_int_enum_equivalence == 0) ! 309: { ! 310: /* Enums can be converted to ints, but not vice-versa. */ ! 311: if (coder != ENUMERAL_TYPE ! 312: || TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (parmtype)) ! 313: return EVIL_RETURN (h); ! 314: } ! 315: ! 316: /* else enums and ints (almost) freely interconvert. */ ! 317: ! 318: if (INTEGRAL_CODE_P (coder)) ! 319: { ! 320: if (TYPE_MAIN_VARIANT (type) ! 321: == TYPE_MAIN_VARIANT (type_promotes_to (parmtype))) ! 322: { ! 323: h.code = PROMO_CODE; ! 324: #if 0 /* What purpose does this serve? -jason */ ! 325: /* A char, short, wchar_t, etc., should promote to an int if ! 326: it can handle it, otherwise to an unsigned. So we'll make ! 327: an unsigned. */ ! 328: if (type != integer_type_node) ! 329: h.int_penalty = 1; ! 330: #endif ! 331: } ! 332: else ! 333: h.code = STD_CODE; ! 334: ! 335: return h; ! 336: } ! 337: else if (coder == REAL_TYPE) ! 338: { ! 339: h.code = STD_CODE; ! 340: h.distance = 0; ! 341: return h; ! 342: } ! 343: } ! 344: ! 345: if (codel == REAL_TYPE) ! 346: { ! 347: if (coder == REAL_TYPE) ! 348: { ! 349: if (TYPE_MAIN_VARIANT (type) ! 350: == TYPE_MAIN_VARIANT (type_promotes_to (parmtype))) ! 351: h.code = PROMO_CODE; ! 352: else ! 353: h.code = STD_CODE; ! 354: ! 355: return h; ! 356: } ! 357: else if (INTEGRAL_CODE_P (coder)) ! 358: { ! 359: h.code = STD_CODE; ! 360: h.distance = 0; ! 361: return h; ! 362: } ! 363: } ! 364: ! 365: /* Convert arrays which have not previously been converted. */ ! 366: if (codel == ARRAY_TYPE) ! 367: codel = POINTER_TYPE; ! 368: if (coder == ARRAY_TYPE) ! 369: coder = POINTER_TYPE; ! 370: ! 371: /* Conversions among pointers */ ! 372: if (codel == POINTER_TYPE && coder == POINTER_TYPE) ! 373: { ! 374: register tree ttl = TYPE_MAIN_VARIANT (TREE_TYPE (type)); ! 375: register tree ttr = TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)); ! 376: int penalty = 4 * (ttl != ttr); ! 377: ! 378: /* Anything converts to void *. void * converts to anything. ! 379: Since these may be `const void *' (etc.) use VOID_TYPE ! 380: instead of void_type_node. Otherwise, the targets must be the same, ! 381: except that we do allow (at some cost) conversion between signed and ! 382: unsigned pointer types. */ ! 383: ! 384: if ((TREE_CODE (ttl) == METHOD_TYPE ! 385: || TREE_CODE (ttl) == FUNCTION_TYPE) ! 386: && TREE_CODE (ttl) == TREE_CODE (ttr)) ! 387: { ! 388: if (comptypes (ttl, ttr, -1)) ! 389: { ! 390: h.code = penalty ? STD_CODE : 0; ! 391: h.distance = 0; ! 392: } ! 393: else ! 394: h.code = EVIL_CODE; ! 395: return h; ! 396: } ! 397: ! 398: #if 1 ! 399: if (TREE_CODE (ttl) != VOID_TYPE && TREE_CODE (ttr) != VOID_TYPE) ! 400: { ! 401: if (TREE_UNSIGNED (ttl) != TREE_UNSIGNED (ttr)) ! 402: { ! 403: ttl = unsigned_type (ttl); ! 404: ttr = unsigned_type (ttr); ! 405: penalty = 10; ! 406: } ! 407: if (! comp_target_types (ttl, ttr, 0)) ! 408: return EVIL_RETURN (h); ! 409: } ! 410: #else ! 411: if (!(TREE_CODE (ttl) == VOID_TYPE ! 412: || TREE_CODE (ttr) == VOID_TYPE ! 413: || (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (ttr) ! 414: && (ttl = unsigned_type (ttl), ! 415: ttr = unsigned_type (ttr), ! 416: penalty = 10, 0)) ! 417: || (comp_target_types (ttl, ttr, 0)))) ! 418: return EVIL_RETURN (h); ! 419: #endif ! 420: ! 421: if (penalty == 10 || ttr == ttl) ! 422: { ! 423: tree tmp1 = TREE_TYPE (type), tmp2 = TREE_TYPE (parmtype); ! 424: ! 425: /* If one was unsigned but the other wasn't, then we need to ! 426: do a standard conversion from T to unsigned T. */ ! 427: if (penalty == 10) ! 428: h.code = PROMO_CODE; /* was STD_CODE */ ! 429: else ! 430: h.code = 0; ! 431: ! 432: /* Note conversion from `T*' to `const T*', ! 433: or `T*' to `volatile T*'. */ ! 434: if (ttl == ttr ! 435: && ((TYPE_READONLY (tmp1) != TREE_READONLY (tmp2)) ! 436: || (TYPE_VOLATILE (tmp1) != TYPE_VOLATILE (tmp2)))) ! 437: h.code |= QUAL_CODE; ! 438: ! 439: h.distance = 0; ! 440: return h; ! 441: } ! 442: ! 443: ! 444: if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE) ! 445: { ! 446: int b_or_d = get_base_distance (ttl, ttr, 0, 0); ! 447: if (b_or_d < 0) ! 448: { ! 449: b_or_d = get_base_distance (ttr, ttl, 0, 0); ! 450: if (b_or_d < 0) ! 451: return EVIL_RETURN (h); ! 452: h.distance = -b_or_d; ! 453: } ! 454: else ! 455: h.distance = b_or_d; ! 456: h.code = STD_CODE; ! 457: return h; ! 458: } ! 459: ! 460: /* If converting from a `class*' to a `void*', make it ! 461: less favorable than any inheritance relationship. */ ! 462: if (TREE_CODE (ttl) == VOID_TYPE && IS_AGGR_TYPE (ttr)) ! 463: { ! 464: h.code = STD_CODE; ! 465: h.distance = CLASSTYPE_MAX_DEPTH (ttr)+1; ! 466: return h; ! 467: } ! 468: h.code = penalty ? STD_CODE : PROMO_CODE; ! 469: return h; ! 470: } ! 471: ! 472: if (codel == POINTER_TYPE && coder == INTEGER_TYPE) ! 473: { ! 474: /* This is not a bad match, but don't let it beat ! 475: integer-enum combinations. */ ! 476: if (parm && integer_zerop (parm)) ! 477: { ! 478: h.code = STD_CODE; ! 479: h.distance = 0; ! 480: return h; ! 481: } ! 482: } ! 483: ! 484: /* C++: Since the `this' parameter of a signature member function ! 485: is represented as a signature pointer to handle default implementations ! 486: correctly, we can have the case that `type' is a signature pointer ! 487: while `parmtype' is a pointer to a signature table. We don't really ! 488: do any conversions in this case, so just return 0. */ ! 489: ! 490: if (codel == RECORD_TYPE && coder == POINTER_TYPE ! 491: && IS_SIGNATURE_POINTER (type) && IS_SIGNATURE (TREE_TYPE (parmtype))) ! 492: return ZERO_RETURN (h); ! 493: ! 494: if (codel == REFERENCE_TYPE) ! 495: { ! 496: tree ttl, ttr; ! 497: int constp = parm ? TREE_READONLY (parm) : TYPE_READONLY (parmtype); ! 498: int volatilep = (parm ? TREE_THIS_VOLATILE (parm) ! 499: : TYPE_VOLATILE (parmtype)); ! 500: register tree intype = TYPE_MAIN_VARIANT (parmtype); ! 501: register enum tree_code form = TREE_CODE (intype); ! 502: int penalty = 0; ! 503: ! 504: ttl = TREE_TYPE (type); ! 505: ! 506: /* When passing a non-const argument into a const reference (or vice ! 507: versa), dig it a little, so a non-const reference is preferred ! 508: over this one. (mrs) */ ! 509: if (TYPE_READONLY (ttl) != constp ! 510: || TYPE_VOLATILE (ttl) != volatilep) ! 511: penalty = 2; ! 512: else ! 513: penalty = 0; ! 514: ! 515: ttl = TYPE_MAIN_VARIANT (ttl); ! 516: ! 517: if (form == OFFSET_TYPE) ! 518: { ! 519: intype = TREE_TYPE (intype); ! 520: form = TREE_CODE (intype); ! 521: } ! 522: ! 523: if (ttl == intype && penalty == 0) ! 524: return ZERO_RETURN (h); ! 525: else ! 526: penalty = 2; ! 527: ! 528: ttr = intype; ! 529: ! 530: /* If the initializer is not an lvalue, then it does not ! 531: matter if we make life easier for the programmer ! 532: by creating a temporary variable with which to ! 533: hold the result. */ ! 534: if (parm && (INTEGRAL_CODE_P (coder) ! 535: || coder == REAL_TYPE) ! 536: && ! lvalue_p (parm)) ! 537: { ! 538: h = convert_harshness (ttl, ttr, NULL_TREE); ! 539: if (penalty > 2 || h.code != 0) ! 540: h.code |= STD_CODE; ! 541: else ! 542: h.code |= TRIVIAL_CODE; ! 543: h.distance = 0; ! 544: return h; ! 545: } ! 546: ! 547: if (TREE_UNSIGNED (ttl) ^ TREE_UNSIGNED (intype)) ! 548: { ! 549: ttl = unsigned_type (ttl); ! 550: ttr = intype = unsigned_type (intype); ! 551: penalty += 2; ! 552: } ! 553: ! 554: if (ttl == ttr) ! 555: { ! 556: if (penalty > 2) ! 557: { ! 558: h.code = STD_CODE; ! 559: h.distance = 0; ! 560: } ! 561: else ! 562: { ! 563: h.code = TRIVIAL_CODE; ! 564: /* We set this here so that build_overload_call_real will be ! 565: able to see the penalty we found, rather than just looking ! 566: at a TRIVIAL_CODE with no other information. */ ! 567: h.int_penalty = penalty; ! 568: } ! 569: return h; ! 570: } ! 571: ! 572: /* Pointers to voids always convert for pointers. But ! 573: make them less natural than more specific matches. */ ! 574: if (TREE_CODE (ttl) == POINTER_TYPE && TREE_CODE (ttr) == POINTER_TYPE) ! 575: { ! 576: if (TREE_TYPE (ttl) == void_type_node ! 577: || TREE_TYPE (ttr) == void_type_node) ! 578: { ! 579: h.code = STD_CODE; ! 580: h.distance = 0; ! 581: return h; ! 582: } ! 583: } ! 584: ! 585: /* Here it does matter. If this conversion is from derived to base, ! 586: allow it. Otherwise, types must be compatible in the strong sense. */ ! 587: if (TREE_CODE (ttl) == RECORD_TYPE && TREE_CODE (ttr) == RECORD_TYPE) ! 588: { ! 589: int b_or_d = get_base_distance (ttl, ttr, 0, 0); ! 590: if (b_or_d < 0) ! 591: { ! 592: b_or_d = get_base_distance (ttr, ttl, 0, 0); ! 593: if (b_or_d < 0) ! 594: return EVIL_RETURN (h); ! 595: h.distance = -b_or_d; ! 596: } ! 597: /* Say that this conversion is relatively painless. ! 598: If it turns out that there is a user-defined X(X&) ! 599: constructor, then that will be invoked, but that's ! 600: preferable to dealing with other user-defined conversions ! 601: that may produce surprising results. */ ! 602: else ! 603: h.distance = b_or_d; ! 604: h.code = STD_CODE; ! 605: return h; ! 606: } ! 607: ! 608: if (comp_target_types (ttl, intype, 1)) ! 609: { ! 610: if (penalty) ! 611: h.code = STD_CODE; ! 612: h.distance = 0; ! 613: return h; ! 614: } ! 615: } ! 616: if (codel == RECORD_TYPE && coder == RECORD_TYPE) ! 617: { ! 618: int b_or_d = get_base_distance (type, parmtype, 0, 0); ! 619: if (b_or_d < 0) ! 620: { ! 621: b_or_d = get_base_distance (parmtype, type, 0, 0); ! 622: if (b_or_d < 0) ! 623: return EVIL_RETURN (h); ! 624: h.distance = -b_or_d; ! 625: } ! 626: else ! 627: h.distance = b_or_d; ! 628: h.code = STD_CODE; ! 629: return h; ! 630: } ! 631: return EVIL_RETURN (h); ! 632: } ! 633: ! 634: #ifdef DEBUG_MATCHING ! 635: static char * ! 636: print_harshness (h) ! 637: struct harshness_code *h; ! 638: { ! 639: static char buf[1024]; ! 640: char tmp[1024]; ! 641: ! 642: bzero (buf, 1024 * sizeof (char)); ! 643: strcat (buf, "codes=["); ! 644: if (h->code & EVIL_CODE) ! 645: strcat (buf, "EVIL"); ! 646: if (h->code & CONST_CODE) ! 647: strcat (buf, " CONST"); ! 648: if (h->code & ELLIPSIS_CODE) ! 649: strcat (buf, " ELLIPSIS"); ! 650: if (h->code & USER_CODE) ! 651: strcat (buf, " USER"); ! 652: if (h->code & STD_CODE) ! 653: strcat (buf, " STD"); ! 654: if (h->code & PROMO_CODE) ! 655: strcat (buf, " PROMO"); ! 656: if (h->code & QUAL_CODE) ! 657: strcat (buf, " QUAL"); ! 658: if (h->code & TRIVIAL_CODE) ! 659: strcat (buf, " TRIVIAL"); ! 660: if (buf[0] == '\0') ! 661: strcat (buf, "0"); ! 662: ! 663: sprintf (tmp, "] distance=%d int_penalty=%d", h->distance, h->int_penalty); ! 664: ! 665: strcat (buf, tmp); ! 666: ! 667: return buf; ! 668: } ! 669: #endif ! 670: ! 671: /* Algorithm: For each argument, calculate how difficult it is to ! 672: make FUNCTION accept that argument. If we can easily tell that ! 673: FUNCTION won't be acceptable to one of the arguments, then we ! 674: don't need to compute the ease of converting the other arguments, ! 675: since it will never show up in the intersection of all arguments' ! 676: favorite functions. ! 677: ! 678: Conversions between builtin and user-defined types are allowed, but ! 679: no function involving such a conversion is preferred to one which ! 680: does not require such a conversion. Furthermore, such conversions ! 681: must be unique. */ ! 682: ! 683: void ! 684: compute_conversion_costs (function, tta_in, cp, arglen) ! 685: tree function; ! 686: tree tta_in; ! 687: struct candidate *cp; ! 688: int arglen; ! 689: { ! 690: tree ttf_in = TYPE_ARG_TYPES (TREE_TYPE (function)); ! 691: tree ttf = ttf_in; ! 692: tree tta = tta_in; ! 693: ! 694: /* Start out with no strikes against. */ ! 695: int evil_strikes = 0; ! 696: int ellipsis_strikes = 0; ! 697: int user_strikes = 0; ! 698: int b_or_d_strikes = 0; ! 699: int easy_strikes = 0; ! 700: ! 701: int strike_index = 0, win; ! 702: struct harshness_code lose; ! 703: extern int cp_silent; ! 704: ! 705: #ifdef GATHER_STATISTICS ! 706: n_compute_conversion_costs++; ! 707: #endif ! 708: ! 709: #ifndef DEBUG_MATCHING ! 710: /* We don't emit any warnings or errors while trying out each candidate. */ ! 711: cp_silent = 1; ! 712: #endif ! 713: ! 714: cp->function = function; ! 715: cp->arg = tta ? TREE_VALUE (tta) : NULL_TREE; ! 716: cp->u.bad_arg = 0; /* optimistic! */ ! 717: ! 718: cp->h.code = 0; ! 719: cp->h.distance = 0; ! 720: cp->h.int_penalty = 0; ! 721: bzero ((char *) cp->harshness, ! 722: (cp->h_len + 1) * sizeof (struct harshness_code)); ! 723: ! 724: while (ttf && tta) ! 725: { ! 726: struct harshness_code h; ! 727: ! 728: if (ttf == void_list_node) ! 729: break; ! 730: ! 731: if (type_unknown_p (TREE_VALUE (tta))) ! 732: { ! 733: /* Must perform some instantiation here. */ ! 734: tree rhs = TREE_VALUE (tta); ! 735: tree lhstype = TREE_VALUE (ttf); ! 736: ! 737: /* Keep quiet about possible contravariance violations. */ ! 738: int old_inhibit_warnings = inhibit_warnings; ! 739: inhibit_warnings = 1; ! 740: ! 741: /* @@ This is to undo what `grokdeclarator' does to ! 742: parameter types. It really should go through ! 743: something more general. */ ! 744: ! 745: TREE_TYPE (tta) = unknown_type_node; ! 746: rhs = instantiate_type (lhstype, rhs, 0); ! 747: inhibit_warnings = old_inhibit_warnings; ! 748: ! 749: if (TREE_CODE (rhs) == ERROR_MARK) ! 750: h.code = EVIL_CODE; ! 751: else ! 752: h = convert_harshness (lhstype, TREE_TYPE (rhs), rhs); ! 753: } ! 754: else ! 755: { ! 756: #ifdef DEBUG_MATCHING ! 757: static tree old_function = NULL_TREE; ! 758: ! 759: if (!old_function || function != old_function) ! 760: { ! 761: cp_error ("trying %D", function); ! 762: old_function = function; ! 763: } ! 764: ! 765: cp_error (" doing (%T) %E against arg %T", ! 766: TREE_TYPE (TREE_VALUE (tta)), TREE_VALUE (tta), ! 767: TREE_VALUE (ttf)); ! 768: #endif ! 769: ! 770: h = convert_harshness (TREE_VALUE (ttf), ! 771: TREE_TYPE (TREE_VALUE (tta)), ! 772: TREE_VALUE (tta)); ! 773: ! 774: #ifdef DEBUG_MATCHING ! 775: cp_error (" evaluated %s", print_harshness (&h)); ! 776: #endif ! 777: } ! 778: ! 779: cp->harshness[strike_index] = h; ! 780: if ((h.code & EVIL_CODE) ! 781: || ((h.code & STD_CODE) && h.distance < 0)) ! 782: { ! 783: cp->u.bad_arg = strike_index; ! 784: evil_strikes = 1; ! 785: } ! 786: else if (h.code & ELLIPSIS_CODE) ! 787: ellipsis_strikes += 1; ! 788: #if 0 ! 789: /* This is never set by `convert_harshness'. */ ! 790: else if (h.code & USER_CODE) ! 791: { ! 792: user_strikes += 1; ! 793: } ! 794: #endif ! 795: else ! 796: { ! 797: if ((h.code & STD_CODE) && h.distance) ! 798: { ! 799: if (h.distance > b_or_d_strikes) ! 800: b_or_d_strikes = h.distance; ! 801: } ! 802: else ! 803: easy_strikes += (h.code & (STD_CODE|PROMO_CODE|TRIVIAL_CODE)); ! 804: cp->h.code |= h.code; ! 805: /* Make sure we communicate this. */ ! 806: cp->h.int_penalty += h.int_penalty; ! 807: } ! 808: ! 809: ttf = TREE_CHAIN (ttf); ! 810: tta = TREE_CHAIN (tta); ! 811: strike_index += 1; ! 812: } ! 813: ! 814: if (tta) ! 815: { ! 816: /* ran out of formals, and parmlist is fixed size. */ ! 817: if (ttf /* == void_type_node */) ! 818: { ! 819: cp->h.code = EVIL_CODE; ! 820: cp->u.bad_arg = -1; ! 821: cp_silent = 0; ! 822: return; ! 823: } ! 824: else ! 825: { ! 826: struct harshness_code h; ! 827: int l = list_length (tta); ! 828: ellipsis_strikes += l; ! 829: h.code = ELLIPSIS_CODE; ! 830: h.distance = 0; ! 831: h.int_penalty = 0; ! 832: for (; l; --l) ! 833: cp->harshness[strike_index++] = h; ! 834: } ! 835: } ! 836: else if (ttf && ttf != void_list_node) ! 837: { ! 838: /* ran out of actuals, and no defaults. */ ! 839: if (TREE_PURPOSE (ttf) == NULL_TREE) ! 840: { ! 841: cp->h.code = EVIL_CODE; ! 842: cp->u.bad_arg = -2; ! 843: cp_silent = 0; ! 844: return; ! 845: } ! 846: /* Store index of first default. */ ! 847: cp->harshness[arglen].distance = strike_index+1; ! 848: } ! 849: else ! 850: cp->harshness[arglen].distance = 0; ! 851: ! 852: /* Argument list lengths work out, so don't need to check them again. */ ! 853: if (evil_strikes) ! 854: { ! 855: /* We do not check for derived->base conversions here, since in ! 856: no case would they give evil strike counts, unless such conversions ! 857: are somehow ambiguous. */ ! 858: ! 859: /* See if any user-defined conversions apply. ! 860: But make sure that we do not loop. */ ! 861: static int dont_convert_types = 0; ! 862: ! 863: if (dont_convert_types) ! 864: { ! 865: cp->h.code = EVIL_CODE; ! 866: cp_silent = 0; ! 867: return; ! 868: } ! 869: ! 870: win = 0; /* Only get one chance to win. */ ! 871: ttf = TYPE_ARG_TYPES (TREE_TYPE (function)); ! 872: tta = tta_in; ! 873: strike_index = 0; ! 874: evil_strikes = 0; ! 875: ! 876: while (ttf && tta) ! 877: { ! 878: if (ttf == void_list_node) ! 879: break; ! 880: ! 881: lose = cp->harshness[strike_index]; ! 882: if ((lose.code & EVIL_CODE) ! 883: || ((lose.code & STD_CODE) && lose.distance < 0)) ! 884: { ! 885: tree actual_type = TREE_TYPE (TREE_VALUE (tta)); ! 886: tree formal_type = TREE_VALUE (ttf); ! 887: int extra_conversions = 0; ! 888: ! 889: dont_convert_types = 1; ! 890: ! 891: if (TREE_CODE (formal_type) == REFERENCE_TYPE) ! 892: formal_type = TREE_TYPE (formal_type); ! 893: if (TREE_CODE (actual_type) == REFERENCE_TYPE) ! 894: actual_type = TREE_TYPE (actual_type); ! 895: ! 896: if (formal_type != error_mark_node ! 897: && actual_type != error_mark_node) ! 898: { ! 899: formal_type = TYPE_MAIN_VARIANT (formal_type); ! 900: actual_type = TYPE_MAIN_VARIANT (actual_type); ! 901: ! 902: if (TYPE_HAS_CONSTRUCTOR (formal_type)) ! 903: { ! 904: /* If it has a constructor for this type, ! 905: try to use it. */ ! 906: /* @@ There is no way to save this result yet, so ! 907: success is a NULL_TREE for now. */ ! 908: if (convert_to_aggr (formal_type, TREE_VALUE (tta), 0, 1) ! 909: != error_mark_node) ! 910: win++; ! 911: } ! 912: if (TYPE_LANG_SPECIFIC (actual_type) ! 913: && TYPE_HAS_CONVERSION (actual_type)) ! 914: { ! 915: tree conv; ! 916: /* Don't issue warnings since we're only groping ! 917: around for the right answer, we haven't yet ! 918: committed to going with this solution. */ ! 919: int old_inhibit_warnings = inhibit_warnings; ! 920: ! 921: inhibit_warnings = 1; ! 922: conv = build_type_conversion ! 923: (CALL_EXPR, TREE_VALUE (ttf), TREE_VALUE (tta), 0); ! 924: inhibit_warnings = old_inhibit_warnings; ! 925: ! 926: if (conv) ! 927: { ! 928: if (conv == error_mark_node) ! 929: win += 2; ! 930: else ! 931: { ! 932: win++; ! 933: if (TREE_CODE (conv) != CALL_EXPR) ! 934: extra_conversions = 1; ! 935: } ! 936: } ! 937: else if (TREE_CODE (TREE_VALUE (ttf)) == REFERENCE_TYPE) ! 938: { ! 939: conv = build_type_conversion (CALL_EXPR, formal_type, ! 940: TREE_VALUE (tta), 0); ! 941: if (conv) ! 942: { ! 943: if (conv == error_mark_node) ! 944: win += 2; ! 945: else ! 946: { ! 947: win++; ! 948: if (TREE_CODE (conv) != CALL_EXPR) ! 949: extra_conversions = 1; ! 950: } ! 951: } ! 952: } ! 953: } ! 954: } ! 955: dont_convert_types = 0; ! 956: ! 957: if (win == 1) ! 958: { ! 959: user_strikes += 1; ! 960: cp->harshness[strike_index].code ! 961: = USER_CODE | (extra_conversions ? STD_CODE : 0); ! 962: win = 0; ! 963: } ! 964: else ! 965: { ! 966: if (cp->u.bad_arg > strike_index) ! 967: cp->u.bad_arg = strike_index; ! 968: ! 969: evil_strikes = win ? 2 : 1; ! 970: break; ! 971: } ! 972: } ! 973: ! 974: ttf = TREE_CHAIN (ttf); ! 975: tta = TREE_CHAIN (tta); ! 976: strike_index += 1; ! 977: } ! 978: } ! 979: ! 980: /* Const member functions get a small penalty because defaulting ! 981: to const is less useful than defaulting to non-const. */ ! 982: /* This is bogus, it does not correspond to anything in the ARM. ! 983: This code will be fixed when this entire section is rewritten ! 984: to conform to the ARM. (mrs) */ ! 985: if (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE) ! 986: { ! 987: tree this_parm = TREE_VALUE (ttf_in); ! 988: ! 989: if (TREE_CODE (this_parm) == RECORD_TYPE /* Is `this' a sig ptr? */ ! 990: ? TYPE_READONLY (TREE_TYPE (TREE_TYPE (TYPE_FIELDS (this_parm)))) ! 991: : TYPE_READONLY (TREE_TYPE (this_parm))) ! 992: { ! 993: cp->harshness[0].code |= TRIVIAL_CODE; ! 994: ++easy_strikes; ! 995: } ! 996: else ! 997: { ! 998: /* Calling a non-const member function from a const member function ! 999: is probably invalid, but for now we let it only draw a warning. ! 1000: We indicate that such a mismatch has occurred by setting the ! 1001: harshness to a maximum value. */ ! 1002: if (TREE_CODE (TREE_TYPE (TREE_VALUE (tta_in))) == POINTER_TYPE ! 1003: && (TYPE_READONLY (TREE_TYPE (TREE_TYPE (TREE_VALUE (tta_in)))))) ! 1004: cp->harshness[0].code |= CONST_CODE; ! 1005: } ! 1006: } ! 1007: ! 1008: if (evil_strikes) ! 1009: cp->h.code = EVIL_CODE; ! 1010: if (ellipsis_strikes) ! 1011: cp->h.code |= ELLIPSIS_CODE; ! 1012: if (user_strikes) ! 1013: cp->h.code |= USER_CODE; ! 1014: cp_silent = 0; ! 1015: #ifdef DEBUG_MATCHING ! 1016: cp_error ("final eval %s", print_harshness (&cp->h)); ! 1017: #endif ! 1018: } ! 1019: ! 1020: /* Subroutine of ideal_candidate. See if X or Y is a better match ! 1021: than the other. */ ! 1022: static int ! 1023: strictly_better (x, y) ! 1024: unsigned short x, y; ! 1025: { ! 1026: unsigned short xor; ! 1027: ! 1028: if (x == y) ! 1029: return 0; ! 1030: ! 1031: xor = x ^ y; ! 1032: if (xor >= x || xor >= y) ! 1033: return 1; ! 1034: return 0; ! 1035: } ! 1036: ! 1037: /* When one of several possible overloaded functions and/or methods ! 1038: can be called, choose the best candidate for overloading. ! 1039: ! 1040: BASETYPE is the context from which we start method resolution ! 1041: or NULL if we are comparing overloaded functions. ! 1042: CANDIDATES is the array of candidates we have to choose from. ! 1043: N_CANDIDATES is the length of CANDIDATES. ! 1044: PARMS is a TREE_LIST of parameters to the function we'll ultimately ! 1045: choose. It is modified in place when resolving methods. It is not ! 1046: modified in place when resolving overloaded functions. ! 1047: LEN is the length of the parameter list. */ ! 1048: ! 1049: static struct candidate * ! 1050: ideal_candidate (basetype, candidates, n_candidates, parms, len) ! 1051: tree basetype; ! 1052: struct candidate *candidates; ! 1053: int n_candidates; ! 1054: tree parms; ! 1055: int len; ! 1056: { ! 1057: struct candidate *cp = candidates+n_candidates; ! 1058: int i, j = -1, best_code; ! 1059: ! 1060: /* For each argument, sort the functions from best to worst for the arg. ! 1061: For each function that's not best for this arg, set its overall ! 1062: harshness to EVIL so that other args won't like it. The candidate ! 1063: list for the last argument is the intersection of all the best-liked ! 1064: functions. */ ! 1065: ! 1066: #if 0 ! 1067: for (i = 0; i < len; i++) ! 1068: { ! 1069: qsort (candidates, n_candidates, sizeof (struct candidate), ! 1070: rank_for_overload); ! 1071: best_code = cp[-1].h.code; ! 1072: ! 1073: /* To find out functions that are worse than that represented ! 1074: by BEST_CODE, we can't just do a comparison like h.code>best_code. ! 1075: The total harshness for the "best" fn may be 8|8 for two args, and ! 1076: the harshness for the next-best may be 8|2. If we just compared, ! 1077: that would be checking 8>10, which would lead to the next-best ! 1078: being disqualified. What we actually want to do is get rid ! 1079: of functions that are definitely worse than that represented ! 1080: by best_code, i.e. those which have bits set higher than the ! 1081: highest in best_code. Sooooo, what we do is clear out everything ! 1082: represented by best_code, and see if we still come up with something ! 1083: higher. If so (e.g., 8|8 vs 8|16), it'll disqualify it properly. */ ! 1084: for (j = n_candidates-2; j >= 0; j--) ! 1085: if ((candidates[j].h.code & ~best_code) > best_code) ! 1086: candidates[j].h.code = EVIL_CODE; ! 1087: } ! 1088: ! 1089: if (cp[-1].h.code & EVIL_CODE) ! 1090: return NULL; ! 1091: #else ! 1092: qsort (candidates, n_candidates, sizeof (struct candidate), ! 1093: rank_for_overload); ! 1094: best_code = cp[-1].h.code; ! 1095: #endif ! 1096: ! 1097: /* If they're at least as good as each other, do an arg-by-arg check. */ ! 1098: if (! strictly_better (cp[-1].h.code, cp[-2].h.code)) ! 1099: { ! 1100: int better = 0; ! 1101: int worse = 0; ! 1102: ! 1103: for (j = 0; j < n_candidates; j++) ! 1104: if (! strictly_better (candidates[j].h.code, best_code)) ! 1105: break; ! 1106: ! 1107: qsort (candidates+j, n_candidates-j, sizeof (struct candidate), ! 1108: rank_for_ideal); ! 1109: for (i = 0; i < len; i++) ! 1110: { ! 1111: if (cp[-1].harshness[i].code < cp[-2].harshness[i].code) ! 1112: better = 1; ! 1113: else if (cp[-1].harshness[i].code > cp[-2].harshness[i].code) ! 1114: worse = 1; ! 1115: else if (cp[-1].harshness[i].code & STD_CODE) ! 1116: { ! 1117: /* If it involves a standard conversion, let the ! 1118: inheritance lattice be the final arbiter. */ ! 1119: if (cp[-1].harshness[i].distance > cp[-2].harshness[i].distance) ! 1120: worse = 1; ! 1121: else if (cp[-1].harshness[i].distance < cp[-2].harshness[i].distance) ! 1122: better = 1; ! 1123: } ! 1124: else if (cp[-1].harshness[i].code & PROMO_CODE) ! 1125: { ! 1126: /* For integral promotions, take into account a finer ! 1127: granularity for determining which types should be favored ! 1128: over others in such promotions. */ ! 1129: if (cp[-1].harshness[i].int_penalty > cp[-2].harshness[i].int_penalty) ! 1130: worse = 1; ! 1131: else if (cp[-1].harshness[i].int_penalty < cp[-2].harshness[i].int_penalty) ! 1132: better = 1; ! 1133: } ! 1134: } ! 1135: ! 1136: if (! better || worse) ! 1137: return NULL; ! 1138: } ! 1139: return cp-1; ! 1140: } ! 1141: ! 1142: /* Assume that if the class referred to is not in the ! 1143: current class hierarchy, that it may be remote. ! 1144: PARENT is assumed to be of aggregate type here. */ ! 1145: static int ! 1146: may_be_remote (parent) ! 1147: tree parent; ! 1148: { ! 1149: if (TYPE_OVERLOADS_METHOD_CALL_EXPR (parent) == 0) ! 1150: return 0; ! 1151: ! 1152: if (current_class_type == NULL_TREE) ! 1153: return 0; ! 1154: ! 1155: if (parent == current_class_type) ! 1156: return 0; ! 1157: ! 1158: if (UNIQUELY_DERIVED_FROM_P (parent, current_class_type)) ! 1159: return 0; ! 1160: return 1; ! 1161: } ! 1162: ! 1163: tree ! 1164: build_vfield_ref (datum, type) ! 1165: tree datum, type; ! 1166: { ! 1167: tree rval; ! 1168: int old_assume_nonnull_objects = flag_assume_nonnull_objects; ! 1169: ! 1170: if (datum == error_mark_node) ! 1171: return error_mark_node; ! 1172: ! 1173: /* Vtable references are always made from non-null objects. */ ! 1174: flag_assume_nonnull_objects = 1; ! 1175: if (TREE_CODE (TREE_TYPE (datum)) == REFERENCE_TYPE) ! 1176: datum = convert_from_reference (datum); ! 1177: ! 1178: if (! TYPE_USES_COMPLEX_INHERITANCE (type)) ! 1179: rval = build (COMPONENT_REF, TREE_TYPE (CLASSTYPE_VFIELD (type)), ! 1180: datum, CLASSTYPE_VFIELD (type)); ! 1181: else ! 1182: rval = build_component_ref (datum, DECL_NAME (CLASSTYPE_VFIELD (type)), 0, 0); ! 1183: flag_assume_nonnull_objects = old_assume_nonnull_objects; ! 1184: ! 1185: return rval; ! 1186: } ! 1187: ! 1188: /* Build a call to a member of an object. I.e., one that overloads ! 1189: operator ()(), or is a pointer-to-function or pointer-to-method. */ ! 1190: static tree ! 1191: build_field_call (basetype_path, instance_ptr, name, parms) ! 1192: tree basetype_path, instance_ptr, name, parms; ! 1193: { ! 1194: tree field, instance; ! 1195: ! 1196: if (instance_ptr == current_class_decl) ! 1197: { ! 1198: /* Check to see if we really have a reference to an instance variable ! 1199: with `operator()()' overloaded. */ ! 1200: field = IDENTIFIER_CLASS_VALUE (name); ! 1201: ! 1202: if (field == NULL_TREE) ! 1203: { ! 1204: cp_error ("`this' has no member named `%D'", name); ! 1205: return error_mark_node; ! 1206: } ! 1207: ! 1208: if (TREE_CODE (field) == FIELD_DECL) ! 1209: { ! 1210: /* If it's a field, try overloading operator (), ! 1211: or calling if the field is a pointer-to-function. */ ! 1212: instance = build_component_ref_1 (C_C_D, field, 0); ! 1213: if (instance == error_mark_node) ! 1214: return error_mark_node; ! 1215: ! 1216: if (TYPE_LANG_SPECIFIC (TREE_TYPE (instance)) ! 1217: && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (instance))) ! 1218: return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, instance, parms, NULL_TREE); ! 1219: ! 1220: if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE) ! 1221: { ! 1222: if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == FUNCTION_TYPE) ! 1223: return build_function_call (instance, parms); ! 1224: else if (TREE_CODE (TREE_TYPE (TREE_TYPE (instance))) == METHOD_TYPE) ! 1225: return build_function_call (instance, tree_cons (NULL_TREE, current_class_decl, parms)); ! 1226: } ! 1227: } ! 1228: return NULL_TREE; ! 1229: } ! 1230: ! 1231: /* Check to see if this is not really a reference to an instance variable ! 1232: with `operator()()' overloaded. */ ! 1233: field = lookup_field (basetype_path, name, 1, 0); ! 1234: ! 1235: /* This can happen if the reference was ambiguous or for access ! 1236: violations. */ ! 1237: if (field == error_mark_node) ! 1238: return error_mark_node; ! 1239: ! 1240: if (field) ! 1241: { ! 1242: tree basetype; ! 1243: tree ftype = TREE_TYPE (field); ! 1244: ! 1245: if (TREE_CODE (ftype) == REFERENCE_TYPE) ! 1246: ftype = TREE_TYPE (ftype); ! 1247: ! 1248: if (TYPE_LANG_SPECIFIC (ftype) && TYPE_OVERLOADS_CALL_EXPR (ftype)) ! 1249: { ! 1250: /* Make the next search for this field very short. */ ! 1251: basetype = DECL_FIELD_CONTEXT (field); ! 1252: instance_ptr = convert_pointer_to (basetype, instance_ptr); ! 1253: ! 1254: instance = build_indirect_ref (instance_ptr, NULL_PTR); ! 1255: return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, ! 1256: build_component_ref_1 (instance, field, 0), ! 1257: parms, NULL_TREE); ! 1258: } ! 1259: if (TREE_CODE (ftype) == POINTER_TYPE) ! 1260: { ! 1261: if (TREE_CODE (TREE_TYPE (ftype)) == FUNCTION_TYPE ! 1262: || TREE_CODE (TREE_TYPE (ftype)) == METHOD_TYPE) ! 1263: { ! 1264: /* This is a member which is a pointer to function. */ ! 1265: tree ref ! 1266: = build_component_ref_1 (build_indirect_ref (instance_ptr, ! 1267: NULL_PTR), ! 1268: field, LOOKUP_COMPLAIN); ! 1269: if (ref == error_mark_node) ! 1270: return error_mark_node; ! 1271: return build_function_call (ref, parms); ! 1272: } ! 1273: } ! 1274: else if (TREE_CODE (ftype) == METHOD_TYPE) ! 1275: { ! 1276: error ("invalid call via pointer-to-member function"); ! 1277: return error_mark_node; ! 1278: } ! 1279: else ! 1280: return NULL_TREE; ! 1281: } ! 1282: return NULL_TREE; ! 1283: } ! 1284: ! 1285: tree ! 1286: find_scoped_type (type, inner_name, inner_types) ! 1287: tree type, inner_name, inner_types; ! 1288: { ! 1289: tree tags = CLASSTYPE_TAGS (type); ! 1290: ! 1291: while (tags) ! 1292: { ! 1293: /* The TREE_PURPOSE of an enum tag (which becomes a member of the ! 1294: enclosing class) is set to the name for the enum type. So, if ! 1295: inner_name is `bar', and we strike `baz' for `enum bar { baz }', ! 1296: then this test will be true. */ ! 1297: if (TREE_PURPOSE (tags) == inner_name) ! 1298: { ! 1299: if (inner_types == NULL_TREE) ! 1300: return DECL_NESTED_TYPENAME (TYPE_NAME (TREE_VALUE (tags))); ! 1301: return resolve_scope_to_name (TREE_VALUE (tags), inner_types); ! 1302: } ! 1303: tags = TREE_CHAIN (tags); ! 1304: } ! 1305: ! 1306: #if 0 ! 1307: /* XXX This needs to be fixed better. */ ! 1308: if (TREE_CODE (type) == UNINSTANTIATED_P_TYPE) ! 1309: { ! 1310: sorry ("nested class lookup in template type"); ! 1311: return NULL_TREE; ! 1312: } ! 1313: #endif ! 1314: ! 1315: /* Look for a TYPE_DECL. */ ! 1316: for (tags = TYPE_FIELDS (type); tags; tags = TREE_CHAIN (tags)) ! 1317: if (TREE_CODE (tags) == TYPE_DECL && DECL_NAME (tags) == inner_name) ! 1318: { ! 1319: /* Code by raeburn. */ ! 1320: if (inner_types == NULL_TREE) ! 1321: return DECL_NESTED_TYPENAME (tags); ! 1322: return resolve_scope_to_name (TREE_TYPE (tags), inner_types); ! 1323: } ! 1324: ! 1325: return NULL_TREE; ! 1326: } ! 1327: ! 1328: /* Resolve an expression NAME1::NAME2::...::NAMEn to ! 1329: the name that names the above nested type. INNER_TYPES ! 1330: is a chain of nested type names (held together by SCOPE_REFs); ! 1331: OUTER_TYPE is the type we know to enclose INNER_TYPES. ! 1332: Returns NULL_TREE if there is an error. */ ! 1333: tree ! 1334: resolve_scope_to_name (outer_type, inner_stuff) ! 1335: tree outer_type, inner_stuff; ! 1336: { ! 1337: register tree tmp; ! 1338: tree inner_name, inner_type; ! 1339: ! 1340: if (outer_type == NULL_TREE && current_class_type != NULL_TREE) ! 1341: { ! 1342: /* We first try to look for a nesting in our current class context, ! 1343: then try any enclosing classes. */ ! 1344: tree type = current_class_type; ! 1345: ! 1346: while (type && (TREE_CODE (type) == RECORD_TYPE ! 1347: || TREE_CODE (type) == UNION_TYPE)) ! 1348: { ! 1349: tree rval = resolve_scope_to_name (type, inner_stuff); ! 1350: ! 1351: if (rval != NULL_TREE) ! 1352: return rval; ! 1353: type = DECL_CONTEXT (TYPE_NAME (type)); ! 1354: } ! 1355: } ! 1356: ! 1357: if (TREE_CODE (inner_stuff) == SCOPE_REF) ! 1358: { ! 1359: inner_name = TREE_OPERAND (inner_stuff, 0); ! 1360: inner_type = TREE_OPERAND (inner_stuff, 1); ! 1361: } ! 1362: else ! 1363: { ! 1364: inner_name = inner_stuff; ! 1365: inner_type = NULL_TREE; ! 1366: } ! 1367: ! 1368: if (outer_type == NULL_TREE) ! 1369: { ! 1370: /* If we have something that's already a type by itself, ! 1371: use that. */ ! 1372: if (IDENTIFIER_HAS_TYPE_VALUE (inner_name)) ! 1373: { ! 1374: if (inner_type) ! 1375: return resolve_scope_to_name (IDENTIFIER_TYPE_VALUE (inner_name), ! 1376: inner_type); ! 1377: return inner_name; ! 1378: } ! 1379: return NULL_TREE; ! 1380: } ! 1381: ! 1382: if (! IS_AGGR_TYPE (outer_type)) ! 1383: return NULL_TREE; ! 1384: ! 1385: /* Look for member classes or enums. */ ! 1386: tmp = find_scoped_type (outer_type, inner_name, inner_type); ! 1387: ! 1388: /* If it's not a type in this class, then go down into the ! 1389: base classes and search there. */ ! 1390: if (! tmp && TYPE_BINFO (outer_type)) ! 1391: { ! 1392: tree binfos = TYPE_BINFO_BASETYPES (outer_type); ! 1393: int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; ! 1394: ! 1395: for (i = 0; i < n_baselinks; i++) ! 1396: { ! 1397: tree base_binfo = TREE_VEC_ELT (binfos, i); ! 1398: tmp = resolve_scope_to_name (BINFO_TYPE (base_binfo), inner_stuff); ! 1399: if (tmp) ! 1400: return tmp; ! 1401: } ! 1402: tmp = NULL_TREE; ! 1403: } ! 1404: ! 1405: return tmp; ! 1406: } ! 1407: ! 1408: /* Build a method call of the form `EXP->SCOPES::NAME (PARMS)'. ! 1409: This is how virtual function calls are avoided. */ ! 1410: tree ! 1411: build_scoped_method_call (exp, scopes, name, parms) ! 1412: tree exp, scopes, name, parms; ! 1413: { ! 1414: /* Because this syntactic form does not allow ! 1415: a pointer to a base class to be `stolen', ! 1416: we need not protect the derived->base conversion ! 1417: that happens here. ! 1418: ! 1419: @@ But we do have to check access privileges later. */ ! 1420: tree basename = resolve_scope_to_name (NULL_TREE, scopes); ! 1421: tree basetype, binfo, decl; ! 1422: tree type = TREE_TYPE (exp); ! 1423: ! 1424: if (type == error_mark_node ! 1425: || basename == NULL_TREE) ! 1426: return error_mark_node; ! 1427: ! 1428: basetype = IDENTIFIER_TYPE_VALUE (basename); ! 1429: ! 1430: if (TREE_CODE (type) == REFERENCE_TYPE) ! 1431: type = TREE_TYPE (type); ! 1432: ! 1433: /* Destructors can be "called" for simple types; see 5.2.4 and 12.4 Note ! 1434: that explicit ~int is caught in the parser; this deals with typedefs ! 1435: and template parms. */ ! 1436: if (TREE_CODE (name) == BIT_NOT_EXPR && ! is_aggr_typedef (basename, 0)) ! 1437: { ! 1438: if (type != basetype) ! 1439: cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')", ! 1440: exp, basetype, type); ! 1441: name = TREE_OPERAND (name, 0); ! 1442: if (basetype != get_type_value (name)) ! 1443: cp_error ("qualified type `%T' does not match destructor name `~%T'", ! 1444: basetype, name); ! 1445: return convert (void_type_node, exp); ! 1446: } ! 1447: ! 1448: if (! is_aggr_typedef (basename, 1)) ! 1449: return error_mark_node; ! 1450: ! 1451: if (! IS_AGGR_TYPE (type)) ! 1452: { ! 1453: cp_error ("base object `%E' of scoped method call is of non-aggregate type `%T'", ! 1454: exp, type); ! 1455: return error_mark_node; ! 1456: } ! 1457: ! 1458: if ((binfo = binfo_or_else (basetype, type))) ! 1459: { ! 1460: if (binfo == error_mark_node) ! 1461: return error_mark_node; ! 1462: if (TREE_CODE (exp) == INDIRECT_REF) ! 1463: decl = build_indirect_ref (convert_pointer_to (binfo, ! 1464: build_unary_op (ADDR_EXPR, exp, 0)), NULL_PTR); ! 1465: else ! 1466: decl = build_scoped_ref (exp, scopes); ! 1467: ! 1468: /* Call to a destructor. */ ! 1469: if (TREE_CODE (name) == BIT_NOT_EXPR) ! 1470: { ! 1471: /* Explicit call to destructor. */ ! 1472: name = TREE_OPERAND (name, 0); ! 1473: if (! (name == constructor_name (TREE_TYPE (decl)) ! 1474: || TREE_TYPE (decl) == get_type_value (name))) ! 1475: { ! 1476: cp_error ! 1477: ("qualified type `%T' does not match destructor name `~%T'", ! 1478: TREE_TYPE (decl), name); ! 1479: return error_mark_node; ! 1480: } ! 1481: if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl))) ! 1482: return convert (void_type_node, exp); ! 1483: ! 1484: return build_delete (TREE_TYPE (decl), decl, integer_two_node, ! 1485: LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, ! 1486: 0); ! 1487: } ! 1488: ! 1489: /* Call to a method. */ ! 1490: return build_method_call (decl, name, parms, binfo, ! 1491: LOOKUP_NORMAL|LOOKUP_NONVIRTUAL); ! 1492: } ! 1493: return error_mark_node; ! 1494: } ! 1495: ! 1496: static void ! 1497: print_candidates (candidates) ! 1498: tree candidates; ! 1499: { ! 1500: cp_error_at ("candidates are: %D", TREE_VALUE (candidates)); ! 1501: candidates = TREE_CHAIN (candidates); ! 1502: ! 1503: while (candidates) ! 1504: { ! 1505: cp_error_at (" %D", TREE_VALUE (candidates)); ! 1506: candidates = TREE_CHAIN (candidates); ! 1507: } ! 1508: } ! 1509: ! 1510: static void ! 1511: print_n_candidates (candidates, n) ! 1512: struct candidate *candidates; ! 1513: int n; ! 1514: { ! 1515: int i; ! 1516: ! 1517: cp_error_at ("candidates are: %D", candidates[0].function); ! 1518: for (i = 1; i < n; i++) ! 1519: cp_error_at (" %D", candidates[i].function); ! 1520: } ! 1521: ! 1522: /* Build something of the form ptr->method (args) ! 1523: or object.method (args). This can also build ! 1524: calls to constructors, and find friends. ! 1525: ! 1526: Member functions always take their class variable ! 1527: as a pointer. ! 1528: ! 1529: INSTANCE is a class instance. ! 1530: ! 1531: NAME is the name of the method desired, usually an IDENTIFIER_NODE. ! 1532: ! 1533: PARMS help to figure out what that NAME really refers to. ! 1534: ! 1535: BASETYPE_PATH, if non-NULL, contains a chain from the type of INSTANCE ! 1536: down to the real instance type to use for access checking. We need this ! 1537: information to get protected accesses correct. This parameter is used ! 1538: by build_member_call. ! 1539: ! 1540: FLAGS is the logical disjunction of zero or more LOOKUP_ ! 1541: flags. See cp-tree.h for more info. ! 1542: ! 1543: If this is all OK, calls build_function_call with the resolved ! 1544: member function. ! 1545: ! 1546: This function must also handle being called to perform ! 1547: initialization, promotion/coercion of arguments, and ! 1548: instantiation of default parameters. ! 1549: ! 1550: Note that NAME may refer to an instance variable name. If ! 1551: `operator()()' is defined for the type of that field, then we return ! 1552: that result. */ ! 1553: tree ! 1554: build_method_call (instance, name, parms, basetype_path, flags) ! 1555: tree instance, name, parms, basetype_path; ! 1556: int flags; ! 1557: { ! 1558: register tree function, fntype, value_type; ! 1559: register tree basetype, save_basetype; ! 1560: register tree baselink, result, method_name, parmtypes, parm; ! 1561: tree last; ! 1562: int pass; ! 1563: enum access_type access = access_public; ! 1564: ! 1565: /* Range of cases for vtable optimization. */ ! 1566: enum vtable_needs { not_needed, maybe_needed, unneeded, needed }; ! 1567: enum vtable_needs need_vtbl = not_needed; ! 1568: ! 1569: char *name_kind; ! 1570: int ever_seen = 0; ! 1571: tree instance_ptr = NULL_TREE; ! 1572: int all_virtual = flag_all_virtual; ! 1573: int static_call_context = 0; ! 1574: tree found_fns = NULL_TREE; ! 1575: ! 1576: /* Keep track of `const' and `volatile' objects. */ ! 1577: int constp, volatilep; ! 1578: ! 1579: #ifdef GATHER_STATISTICS ! 1580: n_build_method_call++; ! 1581: #endif ! 1582: ! 1583: if (instance == error_mark_node ! 1584: || name == error_mark_node ! 1585: || parms == error_mark_node ! 1586: || (instance != NULL_TREE && TREE_TYPE (instance) == error_mark_node)) ! 1587: return error_mark_node; ! 1588: ! 1589: /* This is the logic that magically deletes the second argument to ! 1590: operator delete, if it is not needed. */ ! 1591: if (name == ansi_opname[(int) DELETE_EXPR] && list_length (parms)==2) ! 1592: { ! 1593: tree save_last = TREE_CHAIN (parms); ! 1594: tree result; ! 1595: /* get rid of unneeded argument */ ! 1596: TREE_CHAIN (parms) = NULL_TREE; ! 1597: result = build_method_call (instance, name, parms, basetype_path, ! 1598: (LOOKUP_SPECULATIVELY|flags) ! 1599: &~LOOKUP_COMPLAIN); ! 1600: /* If it works, return it. */ ! 1601: if (result && result != error_mark_node) ! 1602: return build_method_call (instance, name, parms, basetype_path, flags); ! 1603: /* If it doesn't work, two argument delete must work */ ! 1604: TREE_CHAIN (parms) = save_last; ! 1605: } ! 1606: /* We already know whether it's needed or not for vec delete. */ ! 1607: else if (name == ansi_opname[(int) VEC_DELETE_EXPR] ! 1608: && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance))) ! 1609: TREE_CHAIN (parms) = NULL_TREE; ! 1610: ! 1611: if (TREE_CODE (name) == BIT_NOT_EXPR) ! 1612: { ! 1613: flags |= LOOKUP_DESTRUCTOR; ! 1614: name = TREE_OPERAND (name, 0); ! 1615: if (parms) ! 1616: error ("destructors take no parameters"); ! 1617: basetype = TREE_TYPE (instance); ! 1618: if (TREE_CODE (basetype) == REFERENCE_TYPE) ! 1619: basetype = TREE_TYPE (basetype); ! 1620: if (! ((IS_AGGR_TYPE (basetype) ! 1621: && name == constructor_name (basetype)) ! 1622: || basetype == get_type_value (name))) ! 1623: { ! 1624: cp_error ("destructor name `~%D' does not match type `%T' of expression", ! 1625: name, basetype); ! 1626: return convert (void_type_node, instance); ! 1627: } ! 1628: ! 1629: if (! TYPE_HAS_DESTRUCTOR (basetype)) ! 1630: return convert (void_type_node, instance); ! 1631: instance = default_conversion (instance); ! 1632: instance_ptr = build_unary_op (ADDR_EXPR, instance, 0); ! 1633: return build_delete (build_pointer_type (basetype), ! 1634: instance_ptr, integer_two_node, ! 1635: LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 0); ! 1636: } ! 1637: ! 1638: { ! 1639: char *xref_name; ! 1640: ! 1641: /* Initialize name for error reporting. */ ! 1642: if (IDENTIFIER_OPNAME_P (name) && ! IDENTIFIER_TYPENAME_P (name)) ! 1643: { ! 1644: char *p = operator_name_string (name); ! 1645: xref_name = (char *)alloca (strlen (p) + 10); ! 1646: sprintf (xref_name, "operator %s", p); ! 1647: } ! 1648: else if (TREE_CODE (name) == SCOPE_REF) ! 1649: xref_name = IDENTIFIER_POINTER (TREE_OPERAND (name, 1)); ! 1650: else ! 1651: xref_name = IDENTIFIER_POINTER (name); ! 1652: ! 1653: GNU_xref_call (current_function_decl, xref_name); ! 1654: } ! 1655: ! 1656: if (instance == NULL_TREE) ! 1657: { ! 1658: basetype = NULL_TREE; ! 1659: /* Check cases where this is really a call to raise ! 1660: an exception. */ ! 1661: if (current_class_type && TREE_CODE (name) == IDENTIFIER_NODE) ! 1662: { ! 1663: basetype = purpose_member (name, CLASSTYPE_TAGS (current_class_type)); ! 1664: if (basetype) ! 1665: basetype = TREE_VALUE (basetype); ! 1666: } ! 1667: else if (TREE_CODE (name) == SCOPE_REF ! 1668: && TREE_CODE (TREE_OPERAND (name, 0)) == IDENTIFIER_NODE) ! 1669: { ! 1670: if (! is_aggr_typedef (TREE_OPERAND (name, 0), 1)) ! 1671: return error_mark_node; ! 1672: basetype = purpose_member (TREE_OPERAND (name, 1), ! 1673: CLASSTYPE_TAGS (IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name, 0)))); ! 1674: if (basetype) ! 1675: basetype = TREE_VALUE (basetype); ! 1676: } ! 1677: ! 1678: if (basetype != NULL_TREE) ! 1679: ; ! 1680: /* call to a constructor... */ ! 1681: else if (basetype_path) ! 1682: basetype = BINFO_TYPE (basetype_path); ! 1683: else if (IDENTIFIER_HAS_TYPE_VALUE (name)) ! 1684: { ! 1685: basetype = IDENTIFIER_TYPE_VALUE (name); ! 1686: name = constructor_name_full (basetype); ! 1687: } ! 1688: else ! 1689: { ! 1690: tree typedef_name = lookup_name (name, 1); ! 1691: if (typedef_name && TREE_CODE (typedef_name) == TYPE_DECL) ! 1692: { ! 1693: /* Canonicalize the typedef name. */ ! 1694: basetype = TREE_TYPE (typedef_name); ! 1695: name = TYPE_IDENTIFIER (basetype); ! 1696: } ! 1697: else ! 1698: { ! 1699: cp_error ("no constructor named `%T' in scope", ! 1700: name); ! 1701: return error_mark_node; ! 1702: } ! 1703: } ! 1704: ! 1705: if (! IS_AGGR_TYPE (basetype)) ! 1706: { ! 1707: non_aggr_error: ! 1708: if ((flags & LOOKUP_COMPLAIN) && TREE_CODE (basetype) != ERROR_MARK) ! 1709: cp_error ("request for member `%D' in `%E', which is of non-aggregate type `%T'", ! 1710: name, instance, basetype); ! 1711: ! 1712: return error_mark_node; ! 1713: } ! 1714: } ! 1715: else if (instance == C_C_D || instance == current_class_decl) ! 1716: { ! 1717: /* When doing initialization, we side-effect the TREE_TYPE of ! 1718: C_C_D, hence we cannot set up BASETYPE from CURRENT_CLASS_TYPE. */ ! 1719: basetype = TREE_TYPE (C_C_D); ! 1720: ! 1721: /* Anything manifestly `this' in constructors and destructors ! 1722: has a known type, so virtual function tables are not needed. */ ! 1723: if (TYPE_VIRTUAL_P (basetype) ! 1724: && !(flags & LOOKUP_NONVIRTUAL)) ! 1725: need_vtbl = (dtor_label || ctor_label) ! 1726: ? unneeded : maybe_needed; ! 1727: ! 1728: instance = C_C_D; ! 1729: instance_ptr = current_class_decl; ! 1730: result = build_field_call (TYPE_BINFO (current_class_type), ! 1731: instance_ptr, name, parms); ! 1732: ! 1733: if (result) ! 1734: return result; ! 1735: } ! 1736: else if (TREE_CODE (instance) == RESULT_DECL) ! 1737: { ! 1738: basetype = TREE_TYPE (instance); ! 1739: /* Should we ever have to make a virtual function reference ! 1740: from a RESULT_DECL, know that it must be of fixed type ! 1741: within the scope of this function. */ ! 1742: if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype)) ! 1743: need_vtbl = maybe_needed; ! 1744: instance_ptr = build1 (ADDR_EXPR, TYPE_POINTER_TO (basetype), instance); ! 1745: } ! 1746: else ! 1747: { ! 1748: /* The MAIN_VARIANT of the type that `instance_ptr' winds up being. */ ! 1749: tree inst_ptr_basetype; ! 1750: ! 1751: static_call_context = ! 1752: (TREE_CODE (instance) == INDIRECT_REF ! 1753: && TREE_CODE (TREE_OPERAND (instance, 0)) == NOP_EXPR ! 1754: && TREE_OPERAND (TREE_OPERAND (instance, 0), 0) == error_mark_node); ! 1755: ! 1756: if (TREE_CODE (instance) == OFFSET_REF) ! 1757: instance = resolve_offset_ref (instance); ! 1758: ! 1759: /* the base type of an instance variable is pointer to class */ ! 1760: basetype = TREE_TYPE (instance); ! 1761: ! 1762: if (TREE_CODE (basetype) == REFERENCE_TYPE) ! 1763: { ! 1764: basetype = TREE_TYPE (basetype); ! 1765: if (! IS_AGGR_TYPE (basetype)) ! 1766: goto non_aggr_error; ! 1767: /* Call to convert not needed because we are remaining ! 1768: within the same type. */ ! 1769: instance_ptr = build1 (NOP_EXPR, build_pointer_type (basetype), ! 1770: instance); ! 1771: inst_ptr_basetype = TYPE_MAIN_VARIANT (basetype); ! 1772: } ! 1773: else ! 1774: { ! 1775: if (! IS_AGGR_TYPE (basetype)) ! 1776: goto non_aggr_error; ! 1777: ! 1778: /* If `instance' is a signature pointer/reference and `name' is ! 1779: not a constructor, we are calling a signature member function. ! 1780: In that case set the `basetype' to the signature type. */ ! 1781: if ((IS_SIGNATURE_POINTER (basetype) ! 1782: || IS_SIGNATURE_REFERENCE (basetype)) ! 1783: && TYPE_IDENTIFIER (basetype) != name) ! 1784: basetype = SIGNATURE_TYPE (basetype); ! 1785: ! 1786: if ((IS_SIGNATURE (basetype) ! 1787: && (instance_ptr = build_optr_ref (instance))) ! 1788: || (lvalue_p (instance) ! 1789: && (instance_ptr = build_unary_op (ADDR_EXPR, instance, 0))) ! 1790: || (instance_ptr = unary_complex_lvalue (ADDR_EXPR, instance))) ! 1791: { ! 1792: if (instance_ptr == error_mark_node) ! 1793: return error_mark_node; ! 1794: } ! 1795: else if (TREE_CODE (instance) == NOP_EXPR ! 1796: || TREE_CODE (instance) == CONSTRUCTOR) ! 1797: { ! 1798: /* A cast is not an lvalue. Initialize a fresh temp ! 1799: with the value we are casting from, and proceed with ! 1800: that temporary. We can't cast to a reference type, ! 1801: so that simplifies the initialization to something ! 1802: we can manage. */ ! 1803: tree temp = get_temp_name (TREE_TYPE (instance), 0); ! 1804: if (IS_AGGR_TYPE (TREE_TYPE (instance))) ! 1805: expand_aggr_init (temp, instance, 0); ! 1806: else ! 1807: { ! 1808: store_init_value (temp, instance); ! 1809: expand_decl_init (temp); ! 1810: } ! 1811: instance = temp; ! 1812: instance_ptr = build_unary_op (ADDR_EXPR, instance, 0); ! 1813: } ! 1814: else ! 1815: { ! 1816: if (TREE_CODE (instance) != CALL_EXPR ! 1817: #ifdef PCC_STATIC_STRUCT_RETURN ! 1818: && TREE_CODE (instance) != RTL_EXPR ! 1819: #endif ! 1820: ) ! 1821: my_friendly_abort (125); ! 1822: if (TYPE_NEEDS_CONSTRUCTING (basetype)) ! 1823: instance = build_cplus_new (basetype, instance, 0); ! 1824: else ! 1825: { ! 1826: instance = get_temp_name (basetype, 0); ! 1827: TREE_ADDRESSABLE (instance) = 1; ! 1828: } ! 1829: instance_ptr = build_unary_op (ADDR_EXPR, instance, 0); ! 1830: } ! 1831: /* @@ Should we call comp_target_types here? */ ! 1832: inst_ptr_basetype = TREE_TYPE (TREE_TYPE (instance_ptr)); ! 1833: if (TYPE_MAIN_VARIANT (basetype) == TYPE_MAIN_VARIANT (inst_ptr_basetype)) ! 1834: basetype = inst_ptr_basetype; ! 1835: else ! 1836: { ! 1837: instance_ptr = convert (TYPE_POINTER_TO (basetype), instance_ptr); ! 1838: if (instance_ptr == error_mark_node) ! 1839: return error_mark_node; ! 1840: } ! 1841: } ! 1842: ! 1843: /* After converting `instance_ptr' above, `inst_ptr_basetype' was ! 1844: not updated, so we use `basetype' instead. */ ! 1845: if (basetype_path == NULL_TREE ! 1846: && IS_SIGNATURE (basetype)) ! 1847: basetype_path = TYPE_BINFO (basetype); ! 1848: else if (basetype_path == NULL_TREE || ! 1849: BINFO_TYPE (basetype_path) != TYPE_MAIN_VARIANT (inst_ptr_basetype)) ! 1850: basetype_path = TYPE_BINFO (inst_ptr_basetype); ! 1851: ! 1852: result = build_field_call (basetype_path, instance_ptr, name, parms); ! 1853: if (result) ! 1854: return result; ! 1855: ! 1856: if (!(flags & LOOKUP_NONVIRTUAL) && TYPE_VIRTUAL_P (basetype)) ! 1857: { ! 1858: if (TREE_SIDE_EFFECTS (instance_ptr)) ! 1859: { ! 1860: /* This action is needed because the instance is needed ! 1861: for providing the base of the virtual function table. ! 1862: Without using a SAVE_EXPR, the function we are building ! 1863: may be called twice, or side effects on the instance ! 1864: variable (such as a post-increment), may happen twice. */ ! 1865: instance_ptr = save_expr (instance_ptr); ! 1866: instance = build_indirect_ref (instance_ptr, NULL_PTR); ! 1867: } ! 1868: else if (TREE_CODE (TREE_TYPE (instance)) == POINTER_TYPE) ! 1869: { ! 1870: /* This happens when called for operator new (). */ ! 1871: instance = build_indirect_ref (instance, NULL_PTR); ! 1872: } ! 1873: ! 1874: need_vtbl = maybe_needed; ! 1875: } ! 1876: } ! 1877: ! 1878: if (TYPE_SIZE (basetype) == 0) ! 1879: { ! 1880: /* This is worth complaining about, I think. */ ! 1881: cp_error ("cannot lookup method in incomplete type `%T'", basetype); ! 1882: return error_mark_node; ! 1883: } ! 1884: ! 1885: save_basetype = TYPE_MAIN_VARIANT (basetype); ! 1886: ! 1887: #if 0 ! 1888: if (all_virtual == 1 ! 1889: && (! strncmp (IDENTIFIER_POINTER (name), OPERATOR_METHOD_FORMAT, ! 1890: OPERATOR_METHOD_LENGTH) ! 1891: || instance_ptr == NULL_TREE ! 1892: || (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype) == 0))) ! 1893: all_virtual = 0; ! 1894: #endif ! 1895: ! 1896: last = NULL_TREE; ! 1897: for (parmtypes = NULL_TREE, parm = parms; parm; parm = TREE_CHAIN (parm)) ! 1898: { ! 1899: tree t = TREE_TYPE (TREE_VALUE (parm)); ! 1900: if (TREE_CODE (t) == OFFSET_TYPE) ! 1901: { ! 1902: /* Convert OFFSET_TYPE entities to their normal selves. */ ! 1903: TREE_VALUE (parm) = resolve_offset_ref (TREE_VALUE (parm)); ! 1904: t = TREE_TYPE (TREE_VALUE (parm)); ! 1905: } ! 1906: if (TREE_CODE (TREE_VALUE (parm)) == OFFSET_REF ! 1907: && TREE_CODE (t) == METHOD_TYPE) ! 1908: { ! 1909: TREE_VALUE (parm) = build_unary_op (ADDR_EXPR, TREE_VALUE (parm), 0); ! 1910: } ! 1911: #if 0 ! 1912: /* This breaks reference-to-array parameters. */ ! 1913: if (TREE_CODE (t) == ARRAY_TYPE) ! 1914: { ! 1915: /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place. ! 1916: This eliminates needless calls to `compute_conversion_costs'. */ ! 1917: TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm)); ! 1918: t = TREE_TYPE (TREE_VALUE (parm)); ! 1919: } ! 1920: #endif ! 1921: if (t == error_mark_node) ! 1922: return error_mark_node; ! 1923: last = build_tree_list (NULL_TREE, t); ! 1924: parmtypes = chainon (parmtypes, last); ! 1925: } ! 1926: ! 1927: if (instance) ! 1928: { ! 1929: /* TREE_READONLY (instance) fails for references. */ ! 1930: constp = TYPE_READONLY (TREE_TYPE (TREE_TYPE (instance_ptr))); ! 1931: volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (instance_ptr))); ! 1932: parms = tree_cons (NULL_TREE, instance_ptr, parms); ! 1933: } ! 1934: else ! 1935: { ! 1936: /* Raw constructors are always in charge. */ ! 1937: if (TYPE_USES_VIRTUAL_BASECLASSES (basetype) ! 1938: && ! (flags & LOOKUP_HAS_IN_CHARGE)) ! 1939: { ! 1940: flags |= LOOKUP_HAS_IN_CHARGE; ! 1941: parms = tree_cons (NULL_TREE, integer_one_node, parms); ! 1942: parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes); ! 1943: } ! 1944: ! 1945: if (flag_this_is_variable > 0) ! 1946: { ! 1947: constp = 0; ! 1948: volatilep = 0; ! 1949: parms = tree_cons (NULL_TREE, ! 1950: build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), ! 1951: integer_zero_node), parms); ! 1952: } ! 1953: else ! 1954: { ! 1955: constp = 0; ! 1956: volatilep = 0; ! 1957: instance_ptr = build_new (NULL_TREE, basetype, void_type_node, 0); ! 1958: if (instance_ptr == error_mark_node) ! 1959: return error_mark_node; ! 1960: instance_ptr = save_expr (instance_ptr); ! 1961: TREE_CALLS_NEW (instance_ptr) = 1; ! 1962: instance = build_indirect_ref (instance_ptr, NULL_PTR); ! 1963: ! 1964: #if 0 ! 1965: /* This breaks initialization of a reference from a new ! 1966: expression of a different type. And it doesn't appear to ! 1967: serve its original purpose any more, either. jason 10/12/94 */ ! 1968: /* If it's a default argument initialized from a ctor, what we get ! 1969: from instance_ptr will match the arglist for the FUNCTION_DECL ! 1970: of the constructor. */ ! 1971: if (parms && TREE_CODE (TREE_VALUE (parms)) == CALL_EXPR ! 1972: && TREE_OPERAND (TREE_VALUE (parms), 1) ! 1973: && TREE_CALLS_NEW (TREE_VALUE (TREE_OPERAND (TREE_VALUE (parms), 1)))) ! 1974: parms = build_tree_list (NULL_TREE, instance_ptr); ! 1975: else ! 1976: #endif ! 1977: parms = tree_cons (NULL_TREE, instance_ptr, parms); ! 1978: } ! 1979: } ! 1980: ! 1981: parmtypes = tree_cons (NULL_TREE, TREE_TYPE (instance_ptr), parmtypes); ! 1982: ! 1983: if (last == NULL_TREE) ! 1984: last = parmtypes; ! 1985: ! 1986: /* Look up function name in the structure type definition. */ ! 1987: ! 1988: if ((IDENTIFIER_HAS_TYPE_VALUE (name) ! 1989: && ! IDENTIFIER_OPNAME_P (name) ! 1990: && IS_AGGR_TYPE (IDENTIFIER_TYPE_VALUE (name)) ! 1991: && TREE_CODE (IDENTIFIER_TYPE_VALUE (name)) != UNINSTANTIATED_P_TYPE) ! 1992: || name == constructor_name (basetype)) ! 1993: { ! 1994: tree tmp = NULL_TREE; ! 1995: if (IDENTIFIER_TYPE_VALUE (name) == basetype ! 1996: || name == constructor_name (basetype)) ! 1997: tmp = TYPE_BINFO (basetype); ! 1998: else ! 1999: tmp = get_binfo (IDENTIFIER_TYPE_VALUE (name), basetype, 0); ! 2000: ! 2001: if (tmp != NULL_TREE) ! 2002: { ! 2003: name_kind = "constructor"; ! 2004: ! 2005: if (TYPE_USES_VIRTUAL_BASECLASSES (basetype) ! 2006: && ! (flags & LOOKUP_HAS_IN_CHARGE)) ! 2007: { ! 2008: /* Constructors called for initialization ! 2009: only are never in charge. */ ! 2010: tree tmplist; ! 2011: ! 2012: flags |= LOOKUP_HAS_IN_CHARGE; ! 2013: tmplist = tree_cons (NULL_TREE, integer_zero_node, ! 2014: TREE_CHAIN (parms)); ! 2015: TREE_CHAIN (parms) = tmplist; ! 2016: tmplist = tree_cons (NULL_TREE, integer_type_node, TREE_CHAIN (parmtypes)); ! 2017: TREE_CHAIN (parmtypes) = tmplist; ! 2018: } ! 2019: basetype = BINFO_TYPE (tmp); ! 2020: } ! 2021: else ! 2022: name_kind = "method"; ! 2023: } ! 2024: else ! 2025: name_kind = "method"; ! 2026: ! 2027: if (basetype_path == NULL_TREE ! 2028: || BINFO_TYPE (basetype_path) != TYPE_MAIN_VARIANT (basetype)) ! 2029: basetype_path = TYPE_BINFO (basetype); ! 2030: result = lookup_fnfields (basetype_path, name, ! 2031: (flags & LOOKUP_COMPLAIN)); ! 2032: if (result == error_mark_node) ! 2033: return error_mark_node; ! 2034: ! 2035: ! 2036: #if 0 ! 2037: /* Now, go look for this method name. We do not find destructors here. ! 2038: ! 2039: Putting `void_list_node' on the end of the parmtypes ! 2040: fakes out `build_decl_overload' into doing the right thing. */ ! 2041: TREE_CHAIN (last) = void_list_node; ! 2042: method_name = build_decl_overload (name, parmtypes, ! 2043: 1 + (name == constructor_name (save_basetype) ! 2044: || name == constructor_name_full (save_basetype))); ! 2045: TREE_CHAIN (last) = NULL_TREE; ! 2046: #endif ! 2047: ! 2048: for (pass = 0; pass < 2; pass++) ! 2049: { ! 2050: struct candidate *candidates; ! 2051: struct candidate *cp; ! 2052: int len; ! 2053: unsigned best = 1; ! 2054: ! 2055: /* This increments every time we go up the type hierarchy. ! 2056: The idea is to prefer a function of the derived class if possible. */ ! 2057: int b_or_d = 0; ! 2058: ! 2059: baselink = result; ! 2060: ! 2061: if (pass > 0) ! 2062: { ! 2063: candidates ! 2064: = (struct candidate *) alloca ((ever_seen+1) ! 2065: * sizeof (struct candidate)); ! 2066: bzero ((char *) candidates, (ever_seen + 1) * sizeof (struct candidate)); ! 2067: cp = candidates; ! 2068: len = list_length (parms); ! 2069: ever_seen = 0; ! 2070: ! 2071: /* First see if a global function has a shot at it. */ ! 2072: if (flags & LOOKUP_GLOBAL) ! 2073: { ! 2074: tree friend_parms; ! 2075: tree parm = instance_ptr; ! 2076: ! 2077: if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE) ! 2078: { ! 2079: /* TREE_VALUE (parms) may have been modified by now; ! 2080: restore it to its original value. */ ! 2081: TREE_VALUE (parms) = parm; ! 2082: friend_parms = parms; ! 2083: } ! 2084: else if (TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE) ! 2085: { ! 2086: tree new_type; ! 2087: parm = build_indirect_ref (parm, "friendifying parms (compiler error)"); ! 2088: new_type = cp_build_type_variant (TREE_TYPE (parm), constp, ! 2089: volatilep); ! 2090: new_type = build_reference_type (new_type); ! 2091: parm = convert (new_type, parm); ! 2092: friend_parms = tree_cons (NULL_TREE, parm, TREE_CHAIN (parms)); ! 2093: } ! 2094: else ! 2095: my_friendly_abort (167); ! 2096: ! 2097: cp->h_len = len; ! 2098: cp->harshness = (struct harshness_code *) ! 2099: alloca ((len + 1) * sizeof (struct harshness_code)); ! 2100: ! 2101: result = build_overload_call (name, friend_parms, 0, cp); ! 2102: /* If it turns out to be the one we were actually looking for ! 2103: (it was probably a friend function), the return the ! 2104: good result. */ ! 2105: if (TREE_CODE (result) == CALL_EXPR) ! 2106: return result; ! 2107: ! 2108: while ((cp->h.code & EVIL_CODE) == 0) ! 2109: { ! 2110: /* non-standard uses: set the field to 0 to indicate ! 2111: we are using a non-member function. */ ! 2112: cp->u.field = 0; ! 2113: if (cp->harshness[len].distance == 0 ! 2114: && cp->h.code < best) ! 2115: best = cp->h.code; ! 2116: cp += 1; ! 2117: } ! 2118: } ! 2119: } ! 2120: ! 2121: while (baselink) ! 2122: { ! 2123: /* We have a hit (of sorts). If the parameter list is ! 2124: "error_mark_node", or some variant thereof, it won't ! 2125: match any methods. Since we have verified that the is ! 2126: some method vaguely matching this one (in name at least), ! 2127: silently return. ! 2128: ! 2129: Don't stop for friends, however. */ ! 2130: basetype_path = TREE_PURPOSE (baselink); ! 2131: ! 2132: function = TREE_VALUE (baselink); ! 2133: if (TREE_CODE (basetype_path) == TREE_LIST) ! 2134: basetype_path = TREE_VALUE (basetype_path); ! 2135: basetype = BINFO_TYPE (basetype_path); ! 2136: ! 2137: /* Cast the instance variable if necessary. */ ! 2138: if (basetype != TYPE_MAIN_VARIANT ! 2139: (TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))))) ! 2140: { ! 2141: if (basetype == save_basetype) ! 2142: TREE_VALUE (parms) = instance_ptr; ! 2143: else ! 2144: { ! 2145: tree type = build_pointer_type ! 2146: (build_type_variant (basetype, constp, volatilep)); ! 2147: TREE_VALUE (parms) = convert_force (type, instance_ptr); ! 2148: } ! 2149: } ! 2150: ! 2151: /* FIXME: this is the wrong place to get an error. Hopefully ! 2152: the access-control rewrite will make this change more cleanly. */ ! 2153: if (TREE_VALUE (parms) == error_mark_node) ! 2154: return error_mark_node; ! 2155: ! 2156: if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (function))) ! 2157: function = DECL_CHAIN (function); ! 2158: ! 2159: for (; function; function = DECL_CHAIN (function)) ! 2160: { ! 2161: #ifdef GATHER_STATISTICS ! 2162: n_inner_fields_searched++; ! 2163: #endif ! 2164: ever_seen++; ! 2165: if (pass > 0) ! 2166: found_fns = tree_cons (NULL_TREE, function, found_fns); ! 2167: ! 2168: /* Not looking for friends here. */ ! 2169: if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE ! 2170: && ! DECL_STATIC_FUNCTION_P (function)) ! 2171: continue; ! 2172: ! 2173: #if 0 ! 2174: if (pass == 0 ! 2175: && DECL_ASSEMBLER_NAME (function) == method_name) ! 2176: goto found; ! 2177: #endif ! 2178: ! 2179: if (pass > 0) ! 2180: { ! 2181: tree these_parms = parms; ! 2182: ! 2183: #ifdef GATHER_STATISTICS ! 2184: n_inner_fields_searched++; ! 2185: #endif ! 2186: cp->h_len = len; ! 2187: cp->harshness = (struct harshness_code *) ! 2188: alloca ((len + 1) * sizeof (struct harshness_code)); ! 2189: ! 2190: if (DECL_STATIC_FUNCTION_P (function)) ! 2191: these_parms = TREE_CHAIN (these_parms); ! 2192: compute_conversion_costs (function, these_parms, cp, len); ! 2193: ! 2194: if ((cp->h.code & EVIL_CODE) == 0) ! 2195: { ! 2196: cp->u.field = function; ! 2197: cp->function = function; ! 2198: cp->basetypes = basetype_path; ! 2199: ! 2200: /* No "two-level" conversions. */ ! 2201: if (flags & LOOKUP_NO_CONVERSION ! 2202: && (cp->h.code & USER_CODE)) ! 2203: continue; ! 2204: ! 2205: /* If we used default parameters, we must ! 2206: check to see whether anyone else might ! 2207: use them also, and report a possible ! 2208: ambiguity. */ ! 2209: if (! TYPE_USES_MULTIPLE_INHERITANCE (save_basetype) ! 2210: && cp->harshness[len].distance == 0 ! 2211: && cp->h.code < best) ! 2212: { ! 2213: if (! DECL_STATIC_FUNCTION_P (function)) ! 2214: TREE_VALUE (parms) = cp->arg; ! 2215: if (best == 1) ! 2216: goto found_and_maybe_warn; ! 2217: } ! 2218: cp++; ! 2219: } ! 2220: } ! 2221: } ! 2222: /* Now we have run through one link's member functions. ! 2223: arrange to head-insert this link's links. */ ! 2224: baselink = next_baselink (baselink); ! 2225: b_or_d += 1; ! 2226: /* Don't grab functions from base classes. lookup_fnfield will ! 2227: do the work to get us down into the right place. */ ! 2228: baselink = NULL_TREE; ! 2229: } ! 2230: if (pass == 0) ! 2231: { ! 2232: tree igv = lookup_name_nonclass (name); ! 2233: ! 2234: /* No exact match could be found. Now try to find match ! 2235: using default conversions. */ ! 2236: if ((flags & LOOKUP_GLOBAL) && igv) ! 2237: { ! 2238: if (TREE_CODE (igv) == FUNCTION_DECL) ! 2239: ever_seen += 1; ! 2240: else if (TREE_CODE (igv) == TREE_LIST) ! 2241: ever_seen += count_functions (igv); ! 2242: } ! 2243: ! 2244: if (ever_seen == 0) ! 2245: { ! 2246: if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN)) ! 2247: == LOOKUP_SPECULATIVELY) ! 2248: return NULL_TREE; ! 2249: ! 2250: TREE_CHAIN (last) = void_list_node; ! 2251: if (flags & LOOKUP_GLOBAL) ! 2252: cp_error ("no global or member function `%D(%A)' defined", ! 2253: name, parmtypes); ! 2254: else ! 2255: cp_error ("no member function `%T::%D(%A)' defined", ! 2256: save_basetype, name, TREE_CHAIN (parmtypes)); ! 2257: return error_mark_node; ! 2258: } ! 2259: continue; ! 2260: } ! 2261: ! 2262: if (cp - candidates != 0) ! 2263: { ! 2264: /* Rank from worst to best. Then cp will point to best one. ! 2265: Private fields have their bits flipped. For unsigned ! 2266: numbers, this should make them look very large. ! 2267: If the best alternate has a (signed) negative value, ! 2268: then all we ever saw were private members. */ ! 2269: if (cp - candidates > 1) ! 2270: { ! 2271: int n_candidates = cp - candidates; ! 2272: extern int warn_synth; ! 2273: TREE_VALUE (parms) = instance_ptr; ! 2274: cp = ideal_candidate (save_basetype, candidates, ! 2275: n_candidates, parms, len); ! 2276: if (cp == (struct candidate *)0) ! 2277: { ! 2278: if (flags & LOOKUP_COMPLAIN) ! 2279: { ! 2280: TREE_CHAIN (last) = void_list_node; ! 2281: cp_error ("call of overloaded %s `%D(%A)' is ambiguous", ! 2282: name_kind, name, TREE_CHAIN (parmtypes)); ! 2283: print_n_candidates (candidates, n_candidates); ! 2284: } ! 2285: return error_mark_node; ! 2286: } ! 2287: if (cp->h.code & EVIL_CODE) ! 2288: return error_mark_node; ! 2289: if (warn_synth ! 2290: && DECL_NAME (cp->function) == ansi_opname[MODIFY_EXPR] ! 2291: && DECL_ARTIFICIAL (cp->function) ! 2292: && n_candidates == 2) ! 2293: { ! 2294: cp_warning ("using synthesized `%#D' for copy assignment", ! 2295: cp->function); ! 2296: cp_warning_at (" where cfront would use `%#D'", ! 2297: candidates->function); ! 2298: } ! 2299: } ! 2300: else if (cp[-1].h.code & EVIL_CODE) ! 2301: { ! 2302: if (flags & LOOKUP_COMPLAIN) ! 2303: cp_error ("ambiguous type conversion requested for %s `%D'", ! 2304: name_kind, name); ! 2305: return error_mark_node; ! 2306: } ! 2307: else ! 2308: cp--; ! 2309: ! 2310: /* The global function was the best, so use it. */ ! 2311: if (cp->u.field == 0) ! 2312: { ! 2313: /* We must convert the instance pointer into a reference type. ! 2314: Global overloaded functions can only either take ! 2315: aggregate objects (which come for free from references) ! 2316: or reference data types anyway. */ ! 2317: TREE_VALUE (parms) = copy_node (instance_ptr); ! 2318: TREE_TYPE (TREE_VALUE (parms)) = build_reference_type (TREE_TYPE (TREE_TYPE (instance_ptr))); ! 2319: return build_function_call (cp->function, parms); ! 2320: } ! 2321: ! 2322: function = cp->function; ! 2323: basetype_path = cp->basetypes; ! 2324: if (! DECL_STATIC_FUNCTION_P (function)) ! 2325: TREE_VALUE (parms) = cp->arg; ! 2326: goto found_and_maybe_warn; ! 2327: } ! 2328: ! 2329: if (flags & (LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY)) ! 2330: { ! 2331: if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN)) ! 2332: == LOOKUP_SPECULATIVELY) ! 2333: return NULL_TREE; ! 2334: ! 2335: if (DECL_STATIC_FUNCTION_P (cp->function)) ! 2336: parms = TREE_CHAIN (parms); ! 2337: if (ever_seen) ! 2338: { ! 2339: if (flags & LOOKUP_SPECULATIVELY) ! 2340: return NULL_TREE; ! 2341: if (static_call_context ! 2342: && TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE) ! 2343: cp_error ("object missing in call to `%D'", cp->function); ! 2344: else if (ever_seen > 1) ! 2345: { ! 2346: TREE_CHAIN (last) = void_list_node; ! 2347: cp_error ("no matching function for call to `%T::%D (%A)'", ! 2348: TREE_TYPE (TREE_TYPE (instance_ptr)), ! 2349: name, TREE_CHAIN (parmtypes)); ! 2350: TREE_CHAIN (last) = NULL_TREE; ! 2351: print_candidates (found_fns); ! 2352: } ! 2353: else ! 2354: report_type_mismatch (cp, parms, name_kind); ! 2355: return error_mark_node; ! 2356: } ! 2357: ! 2358: if ((flags & (LOOKUP_SPECULATIVELY|LOOKUP_COMPLAIN)) ! 2359: == LOOKUP_COMPLAIN) ! 2360: { ! 2361: cp_error ("%T has no method named %D", save_basetype, name); ! 2362: return error_mark_node; ! 2363: } ! 2364: return NULL_TREE; ! 2365: } ! 2366: continue; ! 2367: ! 2368: found_and_maybe_warn: ! 2369: if ((cp->harshness[0].code & CONST_CODE) ! 2370: /* 12.1p2: Constructors can be called for const objects. */ ! 2371: && ! DECL_CONSTRUCTOR_P (cp->function)) ! 2372: { ! 2373: if (flags & LOOKUP_COMPLAIN) ! 2374: { ! 2375: cp_error_at ("non-const member function `%D'", cp->function); ! 2376: error ("called for const object at this point in file"); ! 2377: } ! 2378: /* Not good enough for a match. */ ! 2379: else ! 2380: return error_mark_node; ! 2381: } ! 2382: goto found; ! 2383: } ! 2384: /* Silently return error_mark_node. */ ! 2385: return error_mark_node; ! 2386: ! 2387: found: ! 2388: if (flags & LOOKUP_PROTECT) ! 2389: access = compute_access (basetype_path, function); ! 2390: ! 2391: if (access == access_private) ! 2392: { ! 2393: if (flags & LOOKUP_COMPLAIN) ! 2394: { ! 2395: cp_error_at ("%s `%+#D' is %s", name_kind, function, ! 2396: TREE_PRIVATE (function) ? "private" ! 2397: : "from private base class"); ! 2398: error ("within this context"); ! 2399: } ! 2400: return error_mark_node; ! 2401: } ! 2402: else if (access == access_protected) ! 2403: { ! 2404: if (flags & LOOKUP_COMPLAIN) ! 2405: { ! 2406: cp_error_at ("%s `%+#D' %s", name_kind, function, ! 2407: TREE_PROTECTED (function) ? "is protected" ! 2408: : "has protected accessibility"); ! 2409: error ("within this context"); ! 2410: } ! 2411: return error_mark_node; ! 2412: } ! 2413: ! 2414: /* From here on down, BASETYPE is the type that INSTANCE_PTR's ! 2415: type (if it exists) is a pointer to. */ ! 2416: ! 2417: if (DECL_ABSTRACT_VIRTUAL_P (function) ! 2418: && instance == C_C_D ! 2419: && DECL_CONSTRUCTOR_P (current_function_decl) ! 2420: && ! (flags & LOOKUP_NONVIRTUAL) ! 2421: && value_member (function, get_abstract_virtuals (basetype))) ! 2422: cp_error ("abstract virtual `%#D' called from constructor", function); ! 2423: ! 2424: if (IS_SIGNATURE (basetype) && static_call_context) ! 2425: { ! 2426: cp_error ("cannot call signature member function `%T::%D' without signature pointer/reference", ! 2427: basetype, name); ! 2428: return error_mark_node; ! 2429: } ! 2430: else if (IS_SIGNATURE (basetype)) ! 2431: return build_signature_method_call (basetype, instance, function, parms); ! 2432: ! 2433: function = DECL_MAIN_VARIANT (function); ! 2434: /* Declare external function if necessary. */ ! 2435: assemble_external (function); ! 2436: ! 2437: fntype = TREE_TYPE (function); ! 2438: if (TREE_CODE (fntype) == POINTER_TYPE) ! 2439: fntype = TREE_TYPE (fntype); ! 2440: basetype = DECL_CLASS_CONTEXT (function); ! 2441: ! 2442: /* If we are referencing a virtual function from an object ! 2443: of effectively static type, then there is no need ! 2444: to go through the virtual function table. */ ! 2445: if (need_vtbl == maybe_needed) ! 2446: { ! 2447: int fixed_type = resolves_to_fixed_type_p (instance, 0); ! 2448: ! 2449: if (all_virtual == 1 ! 2450: && DECL_VINDEX (function) ! 2451: && may_be_remote (basetype)) ! 2452: need_vtbl = needed; ! 2453: else if (DECL_VINDEX (function)) ! 2454: need_vtbl = fixed_type ? unneeded : needed; ! 2455: else ! 2456: need_vtbl = not_needed; ! 2457: } ! 2458: ! 2459: if (TREE_CODE (fntype) == METHOD_TYPE && static_call_context ! 2460: && !DECL_CONSTRUCTOR_P (function)) ! 2461: { ! 2462: /* Let's be nice to the user for now, and give reasonable ! 2463: default behavior. */ ! 2464: instance_ptr = current_class_decl; ! 2465: if (instance_ptr) ! 2466: { ! 2467: if (basetype != current_class_type) ! 2468: { ! 2469: tree binfo = get_binfo (basetype, current_class_type, 1); ! 2470: if (binfo == NULL_TREE) ! 2471: { ! 2472: error_not_base_type (function, current_class_type); ! 2473: return error_mark_node; ! 2474: } ! 2475: else if (basetype == error_mark_node) ! 2476: return error_mark_node; ! 2477: } ! 2478: } ! 2479: /* Only allow a static member function to call another static member ! 2480: function. */ ! 2481: else if (DECL_LANG_SPECIFIC (function) ! 2482: && !DECL_STATIC_FUNCTION_P (function)) ! 2483: { ! 2484: cp_error ("cannot call member function `%D' without object", ! 2485: function); ! 2486: return error_mark_node; ! 2487: } ! 2488: } ! 2489: ! 2490: value_type = TREE_TYPE (fntype) ? TREE_TYPE (fntype) : void_type_node; ! 2491: ! 2492: if (TYPE_SIZE (value_type) == 0) ! 2493: { ! 2494: if (flags & LOOKUP_COMPLAIN) ! 2495: incomplete_type_error (0, value_type); ! 2496: return error_mark_node; ! 2497: } ! 2498: ! 2499: if (DECL_STATIC_FUNCTION_P (function)) ! 2500: parms = convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype), ! 2501: TREE_CHAIN (parms), function, LOOKUP_NORMAL); ! 2502: else if (need_vtbl == unneeded) ! 2503: { ! 2504: int sub_flags = DECL_CONSTRUCTOR_P (function) ? flags : LOOKUP_NORMAL; ! 2505: basetype = TREE_TYPE (instance); ! 2506: if (TYPE_METHOD_BASETYPE (TREE_TYPE (function)) != TYPE_MAIN_VARIANT (basetype) ! 2507: && TYPE_USES_COMPLEX_INHERITANCE (basetype)) ! 2508: { ! 2509: basetype = DECL_CLASS_CONTEXT (function); ! 2510: instance_ptr = convert_pointer_to (basetype, instance_ptr); ! 2511: instance = build_indirect_ref (instance_ptr, NULL_PTR); ! 2512: } ! 2513: parms = tree_cons (NULL_TREE, instance_ptr, ! 2514: convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), function, sub_flags)); ! 2515: } ! 2516: else ! 2517: { ! 2518: if ((flags & LOOKUP_NONVIRTUAL) == 0) ! 2519: basetype = DECL_CONTEXT (function); ! 2520: ! 2521: /* First parm could be integer_zerop with casts like ! 2522: ((Object*)0)->Object::IsA() */ ! 2523: if (!integer_zerop (TREE_VALUE (parms))) ! 2524: { ! 2525: /* Since we can't have inheritance with a union, doing get_binfo ! 2526: on it won't work. We do all the convert_pointer_to_real ! 2527: stuff to handle MI correctly...for unions, that's not ! 2528: an issue, so we must short-circuit that extra work here. */ ! 2529: tree tmp = TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))); ! 2530: if (tmp != NULL_TREE && TREE_CODE (tmp) == UNION_TYPE) ! 2531: instance_ptr = TREE_VALUE (parms); ! 2532: else ! 2533: { ! 2534: tree binfo = get_binfo (basetype, ! 2535: TREE_TYPE (TREE_TYPE (TREE_VALUE (parms))), ! 2536: 0); ! 2537: instance_ptr = convert_pointer_to_real (binfo, TREE_VALUE (parms)); ! 2538: } ! 2539: instance_ptr ! 2540: = convert_pointer_to (build_type_variant (basetype, ! 2541: constp, volatilep), ! 2542: instance_ptr); ! 2543: ! 2544: if (TREE_CODE (instance_ptr) == COND_EXPR) ! 2545: { ! 2546: instance_ptr = save_expr (instance_ptr); ! 2547: instance = build_indirect_ref (instance_ptr, NULL_PTR); ! 2548: } ! 2549: else if (TREE_CODE (instance_ptr) == NOP_EXPR ! 2550: && TREE_CODE (TREE_OPERAND (instance_ptr, 0)) == ADDR_EXPR ! 2551: && TREE_OPERAND (TREE_OPERAND (instance_ptr, 0), 0) == instance) ! 2552: ; ! 2553: /* The call to `convert_pointer_to' may return error_mark_node. */ ! 2554: else if (TREE_CODE (instance_ptr) == ERROR_MARK) ! 2555: return instance_ptr; ! 2556: else if (instance == NULL_TREE ! 2557: || TREE_CODE (instance) != INDIRECT_REF ! 2558: || TREE_OPERAND (instance, 0) != instance_ptr) ! 2559: instance = build_indirect_ref (instance_ptr, NULL_PTR); ! 2560: } ! 2561: parms = tree_cons (NULL_TREE, instance_ptr, ! 2562: convert_arguments (NULL_TREE, TREE_CHAIN (TYPE_ARG_TYPES (fntype)), TREE_CHAIN (parms), function, LOOKUP_NORMAL)); ! 2563: } ! 2564: ! 2565: #if 0 ! 2566: /* Constructors do not overload method calls. */ ! 2567: else if (TYPE_OVERLOADS_METHOD_CALL_EXPR (basetype) ! 2568: && name != TYPE_IDENTIFIER (basetype) ! 2569: && (TREE_CODE (function) != FUNCTION_DECL ! 2570: || strncmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)), ! 2571: OPERATOR_METHOD_FORMAT, ! 2572: OPERATOR_METHOD_LENGTH)) ! 2573: && (may_be_remote (basetype) || instance != C_C_D)) ! 2574: { ! 2575: tree fn_as_int; ! 2576: ! 2577: parms = TREE_CHAIN (parms); ! 2578: ! 2579: if (!all_virtual && TREE_CODE (function) == FUNCTION_DECL) ! 2580: fn_as_int = build_unary_op (ADDR_EXPR, function, 0); ! 2581: else ! 2582: fn_as_int = convert (TREE_TYPE (default_conversion (function)), DECL_VINDEX (function)); ! 2583: if (all_virtual == 1) ! 2584: fn_as_int = convert (integer_type_node, fn_as_int); ! 2585: ! 2586: result = build_opfncall (METHOD_CALL_EXPR, LOOKUP_NORMAL, instance, fn_as_int, parms); ! 2587: ! 2588: if (result == NULL_TREE) ! 2589: { ! 2590: compiler_error ("could not overload `operator->()(...)'"); ! 2591: return error_mark_node; ! 2592: } ! 2593: else if (result == error_mark_node) ! 2594: return error_mark_node; ! 2595: ! 2596: #if 0 ! 2597: /* Do this if we want the result of operator->() to inherit ! 2598: the type of the function it is subbing for. */ ! 2599: TREE_TYPE (result) = value_type; ! 2600: #endif ! 2601: ! 2602: return result; ! 2603: } ! 2604: #endif ! 2605: ! 2606: if (need_vtbl == needed) ! 2607: { ! 2608: function = build_vfn_ref (&TREE_VALUE (parms), instance, ! 2609: DECL_VINDEX (function)); ! 2610: TREE_TYPE (function) = build_pointer_type (fntype); ! 2611: } ! 2612: ! 2613: if (TREE_CODE (function) == FUNCTION_DECL) ! 2614: GNU_xref_call (current_function_decl, ! 2615: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function))); ! 2616: ! 2617: { ! 2618: int is_constructor; ! 2619: ! 2620: if (TREE_CODE (function) == FUNCTION_DECL) ! 2621: { ! 2622: is_constructor = DECL_CONSTRUCTOR_P (function); ! 2623: if (DECL_INLINE (function)) ! 2624: function = build1 (ADDR_EXPR, build_pointer_type (fntype), function); ! 2625: else ! 2626: { ! 2627: assemble_external (function); ! 2628: TREE_USED (function) = 1; ! 2629: function = default_conversion (function); ! 2630: } ! 2631: } ! 2632: else ! 2633: { ! 2634: is_constructor = 0; ! 2635: function = default_conversion (function); ! 2636: } ! 2637: ! 2638: result = build_nt (CALL_EXPR, function, parms, NULL_TREE); ! 2639: ! 2640: TREE_TYPE (result) = value_type; ! 2641: TREE_SIDE_EFFECTS (result) = 1; ! 2642: TREE_RAISES (result) ! 2643: = TYPE_RAISES_EXCEPTIONS (fntype) || (parms && TREE_RAISES (parms)); ! 2644: TREE_HAS_CONSTRUCTOR (result) = is_constructor; ! 2645: return result; ! 2646: } ! 2647: } ! 2648: ! 2649: /* Similar to `build_method_call', but for overloaded non-member functions. ! 2650: The name of this function comes through NAME. The name depends ! 2651: on PARMS. ! 2652: ! 2653: Note that this function must handle simple `C' promotions, ! 2654: as well as variable numbers of arguments (...), and ! 2655: default arguments to boot. ! 2656: ! 2657: If the overloading is successful, we return a tree node which ! 2658: contains the call to the function. ! 2659: ! 2660: If overloading produces candidates which are probable, but not definite, ! 2661: we hold these candidates. If FINAL_CP is non-zero, then we are free ! 2662: to assume that final_cp points to enough storage for all candidates that ! 2663: this function might generate. The `harshness' array is preallocated for ! 2664: the first candidate, but not for subsequent ones. ! 2665: ! 2666: Note that the DECL_RTL of FUNCTION must be made to agree with this ! 2667: function's new name. */ ! 2668: ! 2669: tree ! 2670: build_overload_call_real (fnname, parms, flags, final_cp, buildxxx) ! 2671: tree fnname, parms; ! 2672: int flags; ! 2673: struct candidate *final_cp; ! 2674: int buildxxx; ! 2675: { ! 2676: /* must check for overloading here */ ! 2677: tree overload_name, functions, function, parm; ! 2678: tree parmtypes = NULL_TREE, last = NULL_TREE; ! 2679: register tree outer; ! 2680: int length; ! 2681: int parmlength = list_length (parms); ! 2682: ! 2683: struct candidate *candidates, *cp; ! 2684: ! 2685: if (final_cp) ! 2686: { ! 2687: final_cp[0].h.code = 0; ! 2688: final_cp[0].h.distance = 0; ! 2689: final_cp[0].function = 0; ! 2690: /* end marker. */ ! 2691: final_cp[1].h.code = EVIL_CODE; ! 2692: } ! 2693: ! 2694: for (parm = parms; parm; parm = TREE_CHAIN (parm)) ! 2695: { ! 2696: register tree t = TREE_TYPE (TREE_VALUE (parm)); ! 2697: ! 2698: if (t == error_mark_node) ! 2699: { ! 2700: if (final_cp) ! 2701: final_cp->h.code = EVIL_CODE; ! 2702: return error_mark_node; ! 2703: } ! 2704: if (TREE_CODE (t) == OFFSET_TYPE) ! 2705: #if 0 ! 2706: /* This breaks reference-to-array parameters. */ ! 2707: || TREE_CODE (t) == ARRAY_TYPE ! 2708: #endif ! 2709: { ! 2710: /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place. ! 2711: Also convert OFFSET_TYPE entities to their normal selves. ! 2712: This eliminates needless calls to `compute_conversion_costs'. */ ! 2713: TREE_VALUE (parm) = default_conversion (TREE_VALUE (parm)); ! 2714: t = TREE_TYPE (TREE_VALUE (parm)); ! 2715: } ! 2716: last = build_tree_list (NULL_TREE, t); ! 2717: parmtypes = chainon (parmtypes, last); ! 2718: } ! 2719: if (last) ! 2720: TREE_CHAIN (last) = void_list_node; ! 2721: else ! 2722: parmtypes = void_list_node; ! 2723: ! 2724: if (is_overloaded_fn (fnname)) ! 2725: { ! 2726: functions = fnname; ! 2727: if (TREE_CODE (fnname) == TREE_LIST) ! 2728: fnname = TREE_PURPOSE (functions); ! 2729: else if (TREE_CODE (fnname) == FUNCTION_DECL) ! 2730: fnname = DECL_NAME (functions); ! 2731: } ! 2732: else ! 2733: functions = lookup_name_nonclass (fnname); ! 2734: ! 2735: if (functions == NULL_TREE) ! 2736: { ! 2737: if (flags & LOOKUP_SPECULATIVELY) ! 2738: return NULL_TREE; ! 2739: if (flags & LOOKUP_COMPLAIN) ! 2740: error ("only member functions apply"); ! 2741: if (final_cp) ! 2742: final_cp->h.code = EVIL_CODE; ! 2743: return error_mark_node; ! 2744: } ! 2745: ! 2746: if (TREE_CODE (functions) == FUNCTION_DECL && ! IDENTIFIER_OPNAME_P (fnname)) ! 2747: { ! 2748: functions = DECL_MAIN_VARIANT (functions); ! 2749: if (final_cp) ! 2750: { ! 2751: /* We are just curious whether this is a viable alternative or ! 2752: not. */ ! 2753: compute_conversion_costs (functions, parms, final_cp, parmlength); ! 2754: return functions; ! 2755: } ! 2756: else ! 2757: return build_function_call_real (functions, parms, 1, flags); ! 2758: } ! 2759: ! 2760: if (TREE_CODE (functions) == TREE_LIST ! 2761: && TREE_VALUE (functions) == NULL_TREE) ! 2762: { ! 2763: if (flags & LOOKUP_SPECULATIVELY) ! 2764: return NULL_TREE; ! 2765: ! 2766: if (flags & LOOKUP_COMPLAIN) ! 2767: cp_error ("function `%D' declared overloaded, but no instances of that function declared", ! 2768: TREE_PURPOSE (functions)); ! 2769: if (final_cp) ! 2770: final_cp->h.code = EVIL_CODE; ! 2771: return error_mark_node; ! 2772: } ! 2773: ! 2774: length = count_functions (functions); ! 2775: ! 2776: if (final_cp) ! 2777: candidates = final_cp; ! 2778: else ! 2779: { ! 2780: candidates ! 2781: = (struct candidate *)alloca ((length+1) * sizeof (struct candidate)); ! 2782: bzero ((char *) candidates, (length + 1) * sizeof (struct candidate)); ! 2783: } ! 2784: ! 2785: cp = candidates; ! 2786: ! 2787: my_friendly_assert (is_overloaded_fn (functions), 169); ! 2788: ! 2789: functions = get_first_fn (functions); ! 2790: ! 2791: /* OUTER is the list of FUNCTION_DECLS, in a TREE_LIST. */ ! 2792: for (outer = functions; outer; outer = DECL_CHAIN (outer)) ! 2793: { ! 2794: int template_cost = 0; ! 2795: function = outer; ! 2796: if (TREE_CODE (function) != FUNCTION_DECL ! 2797: && ! (TREE_CODE (function) == TEMPLATE_DECL ! 2798: && ! DECL_TEMPLATE_IS_CLASS (function) ! 2799: && TREE_CODE (DECL_TEMPLATE_RESULT (function)) == FUNCTION_DECL)) ! 2800: { ! 2801: enum tree_code code = TREE_CODE (function); ! 2802: if (code == TEMPLATE_DECL) ! 2803: code = TREE_CODE (DECL_TEMPLATE_RESULT (function)); ! 2804: if (code == CONST_DECL) ! 2805: cp_error_at ! 2806: ("enumeral value `%D' conflicts with function of same name", ! 2807: function); ! 2808: else if (code == VAR_DECL) ! 2809: { ! 2810: if (TREE_STATIC (function)) ! 2811: cp_error_at ! 2812: ("variable `%D' conflicts with function of same name", ! 2813: function); ! 2814: else ! 2815: cp_error_at ! 2816: ("constant field `%D' conflicts with function of same name", ! 2817: function); ! 2818: } ! 2819: else if (code == TYPE_DECL) ! 2820: continue; ! 2821: else ! 2822: my_friendly_abort (2); ! 2823: error ("at this point in file"); ! 2824: continue; ! 2825: } ! 2826: if (TREE_CODE (function) == TEMPLATE_DECL) ! 2827: { ! 2828: int ntparms = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (function)); ! 2829: tree *targs = (tree *) alloca (sizeof (tree) * ntparms); ! 2830: int i; ! 2831: ! 2832: i = type_unification (DECL_TEMPLATE_PARMS (function), targs, ! 2833: TYPE_ARG_TYPES (TREE_TYPE (function)), ! 2834: parms, &template_cost, 0); ! 2835: if (i == 0) ! 2836: function = instantiate_template (function, targs); ! 2837: } ! 2838: ! 2839: if (TREE_CODE (function) == TEMPLATE_DECL) ! 2840: { ! 2841: /* Unconverted template -- failed match. */ ! 2842: cp->function = function; ! 2843: cp->u.bad_arg = -4; ! 2844: cp->h.code = EVIL_CODE; ! 2845: } ! 2846: else ! 2847: { ! 2848: struct candidate *cp2; ! 2849: ! 2850: /* Check that this decl is not the same as a function that's in ! 2851: the list due to some template instantiation. */ ! 2852: cp2 = candidates; ! 2853: while (cp2 != cp) ! 2854: if (cp2->function == function) ! 2855: break; ! 2856: else ! 2857: cp2 += 1; ! 2858: if (cp2->function == function) ! 2859: continue; ! 2860: ! 2861: function = DECL_MAIN_VARIANT (function); ! 2862: ! 2863: /* Can't use alloca here, since result might be ! 2864: passed to calling function. */ ! 2865: cp->h_len = parmlength; ! 2866: cp->harshness = (struct harshness_code *) ! 2867: oballoc ((parmlength + 1) * sizeof (struct harshness_code)); ! 2868: ! 2869: compute_conversion_costs (function, parms, cp, parmlength); ! 2870: ! 2871: /* Make sure this is clear as well. */ ! 2872: cp->h.int_penalty += template_cost; ! 2873: ! 2874: if ((cp[0].h.code & EVIL_CODE) == 0) ! 2875: { ! 2876: cp[1].h.code = EVIL_CODE; ! 2877: cp++; ! 2878: } ! 2879: } ! 2880: } ! 2881: ! 2882: if (cp - candidates) ! 2883: { ! 2884: tree rval = error_mark_node; ! 2885: ! 2886: /* Leave marker. */ ! 2887: cp[0].h.code = EVIL_CODE; ! 2888: if (cp - candidates > 1) ! 2889: { ! 2890: struct candidate *best_cp ! 2891: = ideal_candidate (NULL_TREE, candidates, ! 2892: cp - candidates, parms, parmlength); ! 2893: if (best_cp == (struct candidate *)0) ! 2894: { ! 2895: if (flags & LOOKUP_COMPLAIN) ! 2896: { ! 2897: cp_error ("call of overloaded `%D' is ambiguous", fnname); ! 2898: print_n_candidates (candidates, cp - candidates); ! 2899: } ! 2900: return error_mark_node; ! 2901: } ! 2902: else ! 2903: rval = best_cp->function; ! 2904: } ! 2905: else ! 2906: { ! 2907: cp -= 1; ! 2908: if (cp->h.code & EVIL_CODE) ! 2909: { ! 2910: if (flags & LOOKUP_COMPLAIN) ! 2911: error ("type conversion ambiguous"); ! 2912: } ! 2913: else ! 2914: rval = cp->function; ! 2915: } ! 2916: ! 2917: if (final_cp) ! 2918: return rval; ! 2919: ! 2920: return buildxxx ? build_function_call_real (rval, parms, 0, flags) ! 2921: : build_function_call_real (rval, parms, 1, flags); ! 2922: } ! 2923: ! 2924: if (flags & LOOKUP_SPECULATIVELY) ! 2925: return NULL_TREE; ! 2926: ! 2927: if (flags & LOOKUP_COMPLAIN) ! 2928: report_type_mismatch (cp, parms, "function", ! 2929: decl_as_string (cp->function, 1)); ! 2930: ! 2931: return error_mark_node; ! 2932: } ! 2933: ! 2934: tree ! 2935: build_overload_call (fnname, parms, flags, final_cp) ! 2936: tree fnname, parms; ! 2937: int flags; ! 2938: struct candidate *final_cp; ! 2939: { ! 2940: return build_overload_call_real (fnname, parms, flags, final_cp, 0); ! 2941: } ! 2942: ! 2943: tree ! 2944: build_overload_call_maybe (fnname, parms, flags, final_cp) ! 2945: tree fnname, parms; ! 2946: int flags; ! 2947: struct candidate *final_cp; ! 2948: { ! 2949: return build_overload_call_real (fnname, parms, flags, final_cp, 1); ! 2950: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.