/external/llvm/lib/Analysis/ |
InstructionSimplify.cpp | 1 //===- InstructionSimplify.cpp - Fold instruction operands ----------------===// 73 Instruction *I = dyn_cast<Instruction>(V); 82 // Otherwise, if the instruction is in the entry block, and is not an invoke, 99 Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 114 if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 138 if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 162 Instruction::BinaryOps OpcodeToExtract = (Instruction::BinaryOps)OpcToExtract [all...] |
ScalarEvolutionNormalization.cpp | 29 static bool IVUseShouldUsePostIncValue(Instruction *User, Value *Operand, 80 const SCEV *TransformSubExpr(const SCEV *S, Instruction *User, 84 const SCEV *TransformImpl(const SCEV *S, Instruction *User, 92 TransformImpl(const SCEV *S, Instruction *User, Value *OperandValToReplace) { 112 Instruction *LUser = L->getHeader()->begin(); 200 TransformSubExpr(const SCEV *S, Instruction *User, Value *OperandValToReplace) { 218 Instruction *User,
|
LoopDependenceAnalysis.cpp | 64 const Instruction *I = dyn_cast<const Instruction>(V); 69 SmallVectorImpl<Instruction*> &Memrefs) { 93 llvm_unreachable("Value is no load or store instruction!"); 119 (cast<const Instruction>(A)->mayWriteToMemory() || 120 cast<const Instruction>(B)->mayWriteToMemory()); 338 SmallVector<Instruction*, 8> memrefs; 346 for (SmallVector<Instruction*, 8>::const_iterator x = memrefs.begin(), 351 for (SmallVector<Instruction*, 8>::const_iterator x = memrefs.begin(), 353 for (SmallVector<Instruction*, 8>::const_iterator y = x + 1 [all...] |
/external/llvm/lib/ExecutionEngine/Interpreter/ |
Execution.cpp | 10 // This file contains the actual instruction interpreter. 45 // Binary Instruction Implementations 59 dbgs() << "Unhandled type for FAdd instruction: " << *Ty << "\n"; 70 dbgs() << "Unhandled type for FSub instruction: " << *Ty << "\n"; 81 dbgs() << "Unhandled type for FMul instruction: " << *Ty << "\n"; 92 dbgs() << "Unhandled type for FDiv instruction: " << *Ty << "\n"; 107 dbgs() << "Unhandled type for Rem instruction: " << *Ty << "\n"; 295 dbgs() << "Unhandled type for FCmp EQ instruction: " << *Ty << "\n"; 309 dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n"; 322 dbgs() << "Unhandled type for FCmp LE instruction: " << *Ty << "\n" [all...] |
/external/llvm/lib/Transforms/InstCombine/ |
InstCombineLoadStoreAlloca.cpp | 25 Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) { 54 // insert our getelementptr instruction... 60 Instruction *GEP = 89 static Instruction *InstCombineLoadCast(InstCombiner &IC, LoadInst &LI, 144 Instruction *InstCombiner::visitLoadInst(LoadInst &LI) { 163 if (Instruction *Res = InstCombineLoadCast(*this, LI, TD)) 182 // Insert a new store to null instruction before the load to indicate 184 // an unreachable instruction directly because we cannot modify the 196 // Insert a new store to null instruction before the load to indicate that 198 // unreachable instruction directly because we cannot modify the CFG [all...] |
InstCombineCompares.cpp | 112 /// isSignBitCheck - Given an exploded icmp instruction, return true if the 200 Instruction *InstCombiner:: 564 /// FoldGEPICmp - Fold comparisons between a GEP instruction and something 566 Instruction *InstCombiner::FoldGEPICmp(GEPOperator *GEPLHS, Value *RHS, 568 Instruction &I) { 680 Instruction *InstCombiner::FoldICmpAddOpCst(ICmpInst &ICI, 745 Instruction *InstCombiner::FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI, 758 bool DivIsSigned = DivI->getOpcode() == Instruction::SDiv; 779 // as in the LHS instruction that we're folding [all...] |
/external/llvm/lib/Target/X86/ |
X86FastISel.cpp | 67 virtual bool TargetSelectInstruction(const Instruction *I); 70 /// vreg is being provided by the specified load instruction. If possible, 71 /// try to fold the load as an operand to the instruction, returning true if 92 bool X86SelectLoad(const Instruction *I); 94 bool X86SelectStore(const Instruction *I); 96 bool X86SelectRet(const Instruction *I); 98 bool X86SelectCmp(const Instruction *I); 100 bool X86SelectZExt(const Instruction *I); 102 bool X86SelectBranch(const Instruction *I); 104 bool X86SelectShift(const Instruction *I) [all...] |
/external/llvm/lib/Transforms/Scalar/ |
GVN.cpp | 97 Expression create_expression(Instruction* I); 149 Expression ValueTable::create_expression(Instruction *I) { 153 for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end(); 182 e.opcode = Instruction::Add; 186 e.opcode = Instruction::Sub; 190 e.opcode = Instruction::Mul; 209 for (Instruction::op_iterator OI = EI->op_begin(), OE = EI->op_end(); 285 // Check to see if we have a single dominating call instruction that is 293 // instruction dependencies. 345 if (!isa<Instruction>(V)) [all...] |
JumpThreading.cpp | 182 // If the terminator is the only non-phi instruction, try to nuke it. 223 // Sum up the cost of each instruction until we get to the terminator. Don't 332 // If V is a non-instruction value, or an instruction in a different block, 334 Instruction *I = dyn_cast<Instruction>(V); 345 // "I" is a non-local compare-with-a-constant instruction. This would be 386 if (I->getOpcode() == Instruction::Or || 387 I->getOpcode() == Instruction::And) { 397 if (I->getOpcode() == Instruction::Or [all...] |
DeadStoreElimination.cpp | 98 /// DeleteDeadInstruction - Delete this instruction. Before we do, go through 99 /// and zero out all the operands of this instruction. If any of them become 104 static void DeleteDeadInstruction(Instruction *I, 107 SmallVector<Instruction*, 32> NowDeadInsts; 112 // Before we touch this instruction, remove it from memdep! 114 Instruction *DeadInst = NowDeadInsts.pop_back_val(); 117 // This instruction is dead, zap it, in stages. Start by removing it from 129 if (Instruction *OpI = dyn_cast<Instruction>(Op)) 141 /// hasMemoryWrite - Does this instruction write some memory? This only return [all...] |
/external/llvm/lib/MC/ |
MCStreamer.cpp | 311 MCCFIInstruction Instruction(Label, Dest, Source); 312 CurFrame->Instructions.push_back(Instruction); 322 MCCFIInstruction Instruction(Label, Dest, Source); 323 CurFrame->Instructions.push_back(Instruction); 333 MCCFIInstruction Instruction(MCCFIInstruction::RelMove, Label, Dest, Source); 334 CurFrame->Instructions.push_back(Instruction); 344 MCCFIInstruction Instruction(Label, Dest, Source); 345 CurFrame->Instructions.push_back(Instruction); 355 MCCFIInstruction Instruction(Label, Dest, Source); 356 CurFrame->Instructions.push_back(Instruction); [all...] |
/external/llvm/include/llvm/Support/ |
CallSite.h | 43 typename InstrTy = const Instruction, 57 /// will create an appropriate call site for a Call or Invoke instruction, but 63 if (II->getOpcode() == Instruction::Call) 65 else if (II->getOpcode() == Instruction::Invoke) 73 /// it also could signify a NULL Instruction pointer. 87 assert(getInstruction() && "Not a call or invoke instruction!"); 101 assert(getInstruction() && "Not a call or invoke instruction!"); 118 assert(getInstruction() && "Not a call or invoke instruction!"); 126 assert(getInstruction() && "Not a call or invoke instruction!"); 139 assert(getInstruction() && "Not a call or invoke instruction!"); [all...] |
/external/llvm/lib/CodeGen/SelectionDAG/ |
FastISel.cpp | 12 // "Fast" instruction selection is designed to emit very poor code quickly. 20 // "Fast" instruction selection is able to fail gracefully and transfer 25 // The intended use for "fast" instruction selection is "-O0" mode 30 // time. Despite its limitations, "fast" instruction selection is able to 35 // the same instruction descriptions that the SelectionDAG selector reads, 89 const Instruction *I = dyn_cast<Instruction>(V); 102 !(I->getOpcode() == Instruction::BitCast || 103 I->getOpcode() == Instruction::PtrToInt || 104 I->getOpcode() == Instruction::IntToPtr) & [all...] |
/external/v8/src/mips/ |
simulator-mips.cc | 77 void Stop(Instruction* instr); 98 bool SetBreakpoint(Instruction* breakpc); 99 bool DeleteBreakpoint(Instruction* breakpc); 128 void MipsDebugger::Stop(Instruction* instr) { 138 sim_->set_pc(sim_->get_pc() + Instruction::kInstrSize); 144 #define UNSUPPORTED() printf("Unsupported instruction.\n"); 149 void MipsDebugger::Stop(Instruction* instr) { 152 sim_->set_pc(sim_->get_pc() + Instruction::kInstrSize); 222 bool MipsDebugger::SetBreakpoint(Instruction* breakpc) { 231 // Not setting the breakpoint instruction in the code itself. It will be se [all...] |
/external/llvm/include/llvm/CodeGen/ |
FunctionLoweringInfo.h | 43 class Instruction; 101 SmallSet<const Instruction *, 8> CatchInfoLost; 102 SmallSet<const Instruction *, 8> CatchInfoFound; 113 /// VisitedBBs - The set of basic blocks visited thus far by instruction 135 /// isExportedInst - Return true if the specified value is an instruction 225 /// landingpad instruction and add them to the specified machine module info.
|
/external/llvm/lib/Transforms/Utils/ |
SSAUpdater.cpp | 206 Instruction *User = cast<Instruction>(U.getUser()); 222 Instruction *User = cast<Instruction>(U.getUser()); 297 /// CreateEmptyPHI - Create a new PHI instruction in the specified block. 312 /// InstrIsPHI - Check if an instruction is a PHI. 314 static PHINode *InstrIsPHI(Instruction *I) { 333 /// GetPHIValue - For the specified PHI instruction, return the value 360 LoadAndStorePromoter(const SmallVectorImpl<Instruction*> &Insts, 377 run(const SmallVectorImpl<Instruction*> &Insts) const [all...] |
/external/v8/src/arm/ |
simulator-arm.cc | 59 void Stop(Instruction* instr); 77 bool SetBreakpoint(Instruction* breakpc); 78 bool DeleteBreakpoint(Instruction* breakpc); 109 void ArmDebugger::Stop(Instruction* instr) { 114 reinterpret_cast<char**>(sim_->get_pc() + Instruction::kInstrSize); 128 // Overwrite the instruction and address with nops. 130 reinterpret_cast<Instruction*>(msg_address)->SetInstructionBits(kNopInstr); 132 sim_->set_pc(sim_->get_pc() + 2 * Instruction::kInstrSize); 141 void ArmDebugger::Stop(Instruction* instr) { 146 + Instruction::kInstrSize) [all...] |
/external/llvm/lib/Bitcode/Writer/ |
BitcodeWriter.cpp | 63 default: llvm_unreachable("Unknown cast instruction!"); 64 case Instruction::Trunc : return bitc::CAST_TRUNC; 65 case Instruction::ZExt : return bitc::CAST_ZEXT; 66 case Instruction::SExt : return bitc::CAST_SEXT; 67 case Instruction::FPToUI : return bitc::CAST_FPTOUI; 68 case Instruction::FPToSI : return bitc::CAST_FPTOSI; 69 case Instruction::UIToFP : return bitc::CAST_UITOFP; 70 case Instruction::SIToFP : return bitc::CAST_SITOFP; 71 case Instruction::FPTrunc : return bitc::CAST_FPTRUNC; 72 case Instruction::FPExt : return bitc::CAST_FPEXT [all...] |
/external/webkit/Source/JavaScriptCore/jit/ |
JITArithmetic32_64.cpp | 50 void JIT::emit_op_negate(Instruction* currentInstruction) 75 void JIT::emitSlow_op_negate(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter) 87 void JIT::emit_op_jnless(Instruction* currentInstruction) 143 void JIT::emitSlow_op_jnless(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter) 176 void JIT::emit_op_jless(Instruction* currentInstruction) 231 void JIT::emitSlow_op_jless(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter) 263 void JIT::emit_op_jlesseq(Instruction* currentInstruction, bool invert) 318 void JIT::emitSlow_op_jlesseq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter, bool invert) 351 void JIT::emit_op_jnlesseq(Instruction* currentInstruction) 356 void JIT::emitSlow_op_jnlesseq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter [all...] |
/external/llvm/lib/Target/ARM/ |
ARMFastISel.cpp | 148 virtual bool TargetSelectInstruction(const Instruction *I); 154 // Instruction selection routines. 156 bool SelectLoad(const Instruction *I); 157 bool SelectStore(const Instruction *I); 158 bool SelectBranch(const Instruction *I); 159 bool SelectCmp(const Instruction *I); 160 bool SelectFPExt(const Instruction *I); 161 bool SelectFPTrunc(const Instruction *I); 162 bool SelectBinaryOp(const Instruction *I, unsigned ISDOpcode); 163 bool SelectSIToFP(const Instruction *I) [all...] |
/external/llvm/tools/llvm-diff/ |
DifferenceEngine.cpp | 177 void unify(Instruction *L, Instruction *R) { 200 llvm::SmallVector<std::pair<Instruction*,Instruction*>, 20> TentativePairs; 204 Instruction *LeftI = &*LI, *RightI = &*RI; 227 bool matchForBlockDiff(Instruction *L, Instruction *R); 250 bool diff(Instruction *L, Instruction *R, bool Complain, bool TryUnify) { 255 if (Complain) Engine.log("different instruction types") [all...] |
/external/llvm/unittests/Transforms/Utils/ |
Cloning.cpp | 54 BinaryOperator *Add = BinaryOperator::Create(Instruction::Add, V, V); 55 BinaryOperator *Sub = BinaryOperator::Create(Instruction::Sub, V, V); 56 BinaryOperator *Mul = BinaryOperator::Create(Instruction::Mul, V, V); 137 BinaryOperator *SDiv = BinaryOperator::Create(Instruction::SDiv, V, V);
|
/external/webkit/Source/JavaScriptCore/runtime/ |
ExceptionHelpers.h | 44 struct Instruction;
|
/external/proguard/src/proguard/classfile/util/ |
InstructionSequenceMatcher.java | 27 import proguard.classfile.instruction.*; 28 import proguard.classfile.instruction.visitor.InstructionVisitor; 31 * This InstructionVisitor checks whether a given pattern instruction sequence 33 * instruction sequence can be wildcards that are matched. 61 private final Instruction[] patternInstructions; 80 * instruction. 81 * @param patternInstructions the pattern instruction sequence. 84 Instruction[] patternInstructions) 95 * Starts matching from the first instruction again next time. 187 Instruction patternInstruction = patternInstructions[patternInstructionIndex] [all...] |
/external/llvm/include/llvm/Analysis/ |
ValueTracking.h | 25 class Instruction; 113 Instruction *InsertBefore = 0);
|