Package org.apache.bcel.util
Class InstructionFinder
java.lang.Object
org.apache.bcel.util.InstructionFinder
InstructionFinder is a tool to search for given instructions patterns, i.e., match sequences of instructions in an
instruction list via regular expressions. This can be used, e.g., in order to implement a peep hole optimizer that
looks for code patterns and replaces them with faster equivalents.
This class internally uses the java.util.regex package to search for regular expressions. A typical application would look like this:
InstructionFinder f = new InstructionFinder(il); String pat = "IfInstruction ICONST_0 GOTO ICONST_1 NOP (IFEQ|IFNE)"; for (Iterator i = f.search(pat, constraint); i.hasNext(); ) { InstructionHandle[] match = (InstructionHandle[])i.next(); ... il.delete(match[1], match[5]); ... }
- See Also:
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionstatic interface
Code patterns found may be checked using an additional user-defined constraint object whether they really match the needed criterion. -
Field Summary
FieldsModifier and TypeFieldDescriptionprivate InstructionHandle[]
private final InstructionList
private String
private static final int
private static final int
-
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionprivate static String
compilePattern
(String pattern) Replace symbolic names of instructions with the appropriate character and remove all white space from string.final InstructionList
private InstructionHandle[]
getMatch
(int matchedFrom, int matchLength) private static char
makeChar
(short opcode) Convert opcode number to char.private static String
Map symbolic instruction names like "getfield" to a single character.private static String
precompile
(short from, short to, short extra) final void
reread()
Reread the instruction list, e.g., after you've altered the list upon a match.final Iterator
<InstructionHandle[]> Start search beginning from the start of the given instruction list.final Iterator
<InstructionHandle[]> search
(String pattern, InstructionHandle from) Start search beginning from 'from'.final Iterator
<InstructionHandle[]> search
(String pattern, InstructionHandle from, InstructionFinder.CodeConstraint constraint) Search for the given pattern in the instruction list.final Iterator
<InstructionHandle[]> search
(String pattern, InstructionFinder.CodeConstraint constraint) Start search beginning from the start of the given instruction list.
-
Field Details
-
OFFSET
private static final int OFFSET- See Also:
-
NO_OPCODES
private static final int NO_OPCODES- See Also:
-
map
-
il
-
ilString
-
handles
-
-
Constructor Details
-
InstructionFinder
- Parameters:
il
- instruction list to search for given patterns
-
-
Method Details
-
compilePattern
Replace symbolic names of instructions with the appropriate character and remove all white space from string. Meta characters such as +, * are ignored.- Parameters:
pattern
- The pattern to compile- Returns:
- translated regular expression string
-
makeChar
private static char makeChar(short opcode) Convert opcode number to char. -
mapName
Map symbolic instruction names like "getfield" to a single character.- Parameters:
pattern
- instruction pattern in lower case- Returns:
- encoded string for a pattern such as "BranchInstruction".
-
precompile
-
getInstructionList
- Returns:
- the inquired instruction list
-
getMatch
- Returns:
- the matched piece of code as an array of instruction (handles)
-
reread
public final void reread()Reread the instruction list, e.g., after you've altered the list upon a match. -
search
Start search beginning from the start of the given instruction list.- Parameters:
pattern
- the instruction pattern to search for, where case is ignored- Returns:
- iterator of matches where e.nextElement() returns an array of instruction handles describing the matched area
-
search
public final Iterator<InstructionHandle[]> search(String pattern, InstructionFinder.CodeConstraint constraint) Start search beginning from the start of the given instruction list. Check found matches with the constraint object.- Parameters:
pattern
- the instruction pattern to search for, case is ignoredconstraint
- constraints to be checked on matching code- Returns:
- instruction handle or 'null' if the match failed
-
search
Start search beginning from 'from'.- Parameters:
pattern
- the instruction pattern to search for, where case is ignoredfrom
- where to start the search in the instruction list- Returns:
- iterator of matches where e.nextElement() returns an array of instruction handles describing the matched area
-
search
public final Iterator<InstructionHandle[]> search(String pattern, InstructionHandle from, InstructionFinder.CodeConstraint constraint) Search for the given pattern in the instruction list. You can search for any valid opcode via its symbolic name, e.g. "istore". You can also use a super class or an interface name to match a whole set of instructions, e.g. "BranchInstruction" or "LoadInstruction". "istore" is also an alias for all "istore_x" instructions. Additional aliases are "if" for "ifxx", "if_icmp" for "if_icmpxx", "if_acmp" for "if_acmpxx". Consecutive instruction names must be separated by white space which will be removed during the compilation of the pattern. For the rest the usual pattern matching rules for regular expressions apply.Example pattern:
search("BranchInstruction NOP ((IfInstruction|GOTO)+ ISTORE Instruction)*");
If you alter the instruction list upon a match such that other matching areas are affected, you should call reread() to update the finder and call search() again, because the matches are cached.
- Parameters:
pattern
- the instruction pattern to search for, where case is ignoredfrom
- where to start the search in the instruction listconstraint
- optional CodeConstraint to check the found code pattern for user-defined constraints- Returns:
- iterator of matches where e.nextElement() returns an array of instruction handles describing the matched area
-