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 527 2003-10-23 17:46:34Z carolyn $
  16
  17 *******************************************************************************/
  18
  19 #ifndef __global_h_
  20 #define __global_h_
  21
  22 #include "config.h"
  23
  24 #define _GNU_SOURCE
  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 typedef struct xtafldinfo {
 393                 bool       fieldChecked;
 394                 classinfo *fldClassType;
 395                 classSet  *XTAclassSet;      /* field class type set                  */
 396                 } xtafldinfo;
 397 /* fieldinfo ******************************************************************/
 398
 399 struct fieldinfo {            /* field of a class                                 */
 400         s4       flags;       /* ACC flags                                        */
 401         s4       type;        /* basic data type                                  */
 402         utf *name;            /* name of field                                    */
 403         utf *descriptor;      /* JavaVM descriptor string of field                */
 404
 405         s4       offset;      /* offset from start of object (instance variables) */
 406
 407         union {               /* storage for static values (class variables)      */
 408                 s4 i;
 409                 s8 l;
 410                 float f;
 411                 double d;
 412                 void *a;
 413         } value;
 414
 415         xtafldinfo *xta;
 416
 417 } ;
 418
 419 struct basicblock;
 420
 421 /* exceptiontable *************************************************************/
 422
 423 typedef struct xtable { /* exceptiontable entry in a method           */
 424         s4         startpc;         /* start pc of guarded area (inclusive)       */
 425         struct basicblock *start;
 426
 427         s4         endpc;           /* end pc of guarded area (exklusive)         */
 428         struct basicblock *end;
 429
 430         s4         handlerpc;       /* pc of exception handler                    */
 431         struct basicblock *handler;
 432
 433         classinfo *catchtype;       /* catchtype of exception (NULL == catchall)  */
 434         struct xtable *next;        /* used to build a list of exception when     */
 435                                     /* loops are copied */
 436         struct xtable *down;        /* instead of the old array, a list is used   */
 437 } xtable;
 438
 439
 440 typedef struct exceptiontable { /* exceptiontable entry in a method           */
 441         s4         startpc;         /* start pc of guarded area (inclusive)       */
 442         s4         endpc;           /* end pc of guarded area (exklusive)         */
 443         s4         handlerpc;       /* pc of exception handler                    */
 444         classinfo *catchtype;       /* catchtype of exception (NULL == catchall)  */
 445 } exceptiontable;
 446
 447
 448 /* methodinfo  static info ****************************************************/
 449 typedef struct xtainfo {
 450         s4              XTAmethodUsed;  /* XTA if used in callgraph -    not used /used */
 451         classSet        *XTAclassSet;      /* method class type set                 */
 452         /*classSet      *PartClassSet */   /* method class type set                 */
 453
 454         classSetNode    *paramClassSet;     /* cone set of methods parameters       */
 455
 456         methSet         *calls;            /* methods this method calls             */
 457         methSet         *calledBy;         /* methods that call this method         */
 458         methSet         *marked;           /* methods that marked by this method    */
 459         /*methSet         *markedBy*/
 460         fldSet          *fldsUsed;         /* fields used by this method             */
 461         /*methSetNode  *interfaceCalls*/   /* methods this method calls as interface */
 462         bool             chgdSinceLastParse; /* Changed since last parse ?          */
 463 } xtainfo;
 464
 465 /* methodinfo *****************************************************************/
 466
 467 struct methodinfo {                     /* method structure                       */
 468         s4             flags;           /* ACC flags                              */
 469         utf       *name;                /* name of method                         */
 470         utf       *descriptor;          /* JavaVM descriptor string of method     */
 471         s4         returntype;          /* only temporary valid, return type      */
 472         classinfo *returnclass;         /* pointer to classinfo for the rtn type  */ /*XTA*/
 473         s4         paramcount;          /* only temporary valid, parameter count  */
 474         u1        *paramtypes;          /* only temporary valid, parameter types  */
 475         classinfo **paramclass;         /* pointer to classinfo for a parameter   */ /*XTA*/
 476
 477         classinfo *class;               /* class, the method belongs to           */
 478         s4         vftblindex;          /* index of method in virtual function table
 479                                            (if it is a virtual method)            */
 480         s4         maxstack;            /* maximum stack depth of method          */
 481         s4         maxlocals;           /* maximum number of local variables      */
 482         s4         jcodelength;         /* length of JavaVM code                  */
 483         u1        *jcode;               /* pointer to JavaVM code                 */
 484
 485         s4         exceptiontablelength;/* exceptiontable length                  */
 486         exceptiontable *exceptiontable;
 487                                     /* the exceptiontable                     */
 488
 489         u1        *stubroutine;         /* stub for compiling or calling natives  */
 490         s4         mcodelength;         /* legth of generated machine code        */
 491         u1        *mcode;               /* pointer to machine code                */
 492         u1        *entrypoint;          /* entry point in machine code            */
 493
 494         /*rtainfo   rta;*/
 495         xtainfo    *xta;
 496
 497         s4        methodUsed;           /* marked (might be used later) /not used /used */
 498         s4        monoPoly;             /* call is mono or poly or unknown        */ /*RT stats */
 499         /* should # method def'd and used be kept after static parse (will it be used?) */
 500         s4        subRedefs;
 501         s4        subRedefsUsed;
 502
 503 };
 504
 505
 506
 507 /* innerclassinfo *************************************************************/
 508
 509 typedef struct innerclassinfo {
 510         classinfo *inner_class;       /* inner class pointer                      */
 511         classinfo *outer_class;       /* outer class pointer                      */
 512         utf *name;                    /* innerclass name                          */
 513         s4 flags;                     /* ACC flags                                */
 514 } innerclassinfo;
 515
 516 /* classinfo ******************************************************************/
 517
 518 struct classinfo {                /* class structure                          */
 519         java_objectheader header;     /* classes are also objects                 */
 520
 521         s4          flags;            /* ACC flags                                */
 522         utf        *name;             /* class name                               */
 523
 524         s4          cpcount;          /* number of entries in constant pool       */
 525         u1         *cptags;           /* constant pool tags                       */
 526         voidptr    *cpinfos;          /* pointer to constant pool info structures */
 527
 528         classinfo  *super;            /* super class pointer                      */
 529         classinfo  *sub;              /* sub class pointer                        */
 530         classinfo  *nextsub;          /* pointer to next class in sub class list  */
 531
 532         s4          interfacescount;  /* number of interfaces                     */
 533         classinfo **interfaces;       /* pointer to interfaces                    */
 534
 535         s4          fieldscount;      /* number of fields                         */
 536         fieldinfo  *fields;           /* field table                              */
 537
 538         s4          methodscount;     /* number of methods                        */
 539         methodinfo *methods;          /* method table                             */
 540
 541         listnode    listnode;         /* linkage                                  */
 542
 543         bool        initialized;      /* true, if class already initialised       */
 544         bool        linked;           /* true, if class already linked            */
 545         s4          index;            /* hierarchy depth (classes) or index
 546                                          (interfaces)                             */
 547         s4          instancesize;     /* size of an instance of this class        */
 548 #ifdef SIZE_FROM_CLASSINFO
 549         s4          alignedsize;      /* size of an instance, aligned to the
 550                                                       allocation size on the heap */
 551 #endif
 552
 553         vftbl      *vftbl;            /* pointer to virtual function table        */
 554
 555         methodinfo *finalizer;        /* finalizer method                         */
 556 #ifdef JIT_MARKER_SUPPORT
 557         methodinfo *marker;
 558 #endif
 559
 560     u2             innerclasscount;   /* number of inner classes              */
 561     innerclassinfo *innerclass;
 562
 563     classinfo      *hashlink;         /* link for external hash chain         */
 564         bool        classvftbl;       /* has its own copy of the Class vtbl       */
 565
 566         s4          classUsed;        /* 0= not used 1 = used   CO-RT             */
 567
 568         classSetNode *impldBy;          /* implemented by class set */
 569 };
 570
 571
 572 /* virtual function table ******************************************************
 573
 574         The vtbl has a bidirectional layout with open ends at both sides.
 575         interfacetablelength gives the number of entries of the interface table at
 576         the start of the vftbl. The vftbl pointer points to &interfacetable[0].
 577         vftbllength gives the number of entries of table at the end of the vftbl.
 578
 579         runtime type check (checkcast):
 580
 581         Different methods are used for runtime type check depending on the
 582         argument of checkcast/instanceof.
 583
 584         A check against a class is implemented via relative numbering on the class
 585         hierachy tree. The tree is numbered in a depth first traversal setting
 586         the base field and the diff field. The diff field gets the result of
 587         (high - base) so that a range check can be implemented by an unsigned
 588         compare. A sub type test is done by checking the inclusion of base of
 589         the sub class in the range of the superclass.
 590
 591         A check against an interface is implemented via the interfacevftbl. If the
 592         interfacevftbl contains a nonnull value a class is a subclass of this
 593         interface.
 594
 595         interfacetable:
 596
 597         Like standard virtual methods interface methods are called using
 598         virtual function tables. All interfaces are numbered sequentially
 599         (starting with zero). For each class there exist an interface table
 600         of virtual function tables for each implemented interface. The length
 601         of the interface table is determined by the highest number of an
 602         implemented interface.
 603
 604         The following example assumes a class which implements interface 0 and 3:
 605
 606         interfacetablelength = 4
 607
 608                   | ...       |            +----------+
 609                       +-----------+            | method 2 |---> method z
 610                       | class     |            | method 1 |---> method y
 611                       +-----------+            | method 0 |---> method x
 612                       | ivftbl  0 |----------> +----------+
 613         vftblptr ---> +-----------+
 614                   | ivftbl -1 |--> NULL    +----------+
 615                   | ivftbl -2 |--> NULL    | method 1 |---> method x
 616                   | ivftbl -3 |-----+      | method 0 |---> method a
 617                   +-----------+     +----> +----------+
 618
 619                               +---------------+
 620                                   | length 3 = 2  |
 621                                   | length 2 = 0  |
 622                                   | length 1 = 0  |
 623                                   | length 0 = 3  |
 624         interfacevftbllength ---> +---------------+
 625
 626 *******************************************************************************/
 627
 628 struct vftbl {
 629         methodptr   *interfacetable[1];    /* interface table (access via macro)  */
 630
 631         classinfo   *class;                /* class, the vtbl belongs to          */
 632
 633         s4           vftbllength;          /* virtual function table length       */
 634         s4           interfacetablelength; /* interface table length              */
 635
 636         s4           baseval;              /* base for runtime type check         */
 637         s4           diffval;              /* high - base for runtime type check  */
 638
 639         s4          *interfacevftbllength; /* length of interface vftbls          */
 640
 641         methodptr    table[1];             /* class vftbl                         */
 642 };
 643
 644 #define VFTBLINTERFACETABLE(v,i)       (v)->interfacetable[-i]
 645
 646
 647 /* references to some system classes ******************************************/
 648
 649 extern classinfo *class_java_lang_Object;
 650 extern classinfo *class_java_lang_String;
 651 extern classinfo *class_java_lang_ClassCastException;
 652 extern classinfo *class_java_lang_NullPointerException;
 653 extern classinfo *class_java_lang_ArrayIndexOutOfBoundsException;
 654 extern classinfo *class_java_lang_NegativeArraySizeException;
 655 extern classinfo *class_java_lang_OutOfMemoryError;
 656 extern classinfo *class_java_lang_ArithmeticException;
 657 extern classinfo *class_java_lang_ArrayStoreException;
 658 extern classinfo *class_java_lang_ThreadDeath;
 659 extern classinfo *class_array;
 660
 661 /* instances of some system classes *******************************************/
 662
 663 extern java_objectheader *proto_java_lang_ClassCastException;
 664 extern java_objectheader *proto_java_lang_NullPointerException;
 665 extern java_objectheader *proto_java_lang_ArrayIndexOutOfBoundsException;
 666 extern java_objectheader *proto_java_lang_NegativeArraySizeException;
 667 extern java_objectheader *proto_java_lang_OutOfMemoryError;
 668 extern java_objectheader *proto_java_lang_ArithmeticException;
 669 extern java_objectheader *proto_java_lang_ArrayStoreException;
 670 extern java_objectheader *proto_java_lang_ThreadDeath;
 671
 672
 673 /* flag variables *************************************************************/
 674
 675 extern bool compileall;
 676 extern bool runverbose;
 677 extern bool verbose;
 678 extern bool opt_rt;             /* Rapid Type Analysis for better inlining CO-RT*/
 679 extern bool opt_xta;            /* X Type Analysis for better inlining    CO-XTA*/
 680 extern bool opt_vta;            /* Variable Type Analysis for better inlining    CO-VTA*/
 681
 682 extern int pClassHeir;
 683 extern int pCallgraph;
 684 extern int pOpcodes;
 685 extern int pStats;
 686
 687 extern void RT_jit_parse(methodinfo *m);
 688 extern void printCallgraph ();
 689 extern void printRThierarchyInfo(methodinfo *m);
 690 extern void printObjectClassHeirarchy();
 691
 692 extern void XTA_jit_parse(methodinfo *m);
 693
 694 /* statistic variables ********************************************************/
 695
 696 extern int count_class_infos;
 697 extern int count_const_pool_len;
 698 extern int count_vftbl_len;
 699 extern int count_utf_len;
 700 extern int count_all_methods;
 701 extern int count_vmcode_len;
 702 extern int count_extable_len;
 703 extern int count_class_loads;
 704 extern int count_class_inits;
 705 extern int count_utf_new;
 706 extern int count_utf_new_found;
 707
 708 /* table of primitive types ***************************************************/
 709
 710 extern primitivetypeinfo primitivetype_table[PRIMITIVETYPE_COUNT];
 711
 712 #endif
 713
 714
 715 /*
 716  * These are local overrides for various environment variables in Emacs.
 717  * Please do not remove this and leave it at the end of the file, where
 718  * Emacs will automagically detect them.
 719  * ---------------------------------------------------------------------
 720  * Local variables:
 721  * mode: c
 722  * indent-tabs-mode: t
 723  * c-basic-offset: 4
 724  * tab-width: 4
 725  * End:
 726  */