| /dalvik/vm/mterp/mips/ |
| unflop.S | 4 * specifies an instruction that performs "result = op a0".
5 * This could be a MIPS instruction or a function call.
31 GOTO_OPCODE(t1) # jump to next instruction
|
| unopWide.S | 4 * specifies an instruction that performs "result = op a0/a1".
5 * This could be MIPS instruction or a function call.
20 GOTO_OPCODE(t0) # jump to next instruction
|
| /external/proguard/src/proguard/classfile/util/ |
| InstructionSequenceMatcher.java | 27 import proguard.classfile.instruction.*;
28 import proguard.classfile.instruction.visitor.InstructionVisitor;
31 * This InstructionVisitor checks whether a given pattern instruction sequence
33 * instruction sequence can be wildcards that are matched.
61 private final Instruction[] patternInstructions;
80 * instruction.
81 * @param patternInstructions the pattern instruction sequence.
84 Instruction[] patternInstructions)
95 * Starts matching from the first instruction again next time.
187 Instruction patternInstruction = patternInstructions[patternInstructionIndex]
[all...] |
| /external/proguard/src/proguard/optimize/peephole/ |
| GotoGotoReplacer.java | 26 import proguard.classfile.instruction.*;
27 import proguard.classfile.instruction.visitor.InstructionVisitor;
72 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
77 // Check if the instruction is an unconditional goto instruction.
82 // Check if the goto instruction points to another simple goto
83 // instruction.
91 Instruction targetInstruction =
96 // Simplify the goto instruction
[all...] |
| /external/llvm/include/llvm/MC/ |
| MCInstrDesc.h | 1 //===-- llvm/MC/MCInstrDesc.h - Instruction Descriptors -*- C++ -*-===//
55 /// instruction, indicating the register class for register operands, etc.
81 /// the predicate operand that controls an isPredicable() instruction.
91 // Machine Instruction Flags and Description
131 /// MCInstrDesc - Describe properties that are true of each instruction in the
134 /// for each target instruction class, and the MachineInstr class points to
169 /// that the machine instruction may include implicit register def/uses as
183 /// \brief Return flags of this instruction.
186 /// \brief Return true if this instruction can have a variable number of
194 /// \brief Set if this instruction has an optional definition, e.g
[all...] |
| /dalvik/dx/src/com/android/dx/dex/code/ |
| CodeAddress.java | 23 * Pseudo-instruction which is used to track an address within a code
30 /** If this address should bind closely to the following real instruction */
49 * real instruction.
76 * (non-zero-length) instruction.
78 * When a prefix is added to an instruction (for example, to move a value
80 * {@code CodeAddress} will point to the prefix, or to the instruction
83 * If bindsClosely is true, the address will point to the instruction
86 * @return true if this address binds closely to the next real instruction
|
| /dalvik/dx/tests/074-dex-form35c-edge-case/ |
| info.txt | 2 an edge case of instruction format 35c works, where a reference
4 the instruction has to be rewritten to use a different format.
|
| /external/llvm/test/Transforms/SCCP/ |
| apint-basictest2.ll | 1 ; This is a basic sanity check for constant propagation. The add instruction
2 ; and phi instruction should be eliminated.
|
| /external/smali/dexlib/src/main/java/org/jf/dexlib/Code/Format/ |
| UnresolvedOdexInstruction.java | 31 import org.jf.dexlib.Code.Instruction;
35 * This represents a "fixed" odexed instruction, where the object register is always null and so the correct type
36 * can't be determined. Typically, these are replaced by an equivalent instruction that would have the same
39 public class UnresolvedOdexInstruction extends Instruction {
40 public final Instruction OriginalInstruction;
41 //the register number that holds the (null) reference type that the instruction operates on
44 public UnresolvedOdexInstruction(Instruction originalInstruction, int objectRegisterNumber) {
51 throw new RuntimeException("Cannot rewrite an instruction that couldn't be deodexed");
|
| /external/smali/dexlib/src/main/java/org/jf/dexlib/Code/ |
| Instruction.java | 35 public abstract class Instruction {
39 * Returns the size of this instruction in code blocks, assuming the instruction is located at the given address
40 * @param codeAddress the code address where the instruction is located
41 * @return The size of this instruction in code blocks
47 protected Instruction(Opcode opcode) {
63 opcode.name + " instruction");
69 public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex);
|
| /external/llvm/include/llvm/IR/ |
| Instruction.h | 1 //===-- llvm/Instruction.h - Instruction class definition -------*- C++ -*-===//
10 // This file contains the declaration of the Instruction class, which is the
31 class Instruction : public User, public ilist_node<Instruction> {
32 void operator=(const Instruction &) LLVM_DELETED_FUNCTION;
33 Instruction(const Instruction &) LLVM_DELETED_FUNCTION;
40 /// indicates whether this instruction has metadata attached to it or not.
45 ~Instruction();
[all...] |
| Operator.h | 21 #include "llvm/IR/Instruction.h"
49 /// getOpcode - Return the opcode for this Instruction or ConstantExpr.
52 if (const Instruction *I = dyn_cast<Instruction>(this))
57 /// getOpcode - If V is an Instruction or ConstantExpr, return its
61 if (const Instruction *I = dyn_cast<Instruction>(V))
65 return Instruction::UserOp1;
68 static inline bool classof(const Instruction *) { return true; }
71 return isa<Instruction>(V) || isa<ConstantExpr>(V)
[all...] |
| BasicBlock.h | 19 #include "llvm/IR/Instruction.h"
31 template<> struct ilist_traits<Instruction>
32 : public SymbolTableListTraits<Instruction, BasicBlock> {
38 Instruction *createSentinel() const {
46 return static_cast<Instruction*>(&Sentinel);
48 static void destroySentinel(Instruction*) {}
50 Instruction *provideInitialHead() const { return createSentinel(); }
51 Instruction *ensureHead(Instruction*) const { return createSentinel(); }
52 static void noteHead(Instruction*, Instruction*) {
[all...] |
| /art/runtime/ |
| common_throws.cc | 330 const Instruction* instr = Instruction::At(&code->insns_[throw_dex_pc]);
332 case Instruction::INVOKE_DIRECT:
335 case Instruction::INVOKE_DIRECT_RANGE:
338 case Instruction::INVOKE_VIRTUAL:
341 case Instruction::INVOKE_VIRTUAL_RANGE:
344 case Instruction::INVOKE_INTERFACE:
347 case Instruction::INVOKE_INTERFACE_RANGE:
350 case Instruction::INVOKE_VIRTUAL_QUICK:
351 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK:
[all...] |
| /external/smali/baksmali/src/main/java/org/jf/baksmali/Adaptors/ |
| MethodDefinition.java | 41 import org.jf.dexlib.Code.Instruction;
71 Instruction[] instructions = encodedMethod.codeItem.getInstructions();
79 Instruction instruction = instructions[i]; local
80 if (instruction.opcode == Opcode.PACKED_SWITCH) {
83 ((OffsetInstruction)instruction).getTargetAddressOffset(),
85 } else if (instruction.opcode == Opcode.SPARSE_SWITCH) {
88 ((OffsetInstruction)instruction).getTargetAddressOffset(),
92 currentCodeAddress += instruction.getSize(currentCodeAddress);
243 Instruction[] instructions = encodedMethod.codeItem.getInstructions()
339 Instruction instruction = instructions[i]; local
411 AnalyzedInstruction instruction = instructions.get(i); local
[all...] |
| /external/chromium_org/third_party/mesa/src/src/gallium/drivers/nv50/codegen/ |
| nv50_ir_build_util.h | 41 inline void setPosition(Instruction *, bool after);
45 inline void insert(Instruction *);
46 inline void remove(Instruction *i) { assert(i->bb == bb); bb->remove(i); }
52 inline Instruction *mkOp(operation, DataType, Value *);
53 Instruction *mkOp1(operation, DataType, Value *, Value *);
54 Instruction *mkOp2(operation, DataType, Value *, Value *, Value *);
55 Instruction *mkOp3(operation, DataType, Value *, Value *, Value *, Value *);
62 Instruction *mkStore(operation, DataType, Symbol *, Value *ptr, Value *val);
64 Instruction *mkMov(Value *, Value *, DataType = TYPE_U32);
65 Instruction *mkMovToReg(int id, Value *)
[all...] |
| /external/mesa3d/src/gallium/drivers/nv50/codegen/ |
| nv50_ir_build_util.h | 41 inline void setPosition(Instruction *, bool after);
45 inline void insert(Instruction *);
46 inline void remove(Instruction *i) { assert(i->bb == bb); bb->remove(i); }
52 inline Instruction *mkOp(operation, DataType, Value *);
53 Instruction *mkOp1(operation, DataType, Value *, Value *);
54 Instruction *mkOp2(operation, DataType, Value *, Value *, Value *);
55 Instruction *mkOp3(operation, DataType, Value *, Value *, Value *, Value *);
62 Instruction *mkStore(operation, DataType, Symbol *, Value *ptr, Value *val);
64 Instruction *mkMov(Value *, Value *, DataType = TYPE_U32);
65 Instruction *mkMovToReg(int id, Value *)
[all...] |
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineVectorOps.cpp | 34 Instruction *I = dyn_cast<Instruction>(V);
39 if (I->getOpcode() == Instruction::InsertElement && isConstant &&
42 if (I->getOpcode() == Instruction::Load && I->hasOneUse())
111 Instruction *InstCombiner::scalarizePHI(ExtractElementInst &EI, PHINode *PN) {
120 Instruction *PHIUser = dyn_cast<Instruction>(*iu);
121 if (PHIUser == cast<Instruction>(&EI))
122 PHIUser = cast<Instruction>(*(++iu));
156 Instruction *newEI = ExtractElementInst::Create(PHIInVal, Elt, "")
[all...] |
| /art/compiler/sea_ir/types/ |
| type_inference_visitor.cc | 38 void TypeInferenceVisitor::Visit(UnnamedConstInstructionNode* instruction) {
42 void TypeInferenceVisitor::Visit(PhiInstructionNode* instruction) {
43 std::vector<const Type*> types_to_merge = GetOperandTypes(instruction);
48 void TypeInferenceVisitor::Visit(AddIntInstructionNode* instruction) {
49 std::vector<const Type*> operand_types = GetOperandTypes(instruction);
59 void TypeInferenceVisitor::Visit(MoveResultInstructionNode* instruction) {
60 std::vector<const Type*> operand_types = GetOperandTypes(instruction);
65 void TypeInferenceVisitor::Visit(InvokeStaticInstructionNode* instruction) {
66 FunctionTypeInfo fti(graph_, instruction, type_cache_);
72 InstructionNode* instruction) const
[all...] |
| /external/llvm/docs/HistoricalNotes/ |
| 2002-05-12-InstListChange.txt | 11 instruction list (returned by getInstList()) that is a ValueHolder of
15 To add or remove an instruction from a basic block, we need to get an
16 iterator to an instruction, which, given just an Instruction*, requires a
17 linear search of the basic block the instruction is contained in... just
18 to insert an instruction before another instruction, or to delete an
19 instruction! This complicates algorithms that should be very simple (like
35 instruction list (which can be found by grep'ing for getInstList()) will
44 for (Instruction *I = BB->front(); I; I = I->getNext()) ..
[all...] |
| /external/proguard/src/proguard/classfile/instruction/ |
| LookUpSwitchInstruction.java | 21 package proguard.classfile.instruction;
25 import proguard.classfile.instruction.visitor.InstructionVisitor;
28 * This Instruction represents a simple instruction without variable arguments
60 * Copies the given instruction into this instruction.
61 * @param lookUpSwitchInstruction the instruction to be copied.
62 * @return this instruction.
75 // Implementations for Instruction.
77 public Instruction shrink(
[all...] |
| TableSwitchInstruction.java | 21 package proguard.classfile.instruction;
25 import proguard.classfile.instruction.visitor.InstructionVisitor;
28 * This Instruction represents a simple instruction without variable arguments
63 * Copies the given instruction into this instruction.
64 * @param tableSwitchInstruction the instruction to be copied.
65 * @return this instruction.
79 // Implementations for Instruction.
81 public Instruction shrink(
[all...] |
| /art/compiler/dex/ |
| mir_graph.cc | 28 const Instruction::Code opcodes[MAX_PATTERN_LEN];
33 {{Instruction::RETURN_VOID}, kNullMethod},
34 {{Instruction::CONST, Instruction::RETURN}, kConstFunction},
35 {{Instruction::CONST_4, Instruction::RETURN}, kConstFunction},
36 {{Instruction::CONST_4, Instruction::RETURN_OBJECT}, kConstFunction},
37 {{Instruction::CONST_16, Instruction::RETURN}, kConstFunction}
123 const Instruction* instruction = Instruction::At(code_ptr); local
[all...] |
| /dalvik/dx/src/com/android/dx/rop/ |
| package-info.java | 27 * the dex instruction set.<p>
40 * and potentially local variable information as well for instruction sources
67 * the control flow graph or the instruction list results in replacement
78 * instruction, an instruction whose opcode has a {@link Rop#getBranchingness
80 * instructions may only be the final instruction in any basic block. If
97 * the primary successor) is a property of the final instruction of the basic
100 * {@link ThrowingInsn#getCatches} instruction's catches list, with the
105 * instruction where a catch block exists inside the current method for that
114 * An instruction that may throw an exception may not specify a result. Thi
[all...] |
| /external/chromium_org/third_party/mesa/src/src/gallium/auxiliary/tgsi/ |
| tgsi_build.c | 578 * instruction
584 struct tgsi_instruction instruction; local
586 instruction.Type = TGSI_TOKEN_TYPE_INSTRUCTION;
587 instruction.NrTokens = 0;
588 instruction.Opcode = TGSI_OPCODE_MOV;
589 instruction.Saturate = TGSI_SAT_NONE;
590 instruction.Predicate = 0;
591 instruction.NumDstRegs = 1;
592 instruction.NumSrcRegs = 1;
593 instruction.Label = 0
608 struct tgsi_instruction instruction; local
971 struct tgsi_instruction *instruction; local
[all...] |
