newcomp.c

   1 /***************************** ncomp/ncomp.c ***********************************
   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 the functions which translates a JavaVM method into native code.
   8         This is the new version of the compiler which is a lot faster and has new
   9         exception handling schemes. The main function is new_comp.
  10
  11         Authors: Andreas  Krall      EMAIL: cacao@complang.tuwien.ac.at
  12                  Reinhard Grafl      EMAIL: cacao@complang.tuwien.ac.at
  13
  14         Last Change: 1997/11/05
  15
  16 *******************************************************************************/
  17
  18 #include "signal.h"
  19 #include "global.h"
  20 #include "ncomp/ncomp.h"
  21
  22 #include "loader.h"
  23 #include "tables.h"
  24 #include "builtin.h"
  25 #include "native.h"
  26 #include "asmpart.h"
  27
  28 #include "threads/thread.h"
  29
  30
  31 /*************************** global switches **********************************/
  32
  33 bool compileverbose = false;
  34 bool showstack = false;
  35 bool showdisassemble = false;
  36 bool showintermediate = false;
  37 int  optimizelevel = 0;
  38
  39 bool checkbounds = true;
  40 bool checknull = true;
  41 bool checkfloats = true;
  42 bool checksync = true;
  43
  44 bool getcompilingtime = false;
  45 long compilingtime = 0;
  46
  47 int  has_ext_instr_set = 0;
  48
  49 bool statistics = false;
  50
  51 int count_jit_calls = 0;
  52 int count_methods = 0;
  53 int count_spills = 0;
  54 int count_pcmd_activ = 0;
  55 int count_pcmd_drop = 0;
  56 int count_pcmd_zero = 0;
  57 int count_pcmd_const_store = 0;
  58 int count_pcmd_const_alu = 0;
  59 int count_pcmd_const_bra = 0;
  60 int count_pcmd_load = 0;
  61 int count_pcmd_move = 0;
  62 int count_load_instruction = 0;
  63 int count_pcmd_store = 0;
  64 int count_pcmd_store_comb = 0;
  65 int count_dup_instruction = 0;
  66 int count_pcmd_op = 0;
  67 int count_pcmd_mem = 0;
  68 int count_pcmd_met = 0;
  69 int count_pcmd_bra = 0;
  70 int count_pcmd_table = 0;
  71 int count_pcmd_return = 0;
  72 int count_pcmd_returnx = 0;
  73 int count_check_null = 0;
  74 int count_check_bound = 0;
  75 int count_max_basic_blocks = 0;
  76 int count_basic_blocks = 0;
  77 int count_javainstr = 0;
  78 int count_max_javainstr = 0;
  79 int count_javacodesize = 0;
  80 int count_javaexcsize = 0;
  81 int count_calls = 0;
  82 int count_tryblocks = 0;
  83 int count_code_len = 0;
  84 int count_data_len = 0;
  85 int count_cstub_len = 0;
  86 int count_nstub_len = 0;
  87 int count_max_new_stack = 0;
  88 int count_upper_bound_new_stack = 0;
  89 static int count_block_stack_init[11] = {0, 0, 0, 0, 0,  0, 0, 0, 0, 0,  0};
  90 int *count_block_stack = count_block_stack_init;
  91 static int count_analyse_iterations_init[5] = {0, 0, 0, 0, 0};
  92 int *count_analyse_iterations = count_analyse_iterations_init;
  93 static int count_method_bb_distribution_init[9] = {0, 0, 0, 0, 0,  0, 0, 0, 0};
  94 int *count_method_bb_distribution = count_method_bb_distribution_init;
  95 static int count_block_size_distribution_init[18] = {0, 0, 0, 0, 0,
  96         0, 0, 0, 0, 0,   0, 0, 0, 0, 0,   0, 0, 0};
  97 int *count_block_size_distribution = count_block_size_distribution_init;
  98 static int count_store_length_init[21] = {0, 0, 0, 0, 0,  0, 0, 0, 0, 0,
  99                                           0, 0, 0, 0, 0,  0, 0, 0, 0, 0,  0};
 100 int *count_store_length = count_store_length_init;
 101 static int count_store_depth_init[11] = {0, 0, 0, 0, 0,  0, 0, 0, 0, 0,   0};
 102 int *count_store_depth = count_store_depth_init;
 103
 104
 105 /*********************** include compiler data types **************************/
 106
 107 #include "ncomp/ncompdef.h"
 108
 109
 110 /*********************** global compiler variables ****************************/
 111
 112                                 /* data about the currently compiled method   */
 113
 114 static classinfo  *class;       /* class the compiled method belongs to       */
 115 static methodinfo *method;      /* pointer to method info of compiled method  */
 116 static unicode    *descriptor;  /* type descriptor of compiled method         */
 117 static u2         mparamcount;  /* number of parameters (incl. this)          */
 118 static u1         *mparamtypes; /* types of all parameters (TYPE_INT, ...)    */
 119 static u2         mreturntype;  /* return type of method                      */
 120
 121 static int maxstack;            /* maximal JavaVM stack size                  */
 122 static int maxlocals;           /* maximal number of local JavaVM variables   */
 123 static int jcodelength;         /* length of JavaVM-codes                     */
 124 static u1 *jcode;               /* pointer to start of JavaVM-code            */
 125 static int exceptiontablelength;/* length of exception table                  */
 126 static exceptiontable *extable; /* pointer to start of exception table        */
 127
 128 static int block_count;         /* number of basic blocks                     */
 129 static basicblock *block;       /* points to basic block array                */
 130 static int *block_index;        /* a table which contains for every byte of   */
 131                                 /* JavaVM code a basic block index if at this */
 132                                 /* byte there is the start of a basic block   */
 133
 134 static int instr_count;         /* number of JavaVM instructions              */
 135 static instruction *instr;      /* points to intermediate code instructions   */
 136
 137 static int stack_count;         /* number of stack elements                   */
 138 static stackelement *stack;     /* points to intermediate code instructions   */
 139
 140 static bool isleafmethod;       /* true if a method doesn't call subroutines  */
 141
 142 /* list of all classes used by the compiled method which have to be           */
 143 /* initialised (if not already done) before execution of this method          */
 144
 145 static chain *uninitializedclasses;
 146
 147
 148 /******************** include compiler subsystems *****************************/
 149
 150 #include "sysdep/ngen.h"        /* code generator header file                 */
 151 #include "ncomp/ntools.c"       /* compiler tool functions                    */
 152 #include "ncomp/mcode.c"        /* code generation tool functions             */
 153 #include "ncomp/nparse.c"       /* parsing of JavaVM code                     */
 154 #include "ncomp/nreg.c"         /* register allocation and support routines   */
 155 #include "ncomp/nstack.c"       /* analysing the stack operations             */
 156 #include "sysdep/ngen.c"        /* code generator                             */
 157 #include "sysdep/disass.c"      /* disassembler (for debug purposes only)     */
 158
 159
 160
 161
 162 /* dummy function, used when there is no JavaVM code available                */
 163
 164 static void* do_nothing_function()
 165 {
 166         return NULL;
 167 }
 168
 169
 170 /*******************************************************************************
 171
 172         new_compile, new version of compiler, translates one method to machine code
 173
 174 *******************************************************************************/
 175
 176 methodptr new_compile(methodinfo *m)
 177 {
 178         int  dumpsize;
 179         long starttime = 0;
 180         long stoptime  = 0;
 181
 182         /* if method has been already compiled return immediately */
 183
 184         count_jit_calls++;
 185
 186         if (m->entrypoint)
 187                 return m->entrypoint;
 188
 189         count_methods++;
 190
 191         intsDisable();      /* disable interrupts */
 192
 193
 194         /* mark start of dump memory area */
 195
 196         dumpsize = dump_size ();
 197
 198         /* measure time */
 199
 200         if (getcompilingtime)
 201                 starttime = getcputime();
 202
 203         /* if there is no javacode print error message and return empty method    */
 204
 205         if (! m->jcode) {
 206                 sprintf(logtext, "No code given for: ");
 207                 unicode_sprint(logtext+strlen(logtext), m->class->name);
 208                 strcpy(logtext+strlen(logtext), ".");
 209                 unicode_sprint(logtext+strlen(logtext), m->name);
 210                 unicode_sprint(logtext+strlen(logtext), m->descriptor);
 211                 dolog();
 212                 intsRestore();                             /* enable interrupts again */
 213                 return (methodptr) do_nothing_function;    /* return empty method     */
 214                 }
 215
 216         /* print log message for compiled method */
 217
 218         if (compileverbose) {
 219                 sprintf(logtext, "Compiling: ");
 220                 unicode_sprint(logtext+strlen(logtext), m->class->name);
 221                 strcpy(logtext+strlen(logtext), ".");
 222                 unicode_sprint(logtext+strlen(logtext), m->name);
 223                 unicode_sprint(logtext+strlen(logtext), m->descriptor);
 224                 dolog ();
 225                 }
 226
 227
 228         /* initialisation of variables and subsystems */
 229
 230         isleafmethod = true;
 231
 232         method = m;
 233         class = m->class;
 234         descriptor = m->descriptor;
 235         maxstack = m->maxstack;
 236         maxlocals = m->maxlocals;
 237         jcodelength = m->jcodelength;
 238         jcode = m->jcode;
 239         exceptiontablelength = m->exceptiontablelength;
 240         extable = m->exceptiontable;
 241
 242 #ifdef STATISTICS
 243         count_tryblocks += exceptiontablelength;
 244         count_javacodesize += jcodelength + 18;
 245         count_javaexcsize += exceptiontablelength * 8;
 246 #endif
 247
 248         /* initialise parameter type descriptor */
 249
 250         descriptor2types (m);
 251         mreturntype = m->returntype;
 252         mparamcount = m->paramcount;
 253         mparamtypes = m->paramtypes;
 254
 255         /* initialize class list with class the compiled method belongs to */
 256
 257         uninitializedclasses = chain_new();
 258         compiler_addinitclass (m->class);
 259
 260
 261         /********************** call the compiler passes **************************/
 262
 263         reg_init();
 264         local_init();
 265         mcode_init();
 266
 267         if (runverbose)
 268                 allocate_literals();
 269
 270         parse();
 271
 272         analyse_stack();
 273
 274         interface_regalloc();
 275
 276         allocate_scratch_registers();
 277
 278         local_regalloc();
 279
 280         gen_mcode();
 281
 282
 283         /*********** Zwischendarstellungen auf Wunsch ausgeben **********/
 284
 285         if (showintermediate)
 286                 show_icmd_method();
 287
 288         if (showdisassemble) {
 289                 dseg_display((void*) (m->mcode));
 290                 disassemble((void*) (m->mcode + dseglen), m->mcodelength - dseglen);
 291                 fflush(stdout);
 292                 }
 293
 294
 295         /* release dump area */
 296
 297         dump_release (dumpsize);
 298
 299         /* measure time */
 300
 301         if (getcompilingtime) {
 302                 stoptime = getcputime();
 303                 compilingtime += (stoptime-starttime);
 304                 }
 305
 306         /* initialize all used classes */
 307         /* because of reentrant code global variables are not allowed here        */
 308
 309         {
 310         chain *ul = uninitializedclasses;   /* list of uninitialized classes      */
 311         classinfo *c;                       /* single class                       */
 312
 313         while ((c = chain_first(ul)) != NULL) {
 314                 chain_remove (ul);
 315                 class_init (c);                         /* may again call the compiler        */
 316                 }
 317         chain_free (ul);
 318         }
 319
 320         intsRestore();    /* enable interrupts again */
 321
 322         /* return pointer to the methods entry point */
 323
 324         return m -> entrypoint;
 325 }
 326
 327
 328 /************ functions for compiler initialisation and finalisation **********/
 329
 330 void ncomp_init ()
 331 {
 332         int i;
 333
 334         has_ext_instr_set = ! has_no_x_instr_set();
 335
 336         for (i = 0; i < 256; i++)
 337                 stackreq[i] = 1;
 338
 339         stackreq[JAVA_NOP]          = 0;
 340         stackreq[JAVA_ISTORE]       = 0;
 341         stackreq[JAVA_LSTORE]       = 0;
 342         stackreq[JAVA_FSTORE]       = 0;
 343         stackreq[JAVA_DSTORE]       = 0;
 344         stackreq[JAVA_ASTORE]       = 0;
 345         stackreq[JAVA_ISTORE_0]     = 0;
 346         stackreq[JAVA_ISTORE_1]     = 0;
 347         stackreq[JAVA_ISTORE_2]     = 0;
 348         stackreq[JAVA_ISTORE_3]     = 0;
 349         stackreq[JAVA_LSTORE_0]     = 0;
 350         stackreq[JAVA_LSTORE_1]     = 0;
 351         stackreq[JAVA_LSTORE_2]     = 0;
 352         stackreq[JAVA_LSTORE_3]     = 0;
 353         stackreq[JAVA_FSTORE_0]     = 0;
 354         stackreq[JAVA_FSTORE_1]     = 0;
 355         stackreq[JAVA_FSTORE_2]     = 0;
 356         stackreq[JAVA_FSTORE_3]     = 0;
 357         stackreq[JAVA_DSTORE_0]     = 0;
 358         stackreq[JAVA_DSTORE_1]     = 0;
 359         stackreq[JAVA_DSTORE_2]     = 0;
 360         stackreq[JAVA_DSTORE_3]     = 0;
 361         stackreq[JAVA_ASTORE_0]     = 0;
 362         stackreq[JAVA_ASTORE_1]     = 0;
 363         stackreq[JAVA_ASTORE_2]     = 0;
 364         stackreq[JAVA_ASTORE_3]     = 0;
 365         stackreq[JAVA_IASTORE]      = 0;
 366         stackreq[JAVA_LASTORE]      = 0;
 367         stackreq[JAVA_FASTORE]      = 0;
 368         stackreq[JAVA_DASTORE]      = 0;
 369         stackreq[JAVA_AASTORE]      = 0;
 370         stackreq[JAVA_BASTORE]      = 0;
 371         stackreq[JAVA_CASTORE]      = 0;
 372         stackreq[JAVA_SASTORE]      = 0;
 373         stackreq[JAVA_POP]          = 0;
 374         stackreq[JAVA_POP2]         = 0;
 375         stackreq[JAVA_IINC]         = 0;
 376         stackreq[JAVA_IFEQ]         = 0;
 377         stackreq[JAVA_IFNE]         = 0;
 378         stackreq[JAVA_IFLT]         = 0;
 379         stackreq[JAVA_IFGE]         = 0;
 380         stackreq[JAVA_IFGT]         = 0;
 381         stackreq[JAVA_IFLE]         = 0;
 382         stackreq[JAVA_IF_ICMPEQ]    = 0;
 383         stackreq[JAVA_IF_ICMPNE]    = 0;
 384         stackreq[JAVA_IF_ICMPLT]    = 0;
 385         stackreq[JAVA_IF_ICMPGE]    = 0;
 386         stackreq[JAVA_IF_ICMPGT]    = 0;
 387         stackreq[JAVA_IF_ICMPLE]    = 0;
 388         stackreq[JAVA_IF_ACMPEQ]    = 0;
 389         stackreq[JAVA_IF_ACMPNE]    = 0;
 390         stackreq[JAVA_GOTO]         = 0;
 391         stackreq[JAVA_RET]          = 0;
 392         stackreq[JAVA_TABLESWITCH]  = 0;
 393         stackreq[ICMD_LOOKUPSWITCH] = 0;
 394         stackreq[JAVA_IRETURN]      = 0;
 395         stackreq[JAVA_LRETURN]      = 0;
 396         stackreq[JAVA_FRETURN]      = 0;
 397         stackreq[JAVA_DRETURN]      = 0;
 398         stackreq[JAVA_ARETURN]      = 0;
 399         stackreq[JAVA_RETURN]       = 0;
 400         stackreq[JAVA_PUTSTATIC]    = 0;
 401         stackreq[JAVA_PUTFIELD]     = 0;
 402         stackreq[JAVA_MONITORENTER] = 0;
 403         stackreq[ICMD_MONITOREXIT]  = 0;
 404         stackreq[JAVA_WIDE]         = 0;
 405         stackreq[JAVA_IFNULL]       = 0;
 406         stackreq[JAVA_IFNONNULL]    = 0;
 407         stackreq[JAVA_GOTO_W]       = 0;
 408         stackreq[JAVA_BREAKPOINT]   = 0;
 409
 410         stackreq[JAVA_SWAP] = 2;
 411         stackreq[JAVA_DUP2] = 2;
 412         stackreq[JAVA_DUP_X1] = 3;
 413         stackreq[JAVA_DUP_X2] = 4;
 414         stackreq[JAVA_DUP2_X1] = 3;
 415         stackreq[JAVA_DUP2_X2] = 4;
 416
 417         for (i = 0; i < 256; i++) stdopdescriptors[i] = NULL;
 418
 419         for (i = 0; i < sizeof(stdopdescriptortable)/sizeof(stdopdescriptor); i++) {
 420
 421                 if (stdopdescriptortable[i].isfloat && checkfloats) {
 422                         stdopdescriptortable[i].supported = false;
 423                         }
 424
 425                 stdopdescriptors[stdopdescriptortable[i].opcode] =
 426                    &(stdopdescriptortable[i]);
 427                 }
 428
 429         init_exceptions();
 430 }
 431
 432
 433 void ncomp_close()
 434 {
 435 /*      mcode_close(); */
 436 }
 437