public void visitBranchInstruction(
      Clazz clazz,
      Method method,
      CodeAttribute codeAttribute,
      int offset,
      BranchInstruction branchInstruction) {
    byte opcode = branchInstruction.opcode;
    if (opcode == InstructionConstants.OP_JSR || opcode == InstructionConstants.OP_JSR_W) {
      int branchOffset = branchInstruction.branchOffset;
      int branchTarget = offset + branchOffset;

      // Is the subroutine ever returning?
      if (branchTargetFinder.isSubroutineReturning(branchTarget)) {
        // Append a label at this offset instead of the subroutine invocation.
        codeAttributeComposer.appendLabel(offset);

        // Inline the invoked subroutine.
        inlineSubroutine(clazz, method, codeAttribute, offset, branchTarget);
      } else {
        if (DEBUG) {
          System.out.println(
              "Replacing subroutine invocation at [" + offset + "] by a simple branch");
        }

        // Replace the subroutine invocation by a simple branch.
        Instruction replacementInstruction =
            new BranchInstruction(InstructionConstants.OP_GOTO, branchOffset).shrink();

        codeAttributeComposer.appendInstruction(offset, replacementInstruction);
      }
    } else {
      // Append the instruction.
      codeAttributeComposer.appendInstruction(offset, branchInstruction);
    }
  }
  /** Returns whether the given code attribute contains any subroutines. */
  private boolean containsSubroutines(CodeAttribute codeAttribute) {
    for (int offset = 0; offset < codeAttribute.u4codeLength; offset++) {
      if (branchTargetFinder.isSubroutineInvocation(offset)) {
        return true;
      }
    }

    return false;
  }
  public void visitVariableInstruction(
      Clazz clazz,
      Method method,
      CodeAttribute codeAttribute,
      int offset,
      VariableInstruction variableInstruction) {
    byte opcode = variableInstruction.opcode;
    if (opcode == InstructionConstants.OP_RET) {
      // Is the return instruction the last instruction of the subroutine?
      if (branchTargetFinder.subroutineEnd(offset) == offset + variableInstruction.length(offset)) {
        if (DEBUG) {
          System.out.println("    Replacing subroutine return at [" + offset + "] by a label");
        }

        // Append a label at this offset instead of the subroutine return.
        codeAttributeComposer.appendLabel(offset);
      } else {
        if (DEBUG) {
          System.out.println(
              "    Replacing subroutine return at [" + offset + "] by a simple branch");
        }

        // Replace the instruction by a branch.
        Instruction replacementInstruction =
            new BranchInstruction(
                    InstructionConstants.OP_GOTO, branchTargetFinder.subroutineEnd(offset) - offset)
                .shrink();

        codeAttributeComposer.appendInstruction(offset, replacementInstruction);
      }
    } else if (branchTargetFinder.isSubroutineStart(offset)) {
      if (DEBUG) {
        System.out.println(
            "    Replacing first subroutine instruction at [" + offset + "] by a label");
      }

      // Append a label at this offset instead of saving the subroutine
      // return address.
      codeAttributeComposer.appendLabel(offset);
    } else {
      // Append the instruction.
      codeAttributeComposer.appendInstruction(offset, variableInstruction);
    }
  }
  /** Appends the specified subroutine. */
  private void inlineSubroutine(
      Clazz clazz,
      Method method,
      CodeAttribute codeAttribute,
      int subroutineInvocationOffset,
      int subroutineStart) {
    int subroutineEnd = branchTargetFinder.subroutineEnd(subroutineStart);

    if (DEBUG) {
      System.out.println(
          "  Inlining subroutine ["
              + subroutineStart
              + " -> "
              + subroutineEnd
              + "] at ["
              + subroutineInvocationOffset
              + "]");
    }

    // Don't go inlining exceptions that are already applicable to this
    // subroutine invocation.
    ExceptionInfoVisitor oldSubroutineExceptionInliner = subroutineExceptionInliner;
    int oldClipStart = clipStart;
    int oldClipEnd = clipEnd;

    subroutineExceptionInliner =
        new ExceptionExcludedOffsetFilter(subroutineInvocationOffset, subroutineExceptionInliner);
    clipStart = subroutineStart;
    clipEnd = subroutineEnd;

    codeAttributeComposer.beginCodeFragment(codeAttribute.u4codeLength);

    // Copy the subroutine instructions, inlining any subroutine calls
    // recursively.
    codeAttribute.instructionsAccept(clazz, method, subroutineStart, subroutineEnd, this);

    if (DEBUG) {
      System.out.println("    Appending label after inlined subroutine at [" + subroutineEnd + "]");
    }

    // Append a label just after the code.
    codeAttributeComposer.appendLabel(subroutineEnd);

    // Inline the subroutine exceptions.
    codeAttribute.exceptionsAccept(
        clazz, method, subroutineStart, subroutineEnd, subroutineExceptionInliner);

    // We can again inline exceptions that are applicable to this
    // subroutine invocation.
    subroutineExceptionInliner = oldSubroutineExceptionInliner;
    clipStart = oldClipStart;
    clipEnd = oldClipEnd;

    codeAttributeComposer.endCodeFragment();
  }
  public void visitExceptionInfo(
      Clazz clazz, Method method, CodeAttribute codeAttribute, ExceptionInfo exceptionInfo) {
    int startPC = Math.max(exceptionInfo.u2startPC, clipStart);
    int endPC = Math.min(exceptionInfo.u2endPC, clipEnd);
    int handlerPC = exceptionInfo.u2handlerPC;
    int catchType = exceptionInfo.u2catchType;

    // Exclude any subroutine invocations that jump out of the try block,
    // by adding a try block before (and later on, after) each invocation.
    for (int offset = startPC; offset < endPC; offset++) {
      if (branchTargetFinder.isSubroutineInvocation(offset)) {
        Instruction instruction = InstructionFactory.create(codeAttribute.code, offset);
        int instructionLength = instruction.length(offset);

        // Is it a subroutine invocation?
        if (!exceptionInfo.isApplicable(offset + ((BranchInstruction) instruction).branchOffset)) {
          if (DEBUG) {
            System.out.println(
                "  Appending extra exception [" + startPC + " -> " + offset + "] -> " + handlerPC);
          }

          // Append a try block that ends before the subroutine invocation.
          codeAttributeComposer.appendException(
              new ExceptionInfo(startPC, offset, handlerPC, catchType));

          // The next try block will start after the subroutine invocation.
          startPC = offset + instructionLength;
        }
      }
    }

    if (DEBUG) {
      System.out.println(
          "  Appending exception [" + startPC + " -> " + endPC + "] -> " + handlerPC);
    }

    // Append the exception. Note that exceptions with empty try blocks
    // are automatically ignored.
    codeAttributeComposer.appendException(new ExceptionInfo(startPC, endPC, handlerPC, catchType));
  }
  public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute) {
    //        DEBUG =
    //            clazz.getName().equals("abc/Def") &&
    //            method.getName(clazz).equals("abc");

    if (DEBUG) {
      method.accept(clazz, new ClassPrinter());
    }

    branchTargetFinder.visitCodeAttribute(clazz, method, codeAttribute);

    // Don't bother if there aren't any subroutines anyway.
    if (!containsSubroutines(codeAttribute)) {
      return;
    }

    if (DEBUG) {
      System.out.println(
          "SubroutineInliner: processing ["
              + clazz.getName()
              + "."
              + method.getName(clazz)
              + method.getDescriptor(clazz)
              + "]");
    }

    // Append the body of the code.
    codeAttributeComposer.reset();
    codeAttributeComposer.beginCodeFragment(codeAttribute.u4codeLength);

    // Copy the non-subroutine instructions.
    int offset = 0;
    while (offset < codeAttribute.u4codeLength) {
      Instruction instruction = InstructionFactory.create(codeAttribute.code, offset);
      int instructionLength = instruction.length(offset);

      // Is this returning subroutine?
      if (branchTargetFinder.isSubroutine(offset)
          && branchTargetFinder.isSubroutineReturning(offset)) {
        // Skip the subroutine.
        if (DEBUG) {
          System.out.println(
              "  Skipping original subroutine instruction " + instruction.toString(offset));
        }

        // Append a label at this offset instead.
        codeAttributeComposer.appendLabel(offset);
      } else {
        // Copy the instruction, inlining any subroutine call recursively.
        instruction.accept(clazz, method, codeAttribute, offset, this);
      }

      offset += instructionLength;
    }

    // Copy the exceptions. Note that exceptions with empty try blocks
    // are automatically removed.
    codeAttribute.exceptionsAccept(clazz, method, subroutineExceptionInliner);

    if (DEBUG) {
      System.out.println("  Appending label after code at [" + offset + "]");
    }

    // Append a label just after the code.
    codeAttributeComposer.appendLabel(codeAttribute.u4codeLength);

    // End and update the code attribute.
    codeAttributeComposer.endCodeFragment();
    codeAttributeComposer.visitCodeAttribute(clazz, method, codeAttribute);

    if (DEBUG) {
      method.accept(clazz, new ClassPrinter());
    }
  }