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 5729 2006-10-09 23:53:42Z 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            mi...............the methodinfo of the resolved method
1462            invokestatic.....true if the method is invoked by INVOKESTATIC
1463
1464    RETURN VALUE:
1465        resolveSucceeded....everything ok
1466            resolveDeferred.....tests could not be done, have been deferred
1467        resolveFailed.......exception has been thrown
1468
1469 *******************************************************************************/
1470
1471 #if defined(ENABLE_VERIFIER)
1472 resolve_result_t resolve_method_verifier_checks(methodinfo *refmethod,
1473                                                                                                 constant_FMIref *methodref,
1474                                                                                                 methodinfo *mi,
1475                                                                                                 bool invokestatic)
1476 {
1477         classinfo *declarer;
1478         classinfo *referer;
1479
1480         assert(refmethod);
1481         assert(methodref);
1482         assert(mi);
1483
1484 #ifdef RESOLVE_VERBOSE
1485         printf("resolve_method_verifier_checks\n");
1486         printf("    flags: %02x\n",mi->flags);
1487 #endif
1488
1489         /* get the classinfos and the method descriptor */
1490
1491         referer = refmethod->class;
1492         assert(referer);
1493
1494         declarer = mi->class;
1495         assert(declarer);
1496
1497         /* check static */
1498
1499         if (((mi->flags & ACC_STATIC) != 0) != (invokestatic != false)) {
1500                 /* a static method is accessed via an instance, or vice versa */
1501                 *exceptionptr =
1502                         new_exception_message(string_java_lang_IncompatibleClassChangeError,
1503                                 (mi->flags & ACC_STATIC) ? "static method called via instance"
1504                                                          : "instance method called without instance");
1505                 return resolveFailed;
1506         }
1507
1508         /* check access rights */
1509
1510         if (!access_is_accessible_member(referer,declarer,mi->flags)) {
1511                 int msglen;
1512                 char *message;
1513
1514                 /* XXX clean this up. this should be in exceptions.c */
1515                 msglen = utf_bytes(declarer->name) + utf_bytes(mi->name) +
1516                         utf_bytes(mi->descriptor) + utf_bytes(referer->name) + 100;
1517                 message = MNEW(char, msglen);
1518                 strcpy(message, "method is not accessible (");
1519                 utf_cat_classname(message, declarer->name);
1520                 strcat(message, ".");
1521                 utf_cat(message, mi->name);
1522                 utf_cat(message, mi->descriptor);
1523                 strcat(message," from ");
1524                 utf_cat_classname(message, referer->name);
1525                 strcat(message,")");
1526                 *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException, message);
1527                 MFREE(message, char, msglen);
1528                 return resolveFailed; /* exception */
1529         }
1530
1531         /* everything ok */
1532
1533         return resolveSucceeded;
1534 }
1535 #endif /* defined(ENABLE_VERIFIER) */
1536
1537
1538 /* resolve_method_instance_type_checks *****************************************
1539
1540    Check the instance type of a method invocation.
1541
1542    IN:
1543        refmethod........the method containing the reference
1544            mi...............the methodinfo of the resolved method
1545            instanceti.......typeinfo of the instance slot
1546            invokespecial....true if the method is invoked by INVOKESPECIAL
1547
1548    RETURN VALUE:
1549        resolveSucceeded....everything ok
1550            resolveDeferred.....tests could not be done, have been deferred
1551        resolveFailed.......exception has been thrown
1552
1553 *******************************************************************************/
1554
1555 #if defined(ENABLE_VERIFIER)
1556 resolve_result_t resolve_method_instance_type_checks(methodinfo *refmethod,
1557                                                                                                          methodinfo *mi,
1558                                                                                                          typeinfo *instanceti,
1559                                                                                                          bool invokespecial)
1560 {
1561         typeinfo         tinfo;
1562         typeinfo        *tip;
1563         resolve_result_t result;
1564
1565         if (invokespecial && TYPEINFO_IS_NEWOBJECT(*instanceti))
1566         {   /* XXX clean up */
1567                 instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
1568                 classref_or_classinfo initclass = (ins) ? ins[-1].sx.val.c
1569                                                                          : CLASSREF_OR_CLASSINFO(refmethod->class);
1570                 tip = &tinfo;
1571                 if (!typeinfo_init_class(tip, initclass))
1572                         return false;
1573         }
1574         else {
1575                 tip = instanceti;
1576         }
1577
1578         result = resolve_lazy_subtype_checks(refmethod,
1579                                                                                  tip,
1580                                                                                  CLASSREF_OR_CLASSINFO(mi->class),
1581                                                                                  resolveLinkageError);
1582         if (result != resolveSucceeded)
1583                 return result;
1584
1585         /* check protected access */
1586
1587         /* XXX use other `declarer` than mi->class? */
1588         if (((mi->flags & ACC_PROTECTED) != 0)
1589                         && !SAME_PACKAGE(mi->class, refmethod->class))
1590         {
1591                 result = resolve_lazy_subtype_checks(refmethod,
1592                                 tip,
1593                                 CLASSREF_OR_CLASSINFO(refmethod->class),
1594                                 resolveIllegalAccessError);
1595                 if (result != resolveSucceeded)
1596                         return result;
1597         }
1598
1599         /* everything ok */
1600
1601         return resolveSucceeded;
1602 }
1603 #endif /* defined(ENABLE_VERIFIER) */
1604
1605
1606 /* resolve_method_param_type_checks ********************************************
1607
1608    Check non-instance parameter types of a method invocation.
1609
1610    IN:
1611            jd...............jitdata of the method doing the call
1612        refmethod........the method containing the reference
1613            iptr.............the invoke instruction
1614            mi...............the methodinfo of the resolved method
1615            invokestatic.....true if the method is invoked by INVOKESTATIC
1616
1617    RETURN VALUE:
1618        resolveSucceeded....everything ok
1619            resolveDeferred.....tests could not be done, have been deferred
1620        resolveFailed.......exception has been thrown
1621
1622 *******************************************************************************/
1623
1624 #if defined(ENABLE_VERIFIER)
1625 resolve_result_t resolve_method_param_type_checks(jitdata *jd,
1626                                                                                                   methodinfo *refmethod,
1627                                                                                                   instruction *iptr,
1628                                                                                                   methodinfo *mi,
1629                                                                                                   bool invokestatic)
1630 {
1631         varinfo         *param;
1632         resolve_result_t result;
1633         methoddesc      *md;
1634         typedesc        *paramtypes;
1635         s4               type;
1636         s4               instancecount;
1637         s4               i;
1638
1639         assert(jd);
1640
1641         instancecount = (invokestatic) ? 0 : 1;
1642
1643         /* check subtype constraints for TYPE_ADR parameters */
1644
1645         md = mi->parseddesc;
1646         paramtypes = md->paramtypes;
1647
1648         for (i = md->paramcount-1-instancecount; i>=0; --i) {
1649                 param = VAR(iptr->sx.s23.s2.args[i+instancecount]);
1650                 type = md->paramtypes[i+instancecount].type;
1651
1652                 assert(param);
1653                 assert(type == param->type);
1654
1655                 if (type == TYPE_ADR) {
1656                         result = resolve_lazy_subtype_checks(refmethod,
1657                                         &(param->typeinfo),
1658                                         CLASSREF_OR_CLASSINFO(paramtypes[i+instancecount].classref),
1659                                         resolveLinkageError);
1660                         if (result != resolveSucceeded)
1661                                 return result;
1662                 }
1663         }
1664
1665         /* everything ok */
1666
1667         return resolveSucceeded;
1668 }
1669 #endif /* defined(ENABLE_VERIFIER) */
1670
1671
1672 /* resolve_method_loading_constraints ******************************************
1673
1674    Impose loading constraints on the parameters and return type of the
1675    given method.
1676
1677    IN:
1678        referer..........the class refering to the method
1679            mi...............the method
1680
1681    RETURN VALUE:
1682        true................everything ok
1683            false...............an exception has been thrown
1684
1685 *******************************************************************************/
1686
1687 #if defined(ENABLE_VERIFIER)
1688 bool resolve_method_loading_constraints(classinfo *referer,
1689                                                                                 methodinfo *mi)
1690 {
1691         methoddesc *md;
1692         typedesc   *paramtypes;
1693         utf        *name;
1694         s4          i;
1695         s4          instancecount;
1696
1697         /* impose loading constraints on parameters (including instance) */
1698
1699         md = mi->parseddesc;
1700         paramtypes = md->paramtypes;
1701         instancecount = (mi->flags & ACC_STATIC) / ACC_STATIC;
1702
1703         for (i = 0; i < md->paramcount; i++) {
1704                 if (i < instancecount || paramtypes[i].type == TYPE_ADR) {
1705                         if (i < instancecount) {
1706                                 /* The type of the 'this' pointer is the class containing */
1707                                 /* the method definition. Since container is the same as, */
1708                                 /* or a subclass of declarer, we also constrain declarer  */
1709                                 /* by transitivity of loading constraints.                */
1710                                 name = mi->class->name;
1711                         }
1712                         else {
1713                                 name = paramtypes[i].classref->name;
1714                         }
1715
1716                         /* The caller (referer) and the callee (container) must agree */
1717                         /* on the types of the parameters.                            */
1718                         if (!classcache_add_constraint(referer->classloader,
1719                                                                                    mi->class->classloader, name))
1720                                 return false; /* exception */
1721                 }
1722         }
1723
1724         /* impose loading constraint onto return type */
1725
1726         if (md->returntype.type == TYPE_ADR) {
1727                 /* The caller (referer) and the callee (container) must agree */
1728                 /* on the return type.                                        */
1729                 if (!classcache_add_constraint(referer->classloader,
1730                                         mi->class->classloader,
1731                                         md->returntype.classref->name))
1732                         return false; /* exception */
1733         }
1734
1735         /* everything ok */
1736
1737         return true;
1738 }
1739 #endif /* defined(ENABLE_VERIFIER) */
1740
1741
1742 /* resolve_method_lazy *********************************************************
1743
1744    Resolve an unresolved method reference lazily
1745
1746    NOTE: This function does NOT do any verification checks. In case of a
1747          successful resolution, you must call resolve_method_verifier_checks
1748                  in order to perform the necessary checks!
1749
1750    IN:
1751            refmethod........the referer method
1752            methodref........the method reference
1753            invokespecial....true if this is an INVOKESPECIAL instruction
1754
1755    RETURN VALUE:
1756        resolveSucceeded.....the reference has been resolved
1757        resolveDeferred......the resolving could not be performed lazily
1758            resolveFailed........resolving failed, an exception has been thrown.
1759
1760 *******************************************************************************/
1761
1762 resolve_result_t resolve_method_lazy(methodinfo *refmethod,
1763                                                                          constant_FMIref *methodref,
1764                                                                          bool invokespecial)
1765 {
1766         classinfo *referer;
1767         classinfo *container;
1768         methodinfo *mi;
1769
1770         assert(refmethod);
1771
1772 #ifdef RESOLVE_VERBOSE
1773         printf("resolve_method_lazy\n");
1774 #endif
1775
1776         /* the class containing the reference */
1777
1778         referer = refmethod->class;
1779         assert(referer);
1780
1781         /* check if the method itself is already resolved */
1782
1783         if (IS_FMIREF_RESOLVED(methodref))
1784                 return resolveSucceeded;
1785
1786         /* first we must resolve the class containg the method */
1787
1788         if (!resolve_class_from_name(referer, refmethod,
1789                    methodref->p.classref->name, resolveLazy, true, true, &container))
1790         {
1791                 /* the class reference could not be resolved */
1792                 return resolveFailed; /* exception */
1793         }
1794         if (!container)
1795                 return resolveDeferred; /* be lazy */
1796
1797         assert(container->state & CLASS_LINKED);
1798
1799         /* now we must find the declaration of the method in `container`
1800          * or one of its superclasses */
1801
1802         if (container->flags & ACC_INTERFACE) {
1803                 mi = class_resolveinterfacemethod(container,
1804                                                                               methodref->name,
1805                                                                                   methodref->descriptor,
1806                                                                               referer, true);
1807
1808         } else {
1809                 mi = class_resolveclassmethod(container,
1810                                                                           methodref->name,
1811                                                                           methodref->descriptor,
1812                                                                           referer, true);
1813         }
1814
1815         if (!mi) {
1816                 /* The method does not exist. But since we were called lazily, */
1817                 /* this error must not be reported now. (It will be reported   */
1818                 /* if eager resolving of this method is ever tried.)           */
1819
1820                 *exceptionptr = NULL;
1821                 return resolveDeferred; /* be lazy */
1822         }
1823
1824         if (invokespecial) {
1825                 mi = resolve_method_invokespecial_lookup(refmethod, mi);
1826                 if (!mi)
1827                         return resolveFailed; /* exception */
1828         }
1829
1830         /* have the method params already been parsed? no, do it. */
1831
1832         if (!mi->parseddesc->params)
1833                 if (!descriptor_params_from_paramtypes(mi->parseddesc, mi->flags))
1834                         return resolveFailed;
1835
1836         /* cache the result of the resolution */
1837
1838         methodref->p.method = mi;
1839
1840         /* succeed */
1841
1842         return resolveSucceeded;
1843 }
1844
1845 /* resolve_method **************************************************************
1846
1847    Resolve an unresolved method reference
1848
1849    IN:
1850        ref..............struct containing the reference
1851        mode.............mode of resolution:
1852                             resolveLazy...only resolve if it does not
1853                                           require loading classes
1854                             resolveEager..load classes if necessary
1855
1856    OUT:
1857        *result..........set to the result of resolution, or to NULL if
1858                         the reference has not been resolved
1859                         In the case of an exception, *result is
1860                         guaranteed to be set to NULL.
1861
1862    RETURN VALUE:
1863        true.............everything ok
1864                         (*result may still be NULL for resolveLazy)
1865        false............an exception has been thrown
1866
1867 *******************************************************************************/
1868
1869 bool resolve_method(unresolved_method *ref, resolve_mode_t mode, methodinfo **result)
1870 {
1871         classinfo *referer;
1872         classinfo *container;
1873         classinfo *declarer;
1874         methodinfo *mi;
1875         typedesc *paramtypes;
1876         int instancecount;
1877         int i;
1878         resolve_result_t checkresult;
1879
1880         assert(ref);
1881         assert(result);
1882         assert(mode == resolveLazy || mode == resolveEager);
1883
1884 #ifdef RESOLVE_VERBOSE
1885         unresolved_method_debug_dump(ref,stdout);
1886 #endif
1887
1888         *result = NULL;
1889
1890         /* the class containing the reference */
1891
1892         referer = ref->referermethod->class;
1893         assert(referer);
1894
1895         /* check if the method itself is already resolved */
1896
1897         if (IS_FMIREF_RESOLVED(ref->methodref)) {
1898                 mi = ref->methodref->p.method;
1899                 container = mi->class;
1900                 goto resolved_the_method;
1901         }
1902
1903         /* first we must resolve the class containing the method */
1904
1905         if (!resolve_class_from_name(referer,ref->referermethod,
1906                                            ref->methodref->p.classref->name,mode,true,true,&container))
1907         {
1908                 /* the class reference could not be resolved */
1909                 return false; /* exception */
1910         }
1911         if (!container)
1912                 return true; /* be lazy */
1913
1914         assert(container);
1915         assert(container->state & CLASS_LINKED);
1916
1917         /* now we must find the declaration of the method in `container`
1918          * or one of its superclasses */
1919
1920         if (container->flags & ACC_INTERFACE) {
1921                 mi = class_resolveinterfacemethod(container,
1922                                                                               ref->methodref->name,
1923                                                                                   ref->methodref->descriptor,
1924                                                                               referer, true);
1925
1926         } else {
1927                 mi = class_resolveclassmethod(container,
1928                                                                           ref->methodref->name,
1929                                                                           ref->methodref->descriptor,
1930                                                                           referer, true);
1931         }
1932
1933         if (!mi) {
1934                 if (mode == resolveLazy) {
1935                         /* The method does not exist. But since we were called lazily, */
1936                         /* this error must not be reported now. (It will be reported   */
1937                         /* if eager resolving of this method is ever tried.)           */
1938
1939                         *exceptionptr = NULL;
1940                         return true; /* be lazy */
1941                 }
1942
1943                 return false; /* exception */ /* XXX set exceptionptr? */
1944         }
1945
1946         /* { the method reference has been resolved } */
1947
1948         if (ref->flags & RESOLVE_SPECIAL) {
1949                 mi = resolve_method_invokespecial_lookup(ref->referermethod,mi);
1950                 if (!mi)
1951                         return false; /* exception */
1952         }
1953
1954         /* have the method params already been parsed? no, do it. */
1955
1956         if (!mi->parseddesc->params)
1957                 if (!descriptor_params_from_paramtypes(mi->parseddesc, mi->flags))
1958                         return false;
1959
1960         /* cache the resolution */
1961
1962         ref->methodref->p.method = mi;
1963
1964 resolved_the_method:
1965
1966 #ifdef ENABLE_VERIFIER
1967         if (opt_verify) {
1968
1969                 checkresult = resolve_method_verifier_checks(
1970                                 ref->referermethod,
1971                                 ref->methodref,
1972                                 mi,
1973                                 (ref->flags & RESOLVE_STATIC));
1974
1975                 if (checkresult != resolveSucceeded)
1976                         return (bool) checkresult;
1977
1978                 /* impose loading constraints on params and return type */
1979
1980                 if (!resolve_method_loading_constraints(referer, mi))
1981                         return false;
1982
1983                 declarer = mi->class;
1984                 assert(declarer);
1985                 assert(referer->state & CLASS_LINKED);
1986
1987                 /* for non-static methods we have to check the constraints on the         */
1988                 /* instance type                                                          */
1989
1990                 if (!(ref->flags & RESOLVE_STATIC)) {
1991                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
1992                                         &(ref->instancetypes),
1993                                         CLASSREF_OR_CLASSINFO(container),
1994                                         mode,
1995                                         resolveLinkageError);
1996                         if (checkresult != resolveSucceeded)
1997                                 return (bool) checkresult;
1998                         instancecount = 1;
1999                 }
2000                 else {
2001                         instancecount = 0;
2002                 }
2003
2004                 /* check subtype constraints for TYPE_ADR parameters */
2005
2006                 assert(mi->parseddesc->paramcount == ref->methodref->parseddesc.md->paramcount);
2007                 paramtypes = mi->parseddesc->paramtypes;
2008
2009                 for (i = 0; i < mi->parseddesc->paramcount-instancecount; i++) {
2010                         if (paramtypes[i+instancecount].type == TYPE_ADR) {
2011                                 if (ref->paramconstraints) {
2012                                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
2013                                                         ref->paramconstraints + i,
2014                                                         CLASSREF_OR_CLASSINFO(paramtypes[i+instancecount].classref),
2015                                                         mode,
2016                                                         resolveLinkageError);
2017                                         if (checkresult != resolveSucceeded)
2018                                                 return (bool) checkresult;
2019                                 }
2020                         }
2021                 }
2022
2023                 /* check protected access */
2024
2025                 if (((mi->flags & ACC_PROTECTED) != 0) && !SAME_PACKAGE(declarer,referer))
2026                 {
2027                         checkresult = resolve_and_check_subtype_set(ref->referermethod,
2028                                         &(ref->instancetypes),
2029                                         CLASSREF_OR_CLASSINFO(referer),
2030                                         mode,
2031                                         resolveIllegalAccessError);
2032                         if (checkresult != resolveSucceeded)
2033                                 return (bool) checkresult;
2034                 }
2035         }
2036 #endif /* ENABLE_VERIFIER */
2037
2038         /* succeed */
2039         *result = mi;
2040         return true;
2041 }
2042
2043 /* resolve_method_eager ********************************************************
2044
2045    Resolve an unresolved method reference eagerly.
2046
2047    IN:
2048        ref..............struct containing the reference
2049
2050    RETURN VALUE:
2051        methodinfo * to the method, or
2052            NULL if an exception has been thrown
2053
2054 *******************************************************************************/
2055
2056 methodinfo * resolve_method_eager(unresolved_method *ref)
2057 {
2058         methodinfo *mi;
2059
2060         if (!resolve_method(ref,resolveEager,&mi))
2061                 return NULL;
2062
2063         return mi;
2064 }
2065
2066 /******************************************************************************/
2067 /* CREATING THE DATA STRUCTURES                                               */
2068 /******************************************************************************/
2069
2070 #ifdef ENABLE_VERIFIER
2071 static bool unresolved_subtype_set_from_typeinfo(classinfo *referer,
2072                                                                                                  methodinfo *refmethod,
2073                                                                                                  unresolved_subtype_set *stset,
2074                                                                                                  typeinfo *tinfo,
2075                                                                                                  utf *declaredclassname)
2076 {
2077         int count;
2078         int i;
2079
2080         assert(stset);
2081         assert(tinfo);
2082
2083 #ifdef RESOLVE_VERBOSE
2084         printf("unresolved_subtype_set_from_typeinfo\n");
2085 #ifdef TYPEINFO_DEBUG
2086         typeinfo_print(stdout,tinfo,4);
2087 #endif
2088         printf("    declared classname:");utf_fprint_printable_ascii(stdout,declaredclassname);
2089         printf("\n");
2090 #endif
2091
2092         if (TYPEINFO_IS_PRIMITIVE(*tinfo)) {
2093                 exceptions_throw_verifyerror(refmethod,
2094                                 "Invalid use of returnAddress");
2095                 return false;
2096         }
2097
2098         if (TYPEINFO_IS_NEWOBJECT(*tinfo)) {
2099                 exceptions_throw_verifyerror(refmethod,
2100                                 "Invalid use of uninitialized object");
2101                 return false;
2102         }
2103
2104         /* the nulltype is always assignable */
2105         if (TYPEINFO_IS_NULLTYPE(*tinfo))
2106                 goto empty_set;
2107
2108         /* every type is assignable to (BOOTSTRAP)java.lang.Object */
2109         if (declaredclassname == utf_java_lang_Object
2110                         && referer->classloader == NULL) /* XXX do loading constraints make the second check obsolete? */
2111         {
2112                 goto empty_set;
2113         }
2114
2115         if (tinfo->merged) {
2116                 count = tinfo->merged->count;
2117                 stset->subtyperefs = MNEW(classref_or_classinfo,count + 1);
2118                 for (i=0; i<count; ++i) {
2119                         classref_or_classinfo c = tinfo->merged->list[i];
2120                         if (tinfo->dimension > 0) {
2121                                 /* a merge of array types */
2122                                 /* the merged list contains the possible _element_ types, */
2123                                 /* so we have to create array types with these elements.  */
2124                                 if (IS_CLASSREF(c)) {
2125                                         c.ref = class_get_classref_multiarray_of(tinfo->dimension,c.ref);
2126                                 }
2127                                 else {
2128                                         c.cls = class_multiarray_of(tinfo->dimension,c.cls,false);
2129                                 }
2130                         }
2131                         stset->subtyperefs[i] = c;
2132                 }
2133                 stset->subtyperefs[count].any = NULL; /* terminate */
2134         }
2135         else {
2136                 if ((IS_CLASSREF(tinfo->typeclass)
2137                                         ? tinfo->typeclass.ref->name
2138                                         : tinfo->typeclass.cls->name) == declaredclassname)
2139                 {
2140                         /* the class names are the same */
2141                     /* equality is guaranteed by the loading constraints */
2142                         goto empty_set;
2143                 }
2144                 else {
2145                         stset->subtyperefs = MNEW(classref_or_classinfo,1 + 1);
2146                         stset->subtyperefs[0] = tinfo->typeclass;
2147                         stset->subtyperefs[1].any = NULL; /* terminate */
2148                 }
2149         }
2150
2151         return true;
2152
2153 empty_set:
2154         UNRESOLVED_SUBTYPE_SET_EMTPY(*stset);
2155         return true;
2156 }
2157 #endif /* ENABLE_VERIFIER */
2158
2159 /* create_unresolved_class *****************************************************
2160
2161    Create an unresolved_class struct for the given class reference
2162
2163    IN:
2164            refmethod........the method triggering the resolution (if any)
2165            classref.........the class reference
2166            valuetype........value type to check against the resolved class
2167                                                 may be NULL, if no typeinfo is available
2168
2169    RETURN VALUE:
2170        a pointer to a new unresolved_class struct, or
2171            NULL if an exception has been thrown
2172
2173 *******************************************************************************/
2174
2175 #ifdef ENABLE_VERIFIER
2176 unresolved_class * create_unresolved_class(methodinfo *refmethod,
2177                                                                                    constant_classref *classref,
2178                                                                                    typeinfo *valuetype)
2179 {
2180         unresolved_class *ref;
2181
2182 #ifdef RESOLVE_VERBOSE
2183         printf("create_unresolved_class\n");
2184         printf("    referer: ");utf_fprint_printable_ascii(stdout,classref->referer->name);fputc('\n',stdout);
2185         if (refmethod) {
2186                 printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2187                 printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2188         }
2189         printf("    name   : ");utf_fprint_printable_ascii(stdout,classref->name);fputc('\n',stdout);
2190 #endif
2191
2192         ref = NEW(unresolved_class);
2193         ref->classref = classref;
2194         ref->referermethod = refmethod;
2195
2196         if (valuetype) {
2197                 if (!unresolved_subtype_set_from_typeinfo(classref->referer,refmethod,
2198                                         &(ref->subtypeconstraints),valuetype,classref->name))
2199                         return NULL;
2200         }
2201         else {
2202                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->subtypeconstraints);
2203         }
2204
2205         return ref;
2206 }
2207 #endif /* ENABLE_VERIFIER */
2208
2209 /* resolve_create_unresolved_field *********************************************
2210
2211    Create an unresolved_field struct for the given field access instruction
2212
2213    IN:
2214        referer..........the class containing the reference
2215            refmethod........the method triggering the resolution (if any)
2216            iptr.............the {GET,PUT}{FIELD,STATIC}{,CONST} instruction
2217
2218    RETURN VALUE:
2219        a pointer to a new unresolved_field struct, or
2220            NULL if an exception has been thrown
2221
2222 *******************************************************************************/
2223
2224 unresolved_field * resolve_create_unresolved_field(classinfo *referer,
2225                                                                                                    methodinfo *refmethod,
2226                                                                                                    instruction *iptr)
2227 {
2228         unresolved_field *ref;
2229         constant_FMIref *fieldref = NULL;
2230
2231 #ifdef RESOLVE_VERBOSE
2232         printf("create_unresolved_field\n");
2233         printf("    referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
2234         printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2235         printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2236 #endif
2237
2238         ref = NEW(unresolved_field);
2239         ref->flags = 0;
2240         ref->referermethod = refmethod;
2241         UNRESOLVED_SUBTYPE_SET_EMTPY(ref->valueconstraints);
2242
2243         switch (iptr->opc) {
2244                 case ICMD_PUTFIELD:
2245                         ref->flags |= RESOLVE_PUTFIELD;
2246                         break;
2247
2248                 case ICMD_PUTFIELDCONST:
2249                         ref->flags |= RESOLVE_PUTFIELD;
2250                         break;
2251
2252                 case ICMD_PUTSTATIC:
2253                         ref->flags |= RESOLVE_PUTFIELD | RESOLVE_STATIC;
2254                         break;
2255
2256                 case ICMD_PUTSTATICCONST:
2257                         ref->flags |= RESOLVE_PUTFIELD | RESOLVE_STATIC;
2258                         break;
2259
2260                 case ICMD_GETFIELD:
2261                         break;
2262
2263                 case ICMD_GETSTATIC:
2264                         ref->flags |= RESOLVE_STATIC;
2265                         break;
2266
2267 #if !defined(NDEBUG)
2268                 default:
2269                         assert(false);
2270 #endif
2271         }
2272
2273         fieldref = iptr->sx.s23.s3.fmiref;
2274
2275         assert(fieldref);
2276
2277 #ifdef RESOLVE_VERBOSE
2278 /*      printf("    class  : ");utf_fprint_printable_ascii(stdout,fieldref->p.classref->name);fputc('\n',stdout);*/
2279         printf("    name   : ");utf_fprint_printable_ascii(stdout,fieldref->name);fputc('\n',stdout);
2280         printf("    desc   : ");utf_fprint_printable_ascii(stdout,fieldref->descriptor);fputc('\n',stdout);
2281         printf("    type   : ");descriptor_debug_print_typedesc(stdout,fieldref->parseddesc.fd);
2282         fputc('\n',stdout);
2283         /*printf("    opcode : %d %s\n",iptr->opc,icmd_names[iptr->opc]);*/
2284 #endif
2285
2286         ref->fieldref = fieldref;
2287
2288         return ref;
2289 }
2290
2291 /* resolve_constrain_unresolved_field ******************************************
2292
2293    Record subtype constraints for a field access.
2294
2295    IN:
2296        ref..............the unresolved_field structure of the access
2297        referer..........the class containing the reference
2298            refmethod........the method triggering the resolution (if any)
2299            instanceti.......instance typeinfo, if available
2300            valueti..........value typeinfo, if available
2301
2302    RETURN VALUE:
2303        true.............everything ok
2304            false............an exception has been thrown
2305
2306 *******************************************************************************/
2307
2308 #if defined(ENABLE_VERIFIER)
2309 bool resolve_constrain_unresolved_field(unresolved_field *ref,
2310                                                                                 classinfo *referer,
2311                                                                                 methodinfo *refmethod,
2312                                                                             typeinfo *instanceti,
2313                                                                             typeinfo *valueti)
2314 {
2315         constant_FMIref *fieldref;
2316         int type;
2317         typeinfo tinfo;
2318         typedesc *fd;
2319
2320         assert(ref);
2321
2322         fieldref = ref->fieldref;
2323         assert(fieldref);
2324
2325 #ifdef RESOLVE_VERBOSE
2326         printf("constrain_unresolved_field\n");
2327         printf("    referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
2328         printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2329         printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2330 /*      printf("    class  : ");utf_fprint_printable_ascii(stdout,fieldref->p.classref->name);fputc('\n',stdout); */
2331         printf("    name   : ");utf_fprint_printable_ascii(stdout,fieldref->name);fputc('\n',stdout);
2332         printf("    desc   : ");utf_fprint_printable_ascii(stdout,fieldref->descriptor);fputc('\n',stdout);
2333         printf("    type   : ");descriptor_debug_print_typedesc(stdout,fieldref->parseddesc.fd);
2334         fputc('\n',stdout);
2335         /*printf("    opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
2336 #endif
2337
2338         assert(instanceti || ((ref->flags & RESOLVE_STATIC) != 0));
2339         fd = fieldref->parseddesc.fd;
2340         assert(fd);
2341
2342         /* record subtype constraints for the instance type, if any */
2343         if (instanceti) {
2344                 typeinfo *insttip;
2345
2346                 /* The instanceslot must contain a reference to a non-array type */
2347                 if (!TYPEINFO_IS_REFERENCE(*instanceti)) {
2348                         exceptions_throw_verifyerror(refmethod,
2349                                         "illegal instruction: field access on non-reference");
2350                         return false;
2351                 }
2352                 if (TYPEINFO_IS_ARRAY(*instanceti)) {
2353                         exceptions_throw_verifyerror(refmethod,
2354                                         "illegal instruction: field access on array");
2355                         return false;
2356                 }
2357
2358                 if (((ref->flags & RESOLVE_PUTFIELD) != 0) &&
2359                                 TYPEINFO_IS_NEWOBJECT(*instanceti))
2360                 {
2361                         /* The instruction writes a field in an uninitialized object. */
2362                         /* This is only allowed when a field of an uninitialized 'this' object is */
2363                         /* written inside an initialization method                                */
2364
2365                         classinfo *initclass;
2366                         instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(*instanceti);
2367
2368                         if (ins != NULL) {
2369                                 exceptions_throw_verifyerror(refmethod,
2370                                                 "accessing field of uninitialized object");
2371                                 return false;
2372                         }
2373                         /* XXX check that class of field == refmethod->class */
2374                         initclass = refmethod->class; /* XXX classrefs */
2375                         assert(initclass->state & CLASS_LOADED);
2376                         assert(initclass->state & CLASS_LINKED);
2377
2378                         typeinfo_init_classinfo(&tinfo, initclass);
2379                         insttip = &tinfo;
2380                 }
2381                 else {
2382                         insttip = instanceti;
2383                 }
2384                 if (!unresolved_subtype_set_from_typeinfo(referer, refmethod,
2385                                         &(ref->instancetypes), insttip,
2386                                         FIELDREF_CLASSNAME(fieldref)))
2387                         return false;
2388         }
2389         else {
2390                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->instancetypes);
2391         }
2392
2393         /* record subtype constraints for the value type, if any */
2394         type = fd->type;
2395         if (type == TYPE_ADR && ((ref->flags & RESOLVE_PUTFIELD) != 0)) {
2396                 assert(valueti);
2397                 if (!unresolved_subtype_set_from_typeinfo(referer, refmethod,
2398                                         &(ref->valueconstraints), valueti,
2399                                         fieldref->parseddesc.fd->classref->name))
2400                         return false;
2401         }
2402         else {
2403                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->valueconstraints);
2404         }
2405
2406         return true;
2407 }
2408 #endif /* ENABLE_VERIFIER */
2409
2410 /* resolve_create_unresolved_method ********************************************
2411
2412    Create an unresolved_method struct for the given method invocation
2413
2414    IN:
2415        referer..........the class containing the reference
2416            refmethod........the method triggering the resolution (if any)
2417            iptr.............the INVOKE* instruction
2418
2419    RETURN VALUE:
2420        a pointer to a new unresolved_method struct, or
2421            NULL if an exception has been thrown
2422
2423 *******************************************************************************/
2424
2425 unresolved_method * resolve_create_unresolved_method(classinfo *referer,
2426                                                                                                          methodinfo *refmethod,
2427                                                                                                          constant_FMIref *methodref,
2428                                                                                                          bool invokestatic,
2429                                                                                                          bool invokespecial)
2430 {
2431         unresolved_method *ref;
2432
2433         assert(methodref);
2434
2435 #ifdef RESOLVE_VERBOSE
2436         printf("create_unresolved_method\n");
2437         printf("    referer: ");utf_fprint_printable_ascii(stdout,referer->name);fputc('\n',stdout);
2438         printf("    rmethod: ");utf_fprint_printable_ascii(stdout,refmethod->name);fputc('\n',stdout);
2439         printf("    rmdesc : ");utf_fprint_printable_ascii(stdout,refmethod->descriptor);fputc('\n',stdout);
2440         printf("    name   : ");utf_fprint_printable_ascii(stdout,methodref->name);fputc('\n',stdout);
2441         printf("    desc   : ");utf_fprint_printable_ascii(stdout,methodref->descriptor);fputc('\n',stdout);
2442 #endif
2443
2444         /* allocate params if necessary */
2445         if (!methodref->parseddesc.md->params)
2446                 if (!descriptor_params_from_paramtypes(methodref->parseddesc.md,
2447                                         (invokestatic) ? ACC_STATIC : ACC_NONE))
2448                         return NULL;
2449
2450         /* create the data structure */
2451         ref = NEW(unresolved_method);
2452         ref->flags = ((invokestatic) ? RESOLVE_STATIC : 0)
2453                            | ((invokespecial) ? RESOLVE_SPECIAL : 0);
2454         ref->referermethod = refmethod;
2455         ref->methodref = methodref;
2456         ref->paramconstraints = NULL;
2457         UNRESOLVED_SUBTYPE_SET_EMTPY(ref->instancetypes);
2458
2459         return ref;
2460 }
2461
2462 /* constrain_unresolved_method *********************************************
2463
2464    Record subtype constraints for the arguments of a method call.
2465
2466    IN:
2467        ref..............the unresolved_method structure of the call
2468        referer..........the class containing the reference
2469            refmethod........the method triggering the resolution (if any)
2470            iptr.............the INVOKE* instruction
2471
2472    RETURN VALUE:
2473        true.............everything ok
2474            false............an exception has been thrown
2475
2476 *******************************************************************************/
2477
2478 #ifdef ENABLE_VERIFIER
2479 bool constrain_unresolved_method(jitdata *jd,
2480                                                                          unresolved_method *ref,
2481                                                                          classinfo *referer, methodinfo *refmethod,
2482                                                                          instruction *iptr)
2483 {
2484         constant_FMIref *methodref;
2485         constant_classref *instanceref;
2486         varinfo *instanceslot = NULL;
2487         varinfo *param;
2488         methoddesc *md;
2489         typeinfo tinfo;
2490         int i,j;
2491         int type;
2492         int instancecount;
2493
2494         assert(ref);
2495         methodref = ref->methodref;
2496         assert(methodref);
2497         md = methodref->parseddesc.md;
2498         assert(md);
2499         assert(md->params != NULL);
2500
2501         /* XXX clean this up */
2502         instanceref = IS_FMIREF_RESOLVED(methodref)
2503                 ? class_get_self_classref(methodref->p.method->class)
2504                 : methodref->p.classref;
2505
2506 #ifdef RESOLVE_VERBOSE
2507         printf("constrain_unresolved_method\n");
2508         printf("    referer: "); class_println(referer);
2509         printf("    rmethod: "); method_println(refmethod);
2510         printf("    mref   : "); method_methodref_println(methodref);
2511         /*printf("    opcode : %d %s\n",iptr[0].opc,icmd_names[iptr[0].opc]);*/
2512 #endif
2513
2514         if ((ref->flags & RESOLVE_STATIC) == 0) {
2515                 /* find the instance slot under all the parameter slots on the stack */
2516                 instanceslot = VAR(iptr->sx.s23.s2.args[0]);
2517                 instancecount = 1;
2518         }
2519         else {
2520                 instancecount = 0;
2521         }
2522
2523         assert((instanceslot && instancecount==1) || ((ref->flags & RESOLVE_STATIC) != 0));
2524
2525         /* record subtype constraints for the instance type, if any */
2526         if (instanceslot) {
2527                 typeinfo *tip;
2528
2529                 assert(instanceslot->type == TYPE_ADR);
2530
2531                 if (iptr[0].opc == ICMD_INVOKESPECIAL &&
2532                                 TYPEINFO_IS_NEWOBJECT(instanceslot->typeinfo))
2533                 {   /* XXX clean up */
2534                         instruction *ins = (instruction *) TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
2535                         classref_or_classinfo initclass = (ins) ? ins[-1].sx.val.c
2536                                                                                  : CLASSREF_OR_CLASSINFO(refmethod->class);
2537                         tip = &tinfo;
2538                         if (!typeinfo_init_class(tip,initclass))
2539                                 return false;
2540                 }
2541                 else {
2542                         tip = &(instanceslot->typeinfo);
2543                 }
2544                 if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
2545                                         &(ref->instancetypes),tip,instanceref->name))
2546                         return false;
2547         }
2548
2549         /* record subtype constraints for the parameter types, if any */
2550         for (i=md->paramcount-1-instancecount; i>=0; --i) {
2551                 param = VAR(iptr->sx.s23.s2.args[i+instancecount]);
2552                 type = md->paramtypes[i+instancecount].type;
2553
2554                 assert(param);
2555                 assert(type == param->type);
2556
2557                 if (type == TYPE_ADR) {
2558                         if (!ref->paramconstraints) {
2559                                 ref->paramconstraints = MNEW(unresolved_subtype_set,md->paramcount);
2560                                 for (j=md->paramcount-1-instancecount; j>i; --j)
2561                                         UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[j]);
2562                         }
2563                         assert(ref->paramconstraints);
2564                         if (!unresolved_subtype_set_from_typeinfo(referer,refmethod,
2565                                                 ref->paramconstraints + i,&(param->typeinfo),
2566                                                 md->paramtypes[i+instancecount].classref->name))
2567                                 return false;
2568                 }
2569                 else {
2570                         if (ref->paramconstraints)
2571                                 UNRESOLVED_SUBTYPE_SET_EMTPY(ref->paramconstraints[i]);
2572                 }
2573         }
2574
2575         return true;
2576 }
2577 #endif /* ENABLE_VERIFIER */
2578
2579 /******************************************************************************/
2580 /* FREEING MEMORY                                                             */
2581 /******************************************************************************/
2582
2583 #ifdef ENABLE_VERIFIER
2584 inline static void unresolved_subtype_set_free_list(classref_or_classinfo *list)
2585 {
2586         if (list) {
2587                 classref_or_classinfo *p = list;
2588
2589                 /* this is silly. we *only* need to count the elements for MFREE */
2590                 while ((p++)->any)
2591                         ;
2592                 MFREE(list,classref_or_classinfo,(p - list));
2593         }
2594 }
2595 #endif /* ENABLE_VERIFIER */
2596
2597 /* unresolved_class_free *******************************************************
2598
2599    Free the memory used by an unresolved_class
2600
2601    IN:
2602        ref..............the unresolved_class
2603
2604 *******************************************************************************/
2605
2606 void unresolved_class_free(unresolved_class *ref)
2607 {
2608         assert(ref);
2609
2610 #ifdef ENABLE_VERIFIER
2611         unresolved_subtype_set_free_list(ref->subtypeconstraints.subtyperefs);
2612 #endif
2613         FREE(ref,unresolved_class);
2614 }
2615
2616 /* unresolved_field_free *******************************************************
2617
2618    Free the memory used by an unresolved_field
2619
2620    IN:
2621        ref..............the unresolved_field
2622
2623 *******************************************************************************/
2624
2625 void unresolved_field_free(unresolved_field *ref)
2626 {
2627         assert(ref);
2628
2629 #ifdef ENABLE_VERIFIER
2630         unresolved_subtype_set_free_list(ref->instancetypes.subtyperefs);
2631         unresolved_subtype_set_free_list(ref->valueconstraints.subtyperefs);
2632 #endif
2633         FREE(ref,unresolved_field);
2634 }
2635
2636 /* unresolved_method_free ******************************************************
2637
2638    Free the memory used by an unresolved_method
2639
2640    IN:
2641        ref..............the unresolved_method
2642
2643 *******************************************************************************/
2644
2645 void unresolved_method_free(unresolved_method *ref)
2646 {
2647         assert(ref);
2648
2649 #ifdef ENABLE_VERIFIER
2650         unresolved_subtype_set_free_list(ref->instancetypes.subtyperefs);
2651         if (ref->paramconstraints) {
2652                 int i;
2653                 int count = ref->methodref->parseddesc.md->paramcount;
2654
2655                 for (i=0; i<count; ++i)
2656                         unresolved_subtype_set_free_list(ref->paramconstraints[i].subtyperefs);
2657                 MFREE(ref->paramconstraints,unresolved_subtype_set,count);
2658         }
2659 #endif
2660         FREE(ref,unresolved_method);
2661 }
2662
2663 /******************************************************************************/
2664 /* DEBUG DUMPS                                                                */
2665 /******************************************************************************/
2666
2667 #if !defined(NDEBUG)
2668
2669 /* unresolved_subtype_set_debug_dump *******************************************
2670
2671    Print debug info for unresolved_subtype_set to stream
2672
2673    IN:
2674        stset............the unresolved_subtype_set
2675            file.............the stream
2676
2677 *******************************************************************************/
2678
2679 void unresolved_subtype_set_debug_dump(unresolved_subtype_set *stset,FILE *file)
2680 {
2681         classref_or_classinfo *p;
2682
2683         if (SUBTYPESET_IS_EMPTY(*stset)) {
2684                 fprintf(file,"        (empty)\n");
2685         }
2686         else {
2687                 p = stset->subtyperefs;
2688                 for (;p->any; ++p) {
2689                         if (IS_CLASSREF(*p)) {
2690                                 fprintf(file,"        ref: ");
2691                                 utf_fprint_printable_ascii(file,p->ref->name);
2692                         }
2693                         else {
2694                                 fprintf(file,"        cls: ");
2695                                 utf_fprint_printable_ascii(file,p->cls->name);
2696                         }
2697                         fputc('\n',file);
2698                 }
2699         }
2700 }
2701
2702 /* unresolved_class_debug_dump *************************************************
2703
2704    Print debug info for unresolved_class to stream
2705
2706    IN:
2707        ref..............the unresolved_class
2708            file.............the stream
2709
2710 *******************************************************************************/
2711
2712 void unresolved_class_debug_dump(unresolved_class *ref,FILE *file)
2713 {
2714         fprintf(file,"unresolved_class(%p):\n",(void *)ref);
2715         if (ref) {
2716                 fprintf(file,"    referer   : ");
2717                 utf_fprint_printable_ascii(file,ref->classref->referer->name); fputc('\n',file);
2718                 fprintf(file,"    refmethod : ");
2719                 utf_fprint_printable_ascii(file,ref->referermethod->name); fputc('\n',file);
2720                 fprintf(file,"    refmethodd: ");
2721                 utf_fprint_printable_ascii(file,ref->referermethod->descriptor); fputc('\n',file);
2722                 fprintf(file,"    classname : ");
2723                 utf_fprint_printable_ascii(file,ref->classref->name); fputc('\n',file);
2724                 fprintf(file,"    subtypeconstraints:\n");
2725                 unresolved_subtype_set_debug_dump(&(ref->subtypeconstraints),file);
2726         }
2727 }
2728
2729 /* unresolved_field_debug_dump *************************************************
2730
2731    Print debug info for unresolved_field to stream
2732
2733    IN:
2734        ref..............the unresolved_field
2735            file.............the stream
2736
2737 *******************************************************************************/
2738
2739 void unresolved_field_debug_dump(unresolved_field *ref,FILE *file)
2740 {
2741         fprintf(file,"unresolved_field(%p):\n",(void *)ref);
2742         if (ref) {
2743                 fprintf(file,"    referer   : ");
2744                 utf_fprint_printable_ascii(file,ref->referermethod->class->name); fputc('\n',file);
2745                 fprintf(file,"    refmethod : ");
2746                 utf_fprint_printable_ascii(file,ref->referermethod->name); fputc('\n',file);
2747                 fprintf(file,"    refmethodd: ");
2748                 utf_fprint_printable_ascii(file,ref->referermethod->descriptor); fputc('\n',file);
2749                 fprintf(file,"    classname : ");
2750                 utf_fprint_printable_ascii(file,FIELDREF_CLASSNAME(ref->fieldref)); fputc('\n',file);
2751                 fprintf(file,"    name      : ");
2752                 utf_fprint_printable_ascii(file,ref->fieldref->name); fputc('\n',file);
2753                 fprintf(file,"    descriptor: ");
2754                 utf_fprint_printable_ascii(file,ref->fieldref->descriptor); fputc('\n',file);
2755                 fprintf(file,"    parseddesc: ");
2756                 descriptor_debug_print_typedesc(file,ref->fieldref->parseddesc.fd); fputc('\n',file);
2757                 fprintf(file,"    flags     : %04x\n",ref->flags);
2758                 fprintf(file,"    instancetypes:\n");
2759                 unresolved_subtype_set_debug_dump(&(ref->instancetypes),file);
2760                 fprintf(file,"    valueconstraints:\n");
2761                 unresolved_subtype_set_debug_dump(&(ref->valueconstraints),file);
2762         }
2763 }
2764
2765 /* unresolved_method_debug_dump ************************************************
2766
2767    Print debug info for unresolved_method to stream
2768
2769    IN:
2770        ref..............the unresolved_method
2771            file.............the stream
2772
2773 *******************************************************************************/
2774
2775 void unresolved_method_debug_dump(unresolved_method *ref,FILE *file)
2776 {
2777         int i;
2778
2779         fprintf(file,"unresolved_method(%p):\n",(void *)ref);
2780         if (ref) {
2781                 fprintf(file,"    referer   : ");
2782                 utf_fprint_printable_ascii(file,ref->referermethod->class->name); fputc('\n',file);
2783                 fprintf(file,"    refmethod : ");
2784                 utf_fprint_printable_ascii(file,ref->referermethod->name); fputc('\n',file);
2785                 fprintf(file,"    refmethodd: ");
2786                 utf_fprint_printable_ascii(file,ref->referermethod->descriptor); fputc('\n',file);
2787                 fprintf(file,"    classname : ");
2788                 utf_fprint_printable_ascii(file,METHODREF_CLASSNAME(ref->methodref)); fputc('\n',file);
2789                 fprintf(file,"    name      : ");
2790                 utf_fprint_printable_ascii(file,ref->methodref->name); fputc('\n',file);
2791                 fprintf(file,"    descriptor: ");
2792                 utf_fprint_printable_ascii(file,ref->methodref->descriptor); fputc('\n',file);
2793                 fprintf(file,"    parseddesc: ");
2794                 descriptor_debug_print_methoddesc(file,ref->methodref->parseddesc.md); fputc('\n',file);
2795                 fprintf(file,"    flags     : %04x\n",ref->flags);
2796                 fprintf(file,"    instancetypes:\n");
2797                 unresolved_subtype_set_debug_dump(&(ref->instancetypes),file);
2798                 fprintf(file,"    paramconstraints:\n");
2799                 if (ref->paramconstraints) {
2800                         for (i=0; i<ref->methodref->parseddesc.md->paramcount; ++i) {
2801                                 fprintf(file,"      param %d:\n",i);
2802                                 unresolved_subtype_set_debug_dump(ref->paramconstraints + i,file);
2803                         }
2804                 }
2805                 else {
2806                         fprintf(file,"      (empty)\n");
2807                 }
2808         }
2809 }
2810 #endif /* !defined(NDEBUG) */
2811
2812 /*
2813  * These are local overrides for various environment variables in Emacs.
2814  * Please do not remove this and leave it at the end of the file, where
2815  * Emacs will automagically detect them.
2816  * ---------------------------------------------------------------------
2817  * Local variables:
2818  * mode: c
2819  * indent-tabs-mode: t
2820  * c-basic-offset: 4
2821  * tab-width: 4
2822  * End:
2823  * vim:noexpandtab:sw=4:ts=4:
2824  */
2825