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