| /external/llvm/lib/Transforms/Utils/ |
| SimplifyCFG.cpp | 214 /// see if V (which must be an instruction) and its recursive operands
216 /// are non-trapping. If both are true, the instruction is inserted into the
226 SmallPtrSet<Instruction*, 4> *AggressiveInsts,
228 Instruction *I = dyn_cast<Instruction>(V);
243 // If this instruction is defined in a block that contains an unconditional
254 // If we have seen this instruction before, don't count it again.
257 // Okay, it looks like the instruction IS in the "condition". Check to
258 // see if it's a cheap instruction to unconditionally compute, and if it
267 case Instruction::Load
[all...] |
| LoopUnroll.cpp | 39 /// RemapInstruction - Convert the instruction operands from referencing the
41 static inline void RemapInstruction(Instruction *I,
115 /// branch instruction. However, if the trip count (and multiple) are not known,
258 if (Instruction *InValI = dyn_cast<Instruction>(InVal))
315 if (Instruction *InValI = dyn_cast<Instruction>(InVal)) {
395 if (Instruction *Inst =
396 dyn_cast_or_null<Instruction>(&*DeadInsts.pop_back_val()))
407 Instruction *Inst = I++
[all...] |
| BasicBlockUtils.cpp | 48 Instruction &I = BB->back();
49 // If this instruction is used, replace uses with an arbitrary value.
193 /// ReplaceInstWithValue - Replace all uses of an instruction (specified by BI)
194 /// with a value, then remove and delete the original instruction.
198 Instruction &I = *BI;
199 // Replaces all of the uses of the instruction with uses of the value
206 // Delete the unnecessary instruction now...
211 /// ReplaceInstWithInst - Replace the instruction specified by BI with the
212 /// instruction specified by I. The original instruction is deleted and BI i
[all...] |
| PromoteMemoryToRegister.cpp | 152 /// InstNumbers - For each instruction that we track, keep the index of the
153 /// instruction. The index starts out as the number of the instruction from
155 DenseMap<const Instruction *, unsigned> InstNumbers;
159 static bool isInterestingInstruction(const Instruction *I) {
165 /// instruction.
166 unsigned getInstructionIndex(const Instruction *I) {
170 // If we already have this instruction number, return it.
171 DenseMap<const Instruction *, unsigned>::iterator It = InstNumbers.find(I);
174 // Scan the whole block to get the instruction. This accumulate
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| ScalarReplAggregates.cpp | 83 /// AllocaInfo - When analyzing uses of an alloca instruction, this captures
120 void MarkUnsafe(AllocaInfo &I, Instruction *User) {
127 void isSafeForScalarRepl(Instruction *I, uint64_t Offset, AllocaInfo &Info);
128 void isSafePHISelectUseForScalarRepl(Instruction *User, uint64_t Offset,
133 Instruction *TheAccess, bool AllowWholeAccess);
142 void RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset,
151 void RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *Inst,
160 AllocaInst *AI, SmallVector<Instruction*, 4> &ToDelete);
416 Instruction *User = cast<Instruction>(*UI)
[all...] |
| LoopInstSimplify.cpp | 1 //===- LoopInstSimplify.cpp - Loop Instruction Simplification Pass --------===//
10 // This pass performs lightweight instruction simplification on loop bodies.
72 SmallPtrSet<const Instruction*, 8> S1, S2, *ToSimplify = &S1, *Next = &S2;
97 Instruction *I = BI++;
112 Next->insert(cast<Instruction>(*UI));
|
| LoopIdiomRecognize.cpp | 87 Value *SplatValue, Instruction *TheStore,
131 /// deleteDeadInstruction - Delete this instruction. Before we do, go through
132 /// and zero out all the operands of this instruction. If any of them become
135 static void deleteDeadInstruction(Instruction *I, ScalarEvolution &SE) {
136 SmallVector<Instruction*, 32> NowDeadInsts;
140 // Before we touch this instruction, remove it from SE!
142 Instruction *DeadInst = NowDeadInsts.pop_back_val();
144 // This instruction is dead, zap it, in stages. Start by removing it from
155 if (Instruction *OpI = dyn_cast<Instruction>(Op)
[all...] |
| MemCpyOptimizer.cpp | 134 /// StartPtr - The getelementptr instruction that points to the start of the
142 SmallVector<Instruction*, 16> TheStores;
204 void addInst(int64_t OffsetFromFirst, Instruction *Inst) {
224 unsigned Alignment, Instruction *Inst);
240 unsigned Alignment, Instruction *Inst) {
334 bool performCallSlotOptzn(Instruction *cpy, Value *cpyDst, Value *cpySrc,
339 Instruction *tryMergingIntoMemset(Instruction *I, Value *StartPtr,
364 Instruction *MemCpyOpt::tryMergingIntoMemset(Instruction *StartInst,
[all...] |
| LoopRotation.cpp | 42 // LCSSA form makes instruction renaming easier.
86 /// these instruction that were outside of the loop, we have to insert PHI nodes
115 // Visit each use of the OrigHeader instruction.
126 Instruction *UserInst = cast<Instruction>(U.getUser());
216 // each Instruction.
229 Instruction *Inst = I++;
231 // If the instruction's operands are invariant and it doesn't read or write
233 // execution in the preheader, but does prevent the instruction from
244 // Otherwise, create a duplicate of the instruction
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| InstructionSimplify.h | 14 // ("and i32 %x, %x" -> "%x"). If the simplification is also an instruction
15 // then it dominates the original instruction.
24 class Instruction;
150 /// instruction. If not, this returns null.
151 Value *SimplifyInstruction(Instruction *I, const TargetData *TD = 0,
156 /// delete the From instruction. In addition to a basic RAUW, this does a
161 void ReplaceAndSimplifyAllUses(Instruction *From, Value *To,
|
| /external/llvm/lib/Analysis/ |
| LoopInfo.cpp | 53 if (Instruction *I = dyn_cast<Instruction>(V))
59 /// specified instruction are loop invariant.
60 bool Loop::hasLoopInvariantOperands(Instruction *I) const {
78 Instruction *InsertPt) const {
79 if (Instruction *I = dyn_cast<Instruction>(V))
84 /// makeLoopInvariant - If the given instruction is inside of the
86 /// Return true if the instruction after any hoisting is loop invariant. This
93 bool Loop::makeLoopInvariant(Instruction *I, bool &Changed
[all...] |
| SparsePropagation.cpp | 63 else if (!isa<Instruction>(V))
76 /// UpdateState - When the state for some instruction is potentially updated,
78 void SparseSolver::UpdateState(Instruction &Inst, LatticeVal V) {
119 /// successors are reachable from a given terminator instruction.
276 void SparseSolver::visitInst(Instruction &I) {
297 // Process the instruction work list.
299 Instruction *I = InstWorkList.back();
308 Instruction *U = cast<Instruction>(*UI);
|
| LazyValueInfo.cpp | 413 Instruction *BBI, BasicBlock *BB);
540 Instruction *BBI = dyn_cast<Instruction>(Val);
579 static bool InstructionDereferencesPointer(Instruction *I, Value *Ptr) {
715 Instruction *BBI,
746 case Instruction::Add:
749 case Instruction::Sub:
752 case Instruction::Mul:
755 case Instruction::UDiv:
758 case Instruction::Shl
[all...] |
| InstCount.cpp | 33 #include "llvm/Instruction.def"
46 #include "llvm/Instruction.def"
48 void visitInstruction(Instruction &I) {
49 errs() << "Instruction Count does not know about " << I;
|
| /external/webkit/Source/JavaScriptCore/interpreter/ |
| CallFrame.h | 98 Instruction* returnVPC() const { return this[RegisterFile::ReturnPC].vPC(); }
104 ALWAYS_INLINE void init(CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain,
113 setReturnPC(vPC); // This is either an Instruction* or a pointer into JIT generated code stored as an Instruction*.
145 void setReturnPC(void* value) { static_cast<Register*>(this)[RegisterFile::ReturnPC] = (Instruction*)value; }
|
| /external/llvm/lib/AsmParser/ |
| LLParser.cpp | 48 // Handle any instruction metadata forward references.
50 for (DenseMap<Instruction*, std::vector<MDRef> >::iterator
53 Instruction *Inst = I->first;
[all...] |
| /external/llvm/lib/VMCore/ |
| Android.mk | 19 Instruction.cpp \
|
| BasicBlock.cpp | 39 template class llvm::SymbolTableListTraits<Instruction, BasicBlock>;
89 // Set Parent=parent, updating instruction symtab entries as appropriate.
130 Instruction* BasicBlock::getFirstNonPHI() {
140 Instruction* BasicBlock::getFirstNonPHIOrDbg() {
150 Instruction* BasicBlock::getFirstNonPHIOrDbgOrLifetime() {
288 /// instruction. Note that all instructions BEFORE the specified iterator stay
294 /// terminator), and 'I' must not be the end of instruction list (which would
312 // Add a branch instruction to the newly formed basic block.
346 // that it ends with a non-phi instruction.
359 /// the destination of the 'unwind' edge of an invoke instruction
[all...] |
| /external/proguard/src/proguard/classfile/editor/ |
| VariableRemapper.java | 26 import proguard.classfile.instruction.*;
27 import proguard.classfile.instruction.visitor.InstructionVisitor;
123 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
133 // Replace the instruction.
134 Instruction replacementInstruction =
|
| /external/proguard/src/proguard/optimize/ |
| DuplicateInitializerInvocationFixer.java | 29 import proguard.classfile.instruction.*;
30 import proguard.classfile.instruction.visitor.InstructionVisitor;
98 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
110 Instruction extraInstruction =
|
| /external/proguard/src/proguard/optimize/info/ |
| ExceptionInstructionChecker.java | 27 import proguard.classfile.instruction.*;
28 import proguard.classfile.instruction.visitor.InstructionVisitor;
33 * This class can tell whether an instruction might throw exceptions.
48 * Returns whether the given instruction may throw exceptions.
50 public boolean mayThrowExceptions(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
54 instruction.accept(clazz, method, codeAttribute, offset, this);
62 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
|
| /external/webkit/Source/JavaScriptCore/jit/ |
| JITPropertyAccess.cpp | 84 void JIT::emit_op_get_by_val(Instruction* currentInstruction)
113 void JIT::emitSlow_op_get_by_val(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
147 void JIT::emit_op_get_by_pname(Instruction* currentInstruction)
172 void JIT::emitSlow_op_get_by_pname(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
189 void JIT::emit_op_put_by_val(Instruction* currentInstruction)
223 void JIT::emit_op_put_by_index(Instruction* currentInstruction)
232 void JIT::emit_op_put_getter(Instruction* currentInstruction)
241 void JIT::emit_op_put_setter(Instruction* currentInstruction)
250 void JIT::emit_op_del_by_id(Instruction* currentInstruction)
264 void JIT::emit_op_method_check(Instruction*) {}
[all...] |
| /external/llvm/include/llvm/ |
| ValueSymbolTable.h | 38 friend class SymbolTableListTraits<Instruction, BasicBlock>;
|
| /external/llvm/lib/Transforms/IPO/ |
| IPConstantPropagation.cpp | 94 // Used by a non-instruction, or not the callee of a function, do not
99 CallSite CS(cast<Instruction>(U));
225 Instruction* Call = CS.getInstruction();
227 // Not a call instruction or a call instruction that's not calling F
242 // the call instruction and use that.
250 Instruction *Ins = cast<Instruction>(*I);
268 // the call instruction and use that.
|
| /external/llvm/tools/llvm-diff/ |
| DifferenceEngine.h | 28 class Instruction;
|
