/art/compiler/optimizing/ |
H A D | locations.cc | 23 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 D | ssa_type_propagation.cc | 35 // 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 D | ssa_builder.cc | 124 // - 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 D | pretty_printer.h | 29 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 D | graph_visualizer.cc | 123 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 D | nodes.cc | 291 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 D | ssa_liveness_analysis.cc | 95 // 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 D | code_generator.cc | 146 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 D | builder.cc | 39 * 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 D | register_allocator.cc | 116 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 D | code_generator_arm.cc | 455 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 D | code_generator_x86.cc | 423 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 840 HConstant* instruction = locations->InAt(1).GetConstant(); local 913 HConstant* instruction = locations->InAt(1).GetConstant(); local 952 VisitNewInstance(HNewInstance* instruction) argument 962 VisitNewInstance(HNewInstance* instruction) argument 974 VisitParameterValue(HParameterValue* instruction) argument 986 VisitParameterValue(HParameterValue* instruction) argument 989 VisitNot(HNot* instruction) argument 996 VisitNot(HNot* instruction) argument 1053 VisitPhi(HPhi* instruction) argument 1062 VisitPhi(HPhi* instruction) argument 1066 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument 1085 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument 1147 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument 1154 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument 1208 VisitNullCheck(HNullCheck* instruction) argument 1216 VisitNullCheck(HNullCheck* instruction) argument 1234 VisitArrayGet(HArrayGet* instruction) argument 1242 VisitArrayGet(HArrayGet* instruction) argument 1334 VisitArraySet(HArraySet* instruction) argument 1357 VisitArraySet(HArraySet* instruction) argument 1434 VisitArrayLength(HArrayLength* instruction) argument 1441 VisitArrayLength(HArrayLength* instruction) argument 1449 VisitBoundsCheck(HBoundsCheck* instruction) argument 1458 VisitBoundsCheck(HBoundsCheck* instruction) argument 1479 VisitParallelMove(HParallelMove* instruction) argument 1483 VisitParallelMove(HParallelMove* instruction) argument 1520 HIntConstant* instruction = source.GetConstant()->AsIntConstant(); local [all...] |
H A D | code_generator_x86_64.cc | 307 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 787 HConstant* instruction = locations->InAt(1).GetConstant(); local 853 HConstant* instruction = locations->InAt(1).GetConstant(); local 880 VisitNewInstance(HNewInstance* instruction) argument 887 VisitNewInstance(HNewInstance* instruction) argument 899 VisitParameterValue(HParameterValue* instruction) argument 911 VisitParameterValue(HParameterValue* instruction) argument 915 VisitNot(HNot* instruction) argument 922 VisitNot(HNot* instruction) argument 929 VisitPhi(HPhi* instruction) argument 938 VisitPhi(HPhi* instruction) argument 942 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument 954 VisitInstanceFieldSet(HInstanceFieldSet* instruction) argument 999 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument 1006 VisitInstanceFieldGet(HInstanceFieldGet* instruction) argument 1053 VisitNullCheck(HNullCheck* instruction) argument 1061 VisitNullCheck(HNullCheck* instruction) argument 1079 VisitArrayGet(HArrayGet* instruction) argument 1087 VisitArrayGet(HArrayGet* instruction) argument 1176 VisitArraySet(HArraySet* instruction) argument 1193 VisitArraySet(HArraySet* instruction) argument 1266 VisitArrayLength(HArrayLength* instruction) argument 1273 VisitArrayLength(HArrayLength* instruction) argument 1281 VisitBoundsCheck(HBoundsCheck* instruction) argument 1290 VisitBoundsCheck(HBoundsCheck* instruction) argument 1326 VisitParallelMove(HParallelMove* instruction) argument 1330 VisitParallelMove(HParallelMove* instruction) argument [all...] |
H A D | ssa_liveness_analysis.h | 50 * 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 D | instruction_tools.cc | 21 bool InstructionTools::IsDefinition(const art::Instruction* const instruction) { argument 22 if (0 != (InstructionTools::instruction_attributes_[instruction->Opcode()] & (1 << kDA))) {
|
H A D | visitor.h | 52 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 D | disassembler_arm64.cc | 35 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 D | disassembler_mips.cc | 34 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 D | type_inference_visitor.h | 27 // 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 D | type_inference_visitor.cc | 38 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 D | dot_gen.cc | 44 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 D | dot_gen.h | 45 // 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 D | code_gen.h | 58 // 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 D | code_gen.cc | 118 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 D | inline_method_analyser.cc | 92 // 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...] |