<BODY BGCOLOR="white">

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

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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

protected InstructionHandle BranchInstruction.target

protected InstructionHandle[] Select.targets

Methods in org.apache.bcel.generic that return InstructionHandle

InstructionHandle BranchInstruction.getTarget()


InstructionHandle JsrInstruction.physicalSuccessor()
          Returns an InstructionHandle to the physical successor of this JsrInstruction.

InstructionHandle LocalVariableGen.getStart()


InstructionHandle LocalVariableGen.getEnd()


InstructionHandle[] TargetLostException.getTargets()


InstructionHandle CodeExceptionGen.getStartPC()


InstructionHandle CodeExceptionGen.getEndPC()


InstructionHandle CodeExceptionGen.getHandlerPC()


InstructionHandle InstructionHandle.getNext()


InstructionHandle InstructionHandle.getPrev()


InstructionHandle BranchHandle.getTarget()


InstructionHandle[] Select.getTargets()


InstructionHandle LineNumberGen.getInstruction()


InstructionHandle ReturnaddressType.getTarget()


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.

InstructionHandle InstructionList.append(InstructionHandle ih, InstructionList il)
          Append another list after instruction (handle) ih contained in this list.

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.

InstructionHandle InstructionList.append(Instruction i)
          Append an instruction to the end of 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, CompoundInstruction c)
          Append a compound instruction, after instruction i.

InstructionHandle InstructionList.append(CompoundInstruction c)
          Append a compound instruction.

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.insert(InstructionHandle ih, InstructionList il)
          Insert another list before Instruction handle ih contained in this list.

InstructionHandle InstructionList.insert(InstructionList il)
          Insert another list.

InstructionHandle InstructionList.insert(Instruction i, InstructionList il)
          Insert another list before Instruction i contained in this list.

InstructionHandle InstructionList.insert(Instruction i)
          Insert an instruction at start of 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, CompoundInstruction c)
          Insert a compound instruction before instruction i.

InstructionHandle InstructionList.insert(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, CompoundInstruction c)
          Insert a compound instruction.

InstructionHandle[] InstructionList.getInstructionHandles()


InstructionHandle InstructionList.getStart()


InstructionHandle InstructionList.getEnd()

Methods in org.apache.bcel.generic with parameters of type InstructionHandle

protected int BranchInstruction.getTargetOffset(InstructionHandle target)


void BranchInstruction.setTarget(InstructionHandle target)
          Set branch target

void BranchInstruction.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)


boolean BranchInstruction.containsTarget(InstructionHandle ih)


void LocalVariableGen.setStart(InstructionHandle start)


void LocalVariableGen.setEnd(InstructionHandle end)


void LocalVariableGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)


boolean LocalVariableGen.containsTarget(InstructionHandle ih)


void CodeExceptionGen.setStartPC(InstructionHandle start_pc)


void CodeExceptionGen.setEndPC(InstructionHandle end_pc)


void CodeExceptionGen.setHandlerPC(InstructionHandle handler_pc)


void CodeExceptionGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)


boolean CodeExceptionGen.containsTarget(InstructionHandle ih)


boolean InstructionTargeter.containsTarget(InstructionHandle ih)


void InstructionTargeter.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)


void BranchHandle.setTarget(InstructionHandle ih)
          Pass new target to instruction.

void BranchHandle.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)
          Update target of instruction.

LocalVariableGen MethodGen.addLocalVariable(java.lang.String name, Type type, int slot, InstructionHandle start, InstructionHandle end)
          Adds a local variable to this method.

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.

LineNumberGen MethodGen.addLineNumber(InstructionHandle ih, int src_line)
          Give an instruction a line number corresponding to the source code line.

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.

void Select.setTarget(int i, InstructionHandle target)
          Set branch target for `i'th case

void Select.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)


boolean Select.containsTarget(InstructionHandle ih)


boolean LineNumberGen.containsTarget(InstructionHandle ih)


void LineNumberGen.updateTarget(InstructionHandle old_ih, InstructionHandle new_ih)


void LineNumberGen.setInstruction(InstructionHandle ih)


static BranchInstruction InstructionFactory.createBranchInstruction(short opcode, InstructionHandle target)
          Create branch instruction by given opcode, except LOOKUPSWITCH and TABLESWITCH.

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.append(InstructionHandle ih, InstructionList il)
          Append another list 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.

BranchHandle InstructionList.append(InstructionHandle ih, BranchInstruction i)
          Append an instruction after 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(InstructionHandle ih, Instruction i)
          Insert an instruction before instruction (handle) ih contained in this list.

InstructionHandle InstructionList.insert(InstructionHandle ih, CompoundInstruction c)
          Insert a compound instruction.

BranchHandle InstructionList.insert(InstructionHandle ih, BranchInstruction i)
          Insert an instruction before instruction (handle) ih contained in this list.

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".

void InstructionList.move(InstructionHandle ih, InstructionHandle target)
          Move a single instruction (handle) to a new location.

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.

boolean InstructionList.contains(InstructionHandle i)


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.redirectLocalVariables(LocalVariableGen[] lg, InstructionHandle old_target, InstructionHandle new_target)
          Redirect all references of local variables from old_target to new_target.

void InstructionList.redirectExceptionHandlers(CodeExceptionGen[] exceptions, InstructionHandle old_target, InstructionHandle new_target)
          Redirect all references of exception handlers from old_target to new_target.

Constructors in org.apache.bcel.generic with parameters of type InstructionHandle

BranchInstruction(short opcode, InstructionHandle target)
          Common super constructor

JSR_W(InstructionHandle target)


LocalVariableGen(int index, java.lang.String name, Type type, InstructionHandle start, InstructionHandle end)
          Generate a local variable that with index `index'.

IfInstruction(short opcode, InstructionHandle target)


IFGE(InstructionHandle target)


IFNONNULL(InstructionHandle target)


IFEQ(InstructionHandle target)


SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target, int max_gap)
          Template for switch() constructs.

SWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target)


IF_ACMPEQ(InstructionHandle target)


GOTO(InstructionHandle target)


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.

IF_ICMPLT(InstructionHandle target)


IFNULL(InstructionHandle target)


IF_ICMPNE(InstructionHandle target)


IF_ICMPGT(InstructionHandle target)


IF_ICMPLE(InstructionHandle target)


IF_ICMPGE(InstructionHandle target)


TABLESWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target)


LineNumberGen(InstructionHandle ih, int src_line)
          Create a line number.

GOTO_W(InstructionHandle target)


LOOKUPSWITCH(int[] match, InstructionHandle[] targets, InstructionHandle target)


IFLT(InstructionHandle target)


ReturnaddressType(InstructionHandle returnTarget)
          Creates a ReturnaddressType object with a target.

IFNE(InstructionHandle target)


IF_ICMPEQ(InstructionHandle target)


IF_ACMPNE(InstructionHandle target)


IFGT(InstructionHandle target)


IFLE(InstructionHandle target)


JSR(InstructionHandle target)

Uses of InstructionHandle in org.apache.bcel.util

Methods in org.apache.bcel.util with parameters of type InstructionHandle

java.util.Iterator InstructionFinder.search(java.lang.String pattern, InstructionHandle from, InstructionFinder.CodeConstraint constraint)
          Search for the given pattern in the instruction list.

java.util.Iterator InstructionFinder.search(java.lang.String pattern, InstructionHandle from)
          Start search beginning from `from'.

boolean InstructionFinder.CodeConstraint.checkCode(InstructionHandle[] match)

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

Methods in org.apache.bcel.verifier.structurals that return InstructionHandle

InstructionHandle ExceptionHandler.getHandlerStart()
          Returns the InstructionHandle where the handler starts off.

InstructionHandle[] Subroutine.getEnteringJsrInstructions()
          Returns all the JsrInstructions that have the first instruction of this subroutine as their target.

InstructionHandle Subroutine.getLeavingRET()
          Returns the one and only RET that leaves the subroutine.

InstructionHandle[] Subroutine.getInstructions()
          Returns all instructions that together form this subroutine.

InstructionHandle InstructionContext.getInstruction()
          Returns the InstructionHandle this InstructionContext is wrapped around.

Methods in org.apache.bcel.verifier.structurals with parameters of type InstructionHandle

Subroutine Subroutines.getSubroutine(InstructionHandle leader)
          Returns the Subroutine object associated with the given leader (that is, the first instruction of the subroutine).

Subroutine Subroutines.subroutineOf(InstructionHandle any)
          Returns the subroutine object associated with the given instruction.

ExceptionHandler[] ExceptionHandlers.getExceptionHandlers(InstructionHandle ih)
          Returns all the ExceptionHandler instances representing exception handlers that protect the instruction ih.

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.

boolean ControlFlowGraph.isDead(InstructionHandle i)
          Returns true, if and only if the said instruction is not reachable; that means, if it not part of this ControlFlowGraph.