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