| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombine.h | 41 if (isa<Instruction>(V)) {
62 void InsertHelper(Instruction *I, const Twine &Name,
72 public InstVisitor<InstCombiner, Instruction*> {
98 // Visitation implementation - Implement instruction combining for different
99 // instruction types. The semantics are as follows:
103 // otherwise - Change was made, replace I with returned instruction
105 Instruction *visitAdd(BinaryOperator &I);
106 Instruction *visitFAdd(BinaryOperator &I);
108 Instruction *visitSub(BinaryOperator &I);
109 Instruction *visitFSub(BinaryOperator &I)
[all...] |
| InstCombineWorklist.h | 14 #include "llvm/Instruction.h"
26 SmallVector<Instruction*, 256> Worklist;
27 DenseMap<Instruction*, unsigned> WorklistMap;
36 /// Add - Add the specified instruction to the worklist if it isn't already
38 void Add(Instruction *I) {
46 if (Instruction *I = dyn_cast<Instruction>(V))
53 void AddInitialGroup(Instruction *const *List, unsigned NumEntries) {
59 Instruction *I = List[NumEntries-1];
66 void Remove(Instruction *I)
[all...] |
| /external/llvm/tools/llvm-diff/ |
| DiffLog.h | 21 class Instruction;
58 typedef std::pair<Instruction*,Instruction*> DiffRecord;
67 void addMatch(Instruction *L, Instruction *R);
69 void addLeft(Instruction *L);
70 void addRight(Instruction *R);
74 Instruction *getLeft(unsigned I) const;
75 Instruction *getRight(unsigned I) const;
|
| DiffLog.cpp | 34 void DiffLogBuilder::addMatch(Instruction *L, Instruction *R) {
37 void DiffLogBuilder::addLeft(Instruction *L) {
41 void DiffLogBuilder::addRight(Instruction *R) {
52 Instruction *DiffLogBuilder::getLeft(unsigned I) const { return Diff[I].first; }
53 Instruction *DiffLogBuilder::getRight(unsigned I) const { return Diff[I].second; }
|
| /external/llvm/include/llvm/Support/ |
| NoFolder.h | 40 Instruction *CreateAdd(Constant *LHS, Constant *RHS,
47 Instruction *CreateNSWAdd(Constant *LHS, Constant *RHS) const {
50 Instruction *CreateNUWAdd(Constant *LHS, Constant *RHS) const {
53 Instruction *CreateFAdd(Constant *LHS, Constant *RHS) const {
56 Instruction *CreateSub(Constant *LHS, Constant *RHS,
63 Instruction *CreateNSWSub(Constant *LHS, Constant *RHS) const {
66 Instruction *CreateNUWSub(Constant *LHS, Constant *RHS) const {
69 Instruction *CreateFSub(Constant *LHS, Constant *RHS) const {
72 Instruction *CreateMul(Constant *LHS, Constant *RHS,
79 Instruction *CreateNSWMul(Constant *LHS, Constant *RHS) const
[all...] |
| InstVisitor.h | 1 //===- llvm/Support/InstVisitor.h - Define instruction visitors -*- C++ -*-===//
21 // We operate on opaque instruction classes, so forward declare all instruction
25 #include "llvm/Instruction.def"
32 /// @brief Base class for instruction visitors
34 /// Instruction visitors are used when you want to perform different actions
61 /// The defined has 'visit' methods for Instruction, and also for BasicBlock,
64 /// Note that if you don't implement visitXXX for some instruction type,
65 /// the visitXXX method for instruction superclass will be invoked. So
69 /// The optional second template argument specifies the type that instruction
[all...] |
| /external/llvm/lib/Analysis/ |
| CaptureTracking.cpp | 67 Instruction *I = cast<Instruction>(U->getUser());
71 case Instruction::Call:
72 case Instruction::Invoke: {
96 case Instruction::Load:
99 case Instruction::VAArg:
102 case Instruction::Ret:
106 case Instruction::Store:
116 case Instruction::BitCast:
117 case Instruction::GetElementPtr
[all...] |
| /external/llvm/include/llvm/ |
| BasicBlock.h | 17 #include "llvm/Instruction.h"
30 template<> struct ilist_traits<Instruction>
31 : public SymbolTableListTraits<Instruction, BasicBlock> {
36 Instruction *createSentinel() const {
45 return static_cast<Instruction*>(&Sentinel);
47 static void destroySentinel(Instruction*) {}
49 Instruction *provideInitialHead() const { return createSentinel(); }
50 Instruction *ensureHead(Instruction*) const { return createSentinel(); }
51 static void noteHead(Instruction*, Instruction*) {
[all...] |
| Operator.h | 18 #include "llvm/Instruction.h"
40 /// getOpcode - Return the opcode for this Instruction or ConstantExpr.
43 if (const Instruction *I = dyn_cast<Instruction>(this))
48 /// getOpcode - If V is an Instruction or ConstantExpr, return its
52 if (const Instruction *I = dyn_cast<Instruction>(V))
56 return Instruction::UserOp1;
60 static inline bool classof(const Instruction *) { return true; }
63 return isa<Instruction>(V) || isa<ConstantExpr>(V)
[all...] |
| InstrTypes.h | 1 //===-- llvm/InstrTypes.h - Important Instruction subclasses ----*- C++ -*-===//
19 #include "llvm/Instruction.h"
35 class TerminatorInst : public Instruction {
37 TerminatorInst(Type *Ty, Instruction::TermOps iType,
39 Instruction *InsertBefore = 0)
40 : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {}
42 TerminatorInst(Type *Ty, Instruction::TermOps iType,
44 : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
77 static inline bool classof(const Instruction *I) {
81 return isa<Instruction>(V) && classof(cast<Instruction>(V))
[all...] |
| Instructions.h | 1 //===-- llvm/Instructions.h - Instruction subclass definitions --*- C++ -*-===//
11 // Instruction class. This is meant to be an easy way to get access to all
12 // instruction subclasses.
55 /// AllocaInst - an instruction to allocate memory on the stack
62 const Twine &Name = "", Instruction *InsertBefore = 0);
66 AllocaInst(Type *Ty, const Twine &Name, Instruction *InsertBefore = 0);
70 const Twine &Name = "", Instruction *InsertBefore = 0);
78 /// to the allocation instruction that is not 1.
91 return reinterpret_cast<PointerType*>(Instruction::getType());
95 /// instruction
[all...] |
| Instruction.h | 1 //===-- llvm/Instruction.h - Instruction class definition -------*- C++ -*-===//
10 // This file contains the declaration of the Instruction class, which is the
30 class Instruction : public User, public ilist_node<Instruction> {
31 void operator=(const Instruction &); // Do not implement
32 Instruction(const Instruction &); // Do not implement
39 /// indicates whether this instruction has metadata attached to it or not.
44 ~Instruction();
[all...] |
| /external/webkit/Source/JavaScriptCore/jit/ |
| JIT.h | 60 struct Instruction;
284 void compileOpCall(OpcodeID, Instruction* instruction, unsigned callLinkInfoIndex);
285 void compileOpCallVarargs(Instruction* instruction);
287 void compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter, unsigned callLinkInfoIndex, OpcodeID opcodeID);
288 void compileOpCallVarargsSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter);
291 void compileOpStrictEq(Instruction* instruction, CompileOpStrictEqType type)
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| ScalarEvolutionNormalization.h | 43 class Instruction;
70 Instruction *User,
|
| PHITransAddr.h | 17 #include "llvm/Instruction.h"
42 SmallVector<Instruction*, 4> InstInputs;
45 // If the address is an instruction, the whole thing is considered an input.
46 if (Instruction *I = dyn_cast<Instruction>(Addr))
84 SmallVectorImpl<Instruction*> &NewInsts);
103 SmallVectorImpl<Instruction*> &NewInsts);
105 /// AddAsInput - If the specified value is an instruction, add it as an input.
107 // If V is an instruction, it is now an input.
108 if (Instruction *VI = dyn_cast<Instruction>(V)
[all...] |
| /external/llvm/lib/VMCore/ |
| Instruction.cpp | 1 //===-- Instruction.cpp - Implement the Instruction class -----------------===//
10 // This file implements the Instruction class for the VMCore library.
14 #include "llvm/Instruction.h"
23 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
24 Instruction *InsertBefore)
29 // If requested, insert this instruction into a basic block...
32 "Instruction to insert before is not in a basic block!");
37 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps
[all...] |
| /external/v8/src/mips/ |
| disasm-mips.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
86 // Writes one disassembled instruction into 'buffer' (0-terminated).
87 // Returns the length of the disassembled machine instruction in bytes.
88 int InstructionDecode(byte_* instruction);
98 void PrintRs(Instruction* instr);
99 void PrintRt(Instruction* instr);
100 void PrintRd(Instruction* instr);
101 void PrintFs(Instruction* instr);
102 void PrintFt(Instruction* instr)
[all...] |
| /external/llvm/include/llvm/Assembly/ |
| AssemblyAnnotationWriter.h | 24 class Instruction;
39 /// after the basic block label, but before the first instruction in the
52 /// before an instruction is emitted.
53 virtual void emitInstructionAnnot(const Instruction *I,
57 /// right of an instruction or global value.
|
| /external/llvm/include/llvm/Transforms/Utils/ |
| AddrModeMatcher.h | 28 class Instruction;
56 SmallVectorImpl<Instruction*> &AddrModeInsts;
60 /// the memory instruction that we're computing this address for.
62 Instruction *MemoryInst;
73 AddressingModeMatcher(SmallVectorImpl<Instruction*> &AMI,
75 Instruction *MI, ExtAddrMode &AM)
85 Instruction *MemoryInst,
86 SmallVectorImpl<Instruction*> &AddrModeInsts,
100 bool IsProfitableToFoldIntoAddressingMode(Instruction *I,
|
| SSAUpdater.h | 126 LoadAndStorePromoter(const SmallVectorImpl<Instruction*> &Insts,
133 void run(const SmallVectorImpl<Instruction*> &Insts) const;
136 /// Return true if the specified instruction is in the Inst list (which was
139 virtual bool isInstInList(Instruction *I,
140 const SmallVectorImpl<Instruction*> &Insts) const {
157 /// This is called before each instruction is deleted.
158 virtual void instructionDeleted(Instruction *I) const {
162 /// instruction.
163 virtual void updateDebugInfo(Instruction *I) const {
|
| /external/proguard/src/proguard/classfile/instruction/visitor/ |
| InstructionCounter.java | 21 package proguard.classfile.instruction.visitor;
25 import proguard.classfile.instruction.Instruction;
55 Instruction instruction)
|
| /external/v8/src/arm/ |
| simulator-arm.h | 155 // instruction.
216 void Format(Instruction* instr, const char* format);
218 // Checks if the current instruction should be executed based on its
220 bool ConditionallyExecute(Instruction* instr);
238 int32_t GetShiftRm(Instruction* instr, bool* carry_out);
239 int32_t GetImm(Instruction* instr, bool* carry_out);
240 void ProcessPUW(Instruction* instr,
245 void HandleRList(Instruction* instr, bool load);
246 void HandleVList(Instruction* inst);
247 void SoftwareInterrupt(Instruction* instr)
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| Reassociate.cpp | 62 static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) {
64 dbgs() << Instruction::getOpcodeName(I->getOpcode()) << " "
100 Value *OptimizeAdd(Instruction *I, SmallVectorImpl<ValueEntry> &Ops);
118 Instruction *Op = dyn_cast<Instruction>(V);
131 static bool isUnmovableInstruction(Instruction *I) {
132 if (I->getOpcode() == Instruction::PHI ||
133 I->getOpcode() == Instruction::Alloca ||
134 I->getOpcode() == Instruction::Load ||
135 I->getOpcode() == Instruction::Invoke |
[all...] |
| ADCE.cpp | 53 SmallPtrSet<Instruction*, 128> alive;
54 SmallVector<Instruction*, 128> worklist;
68 Instruction* curr = worklist.pop_back_val();
69 for (Instruction::op_iterator OI = curr->op_begin(), OE = curr->op_end();
71 if (Instruction* Inst = dyn_cast<Instruction>(OI))
86 for (SmallVector<Instruction*, 1024>::iterator I = worklist.begin(),
|
| Sink.cpp | 55 bool SinkInstruction(Instruction *I, SmallPtrSet<Instruction *, 8> &Stores);
56 bool AllUsesDominatedByBlock(Instruction *Inst, BasicBlock *BB) const;
71 bool Sinking::AllUsesDominatedByBlock(Instruction *Inst,
80 Instruction *UseInst = cast<Instruction>(*I);
132 SmallPtrSet<Instruction *, 8> Stores;
134 Instruction *Inst = I; // The instruction to sink.
148 // If we just processed the first instruction in the block, we're done
[all...] |
