|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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 |
LocalVariableGen.end
|
private InstructionHandle |
InstructionList.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 |
LocalVariableGen.start
|
private InstructionHandle |
InstructionList.start
|
private InstructionHandle |
CodeExceptionGen.start_pc
|
protected InstructionHandle |
BranchInstruction.target
|
(package private) InstructionHandle |
MethodGen.BranchTarget.target
|
private InstructionHandle[] |
TargetLostException.targets
|
protected InstructionHandle[] |
Select.targets
|
private InstructionHandle[] |
SWITCH.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 |
LocalVariableGen.getEnd()
|
InstructionHandle |
InstructionList.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 |
LocalVariableGen.getStart()
|
InstructionHandle |
InstructionList.getStart()
|
InstructionHandle |
CodeExceptionGen.getStartPC()
|
InstructionHandle |
BranchHandle.getTarget()
|
InstructionHandle |
BranchInstruction.getTarget()
|
InstructionHandle |
ReturnaddressType.getTarget()
|
InstructionHandle[] |
TargetLostException.getTargets()
|
InstructionHandle[] |
Select.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 |
Select.containsTarget(InstructionHandle ih)
|
boolean |
LocalVariableGen.containsTarget(InstructionHandle ih)
|
boolean |
LineNumberGen.containsTarget(InstructionHandle ih)
|
boolean |
BranchInstruction.containsTarget(InstructionHandle ih)
|
boolean |
InstructionTargeter.containsTarget(InstructionHandle ih)
|
boolean |
CodeExceptionGen.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 |
BranchHandle.setTarget(InstructionHandle ih)
Pass new target to instruction. |
void |
BranchInstruction.setTarget(InstructionHandle target)
Set branch target |
void |
Select.setTarget(int i,
InstructionHandle target)
Set branch target for `i'th case |
void |
Select.updateTarget(InstructionHandle old_ih,
InstructionHandle new_ih)
|
void |
LocalVariableGen.updateTarget(InstructionHandle old_ih,
InstructionHandle new_ih)
|
void |
LineNumberGen.updateTarget(InstructionHandle old_ih,
InstructionHandle new_ih)
|
void |
BranchHandle.updateTarget(InstructionHandle old_ih,
InstructionHandle new_ih)
Update target of instruction. |
void |
BranchInstruction.updateTarget(InstructionHandle old_ih,
InstructionHandle new_ih)
|
void |
InstructionTargeter.updateTarget(InstructionHandle old_ih,
InstructionHandle new_ih)
|
void |
CodeExceptionGen.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[] |
Subroutines.SubroutineImpl.getEnteringJsrInstructions()
|
InstructionHandle[] |
Subroutine.getEnteringJsrInstructions()
Returns all the JsrInstructions that have the first instruction of this subroutine as their target. |
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[] |
Subroutines.SubroutineImpl.getInstructions()
|
InstructionHandle[] |
Subroutine.getInstructions()
Returns all instructions that together form this subroutine. |
InstructionHandle |
Subroutines.SubroutineImpl.getLeavingRET()
|
InstructionHandle |
Subroutine.getLeavingRET()
Returns the one and only RET that leaves the subroutine. |
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 |
Subroutines.SubroutineImpl.contains(InstructionHandle inst)
|
boolean |
Subroutine.contains(InstructionHandle inst)
Returns if the given InstructionHandle refers to an instruction that is part of this subroutine. |
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |