src/vm/global.h

   1 /* global.h ********************************************************************
   2
   3         Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
   4
   5         See file COPYRIGHT for information on usage and disclaimer of warranties
   6
   7         Contains global definitions which are used in the whole program, includes
   8         some files and contains global used macros.
   9
  10         Authors: Reinhard Grafl              EMAIL: cacao@complang.tuwien.ac.at
  11                  Andreas  Krall   (andi)     EMAIL: cacao@complang.tuwien.ac.at
  12         Changes: Mark     Probst  (schani)   EMAIL: cacao@complang.tuwien.ac.at
  13                          Philipp  Tomsich (phil)     EMAIL: cacao@complang.tuwien.ac.at
  14
  15         Last Change: $Id: global.h 478 2003-10-06 12:57:38Z carolyn $
  16
  17 *******************************************************************************/
  18
  19 #ifndef __global_h_
  20 #define __global_h_
  21
  22 #include "config.h"
  23
  24 #define NEW_GC              /* if enabled, includes the new gc. -- phil.      */
  25
  26 #define STATISTICS          /* if enabled collects program statistics         */
  27
  28 /*
  29  * JIT_MARKER_SUPPORT is the define used to toggle Just-in-time generated
  30  * marker functions on and off.
  31  *
  32  * SIZE_FROM_CLASSINFO toggles between the bitmap_based and the new method
  33  * of determining the sizes of objects on the heap.
  34  */
  35 #undef JIT_MARKER_SUPPORT        /* phil */
  36 #define SIZE_FROM_CLASSINFO
  37
  38 /* standard includes **********************************************************/
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <time.h>
  44
  45 #include "toolbox/memory.h"
  46 #include "toolbox/chain.h"
  47 #include "toolbox/list.h"
  48 #include "toolbox/loging.h"
  49
  50 /* system dependent types *****************************************************/
  51
  52 #include "types.h"
  53
  54
  55 /* additional data types ******************************************************/
  56
  57 typedef void *voidptr;          /* generic pointer */
  58
  59 typedef int   bool;             /* boolean data type */
  60
  61 #define true  1
  62 #define false 0
  63
  64 #define PRIMITIVETYPE_COUNT  9  /* number of primitive types */
  65
  66 typedef void (*functionptr) (); /* generic function pointer */
  67
  68
  69 #define MAX_ALIGN 8             /* most generic alignment for JavaVM values   */
  70
  71 /* shutdown function **********************************************************/
  72
  73 void cacao_shutdown(s4 status);
  74
  75
  76 /* basic data types ***********************************************************/
  77
  78 #define TYPE_INT      0         /* the JavaVM types must numbered in the      */
  79 #define TYPE_LONG     1         /* same order as the ICMD_Ixxx to ICMD_Axxx   */
  80 #define TYPE_FLOAT    2         /* instructions (LOAD and STORE)              */
  81 #define TYPE_DOUBLE   3         /* integer, long, float, double, address      */
  82 #define TYPE_ADDRESS  4         /* all other types can be numbered arbitrarly */
  83
  84 #define TYPE_VOID    10
  85
  86
  87 /* Java class file constants **************************************************/
  88
  89 #define MAGIC         0xcafebabe
  90 #define MINOR_VERSION 3
  91 #define MAJOR_VERSION 45
  92
  93 #define CONSTANT_Class                 7
  94 #define CONSTANT_Fieldref              9
  95 #define CONSTANT_Methodref            10
  96 #define CONSTANT_InterfaceMethodref   11
  97 #define CONSTANT_String                8
  98 #define CONSTANT_Integer               3
  99 #define CONSTANT_Float                 4
 100 #define CONSTANT_Long                  5
 101 #define CONSTANT_Double                6
 102 #define CONSTANT_NameAndType          12
 103 #define CONSTANT_Utf8                  1
 104
 105 #define CONSTANT_Arraydescriptor      13
 106 #define CONSTANT_UNUSED                0
 107
 108 #define ACC_PUBLIC                0x0001
 109 #define ACC_PRIVATE               0x0002
 110 #define ACC_PROTECTED             0x0004
 111 #define ACC_STATIC                0x0008
 112 #define ACC_FINAL                 0x0010
 113 #define ACC_SYNCHRONIZED          0x0020
 114 #define ACC_VOLATILE              0x0040
 115 #define ACC_TRANSIENT             0x0080
 116 #define ACC_NATIVE                0x0100
 117 #define ACC_INTERFACE             0x0200
 118 #define ACC_ABSTRACT              0x0400
 119
 120
 121 /* resolve typedef cycles *****************************************************/
 122
 123 typedef struct utf utf;
 124 typedef struct literalstring literalstring;
 125 typedef struct java_objectheader java_objectheader;
 126 typedef struct classinfo classinfo;
 127 typedef struct vftbl vftbl;
 128 typedef u1* methodptr;
 129 typedef struct fieldinfo  fieldinfo;
 130 typedef struct methodinfo methodinfo;
 131
 132
 133 /* constant pool entries *******************************************************
 134
 135         All constant pool entries need a data structure which contain the entrys
 136         value. In some cases this structure exist already, in the remaining cases
 137         this structure must be generated:
 138
 139                 kind                      structure                     generated?
 140         ----------------------------------------------------------------------
 141     CONSTANT_Class               classinfo                           no
 142     CONSTANT_Fieldref            constant_FMIref                    yes
 143     CONSTANT_Methodref           constant_FMIref                    yes
 144     CONSTANT_InterfaceMethodref  constant_FMIref                    yes
 145     CONSTANT_String              unicode                             no
 146     CONSTANT_Integer             constant_integer                   yes
 147     CONSTANT_Float               constant_float                     yes
 148     CONSTANT_Long                constant_long                      yes
 149     CONSTANT_Double              constant_double                    yes
 150     CONSTANT_NameAndType         constant_nameandtype               yes
 151     CONSTANT_Utf8                unicode                             no
 152     CONSTANT_Arraydescriptor     constant_arraydescriptor           yes
 153     CONSTANT_UNUSED              -
 154
 155 *******************************************************************************/
 156
 157 /* data structures for hashtables ********************************************
 158
 159
 160         All utf-symbols, javastrings and classes are stored in global hashtables,
 161         so every symbol exists only once. Equal symbols have identical pointers.
 162         The functions for adding hashtable elements search the table for the
 163         element with the specified name/text and return it on success. Otherwise a
 164         new hashtable element is created.
 165
 166     The hashtables use external linking for handling collisions. The hashtable
 167         structure contains a pointer <ptr> to the array of hashtable slots. The
 168         number of hashtable slots and therefore the size of this array is specified
 169         by the element <size> of hashtable structure. <entries> contains the number
 170         of all hashtable elements stored in the table, including those in the
 171         external chains.
 172         The hashtable element structures (utf, literalstring, classinfo) contain
 173         both a pointer to the next hashtable element as a link for the external hash
 174         chain and the key of the element. The key is computed from the text of
 175         the string or the classname by using up to 8 characters.
 176
 177         If the number of entries in the hashtable exceeds twice the size of the
 178         hashtableslot-array it is supposed that the average length of the
 179         external chains has reached a value beyond 2. Therefore the functions for
 180         adding hashtable elements (utf_new, class_new, literalstring_new) double
 181         the hashtableslot-array. In this restructuring process all elements have
 182         to be inserted into the new hashtable and new external chains must be built.
 183
 184
 185 example for the layout of a hashtable:
 186
 187 hashtable.ptr-->  +-------------------+
 188                   |                   |
 189                            ...
 190                   |                   |
 191                   +-------------------+   +-------------------+   +-------------------+
 192                   | hashtable element |-->| hashtable element |-->| hashtable element |-->NULL
 193                   +-------------------+   +-------------------+   +-------------------+
 194                   | hashtable element |
 195                   +-------------------+   +-------------------+
 196                   | hashtable element |-->| hashtable element |-->NULL
 197                   +-------------------+   +-------------------+
 198                   | hashtable element |-->NULL
 199                   +-------------------+
 200                   |                   |
 201                            ...
 202                   |                   |
 203                   +-------------------+
 204
 205 */
 206
 207
 208 /* data structure for utf8 symbols ********************************************/
 209
 210 struct utf {
 211         utf        *hashlink;       /* link for external hash chain               */
 212         int         blength;        /* text length in bytes                       */
 213         char       *text;           /* pointer to text                            */
 214 };
 215
 216 /* data structure of internal javastrings stored in global hashtable **********/
 217
 218 struct literalstring {
 219         literalstring     *hashlink;     /* link for external hash chain          */
 220         java_objectheader *string;
 221 };
 222
 223 /* data structure for accessing hashtables ************************************/
 224
 225 typedef struct {
 226   u4 size;
 227   u4 entries;        /* number of entries in the table */
 228   void **ptr;        /* pointer to hashtable */
 229 } hashtable;
 230
 231 /* data structures of remaining constant pool entries *************************/
 232
 233 typedef struct {                /* Fieldref, Methodref and InterfaceMethodref     */
 234         classinfo *class;       /* class containing this field/method/interface   */
 235         utf       *name;        /* field/method/interface name                    */
 236         utf       *descriptor;  /* field/method/interface type descriptor string  */
 237 } constant_FMIref;
 238
 239 typedef struct {            /* Integer                                        */
 240         s4 value;
 241 } constant_integer;
 242
 243 typedef struct {            /* Float                                          */
 244         float value;
 245 } constant_float;
 246
 247 typedef struct {            /* Long                                           */
 248         s8 value;
 249 } constant_long;
 250
 251 typedef struct {            /* Double                                         */
 252         double value;
 253 } constant_double;
 254
 255 typedef struct {            /* NameAndType (Field or Method)                  */
 256         utf *name;              /* field/method name                              */
 257         utf *descriptor;        /* field/method type descriptor string            */
 258 } constant_nameandtype;
 259
 260 /*  arraydescriptor describes array types. Basic array types contain their
 261         type in the arraytype field, objectclass contains a class pointer for
 262         arrays of objects (arraytype == ARRAYTYPE_OBJECT), elementdescriptor
 263         contains a pointer to an arraydescriptor which describes the element
 264         types in the case of arrays of arrays (arraytype == ARRAYTYPE_ARRAY).
 265 */
 266
 267 typedef struct constant_arraydescriptor {
 268         int arraytype;
 269         classinfo *objectclass;
 270         struct constant_arraydescriptor *elementdescriptor;
 271 } constant_arraydescriptor;
 272
 273 #include "jit/sets.h"
 274
 275 /* data structures of the runtime system **************************************/
 276
 277 /* objects *********************************************************************
 278
 279         All objects (and arrays) which resides on the heap need the following
 280         header at the beginning of the data structure.
 281 */
 282
 283 struct java_objectheader {              /* header for all objects             */
 284         vftbl *vftbl;                       /* pointer to virtual function table  */
 285 };
 286
 287
 288
 289 /* arrays **********************************************************************
 290
 291         All arrays are objects (they need the object header with a pointer to a
 292         vvftbl (array class table). There is only one class for all arrays. The
 293         type of an array is stored directly in the array object. Following types
 294         are defined:
 295 */
 296
 297 #define ARRAYTYPE_INT      0
 298 #define ARRAYTYPE_LONG     1
 299 #define ARRAYTYPE_FLOAT    2
 300 #define ARRAYTYPE_DOUBLE   3
 301 #define ARRAYTYPE_BYTE     4
 302 #define ARRAYTYPE_CHAR     5
 303 #define ARRAYTYPE_SHORT    6
 304 #define ARRAYTYPE_BOOLEAN  7
 305 #define ARRAYTYPE_OBJECT   8
 306 #define ARRAYTYPE_ARRAY    9
 307
 308 typedef struct java_arrayheader {       /* header for all arrays              */
 309         java_objectheader objheader;        /* object header                      */
 310         s4 size;                            /* array size                         */
 311 #ifdef SIZE_FROM_CLASSINFO
 312         s4 alignedsize; /* phil */
 313 #endif
 314         s4 arraytype;                       /* array type from previous list      */
 315 } java_arrayheader;
 316
 317
 318
 319 /* structs for all kinds of arrays ********************************************/
 320
 321 typedef struct java_chararray {
 322         java_arrayheader header;
 323         u2 data[1];
 324 } java_chararray;
 325
 326 typedef struct java_floatheader {
 327         java_arrayheader header;
 328         float data[1];
 329 } java_floatarray;
 330
 331 typedef struct java_doublearray {
 332         java_arrayheader header;
 333         double data[1];
 334 } java_doublearray;
 335
 336 /*  booleanarray and bytearray need identical memory layout (access methods
 337     use the same machine code */
 338
 339 typedef struct java_booleanarray {
 340         java_arrayheader header;
 341         u1 data[1];
 342 } java_booleanarray;
 343
 344 typedef struct java_bytearray {
 345         java_arrayheader header;
 346         s1 data[1];
 347 } java_bytearray;
 348
 349 typedef struct java_shortarray {
 350         java_arrayheader header;
 351         s2 data[1];
 352 } java_shortarray;
 353
 354 typedef struct java_intarray {
 355         java_arrayheader header;
 356         s4 data[1];
 357 } java_intarray;
 358
 359 typedef struct java_longarray {
 360         java_arrayheader header;
 361         s8 data[1];
 362 } java_longarray;
 363
 364 /*  objectarray and arrayarray need identical memory layout (access methods
 365     use the same machine code */
 366
 367 typedef struct java_objectarray {
 368         java_arrayheader header;
 369         classinfo *elementtype;
 370         java_objectheader *data[1];
 371 } java_objectarray;
 372
 373 typedef struct java_arrayarray {
 374         java_arrayheader header;
 375         constant_arraydescriptor *elementdescriptor;
 376         java_arrayheader *data[1];
 377 } java_arrayarray;
 378
 379
 380 /* structure for primitive classes ********************************************/
 381
 382 typedef struct primitivetypeinfo {
 383         classinfo *class_wrap;               /* class for wrapping primitive type */
 384         classinfo *class_primitive;          /* primitive class                   */
 385         char *wrapname;                      /* name of class for wrapping        */
 386         char typesig;                        /* one character type signature      */
 387         char *name;                          /* name of primitive class           */
 388 } primitivetypeinfo;
 389
 390 /* field, method and class structures *****************************************/
 391
 392 /* fieldinfo ******************************************************************/
 393
 394 struct fieldinfo {            /* field of a class                                 */
 395         s4       flags;       /* ACC flags                                        */
 396         s4       type;        /* basic data type                                  */
 397         utf *name;            /* name of field                                    */
 398         utf *descriptor;      /* JavaVM descriptor string of field                */
 399
 400         s4       offset;      /* offset from start of object (instance variables) */
 401
 402         union {               /* storage for static values (class variables)      */
 403                 s4 i;
 404                 s8 l;
 405                 float f;
 406                 double d;
 407                 void *a;
 408         } value;
 409
 410         /*--- XTA ---*/
 411         bool       fieldChecked;
 412         classinfo *fldClassType;
 413         classSet  *XTAclassSet;      /* field class type set                  */
 414         s4        lastRoundChgd;
 415         /*--- VTA ---*/
 416         s4            VTAfieldUsed;             /* -1=marked (might be used) 0=not used 1=used */
 417         classSetNode *VTAclassSet;      /* field class type set                  */
 418
 419 } ;
 420
 421 struct basicblock;
 422
 423 /* exceptiontable *************************************************************/
 424
 425 typedef struct xtable { /* exceptiontable entry in a method           */
 426         s4         startpc;         /* start pc of guarded area (inclusive)       */
 427         struct basicblock *start;
 428
 429         s4         endpc;           /* end pc of guarded area (exklusive)         */
 430         struct basicblock *end;
 431
 432         s4         handlerpc;       /* pc of exception handler                    */
 433         struct basicblock *handler;
 434
 435         classinfo *catchtype;       /* catchtype of exception (NULL == catchall)  */
 436         struct xtable *next;        /* used to build a list of exception when     */
 437                                     /* loops are copied */
 438         struct xtable *down;        /* instead of the old array, a list is used   */
 439 } xtable;
 440
 441
 442 typedef struct exceptiontable { /* exceptiontable entry in a method           */
 443         s4         startpc;         /* start pc of guarded area (inclusive)       */
 444         s4         endpc;           /* end pc of guarded area (exklusive)         */
 445         s4         handlerpc;       /* pc of exception handler                    */
 446         classinfo *catchtype;       /* catchtype of exception (NULL == catchall)  */
 447 } exceptiontable;
 448
 449
 450 /* methodinfo  static info ****************************************************/
 451 /*typedef struct rtainfo {
 452
 453 } rtainfo; */
 454 /* methodinfo *****************************************************************/
 455
 456 struct methodinfo {                     /* method structure                       */
 457         s4             flags;           /* ACC flags                              */
 458         utf       *name;                /* name of method                         */
 459         utf       *descriptor;          /* JavaVM descriptor string of method     */
 460         s4         returntype;          /* only temporary valid, return type      */
 461         classinfo *returnclass;         /* pointer to classinfo for the rtn type  */ /*XTA*/
 462         s4         paramcount;          /* only temporary valid, parameter count  */
 463         u1        *paramtypes;          /* only temporary valid, parameter types  */
 464         classinfo **paramclass;         /* pointer to classinfo for a parameter   */ /*XTA*/
 465
 466         classinfo *class;               /* class, the method belongs to           */
 467         s4         vftblindex;          /* index of method in virtual function table
 468                                            (if it is a virtual method)            */
 469         s4         maxstack;            /* maximum stack depth of method          */
 470         s4         maxlocals;           /* maximum number of local variables      */
 471         s4         jcodelength;         /* length of JavaVM code                  */
 472         u1        *jcode;               /* pointer to JavaVM code                 */
 473
 474         s4         exceptiontablelength;/* exceptiontable length                  */
 475         exceptiontable *exceptiontable;
 476                                     /* the exceptiontable                     */
 477
 478         u1        *stubroutine;         /* stub for compiling or calling natives  */
 479         s4         mcodelength;         /* legth of generated machine code        */
 480         u1        *mcode;               /* pointer to machine code                */
 481         u1        *entrypoint;          /* entry point in machine code            */
 482
 483         /*rtainfo   rta;*/
 484         /*xtainfo   xta;*/
 485
 486         s4        methodUsed;           /* marked (might be used later) /not used /used */
 487         s4        monoPoly;             /* call is mono or poly or unknown        */ /*RT stats */
 488         /* should # method def'd and used be kept after static parse (will it be used?) */
 489         s4        subRedefs;
 490         s4        subRedefsUsed;
 491
 492         /* --- XTA --- */
 493         s4              XTAmethodUsed;  /* XTA if used in callgraph -    not used /used */
 494         classSet        *XTAclassSet;      /* method class type set                 */
 495         classSet        *PartClassSet;     /* method class type set                 */
 496
 497         classSetNode    *paramClassSet;     /* cone set of methods parameters       */
 498
 499         methSet         *calls;            /* methods this method calls             */
 500         methSet         *calledBy;         /* methods that call this method         */
 501         methSet         *marked;           /* methods that marked by this method    */
 502         methSet         *markedBy;
 503         fldSet          *fldsUsed;         /* fields used by this method             */
 504         bool             chgdSinceLastParse; /* Changed since last parse ?          */
 505
 506         s4           lastRoundParsed;   /* Last round parsed                      */
 507         methSetNode  *interfaceCalls;   /* methods this method calls as interface */
 508
 509         /* --- VTA --- */
 510         classSetNode  *VTAclassSet;      /* method class type set                  */
 511         methSetNode   *VTAcalls;         /* methods this method calls             */
 512         classSetNode **VTAlocalSets;    /*VTA*/
 513         classSetNode **VTAstackType;    /*VTA*/
 514 };
 515
 516
 517
 518 /* innerclassinfo *************************************************************/
 519
 520 typedef struct innerclassinfo {
 521         classinfo *inner_class;       /* inner class pointer                      */
 522         classinfo *outer_class;       /* outer class pointer                      */
 523         utf *name;                    /* innerclass name                          */
 524         s4 flags;                     /* ACC flags                                */
 525 } innerclassinfo;
 526
 527 /* classinfo ******************************************************************/
 528
 529 struct classinfo {                /* class structure                          */
 530         java_objectheader header;     /* classes are also objects                 */
 531
 532         s4          flags;            /* ACC flags                                */
 533         utf        *name;             /* class name                               */
 534
 535         s4          cpcount;          /* number of entries in constant pool       */
 536         u1         *cptags;           /* constant pool tags                       */
 537         voidptr    *cpinfos;          /* pointer to constant pool info structures */
 538
 539         classinfo  *super;            /* super class pointer                      */
 540         classinfo  *sub;              /* sub class pointer                        */
 541         classinfo  *nextsub;          /* pointer to next class in sub class list  */
 542
 543         s4          interfacescount;  /* number of interfaces                     */
 544         classinfo **interfaces;       /* pointer to interfaces                    */
 545
 546         s4          fieldscount;      /* number of fields                         */
 547         fieldinfo  *fields;           /* field table                              */
 548
 549         s4          methodscount;     /* number of methods                        */
 550         methodinfo *methods;          /* method table                             */
 551
 552         listnode    listnode;         /* linkage                                  */
 553
 554         bool        initialized;      /* true, if class already initialised       */
 555         bool        linked;           /* true, if class already linked            */
 556         s4          index;            /* hierarchy depth (classes) or index
 557                                          (interfaces)                             */
 558         s4          instancesize;     /* size of an instance of this class        */
 559 #ifdef SIZE_FROM_CLASSINFO
 560         s4          alignedsize;      /* size of an instance, aligned to the
 561                                                       allocation size on the heap */
 562 #endif
 563
 564         vftbl      *vftbl;            /* pointer to virtual function table        */
 565
 566         methodinfo *finalizer;        /* finalizer method                         */
 567 #ifdef JIT_MARKER_SUPPORT
 568         methodinfo *marker;
 569 #endif
 570
 571     u2             innerclasscount;   /* number of inner classes              */
 572     innerclassinfo *innerclass;
 573
 574     classinfo      *hashlink;         /* link for external hash chain         */
 575         bool        classvftbl;       /* has its own copy of the Class vtbl       */
 576
 577         s4          classUsed;        /* 0= not used 1 = used   CO-RT             */
 578
 579         classSetNode *impldBy;          /* implemented by class set */
 580 };
 581
 582
 583 /* virtual function table ******************************************************
 584
 585         The vtbl has a bidirectional layout with open ends at both sides.
 586         interfacetablelength gives the number of entries of the interface table at
 587         the start of the vftbl. The vftbl pointer points to &interfacetable[0].
 588         vftbllength gives the number of entries of table at the end of the vftbl.
 589
 590         runtime type check (checkcast):
 591
 592         Different methods are used for runtime type check depending on the
 593         argument of checkcast/instanceof.
 594
 595         A check against a class is implemented via relative numbering on the class
 596         hierachy tree. The tree is numbered in a depth first traversal setting
 597         the base field and the diff field. The diff field gets the result of
 598         (high - base) so that a range check can be implemented by an unsigned
 599         compare. A sub type test is done by checking the inclusion of base of
 600         the sub class in the range of the superclass.
 601
 602         A check against an interface is implemented via the interfacevftbl. If the
 603         interfacevftbl contains a nonnull value a class is a subclass of this
 604         interface.
 605
 606         interfacetable:
 607
 608         Like standard virtual methods interface methods are called using
 609         virtual function tables. All interfaces are numbered sequentially
 610         (starting with zero). For each class there exist an interface table
 611         of virtual function tables for each implemented interface. The length
 612         of the interface table is determined by the highest number of an
 613         implemented interface.
 614
 615         The following example assumes a class which implements interface 0 and 3:
 616
 617         interfacetablelength = 4
 618
 619                   | ...       |            +----------+
 620                       +-----------+            | method 2 |---> method z
 621                       | class     |            | method 1 |---> method y
 622                       +-----------+            | method 0 |---> method x
 623                       | ivftbl  0 |----------> +----------+
 624         vftblptr ---> +-----------+
 625                   | ivftbl -1 |--> NULL    +----------+
 626                   | ivftbl -2 |--> NULL    | method 1 |---> method x
 627                   | ivftbl -3 |-----+      | method 0 |---> method a
 628                   +-----------+     +----> +----------+
 629
 630                               +---------------+
 631                                   | length 3 = 2  |
 632                                   | length 2 = 0  |
 633                                   | length 1 = 0  |
 634                                   | length 0 = 3  |
 635         interfacevftbllength ---> +---------------+
 636
 637 *******************************************************************************/
 638
 639 struct vftbl {
 640         methodptr   *interfacetable[1];    /* interface table (access via macro)  */
 641
 642         classinfo   *class;                /* class, the vtbl belongs to          */
 643
 644         s4           vftbllength;          /* virtual function table length       */
 645         s4           interfacetablelength; /* interface table length              */
 646
 647         s4           baseval;              /* base for runtime type check         */
 648         s4           diffval;              /* high - base for runtime type check  */
 649
 650         s4          *interfacevftbllength; /* length of interface vftbls          */
 651
 652         methodptr    table[1];             /* class vftbl                         */
 653 };
 654
 655 #define VFTBLINTERFACETABLE(v,i)       (v)->interfacetable[-i]
 656
 657
 658 /* references to some system classes ******************************************/
 659
 660 extern classinfo *class_java_lang_Object;
 661 extern classinfo *class_java_lang_String;
 662 extern classinfo *class_java_lang_ClassCastException;
 663 extern classinfo *class_java_lang_NullPointerException;
 664 extern classinfo *class_java_lang_ArrayIndexOutOfBoundsException;
 665 extern classinfo *class_java_lang_NegativeArraySizeException;
 666 extern classinfo *class_java_lang_OutOfMemoryError;
 667 extern classinfo *class_java_lang_ArithmeticException;
 668 extern classinfo *class_java_lang_ArrayStoreException;
 669 extern classinfo *class_java_lang_ThreadDeath;
 670 extern classinfo *class_array;
 671
 672 /* instances of some system classes *******************************************/
 673
 674 extern java_objectheader *proto_java_lang_ClassCastException;
 675 extern java_objectheader *proto_java_lang_NullPointerException;
 676 extern java_objectheader *proto_java_lang_ArrayIndexOutOfBoundsException;
 677 extern java_objectheader *proto_java_lang_NegativeArraySizeException;
 678 extern java_objectheader *proto_java_lang_OutOfMemoryError;
 679 extern java_objectheader *proto_java_lang_ArithmeticException;
 680 extern java_objectheader *proto_java_lang_ArrayStoreException;
 681 extern java_objectheader *proto_java_lang_ThreadDeath;
 682
 683
 684 /* flag variables *************************************************************/
 685
 686 extern bool compileall;
 687 extern bool runverbose;
 688 extern bool verbose;
 689 extern bool opt_rt;             /* Rapid Type Analysis for better inlining CO-RT*/
 690 extern bool opt_xta;            /* X Type Analysis for better inlining    CO-XTA*/
 691 extern bool opt_vta;            /* Variable Type Analysis for better inlining    CO-VTA*/
 692
 693 extern int pClassHeir;
 694 extern int pCallgraph;
 695 extern int pOpcodes;
 696 extern int pStats;
 697
 698 extern void RT_jit_parse(methodinfo *m);
 699 extern void printCallgraph ();
 700 extern void printRThierarchyInfo(methodinfo *m);
 701 extern void printObjectClassHeirarchy();
 702
 703 extern void XTA_jit_parse(methodinfo *m);
 704
 705 /* statistic variables ********************************************************/
 706
 707 extern int count_class_infos;
 708 extern int count_const_pool_len;
 709 extern int count_vftbl_len;
 710 extern int count_utf_len;
 711 extern int count_all_methods;
 712 extern int count_vmcode_len;
 713 extern int count_extable_len;
 714 extern int count_class_loads;
 715 extern int count_class_inits;
 716 extern int count_utf_new;
 717 extern int count_utf_new_found;
 718
 719 /* table of primitive types ***************************************************/
 720
 721 extern primitivetypeinfo primitivetype_table[PRIMITIVETYPE_COUNT];
 722
 723 #endif
 724
 725
 726 /*
 727  * These are local overrides for various environment variables in Emacs.
 728  * Please do not remove this and leave it at the end of the file, where
 729  * Emacs will automagically detect them.
 730  * ---------------------------------------------------------------------
 731  * Local variables:
 732  * mode: c
 733  * indent-tabs-mode: t
 734  * c-basic-offset: 4
 735  * tab-width: 4
 736  * End:
 737  */