Searched defs:instruction (Results 1 - 25 of 29) sorted by relevance

12

/art/compiler/optimizing/
H A Dlocations.cc23 LocationSummary::LocationSummary(HInstruction* instruction) argument
24 : inputs_(instruction->GetBlock()->GetGraph()->GetArena(), instruction->InputCount()),
25 temps_(instruction->GetBlock()->GetGraph()->GetArena(), 0) {
26 inputs_.SetSize(instruction->InputCount());
27 for (size_t i = 0; i < instruction->InputCount(); i++) {
33 Location Location::RegisterOrConstant(HInstruction* instruction) { argument
34 return instruction->IsConstant()
35 ? Location::ConstantLocation(instruction->AsConstant())
H A Dssa_type_propagation.cc35 // Re-compute and update the type of the instruction. Returns
77 HPhi* instruction = worklist_.Pop(); local
78 if (UpdateType(instruction)) {
79 AddDependentInstructionsToWorklist(instruction);
84 void SsaTypePropagation::AddToWorklist(HPhi* instruction) { argument
85 worklist_.Add(instruction);
88 void SsaTypePropagation::AddDependentInstructionsToWorklist(HPhi* instruction) { argument
89 for (HUseIterator<HInstruction> it(instruction->GetUses()); !it.Done(); it.Advance()) {
H A Dssa_builder.cc124 // - HStoreLocal: update current value of the local and remove the instruction.
142 void SsaBuilder::VisitInstruction(HInstruction* instruction) { argument
143 if (!instruction->NeedsEnvironment()) {
149 instruction->SetEnvironment(environment);
H A Dpretty_printer.h29 void PrintPreInstruction(HInstruction* instruction) { argument
31 PrintInt(instruction->GetId());
35 virtual void VisitInstruction(HInstruction* instruction) { argument
36 PrintPreInstruction(instruction);
37 PrintString(instruction->DebugName());
38 PrintPostInstruction(instruction);
41 void PrintPostInstruction(HInstruction* instruction) { argument
42 if (instruction->InputCount() != 0) {
45 for (HInputIterator it(instruction); !it.Done(); it.Advance()) {
55 if (instruction
[all...]
H A Dgraph_visualizer.cc123 void VisitParallelMove(HParallelMove* instruction) { argument
124 output_ << instruction->DebugName();
126 for (size_t i = 0, e = instruction->NumMoves(); i < e; ++i) {
127 MoveOperands* move = instruction->MoveOperandsAt(i);
138 void VisitInstruction(HInstruction* instruction) { argument
139 output_ << instruction->DebugName();
140 if (instruction->InputCount() > 0) {
142 for (HInputIterator inputs(instruction); !inputs.Done(); inputs.Advance()) {
147 if (pass_name_ == kLivenessPassName && instruction->GetLifetimePosition() != kNoLifetime) {
148 output_ << " (liveness: " << instruction
175 HInstruction* instruction = it.Current(); local
216 HInstruction* instruction = it.Current(); local
[all...]
H A Dnodes.cc291 void HBasicBlock::InsertInstructionBefore(HInstruction* instruction, HInstruction* cursor) { argument
293 DCHECK(instruction->AsPhi() == nullptr);
294 DCHECK_EQ(instruction->GetId(), -1);
297 DCHECK(!instruction->IsControlFlow());
298 instruction->next_ = cursor;
299 instruction->previous_ = cursor->previous_;
300 cursor->previous_ = instruction;
302 instructions_.first_instruction_ = instruction;
304 instruction->previous_->next_ = instruction;
310 Add(HInstructionList* instruction_list, HBasicBlock* block, HInstruction* instruction) argument
320 AddInstruction(HInstruction* instruction) argument
328 Remove(HInstructionList* instruction_list, HBasicBlock* block, HInstruction* instruction) argument
342 RemoveInstruction(HInstruction* instruction) argument
366 AddInstruction(HInstruction* instruction) argument
380 RemoveInstruction(HInstruction* instruction) argument
[all...]
H A Dssa_liveness_analysis.cc95 // Each instruction gets a lifetime position, and a block gets a lifetime
101 // to differentiate between the start and end of an instruction. Adding 2 to
102 // the lifetime position for each instruction ensures the start of an
103 // instruction is different than the end of the previous instruction.
166 // that instruction is defined, and killing instructions that are being visited.
198 // Kill the instruction and shorten its interval.
204 // All inputs of an instruction must be live.
219 HInstruction* instruction = environment->Get(i); local
220 if (instruction !
[all...]
H A Dcode_generator.cc146 void CodeGenerator::AllocateRegistersLocally(HInstruction* instruction) const {
147 LocationSummary* locations = instruction->GetLocations();
178 HInstruction* input = instruction->InputAt(i);
215 AllocateFreeRegister(instruction->GetType(), blocked_registers_));
225 void CodeGenerator::InitLocations(HInstruction* instruction) { argument
226 if (instruction->GetLocations() == nullptr) {
227 if (instruction->IsTemporary()) {
228 HInstruction* previous = instruction->GetPrevious();
229 Location temp_location = GetTemporaryLocation(instruction->AsTemporary());
230 Move(previous, temp_location, instruction);
[all...]
H A Dbuilder.cc39 * converting a DEX instruction to multiple HInstruction, and where those
40 * instructions do not die at the following instruction, but instead spans
49 void Add(HInstruction* instruction) { argument
51 DCHECK(instruction->GetType() != Primitive::kPrimLong
52 && instruction->GetType() != Primitive::kPrimDouble);
54 instruction->GetBlock()->AddInstruction(temp);
55 DCHECK(temp->GetPrevious() == instruction);
140 void HGraphBuilder::If_22t(const Instruction& instruction, uint32_t dex_offset) { argument
141 HInstruction* first = LoadLocal(instruction.VRegA(), Primitive::kPrimInt);
142 HInstruction* second = LoadLocal(instruction
157 If_21t(const Instruction& instruction, uint32_t dex_offset) argument
203 const Instruction& instruction = *Instruction::At(code_ptr); local
246 const Instruction& instruction = *Instruction::At(code_ptr); local
273 Binop_23x(const Instruction& instruction, Primitive::Type type) argument
281 Binop_12x(const Instruction& instruction, Primitive::Type type) argument
289 Binop_22s(const Instruction& instruction, bool reverse) argument
300 Binop_22b(const Instruction& instruction, bool reverse) argument
310 BuildReturn(const Instruction& instruction, Primitive::Type type) argument
321 BuildInvoke(const Instruction& instruction, uint32_t dex_offset, uint32_t method_idx, uint32_t number_of_vreg_arguments, bool is_range, uint32_t* args, uint32_t register_index) argument
381 BuildFieldAccess(const Instruction& instruction, uint32_t dex_offset, bool is_put) argument
428 BuildArrayAccess(const Instruction& instruction, uint32_t dex_offset, bool is_put, Primitive::Type anticipated_type) argument
463 AnalyzeDexInstruction(const Instruction& instruction, int32_t dex_offset) argument
782 HIntConstant* instruction = new (arena_) HIntConstant(constant); local
790 HLongConstant* instruction = new (arena_) HLongConstant(constant); local
[all...]
H A Dregister_allocator.cc116 HInstruction* instruction = liveness_.GetInstructionFromSsaIndex(i - 1); local
117 LiveInterval* current = instruction->GetLiveInterval();
121 LocationSummary* locations = instruction->GetLocations();
136 size_t position = instruction->GetLifetimePosition();
141 BlockRegister(output, position, position + 1, instruction->GetType());
145 for (size_t i = 0; i < instruction->InputCount(); ++i) {
148 BlockRegister(input, position, position + 1, instruction->InputAt(i)->GetType());
154 DCHECK(instruction->IsParameterValue());
156 } else if (current->HasSpillSlot() || instruction->IsConstant()) {
209 HInstruction* instruction local
671 IsInputMove(HInstruction* instruction) argument
675 AddInputMoveFor(HInstruction* instruction, Location source, Location destination) const argument
779 InsertMoveAfter(HInstruction* instruction, Location source, Location destination) const argument
914 HInstruction* instruction = liveness_.GetInstructionFromSsaIndex(i); local
947 HInstruction* instruction = liveness_.GetInstructionFromSsaIndex(i); local
[all...]
H A Dcode_generator_arm.cc455 void CodeGeneratorARM::Move(HInstruction* instruction, Location location, HInstruction* move_for) { argument
456 LocationSummary* locations = instruction->GetLocations();
461 if (instruction->AsIntConstant() != nullptr) {
462 int32_t value = instruction->AsIntConstant()->GetValue();
470 } else if (instruction->AsLongConstant() != nullptr) {
471 int64_t value = instruction->AsLongConstant()->GetValue();
482 } else if (instruction->AsLoadLocal() != nullptr) {
483 uint32_t stack_slot = GetStackSlot(instruction->AsLoadLocal()->GetLocal());
484 switch (instruction->GetType()) {
499 LOG(FATAL) << "Unimplemented type " << instruction
987 VisitNewInstance(HNewInstance* instruction) argument
997 VisitNewInstance(HNewInstance* instruction) argument
1010 VisitParameterValue(HParameterValue* instruction) argument
1022 VisitParameterValue(HParameterValue* instruction) argument
1026 VisitNot(HNot* instruction) argument
1033 VisitNot(HNot* instruction) argument
1083 VisitPhi(HPhi* instruction) argument
1092 VisitPhi(HPhi* instruction) argument
1096 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument
1108 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument
1156 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument
1163 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument
1216 VisitNullCheck(HNullCheck* instruction) argument
1224 VisitNullCheck(HNullCheck* instruction) argument
1239 VisitArrayGet(HArrayGet* instruction) argument
1247 VisitArrayGet(HArrayGet* instruction) argument
1342 VisitArraySet(HArraySet* instruction) argument
1359 VisitArraySet(HArraySet* instruction) argument
1438 VisitArrayLength(HArrayLength* instruction) argument
1445 VisitArrayLength(HArrayLength* instruction) argument
1453 VisitBoundsCheck(HBoundsCheck* instruction) argument
1462 VisitBoundsCheck(HBoundsCheck* instruction) argument
1492 VisitParallelMove(HParallelMove* instruction) argument
1496 VisitParallelMove(HParallelMove* instruction) argument
[all...]
H A Dcode_generator_x86.cc423 void CodeGeneratorX86::Move(HInstruction* instruction, Location location, HInstruction* move_for) { argument
424 if (instruction->AsIntConstant() != nullptr) {
425 Immediate imm(instruction->AsIntConstant()->GetValue());
431 } else if (instruction->AsLongConstant() != nullptr) {
432 int64_t value = instruction->AsLongConstant()->GetValue();
440 } else if (instruction->AsLoadLocal() != nullptr) {
441 switch (instruction->GetType()) {
448 Move32(location, Location::StackSlot(GetStackSlot(instruction->AsLoadLocal()->GetLocal())));
453 GetStackSlot(instruction->AsLoadLocal()->GetLocal())));
457 LOG(FATAL) << "Unimplemented local type " << instruction
536 HIntConstant* instruction = rhs.GetConstant()->AsIntConstant(); local
608 HConstant* instruction = locations->InAt(1).GetConstant(); local
839 HConstant* instruction = locations->InAt(1).GetConstant(); local
912 HConstant* instruction = locations->InAt(1).GetConstant(); local
951 VisitNewInstance(HNewInstance* instruction) argument
961 VisitNewInstance(HNewInstance* instruction) argument
973 VisitParameterValue(HParameterValue* instruction) argument
985 VisitParameterValue(HParameterValue* instruction) argument
988 VisitNot(HNot* instruction) argument
995 VisitNot(HNot* instruction) argument
1052 VisitPhi(HPhi* instruction) argument
1061 VisitPhi(HPhi* instruction) argument
1065 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument
1084 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument
1146 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument
1153 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument
1207 VisitNullCheck(HNullCheck* instruction) argument
1215 VisitNullCheck(HNullCheck* instruction) argument
1233 VisitArrayGet(HArrayGet* instruction) argument
1241 VisitArrayGet(HArrayGet* instruction) argument
1333 VisitArraySet(HArraySet* instruction) argument
1356 VisitArraySet(HArraySet* instruction) argument
1433 VisitArrayLength(HArrayLength* instruction) argument
1440 VisitArrayLength(HArrayLength* instruction) argument
1448 VisitBoundsCheck(HBoundsCheck* instruction) argument
1457 VisitBoundsCheck(HBoundsCheck* instruction) argument
1478 VisitParallelMove(HParallelMove* instruction) argument
1482 VisitParallelMove(HParallelMove* instruction) argument
1519 HIntConstant* instruction = source.GetConstant()->AsIntConstant(); local
[all...]
H A Dcode_generator_x86_64.cc307 void CodeGeneratorX86_64::Move(HInstruction* instruction, argument
310 if (instruction->AsIntConstant() != nullptr) {
311 Immediate imm(instruction->AsIntConstant()->GetValue());
317 } else if (instruction->AsLongConstant() != nullptr) {
318 int64_t value = instruction->AsLongConstant()->GetValue();
325 } else if (instruction->AsLoadLocal() != nullptr) {
326 switch (instruction->GetType()) {
333 Move(location, Location::StackSlot(GetStackSlot(instruction->AsLoadLocal()->GetLocal())));
337 Move(location, Location::DoubleStackSlot(GetStackSlot(instruction->AsLoadLocal()->GetLocal())));
341 LOG(FATAL) << "Unimplemented local type " << instruction
786 HConstant* instruction = locations->InAt(1).GetConstant(); local
852 HConstant* instruction = locations->InAt(1).GetConstant(); local
879 VisitNewInstance(HNewInstance* instruction) argument
886 VisitNewInstance(HNewInstance* instruction) argument
898 VisitParameterValue(HParameterValue* instruction) argument
910 VisitParameterValue(HParameterValue* instruction) argument
914 VisitNot(HNot* instruction) argument
921 VisitNot(HNot* instruction) argument
928 VisitPhi(HPhi* instruction) argument
937 VisitPhi(HPhi* instruction) argument
941 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument
953 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument
998 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument
1005 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument
1052 VisitNullCheck(HNullCheck* instruction) argument
1060 VisitNullCheck(HNullCheck* instruction) argument
1078 VisitArrayGet(HArrayGet* instruction) argument
1086 VisitArrayGet(HArrayGet* instruction) argument
1175 VisitArraySet(HArraySet* instruction) argument
1192 VisitArraySet(HArraySet* instruction) argument
1265 VisitArrayLength(HArrayLength* instruction) argument
1272 VisitArrayLength(HArrayLength* instruction) argument
1280 VisitBoundsCheck(HBoundsCheck* instruction) argument
1289 VisitBoundsCheck(HBoundsCheck* instruction) argument
1325 VisitParallelMove(HParallelMove* instruction) argument
1329 VisitParallelMove(HParallelMove* instruction) argument
[all...]
H A Dssa_liveness_analysis.h50 * A live range contains the start and end of a range where an instruction
131 * An interval is a list of disjoint live ranges where an instruction is live.
132 * Each instruction that has uses gets an interval.
158 void AddUse(HInstruction* instruction, size_t input_index, bool is_environment) { argument
159 // Set the use within the instruction.
160 // TODO: Use the instruction's location to know whether the instruction can die
162 size_t position = instruction->GetLifetimePosition() + 1;
163 size_t start_block_position = instruction->GetBlock()->GetLifetimeStart();
164 size_t end_block_position = instruction
183 AddPhiUse(HInstruction* instruction, size_t input_index, HBasicBlock* block) argument
[all...]
/art/compiler/sea_ir/ir/
H A Dinstruction_tools.cc21 bool InstructionTools::IsDefinition(const art::Instruction* const instruction) { argument
22 if (0 != (InstructionTools::instruction_attributes_[instruction->Opcode()] & (1 << kDA))) {
H A Dvisitor.h52 virtual void Visit(ConstInstructionNode* instruction) = 0;
53 virtual void Visit(UnnamedConstInstructionNode* instruction) = 0;
54 virtual void Visit(ReturnInstructionNode* instruction) = 0;
55 virtual void Visit(IfNeInstructionNode* instruction) = 0;
56 virtual void Visit(MoveResultInstructionNode* instruction) = 0;
57 virtual void Visit(InvokeStaticInstructionNode* instruction) = 0;
58 virtual void Visit(AddIntInstructionNode* instruction) = 0;
59 virtual void Visit(GotoInstructionNode* instruction) = 0;
60 virtual void Visit(IfEqzInstructionNode* instruction) = 0;
70 virtual void Traverse(ConstInstructionNode* instruction) { } argument
71 Traverse(ReturnInstructionNode* instruction) argument
72 Traverse(IfNeInstructionNode* instruction) argument
73 Traverse(AddIntLit8InstructionNode* instruction) argument
74 Traverse(MoveResultInstructionNode* instruction) argument
75 Traverse(InvokeStaticInstructionNode* instruction) argument
76 Traverse(AddIntInstructionNode* instruction) argument
77 Traverse(GotoInstructionNode* instruction) argument
78 Traverse(IfEqzInstructionNode* instruction) argument
[all...]
/art/disassembler/
H A Ddisassembler_arm64.cc35 uint32_t instruction = ReadU32(begin); local
36 decoder.Decode(reinterpret_cast<vixl::Instruction*>(&instruction));
38 << StringPrintf(": %08x\t%s\n", instruction, disasm.GetOutput());
H A Ddisassembler_mips.cc34 bool Matches(uint32_t instruction) const {
35 return (instruction & mask) == value;
172 uint32_t instruction = ReadU32(instr_ptr); local
174 uint32_t rs = (instruction >> 21) & 0x1f; // I-type, R-type.
175 uint32_t rt = (instruction >> 16) & 0x1f; // I-type, R-type.
176 uint32_t rd = (instruction >> 11) & 0x1f; // R-type.
177 uint32_t sa = (instruction >> 6) & 0x1f; // R-type.
183 uint32_t op = (instruction >> 26) & 0x3f;
184 uint32_t function = (instruction & 0x3f); // R-type.
188 if (gMipsInstructions[i].Matches(instruction)) {
[all...]
/art/compiler/sea_ir/types/
H A Dtype_inference_visitor.h27 // The TypeInferenceVisitor visits each instruction and computes its type taking into account
46 void Visit(PhiInstructionNode* instruction);
48 void Visit(InstructionNode* instruction) { } argument
49 void Visit(UnnamedConstInstructionNode* instruction);
50 void Visit(ConstInstructionNode* instruction) { } argument
51 void Visit(ReturnInstructionNode* instruction) { } argument
52 void Visit(IfNeInstructionNode* instruction) { } argument
53 void Visit(MoveResultInstructionNode* instruction);
54 void Visit(InvokeStaticInstructionNode* instruction);
55 void Visit(AddIntInstructionNode* instruction);
56 Visit(GotoInstructionNode* instruction) argument
57 Visit(IfEqzInstructionNode* instruction) argument
[all...]
H A Dtype_inference_visitor.cc38 void TypeInferenceVisitor::Visit(UnnamedConstInstructionNode* instruction) { argument
42 void TypeInferenceVisitor::Visit(PhiInstructionNode* instruction) { argument
43 std::vector<const Type*> types_to_merge = GetOperandTypes(instruction);
48 void TypeInferenceVisitor::Visit(AddIntInstructionNode* instruction) { argument
49 std::vector<const Type*> operand_types = GetOperandTypes(instruction);
59 void TypeInferenceVisitor::Visit(MoveResultInstructionNode* instruction) { argument
60 std::vector<const Type*> operand_types = GetOperandTypes(instruction);
65 void TypeInferenceVisitor::Visit(InvokeStaticInstructionNode* instruction) { argument
66 FunctionTypeInfo fti(graph_, instruction, type_cache_);
72 InstructionNode* instruction) cons
[all...]
/art/compiler/sea_ir/debug/
H A Ddot_gen.cc44 void DotGenerationVisitor::ToDotSSAEdges(InstructionNode* instruction) { argument
45 std::map<int, InstructionNode*>* definition_edges = instruction->GetSSAProducersMap();
52 dot_text_ += instruction->StringId() + "[color=gray,label=\"";
67 std::vector<InstructionNode*>* used_in = instruction->GetSSAConsumers();
70 dot_text_ += (*cit)->StringId() + " -> " + instruction->StringId() + "[color=gray,label=\"";
76 void DotGenerationVisitor::ToDotSSAEdges(PhiInstructionNode* instruction) { argument
77 std::vector<InstructionNode*> definition_edges = instruction->GetSSAProducers();
84 dot_text_ += instruction->StringId() + "[color=gray,label=\"";
85 dot_text_ += art::StringPrintf("vR = %d", instruction->GetRegisterNumber());
99 std::vector<InstructionNode*>* used_in = instruction
149 Visit(InstructionNode* instruction) argument
157 Visit(UnnamedConstInstructionNode* instruction) argument
[all...]
H A Ddot_gen.h45 // Saves the ssa def->use edges corresponding to @instruction.
46 void ToDotSSAEdges(InstructionNode* instruction);
47 void ToDotSSAEdges(PhiInstructionNode* instruction);
57 void Visit(InstructionNode* instruction);
59 void Visit(UnnamedConstInstructionNode* instruction);
61 void Visit(ConstInstructionNode* instruction) { argument
62 Visit(reinterpret_cast<InstructionNode*>(instruction));
64 void Visit(ReturnInstructionNode* instruction) { argument
65 Visit(reinterpret_cast<InstructionNode*>(instruction));
67 void Visit(IfNeInstructionNode* instruction) { argument
70 Visit(MoveResultInstructionNode* instruction) argument
73 Visit(InvokeStaticInstructionNode* instruction) argument
76 Visit(AddIntInstructionNode* instruction) argument
79 Visit(GotoInstructionNode* instruction) argument
82 Visit(IfEqzInstructionNode* instruction) argument
[all...]
/art/compiler/sea_ir/code_gen/
H A Dcode_gen.h58 // Returns the llvm::Value* corresponding to the output of @instruction.
59 llvm::Value* GetValue(InstructionNode* instruction) { argument
60 return GetValue(instruction->Id());
66 // Records @value as corresponding to the sea_ir::InstructionNode @instruction.
67 void AddValue(InstructionNode* instruction, llvm::Value* value) { argument
68 AddValue(instruction->Id(), value);
109 void Visit(InstructionNode* instruction) { } argument
111 void Visit(UnnamedConstInstructionNode* instruction) { } argument
112 void Visit(ConstInstructionNode* instruction) { } argument
113 void Visit(ReturnInstructionNode* instruction) { } argument
114 Visit(IfNeInstructionNode* instruction) argument
116 Visit(MoveResultInstructionNode* instruction) argument
117 Visit(InvokeStaticInstructionNode* instruction) argument
118 Visit(AddIntInstructionNode* instruction) argument
119 Visit(GotoInstructionNode* instruction) argument
120 Visit(IfEqzInstructionNode* instruction) argument
134 Visit(UnnamedConstInstructionNode* instruction) argument
135 Visit(ConstInstructionNode* instruction) argument
136 Visit(ReturnInstructionNode* instruction) argument
137 Visit(IfNeInstructionNode* instruction) argument
139 Visit(MoveResultInstructionNode* instruction) argument
140 Visit(InvokeStaticInstructionNode* instruction) argument
141 Visit(AddIntInstructionNode* instruction) argument
142 Visit(GotoInstructionNode* instruction) argument
143 Visit(IfEqzInstructionNode* instruction) argument
[all...]
H A Dcode_gen.cc118 void CodeGenVisitor::Visit(InstructionNode* instruction) { argument
119 std::string instr = instruction->GetInstruction()->DumpString(NULL);
123 void CodeGenVisitor::Visit(UnnamedConstInstructionNode* instruction) { argument
124 std::string instr = instruction->GetInstruction()->DumpString(NULL);
126 llvm_data_->AddValue(instruction,
127 llvm::ConstantInt::get(*llvm_data_->context_, llvm::APInt(32, instruction->GetConstValue())));
130 void CodeGenVisitor::Visit(ConstInstructionNode* instruction) { argument
131 std::string instr = instruction->GetInstruction()->DumpString(NULL);
133 llvm_data_->AddValue(instruction,
134 llvm::ConstantInt::get(*llvm_data_->context_, llvm::APInt(32, instruction
136 Visit(ReturnInstructionNode* instruction) argument
143 Visit(IfNeInstructionNode* instruction) argument
176 Visit(MoveResultInstructionNode* instruction) argument
218 Visit(AddIntInstructionNode* instruction) argument
230 Visit(GotoInstructionNode* instruction) argument
238 Visit(IfEqzInstructionNode* instruction) argument
[all...]
/art/runtime/quick/
H A Dinline_method_analyser.cc92 // We currently support only plain return or 2-instruction methods.
96 const Instruction* instruction = Instruction::At(code_item->insns_); local
97 Instruction::Code opcode = instruction->Opcode();
169 const Instruction* instruction = Instruction::At(code_item->insns_); local
170 const Instruction* return_instruction = instruction->Next();
180 int32_t const_value = instruction->VRegB();
181 if (instruction->Opcode() == Instruction::CONST_HIGH16) {
184 DCHECK_LT(instruction->VRegA(), code_item->registers_size_);
185 if (instruction->VRegA() != return_reg) {
202 const Instruction* instruction local
265 const Instruction* instruction = Instruction::At(code_item->insns_); local
[all...]

Completed in 383 milliseconds

12