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