/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;
|