MPC.3.5.LINUX/preverifier/inlinejsr.c

   1 /*
   2  * @(#)inlinejsr.c      1.22 02/09/27
   3  *
   4  * Copyright 1995-2001 by Sun Microsystems, Inc.,
   5  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
   6  * All rights reserved.
   7  *
   8  * This software is the confidential and proprietary information
   9  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10  * shall not disclose such Confidential Information and shall use
  11  * it only in accordance with the terms of the license agreement
  12  * you entered into with Sun.
  13  * Use is subject to license terms.
  14  */
  15
  16 /*=========================================================================
  17  * SYSTEM:    Verifier
  18  * SUBSYSTEM: JSR inlining
  19  * FILE:      inlinejsr.c
  20  * OVERVIEW:  Routines for inlining of JSR and RET bytecodes.
  21  *
  22  * AUTHOR:    Frank Yellin, Sun Microsystems, Inc.
  23  *            Edited by Tasneem Sayeed, Sun Microsystems
  24  *=======================================================================*/
  25
  26 /*=========================================================================
  27  * Include files
  28  *=======================================================================*/
  29
  30 #include "check_code.h"
  31
  32 /*=========================================================================
  33  * Globals and extern declarations
  34  *=======================================================================*/
  35
  36 /* Maximum byte code size is 64K. */
  37 #define MAX_CODE_SIZE 65535
  38
  39 typedef struct SubrContext {
  40     int id;                         /* id, for debugging */
  41     int depth;                      /* depth of subroutine */
  42     struct SubrContext *parent;     /* subroutine of caller */
  43     struct CodeRef *caller;         /* jsr that got us there */
  44     struct CodeRef *nextInstruction; /* first instruction following inlining */
  45     int target;
  46
  47     struct SubrContext *next;   /* linked list of all subr contexts */
  48 } SubrContext;
  49
  50
  51 /* global context, keep track of info when a method is rewritten */
  52 typedef struct JsrContext {
  53     context_type *vcontext;     /* The verifier's context */
  54     struct CodeRef *codeRef;    /* big array of codeRef's */
  55     struct CodeRef *codeRefEnd; /* pointer to next codeRef to fill in */
  56     int scontext_id;            /* ID assigned to last SubrContext */
  57     struct SubrContext *allSubrContexts; /* pointer to linked list */
  58     struct CodeRef **mapping;   /* maps inumbers CodeRef's */
  59 } JsrContext;
  60
  61 /* A single instruction in the resulting stream */
  62 typedef struct CodeRef {
  63     long inumber;               /* instruction number in original code */
  64     SubrContext *subroutine;    /* subroutine call that this is part of */
  65     enum { CRF_NORMAL,          /* normal instruction */
  66            CRF_SKIP,            /* skip this instruction */
  67            CRF_JSR_SIMPLE_GOTO, /* jsr to subroutine that doesn't return */
  68            CRF_JSR_TARGETED_GOTO, /* jsr to subroutine that does return */
  69            CRF_RET_SIMPLE_GOTO  /* ret that's not at the end of subroutine */
  70     } flags;
  71     /* My offset in the new code */
  72     int offset;
  73     struct CodeRef *next;       /* next codeRef with same "inumber" */
  74 } CodeRef;
  75
  76
  77 static bool_t matchSubroutine(JsrContext *, instruction_data_type*,
  78                             SubrContext *);
  79 static bool_t subroutineGoto(JsrContext *, SubrContext *, SubrContext *);
  80
  81
  82 static void
  83 rewriteOneSubroutine(JsrContext *context, SubrContext *subroutine);
  84
  85 static void fixupCode(JsrContext*);
  86 static void fixupExceptionHandlers(JsrContext*);
  87 static void fixupLineNumberTable(JsrContext*);
  88 static void fixupVariableTable(JsrContext*);
  89
  90
  91 static void
  92 updateTarget(JsrContext *,
  93              int inumber,
  94              SubrContext* subroutine,
  95              void* target, int offset, int size);
  96
  97
  98 void
  99 rewriteCode(context_type *vcontext, struct methodblock *mb)
 100 {
 101     JsrContext context_buf;
 102     JsrContext *context = &context_buf;
 103
 104 #if MYDEBUG
 105     printf("Starting %s.%s%s\n", cbName(mb->fb.clazz), mb->fb.name, mb->fb.signature);
 106 #endif
 107     /* Initialize the context */
 108     memset(context, 0, sizeof(context));
 109     context->vcontext = vcontext; /* The verifier context */
 110     /* Allow up to MAX_CODE_SIZE instructions.  */
 111     context->codeRef = (CodeRef *)malloc(MAX_CODE_SIZE * sizeof(CodeRef));
 112     context->codeRefEnd = context->codeRef;
 113     /* Id (for debugging) of last subroutine structure created */
 114     context->scontext_id = 0;
 115     /* Keep a list of all subroutines, so that we can easily free() them */
 116     context->allSubrContexts = NULL;
 117     /* Make it easy to go from inumber to all CodeRef's that have that inumber*/
 118     context->mapping = (CodeRef **)calloc(vcontext->instruction_count,
 119                                           sizeof(CodeRef **));
 120
 121     /* Fill in context->codeRef with this routine.  In line all subroutine
 122      * calls, and delete all unreachable code */
 123     rewriteOneSubroutine(context, NULL);
 124
 125     /* Modify mb->code and mb->code_length for the new code */
 126     fixupCode(context);
 127
 128     /* Update the exception table */
 129     if (mb->exception_table_length != 0) {
 130         fixupExceptionHandlers(context);
 131     }
 132
 133     /* Update the line number table */
 134     if (mb->line_number_table_length != 0) {
 135         fixupLineNumberTable(context);
 136     }
 137
 138     /* Update the local variable table */
 139     if (mb->localvar_table_length != 0) {
 140         fixupVariableTable(context);
 141     }
 142
 143     /* Clean up */
 144     free(context->codeRef);
 145     free(context->mapping);
 146
 147     /* Free all the subroutine contexts that we created */
 148     while (context->allSubrContexts != NULL) {
 149         SubrContext *this = context->allSubrContexts;
 150         SubrContext *next = this->next;
 151         free(this);
 152         context->allSubrContexts = next;
 153     }
 154 }
 155
 156 static void
 157 rewriteOneSubroutine(JsrContext *context, SubrContext *subroutine)
 158 {
 159     context_type *vcontext = context->vcontext;
 160     int depth = subroutine ? subroutine->depth : 0;
 161     instruction_data_type *idata = vcontext->instruction_data;
 162     int instruction_count = vcontext->instruction_count;
 163     CodeRef **mapping = context->mapping;
 164
 165     instruction_data_type *this_idata;
 166     int inumber;
 167     int count = 0;
 168     CodeRef *retOpcode = NULL;
 169
 170
 171     for (    inumber = 0, this_idata = idata;
 172              inumber < instruction_count;
 173              inumber++, this_idata++) {
 174         if (    (this_idata->or_flags & FLAG_REACHED)
 175             &&  (this_idata->register_info.mask_count == depth)
 176             &&  ((depth == 0)
 177                      || matchSubroutine(context, this_idata, subroutine))) {
 178
 179             /* We have an instruction that is part of this subroutine */
 180
 181             CodeRef *codeRef = context->codeRefEnd++;
 182 #if MYDEBUG
 183             printf("\t%d:\t%d (%d)\t%s (%d)\n",
 184                    (codeRef - context->codeRef), /* new instruction index */
 185                    inumber, (subroutine ? subroutine->id : 0),
 186                    (this_idata->opcode == 256
 187                          ? "invokeinit" : opnames[this_idata->opcode]),
 188                    this_idata->offset);
 189 #endif
 190             codeRef->inumber = inumber;
 191             codeRef->subroutine = subroutine;
 192             codeRef->flags = CRF_NORMAL;
 193             codeRef->next = mapping[inumber]; /* Add to inumber mapping */
 194             mapping[inumber] = codeRef;
 195
 196             count++;
 197
 198             if (count == 1 && depth > 0) {
 199                 /* This is the first instruction included as part of the
 200                  * subroutine call.  If it's the target of the jsr that got
 201                  * us here, then we can just "ignore" the jsr.
 202                  * Otherwise, we have to convert the 'jsr' into a 'goto'
 203                  */
 204                 CodeRef *caller = subroutine->caller;
 205                 if (inumber != idata[caller->inumber].operand.i) {
 206                     caller->flags = CRF_JSR_TARGETED_GOTO;
 207                 }
 208             }
 209
 210             switch(this_idata->opcode) {
 211                 case opc_jsr: case opc_jsr_w:
 212                     if (this_idata->operand2.i == UNKNOWN_RET_INSTRUCTION) {
 213                         /* We're calling a subroutine that doesn't return.
 214                          * The verifier has already made sure that the
 215                          * subroutine doesn't have a deeper depth.
 216                          * We turn the JSR into a goto */
 217                         codeRef->flags = CRF_JSR_SIMPLE_GOTO;
 218                     } else {
 219                         SubrContext *newSubr = malloc(sizeof(SubrContext));
 220
 221                         /* In rare cases, we'll have to change this in the
 222                          * subroutine code */
 223                         codeRef->flags = CRF_SKIP;
 224
 225                         /* Create a new subroutine, and inline it */
 226                         newSubr->id = ++context->scontext_id;
 227                         newSubr->caller = codeRef;
 228                         newSubr->target = this_idata->operand.i;
 229                         newSubr->depth = depth + 1;
 230                         newSubr->nextInstruction = NULL; /* unknown for now */
 231                         newSubr->parent = subroutine;
 232                         /* Add this to the list of all subroutine contexts */
 233                         newSubr->next = context->allSubrContexts;
 234                         context->allSubrContexts = newSubr;
 235                         /* Generate the code for this subroutine */
 236                         rewriteOneSubroutine(context, newSubr);
 237                     }
 238                     break;
 239
 240                 case opc_ret:
 241                     if (retOpcode != NULL) {
 242                         /* There should only be one per subroutine */
 243                         panic("Multiple return opcodes??");
 244                     } else if (depth == 0) {
 245                         /* We're not in a subroutine */
 246                         panic("Ret at depth = 0");
 247                     }
 248                     retOpcode = codeRef;
 249                     /* Flags are set at the end of the loop, below */
 250                     break;
 251
 252                 case opc_astore:
 253                     /* We discard any astore's that move a return address
 254                      * from the stack to a register.
 255                      */
 256                     if (GET_ITEM_TYPE(this_idata->stack_info.stack->item)
 257                                         == ITEM_ReturnAddress) {
 258                         codeRef->flags = CRF_SKIP;
 259                     }
 260                     break;
 261
 262                 default:
 263                     /* Nothing to do */
 264                     break;
 265             }
 266         }
 267     }
 268     if (depth > 0) {
 269         subroutine->nextInstruction = context->codeRefEnd;
 270         if (retOpcode != NULL) {
 271             /* If the last instruction wasn't a 'ret', then we need to
 272              * convert the 'ret' into a 'goto'.
 273              */
 274             if (context->codeRefEnd == retOpcode + 1) {
 275                 retOpcode->flags = CRF_SKIP;
 276             } else {
 277                 retOpcode->flags = CRF_RET_SIMPLE_GOTO;
 278             }
 279         }
 280     }
 281 }
 282
 283
 284 static void
 285 fixupCode(JsrContext *context)
 286 {
 287     context_type *vcontext = context->vcontext;
 288     instruction_data_type *idata = vcontext->instruction_data;
 289     struct methodblock *mb = vcontext->mb;
 290     unsigned char *oldCode = mb->code;
 291     CodeRef *codeRefEnd = context->codeRefEnd;
 292
 293     unsigned char *newCode;
 294     CodeRef *codeRef;
 295     int pc;
 296     long newCodeLength;
 297
 298     /* Assign offsets to each instruction. */
 299 #if MYDEBUG
 300     printf("Assigning offsets\n");
 301 #endif
 302     for (pc = 0, codeRef = context->codeRef; codeRef < codeRefEnd; codeRef++) {
 303         instruction_data_type *this_idata = &idata[codeRef->inumber];
 304         opcode_type opcode = this_idata->opcode;
 305
 306         codeRef->offset = pc;
 307
 308 #if MYDEBUG
 309         printf("\t%d:\t%d\tpc=%d\t%s (%d) %s\n",
 310                (codeRef - context->codeRef),
 311                (this_idata - vcontext->instruction_data),
 312                pc,
 313                (this_idata->opcode == 256
 314                     ? "invokeinit" : opnames[this_idata->opcode]),
 315                this_idata->offset,
 316                ((codeRef->flags == CRF_SKIP) ? " XX" : "")
 317                );
 318 #endif
 319
 320         /* Now increment the pc, depending on the instruction */
 321         if (codeRef->flags == CRF_SKIP) {
 322             /* do nothing */
 323         } else if (opcode == opc_tableswitch || opcode == opc_lookupswitch) {
 324             /* This mysterious calculation works.
 325              * The first term increments pc and then rounds it up to a
 326              * multiple of 4.   The second term is the size of the word-aligned
 327              * values.
 328              */
 329             pc = ((pc + 1 + 3) & ~3) + ((this_idata->length - 1) & ~3);
 330         } else if (opcode == opc_ret) {
 331             /* We must be turning it into an opc_goto */
 332             pc += 3;
 333         } else {
 334             pc += this_idata->length;
 335         }
 336     }
 337
 338     /* Create a new code object */
 339     newCode = (unsigned char *)malloc(pc);
 340     newCodeLength = pc;
 341
 342 #if MYDEBUG
 343     printf("Creating code of length %d\n", pc);
 344 #endif
 345
 346     for (codeRef = context->codeRef; codeRef < codeRefEnd; codeRef++) {
 347         if (codeRef->flags != CRF_SKIP) {
 348             instruction_data_type *this_idata = &idata[codeRef->inumber];
 349             opcode_type opcode = this_idata->opcode;
 350             int pc = codeRef->offset;
 351             unsigned char *source = &oldCode[this_idata->offset];
 352             unsigned char *target = &newCode[pc];
 353
 354 #if MYDEBUG
 355             printf("\t%d:\t%d\tpc=%d\t%s (%d) \n",
 356                    (codeRef - context->codeRef),
 357                    (this_idata - vcontext->instruction_data),
 358                    pc,
 359                    (this_idata->opcode == 256
 360                          ? "invokeinit" : opnames[this_idata->opcode]),
 361                    this_idata->offset
 362                    );
 363 #endif
 364
 365             switch(opcode) {
 366                 case opc_ifeq: case opc_ifne: case opc_iflt:
 367                 case opc_ifge: case opc_ifgt: case opc_ifle:
 368                 case opc_ifnull: case opc_ifnonnull:
 369                 case opc_if_icmpeq: case opc_if_icmpne: case opc_if_icmplt:
 370                 case opc_if_icmpge: case opc_if_icmpgt: case opc_if_icmple:
 371                 case opc_if_acmpeq: case opc_if_acmpne:
 372                 case opc_goto: case opc_goto_w:
 373                     target[0] = source[0];
 374                     updateTarget(context, this_idata->operand.i,
 375                                  codeRef->subroutine,
 376                                  target + 1, pc, this_idata->length - 1);
 377                     break;
 378
 379                 case opc_jsr: case opc_jsr_w:
 380                     target[0] = opc_goto;
 381                     if (codeRef->flags == CRF_JSR_SIMPLE_GOTO) {
 382                         updateTarget(context, this_idata->operand.i,
 383                                      codeRef->subroutine,
 384                                      target + 1, pc, this_idata->length - 1);
 385                     } else if (codeRef->flags == CRF_JSR_TARGETED_GOTO) {
 386                         updateTarget(context, this_idata->operand.i,
 387                                      codeRef[1].subroutine,
 388                                      target + 1, pc, this_idata->length - 1);
 389                     } else {
 390                         panic("Shouldn't have anything referring to jsr");
 391                     }
 392                     break;
 393
 394                 case opc_ret:
 395                     if (codeRef->flags & CRF_RET_SIMPLE_GOTO) {
 396                         int gotoTarget =
 397                             codeRef->subroutine->nextInstruction->offset;
 398                         target[0] = opc_goto;
 399                         target[1] = (gotoTarget - pc) >> 8;
 400                         target[2] = (gotoTarget - pc);
 401                     } else {
 402                         panic("Shouldn't have anything referring to ret");
 403                     }
 404                     break;
 405
 406                 default:
 407                     memcpy(target, source, this_idata->length);
 408                     break;
 409
 410
 411                 case opc_tableswitch:
 412                 case opc_lookupswitch: {
 413                     int *successors = this_idata->operand.ip;
 414                     int keys = successors[0] - 1; /* don't include default */
 415                     SubrContext *subroutine = codeRef->subroutine;
 416                     int i;
 417
 418                     long *targetPtr, *sourcePtr;
 419                     target[0] = source[0];
 420                     target[1] = target[2] = target[3] = 0; /* clear alignment */
 421
 422                     targetPtr = (long *)UCALIGN(target + 1);
 423                     sourcePtr = (long *)UCALIGN(source + 1);
 424
 425                     /* Update the default target */
 426                     updateTarget(context, successors[1], subroutine,
 427                                  targetPtr, pc, 4);
 428                     if (opcode == opc_tableswitch) {
 429                         targetPtr[1] = sourcePtr[1]; /* low */
 430                         targetPtr[2] = sourcePtr[2]; /* high */
 431                         for (i = 0; i < keys; i++) {
 432                             updateTarget(context, successors[2 + i], subroutine,
 433                                          &targetPtr[3 + i], pc, 4);
 434                         }
 435                     } else {
 436                         targetPtr[1] = sourcePtr[1]; /* pairs */
 437                         for (i = 0; i < keys; i++) {
 438                             targetPtr[2 + (i << 1)] = sourcePtr[2 + (i << 1)];
 439                             updateTarget(context, successors[2 + i], subroutine,
 440                                          &targetPtr[3 + (i << 1)], pc, 4);
 441                         }
 442                     }
 443                     break;
 444
 445                 }
 446             }
 447         }
 448     }
 449     mb->code = newCode;
 450     mb->code_length = newCodeLength;
 451 }
 452
 453 static void fixupExceptionHandlers(JsrContext *context) {
 454     const int catchFrameSize = sizeof(struct CatchFrame);
 455     context_type *vcontext = context->vcontext;
 456     struct methodblock *mb = vcontext->mb;
 457
 458     short *code_data = vcontext->code_data; /* maps offset to inumber */
 459
 460     CodeRef *codeRefEnd = context->codeRefEnd;
 461
 462     /* Structure to hold new catch frames */
 463     struct CatchFrame *catchFrames = malloc(catchFrameSize * MAX_CODE_SIZE);
 464     struct CatchFrame *currentCatchFrame = catchFrames;
 465
 466     CodeRef *hRef, *instRef;
 467     unsigned long i;
 468
 469     /* Look at each exception handler */
 470     for (i = 0; i < mb->exception_table_length; i++) {
 471         struct CatchFrame *this_handler = &mb->exception_table[i];
 472         int start_inumber   = code_data[this_handler->start_pc];
 473         int end_inumber     = code_data[this_handler->end_pc];
 474         int handler_inumber = code_data[this_handler->handler_pc];
 475
 476         /* First instruction that maps to the specified handler */
 477         for (hRef = context->mapping[handler_inumber]
 478                    ; hRef != NULL; hRef = hRef->next) {
 479             /* Find all instructions that go to this handler. */
 480             bool_t wasMatch = FALSE;
 481             for (instRef = context->codeRef; instRef < codeRefEnd; instRef++) {
 482                 if (instRef->flags != CRF_SKIP) {
 483                     bool_t thisMatch = instRef->inumber >= start_inumber
 484                                     && instRef->inumber < end_inumber
 485                                     && subroutineGoto(context,
 486                                                       instRef->subroutine,
 487                                                       hRef->subroutine);
 488                     if (thisMatch && !wasMatch) {
 489                         /* Start a new catch frame */
 490                         memcpy(currentCatchFrame, this_handler, catchFrameSize);
 491                         currentCatchFrame->handler_pc = hRef->offset;
 492                         currentCatchFrame->start_pc = instRef->offset;
 493                         wasMatch = TRUE;
 494                     } else if (wasMatch && !thisMatch) {
 495                         currentCatchFrame->end_pc = instRef->offset;
 496                         currentCatchFrame++;
 497                         wasMatch = FALSE;
 498                     }
 499                 }
 500             }
 501             if (wasMatch) {
 502                 /* We end the code still in the catch frame */
 503                 currentCatchFrame->end_pc = mb->code_length;
 504                 currentCatchFrame++;
 505             }
 506         }
 507     }
 508     /* free(mb->exception_table); */
 509     mb->exception_table_length = currentCatchFrame - catchFrames;
 510     mb->exception_table = realloc(catchFrames,
 511                              (char *)currentCatchFrame - (char *)catchFrames);
 512
 513 }
 514
 515 static void fixupLineNumberTable(JsrContext *context) {
 516     context_type *vcontext = context->vcontext;
 517     struct methodblock *mb = vcontext->mb;
 518     int tableLength = mb->line_number_table_length;
 519
 520     instruction_data_type *idata = vcontext->instruction_data;
 521     instruction_data_type *last_idata = &idata[vcontext->instruction_count - 1];
 522     int oldCodeLength = last_idata->offset + last_idata->length;
 523     struct lineno *lineTable = malloc(sizeof(struct lineno) * MAX_CODE_SIZE);
 524     struct lineno *currentLineTableEntry = lineTable;
 525     unsigned long *mapTable = calloc(sizeof(short *), oldCodeLength);
 526     CodeRef *codeRefEnd = context->codeRefEnd;
 527     CodeRef *codeRef;
 528     int i, currentLineNumber;
 529
 530     {
 531         unsigned long startPC, endPC, line, pc;
 532
 533         for (i = 0; i < tableLength - 1; i++) {
 534             startPC = mb->line_number_table[i].pc;
 535             endPC   = mb->line_number_table[i + 1].pc;
 536             line    = mb->line_number_table[i].line_number;
 537             for (pc = startPC; pc < endPC; pc++) {
 538                 mapTable[pc] = line;
 539             }
 540         }
 541         startPC = mb->line_number_table[tableLength - 1].pc;
 542         endPC = oldCodeLength;
 543         line = mb->line_number_table[tableLength - 1].line_number;
 544         for (pc = startPC; pc < endPC; pc++) {
 545             mapTable[pc] = line;
 546         }
 547     }
 548
 549     currentLineNumber = -1;
 550     for (codeRef = context->codeRef; codeRef < codeRefEnd; codeRef++) {
 551         if (codeRef->flags != CRF_SKIP) {
 552             instruction_data_type *this_idata = &idata[codeRef->inumber];
 553             int thisLineNumber = mapTable[this_idata->offset];
 554             if (thisLineNumber != currentLineNumber) {
 555                 currentLineTableEntry->line_number = thisLineNumber;
 556                 currentLineTableEntry->pc = codeRef->offset;
 557                 currentLineTableEntry++;
 558                 currentLineNumber = thisLineNumber;
 559             }
 560         }
 561     }
 562
 563     free(mapTable);
 564     mb->line_number_table = realloc(lineTable,
 565                                     (char *)currentLineTableEntry -
 566                                     (char *)lineTable);
 567     mb->line_number_table_length = currentLineTableEntry - lineTable;
 568 }
 569
 570
 571 static void fixupVariableTable(JsrContext *context) {
 572     context_type *vcontext = context->vcontext;
 573     struct methodblock *mb = context->vcontext->mb;
 574     instruction_data_type *idata = vcontext->instruction_data;
 575     CodeRef *codeRefEnd = context->codeRefEnd;
 576     CodeRef *codeRef;
 577     unsigned long i;
 578
 579     struct localvar *localVars =
 580         malloc(sizeof(struct localvar) * MAX_CODE_SIZE);
 581     struct localvar *currentLocalVar = localVars;
 582
 583     for (i = 0; i < mb->localvar_table_length; i++) {
 584         struct localvar *oldEntry = &mb->localvar_table[i];
 585         int startPC = oldEntry->pc0;
 586         int endPC = startPC + oldEntry->length; /* inclusive! */
 587
 588         bool_t was_matching = FALSE;
 589
 590         for (codeRef = context->codeRef; codeRef < codeRefEnd; codeRef++) {
 591             if (codeRef->flags != CRF_SKIP) {
 592                 instruction_data_type *this_idata = &idata[codeRef->inumber];
 593                 bool_t is_matching = this_idata->offset >= startPC
 594                                   && this_idata->offset <= endPC;
 595                 if (!was_matching && is_matching) {
 596                     memcpy(currentLocalVar, oldEntry, sizeof(struct localvar));
 597                     currentLocalVar->pc0 = codeRef->offset;
 598                     was_matching = TRUE;
 599                 } else if (was_matching && !is_matching) {
 600                     currentLocalVar->length =
 601                         codeRef[-1].offset - currentLocalVar->pc0;
 602                     currentLocalVar++;
 603                     was_matching = FALSE;
 604                 }
 605             }
 606         }
 607         if (was_matching) {
 608             currentLocalVar->length =
 609                 codeRefEnd[-1].offset - currentLocalVar->pc0;
 610             currentLocalVar++;
 611         }
 612     }
 613
 614     /* free(mb->localvar_table); */
 615     mb->localvar_table_length = currentLocalVar - localVars;
 616     mb->localvar_table = realloc(localVars,
 617                                  (char *)currentLocalVar - (char *)localVars);
 618 }
 619
 620
 621 static void
 622 updateTarget(JsrContext *context, int inumber,
 623              SubrContext* subroutine, void* target, int offset, int size)
 624 {
 625     CodeRef *codeRef;
 626     for (codeRef = context->mapping[inumber];
 627              codeRef != NULL;
 628              codeRef = codeRef->next) {
 629         if (subroutineGoto(context, subroutine, codeRef->subroutine)) {
 630             int value = codeRef->offset - offset;
 631             unsigned char *t = target;
 632             if (size == 2) {
 633                 t[0] = value >> 8;
 634                 t[1] = value;
 635             } else if (size == 4) {
 636                 t[0] = value >> 24;
 637                 t[1] = value >> 16;
 638                 t[2] = value >> 8;
 639                 t[3] = value;
 640             } else {
 641                 panic("Bad value passed for size");
 642             }
 643             return;
 644         }
 645     }
 646     panic("Cannot find value for updateTarget");
 647 }
 648
 649
 650
 651 static bool_t
 652 subroutineGoto(JsrContext *context, SubrContext *from, SubrContext *to)
 653 {
 654     if (to == NULL || to == from) {
 655         return TRUE;
 656     } else if (from == NULL || to->depth >= from->depth) {
 657         return FALSE;
 658     } else {
 659         do { from = from->parent; } while (from->depth > to->depth);
 660         return from == to;
 661     }
 662 }
 663
 664
 665 static bool_t
 666 matchSubroutine(JsrContext *context,
 667                 instruction_data_type *this_idata,
 668                 SubrContext *subroutine)
 669 {
 670     int depth = subroutine->depth;
 671     int i;
 672
 673     for (i = depth - 1; i >= 0; --i) {
 674         if (this_idata->register_info.masks[i].entry != subroutine->target) {
 675             return FALSE;
 676         }
 677         subroutine = subroutine->parent;
 678     }
 679     return TRUE;
 680 }
 681