Java Code Examples for com.sun.org.apache.bcel.internal.generic.InstructionHandle#getPosition()

/**
 * <p>Get all {@link Method}s generated by this {@link MethodGenerator}.
 * The {@link MethodGen#getMethod()} only returns a single
 * <code>Method</code> object.  This method takes into account the Java
 * Virtual Machine Specification limit of 64KB on the size of a method, and
 * may return more than one <code>Method</code>.</p>
 * <p>If the code associated with the <code>MethodGenerator</code> would
 * exceed the 64KB limit, this method will attempt to split the code in
 * the {@link InstructionList} associated with this
 * <code>MethodGenerator</code> into several methods.</p>
 * @param classGen the {@link ClassGenerator} of which these methods are
 *                 members
 * @return an array of all the <code>Method</code>s generated
 */
Method[] getGeneratedMethods(ClassGenerator classGen) {
    Method[] generatedMethods;
    InstructionList il = getInstructionList();
    InstructionHandle last = il.getEnd();

    il.setPositions();

    int instructionListSize =
                last.getPosition() + last.getInstruction().getLength();

    // Need to look for any branch target offsets that exceed the range
    // [-32768,32767]
    if (instructionListSize > MAX_BRANCH_TARGET_OFFSET) {
        boolean ilChanged = widenConditionalBranchTargetOffsets();

        // If any branch instructions needed widening, recompute the size
        // of the byte code for the method
        if (ilChanged) {
            il.setPositions();
            last = il.getEnd();
            instructionListSize =
                    last.getPosition() + last.getInstruction().getLength();
        }
    }

    if (instructionListSize > MAX_METHOD_SIZE) {
        generatedMethods = outlineChunks(classGen, instructionListSize);
    } else {
        generatedMethods = new Method[] {getThisMethod()};
    }
    return generatedMethods;
}
 

/**
 * <p>Get all {@link Method}s generated by this {@link MethodGenerator}.
 * The {@link MethodGen#getMethod()} only returns a single
 * <code>Method</code> object.  This method takes into account the Java
 * Virtual Machine Specification limit of 64KB on the size of a method, and
 * may return more than one <code>Method</code>.</p>
 * <p>If the code associated with the <code>MethodGenerator</code> would
 * exceed the 64KB limit, this method will attempt to split the code in
 * the {@link InstructionList} associated with this
 * <code>MethodGenerator</code> into several methods.</p>
 * @param classGen the {@link ClassGenerator} of which these methods are
 *                 members
 * @return an array of all the <code>Method</code>s generated
 */
Method[] getGeneratedMethods(ClassGenerator classGen) {
    Method[] generatedMethods;
    InstructionList il = getInstructionList();
    InstructionHandle last = il.getEnd();

    il.setPositions();

    int instructionListSize =
                last.getPosition() + last.getInstruction().getLength();

    // Need to look for any branch target offsets that exceed the range
    // [-32768,32767]
    if (instructionListSize > MAX_BRANCH_TARGET_OFFSET) {
        boolean ilChanged = widenConditionalBranchTargetOffsets();

        // If any branch instructions needed widening, recompute the size
        // of the byte code for the method
        if (ilChanged) {
            il.setPositions();
            last = il.getEnd();
            instructionListSize =
                    last.getPosition() + last.getInstruction().getLength();
        }
    }

    if (instructionListSize > MAX_METHOD_SIZE) {
        generatedMethods = outlineChunks(classGen, instructionListSize);
    } else {
        generatedMethods = new Method[] {getThisMethod()};
    }
    return generatedMethods;
}
 

/**
 * Determines whether a particular variable is in use at a particular offset
 * in the byte code for this method.
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for the
 * {@link InstructionList} associated with this {@link MethodGenerator}.
 * </li></ul></p>
 * @param lvg the {@link LocalVariableGen} for the variable
 * @param offset the position in the byte code
 * @return <code>true</code> if and only if the specified variable is in
 * use at the particular byte code offset.
 */
boolean offsetInLocalVariableGenRange(LocalVariableGen lvg, int offset) {
    InstructionHandle lvgStart = lvg.getStart();
    InstructionHandle lvgEnd = lvg.getEnd();

    // If no start handle is recorded for the LocalVariableGen, it is
    // assumed to be in use from the beginning of the method.
    if (lvgStart == null) {
        lvgStart = getInstructionList().getStart();
    }

    // If no end handle is recorded for the LocalVariableGen, it is assumed
    // to be in use to the end of the method.
    if (lvgEnd == null) {
        lvgEnd = getInstructionList().getEnd();
    }

    // Does the range of the instruction include the specified offset?
    // Note that the InstructionHandle.getPosition method returns the
    // offset of the beginning of an instruction.  A LocalVariableGen's
    // range includes the end instruction itself, so that instruction's
    // length must be taken into consideration in computing whether the
    // varible is in range at a particular offset.
    return ((lvgStart.getPosition() <= offset)
                && (lvgEnd.getPosition()
                        + lvgEnd.getInstruction().getLength() >= offset));
}
 

/**
 * Determines whether a particular variable is in use at a particular offset
 * in the byte code for this method.
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for the
 * {@link InstructionList} associated with this {@link MethodGenerator}.
 * </li></ul></p>
 * @param lvg the {@link LocalVariableGen} for the variable
 * @param offset the position in the byte code
 * @return <code>true</code> if and only if the specified variable is in
 * use at the particular byte code offset.
 */
boolean offsetInLocalVariableGenRange(LocalVariableGen lvg, int offset) {
    InstructionHandle lvgStart = lvg.getStart();
    InstructionHandle lvgEnd = lvg.getEnd();

    // If no start handle is recorded for the LocalVariableGen, it is
    // assumed to be in use from the beginning of the method.
    if (lvgStart == null) {
        lvgStart = getInstructionList().getStart();
    }

    // If no end handle is recorded for the LocalVariableGen, it is assumed
    // to be in use to the end of the method.
    if (lvgEnd == null) {
        lvgEnd = getInstructionList().getEnd();
    }

    // Does the range of the instruction include the specified offset?
    // Note that the InstructionHandle.getPosition method returns the
    // offset of the beginning of an instruction.  A LocalVariableGen's
    // range includes the end instruction itself, so that instruction's
    // length must be taken into consideration in computing whether the
    // varible is in range at a particular offset.
    return ((lvgStart.getPosition() <= offset)
                && (lvgEnd.getPosition()
                        + lvgEnd.getInstruction().getLength() >= offset));
}
 

/**
 * <p>Get all {@link Method}s generated by this {@link MethodGenerator}.
 * The {@link MethodGen#getMethod()} only returns a single
 * <code>Method</code> object.  This method takes into account the Java
 * Virtual Machine Specification limit of 64KB on the size of a method, and
 * may return more than one <code>Method</code>.</p>
 * <p>If the code associated with the <code>MethodGenerator</code> would
 * exceed the 64KB limit, this method will attempt to split the code in
 * the {@link InstructionList} associated with this
 * <code>MethodGenerator</code> into several methods.</p>
 * @param classGen the {@link ClassGenerator} of which these methods are
 *                 members
 * @return an array of all the <code>Method</code>s generated
 */
Method[] getGeneratedMethods(ClassGenerator classGen) {
    Method[] generatedMethods;
    InstructionList il = getInstructionList();
    InstructionHandle last = il.getEnd();

    il.setPositions();

    int instructionListSize =
                last.getPosition() + last.getInstruction().getLength();

    // Need to look for any branch target offsets that exceed the range
    // [-32768,32767]
    if (instructionListSize > MAX_BRANCH_TARGET_OFFSET) {
        boolean ilChanged = widenConditionalBranchTargetOffsets();

        // If any branch instructions needed widening, recompute the size
        // of the byte code for the method
        if (ilChanged) {
            il.setPositions();
            last = il.getEnd();
            instructionListSize =
                    last.getPosition() + last.getInstruction().getLength();
        }
    }

    if (instructionListSize > MAX_METHOD_SIZE) {
        generatedMethods = outlineChunks(classGen, instructionListSize);
    } else {
        generatedMethods = new Method[] {getThisMethod()};
    }
    return generatedMethods;
}
 

/**
 * <p>Get all {@link Method}s generated by this {@link MethodGenerator}.
 * The {@link MethodGen#getMethod()} only returns a single
 * <code>Method</code> object.  This method takes into account the Java
 * Virtual Machine Specification limit of 64KB on the size of a method, and
 * may return more than one <code>Method</code>.</p>
 * <p>If the code associated with the <code>MethodGenerator</code> would
 * exceed the 64KB limit, this method will attempt to split the code in
 * the {@link InstructionList} associated with this
 * <code>MethodGenerator</code> into several methods.</p>
 * @param classGen the {@link ClassGenerator} of which these methods are
 *                 members
 * @return an array of all the <code>Method</code>s generated
 */
Method[] getGeneratedMethods(ClassGenerator classGen) {
    Method[] generatedMethods;
    InstructionList il = getInstructionList();
    InstructionHandle last = il.getEnd();

    il.setPositions();

    int instructionListSize =
                last.getPosition() + last.getInstruction().getLength();

    // Need to look for any branch target offsets that exceed the range
    // [-32768,32767]
    if (instructionListSize > MAX_BRANCH_TARGET_OFFSET) {
        boolean ilChanged = widenConditionalBranchTargetOffsets();

        // If any branch instructions needed widening, recompute the size
        // of the byte code for the method
        if (ilChanged) {
            il.setPositions();
            last = il.getEnd();
            instructionListSize =
                    last.getPosition() + last.getInstruction().getLength();
        }
    }

    if (instructionListSize > MAX_METHOD_SIZE) {
        generatedMethods = outlineChunks(classGen, instructionListSize);
    } else {
        generatedMethods = new Method[] {getThisMethod()};
    }
    return generatedMethods;
}
 

/**
 * Determines whether a particular variable is in use at a particular offset
 * in the byte code for this method.
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for the
 * {@link InstructionList} associated with this {@link MethodGenerator}.
 * </li></ul></p>
 * @param lvg the {@link LocalVariableGen} for the variable
 * @param offset the position in the byte code
 * @return <code>true</code> if and only if the specified variable is in
 * use at the particular byte code offset.
 */
boolean offsetInLocalVariableGenRange(LocalVariableGen lvg, int offset) {
    InstructionHandle lvgStart = lvg.getStart();
    InstructionHandle lvgEnd = lvg.getEnd();

    // If no start handle is recorded for the LocalVariableGen, it is
    // assumed to be in use from the beginning of the method.
    if (lvgStart == null) {
        lvgStart = getInstructionList().getStart();
    }

    // If no end handle is recorded for the LocalVariableGen, it is assumed
    // to be in use to the end of the method.
    if (lvgEnd == null) {
        lvgEnd = getInstructionList().getEnd();
    }

    // Does the range of the instruction include the specified offset?
    // Note that the InstructionHandle.getPosition method returns the
    // offset of the beginning of an instruction.  A LocalVariableGen's
    // range includes the end instruction itself, so that instruction's
    // length must be taken into consideration in computing whether the
    // varible is in range at a particular offset.
    return ((lvgStart.getPosition() <= offset)
                && (lvgEnd.getPosition()
                        + lvgEnd.getInstruction().getLength() >= offset));
}
 

/**
 * Determines whether a particular variable is in use at a particular offset
 * in the byte code for this method.
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for the
 * {@link InstructionList} associated with this {@link MethodGenerator}.
 * </li></ul></p>
 * @param lvg the {@link LocalVariableGen} for the variable
 * @param offset the position in the byte code
 * @return <code>true</code> if and only if the specified variable is in
 * use at the particular byte code offset.
 */
boolean offsetInLocalVariableGenRange(LocalVariableGen lvg, int offset) {
    InstructionHandle lvgStart = lvg.getStart();
    InstructionHandle lvgEnd = lvg.getEnd();

    // If no start handle is recorded for the LocalVariableGen, it is
    // assumed to be in use from the beginning of the method.
    if (lvgStart == null) {
        lvgStart = getInstructionList().getStart();
    }

    // If no end handle is recorded for the LocalVariableGen, it is assumed
    // to be in use to the end of the method.
    if (lvgEnd == null) {
        lvgEnd = getInstructionList().getEnd();
    }

    // Does the range of the instruction include the specified offset?
    // Note that the InstructionHandle.getPosition method returns the
    // offset of the beginning of an instruction.  A LocalVariableGen's
    // range includes the end instruction itself, so that instruction's
    // length must be taken into consideration in computing whether the
    // varible is in range at a particular offset.
    return ((lvgStart.getPosition() <= offset)
                && (lvgEnd.getPosition()
                        + lvgEnd.getInstruction().getLength() >= offset));
}
 

/**
 * <p>Get all {@link Method}s generated by this {@link MethodGenerator}.
 * The {@link MethodGen#getMethod()} only returns a single
 * <code>Method</code> object.  This method takes into account the Java
 * Virtual Machine Specification limit of 64KB on the size of a method, and
 * may return more than one <code>Method</code>.</p>
 * <p>If the code associated with the <code>MethodGenerator</code> would
 * exceed the 64KB limit, this method will attempt to split the code in
 * the {@link InstructionList} associated with this
 * <code>MethodGenerator</code> into several methods.</p>
 * @param classGen the {@link ClassGenerator} of which these methods are
 *                 members
 * @return an array of all the <code>Method</code>s generated
 */
Method[] getGeneratedMethods(ClassGenerator classGen) {
    Method[] generatedMethods;
    InstructionList il = getInstructionList();
    InstructionHandle last = il.getEnd();

    il.setPositions();

    int instructionListSize =
                last.getPosition() + last.getInstruction().getLength();

    // Need to look for any branch target offsets that exceed the range
    // [-32768,32767]
    if (instructionListSize > MAX_BRANCH_TARGET_OFFSET) {
        boolean ilChanged = widenConditionalBranchTargetOffsets();

        // If any branch instructions needed widening, recompute the size
        // of the byte code for the method
        if (ilChanged) {
            il.setPositions();
            last = il.getEnd();
            instructionListSize =
                    last.getPosition() + last.getInstruction().getLength();
        }
    }

    if (instructionListSize > MAX_METHOD_SIZE) {
        generatedMethods = outlineChunks(classGen, instructionListSize);
    } else {
        generatedMethods = new Method[] {getThisMethod()};
    }
    return generatedMethods;
}
 

/**
 * Determines whether a particular variable is in use at a particular offset
 * in the byte code for this method.
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for the
 * {@link InstructionList} associated with this {@link MethodGenerator}.
 * </li></ul></p>
 * @param lvg the {@link LocalVariableGen} for the variable
 * @param offset the position in the byte code
 * @return <code>true</code> if and only if the specified variable is in
 * use at the particular byte code offset.
 */
boolean offsetInLocalVariableGenRange(LocalVariableGen lvg, int offset) {
    InstructionHandle lvgStart = lvg.getStart();
    InstructionHandle lvgEnd = lvg.getEnd();

    // If no start handle is recorded for the LocalVariableGen, it is
    // assumed to be in use from the beginning of the method.
    if (lvgStart == null) {
        lvgStart = getInstructionList().getStart();
    }

    // If no end handle is recorded for the LocalVariableGen, it is assumed
    // to be in use to the end of the method.
    if (lvgEnd == null) {
        lvgEnd = getInstructionList().getEnd();
    }

    // Does the range of the instruction include the specified offset?
    // Note that the InstructionHandle.getPosition method returns the
    // offset of the beginning of an instruction.  A LocalVariableGen's
    // range includes the end instruction itself, so that instruction's
    // length must be taken into consideration in computing whether the
    // varible is in range at a particular offset.
    return ((lvgStart.getPosition() <= offset)
                && (lvgEnd.getPosition()
                        + lvgEnd.getInstruction().getLength() >= offset));
}
 

/**
 * Breaks up the IL for this {@link MethodGenerator} into separate
 * outlined methods so that no method exceeds the 64KB limit on the length
 * of the byte code associated with a method.
 * @param classGen The {@link ClassGen} with which the generated methods
 *                 will be associated
 * @param originalMethodSize The number of bytes of bytecode represented by
 *                 the {@link InstructionList} of this method
 * @return an array of the outlined <code>Method</code>s and the original
 *         method itself
 */
public Method[] outlineChunks(ClassGenerator classGen,
                              int originalMethodSize) {
    ArrayList methodsOutlined = new ArrayList();
    int currentMethodSize = originalMethodSize;

    int outlinedCount = 0;
    boolean moreMethodsOutlined;
    String originalMethodName = getName();

    // Special handling for initialization methods.  No other methods can
    // include the less than and greater than characters in their names,
    // so we munge the names here.
    if (originalMethodName.equals("<init>")) {
        originalMethodName = "$lt$init$gt$";
    } else if (originalMethodName.equals("<clinit>")) {
        originalMethodName = "$lt$clinit$gt$";
    }

    // Loop until the original method comes in under the JVM limit or
    // the loop was unable to outline any more methods
    do {
        // Get all the best candidates for outlining, and sort them in
        // ascending order of size
        ArrayList candidateChunks = getCandidateChunks(classGen,
                                                       currentMethodSize);
        Collections.sort(candidateChunks);

        moreMethodsOutlined = false;

        // Loop over the candidates for outlining, from the largest to the
        // smallest and outline them one at a time, until the loop has
        // outlined all or the original method comes in under the JVM
        // limit on the size of a method.
        for (int i = candidateChunks.size()-1;
             i >= 0 && currentMethodSize > TARGET_METHOD_SIZE;
             i--) {
            Chunk chunkToOutline = (Chunk)candidateChunks.get(i);

            methodsOutlined.add(outline(chunkToOutline.getChunkStart(),
                                        chunkToOutline.getChunkEnd(),
                                        originalMethodName + "$outline$"
                                                           + outlinedCount,
                                        classGen));
            outlinedCount++;
            moreMethodsOutlined = true;

            InstructionList il = getInstructionList();
            InstructionHandle lastInst = il.getEnd();
            il.setPositions();

            // Check the size of the method now
            currentMethodSize =
                    lastInst.getPosition()
                            + lastInst.getInstruction().getLength();
        }
    } while (moreMethodsOutlined && currentMethodSize > TARGET_METHOD_SIZE);

    // Outlining failed to reduce the size of the current method
    // sufficiently.  Throw an internal error.
    if (currentMethodSize > MAX_METHOD_SIZE) {
        String msg = (new ErrorMsg(ErrorMsg.OUTLINE_ERR_METHOD_TOO_BIG))
                              .toString();
        throw new InternalError(msg);
    }

    Method[] methodsArr = new Method[methodsOutlined.size() + 1];
    methodsOutlined.toArray(methodsArr);

    methodsArr[methodsOutlined.size()] = getThisMethod();

    return methodsArr;
}
 

/**
 * Breaks up the IL for this {@link MethodGenerator} into separate
 * outlined methods so that no method exceeds the 64KB limit on the length
 * of the byte code associated with a method.
 * @param classGen The {@link ClassGen} with which the generated methods
 *                 will be associated
 * @param originalMethodSize The number of bytes of bytecode represented by
 *                 the {@link InstructionList} of this method
 * @return an array of the outlined <code>Method</code>s and the original
 *         method itself
 */
public Method[] outlineChunks(ClassGenerator classGen,
                              int originalMethodSize) {
    ArrayList methodsOutlined = new ArrayList();
    int currentMethodSize = originalMethodSize;

    int outlinedCount = 0;
    boolean moreMethodsOutlined;
    String originalMethodName = getName();

    // Special handling for initialization methods.  No other methods can
    // include the less than and greater than characters in their names,
    // so we munge the names here.
    if (originalMethodName.equals("<init>")) {
        originalMethodName = "$lt$init$gt$";
    } else if (originalMethodName.equals("<clinit>")) {
        originalMethodName = "$lt$clinit$gt$";
    }

    // Loop until the original method comes in under the JVM limit or
    // the loop was unable to outline any more methods
    do {
        // Get all the best candidates for outlining, and sort them in
        // ascending order of size
        ArrayList candidateChunks = getCandidateChunks(classGen,
                                                       currentMethodSize);
        Collections.sort(candidateChunks);

        moreMethodsOutlined = false;

        // Loop over the candidates for outlining, from the largest to the
        // smallest and outline them one at a time, until the loop has
        // outlined all or the original method comes in under the JVM
        // limit on the size of a method.
        for (int i = candidateChunks.size()-1;
             i >= 0 && currentMethodSize > TARGET_METHOD_SIZE;
             i--) {
            Chunk chunkToOutline = (Chunk)candidateChunks.get(i);

            methodsOutlined.add(outline(chunkToOutline.getChunkStart(),
                                        chunkToOutline.getChunkEnd(),
                                        originalMethodName + "$outline$"
                                                           + outlinedCount,
                                        classGen));
            outlinedCount++;
            moreMethodsOutlined = true;

            InstructionList il = getInstructionList();
            InstructionHandle lastInst = il.getEnd();
            il.setPositions();

            // Check the size of the method now
            currentMethodSize =
                    lastInst.getPosition()
                            + lastInst.getInstruction().getLength();
        }
    } while (moreMethodsOutlined && currentMethodSize > TARGET_METHOD_SIZE);

    // Outlining failed to reduce the size of the current method
    // sufficiently.  Throw an internal error.
    if (currentMethodSize > MAX_METHOD_SIZE) {
        String msg = (new ErrorMsg(ErrorMsg.OUTLINE_ERR_METHOD_TOO_BIG))
                              .toString();
        throw new InternalError(msg);
    }

    Method[] methodsArr = new Method[methodsOutlined.size() + 1];
    methodsOutlined.toArray(methodsArr);

    methodsArr[methodsOutlined.size()] = getThisMethod();

    return methodsArr;
}
 

/**
 * Breaks up the IL for this {@link MethodGenerator} into separate
 * outlined methods so that no method exceeds the 64KB limit on the length
 * of the byte code associated with a method.
 * @param classGen The {@link ClassGen} with which the generated methods
 *                 will be associated
 * @param originalMethodSize The number of bytes of bytecode represented by
 *                 the {@link InstructionList} of this method
 * @return an array of the outlined <code>Method</code>s and the original
 *         method itself
 */
public Method[] outlineChunks(ClassGenerator classGen,
                              int originalMethodSize) {
    ArrayList methodsOutlined = new ArrayList();
    int currentMethodSize = originalMethodSize;

    int outlinedCount = 0;
    boolean moreMethodsOutlined;
    String originalMethodName = getName();

    // Special handling for initialization methods.  No other methods can
    // include the less than and greater than characters in their names,
    // so we munge the names here.
    if (originalMethodName.equals("<init>")) {
        originalMethodName = "$lt$init$gt$";
    } else if (originalMethodName.equals("<clinit>")) {
        originalMethodName = "$lt$clinit$gt$";
    }

    // Loop until the original method comes in under the JVM limit or
    // the loop was unable to outline any more methods
    do {
        // Get all the best candidates for outlining, and sort them in
        // ascending order of size
        ArrayList candidateChunks = getCandidateChunks(classGen,
                                                       currentMethodSize);
        Collections.sort(candidateChunks);

        moreMethodsOutlined = false;

        // Loop over the candidates for outlining, from the largest to the
        // smallest and outline them one at a time, until the loop has
        // outlined all or the original method comes in under the JVM
        // limit on the size of a method.
        for (int i = candidateChunks.size()-1;
             i >= 0 && currentMethodSize > TARGET_METHOD_SIZE;
             i--) {
            Chunk chunkToOutline = (Chunk)candidateChunks.get(i);

            methodsOutlined.add(outline(chunkToOutline.getChunkStart(),
                                        chunkToOutline.getChunkEnd(),
                                        originalMethodName + "$outline$"
                                                           + outlinedCount,
                                        classGen));
            outlinedCount++;
            moreMethodsOutlined = true;

            InstructionList il = getInstructionList();
            InstructionHandle lastInst = il.getEnd();
            il.setPositions();

            // Check the size of the method now
            currentMethodSize =
                    lastInst.getPosition()
                            + lastInst.getInstruction().getLength();
        }
    } while (moreMethodsOutlined && currentMethodSize > TARGET_METHOD_SIZE);

    // Outlining failed to reduce the size of the current method
    // sufficiently.  Throw an internal error.
    if (currentMethodSize > MAX_METHOD_SIZE) {
        String msg = (new ErrorMsg(ErrorMsg.OUTLINE_ERR_METHOD_TOO_BIG))
                              .toString();
        throw new InternalError(msg);
    }

    Method[] methodsArr = new Method[methodsOutlined.size() + 1];
    methodsOutlined.toArray(methodsArr);

    methodsArr[methodsOutlined.size()] = getThisMethod();

    return methodsArr;
}
 

/**
 * Breaks up the IL for this {@link MethodGenerator} into separate
 * outlined methods so that no method exceeds the 64KB limit on the length
 * of the byte code associated with a method.
 * @param classGen The {@link ClassGen} with which the generated methods
 *                 will be associated
 * @param originalMethodSize The number of bytes of bytecode represented by
 *                 the {@link InstructionList} of this method
 * @return an array of the outlined <code>Method</code>s and the original
 *         method itself
 */
public Method[] outlineChunks(ClassGenerator classGen,
                              int originalMethodSize) {
    ArrayList methodsOutlined = new ArrayList();
    int currentMethodSize = originalMethodSize;

    int outlinedCount = 0;
    boolean moreMethodsOutlined;
    String originalMethodName = getName();

    // Special handling for initialization methods.  No other methods can
    // include the less than and greater than characters in their names,
    // so we munge the names here.
    if (originalMethodName.equals("<init>")) {
        originalMethodName = "$lt$init$gt$";
    } else if (originalMethodName.equals("<clinit>")) {
        originalMethodName = "$lt$clinit$gt$";
    }

    // Loop until the original method comes in under the JVM limit or
    // the loop was unable to outline any more methods
    do {
        // Get all the best candidates for outlining, and sort them in
        // ascending order of size
        ArrayList candidateChunks = getCandidateChunks(classGen,
                                                       currentMethodSize);
        Collections.sort(candidateChunks);

        moreMethodsOutlined = false;

        // Loop over the candidates for outlining, from the largest to the
        // smallest and outline them one at a time, until the loop has
        // outlined all or the original method comes in under the JVM
        // limit on the size of a method.
        for (int i = candidateChunks.size()-1;
             i >= 0 && currentMethodSize > TARGET_METHOD_SIZE;
             i--) {
            Chunk chunkToOutline = (Chunk)candidateChunks.get(i);

            methodsOutlined.add(outline(chunkToOutline.getChunkStart(),
                                        chunkToOutline.getChunkEnd(),
                                        originalMethodName + "$outline$"
                                                           + outlinedCount,
                                        classGen));
            outlinedCount++;
            moreMethodsOutlined = true;

            InstructionList il = getInstructionList();
            InstructionHandle lastInst = il.getEnd();
            il.setPositions();

            // Check the size of the method now
            currentMethodSize =
                    lastInst.getPosition()
                            + lastInst.getInstruction().getLength();
        }
    } while (moreMethodsOutlined && currentMethodSize > TARGET_METHOD_SIZE);

    // Outlining failed to reduce the size of the current method
    // sufficiently.  Throw an internal error.
    if (currentMethodSize > MAX_METHOD_SIZE) {
        String msg = (new ErrorMsg(ErrorMsg.OUTLINE_ERR_METHOD_TOO_BIG))
                              .toString();
        throw new InternalError(msg);
    }

    Method[] methodsArr = new Method[methodsOutlined.size() + 1];
    methodsOutlined.toArray(methodsArr);

    methodsArr[methodsOutlined.size()] = getThisMethod();

    return methodsArr;
}
 

/**
 * Breaks up the IL for this {@link MethodGenerator} into separate
 * outlined methods so that no method exceeds the 64KB limit on the length
 * of the byte code associated with a method.
 * @param classGen The {@link ClassGen} with which the generated methods
 *                 will be associated
 * @param originalMethodSize The number of bytes of bytecode represented by
 *                 the {@link InstructionList} of this method
 * @return an array of the outlined <code>Method</code>s and the original
 *         method itself
 */
public Method[] outlineChunks(ClassGenerator classGen,
                              int originalMethodSize) {
    ArrayList methodsOutlined = new ArrayList();
    int currentMethodSize = originalMethodSize;

    int outlinedCount = 0;
    boolean moreMethodsOutlined;
    String originalMethodName = getName();

    // Special handling for initialization methods.  No other methods can
    // include the less than and greater than characters in their names,
    // so we munge the names here.
    if (originalMethodName.equals("<init>")) {
        originalMethodName = "$lt$init$gt$";
    } else if (originalMethodName.equals("<clinit>")) {
        originalMethodName = "$lt$clinit$gt$";
    }

    // Loop until the original method comes in under the JVM limit or
    // the loop was unable to outline any more methods
    do {
        // Get all the best candidates for outlining, and sort them in
        // ascending order of size
        ArrayList candidateChunks = getCandidateChunks(classGen,
                                                       currentMethodSize);
        Collections.sort(candidateChunks);

        moreMethodsOutlined = false;

        // Loop over the candidates for outlining, from the largest to the
        // smallest and outline them one at a time, until the loop has
        // outlined all or the original method comes in under the JVM
        // limit on the size of a method.
        for (int i = candidateChunks.size()-1;
             i >= 0 && currentMethodSize > TARGET_METHOD_SIZE;
             i--) {
            Chunk chunkToOutline = (Chunk)candidateChunks.get(i);

            methodsOutlined.add(outline(chunkToOutline.getChunkStart(),
                                        chunkToOutline.getChunkEnd(),
                                        originalMethodName + "$outline$"
                                                           + outlinedCount,
                                        classGen));
            outlinedCount++;
            moreMethodsOutlined = true;

            InstructionList il = getInstructionList();
            InstructionHandle lastInst = il.getEnd();
            il.setPositions();

            // Check the size of the method now
            currentMethodSize =
                    lastInst.getPosition()
                            + lastInst.getInstruction().getLength();
        }
    } while (moreMethodsOutlined && currentMethodSize > TARGET_METHOD_SIZE);

    // Outlining failed to reduce the size of the current method
    // sufficiently.  Throw an internal error.
    if (currentMethodSize > MAX_METHOD_SIZE) {
        String msg = (new ErrorMsg(ErrorMsg.OUTLINE_ERR_METHOD_TOO_BIG))
                              .toString();
        throw new InternalError(msg);
    }

    Method[] methodsArr = new Method[methodsOutlined.size() + 1];
    methodsOutlined.toArray(methodsArr);

    methodsArr[methodsOutlined.size()] = getThisMethod();

    return methodsArr;
}
 

/**
 * <p>Constructor for an outlineable {@link MethodGenerator.Chunk}.</p>
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for
 * the {@link InstructionList} associated with this
 * {@link MethodGenerator}.</li>
 * </ul></p>
 * @param start The {@link InstructionHandle} of the first
 *              instruction in the outlineable chunk.
 * @param end The {@link InstructionHandle} of the last
 *            instruction in the outlineable chunk.
 */
Chunk(InstructionHandle start, InstructionHandle end) {
    m_start = start;
    m_end = end;
    m_size = end.getPosition() - start.getPosition();
}
 

/**
 * <p>Constructor for an outlineable {@link MethodGenerator.Chunk}.</p>
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for
 * the {@link InstructionList} associated with this
 * {@link MethodGenerator}.</li>
 * </ul></p>
 * @param start The {@link InstructionHandle} of the first
 *              instruction in the outlineable chunk.
 * @param end The {@link InstructionHandle} of the last
 *            instruction in the outlineable chunk.
 */
Chunk(InstructionHandle start, InstructionHandle end) {
    m_start = start;
    m_end = end;
    m_size = end.getPosition() - start.getPosition();
}
 

/**
 * <p>Constructor for an outlineable {@link MethodGenerator.Chunk}.</p>
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for
 * the {@link InstructionList} associated with this
 * {@link MethodGenerator}.</li>
 * </ul></p>
 * @param start The {@link InstructionHandle} of the first
 *              instruction in the outlineable chunk.
 * @param end The {@link InstructionHandle} of the last
 *            instruction in the outlineable chunk.
 */
Chunk(InstructionHandle start, InstructionHandle end) {
    m_start = start;
    m_end = end;
    m_size = end.getPosition() - start.getPosition();
}
 

/**
 * <p>Constructor for an outlineable {@link MethodGenerator.Chunk}.</p>
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for
 * the {@link InstructionList} associated with this
 * {@link MethodGenerator}.</li>
 * </ul></p>
 * @param start The {@link InstructionHandle} of the first
 *              instruction in the outlineable chunk.
 * @param end The {@link InstructionHandle} of the last
 *            instruction in the outlineable chunk.
 */
Chunk(InstructionHandle start, InstructionHandle end) {
    m_start = start;
    m_end = end;
    m_size = end.getPosition() - start.getPosition();
}
 

/**
 * <p>Constructor for an outlineable {@link MethodGenerator.Chunk}.</p>
 * <p><b>Preconditions:</b>
 * <ul>
 * <li>The {@link InstructionList#setPositions()} has been called for
 * the {@link InstructionList} associated with this
 * {@link MethodGenerator}.</li>
 * </ul></p>
 * @param start The {@link InstructionHandle} of the first
 *              instruction in the outlineable chunk.
 * @param end The {@link InstructionHandle} of the last
 *            instruction in the outlineable chunk.
 */
Chunk(InstructionHandle start, InstructionHandle end) {
    m_start = start;
    m_end = end;
    m_size = end.getPosition() - start.getPosition();
}