src/vmcore/class.c

   1 /* src/vmcore/class.c - class related functions
   2
   3    Copyright (C) 1996-2005, 2006, 2007 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 */
  26
  27
  28 #include "config.h"
  29
  30 #include <assert.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "vm/types.h"
  36
  37 #include "arch.h"
  38
  39 #include "mm/memory.h"
  40
  41 #include "native/llni.h"
  42
  43 #include "threads/lock-common.h"
  44
  45 #include "toolbox/logging.h"
  46
  47 #include "vm/array.h"
  48 #include "vm/builtin.h"
  49 #include "vm/exceptions.h"
  50 #include "vm/global.h"
  51 #include "vm/resolve.h"
  52
  53 #include "vm/jit/asmpart.h"
  54
  55 #include "vmcore/class.h"
  56 #include "vmcore/classcache.h"
  57 #include "vmcore/linker.h"
  58 #include "vmcore/loader.h"
  59 #include "vmcore/options.h"
  60
  61 #if defined(ENABLE_STATISTICS)
  62 # include "vmcore/statistics.h"
  63 #endif
  64
  65 #include "vmcore/suck.h"
  66 #include "vmcore/utf8.h"
  67
  68
  69 /* global variables ***********************************************************/
  70
  71 /* frequently used classes ****************************************************/
  72
  73 /* important system classes */
  74
  75 classinfo *class_java_lang_Object;
  76 classinfo *class_java_lang_Class;
  77 classinfo *class_java_lang_ClassLoader;
  78 classinfo *class_java_lang_Cloneable;
  79 classinfo *class_java_lang_SecurityManager;
  80 classinfo *class_java_lang_String;
  81 classinfo *class_java_lang_System;
  82 classinfo *class_java_lang_Thread;
  83 classinfo *class_java_lang_ThreadGroup;
  84 classinfo *class_java_lang_VMSystem;
  85 classinfo *class_java_lang_VMThread;
  86 classinfo *class_java_io_Serializable;
  87
  88 #if defined(WITH_CLASSPATH_SUN)
  89 classinfo *class_sun_reflect_MagicAccessorImpl;
  90 #endif
  91
  92 /* system exception classes required in cacao */
  93
  94 classinfo *class_java_lang_Throwable;
  95 classinfo *class_java_lang_Error;
  96 classinfo *class_java_lang_LinkageError;
  97 classinfo *class_java_lang_NoClassDefFoundError;
  98 classinfo *class_java_lang_OutOfMemoryError;
  99 classinfo *class_java_lang_VirtualMachineError;
 100
 101 #if defined(WITH_CLASSPATH_GNU)
 102 classinfo *class_java_lang_VMThrowable;
 103 #endif
 104
 105 classinfo *class_java_lang_Exception;
 106 classinfo *class_java_lang_ClassCastException;
 107 classinfo *class_java_lang_ClassNotFoundException;
 108
 109 #if defined(ENABLE_JAVASE)
 110 classinfo *class_java_lang_Void;
 111 #endif
 112 classinfo *class_java_lang_Boolean;
 113 classinfo *class_java_lang_Byte;
 114 classinfo *class_java_lang_Character;
 115 classinfo *class_java_lang_Short;
 116 classinfo *class_java_lang_Integer;
 117 classinfo *class_java_lang_Long;
 118 classinfo *class_java_lang_Float;
 119 classinfo *class_java_lang_Double;
 120
 121
 122 /* some runtime exception */
 123
 124 classinfo *class_java_lang_NullPointerException;
 125
 126
 127 /* some classes which may be used more often */
 128
 129 #if defined(ENABLE_JAVASE)
 130 classinfo *class_java_lang_StackTraceElement;
 131 classinfo *class_java_lang_reflect_Constructor;
 132 classinfo *class_java_lang_reflect_Field;
 133 classinfo *class_java_lang_reflect_Method;
 134 classinfo *class_java_security_PrivilegedAction;
 135 classinfo *class_java_util_Vector;
 136
 137 classinfo *arrayclass_java_lang_Object;
 138
 139 #if defined(ENABLE_ANNOTATIONS)
 140 classinfo *class_sun_reflect_ConstantPool;
 141 #if defined(WITH_CLASSPATH_GNU)
 142 classinfo *class_sun_reflect_annotation_AnnotationParser;
 143 #endif
 144 #endif
 145 #endif
 146
 147
 148 /* pseudo classes for the typechecker */
 149
 150 classinfo *pseudo_class_Arraystub;
 151 classinfo *pseudo_class_Null;
 152 classinfo *pseudo_class_New;
 153
 154
 155 /* class_set_packagename *******************************************************
 156
 157    Derive the package name from the class name and store it in the struct.
 158
 159 *******************************************************************************/
 160
 161 void class_set_packagename(classinfo *c)
 162 {
 163         char *p = UTF_END(c->name) - 1;
 164         char *start = c->name->text;
 165
 166         /* set the package name */
 167         /* classes in the unnamed package keep packagename == NULL */
 168
 169         if (c->name->text[0] == '[') {
 170                 /* set packagename of arrays to the element's package */
 171
 172                 for (; *start == '['; start++);
 173
 174                 /* skip the 'L' in arrays of references */
 175                 if (*start == 'L')
 176                         start++;
 177
 178                 for (; (p > start) && (*p != '/'); --p);
 179
 180                 c->packagename = utf_new(start, p - start);
 181
 182         } else {
 183                 for (; (p > start) && (*p != '/'); --p);
 184
 185                 c->packagename = utf_new(start, p - start);
 186         }
 187 }
 188
 189
 190 /* class_create_classinfo ******************************************************
 191
 192    Create a new classinfo struct. The class name is set to the given utf *,
 193    most other fields are initialized to zero.
 194
 195    Note: classname may be NULL. In this case a not-yet-named classinfo is
 196          created. The name must be filled in later and class_set_packagename
 197                  must be called after that.
 198
 199 *******************************************************************************/
 200
 201 classinfo *class_create_classinfo(utf *classname)
 202 {
 203         classinfo *c;
 204
 205 #if defined(ENABLE_STATISTICS)
 206         if (opt_stat)
 207                 size_classinfo += sizeof(classinfo);
 208 #endif
 209
 210         /* we use a safe name for temporarily unnamed classes */
 211
 212         if (classname == NULL)
 213                 classname = utf_not_named_yet;
 214
 215 #if !defined(NDEBUG)
 216         if (initverbose)
 217                 log_message_utf("Creating class: ", classname);
 218 #endif
 219
 220         /* GCNEW_UNCOLLECTABLE clears the allocated memory */
 221
 222         c = GCNEW_UNCOLLECTABLE(classinfo, 1);
 223         /*c=NEW(classinfo);*/
 224         c->name = classname;
 225
 226         /* Set the header.vftbl of all loaded classes to the one of
 227        java.lang.Class, so Java code can use a class as object. */
 228
 229         if (class_java_lang_Class != NULL)
 230                 if (class_java_lang_Class->vftbl != NULL)
 231                         c->object.header.vftbl = class_java_lang_Class->vftbl;
 232
 233 #if defined(ENABLE_JAVASE)
 234         /* check if the class is a reference class and flag it */
 235
 236         if (classname == utf_java_lang_ref_SoftReference) {
 237                 c->flags |= ACC_CLASS_REFERENCE_SOFT;
 238         }
 239         else if (classname == utf_java_lang_ref_WeakReference) {
 240                 c->flags |= ACC_CLASS_REFERENCE_WEAK;
 241         }
 242         else if (classname == utf_java_lang_ref_PhantomReference) {
 243                 c->flags |= ACC_CLASS_REFERENCE_PHANTOM;
 244         }
 245 #endif
 246
 247         if (classname != utf_not_named_yet)
 248                 class_set_packagename(c);
 249
 250         LOCK_INIT_OBJECT_LOCK(&c->object.header);
 251
 252         return c;
 253 }
 254
 255
 256 /* class_postset_header_vftbl **************************************************
 257
 258    Set the header.vftbl of all classes created before java.lang.Class
 259    was linked.  This is necessary that Java code can use a class as
 260    object.
 261
 262 *******************************************************************************/
 263
 264 void class_postset_header_vftbl(void)
 265 {
 266         classinfo *c;
 267         u4 slot;
 268         classcache_name_entry *nmen;
 269         classcache_class_entry *clsen;
 270
 271         assert(class_java_lang_Class);
 272
 273         for (slot = 0; slot < hashtable_classcache.size; slot++) {
 274                 nmen = (classcache_name_entry *) hashtable_classcache.ptr[slot];
 275
 276                 for (; nmen; nmen = nmen->hashlink) {
 277                         /* iterate over all class entries */
 278
 279                         for (clsen = nmen->classes; clsen; clsen = clsen->next) {
 280                                 c = clsen->classobj;
 281
 282                                 /* now set the the vftbl */
 283
 284                                 if (c->object.header.vftbl == NULL)
 285                                         c->object.header.vftbl = class_java_lang_Class->vftbl;
 286                         }
 287                 }
 288         }
 289 }
 290
 291 /* class_define ****************************************************************
 292
 293    Calls the loader and defines a class in the VM.
 294
 295 *******************************************************************************/
 296
 297 classinfo *class_define(utf *name, classloader *cl, int32_t length, const uint8_t *data, java_handle_t *pd)
 298 {
 299         classinfo   *c;
 300         classinfo   *r;
 301         classbuffer *cb;
 302
 303         if (name != NULL) {
 304                 /* check if this class has already been defined */
 305
 306                 c = classcache_lookup_defined_or_initiated(cl, name);
 307
 308                 if (c != NULL) {
 309                         exceptions_throw_linkageerror("duplicate class definition: ", c);
 310                         return NULL;
 311                 }
 312         }
 313
 314         /* create a new classinfo struct */
 315
 316         c = class_create_classinfo(name);
 317
 318 #if defined(ENABLE_STATISTICS)
 319         /* measure time */
 320
 321         if (opt_getloadingtime)
 322                 loadingtime_start();
 323 #endif
 324
 325         /* build a classbuffer with the given data */
 326
 327         cb = NEW(classbuffer);
 328
 329         cb->class = c;
 330         cb->size  = length;
 331         cb->data  = data;
 332         cb->pos   = cb->data;
 333
 334         /* preset the defining classloader */
 335
 336         c->classloader = cl;
 337
 338         /* load the class from this buffer */
 339
 340         r = load_class_from_classbuffer(cb);
 341
 342         /* free memory */
 343
 344         FREE(cb, classbuffer);
 345
 346 #if defined(ENABLE_STATISTICS)
 347         /* measure time */
 348
 349         if (opt_getloadingtime)
 350                 loadingtime_stop();
 351 #endif
 352
 353         if (r == NULL) {
 354                 /* If return value is NULL, we had a problem and the class is
 355                    not loaded.  Now free the allocated memory, otherwise we
 356                    could run into a DOS. */
 357
 358                 class_free(c);
 359
 360                 return NULL;
 361         }
 362
 363 #if defined(ENABLE_JAVASE)
 364 # if defined(WITH_CLASSPATH_SUN)
 365         /* Store the protection domain. */
 366
 367         c->protectiondomain = pd;
 368 # endif
 369 #endif
 370
 371         /* Store the newly defined class in the class cache. This call
 372            also checks whether a class of the same name has already been
 373            defined by the same defining loader, and if so, replaces the
 374            newly created class by the one defined earlier. */
 375
 376         /* Important: The classinfo given to classcache_store must be
 377                       fully prepared because another thread may return
 378                       this pointer after the lookup at to top of this
 379                       function directly after the class cache lock has
 380                       been released. */
 381
 382         c = classcache_store(cl, c, true);
 383
 384         return c;
 385 }
 386
 387
 388 /* class_load_attribute_sourcefile *********************************************
 389
 390    SourceFile_attribute {
 391        u2 attribute_name_index;
 392        u4 attribute_length;
 393            u2 sourcefile_index;
 394    }
 395
 396 *******************************************************************************/
 397
 398 static bool class_load_attribute_sourcefile(classbuffer *cb)
 399 {
 400         classinfo *c;
 401         u4         attribute_length;
 402         u2         sourcefile_index;
 403         utf       *sourcefile;
 404
 405         /* get classinfo */
 406
 407         c = cb->class;
 408
 409         /* check buffer size */
 410
 411         if (!suck_check_classbuffer_size(cb, 4 + 2))
 412                 return false;
 413
 414         /* check attribute length */
 415
 416         attribute_length = suck_u4(cb);
 417
 418         if (attribute_length != 2) {
 419                 exceptions_throw_classformaterror(c, "Wrong size for VALUE attribute");
 420                 return false;
 421         }
 422
 423         /* there can be no more than one SourceFile attribute */
 424
 425         if (c->sourcefile != NULL) {
 426                 exceptions_throw_classformaterror(c, "Multiple SourceFile attributes");
 427                 return false;
 428         }
 429
 430         /* get sourcefile */
 431
 432         sourcefile_index = suck_u2(cb);
 433         sourcefile = class_getconstant(c, sourcefile_index, CONSTANT_Utf8);
 434
 435         if (sourcefile == NULL)
 436                 return false;
 437
 438         /* store sourcefile */
 439
 440         c->sourcefile = sourcefile;
 441
 442         return true;
 443 }
 444
 445
 446 /* class_load_attribute_enclosingmethod ****************************************
 447
 448    EnclosingMethod_attribute {
 449        u2 attribute_name_index;
 450        u4 attribute_length;
 451            u2 class_index;
 452            u2 method_index;
 453    }
 454
 455 *******************************************************************************/
 456
 457 #if defined(ENABLE_JAVASE)
 458 static bool class_load_attribute_enclosingmethod(classbuffer *cb)
 459 {
 460         classinfo             *c;
 461         u4                     attribute_length;
 462         u2                     class_index;
 463         u2                     method_index;
 464         classref_or_classinfo  cr;
 465         constant_nameandtype  *cn;
 466
 467         /* get classinfo */
 468
 469         c = cb->class;
 470
 471         /* check buffer size */
 472
 473         if (!suck_check_classbuffer_size(cb, 4 + 2 + 2))
 474                 return false;
 475
 476         /* check attribute length */
 477
 478         attribute_length = suck_u4(cb);
 479
 480         if (attribute_length != 4) {
 481                 exceptions_throw_classformaterror(c, "Wrong size for VALUE attribute");
 482                 return false;
 483         }
 484
 485         /* there can be no more than one EnclosingMethod attribute */
 486
 487         if (c->enclosingmethod != NULL) {
 488                 exceptions_throw_classformaterror(c, "Multiple EnclosingMethod attributes");
 489                 return false;
 490         }
 491
 492         /* get class index */
 493
 494         class_index = suck_u2(cb);
 495         cr.ref = innerclass_getconstant(c, class_index, CONSTANT_Class);
 496
 497         /* get method index */
 498
 499         method_index = suck_u2(cb);
 500         cn = innerclass_getconstant(c, method_index, CONSTANT_NameAndType);
 501
 502         /* store info in classinfo */
 503
 504         c->enclosingclass.any = cr.any;
 505         c->enclosingmethod    = cn;
 506
 507         return true;
 508 }
 509 #endif /* defined(ENABLE_JAVASE) */
 510
 511
 512 /* class_load_attributes *******************************************************
 513
 514    Read attributes from ClassFile.
 515
 516    attribute_info {
 517        u2 attribute_name_index;
 518        u4 attribute_length;
 519        u1 info[attribute_length];
 520    }
 521
 522    InnerClasses_attribute {
 523        u2 attribute_name_index;
 524        u4 attribute_length;
 525    }
 526
 527 *******************************************************************************/
 528
 529 bool class_load_attributes(classbuffer *cb)
 530 {
 531         classinfo             *c;
 532         uint16_t               attributes_count;
 533         uint16_t               attribute_name_index;
 534         utf                   *attribute_name;
 535         innerclassinfo        *info;
 536         classref_or_classinfo  inner;
 537         classref_or_classinfo  outer;
 538         utf                   *name;
 539         uint16_t               flags;
 540         int                    i, j;
 541
 542         c = cb->class;
 543
 544         /* get attributes count */
 545
 546         if (!suck_check_classbuffer_size(cb, 2))
 547                 return false;
 548
 549         attributes_count = suck_u2(cb);
 550
 551         for (i = 0; i < attributes_count; i++) {
 552                 /* get attribute name */
 553
 554                 if (!suck_check_classbuffer_size(cb, 2))
 555                         return false;
 556
 557                 attribute_name_index = suck_u2(cb);
 558                 attribute_name =
 559                         class_getconstant(c, attribute_name_index, CONSTANT_Utf8);
 560
 561                 if (attribute_name == NULL)
 562                         return false;
 563
 564                 if (attribute_name == utf_InnerClasses) {
 565                         /* InnerClasses */
 566
 567                         if (c->innerclass != NULL) {
 568                                 exceptions_throw_classformaterror(c, "Multiple InnerClasses attributes");
 569                                 return false;
 570                         }
 571
 572                         if (!suck_check_classbuffer_size(cb, 4 + 2))
 573                                 return false;
 574
 575                         /* skip attribute length */
 576                         suck_u4(cb);
 577
 578                         /* number of records */
 579                         c->innerclasscount = suck_u2(cb);
 580
 581                         if (!suck_check_classbuffer_size(cb, (2 + 2 + 2 + 2) * c->innerclasscount))
 582                                 return false;
 583
 584                         /* allocate memory for innerclass structure */
 585                         c->innerclass = MNEW(innerclassinfo, c->innerclasscount);
 586
 587                         for (j = 0; j < c->innerclasscount; j++) {
 588                                 /* The innerclass structure contains a class with an encoded
 589                                    name, its defining scope, its simple name and a bitmask of
 590                                    the access flags. */
 591
 592                                 info = c->innerclass + j;
 593
 594                                 inner.ref = innerclass_getconstant(c, suck_u2(cb), CONSTANT_Class);
 595                                 outer.ref = innerclass_getconstant(c, suck_u2(cb), CONSTANT_Class);
 596                                 name      = innerclass_getconstant(c, suck_u2(cb), CONSTANT_Utf8);
 597                                 flags     = suck_u2(cb);
 598
 599                                 /* If the current inner-class is the currently loaded
 600                                    class check for some special flags. */
 601
 602                                 if (inner.ref->name == c->name) {
 603                                         /* If an inner-class is not a member, its
 604                                            outer-class is NULL. */
 605
 606                                         if (outer.ref != NULL) {
 607                                                 c->flags |= ACC_CLASS_MEMBER;
 608
 609                                                 /* A member class doesn't have an
 610                                                    EnclosingMethod attribute, so set the
 611                                                    enclosing-class to be the same as the
 612                                                    declaring-class. */
 613
 614                                                 c->declaringclass = outer;
 615                                                 c->enclosingclass = outer;
 616                                         }
 617
 618                                         /* If an inner-class is anonymous, its name is
 619                                            NULL. */
 620
 621                                         if (name == NULL)
 622                                                 c->flags |= ACC_CLASS_ANONYMOUS;
 623                                 }
 624
 625                                 info->inner_class = inner;
 626                                 info->outer_class = outer;
 627                                 info->name        = name;
 628                                 info->flags       = flags;
 629                         }
 630                 }
 631                 else if (attribute_name == utf_SourceFile) {
 632                         /* SourceFile */
 633
 634                         if (!class_load_attribute_sourcefile(cb))
 635                                 return false;
 636                 }
 637 #if defined(ENABLE_JAVASE)
 638                 else if (attribute_name == utf_EnclosingMethod) {
 639                         /* EnclosingMethod */
 640
 641                         if (!class_load_attribute_enclosingmethod(cb))
 642                                 return false;
 643                 }
 644                 else if (attribute_name == utf_Signature) {
 645                         /* Signature */
 646
 647                         if (!loader_load_attribute_signature(cb, &(c->signature)))
 648                                 return false;
 649                 }
 650 #endif
 651
 652 #if defined(ENABLE_ANNOTATIONS)
 653                 /* XXX We can't do a release with that enabled */
 654
 655                 else if (attribute_name == utf_RuntimeVisibleAnnotations) {
 656                         /* RuntimeVisibleAnnotations */
 657                         if (!annotation_load_class_attribute_runtimevisibleannotations(cb))
 658                                 return false;
 659                 }
 660                 /* XXX RuntimeInvisibleAnnotations should only be loaded
 661                  * (or returned to Java) if some commandline options says so.
 662                  * Currently there is no such option available in cacao,
 663                  * therefore I load them allways (for testing purpose).
 664                  * Anyway, bytecode for RuntimeInvisibleAnnotations is only
 665                  * generated if you tell javac to do so. So in most cases
 666                  * there won't be any.
 667                  */
 668                 else if (attribute_name == utf_RuntimeInvisibleAnnotations) {
 669                         /* RuntimeInvisibleAnnotations */
 670                         if (!annotation_load_class_attribute_runtimeinvisibleannotations(cb))
 671                                 return false;
 672                 }
 673 #endif
 674
 675                 else {
 676                         /* unknown attribute */
 677
 678                         if (!loader_skip_attribute_body(cb))
 679                                 return false;
 680                 }
 681         }
 682
 683         return true;
 684 }
 685
 686
 687 /* class_freepool **************************************************************
 688
 689         Frees all resources used by this classes Constant Pool.
 690
 691 *******************************************************************************/
 692
 693 static void class_freecpool(classinfo *c)
 694 {
 695         u4 idx;
 696         u4 tag;
 697         voidptr info;
 698
 699         if (c->cptags && c->cpinfos) {
 700                 for (idx = 0; idx < c->cpcount; idx++) {
 701                         tag = c->cptags[idx];
 702                         info = c->cpinfos[idx];
 703
 704                         if (info != NULL) {
 705                                 switch (tag) {
 706                                 case CONSTANT_Fieldref:
 707                                 case CONSTANT_Methodref:
 708                                 case CONSTANT_InterfaceMethodref:
 709                                         FREE(info, constant_FMIref);
 710                                         break;
 711                                 case CONSTANT_Integer:
 712                                         FREE(info, constant_integer);
 713                                         break;
 714                                 case CONSTANT_Float:
 715                                         FREE(info, constant_float);
 716                                         break;
 717                                 case CONSTANT_Long:
 718                                         FREE(info, constant_long);
 719                                         break;
 720                                 case CONSTANT_Double:
 721                                         FREE(info, constant_double);
 722                                         break;
 723                                 case CONSTANT_NameAndType:
 724                                         FREE(info, constant_nameandtype);
 725                                         break;
 726                                 }
 727                         }
 728                 }
 729         }
 730
 731         if (c->cptags)
 732                 MFREE(c->cptags, u1, c->cpcount);
 733
 734         if (c->cpinfos)
 735                 MFREE(c->cpinfos, voidptr, c->cpcount);
 736 }
 737
 738
 739 /* class_getconstant ***********************************************************
 740
 741    Retrieves the value at position 'pos' of the constantpool of a
 742    class. If the type of the value is other than 'ctype', an error is
 743    thrown.
 744
 745 *******************************************************************************/
 746
 747 voidptr class_getconstant(classinfo *c, u4 pos, u4 ctype)
 748 {
 749         /* check index and type of constantpool entry */
 750         /* (pos == 0 is caught by type comparison) */
 751
 752         if ((pos >= c->cpcount) || (c->cptags[pos] != ctype)) {
 753                 exceptions_throw_classformaterror(c, "Illegal constant pool index");
 754                 return NULL;
 755         }
 756
 757         return c->cpinfos[pos];
 758 }
 759
 760
 761 /* innerclass_getconstant ******************************************************
 762
 763    Like class_getconstant, but if cptags is ZERO, null is returned.
 764
 765 *******************************************************************************/
 766
 767 voidptr innerclass_getconstant(classinfo *c, u4 pos, u4 ctype)
 768 {
 769         /* invalid position in constantpool */
 770
 771         if (pos >= c->cpcount) {
 772                 exceptions_throw_classformaterror(c, "Illegal constant pool index");
 773                 return NULL;
 774         }
 775
 776         /* constantpool entry of type 0 */
 777
 778         if (c->cptags[pos] == 0)
 779                 return NULL;
 780
 781         /* check type of constantpool entry */
 782
 783         if (c->cptags[pos] != ctype) {
 784                 exceptions_throw_classformaterror(c, "Illegal constant pool index");
 785                 return NULL;
 786         }
 787
 788         return c->cpinfos[pos];
 789 }
 790
 791
 792 /* class_free ******************************************************************
 793
 794    Frees all resources used by the class.
 795
 796 *******************************************************************************/
 797
 798 void class_free(classinfo *c)
 799 {
 800         s4 i;
 801         vftbl_t *v;
 802
 803         class_freecpool(c);
 804
 805         if (c->interfaces)
 806                 MFREE(c->interfaces, classinfo*, c->interfacescount);
 807
 808         if (c->fields) {
 809                 for (i = 0; i < c->fieldscount; i++)
 810                         field_free(&(c->fields[i]));
 811 #if defined(ENABLE_CACAO_GC)
 812                 MFREE(c->fields, fieldinfo, c->fieldscount);
 813 #endif
 814         }
 815
 816         if (c->methods) {
 817                 for (i = 0; i < c->methodscount; i++)
 818                         method_free(&(c->methods[i]));
 819                 MFREE(c->methods, methodinfo, c->methodscount);
 820         }
 821
 822         if ((v = c->vftbl) != NULL) {
 823                 if (v->arraydesc)
 824                         mem_free(v->arraydesc,sizeof(arraydescriptor));
 825
 826                 for (i = 0; i < v->interfacetablelength; i++) {
 827                         MFREE(v->interfacetable[-i], methodptr, v->interfacevftbllength[i]);
 828                 }
 829                 MFREE(v->interfacevftbllength, s4, v->interfacetablelength);
 830
 831                 i = sizeof(vftbl_t) + sizeof(methodptr) * (v->vftbllength - 1) +
 832                     sizeof(methodptr*) * (v->interfacetablelength -
 833                                          (v->interfacetablelength > 0));
 834                 v = (vftbl_t*) (((methodptr*) v) -
 835                                                 (v->interfacetablelength - 1) * (v->interfacetablelength > 1));
 836                 mem_free(v, i);
 837         }
 838
 839         if (c->innerclass)
 840                 MFREE(c->innerclass, innerclassinfo, c->innerclasscount);
 841
 842         /*      if (c->classvftbl)
 843                 mem_free(c->header.vftbl, sizeof(vftbl) + sizeof(methodptr)*(c->vftbl->vftbllength-1)); */
 844
 845 /*      GCFREE(c); */
 846 }
 847
 848
 849 /* get_array_class *************************************************************
 850
 851    Returns the array class with the given name for the given
 852    classloader, or NULL if an exception occurred.
 853
 854    Note: This function does eager loading.
 855
 856 *******************************************************************************/
 857
 858 static classinfo *get_array_class(utf *name,classloader *initloader,
 859                                                                                         classloader *defloader,bool link)
 860 {
 861         classinfo *c;
 862
 863         /* lookup this class in the classcache */
 864         c = classcache_lookup(initloader,name);
 865         if (!c)
 866                 c = classcache_lookup_defined(defloader,name);
 867
 868         if (!c) {
 869                 /* we have to create it */
 870                 c = class_create_classinfo(name);
 871                 c = load_newly_created_array(c,initloader);
 872                 if (c == NULL)
 873                         return NULL;
 874         }
 875
 876         assert(c);
 877         assert(c->state & CLASS_LOADED);
 878         assert(c->classloader == defloader);
 879
 880         if (link && !(c->state & CLASS_LINKED))
 881                 if (!link_class(c))
 882                         return NULL;
 883
 884         assert(!link || (c->state & CLASS_LINKED));
 885
 886         return c;
 887 }
 888
 889
 890 /* class_array_of **************************************************************
 891
 892    Returns an array class with the given component class. The array
 893    class is dynamically created if neccessary.
 894
 895 *******************************************************************************/
 896
 897 classinfo *class_array_of(classinfo *component, bool link)
 898 {
 899         classloader       *cl;
 900     s4                 namelen;
 901     char              *namebuf;
 902         utf               *u;
 903         classinfo         *c;
 904         s4                 dumpsize;
 905
 906         cl = component->classloader;
 907
 908         dumpsize = dump_size();
 909
 910     /* Assemble the array class name */
 911     namelen = component->name->blength;
 912
 913     if (component->name->text[0] == '[') {
 914         /* the component is itself an array */
 915         namebuf = DMNEW(char, namelen + 1);
 916         namebuf[0] = '[';
 917         MCOPY(namebuf + 1, component->name->text, char, namelen);
 918         namelen++;
 919     }
 920         else {
 921         /* the component is a non-array class */
 922         namebuf = DMNEW(char, namelen + 3);
 923         namebuf[0] = '[';
 924         namebuf[1] = 'L';
 925         MCOPY(namebuf + 2, component->name->text, char, namelen);
 926         namebuf[2 + namelen] = ';';
 927         namelen += 3;
 928     }
 929
 930         u = utf_new(namebuf, namelen);
 931
 932         c = get_array_class(u, cl, cl, link);
 933
 934         dump_release(dumpsize);
 935
 936         return c;
 937 }
 938
 939
 940 /* class_multiarray_of *********************************************************
 941
 942    Returns an array class with the given dimension and element class.
 943    The array class is dynamically created if neccessary.
 944
 945 *******************************************************************************/
 946
 947 classinfo *class_multiarray_of(s4 dim, classinfo *element, bool link)
 948 {
 949     s4 namelen;
 950     char *namebuf;
 951         s4 dumpsize;
 952         classinfo *c;
 953
 954         dumpsize = dump_size();
 955
 956         if (dim < 1) {
 957                 log_text("Invalid array dimension requested");
 958                 assert(0);
 959         }
 960
 961     /* Assemble the array class name */
 962     namelen = element->name->blength;
 963
 964     if (element->name->text[0] == '[') {
 965         /* the element is itself an array */
 966         namebuf = DMNEW(char, namelen + dim);
 967         memcpy(namebuf + dim, element->name->text, namelen);
 968         namelen += dim;
 969     }
 970     else {
 971         /* the element is a non-array class */
 972         namebuf = DMNEW(char, namelen + 2 + dim);
 973         namebuf[dim] = 'L';
 974         memcpy(namebuf + dim + 1, element->name->text, namelen);
 975         namelen += (2 + dim);
 976         namebuf[namelen - 1] = ';';
 977     }
 978         memset(namebuf, '[', dim);
 979
 980         c = get_array_class(utf_new(namebuf, namelen),
 981                                                 element->classloader,
 982                                                 element->classloader,
 983                                                 link);
 984
 985         dump_release(dumpsize);
 986
 987         return c;
 988 }
 989
 990
 991 /* class_lookup_classref *******************************************************
 992
 993    Looks up the constant_classref for a given classname in the classref
 994    tables of a class.
 995
 996    IN:
 997        cls..............the class containing the reference
 998            name.............the name of the class refered to
 999
1000     RETURN VALUE:
1001            a pointer to a constant_classref, or
1002            NULL if the reference was not found
1003
1004 *******************************************************************************/
1005
1006 constant_classref *class_lookup_classref(classinfo *cls, utf *name)
1007 {
1008         constant_classref *ref;
1009         extra_classref *xref;
1010         int count;
1011
1012         assert(cls);
1013         assert(name);
1014         assert(!cls->classrefcount || cls->classrefs);
1015
1016         /* first search the main classref table */
1017         count = cls->classrefcount;
1018         ref = cls->classrefs;
1019         for (; count; --count, ++ref)
1020                 if (ref->name == name)
1021                         return ref;
1022
1023         /* next try the list of extra classrefs */
1024         for (xref = cls->extclassrefs; xref; xref = xref->next) {
1025                 if (xref->classref.name == name)
1026                         return &(xref->classref);
1027         }
1028
1029         /* not found */
1030         return NULL;
1031 }
1032
1033
1034 /* class_get_classref **********************************************************
1035
1036    Returns the constant_classref for a given classname.
1037
1038    IN:
1039        cls..............the class containing the reference
1040            name.............the name of the class refered to
1041
1042    RETURN VALUE:
1043        a pointer to a constant_classref (never NULL)
1044
1045    NOTE:
1046        The given name is not checked for validity!
1047
1048 *******************************************************************************/
1049
1050 constant_classref *class_get_classref(classinfo *cls, utf *name)
1051 {
1052         constant_classref *ref;
1053         extra_classref *xref;
1054
1055         assert(cls);
1056         assert(name);
1057
1058         ref = class_lookup_classref(cls,name);
1059         if (ref)
1060                 return ref;
1061
1062         xref = NEW(extra_classref);
1063         CLASSREF_INIT(xref->classref,cls,name);
1064
1065         xref->next = cls->extclassrefs;
1066         cls->extclassrefs = xref;
1067
1068         return &(xref->classref);
1069 }
1070
1071
1072 /* class_get_self_classref *****************************************************
1073
1074    Returns the constant_classref to the class itself.
1075
1076    IN:
1077        cls..............the class containing the reference
1078
1079    RETURN VALUE:
1080        a pointer to a constant_classref (never NULL)
1081
1082 *******************************************************************************/
1083
1084 constant_classref *class_get_self_classref(classinfo *cls)
1085 {
1086         /* XXX this should be done in a faster way. Maybe always make */
1087         /* the classref of index 0 a self reference.                  */
1088         return class_get_classref(cls,cls->name);
1089 }
1090
1091 /* class_get_classref_multiarray_of ********************************************
1092
1093    Returns an array type reference with the given dimension and element class
1094    reference.
1095
1096    IN:
1097        dim..............the requested dimension
1098                             dim must be in [1;255]. This is NOT checked!
1099            ref..............the component class reference
1100
1101    RETURN VALUE:
1102        a pointer to the class reference for the array type
1103
1104    NOTE:
1105        The referer of `ref` is used as the referer for the new classref.
1106
1107 *******************************************************************************/
1108
1109 constant_classref *class_get_classref_multiarray_of(s4 dim, constant_classref *ref)
1110 {
1111     s4 namelen;
1112     char *namebuf;
1113         s4 dumpsize;
1114         constant_classref *cr;
1115
1116         assert(ref);
1117         assert(dim >= 1 && dim <= 255);
1118
1119         dumpsize = dump_size();
1120
1121     /* Assemble the array class name */
1122     namelen = ref->name->blength;
1123
1124     if (ref->name->text[0] == '[') {
1125         /* the element is itself an array */
1126         namebuf = DMNEW(char, namelen + dim);
1127         memcpy(namebuf + dim, ref->name->text, namelen);
1128         namelen += dim;
1129     }
1130     else {
1131         /* the element is a non-array class */
1132         namebuf = DMNEW(char, namelen + 2 + dim);
1133         namebuf[dim] = 'L';
1134         memcpy(namebuf + dim + 1, ref->name->text, namelen);
1135         namelen += (2 + dim);
1136         namebuf[namelen - 1] = ';';
1137     }
1138         memset(namebuf, '[', dim);
1139
1140     cr = class_get_classref(ref->referer,utf_new(namebuf, namelen));
1141
1142         dump_release(dumpsize);
1143
1144         return cr;
1145 }
1146
1147
1148 /* class_get_classref_component_of *********************************************
1149
1150    Returns the component classref of a given array type reference
1151
1152    IN:
1153        ref..............the array type reference
1154
1155    RETURN VALUE:
1156        a reference to the component class, or
1157            NULL if `ref` is not an object array type reference
1158
1159    NOTE:
1160        The referer of `ref` is used as the referer for the new classref.
1161
1162 *******************************************************************************/
1163
1164 constant_classref *class_get_classref_component_of(constant_classref *ref)
1165 {
1166         s4 namelen;
1167         char *name;
1168
1169         assert(ref);
1170
1171         name = ref->name->text;
1172         if (*name++ != '[')
1173                 return NULL;
1174
1175         namelen = ref->name->blength - 1;
1176         if (*name == 'L') {
1177                 name++;
1178                 namelen -= 2;
1179         }
1180         else if (*name != '[') {
1181                 return NULL;
1182         }
1183
1184     return class_get_classref(ref->referer, utf_new(name, namelen));
1185 }
1186
1187
1188 /* class_findmethod ************************************************************
1189
1190    Searches a 'classinfo' structure for a method having the given name
1191    and descriptor. If descriptor is NULL, it is ignored.
1192
1193 *******************************************************************************/
1194
1195 methodinfo *class_findmethod(classinfo *c, utf *name, utf *desc)
1196 {
1197         methodinfo *m;
1198         s4          i;
1199
1200         for (i = 0; i < c->methodscount; i++) {
1201                 m = &(c->methods[i]);
1202
1203                 if ((m->name == name) && ((desc == NULL) || (m->descriptor == desc)))
1204                         return m;
1205         }
1206
1207         return NULL;
1208 }
1209
1210
1211 /* class_resolvemethod *********************************************************
1212
1213    Searches a class and it's super classes for a method.
1214
1215    Superinterfaces are *not* searched.
1216
1217 *******************************************************************************/
1218
1219 methodinfo *class_resolvemethod(classinfo *c, utf *name, utf *desc)
1220 {
1221         methodinfo *m;
1222
1223         while (c) {
1224                 m = class_findmethod(c, name, desc);
1225
1226                 if (m)
1227                         return m;
1228
1229                 /* JVM Specification bug:
1230
1231                    It is important NOT to resolve special <init> and <clinit>
1232                    methods to super classes or interfaces; yet, this is not
1233                    explicited in the specification.  Section 5.4.3.3 should be
1234                    updated appropriately.  */
1235
1236                 if (name == utf_init || name == utf_clinit)
1237                         return NULL;
1238
1239                 c = c->super.cls;
1240         }
1241
1242         return NULL;
1243 }
1244
1245
1246 /* class_resolveinterfacemethod_intern *****************************************
1247
1248    Internally used helper function. Do not use this directly.
1249
1250 *******************************************************************************/
1251
1252 static methodinfo *class_resolveinterfacemethod_intern(classinfo *c,
1253                                                                                                            utf *name, utf *desc)
1254 {
1255         methodinfo *m;
1256         s4          i;
1257
1258         /* try to find the method in the class */
1259
1260         m = class_findmethod(c, name, desc);
1261
1262         if (m != NULL)
1263                 return m;
1264
1265         /* no method found? try the superinterfaces */
1266
1267         for (i = 0; i < c->interfacescount; i++) {
1268                 m = class_resolveinterfacemethod_intern(c->interfaces[i].cls,
1269                                                                                                         name, desc);
1270
1271                 if (m != NULL)
1272                         return m;
1273         }
1274
1275         /* no method found */
1276
1277         return NULL;
1278 }
1279
1280
1281 /* class_resolveclassmethod ****************************************************
1282
1283    Resolves a reference from REFERER to a method with NAME and DESC in
1284    class C.
1285
1286    If the method cannot be resolved the return value is NULL. If
1287    EXCEPT is true *exceptionptr is set, too.
1288
1289 *******************************************************************************/
1290
1291 methodinfo *class_resolveclassmethod(classinfo *c, utf *name, utf *desc,
1292                                                                          classinfo *referer, bool throwexception)
1293 {
1294         classinfo  *cls;
1295         methodinfo *m;
1296         s4          i;
1297
1298 /*      if (c->flags & ACC_INTERFACE) { */
1299 /*              if (throwexception) */
1300 /*                      *exceptionptr = */
1301 /*                              new_exception(string_java_lang_IncompatibleClassChangeError); */
1302 /*              return NULL; */
1303 /*      } */
1304
1305         /* try class c and its superclasses */
1306
1307         cls = c;
1308
1309         m = class_resolvemethod(cls, name, desc);
1310
1311         if (m != NULL)
1312                 goto found;
1313
1314         /* try the superinterfaces */
1315
1316         for (i = 0; i < c->interfacescount; i++) {
1317                 m = class_resolveinterfacemethod_intern(c->interfaces[i].cls,
1318                                                                                                 name, desc);
1319
1320                 if (m != NULL)
1321                         goto found;
1322         }
1323
1324         if (throwexception)
1325                 exceptions_throw_nosuchmethoderror(c, name, desc);
1326
1327         return NULL;
1328
1329  found:
1330         if ((m->flags & ACC_ABSTRACT) && !(c->flags & ACC_ABSTRACT)) {
1331                 if (throwexception)
1332                         exceptions_throw_abstractmethoderror();
1333
1334                 return NULL;
1335         }
1336
1337         /* XXX check access rights */
1338
1339         return m;
1340 }
1341
1342
1343 /* class_resolveinterfacemethod ************************************************
1344
1345    Resolves a reference from REFERER to a method with NAME and DESC in
1346    interface C.
1347
1348    If the method cannot be resolved the return value is NULL. If
1349    EXCEPT is true *exceptionptr is set, too.
1350
1351 *******************************************************************************/
1352
1353 methodinfo *class_resolveinterfacemethod(classinfo *c, utf *name, utf *desc,
1354                                                                                  classinfo *referer, bool throwexception)
1355 {
1356         methodinfo *mi;
1357
1358         if (!(c->flags & ACC_INTERFACE)) {
1359                 if (throwexception)
1360                         exceptions_throw_incompatibleclasschangeerror(c, "Not an interface");
1361
1362                 return NULL;
1363         }
1364
1365         mi = class_resolveinterfacemethod_intern(c, name, desc);
1366
1367         if (mi != NULL)
1368                 return mi;
1369
1370         /* try class java.lang.Object */
1371
1372         mi = class_findmethod(class_java_lang_Object, name, desc);
1373
1374         if (mi != NULL)
1375                 return mi;
1376
1377         if (throwexception)
1378                 exceptions_throw_nosuchmethoderror(c, name, desc);
1379
1380         return NULL;
1381 }
1382
1383
1384 /* class_findfield *************************************************************
1385
1386    Searches for field with specified name and type in a classinfo
1387    structure. If no such field is found NULL is returned.
1388
1389 *******************************************************************************/
1390
1391 fieldinfo *class_findfield(classinfo *c, utf *name, utf *desc)
1392 {
1393         s4 i;
1394
1395         for (i = 0; i < c->fieldscount; i++)
1396                 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
1397                         return &(c->fields[i]);
1398
1399         if (c->super.cls)
1400                 return class_findfield(c->super.cls, name, desc);
1401
1402         return NULL;
1403 }
1404
1405
1406 /* class_findfield_approx ******************************************************
1407
1408    Searches in 'classinfo'-structure for a field with the specified
1409    name.
1410
1411 *******************************************************************************/
1412
1413 fieldinfo *class_findfield_by_name(classinfo *c, utf *name)
1414 {
1415         s4 i;
1416
1417         /* get field index */
1418
1419         i = class_findfield_index_by_name(c, name);
1420
1421         /* field was not found, return */
1422
1423         if (i == -1)
1424                 return NULL;
1425
1426         /* return field address */
1427
1428         return &(c->fields[i]);
1429 }
1430
1431
1432 s4 class_findfield_index_by_name(classinfo *c, utf *name)
1433 {
1434         s4 i;
1435
1436         for (i = 0; i < c->fieldscount; i++) {
1437                 /* compare field names */
1438
1439                 if ((c->fields[i].name == name))
1440                         return i;
1441         }
1442
1443         /* field was not found, raise exception */
1444
1445         exceptions_throw_nosuchfielderror(c, name);
1446
1447         return -1;
1448 }
1449
1450
1451 /****************** Function: class_resolvefield_int ***************************
1452
1453     This is an internally used helper function. Do not use this directly.
1454
1455         Tries to resolve a field having the given name and type.
1456     If the field cannot be resolved, NULL is returned.
1457
1458 *******************************************************************************/
1459
1460 static fieldinfo *class_resolvefield_int(classinfo *c, utf *name, utf *desc)
1461 {
1462         fieldinfo *fi;
1463         s4         i;
1464
1465         /* search for field in class c */
1466
1467         for (i = 0; i < c->fieldscount; i++) {
1468                 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc)) {
1469                         return &(c->fields[i]);
1470                 }
1471     }
1472
1473         /* try superinterfaces recursively */
1474
1475         for (i = 0; i < c->interfacescount; i++) {
1476                 fi = class_resolvefield_int(c->interfaces[i].cls, name, desc);
1477                 if (fi)
1478                         return fi;
1479         }
1480
1481         /* try superclass */
1482
1483         if (c->super.cls)
1484                 return class_resolvefield_int(c->super.cls, name, desc);
1485
1486         /* not found */
1487
1488         return NULL;
1489 }
1490
1491
1492 /********************* Function: class_resolvefield ***************************
1493
1494         Resolves a reference from REFERER to a field with NAME and DESC in class C.
1495
1496     If the field cannot be resolved the return value is NULL. If EXCEPT is
1497     true *exceptionptr is set, too.
1498
1499 *******************************************************************************/
1500
1501 fieldinfo *class_resolvefield(classinfo *c, utf *name, utf *desc,
1502                                                           classinfo *referer, bool throwexception)
1503 {
1504         fieldinfo *fi;
1505
1506         fi = class_resolvefield_int(c, name, desc);
1507
1508         if (!fi) {
1509                 if (throwexception)
1510                         exceptions_throw_nosuchfielderror(c, name);
1511
1512                 return NULL;
1513         }
1514
1515         /* XXX check access rights */
1516
1517         return fi;
1518 }
1519
1520
1521 /* class_resolve_superclass ****************************************************
1522
1523    Resolves the super class reference of the given class if necessary.
1524
1525 *******************************************************************************/
1526
1527 static classinfo *class_resolve_superclass(classinfo *c)
1528 {
1529         classinfo *super;
1530
1531         if (c->super.any == NULL)
1532                 return NULL;
1533
1534         /* Check if the super class is a reference. */
1535
1536         if (IS_CLASSREF(c->super)) {
1537                 /* XXX I'm very sure this is not correct. */
1538                 super = resolve_classref_or_classinfo_eager(c->super, true);
1539 /*              super = resolve_classref_or_classinfo_eager(c->super, false); */
1540
1541                 if (super == NULL)
1542                         return NULL;
1543
1544                 /* Store the resolved super class in the class structure. */
1545
1546                 c->super.cls = super;
1547         }
1548
1549         return c->super.cls;
1550 }
1551
1552
1553 /* class_issubclass ************************************************************
1554
1555    Checks if sub is a descendant of super.
1556
1557 *******************************************************************************/
1558
1559 bool class_issubclass(classinfo *sub, classinfo *super)
1560 {
1561         for (;;) {
1562                 if (sub == NULL)
1563                         return false;
1564
1565                 if (sub == super)
1566                         return true;
1567
1568 /*              sub = class_resolve_superclass(sub); */
1569                 if (sub->super.any == NULL)
1570                         return false;
1571
1572                 assert(IS_CLASSREF(sub->super) == 0);
1573
1574                 sub = sub->super.cls;
1575         }
1576 }
1577
1578
1579 /* class_isanysubclass *********************************************************
1580
1581    Checks a subclass relation between two classes. Implemented
1582    interfaces are interpreted as super classes.
1583
1584    Return value: 1 ... sub is subclass of super
1585                  0 ... otherwise
1586
1587 *******************************************************************************/
1588
1589 bool class_isanysubclass(classinfo *sub, classinfo *super)
1590 {
1591         uint32_t diffval;
1592         bool     result;
1593
1594         /* This is the trivial case. */
1595
1596         if (sub == super)
1597                 return true;
1598
1599         /* Primitive classes are only subclasses of themselves. */
1600
1601         if (class_is_primitive(sub) || class_is_primitive(super))
1602                 return false;
1603
1604         /* Check for interfaces. */
1605
1606         if (super->flags & ACC_INTERFACE) {
1607                 result = (sub->vftbl->interfacetablelength > super->index) &&
1608                         (sub->vftbl->interfacetable[-super->index] != NULL);
1609         }
1610         else {
1611                 /* java.lang.Object is the only super class of any
1612                    interface. */
1613
1614                 if (sub->flags & ACC_INTERFACE)
1615                         return (super == class_java_lang_Object);
1616
1617                 LOCK_MONITOR_ENTER(linker_classrenumber_lock);
1618
1619                 diffval = sub->vftbl->baseval - super->vftbl->baseval;
1620                 result  = diffval <= (uint32_t) super->vftbl->diffval;
1621
1622                 LOCK_MONITOR_EXIT(linker_classrenumber_lock);
1623         }
1624
1625         return result;
1626 }
1627
1628
1629 /* class_is_primitive **********************************************************
1630
1631    Checks if the given class is a primitive class.
1632
1633 *******************************************************************************/
1634
1635 bool class_is_primitive(classinfo *c)
1636 {
1637         if (c->flags & ACC_CLASS_PRIMITIVE)
1638                 return true;
1639
1640         return false;
1641 }
1642
1643
1644 /* class_is_anonymousclass *****************************************************
1645
1646    Checks if the given class is an anonymous class.
1647
1648 *******************************************************************************/
1649
1650 bool class_is_anonymousclass(classinfo *c)
1651 {
1652         if (c->flags & ACC_CLASS_ANONYMOUS)
1653                 return true;
1654
1655         return false;
1656 }
1657
1658
1659 /* class_is_array **************************************************************
1660
1661    Checks if the given class is an array class.
1662
1663 *******************************************************************************/
1664
1665 bool class_is_array(classinfo *c)
1666 {
1667         if (!(c->state & CLASS_LINKED))
1668                 if (!link_class(c))
1669                         return false;
1670
1671         return (c->vftbl->arraydesc != NULL);
1672 }
1673
1674
1675 /* class_is_interface **********************************************************
1676
1677    Checks if the given class is an interface.
1678
1679 *******************************************************************************/
1680
1681 bool class_is_interface(classinfo *c)
1682 {
1683         if (c->flags & ACC_INTERFACE)
1684                 return true;
1685
1686         return false;
1687 }
1688
1689
1690 /* class_is_localclass *********************************************************
1691
1692    Checks if the given class is a local class.
1693
1694 *******************************************************************************/
1695
1696 bool class_is_localclass(classinfo *c)
1697 {
1698         if ((c->enclosingmethod != NULL) && !class_is_anonymousclass(c))
1699                 return true;
1700
1701         return false;
1702 }
1703
1704
1705 /* class_is_memberclass ********************************************************
1706
1707    Checks if the given class is a member class.
1708
1709 *******************************************************************************/
1710
1711 bool class_is_memberclass(classinfo *c)
1712 {
1713         if (c->flags & ACC_CLASS_MEMBER)
1714                 return true;
1715
1716         return false;
1717 }
1718
1719
1720 /* class_get_superclass ********************************************************
1721
1722    Return the super class of the given class.  If the super-field is a
1723    class-reference, resolve it and store it in the classinfo.
1724
1725 *******************************************************************************/
1726
1727 classinfo *class_get_superclass(classinfo *c)
1728 {
1729         classinfo *super;
1730
1731         /* For java.lang.Object, primitive and Void classes we return
1732            NULL. */
1733
1734         if (c->super.any == NULL)
1735                 return NULL;
1736
1737         /* For interfaces we also return NULL. */
1738
1739         if (c->flags & ACC_INTERFACE)
1740                 return NULL;
1741
1742         /* We may have to resolve the super class reference. */
1743
1744         super = class_resolve_superclass(c);
1745
1746         return super;
1747 }
1748
1749
1750 /* class_get_componenttype *****************************************************
1751
1752    Return the component class of the given class.  If the given class
1753    is not an array, return NULL.
1754
1755 *******************************************************************************/
1756
1757 classinfo *class_get_componenttype(classinfo *c)
1758 {
1759         classinfo       *component;
1760         arraydescriptor *ad;
1761
1762         /* XXX maybe we could find a way to do this without linking. */
1763         /* This way should be safe and easy, however.                */
1764
1765         if (!(c->state & CLASS_LINKED))
1766                 if (!link_class(c))
1767                         return NULL;
1768
1769         ad = c->vftbl->arraydesc;
1770
1771         if (ad == NULL)
1772                 return NULL;
1773
1774         if (ad->arraytype == ARRAYTYPE_OBJECT)
1775                 component = ad->componentvftbl->class;
1776         else
1777                 component = primitive_class_get_by_type(ad->arraytype);
1778
1779         return component;
1780 }
1781
1782
1783 /* class_get_declaredclasses ***************************************************
1784
1785    Return an array of declared classes of the given class.
1786
1787 *******************************************************************************/
1788
1789 java_handle_objectarray_t *class_get_declaredclasses(classinfo *c, bool publicOnly)
1790 {
1791         classref_or_classinfo  inner;
1792         classref_or_classinfo  outer;
1793         utf                   *outername;
1794         int                    declaredclasscount;  /* number of declared classes */
1795         int                    pos;                     /* current declared class */
1796         java_handle_objectarray_t *oa;               /* array of declared classes */
1797         int                    i;
1798         classinfo             *ic;
1799
1800         declaredclasscount = 0;
1801
1802         if (!class_is_primitive(c) && !class_is_array(c)) {
1803                 /* Determine number of declared classes. */
1804
1805                 for (i = 0; i < c->innerclasscount; i++) {
1806                         /* Get outer-class.  If the inner-class is not a member
1807                            class, the outer-class is NULL. */
1808
1809                         outer = c->innerclass[i].outer_class;
1810
1811                         if (outer.any == NULL)
1812                                 continue;
1813
1814                         /* Check if outer-class is a classref or a real class and
1815                get the class name from the structure. */
1816
1817                         outername = IS_CLASSREF(outer) ? outer.ref->name : outer.cls->name;
1818
1819                         /* Outer class is this class. */
1820
1821                         if ((outername == c->name) &&
1822                                 ((publicOnly == 0) || (c->innerclass[i].flags & ACC_PUBLIC)))
1823                                 declaredclasscount++;
1824                 }
1825         }
1826
1827         /* Allocate Class[] and check for OOM. */
1828
1829         oa = builtin_anewarray(declaredclasscount, class_java_lang_Class);
1830
1831         if (oa == NULL)
1832                 return NULL;
1833
1834         for (i = 0, pos = 0; i < c->innerclasscount; i++) {
1835                 inner = c->innerclass[i].inner_class;
1836                 outer = c->innerclass[i].outer_class;
1837
1838                 /* Get outer-class.  If the inner-class is not a member class,
1839                    the outer-class is NULL. */
1840
1841                 if (outer.any == NULL)
1842                         continue;
1843
1844                 /* Check if outer_class is a classref or a real class and get
1845                    the class name from the structure. */
1846
1847                 outername = IS_CLASSREF(outer) ? outer.ref->name : outer.cls->name;
1848
1849                 /* Outer class is this class. */
1850
1851                 if ((outername == c->name) &&
1852                         ((publicOnly == 0) || (c->innerclass[i].flags & ACC_PUBLIC))) {
1853
1854                         ic = resolve_classref_or_classinfo_eager(inner, false);
1855
1856                         if (ic == NULL)
1857                                 return NULL;
1858
1859                         if (!(ic->state & CLASS_LINKED))
1860                                 if (!link_class(ic))
1861                                         return NULL;
1862
1863                         LLNI_array_direct(oa, pos++) = (java_object_t *) ic;
1864                 }
1865         }
1866
1867         return oa;
1868 }
1869
1870
1871 /* class_get_declaringclass ****************************************************
1872
1873    If the class or interface given is a member of another class,
1874    return the declaring class.  For array and primitive classes return
1875    NULL.
1876
1877 *******************************************************************************/
1878
1879 classinfo *class_get_declaringclass(classinfo *c)
1880 {
1881         classref_or_classinfo  cr;
1882         classinfo             *dc;
1883
1884         /* Get declaring class. */
1885
1886         cr = c->declaringclass;
1887
1888         if (cr.any == NULL)
1889                 return NULL;
1890
1891         /* Resolve the class if necessary. */
1892
1893         if (IS_CLASSREF(cr)) {
1894 /*              dc = resolve_classref_eager(cr.ref); */
1895                 dc = resolve_classref_or_classinfo_eager(cr, true);
1896
1897                 if (dc == NULL)
1898                         return NULL;
1899
1900                 /* Store the resolved class in the class structure. */
1901
1902                 cr.cls = dc;
1903         }
1904
1905         dc = cr.cls;
1906
1907         return dc;
1908 }
1909
1910
1911 /* class_get_enclosingclass ****************************************************
1912
1913    Return the enclosing class for the given class.
1914
1915 *******************************************************************************/
1916
1917 classinfo *class_get_enclosingclass(classinfo *c)
1918 {
1919         classref_or_classinfo  cr;
1920         classinfo             *ec;
1921
1922         /* Get enclosing class. */
1923
1924         cr = c->enclosingclass;
1925
1926         if (cr.any == NULL)
1927                 return NULL;
1928
1929         /* Resolve the class if necessary. */
1930
1931         if (IS_CLASSREF(cr)) {
1932 /*              ec = resolve_classref_eager(cr.ref); */
1933                 ec = resolve_classref_or_classinfo_eager(cr, true);
1934
1935                 if (ec == NULL)
1936                         return NULL;
1937
1938                 /* Store the resolved class in the class structure. */
1939
1940                 cr.cls = ec;
1941         }
1942
1943         ec = cr.cls;
1944
1945         return ec;
1946 }
1947
1948
1949 /* class_get_interfaces ********************************************************
1950
1951    Return an array of interfaces of the given class.
1952
1953 *******************************************************************************/
1954
1955 java_handle_objectarray_t *class_get_interfaces(classinfo *c)
1956 {
1957         classinfo                 *ic;
1958         java_handle_objectarray_t *oa;
1959         u4                         i;
1960
1961         if (!(c->state & CLASS_LINKED))
1962                 if (!link_class(c))
1963                         return NULL;
1964
1965         oa = builtin_anewarray(c->interfacescount, class_java_lang_Class);
1966
1967         if (oa == NULL)
1968                 return NULL;
1969
1970         for (i = 0; i < c->interfacescount; i++) {
1971                 ic = c->interfaces[i].cls;
1972
1973                 LLNI_array_direct(oa, i) = (java_object_t *) ic;
1974         }
1975
1976         return oa;
1977 }
1978
1979
1980 /* class_get_annotations *******************************************************
1981
1982    Return the unparsed declared annotations in an byte array
1983    of the given class (or NULL if there aren't any).
1984
1985 *******************************************************************************/
1986
1987 java_handle_bytearray_t *class_get_annotations(classinfo *c)
1988 {
1989 #if defined(ENABLE_ANNOTATIONS)
1990         return c->annotations;
1991 #else
1992         return NULL;
1993 #endif
1994 }
1995
1996
1997 /* class_get_signature *********************************************************
1998
1999    Return the signature of the given class.  For array and primitive
2000    classes return NULL.
2001
2002 *******************************************************************************/
2003
2004 #if defined(ENABLE_JAVASE)
2005 utf *class_get_signature(classinfo *c)
2006 {
2007         /* For array and primitive classes return NULL. */
2008
2009         if (class_is_array(c) || class_is_primitive(c))
2010                 return NULL;
2011
2012         return c->signature;
2013 }
2014 #endif
2015
2016
2017 /* class_printflags ************************************************************
2018
2019    Prints flags of a class.
2020
2021 *******************************************************************************/
2022
2023 #if !defined(NDEBUG)
2024 void class_printflags(classinfo *c)
2025 {
2026         if (c == NULL) {
2027                 printf("NULL");
2028                 return;
2029         }
2030
2031         if (c->flags & ACC_PUBLIC)       printf(" PUBLIC");
2032         if (c->flags & ACC_PRIVATE)      printf(" PRIVATE");
2033         if (c->flags & ACC_PROTECTED)    printf(" PROTECTED");
2034         if (c->flags & ACC_STATIC)       printf(" STATIC");
2035         if (c->flags & ACC_FINAL)        printf(" FINAL");
2036         if (c->flags & ACC_SYNCHRONIZED) printf(" SYNCHRONIZED");
2037         if (c->flags & ACC_VOLATILE)     printf(" VOLATILE");
2038         if (c->flags & ACC_TRANSIENT)    printf(" TRANSIENT");
2039         if (c->flags & ACC_NATIVE)       printf(" NATIVE");
2040         if (c->flags & ACC_INTERFACE)    printf(" INTERFACE");
2041         if (c->flags & ACC_ABSTRACT)     printf(" ABSTRACT");
2042 }
2043 #endif
2044
2045
2046 /* class_print *****************************************************************
2047
2048    Prints classname plus flags.
2049
2050 *******************************************************************************/
2051
2052 #if !defined(NDEBUG)
2053 void class_print(classinfo *c)
2054 {
2055         if (c == NULL) {
2056                 printf("NULL");
2057                 return;
2058         }
2059
2060         utf_display_printable_ascii(c->name);
2061         class_printflags(c);
2062 }
2063 #endif
2064
2065
2066 /* class_classref_print ********************************************************
2067
2068    Prints classname plus referer class.
2069
2070 *******************************************************************************/
2071
2072 #if !defined(NDEBUG)
2073 void class_classref_print(constant_classref *cr)
2074 {
2075         if (cr == NULL) {
2076                 printf("NULL");
2077                 return;
2078         }
2079
2080         utf_display_printable_ascii(cr->name);
2081         printf("(ref.by ");
2082         if (cr->referer)
2083                 class_print(cr->referer);
2084         else
2085                 printf("NULL");
2086         printf(")");
2087 }
2088 #endif
2089
2090
2091 /* class_println ***************************************************************
2092
2093    Prints classname plus flags and new line.
2094
2095 *******************************************************************************/
2096
2097 #if !defined(NDEBUG)
2098 void class_println(classinfo *c)
2099 {
2100         class_print(c);
2101         printf("\n");
2102 }
2103 #endif
2104
2105
2106 /* class_classref_println ******************************************************
2107
2108    Prints classname plus referer class and new line.
2109
2110 *******************************************************************************/
2111
2112 #if !defined(NDEBUG)
2113 void class_classref_println(constant_classref *cr)
2114 {
2115         class_classref_print(cr);
2116         printf("\n");
2117 }
2118 #endif
2119
2120
2121 /* class_classref_or_classinfo_print *******************************************
2122
2123    Prints classname plus referer class.
2124
2125 *******************************************************************************/
2126
2127 #if !defined(NDEBUG)
2128 void class_classref_or_classinfo_print(classref_or_classinfo c)
2129 {
2130         if (c.any == NULL) {
2131                 printf("(classref_or_classinfo) NULL");
2132                 return;
2133         }
2134         if (IS_CLASSREF(c))
2135                 class_classref_print(c.ref);
2136         else
2137                 class_print(c.cls);
2138 }
2139 #endif
2140
2141
2142 /* class_classref_or_classinfo_println *****************************************
2143
2144    Prints classname plus referer class and a newline.
2145
2146 *******************************************************************************/
2147
2148 void class_classref_or_classinfo_println(classref_or_classinfo c)
2149 {
2150         class_classref_or_classinfo_println(c);
2151         printf("\n");
2152 }
2153
2154
2155 /* class_showconstantpool ******************************************************
2156
2157    Dump the constant pool of the given class to stdout.
2158
2159 *******************************************************************************/
2160
2161 #if !defined(NDEBUG)
2162 void class_showconstantpool (classinfo *c)
2163 {
2164         u4 i;
2165         voidptr e;
2166
2167         printf ("---- dump of constant pool ----\n");
2168
2169         for (i=0; i<c->cpcount; i++) {
2170                 printf ("#%d:  ", (int) i);
2171
2172                 e = c -> cpinfos [i];
2173                 if (e) {
2174
2175                         switch (c -> cptags [i]) {
2176                         case CONSTANT_Class:
2177                                 printf ("Classreference -> ");
2178                                 utf_display_printable_ascii ( ((constant_classref*)e) -> name );
2179                                 break;
2180                         case CONSTANT_Fieldref:
2181                                 printf ("Fieldref -> ");
2182                                 field_fieldref_print((constant_FMIref *) e);
2183                                 break;
2184                         case CONSTANT_Methodref:
2185                                 printf ("Methodref -> ");
2186                                 method_methodref_print((constant_FMIref *) e);
2187                                 break;
2188                         case CONSTANT_InterfaceMethodref:
2189                                 printf ("InterfaceMethod -> ");
2190                                 method_methodref_print((constant_FMIref *) e);
2191                                 break;
2192                         case CONSTANT_String:
2193                                 printf ("String -> ");
2194                                 utf_display_printable_ascii (e);
2195                                 break;
2196                         case CONSTANT_Integer:
2197                                 printf ("Integer -> %d", (int) ( ((constant_integer*)e) -> value) );
2198                                 break;
2199                         case CONSTANT_Float:
2200                                 printf ("Float -> %f", ((constant_float*)e) -> value);
2201                                 break;
2202                         case CONSTANT_Double:
2203                                 printf ("Double -> %f", ((constant_double*)e) -> value);
2204                                 break;
2205                         case CONSTANT_Long:
2206                                 {
2207                                         u8 v = ((constant_long*)e) -> value;
2208 #if U8_AVAILABLE
2209                                         printf ("Long -> %ld", (long int) v);
2210 #else
2211                                         printf ("Long -> HI: %ld, LO: %ld\n",
2212                                                         (long int) v.high, (long int) v.low);
2213 #endif
2214                                 }
2215                                 break;
2216                         case CONSTANT_NameAndType:
2217                                 {
2218                                         constant_nameandtype *cnt = e;
2219                                         printf ("NameAndType: ");
2220                                         utf_display_printable_ascii (cnt->name);
2221                                         printf (" ");
2222                                         utf_display_printable_ascii (cnt->descriptor);
2223                                 }
2224                                 break;
2225                         case CONSTANT_Utf8:
2226                                 printf ("Utf8 -> ");
2227                                 utf_display_printable_ascii (e);
2228                                 break;
2229                         default:
2230                                 log_text("Invalid type of ConstantPool-Entry");
2231                                 assert(0);
2232                         }
2233                 }
2234
2235                 printf ("\n");
2236         }
2237 }
2238 #endif /* !defined(NDEBUG) */
2239
2240
2241 /* class_showmethods ***********************************************************
2242
2243    Dump info about the fields and methods of the given class to stdout.
2244
2245 *******************************************************************************/
2246
2247 #if !defined(NDEBUG)
2248 void class_showmethods (classinfo *c)
2249 {
2250         s4 i;
2251
2252         printf("--------- Fields and Methods ----------------\n");
2253         printf("Flags: ");
2254         class_printflags(c);
2255         printf("\n");
2256
2257         printf("This: ");
2258         utf_display_printable_ascii(c->name);
2259         printf("\n");
2260
2261         if (c->super.cls) {
2262                 printf("Super: ");
2263                 utf_display_printable_ascii(c->super.cls->name);
2264                 printf ("\n");
2265         }
2266
2267         printf("Index: %d\n", c->index);
2268
2269         printf("Interfaces:\n");
2270         for (i = 0; i < c->interfacescount; i++) {
2271                 printf("   ");
2272                 utf_display_printable_ascii(c->interfaces[i].cls->name);
2273                 printf (" (%d)\n", c->interfaces[i].cls->index);
2274         }
2275
2276         printf("Fields:\n");
2277         for (i = 0; i < c->fieldscount; i++)
2278                 field_println(&(c->fields[i]));
2279
2280         printf("Methods:\n");
2281         for (i = 0; i < c->methodscount; i++) {
2282                 methodinfo *m = &(c->methods[i]);
2283
2284                 if (!(m->flags & ACC_STATIC))
2285                         printf("vftblindex: %d   ", m->vftblindex);
2286
2287                 method_println(m);
2288         }
2289
2290         printf ("Virtual function table:\n");
2291         for (i = 0; i < c->vftbl->vftbllength; i++)
2292                 printf ("entry: %d,  %ld\n", i, (long int) (c->vftbl->table[i]));
2293 }
2294 #endif /* !defined(NDEBUG) */
2295
2296
2297 /*
2298  * These are local overrides for various environment variables in Emacs.
2299  * Please do not remove this and leave it at the end of the file, where
2300  * Emacs will automagically detect them.
2301  * ---------------------------------------------------------------------
2302  * Local variables:
2303  * mode: c
2304  * indent-tabs-mode: t
2305  * c-basic-offset: 4
2306  * tab-width: 4
2307  * End:
2308  * vim:noexpandtab:sw=4:ts=4:
2309  */