| /frameworks/rs/rsov/compiler/ |
| Builtin.cpp | 34 Instruction *translateClampVector(const char *name,
59 std::unique_ptr<Instruction> min(
64 std::unique_ptr<Instruction> max(
72 Instruction *translateExtInst(const uint32_t extOpCode,
81 typedef std::function<Instruction *(const char *, const FunctionCallInst *,
114 Builder *b, Module *) -> Instruction * {
121 Transformer *, Builder *b, Module *) -> Instruction * {
287 Instruction *transform(CapabilityInst *inst) override {
295 Instruction *transform(ExtInstImportInst *inst) override {
302 Instruction *transform(SourceInst *inst) override
[all...] |
| /external/swiftshader/third_party/LLVM/lib/Transforms/Scalar/ |
| IndVarSimplify.cpp | 200 static Instruction *getInsertPointForUses(Instruction *User, Value *Def,
206 Instruction *InsertPt = 0;
220 assert((!isa<Instruction>(Def) ||
221 DT->dominates(cast<Instruction>(Def), InsertPt)) &&
269 if (Incr == 0 || Incr->getOpcode() != Instruction::FAdd) return;
282 Instruction *U1 = cast<Instruction>(*IncrUse++);
284 Instruction *U2 = cast<Instruction>(*IncrUse++)
[all...] |
| LICM.cpp | 20 // we can hoist it or sink it like any other instruction.
21 // 2. Scalar Promotion of Memory - If there is a store instruction inside of
137 /// sink - When an instruction is found to only be used outside of the loop,
141 void sink(Instruction &I);
143 /// hoist - When an instruction is found to only use loop invariant operands
144 /// that is safe to hoist, this instruction is called to do the dirty work.
146 void hoist(Instruction &I);
148 /// isSafeToExecuteUnconditionally - Only sink or hoist an instruction if it
149 /// is not a trapping instruction or if it is a trapping instruction and i
[all...] |
| /external/llvm/lib/Target/Lanai/ |
| LanaiInstrInfo.cpp | 1 //===-- LanaiInstrInfo.cpp - Lanai Instruction Information ------*- C++ -*-===//
203 // isRedundantFlagInstr - check whether the first instruction, whose only
302 // One is MI, the other is a SUB instruction.
307 // MI is not a candidate to transform into a flag setting instruction.
310 // Conservatively refuse to convert an instruction which isn't in the same
319 // Check that SR isn't set between the comparison instruction and the
320 // instruction we want to change while searching for Sub.
327 // This instruction modifies or uses SR after the one we want to change.
331 // Check whether CmpInstr can be made redundant by the current instruction.
410 // The instruction uses the V bit or C bit which is not safe
[all...] |
| /external/llvm/lib/Transforms/Instrumentation/ |
| IndirectCallPromotion.cpp | 86 "invoke instruction only"));
149 TargetStatus isPromotionLegal(Instruction *Inst, uint64_t Target,
165 Instruction *Inst, const ArrayRef<InstrProfValueData> &ValueDataRef,
168 // Main function that transforms Inst (either a indirect-call instruction, or
169 // an invoke instruction , to a conditional call to F. This is like:
175 // TotalCount is the profile count value that the instruction executes.
178 void promote(Instruction *Inst, Function *F, uint64_t Count,
183 uint32_t tryToPromote(Instruction *Inst,
216 ICallPromotionFunc::isPromotionLegal(Instruction *Inst, uint64_t Target,
244 if (!CastInst::castIsValid(Instruction::BitCast, CS.getArgument(I), PTy)
[all...] |
| /external/llvm/lib/Transforms/Utils/ |
| IntegerDivision.cpp | 31 /// instruction. This will generate a urem in the process, and Builder's insert
68 if (Instruction *URemInst = dyn_cast<Instruction>(URem))
77 /// code generated, e.g. at the urem instruction. This will generate a udiv in
93 if (Instruction *UDiv = dyn_cast<Instruction>(Quotient))
101 /// code generated, e.g. at the sdiv instruction. This will generate a udiv in
142 if (Instruction *UDiv = dyn_cast<Instruction>(Q_Mag))
150 /// point where the caller wants code generated, e.g. at the udiv instruction
[all...] |
| /external/llvm/lib/Target/WebAssembly/ |
| WebAssemblyFastISel.cpp | 149 bool selectCall(const Instruction *I);
150 bool selectSelect(const Instruction *I);
151 bool selectTrunc(const Instruction *I);
152 bool selectZExt(const Instruction *I);
153 bool selectSExt(const Instruction *I);
154 bool selectICmp(const Instruction *I);
155 bool selectFCmp(const Instruction *I);
156 bool selectBitCast(const Instruction *I);
157 bool selectLoad(const Instruction *I);
158 bool selectStore(const Instruction *I)
[all...] |
| /art/compiler/optimizing/ |
| register_allocator_test.cc | 179 Instruction::CONST_4 | 0 | 0,
180 Instruction::RETURN);
216 Instruction::CONST_4 | 0 | 0,
217 Instruction::IF_EQ, 4,
218 Instruction::CONST_4 | 4 << 12 | 0,
219 Instruction::GOTO | 0xFD00,
220 Instruction::CONST_4 | 5 << 12 | 1 << 8,
221 Instruction::RETURN | 1 << 8);
262 Instruction::CONST_4 | 0 | 0,
263 Instruction::CONST_4 | 8 << 12 | 1 << 8
[all...] |
| /external/llvm/lib/Target/AArch64/ |
| AArch64TargetTransformInfo.cpp | 27 // Check if the immediate can be encoded within an instruction.
60 // We need at least one instruction to materialze the constant.
78 case Instruction::GetElementPtr:
83 case Instruction::Store:
86 case Instruction::Add:
87 case Instruction::Sub:
88 case Instruction::Mul:
89 case Instruction::UDiv:
90 case Instruction::SDiv:
91 case Instruction::URem
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| PlaceSafepoints.cpp | 172 // Insert a safepoint poll immediately before the given instruction. Does
176 InsertSafepointPoll(Instruction *InsertBefore,
201 // instruction in a block which is dominated by the Header and dominates the
212 for (Instruction &I : *Current) {
261 static void scanOneBB(Instruction *Start, Instruction *End,
275 // Only add the successor blocks if we reach the terminator instruction
288 static void scanInlinedCode(Instruction *Start, Instruction *End,
344 DEBUG(dbgs() << "[LSP] terminator instruction: " << *Term)
[all...] |
| /external/swiftshader/third_party/LLVM/lib/Transforms/InstCombine/ |
| InstCombineMulDivRem.cpp | 57 if (I->getOpcode() == Instruction::LShr && !I->isExact()) {
62 if (I->getOpcode() == Instruction::Shl && !I->hasNoUnsignedWrap()) {
99 Instruction *InstCombiner::visitMul(BinaryOperator &I) {
116 if (SI->getOpcode() == Instruction::Shl)
167 if (Instruction *R = FoldOpIntoSelect(I, SI))
171 if (Instruction *NV = FoldOpIntoPhi(I))
185 (BO->getOpcode() != Instruction::UDiv &&
186 BO->getOpcode() != Instruction::SDiv)) {
193 (BO->getOpcode() == Instruction::UDiv ||
194 BO->getOpcode() == Instruction::SDiv))
[all...] |
| /external/v8/src/arm/ |
| disasm-arm.cc | 5 // A Disassembler object is used to disassemble a block of code instruction by
6 // instruction. The default implementation of the NameConverter object can be
62 // Writes one disassembled instruction into 'buffer' (0-terminated).
63 // Returns the length of the disassembled machine instruction in bytes.
64 int InstructionDecode(byte* instruction);
78 int FormatVFPRegister(Instruction* instr, const char* format);
79 void PrintMovwMovt(Instruction* instr);
80 int FormatVFPinstruction(Instruction* instr, const char* format);
81 void PrintCondition(Instruction* instr);
82 void PrintShiftRm(Instruction* instr)
[all...] |
| /external/swiftshader/third_party/LLVM/lib/Analysis/ |
| ScalarEvolutionExpander.cpp | 31 Instruction::CastOps Op,
45 Instruction *NewCI = CastInst::Create(Op, V, Ty, "", IP);
58 Instruction *I = CastInst::Create(Op, V, Ty, V->getName(), IP);
67 Instruction::CastOps Op = CastInst::getCastOpcode(V, false, Ty, false);
68 assert((Op == Instruction::BitCast ||
69 Op == Instruction::PtrToInt ||
70 Op == Instruction::IntToPtr) &&
76 if (Op == Instruction::BitCast && V->getType() == Ty)
80 if ((Op == Instruction::PtrToInt || Op == Instruction::IntToPtr) &
[all...] |
| Loads.cpp | 42 if (const Instruction *BI = dyn_cast<Instruction>(B))
43 if (cast<Instruction>(A)->isIdenticalToWhenDefined(BI))
68 } else if (Operator::getOpcode(V) == Instruction::BitCast) {
86 bool llvm::isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom,
151 /// instruction before ScanFrom) checking to see if we have the value at the
155 /// If not, return the iterator for the last validated instruction that the
179 Instruction *Inst = --ScanFrom;
223 // If this is some other instruction that may clobber Ptr, bail out.
|
| /external/llvm/lib/Analysis/ |
| MemDepPrinter.cpp | 36 typedef PointerIntPair<const Instruction *, 2, DepType> InstTypePair;
39 typedef DenseMap<const Instruction *, DepSet> DepSetMap;
73 static InstTypePair getInstTypePair(const Instruction* inst, DepType type) {
100 Instruction *Inst = &I;
121 isa<VAArgInst>(Inst)) && "Unknown memory instruction!");
137 const Instruction *Inst = &I;
146 const Instruction *DepInst = I.first.getPointer();
|
| /external/mesa3d/src/gallium/drivers/nvc0/codegen/ |
| nv50_ir_emit_nvc0.cpp | 34 virtual bool emitInstruction(Instruction *);
35 virtual uint32_t getMinEncodingSize(const Instruction *) const;
48 void emitForm_A(const Instruction *, uint64_t);
49 void emitForm_B(const Instruction *, uint64_t);
50 void emitForm_S(const Instruction *, uint32_t, bool pred);
52 void emitPredicate(const Instruction *);
55 void setImmediate(const Instruction *, const int s); // needs op already set
59 void emitInterpMode(const Instruction *);
67 void roundMode_A(const Instruction *);
68 void roundMode_C(const Instruction *);
[all...] |
| /external/proguard/src/proguard/classfile/editor/ |
| MethodInvocationFixer.java | 28 import proguard.classfile.instruction.*;
29 import proguard.classfile.instruction.visitor.InstructionVisitor;
75 public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
100 // Replace the invocation by an invokestatic instruction.
101 Instruction replacementInstruction =
121 // Replace the invocation by an invokespecial instruction.
122 Instruction replacementInstruction =
147 Instruction replacementInstruction =
172 // Replace the invocation by an invokevirtual instruction
[all...] |
| /external/llvm/lib/Transforms/Vectorize/ |
| BBVectorize.cpp | 73 cl::desc("The maximum search distance for instruction pairs"));
97 cl::desc("The maximum number of candidate instruction pairs per group"));
164 cl::desc("Use a fast instruction dependency analysis"));
168 DebugInstructionExamination("bb-vectorize-debug-instruction-examination",
171 " instruction-examination process"));
283 bool isInstVectorizable(Instruction *I, bool &IsSimpleLoadStore);
285 bool areInstsCompatible(Instruction *I, Instruction *J,
290 AliasSetTracker &WriteSet, Instruction *I,
291 Instruction *J, bool UpdateUsers = true
[all...] |
| LoopVectorize.cpp | 161 "force-target-instruction-cost", cl::init(0), cl::Hidden,
163 "an instruction to a single constant value. Mostly "
227 VectorizationReport(Instruction *I = nullptr)
247 /// A helper function that returns GEP instruction and knows to skip a
307 const MapVector<Instruction *, uint64_t> &MinimumBitWidths,
314 // Widen each instruction in the old loop to a new one in the new loop.
329 /// originated from one scalar instruction.
347 Value *Step, Instruction *DL);
378 void widenPHIInstruction(Instruction *PN, VectorParts &Entry, unsigned UF,
385 /// This instruction is un-vectorizable. Implement it as a sequenc
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| ConstantFolding.h | 31 class Instruction;
40 /// ConstantFoldInstruction - Try to constant fold the specified instruction.
45 Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
55 /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
61 Constant *ConstantFoldInstOperands(Instruction *I, ArrayRef<Constant *> Ops,
65 /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
79 /// instruction (icmp/fcmp) with the specified operands. If it fails, it
99 /// instruction with the specified operands and indices. The constant result is
104 /// \brief Attempt to constant fold an extractvalue instruction with the
110 /// \brief Attempt to constant fold an extractelement instruction with th
[all...] |
| CodeMetrics.h | 27 class Instruction;
36 /// instruction. Note that if isInstructionFree(CS.getInstruction()) would
|
| /external/llvm/lib/CodeGen/ |
| SafeStackColoring.h | 28 /// * first instruction of any basic block
69 DenseMap<Instruction *, unsigned> InstructionNumbering;
70 /// A range [Start, End) of instruction ids for each basic block.
83 SmallVector<Instruction *, 8> Markers;
97 bool readMarker(Instruction *I, bool *IsStart);
|
| /prebuilts/ndk/r13/sources/third_party/shaderc/third_party/spirv-tools/source/opt/ |
| module.cpp | 33 std::vector<Instruction*> Module::types() {
34 std::vector<Instruction*> insts;
42 void Module::ForEachInst(const std::function<void(Instruction*)>& f) {
|
| /external/swiftshader/third_party/LLVM/lib/Target/CBackend/ |
| CBackend.cpp | 185 void writeInstComputationInline(Instruction &I);
189 bool writeInstructionCast(const Instruction &I);
233 static bool isInlinableInst(const Instruction &I) {
250 const Instruction &User = cast<Instruction>(*I.use_back());
256 // Only inline instruction it if it's use is in the same BB as the inst.
257 return I.getParent() == cast<Instruction>(I.use_back())->getParent();
274 // isInlineAsm - Check if the instruction is a call to an inline asm chunk.
275 static bool isInlineAsm(const Instruction& I) {
281 // Instruction visitation function
[all...] |
| /art/test/983-source-transform-verify/ |
| source_transform.cc | 92 const Instruction& inst = code_it.CurrentInstruction();
93 int forbiden_flags = (Instruction::kVerifyError | Instruction::kVerifyRuntimeOnly);
94 if (inst.Opcode() == Instruction::RETURN_VOID_NO_BARRIER ||
96 std::cout << "Unexpected instruction found in " << dex->PrettyMethod(it.GetMemberIndex())
|
