| /external/v8/src/arm64/ |
| instructions-arm64.cc | 16 bool Instruction::IsLoad() const {
43 bool Instruction::IsStore() const {
92 uint64_t Instruction::ImmLogical() {
143 float Instruction::ImmFP32() {
157 double Instruction::ImmFP64() {
183 int64_t Instruction::ImmPCOffset() {
190 // Relative branch offsets are instruction-size-aligned.
206 Instruction* Instruction::ImmPCOffsetTarget() {
211 bool Instruction::IsValidImmPCOffset(ImmBranchType branch_type
[all...] |
| /external/swiftshader/third_party/LLVM/lib/Transforms/Scalar/ |
| Reassociate.cpp | 62 static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) {
64 dbgs() << Instruction::getOpcodeName(I->getOpcode()) << " "
100 Value *OptimizeAdd(Instruction *I, SmallVectorImpl<ValueEntry> &Ops);
118 Instruction *Op = dyn_cast<Instruction>(V);
131 static bool isUnmovableInstruction(Instruction *I) {
132 if (I->getOpcode() == Instruction::PHI ||
133 I->getOpcode() == Instruction::Alloca ||
134 I->getOpcode() == Instruction::Load ||
135 I->getOpcode() == Instruction::Invoke |
[all...] |
| ADCE.cpp | 53 SmallPtrSet<Instruction*, 128> alive;
54 SmallVector<Instruction*, 128> worklist;
68 Instruction* curr = worklist.pop_back_val();
69 for (Instruction::op_iterator OI = curr->op_begin(), OE = curr->op_end();
71 if (Instruction* Inst = dyn_cast<Instruction>(OI))
86 for (SmallVector<Instruction*, 1024>::iterator I = worklist.begin(),
|
| Sink.cpp | 55 bool SinkInstruction(Instruction *I, SmallPtrSet<Instruction *, 8> &Stores);
56 bool AllUsesDominatedByBlock(Instruction *Inst, BasicBlock *BB) const;
71 bool Sinking::AllUsesDominatedByBlock(Instruction *Inst,
80 Instruction *UseInst = cast<Instruction>(*I);
132 SmallPtrSet<Instruction *, 8> Stores;
134 Instruction *Inst = I; // The instruction to sink.
148 // If we just processed the first instruction in the block, we're done
[all...] |
| /external/v8/src/mips/ |
| disasm-mips.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
57 // Writes one disassembled instruction into 'buffer' (0-terminated).
58 // Returns the length of the disassembled machine instruction in bytes.
59 int InstructionDecode(byte* instruction);
70 void PrintRs(Instruction* instr);
71 void PrintRt(Instruction* instr);
72 void PrintRd(Instruction* instr);
73 void PrintFs(Instruction* instr);
74 void PrintFt(Instruction* instr)
[all...] |
| /prebuilts/ndk/r13/sources/third_party/shaderc/third_party/glslang/SPIRV/ |
| SpvBuilder.cpp | 76 Instruction* import = new Instruction(getUniqueId(), NoType, OpExtInstImport);
79 imports.push_back(std::unique_ptr<Instruction>(import));
86 Instruction* type;
88 type = new Instruction(getUniqueId(), NoType, OpTypeVoid);
90 constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
100 Instruction* type;
102 type = new Instruction(getUniqueId(), NoType, OpTypeBool);
104 constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
114 Instruction* type
[all...] |
| /prebuilts/ndk/r13/sources/third_party/vulkan/glslang/SPIRV/ |
| SpvBuilder.cpp | 76 Instruction* import = new Instruction(getUniqueId(), NoType, OpExtInstImport);
79 imports.push_back(std::unique_ptr<Instruction>(import));
86 Instruction* type;
88 type = new Instruction(getUniqueId(), NoType, OpTypeVoid);
90 constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
100 Instruction* type;
102 type = new Instruction(getUniqueId(), NoType, OpTypeBool);
104 constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
114 Instruction* type
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| MemoryDependenceAnalysis.h | 31 class Instruction;
45 /// when the instruction they previously referenced was removed from
46 /// MemDep. In either case, the entry may include an instruction pointer.
47 /// If so, the pointer is an instruction in the block where scanning can
51 /// and the instruction pointer will be null.
54 /// This is a dependence on the specified instruction which clobbers the
56 /// instruction that clobbers the memory. For example, this occurs when we
65 /// This is a dependence on the specified instruction which defines or
67 /// MemDepResult pair holds the instruction that defines the memory.
76 /// 2. For loads and stores, this could be an allocation instruction. I
[all...] |
| InstructionSimplify.h | 14 // ("and i32 %x, %x" -> "%x"). If the simplification is also an instruction
15 // then it dominates the original instruction.
42 class Instruction;
56 const Instruction *CxtI = nullptr);
65 const Instruction *CxtI = nullptr);
74 const Instruction *CxtI = nullptr);
83 const Instruction *CxtI = nullptr);
92 const Instruction *CxtI = nullptr);
100 const Instruction *CxtI = nullptr);
108 const Instruction *CxtI = nullptr)
[all...] |
| CFG.h | 26 class Instruction;
41 /// in the terminator instruction's list of successors. It is an error to call
52 /// \brief Determine whether instruction 'To' is reachable from 'From',
67 bool isPotentiallyReachable(const Instruction *From, const Instruction *To,
|
| /external/llvm/lib/Analysis/ |
| CaptureTracking.cpp | 57 /// Only find pointer captures which happen before the given instruction. Uses
58 /// the dominator tree to determine whether one instruction is before another.
60 /// as the given instruction and the use.
63 CapturesBefore(bool ReturnCaptures, const Instruction *I, DominatorTree *DT,
70 bool isSafeToPrune(Instruction *I) {
84 // The value defined by an invoke dominates an instruction only
85 // if it dominates every instruction in UseBB. A PHI is dominated only
86 // if the instruction dominates every possible use in the UseBB. Since
119 Instruction *I = cast<Instruction>(U->getUser())
[all...] |
| /external/llvm/include/llvm/IR/ |
| BasicBlock.h | 19 #include "llvm/IR/Instruction.h"
46 /// instructions followed by a single TerminatorInst instruction.
56 typedef SymbolTableList<Instruction> InstListType;
80 /// Instruction iterators...
109 /// \brief Returns the terminator instruction if the block is well formed or
114 /// \brief Returns the call instruction calling @llvm.experimental.deoptimize
115 /// prior to the terminating return instruction of this basic block, if such a
122 /// \brief Returns the call instruction marked 'musttail' prior to the
123 /// terminating return instruction of this basic block, if such a call is
130 /// \brief Returns a pointer to the first instruction in this block that i
[all...] |
| InstVisitor.h | 1 //===- InstVisitor.h - Instruction visitor templates ------------*- C++ -*-===//
24 // We operate on opaque instruction classes, so forward declare all instruction
28 #include "llvm/IR/Instruction.def"
35 /// @brief Base class for instruction visitors
37 /// Instruction visitors are used when you want to perform different actions
64 /// The defined has 'visit' methods for Instruction, and also for BasicBlock,
67 /// Note that if you don't implement visitXXX for some instruction type,
68 /// the visitXXX method for instruction superclass will be invoked. So
72 /// The optional second template argument specifies the type that instruction
[all...] |
| /external/mesa3d/src/gallium/drivers/nv50/codegen/ |
| nv50_ir_target.h | 66 // returns whether the instruction was encodable and written
67 virtual bool emitInstruction(Instruction *) = 0;
69 virtual uint32_t getMinEncodingSize(const Instruction *) const = 0;
161 inline const OpInfo& getOpInfo(const Instruction *) const;
166 virtual bool insnCanLoad(const Instruction *insn, int s,
167 const Instruction *ld) const = 0;
170 virtual bool isModSupported(const Instruction *,
172 virtual bool isSatSupported(const Instruction *) const = 0;
175 virtual bool mayPredicate(const Instruction *,
179 virtual bool canDualIssue(const Instruction *insn
[all...] |
| /device/linaro/bootloader/edk2/MdePkg/Library/BasePeCoffLib/Arm/ |
| PeCoffLoaderEx.c | 22 return the immediate data encoded in the instruction.
24 @param Instruction Pointer to ARM MOVT or MOVW immediate instruction
26 @return Immediate address encoded in the instruction
31 IN UINT16 *Instruction
37 // Thumb2 is two 16-bit instructions working together. Not a single 32-bit instruction
39 Movt = (*Instruction << 16) | (*(Instruction + 1));
54 Update an ARM MOVT or MOVW immediate instruction immediate data.
56 @param Instruction Pointer to ARM MOVT or MOVW immediate instruction
[all...] |
| /external/llvm/lib/Target/Hexagon/ |
| HexagonOptimizeSZextends.cpp | 84 Instruction* Use = cast<Instruction>(*UI);
90 Instruction* First = &F.getEntryBlock().front();
112 if (!(Ashr && Ashr->getOpcode() == Instruction::AShr))
121 Instruction *Shl = dyn_cast<Instruction>(Ashr->getOperand(0));
122 if (!(Shl && Shl->getOpcode() == Instruction::Shl))
139 if (Instruction *J = dyn_cast<Instruction>(TheUse.getUser())) {
|
| /art/runtime/ |
| dex_instruction_visitor.h | 33 const Instruction* inst = Instruction::At(&code[i]);
36 case Instruction::cname: { \
52 // Specific handlers for each instruction.
54 void Do_ ## cname(const Instruction* inst) { \
63 // The default instruction handler.
64 void Do_Default(const Instruction*) {
|
| /external/llvm/include/llvm/Transforms/Utils/ |
| LoopVersioning.h | 63 void versionLoop(const SmallVectorImpl<Instruction *> &DefsUsedOutside);
94 /// \p OrigInst is the instruction corresponding to \p VersionedInst in the
97 void annotateInstWithNoAlias(Instruction *VersionedInst,
98 const Instruction *OrigInst);
106 void addPHINodes(const SmallVectorImpl<Instruction *> &DefsUsedOutside);
110 void annotateInstWithNoAlias(Instruction *I) {
|
| /external/proguard/src/proguard/optimize/peephole/ |
| InstructionSequencesReplacer.java | 25 import proguard.classfile.instruction.Instruction;
26 import proguard.classfile.instruction.visitor.*;
29 * This InstructionVisitor replaces multiple instruction sequences at once.
45 * instruction.
46 * @param instructionSequences the instruction sequences to be replaced,
49 * and the instruction index in the sequence.
57 Instruction[][][] instructionSequences,
72 * instruction.
73 * @param instructionSequences the instruction sequences to be replaced
[all...] |
| /external/swiftshader/third_party/LLVM/include/llvm/Analysis/ |
| MemoryDependenceAnalysis.h | 29 class Instruction;
45 /// Clobber - This is a dependence on the specified instruction which
47 /// pair holds the instruction that clobbers the memory. For example,
57 /// Def - This is a dependence on the specified instruction which
59 /// the MemDepResult pair holds the instruction that defines the memory.
67 /// 2. For loads and stores, this could be an allocation instruction. In
78 /// upper part of the pair (i.e. the Instruction*)
82 /// (i.e. the Instruction* part) is instead used to encode more detailed
97 typedef PointerIntPair<Instruction*, 2, DepType> PairTy;
105 static MemDepResult getDef(Instruction *Inst)
[all...] |
| /external/swiftshader/third_party/LLVM/include/llvm/Transforms/Utils/ |
| Local.h | 24 class Instruction;
42 /// ConstantFoldTerminator - If a terminator instruction is predicated on a
56 /// instruction is not used, and the instruction has no side effects.
58 bool isInstructionTriviallyDead(Instruction *I);
61 /// trivially dead instruction, delete it. If that makes any of its operands
68 /// either forms a cycle or is terminated by a trivially dead instruction,
137 /// Instruction and replaces it with a slot in the stack frame, allocated via
142 AllocaInst *DemoteRegToStack(Instruction &X,
144 Instruction *AllocaPoint = 0)
[all...] |
| /external/v8/src/compiler/ |
| code-generator.h | 9 #include "src/compiler/instruction.h"
39 InstructionOperandIterator(Instruction* instr, size_t pos)
42 Instruction* instruction() const { return instr_; } function in class:v8::internal::compiler::InstructionOperandIterator
46 Instruction* instr_;
100 // Assemble code for the specified instruction.
101 CodeGenResult AssembleInstruction(Instruction* instr,
103 void AssembleSourcePosition(Instruction* instr);
104 void AssembleGaps(Instruction* instr);
106 // Returns true if a instruction is a tail call that needs to adjust the stac
[all...] |
| /external/swiftshader/third_party/LLVM/lib/Transforms/InstCombine/ |
| InstCombineCasts.cpp | 43 if (I->getOpcode() == Instruction::Shl) {
50 if (I->getOpcode() == Instruction::Mul) {
57 if (I->getOpcode() == Instruction::Add) {
76 /// PromoteCastOfAllocation - If we find a cast of an allocation instruction,
78 Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
142 // New is the allocation instruction, pointer typed. AI is the original
143 // allocation instruction, also pointer typed. Thus, cast to use is BitCast.
165 // Otherwise, it must be an instruction.
166 Instruction *I = cast<Instruction>(V)
[all...] |
| /art/runtime/verifier/ |
| method_verifier.cc | 622 const Instruction* inst = Instruction::At(code_item->insns_);
626 if (inst->Opcode() == Instruction::MONITOR_ENTER) {
689 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
729 const Instruction* inst = Instruction::At(code_item_->insns_ + dex_pc);
730 const bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE_QUICK);
[all...] |
| /external/llvm/lib/Transforms/InstCombine/ |
| InstCombineShifts.cpp | 24 Instruction *InstCombiner::commonShiftTransforms(BinaryOperator &I) {
35 if (Instruction *R = FoldOpIntoSelect(I, SI))
39 if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I))
62 Instruction *SecondShift, InstCombiner &IC,
63 Instruction *CxtI) {
64 assert(SecondShift->isLogicalShift() && "Unexpected instruction type");
72 bool IsSecondShiftLeft = SecondShift->getOpcode() == Instruction::Shl;
116 InstCombiner &IC, Instruction *CxtI) {
121 Instruction *I = dyn_cast<Instruction>(V)
[all...] |
