| /external/llvm/include/llvm/Analysis/ |
| MemoryDependenceAnalysis.h | 29 class Instruction;
45 /// Clobber - This is a dependence on the specified instruction which
47 /// pair holds the instruction that clobbers the memory. For example,
57 /// Def - This is a dependence on the specified instruction which
59 /// the MemDepResult pair holds the instruction that defines the memory.
67 /// 2. For loads and stores, this could be an allocation instruction. In
78 /// upper part of the pair (i.e. the Instruction*)
82 /// (i.e. the Instruction* part) is instead used to encode more detailed
97 typedef PointerIntPair<Instruction*, 2, DepType> PairTy;
105 static MemDepResult getDef(Instruction *Inst)
[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...] |
| ScalarEvolutionExpander.h | 37 std::map<std::pair<const SCEV *, Instruction *>, AssertingVH<Value> >
47 /// returns the add instruction that adds one to the phi for {0,+,1}<L>,
59 Instruction *IVIncInsertPos;
112 static bool hoistStep(Instruction *IncV, Instruction *InsertPos,
123 Value *expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I);
126 void setIVIncInsertPos(const Loop *L, Instruction *Pos) {
159 /// if the instruction that had been serving as the insertion point may
169 Value *InsertBinop(Instruction::BinaryOps Opcode, Value *LHS, Value *RHS);
176 Instruction::CastOps Op
[all...] |
| Loads.h | 28 bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom,
32 /// the instruction before ScanFrom) checking to see if we have the value at
36 /// If not, return the iterator for the last validated instruction that the
|
| ConstantFolding.h | 26 class Instruction;
33 /// ConstantFoldInstruction - Try to constant fold the specified instruction.
38 Constant *ConstantFoldInstruction(Instruction *I, const TargetData *TD = 0);
46 /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
57 /// instruction (icmp/fcmp) with the specified operands. If it fails, it
65 /// instruction with the specified operands and indices. The constant result is
|
| /external/llvm/include/llvm/Transforms/Utils/ |
| Local.h | 24 class Instruction;
42 /// ConstantFoldTerminator - If a terminator instruction is predicated on a
56 /// instruction is not used, and the instruction has no side effects.
58 bool isInstructionTriviallyDead(Instruction *I);
61 /// trivially dead instruction, delete it. If that makes any of its operands
68 /// either forms a cycle or is terminated by a trivially dead instruction,
137 /// Instruction and replaces it with a slot in the stack frame, allocated via
142 AllocaInst *DemoteRegToStack(Instruction &X,
144 Instruction *AllocaPoint = 0)
[all...] |
| /external/proguard/src/proguard/optimize/peephole/ |
| InstructionSequencesReplacer.java | 25 import proguard.classfile.instruction.Instruction;
26 import proguard.classfile.instruction.visitor.*;
29 * This InstructionVisitor replaces multiple instruction sequences at once.
45 * instruction.
46 * @param instructionSequences the instruction sequences to be replaced,
49 * and the instruction index in the sequence.
57 Instruction[][][] instructionSequences,
72 * instruction.
73 * @param instructionSequences the instruction sequences to be replaced
[all...] |
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineCasts.cpp | 43 if (I->getOpcode() == Instruction::Shl) {
50 if (I->getOpcode() == Instruction::Mul) {
57 if (I->getOpcode() == Instruction::Add) {
76 /// PromoteCastOfAllocation - If we find a cast of an allocation instruction,
78 Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
142 // New is the allocation instruction, pointer typed. AI is the original
143 // allocation instruction, also pointer typed. Thus, cast to use is BitCast.
165 // Otherwise, it must be an instruction.
166 Instruction *I = cast<Instruction>(V)
[all...] |
| InstCombineShifts.cpp | 22 Instruction *InstCombiner::commonShiftTransforms(BinaryOperator &I) {
33 if (Instruction *R = FoldOpIntoSelect(I, SI))
37 if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I))
74 Instruction *I = dyn_cast<Instruction>(V);
103 // require duplicating the instruction in general, which isn't profitable.
108 case Instruction::And:
109 case Instruction::Or:
110 case Instruction::Xor:
115 case Instruction::Shl:
[all...] |
| 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/webkit/Source/JavaScriptCore/bytecode/ |
| Instruction.h | 57 // Structure used by op_get_by_id_self_list and op_get_by_id_proto_list instruction to hold data off the main opcode stream.
125 struct Instruction {
126 Instruction(Opcode opcode)
136 Instruction(int operand)
144 Instruction(JSGlobalData& globalData, JSCell* owner, Structure* structure)
149 Instruction(JSGlobalData& globalData, JSCell* owner, StructureChain* structureChain)
154 Instruction(JSGlobalData& globalData, JSCell* owner, JSCell* jsCell)
159 Instruction(PolymorphicAccessStructureList* polymorphicStructures) { u.polymorphicStructures = polymorphicStructures; }
160 Instruction(PropertySlot::GetValueFunc getterFunc) { u.getterFunc = getterFunc; }
173 Instruction(StructureChain*)
[all...] |
| /external/webkit/Source/JavaScriptCore/interpreter/ |
| Interpreter.h | 54 struct Instruction;
127 NEVER_INLINE bool resolve(CallFrame*, Instruction*, JSValue& exceptionValue);
128 NEVER_INLINE bool resolveSkip(CallFrame*, Instruction*, JSValue& exceptionValue);
129 NEVER_INLINE bool resolveGlobal(CallFrame*, Instruction*, JSValue& exceptionValue);
130 NEVER_INLINE bool resolveGlobalDynamic(CallFrame*, Instruction*, JSValue& exceptionValue);
131 NEVER_INLINE void resolveBase(CallFrame*, Instruction* vPC);
132 NEVER_INLINE bool resolveBaseAndProperty(CallFrame*, Instruction*, JSValue& exceptionValue);
133 NEVER_INLINE ScopeChainNode* createExceptionScope(CallFrame*, const Instruction* vPC);
135 void tryCacheGetByID(CallFrame*, CodeBlock*, Instruction*, JSValue baseValue, const Identifier& propertyName, const PropertySlot&);
136 void uncacheGetByID(CodeBlock*, Instruction* vPC)
[all...] |
| Register.h | 45 struct Instruction;
62 Register& operator=(Instruction*);
71 Instruction* vPC() const;
86 Instruction* vPC;
138 ALWAYS_INLINE Register& Register::operator=(Instruction* vPC)
159 ALWAYS_INLINE Instruction* Register::vPC() const
|
| /external/llvm/lib/Transforms/Scalar/ |
| DCE.cpp | 22 #include "llvm/Instruction.h"
43 Instruction *Inst = DI++;
61 "Dead Instruction Elimination", false, false)
91 std::vector<Instruction*> WorkList;
101 Instruction *I = WorkList.back();
104 if (isInstructionTriviallyDead(I)) { // If the instruction is dead.
105 // Loop over all of the values that the instruction uses, if there are
110 if (Instruction *Used = dyn_cast<Instruction>(*OI))
113 // Remove the instruction
[all...] |
| Reg2Mem.cpp | 48 bool valueEscapes(const Instruction *Inst) const {
52 const Instruction *I = cast<Instruction>(*UI);
79 // Find first non-alloca instruction and create insertion point. This is
92 std::list<Instruction*> WorkList;
105 for (std::list<Instruction*>::iterator ilb = WorkList.begin(),
121 for (std::list<Instruction*>::iterator ilb = WorkList.begin(),
|
| /external/llvm/lib/AsmParser/ |
| LLParser.h | 32 class Instruction;
92 // Instruction metadata resolution. Each instruction can have a list of
97 // instruction metadata kinds, such as dbg, get stored in the IR in an
106 DenseMap<Instruction*, std::vector<MDRef> > ForwardRefInstMetadata;
258 /// SetInstName - After an instruction is parsed and inserted into its
261 Instruction *Inst);
322 bool ParseInstructionMetadata(Instruction *Inst, PerFunctionState *PFS);
338 // Instruction Parsing. Each instruction parsing routine can return with
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| SimplifyIndVar.cpp | 76 Value *foldIVUser(Instruction *UseInst, Instruction *IVOperand);
78 bool eliminateIVUser(Instruction *UseInst, Instruction *IVOperand);
86 /// aligned IV when used by a instruction that ignores the low bits.
93 Value *SimplifyIndvar::foldIVUser(Instruction *UseInst, Instruction *IVOperand) {
100 case Instruction::UDiv:
101 case Instruction::LShr:
119 if (UseInst->getOpcode() == Instruction::LShr)
[all...] |
| AddrModeMatcher.cpp | 17 #include "llvm/Instruction.h"
101 if (isa<Instruction>(ScaleReg) && // not a constant expr.
107 // this instruction.
109 AddrModeInsts.push_back(cast<Instruction>(ScaleReg));
123 static bool MightBeFoldableInst(Instruction *I) {
125 case Instruction::BitCast:
130 case Instruction::PtrToInt:
133 case Instruction::IntToPtr:
136 case Instruction::Add:
138 case Instruction::Mul
[all...] |
| /external/llvm/include/llvm/Support/ |
| PatternMatch.h | 24 // This is primarily useful to things like the instruction combiner, but can
291 inline BinaryOp_match<LHS, RHS, Instruction::Add>
293 return BinaryOp_match<LHS, RHS, Instruction::Add>(L, R);
297 inline BinaryOp_match<LHS, RHS, Instruction::FAdd>
299 return BinaryOp_match<LHS, RHS, Instruction::FAdd>(L, R);
303 inline BinaryOp_match<LHS, RHS, Instruction::Sub>
305 return BinaryOp_match<LHS, RHS, Instruction::Sub>(L, R);
309 inline BinaryOp_match<LHS, RHS, Instruction::FSub>
311 return BinaryOp_match<LHS, RHS, Instruction::FSub>(L, R);
315 inline BinaryOp_match<LHS, RHS, Instruction::Mul
[all...] |
| /external/llvm/lib/Analysis/ |
| PHITransAddr.cpp | 24 static bool CanPHITrans(Instruction *Inst) {
33 if (Inst->getOpcode() == Instruction::Add &&
55 SmallVectorImpl<Instruction*> &InstInputs) {
56 // If this is a non-instruction value, there is nothing to do.
57 Instruction *I = dyn_cast<Instruction>(Expr);
60 // If it's an instruction, it is either in Tmp or its operands recursively
62 SmallVectorImpl<Instruction*>::iterator Entry =
72 errs() << "Non phi translatable instruction found in PHITransAddr:\n";
79 // Validate the operands of the instruction
[all...] |
| /external/llvm/lib/VMCore/ |
| Constants.cpp | 194 case Instruction::UDiv:
195 case Instruction::SDiv:
196 case Instruction::FDiv:
197 case Instruction::URem:
198 case Instruction::SRem:
199 case Instruction::FRem:
252 if (CE->getOpcode() == Instruction::Sub) {
256 LHS->getOpcode() == Instruction::PtrToInt &&
257 RHS->getOpcode() == Instruction::PtrToInt &&
739 // can't be inline because we don't want to #include Instruction.h int
[all...] |
| Instructions.cpp | 10 // This file implements all of the non-inline methods for the LLVM instruction
33 Instruction *II(getInstruction());
87 : Instruction(PN.getType(), Instruction::PHI,
175 Instruction *InsertBefore)
176 : Instruction(RetTy, Instruction::LandingPad, 0, 0, InsertBefore) {
183 : Instruction(RetTy, Instruction::LandingPad, 0, 0, InsertAtEnd) {
188 : Instruction(LP.getType(), Instruction::LandingPad
[all...] |
| /external/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/v8/src/mips/ |
| simulator-mips.h | 182 // instruction.
244 void Format(Instruction* instr, const char* format);
252 inline uint16_t ReadHU(int32_t addr, Instruction* instr);
253 inline int16_t ReadH(int32_t addr, Instruction* instr);
255 inline void WriteH(int32_t addr, uint16_t value, Instruction* instr);
256 inline void WriteH(int32_t addr, int16_t value, Instruction* instr);
258 inline int ReadW(int32_t addr, Instruction* instr);
259 inline void WriteW(int32_t addr, int value, Instruction* instr);
261 inline double ReadD(int32_t addr, Instruction* instr);
262 inline void WriteD(int32_t addr, double value, Instruction* instr)
[all...] |
| /external/llvm/examples/ModuleMaker/ |
| ModuleMaker.cpp | 48 // Create the add instruction... does not insert...
49 Instruction *Add = BinaryOperator::Create(Instruction::Add, Two, Three,
55 // Create the return instruction and add it to the basic block
|
