Uses of Class
org.apache.bcel.generic.InstructionHandle

Packages that use InstructionHandle
org.apache.bcel.generic This package contains the "generic" part of the Byte Code Engineering Library, i.e., classes to dynamically modify class objects and byte code instructions. 
org.apache.bcel.util This package contains utility classes for the Byte Code Engineering Library, namely: 
org.apache.bcel.verifier.structurals Provides a PassVerifier class mostly used internally by JustIce, yielding a control flow graph for public use as a nice side effect. 
 

Uses of InstructionHandle in org.apache.bcel.generic
 

Subclasses of InstructionHandle in org.apache.bcel.generic
 class BranchHandle
          BranchHandle is returned by specialized InstructionList.append() whenever a BranchInstruction is appended.
 

Fields in org.apache.bcel.generic declared as InstructionHandle
private  InstructionHandle InstructionList.end
           
private  InstructionHandle LocalVariableGen.end
           
private  InstructionHandle CodeExceptionGen.end_pc
           
private  InstructionHandle CodeExceptionGen.handler_pc
           
private  InstructionHandle LineNumberGen.ih
           
private static InstructionHandle InstructionHandle.ih_list
           
(package private)  InstructionHandle InstructionHandle.next
           
(package private)  InstructionHandle InstructionHandle.prev
           
private  InstructionHandle ReturnaddressType.returnTarget
           
private  InstructionHandle InstructionList.start
           
private  InstructionHandle LocalVariableGen.start
           
private  InstructionHandle CodeExceptionGen.start_pc
           
protected  InstructionHandle BranchInstruction.target
           
(package private)  InstructionHandle MethodGen.BranchTarget.target
           
protected  InstructionHandle[] Select.targets
           
private  InstructionHandle[] SWITCH.targets
           
private  InstructionHandle[] TargetLostException.targets
           
 

Methods in org.apache.bcel.generic that return InstructionHandle
 InstructionHandle InstructionList.append(CompoundInstruction c)
          Append a compound instruction.
 InstructionHandle InstructionList.append(Instruction i)
          Append an instruction to the end of this list.
 InstructionHandle InstructionList.append(Instruction i, CompoundInstruction c)
          Append a compound instruction, after instruction i.
 InstructionHandle InstructionList.append(InstructionHandle ih, CompoundInstruction c)
          Append a compound instruction.
 InstructionHandle InstructionList.append(InstructionHandle ih, Instruction i)
          Append an instruction after instruction (handle) ih contained in this list.
 InstructionHandle InstructionList.append(InstructionHandle ih, InstructionList il)
          Append another list after instruction (handle) ih contained in this list.
 InstructionHandle InstructionList.append(Instruction i, Instruction j)
          Append a single instruction j after another instruction i, which must be in this list of course!
 InstructionHandle InstructionList.append(Instruction i, InstructionList il)
          Append another list after instruction i contained in this list.
 InstructionHandle InstructionList.append(InstructionList il)
          Append another list to this one.
static InstructionHandle InstructionList.findHandle(InstructionHandle[] ihs, int[] pos, int count, int target)
          Find the target instruction (handle) that corresponds to the given target position (byte code offset).
 InstructionHandle InstructionList.findHandle(int pos)
          Get instruction handle for instruction at byte code position pos.
private  InstructionHandle InstructionList.findInstruction1(Instruction i)
          Search for given Instruction reference, start at beginning of list.
private  InstructionHandle InstructionList.findInstruction2(Instruction i)
          Search for given Instruction reference, start at end of list
 InstructionHandle InstructionList.getEnd()
           
 InstructionHandle LocalVariableGen.getEnd()
           
 InstructionHandle CodeExceptionGen.getEndPC()
           
 InstructionHandle CodeExceptionGen.getHandlerPC()
           
 InstructionHandle LineNumberGen.getInstruction()
           
(package private) static InstructionHandle InstructionHandle.getInstructionHandle(Instruction i)
          Factory method.
 InstructionHandle[] InstructionList.getInstructionHandles()
           
 InstructionHandle InstructionHandle.getNext()
           
 InstructionHandle InstructionHandle.getPrev()
           
 InstructionHandle InstructionList.getStart()
           
 InstructionHandle LocalVariableGen.getStart()
           
 InstructionHandle CodeExceptionGen.getStartPC()
           
 InstructionHandle ReturnaddressType.getTarget()
           
 InstructionHandle BranchInstruction.getTarget()
           
 InstructionHandle BranchHandle.getTarget()
           
 InstructionHandle[] Select.getTargets()
           
 InstructionHandle[] TargetLostException.getTargets()
           
 InstructionHandle InstructionList.insert(CompoundInstruction c)
          Insert a compound instruction.
 InstructionHandle InstructionList.insert(Instruction i)
          Insert an instruction at start of this list.
 InstructionHandle InstructionList.insert(Instruction i, CompoundInstruction c)
          Insert a compound instruction before instruction i.
 InstructionHandle InstructionList.insert(InstructionHandle ih, CompoundInstruction c)
          Insert a compound instruction.
 InstructionHandle InstructionList.insert(InstructionHandle ih, Instruction i)
          Insert an instruction before instruction (handle) ih contained in this list.
 InstructionHandle InstructionList.insert(InstructionHandle ih, InstructionList il)
          Insert another list before Instruction handle ih contained in this list.
 InstructionHandle InstructionList.insert(Instruction i, Instruction j)
          Insert a single instruction j before another instruction i, which must be in this list of course!
 InstructionHandle InstructionList.insert(Instruction i, InstructionList il)
          Insert another list before Instruction i contained in this list.
 InstructionHandle InstructionList.insert(InstructionList il)
          Insert another list.
 InstructionHandle JsrInstruction.physicalSuccessor()
          Returns an InstructionHandle to the physical successor of this JsrInstruction.
 

Methods in org.apache.bcel.generic with parameters of type InstructionHandle
 CodeExceptionGen MethodGen.addExceptionHandler(InstructionHandle start_pc, InstructionHandle end_pc, InstructionHandle handler_pc, ObjectType catch_type)
          Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is done.
 LineNumberGen MethodGen.addLineNumber(InstructionHandle ih, int src_line)
          Give an instruction a line number corresponding to the source code line.
 LocalVariableGen MethodGen.addLocalVariable(java.lang.String name, Type type, InstructionHandle start, InstructionHandle end)
          Adds a local variable to this method and assigns an index automatically.
 LocalVariableGen MethodGen.addLocalVariable(java.lang.String name, Type type, int slot, InstructionHandle start, InstructionHandle end)
          Adds a local variable to this method.
private  void InstructionList.append(InstructionHandle ih)
          Append an instruction to the end of this list.
 BranchHandle InstructionList.append(InstructionHandle ih, BranchInstruction i)
          Append an instruction after instruction (handle) ih contained in this list.
 InstructionHandle InstructionList.append(InstructionHandle ih, CompoundInstruction c)
          Append a compound instruction.
 InstructionHandle InstructionList.append(InstructionHandle ih, Instruction i)
          Append an instruction after instruction (handle) ih contained in this list.
 InstructionHandle InstructionList.append(InstructionHandle ih, InstructionList il)
          Append another list after instruction (handle) ih contained in this list.
 boolean InstructionList.contains(InstructionHandle i)
           
 boolean LineNumberGen.containsTarget(InstructionHandle ih)
           
 boolean Select.containsTarget(InstructionHandle ih)
           
 boolean CodeExceptionGen.containsTarget(InstructionHandle ih)
           
 boolean LocalVariableGen.containsTarget(InstructionHandle ih)
           
 boolean BranchInstruction.containsTarget(InstructionHandle ih)
           
 boolean InstructionTargeter.containsTarget(InstructionHandle ih)
           
static BranchInstruction InstructionFactory.createBranchInstruction(short opcode, InstructionHandle target)
          Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH.
 void InstructionList.delete(InstructionHandle ih)
          Remove instruction from this list.
 void InstructionList.delete(InstructionHandle from, InstructionHandle to)
          Remove instructions from instruction `from' to instruction `to' contained in this list.
private  void SWITCH.fillup(int max_gap, InstructionHandle target)
           
static InstructionHandle InstructionList.findHandle(InstructionHandle[] ihs, int[] pos, int count, int target)
          Find the target instruction (handle) that corresponds to the given target position (byte code offset).
protected  int BranchInstruction.getTargetOffset(InstructionHandle _target)
           
private  void InstructionList.insert(InstructionHandle ih)
          Insert an instruction at start of this list.
 BranchHandle InstructionList.insert(InstructionHandle ih, BranchInstruction i)
          Insert an instruction before instruction (handle) ih contained in this list.
 InstructionHandle InstructionList.insert(InstructionHandle ih, CompoundInstruction c)
          Insert a compound instruction.
 InstructionHandle InstructionList.insert(InstructionHandle ih, Instruction i)
          Insert an instruction before instruction (handle) ih contained in this list.
 InstructionHandle InstructionList.insert(InstructionHandle ih, InstructionList il)
          Insert another list before Instruction handle ih contained in this list.
 void InstructionList.move(InstructionHandle ih, InstructionHandle target)
          Move a single instruction (handle) to a new location.
 void InstructionList.move(InstructionHandle start, InstructionHandle end, InstructionHandle target)
          Take all instructions (handles) from "start" to "end" and append them after the new location "target".
(package private) static void BranchInstruction.notifyTarget(InstructionHandle old_ih, InstructionHandle new_ih, InstructionTargeter t)
          Used by BranchInstruction, LocalVariableGen, CodeExceptionGen
 void MethodGen.BranchStack.push(InstructionHandle target, int stackDepth)
           
 void InstructionList.redirectBranches(InstructionHandle old_target, InstructionHandle new_target)
          Redirect all references from old_target to new_target, i.e., update targets of branch instructions.
 void InstructionList.redirectExceptionHandlers(CodeExceptionGen[] exceptions, InstructionHandle old_target, InstructionHandle new_target)
          Redirect all references of exception handlers from old_target to new_target.
 void InstructionList.redirectLocalVariables(LocalVariableGen[] lg, InstructionHandle old_target, InstructionHandle new_target)
          Redirect all references of local variables from old_target to new_target.
private  void InstructionList.remove(InstructionHandle prev, InstructionHandle next)
          Remove from instruction `prev' to instruction `next' both contained in this list.
 void LocalVariableGen.setEnd(InstructionHandle end)
           
 void CodeExceptionGen.setEndPC(InstructionHandle end_pc)
           
 void CodeExceptionGen.setHandlerPC(InstructionHandle handler_pc)
           
 void LineNumberGen.setInstruction(InstructionHandle ih)
           
 void LocalVariableGen.setStart(InstructionHandle start)
           
 void CodeExceptionGen.setStartPC(InstructionHandle start_pc)
           
 void BranchInstruction.setTarget(InstructionHandle target)
          Set branch target
 void BranchHandle.setTarget(InstructionHandle ih)
          Pass new target to instruction.
 void Select.setTarget(int i, InstructionHandle target)
          Set branch target for `i'th case
 void LineNumberGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
           
 void Select.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
           
 void CodeExceptionGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
           
 void LocalVariableGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
           
 void BranchInstruction.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
           
 void BranchHandle.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
          Update target of instruction.
 void InstructionTargeter.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
           
private  MethodGen.BranchTarget MethodGen.BranchStack.visit(InstructionHandle target, int stackDepth)
           
private  boolean MethodGen.BranchStack.visited(InstructionHandle target)
           
 

Constructors in org.apache.bcel.generic with parameters of type InstructionHandle
BranchInstruction(short opcode, InstructionHandle target)
          Common super constructor
CodeExceptionGen(InstructionHandle start_pc, InstructionHandle end_pc, InstructionHandle handler_pc, ObjectType catch_type)
          Add an exception handler, i.e., specify region where a handler is active and an instruction where the actual handling is done.
GOTO_W(InstructionHandle target)
           
GOTO(InstructionHandle target)
           
GotoInstruction(short opcode, InstructionHandle target)
           
IF_ACMPEQ(InstructionHandle target)
           
IF_ACMPNE(InstructionHandle target)
           
IF_ICMPEQ(InstructionHandle target)
           
IF_ICMPGE(InstructionHandle target)
           
IF_ICMPGT(InstructionHandle target)
           
IF_ICMPLE(InstructionHandle target)
           
IF_ICMPLT(InstructionHandle target)
           
IF_ICMPNE(InstructionHandle target)
           
IFEQ(InstructionHandle target)
           
IFGE(InstructionHandle target)
           
IFGT(InstructionHandle target)
           
IfInstruction(short opcode, InstructionHandle target)
           
IFLE(InstructionHandle target)
           
IFLT(InstructionHandle target)
           
IFNE(InstructionHandle target)
           
IFNONNULL(InstructionHandle target)
           
IFNULL(InstructionHandle target)
           
JSR_W(InstructionHandle target)
           
JSR(InstructionHandle target)
           
JsrInstruction(short opcode, InstructionHandle target)
           
LineNumberGen(InstructionHandle ih, int src_line)
          Create a line number.
LocalVariableGen(int index, java.lang.String name, Type type, InstructionHandle start, InstructionHandle end)
          Generate a local variable that with index `index'.
LOOKUPSWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)
           
LOOKUPSWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)
           
MethodGen.BranchTarget(InstructionHandle target, int stackDepth)
           
ReturnaddressType(InstructionHandle returnTarget)
          Creates a ReturnaddressType object with a target.
Select(short opcode, int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)
          (Match, target) pairs for switch.
Select(short opcode, int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)
          (Match, target) pairs for switch.
SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target)
           
SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target)
           
SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target, int max_gap)
          Template for switch() constructs.
SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target, int max_gap)
          Template for switch() constructs.
TABLESWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)
           
TABLESWITCH(int[] match, InstructionHandle[] targets, InstructionHandle defaultTarget)
           
TargetLostException(InstructionHandle[] t, java.lang.String mesg)
           
 

Uses of InstructionHandle in org.apache.bcel.util
 

Fields in org.apache.bcel.util declared as InstructionHandle
private  InstructionHandle[] InstructionFinder.handles
           
 

Methods in org.apache.bcel.util that return InstructionHandle
private  InstructionHandle[] InstructionFinder.getMatch(int matched_from, int match_length)
           
 

Methods in org.apache.bcel.util with parameters of type InstructionHandle
 boolean InstructionFinder.CodeConstraint.checkCode(InstructionHandle[] match)
           
 java.util.Iterator InstructionFinder.search(java.lang.String pattern, InstructionHandle from)
          Start search beginning from `from'.
 java.util.Iterator InstructionFinder.search(java.lang.String pattern, InstructionHandle from, InstructionFinder.CodeConstraint constraint)
          Search for the given pattern in the instruction list.
 

Uses of InstructionHandle in org.apache.bcel.verifier.structurals
 

Fields in org.apache.bcel.verifier.structurals declared as InstructionHandle
private  InstructionHandle ExceptionHandler.handlerpc
          The InstructionHandle where the handling begins.
private  InstructionHandle ControlFlowGraph.InstructionContextImpl.instruction
          The InstructionHandle this InstructionContext is wrapped around.
private  InstructionHandle Subroutines.SubroutineImpl.theRET
          The RET instruction that leaves this subroutine.
 

Methods in org.apache.bcel.verifier.structurals that return InstructionHandle
private  InstructionHandle[] ControlFlowGraph.InstructionContextImpl._getSuccessors()
          A utility method that calculates the successors of a given InstructionHandle That means, a RET does have successors as defined here.
 InstructionHandle[] Subroutine.getEnteringJsrInstructions()
          Returns all the JsrInstructions that have the first instruction of this subroutine as their target.
 InstructionHandle[] Subroutines.SubroutineImpl.getEnteringJsrInstructions()
           
 InstructionHandle ExceptionHandler.getHandlerStart()
          Returns the InstructionHandle where the handler starts off.
 InstructionHandle InstructionContext.getInstruction()
          Returns the InstructionHandle this InstructionContext is wrapped around.
 InstructionHandle ControlFlowGraph.InstructionContextImpl.getInstruction()
           
 InstructionHandle[] Subroutine.getInstructions()
          Returns all instructions that together form this subroutine.
 InstructionHandle[] Subroutines.SubroutineImpl.getInstructions()
           
 InstructionHandle Subroutine.getLeavingRET()
          Returns the one and only RET that leaves the subroutine.
 InstructionHandle Subroutines.SubroutineImpl.getLeavingRET()
           
private static InstructionHandle[] Subroutines.getSuccessors(InstructionHandle instruction)
          A utility method that calculates the successors of a given InstructionHandle in the same subroutine.
 

Methods in org.apache.bcel.verifier.structurals with parameters of type InstructionHandle
 void Subroutines.SubroutineImpl.addEnteringJsrInstruction(InstructionHandle jsrInst)
          Adds a new JSR or JSR_W that has this subroutine as its target.
(package private)  void Subroutines.SubroutineImpl.addInstruction(InstructionHandle ih)
           
 boolean Subroutine.contains(InstructionHandle inst)
          Returns if the given InstructionHandle refers to an instruction that is part of this subroutine.
 boolean Subroutines.SubroutineImpl.contains(InstructionHandle inst)
           
 InstructionContext ControlFlowGraph.contextOf(InstructionHandle inst)
          Returns the InstructionContext of a given instruction.
 InstructionContext[] ControlFlowGraph.contextsOf(InstructionHandle[] insts)
          Returns the InstructionContext[] of a given InstructionHandle[], in a naturally ordered manner.
 ExceptionHandler[] ExceptionHandlers.getExceptionHandlers(InstructionHandle ih)
          Returns all the ExceptionHandler instances representing exception handlers that protect the instruction ih.
 Subroutine Subroutines.getSubroutine(InstructionHandle leader)
          Returns the Subroutine object associated with the given leader (that is, the first instruction of the subroutine).
private static InstructionHandle[] Subroutines.getSuccessors(InstructionHandle instruction)
          A utility method that calculates the successors of a given InstructionHandle in the same subroutine.
 boolean ControlFlowGraph.isDead(InstructionHandle i)
          Returns true, if and only if the said instruction is not reachable; that means, if it is not part of this ControlFlowGraph.
 Subroutine Subroutines.subroutineOf(InstructionHandle any)
          Returns the subroutine object associated with the given instruction.
 

Constructors in org.apache.bcel.verifier.structurals with parameters of type InstructionHandle
ControlFlowGraph.InstructionContextImpl(InstructionHandle inst)
          Creates an InstructionHandleImpl object from an InstructionHandle.
ExceptionHandler(ObjectType catch_type, InstructionHandle handler_pc)
          Leave instance creation to JustIce.