| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombine.h | 42 if (isa<Instruction>(V)) {
63 void InsertHelper(Instruction *I, const Twine &Name,
73 public InstVisitor<InstCombiner, Instruction*> {
102 // Visitation implementation - Implement instruction combining for different
103 // instruction types. The semantics are as follows:
107 // otherwise - Change was made, replace I with returned instruction
109 Instruction *visitAdd(BinaryOperator &I);
110 Instruction *visitFAdd(BinaryOperator &I);
112 Instruction *visitSub(BinaryOperator &I);
113 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++ -*-===//
22 // We operate on opaque instruction classes, so forward declare all instruction
26 #include "llvm/Instruction.def"
33 /// @brief Base class for instruction visitors
35 /// Instruction visitors are used when you want to perform different actions
62 /// The defined has 'visit' methods for Instruction, and also for BasicBlock,
65 /// Note that if you don't implement visitXXX for some instruction type,
66 /// the visitXXX method for instruction superclass will be invoked. So
70 /// The optional second template argument specifies the type that instruction
[all...] |
| /external/llvm/include/llvm/ |
| Operator.h | 19 #include "llvm/Instruction.h"
41 /// getOpcode - Return the opcode for this Instruction or ConstantExpr.
44 if (const Instruction *I = dyn_cast<Instruction>(this))
49 /// getOpcode - If V is an Instruction or ConstantExpr, return its
53 if (const Instruction *I = dyn_cast<Instruction>(V))
57 return Instruction::UserOp1;
61 static inline bool classof(const Instruction *) { return true; }
64 return isa<Instruction>(V) || isa<ConstantExpr>(V)
[all...] |
| 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...] |
| 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/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/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"
46 SmallVector<Instruction*, 4> InstInputs;
49 // If the address is an instruction, the whole thing is considered an input.
50 if (Instruction *I = dyn_cast<Instruction>(Addr))
88 SmallVectorImpl<Instruction*> &NewInsts);
107 SmallVectorImpl<Instruction*> &NewInsts);
109 /// AddAsInput - If the specified value is an instruction, add it as an input.
111 // If V is an instruction, it is now an input.
112 if (Instruction *VI = dyn_cast<Instruction>(V)
[all...] |
| IVUsers.h | 25 class Instruction;
35 /// instruction of the operand, and 'OperandValToReplace' is the operand of
40 IVStrideUse(IVUsers *P, Instruction* U, Value *O)
44 /// getUser - Return the user instruction for this use.
45 Instruction *getUser() const {
46 return cast<Instruction>(getValPtr());
49 /// setUser - Assign a new user instruction for this use.
50 void setUser(Instruction *NewUser) {
55 /// instruction that this IVStrideUse is representing.
80 /// OperandValToReplace - The Value of the operand in the user instruction
[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 *,
57 /// right of an instruction or global value.
|
| /external/llvm/lib/Analysis/ |
| CaptureTracking.cpp | 98 Instruction *I = cast<Instruction>(U->getUser());
102 case Instruction::Call:
103 case Instruction::Invoke: {
126 case Instruction::Load:
129 case Instruction::VAArg:
132 case Instruction::Store:
139 case Instruction::BitCast:
140 case Instruction::GetElementPtr:
141 case Instruction::PHI
[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/Transforms/Utils/ |
| SSAUpdater.h | 21 class Instruction;
128 LoadAndStorePromoter(const SmallVectorImpl<Instruction*> &Insts,
135 void run(const SmallVectorImpl<Instruction*> &Insts) const;
138 /// Return true if the specified instruction is in the Inst list (which was
141 virtual bool isInstInList(Instruction *I,
142 const SmallVectorImpl<Instruction*> &Insts) const;
154 /// This is called before each instruction is deleted.
155 virtual void instructionDeleted(Instruction *I) const {
159 /// instruction.
160 virtual void updateDebugInfo(Instruction *I) const
[all...] |
| 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,
|
| /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/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 | 157 // instruction.
231 void Format(Instruction* instr, const char* format);
233 // Checks if the current instruction should be executed based on its
235 bool ConditionallyExecute(Instruction* instr);
257 int32_t GetShiftRm(Instruction* instr, bool* carry_out);
258 int32_t GetImm(Instruction* instr, bool* carry_out);
259 void ProcessPUW(Instruction* instr,
264 void HandleRList(Instruction* instr, bool load);
265 void HandleVList(Instruction* inst);
266 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...] |
