Lines Matching refs:instruction
41 * The actual instruction
43 protected Instruction instruction;
46 * The index of the instruction, where the first instruction in the method is at index 0, and so on
61 * This contains the register types *before* the instruction has executed
66 * This contains the register types *after* the instruction has executed
71 * When deodexing, we might need to deodex this instruction multiple times, when we merge in new register
72 * information. When this happens, we need to restore the original (odexed) instruction, so we can deodex it again
77 * An analyzed instruction's "deadness" is set during analysis (i.e. MethodAnalyzer.analyzer()). A dead instruction
79 * code path that can ever reach it, or code that follows an odexed instruction that can't be deodexed.
83 public AnalyzedInstruction(Instruction instruction, int instructionIndex, int registerCount) {
84 this.instruction = instruction;
85 this.originalInstruction = instruction;
116 protected void setDeodexedInstruction(Instruction instruction) {
118 this.instruction = instruction;
123 instruction = originalInstruction;
135 return instruction;
147 * Is this instruction a "beginning instruction". A beginning instruction is defined to be an instruction
148 * that can be the first successfully executed instruction in the method. The first instruction is always a
149 * beginning instruction. If the first instruction can throw an exception, and is covered by a try block, then
150 * the first instruction of any exception handler for that try block is also a beginning instruction. And likewise,
151 * if any of those instructions can throw an exception and are covered by try blocks, the first instruction of the
152 * corresponding exception handler is a beginning instruction, etc.
154 * To determine this, we simply check if the first predecessor is the fake "StartOfMethod" instruction, which has
155 * an instruction index of -1.
156 * @return a boolean value indicating whether this instruction is a beginning instruction
159 //if this instruction has no predecessors, it is either the fake "StartOfMethod" instruction or it is an
160 //unreachable instruction.
172 * Merges the given register type into the specified pre-instruction register, and also sets the post-instruction
173 * register type accordingly if it isn't a destination register for this instruction
176 * @returns true If the post-instruction register type was changed. This might be false if either the specified
177 * register is a destination register for this instruction, or if the pre-instruction register type didn't change
203 * Iterates over the predecessors of this instruction, and merges all the post-instruction register types for the
206 * @return The register type resulting from merging the post-instruction register types from all predecessors
219 * Sets the "post-instruction" register type as indicated.
221 * @param registerType The "post-instruction" register type
222 * @returns true if the given register type is different than the existing post-instruction register type
239 if (instruction == null || !instruction.opcode.canInitializeReference()) {
245 InstructionWithReference instruction = (InstructionWithReference)this.instruction;
246 Item item = instruction.getReferencedItem();
258 return instruction.opcode.setsRegister();
262 return instruction.opcode.setsWideRegister();
267 //instruction, but becomes an initialized reference once the <init> method is called. So even though invoke
273 if (instruction instanceof FiveRegisterInstruction) {
274 destinationRegister = ((FiveRegisterInstruction)instruction).getRegisterD();
276 assert instruction instanceof RegisterRangeInstruction;
277 RegisterRangeInstruction rangeInstruction = (RegisterRangeInstruction)instruction;
313 if (!this.instruction.opcode.setsRegister()) {
314 throw new ExceptionWithContext("Cannot call getDestinationRegister() for an instruction that doesn't " +
317 return ((SingleRegisterInstruction)instruction).getRegisterA();