src/vm/jit/parse.c

   1 /* src/vm/jit/parse.c - parser for JavaVM to intermediate code translation
   2
   3    Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   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., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    Contact: cacao@cacaojvm.org
  26
  27    Author: Andreas Krall
  28
  29    Changes: Carolyn Oates
  30             Edwin Steiner
  31             Joseph Wenninger
  32             Christian Thalinger
  33
  34    $Id: parse.c 5302 2006-09-05 10:37:26Z edwin $
  35
  36 */
  37
  38
  39 #include "config.h"
  40
  41 #include <assert.h>
  42 #include <string.h>
  43
  44 #include "vm/types.h"
  45
  46 #include "mm/memory.h"
  47 #include "native/native.h"
  48
  49 #if defined(ENABLE_THREADS)
  50 # include "threads/native/lock.h"
  51 #endif
  52
  53 #include "toolbox/logging.h"
  54 #include "vm/builtin.h"
  55 #include "vm/exceptions.h"
  56 #include "vm/global.h"
  57 #include "vm/linker.h"
  58 #include "vm/loader.h"
  59 #include "vm/resolve.h"
  60 #include "vm/options.h"
  61 #include "vm/statistics.h"
  62 #include "vm/stringlocal.h"
  63 #include "vm/suck.h"
  64 #include "vm/jit/asmpart.h"
  65 #include "vm/jit/jit.h"
  66 #include "vm/jit/parse.h"
  67 #include "vm/jit/patcher.h"
  68 #include "vm/jit/loop/loop.h"
  69
  70 /*******************************************************************************
  71
  72         function 'parse' scans the JavaVM code and generates intermediate code
  73
  74         During parsing the block index table is used to store at bit pos 0
  75         a flag which marks basic block starts and at position 1 to 31 the
  76         intermediate instruction index. After parsing the block index table
  77         is scanned, for marked positions a block is generated and the block
  78         number is stored in the block index table.
  79
  80 *******************************************************************************/
  81
  82 static exceptiontable * new_fillextable(
  83                                                                         jitdata *jd,
  84                                                                         methodinfo *m,
  85                                                                         exceptiontable *extable,
  86                                                                         exceptiontable *raw_extable,
  87                                                                 int exceptiontablelength,
  88                                                                         int *block_count)
  89 {
  90         int b_count, p, src;
  91
  92         if (exceptiontablelength == 0)
  93                 return extable;
  94
  95         b_count = *block_count;
  96
  97         for (src = exceptiontablelength-1; src >=0; src--) {
  98                 /* the start of the handled region becomes a basic block start */
  99                 p = raw_extable[src].startpc;
 100                 CHECK_BYTECODE_INDEX(p);
 101                 extable->startpc = p;
 102                 NEW_MARK_BASICBLOCK(p);
 103
 104                 p = raw_extable[src].endpc; /* see JVM Spec 4.7.3 */
 105                 CHECK_BYTECODE_INDEX_EXCLUSIVE(p);
 106
 107 #if defined(ENABLE_VERIFIER)
 108                 if (p <= raw_extable[src].startpc) {
 109                         exceptions_throw_verifyerror(m,
 110                                 "Invalid exception handler range");
 111                         return NULL;
 112                 }
 113 #endif
 114                 extable->endpc = p;
 115
 116                 /* end of handled region becomes a basic block boundary  */
 117                 /* (If it is the bytecode end, we'll use the special     */
 118                 /* end block that is created anyway.)                    */
 119                 if (p < m->jcodelength)
 120                         NEW_MARK_BASICBLOCK(p);
 121
 122                 /* the start of the handler becomes a basic block start  */
 123                 p = raw_extable[src].handlerpc;
 124                 CHECK_BYTECODE_INDEX(p);
 125                 extable->handlerpc = p;
 126                 NEW_MARK_BASICBLOCK(p);
 127
 128                 extable->catchtype = raw_extable[src].catchtype;
 129                 extable->next = NULL;
 130                 extable->down = &extable[1];
 131                 extable--;
 132         }
 133
 134         *block_count = b_count;
 135
 136         /* everything ok */
 137         return extable;
 138
 139 #if defined(ENABLE_VERIFIER)
 140 throw_invalid_bytecode_index:
 141         exceptions_throw_verifyerror(m,
 142                                                                  "Illegal bytecode index in exception table");
 143         return NULL;
 144 #endif
 145 }
 146
 147 /*** macro for checking the length of the bytecode ***/
 148
 149 #if defined(ENABLE_VERIFIER)
 150 #define CHECK_END_OF_BYTECODE(neededlength) \
 151         do { \
 152                 if ((neededlength) > m->jcodelength) \
 153                         goto throw_unexpected_end_of_bytecode; \
 154         } while (0)
 155 #else /* !ENABLE_VERIFIER */
 156 #define CHECK_END_OF_BYTECODE(neededlength)
 157 #endif /* ENABLE_VERIFIER */
 158
 159 bool new_parse(jitdata *jd)
 160 {
 161         methodinfo  *m;             /* method being parsed                      */
 162         codeinfo    *code;
 163         codegendata *cd;
 164         int  p;                     /* java instruction counter                 */
 165         int  nextp;                 /* start of next java instruction           */
 166         int  opcode;                /* java opcode                              */
 167         int  i;                     /* temporary for different uses (ctrs)      */
 168         int  ipc = 0;               /* intermediate instruction counter         */
 169         int  b_count = 0;           /* basic block counter                      */
 170         int  s_count = 0;           /* stack element counter                    */
 171         bool blockend = false;      /* true if basic block end has been reached */
 172         bool iswide = false;        /* true if last instruction was a wide      */
 173         new_instruction *iptr;      /* current ptr into instruction array       */
 174         u1 *instructionstart;       /* 1 for pcs which are valid instr. starts  */
 175         constant_classref  *cr;
 176         constant_classref  *compr;
 177         classinfo          *c;
 178         builtintable_entry *bte;
 179         constant_FMIref    *mr;
 180         methoddesc         *md;
 181         unresolved_method  *um;
 182         resolve_result_t    result;
 183         u2                  lineindex = 0;
 184         u2                  currentline = 0;
 185         u2                  linepcchange = 0;
 186         u4                  flags;
 187         basicblock         *bptr;
 188
 189         /* get required compiler data */
 190
 191         m    = jd->m;
 192         code = jd->code;
 193         cd   = jd->cd;
 194
 195         /* allocate instruction array and block index table */
 196
 197         /* 1 additional for end ipc  */
 198         jd->new_basicblockindex = DMNEW(s4, m->jcodelength + 1);
 199         memset(jd->new_basicblockindex, 0, sizeof(s4) * (m->jcodelength + 1));
 200
 201         instructionstart = DMNEW(u1, m->jcodelength + 1);
 202         memset(instructionstart, 0, sizeof(u1) * (m->jcodelength + 1));
 203
 204         /* IMPORTANT: We assume that parsing creates at most one instruction per */
 205         /*            byte of original bytecode!                                 */
 206
 207         iptr = jd->new_instructions = DMNEW(new_instruction, m->jcodelength);
 208
 209         /* compute branch targets of exception table */
 210
 211         if (!new_fillextable(jd, m,
 212                         &(cd->exceptiontable[cd->exceptiontablelength-1]),
 213                         m->exceptiontable,
 214                         m->exceptiontablelength,
 215                         &b_count))
 216         {
 217                 return false;
 218         }
 219
 220         s_count = 1 + m->exceptiontablelength; /* initialize stack element counter   */
 221
 222 #if defined(ENABLE_THREADS)
 223         if (checksync && (m->flags & ACC_SYNCHRONIZED))
 224                 jd->isleafmethod = false;
 225 #endif
 226
 227         /* setup line number info */
 228
 229         currentline = 0;
 230         linepcchange = 0;
 231
 232         if (m->linenumbercount == 0) {
 233                 lineindex = 0;
 234         }
 235         else {
 236                 linepcchange = m->linenumbers[0].start_pc;
 237         }
 238
 239         /*** LOOP OVER ALL BYTECODE INSTRUCTIONS **********************************/
 240
 241         for (p = 0; p < m->jcodelength; p = nextp) {
 242
 243                 /* mark this position as a valid instruction start */
 244
 245                 instructionstart[p] = 1;
 246
 247                 /* change the current line number, if necessary */
 248
 249                 /* XXX rewrite this using pointer arithmetic */
 250
 251                 if (linepcchange == p) {
 252                         if (m->linenumbercount > lineindex) {
 253 next_linenumber:
 254                                 currentline = m->linenumbers[lineindex].line_number;
 255                                 lineindex++;
 256                                 if (lineindex < m->linenumbercount) {
 257                                         linepcchange = m->linenumbers[lineindex].start_pc;
 258                                         if (linepcchange == p)
 259                                                 goto next_linenumber;
 260                                 }
 261                         }
 262                 }
 263
 264                 /* fetch next opcode  */
 265 fetch_opcode:
 266                 opcode = SUCK_BE_U1(m->jcode + p);
 267
 268                 /* store intermediate instruction count (bit 0 mark block starts) */
 269
 270                 jd->new_basicblockindex[p] |= (ipc << 1);
 271
 272                 /* some compilers put a JAVA_NOP after a blockend instruction */
 273
 274                 if (blockend && (opcode != JAVA_NOP)) {
 275                         /* start new block */
 276
 277                         NEW_MARK_BASICBLOCK(p);
 278                         blockend = false;
 279                 }
 280
 281                 /* compute next instruction start */
 282
 283                 nextp = p + jcommandsize[opcode];
 284
 285                 CHECK_END_OF_BYTECODE(nextp);
 286
 287                 /* add stack elements produced by this instruction */
 288
 289                 s_count += stackreq[opcode];
 290
 291                 /* translate this bytecode instruction */
 292
 293                 switch (opcode) {
 294
 295                 case JAVA_NOP:
 296                         break;
 297
 298                 /* pushing constants onto the stack ***********************************/
 299
 300                 case JAVA_BIPUSH:
 301                         NEW_OP_LOADCONST_I(SUCK_BE_S1(m->jcode + p + 1));
 302                         break;
 303
 304                 case JAVA_SIPUSH:
 305                         NEW_OP_LOADCONST_I(SUCK_BE_S2(m->jcode + p + 1));
 306                         break;
 307
 308                 case JAVA_LDC1:
 309                         i = SUCK_BE_U1(m->jcode + p + 1);
 310                         goto pushconstantitem;
 311
 312                 case JAVA_LDC2:
 313                 case JAVA_LDC2W:
 314                         i = SUCK_BE_U2(m->jcode + p + 1);
 315
 316                 pushconstantitem:
 317
 318 #if defined(ENABLE_VERIFIER)
 319                         if (i >= m->class->cpcount) {
 320                                 exceptions_throw_verifyerror(m,
 321                                         "Attempt to access constant outside range");
 322                                 return false;
 323                         }
 324 #endif
 325
 326                         switch (m->class->cptags[i]) {
 327                         case CONSTANT_Integer:
 328                                 NEW_OP_LOADCONST_I(((constant_integer *) (m->class->cpinfos[i]))->value);
 329                                 break;
 330                         case CONSTANT_Long:
 331                                 NEW_OP_LOADCONST_L(((constant_long *) (m->class->cpinfos[i]))->value);
 332                                 break;
 333                         case CONSTANT_Float:
 334                                 NEW_OP_LOADCONST_F(((constant_float *) (m->class->cpinfos[i]))->value);
 335                                 break;
 336                         case CONSTANT_Double:
 337                                 NEW_OP_LOADCONST_D(((constant_double *) (m->class->cpinfos[i]))->value);
 338                                 break;
 339                         case CONSTANT_String:
 340                                 NEW_OP_LOADCONST_STRING(literalstring_new((utf *) (m->class->cpinfos[i])));
 341                                 break;
 342                         case CONSTANT_Class:
 343                                 cr = (constant_classref *) (m->class->cpinfos[i]);
 344
 345                                 if (!resolve_classref(m, cr, resolveLazy, true,
 346                                                                           true, &c))
 347                                         return false;
 348
 349                                 /* if not resolved, c == NULL */
 350
 351                                 NEW_OP_LOADCONST_CLASSINFO_OR_CLASSREF(c, cr, 0 /* no extra flags */);
 352
 353                                 break;
 354
 355 #if defined(ENABLE_VERIFIER)
 356                         default:
 357                                 exceptions_throw_verifyerror(m,
 358                                                 "Invalid constant type to push");
 359                                 return false;
 360 #endif
 361                         }
 362                         break;
 363
 364                 case JAVA_ACONST_NULL:
 365                         NEW_OP_LOADCONST_NULL();
 366                         break;
 367
 368                 case JAVA_ICONST_M1:
 369                 case JAVA_ICONST_0:
 370                 case JAVA_ICONST_1:
 371                 case JAVA_ICONST_2:
 372                 case JAVA_ICONST_3:
 373                 case JAVA_ICONST_4:
 374                 case JAVA_ICONST_5:
 375                         NEW_OP_LOADCONST_I(opcode - JAVA_ICONST_0);
 376                         break;
 377
 378                 case JAVA_LCONST_0:
 379                 case JAVA_LCONST_1:
 380                         NEW_OP_LOADCONST_L(opcode - JAVA_LCONST_0);
 381                         break;
 382
 383                 case JAVA_FCONST_0:
 384                 case JAVA_FCONST_1:
 385                 case JAVA_FCONST_2:
 386                         NEW_OP_LOADCONST_F(opcode - JAVA_FCONST_0);
 387                         break;
 388
 389                 case JAVA_DCONST_0:
 390                 case JAVA_DCONST_1:
 391                         NEW_OP_LOADCONST_D(opcode - JAVA_DCONST_0);
 392                         break;
 393
 394                 /* local variable access instructions *********************************/
 395
 396                 case JAVA_ILOAD:
 397                 case JAVA_FLOAD:
 398                 case JAVA_ALOAD:
 399                         if (iswide == false) {
 400                                 i = SUCK_BE_U1(m->jcode + p + 1);
 401                         }
 402                         else {
 403                                 i = SUCK_BE_U2(m->jcode + p + 1);
 404                                 nextp = p + 3;
 405                                 iswide = false;
 406                         }
 407                         NEW_OP_LOAD_ONEWORD(opcode, i);
 408                         break;
 409
 410                 case JAVA_LLOAD:
 411                 case JAVA_DLOAD:
 412                         if (iswide == false) {
 413                                 i = SUCK_BE_U1(m->jcode + p + 1);
 414                         }
 415                         else {
 416                                 i = SUCK_BE_U2(m->jcode + p + 1);
 417                                 nextp = p + 3;
 418                                 iswide = false;
 419                         }
 420                         NEW_OP_LOAD_TWOWORD(opcode, i);
 421                         break;
 422
 423                 case JAVA_ILOAD_0:
 424                 case JAVA_ILOAD_1:
 425                 case JAVA_ILOAD_2:
 426                 case JAVA_ILOAD_3:
 427                         NEW_OP_LOAD_ONEWORD(ICMD_ILOAD, opcode - JAVA_ILOAD_0);
 428                         break;
 429
 430                 case JAVA_LLOAD_0:
 431                 case JAVA_LLOAD_1:
 432                 case JAVA_LLOAD_2:
 433                 case JAVA_LLOAD_3:
 434                         NEW_OP_LOAD_TWOWORD(ICMD_LLOAD, opcode - JAVA_LLOAD_0);
 435                         break;
 436
 437                 case JAVA_FLOAD_0:
 438                 case JAVA_FLOAD_1:
 439                 case JAVA_FLOAD_2:
 440                 case JAVA_FLOAD_3:
 441                         NEW_OP_LOAD_ONEWORD(ICMD_FLOAD, opcode - JAVA_FLOAD_0);
 442                         break;
 443
 444                 case JAVA_DLOAD_0:
 445                 case JAVA_DLOAD_1:
 446                 case JAVA_DLOAD_2:
 447                 case JAVA_DLOAD_3:
 448                         NEW_OP_LOAD_TWOWORD(ICMD_DLOAD, opcode - JAVA_DLOAD_0);
 449                         break;
 450
 451                 case JAVA_ALOAD_0:
 452                 case JAVA_ALOAD_1:
 453                 case JAVA_ALOAD_2:
 454                 case JAVA_ALOAD_3:
 455                         NEW_OP_LOAD_ONEWORD(ICMD_ALOAD, opcode - JAVA_ALOAD_0);
 456                         break;
 457
 458                 case JAVA_ISTORE:
 459                 case JAVA_FSTORE:
 460                 case JAVA_ASTORE:
 461                         if (iswide == false) {
 462                                 i = SUCK_BE_U1(m->jcode + p + 1);
 463                         }
 464                         else {
 465                                 i = SUCK_BE_U2(m->jcode + p + 1);
 466                                 iswide = false;
 467                                 nextp = p + 3;
 468                         }
 469                         NEW_OP_STORE_ONEWORD(opcode, i);
 470                         break;
 471
 472                 case JAVA_LSTORE:
 473                 case JAVA_DSTORE:
 474                         if (iswide == false) {
 475                                 i = SUCK_BE_U1(m->jcode + p + 1);
 476                         }
 477                         else {
 478                                 i = SUCK_BE_U2(m->jcode + p + 1);
 479                                 iswide = false;
 480                                 nextp = p + 3;
 481                         }
 482                         NEW_OP_STORE_TWOWORD(opcode, i);
 483                         break;
 484
 485                 case JAVA_ISTORE_0:
 486                 case JAVA_ISTORE_1:
 487                 case JAVA_ISTORE_2:
 488                 case JAVA_ISTORE_3:
 489                         NEW_OP_STORE_ONEWORD(ICMD_ISTORE, opcode - JAVA_ISTORE_0);
 490                         break;
 491
 492                 case JAVA_LSTORE_0:
 493                 case JAVA_LSTORE_1:
 494                 case JAVA_LSTORE_2:
 495                 case JAVA_LSTORE_3:
 496                         NEW_OP_STORE_TWOWORD(ICMD_LSTORE, opcode - JAVA_LSTORE_0);
 497                         break;
 498
 499                 case JAVA_FSTORE_0:
 500                 case JAVA_FSTORE_1:
 501                 case JAVA_FSTORE_2:
 502                 case JAVA_FSTORE_3:
 503                         NEW_OP_STORE_ONEWORD(ICMD_FSTORE, opcode - JAVA_FSTORE_0);
 504                         break;
 505
 506                 case JAVA_DSTORE_0:
 507                 case JAVA_DSTORE_1:
 508                 case JAVA_DSTORE_2:
 509                 case JAVA_DSTORE_3:
 510                         NEW_OP_STORE_TWOWORD(ICMD_DSTORE, opcode - JAVA_DSTORE_0);
 511                         break;
 512
 513                 case JAVA_ASTORE_0:
 514                 case JAVA_ASTORE_1:
 515                 case JAVA_ASTORE_2:
 516                 case JAVA_ASTORE_3:
 517                         NEW_OP_STORE_ONEWORD(ICMD_ASTORE, opcode - JAVA_ASTORE_0);
 518                         break;
 519
 520                 case JAVA_IINC:
 521                         {
 522                                 int v;
 523
 524                                 if (iswide == false) {
 525                                         i = SUCK_BE_U1(m->jcode + p + 1);
 526                                         v = SUCK_BE_S1(m->jcode + p + 2);
 527
 528                                 }
 529                                 else {
 530                                         i = SUCK_BE_U2(m->jcode + p + 1);
 531                                         v = SUCK_BE_S2(m->jcode + p + 3);
 532                                         iswide = false;
 533                                         nextp = p + 5;
 534                                 }
 535                                 INDEX_ONEWORD(i);
 536                                 NEW_OP_LOCALINDEX_I(opcode, i, v);
 537                         }
 538                         break;
 539
 540                 /* wider index for loading, storing and incrementing ******************/
 541
 542                 case JAVA_WIDE:
 543                         iswide = true;
 544                         p++;
 545                         goto fetch_opcode;
 546
 547                 /* managing arrays ****************************************************/
 548
 549                 case JAVA_NEWARRAY:
 550                         switch (SUCK_BE_S1(m->jcode + p + 1)) {
 551                         case 4:
 552                                 bte = builtintable_get_internal(BUILTIN_newarray_boolean);
 553                                 break;
 554                         case 5:
 555                                 bte = builtintable_get_internal(BUILTIN_newarray_char);
 556                                 break;
 557                         case 6:
 558                                 bte = builtintable_get_internal(BUILTIN_newarray_float);
 559                                 break;
 560                         case 7:
 561                                 bte = builtintable_get_internal(BUILTIN_newarray_double);
 562                                 break;
 563                         case 8:
 564                                 bte = builtintable_get_internal(BUILTIN_newarray_byte);
 565                                 break;
 566                         case 9:
 567                                 bte = builtintable_get_internal(BUILTIN_newarray_short);
 568                                 break;
 569                         case 10:
 570                                 bte = builtintable_get_internal(BUILTIN_newarray_int);
 571                                 break;
 572                         case 11:
 573                                 bte = builtintable_get_internal(BUILTIN_newarray_long);
 574                                 break;
 575 #if defined(ENABLE_VERIFIER)
 576                         default:
 577                                 exceptions_throw_verifyerror(m, "Invalid array-type to create");
 578                                 return false;
 579 #endif
 580                         }
 581                         NEW_OP_BUILTIN_CHECK_EXCEPTION(bte);
 582                         break;
 583
 584                 case JAVA_ANEWARRAY:
 585                         i = SUCK_BE_U2(m->jcode + p + 1);
 586                         compr = (constant_classref *) class_getconstant(m->class, i, CONSTANT_Class);
 587                         if (!compr)
 588                                 return false;
 589
 590                         if (!(cr = class_get_classref_multiarray_of(1, compr)))
 591                                 return false;
 592
 593                         if (!resolve_classref(m, cr, resolveLazy, true, true, &c))
 594                                 return false;
 595
 596                         NEW_OP_LOADCONST_CLASSINFO_OR_CLASSREF(c, cr, INS_FLAG_NOCHECK);
 597                         bte = builtintable_get_internal(BUILTIN_newarray);
 598                         NEW_OP_BUILTIN_CHECK_EXCEPTION(bte);
 599                         s_count++;
 600                         break;
 601
 602                 case JAVA_MULTIANEWARRAY:
 603                         jd->isleafmethod = false;
 604                         i = SUCK_BE_U2(m->jcode + p + 1);
 605                         {
 606                                 s4 v = SUCK_BE_U1(m->jcode + p + 3);
 607
 608                                 cr = (constant_classref *) class_getconstant(m->class, i, CONSTANT_Class);
 609                                 if (!cr)
 610                                         return false;
 611
 612                                 if (!resolve_classref(m, cr, resolveLazy, true, true, &c))
 613                                         return false;
 614
 615                                 /* if unresolved, c == NULL */
 616
 617                                 iptr->s1.argcount = v;
 618                                 NEW_OP_S3_CLASSINFO_OR_CLASSREF(opcode, c, cr, 0 /* flags */);
 619                         }
 620                         break;
 621
 622                 /* control flow instructions ******************************************/
 623
 624                 case JAVA_IFEQ:
 625                 case JAVA_IFLT:
 626                 case JAVA_IFLE:
 627                 case JAVA_IFNE:
 628                 case JAVA_IFGT:
 629                 case JAVA_IFGE:
 630                 case JAVA_IFNULL:
 631                 case JAVA_IFNONNULL:
 632                 case JAVA_IF_ICMPEQ:
 633                 case JAVA_IF_ICMPNE:
 634                 case JAVA_IF_ICMPLT:
 635                 case JAVA_IF_ICMPGT:
 636                 case JAVA_IF_ICMPLE:
 637                 case JAVA_IF_ICMPGE:
 638                 case JAVA_IF_ACMPEQ:
 639                 case JAVA_IF_ACMPNE:
 640                 case JAVA_GOTO:
 641                         i = p + SUCK_BE_S2(m->jcode + p + 1);
 642                         CHECK_BYTECODE_INDEX(i);
 643                         NEW_MARK_BASICBLOCK(i);
 644                         blockend = true;
 645                         NEW_OP_INSINDEX(opcode, i);
 646                         break;
 647
 648                 case JAVA_GOTO_W:
 649                         i = p + SUCK_BE_S4(m->jcode + p + 1);
 650                         CHECK_BYTECODE_INDEX(i);
 651                         NEW_MARK_BASICBLOCK(i);
 652                         blockend = true;
 653                         NEW_OP_INSINDEX(opcode, i);
 654                         break;
 655
 656                 case JAVA_JSR:
 657                         i = p + SUCK_BE_S2(m->jcode + p + 1);
 658 jsr_tail:
 659                         CHECK_BYTECODE_INDEX(i);
 660                         NEW_MARK_BASICBLOCK(i);
 661                         blockend = true;
 662                         NEW_OP_PREPARE_ZEROFLAGS(JAVA_JSR);
 663                         iptr->sx.s23.s3.jsrtarget.insindex = i;
 664                         PINC;
 665                         break;
 666
 667                 case JAVA_JSR_W:
 668                         i = p + SUCK_BE_S4(m->jcode + p + 1);
 669                         goto jsr_tail;
 670
 671                 case JAVA_RET:
 672                         if (iswide == false) {
 673                                 i = SUCK_BE_U1(m->jcode + p + 1);
 674                         }
 675                         else {
 676                                 i = SUCK_BE_U2(m->jcode + p + 1);
 677                                 nextp = p + 3;
 678                                 iswide = false;
 679                         }
 680                         blockend = true;
 681
 682                         NEW_OP_LOAD_ONEWORD(opcode, i);
 683                         break;
 684
 685                 case JAVA_IRETURN:
 686                 case JAVA_LRETURN:
 687                 case JAVA_FRETURN:
 688                 case JAVA_DRETURN:
 689                 case JAVA_ARETURN:
 690                 case JAVA_RETURN:
 691                         blockend = true;
 692                         /* XXX ARETURN will need a flag in the typechecker */
 693                         NEW_OP(opcode);
 694                         break;
 695
 696                 case JAVA_ATHROW:
 697                         blockend = true;
 698                         /* XXX ATHROW will need a flag in the typechecker */
 699                         NEW_OP(opcode);
 700                         break;
 701
 702
 703                 /* table jumps ********************************************************/
 704
 705                 case JAVA_LOOKUPSWITCH:
 706                         {
 707                                 s4 num, j;
 708                                 lookup_target_t *lookup;
 709 #if defined(ENABLE_VERIFIER)
 710                                 s4 prevvalue = 0;
 711 #endif
 712                                 blockend = true;
 713                                 nextp = ALIGN((p + 1), 4);
 714
 715                                 CHECK_END_OF_BYTECODE(nextp + 8);
 716
 717                                 NEW_OP_PREPARE_ZEROFLAGS(opcode);
 718
 719                                 /* default target */
 720
 721                                 j = p + SUCK_BE_S4(m->jcode + nextp);
 722                                 iptr->sx.s23.s3.lookupdefault.insindex = j;
 723                                 nextp += 4;
 724                                 CHECK_BYTECODE_INDEX(j);
 725                                 NEW_MARK_BASICBLOCK(j);
 726
 727                                 /* number of pairs */
 728
 729                                 num = SUCK_BE_U4(m->jcode + nextp);
 730                                 iptr->sx.s23.s2.lookupcount = num;
 731                                 nextp += 4;
 732
 733                                 /* allocate the intermediate code table */
 734
 735                                 lookup = DMNEW(lookup_target_t, num);
 736                                 iptr->dst.lookup = lookup;
 737
 738                                 /* iterate over the lookup table */
 739
 740                                 CHECK_END_OF_BYTECODE(nextp + 8 * num);
 741
 742                                 for (i = 0; i < num; i++) {
 743                                         /* value */
 744
 745                                         j = SUCK_BE_S4(m->jcode + nextp);
 746                                         lookup->value = j;
 747
 748                                         nextp += 4;
 749
 750 #if defined(ENABLE_VERIFIER)
 751                                         /* check if the lookup table is sorted correctly */
 752
 753                                         if (i && (j <= prevvalue)) {
 754                                                 exceptions_throw_verifyerror(m, "Unsorted lookup switch");
 755                                                 return false;
 756                                         }
 757                                         prevvalue = j;
 758 #endif
 759                                         /* target */
 760
 761                                         j = p + SUCK_BE_S4(m->jcode + nextp);
 762                                         lookup->target.insindex = j;
 763                                         lookup++;
 764                                         nextp += 4;
 765                                         CHECK_BYTECODE_INDEX(j);
 766                                         NEW_MARK_BASICBLOCK(j);
 767                                 }
 768
 769                                 PINC;
 770                                 break;
 771                         }
 772
 773
 774                 case JAVA_TABLESWITCH:
 775                         {
 776                                 s4 num, j;
 777                                 s4 deftarget;
 778                                 branch_target_t *table;
 779
 780                                 blockend = true;
 781                                 nextp = ALIGN((p + 1), 4);
 782
 783                                 CHECK_END_OF_BYTECODE(nextp + 12);
 784
 785                                 NEW_OP_PREPARE_ZEROFLAGS(opcode);
 786
 787                                 /* default target */
 788
 789                                 deftarget = p + SUCK_BE_S4(m->jcode + nextp);
 790                                 nextp += 4;
 791                                 CHECK_BYTECODE_INDEX(deftarget);
 792                                 NEW_MARK_BASICBLOCK(deftarget);
 793
 794                                 /* lower bound */
 795
 796                                 j = SUCK_BE_S4(m->jcode + nextp);
 797                                 iptr->sx.s23.s2.tablelow = j;
 798                                 nextp += 4;
 799
 800                                 /* upper bound */
 801
 802                                 num = SUCK_BE_S4(m->jcode + nextp);
 803                                 iptr->sx.s23.s3.tablehigh = num;
 804                                 nextp += 4;
 805
 806                                 /* calculate the number of table entries */
 807
 808                                 num = num - j + 1;
 809
 810 #if defined(ENABLE_VERIFIER)
 811                                 if (num < 1) {
 812                                         exceptions_throw_verifyerror(m,
 813                                                         "invalid TABLESWITCH: upper bound < lower bound");
 814                                         return false;
 815                                 }
 816 #endif
 817                                 /* create the intermediate code table */
 818                                 /* the first entry is the default target */
 819
 820                                 table = MNEW(branch_target_t, 1 + num);
 821                                 iptr->dst.table = table;
 822                                 (table++)->insindex = deftarget;
 823
 824                                 /* iterate over the target table */
 825
 826                                 CHECK_END_OF_BYTECODE(nextp + 4 * num);
 827
 828                                 for (i = 0; i < num; i++) {
 829                                         j = p + SUCK_BE_S4(m->jcode + nextp);
 830                                         (table++)->insindex = j;
 831                                         nextp += 4;
 832                                         CHECK_BYTECODE_INDEX(j);
 833                                         NEW_MARK_BASICBLOCK(j);
 834                                 }
 835
 836                                 PINC;
 837                                 break;
 838                         }
 839
 840
 841                 /* load and store of object fields ************************************/
 842
 843                 case JAVA_AASTORE:
 844                         NEW_OP(opcode);
 845                         jd->isleafmethod = false;
 846                         break;
 847
 848                 case JAVA_GETSTATIC:
 849                 case JAVA_PUTSTATIC:
 850                 case JAVA_GETFIELD:
 851                 case JAVA_PUTFIELD:
 852                         {
 853                                 constant_FMIref  *fr;
 854                                 unresolved_field *uf;
 855
 856                                 i = SUCK_BE_U2(m->jcode + p + 1);
 857                                 fr = class_getconstant(m->class, i, CONSTANT_Fieldref);
 858                                 if (!fr)
 859                                         return false;
 860
 861                                 NEW_OP_PREPARE_ZEROFLAGS(opcode);
 862                                 iptr->sx.s23.s3.fmiref = fr;
 863
 864                                 /* only with -noverify, otherwise the typechecker does this */
 865
 866 #if defined(ENABLE_VERIFIER)
 867                                 if (!JITDATA_HAS_FLAG_VERIFY(jd)) {
 868 #endif
 869                                         result = new_resolve_field_lazy(iptr, m);
 870                                         if (result == resolveFailed)
 871                                                 return false;
 872
 873                                         if (result != resolveSucceeded) {
 874                                                 uf = new_create_unresolved_field(m->class, m, iptr);
 875
 876                                                 if (uf == NULL)
 877                                                         return false;
 878
 879                                                 /* store the unresolved_field pointer */
 880
 881                                                 iptr->sx.s23.s3.uf = uf;
 882                                                 iptr->flags.bits = INS_FLAG_UNRESOLVED;
 883                                         }
 884 #if defined(ENABLE_VERIFIER)
 885                                 }
 886 #endif
 887                                 PINC;
 888                         }
 889                         break;
 890
 891
 892                 /* method invocation **************************************************/
 893
 894                 case JAVA_INVOKESTATIC:
 895                         i = SUCK_BE_U2(m->jcode + p + 1);
 896                         mr = class_getconstant(m->class, i, CONSTANT_Methodref);
 897                         if (!mr)
 898                                 return false;
 899
 900                         md = mr->parseddesc.md;
 901
 902                         if (!md->params)
 903                                 if (!descriptor_params_from_paramtypes(md, ACC_STATIC))
 904                                         return false;
 905
 906                         goto invoke_method;
 907
 908                 case JAVA_INVOKEINTERFACE:
 909                         i = SUCK_BE_U2(m->jcode + p + 1);
 910
 911                         mr = class_getconstant(m->class, i,
 912                                         CONSTANT_InterfaceMethodref);
 913
 914                         goto invoke_nonstatic_method;
 915
 916                 case JAVA_INVOKESPECIAL:
 917                 case JAVA_INVOKEVIRTUAL:
 918                         i = SUCK_BE_U2(m->jcode + p + 1);
 919                         mr = class_getconstant(m->class, i, CONSTANT_Methodref);
 920
 921 invoke_nonstatic_method:
 922                         if (!mr)
 923                                 return false;
 924
 925                         md = mr->parseddesc.md;
 926
 927                         if (!md->params)
 928                                 if (!descriptor_params_from_paramtypes(md, 0))
 929                                         return false;
 930
 931 invoke_method:
 932                         jd->isleafmethod = false;
 933
 934                         NEW_OP_PREPARE_ZEROFLAGS(opcode);
 935                         iptr->sx.s23.s3.fmiref = mr;
 936
 937                         /* only with -noverify, otherwise the typechecker does this */
 938
 939 #if defined(ENABLE_VERIFIER)
 940                         if (!JITDATA_HAS_FLAG_VERIFY(jd)) {
 941 #endif
 942                                 result = new_resolve_method_lazy(iptr, m);
 943                                 if (result == resolveFailed)
 944                                         return false;
 945
 946                                 if (result != resolveSucceeded) {
 947                                         um = new_create_unresolved_method(m->class, m, iptr);
 948
 949                                         if (!um)
 950                                                 return false;
 951
 952                                         /* store the unresolved_method pointer */
 953
 954                                         iptr->sx.s23.s3.um = um;
 955                                         iptr->flags.bits = INS_FLAG_UNRESOLVED;
 956                                 }
 957 #if defined(ENABLE_VERIFIER)
 958                         }
 959 #endif
 960                         PINC;
 961                         break;
 962
 963                 /* instructions taking class arguments ********************************/
 964
 965                 case JAVA_NEW:
 966                         i = SUCK_BE_U2(m->jcode + p + 1);
 967                         cr = (constant_classref *) class_getconstant(m->class, i, CONSTANT_Class);
 968                         if (!cr)
 969                                 return false;
 970
 971                         if (!resolve_classref(m, cr, resolveLazy, true, true, &c))
 972                                 return false;
 973
 974                         NEW_OP_LOADCONST_CLASSINFO_OR_CLASSREF(c, cr, INS_FLAG_NOCHECK);
 975                         bte = builtintable_get_internal(BUILTIN_new);
 976                         NEW_OP_BUILTIN_CHECK_EXCEPTION(bte);
 977                         s_count++;
 978                         break;
 979
 980                 case JAVA_CHECKCAST:
 981                         i = SUCK_BE_U2(m->jcode + p + 1);
 982                         cr = (constant_classref *) class_getconstant(m->class, i, CONSTANT_Class);
 983                         if (!cr)
 984                                 return false;
 985
 986                         if (!resolve_classref(m, cr, resolveLazy, true, true, &c))
 987                                 return false;
 988
 989                         if (cr->name->text[0] == '[') {
 990                                 /* array type cast-check */
 991                                 flags = INS_FLAG_ARRAY;
 992                                 jd->isleafmethod = false;
 993                         }
 994                         else {
 995                                 /* object type cast-check */
 996                                 flags = 0;
 997                         }
 998                         NEW_OP_S3_CLASSINFO_OR_CLASSREF(opcode, c, cr, flags);
 999                         break;
1000
1001                 case JAVA_INSTANCEOF:
1002                         i = SUCK_BE_U2(m->jcode + p + 1);
1003                         cr = (constant_classref *) class_getconstant(m->class, i, CONSTANT_Class);
1004                         if (!cr)
1005                                 return false;
1006
1007                         if (!resolve_classref(m, cr, resolveLazy, true, true, &c))
1008                                 return false;
1009
1010                         if (cr->name->text[0] == '[') {
1011                                 /* array type cast-check */
1012                                 NEW_OP_LOADCONST_CLASSINFO_OR_CLASSREF(c, cr, INS_FLAG_NOCHECK);
1013                                 bte = builtintable_get_internal(BUILTIN_arrayinstanceof);
1014                                 NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1015                                 s_count++;
1016                         }
1017                         else {
1018                                 /* object type cast-check */
1019                                 NEW_OP_S3_CLASSINFO_OR_CLASSREF(opcode, c, cr, 0 /* flags*/);
1020                         }
1021                         break;
1022
1023                 /* synchronization instructions ***************************************/
1024
1025                 case JAVA_MONITORENTER:
1026 #if defined(ENABLE_THREADS)
1027                         if (checksync) {
1028                                 /* XXX null check */
1029                                 bte = builtintable_get_internal(LOCK_monitor_enter);
1030                                 NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1031                         }
1032                         else
1033 #endif
1034                         {
1035                                 NEW_OP(ICMD_CHECKNULL_POP);
1036                         }
1037                         break;
1038
1039                 case JAVA_MONITOREXIT:
1040 #if defined(ENABLE_THREADS)
1041                         if (checksync) {
1042                                 /* XXX null check */
1043                                 bte = builtintable_get_internal(LOCK_monitor_exit);
1044                                 NEW_OP_BUILTIN_CHECK_EXCEPTION(bte);
1045                         }
1046                         else
1047 #endif
1048                         {
1049                                 NEW_OP(ICMD_CHECKNULL_POP);
1050                         }
1051                         break;
1052
1053                 /* arithmetic instructions that may become builtin functions **********/
1054
1055                 case JAVA_IDIV:
1056 #if !SUPPORT_DIVISION
1057                         bte = builtintable_get_internal(BUILTIN_idiv);
1058                         NEW_OP_BUILTIN_ARITHMETIC(opcode, bte);
1059 #else
1060                         NEW_OP(opcode);
1061 #endif
1062                         break;
1063
1064                 case JAVA_IREM:
1065 #if !SUPPORT_DIVISION
1066                         bte = builtintable_get_internal(BUILTIN_irem);
1067                         NEW_OP_BUILTIN_ARITHMETIC(opcode, bte);
1068 #else
1069                         NEW_OP(opcode);
1070 #endif
1071                         break;
1072
1073                 case JAVA_LDIV:
1074 #if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV)
1075                         bte = builtintable_get_internal(BUILTIN_ldiv);
1076                         NEW_OP_BUILTIN_ARITHMETIC(opcode, bte);
1077 #else
1078                         NEW_OP(opcode);
1079 #endif
1080                         break;
1081
1082                 case JAVA_LREM:
1083 #if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV)
1084                         bte = builtintable_get_internal(BUILTIN_lrem);
1085                         NEW_OP_BUILTIN_ARITHMETIC(opcode, bte);
1086 #else
1087                         NEW_OP(opcode);
1088 #endif
1089                         break;
1090
1091                 case JAVA_FREM:
1092 #if defined(__I386__)
1093                         NEW_OP(opcode);
1094 #else
1095                         bte = builtintable_get_internal(BUILTIN_frem);
1096                         NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1097 #endif
1098                         break;
1099
1100                 case JAVA_DREM:
1101 #if defined(__I386__)
1102                         NEW_OP(opcode);
1103 #else
1104                         bte = builtintable_get_internal(BUILTIN_drem);
1105                         NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1106 #endif
1107                         break;
1108
1109                 case JAVA_F2I:
1110 #if defined(__ALPHA__)
1111                         if (!opt_noieee) {
1112                                 bte = builtintable_get_internal(BUILTIN_f2i);
1113                                 NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1114                         }
1115                         else
1116 #endif
1117                         {
1118                                 NEW_OP(opcode);
1119                         }
1120                         break;
1121
1122                 case JAVA_F2L:
1123 #if defined(__ALPHA__)
1124                         if (!opt_noieee) {
1125                                 bte = builtintable_get_internal(BUILTIN_f2l);
1126                                 NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1127                         }
1128                         else
1129 #endif
1130                         {
1131                                 NEW_OP(opcode);
1132                         }
1133                         break;
1134
1135                 case JAVA_D2I:
1136 #if defined(__ALPHA__)
1137                         if (!opt_noieee) {
1138                                 bte = builtintable_get_internal(BUILTIN_d2i);
1139                                 NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1140                         }
1141                         else
1142 #endif
1143                         {
1144                                 NEW_OP(opcode);
1145                         }
1146                         break;
1147
1148                 case JAVA_D2L:
1149 #if defined(__ALPHA__)
1150                         if (!opt_noieee) {
1151                                 bte = builtintable_get_internal(BUILTIN_d2l);
1152                                 NEW_OP_BUILTIN_NO_EXCEPTION(bte);
1153                         }
1154                         else
1155 #endif
1156                         {
1157                                 NEW_OP(opcode);
1158                         }
1159                         break;
1160
1161                 /* invalid opcodes ****************************************************/
1162
1163                         /* check for invalid opcodes if the verifier is enabled */
1164 #if defined(ENABLE_VERIFIER)
1165                 case JAVA_BREAKPOINT:
1166                         exceptions_throw_verifyerror(m, "Quick instructions shouldn't appear, yet.");
1167                         return false;
1168
1169                 case 186: /* unused opcode */
1170                 case 203:
1171                 case 204:
1172                 case 205:
1173                 case 206:
1174                 case 207:
1175                 case 208:
1176                 case 209:
1177                 case 210:
1178                 case 211:
1179                 case 212:
1180                 case 213:
1181                 case 214:
1182                 case 215:
1183                 case 216:
1184                 case 217:
1185                 case 218:
1186                 case 219:
1187                 case 220:
1188                 case 221:
1189                 case 222:
1190                 case 223:
1191                 case 224:
1192                 case 225:
1193                 case 226:
1194                 case 227:
1195                 case 228:
1196                 case 229:
1197                 case 230:
1198                 case 231:
1199                 case 232:
1200                 case 233:
1201                 case 234:
1202                 case 235:
1203                 case 236:
1204                 case 237:
1205                 case 238:
1206                 case 239:
1207                 case 240:
1208                 case 241:
1209                 case 242:
1210                 case 243:
1211                 case 244:
1212                 case 245:
1213                 case 246:
1214                 case 247:
1215                 case 248:
1216                 case 249:
1217                 case 250:
1218                 case 251:
1219                 case 252:
1220                 case 253:
1221                 case 254:
1222                 case 255:
1223                         exceptions_throw_verifyerror(m, "Illegal opcode %d at instr %d\n",
1224                                                                                  opcode, ipc);
1225                         return false;
1226                         break;
1227 #endif /* defined(ENABLE_VERIFIER) */
1228
1229                 /* opcodes that don't require translation *****************************/
1230
1231                 default:
1232                         /* straight-forward translation to ICMD */
1233                         NEW_OP(opcode);
1234                         break;
1235
1236                 } /* end switch */
1237
1238                 /* verifier checks ****************************************************/
1239
1240 #if defined(ENABLE_VERIFIER)
1241                 /* If WIDE was used correctly, iswide should have been reset by now. */
1242                 if (iswide) {
1243                         exceptions_throw_verifyerror(m,
1244                                         "Illegal instruction: WIDE before incompatible opcode");
1245                         return false;
1246                 }
1247 #endif /* defined(ENABLE_VERIFIER) */
1248
1249         } /* end for */
1250
1251         /*** END OF LOOP **********************************************************/
1252
1253         /* assert that we did not write more ICMDs than allocated */
1254
1255         assert(ipc == (iptr - jd->new_instructions));
1256         assert(ipc <= m->jcodelength);
1257
1258         /*** verifier checks ******************************************************/
1259
1260 #if defined(ENABLE_VERIFIER)
1261         if (p != m->jcodelength) {
1262                 exceptions_throw_verifyerror(m,
1263                                 "Command-sequence crosses code-boundary");
1264                 return false;
1265         }
1266
1267         if (!blockend) {
1268                 exceptions_throw_verifyerror(m, "Falling off the end of the code");
1269                 return false;
1270         }
1271 #endif /* defined(ENABLE_VERIFIER) */
1272
1273         /*** setup the methodinfo, allocate stack and basic blocks ****************/
1274
1275         /* adjust block count if target 0 is not first intermediate instruction */
1276
1277         if (!jd->new_basicblockindex[0] || (jd->new_basicblockindex[0] > 1))
1278                 b_count++;
1279
1280         /* copy local to method variables */
1281
1282         jd->new_instructioncount = ipc;
1283         jd->new_basicblockcount = b_count;
1284         jd->new_stackcount = s_count + jd->new_basicblockcount * m->maxstack; /* in-stacks */
1285
1286         /* allocate stack table */
1287
1288         jd->new_stack = DMNEW(stackelement, jd->new_stackcount);
1289
1290         /* build basic block list */
1291
1292         bptr = jd->new_basicblocks = DMNEW(basicblock, b_count + 1);    /* one more for end ipc */
1293
1294         /* zero out all basic block structures */
1295
1296         MZERO(bptr, basicblock, b_count + 1);
1297
1298         b_count = 0;
1299         jd->new_c_debug_nr = 0;
1300
1301         /* additional block if target 0 is not first intermediate instruction */
1302
1303         if (!jd->new_basicblockindex[0] || (jd->new_basicblockindex[0] > 1)) {
1304                 BASICBLOCK_INIT(bptr, m);
1305
1306                 bptr->iinstr = /* XXX */ (instruction *) jd->new_instructions;
1307                 /* bptr->icount is set when the next block is allocated */
1308
1309                 bptr++;
1310                 b_count++;
1311                 bptr[-1].next = bptr;
1312         }
1313
1314         /* allocate blocks */
1315
1316         for (p = 0; p < m->jcodelength; p++) {
1317                 if (jd->new_basicblockindex[p] & 1) {
1318                         /* Check if this block starts at the beginning of an          */
1319                         /* instruction.                                               */
1320 #if defined(ENABLE_VERIFIER)
1321                         if (!instructionstart[p]) {
1322                                 exceptions_throw_verifyerror(m,
1323                                                 "Branch into middle of instruction");
1324                                 return false;
1325                         }
1326 #endif
1327
1328                         /* allocate the block */
1329
1330                         BASICBLOCK_INIT(bptr, m);
1331
1332                         bptr->iinstr = /* XXX */ (instruction *) (jd->new_instructions + (jd->new_basicblockindex[p] >> 1));
1333                         if (b_count) {
1334                                 bptr[-1].icount = /*XXX*/ (new_instruction *)bptr->iinstr - (new_instruction*) bptr[-1].iinstr;
1335                         }
1336                         /* bptr->icount is set when the next block is allocated */
1337
1338                         jd->new_basicblockindex[p] = b_count;
1339
1340                         bptr++;
1341                         b_count++;
1342                         bptr[-1].next = bptr;
1343                 }
1344         }
1345
1346         /* set instruction count of last real block */
1347
1348         if (b_count) {
1349                 bptr[-1].icount = (jd->new_instructions + jd->new_instructioncount) - /* XXX */ (new_instruction *) bptr[-1].iinstr;
1350         }
1351
1352         /* allocate additional block at end */
1353
1354         BASICBLOCK_INIT(bptr,m);
1355
1356         /* set basicblock pointers in exception table */
1357
1358         if (cd->exceptiontablelength > 0) {
1359                 cd->exceptiontable[cd->exceptiontablelength - 1].down = NULL;
1360         }
1361
1362         for (i = 0; i < cd->exceptiontablelength; ++i) {
1363                 p = cd->exceptiontable[i].startpc;
1364                 cd->exceptiontable[i].start = jd->new_basicblocks + jd->new_basicblockindex[p];
1365
1366                 p = cd->exceptiontable[i].endpc;
1367                 cd->exceptiontable[i].end = (p == m->jcodelength) ? (jd->new_basicblocks + jd->new_basicblockcount /*+ 1*/) : (jd->new_basicblocks + jd->new_basicblockindex[p]);
1368
1369                 p = cd->exceptiontable[i].handlerpc;
1370                 cd->exceptiontable[i].handler = jd->new_basicblocks + jd->new_basicblockindex[p];
1371         }
1372
1373         /* XXX activate this if you want to try inlining */
1374 #if 0
1375         for (i = 0; i < m->exceptiontablelength; ++i) {
1376                 p = m->exceptiontable[i].startpc;
1377                 m->exceptiontable[i].start = jd->new_basicblocks + jd->new_basicblockindex[p];
1378
1379                 p = m->exceptiontable[i].endpc;
1380                 m->exceptiontable[i].end = (p == m->jcodelength) ? (jd->new_basicblocks + jd->new_basicblockcount /*+ 1*/) : (jd->new_basicblocks + jd->new_basicblockindex[p]);
1381
1382                 p = m->exceptiontable[i].handlerpc;
1383                 m->exceptiontable[i].handler = jd->new_basicblocks + jd->new_basicblockindex[p];
1384         }
1385 #endif
1386
1387         /* everything's ok */
1388
1389         return true;
1390
1391         /*** goto labels for throwing verifier exceptions *************************/
1392
1393 #if defined(ENABLE_VERIFIER)
1394
1395 throw_unexpected_end_of_bytecode:
1396         exceptions_throw_verifyerror(m, "Unexpected end of bytecode");
1397         return false;
1398
1399 throw_invalid_bytecode_index:
1400         exceptions_throw_verifyerror(m, "Illegal target of branch instruction");
1401         return false;
1402
1403 throw_illegal_local_variable_number:
1404         exceptions_throw_verifyerror(m, "Illegal local variable number");
1405         return false;
1406
1407 #endif /* ENABLE_VERIFIER */
1408 }
1409
1410
1411 /*
1412  * These are local overrides for various environment variables in Emacs.
1413  * Please do not remove this and leave it at the end of the file, where
1414  * Emacs will automagically detect them.
1415  * ---------------------------------------------------------------------
1416  * Local variables:
1417  * mode: c
1418  * indent-tabs-mode: t
1419  * c-basic-offset: 4
1420  * tab-width: 4
1421  * End:
1422  * vim:noexpandtab:sw=4:ts=4:
1423  */