VM_Class           declaringClass;
  public void buildReferenceMaps(VM_NormalMethod method,                                  int[] stackHeights,                                 VM_ReferenceMaps referenceMaps,                                  VM_BuildBB buildBB) {    //****************************************************************//    //                                                                //    // These were calculated by VM_BuildBB.determineTheBasicBlocks    //    //                                                                //    //****************************************************************//    int             gcPointCount     = buildBB.gcPointCount;    short           byteToBlockMap[] = buildBB.byteToBlockMap;    VM_BasicBlock   basicBlocks[]    = buildBB.basicBlocks;    int             jsrCount         = buildBB.numJsrs;    byte    bbMaps[][];            // The starting map for each block, a block is not                                   // processed until it has a starting map.    int[]   blockStkTop;           // For each block, track where its current stack top is.    int     currBBNum;             // Block number of block currently being processed    byte    currBBMap[];           // The current map, used during processing thru a block    int     currBBStkTop;          // Stack top for the current map    int     currBBStkEmpty;        // Level when stack is empty - value depends on number of locals    int     paramCount;            // Number of parameters to the method being processed       // Variables for processing JSR instructions, RET instructions and JSR subroutines    VM_PendingRETInfo        bbPendingRETs[] = null;    VM_PendingRETInfo        currPendingRET;    VM_JSRSubroutineInfo     JSRSubs[] = null;    // Blocks that need to be processed are put on the workStk    short                    workStk[];    // Track whether a block has already been seen once. Any recording of maps done     // within such a block will be processed as a "rerecording" instead of a new map.    //    boolean                 blockSeen[];    // blocks that represent "catch" blocks need special processing. Catch blocks     // also referred to as handlers     //    VM_ExceptionHandlerMap  exceptions;                // exception table class for method being processed    int                     tryStartPC[];              // array of try start indicesinto byte code table    int                     tryEndPC[];                // array of try end indices into byte code table    int                     tryHandlerPC[];            // array of try handlers start indices into bytecode    int                     tryHandlerLength;          // length of try handlers array    int                     reachableHandlerBBNums[];  // array of reachable handlers from a given try block    int                     reachableHandlersCount;    // Number of reachable handlers     boolean                 handlerProcessed[];        // Handler blocks are processed after the normal flow. As                                                       // they may be nested, they need to be handled                                                        // individually. This array is used to track which                                                        // have been processed.    boolean                 handlersAllDone;    // Other local variables    //    VM_BytecodeStream  bcodes;                // byte codes for the method    short              brBBNum;               // For processing branches, need block number of target    VM_Class           declaringClass;        // The declaring class of the method     // Note that the mapping done here is "double mapping" of parameters.    // Double mapping is when the parameters for a method are included in the map of     // the method as well as in the map of the caller of the method. The original     // intent was that with double mapping call sites that are tricks     // (eg VM_Magic.callFunctionReturnVoid ) would at least be correctly mapped on one    // of the two sides. However with more recent changes to the runtime stack frame    // layout, the parameters specified on the caller side occupy different     // locations than the parameters on the callee side for the baseline compiler.     // Thus both need to be described.    //    //  Initialization    //    // Determine what stack empty looks like    paramCount = method.getParameterWords();    if (!method.isStatic()) paramCount++;    currBBStkEmpty = method.getLocalWords()-1;   // -1 to locate the last "local" index    if (debug) VM.sysWrite("getLocalWords() : " + method.getLocalWords() + "\n");    // Get information from the method being processed    bcodes = method.getBytecodes();    declaringClass = method.getDeclaringClass();    // Set up the array of maps per block; block 0 is not used    int numBB = buildBB.bbf.getNumberofBlocks();    bbMaps   = new byte[numBB + 1][];    blockStkTop = new int[bbMaps.length];    blockSeen   = new boolean[bbMaps.length];    // Try Handler processing initialization    exceptions       = method.getExceptionHandlerMap();    if (exceptions != null) {      tryStartPC       = exceptions.getStartPC();      tryEndPC         = exceptions.getEndPC();      tryHandlerPC     = exceptions.getHandlerPC();      tryHandlerLength = tryHandlerPC.length;      reachableHandlerBBNums = new int[tryStartPC.length];      handlerProcessed       = new boolean[tryStartPC.length];      if (jsrCount > 0) {        JSRSubs       = new VM_JSRSubroutineInfo[jsrCount];        JSRSubNext    = 0;        bbPendingRETs = new VM_PendingRETInfo[bbMaps.length];      }      handlersAllDone = (tryHandlerLength == 0);      // write poison values to help distinguish different errors      for(int ii = 0; ii < reachableHandlerBBNums.length; ii++)        reachableHandlerBBNums[ii] = -1;    } else {      tryHandlerLength       = 0;      handlersAllDone        = true;      tryStartPC             = null;       tryEndPC               = null;      tryHandlerPC           = null;      reachableHandlerBBNums = null;      handlerProcessed       = null;    }    reachableHandlersCount = 0;    // Start a new set of maps with the reference Map class.    // 3rd argument is parameter count included with the maps    referenceMaps.startNewMaps(gcPointCount, jsrCount, paramCount);        // Set up the Work stack    workStk = new short[10+tryHandlerLength];    // Start by putting the first block on the work stack    workStkTop = 0;    workStk[workStkTop] = byteToBlockMap[0];    currBBMap = new byte[method.getOperandWords() + currBBStkEmpty+1];        //    // Need to include the parameters of this method in the map     //    VM_TypeReference[] parameterTypes = method.getParameterTypes();    int paramStart;    if (!method.isStatic()) {      currBBMap[0] = REFERENCE; // implicit "this" object      paramStart = 1;    } else {      paramStart = 0;    }    for (int i=0; i<parameterTypes.length; i++, paramStart++) {      VM_TypeReference parameterType = parameterTypes[i];      currBBMap[paramStart] = parameterType.isReferenceType() ? REFERENCE : NON_REFERENCE;      if (parameterType.getStackWords() == DOUBLEWORD)        paramStart++;    }    // The map for the start of the first block, is stack empty, with none    // of the locals set yet    //    currBBStkTop                   = currBBStkEmpty;    bbMaps[byteToBlockMap[0]]      = currBBMap;    blockStkTop[byteToBlockMap[0]] = currBBStkTop;    // For all methods, record a map at the start of the method for the corresponding    // conditional call to "yield".     referenceMaps.recordStkMap(0, currBBMap, currBBStkTop, false);        currBBMap = new byte[currBBMap.length];    //----------------------------------------------------------    //    //  Keep looping until the Work Stack is empty    //    //----------------------------------------------------------    while (workStkTop > -1) {      // Get the next item off the work stack      currBBNum = workStk[workStkTop];      workStkTop--;          boolean inJSRSub = false;      if (bbMaps[currBBNum] != null) {        currBBStkTop = blockStkTop[currBBNum];        for (int k = 0; k <= currBBStkTop; k++)           currBBMap[k] = bbMaps[currBBNum][k];        if (jsrCount > 0 && basicBlocks[currBBNum].isInJSR()) {          inJSRSub = true;        }      } else {              VM.sysWrite("VM_BuildReferenceMaps, error: found a block on work stack with");        VM.sysWrite(" no starting map. The block number is ");        VM.sysWrite(basicBlocks[currBBNum].blockNumber);        VM.sysWrite("\n");        VM.sysFail("VM_BuildReferenceMaps work stack failure");      }      int start = basicBlocks[currBBNum].getStart();      int end = basicBlocks[currBBNum].getEnd();      if (jsrCount > 0 && inJSRSub ) {        currPendingRET = bbPendingRETs[currBBNum];        if (basicBlocks[currBBNum].isTryStart()) {          for (int k = 0; k < tryHandlerLength; k++) {            if (tryStartPC[k] == start) {              int handlerBBNum = byteToBlockMap[tryHandlerPC[k]];              bbPendingRETs[handlerBBNum] = new VM_PendingRETInfo(currPendingRET);            }          }        }      } else {        currPendingRET = null;      }      boolean inTryBlock;      if (basicBlocks[currBBNum].isTryBlock()) {        inTryBlock = true;        reachableHandlersCount = 0;        for (int i=0; i<tryHandlerLength; i++)          if (start <= tryEndPC[i] && end >= tryStartPC[i]) {            reachableHandlerBBNums[reachableHandlersCount] =               byteToBlockMap[tryHandlerPC[i]];            reachableHandlersCount++;            int handlerBBNum = byteToBlockMap[tryHandlerPC[i]];            if (bbMaps[handlerBBNum] == null) {              bbMaps[handlerBBNum] = new byte[currBBMap.length];              for (int k=0; k<=currBBStkEmpty; k++)                bbMaps[handlerBBNum][k] = currBBMap[k];              bbMaps[handlerBBNum][currBBStkEmpty+1] = REFERENCE;              blockStkTop[handlerBBNum] = currBBStkEmpty+1;            }          }      } else {        inTryBlock = false;      }      boolean processNextBlock = true;      bcodes.reset(start);      while(bcodes.index() <= end) {        int biStart = bcodes.index();        int opcode = bcodes.nextInstruction();        if (stackHeights != null) {          stackHeights[biStart] = currBBStkTop;        }        if (debug) {          VM.sysWrite("opcode : " + opcode + "\n");          VM.sysWrite("current map: ");          for (int j=0; j<=currBBStkTop; j++) {            VM.sysWrite(currBBMap[j]);          }          VM.sysWrite("\n");        }        switch (opcode) {        case JBC_nop: {          break;        }        case JBC_aconst_null: {          currBBStkTop++;          currBBMap[currBBStkTop] = REFERENCE;          break;        }        case JBC_aload_0: {          int localNumber = 0;          currBBStkTop++;          currBBMap[currBBStkTop] = currBBMap[localNumber];          break;        }        case JBC_aload_1: {          int localNumber = 1;          currBBStkTop++;          currBBMap[currBBStkTop] = currBBMap[localNumber];          break;        }        case JBC_aload_2: {          int localNumber = 2;          currBBStkTop++;          currBBMap[currBBStkTop] = currBBMap[localNumber];          break;        }        case JBC_aload_3: {          int localNumber = 3;          currBBStkTop++;          currBBMap[currBBStkTop] = currBBMap[localNumber];          break;        }        case JBC_aload: {          int localNumber = bcodes.getLocalNumber();          currBBStkTop++;          currBBMap[currBBStkTop] = currBBMap[localNumber];          break;        }        case JBC_iconst_m1:        case JBC_iconst_0:        case JBC_iconst_1:        case JBC_iconst_2:        case JBC_iconst_3:        case JBC_iconst_4:        case JBC_iconst_5:        case JBC_fconst_0:        case JBC_fconst_1:        case JBC_fconst_2:        case JBC_iload_0:        case JBC_iload_1:        case JBC_iload_2:        case JBC_iload_3:        case JBC_fload_0:        case JBC_fload_1:        case JBC_fload_2:        case JBC_fload_3:        case JBC_bipush:        case JBC_iload:        case JBC_fload:        case JBC_sipush:        case JBC_i2l:        case JBC_i2d:        case JBC_f2l:        case JBC_f2d: {          currBBStkTop++;          currBBMap[currBBStkTop] = NON_REFERENCE;          bcodes.skipInstruction(); // contains mix of 1,2,3 byte bytecodes          break;        }        case JBC_lconst_0:        case JBC_lconst_1:        case JBC_dconst_0:        case JBC_dconst_1:        case JBC_lload_0:        case JBC_lload_1:        case JBC_lload_2:        case JBC_lload_3:        case JBC_dload_0:        case JBC_dload_1:        case JBC_dload_2:        case JBC_dload_3:        case JBC_ldc2_w:        case JBC_lload:        case JBC_dload: {          currBBStkTop++;          currBBMap[currBBStkTop] = NON_REFERENCE;          currBBStkTop++;          currBBMap[currBBStkTop] = NON_REFERENCE;          bcodes.skipInstruction(); // mix of 1, 2, and 3 byte bytecodes          break;        }        case JBC_ldc: {          currBBStkTop++;          int cpi = bcodes.getConstantIndex();          int type = bcodes.getConstantType(cpi);          if (type == VM_Class.CP_STRING || type == VM_Class.CP_CLASS)            currBBMap[currBBStkTop] = REFERENCE;          else            currBBMap[currBBStkTop] = NON_REFERENCE;          break;        }        case JBC_ldc_w: {          currBBStkTop++;          int cpi = bcodes.getWideConstantIndex();          int type = bcodes.getConstantType(cpi);          if (type == VM_Class.CP_STRING || type == VM_Class.CP_CLASS)            currBBMap[currBBStkTop] = REFERENCE;          else            currBBMap[currBBStkTop] = NON_REFERENCE;          break;        }        case JBC_istore:        case JBC_fstore: {          int index = bcodes.getLocalNumber();          if (!inJSRSub)             currBBMap[index] = NON_REFERENCE;          else            currBBMap[index] = SET_TO_NONREFERENCE;          if (inTryBlock)             setHandlersMapsNonRef(index,ONEWORD,reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop--;          break;        }        case JBC_lstore:        case JBC_dstore: {          int index = bcodes.getLocalNumber();          if (!inJSRSub) {            currBBMap[index]   = NON_REFERENCE;            currBBMap[index+1] = NON_REFERENCE;          } else {            currBBMap[index]   = SET_TO_NONREFERENCE;            currBBMap[index+1] = SET_TO_NONREFERENCE;          }          if (inTryBlock)             setHandlersMapsNonRef(index, DOUBLEWORD, reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop = currBBStkTop - 2;          break;        }        case JBC_astore: {          int index = bcodes.getLocalNumber();          currBBMap[index] = currBBMap[currBBStkTop];// may be a reference or a return address          if (inJSRSub) {            if (currBBMap[index] == RETURN_ADDRESS)               currPendingRET.updateReturnAddressLocation(index);            if (inTryBlock) {              if (currBBMap[index] == REFERENCE)                setHandlersMapsRef(index, reachableHandlerBBNums,                                    reachableHandlersCount, bbMaps);              else                setHandlersMapsReturnAddress(index, reachableHandlerBBNums,                                              reachableHandlersCount, bbMaps);            }          }          currBBStkTop--;          break;        }        case JBC_istore_0:        case JBC_fstore_0: {          if (!inJSRSub)            currBBMap[0] = NON_REFERENCE;          else             currBBMap[0] = SET_TO_NONREFERENCE;          if (inTryBlock)             setHandlersMapsNonRef(0,ONEWORD,reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop--;          break;        }        case JBC_istore_1:        case JBC_fstore_1: {          if (!inJSRSub)            currBBMap[1] = NON_REFERENCE;          else             currBBMap[1] = SET_TO_NONREFERENCE;          if (inTryBlock)             setHandlersMapsNonRef(1,ONEWORD,reachableHandlerBBNums,                                   reachableHandlersCount,inJSRSub, bbMaps);          currBBStkTop--;          break;        }        case JBC_istore_2:        case JBC_fstore_2: {          if (!inJSRSub)            currBBMap[2] = NON_REFERENCE;          else            currBBMap[2] = SET_TO_NONREFERENCE;          if (inTryBlock)             setHandlersMapsNonRef(2,ONEWORD,reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop--;          break;        }        case JBC_istore_3:        case JBC_fstore_3: {          if (!inJSRSub)            currBBMap[3] = NON_REFERENCE;          else            currBBMap[3] = SET_TO_NONREFERENCE;          if (inTryBlock)             setHandlersMapsNonRef(3,ONEWORD,reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop--;          break;        }        case JBC_lstore_0:        case JBC_dstore_0: {          if (inJSRSub) {            currBBMap[0] = NON_REFERENCE;            currBBMap[1] = NON_REFERENCE;          } else {            currBBMap[0] = SET_TO_NONREFERENCE;            currBBMap[1] = SET_TO_NONREFERENCE;          }          if (inTryBlock)             setHandlersMapsNonRef(0,DOUBLEWORD,reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop = currBBStkTop - 2;          break;        }        case JBC_lstore_1:        case JBC_dstore_1: {          if (!inJSRSub) {            currBBMap[1]=NON_REFERENCE;            currBBMap[2]=NON_REFERENCE;          } else {            currBBMap[1]=SET_TO_NONREFERENCE;            currBBMap[2]=SET_TO_NONREFERENCE;          }          if (inTryBlock)             setHandlersMapsNonRef(1, DOUBLEWORD, reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop = currBBStkTop - 2;          break;        }        case JBC_lstore_2:        case JBC_dstore_2: {          if (!inJSRSub) {            currBBMap[2]=NON_REFERENCE;            currBBMap[3]=NON_REFERENCE;          } else {            currBBMap[2]=SET_TO_NONREFERENCE;            currBBMap[3]=SET_TO_NONREFERENCE;          }          if (inTryBlock)             setHandlersMapsNonRef(2,DOUBLEWORD,reachableHandlerBBNums,                                   reachableHandlersCount, inJSRSub, bbMaps);          currBBStkTop = currBBStkTop - 2;          break;        }        case JBC_lstore_3:        case JBC_dstore_3: {          if (!inJSRSub) {            currBBMap[3]=NON_REFERENCE;            currBBMap[4]=NON_REFERENCE;          } else {            currBBMap[3]=SET_TO_NONREFERENCE;            currBBMap[4]=SET_TO_NONREFERENCE;          }          if (inTryBlock)             setHandlersMapsNonRef(3, DOUBLEWORD, reachableHandlerBBNums,                                  reachableHandlersCount,inJSRSub, bbMaps);          currBBStkTop = currBBStkTop - 2;          break;        }        case JBC_astore_0: {          currBBMap[0]=currBBMap[currBBStkTop];          if (inJSRSub) {            if (currBBMap[0] == RETURN_ADDRESS)              currPendingRET.updateReturnAddressLocation(0);            if (inTryBlock) {              if (currBBMap[0] == REFERENCE)                setHandlersMapsRef(0, reachableHandlerBBNums, reachableHandlersCount,                                    bbMaps);              else                setHandlersMapsReturnAddress(0, reachableHandlerBBNums,                                              reachableHandlersCount, bbMaps);            }          }          currBBStkTop--;          break;        }        case JBC_astore_1: {          currBBMap[1]=currBBMap[currBBStkTop];          if (inJSRSub) {            if (currBBMap[1] == RETURN_ADDRESS)              currPendingRET.updateReturnAddressLocation(1);            if (inTryBlock) {              if (currBBMap[1] == REFERENCE)                setHandlersMapsRef(1, reachableHandlerBBNums, reachableHandlersCount,                                    bbMaps);              else                setHandlersMapsReturnAddress(1, reachableHandlerBBNums,                                              reachableHandlersCount, bbMaps);            }          }          currBBStkTop--;          break;        }        case JBC_astore_2: {          currBBMap[2]=currBBMap[currBBStkTop];          if (inJSRSub) {            if (currBBMap[2] == RETURN_ADDRESS)              currPendingRET.updateReturnAddressLocation(2);            if (inTryBlock) {              if (currBBMap[2] == REFERENCE)                setHandlersMapsRef(2, reachableHandlerBBNums, reachableHandlersCount,                                    bbMaps);              else                setHandlersMapsReturnAddress(2, reachableHandlerBBNums,                                              reachableHandlersCount, bbMaps);            }          }          currBBStkTop--;          break;        }        case JBC_astore_3: {          currBBMap[3]=currBBMap[currBBStkTop];          if (inJSRSub) {            if (currBBMap[3] == RETURN_ADDRESS)              currPendingRET.updateReturnAddressLocation(3);            if (inTryBlock) {              if (currBBMap[3] == REFERENCE)                setHandlersMapsRef(3, reachableHandlerBBNums, reachableHandlersCount,                                    bbMaps);              else                setHandlersMapsReturnAddress(3, reachableHandlerBBNums,                                              reachableHandlersCount, bbMaps);            }                }          currBBStkTop--;          break;        }        case JBC_dup: {          currBBMap[currBBStkTop+1] = currBBMap[currBBStkTop];          currBBStkTop++;          break;        }        case JBC_dup2: {          currBBMap[currBBStkTop+1] = currBBMap[currBBStkTop-1];          currBBMap[currBBStkTop+2] = currBBMap[currBBStkTop];          currBBStkTop = currBBStkTop + 2;          break;        }        case JBC_dup_x1: {          currBBMap[currBBStkTop+1] = currBBMap[currBBStkTop];          currBBMap[currBBStkTop]   = currBBMap[currBBStkTop-1];          currBBMap[currBBStkTop-1] = currBBMap[currBBStkTop+1];          currBBStkTop++;          break;        }        case JBC_dup2_x1: {          currBBMap[currBBStkTop+2] = currBBMap[currBBStkTop];          currBBMap[currBBStkTop+1] = currBBMap[currBBStkTop-1];          currBBMap[currBBStkTop]   = currBBMap[currBBStkTop-2];          currBBMap[currBBStkTop-1] = currBBMap[currBBStkTop+2];          currBBMap[currBBStkTop-2] = currBBMap[currBBStkTop+1];          currBBStkTop = currBBStkTop + 2;          break;        }        case JBC_dup_x2: {          currBBMap[currBBStkTop+1] = currBBMap[currBBStkTop];          currBBMap[currBBStkTop]   = currBBMap[currBBStkTop-1];          currBBMap[currBBStkTop-1] = currBBMap[currBBStkTop-2];          currBBMap[currBBStkTop-2] = currBBMap[currBBStkTop+1];          currBBStkTop++;          break;        }        case JBC_dup2_x2: {          currBBMap[currBBStkTop+2] = currBBMap[currBBStkTop];          currBBMap[currBBStkTop+1] = currBBMap[currBBStkTop-1];          currBBMap[currBBStkTop]   = currBBMap[currBBStkTop-2];          currBBMap[currBBStkTop-1] = currBBMap[currBBStkTop-3];          currBBMap[currBBStkTop-2] = currBBMap[currBBStkTop+2];          currBBMap[currBBStkTop-3] = currBBMap[currBBStkTop+1];          currBBStkTop = currBBStkTop + 2;          break;        }        case JBC_swap: {          byte temp;          temp = currBBMap[currBBStkTop];          currBBMap[currBBStkTop] = currBBMap[currBBStkTop-1];          currBBMap[currBBStkTop-1] = temp;          break;        }        case JBC_pop:        case JBC_iadd:        case JBC_fadd:        case JBC_isub:        case JBC_fsub:        case JBC_imul:        case JBC_fmul:        case JBC_fdiv:        case JBC_frem:        case JBC_ishl:        case JBC_ishr:        case JBC_iushr:        case JBC_lshl:      // long shifts that int shift value        case JBC_lshr:        case JBC_lushr:        case JBC_iand:        case JBC_ior:        case JBC_ixor:        case JBC_l2i:        case JBC_l2f:        case JBC_d2i:        case JBC_d2f:        case JBC_fcmpl:        case JBC_fcmpg: {          currBBStkTop--;          bcodes.skipInstruction();          break;        }        case JBC_irem:        case JBC_idiv: {          currBBStkTop = currBBStkTop-2; // record map after 2 integers popped off stack          if (!inJSRSub)             referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop++;          break;        }        case JBC_ladd:        case JBC_dadd:        case JBC_lsub:        case JBC_dsub:        case JBC_lmul:        case JBC_dmul:        case JBC_ddiv:        case JBC_drem:        case JBC_land:        case JBC_lor:        case JBC_lxor:        case JBC_pop2: {          currBBStkTop = currBBStkTop - 2;          break;        }        case JBC_lrem:        case JBC_ldiv: {          currBBStkTop = currBBStkTop - 4; // record map after 2 longs popped off stack          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop = currBBStkTop + 2;          break;        }        case JBC_ineg:        case JBC_lneg:        case JBC_fneg:        case JBC_dneg:        case JBC_iinc:        case JBC_i2f:        case JBC_l2d:        case JBC_f2i:        case JBC_d2l:        case JBC_int2byte:        case JBC_int2char:        case JBC_int2short: {          bcodes.skipInstruction();          break;        }        case JBC_lcmp:        case JBC_dcmpl:        case JBC_dcmpg: {          currBBStkTop = currBBStkTop - 3;          break;        }        case JBC_ifeq:        case JBC_ifne:        case JBC_iflt:        case JBC_ifge:        case JBC_ifgt:        case JBC_ifle: {          int offset = bcodes.getBranchOffset();          if(offset< 0){            // potential backward branch-generate reference map            // Register the reference map            if (!inJSRSub)              referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                          blockSeen[currBBNum]);            else              // in a jsr subroutine              referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                    currPendingRET.returnAddressLocation,                                                   blockSeen[currBBNum]);          }          // process the basic block logic          currBBStkTop--;          if (offset < 0) {            short fallThruBBNum = byteToBlockMap[biStart+3];            workStk = processBranchBB(fallThruBBNum, currBBStkTop, currBBMap,                                       currBBStkEmpty, inJSRSub, bbMaps, blockStkTop,                                       currPendingRET, bbPendingRETs, workStk);            processNextBlock = false;          }          brBBNum = byteToBlockMap[biStart+offset];          workStk = processBranchBB(brBBNum, currBBStkTop, currBBMap, currBBStkEmpty,                                    inJSRSub, bbMaps, blockStkTop, currPendingRET,                                    bbPendingRETs, workStk);          break;        }        case JBC_if_icmpeq:        case JBC_if_icmpne:        case JBC_if_icmplt:        case JBC_if_icmpge:        case JBC_if_icmpgt:        case JBC_if_icmple:        case JBC_if_acmpeq:        case JBC_if_acmpne: {          int offset = bcodes.getBranchOffset();          if(offset< 0){            // possible backward branch-generate reference map            // Register the reference map            if (!inJSRSub)              referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                          blockSeen[currBBNum]);            else              // in a jsr subroutine              referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                    currPendingRET.returnAddressLocation,                                                   blockSeen[currBBNum]);          }          //process the basic blocks          currBBStkTop = currBBStkTop - 2;          if (offset < 0) {            short fallThruBBNum = byteToBlockMap[biStart+3];            workStk = processBranchBB(fallThruBBNum, currBBStkTop, currBBMap, currBBStkEmpty,                                      inJSRSub, bbMaps, blockStkTop, currPendingRET,                                       bbPendingRETs, workStk);            processNextBlock = false;          }          brBBNum = byteToBlockMap[biStart+offset];          workStk = processBranchBB(brBBNum, currBBStkTop, currBBMap, currBBStkEmpty,                                    inJSRSub, bbMaps, blockStkTop, currPendingRET,                                     bbPendingRETs, workStk);          break;        }        case JBC_ifnull:        case JBC_ifnonnull: {          int offset = bcodes.getBranchOffset();          if(offset< 0){            // possible backward branch-generate reference map            // Register the reference map            if (!inJSRSub)              referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                          blockSeen[currBBNum]);            else              // in a jsr subroutine              referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                    currPendingRET.returnAddressLocation,                                                   blockSeen[currBBNum]);          }          //process the basic block logic          currBBStkTop--;          if (offset < 0) {            short fallThruBBNum = byteToBlockMap[biStart+3];            workStk = processBranchBB(fallThruBBNum, currBBStkTop, currBBMap,                                       currBBStkEmpty, inJSRSub, bbMaps, blockStkTop,                                       currPendingRET, bbPendingRETs, workStk);            processNextBlock = false;          }          brBBNum = byteToBlockMap[biStart+offset];          workStk = processBranchBB(brBBNum, currBBStkTop, currBBMap, currBBStkEmpty,                                    inJSRSub, bbMaps, blockStkTop, currPendingRET,                                    bbPendingRETs, workStk);          break;        }        case JBC_goto: {          int offset = bcodes.getBranchOffset();          if(offset< 0){            // backward branch-generate reference map            // Register the reference map            if (!inJSRSub)              referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                          blockSeen[currBBNum]);            else              // in a jsr subroutine              referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                    currPendingRET.returnAddressLocation,                                                   blockSeen[currBBNum]);          }          //  process the basic block logic          brBBNum = byteToBlockMap[biStart+offset];          workStk = processBranchBB(brBBNum, currBBStkTop, currBBMap, currBBStkEmpty,                                    inJSRSub, bbMaps, blockStkTop, currPendingRET,                                    bbPendingRETs, workStk);          processNextBlock = false;          break;        }        case JBC_goto_w: {          int offset = bcodes.getWideBranchOffset();          if(offset< 0){            // backward branch-generate reference map            // Register the reference map            if (!inJSRSub)              referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                          blockSeen[currBBNum]);            else              // in a jsr subroutine              referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                    currPendingRET.returnAddressLocation,                                                   blockSeen[currBBNum]);          }          //process basic block structures          brBBNum = byteToBlockMap[biStart+offset];          workStk = processBranchBB(brBBNum, currBBStkTop, currBBMap, currBBStkEmpty,                                    inJSRSub, bbMaps, blockStkTop, currPendingRET,                                    bbPendingRETs, workStk);          processNextBlock = false;          break;        }        case JBC_tableswitch: {          currBBStkTop--;           bcodes.alignSwitch();          // get default offset and process branch to default branch point          int def = bcodes.getDefaultSwitchOffset();          workStk = processBranchBB(byteToBlockMap[biStart+def], currBBStkTop, currBBMap,                                     currBBStkEmpty, inJSRSub, bbMaps, blockStkTop,                                     currPendingRET, bbPendingRETs, workStk);           int low = bcodes.getLowSwitchValue();          int high = bcodes.getHighSwitchValue();          int n = high - low + 1;          // generate labels for offsets          for (int k = 0; k<n; k++) {            int offset = bcodes.getTableSwitchOffset(k);            workStk = processBranchBB(byteToBlockMap[biStart+offset], currBBStkTop, currBBMap,                                       currBBStkEmpty, inJSRSub, bbMaps, blockStkTop,                                       currPendingRET, bbPendingRETs, workStk);          }          bcodes.skipTableSwitchOffsets(n);          processNextBlock = false;                 break;        }        case JBC_lookupswitch: {          currBBStkTop--;          bcodes.alignSwitch();          // get default offset and process branch to default branch point          int def = bcodes.getDefaultSwitchOffset();          workStk = processBranchBB(byteToBlockMap[biStart+def], currBBStkTop, currBBMap,                                     currBBStkEmpty, inJSRSub, bbMaps, blockStkTop,                                     currPendingRET, bbPendingRETs, workStk);          int npairs = bcodes.getSwitchLength();          // generate label for each offset in table          for (int k = 0; k < npairs; k++) {            int offset = bcodes.getLookupSwitchOffset(k);            workStk = processBranchBB(byteToBlockMap[biStart+offset], currBBStkTop, currBBMap,                                       currBBStkEmpty, inJSRSub, bbMaps, blockStkTop,                                       currPendingRET, bbPendingRETs, workStk);          }          bcodes.skipLookupSwitchPairs(npairs);          processNextBlock = false;          break;        }        case JBC_jsr: {          processNextBlock = false;          int offset = bcodes.getBranchOffset();          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkEmpty,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkEmpty,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop++;          currBBMap[currBBStkTop] = RETURN_ADDRESS;           workStk = processJSR(byteToBlockMap[biStart], biStart+offset, byteToBlockMap[biStart+offset],                                byteToBlockMap[biStart+3], bbMaps, currBBStkTop, currBBMap,                               currBBStkEmpty, blockStkTop, bbPendingRETs,                                currPendingRET, JSRSubs, workStk);          break;        }        case JBC_jsr_w: {          processNextBlock = false;          int offset = bcodes.getWideBranchOffset();          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkEmpty,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkEmpty,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop++;          currBBMap[currBBStkTop] = RETURN_ADDRESS;            workStk = processJSR(byteToBlockMap[biStart], biStart+offset, byteToBlockMap[biStart+offset],                                byteToBlockMap[biStart+5], bbMaps, currBBStkTop, currBBMap,                                currBBStkEmpty, blockStkTop, bbPendingRETs,                                currPendingRET, JSRSubs, workStk);          break;        }        case JBC_ret: {          int index = bcodes.getLocalNumber();          // Can not be used again as a return addr.          //          currBBMap[index] = SET_TO_NONREFERENCE;             processNextBlock = false;          int subStart = currPendingRET.JSRSubStartByteIndex;          int k;          for (k=0; k<JSRSubNext; k++) {            if (JSRSubs[k].subroutineByteCodeStart == subStart) {              JSRSubs[k].newEndMaps(currBBMap, currBBStkTop);              break;            }          }           boolean JSRisinJSRSub = bbPendingRETs[currPendingRET.JSRBBNum] != null;          workStk = computeJSRNextMaps(currPendingRET.JSRNextBBNum, currBBMap.length,                                        k, JSRisinJSRSub, bbMaps, blockStkTop, JSRSubs,                                        currBBStkEmpty, workStk);          if (JSRisinJSRSub && bbPendingRETs[currPendingRET.JSRNextBBNum] == null)             bbPendingRETs[currPendingRET.JSRNextBBNum] =               new VM_PendingRETInfo(bbPendingRETs[currPendingRET.JSRBBNum]);          break;        }        case JBC_invokevirtual:        case JBC_invokespecial: {          VM_MethodReference target = bcodes.getMethodReference();          currBBStkTop = processInvoke(target, biStart, currBBStkTop, currBBMap, false,                                        inJSRSub, referenceMaps, currPendingRET,                                        blockSeen[currBBNum], currBBStkEmpty);          break;        }        case JBC_invokeinterface: {          VM_MethodReference target = bcodes.getMethodReference();          bcodes.alignInvokeInterface();          currBBStkTop = processInvoke(target, biStart, currBBStkTop, currBBMap, false,                                        inJSRSub, referenceMaps, currPendingRET,                                        blockSeen[currBBNum], currBBStkEmpty);          break;        }        case JBC_invokestatic: {          VM_MethodReference target = bcodes.getMethodReference();          currBBStkTop = processInvoke(target, biStart, currBBStkTop, currBBMap, true,                                        inJSRSub, referenceMaps, currPendingRET,                                        blockSeen[currBBNum], currBBStkEmpty);          break;        }        case JBC_ireturn:        case JBC_lreturn:        case JBC_freturn:        case JBC_dreturn:        case JBC_areturn:        case JBC_return: {          if (VM.UseEpilogueYieldPoints || method.isSynchronized())            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          processNextBlock = false;          break;        }        case JBC_getstatic: {          // Register the reference map (could cause dynamic linking)          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          VM_TypeReference fieldType = bcodes.getFieldReference().getFieldContentsType();          currBBMap[++currBBStkTop] = fieldType.isPrimitiveType() ? NON_REFERENCE : REFERENCE;          if (fieldType.getStackWords() == 2)            currBBMap[++currBBStkTop] = NON_REFERENCE;          break;        }        case JBC_putstatic: {          // Register the reference map (could cause dynamic linking)          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          VM_TypeReference fieldType = bcodes.getFieldReference().getFieldContentsType();          currBBStkTop--;          if (fieldType.getStackWords() == 2)            currBBStkTop--;          break;        }        case JBC_getfield: {          VM_TypeReference fieldType = bcodes.getFieldReference().getFieldContentsType();          // Register the reference map, minus the object pointer on the stack          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          currBBStkTop--;    // pop object pointer          currBBMap[++currBBStkTop] = fieldType.isPrimitiveType() ? NON_REFERENCE : REFERENCE;          if (fieldType.getStackWords() == 2)            currBBMap[++currBBStkTop] = NON_REFERENCE;          break;        }        case JBC_putfield: {          VM_TypeReference fieldType = bcodes.getFieldReference().getFieldContentsType();          // Register the reference map with the values still on the stack          //  note: putfield could result in a call to the classloader           if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop -= 2;  // remove objectref and one value          if (fieldType.getStackWords() == 2)            currBBStkTop--;          break;        }        case JBC_checkcast: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          bcodes.skipInstruction();          break;        }        case JBC_instanceof: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          currBBMap[currBBStkTop] = NON_REFERENCE;          bcodes.skipInstruction();          break;        }        case JBC_new: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop++;          currBBMap[currBBStkTop] = REFERENCE;          bcodes.skipInstruction();          break;        }        // For the <x>aload instructions the map is needed in case gc occurs        // while the array index check is taking place. Stack has not been        // altered yet.        case JBC_iaload:        case JBC_faload:        case JBC_baload:        case JBC_caload:        case JBC_saload: {          if (!inJSRSub)             referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else             referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop--;          currBBMap[currBBStkTop] = NON_REFERENCE;          break;        }        case JBC_laload:        case JBC_daload: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBMap[currBBStkTop-1] = NON_REFERENCE;          break;        }        case JBC_aaload: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop--;          break;        }        // For the <x>astore instructions the map recorded is in case gc occurs        // during the array index bounds check or the arraystore check (for aastore).        // Stack has not been modified at this point.        case JBC_iastore:        case JBC_fastore:        case JBC_aastore:        case JBC_bastore:        case JBC_castore:        case JBC_sastore: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop = currBBStkTop - 3;          break;        }        case JBC_lastore:        case JBC_dastore: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBStkTop = currBBStkTop - 4;          break;        }        case JBC_newarray:        case JBC_anewarray: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                  blockSeen[currBBNum]);          currBBMap[currBBStkTop] = REFERENCE;          bcodes.skipInstruction();          break;        }        case JBC_multianewarray: {          VM_TypeReference tRef = bcodes.getTypeReference();          int dim = bcodes.getArrayDimension();          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          currBBStkTop = currBBStkTop - dim + 1;          currBBMap[currBBStkTop] = REFERENCE;          break;        }        case JBC_arraylength: {          currBBMap[currBBStkTop] = NON_REFERENCE;          break;        }        case JBC_athrow: {          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          currBBStkTop = currBBStkEmpty+1;          currBBMap[currBBStkTop] = REFERENCE;          processNextBlock = false;          break;        }        case JBC_monitorenter:        case JBC_monitorexit: {          currBBStkTop--;          if (!inJSRSub)            referenceMaps.recordStkMap(biStart, currBBMap, currBBStkTop,                                        blockSeen[currBBNum]);          else            referenceMaps.recordJSRSubroutineMap(biStart, currBBMap, currBBStkTop,                                                  currPendingRET.returnAddressLocation,                                                 blockSeen[currBBNum]);          break;        }        case JBC_wide: {          int widecode = bcodes.getWideOpcode();          int index = bcodes.getWideLocalNumber();          switch(widecode) {          case JBC_iload:          case JBC_fload: {            currBBStkTop++;            currBBMap[currBBStkTop] = NON_REFERENCE;            break;          }          case JBC_lload:          case JBC_dload: {              currBBStkTop++;              currBBMap[currBBStkTop] = NON_REFERENCE;              currBBStkTop++;              currBBMap[currBBStkTop] = NON_REFERENCE;              break;          }          case JBC_aload: {            currBBStkTop++;            currBBMap[currBBStkTop] = currBBMap[index];            break;          }          case JBC_istore:          case JBC_fstore: {            if (!inJSRSub)              currBBMap[index]=NON_REFERENCE;            else              currBBMap[index]=SET_TO_NONREFERENCE;            currBBStkTop--;            break;          }          case JBC_lstore:          case JBC_dstore: {            if (!inJSRSub) {              currBBMap[index]=NON_REFERENCE;              currBBMap[index+1]=NON_REFERENCE;            } else {              currBBMap[index]=SET_TO_NONREFERENCE;              currBBMap[index+1]=SET_TO_NONREFERENCE;            }            currBBStkTop = currBBStkTop - 2;            break;          }          case JBC_astore: {            currBBMap[index]=currBBMap[currBBStkTop];            currBBStkTop--;            break;          }          case JBC_iinc: {            int val = bcodes.getWideIncrement();            break;          }          case JBC_ret: {            // Can not be used again as a return addr.            //            currBBMap[index] = SET_TO_NONREFERENCE;               processNextBlock = false;            int subStart = currPendingRET.JSRSubStartByteIndex;            int k;            for (k=0; k<JSRSubNext; k++) {              if (JSRSubs[k].subroutineByteCodeStart == subStart) {                JSRSubs[k].newEndMaps(currBBMap, currBBStkTop);                break;              }            }             boolean JSRisinJSRSub = bbPendingRETs[currPendingRET.JSRBBNum] != null;            workStk = computeJSRNextMaps(currPendingRET.JSRNextBBNum, currBBMap.length,                                          k, JSRisinJSRSub, bbMaps, blockStkTop, JSRSubs,                                          currBBStkEmpty, workStk);            if (JSRisinJSRSub && bbPendingRETs[currPendingRET.JSRNextBBNum] == null)               bbPendingRETs[currPendingRET.JSRNextBBNum] =                 new VM_PendingRETInfo(bbPendingRETs[currPendingRET.JSRBBNum]);            break;          }          default: // switch on widecode            if (VM.VerifyAssertions) VM._assert(VM.NOT_REACHED);          }          break;        }  // case JBC_wide:                default: {          VM.sysFail("Unknown opcode:" + opcode);        }        }  // end switch (opcode)            }  // for start to end      blockSeen[currBBNum] = true;      if (processNextBlock) {        short fallThruBBNum = byteToBlockMap[bcodes.index()];        workStk = processBranchBB(fallThruBBNum, currBBStkTop, currBBMap,                                   currBBStkEmpty, inJSRSub, bbMaps, blockStkTop,                                   currPendingRET, bbPendingRETs, workStk);      }      // if the work stack is empty, we must have processed the whole program      // we can now process the try handlers if there are any.      // If a handler doesn't have a starting map already, then the associated try      // has not been processed yet. The try and the handler must be in another       // handler, so that handler must be processed first.      // If one handler is in the try block associated with a second handler, then       // the second handler must not be processed until the first handler has been.      //      if ((workStkTop == -1) && !handlersAllDone ) {        int i;        for (i=0; i < tryHandlerLength; i++) {          if (handlerProcessed[i] || bbMaps[byteToBlockMap[tryHandlerPC[i]]] == null)            continue;   // already processed this handler, or, haven't seen the           // associated try block yet so no starting map is available,          // the try block must be in one of the other handlers          else             break;        }        if (i == tryHandlerLength) {          handlersAllDone = true;        } else {          int considerIndex = i;          while (i != tryHandlerLength) {            int tryStart = tryStartPC[considerIndex];            int tryEnd   = tryEndPC[considerIndex];            for (i=0; i<tryHandlerLength; i++) {              // If the handler handles itself, then make the wild assumption              // that the local variables will be the same......is this reasonable??              // This is a patch to deal with defect 3046.              // I'm not entirely convinced this is right, but don't know what else we can do. --dave              if (i == considerIndex) continue;              // For every handler that has not yet been processed,               // but already has a known starting map,              // make sure it is not in the try block part of the handler              // we are considering working on.               if (!handlerProcessed[i] &&                  tryStart <= tryHandlerPC[i] &&                  tryHandlerPC[i] < tryEnd &&                  bbMaps[byteToBlockMap[tryHandlerPC[i]]] != null) {                break;              }            }            if (i != tryHandlerLength)              considerIndex = i;          }          short blockNum = byteToBlockMap[tryHandlerPC[considerIndex]];          handlerProcessed[considerIndex] = true;          workStk = addToWorkStk(blockNum, workStk);        }      }    }  // while workStk not empty    // Indicate that any temporaries can be freed    referenceMaps.recordingComplete();    return;  }  