src/vm/resolve.c

   1 /* src/vm/resolve.c - resolving classes/interfaces/fields/methods
   2
   3    Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    Contact: cacao@cacaojvm.org
  26
  27    Authors: Edwin Steiner
  28
  29    Changes: Christan Thalinger
  30
  31    $Id: resolve.c 5726 2006-10-09 23:06:39Z edwin $
  32
  33 */
  34
  35
  36 #include "config.h"
  37
  38 #include <assert.h>
  39
  40 #include "mm/memory.h"
  41 #include "vm/resolve.h"
  42 #include "vm/access.h"
  43 #include "vm/classcache.h"
  44 #include "vm/descriptor.h"
  45 #include "vm/exceptions.h"
  46 #include "vm/global.h"
  47 #include "vm/linker.h"
  48 #include "vm/loader.h"
  49 #include "vm/options.h"
  50 #include "vm/stringlocal.h"
  51 #include "vm/jit/jit.h"
  52 #include "vm/jit/verify/typeinfo.h"
  53
  54
  55 /******************************************************************************/
  56 /* DEBUG HELPERS                                                              */
  57 /******************************************************************************/
  58
  59 /*#define RESOLVE_VERBOSE*/
  60
  61 /******************************************************************************/
  62 /* CLASS RESOLUTION                                                           */
  63 /******************************************************************************/
  64
  65 /* resolve_class_from_name *****************************************************
  66
  67    Resolve a symbolic class reference
  68
  69    IN:
  70        referer..........the class containing the reference
  71        refmethod........the method from which resolution was triggered
  72                         (may be NULL if not applicable)
  73        classname........class name to resolve
  74        mode.............mode of resolution:
  75                             resolveLazy...only resolve if it does not
  76                                           require loading classes
  77                             resolveEager..load classes if necessary
  78            checkaccess......if true, access rights to the class are checked
  79            link.............if true, guarantee that the returned class, if any,
  80                             has been linked
  81
  82    OUT:
  83        *result..........set to result of resolution, or to NULL if
  84                         the reference has not been resolved
  85                         In the case of an exception, *result is
  86                         guaranteed to be set to NULL.
  87
  88    RETURN VALUE:
  89        true.............everything ok
  90                         (*result may still be NULL for resolveLazy)
  91        false............an exception has been thrown
  92
  93    NOTE:
  94        The returned class is *not* guaranteed to be linked!
  95            (It is guaranteed to be loaded, though.)
  96
  97 *******************************************************************************/
  98
  99 bool resolve_class_from_name(classinfo *referer,
 100                                                          methodinfo *refmethod,
 101                                                          utf *classname,
 102                                                          resolve_mode_t mode,
 103                                                          bool checkaccess,
 104                                                          bool link,
 105                                                          classinfo **result)
 106 {
 107         classinfo *cls = NULL;
 108         char *utf_ptr;
 109         int len;
 110
 111         assert(result);
 112         assert(referer);
 113         assert(classname);
 114         assert(mode == resolveLazy || mode == resolveEager);
 115
 116         *result = NULL;
 117
 118 #ifdef RESOLVE_VERBOSE
 119         printf("resolve_class_from_name(");
 120         utf_fprint_printable_ascii(stdout,referer->name);
 121         printf(",%p,",(void*)referer->classloader);
 122         utf_fprint_printable_ascii(stdout,classname);
 123         printf(",%d,%d)\n",(int)checkaccess,(int)link);
 124 #endif
 125
 126         /* lookup if this class has already been loaded */
 127
 128         cls = classcache_lookup(referer->classloader, classname);
 129
 130 #ifdef RESOLVE_VERBOSE
 131         printf("    lookup result: %p\n",(void*)cls);
 132 #endif
 133
 134         if (!cls) {
 135                 /* resolve array types */
 136
 137                 if (classname->text[0] == '[') {
 138                         utf_ptr = classname->text + 1;
 139                         len = classname->blength - 1;
 140
 141                         /* classname is an array type name */
 142
 143                         switch (*utf_ptr) {
 144                                 case 'L':
 145                                         utf_ptr++;
 146                                         len -= 2;
 147                                         /* FALLTHROUGH */
 148                                 case '[':
 149                                         /* the component type is a reference type */
 150                                         /* resolve the component type */
 151                                         if (!resolve_class_from_name(referer,refmethod,
 152                                                                            utf_new(utf_ptr,len),
 153                                                                            mode,checkaccess,link,&cls))
 154                                                 return false; /* exception */
 155                                         if (!cls) {
 156                                                 assert(mode == resolveLazy);
 157                                                 return true; /* be lazy */
 158                                         }
 159                                         /* create the array class */
 160                                         cls = class_array_of(cls,false);
 161                                         if (!cls)
 162                                                 return false; /* exception */
 163                         }
 164                 }
 165                 else {
 166                         /* the class has not been loaded, yet */
 167                         if (mode == resolveLazy)
 168                                 return true; /* be lazy */
 169                 }
 170
 171 #ifdef RESOLVE_VERBOSE
 172                 printf("    loading...\n");
 173 #endif
 174
 175                 /* load the class */
 176                 if (!cls) {
 177                         if (!(cls = load_class_from_classloader(classname,
 178                                                                                                         referer->classloader)))
 179                                 return false; /* exception */
 180                 }
 181         }
 182
 183         /* the class is now loaded */
 184         assert(cls);
 185         assert(cls->state & CLASS_LOADED);
 186
 187 #ifdef RESOLVE_VERBOSE
 188         printf("    checking access rights...\n");
 189 #endif
 190
 191         /* check access rights of referer to refered class */
 192         if (checkaccess && !access_is_accessible_class(referer,cls)) {
 193                 int msglen;
 194                 char *message;
 195
 196                 msglen = utf_bytes(cls->name) + utf_bytes(referer->name) + 100;
 197                 message = MNEW(char, msglen);
 198                 strcpy(message, "class is not accessible (");
 199                 utf_cat_classname(message, cls->name);
 200                 strcat(message, " from ");
 201                 utf_cat_classname(message, referer->name);
 202                 strcat(message, ")");
 203                 *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException, message);
 204                 MFREE(message,char,msglen);
 205                 return false; /* exception */
 206         }
 207
 208         /* link the class if necessary */
 209         if (link) {
 210                 if (!(cls->state & CLASS_LINKED))
 211                         if (!link_class(cls))
 212                                 return false; /* exception */
 213
 214                 assert(cls->state & CLASS_LINKED);
 215         }
 216
 217         /* resolution succeeds */
 218 #ifdef RESOLVE_VERBOSE
 219         printf("    success.\n");
 220 #endif
 221         *result = cls;
 222         return true;
 223 }
 224
 225 /* resolve_classref ************************************************************
 226
 227    Resolve a symbolic class reference
 228
 229    IN:
 230        refmethod........the method from which resolution was triggered
 231                         (may be NULL if not applicable)
 232        ref..............class reference
 233        mode.............mode of resolution:
 234                             resolveLazy...only resolve if it does not
 235                                           require loading classes
 236                             resolveEager..load classes if necessary
 237            checkaccess......if true, access rights to the class are checked
 238            link.............if true, guarantee that the returned class, if any,
 239                             has been linked
 240
 241    OUT:
 242        *result..........set to result of resolution, or to NULL if
 243                         the reference has not been resolved
 244                         In the case of an exception, *result is
 245                         guaranteed to be set to NULL.
 246
 247    RETURN VALUE:
 248        true.............everything ok
 249                         (*result may still be NULL for resolveLazy)
 250        false............an exception has been thrown
 251
 252 *******************************************************************************/
 253
 254 bool resolve_classref(methodinfo *refmethod,
 255                                           constant_classref *ref,
 256                                           resolve_mode_t mode,
 257                                           bool checkaccess,
 258                                           bool link,
 259                                           classinfo **result)
 260 {
 261         return resolve_classref_or_classinfo(refmethod,CLASSREF_OR_CLASSINFO(ref),mode,checkaccess,link,result);
 262 }
 263
 264 /* resolve_classref_or_classinfo ***********************************************
 265
 266    Resolve a symbolic class reference if necessary
 267
 268    IN:
 269        refmethod........the method from which resolution was triggered
 270                         (may be NULL if not applicable)
 271        cls..............class reference or classinfo
 272        mode.............mode of resolution:
 273                             resolveLazy...only resolve if it does not
 274                                           require loading classes
 275                             resolveEager..load classes if necessary
 276            checkaccess......if true, access rights to the class are checked
 277            link.............if true, guarantee that the returned class, if any,
 278                             has been linked
 279
 280    OUT:
 281        *result..........set to result of resolution, or to NULL if
 282                         the reference has not been resolved
 283                         In the case of an exception, *result is
 284                         guaranteed to be set to NULL.
 285
 286    RETURN VALUE:
 287        true.............everything ok
 288                         (*result may still be NULL for resolveLazy)
 289        false............an exception has been thrown
 290
 291 *******************************************************************************/
 292
 293 bool resolve_classref_or_classinfo(methodinfo *refmethod,
 294                                                                    classref_or_classinfo cls,
 295                                                                    resolve_mode_t mode,
 296                                                                    bool checkaccess,
 297                                                                    bool link,
 298                                                                    classinfo **result)
 299 {
 300         classinfo         *c;
 301
 302         assert(cls.any);
 303         assert(mode == resolveEager || mode == resolveLazy);
 304         assert(result);
 305
 306 #ifdef RESOLVE_VERBOSE
 307         printf("resolve_classref_or_classinfo(");
 308         utf_fprint_printable_ascii(stdout,(IS_CLASSREF(cls)) ? cls.ref->name : cls.cls->name);
 309         printf(",%i,%i,%i)\n",mode,(int)checkaccess,(int)link);
 310 #endif
 311
 312         *result = NULL;
 313
 314         if (IS_CLASSREF(cls)) {
 315                 /* we must resolve this reference */
 316
 317                 if (!resolve_class_from_name(cls.ref->referer, refmethod, cls.ref->name,
 318                                                                          mode, checkaccess, link, &c))
 319                         goto return_exception;
 320
 321         } else {
 322                 /* cls has already been resolved */
 323                 c = cls.cls;
 324                 assert(c->state & CLASS_LOADED);
 325         }
 326         assert(c || (mode == resolveLazy));
 327
 328         if (!c)
 329                 return true; /* be lazy */
 330
 331         assert(c);
 332         assert(c->state & CLASS_LOADED);
 333
 334         if (link) {
 335                 if (!(c->state & CLASS_LINKED))
 336                         if (!link_class(c))
 337                                 goto return_exception;
 338
 339                 assert(c->state & CLASS_LINKED);
 340         }
 341
 342         /* succeeded */
 343         *result = c;
 344         return true;
 345
 346  return_exception:
 347         *result = NULL;
 348         return false;
 349 }
 350
 351
 352 /* resolve_class_from_typedesc *************************************************
 353
 354    Return a classinfo * for the given type descriptor
 355
 356    IN:
 357        d................type descriptor
 358            checkaccess......if true, access rights to the class are checked
 359            link.............if true, guarantee that the returned class, if any,
 360                             has been linked
 361    OUT:
 362        *result..........set to result of resolution, or to NULL if
 363                         the reference has not been resolved
 364                         In the case of an exception, *result is
 365                         guaranteed to be set to NULL.
 366
 367    RETURN VALUE:
 368        true.............everything ok
 369        false............an exception has been thrown
 370
 371    NOTE:
 372        This function always resolves eagerly.
 373
 374 *******************************************************************************/
 375
 376 bool resolve_class_from_typedesc(typedesc *d, bool checkaccess, bool link, classinfo **result)
 377 {
 378         classinfo *cls;
 379
 380         assert(d);
 381         assert(result);
 382
 383         *result = NULL;
 384
 385 #ifdef RESOLVE_VERBOSE
 386         printf("resolve_class_from_typedesc(");
 387         descriptor_debug_print_typedesc(stdout,d);
 388         printf(",%i,%i)\n",(int)checkaccess,(int)link);
 389 #endif
 390
 391         if (d->type == TYPE_ADR) {
 392                 /* a reference type */
 393                 assert(d->classref);
 394                 if (!resolve_classref_or_classinfo(NULL,CLASSREF_OR_CLASSINFO(d->classref),
 395                                                                                    resolveEager,checkaccess,link,&cls))
 396                         return false; /* exception */
 397         }
 398         else {
 399                 /* a primitive type */
 400                 cls = primitivetype_table[d->decltype].class_primitive;
 401                 assert(cls->state & CLASS_LOADED);
 402                 if (!(cls->state & CLASS_LINKED))
 403                         if (!link_class(cls))
 404                                 return false; /* exception */
 405         }
 406         assert(cls);
 407         assert(cls->state & CLASS_LOADED);
 408         assert(!link || (cls->state & CLASS_LINKED));
 409
 410 #ifdef RESOLVE_VERBOSE
 411         printf("    result = ");utf_fprint_printable_ascii(stdout,cls->name);printf("\n");
 412 #endif
 413
 414         *result = cls;
 415         return true;
 416 }
 417
 418 /******************************************************************************/
 419 /* SUBTYPE SET CHECKS                                                         */
 420 /******************************************************************************/
 421
 422 /* resolve_subtype_check *******************************************************
 423
 424    Resolve the given types lazily and perform a subtype check
 425
 426    IN:
 427        refmethod........the method triggering the resolution
 428        subtype..........checked to be a subtype of supertype
 429            supertype........the super type to check agaings
 430            mode.............mode of resolution:
 431                             resolveLazy...only resolve if it does not
 432                                           require loading classes
 433                             resolveEager..load classes if necessary
 434        error............which type of exception to throw if
 435                         the test fails. May be:
 436                             resolveLinkageError, or
 437                             resolveIllegalAccessError
 438                                                 IMPORTANT: If error==resolveIllegalAccessError,
 439                                                 then array types are not checked.
 440
 441    RETURN VALUE:
 442        resolveSucceeded.....the check succeeded
 443        resolveDeferred......the check could not be performed due to
 444                                 unresolved types. (This can only happen for
 445                                                         mode == resolveLazy.)
 446            resolveFailed........the check failed, an exception has been thrown.
 447
 448    NOTE:
 449            The types are resolved first, so any
 450            exception which may occurr during resolution may
 451            be thrown by this function.
 452
 453 *******************************************************************************/
 454
 455 #if defined(ENABLE_VERIFIER)
 456 static resolve_result_t resolve_subtype_check(methodinfo *refmethod,
 457                                                                                       classref_or_classinfo subtype,
 458                                                                                           classref_or_classinfo supertype,
 459                                                                                           resolve_mode_t mode,
 460                                                                                           resolve_err_t error)
 461 {
 462         classinfo *subclass;
 463         typeinfo subti;
 464         typecheck_result r;
 465
 466         assert(refmethod);
 467         assert(subtype.any);
 468         assert(supertype.any);
 469         assert(mode == resolveLazy || mode == resolveEager);
 470         assert(error == resolveLinkageError || error == resolveIllegalAccessError);
 471
 472         /* resolve the subtype */
 473
 474         if (!resolve_classref_or_classinfo(refmethod,subtype,mode,false,true,&subclass)) {
 475                 /* the subclass could not be resolved. therefore we are sure that  */
 476                 /* no instances of this subclass will ever exist -> skip this test */
 477                 /* XXX this assumes that class loading has invariant results (as in JVM spec) */
 478                 *exceptionptr = NULL;
 479                 return resolveSucceeded;
 480         }
 481         if (!subclass)
 482                 return resolveDeferred; /* be lazy */
 483
 484         assert(subclass->state & CLASS_LINKED);
 485
 486         /* do not check access to protected members of arrays */
 487
 488         if (error == resolveIllegalAccessError && subclass->name->text[0] == '[') {
 489                 return resolveSucceeded;
 490         }
 491
 492         /* perform the subtype check */
 493
 494         typeinfo_init_classinfo(&subti,subclass);
 495 check_again:
 496         r = typeinfo_is_assignable_to_class(&subti,supertype);
 497         if (r == typecheck_FAIL)
 498                 return resolveFailed; /* failed, exception is already set */
 499
 500         if (r == typecheck_MAYBE) {
 501                 assert(IS_CLASSREF(supertype));
 502                 if (mode == resolveEager) {
 503                         if (!resolve_classref_or_classinfo(refmethod,supertype,
 504                                                                                            resolveEager,false,true,
 505                                                                                            &supertype.cls))
 506                         {
 507                                 return resolveFailed;
 508                         }
 509                         assert(supertype.cls);
 510                         goto check_again;
 511                 }
 512
 513                 return resolveDeferred; /* be lazy */
 514         }
 515
 516         if (!r) {
 517                 /* sub class relationship is false */
 518
 519                 char *message;
 520                 int msglen;
 521
 522 #if defined(RESOLVE_VERBOSE)
 523                 printf("SUBTYPE CHECK FAILED!\n");
 524 #endif
 525
 526                 msglen = utf_bytes(subclass->name) + utf_bytes(CLASSREF_OR_CLASSINFO_NAME(supertype)) + 200;
 527                 message = MNEW(char, msglen);
 528                 strcpy(message, (error == resolveIllegalAccessError) ?
 529                                 "illegal access to protected member ("
 530                                 : "subtype constraint violated (");
 531                 utf_cat_classname(message, subclass->name);
 532                 strcat(message, " is not a subclass of ");
 533                 utf_cat_classname(message, CLASSREF_OR_CLASSINFO_NAME(supertype));
 534                 strcat(message, ")");
 535                 if (error == resolveIllegalAccessError)
 536                         *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException, message);
 537                 else
 538                         *exceptionptr = exceptions_new_linkageerror(message, NULL);
 539                 MFREE(message, char, msglen);
 540                 return resolveFailed; /* exception */
 541         }
 542
 543         /* everything ok */
 544
 545         return resolveSucceeded;
 546 }
 547 #endif /* defined(ENABLE_VERIFIER) */
 548
 549 /* resolve_lazy_subtype_checks *************************************************
 550
 551    Resolve the types to check lazily and perform subtype checks
 552
 553    IN:
 554        refmethod........the method triggering the resolution
 555        subtinfo.........the typeinfo containing the subtypes
 556        supertype........the supertype to test againgst
 557            mode.............mode of resolution:
 558                             resolveLazy...only resolve if it does not
 559                                           require loading classes
 560                             resolveEager..load classes if necessary
 561        error............which type of exception to throw if
 562                         the test fails. May be:
 563                             resolveLinkageError, or
 564                             resolveIllegalAccessError
 565                                                 IMPORTANT: If error==resolveIllegalAccessError,
 566                                                 then array types in the set are skipped.
 567
 568    RETURN VALUE:
 569        resolveSucceeded.....the check succeeded
 570        resolveDeferred......the check could not be performed due to
 571                                 unresolved types
 572            resolveFailed........the check failed, an exception has been thrown.
 573
 574    NOTE:
 575        The references in the set are resolved first, so any
 576        exception which may occurr during resolution may
 577        be thrown by this function.
 578
 579 *******************************************************************************/
 580
 581 #if defined(ENABLE_VERIFIER)
 582 static resolve_result_t resolve_lazy_subtype_checks(methodinfo *refmethod,
 583                                                                                                         typeinfo *subtinfo,
 584                                                                                                         classref_or_classinfo supertype,
 585                                                                                                         resolve_err_t error)
 586 {
 587         int count;
 588         int i;
 589         resolve_result_t result;
 590
 591         assert(refmethod);
 592         assert(subtinfo);
 593         assert(supertype.any);
 594         assert(error == resolveLinkageError || error == resolveIllegalAccessError);
 595
 596         /* returnAddresses are illegal here */
 597
 598         if (TYPEINFO_IS_PRIMITIVE(*subtinfo)) {
 599                 exceptions_throw_verifyerror(refmethod,
 600                                 "Invalid use of returnAddress");
 601                 return resolveFailed;
 602         }
 603
 604         /* uninitialized objects are illegal here */
 605
 606         if (TYPEINFO_IS_NEWOBJECT(*subtinfo)) {
 607                 exceptions_throw_verifyerror(refmethod,
 608                                 "Invalid use of uninitialized object");
 609                 return resolveFailed;
 610         }
 611
 612         /* the nulltype is always assignable */
 613
 614         if (TYPEINFO_IS_NULLTYPE(*subtinfo))
 615                 return resolveSucceeded;
 616
 617         /* every type is assignable to (BOOTSTRAP)java.lang.Object */
 618
 619         if (supertype.cls == class_java_lang_Object
 620                 || (CLASSREF_OR_CLASSINFO_NAME(supertype) == utf_java_lang_Object
 621                         && refmethod->class->classloader == NULL))
 622         {
 623                 return resolveSucceeded;
 624         }
 625
 626         if (subtinfo->merged) {
 627
 628                 /* for a merged type we have to do a series of checks */
 629
 630                 count = subtinfo->merged->count;
 631                 for (i=0; i<count; ++i) {
 632                         classref_or_classinfo c = subtinfo->merged->list[i];
 633                         if (subtinfo->dimension > 0) {
 634                                 /* a merge of array types */
 635                                 /* the merged list contains the possible _element_ types, */
 636                                 /* so we have to create array types with these elements.  */
 637                                 if (IS_CLASSREF(c)) {
 638                                         c.ref = class_get_classref_multiarray_of(subtinfo->dimension,c.ref);
 639                                 }
 640                                 else {
 641                                         c.cls = class_multiarray_of(subtinfo->dimension,c.cls,false);
 642                                 }
 643                         }
 644
 645                         /* do the subtype check against the type c */
 646
 647                         result = resolve_subtype_check(refmethod,c,supertype,resolveLazy,error);
 648                         if (result != resolveSucceeded)
 649                                 return result;
 650                 }
 651         }
 652         else {
 653
 654                 /* a single type, this is the common case, hopefully */
 655
 656                 if (CLASSREF_OR_CLASSINFO_NAME(subtinfo->typeclass)
 657                         == CLASSREF_OR_CLASSINFO_NAME(supertype))
 658                 {
 659                         /* the class names are the same */
 660                     /* equality is guaranteed by the loading constraints */
 661                         return resolveSucceeded;
 662                 }
 663                 else {
 664
 665                         /* some other type name, try to perform the check lazily */
 666
 667                         return resolve_subtype_check(refmethod,
 668                                                                                  subtinfo->typeclass,supertype,
 669                                                                                  resolveLazy,
 670                                                                                  error);
 671                 }
 672         }
 673
 674         /* everything ok */
 675         return resolveSucceeded;
 676 }
 677 #endif /* defined(ENABLE_VERIFIER) */
 678
 679 /* resolve_and_check_subtype_set ***********************************************
 680
 681    Resolve the references in the given set and test subtype relationships
 682
 683    IN:
 684        refmethod........the method triggering the resolution
 685        ref..............a set of class/interface references
 686                         (may be empty)
 687        typeref..........the type to test against the set
 688        mode.............mode of resolution:
 689                             resolveLazy...only resolve if it does not
 690                                           require loading classes
 691                             resolveEager..load classes if necessary
 692        error............which type of exception to throw if
 693                         the test fails. May be:
 694                             resolveLinkageError, or
 695                             resolveIllegalAccessError
 696                                                 IMPORTANT: If error==resolveIllegalAccessError,
 697                                                 then array types in the set are skipped.
 698
 699    RETURN VALUE:
 700        resolveSucceeded.....the check succeeded
 701        resolveDeferred......the check could not be performed due to
 702                                 unresolved types. (This can only happen if
 703                                                         mode == resolveLazy.)
 704            resolveFailed........the check failed, an exception has been thrown.
 705
 706    NOTE:
 707        The references in the set are resolved first, so any
 708        exception which may occurr during resolution may
 709        be thrown by this function.
 710
 711 *******************************************************************************/
 712
 713 #if defined(ENABLE_VERIFIER)
 714 static resolve_result_t resolve_and_check_subtype_set(methodinfo *refmethod,
 715                                                                           unresolved_subtype_set *ref,
 716                                                                           classref_or_classinfo typeref,
 717                                                                           resolve_mode_t mode,
 718                                                                           resolve_err_t error)
 719 {
 720         classref_or_classinfo *setp;
 721         typecheck_result checkresult;
 722
 723         assert(refmethod);
 724         assert(ref);
 725         assert(typeref.any);
 726         assert(mode == resolveLazy || mode == resolveEager);
 727         assert(error == resolveLinkageError || error == resolveIllegalAccessError);
 728
 729 #if defined(RESOLVE_VERBOSE)
 730         printf("resolve_and_check_subtype_set:\n");
 731         unresolved_subtype_set_debug_dump(ref, stdout);
 732         if (IS_CLASSREF(typeref))
 733                 class_classref_println(typeref.ref);
 734         else
 735                 class_println(typeref.cls);
 736 #endif
 737
 738         setp = ref->subtyperefs;
 739
 740         /* an empty set of tests always succeeds */
 741         if (!setp || !setp->any) {
 742                 return resolveSucceeded;
 743         }
 744
 745         /* first resolve the type if necessary */
 746         if (!resolve_classref_or_classinfo(refmethod,typeref,mode,false,true,&(typeref.cls)))
 747                 return resolveFailed; /* exception */
 748         if (!typeref.cls)
 749                 return resolveDeferred; /* be lazy */
 750
 751         assert(typeref.cls->state & CLASS_LINKED);
 752
 753         /* iterate over the set members */
 754
 755         for (; setp->any; ++setp) {
 756                 checkresult = resolve_subtype_check(refmethod,*setp,typeref,mode,error);
 757 #if defined(RESOLVE_VERBOSE)
 758                 if (checkresult != resolveSucceeded)
 759                         printf("SUBTYPE CHECK FAILED!\n");
 760 #endif
 761                 if (checkresult != resolveSucceeded)
 762                         return checkresult;
 763         }
 764
 765         /* check succeeds */
 766         return resolveSucceeded;
 767 }
 768 #endif /* defined(ENABLE_VERIFIER) */
 769
 770 /******************************************************************************/
 771 /* CLASS RESOLUTION                                                           */
 772 /******************************************************************************/
 773
 774 /* resolve_class ***************************************************************
 775
 776    Resolve an unresolved class reference. The class is also linked.
 777
 778    IN:
 779        ref..............struct containing the reference
 780        mode.............mode of resolution:
 781                             resolveLazy...only resolve if it does not
 782                                           require loading classes
 783                             resolveEager..load classes if necessary
 784            checkaccess......if true, access rights to the class are checked
 785
 786    OUT:
 787        *result..........set to the result of resolution, or to NULL if
 788                         the reference has not been resolved
 789                         In the case of an exception, *result is
 790                         guaranteed to be set to NULL.
 791
 792    RETURN VALUE:
 793        true.............everything ok
 794                         (*result may still be NULL for resolveLazy)
 795        false............an exception has been thrown
 796
 797 *******************************************************************************/
 798
 799 #ifdef ENABLE_VERIFIER
 800 bool resolve_class(unresolved_class *ref,
 801                                    resolve_mode_t mode,
 802                                    bool checkaccess,
 803                                    classinfo **result)
 804 {
 805         classinfo *cls;
 806         resolve_result_t checkresult;
 807
 808         assert(ref);
 809         assert(result);
 810         assert(mode == resolveLazy || mode == resolveEager);
 811
 812         *result = NULL;
 813
 814 #ifdef RESOLVE_VERBOSE
 815         unresolved_class_debug_dump(ref,stdout);
 816 #endif
 817
 818         /* first we must resolve the class */
 819         if (!resolve_classref(ref->referermethod,
 820                                               ref->classref,mode,checkaccess,true,&cls))
 821         {
 822                 /* the class reference could not be resolved */
 823                 return false; /* exception */
 824         }
 825         if (!cls)
 826                 return true; /* be lazy */
 827
 828         assert(cls);
 829         assert((cls->state & CLASS_LOADED) && (cls->state & CLASS_LINKED));
 830
 831         /* now we check the subtype constraints */
 832
 833         checkresult = resolve_and_check_subtype_set(ref->referermethod,
 834                                                                            &(ref->subtypeconstraints),
 835                                                                            CLASSREF_OR_CLASSINFO(cls),
 836                                                                            mode,
 837                                                                            resolveLinkageError);
 838         if (checkresult != resolveSucceeded)
 839                 return (bool) checkresult;
 840
 841         /* succeed */
 842         *result = cls;
 843         return true;
 844 }
 845 #endif /* ENABLE_VERIFIER */
 846
 847 /* resolve_classref_eager ******************************************************
 848
 849    Resolve an unresolved class reference eagerly. The class is also linked and
 850    access rights to the class are checked.
 851
 852    IN:
 853        ref..............constant_classref to the class
 854
 855    RETURN VALUE:
 856        classinfo * to the class, or
 857            NULL if an exception has been thrown
 858
 859 *******************************************************************************/
 860
 861 classinfo * resolve_classref_eager(constant_classref *ref)
 862 {
 863         classinfo *c;
 864
 865         if (!resolve_classref(NULL,ref,resolveEager,true,true,&c))
 866                 return NULL;
 867
 868         return c;
 869 }
 870
 871 /* resolve_classref_eager_nonabstract ******************************************
 872
 873    Resolve an unresolved class reference eagerly. The class is also linked and
 874    access rights to the class are checked. A check is performed that the class
 875    is not abstract.
 876
 877    IN:
 878        ref..............constant_classref to the class
 879
 880    RETURN VALUE:
 881        classinfo * to the class, or
 882            NULL if an exception has been thrown
 883
 884 *******************************************************************************/
 885
 886 classinfo * resolve_classref_eager_nonabstract(constant_classref *ref)
 887 {
 888         classinfo *c;
 889
 890         if (!resolve_classref(NULL,ref,resolveEager,true,true,&c))
 891                 return NULL;
 892
 893         /* ensure that the class is not abstract */
 894
 895         if (c->flags & ACC_ABSTRACT) {
 896                 exceptions_throw_verifyerror(NULL,"creating instance of abstract class");
 897                 return NULL;
 898         }
 899
 900         return c;
 901 }
 902
 903 /* resolve_class_eager *********************************************************
 904
 905    Resolve an unresolved class reference eagerly. The class is also linked and
 906    access rights to the class are checked.
 907
 908    IN:
 909        ref..............struct containing the reference
 910
 911    RETURN VALUE:
 912        classinfo * to the class, or
 913            NULL if an exception has been thrown
 914
 915 *******************************************************************************/
 916
 917 #ifdef ENABLE_VERIFIER
 918 classinfo * resolve_class_eager(unresolved_class *ref)
 919 {
 920         classinfo *c;
 921
 922         if (!resolve_class(ref,resolveEager,true,&c))
 923                 return NULL;
 924
 925         return c;
 926 }
 927 #endif /* ENABLE_VERIFIER */
 928
 929 /******************************************************************************/
 930 /* FIELD RESOLUTION                                                           */
 931 /******************************************************************************/
 932
 933 /* resolve_field_verifier_checks *******************************************
 934
 935    Do the verifier checks necessary after field has been resolved.
 936
 937    IN:
 938        refmethod........the method containing the reference
 939            fieldref.........the field reference
 940            container........the class where the field was found
 941            fi...............the fieldinfo of the resolved field
 942            instanceti.......instance typeinfo, if available
 943            valueti..........value typeinfo, if available
 944            isstatic.........true if this is a *STATIC* instruction
 945            isput............true if this is a PUT* instruction
 946
 947    RETURN VALUE:
 948        resolveSucceeded....everything ok
 949            resolveDeferred.....tests could not be done, have been deferred
 950        resolveFailed.......exception has been thrown
 951
 952 *******************************************************************************/
 953
 954 #if defined(ENABLE_VERIFIER)
 955 resolve_result_t resolve_field_verifier_checks(methodinfo *refmethod,
 956                                                                                            constant_FMIref *fieldref,
 957                                                                                            classinfo *container,
 958                                                                                            fieldinfo *fi,
 959                                                                                            typeinfo *instanceti,
 960                                                                                            typeinfo *valueti,
 961                                                                                            bool isstatic,
 962                                                                                            bool isput)
 963 {
 964         classinfo *declarer;
 965         classinfo *referer;
 966         resolve_result_t result;
 967         constant_classref *fieldtyperef;
 968
 969         assert(refmethod);
 970         assert(fieldref);
 971         assert(container);
 972         assert(fi);
 973
 974         /* get the classinfos and the field type */
 975
 976         referer = refmethod->class;
 977         assert(referer);
 978
 979         declarer = fi->class;
 980         assert(declarer);
 981         assert(referer->state & CLASS_LINKED);
 982
 983         fieldtyperef = fieldref->parseddesc.fd->classref;
 984
 985         /* check static */
 986
 987 #if true != 1
 988 #error This code assumes that `true` is `1`. Otherwise, use the ternary operator below.
 989 #endif
 990
 991         if (((fi->flags & ACC_STATIC) != 0) != isstatic) {
 992                 /* a static field is accessed via an instance, or vice versa */
 993                 *exceptionptr =
 994                         new_exception_message(string_java_lang_IncompatibleClassChangeError,
 995                                 (fi->flags & ACC_STATIC) ? "static field accessed via instance"
 996                                                          : "instance field  accessed without instance");
 997                 return resolveFailed;
 998         }
 999
1000         /* check access rights */
1001
1002         if (!access_is_accessible_member(referer,declarer,fi->flags)) {
1003                 int msglen;
1004                 char *message;
1005
1006                 msglen = utf_bytes(declarer->name) + utf_bytes(fi->name) + utf_bytes(referer->name) + 100;
1007                 message = MNEW(char, msglen);
1008                 strcpy(message, "field is not accessible (");
1009                 utf_cat_classname(message, declarer->name);
1010                 strcat(message, ".");
1011                 utf_cat(message, fi->name);
1012                 strcat(message, " from ");
1013                 utf_cat_classname(message, referer->name);
1014                 strcat(message, ")");
1015                 *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException, message);
1016                 MFREE(message,char,msglen);
1017                 return resolveFailed; /* exception */
1018         }
1019
1020         /* for non-static methods we have to check the constraints on the         */
1021         /* instance type                                                          */
1022
1023         if (instanceti) {
1024                 typeinfo *insttip;
1025                 typeinfo tinfo;
1026
1027                 /* The instanceslot must contain a reference to a non-array type */
1028
1029                 if (!TYPEINFO_IS_REFERENCE(*instanceti)) {
1030                         exceptions_throw_verifyerror(refmethod, "illegal instruction: field access on non-reference");
1031                         return resolveFailed;
1032                 }
1033                 if (TYPEINFO_IS_ARRAY(*instanceti)) {
1034                         exceptions_throw_verifyerror(refmethod, "illegal instruction: field access on array");
1035                         return resolveFailed;
1036                 }
1037
1038                 if (isput && TYPEINFO_IS_NEWOBJECT(*instanceti))
1039                 {
1040                         /* The instruction writes a field in an uninitialized object. */
1041                         /* This is only allowed when a field of an uninitialized 'this' object is */
1042                         /* written inside an initialization method                                */
1043
1044                         classinfo *initclass;
1045                         instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
1046
1047                         if (ins != NULL) {
1048                                 exceptions_throw_verifyerror(refmethod, "accessing field of uninitialized object");
1049                                 return resolveFailed;
1050                         }
1051
1052                         /* XXX check that class of field == refmethod->class */
1053                         initclass = referer; /* XXX classrefs */
1054                         assert(initclass->state & CLASS_LINKED);
1055
1056                         typeinfo_init_classinfo(&tinfo, initclass);
1057                         insttip = &tinfo;
1058                 }
1059                 else {
1060                         insttip = instanceti;
1061                 }
1062
1063                 result = resolve_lazy_subtype_checks(refmethod,
1064                                 insttip,
1065                                 CLASSREF_OR_CLASSINFO(container),
1066                                 resolveLinkageError);
1067                 if (result != resolveSucceeded)
1068                         return result;
1069
1070                 /* check protected access */
1071
1072                 if (((fi->flags & ACC_PROTECTED) != 0) && !SAME_PACKAGE(declarer,referer))
1073                 {
1074                         result = resolve_lazy_subtype_checks(refmethod,
1075                                         instanceti,
1076                                         CLASSREF_OR_CLASSINFO(referer),
1077                                         resolveIllegalAccessError);
1078                         if (result != resolveSucceeded)
1079                                 return result;
1080                 }
1081
1082         }
1083
1084         /* for PUT* instructions we have to check the constraints on the value type */
1085
1086         if (valueti) {
1087                 assert(fieldtyperef);
1088
1089                 /* check subtype constraints */
1090                 result = resolve_lazy_subtype_checks(refmethod,
1091                                 valueti,
1092                                 CLASSREF_OR_CLASSINFO(fieldtyperef),
1093                                 resolveLinkageError);
1094
1095                 if (result != resolveSucceeded)
1096                         return result;
1097         }
1098
1099         /* impose loading constraint on field type */
1100
1101         if (fi->type == TYPE_ADR) {
1102                 assert(fieldtyperef);
1103                 if (!classcache_add_constraint(declarer->classloader,
1104                                                                            referer->classloader,
1105                                                                            fieldtyperef->name))
1106                         return resolveFailed;
1107         }
1108
1109         /* XXX impose loading constraint on instance? */
1110
1111         /* everything ok */
1112         return resolveSucceeded;
1113 }
1114 #endif /* defined(ENABLE_VERIFIER) */
1115
1116 /* resolve_field_lazy **********************************************************
1117
1118    Resolve an unresolved field reference lazily
1119
1120    NOTE: This function does NOT do any verification checks. In case of a
1121          successful resolution, you must call resolve_field_verifier_checks
1122                  in order to perform the necessary checks!
1123
1124    IN:
1125            refmethod........the referer method
1126            fieldref.........the field reference
1127
1128    RETURN VALUE:
1129        resolveSucceeded.....the reference has been resolved
1130        resolveDeferred......the resolving could not be performed lazily
1131            resolveFailed........resolving failed, an exception has been thrown.
1132
1133 *******************************************************************************/
1134
1135 resolve_result_t resolve_field_lazy(methodinfo *refmethod,
1136                                                                         constant_FMIref *fieldref)
1137 {
1138         classinfo *referer;
1139         classinfo *container;
1140         fieldinfo *fi;
1141
1142         assert(refmethod);
1143
1144         /* the class containing the reference */
1145
1146         referer = refmethod->class;
1147         assert(referer);
1148
1149         /* check if the field itself is already resolved */
1150
1151         if (IS_FMIREF_RESOLVED(fieldref))
1152                 return resolveSucceeded;
1153
1154         /* first we must resolve the class containg the field */
1155
1156         /* XXX can/may lazyResolving trigger linking? */
1157
1158         if (!resolve_class_from_name(referer, refmethod,
1159                    fieldref->p.classref->name, resolveLazy, true, true, &container))
1160         {
1161                 /* the class reference could not be resolved */
1162                 return resolveFailed; /* exception */
1163         }
1164         if (!container)
1165                 return resolveDeferred; /* be lazy */
1166
1167         assert(container->state & CLASS_LINKED);
1168
1169         /* now we must find the declaration of the field in `container`
1170          * or one of its superclasses */
1171
1172         fi = class_resolvefield(container,
1173                                                         fieldref->name, fieldref->descriptor,
1174                                                         referer, true);
1175         if (!fi) {
1176                 /* The field does not exist. But since we were called lazily, */
1177                 /* this error must not be reported now. (It will be reported   */
1178                 /* if eager resolving of this field is ever tried.)           */
1179
1180                 *exceptionptr = NULL;
1181                 return resolveDeferred; /* be lazy */
1182         }
1183
1184         /* cache the result of the resolution */
1185
1186         fieldref->p.field = fi;
1187
1188         /* everything ok */
1189         return resolveSucceeded;
1190 }
1191
1192 /* resolve_field ***************************************************************
1193
1194    Resolve an unresolved field reference
1195
1196    IN:
1197        ref..............struct containing the reference
1198        mode.............mode of resolution:
1199                             resolveLazy...only resolve if it does not
1200                                           require loading classes
1201                             resolveEager..load classes if necessary
1202
1203    OUT:
1204        *result..........set to the result of resolution, or to NULL if
1205                         the reference has not been resolved
1206                         In the case of an exception, *result is
1207                         guaranteed to be set to NULL.
1208
1209    RETURN VALUE:
1210        true.............everything ok
1211                         (*result may still be NULL for resolveLazy)
1212        false............an exception has been thrown
1213
1214 *******************************************************************************/
1215
1216 bool resolve_field(unresolved_field *ref,
1217                                    resolve_mode_t mode,
1218                                    fieldinfo **result)
1219 {
1220         classinfo *referer;
1221         classinfo *container;
1222         classinfo *declarer;
1223         constant_classref *fieldtyperef;
1224         fieldinfo *fi;
1225         resolve_result_t checkresult;
1226
1227         assert(ref);
1228         assert(result);
1229         assert(mode == resolveLazy || mode == resolveEager);
1230
1231         *result = NULL;
1232
1233 #ifdef RESOLVE_VERBOSE
1234         unresolved_field_debug_dump(ref,stdout);
1235 #endif
1236
1237         /* the class containing the reference */
1238
1239         referer = ref->referermethod->class;
1240         assert(referer);
1241
1242         /* check if the field itself is already resolved */
1243         if (IS_FMIREF_RESOLVED(ref->fieldref)) {
1244                 fi = ref->fieldref->p.field;
1245                 container = fi->class;
1246                 goto resolved_the_field;
1247         }
1248
1249         /* first we must resolve the class containg the field */
1250         if (!resolve_class_from_name(referer,ref->referermethod,
1251                                            ref->fieldref->p.classref->name,mode,true,true,&container))
1252         {
1253                 /* the class reference could not be resolved */
1254                 return false; /* exception */
1255         }
1256         if (!container)
1257                 return true; /* be lazy */
1258
1259         assert(container);
1260         assert(container->state & CLASS_LOADED);
1261         assert(container->state & CLASS_LINKED);
1262
1263         /* now we must find the declaration of the field in `container`
1264          * or one of its superclasses */
1265
1266 #ifdef RESOLVE_VERBOSE
1267                 printf("    resolving field in class...\n");
1268 #endif
1269
1270         fi = class_resolvefield(container,
1271                                                         ref->fieldref->name,ref->fieldref->descriptor,
1272                                                         referer,true);
1273         if (!fi) {
1274                 if (mode == resolveLazy) {
1275                         /* The field does not exist. But since we were called lazily, */
1276                         /* this error must not be reported now. (It will be reported   */
1277                         /* if eager resolving of this field is ever tried.)           */
1278
1279                         *exceptionptr = NULL;
1280                         return true; /* be lazy */
1281                 }
1282
1283                 return false; /* exception */
1284         }
1285
1286         /* cache the result of the resolution */
1287         ref->fieldref->p.field = fi;
1288
1289 resolved_the_field:
1290
1291 #ifdef ENABLE_VERIFIER
1292         /* Checking opt_verify is ok here, because the NULL iptr guarantees */
1293         /* that no missing parts of an instruction will be accessed.        */
1294         if (opt_verify) {
1295                 checkresult = resolve_field_verifier_checks(
1296                                 ref->referermethod,
1297                                 ref->fieldref,
1298                                 container,
1299                                 fi,
1300                                 NULL, /* instanceti, handled by constraints below */
1301                                 NULL, /* valueti, handled by constraints below  */
1302                                 (ref->flags & RESOLVE_STATIC) != 0, /* isstatic */
1303                                 (ref->flags & RESOLVE_PUTFIELD) != 0 /* isput */);
1304
1305                 if (checkresult != resolveSucceeded)
1306                         return (bool) checkresult;
1307
1308                 declarer = fi->class;
1309                 assert(declarer);
1310                 assert(declarer->state & CLASS_LOADED);
1311                 assert(declarer->state & CLASS_LINKED);
1312
1313                 /* for non-static accesses we have to check the constraints on the */
1314                 /* instance type */
1315
1316                 if (!(ref->flags & RESOLVE_STATIC)) {
1317                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
1318                                         &(ref->instancetypes),
1319                                         CLASSREF_OR_CLASSINFO(container),
1320                                         mode, resolveLinkageError);
1321                         if (checkresult != resolveSucceeded)
1322                                 return (bool) checkresult;
1323                 }
1324
1325                 fieldtyperef = ref->fieldref->parseddesc.fd->classref;
1326
1327                 /* for PUT* instructions we have to check the constraints on the value type */
1328                 if (((ref->flags & RESOLVE_PUTFIELD) != 0) && fi->type == TYPE_ADR) {
1329                         assert(fieldtyperef);
1330                         if (!SUBTYPESET_IS_EMPTY(ref->valueconstraints)) {
1331                                 /* check subtype constraints */
1332                                 checkresult = resolve_and_check_subtype_set(ref->referermethod,
1333                                                 &(ref->valueconstraints),
1334                                                 CLASSREF_OR_CLASSINFO(fieldtyperef),
1335                                                 mode, resolveLinkageError);
1336                                 if (checkresult != resolveSucceeded)
1337                                         return (bool) checkresult;
1338                         }
1339                 }
1340
1341                 /* check protected access */
1342                 if (((fi->flags & ACC_PROTECTED) != 0) && !SAME_PACKAGE(declarer,referer)) {
1343                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
1344                                         &(ref->instancetypes),
1345                                         CLASSREF_OR_CLASSINFO(referer),
1346                                         mode,
1347                                         resolveIllegalAccessError);
1348                         if (checkresult != resolveSucceeded)
1349                                 return (bool) checkresult;
1350                 }
1351
1352         }
1353 #endif /* ENABLE_VERIFIER */
1354
1355         /* succeed */
1356         *result = fi;
1357
1358         return true;
1359 }
1360
1361 /* resolve_field_eager *********************************************************
1362
1363    Resolve an unresolved field reference eagerly.
1364
1365    IN:
1366        ref..............struct containing the reference
1367
1368    RETURN VALUE:
1369        fieldinfo * to the field, or
1370            NULL if an exception has been thrown
1371
1372 *******************************************************************************/
1373
1374 fieldinfo * resolve_field_eager(unresolved_field *ref)
1375 {
1376         fieldinfo *fi;
1377
1378         if (!resolve_field(ref,resolveEager,&fi))
1379                 return NULL;
1380
1381         return fi;
1382 }
1383
1384 /******************************************************************************/
1385 /* METHOD RESOLUTION                                                          */
1386 /******************************************************************************/
1387
1388 /* resolve_method_invokespecial_lookup *****************************************
1389
1390    Do the special lookup for methods invoked by INVOKESPECIAL
1391
1392    IN:
1393        refmethod........the method containing the reference
1394            mi...............the methodinfo of the resolved method
1395
1396    RETURN VALUE:
1397        a methodinfo *...the result of the lookup,
1398            NULL.............an exception has been thrown
1399
1400 *******************************************************************************/
1401
1402 methodinfo * resolve_method_invokespecial_lookup(methodinfo *refmethod,
1403                                                                                                  methodinfo *mi)
1404 {
1405         classinfo *declarer;
1406         classinfo *referer;
1407
1408         assert(refmethod);
1409         assert(mi);
1410
1411         /* get referer and declarer classes */
1412
1413         referer = refmethod->class;
1414         assert(referer);
1415
1416         declarer = mi->class;
1417         assert(declarer);
1418         assert(referer->state & CLASS_LINKED);
1419
1420         /* checks for INVOKESPECIAL:                                       */
1421         /* for <init> and methods of the current class we don't need any   */
1422         /* special checks. Otherwise we must verify that the called method */
1423         /* belongs to a super class of the current class                   */
1424
1425         if ((referer != declarer) && (mi->name != utf_init)) {
1426                 /* check that declarer is a super class of the current class   */
1427
1428                 if (!class_issubclass(referer,declarer)) {
1429                         exceptions_throw_verifyerror(refmethod,
1430                                         "INVOKESPECIAL calling non-super class method");
1431                         return NULL;
1432                 }
1433
1434                 /* if the referer has ACC_SUPER set, we must do the special    */
1435                 /* lookup starting with the direct super class of referer      */
1436
1437                 if ((referer->flags & ACC_SUPER) != 0) {
1438                         mi = class_resolvemethod(referer->super.cls,
1439                                                                          mi->name,
1440                                                                          mi->descriptor);
1441
1442                         if (mi == NULL) {
1443                                 /* the spec calls for an AbstractMethodError in this case */
1444                                 exceptions_throw_abstractmethoderror();
1445                                 return NULL;
1446                         }
1447                 }
1448         }
1449
1450         /* everything ok */
1451         return mi;
1452 }
1453
1454 /* resolve_method_verifier_checks ******************************************
1455
1456    Do the verifier checks necessary after a method has been resolved.
1457
1458    IN:
1459        refmethod........the method containing the reference
1460            methodref........the method reference
1461            container........the class where the method was found
1462            mi...............the methodinfo of the resolved method
1463            invokestatic.....true if the method is invoked by INVOKESTATIC
1464            iptr.............the invoke instruction, or NULL
1465
1466    RETURN VALUE:
1467        resolveSucceeded....everything ok
1468            resolveDeferred.....tests could not be done, have been deferred
1469        resolveFailed.......exception has been thrown
1470
1471 *******************************************************************************/
1472
1473 #if defined(ENABLE_VERIFIER)
1474 resolve_result_t resolve_method_verifier_checks(jitdata *jd,
1475                                                                                                 methodinfo *refmethod,
1476                                                                                                 constant_FMIref *methodref,
1477                                                                                                 classinfo *container,
1478                                                                                                 methodinfo *mi,
1479                                                                                                 bool invokestatic,
1480                                                                                                 bool invokespecial,
1481                                                                                                 instruction *iptr)
1482 {
1483         classinfo *declarer;
1484         classinfo *referer;
1485         int instancecount;
1486         methoddesc *md;
1487
1488         assert(refmethod);
1489         assert(methodref);
1490         assert(container);
1491         assert(mi);
1492
1493 #ifdef RESOLVE_VERBOSE
1494         printf("resolve_method_verifier_checks\n");
1495         printf("    flags: %02x\n",mi->flags);
1496 #endif
1497
1498         /* get the classinfos and the method descriptor */
1499
1500         referer = refmethod->class;
1501         assert(referer);
1502
1503         declarer = mi->class;
1504         assert(declarer);
1505         assert(referer->state & CLASS_LINKED);
1506
1507         md = methodref->parseddesc.md;
1508         assert(md);
1509         assert(md->params);
1510
1511         instancecount = (invokestatic) ? 0 : 1;
1512
1513         /* check static */
1514
1515         if (((mi->flags & ACC_STATIC) != 0) != (invokestatic != false)) {
1516                 /* a static method is accessed via an instance, or vice versa */
1517                 *exceptionptr =
1518                         new_exception_message(string_java_lang_IncompatibleClassChangeError,
1519                                 (mi->flags & ACC_STATIC) ? "static method called via instance"
1520                                                          : "instance method called without instance");
1521                 return resolveFailed;
1522         }
1523
1524         /* check access rights */
1525
1526         if (!access_is_accessible_member(referer,declarer,mi->flags)) {
1527                 int msglen;
1528                 char *message;
1529
1530                 /* XXX clean this up. this should be in exceptions.c */
1531                 msglen = utf_bytes(declarer->name) + utf_bytes(mi->name) +
1532                         utf_bytes(mi->descriptor) + utf_bytes(referer->name) + 100;
1533                 message = MNEW(char, msglen);
1534                 strcpy(message, "method is not accessible (");
1535                 utf_cat_classname(message, declarer->name);
1536                 strcat(message, ".");
1537                 utf_cat(message, mi->name);
1538                 utf_cat(message, mi->descriptor);
1539                 strcat(message," from ");
1540                 utf_cat_classname(message, referer->name);
1541                 strcat(message,")");
1542                 *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException, message);
1543                 MFREE(message, char, msglen);
1544                 return resolveFailed; /* exception */
1545         }
1546
1547         /* everything ok */
1548
1549         return resolveSucceeded;
1550 }
1551 #endif /* defined(ENABLE_VERIFIER) */
1552
1553
1554 /* resolve_method_type_checks **************************************************
1555
1556    Check parameter types of a method invocation.
1557
1558    IN:
1559            jd...............jitdata of the method doing the call
1560        refmethod........the method containing the reference
1561            iptr.............the invoke instruction
1562            mi...............the methodinfo of the resolved method
1563            invokestatic.....true if the method is invoked by INVOKESTATIC
1564            invokespecial....true if the method is invoked by INVOKESPECIAL
1565
1566    RETURN VALUE:
1567        resolveSucceeded....everything ok
1568            resolveDeferred.....tests could not be done, have been deferred
1569        resolveFailed.......exception has been thrown
1570
1571 *******************************************************************************/
1572
1573 #if defined(ENABLE_VERIFIER)
1574 resolve_result_t resolve_method_type_checks(jitdata *jd,
1575                                                                                         methodinfo *refmethod,
1576                                                                                         instruction *iptr,
1577                                                                                         methodinfo *mi,
1578                                                                                         bool invokestatic,
1579                                                                                         bool invokespecial)
1580 {
1581         varinfo         *instanceslot;
1582         varinfo         *param;
1583         typeinfo         tinfo;
1584         resolve_result_t result;
1585         methoddesc      *md;
1586         typedesc        *paramtypes;
1587         s4               type;
1588         s4               instancecount;
1589         s4               i;
1590
1591         /* for non-static methods we have to check the constraints on the         */
1592         /* instance type                                                          */
1593
1594         assert(jd);
1595
1596         if (invokestatic) {
1597                 instancecount = 0;
1598                 instanceslot = NULL;
1599         }
1600         else {
1601                 instancecount = 1;
1602                 instanceslot = VAR(iptr->sx.s23.s2.args[0]);
1603         }
1604
1605         assert((instanceslot && instancecount == 1) || invokestatic);
1606
1607         /* record subtype constraints for the instance type, if any */
1608         if (instanceslot) {
1609                 typeinfo *tip;
1610
1611                 assert(instanceslot->type == TYPE_ADR);
1612
1613                 if (invokespecial && TYPEINFO_IS_NEWOBJECT(instanceslot->typeinfo))
1614                 {   /* XXX clean up */
1615                         instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
1616                         classref_or_classinfo initclass = (ins) ? ins[-1].sx.val.c
1617                                                                                  : CLASSREF_OR_CLASSINFO(refmethod->class);
1618                         tip = &tinfo;
1619                         if (!typeinfo_init_class(tip,initclass))
1620                                 return false;
1621                 }
1622                 else {
1623                         tip = &(instanceslot->typeinfo);
1624                 }
1625
1626                 result = resolve_lazy_subtype_checks(refmethod,
1627                                                                                          tip,
1628                                                                                          CLASSREF_OR_CLASSINFO(mi->class),
1629                                                                                          resolveLinkageError);
1630                 if (result != resolveSucceeded)
1631                         return result;
1632
1633                 /* check protected access */
1634
1635                 /* XXX use other `declarer` than mi->class? */
1636                 if (((mi->flags & ACC_PROTECTED) != 0)
1637                                 && !SAME_PACKAGE(mi->class, refmethod->class))
1638                 {
1639                         result = resolve_lazy_subtype_checks(refmethod,
1640                                         tip,
1641                                         CLASSREF_OR_CLASSINFO(refmethod->class),
1642                                         resolveIllegalAccessError);
1643                         if (result != resolveSucceeded)
1644                                 return result;
1645                 }
1646
1647         }
1648
1649         /* check subtype constraints for TYPE_ADR parameters */
1650
1651         md = mi->parseddesc;
1652         paramtypes = md->paramtypes;
1653
1654         for (i = md->paramcount-1-instancecount; i>=0; --i) {
1655                 param = VAR(iptr->sx.s23.s2.args[i+instancecount]);
1656                 type = md->paramtypes[i+instancecount].type;
1657
1658                 assert(param);
1659                 assert(type == param->type);
1660
1661                 if (type == TYPE_ADR) {
1662                         result = resolve_lazy_subtype_checks(refmethod,
1663                                         &(param->typeinfo),
1664                                         CLASSREF_OR_CLASSINFO(paramtypes[i+instancecount].classref),
1665                                         resolveLinkageError);
1666                         if (result != resolveSucceeded)
1667                                 return result;
1668                 }
1669         }
1670
1671         /* everything ok */
1672
1673         return resolveSucceeded;
1674 }
1675 #endif /* defined(ENABLE_VERIFIER) */
1676
1677
1678 /* resolve_method_loading_constraints ******************************************
1679
1680    Impose loading constraints on the parameters and return type of the
1681    given method.
1682
1683    IN:
1684        referer..........the class refering to the method
1685            mi...............the method
1686
1687    RETURN VALUE:
1688        true................everything ok
1689            false...............an exception has been thrown
1690
1691 *******************************************************************************/
1692
1693 #if defined(ENABLE_VERIFIER)
1694 bool resolve_method_loading_constraints(classinfo *referer,
1695                                                                                 methodinfo *mi)
1696 {
1697         methoddesc *md;
1698         typedesc   *paramtypes;
1699         utf        *name;
1700         s4          i;
1701         s4          instancecount;
1702
1703         /* impose loading constraints on parameters (including instance) */
1704
1705         md = mi->parseddesc;
1706         paramtypes = md->paramtypes;
1707         instancecount = (mi->flags & ACC_STATIC) / ACC_STATIC;
1708
1709         for (i = 0; i < md->paramcount; i++) {
1710                 if (i < instancecount || paramtypes[i].type == TYPE_ADR) {
1711                         if (i < instancecount) {
1712                                 /* The type of the 'this' pointer is the class containing */
1713                                 /* the method definition. Since container is the same as, */
1714                                 /* or a subclass of declarer, we also constrain declarer  */
1715                                 /* by transitivity of loading constraints.                */
1716                                 name = mi->class->name;
1717                         }
1718                         else {
1719                                 name = paramtypes[i].classref->name;
1720                         }
1721
1722                         /* The caller (referer) and the callee (container) must agree */
1723                         /* on the types of the parameters.                            */
1724                         if (!classcache_add_constraint(referer->classloader,
1725                                                                                    mi->class->classloader, name))
1726                                 return false; /* exception */
1727                 }
1728         }
1729
1730         /* impose loading constraint onto return type */
1731
1732         if (md->returntype.type == TYPE_ADR) {
1733                 /* The caller (referer) and the callee (container) must agree */
1734                 /* on the return type.                                        */
1735                 if (!classcache_add_constraint(referer->classloader,
1736                                         mi->class->classloader,
1737                                         md->returntype.classref->name))
1738                         return false; /* exception */
1739         }
1740
1741         /* everything ok */
1742
1743         return true;
1744 }
1745 #endif /* defined(ENABLE_VERIFIER) */
1746
1747
1748 /* resolve_method_lazy *********************************************************
1749
1750    Resolve an unresolved method reference lazily
1751
1752    NOTE: This function does NOT do any verification checks. In case of a
1753          successful resolution, you must call resolve_method_verifier_checks
1754                  in order to perform the necessary checks!
1755
1756    IN:
1757            refmethod........the referer method
1758            methodref........the method reference
1759            invokespecial....true if this is an INVOKESPECIAL instruction
1760
1761    RETURN VALUE:
1762        resolveSucceeded.....the reference has been resolved
1763        resolveDeferred......the resolving could not be performed lazily
1764            resolveFailed........resolving failed, an exception has been thrown.
1765
1766 *******************************************************************************/
1767
1768 resolve_result_t resolve_method_lazy(methodinfo *refmethod,
1769                                                                          constant_FMIref *methodref,
1770                                                                          bool invokespecial)
1771 {
1772         classinfo *referer;
1773         classinfo *container;
1774         methodinfo *mi;
1775
1776         assert(refmethod);
1777
1778 #ifdef RESOLVE_VERBOSE
1779         printf("resolve_method_lazy\n");
1780 #endif
1781
1782         /* the class containing the reference */
1783
1784         referer = refmethod->class;
1785         assert(referer);
1786
1787         /* check if the method itself is already resolved */
1788
1789         if (IS_FMIREF_RESOLVED(methodref))
1790                 return resolveSucceeded;
1791
1792         /* first we must resolve the class containg the method */
1793
1794         if (!resolve_class_from_name(referer, refmethod,
1795                    methodref->p.classref->name, resolveLazy, true, true, &container))
1796         {
1797                 /* the class reference could not be resolved */
1798                 return resolveFailed; /* exception */
1799         }
1800         if (!container)
1801                 return resolveDeferred; /* be lazy */
1802
1803         assert(container->state & CLASS_LINKED);
1804
1805         /* now we must find the declaration of the method in `container`
1806          * or one of its superclasses */
1807
1808         if (container->flags & ACC_INTERFACE) {
1809                 mi = class_resolveinterfacemethod(container,
1810                                                                               methodref->name,
1811                                                                                   methodref->descriptor,
1812                                                                               referer, true);
1813
1814         } else {
1815                 mi = class_resolveclassmethod(container,
1816                                                                           methodref->name,
1817                                                                           methodref->descriptor,
1818                                                                           referer, true);
1819         }
1820
1821         if (!mi) {
1822                 /* The method does not exist. But since we were called lazily, */
1823                 /* this error must not be reported now. (It will be reported   */
1824                 /* if eager resolving of this method is ever tried.)           */
1825
1826                 *exceptionptr = NULL;
1827                 return resolveDeferred; /* be lazy */
1828         }
1829
1830         if (invokespecial) {
1831                 mi = resolve_method_invokespecial_lookup(refmethod, mi);
1832                 if (!mi)
1833                         return resolveFailed; /* exception */
1834         }
1835
1836         /* have the method params already been parsed? no, do it. */
1837
1838         if (!mi->parseddesc->params)
1839                 if (!descriptor_params_from_paramtypes(mi->parseddesc, mi->flags))
1840                         return resolveFailed;
1841
1842         /* cache the result of the resolution */
1843
1844         methodref->p.method = mi;
1845
1846         /* succeed */
1847
1848         return resolveSucceeded;
1849 }
1850
1851 /* resolve_method **************************************************************
1852
1853    Resolve an unresolved method reference
1854
1855    IN:
1856        ref..............struct containing the reference
1857        mode.............mode of resolution:
1858                             resolveLazy...only resolve if it does not
1859                                           require loading classes
1860                             resolveEager..load classes if necessary
1861
1862    OUT:
1863        *result..........set to the result of resolution, or to NULL if
1864                         the reference has not been resolved
1865                         In the case of an exception, *result is
1866                         guaranteed to be set to NULL.
1867
1868    RETURN VALUE:
1869        true.............everything ok
1870                         (*result may still be NULL for resolveLazy)
1871        false............an exception has been thrown
1872
1873 *******************************************************************************/
1874
1875 bool resolve_method(unresolved_method *ref, resolve_mode_t mode, methodinfo **result)
1876 {
1877         classinfo *referer;
1878         classinfo *container;
1879         classinfo *declarer;
1880         methodinfo *mi;
1881         typedesc *paramtypes;
1882         int instancecount;
1883         int i;
1884         resolve_result_t checkresult;
1885
1886         assert(ref);
1887         assert(result);
1888         assert(mode == resolveLazy || mode == resolveEager);
1889
1890 #ifdef RESOLVE_VERBOSE
1891         unresolved_method_debug_dump(ref,stdout);
1892 #endif
1893
1894         *result = NULL;
1895
1896         /* the class containing the reference */
1897
1898         referer = ref->referermethod->class;
1899         assert(referer);
1900
1901         /* check if the method itself is already resolved */
1902
1903         if (IS_FMIREF_RESOLVED(ref->methodref)) {
1904                 mi = ref->methodref->p.method;
1905                 container = mi->class;
1906                 goto resolved_the_method;
1907         }
1908
1909         /* first we must resolve the class containing the method */
1910
1911         if (!resolve_class_from_name(referer,ref->referermethod,
1912                                            ref->methodref->p.classref->name,mode,true,true,&container))
1913         {
1914                 /* the class reference could not be resolved */
1915                 return false; /* exception */
1916         }
1917         if (!container)
1918                 return true; /* be lazy */
1919
1920         assert(container);
1921         assert(container->state & CLASS_LINKED);
1922
1923         /* now we must find the declaration of the method in `container`
1924          * or one of its superclasses */
1925
1926         if (container->flags & ACC_INTERFACE) {
1927                 mi = class_resolveinterfacemethod(container,
1928                                                                               ref->methodref->name,
1929                                                                                   ref->methodref->descriptor,
1930                                                                               referer, true);
1931
1932         } else {
1933                 mi = class_resolveclassmethod(container,
1934                                                                           ref->methodref->name,
1935                                                                           ref->methodref->descriptor,
1936                                                                           referer, true);
1937         }
1938
1939         if (!mi) {
1940                 if (mode == resolveLazy) {
1941                         /* The method does not exist. But since we were called lazily, */
1942                         /* this error must not be reported now. (It will be reported   */
1943                         /* if eager resolving of this method is ever tried.)           */
1944
1945                         *exceptionptr = NULL;
1946                         return true; /* be lazy */
1947                 }
1948
1949                 return false; /* exception */ /* XXX set exceptionptr? */
1950         }
1951
1952         /* { the method reference has been resolved } */
1953
1954         if (ref->flags & RESOLVE_SPECIAL) {
1955                 mi = resolve_method_invokespecial_lookup(ref->referermethod,mi);
1956                 if (!mi)
1957                         return false; /* exception */
1958         }
1959
1960         /* have the method params already been parsed? no, do it. */
1961
1962         if (!mi->parseddesc->params)
1963                 if (!descriptor_params_from_paramtypes(mi->parseddesc, mi->flags))
1964                         return false;
1965
1966         /* cache the resolution */
1967
1968         ref->methodref->p.method = mi;
1969
1970 resolved_the_method:
1971
1972 #ifdef ENABLE_VERIFIER
1973         /* Checking opt_verify is ok here, because the NULL iptr guarantees */
1974         /* that no missing parts of an instruction will be accessed.        */
1975         if (opt_verify) {
1976
1977                 checkresult = resolve_method_verifier_checks(NULL,
1978                                 ref->referermethod,
1979                                 ref->methodref,
1980                                 container,
1981                                 mi,
1982                                 (ref->flags & RESOLVE_STATIC),
1983                                 (ref->flags & RESOLVE_SPECIAL),
1984                                 NULL);
1985
1986                 if (checkresult != resolveSucceeded)
1987                         return (bool) checkresult;
1988
1989                 /* impose loading constraints on params and return type */
1990
1991                 if (!resolve_method_loading_constraints(referer, mi))
1992                         return false;
1993
1994                 declarer = mi->class;
1995                 assert(declarer);
1996                 assert(referer->state & CLASS_LINKED);
1997
1998                 /* for non-static methods we have to check the constraints on the         */
1999                 /* instance type                                                          */
2000
2001                 if (!(ref->flags & RESOLVE_STATIC)) {
2002                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
2003                                         &(ref->instancetypes),
2004                                         CLASSREF_OR_CLASSINFO(container),
2005                                         mode,
2006                                         resolveLinkageError);
2007                         if (checkresult != resolveSucceeded)
2008                                 return (bool) checkresult;
2009                         instancecount = 1;
2010                 }
2011                 else {
2012                         instancecount = 0;
2013                 }
2014
2015                 /* check subtype constraints for TYPE_ADR parameters */
2016
2017                 assert(mi->parseddesc->paramcount == ref->methodref->parseddesc.md->paramcount);
2018                 paramtypes = mi->parseddesc->paramtypes;
2019
2020                 for (i = 0; i < mi->parseddesc->paramcount-instancecount; i++) {
2021                         if (paramtypes[i+instancecount].type == TYPE_ADR) {
2022                                 if (ref->paramconstraints) {
2023                                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
2024                                                         ref->paramconstraints + i,
2025                                                         CLASSREF_OR_CLASSINFO(paramtypes[i+instancecount].classref),
2026                                                         mode,
2027                                                         resolveLinkageError);
2028                                         if (checkresult != resolveSucceeded)
2029                                                 return (bool) checkresult;
2030                                 }
2031                         }
2032                 }
2033
2034                 /* check protected access */
2035
2036                 if (((mi->flags & ACC_PROTECTED) != 0) && !SAME_PACKAGE(declarer,referer))
2037                 {
2038                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
2039                                         &(ref->instancetypes),
2040                                         CLASSREF_OR_CLASSINFO(referer),
2041                                         mode,
2042                                         resolveIllegalAccessError);
2043                         if (checkresult != resolveSucceeded)
2044                                 return (bool) checkresult;
2045                 }
2046         }
2047 #endif /* ENABLE_VERIFIER */
2048
2049         /* succeed */
2050         *result = mi;
2051         return true;
2052 }
2053
2054 /* resolve_method_eager ********************************************************
2055
2056    Resolve an unresolved method reference eagerly.
2057
2058    IN:
2059        ref..............struct containing the reference
2060
2061    RETURN VALUE:
2062        methodinfo * to the method, or
2063            NULL if an exception has been thrown
2064
2065 *******************************************************************************/
2066
2067 methodinfo * resolve_method_eager(unresolved_method *ref)
2068 {
2069         methodinfo *mi;
2070
2071         if (!resolve_method(ref,resolveEager,&mi))
2072                 return NULL;
2073
2074         return mi;
2075 }
2076
2077 /******************************************************************************/
2078 /* CREATING THE DATA STRUCTURES                                               */
2079 /******************************************************************************/
2080
2081 #ifdef ENABLE_VERIFIER
2082 static bool unresolved_subtype_set_from_typeinfo(classinfo *referer,
2083                                                                                                  methodinfo *refmethod,
2084                                                                                                  unresolved_subtype_set *stset,
2085                                                                                                  typeinfo *tinfo,
2086                                                                                                  utf *declaredclassname)
2087 {
2088         int count;
2089         int i;
2090
2091         assert(stset);
2092         assert(tinfo);
2093
2094 #ifdef RESOLVE_VERBOSE
2095         printf("unresolved_subtype_set_from_typeinfo\n");
2096 #ifdef TYPEINFO_DEBUG
2097         typeinfo_print(stdout,tinfo,4);
2098 #endif
2099         printf("    declared classname:");utf_fprint_printable_ascii(stdout,declaredclassname);
2100         printf("\n");
2101 #endif
2102
2103         if (TYPEINFO_IS_PRIMITIVE(*tinfo)) {
2104                 exceptions_throw_verifyerror(refmethod,
2105                                 "Invalid use of returnAddress");
2106                 return false;
2107         }
2108
2109         if (TYPEINFO_IS_NEWOBJECT(*tinfo)) {
2110                 exceptions_throw_verifyerror(refmethod,
2111                                 "Invalid use of uninitialized object");
2112                 return false;
2113         }
2114
2115         /* the nulltype is always assignable */
2116         if (TYPEINFO_IS_NULLTYPE(*tinfo))
2117                 goto empty_set;
2118
2119         /* every type is assignable to (BOOTSTRAP)java.lang.Object */
2120         if (declaredclassname == utf_java_lang_Object
2121                         && referer->classloader == NULL) /* XXX do loading constraints make the second check obsolete? */
2122         {
2123                 goto empty_set;
2124         }
2125
2126         if (tinfo->merged) {
2127                 count = tinfo->merged->count;
2128                 stset->subtyperefs = MNEW(classref_or_classinfo,count + 1);
2129                 for (i=0; i<count; ++i) {
2130                         classref_or_classinfo c = tinfo->merged->list[i];
2131                         if (tinfo->dimension > 0) {
2132                                 /* a merge of array types */
2133                                 /* the merged list contains the possible _element_ types, */
2134                                 /* so we have to create array types with these elements.  */
2135                                 if (IS_CLASSREF(c)) {
2136                                         c.ref = class_get_classref_multiarray_of(tinfo->dimension,c.ref);
2137                                 }
2138                                 else {
2139                                         c.cls = class_multiarray_of(tinfo->dimension,c.cls,false);
2140                                 }
2141                         }
2142                         stset->subtyperefs[i] = c;
2143                 }
2144                 stset->subtyperefs[count].any = NULL; /* terminate */
2145         }
2146         else {
2147                 if ((IS_CLASSREF(tinfo->typeclass)
2148                                         ? tinfo->typeclass.ref->name
2149                                         : tinfo->typeclass.cls->name) == declaredclassname)
2150                 {
2151                         /* the class names are the same */
2152                     /* equality is guaranteed by the loading constraints */
2153                         goto empty_set;
2154                 }
2155                 else {
2156                         stset->subtyperefs = MNEW(classref_or_classinfo,1 + 1);
2157                         stset->subtyperefs[0] = tinfo->typeclass;
2158                         stset->subtyperefs[1].any = NULL; /* terminate */
2159                 }
2160         }
2161
2162         return true;
2163
2164 empty_set:
2165         UNRESOLVED_SUBTYPE_SET_EMTPY(*stset);
2166         return true;
2167 }
2168 #endif /* ENABLE_VERIFIER */
2169
2170 /* create_unresolved_class *****************************************************
2171
2172    Create an unresolved_class struct for the given class reference
2173
2174    IN:
2175            refmethod........the method triggering the resolution (if any)
2176            classref.........the class reference
2177            valuetype........value type to check against the resolved class
2178                                                 may be NULL, if no typeinfo is available
2179
2180    RETURN VALUE:
2181        a pointer to a new unresolved_class struct, or
2182            NULL if an exception has been thrown
2183
2184 *******************************************************************************/
2185
2186 #ifdef ENABLE_VERIFIER
2187 unresolved_class * create_unresolved_class(methodinfo *refmethod,
2188                                                                                    constant_classref *classref,
2189                                                                                    typeinfo *valuetype)
2190 {
2191         unresolved_class *ref;
2192
2193 #ifdef RESOLVE_VERBOSE
2194         printf("create_unresolved_class\n");
2195         printf("    referer: ");utf_fprint_printable_ascii(stdout,classref->referer->name);fputc('\n',stdout);
2196         if (refmethod) {
2197                 printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2198                 printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2199         }
2200         printf("    name   : ");utf_fprint_printable_ascii(stdout,classref->name);fputc('\n',stdout);
2201 #endif
2202
2203         ref = NEW(unresolved_class);
2204         ref->classref = classref;
2205         ref->referermethod = refmethod;
2206
2207         if (valuetype) {
2208                 if (!unresolved_subtype_set_from_typeinfo(classref->referer,refmethod,
2209                                         &(ref->subtypeconstraints),valuetype,classref->name))
2210                         return NULL;
2211         }
2212         else {
2213                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->subtypeconstraints);
2214         }
2215
2216         return ref;
2217 }
2218 #endif /* ENABLE_VERIFIER */
2219
2220 /* resolve_create_unresolved_field *********************************************
2221
2222    Create an unresolved_field struct for the given field access instruction
2223
2224    IN:
2225        referer..........the class containing the reference
2226            refmethod........the method triggering the resolution (if any)
2227            iptr.............the {GET,PUT}{FIELD,STATIC}{,CONST} instruction
2228
2229    RETURN VALUE:
2230        a pointer to a new unresolved_field struct, or
2231            NULL if an exception has been thrown
2232
2233 *******************************************************************************/
2234
2235 unresolved_field * resolve_create_unresolved_field(classinfo *referer,
2236                                                                                                    methodinfo *refmethod,
2237                                                                                                    instruction *iptr)
2238 {
2239         unresolved_field *ref;
2240         constant_FMIref *fieldref = NULL;
2241
2242 #ifdef RESOLVE_VERBOSE
2243         printf("create_unresolved_field\n");
2244         printf("    referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
2245         printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2246         printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2247 #endif
2248
2249         ref = NEW(unresolved_field);
2250         ref->flags = 0;
2251         ref->referermethod = refmethod;
2252         UNRESOLVED_SUBTYPE_SET_EMTPY(ref->valueconstraints);
2253
2254         switch (iptr->opc) {
2255                 case ICMD_PUTFIELD:
2256                         ref->flags |= RESOLVE_PUTFIELD;
2257                         break;
2258
2259                 case ICMD_PUTFIELDCONST:
2260                         ref->flags |= RESOLVE_PUTFIELD;
2261                         break;
2262
2263                 case ICMD_PUTSTATIC:
2264                         ref->flags |= RESOLVE_PUTFIELD | RESOLVE_STATIC;
2265                         break;
2266
2267                 case ICMD_PUTSTATICCONST:
2268                         ref->flags |= RESOLVE_PUTFIELD | RESOLVE_STATIC;
2269                         break;
2270
2271                 case ICMD_GETFIELD:
2272                         break;
2273
2274                 case ICMD_GETSTATIC:
2275                         ref->flags |= RESOLVE_STATIC;
2276                         break;
2277
2278 #if !defined(NDEBUG)
2279                 default:
2280                         assert(false);
2281 #endif
2282         }
2283
2284         fieldref = iptr->sx.s23.s3.fmiref;
2285
2286         assert(fieldref);
2287
2288 #ifdef RESOLVE_VERBOSE
2289 /*      printf("    class  : ");utf_fprint_printable_ascii(stdout,fieldref->p.classref->name);fputc('\n',stdout);*/
2290         printf("    name   : ");utf_fprint_printable_ascii(stdout,fieldref->name);fputc('\n',stdout);
2291         printf("    desc   : ");utf_fprint_printable_ascii(stdout,fieldref->descriptor);fputc('\n',stdout);
2292         printf("    type   : ");descriptor_debug_print_typedesc(stdout,fieldref->parseddesc.fd);
2293         fputc('\n',stdout);
2294         /*printf("    opcode : %d %s\n",iptr->opc,icmd_names[iptr->opc]);*/
2295 #endif
2296
2297         ref->fieldref = fieldref;
2298
2299         return ref;
2300 }
2301
2302 /* resolve_constrain_unresolved_field ******************************************
2303
2304    Record subtype constraints for a field access.
2305
2306    IN:
2307        ref..............the unresolved_field structure of the access
2308        referer..........the class containing the reference
2309            refmethod........the method triggering the resolution (if any)
2310            instanceti.......instance typeinfo, if available
2311            valueti..........value typeinfo, if available
2312
2313    RETURN VALUE:
2314        true.............everything ok
2315            false............an exception has been thrown
2316
2317 *******************************************************************************/
2318
2319 #if defined(ENABLE_VERIFIER)
2320 bool resolve_constrain_unresolved_field(unresolved_field *ref,
2321                                                                                 classinfo *referer,
2322                                                                                 methodinfo *refmethod,
2323                                                                             typeinfo *instanceti,
2324                                                                             typeinfo *valueti)
2325 {
2326         constant_FMIref *fieldref;
2327         int type;
2328         typeinfo tinfo;
2329         typedesc *fd;
2330
2331         assert(ref);
2332
2333         fieldref = ref->fieldref;
2334         assert(fieldref);
2335
2336 #ifdef RESOLVE_VERBOSE
2337         printf("constrain_unresolved_field\n");
2338         printf("    referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
2339         printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2340         printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2341 /*      printf("    class  : ");utf_fprint_printable_ascii(stdout,fieldref->p.classref->name);fputc('\n',stdout); */
2342         printf("    name   : ");utf_fprint_printable_ascii(stdout,fieldref->name);fputc('\n',stdout);
2343         printf("    desc   : ");utf_fprint_printable_ascii(stdout,fieldref->descriptor);fputc('\n',stdout);
2344         printf("    type   : ");descriptor_debug_print_typedesc(stdout,fieldref->parseddesc.fd);
2345         fputc('\n',stdout);
2346         /*printf("    opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
2347 #endif
2348
2349         assert(instanceti || ((ref->flags & RESOLVE_STATIC) != 0));
2350         fd = fieldref->parseddesc.fd;
2351         assert(fd);
2352
2353         /* record subtype constraints for the instance type, if any */
2354         if (instanceti) {
2355                 typeinfo *insttip;
2356
2357                 /* The instanceslot must contain a reference to a non-array type */
2358                 if (!TYPEINFO_IS_REFERENCE(*instanceti)) {
2359                         exceptions_throw_verifyerror(refmethod,
2360                                         "illegal instruction: field access on non-reference");
2361                         return false;
2362                 }
2363                 if (TYPEINFO_IS_ARRAY(*instanceti)) {
2364                         exceptions_throw_verifyerror(refmethod,
2365                                         "illegal instruction: field access on array");
2366                         return false;
2367                 }
2368
2369                 if (((ref->flags & RESOLVE_PUTFIELD) != 0) &&
2370                                 TYPEINFO_IS_NEWOBJECT(*instanceti))
2371                 {
2372                         /* The instruction writes a field in an uninitialized object. */
2373                         /* This is only allowed when a field of an uninitialized 'this' object is */
2374                         /* written inside an initialization method                                */
2375
2376                         classinfo *initclass;
2377                         instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
2378
2379                         if (ins != NULL) {
2380                                 exceptions_throw_verifyerror(refmethod,
2381                                                 "accessing field of uninitialized object");
2382                                 return false;
2383                         }
2384                         /* XXX check that class of field == refmethod->class */
2385                         initclass = refmethod->class; /* XXX classrefs */
2386                         assert(initclass->state & CLASS_LOADED);
2387                         assert(initclass->state & CLASS_LINKED);
2388
2389                         typeinfo_init_classinfo(&tinfo, initclass);
2390                         insttip = &tinfo;
2391                 }
2392                 else {
2393                         insttip = instanceti;
2394                 }
2395                 if (!unresolved_subtype_set_from_typeinfo(referer, refmethod,
2396                                         &(ref->instancetypes), insttip,
2397                                         FIELDREF_CLASSNAME(fieldref)))
2398                         return false;
2399         }
2400         else {
2401                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->instancetypes);
2402         }
2403
2404         /* record subtype constraints for the value type, if any */
2405         type = fd->type;
2406         if (type == TYPE_ADR && ((ref->flags & RESOLVE_PUTFIELD) != 0)) {
2407                 assert(valueti);
2408                 if (!unresolved_subtype_set_from_typeinfo(referer, refmethod,
2409                                         &(ref->valueconstraints), valueti,
2410                                         fieldref->parseddesc.fd->classref->name))
2411                         return false;
2412         }
2413         else {
2414                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->valueconstraints);
2415         }
2416
2417         return true;
2418 }
2419 #endif /* ENABLE_VERIFIER */
2420
2421 /* resolve_create_unresolved_method ********************************************
2422
2423    Create an unresolved_method struct for the given method invocation
2424
2425    IN:
2426        referer..........the class containing the reference
2427            refmethod........the method triggering the resolution (if any)
2428            iptr.............the INVOKE* instruction
2429
2430    RETURN VALUE:
2431        a pointer to a new unresolved_method struct, or
2432            NULL if an exception has been thrown
2433
2434 *******************************************************************************/
2435
2436 unresolved_method * resolve_create_unresolved_method(classinfo *referer,
2437                                                                                                          methodinfo *refmethod,
2438                                                                                                          constant_FMIref *methodref,
2439                                                                                                          bool invokestatic,
2440                                                                                                          bool invokespecial)
2441 {
2442         unresolved_method *ref;
2443
2444         assert(methodref);
2445
2446 #ifdef RESOLVE_VERBOSE
2447         printf("create_unresolved_method\n");
2448         printf("    referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
2449         printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2450         printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2451         printf("    name   : ");utf_fprint_printable_ascii(stdout,methodref->name);fputc('\n',stdout);
2452         printf("    desc   : ");utf_fprint_printable_ascii(stdout,methodref->descriptor);fputc('\n',stdout);
2453 #endif
2454
2455         /* allocate params if necessary */
2456         if (!methodref->parseddesc.md->params)
2457                 if (!descriptor_params_from_paramtypes(methodref->parseddesc.md,
2458                                         (invokestatic) ? ACC_STATIC : ACC_NONE))
2459                         return NULL;
2460
2461         /* create the data structure */
2462         ref = NEW(unresolved_method);
2463         ref->flags = ((invokestatic) ? RESOLVE_STATIC : 0)
2464                            | ((invokespecial) ? RESOLVE_SPECIAL : 0);
2465         ref->referermethod = refmethod;
2466         ref->methodref = methodref;
2467         ref->paramconstraints = NULL;
2468         UNRESOLVED_SUBTYPE_SET_EMTPY(ref->instancetypes);
2469
2470         return ref;
2471 }
2472
2473 /* constrain_unresolved_method *********************************************
2474
2475    Record subtype constraints for the arguments of a method call.
2476
2477    IN:
2478        ref..............the unresolved_method structure of the call
2479        referer..........the class containing the reference
2480            refmethod........the method triggering the resolution (if any)
2481            iptr.............the INVOKE* instruction
2482
2483    RETURN VALUE:
2484        true.............everything ok
2485            false............an exception has been thrown
2486
2487 *******************************************************************************/
2488
2489 #ifdef ENABLE_VERIFIER
2490 bool constrain_unresolved_method(jitdata *jd,
2491                                                                          unresolved_method *ref,
2492                                                                          classinfo *referer, methodinfo *refmethod,
2493                                                                          instruction *iptr)
2494 {
2495         constant_FMIref *methodref;
2496         constant_classref *instanceref;
2497         varinfo *instanceslot = NULL;
2498         varinfo *param;
2499         methoddesc *md;
2500         typeinfo tinfo;
2501         int i,j;
2502         int type;
2503         int instancecount;
2504
2505         assert(ref);
2506         methodref = ref->methodref;
2507         assert(methodref);
2508         md = methodref->parseddesc.md;
2509         assert(md);
2510         assert(md->params != NULL);
2511
2512         /* XXX clean this up */
2513         instanceref = IS_FMIREF_RESOLVED(methodref)
2514                 ? class_get_self_classref(methodref->p.method->class)
2515                 : methodref->p.classref;
2516
2517 #ifdef RESOLVE_VERBOSE
2518         printf("constrain_unresolved_method\n");
2519         printf("    referer: "); class_println(referer);
2520         printf("    rmethod: "); method_println(refmethod);
2521         printf("    mref   : "); method_methodref_println(methodref);
2522         /*printf("    opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
2523 #endif
2524
2525         if ((ref->flags & RESOLVE_STATIC) == 0) {
2526                 /* find the instance slot under all the parameter slots on the stack */
2527                 instanceslot = VAR(iptr->sx.s23.s2.args[0]);
2528                 instancecount = 1;
2529         }
2530         else {
2531                 instancecount = 0;
2532         }
2533
2534         assert((instanceslot && instancecount==1) || ((ref->flags & RESOLVE_STATIC) != 0));
2535
2536         /* record subtype constraints for the instance type, if any */
2537         if (instanceslot) {
2538                 typeinfo *tip;
2539
2540                 assert(instanceslot->type == TYPE_ADR);
2541
2542                 if (iptr[0].opc == ICMD_INVOKESPECIAL &&
2543                                 TYPEINFO_IS_NEWOBJECT(instanceslot->typeinfo))
2544                 {   /* XXX clean up */
2545                         instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
2546                         classref_or_classinfo initclass = (ins) ? ins[-1].sx.val.c
2547                                                                                  : CLASSREF_OR_CLASSINFO(refmethod->class);
2548                         tip = &tinfo;
2549                         if (!typeinfo_init_class(tip,initclass))
2550                                 return false;
2551                 }
2552                 else {
2553                         tip = &(instanceslot->typeinfo);
2554                 }
2555                 if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
2556                                         &(ref->instancetypes),tip,instanceref->name))
2557                         return false;
2558         }
2559
2560         /* record subtype constraints for the parameter types, if any */
2561         for (i=md->paramcount-1-instancecount; i>=0; --i) {
2562                 param = VAR(iptr->sx.s23.s2.args[i+instancecount]);
2563                 type = md->paramtypes[i+instancecount].type;
2564
2565                 assert(param);
2566                 assert(type == param->type);
2567
2568                 if (type == TYPE_ADR) {
2569                         if (!ref->paramconstraints) {
2570                                 ref->paramconstraints = MNEW(unresolved_subtype_set,md->paramcount);
2571                                 for (j=md->paramcount-1-instancecount; j>i; --j)
2572                                         UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[j]);
2573                         }
2574                         assert(ref->paramconstraints);
2575                         if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
2576                                                 ref->paramconstraints + i,&(param->typeinfo),
2577                                                 md->paramtypes[i+instancecount].classref->name))
2578                                 return false;
2579                 }
2580                 else {
2581                         if (ref->paramconstraints)
2582                                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[i]);
2583                 }
2584         }
2585
2586         return true;
2587 }
2588 #endif /* ENABLE_VERIFIER */
2589
2590 /******************************************************************************/
2591 /* FREEING MEMORY                                                             */
2592 /******************************************************************************/
2593
2594 #ifdef ENABLE_VERIFIER
2595 inline static void unresolved_subtype_set_free_list(classref_or_classinfo *list)
2596 {
2597         if (list) {
2598                 classref_or_classinfo *p = list;
2599
2600                 /* this is silly. we *only* need to count the elements for MFREE */
2601                 while ((p++)->any)
2602                         ;
2603                 MFREE(list,classref_or_classinfo,(p - list));
2604         }
2605 }
2606 #endif /* ENABLE_VERIFIER */
2607
2608 /* unresolved_class_free *******************************************************
2609
2610    Free the memory used by an unresolved_class
2611
2612    IN:
2613        ref..............the unresolved_class
2614
2615 *******************************************************************************/
2616
2617 void unresolved_class_free(unresolved_class *ref)
2618 {
2619         assert(ref);
2620
2621 #ifdef ENABLE_VERIFIER
2622         unresolved_subtype_set_free_list(ref->subtypeconstraints.subtyperefs);
2623 #endif
2624         FREE(ref,unresolved_class);
2625 }
2626
2627 /* unresolved_field_free *******************************************************
2628
2629    Free the memory used by an unresolved_field
2630
2631    IN:
2632        ref..............the unresolved_field
2633
2634 *******************************************************************************/
2635
2636 void unresolved_field_free(unresolved_field *ref)
2637 {
2638         assert(ref);
2639
2640 #ifdef ENABLE_VERIFIER
2641         unresolved_subtype_set_free_list(ref->instancetypes.subtyperefs);
2642         unresolved_subtype_set_free_list(ref->valueconstraints.subtyperefs);
2643 #endif
2644         FREE(ref,unresolved_field);
2645 }
2646
2647 /* unresolved_method_free ******************************************************
2648
2649    Free the memory used by an unresolved_method
2650
2651    IN:
2652        ref..............the unresolved_method
2653
2654 *******************************************************************************/
2655
2656 void unresolved_method_free(unresolved_method *ref)
2657 {
2658         assert(ref);
2659
2660 #ifdef ENABLE_VERIFIER
2661         unresolved_subtype_set_free_list(ref->instancetypes.subtyperefs);
2662         if (ref->paramconstraints) {
2663                 int i;
2664                 int count = ref->methodref->parseddesc.md->paramcount;
2665
2666                 for (i=0; i<count; ++i)
2667                         unresolved_subtype_set_free_list(ref->paramconstraints[i].subtyperefs);
2668                 MFREE(ref->paramconstraints,unresolved_subtype_set,count);
2669         }
2670 #endif
2671         FREE(ref,unresolved_method);
2672 }
2673
2674 /******************************************************************************/
2675 /* DEBUG DUMPS                                                                */
2676 /******************************************************************************/
2677
2678 #if !defined(NDEBUG)
2679
2680 /* unresolved_subtype_set_debug_dump *******************************************
2681
2682    Print debug info for unresolved_subtype_set to stream
2683
2684    IN:
2685        stset............the unresolved_subtype_set
2686            file.............the stream
2687
2688 *******************************************************************************/
2689
2690 void unresolved_subtype_set_debug_dump(unresolved_subtype_set *stset,FILE *file)
2691 {
2692         classref_or_classinfo *p;
2693
2694         if (SUBTYPESET_IS_EMPTY(*stset)) {
2695                 fprintf(file,"        (empty)\n");
2696         }
2697         else {
2698                 p = stset->subtyperefs;
2699                 for (;p->any; ++p) {
2700                         if (IS_CLASSREF(*p)) {
2701                                 fprintf(file,"        ref: ");
2702                                 utf_fprint_printable_ascii(file,p->ref->name);
2703                         }
2704                         else {
2705                                 fprintf(file,"        cls: ");
2706                                 utf_fprint_printable_ascii(file,p->cls->name);
2707                         }
2708                         fputc('\n',file);
2709                 }
2710         }
2711 }
2712
2713 /* unresolved_class_debug_dump *************************************************
2714
2715    Print debug info for unresolved_class to stream
2716
2717    IN:
2718        ref..............the unresolved_class
2719            file.............the stream
2720
2721 *******************************************************************************/
2722
2723 void unresolved_class_debug_dump(unresolved_class *ref,FILE *file)
2724 {
2725         fprintf(file,"unresolved_class(%p):\n",(void *)ref);
2726         if (ref) {
2727                 fprintf(file,"    referer   : ");
2728                 utf_fprint_printable_ascii(file,ref->classref->referer->name); fputc('\n',file);
2729                 fprintf(file,"    refmethod : ");
2730                 utf_fprint_printable_ascii(file,ref->referermethod->name); fputc('\n',file);
2731                 fprintf(file,"    refmethodd: ");
2732                 utf_fprint_printable_ascii(file,ref->referermethod->descriptor); fputc('\n',file);
2733                 fprintf(file,"    classname : ");
2734                 utf_fprint_printable_ascii(file,ref->classref->name); fputc('\n',file);
2735                 fprintf(file,"    subtypeconstraints:\n");
2736                 unresolved_subtype_set_debug_dump(&(ref->subtypeconstraints),file);
2737         }
2738 }
2739
2740 /* unresolved_field_debug_dump *************************************************
2741
2742    Print debug info for unresolved_field to stream
2743
2744    IN:
2745        ref..............the unresolved_field
2746            file.............the stream
2747
2748 *******************************************************************************/
2749
2750 void unresolved_field_debug_dump(unresolved_field *ref,FILE *file)
2751 {
2752         fprintf(file,"unresolved_field(%p):\n",(void *)ref);
2753         if (ref) {
2754                 fprintf(file,"    referer   : ");
2755                 utf_fprint_printable_ascii(file,ref->referermethod->class->name); fputc('\n',file);
2756                 fprintf(file,"    refmethod : ");
2757                 utf_fprint_printable_ascii(file,ref->referermethod->name); fputc('\n',file);
2758                 fprintf(file,"    refmethodd: ");
2759                 utf_fprint_printable_ascii(file,ref->referermethod->descriptor); fputc('\n',file);
2760                 fprintf(file,"    classname : ");
2761                 utf_fprint_printable_ascii(file,FIELDREF_CLASSNAME(ref->fieldref)); fputc('\n',file);
2762                 fprintf(file,"    name      : ");
2763                 utf_fprint_printable_ascii(file,ref->fieldref->name); fputc('\n',file);
2764                 fprintf(file,"    descriptor: ");
2765                 utf_fprint_printable_ascii(file,ref->fieldref->descriptor); fputc('\n',file);
2766                 fprintf(file,"    parseddesc: ");
2767                 descriptor_debug_print_typedesc(file,ref->fieldref->parseddesc.fd); fputc('\n',file);
2768                 fprintf(file,"    flags     : %04x\n",ref->flags);
2769                 fprintf(file,"    instancetypes:\n");
2770                 unresolved_subtype_set_debug_dump(&(ref->instancetypes),file);
2771                 fprintf(file,"    valueconstraints:\n");
2772                 unresolved_subtype_set_debug_dump(&(ref->valueconstraints),file);
2773         }
2774 }
2775
2776 /* unresolved_method_debug_dump ************************************************
2777
2778    Print debug info for unresolved_method to stream
2779
2780    IN:
2781        ref..............the unresolved_method
2782            file.............the stream
2783
2784 *******************************************************************************/
2785
2786 void unresolved_method_debug_dump(unresolved_method *ref,FILE *file)
2787 {
2788         int i;
2789
2790         fprintf(file,"unresolved_method(%p):\n",(void *)ref);
2791         if (ref) {
2792                 fprintf(file,"    referer   : ");
2793                 utf_fprint_printable_ascii(file,ref->referermethod->class->name); fputc('\n',file);
2794                 fprintf(file,"    refmethod : ");
2795                 utf_fprint_printable_ascii(file,ref->referermethod->name); fputc('\n',file);
2796                 fprintf(file,"    refmethodd: ");
2797                 utf_fprint_printable_ascii(file,ref->referermethod->descriptor); fputc('\n',file);
2798                 fprintf(file,"    classname : ");
2799                 utf_fprint_printable_ascii(file,METHODREF_CLASSNAME(ref->methodref)); fputc('\n',file);
2800                 fprintf(file,"    name      : ");
2801                 utf_fprint_printable_ascii(file,ref->methodref->name); fputc('\n',file);
2802                 fprintf(file,"    descriptor: ");
2803                 utf_fprint_printable_ascii(file,ref->methodref->descriptor); fputc('\n',file);
2804                 fprintf(file,"    parseddesc: ");
2805                 descriptor_debug_print_methoddesc(file,ref->methodref->parseddesc.md); fputc('\n',file);
2806                 fprintf(file,"    flags     : %04x\n",ref->flags);
2807                 fprintf(file,"    instancetypes:\n");
2808                 unresolved_subtype_set_debug_dump(&(ref->instancetypes),file);
2809                 fprintf(file,"    paramconstraints:\n");
2810                 if (ref->paramconstraints) {
2811                         for (i=0; i<ref->methodref->parseddesc.md->paramcount; ++i) {
2812                                 fprintf(file,"      param %d:\n",i);
2813                                 unresolved_subtype_set_debug_dump(ref->paramconstraints + i,file);
2814                         }
2815                 }
2816                 else {
2817                         fprintf(file,"      (empty)\n");
2818                 }
2819         }
2820 }
2821 #endif /* !defined(NDEBUG) */
2822
2823 /*
2824  * These are local overrides for various environment variables in Emacs.
2825  * Please do not remove this and leave it at the end of the file, where
2826  * Emacs will automagically detect them.
2827  * ---------------------------------------------------------------------
2828  * Local variables:
2829  * mode: c
2830  * indent-tabs-mode: t
2831  * c-basic-offset: 4
2832  * tab-width: 4
2833  * End:
2834  * vim:noexpandtab:sw=4:ts=4:
2835  */
2836