| /external/llvm/lib/AsmParser/ |
| LLParser.h | 34 class Instruction;
94 // Instruction metadata resolution. Each instruction can have a list of
99 // instruction metadata kinds, such as dbg, get stored in the IR in an
108 DenseMap<Instruction*, std::vector<MDRef> > ForwardRefInstMetadata;
287 /// SetInstName - After an instruction is parsed and inserted into its
290 Instruction *Inst);
351 bool ParseInstructionMetadata(Instruction *Inst, PerFunctionState *PFS);
367 // Instruction Parsing. Each instruction parsing routine can return with
[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/chromium_org/sandbox/linux/seccomp-bpf/ |
| codegen_unittest.cc | 24 void FindBranchTargets(const Instruction& instructions,
29 BasicBlock *CutGraphIntoBasicBlocks(Instruction *insns,
44 Instruction *SampleProgramOneInstruction(CodeGen *codegen, int *flags) {
52 Instruction *SampleProgramSimpleBranch(CodeGen *codegen, int *flags) {
65 Instruction *SampleProgramAtypicalBranch(CodeGen *codegen, int *flags) {
75 Instruction *ret =
81 Instruction *SampleProgramComplex(CodeGen *codegen, int *flags) {
93 Instruction *insn0 = codegen->MakeInstruction(BPF_LD+BPF_W+BPF_ABS, 42);
99 Instruction *insn1 = codegen->MakeInstruction(BPF_JMP+BPF_JA, 0, insn0);
104 Instruction *insn2 = codegen->MakeInstruction(BPF_RET+BPF_K, ErrorCode(42))
[all...] |
| codegen.cc | 13 void TraverseRecursively(std::set<playground2::Instruction *> *visited,
14 playground2::Instruction *instruction) {
15 if (visited->find(instruction) == visited->end()) {
16 visited->insert(instruction);
17 switch (BPF_CLASS(instruction->code)) {
19 if (BPF_OP(instruction->code) != BPF_JA) {
20 TraverseRecursively(visited, instruction->jf_ptr);
22 TraverseRecursively(visited, instruction->jt_ptr);
27 TraverseRecursively(visited, instruction->next)
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| Reassociate.cpp | 64 static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) {
66 dbgs() << Instruction::getOpcodeName(I->getOpcode()) << " "
163 SetVector<AssertingVH<Instruction> > RedoInsts;
183 Value *OptimizeAdd(Instruction *I, SmallVectorImpl<ValueEntry> &Ops);
184 Value *OptimizeXor(Instruction *I, SmallVectorImpl<ValueEntry> &Ops);
185 bool CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, APInt &ConstOpnd,
187 bool CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, XorOpnd *Opnd2,
195 void EraseInst(Instruction *I);
196 void OptimizeInst(Instruction *I);
203 Instruction *I = dyn_cast<Instruction>(V)
[all...] |
| DCE.cpp | 22 #include "llvm/IR/Instruction.h"
45 Instruction *Inst = DI++;
63 "Dead Instruction Elimination", false, false)
95 std::vector<Instruction*> WorkList;
105 Instruction *I = WorkList.back();
108 if (isInstructionTriviallyDead(I, TLI)) { // If the instruction is dead.
109 // Loop over all of the values that the instruction uses, if there are
114 if (Instruction *Used = dyn_cast<Instruction>(*OI))
117 // Remove the instruction
[all...] |
| CorrelatedValuePropagation.cpp | 41 bool processMemAccess(Instruction *I);
140 bool CorrelatedValuePropagation::processMemAccess(Instruction *I) {
164 if (isa<Instruction>(Op0) &&
165 cast<Instruction>(Op0)->getParent() == C->getParent())
198 /// processSwitch - Simplify a switch instruction by removing cases which can
211 if (isa<Instruction>(Cond) && cast<Instruction>(Cond)->getParent() == BB)
291 Instruction *II = BI++;
293 case Instruction::Select:
296 case Instruction::PHI
[all...] |
| Sink.cpp | 57 bool SinkInstruction(Instruction *I, SmallPtrSet<Instruction *, 8> &Stores);
58 bool AllUsesDominatedByBlock(Instruction *Inst, BasicBlock *BB) const;
59 bool IsAcceptableTarget(Instruction *Inst, BasicBlock *SuccToSinkTo) const;
74 bool Sinking::AllUsesDominatedByBlock(Instruction *Inst,
83 Instruction *UseInst = cast<Instruction>(*I);
134 SmallPtrSet<Instruction *, 8> Stores;
136 Instruction *Inst = I; // The instruction to sink
[all...] |
| /art/runtime/interpreter/ |
| interpreter.cc | 421 const Instruction* inst, JValue* result) NO_THREAD_SAFETY_ANALYSIS;
425 const Instruction* inst, JValue* result) {
528 const Instruction* inst, JValue* result)
533 const Instruction* inst, JValue* result) {
627 const Instruction* inst)
632 const Instruction* inst) {
685 const Instruction* inst)
690 const Instruction* inst) {
[all...] |
| /art/compiler/dex/quick/ |
| gen_common.cc | 85 void Mir2Lir::GenCompareAndBranch(Instruction::Code opcode, RegLocation rl_src1,
90 case Instruction::IF_EQ:
93 case Instruction::IF_NE:
96 case Instruction::IF_LT:
99 case Instruction::IF_GE:
102 case Instruction::IF_GT:
105 case Instruction::IF_LE:
139 void Mir2Lir::GenCompareZeroAndBranch(Instruction::Code opcode, RegLocation rl_src, LIR* taken,
144 case Instruction::IF_EQZ:
147 case Instruction::IF_NEZ
[all...] |
| /external/llvm/lib/Analysis/ |
| PHITransAddr.cpp | 25 static bool CanPHITrans(Instruction *Inst) {
34 if (Inst->getOpcode() == Instruction::Add &&
58 SmallVectorImpl<Instruction*> &InstInputs) {
59 // If this is a non-instruction value, there is nothing to do.
60 Instruction *I = dyn_cast<Instruction>(Expr);
63 // If it's an instruction, it is either in Tmp or its operands recursively
65 SmallVectorImpl<Instruction*>::iterator Entry =
75 errs() << "Non phi translatable instruction found in PHITransAddr:\n";
81 // Validate the operands of the instruction
[all...] |
| /external/v8/src/mips/ |
| simulator-mips.h | 185 // instruction.
251 void Format(Instruction* instr, const char* format);
259 inline uint16_t ReadHU(int32_t addr, Instruction* instr);
260 inline int16_t ReadH(int32_t addr, Instruction* instr);
262 inline void WriteH(int32_t addr, uint16_t value, Instruction* instr);
263 inline void WriteH(int32_t addr, int16_t value, Instruction* instr);
265 inline int ReadW(int32_t addr, Instruction* instr);
266 inline void WriteW(int32_t addr, int value, Instruction* instr);
268 inline double ReadD(int32_t addr, Instruction* instr);
269 inline void WriteD(int32_t addr, double value, Instruction* instr)
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| Loads.h | 29 bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom,
33 /// the instruction before ScanFrom) checking to see if we have the value at
37 /// If not, return the iterator for the last validated instruction that the
|
| PtrUseVisitor.h | 10 /// This file provides a collection of visitors which walk the (instruction)
67 /// \brief Get the instruction causing the visit to abort.
68 /// \returns a pointer to the instruction causing the abort if one is
70 Instruction *getAbortingInst() const { return AbortedInfo.getPointer(); }
72 /// \brief Get the instruction causing the pointer to escape.
73 /// \returns a pointer to the instruction which escapes the pointer if one
75 Instruction *getEscapingInst() const { return EscapedInfo.getPointer(); }
78 /// \param I The instruction which caused the visit to abort, if available.
79 void setAborted(Instruction *I = 0) {
85 /// \param I The instruction which escapes the pointer, if available
[all...] |
| /external/llvm/lib/Target/Hexagon/ |
| HexagonRemoveSZExtArgs.cpp | 62 for (Instruction::use_iterator UI = Arg->use_begin();
65 Instruction* Use = cast<Instruction>(*UI);
71 Instruction* First = F.getEntryBlock().begin();
|
| /external/smali/dexlib/src/main/java/org/jf/dexlib/Code/Format/ |
| Instruction11n.java | 31 import org.jf.dexlib.Code.Instruction;
39 public class Instruction11n extends Instruction implements SingleRegisterInstruction, LiteralInstruction {
84 private static class Factory implements Instruction.InstructionFactory {
85 public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
|
| Instruction31c.java | 31 import org.jf.dexlib.Code.Instruction;
41 public static final Instruction.InstructionFactory Factory = new Factory();
74 private static class Factory implements Instruction.InstructionFactory {
75 public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
|
| Instruction31t.java | 31 import org.jf.dexlib.Code.Instruction;
40 public static final Instruction.InstructionFactory Factory = new Factory();
85 private static class Factory implements Instruction.InstructionFactory {
86 public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
|
| Instruction22c.java | 31 import org.jf.dexlib.Code.Instruction;
42 public static final Instruction.InstructionFactory Factory = new Factory();
68 throw new RuntimeException(String.format("%s index is too large. Use the %s instruction instead.",
92 public Instruction makeJumbo() {
101 private static class Factory implements Instruction.InstructionFactory {
102 public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
|
| Instruction22cs.java | 31 import org.jf.dexlib.Code.Instruction;
39 public class Instruction22cs extends Instruction implements TwoRegisterInstruction, OdexedFieldAccess {
40 public static final Instruction.InstructionFactory Factory = new Factory();
92 private static class Factory implements Instruction.InstructionFactory {
93 public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
|
| Instruction3rms.java | 31 import org.jf.dexlib.Code.Instruction;
39 public class Instruction3rms extends Instruction implements RegisterRangeInstruction, OdexedInvokeVirtual {
40 public static final Instruction.InstructionFactory Factory = new Factory();
102 private static class Factory implements Instruction.InstructionFactory {
103 public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
|
| /external/chromium_org/v8/src/mips/ |
| simulator-mips.h | 185 // instruction.
255 void Format(Instruction* instr, const char* format);
263 inline uint16_t ReadHU(int32_t addr, Instruction* instr);
264 inline int16_t ReadH(int32_t addr, Instruction* instr);
266 inline void WriteH(int32_t addr, uint16_t value, Instruction* instr);
267 inline void WriteH(int32_t addr, int16_t value, Instruction* instr);
269 inline int ReadW(int32_t addr, Instruction* instr);
270 inline void WriteW(int32_t addr, int value, Instruction* instr);
272 inline double ReadD(int32_t addr, Instruction* instr);
273 inline void WriteD(int32_t addr, double value, Instruction* instr)
[all...] |
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineSelect.cpp | 80 /// Assuming that the specified instruction is an operand to the select, return
81 /// a bitmask indicating which operands of this instruction are foldable if they
84 static unsigned GetSelectFoldableOperands(Instruction *I) {
86 case Instruction::Add:
87 case Instruction::Mul:
88 case Instruction::And:
89 case Instruction::Or:
90 case Instruction::Xor:
92 case Instruction::Sub: // Can only fold on the amount subtracted.
93 case Instruction::Shl: // Can only fold on the shift amount
[all...] |
| /external/chromium_org/v8/src/arm/ |
| disasm-arm.cc | 28 // A Disassembler object is used to disassemble a block of code instruction by
29 // instruction. The default implementation of the NameConverter object can be
88 // Writes one disassembled instruction into 'buffer' (0-terminated).
89 // Returns the length of the disassembled machine instruction in bytes.
90 int InstructionDecode(byte* instruction);
104 int FormatVFPRegister(Instruction* instr, const char* format);
105 void PrintMovwMovt(Instruction* instr);
106 int FormatVFPinstruction(Instruction* instr, const char* format);
107 void PrintCondition(Instruction* instr);
108 void PrintShiftRm(Instruction* instr)
[all...] |
| /external/llvm/lib/IR/ |
| Instructions.cpp | 10 // This file implements all of the non-inline methods for the LLVM instruction
34 Instruction *II(getInstruction());
88 : Instruction(PN.getType(), Instruction::PHI,
182 Instruction *InsertBefore)
183 : Instruction(RetTy, Instruction::LandingPad, 0, 0, InsertBefore) {
190 : Instruction(RetTy, Instruction::LandingPad, 0, 0, InsertAtEnd) {
195 : Instruction(LP.getType(), Instruction::LandingPad
[all...] |
