diff options
| -rw-r--r-- | compiler/dex/quick/gen_common.cc | 20 | ||||
| -rw-r--r-- | compiler/optimizing/builder.cc | 188 | ||||
| -rw-r--r-- | compiler/optimizing/builder.h | 28 | ||||
| -rw-r--r-- | compiler/optimizing/code_generator_arm.cc | 47 | ||||
| -rw-r--r-- | compiler/optimizing/code_generator_x86.cc | 54 | ||||
| -rw-r--r-- | compiler/optimizing/code_generator_x86_64.cc | 50 | ||||
| -rw-r--r-- | test/Android.run-test.mk | 13 |
7 files changed, 211 insertions, 189 deletions
diff --git a/compiler/dex/quick/gen_common.cc b/compiler/dex/quick/gen_common.cc index 061ee0747a..ee523f3f5b 100644 --- a/compiler/dex/quick/gen_common.cc +++ b/compiler/dex/quick/gen_common.cc @@ -425,7 +425,11 @@ void Mir2Lir::GenFilledNewArray(CallInfo* info) { RegLocation loc = UpdateLoc(info->args[i]); if (loc.location == kLocPhysReg) { ScopedMemRefType mem_ref_type(this, ResourceMask::kDalvikReg); - Store32Disp(TargetPtrReg(kSp), SRegOffset(loc.s_reg_low), loc.reg); + if (loc.ref) { + StoreRefDisp(TargetPtrReg(kSp), SRegOffset(loc.s_reg_low), loc.reg, kNotVolatile); + } else { + Store32Disp(TargetPtrReg(kSp), SRegOffset(loc.s_reg_low), loc.reg); + } } } /* @@ -481,9 +485,17 @@ void Mir2Lir::GenFilledNewArray(CallInfo* info) { } else if (!info->is_range) { // TUNING: interleave for (int i = 0; i < elems; i++) { - RegLocation rl_arg = LoadValue(info->args[i], kCoreReg); - Store32Disp(ref_reg, - mirror::Array::DataOffset(component_size).Int32Value() + i * 4, rl_arg.reg); + RegLocation rl_arg; + if (info->args[i].ref) { + rl_arg = LoadValue(info->args[i], kRefReg); + StoreRefDisp(ref_reg, + mirror::Array::DataOffset(component_size).Int32Value() + i * 4, rl_arg.reg, + kNotVolatile); + } else { + rl_arg = LoadValue(info->args[i], kCoreReg); + Store32Disp(ref_reg, + mirror::Array::DataOffset(component_size).Int32Value() + i * 4, rl_arg.reg); + } // If the LoadValue caused a temp to be allocated, free it if (IsTemp(rl_arg.reg)) { FreeTemp(rl_arg.reg); diff --git a/compiler/optimizing/builder.cc b/compiler/optimizing/builder.cc index c29e283850..df3d57ebdf 100644 --- a/compiler/optimizing/builder.cc +++ b/compiler/optimizing/builder.cc @@ -119,37 +119,37 @@ void HGraphBuilder::InitializeParameters(uint16_t number_of_parameters) { } template<typename T> -void HGraphBuilder::If_22t(const Instruction& instruction, uint32_t dex_offset) { +void HGraphBuilder::If_22t(const Instruction& instruction, uint32_t dex_pc) { int32_t target_offset = instruction.GetTargetOffset(); - PotentiallyAddSuspendCheck(target_offset, dex_offset); + PotentiallyAddSuspendCheck(target_offset, dex_pc); HInstruction* first = LoadLocal(instruction.VRegA(), Primitive::kPrimInt); HInstruction* second = LoadLocal(instruction.VRegB(), Primitive::kPrimInt); T* comparison = new (arena_) T(first, second); current_block_->AddInstruction(comparison); HInstruction* ifinst = new (arena_) HIf(comparison); current_block_->AddInstruction(ifinst); - HBasicBlock* target = FindBlockStartingAt(dex_offset + target_offset); + HBasicBlock* target = FindBlockStartingAt(dex_pc + target_offset); DCHECK(target != nullptr); current_block_->AddSuccessor(target); - target = FindBlockStartingAt(dex_offset + instruction.SizeInCodeUnits()); + target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits()); DCHECK(target != nullptr); current_block_->AddSuccessor(target); current_block_ = nullptr; } template<typename T> -void HGraphBuilder::If_21t(const Instruction& instruction, uint32_t dex_offset) { +void HGraphBuilder::If_21t(const Instruction& instruction, uint32_t dex_pc) { int32_t target_offset = instruction.GetTargetOffset(); - PotentiallyAddSuspendCheck(target_offset, dex_offset); + PotentiallyAddSuspendCheck(target_offset, dex_pc); HInstruction* value = LoadLocal(instruction.VRegA(), Primitive::kPrimInt); T* comparison = new (arena_) T(value, GetIntConstant(0)); current_block_->AddInstruction(comparison); HInstruction* ifinst = new (arena_) HIf(comparison); current_block_->AddInstruction(ifinst); - HBasicBlock* target = FindBlockStartingAt(dex_offset + target_offset); + HBasicBlock* target = FindBlockStartingAt(dex_pc + target_offset); DCHECK(target != nullptr); current_block_->AddSuccessor(target); - target = FindBlockStartingAt(dex_offset + instruction.SizeInCodeUnits()); + target = FindBlockStartingAt(dex_pc + instruction.SizeInCodeUnits()); DCHECK(target != nullptr); current_block_->AddSuccessor(target); current_block_ = nullptr; @@ -196,13 +196,13 @@ HGraph* HGraphBuilder::BuildGraph(const DexFile::CodeItem& code_item) { InitializeParameters(code_item.ins_size_); - size_t dex_offset = 0; + size_t dex_pc = 0; while (code_ptr < code_end) { - // Update the current block if dex_offset starts a new block. - MaybeUpdateCurrentBlock(dex_offset); + // Update the current block if dex_pc starts a new block. + MaybeUpdateCurrentBlock(dex_pc); const Instruction& instruction = *Instruction::At(code_ptr); - if (!AnalyzeDexInstruction(instruction, dex_offset)) return nullptr; - dex_offset += instruction.SizeInCodeUnits(); + if (!AnalyzeDexInstruction(instruction, dex_pc)) return nullptr; + dex_pc += instruction.SizeInCodeUnits(); code_ptr += instruction.SizeInCodeUnits(); } @@ -243,25 +243,25 @@ void HGraphBuilder::ComputeBranchTargets(const uint16_t* code_ptr, const uint16_ // Iterate over all instructions and find branching instructions. Create blocks for // the locations these instructions branch to. - size_t dex_offset = 0; + size_t dex_pc = 0; while (code_ptr < code_end) { const Instruction& instruction = *Instruction::At(code_ptr); if (instruction.IsBranch()) { - int32_t target = instruction.GetTargetOffset() + dex_offset; + int32_t target = instruction.GetTargetOffset() + dex_pc; // Create a block for the target instruction. if (FindBlockStartingAt(target) == nullptr) { block = new (arena_) HBasicBlock(graph_, target); branch_targets_.Put(target, block); } - dex_offset += instruction.SizeInCodeUnits(); + dex_pc += instruction.SizeInCodeUnits(); code_ptr += instruction.SizeInCodeUnits(); - if ((code_ptr < code_end) && (FindBlockStartingAt(dex_offset) == nullptr)) { - block = new (arena_) HBasicBlock(graph_, dex_offset); - branch_targets_.Put(dex_offset, block); + if ((code_ptr < code_end) && (FindBlockStartingAt(dex_pc) == nullptr)) { + block = new (arena_) HBasicBlock(graph_, dex_pc); + branch_targets_.Put(dex_pc, block); } } else { code_ptr += instruction.SizeInCodeUnits(); - dex_offset += instruction.SizeInCodeUnits(); + dex_pc += instruction.SizeInCodeUnits(); } } } @@ -356,7 +356,7 @@ void HGraphBuilder::BuildReturn(const Instruction& instruction, Primitive::Type } bool HGraphBuilder::BuildInvoke(const Instruction& instruction, - uint32_t dex_offset, + uint32_t dex_pc, uint32_t method_idx, uint32_t number_of_vreg_arguments, bool is_range, @@ -404,7 +404,7 @@ bool HGraphBuilder::BuildInvoke(const Instruction& instruction, uintptr_t direct_method; int table_index; InvokeType optimized_invoke_type = invoke_type; - compiler_driver_->ComputeInvokeInfo(dex_compilation_unit_, dex_offset, true, true, + compiler_driver_->ComputeInvokeInfo(dex_compilation_unit_, dex_pc, true, true, &optimized_invoke_type, &target_method, &table_index, &direct_code, &direct_method); if (table_index == -1) { @@ -413,29 +413,29 @@ bool HGraphBuilder::BuildInvoke(const Instruction& instruction, if (optimized_invoke_type == kVirtual) { invoke = new (arena_) HInvokeVirtual( - arena_, number_of_arguments, return_type, dex_offset, table_index); + arena_, number_of_arguments, return_type, dex_pc, table_index); } else if (optimized_invoke_type == kInterface) { invoke = new (arena_) HInvokeInterface( - arena_, number_of_arguments, return_type, dex_offset, method_idx, table_index); + arena_, number_of_arguments, return_type, dex_pc, method_idx, table_index); } else if (optimized_invoke_type == kDirect) { // For this compiler, sharpening only works if we compile PIC. DCHECK(compiler_driver_->GetCompilerOptions().GetCompilePic()); // Treat invoke-direct like static calls for now. invoke = new (arena_) HInvokeStatic( - arena_, number_of_arguments, return_type, dex_offset, target_method.dex_method_index); + arena_, number_of_arguments, return_type, dex_pc, target_method.dex_method_index); } } else { DCHECK(invoke_type == kDirect || invoke_type == kStatic); // Treat invoke-direct like static calls for now. invoke = new (arena_) HInvokeStatic( - arena_, number_of_arguments, return_type, dex_offset, method_idx); + arena_, number_of_arguments, return_type, dex_pc, method_idx); } size_t start_index = 0; Temporaries temps(graph_); if (is_instance_call) { HInstruction* arg = LoadLocal(is_range ? register_index : args[0], Primitive::kPrimNot); - HNullCheck* null_check = new (arena_) HNullCheck(arg, dex_offset); + HNullCheck* null_check = new (arena_) HNullCheck(arg, dex_pc); current_block_->AddInstruction(null_check); temps.Add(null_check); invoke->SetArgumentAt(0, null_check); @@ -449,7 +449,7 @@ bool HGraphBuilder::BuildInvoke(const Instruction& instruction, bool is_wide = (type == Primitive::kPrimLong) || (type == Primitive::kPrimDouble); if (!is_range && is_wide && args[i] + 1 != args[i + 1]) { LOG(WARNING) << "Non sequential register pair in " << dex_compilation_unit_->GetSymbol() - << " at " << dex_offset; + << " at " << dex_pc; // We do not implement non sequential register pair. return false; } @@ -467,7 +467,7 @@ bool HGraphBuilder::BuildInvoke(const Instruction& instruction, } bool HGraphBuilder::BuildInstanceFieldAccess(const Instruction& instruction, - uint32_t dex_offset, + uint32_t dex_pc, bool is_put) { uint32_t source_or_dest_reg = instruction.VRegA_22c(); uint32_t obj_reg = instruction.VRegB_22c(); @@ -488,7 +488,7 @@ bool HGraphBuilder::BuildInstanceFieldAccess(const Instruction& instruction, Primitive::Type field_type = resolved_field->GetTypeAsPrimitiveType(); HInstruction* object = LoadLocal(obj_reg, Primitive::kPrimNot); - current_block_->AddInstruction(new (arena_) HNullCheck(object, dex_offset)); + current_block_->AddInstruction(new (arena_) HNullCheck(object, dex_pc)); if (is_put) { Temporaries temps(graph_); HInstruction* null_check = current_block_->GetLastInstruction(); @@ -514,7 +514,7 @@ bool HGraphBuilder::BuildInstanceFieldAccess(const Instruction& instruction, bool HGraphBuilder::BuildStaticFieldAccess(const Instruction& instruction, - uint32_t dex_offset, + uint32_t dex_pc, bool is_put) { uint32_t source_or_dest_reg = instruction.VRegA_21c(); uint16_t field_index = instruction.VRegB_21c(); @@ -544,12 +544,12 @@ bool HGraphBuilder::BuildStaticFieldAccess(const Instruction& instruction, } HLoadClass* constant = new (arena_) HLoadClass( - storage_index, is_referrers_class, dex_offset); + storage_index, is_referrers_class, dex_pc); current_block_->AddInstruction(constant); HInstruction* cls = constant; if (!is_initialized) { - cls = new (arena_) HClinitCheck(constant, dex_offset); + cls = new (arena_) HClinitCheck(constant, dex_pc); current_block_->AddInstruction(cls); } @@ -602,7 +602,7 @@ void HGraphBuilder::BuildCheckedDiv(uint16_t out_vreg, } void HGraphBuilder::BuildArrayAccess(const Instruction& instruction, - uint32_t dex_offset, + uint32_t dex_pc, bool is_put, Primitive::Type anticipated_type) { uint8_t source_or_dest_reg = instruction.VRegA_23x(); @@ -613,7 +613,7 @@ void HGraphBuilder::BuildArrayAccess(const Instruction& instruction, Temporaries temps(graph_); HInstruction* object = LoadLocal(array_reg, Primitive::kPrimNot); - object = new (arena_) HNullCheck(object, dex_offset); + object = new (arena_) HNullCheck(object, dex_pc); current_block_->AddInstruction(object); temps.Add(object); @@ -621,28 +621,28 @@ void HGraphBuilder::BuildArrayAccess(const Instruction& instruction, current_block_->AddInstruction(length); temps.Add(length); HInstruction* index = LoadLocal(index_reg, Primitive::kPrimInt); - index = new (arena_) HBoundsCheck(index, length, dex_offset); + index = new (arena_) HBoundsCheck(index, length, dex_pc); current_block_->AddInstruction(index); temps.Add(index); if (is_put) { HInstruction* value = LoadLocal(source_or_dest_reg, anticipated_type); // TODO: Insert a type check node if the type is Object. current_block_->AddInstruction(new (arena_) HArraySet( - object, index, value, anticipated_type, dex_offset)); + object, index, value, anticipated_type, dex_pc)); } else { current_block_->AddInstruction(new (arena_) HArrayGet(object, index, anticipated_type)); UpdateLocal(source_or_dest_reg, current_block_->GetLastInstruction()); } } -void HGraphBuilder::BuildFilledNewArray(uint32_t dex_offset, +void HGraphBuilder::BuildFilledNewArray(uint32_t dex_pc, uint32_t type_index, uint32_t number_of_vreg_arguments, bool is_range, uint32_t* args, uint32_t register_index) { HInstruction* length = GetIntConstant(number_of_vreg_arguments); - HInstruction* object = new (arena_) HNewArray(length, dex_offset, type_index); + HInstruction* object = new (arena_) HNewArray(length, dex_pc, type_index); current_block_->AddInstruction(object); const char* descriptor = dex_file_->StringByTypeIdx(type_index); @@ -660,7 +660,7 @@ void HGraphBuilder::BuildFilledNewArray(uint32_t dex_offset, HInstruction* value = LoadLocal(is_range ? register_index + i : args[i], type); HInstruction* index = GetIntConstant(i); current_block_->AddInstruction( - new (arena_) HArraySet(object, index, value, type, dex_offset)); + new (arena_) HArraySet(object, index, value, type, dex_pc)); } latest_result_ = object; } @@ -670,26 +670,26 @@ void HGraphBuilder::BuildFillArrayData(HInstruction* object, const T* data, uint32_t element_count, Primitive::Type anticipated_type, - uint32_t dex_offset) { + uint32_t dex_pc) { for (uint32_t i = 0; i < element_count; ++i) { HInstruction* index = GetIntConstant(i); HInstruction* value = GetIntConstant(data[i]); current_block_->AddInstruction(new (arena_) HArraySet( - object, index, value, anticipated_type, dex_offset)); + object, index, value, anticipated_type, dex_pc)); } } -void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t dex_offset) { +void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc) { Temporaries temps(graph_); HInstruction* array = LoadLocal(instruction.VRegA_31t(), Primitive::kPrimNot); - HNullCheck* null_check = new (arena_) HNullCheck(array, dex_offset); + HNullCheck* null_check = new (arena_) HNullCheck(array, dex_pc); current_block_->AddInstruction(null_check); temps.Add(null_check); HInstruction* length = new (arena_) HArrayLength(null_check); current_block_->AddInstruction(length); - int32_t payload_offset = instruction.VRegB_31t() + dex_offset; + int32_t payload_offset = instruction.VRegB_31t() + dex_pc; const Instruction::ArrayDataPayload* payload = reinterpret_cast<const Instruction::ArrayDataPayload*>(code_start_ + payload_offset); const uint8_t* data = payload->data; @@ -698,7 +698,7 @@ void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t // Implementation of this DEX instruction seems to be that the bounds check is // done before doing any stores. HInstruction* last_index = GetIntConstant(payload->element_count - 1); - current_block_->AddInstruction(new (arena_) HBoundsCheck(last_index, length, dex_offset)); + current_block_->AddInstruction(new (arena_) HBoundsCheck(last_index, length, dex_pc)); switch (payload->element_width) { case 1: @@ -706,27 +706,27 @@ void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t reinterpret_cast<const int8_t*>(data), element_count, Primitive::kPrimByte, - dex_offset); + dex_pc); break; case 2: BuildFillArrayData(null_check, reinterpret_cast<const int16_t*>(data), element_count, Primitive::kPrimShort, - dex_offset); + dex_pc); break; case 4: BuildFillArrayData(null_check, reinterpret_cast<const int32_t*>(data), element_count, Primitive::kPrimInt, - dex_offset); + dex_pc); break; case 8: BuildFillWideArrayData(null_check, reinterpret_cast<const int64_t*>(data), element_count, - dex_offset); + dex_pc); break; default: LOG(FATAL) << "Unknown element width for " << payload->element_width; @@ -736,12 +736,12 @@ void HGraphBuilder::BuildFillArrayData(const Instruction& instruction, uint32_t void HGraphBuilder::BuildFillWideArrayData(HInstruction* object, const int64_t* data, uint32_t element_count, - uint32_t dex_offset) { + uint32_t dex_pc) { for (uint32_t i = 0; i < element_count; ++i) { HInstruction* index = GetIntConstant(i); HInstruction* value = GetLongConstant(data[i]); current_block_->AddInstruction(new (arena_) HArraySet( - object, index, value, Primitive::kPrimLong, dex_offset)); + object, index, value, Primitive::kPrimLong, dex_pc)); } } @@ -749,7 +749,7 @@ bool HGraphBuilder::BuildTypeCheck(const Instruction& instruction, uint8_t destination, uint8_t reference, uint16_t type_index, - uint32_t dex_offset) { + uint32_t dex_pc) { bool type_known_final; bool type_known_abstract; bool is_referrers_class; @@ -760,32 +760,32 @@ bool HGraphBuilder::BuildTypeCheck(const Instruction& instruction, return false; } HInstruction* object = LoadLocal(reference, Primitive::kPrimNot); - HLoadClass* cls = new (arena_) HLoadClass(type_index, is_referrers_class, dex_offset); + HLoadClass* cls = new (arena_) HLoadClass(type_index, is_referrers_class, dex_pc); current_block_->AddInstruction(cls); // The class needs a temporary before being used by the type check. Temporaries temps(graph_); temps.Add(cls); if (instruction.Opcode() == Instruction::INSTANCE_OF) { current_block_->AddInstruction( - new (arena_) HInstanceOf(object, cls, type_known_final, dex_offset)); + new (arena_) HInstanceOf(object, cls, type_known_final, dex_pc)); UpdateLocal(destination, current_block_->GetLastInstruction()); } else { DCHECK_EQ(instruction.Opcode(), Instruction::CHECK_CAST); current_block_->AddInstruction( - new (arena_) HCheckCast(object, cls, type_known_final, dex_offset)); + new (arena_) HCheckCast(object, cls, type_known_final, dex_pc)); } return true; } -void HGraphBuilder::PotentiallyAddSuspendCheck(int32_t target_offset, uint32_t dex_offset) { +void HGraphBuilder::PotentiallyAddSuspendCheck(int32_t target_offset, uint32_t dex_pc) { if (target_offset <= 0) { // Unconditionnally add a suspend check to backward branches. We can remove // them after we recognize loops in the graph. - current_block_->AddInstruction(new (arena_) HSuspendCheck(dex_offset)); + current_block_->AddInstruction(new (arena_) HSuspendCheck(dex_pc)); } } -bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_offset) { +bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_pc) { if (current_block_ == nullptr) { return true; // Dead code } @@ -888,8 +888,8 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 } #define IF_XX(comparison, cond) \ - case Instruction::IF_##cond: If_22t<comparison>(instruction, dex_offset); break; \ - case Instruction::IF_##cond##Z: If_21t<comparison>(instruction, dex_offset); break + case Instruction::IF_##cond: If_22t<comparison>(instruction, dex_pc); break; \ + case Instruction::IF_##cond##Z: If_21t<comparison>(instruction, dex_pc); break IF_XX(HEqual, EQ); IF_XX(HNotEqual, NE); @@ -902,8 +902,8 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::GOTO_16: case Instruction::GOTO_32: { int32_t offset = instruction.GetTargetOffset(); - PotentiallyAddSuspendCheck(offset, dex_offset); - HBasicBlock* target = FindBlockStartingAt(offset + dex_offset); + PotentiallyAddSuspendCheck(offset, dex_pc); + HBasicBlock* target = FindBlockStartingAt(offset + dex_pc); DCHECK(target != nullptr); current_block_->AddInstruction(new (arena_) HGoto()); current_block_->AddSuccessor(target); @@ -940,7 +940,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 uint32_t number_of_vreg_arguments = instruction.VRegA_35c(); uint32_t args[5]; instruction.GetVarArgs(args); - if (!BuildInvoke(instruction, dex_offset, method_idx, + if (!BuildInvoke(instruction, dex_pc, method_idx, number_of_vreg_arguments, false, args, -1)) { return false; } @@ -955,7 +955,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 uint32_t method_idx = instruction.VRegB_3rc(); uint32_t number_of_vreg_arguments = instruction.VRegA_3rc(); uint32_t register_index = instruction.VRegC(); - if (!BuildInvoke(instruction, dex_offset, method_idx, + if (!BuildInvoke(instruction, dex_pc, method_idx, number_of_vreg_arguments, true, nullptr, register_index)) { return false; } @@ -1074,23 +1074,23 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::DIV_INT: { BuildCheckedDiv(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), - dex_offset, Primitive::kPrimInt, false); + dex_pc, Primitive::kPrimInt, false); break; } case Instruction::DIV_LONG: { BuildCheckedDiv(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), - dex_offset, Primitive::kPrimLong, false); + dex_pc, Primitive::kPrimLong, false); break; } case Instruction::DIV_FLOAT: { - Binop_23x<HDiv>(instruction, Primitive::kPrimFloat, dex_offset); + Binop_23x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc); break; } case Instruction::DIV_DOUBLE: { - Binop_23x<HDiv>(instruction, Primitive::kPrimDouble, dex_offset); + Binop_23x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc); break; } @@ -1181,23 +1181,23 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::DIV_INT_2ADDR: { BuildCheckedDiv(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(), - dex_offset, Primitive::kPrimInt, false); + dex_pc, Primitive::kPrimInt, false); break; } case Instruction::DIV_LONG_2ADDR: { BuildCheckedDiv(instruction.VRegA(), instruction.VRegA(), instruction.VRegB(), - dex_offset, Primitive::kPrimLong, false); + dex_pc, Primitive::kPrimLong, false); break; } case Instruction::DIV_FLOAT_2ADDR: { - Binop_12x<HDiv>(instruction, Primitive::kPrimFloat, dex_offset); + Binop_12x<HDiv>(instruction, Primitive::kPrimFloat, dex_pc); break; } case Instruction::DIV_DOUBLE_2ADDR: { - Binop_12x<HDiv>(instruction, Primitive::kPrimDouble, dex_offset); + Binop_12x<HDiv>(instruction, Primitive::kPrimDouble, dex_pc); break; } @@ -1294,13 +1294,13 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::DIV_INT_LIT16: case Instruction::DIV_INT_LIT8: { BuildCheckedDiv(instruction.VRegA(), instruction.VRegB(), instruction.VRegC(), - dex_offset, Primitive::kPrimInt, true); + dex_pc, Primitive::kPrimInt, true); break; } case Instruction::NEW_INSTANCE: { current_block_->AddInstruction( - new (arena_) HNewInstance(dex_offset, instruction.VRegB_21c())); + new (arena_) HNewInstance(dex_pc, instruction.VRegB_21c())); UpdateLocal(instruction.VRegA(), current_block_->GetLastInstruction()); break; } @@ -1308,7 +1308,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::NEW_ARRAY: { HInstruction* length = LoadLocal(instruction.VRegB_22c(), Primitive::kPrimInt); current_block_->AddInstruction( - new (arena_) HNewArray(length, dex_offset, instruction.VRegC_22c())); + new (arena_) HNewArray(length, dex_pc, instruction.VRegC_22c())); UpdateLocal(instruction.VRegA_22c(), current_block_->GetLastInstruction()); break; } @@ -1318,7 +1318,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 uint32_t type_index = instruction.VRegB_35c(); uint32_t args[5]; instruction.GetVarArgs(args); - BuildFilledNewArray(dex_offset, type_index, number_of_vreg_arguments, false, args, 0); + BuildFilledNewArray(dex_pc, type_index, number_of_vreg_arguments, false, args, 0); break; } @@ -1327,12 +1327,12 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 uint32_t type_index = instruction.VRegB_3rc(); uint32_t register_index = instruction.VRegC_3rc(); BuildFilledNewArray( - dex_offset, type_index, number_of_vreg_arguments, true, nullptr, register_index); + dex_pc, type_index, number_of_vreg_arguments, true, nullptr, register_index); break; } case Instruction::FILL_ARRAY_DATA: { - BuildFillArrayData(instruction, dex_offset); + BuildFillArrayData(instruction, dex_pc); break; } @@ -1358,7 +1358,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::IGET_BYTE: case Instruction::IGET_CHAR: case Instruction::IGET_SHORT: { - if (!BuildInstanceFieldAccess(instruction, dex_offset, false)) { + if (!BuildInstanceFieldAccess(instruction, dex_pc, false)) { return false; } break; @@ -1371,7 +1371,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::IPUT_BYTE: case Instruction::IPUT_CHAR: case Instruction::IPUT_SHORT: { - if (!BuildInstanceFieldAccess(instruction, dex_offset, true)) { + if (!BuildInstanceFieldAccess(instruction, dex_pc, true)) { return false; } break; @@ -1384,7 +1384,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::SGET_BYTE: case Instruction::SGET_CHAR: case Instruction::SGET_SHORT: { - if (!BuildStaticFieldAccess(instruction, dex_offset, false)) { + if (!BuildStaticFieldAccess(instruction, dex_pc, false)) { return false; } break; @@ -1397,7 +1397,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::SPUT_BYTE: case Instruction::SPUT_CHAR: case Instruction::SPUT_SHORT: { - if (!BuildStaticFieldAccess(instruction, dex_offset, true)) { + if (!BuildStaticFieldAccess(instruction, dex_pc, true)) { return false; } break; @@ -1405,11 +1405,11 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 #define ARRAY_XX(kind, anticipated_type) \ case Instruction::AGET##kind: { \ - BuildArrayAccess(instruction, dex_offset, false, anticipated_type); \ + BuildArrayAccess(instruction, dex_pc, false, anticipated_type); \ break; \ } \ case Instruction::APUT##kind: { \ - BuildArrayAccess(instruction, dex_offset, true, anticipated_type); \ + BuildArrayAccess(instruction, dex_pc, true, anticipated_type); \ break; \ } @@ -1425,7 +1425,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 HInstruction* object = LoadLocal(instruction.VRegB_12x(), Primitive::kPrimNot); // No need for a temporary for the null check, it is the only input of the following // instruction. - object = new (arena_) HNullCheck(object, dex_offset); + object = new (arena_) HNullCheck(object, dex_pc); current_block_->AddInstruction(object); current_block_->AddInstruction(new (arena_) HArrayLength(object)); UpdateLocal(instruction.VRegA_12x(), current_block_->GetLastInstruction()); @@ -1433,13 +1433,13 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 } case Instruction::CONST_STRING: { - current_block_->AddInstruction(new (arena_) HLoadString(instruction.VRegB_21c(), dex_offset)); + current_block_->AddInstruction(new (arena_) HLoadString(instruction.VRegB_21c(), dex_pc)); UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction()); break; } case Instruction::CONST_STRING_JUMBO: { - current_block_->AddInstruction(new (arena_) HLoadString(instruction.VRegB_31c(), dex_offset)); + current_block_->AddInstruction(new (arena_) HLoadString(instruction.VRegB_31c(), dex_pc)); UpdateLocal(instruction.VRegA_31c(), current_block_->GetLastInstruction()); break; } @@ -1456,7 +1456,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 return false; } current_block_->AddInstruction( - new (arena_) HLoadClass(type_index, is_referrers_class, dex_offset)); + new (arena_) HLoadClass(type_index, is_referrers_class, dex_pc)); UpdateLocal(instruction.VRegA_21c(), current_block_->GetLastInstruction()); break; } @@ -1469,7 +1469,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::THROW: { HInstruction* exception = LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot); - current_block_->AddInstruction(new (arena_) HThrow(exception, dex_offset)); + current_block_->AddInstruction(new (arena_) HThrow(exception, dex_pc)); // A throw instruction must branch to the exit block. current_block_->AddSuccessor(exit_block_); // We finished building this block. Set the current block to null to avoid @@ -1482,7 +1482,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 uint8_t destination = instruction.VRegA_22c(); uint8_t reference = instruction.VRegB_22c(); uint16_t type_index = instruction.VRegC_22c(); - if (!BuildTypeCheck(instruction, destination, reference, type_index, dex_offset)) { + if (!BuildTypeCheck(instruction, destination, reference, type_index, dex_pc)) { return false; } break; @@ -1491,7 +1491,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 case Instruction::CHECK_CAST: { uint8_t reference = instruction.VRegA_21c(); uint16_t type_index = instruction.VRegB_21c(); - if (!BuildTypeCheck(instruction, -1, reference, type_index, dex_offset)) { + if (!BuildTypeCheck(instruction, -1, reference, type_index, dex_pc)) { return false; } break; @@ -1501,7 +1501,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 current_block_->AddInstruction(new (arena_) HMonitorOperation( LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot), HMonitorOperation::kEnter, - dex_offset)); + dex_pc)); break; } @@ -1509,7 +1509,7 @@ bool HGraphBuilder::AnalyzeDexInstruction(const Instruction& instruction, uint32 current_block_->AddInstruction(new (arena_) HMonitorOperation( LoadLocal(instruction.VRegA_11x(), Primitive::kPrimNot), HMonitorOperation::kExit, - dex_offset)); + dex_pc)); break; } diff --git a/compiler/optimizing/builder.h b/compiler/optimizing/builder.h index b4497bf47c..799e628a78 100644 --- a/compiler/optimizing/builder.h +++ b/compiler/optimizing/builder.h @@ -76,7 +76,7 @@ class HGraphBuilder : public ValueObject { // Analyzes the dex instruction and adds HInstruction to the graph // to execute that instruction. Returns whether the instruction can // be handled. - bool AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_offset); + bool AnalyzeDexInstruction(const Instruction& instruction, uint32_t dex_pc); // Finds all instructions that start a new block, and populates branch_targets_ with // the newly created blocks. @@ -92,7 +92,7 @@ class HGraphBuilder : public ValueObject { HLocal* GetLocalAt(int register_index) const; void UpdateLocal(int register_index, HInstruction* instruction) const; HInstruction* LoadLocal(int register_index, Primitive::Type type) const; - void PotentiallyAddSuspendCheck(int32_t target_offset, uint32_t dex_offset); + void PotentiallyAddSuspendCheck(int32_t target_offset, uint32_t dex_pc); void InitializeParameters(uint16_t number_of_parameters); template<typename T> @@ -116,8 +116,8 @@ class HGraphBuilder : public ValueObject { template<typename T> void Binop_22s(const Instruction& instruction, bool reverse); - template<typename T> void If_21t(const Instruction& instruction, uint32_t dex_offset); - template<typename T> void If_22t(const Instruction& instruction, uint32_t dex_offset); + template<typename T> void If_21t(const Instruction& instruction, uint32_t dex_pc); + template<typename T> void If_22t(const Instruction& instruction, uint32_t dex_pc); void Conversion_12x(const Instruction& instruction, Primitive::Type input_type, @@ -126,26 +126,26 @@ class HGraphBuilder : public ValueObject { void BuildCheckedDiv(uint16_t out_reg, uint16_t first_reg, int64_t second_reg_or_constant, - uint32_t dex_offset, + uint32_t dex_pc, Primitive::Type type, bool second_is_lit); void BuildReturn(const Instruction& instruction, Primitive::Type type); // Builds an instance field access node and returns whether the instruction is supported. - bool BuildInstanceFieldAccess(const Instruction& instruction, uint32_t dex_offset, bool is_put); + bool BuildInstanceFieldAccess(const Instruction& instruction, uint32_t dex_pc, bool is_put); // Builds a static field access node and returns whether the instruction is supported. - bool BuildStaticFieldAccess(const Instruction& instruction, uint32_t dex_offset, bool is_put); + bool BuildStaticFieldAccess(const Instruction& instruction, uint32_t dex_pc, bool is_put); void BuildArrayAccess(const Instruction& instruction, - uint32_t dex_offset, + uint32_t dex_pc, bool is_get, Primitive::Type anticipated_type); // Builds an invocation node and returns whether the instruction is supported. bool BuildInvoke(const Instruction& instruction, - uint32_t dex_offset, + uint32_t dex_pc, uint32_t method_idx, uint32_t number_of_vreg_arguments, bool is_range, @@ -153,14 +153,14 @@ class HGraphBuilder : public ValueObject { uint32_t register_index); // Builds a new array node and the instructions that fill it. - void BuildFilledNewArray(uint32_t dex_offset, + void BuildFilledNewArray(uint32_t dex_pc, uint32_t type_index, uint32_t number_of_vreg_arguments, bool is_range, uint32_t* args, uint32_t register_index); - void BuildFillArrayData(const Instruction& instruction, uint32_t dex_offset); + void BuildFillArrayData(const Instruction& instruction, uint32_t dex_pc); // Fills the given object with data as specified in the fill-array-data // instruction. Currently only used for non-reference and non-floating point @@ -170,14 +170,14 @@ class HGraphBuilder : public ValueObject { const T* data, uint32_t element_count, Primitive::Type anticipated_type, - uint32_t dex_offset); + uint32_t dex_pc); // Fills the given object with data as specified in the fill-array-data // instruction. The data must be for long and double arrays. void BuildFillWideArrayData(HInstruction* object, const int64_t* data, uint32_t element_count, - uint32_t dex_offset); + uint32_t dex_pc); // Builds a `HInstanceOf`, or a `HCheckCast` instruction. // Returns whether we succeeded in building the instruction. @@ -185,7 +185,7 @@ class HGraphBuilder : public ValueObject { uint8_t destination, uint8_t reference, uint16_t type_index, - uint32_t dex_offset); + uint32_t dex_pc); ArenaAllocator* const arena_; diff --git a/compiler/optimizing/code_generator_arm.cc b/compiler/optimizing/code_generator_arm.cc index 0403c5e666..7444506771 100644 --- a/compiler/optimizing/code_generator_arm.cc +++ b/compiler/optimizing/code_generator_arm.cc @@ -670,13 +670,13 @@ void CodeGeneratorARM::Move32(Location destination, Location source) { __ LoadSFromOffset(destination.As<SRegister>(), SP, source.GetStackIndex()); } } else { - DCHECK(destination.IsStackSlot()); + DCHECK(destination.IsStackSlot()) << destination; if (source.IsRegister()) { __ StoreToOffset(kStoreWord, source.As<Register>(), SP, destination.GetStackIndex()); } else if (source.IsFpuRegister()) { __ StoreSToOffset(source.As<SRegister>(), SP, destination.GetStackIndex()); } else { - DCHECK(source.IsStackSlot()); + DCHECK(source.IsStackSlot()) << source; __ LoadFromOffset(kLoadWord, IP, SP, source.GetStackIndex()); __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex()); } @@ -778,26 +778,29 @@ void CodeGeneratorARM::Move(HInstruction* instruction, Location location, HInstr return; } - if (instruction->IsIntConstant()) { - int32_t value = instruction->AsIntConstant()->GetValue(); - if (location.IsRegister()) { - __ LoadImmediate(location.As<Register>(), value); - } else { - DCHECK(location.IsStackSlot()); - __ LoadImmediate(IP, value); - __ StoreToOffset(kStoreWord, IP, SP, location.GetStackIndex()); - } - } else if (instruction->IsLongConstant()) { - int64_t value = instruction->AsLongConstant()->GetValue(); - if (location.IsRegisterPair()) { - __ LoadImmediate(location.AsRegisterPairLow<Register>(), Low32Bits(value)); - __ LoadImmediate(location.AsRegisterPairHigh<Register>(), High32Bits(value)); - } else { - DCHECK(location.IsDoubleStackSlot()); - __ LoadImmediate(IP, Low32Bits(value)); - __ StoreToOffset(kStoreWord, IP, SP, location.GetStackIndex()); - __ LoadImmediate(IP, High32Bits(value)); - __ StoreToOffset(kStoreWord, IP, SP, location.GetHighStackIndex(kArmWordSize)); + if (locations != nullptr && locations->Out().IsConstant()) { + HConstant* const_to_move = locations->Out().GetConstant(); + if (const_to_move->IsIntConstant()) { + int32_t value = const_to_move->AsIntConstant()->GetValue(); + if (location.IsRegister()) { + __ LoadImmediate(location.As<Register>(), value); + } else { + DCHECK(location.IsStackSlot()); + __ LoadImmediate(IP, value); + __ StoreToOffset(kStoreWord, IP, SP, location.GetStackIndex()); + } + } else if (const_to_move->IsLongConstant()) { + int64_t value = const_to_move->AsLongConstant()->GetValue(); + if (location.IsRegisterPair()) { + __ LoadImmediate(location.AsRegisterPairLow<Register>(), Low32Bits(value)); + __ LoadImmediate(location.AsRegisterPairHigh<Register>(), High32Bits(value)); + } else { + DCHECK(location.IsDoubleStackSlot()); + __ LoadImmediate(IP, Low32Bits(value)); + __ StoreToOffset(kStoreWord, IP, SP, location.GetStackIndex()); + __ LoadImmediate(IP, High32Bits(value)); + __ StoreToOffset(kStoreWord, IP, SP, location.GetHighStackIndex(kArmWordSize)); + } } } else if (instruction->IsLoadLocal()) { uint32_t stack_slot = GetStackSlot(instruction->AsLoadLocal()->GetLocal()); diff --git a/compiler/optimizing/code_generator_x86.cc b/compiler/optimizing/code_generator_x86.cc index 0944f4c38f..6e1abbf076 100644 --- a/compiler/optimizing/code_generator_x86.cc +++ b/compiler/optimizing/code_generator_x86.cc @@ -662,27 +662,35 @@ void CodeGeneratorX86::Move64(Location destination, Location source) { } void CodeGeneratorX86::Move(HInstruction* instruction, Location location, HInstruction* move_for) { - if (instruction->IsIntConstant()) { - Immediate imm(instruction->AsIntConstant()->GetValue()); - if (location.IsRegister()) { - __ movl(location.As<Register>(), imm); - } else if (location.IsStackSlot()) { - __ movl(Address(ESP, location.GetStackIndex()), imm); - } else { - DCHECK(location.IsConstant()); - DCHECK_EQ(location.GetConstant(), instruction); - } - } else if (instruction->IsLongConstant()) { - int64_t value = instruction->AsLongConstant()->GetValue(); - if (location.IsRegisterPair()) { - __ movl(location.AsRegisterPairLow<Register>(), Immediate(Low32Bits(value))); - __ movl(location.AsRegisterPairHigh<Register>(), Immediate(High32Bits(value))); - } else if (location.IsDoubleStackSlot()) { - __ movl(Address(ESP, location.GetStackIndex()), Immediate(Low32Bits(value))); - __ movl(Address(ESP, location.GetHighStackIndex(kX86WordSize)), Immediate(High32Bits(value))); - } else { - DCHECK(location.IsConstant()); - DCHECK_EQ(location.GetConstant(), instruction); + LocationSummary* locations = instruction->GetLocations(); + if (locations != nullptr && locations->Out().Equals(location)) { + return; + } + + if (locations != nullptr && locations->Out().IsConstant()) { + HConstant* const_to_move = locations->Out().GetConstant(); + if (const_to_move->IsIntConstant()) { + Immediate imm(const_to_move->AsIntConstant()->GetValue()); + if (location.IsRegister()) { + __ movl(location.As<Register>(), imm); + } else if (location.IsStackSlot()) { + __ movl(Address(ESP, location.GetStackIndex()), imm); + } else { + DCHECK(location.IsConstant()); + DCHECK_EQ(location.GetConstant(), const_to_move); + } + } else if (const_to_move->IsLongConstant()) { + int64_t value = const_to_move->AsLongConstant()->GetValue(); + if (location.IsRegisterPair()) { + __ movl(location.AsRegisterPairLow<Register>(), Immediate(Low32Bits(value))); + __ movl(location.AsRegisterPairHigh<Register>(), Immediate(High32Bits(value))); + } else if (location.IsDoubleStackSlot()) { + __ movl(Address(ESP, location.GetStackIndex()), Immediate(Low32Bits(value))); + __ movl(Address(ESP, location.GetHighStackIndex(kX86WordSize)), Immediate(High32Bits(value))); + } else { + DCHECK(location.IsConstant()); + DCHECK_EQ(location.GetConstant(), instruction); + } } } else if (instruction->IsTemporary()) { Location temp_location = GetTemporaryLocation(instruction->AsTemporary()); @@ -723,12 +731,12 @@ void CodeGeneratorX86::Move(HInstruction* instruction, Location location, HInstr case Primitive::kPrimInt: case Primitive::kPrimNot: case Primitive::kPrimFloat: - Move32(location, instruction->GetLocations()->Out()); + Move32(location, locations->Out()); break; case Primitive::kPrimLong: case Primitive::kPrimDouble: - Move64(location, instruction->GetLocations()->Out()); + Move64(location, locations->Out()); break; default: diff --git a/compiler/optimizing/code_generator_x86_64.cc b/compiler/optimizing/code_generator_x86_64.cc index a827f99995..2393fb5119 100644 --- a/compiler/optimizing/code_generator_x86_64.cc +++ b/compiler/optimizing/code_generator_x86_64.cc @@ -584,26 +584,34 @@ void CodeGeneratorX86_64::Move(Location destination, Location source) { void CodeGeneratorX86_64::Move(HInstruction* instruction, Location location, HInstruction* move_for) { - if (instruction->IsIntConstant()) { - Immediate imm(instruction->AsIntConstant()->GetValue()); - if (location.IsRegister()) { - __ movl(location.As<CpuRegister>(), imm); - } else if (location.IsStackSlot()) { - __ movl(Address(CpuRegister(RSP), location.GetStackIndex()), imm); - } else { - DCHECK(location.IsConstant()); - DCHECK_EQ(location.GetConstant(), instruction); - } - } else if (instruction->IsLongConstant()) { - int64_t value = instruction->AsLongConstant()->GetValue(); - if (location.IsRegister()) { - __ movq(location.As<CpuRegister>(), Immediate(value)); - } else if (location.IsDoubleStackSlot()) { - __ movq(CpuRegister(TMP), Immediate(value)); - __ movq(Address(CpuRegister(RSP), location.GetStackIndex()), CpuRegister(TMP)); - } else { - DCHECK(location.IsConstant()); - DCHECK_EQ(location.GetConstant(), instruction); + LocationSummary* locations = instruction->GetLocations(); + if (locations != nullptr && locations->Out().Equals(location)) { + return; + } + + if (locations != nullptr && locations->Out().IsConstant()) { + HConstant* const_to_move = locations->Out().GetConstant(); + if (const_to_move->IsIntConstant()) { + Immediate imm(const_to_move->AsIntConstant()->GetValue()); + if (location.IsRegister()) { + __ movl(location.As<CpuRegister>(), imm); + } else if (location.IsStackSlot()) { + __ movl(Address(CpuRegister(RSP), location.GetStackIndex()), imm); + } else { + DCHECK(location.IsConstant()); + DCHECK_EQ(location.GetConstant(), const_to_move); + } + } else if (const_to_move->IsLongConstant()) { + int64_t value = const_to_move->AsLongConstant()->GetValue(); + if (location.IsRegister()) { + __ movq(location.As<CpuRegister>(), Immediate(value)); + } else if (location.IsDoubleStackSlot()) { + __ movq(CpuRegister(TMP), Immediate(value)); + __ movq(Address(CpuRegister(RSP), location.GetStackIndex()), CpuRegister(TMP)); + } else { + DCHECK(location.IsConstant()); + DCHECK_EQ(location.GetConstant(), const_to_move); + } } } else if (instruction->IsLoadLocal()) { switch (instruction->GetType()) { @@ -640,7 +648,7 @@ void CodeGeneratorX86_64::Move(HInstruction* instruction, case Primitive::kPrimLong: case Primitive::kPrimFloat: case Primitive::kPrimDouble: - Move(location, instruction->GetLocations()->Out()); + Move(location, locations->Out()); break; default: diff --git a/test/Android.run-test.mk b/test/Android.run-test.mk index a8a931313f..3b949d6ad0 100644 --- a/test/Android.run-test.mk +++ b/test/Android.run-test.mk @@ -177,15 +177,6 @@ endif TEST_ART_TIMING_SENSITIVE_RUN_TESTS := -TEST_ART_BROKEN_RUN_TESTS := \ - 004-ThreadStress - -ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \ - $(COMPILER_TYPES),$(RELOCATE_TYPES),$(TRACE_TYPES),$(GC_TYPES),$(JNI_TYPES), \ - $(IMAGE_TYPES), $(PICTEST_TYPES), $(TEST_ART_BROKEN_RUN_TESTS), $(ALL_ADDRESS_SIZES)) - -TEST_ART_BROKEN_RUN_TESTS := - # Note 116-nodex2oat is not broken per-se it just doesn't (and isn't meant to) work with --prebuild. TEST_ART_BROKEN_PREBUILD_RUN_TESTS := \ 116-nodex2oat @@ -295,8 +286,7 @@ endif TEST_ART_BROKEN_NDEBUG_TESTS := # Known broken tests for the default compiler (Quick). -TEST_ART_BROKEN_DEFAULT_RUN_TESTS := \ - 412-new-array +TEST_ART_BROKEN_DEFAULT_RUN_TESTS := ifneq (,$(filter default,$(COMPILER_TYPES))) ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \ @@ -326,6 +316,7 @@ TEST_ART_BROKEN_OPTIMIZING_ARM64_RUN_TESTS := \ 010-instance \ 011-array-copy \ 013-math2 \ + 014-math3 \ 016-intern \ 017-float \ 018-stack-overflow \ |