src/vm/global.h

   1 /* global.h - global definitions
   2
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   4    R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser,
   5    M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck,
   6    P. Tomsich, J. Wenninger
   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., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Reinhard Grafl
  28             Andreas Krall
  29
  30    Changes: Mark Probst
  31             Philipp Tomsich
  32                         Edwin Steiner
  33
  34    $Id: global.h 1028 2004-04-26 15:55:41Z twisti $
  35
  36 */
  37
  38
  39 #ifndef _GLOBAL_H
  40 #define _GLOBAL_H
  41
  42 #define _GNU_SOURCE
  43
  44 #include "config.h"
  45 #include "types.h"
  46 #include "toolbox/list.h"
  47
  48 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
  49 #include <pthread.h>
  50 #endif
  51
  52 #define STATISTICS          /* if enabled collects program statistics         */
  53
  54 /*
  55  * SIZE_FROM_CLASSINFO toggles between the bitmap_based and the new method
  56  * of determining the sizes of objects on the heap.
  57  */
  58 #define SIZE_FROM_CLASSINFO
  59
  60 /*
  61  * CACAO_TYPECHECK activates typechecking (part of bytecode verification)
  62  */
  63 #define CACAO_TYPECHECK
  64
  65 /*
  66  * TYPECHECK_STACK_COMPCAT activates full checking of computational
  67  * categories for stack manipulations (POP,POP2,SWAP,DUP,DUP2,DUP_X1,
  68  * DUP2_X1,DUP_X2,DUP2_X2).
  69  */
  70 /* #define TYPECHECK_STACK_COMPCAT */
  71
  72 /*
  73  * Macros for configuration of the typechecking code
  74  *
  75  * TYPECHECK_STATISTICS activates gathering statistical information.
  76  * TYPEINFO_DEBUG activates debug checks and debug helpers in typeinfo.c
  77  * TYPECHECK_DEBUG activates debug checks in typecheck.c
  78  * TYPEINFO_DEBUG_TEST activates the typeinfo test at startup.
  79  * TYPECHECK_VERBOSE_IMPORTANT activates important debug messages
  80  * TYPECHECK_VERBOSE activates all debug messages
  81  */
  82 #ifdef CACAO_TYPECHECK
  83 /*#define TYPECHECK_STATISTICS*/
  84 /*#define TYPEINFO_DEBUG*/
  85 /*#define TYPECHECK_DEBUG*/
  86 /*#define TYPEINFO_DEBUG_TEST*/
  87 /*#define TYPECHECK_VERBOSE*/
  88 /*#define TYPECHECK_VERBOSE_IMPORTANT*/
  89 #if defined(TYPECHECK_VERBOSE) || defined(TYPECHECK_VERBOSE_IMPORTANT)
  90 #define TYPECHECK_VERBOSE_OPT
  91 #endif
  92 #endif
  93
  94
  95 /* additional data types ******************************************************/
  96
  97 typedef void *voidptr;          /* generic pointer */
  98
  99 typedef int   bool;             /* boolean data type */
 100
 101 #define true  1
 102 #define false 0
 103
 104
 105 /* immediate data union */
 106
 107 typedef union {
 108     s4 i;
 109     s8 l;
 110     float f;
 111     double d;
 112     void *a;
 113     u1 b[8];
 114 } imm_union;
 115
 116
 117 #define PRIMITIVETYPE_COUNT  9  /* number of primitive types */
 118
 119 /* CAUTION: Don't change the numerical values! These constants are
 120  * used as indices into the primitive type table.
 121  */
 122 #define PRIMITIVETYPE_INT     0
 123 #define PRIMITIVETYPE_LONG    1
 124 #define PRIMITIVETYPE_FLOAT   2
 125 #define PRIMITIVETYPE_DOUBLE  3
 126 #define PRIMITIVETYPE_BYTE    4
 127 #define PRIMITIVETYPE_CHAR    5
 128 #define PRIMITIVETYPE_SHORT   6
 129 #define PRIMITIVETYPE_BOOLEAN 7
 130 #define PRIMITIVETYPE_VOID    8
 131
 132 typedef void (*functionptr) (); /* generic function pointer */
 133
 134
 135 #define MAX_ALIGN 8             /* most generic alignment for JavaVM values   */
 136
 137 /* shutdown function **********************************************************/
 138
 139 void cacao_shutdown(s4 status);
 140
 141
 142 /* basic data types ***********************************************************/
 143
 144 /* CAUTION: jit/jit.h relies on these numerical values! */
 145 #define TYPE_INT      0         /* the JavaVM types must numbered in the      */
 146 #define TYPE_LONG     1         /* same order as the ICMD_Ixxx to ICMD_Axxx   */
 147 #define TYPE_FLOAT    2         /* instructions (LOAD and STORE)              */
 148 #define TYPE_DOUBLE   3         /* integer, long, float, double, address      */
 149 #define TYPE_ADDRESS  4         /* all other types can be numbered arbitrarly */
 150
 151 #define TYPE_VOID    10
 152
 153
 154 /* Java class file constants **************************************************/
 155
 156 #define MAGIC         0xcafebabe
 157 #define MINOR_VERSION 3
 158 #define MAJOR_VERSION 45
 159
 160 #define CONSTANT_Class                 7
 161 #define CONSTANT_Fieldref              9
 162 #define CONSTANT_Methodref            10
 163 #define CONSTANT_InterfaceMethodref   11
 164 #define CONSTANT_String                8
 165 #define CONSTANT_Integer               3
 166 #define CONSTANT_Float                 4
 167 #define CONSTANT_Long                  5
 168 #define CONSTANT_Double                6
 169 #define CONSTANT_NameAndType          12
 170 #define CONSTANT_Utf8                  1
 171
 172 #define CONSTANT_UNUSED                0
 173
 174 #define ACC_PUBLIC                0x0001
 175 #define ACC_PRIVATE               0x0002
 176 #define ACC_PROTECTED             0x0004
 177 #define ACC_STATIC                0x0008
 178 #define ACC_FINAL                 0x0010
 179 #define ACC_SUPER                 0x0020
 180 #define ACC_SYNCHRONIZED          0x0020
 181 #define ACC_VOLATILE              0x0040
 182 #define ACC_TRANSIENT             0x0080
 183 #define ACC_NATIVE                0x0100
 184 #define ACC_INTERFACE             0x0200
 185 #define ACC_ABSTRACT              0x0400
 186 #define ACC_STRICT                0x0800
 187
 188 /* resolve typedef cycles *****************************************************/
 189
 190 typedef struct utf utf;
 191 typedef struct literalstring literalstring;
 192 typedef struct java_objectheader java_objectheader;
 193 typedef struct classinfo classinfo;
 194 typedef struct vftbl vftbl;
 195 typedef u1* methodptr;
 196 typedef struct fieldinfo  fieldinfo;
 197 typedef struct methodinfo methodinfo;
 198 typedef struct lineinfo lineinfo;
 199 typedef struct arraydescriptor arraydescriptor;
 200
 201
 202 /* constant pool entries *******************************************************
 203
 204         All constant pool entries need a data structure which contain the entrys
 205         value. In some cases this structure exist already, in the remaining cases
 206         this structure must be generated:
 207
 208                 kind                      structure                     generated?
 209         ----------------------------------------------------------------------
 210     CONSTANT_Class               classinfo                           no
 211     CONSTANT_Fieldref            constant_FMIref                    yes
 212     CONSTANT_Methodref           constant_FMIref                    yes
 213     CONSTANT_InterfaceMethodref  constant_FMIref                    yes
 214     CONSTANT_String              unicode                             no
 215     CONSTANT_Integer             constant_integer                   yes
 216     CONSTANT_Float               constant_float                     yes
 217     CONSTANT_Long                constant_long                      yes
 218     CONSTANT_Double              constant_double                    yes
 219     CONSTANT_NameAndType         constant_nameandtype               yes
 220     CONSTANT_Utf8                unicode                             no
 221     CONSTANT_UNUSED              -
 222
 223 *******************************************************************************/
 224
 225 /* data structures for hashtables ********************************************
 226
 227
 228         All utf-symbols, javastrings and classes are stored in global hashtables,
 229         so every symbol exists only once. Equal symbols have identical pointers.
 230         The functions for adding hashtable elements search the table for the
 231         element with the specified name/text and return it on success. Otherwise a
 232         new hashtable element is created.
 233
 234     The hashtables use external linking for handling collisions. The hashtable
 235         structure contains a pointer <ptr> to the array of hashtable slots. The
 236         number of hashtable slots and therefore the size of this array is specified
 237         by the element <size> of hashtable structure. <entries> contains the number
 238         of all hashtable elements stored in the table, including those in the
 239         external chains.
 240         The hashtable element structures (utf, literalstring, classinfo) contain
 241         both a pointer to the next hashtable element as a link for the external hash
 242         chain and the key of the element. The key is computed from the text of
 243         the string or the classname by using up to 8 characters.
 244
 245         If the number of entries in the hashtable exceeds twice the size of the
 246         hashtableslot-array it is supposed that the average length of the
 247         external chains has reached a value beyond 2. Therefore the functions for
 248         adding hashtable elements (utf_new, class_new, literalstring_new) double
 249         the hashtableslot-array. In this restructuring process all elements have
 250         to be inserted into the new hashtable and new external chains must be built.
 251
 252
 253 example for the layout of a hashtable:
 254
 255 hashtable.ptr-->  +-------------------+
 256                   |                   |
 257                            ...
 258                   |                   |
 259                   +-------------------+   +-------------------+   +-------------------+
 260                   | hashtable element |-->| hashtable element |-->| hashtable element |-->NULL
 261                   +-------------------+   +-------------------+   +-------------------+
 262                   | hashtable element |
 263                   +-------------------+   +-------------------+
 264                   | hashtable element |-->| hashtable element |-->NULL
 265                   +-------------------+   +-------------------+
 266                   | hashtable element |-->NULL
 267                   +-------------------+
 268                   |                   |
 269                            ...
 270                   |                   |
 271                   +-------------------+
 272
 273 */
 274
 275
 276 /* data structure for utf8 symbols ********************************************/
 277
 278 struct utf {
 279         utf        *hashlink;       /* link for external hash chain               */
 280         int         blength;        /* text length in bytes                       */
 281         char       *text;           /* pointer to text                            */
 282 };
 283
 284
 285 /* data structure of internal javastrings stored in global hashtable **********/
 286
 287 struct literalstring {
 288         literalstring     *hashlink;     /* link for external hash chain          */
 289         java_objectheader *string;
 290 };
 291
 292
 293 /* data structure for storing information needed for a stacktrace across native functions*/
 294 struct native_stackframeinfo {
 295         void *returnFromNative;
 296         void *addrReturnFromNative;
 297         methodinfo *method;
 298         struct native_stackframeinfo *next;
 299         struct native_stackframeinfo *prev;
 300 };
 301
 302 typedef struct native_stackframeinfo native_stackframeinfo;
 303
 304 struct stacktraceelement {
 305 #if POINTERSIZE == 8
 306         u8 linenumber;
 307 #else
 308         u4 linenumber;
 309 #endif
 310         methodinfo *method;
 311 };
 312
 313 typedef struct stacktraceelement stacktraceelement;
 314
 315 /* data structure for calls from c code to java methods */
 316
 317 struct jni_callblock {
 318         u1 itemtype;
 319         u8 item;
 320 };
 321
 322 typedef struct jni_callblock jni_callblock;
 323
 324
 325 /* data structure for accessing hashtables ************************************/
 326
 327 typedef struct {
 328         u4 size;
 329         u4 entries;        /* number of entries in the table */
 330         void **ptr;        /* pointer to hashtable */
 331 } hashtable;
 332
 333
 334 /* data structures of remaining constant pool entries *************************/
 335
 336 typedef struct {            /* Fieldref, Methodref and InterfaceMethodref     */
 337         classinfo *class;       /* class containing this field/method/interface   */
 338         utf       *name;        /* field/method/interface name                    */
 339         utf       *descriptor;  /* field/method/interface type descriptor string  */
 340 } constant_FMIref;
 341
 342
 343 typedef struct {            /* Integer                                        */
 344         s4 value;
 345 } constant_integer;
 346
 347
 348 typedef struct {            /* Float                                          */
 349         float value;
 350 } constant_float;
 351
 352
 353 typedef struct {            /* Long                                           */
 354         s8 value;
 355 } constant_long;
 356
 357
 358 typedef struct {            /* Double                                         */
 359         double value;
 360 } constant_double;
 361
 362
 363 typedef struct {            /* NameAndType (Field or Method)                  */
 364         utf *name;              /* field/method name                              */
 365         utf *descriptor;        /* field/method type descriptor string            */
 366 } constant_nameandtype;
 367
 368
 369 /* data structures of the runtime system **************************************/
 370
 371 /* objects *********************************************************************
 372
 373         All objects (and arrays) which resides on the heap need the following
 374         header at the beginning of the data structure.
 375 */
 376
 377 struct java_objectheader {              /* header for all objects             */
 378         vftbl *vftbl;                       /* pointer to virtual function table  */
 379 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
 380         long monitorBits;
 381 #endif
 382 };
 383
 384
 385
 386 /* arrays **********************************************************************
 387
 388         All arrays are objects (they need the object header with a pointer
 389         to a vftbl (array class table). There is one class for each array
 390         type. The array type is described by an arraydescriptor struct
 391         which is referenced by the vftbl.
 392 */
 393
 394 /* CAUTION: Don't change the numerical values! These constants (with
 395  * the exception of ARRAYTYPE_OBJECT) are used as indices in the
 396  * primitive type table.
 397  */
 398 #define ARRAYTYPE_INT      PRIMITIVETYPE_INT
 399 #define ARRAYTYPE_LONG     PRIMITIVETYPE_LONG
 400 #define ARRAYTYPE_FLOAT    PRIMITIVETYPE_FLOAT
 401 #define ARRAYTYPE_DOUBLE   PRIMITIVETYPE_DOUBLE
 402 #define ARRAYTYPE_BYTE     PRIMITIVETYPE_BYTE
 403 #define ARRAYTYPE_CHAR     PRIMITIVETYPE_CHAR
 404 #define ARRAYTYPE_SHORT    PRIMITIVETYPE_SHORT
 405 #define ARRAYTYPE_BOOLEAN  PRIMITIVETYPE_BOOLEAN
 406 #define ARRAYTYPE_OBJECT   PRIMITIVETYPE_VOID     /* don't use as index! */
 407
 408 typedef struct java_arrayheader {       /* header for all arrays              */
 409         java_objectheader objheader;        /* object header                      */
 410         s4 size;                            /* array size                         */
 411 #ifdef SIZE_FROM_CLASSINFO
 412         s4 alignedsize; /* phil */
 413 #endif
 414 } java_arrayheader;
 415
 416
 417
 418 /* structs for all kinds of arrays ********************************************/
 419
 420 typedef struct java_chararray {
 421         java_arrayheader header;
 422         u2 data[1];
 423 } java_chararray;
 424
 425 typedef struct java_floatheader {
 426         java_arrayheader header;
 427         float data[1];
 428 } java_floatarray;
 429
 430 typedef struct java_doublearray {
 431         java_arrayheader header;
 432         double data[1];
 433 } java_doublearray;
 434
 435 /*  booleanarray and bytearray need identical memory layout (access methods
 436     use the same machine code */
 437
 438 typedef struct java_booleanarray {
 439         java_arrayheader header;
 440         u1 data[1];
 441 } java_booleanarray;
 442
 443 typedef struct java_bytearray {
 444         java_arrayheader header;
 445         s1 data[1];
 446 } java_bytearray;
 447
 448 typedef struct java_shortarray {
 449         java_arrayheader header;
 450         s2 data[1];
 451 } java_shortarray;
 452
 453 typedef struct java_intarray {
 454         java_arrayheader header;
 455         s4 data[1];
 456 } java_intarray;
 457
 458 typedef struct java_longarray {
 459         java_arrayheader header;
 460         s8 data[1];
 461 } java_longarray;
 462
 463 /*  objectarray and arrayarray need identical memory layout (access methods
 464     use the same machine code */
 465
 466 typedef struct java_objectarray {
 467         java_arrayheader header;
 468         java_objectheader *data[1];
 469 } java_objectarray;
 470
 471
 472 /* structure for primitive classes ********************************************/
 473
 474 typedef struct primitivetypeinfo {
 475         classinfo *class_wrap;               /* class for wrapping primitive type */
 476         classinfo *class_primitive;          /* primitive class                   */
 477         char      *wrapname;                 /* name of class for wrapping        */
 478         char      typesig;                   /* one character type signature      */
 479         char      *name;                     /* name of primitive class           */
 480         char      *arrayname;                /* name of primitive array class     */
 481         classinfo *arrayclass;               /* primitive array class             */
 482         vftbl     *arrayvftbl;               /* vftbl of primitive array class    */
 483 } primitivetypeinfo;
 484
 485
 486 /* field, method and class structures *****************************************/
 487
 488 #include "sets.h"
 489 typedef struct xtafldinfo {
 490         bool       fieldChecked;
 491         classinfo *fldClassType;
 492         classSet  *XTAclassSet;          /* field class type set                  */
 493 } xtafldinfo;
 494
 495
 496 /* fieldinfo ******************************************************************/
 497
 498 struct fieldinfo {            /* field of a class                                 */
 499         s4  flags;            /* ACC flags                                        */
 500         s4  type;             /* basic data type                                  */
 501         utf *name;            /* name of field                                    */
 502         utf *descriptor;      /* JavaVM descriptor string of field                */
 503
 504         s4  offset;           /* offset from start of object (instance variables) */
 505
 506         imm_union value;      /* storage for static values (class variables)      */
 507
 508         classinfo *class;     /* needed by typechecker. Could be optimized        */
 509                               /* away by using constant_FMIref instead of         */
 510                               /* fieldinfo throughout the compiler.               */
 511
 512         xtafldinfo *xta;
 513 };
 514
 515 struct basicblock;
 516
 517
 518 /* exceptiontable *************************************************************/
 519
 520 typedef struct xtable {         /* exceptiontable entry in a method           */
 521         s4         startpc;         /* start pc of guarded area (inclusive)       */
 522         struct basicblock *start;
 523
 524         s4         endpc;           /* end pc of guarded area (exklusive)         */
 525         struct basicblock *end;
 526
 527         s4         handlerpc;       /* pc of exception handler                    */
 528         struct basicblock *handler;
 529
 530         classinfo *catchtype;       /* catchtype of exception (NULL == catchall)  */
 531         struct xtable *next;        /* used to build a list of exception when     */
 532                                     /* loops are copied */
 533         struct xtable *down;        /* instead of the old array, a list is used   */
 534 } xtable;
 535
 536
 537 typedef struct exceptiontable { /* exceptiontable entry in a method           */
 538         s4         startpc;         /* start pc of guarded area (inclusive)       */
 539         s4         endpc;           /* end pc of guarded area (exklusive)         */
 540         s4         handlerpc;       /* pc of exception handler                    */
 541         classinfo *catchtype;       /* catchtype of exception (NULL == catchall)  */
 542 } exceptiontable;
 543
 544
 545 /* methodinfo  static info ****************************************************/
 546 typedef struct xtainfo {
 547         s4          XTAmethodUsed;     /* XTA if used in callgraph - not used /used */
 548         classSet    *XTAclassSet;      /* method class type set                 */
 549         /*classSet      *PartClassSet */   /* method class type set                 */
 550
 551         classSetNode    *paramClassSet; /* cone set of methods parameters       */
 552
 553         methSet         *calls;            /* methods this method calls                 */
 554         methSet         *calledBy;         /* methods that call this method         */
 555         methSet         *marked;  //not in Dez         /* methods that marked by this method    */
 556         methSet         *markedBy;
 557         fldSet          *fldsUsed;         /* fields used by this method             */
 558         /*methSetNode  *interfaceCalls*/   /* methods this method calls as interface */
 559         bool           chgdSinceLastParse; /* Changed since last parse ?          */
 560 } xtainfo;
 561
 562
 563 /* lineinfo *****************************************************************/
 564 struct lineinfo {
 565         u2 start_pc;
 566         u2 line_number;
 567 };
 568
 569 /* methodinfo *****************************************************************/
 570
 571 struct methodinfo {                 /* method structure                       */
 572         s4             flags;               /* ACC flags                              */
 573         utf       *name;                /* name of method                         */
 574         utf       *descriptor;          /* JavaVM descriptor string of method     */
 575         s4         returntype;          /* only temporary valid, return type      */
 576         classinfo *returnclass;         /* pointer to classinfo for the rtn type  */ /*XTA*/
 577         s4         paramcount;          /* only temporary valid, parameter count  */
 578         u1        *paramtypes;          /* only temporary valid, parameter types  */
 579         classinfo **paramclass;         /* pointer to classinfo for a parameter   */ /*XTA*/
 580
 581         classinfo *class;               /* class, the method belongs to           */
 582         s4         vftblindex;          /* index of method in virtual function table
 583                                            (if it is a virtual method)            */
 584         s4         maxstack;            /* maximum stack depth of method          */
 585         s4         maxlocals;           /* maximum number of local variables      */
 586         s4         jcodelength;         /* length of JavaVM code                  */
 587         u1        *jcode;               /* pointer to JavaVM code                 */
 588
 589         s4         exceptiontablelength;/* exceptiontable length                  */
 590         exceptiontable *exceptiontable; /* the exceptiontable                     */
 591
 592         u2        thrownexceptionscount;/*number of exceptions declared to be thrown by a method*/
 593         classinfo **thrownexceptions;   /*array of classinfos of declared exceptions*/
 594
 595         u2         linenumbercount;     /*number of linenumber attributes*/
 596         lineinfo  *linenumbers;         /*array of lineinfo items (start_pc,line_number)*/
 597
 598         u1        *stubroutine;         /* stub for compiling or calling natives  */
 599         s4         mcodelength;         /* legth of generated machine code        */
 600         u1        *mcode;               /* pointer to machine code                */
 601         u1        *entrypoint;          /* entry point in machine code            */
 602
 603         /*rtainfo   rta;*/
 604         xtainfo    *xta;
 605
 606         s4        methodUsed;           /* marked (might be used later) /not used /used */
 607         s4        monoPoly;             /* call is mono or poly or unknown        */ /*RT stats */
 608         /* should # method def'd and used be kept after static parse (will it be used?) */
 609         s4        subRedefs;
 610         s4        subRedefsUsed;
 611 };
 612
 613
 614 /* innerclassinfo *************************************************************/
 615
 616 typedef struct innerclassinfo {
 617         classinfo *inner_class;       /* inner class pointer                      */
 618         classinfo *outer_class;       /* outer class pointer                      */
 619         utf *name;                    /* innerclass name                          */
 620         s4 flags;                     /* ACC flags                                */
 621 } innerclassinfo;
 622
 623
 624 /* classinfo ******************************************************************/
 625
 626 struct classinfo {                /* class structure                          */
 627         java_objectheader header;     /* classes are also objects                 */
 628         java_objectarray* signers;
 629         struct java_security_ProtectionDomain* pd;
 630         struct java_lang_VMClass* vmClass;
 631         struct java_lang_reflect_Constructor* constructor;
 632
 633         s4 initializing_thread;       /* gnu classpath                            */
 634         s4 erroneous_state;           /* gnu classpath                            */
 635         struct gnu_classpath_RawData* vmData; /* gnu classpath                    */
 636
 637         s4          flags;            /* ACC flags                                */
 638         utf        *name;             /* class name                               */
 639
 640         s4          cpcount;          /* number of entries in constant pool       */
 641         u1         *cptags;           /* constant pool tags                       */
 642         voidptr    *cpinfos;          /* pointer to constant pool info structures */
 643
 644         classinfo  *super;            /* super class pointer                      */
 645         classinfo  *sub;              /* sub class pointer                        */
 646         classinfo  *nextsub;          /* pointer to next class in sub class list  */
 647
 648         s4          interfacescount;  /* number of interfaces                     */
 649         classinfo **interfaces;       /* pointer to interfaces                    */
 650
 651         s4          fieldscount;      /* number of fields                         */
 652         fieldinfo  *fields;           /* field table                              */
 653
 654         s4          methodscount;     /* number of methods                        */
 655         methodinfo *methods;          /* method table                             */
 656
 657         listnode    listnode;         /* linkage                                  */
 658
 659         bool        initialized;      /* true, if class already initialised       */
 660         bool        loaded;           /* true, if class already loaded            */
 661         bool        linked;           /* true, if class already linked            */
 662         s4          index;            /* hierarchy depth (classes) or index
 663                                          (interfaces)                             */
 664         s4          instancesize;     /* size of an instance of this class        */
 665 #ifdef SIZE_FROM_CLASSINFO
 666         s4          alignedsize;      /* size of an instance, aligned to the
 667                                                                          allocation size on the heap              */
 668 #endif
 669
 670         vftbl      *vftbl;            /* pointer to virtual function table        */
 671
 672         methodinfo *finalizer;        /* finalizer method                         */
 673
 674     u2             innerclasscount;   /* number of inner classes              */
 675     innerclassinfo *innerclass;
 676
 677     classinfo      *hashlink;         /* link for external hash chain         */
 678         bool        classvftbl;       /* has its own copy of the Class vtbl       */
 679
 680         s4          classUsed;        /* 0= not used 1 = used   CO-RT             */
 681
 682         classSetNode *impldBy;        /* implemented by class set                 */
 683         utf        *packagename;      /* full name of the package                 */
 684         utf        *sourcefile;       /* classfile name containing this class     */
 685         java_objectheader *classloader;       /* 0 for bootstrap classloader */
 686 };
 687
 688 /* check if class is an array class. Only use for linked classes! */
 689 #define CLASS_IS_ARRAY(clsinfo)  ((clsinfo)->vftbl->arraydesc != NULL)
 690
 691
 692 /* virtual function table ******************************************************
 693
 694         The vtbl has a bidirectional layout with open ends at both sides.
 695         interfacetablelength gives the number of entries of the interface table at
 696         the start of the vftbl. The vftbl pointer points to &interfacetable[0].
 697         vftbllength gives the number of entries of table at the end of the vftbl.
 698
 699         runtime type check (checkcast):
 700
 701         Different methods are used for runtime type check depending on the
 702         argument of checkcast/instanceof.
 703
 704         A check against a class is implemented via relative numbering on the class
 705         hierachy tree. The tree is numbered in a depth first traversal setting
 706         the base field and the diff field. The diff field gets the result of
 707         (high - base) so that a range check can be implemented by an unsigned
 708         compare. A sub type test is done by checking the inclusion of base of
 709         the sub class in the range of the superclass.
 710
 711         A check against an interface is implemented via the interfacevftbl. If the
 712         interfacevftbl contains a nonnull value a class is a subclass of this
 713         interface.
 714
 715         interfacetable:
 716
 717         Like standard virtual methods interface methods are called using
 718         virtual function tables. All interfaces are numbered sequentially
 719         (starting with zero). For each class there exist an interface table
 720         of virtual function tables for each implemented interface. The length
 721         of the interface table is determined by the highest number of an
 722         implemented interface.
 723
 724         The following example assumes a class which implements interface 0 and 3:
 725
 726         interfacetablelength = 4
 727
 728                   | ...       |            +----------+
 729                       +-----------+            | method 2 |---> method z
 730                       | class     |            | method 1 |---> method y
 731                       +-----------+            | method 0 |---> method x
 732                       | ivftbl  0 |----------> +----------+
 733         vftblptr ---> +-----------+
 734                   | ivftbl -1 |--> NULL    +----------+
 735                   | ivftbl -2 |--> NULL    | method 1 |---> method x
 736                   | ivftbl -3 |-----+      | method 0 |---> method a
 737                   +-----------+     +----> +----------+
 738
 739                               +---------------+
 740                                   | length 3 = 2  |
 741                                   | length 2 = 0  |
 742                                   | length 1 = 0  |
 743                                   | length 0 = 3  |
 744         interfacevftbllength ---> +---------------+
 745
 746 *******************************************************************************/
 747
 748 struct vftbl {
 749         methodptr   *interfacetable[1];    /* interface table (access via macro)  */
 750
 751         classinfo   *class;                /* class, the vtbl belongs to          */
 752
 753         arraydescriptor *arraydesc;        /* for array classes, otherwise NULL   */
 754
 755         s4           vftbllength;          /* virtual function table length       */
 756         s4           interfacetablelength; /* interface table length              */
 757
 758         s4           baseval;              /* base for runtime type check         */
 759                                            /* (-index for interfaces)             */
 760         s4           diffval;              /* high - base for runtime type check  */
 761
 762         s4          *interfacevftbllength; /* length of interface vftbls          */
 763
 764         methodptr    table[1];             /* class vftbl                         */
 765 };
 766
 767 #define VFTBLINTERFACETABLE(v,i)       (v)->interfacetable[-i]
 768
 769
 770 /* arraydescriptor ************************************************************
 771
 772     For every array class an arraydescriptor is allocated which
 773     describes the array class.
 774         The arraydescriptor is referenced from the vftbl of the array
 775         class.
 776
 777 *******************************************************************************/
 778
 779 struct arraydescriptor {
 780         vftbl *componentvftbl;   /* vftbl of the component type, NULL for primit. */
 781         vftbl *elementvftbl;     /* vftbl of the element type, NULL for primitive */
 782         short  arraytype;        /* ARRAYTYPE_* constant                          */
 783         short  dimension;        /* dimension of the array (always >= 1)          */
 784     s4     dataoffset;       /* offset of the array data from object pointer  */
 785         s4     componentsize;    /* size of a component in bytes                  */
 786         short  elementtype;      /* ARRAYTYPE_* constant                          */
 787 };
 788
 789
 790 /* flag variables *************************************************************/
 791
 792 extern bool compileall;
 793 extern bool runverbose;
 794 extern bool verboseexception;
 795 extern bool verbose;
 796 extern bool opt_rt;             /* Rapid Type Analysis for better inlining CO-RT*/
 797 extern bool opt_xta;            /* X Type Analysis for better inlining    CO-XTA*/
 798 extern bool opt_vta;            /* Variable Type Analysis for better inlining    CO-VTA*/
 799 extern bool opt_verify;         /* true if classfiles should be verified      */
 800 #ifdef TYPECHECK_VERBOSE_OPT
 801 extern bool typecheckverbose;
 802 #endif
 803
 804 /*extern int pClassHeir;*/
 805 /*extern int pCallgraph;*/
 806 /*extern int pOpcodes;*/
 807 /*extern int pStats;*/
 808
 809 /*extern void RT_jit_parse(methodinfo *m);*/
 810
 811
 812 /* statistic variables ********************************************************/
 813
 814 extern int count_class_infos;
 815 extern int count_const_pool_len;
 816 extern int count_vftbl_len;
 817 extern int count_utf_len;
 818 extern int count_all_methods;
 819 extern int count_vmcode_len;
 820 extern int count_extable_len;
 821 extern int count_class_loads;
 822 extern int count_class_inits;
 823 extern int count_utf_new;
 824 extern int count_utf_new_found;
 825
 826
 827 /* table of primitive types ***************************************************/
 828
 829 /* This array can be indexed by the PRIMITIVETYPE_ and ARRAYTYPE_
 830  * constants (except ARRAYTYPE_OBJECT).
 831  */
 832 extern primitivetypeinfo primitivetype_table[PRIMITIVETYPE_COUNT];
 833
 834
 835 /* macros for descriptor parsing **********************************************/
 836
 837 /* SKIP_FIELDDESCRIPTOR:
 838  * utf_ptr must point to the first character of a field descriptor.
 839  * After the macro call utf_ptr points to the first character after
 840  * the field descriptor.
 841  *
 842  * CAUTION: This macro does not check for an unexpected end of the
 843  * descriptor. Better use SKIP_FIELDDESCRIPTOR_SAFE.
 844  */
 845 #define SKIP_FIELDDESCRIPTOR(utf_ptr)                                                   \
 846         do { while (*(utf_ptr)=='[') (utf_ptr)++;                                       \
 847                 if (*(utf_ptr)++=='L')                                                                  \
 848                         while(*(utf_ptr)++ != ';') /* skip */; } while(0)
 849
 850 /* SKIP_FIELDDESCRIPTOR_SAFE:
 851  * utf_ptr must point to the first character of a field descriptor.
 852  * After the macro call utf_ptr points to the first character after
 853  * the field descriptor.
 854  *
 855  * Input:
 856  *     utf_ptr....points to first char of descriptor
 857  *     end_ptr....points to first char after the end of the string
 858  *     errorflag..must be initialized (to false) by the caller!
 859  * Output:
 860  *     utf_ptr....points to first char after the descriptor
 861  *     errorflag..set to true if the string ended unexpectedly
 862  */
 863 #define SKIP_FIELDDESCRIPTOR_SAFE(utf_ptr,end_ptr,errorflag)                    \
 864         do { while ((utf_ptr) != (end_ptr) && *(utf_ptr)=='[') (utf_ptr)++;     \
 865                 if ((utf_ptr) == (end_ptr))                                                                             \
 866                         (errorflag) = true;                                                                                     \
 867                 else                                                                                                                    \
 868                         if (*(utf_ptr)++=='L') {                                                                        \
 869                                 while((utf_ptr) != (end_ptr) && *(utf_ptr)++ != ';')    \
 870                                         /* skip */;                                                                                     \
 871                                 if ((utf_ptr)[-1] != ';')                                                               \
 872                                         (errorflag) = true; }} while(0)
 873
 874
 875 /* Synchronization ************************************************************/
 876
 877 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
 878 void cast_lock();
 879 void cast_unlock();
 880 void compiler_lock();
 881 void compiler_unlock();
 882 #endif
 883
 884 #endif /* _GLOBAL_H */
 885
 886
 887 /*
 888  * These are local overrides for various environment variables in Emacs.
 889  * Please do not remove this and leave it at the end of the file, where
 890  * Emacs will automagically detect them.
 891  * ---------------------------------------------------------------------
 892  * Local variables:
 893  * mode: c
 894  * indent-tabs-mode: t
 895  * c-basic-offset: 4
 896  * tab-width: 4
 897  * End:
 898  */