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         Chages:  Andreas  Krall      EMAIL: cacao@complang.tuwien.ac.at
  12                  Mark Probst         EMAIL: cacao@complang.tuwien.ac.at
  13
  14         Last Change: 1997/10/28
  15
  16 *******************************************************************************/
  17
  18 #ifndef __global_h_
  19 #define __global_h_                        /* schani */
  20
  21 #define STATISTICS                         /* andi   */
  22
  23 /***************************** standard includes ******************************/
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <time.h>
  29
  30 #include "toolbox/memory.h"
  31 #include "toolbox/chain.h"
  32 #include "toolbox/list.h"
  33 #include "toolbox/loging.h"
  34
  35
  36 /**************************** system dependent types **************************/
  37
  38 #include "sysdep/types.h"
  39
  40
  41 /**************************** additional data types ***************************/
  42
  43 typedef void *voidptr;          /* generic pointer */
  44
  45
  46 typedef u1    bool;             /* boolean data type */
  47
  48 #define true  1
  49 #define false 0
  50
  51 typedef void (*functionptr) (); /* generic function pointer */
  52
  53
  54 #define MAX_ALIGN 8             /* most generic alignment for JavaVM values   */
  55
  56
  57 /**************************** shutdown function *******************************/
  58
  59 void cacao_shutdown(s4 status);
  60
  61
  62 /**************************** basic data types ********************************/
  63
  64 #define TYPE_INT      0         /* the JavaVM types must numbered in the      */
  65 #define TYPE_LONG     1         /* same order as the ICMD_Ixxx to ICMD_Axxx   */
  66 #define TYPE_FLOAT    2         /* instructions (LOAD and STORE)              */
  67 #define TYPE_DOUBLE   3         /* integer, long, float, double, address      */
  68 #define TYPE_ADDRESS  4         /* all other types can be numbered arbitrarily*/
  69
  70 #define TYPE_VOID    10
  71
  72
  73 /**************************** Java class file constants ***********************/
  74
  75 #define MAGIC         0xcafebabe
  76 #define MINOR_VERSION 3
  77 #define MAJOR_VERSION 45
  78
  79 #define CONSTANT_Class                7
  80 #define CONSTANT_Fieldref             9
  81 #define CONSTANT_Methodref           10
  82 #define CONSTANT_InterfaceMethodref  11
  83 #define CONSTANT_String               8
  84 #define CONSTANT_Integer              3
  85 #define CONSTANT_Float                4
  86 #define CONSTANT_Long                 5
  87 #define CONSTANT_Double               6
  88 #define CONSTANT_NameAndType         12
  89 #define CONSTANT_Utf8                 1
  90
  91 #define CONSTANT_Arraydescriptor     13
  92 #define CONSTANT_UNUSED               0
  93
  94
  95 #define ACC_PUBLIC                0x0001
  96 #define ACC_PRIVATE               0x0002
  97 #define ACC_PROTECTED             0x0004
  98 #define ACC_STATIC                0x0008
  99 #define ACC_FINAL                 0x0010
 100 #define ACC_SYNCHRONIZED          0x0020
 101 #define ACC_VOLATILE              0x0040
 102 #define ACC_TRANSIENT             0x0080
 103 #define ACC_NATIVE                0x0100
 104 #define ACC_INTERFACE             0x0200
 105 #define ACC_ABSTRACT              0x0400
 106
 107
 108
 109 /**************************** resolve typedef-cycles **************************/
 110
 111 typedef struct unicode unicode;
 112 typedef struct classinfo classinfo;
 113 typedef struct vftbl vftbl;
 114 typedef u1* methodptr;
 115
 116
 117 /********************** data structures of UNICODE symbol *********************/
 118
 119 struct unicode {
 120         unicode   *hashlink; /* externe Verkettung f"ur die unicode-Hashtabelle */
 121         u4         key;      /* Hash-Schl"ussel (h"angt nur vom Text ab) */
 122         int        length;   /* L"ange des Textes */
 123         u2        *text;     /* Zeiger auf den Text (jeder Buchstabe 16 Bit) */
 124         classinfo *class;    /* gegebenenfalls Referenz auf die Klasse dieses
 125                                 Namens (oder NULL, wenn es keine solche gibt)  */
 126         struct java_objectheader *string;
 127                              /* gegebenenfalls Referenz auf einen konstanten
 128                                 String mit dem entsprechenden Wert */
 129         };
 130
 131         /* Alle Unicode-Symbole werden in einer einzigen globalen Tabelle
 132            (Hashtabelle) verwaltet, jedes Symbol wird nur einmal angelegt.
 133            -> Speicherersparnis, und "Uberpr"ufung auf Gleichheit durch einfachen
 134            Zeigervergleich */
 135
 136
 137 /************ data structures of remaining constant pool entries **************/
 138
 139
 140 typedef struct {
 141         classinfo *class;
 142         unicode   *name;
 143         unicode   *descriptor;
 144         } constant_FMIref;
 145
 146
 147 typedef struct {
 148         s4 value;
 149         } constant_integer;
 150
 151 typedef struct {
 152         float value;
 153         } constant_float;
 154
 155 typedef struct {
 156         s8 value;
 157         } constant_long;
 158
 159 typedef struct {
 160         double value;
 161         } constant_double;
 162
 163
 164 typedef struct {
 165         unicode *name;
 166         unicode *descriptor;
 167         } constant_nameandtype;
 168
 169
 170 typedef struct constant_arraydescriptor {
 171         int arraytype;
 172         classinfo *objectclass;
 173         struct constant_arraydescriptor *elementdescriptor;
 174         } constant_arraydescriptor;
 175
 176         /* Mit einem Arraydescriptor kann ein Array-Typ dargestellt werden.
 177            Bei normalen Arrays (z.B. Array von Bytes,...) gen"ugt dazu,
 178        dass das Feld arraytype die entsprechende Kennzahl enth"alt
 179        (z.B. ARRAYTYPE_BYTE).
 180        Bei Arrays von Objekten (arraytype=ARRAYTYPE_OBJECT) muss das
 181        Feld objectclass auf die Klassenstruktur der m"oglichen
 182        Element-Objekte zeigen.
 183        Bei Arrays von Arrays (arraytype=ARRAYTYPE_ARRAY) muss das
 184        Feld elementdescriptor auf eine weiter arraydescriptor-Struktur
 185        zeigen, die die Element-Typen beschreibt.
 186         */
 187
 188
 189
 190 /********* Anmerkungen zum Constant-Pool:
 191
 192         Die Typen der Eintr"age in den Constant-Pool werden durch die oben
 193         definierten CONSTANT_.. Werte angegeben.
 194         Bei allen Typen muss zus"atzlich noch eine Datenstruktur hinzugef"ugt
 195         werden, die den wirklichen Wert angibt.
 196         Bei manchen Typen reicht es, einen Verweis auf eine schon bereits
 197         existierende Struktur (z.B. unicode-Texte) einzutragen, bei anderen
 198         muss diese Struktur erst extra erzeugt werden.
 199         Ich habe folgende Datenstrukturen f"ur diese Typen verwendet:
 200
 201                 Typ                      Struktur                    extra erzeugt?
 202         ----------------------------------------------------------------------
 203     CONSTANT_Class               classinfo                         nein
 204     CONSTANT_Fieldref            constant_FMIref                     ja
 205     CONSTANT_Methodref           constant_FMIref                     ja
 206     CONSTANT_InterfaceMethodref  constant_FMIref                     ja
 207     CONSTANT_String              unicode                           nein
 208     CONSTANT_Integer             constant_integer                    ja
 209     CONSTANT_Float               constant_float                      ja
 210     CONSTANT_Long                constant_long                       ja
 211     CONSTANT_Double              constant_double                     ja
 212     CONSTANT_NameAndType         constant_nameandtype                ja
 213     CONSTANT_Utf8                unicode                           nein
 214     CONSTANT_Arraydescriptor     constant_arraydescriptor            ja
 215     CONSTANT_UNUSED              -
 216
 217 *******************************/
 218
 219
 220
 221 /***************** Die Datenstrukturen fuer das Laufzeitsystem ***************/
 222
 223
 224         /********* Objekte **********
 225
 226         Alle Objekte (und Arrays), die am Heap gespeichert werden, m"ussen eine
 227         folgende spezielle Datenstruktur ganz vorne stehen haben:
 228
 229         */
 230
 231 typedef struct java_objectheader {    /* Der Header f"ur alle Objekte */
 232         vftbl *vftbl;                     /* Zeiger auf die Function Table */
 233 } java_objectheader;
 234
 235
 236
 237         /********* Arrays ***********
 238
 239         Alle Arrays in Java sind auch gleichzeitig Objekte (d.h. sie haben auch
 240         den obligatorischen Object-Header und darin einen Verweis auf eine Klasse)
 241         Es gibt aber (der Einfachheit halber) nur eine einzige Klasse f"ur alle
 242         m"oglichen Typen von Arrays, deshalb wird der tats"achliche Typ in einem
 243         Feld im Array-Objekt selbst gespeichert.
 244         Die Typen sind: */
 245
 246 #define ARRAYTYPE_INT      0
 247 #define ARRAYTYPE_LONG     1
 248 #define ARRAYTYPE_FLOAT    2
 249 #define ARRAYTYPE_DOUBLE   3
 250 #define ARRAYTYPE_BYTE     4
 251 #define ARRAYTYPE_CHAR     5
 252 #define ARRAYTYPE_SHORT    6
 253 #define ARRAYTYPE_BOOLEAN  7
 254 #define ARRAYTYPE_OBJECT   8
 255 #define ARRAYTYPE_ARRAY    9
 256
 257
 258         /** Der Header f"ur ein Java-Array **/
 259
 260 typedef struct java_arrayheader {  /* Der Arrayheader f"ur alle Arrays */
 261         java_objectheader objheader;       /* Der Object-Header */
 262         s4 size;                           /* Gr"osse des Arrays */
 263         s4 arraytype;                      /* Typ der Elemente */
 264 } java_arrayheader;
 265
 266
 267
 268         /** Die Unterschiedlichen Strukturen f"ur alle Typen von Arrays **/
 269
 270 typedef struct java_chararray {
 271         java_arrayheader header;
 272         u2 data[1];
 273 } java_chararray;
 274
 275 typedef struct java_floatheader {
 276         java_arrayheader header;
 277         float data[1];
 278 } java_floatarray;
 279
 280 typedef struct java_doublearray {
 281         java_arrayheader header;
 282         double data[1];
 283 } java_doublearray;
 284
 285
 286    /* achtung: die beiden Stukturen booleanarray und bytearray m"ussen
 287       identisches memory-layout haben, weil mit den selben Funktionen
 288       darauf zugegriffen wird */
 289
 290 typedef struct java_booleanarray {
 291         java_arrayheader header;
 292         u1 data[1];
 293 } java_booleanarray;
 294
 295 typedef struct java_bytearray {
 296         java_arrayheader header;
 297         s1 data[1];
 298 } java_bytearray;
 299
 300 typedef struct java_shortarray {
 301         java_arrayheader header;
 302         s2 data[1];
 303 } java_shortarray;
 304
 305 typedef struct java_intarray {
 306         java_arrayheader header;
 307         s4 data[1];
 308 } java_intarray;
 309
 310 typedef struct java_longarray {
 311         java_arrayheader header;
 312         s8 data[1];
 313 } java_longarray;
 314
 315
 316         /* ACHTUNG: die beiden folgenden Strukturen m"ussen unbedingt gleiches
 317            Memory-Layout haben, weil mit ein und der selben Funktion auf die
 318            data-Eintr"age beider Typen zugegriffen wird !!!! */
 319
 320 typedef struct java_objectarray {
 321         java_arrayheader header;
 322         classinfo *elementtype;
 323         java_objectheader *data[1];
 324 } java_objectarray;
 325
 326 typedef struct java_arrayarray {
 327         java_arrayheader header;
 328         constant_arraydescriptor *elementdescriptor;
 329         java_arrayheader *data[1];
 330 } java_arrayarray;
 331
 332
 333
 334
 335 /************** Strukturen f"ur Klassen, Felder & Methoden *****************/
 336
 337
 338     /*** Struktur: fieldinfo ***/
 339
 340 typedef struct fieldinfo {   /* Struktur f"ur ein Feld einer Klasse */
 341         s4       flags;              /* die ACC-Flags */
 342         s4       type;               /* Grunddatentyp */
 343         unicode *name;               /* Name des Felds */
 344         unicode *descriptor;         /* Typedescriptor in JavaVM-Form */
 345
 346         s4       offset;             /* Offset vom Anfang des Objektes */
 347                                      /* (bei Instanzvariablen) */
 348
 349         union {                      /* Speicher f"ur den Wert */
 350                 s4 i;                    /* (bei Klassenvariablen) */
 351                 s8 l;
 352                 float f;
 353                 double d;
 354                 void *a;
 355                 } value;
 356
 357         } fieldinfo;
 358
 359
 360     /*** Struktur: exceptiontable ***/
 361
 362 typedef struct exceptiontable {  /* Exceptionhandler-Eintrag in einer Methode */
 363         s4         startpc;            /* Anfang des G"ultigkeitsbereichs */
 364         s4         endpc;              /* Ende des Bereichs (exklusive) */
 365         s4         handlerpc;          /* JavaVM-Position des Handlers */
 366         classinfo *catchtype;          /* Typ der behandelten Exceptions (oder
 367                                         NULL, wenn alle behandelt werden sollen) */
 368         } exceptiontable;
 369
 370
 371
 372     /*** Struktur: methodinfo ***/
 373
 374 typedef struct methodinfo {  /* Struktur f"ur eine Methode einer Klasse */
 375         s4             flags;            /* die ACC-Flags */
 376         unicode   *name;             /* Name der Methode */
 377         unicode   *descriptor;       /* der JavaVM-Descriptorstring f"ur Methoden */
 378         s4        returntype;        /* only temporary valid, return type */
 379         s4        paramcount;        /* only temporary valid, number of parameters */
 380         u1        *paramtypes;       /* only temporary valid, parameter types */
 381         classinfo *class;            /* Die Klasse, der die Methode geh"ort */
 382         u4         vftblindex;       /* Index dieser Methode f"ur die Virtual
 383                                         Function Table (wenn es keine statische
 384                                         Methode ist) */
 385
 386         s4       maxstack;                  /* maximale Stacktiefe des JavaVM-Codes */
 387         s4   maxlocals;                 /* maximale Anzahl der JavaVM-Variablen */
 388         u4   jcodelength;               /* L"ange des JavaVM-Codes */
 389         u1  *jcode;                     /* und Zeiger auf den JavaVM-Code */
 390
 391         s4   exceptiontablelength;      /* L"ange der Exceptintable */
 392         exceptiontable *exceptiontable; /* Die Exceptiontable selber */
 393
 394         u1  *stubroutine;               /* STUB-Routine for compiling or calling
 395                                            natives */
 396         u4   mcodelength;               /* L"ange des generierten Maschinencodes */
 397         u1  *mcode;                     /* Zeiger auf den Maschinencode */
 398         u1  *entrypoint;                /* Entrypoint to the Maschine-Code */
 399
 400
 401         } methodinfo;
 402
 403
 404     /*** Struktur: classinfo ***/
 405
 406 struct classinfo {           /* Datenstruktur f"ur eine Klasse */
 407         java_objectheader header;     /* Weil auch Klassen als Objekte angesprochen
 408                                          werden */
 409
 410         s4 flags;                     /* Die ACC-Flags */
 411         unicode *name;                /* Name der Klasse */
 412
 413         s4       cpcount;             /* Anzahl der Eintr"age im Constant-Pool */
 414         u1      *cptags;              /* Die TAGs f"ur den Constant-Pool */
 415         voidptr *cpinfos;             /* Die Zeiger auf die Info-Strukturen */
 416
 417         classinfo *super;             /* Zeiger auf die "ubergeordnete Klasse */
 418
 419         s4          interfacescount;  /* Anzahl der Interfaces */
 420         classinfo **interfaces;       /* Zeiger auf die Interfaces */
 421
 422         s4          fieldscount;      /* Anzahl der Felder */
 423         fieldinfo  *fields;           /* Die Tabelle der Felder */
 424
 425         s4          methodscount;     /* Anzahl der Methoden */
 426         methodinfo *methods;          /* Die Tabelle der Methoden */
 427
 428
 429         listnode    listnode;         /* Verkettungsstruktur (f"ur Listen) */
 430
 431         bool        initialized;      /* true, wenn Klasse bereits Initialisiert */
 432         bool        linked;           /* wird von `class_link` auf true gesetzt */
 433         s4                      index;            /* Hierarchietiefe  (bei normalen Klassen)
 434                                          oder fortlaufende Nummer (bei Interfaces)*/
 435         u4          instancesize;     /* Gr"osse eines Objektes dieser Klasse */
 436
 437         vftbl       *vftbl;
 438
 439         methodinfo *finalizer;        /* Finalizer-Methode f"ur die Klasse */
 440         };
 441
 442
 443 struct vftbl {
 444         classinfo  *class;            /* Class, the function table belongs to */
 445
 446         s4          vftbllength;      /* L"aenge der Virtual Function Table */
 447
 448         s4          interfacetablelength;   /* L"ange der Interfacetable */
 449         u4         *interfacevftbllength;   /* -> siehe unten */
 450         methodptr **interfacevftbl;
 451
 452         methodptr   table[1];
 453         };
 454
 455 /*********** Anmerkungen zur Interfacetable:
 456
 457         "Ahnlich wie die 'normalen' virtuellen Methoden k"onnen auch die
 458         Interface-Methoden mit Hilfe einer Art Virtual Function Table
 459         aufgerufen werden.
 460         Dazu werden alle Interfaces im System fortlaufend nummeriert (beginnend
 461         bei 0), und f"ur jede Klasse wird eine ganze Tabelle von
 462         Virtual Function Tables erzeugt, n"amlich zu jedem Interface, das die
 463         Klasse implementiert, eine.
 464
 465         z.B. Nehmen wir an, eine Klasse implementiert zwei Interfaces (die durch
 466         die Nummerierung die Indizes 0 und 3 bekommen haben)
 467
 468         Das sieht dann ungef"ahr so aus:
 469                                 --------------           -------------
 470         interfacevftbl ---> | Eintrag 0  |---------> | Methode 0 |---> Methode X
 471                         | Eintrag 1  |--> NULL   | Methode 1 |---> Methode Y
 472                         | Eintrag 2  |--> NULL   | Methode 2 |---> Methode Z
 473                         | Eintrag 3  |-----+     -------------
 474                         --------------     |
 475                                            +---> -------------
 476                                                  | Methode 0 |---> Methode X
 477                                                  | Methode 1 |---> Methode A
 478                                                  -------------
 479                               ---------------
 480         interfacevftlblength ---> | Wert 0 = 3  |
 481                                   | Wert 1 = 0  |
 482                                   | Wert 2 = 0  |
 483                                   | Wert 3 = 2  |
 484                                   ---------------
 485
 486         Der Aufruf einer Interface-Methode geht dann so vor sich:
 487         Zur Compilezeit steht der Index (i) des Interfaces und die Stelle (s), wo
 488         in der entsprechenden Untertabelle die Methode eingetragen ist, schon fest.
 489         Also muss zur Laufzeit nur mehr der n-te Eintrag aus der Interfacetable
 490         gelesen werden, von dieser Tabelle aus wird der s-te Eintrag geholt,
 491         und diese Methode wird angesprungen.
 492
 493 ****************/
 494
 495
 496
 497 /************************* Referenzen auf die wichtigen Systemklassen ********************/
 498
 499 extern classinfo *class_java_lang_Object;
 500 extern classinfo *class_java_lang_String;
 501 extern classinfo *class_java_lang_ClassCastException;
 502 extern classinfo *class_java_lang_NullPointerException;
 503 extern classinfo *class_java_lang_ArrayIndexOutOfBoundsException;
 504 extern classinfo *class_java_lang_NegativeArraySizeException;
 505 extern classinfo *class_java_lang_OutOfMemoryError;
 506 extern classinfo *class_java_lang_ArithmeticException;
 507 extern classinfo *class_java_lang_ArrayStoreException;
 508 extern classinfo *class_java_lang_ThreadDeath;              /* schani */
 509
 510 extern classinfo *class_array;
 511
 512
 513 /********************** Vorgefertigte Instanzen einiger Systemklassen ********************/
 514
 515 extern java_objectheader *proto_java_lang_ClassCastException;
 516 extern java_objectheader *proto_java_lang_NullPointerException;
 517 extern java_objectheader *proto_java_lang_ArrayIndexOutOfBoundsException;
 518 extern java_objectheader *proto_java_lang_NegativeArraySizeException;
 519 extern java_objectheader *proto_java_lang_OutOfMemoryError;
 520 extern java_objectheader *proto_java_lang_ArithmeticException;
 521 extern java_objectheader *proto_java_lang_ArrayStoreException;
 522 extern java_objectheader *proto_java_lang_ThreadDeath;      /* schani */
 523
 524
 525 /********************** flag variables *********************/
 526
 527 extern bool compileall;
 528 extern bool runverbose;
 529 extern bool verbose;
 530
 531
 532 /********************** trace variables ********************/
 533
 534 extern int count_class_infos;
 535 extern int count_const_pool_len;
 536 extern int count_vftbl_len;
 537 extern int count_unicode_len;
 538 extern int count_all_methods;
 539 extern int count_vmcode_len;
 540 extern int count_extable_len;
 541
 542 #endif