ART: Introduce compiler data type.
Replace most uses of the runtime's Primitive in compiler
with a new class DataType. This prepares for introducing
new types, such as Uint8, that the runtime does not need
to know about.
Test: m test-art-host-gtest
Test: testrunner.py --host
Bug: 23964345
Change-Id: Iec2ad82454eec678fffcd8279a9746b90feb9b0c
diff --git a/compiler/optimizing/code_generator_mips.cc b/compiler/optimizing/code_generator_mips.cc
index 0e6d210..a7c8557 100644
--- a/compiler/optimizing/code_generator_mips.cc
+++ b/compiler/optimizing/code_generator_mips.cc
@@ -49,30 +49,30 @@
constexpr bool kBakerReadBarrierThunksEnableForArrays = true;
constexpr bool kBakerReadBarrierThunksEnableForGcRoots = true;
-Location MipsReturnLocation(Primitive::Type return_type) {
+Location MipsReturnLocation(DataType::Type return_type) {
switch (return_type) {
- case Primitive::kPrimBoolean:
- case Primitive::kPrimByte:
- case Primitive::kPrimChar:
- case Primitive::kPrimShort:
- case Primitive::kPrimInt:
- case Primitive::kPrimNot:
+ case DataType::Type::kBool:
+ case DataType::Type::kInt8:
+ case DataType::Type::kUint16:
+ case DataType::Type::kInt16:
+ case DataType::Type::kInt32:
+ case DataType::Type::kReference:
return Location::RegisterLocation(V0);
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
return Location::RegisterPairLocation(V0, V1);
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
return Location::FpuRegisterLocation(F0);
- case Primitive::kPrimVoid:
+ case DataType::Type::kVoid:
return Location();
}
UNREACHABLE();
}
-Location InvokeDexCallingConventionVisitorMIPS::GetReturnLocation(Primitive::Type type) const {
+Location InvokeDexCallingConventionVisitorMIPS::GetReturnLocation(DataType::Type type) const {
return MipsReturnLocation(type);
}
@@ -80,16 +80,16 @@
return Location::RegisterLocation(kMethodRegisterArgument);
}
-Location InvokeDexCallingConventionVisitorMIPS::GetNextLocation(Primitive::Type type) {
+Location InvokeDexCallingConventionVisitorMIPS::GetNextLocation(DataType::Type type) {
Location next_location;
switch (type) {
- case Primitive::kPrimBoolean:
- case Primitive::kPrimByte:
- case Primitive::kPrimChar:
- case Primitive::kPrimShort:
- case Primitive::kPrimInt:
- case Primitive::kPrimNot: {
+ case DataType::Type::kBool:
+ case DataType::Type::kInt8:
+ case DataType::Type::kUint16:
+ case DataType::Type::kInt16:
+ case DataType::Type::kInt32:
+ case DataType::Type::kReference: {
uint32_t gp_index = gp_index_++;
if (gp_index < calling_convention.GetNumberOfRegisters()) {
next_location = Location::RegisterLocation(calling_convention.GetRegisterAt(gp_index));
@@ -100,7 +100,7 @@
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
uint32_t gp_index = gp_index_;
gp_index_ += 2;
if (gp_index + 1 < calling_convention.GetNumberOfRegisters()) {
@@ -123,32 +123,32 @@
// Note: both float and double types are stored in even FPU registers. On 32 bit FPU, double
// will take up the even/odd pair, while floats are stored in even regs only.
// On 64 bit FPU, both double and float are stored in even registers only.
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64: {
uint32_t float_index = float_index_++;
if (float_index < calling_convention.GetNumberOfFpuRegisters()) {
next_location = Location::FpuRegisterLocation(
calling_convention.GetFpuRegisterAt(float_index));
} else {
size_t stack_offset = calling_convention.GetStackOffsetOf(stack_index_);
- next_location = Primitive::Is64BitType(type) ? Location::DoubleStackSlot(stack_offset)
- : Location::StackSlot(stack_offset);
+ next_location = DataType::Is64BitType(type) ? Location::DoubleStackSlot(stack_offset)
+ : Location::StackSlot(stack_offset);
}
break;
}
- case Primitive::kPrimVoid:
+ case DataType::Type::kVoid:
LOG(FATAL) << "Unexpected parameter type " << type;
break;
}
// Space on the stack is reserved for all arguments.
- stack_index_ += Primitive::Is64BitType(type) ? 2 : 1;
+ stack_index_ += DataType::Is64BitType(type) ? 2 : 1;
return next_location;
}
-Location InvokeRuntimeCallingConvention::GetReturnLocation(Primitive::Type type) {
+Location InvokeRuntimeCallingConvention::GetReturnLocation(DataType::Type type) {
return MipsReturnLocation(type);
}
@@ -173,10 +173,10 @@
InvokeRuntimeCallingConvention calling_convention;
codegen->EmitParallelMoves(locations->InAt(0),
Location::RegisterLocation(calling_convention.GetRegisterAt(0)),
- Primitive::kPrimInt,
+ DataType::Type::kInt32,
locations->InAt(1),
Location::RegisterLocation(calling_convention.GetRegisterAt(1)),
- Primitive::kPrimInt);
+ DataType::Type::kInt32);
QuickEntrypointEnum entrypoint = instruction_->AsBoundsCheck()->IsStringCharAt()
? kQuickThrowStringBounds
: kQuickThrowArrayBounds;
@@ -279,7 +279,7 @@
// Move the class to the desired location.
if (out.IsValid()) {
DCHECK(out.IsRegister() && !locations->GetLiveRegisters()->ContainsCoreRegister(out.reg()));
- Primitive::Type type = instruction_->GetType();
+ DataType::Type type = instruction_->GetType();
mips_codegen->MoveLocation(out,
Location::RegisterLocation(calling_convention.GetRegisterAt(0)),
type);
@@ -372,7 +372,7 @@
&info_low->label);
}
- Primitive::Type type = instruction_->GetType();
+ DataType::Type type = instruction_->GetType();
mips_codegen->MoveLocation(locations->Out(),
Location::RegisterLocation(calling_convention.GetRegisterAt(0)),
type);
@@ -490,14 +490,14 @@
InvokeRuntimeCallingConvention calling_convention;
codegen->EmitParallelMoves(locations->InAt(0),
Location::RegisterLocation(calling_convention.GetRegisterAt(0)),
- Primitive::kPrimNot,
+ DataType::Type::kReference,
locations->InAt(1),
Location::RegisterLocation(calling_convention.GetRegisterAt(1)),
- Primitive::kPrimNot);
+ DataType::Type::kReference);
if (instruction_->IsInstanceOf()) {
mips_codegen->InvokeRuntime(kQuickInstanceofNonTrivial, instruction_, dex_pc, this);
CheckEntrypointTypes<kQuickInstanceofNonTrivial, size_t, mirror::Object*, mirror::Class*>();
- Primitive::Type ret_type = instruction_->GetType();
+ DataType::Type ret_type = instruction_->GetType();
Location ret_loc = calling_convention.GetReturnLocation(ret_type);
mips_codegen->MoveLocation(locations->Out(), ret_loc, ret_type);
} else {
@@ -559,17 +559,17 @@
parallel_move.AddMove(
locations->InAt(0),
Location::RegisterLocation(calling_convention.GetRegisterAt(0)),
- Primitive::kPrimNot,
+ DataType::Type::kReference,
nullptr);
parallel_move.AddMove(
locations->InAt(1),
Location::RegisterLocation(calling_convention.GetRegisterAt(1)),
- Primitive::kPrimInt,
+ DataType::Type::kInt32,
nullptr);
parallel_move.AddMove(
locations->InAt(2),
Location::RegisterLocation(calling_convention.GetRegisterAt(2)),
- Primitive::kPrimNot,
+ DataType::Type::kReference,
nullptr);
codegen->GetMoveResolver()->EmitNativeCode(¶llel_move);
@@ -969,16 +969,16 @@
HParallelMove parallel_move(codegen->GetGraph()->GetArena());
parallel_move.AddMove(ref_,
Location::RegisterLocation(calling_convention.GetRegisterAt(0)),
- Primitive::kPrimNot,
+ DataType::Type::kReference,
nullptr);
parallel_move.AddMove(obj_,
Location::RegisterLocation(calling_convention.GetRegisterAt(1)),
- Primitive::kPrimNot,
+ DataType::Type::kReference,
nullptr);
if (index.IsValid()) {
parallel_move.AddMove(index,
Location::RegisterLocation(calling_convention.GetRegisterAt(2)),
- Primitive::kPrimInt,
+ DataType::Type::kInt32,
nullptr);
codegen->GetMoveResolver()->EmitNativeCode(¶llel_move);
} else {
@@ -992,8 +992,8 @@
CheckEntrypointTypes<
kQuickReadBarrierSlow, mirror::Object*, mirror::Object*, mirror::Object*, uint32_t>();
mips_codegen->MoveLocation(out_,
- calling_convention.GetReturnLocation(Primitive::kPrimNot),
- Primitive::kPrimNot);
+ calling_convention.GetReturnLocation(DataType::Type::kReference),
+ DataType::Type::kReference);
RestoreLiveRegisters(codegen, locations);
__ B(GetExitLabel());
@@ -1058,15 +1058,15 @@
CodeGeneratorMIPS* mips_codegen = down_cast<CodeGeneratorMIPS*>(codegen);
mips_codegen->MoveLocation(Location::RegisterLocation(calling_convention.GetRegisterAt(0)),
root_,
- Primitive::kPrimNot);
+ DataType::Type::kReference);
mips_codegen->InvokeRuntime(kQuickReadBarrierForRootSlow,
instruction_,
instruction_->GetDexPc(),
this);
CheckEntrypointTypes<kQuickReadBarrierForRootSlow, mirror::Object*, GcRoot<mirror::Object>*>();
mips_codegen->MoveLocation(out_,
- calling_convention.GetReturnLocation(Primitive::kPrimNot),
- Primitive::kPrimNot);
+ calling_convention.GetReturnLocation(DataType::Type::kReference),
+ DataType::Type::kReference);
RestoreLiveRegisters(codegen, locations);
__ B(GetExitLabel());
@@ -1165,7 +1165,7 @@
void ParallelMoveResolverMIPS::EmitSwap(size_t index) {
DCHECK_LT(index, moves_.size());
MoveOperands* move = moves_[index];
- Primitive::Type type = move->GetType();
+ DataType::Type type = move->GetType();
Location loc1 = move->GetDestination();
Location loc2 = move->GetSource();
@@ -1186,12 +1186,12 @@
} else if (loc1.IsFpuRegister() && loc2.IsFpuRegister()) {
FRegister f1 = loc1.AsFpuRegister<FRegister>();
FRegister f2 = loc2.AsFpuRegister<FRegister>();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ MovS(FTMP, f2);
__ MovS(f2, f1);
__ MovS(f1, FTMP);
} else {
- DCHECK_EQ(type, Primitive::kPrimDouble);
+ DCHECK_EQ(type, DataType::Type::kFloat64);
__ MovD(FTMP, f2);
__ MovD(f2, f1);
__ MovD(f1, FTMP);
@@ -1199,7 +1199,7 @@
} else if ((loc1.IsRegister() && loc2.IsFpuRegister()) ||
(loc1.IsFpuRegister() && loc2.IsRegister())) {
// Swap FPR and GPR.
- DCHECK_EQ(type, Primitive::kPrimFloat); // Can only swap a float.
+ DCHECK_EQ(type, DataType::Type::kFloat32); // Can only swap a float.
FRegister f1 = loc1.IsFpuRegister() ? loc1.AsFpuRegister<FRegister>()
: loc2.AsFpuRegister<FRegister>();
Register r2 = loc1.IsRegister() ? loc1.AsRegister<Register>() : loc2.AsRegister<Register>();
@@ -1221,7 +1221,7 @@
} else if ((loc1.IsRegisterPair() && loc2.IsFpuRegister()) ||
(loc1.IsFpuRegister() && loc2.IsRegisterPair())) {
// Swap FPR and GPR register pair.
- DCHECK_EQ(type, Primitive::kPrimDouble);
+ DCHECK_EQ(type, DataType::Type::kFloat64);
FRegister f1 = loc1.IsFpuRegister() ? loc1.AsFpuRegister<FRegister>()
: loc2.AsFpuRegister<FRegister>();
Register r2_l = loc1.IsRegisterPair() ? loc1.AsRegisterPairLow<Register>()
@@ -1267,12 +1267,12 @@
FRegister reg = loc1.IsFpuRegister() ? loc1.AsFpuRegister<FRegister>()
: loc2.AsFpuRegister<FRegister>();
intptr_t offset = loc1.IsFpuRegister() ? loc2.GetStackIndex() : loc1.GetStackIndex();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ MovS(FTMP, reg);
__ LoadSFromOffset(reg, SP, offset);
__ StoreSToOffset(FTMP, SP, offset);
} else {
- DCHECK_EQ(type, Primitive::kPrimDouble);
+ DCHECK_EQ(type, DataType::Type::kFloat64);
__ MovD(FTMP, reg);
__ LoadDFromOffset(reg, SP, offset);
__ StoreDToOffset(FTMP, SP, offset);
@@ -1462,7 +1462,7 @@
void CodeGeneratorMIPS::MoveLocation(Location destination,
Location source,
- Primitive::Type dst_type) {
+ DataType::Type dst_type) {
if (source.Equals(destination)) {
return;
}
@@ -1498,10 +1498,10 @@
}
} else if (destination.IsFpuRegister()) {
if (source.IsRegister()) {
- DCHECK(!Primitive::Is64BitType(dst_type));
+ DCHECK(!DataType::Is64BitType(dst_type));
__ Mtc1(source.AsRegister<Register>(), destination.AsFpuRegister<FRegister>());
} else if (source.IsRegisterPair()) {
- DCHECK(Primitive::Is64BitType(dst_type));
+ DCHECK(DataType::Is64BitType(dst_type));
FRegister dst = destination.AsFpuRegister<FRegister>();
Register src_high = source.AsRegisterPairHigh<Register>();
Register src_low = source.AsRegisterPairLow<Register>();
@@ -1512,20 +1512,20 @@
__ MoveV(VectorRegisterFrom(destination),
VectorRegisterFrom(source));
} else {
- if (Primitive::Is64BitType(dst_type)) {
+ if (DataType::Is64BitType(dst_type)) {
__ MovD(destination.AsFpuRegister<FRegister>(), source.AsFpuRegister<FRegister>());
} else {
- DCHECK_EQ(dst_type, Primitive::kPrimFloat);
+ DCHECK_EQ(dst_type, DataType::Type::kFloat32);
__ MovS(destination.AsFpuRegister<FRegister>(), source.AsFpuRegister<FRegister>());
}
}
} else if (source.IsSIMDStackSlot()) {
__ LoadQFromOffset(destination.AsFpuRegister<FRegister>(), SP, source.GetStackIndex());
} else if (source.IsDoubleStackSlot()) {
- DCHECK(Primitive::Is64BitType(dst_type));
+ DCHECK(DataType::Is64BitType(dst_type));
__ LoadDFromOffset(destination.AsFpuRegister<FRegister>(), SP, source.GetStackIndex());
} else {
- DCHECK(!Primitive::Is64BitType(dst_type));
+ DCHECK(!DataType::Is64BitType(dst_type));
DCHECK(source.IsStackSlot()) << "Cannot move from " << source << " to " << destination;
__ LoadSFromOffset(destination.AsFpuRegister<FRegister>(), SP, source.GetStackIndex());
}
@@ -2022,9 +2022,9 @@
void LocationsBuilderMIPS::HandleBinaryOp(HBinaryOperation* instruction) {
DCHECK_EQ(instruction->InputCount(), 2U);
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(instruction);
- Primitive::Type type = instruction->GetResultType();
+ DataType::Type type = instruction->GetResultType();
switch (type) {
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
locations->SetInAt(0, Location::RequiresRegister());
HInstruction* right = instruction->InputAt(1);
bool can_use_imm = false;
@@ -2047,15 +2047,15 @@
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(instruction->InputAt(1)));
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
break;
}
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
DCHECK(instruction->IsAdd() || instruction->IsSub());
locations->SetInAt(0, Location::RequiresFpuRegister());
locations->SetInAt(1, Location::RequiresFpuRegister());
@@ -2068,11 +2068,11 @@
}
void InstructionCodeGeneratorMIPS::HandleBinaryOp(HBinaryOperation* instruction) {
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
LocationSummary* locations = instruction->GetLocations();
switch (type) {
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
Register dst = locations->Out().AsRegister<Register>();
Register lhs = locations->InAt(0).AsRegister<Register>();
Location rhs_location = locations->InAt(1);
@@ -2116,7 +2116,7 @@
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
Register dst_high = locations->Out().AsRegisterPairHigh<Register>();
Register dst_low = locations->Out().AsRegisterPairLow<Register>();
Register lhs_high = locations->InAt(0).AsRegisterPairHigh<Register>();
@@ -2257,20 +2257,20 @@
break;
}
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64: {
FRegister dst = locations->Out().AsFpuRegister<FRegister>();
FRegister lhs = locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = locations->InAt(1).AsFpuRegister<FRegister>();
if (instruction->IsAdd()) {
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ AddS(dst, lhs, rhs);
} else {
__ AddD(dst, lhs, rhs);
}
} else {
DCHECK(instruction->IsSub());
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ SubS(dst, lhs, rhs);
} else {
__ SubD(dst, lhs, rhs);
@@ -2288,14 +2288,14 @@
DCHECK(instr->IsShl() || instr->IsShr() || instr->IsUShr() || instr->IsRor());
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(instr);
- Primitive::Type type = instr->GetResultType();
+ DataType::Type type = instr->GetResultType();
switch (type) {
- case Primitive::kPrimInt:
+ case DataType::Type::kInt32:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(instr->InputAt(1)));
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(instr->InputAt(1)));
locations->SetOut(Location::RequiresRegister());
@@ -2310,20 +2310,20 @@
void InstructionCodeGeneratorMIPS::HandleShift(HBinaryOperation* instr) {
DCHECK(instr->IsShl() || instr->IsShr() || instr->IsUShr() || instr->IsRor());
LocationSummary* locations = instr->GetLocations();
- Primitive::Type type = instr->GetType();
+ DataType::Type type = instr->GetType();
Location rhs_location = locations->InAt(1);
bool use_imm = rhs_location.IsConstant();
Register rhs_reg = use_imm ? ZERO : rhs_location.AsRegister<Register>();
int64_t rhs_imm = use_imm ? CodeGenerator::GetInt64ValueOf(rhs_location.GetConstant()) : 0;
const uint32_t shift_mask =
- (type == Primitive::kPrimInt) ? kMaxIntShiftDistance : kMaxLongShiftDistance;
+ (type == DataType::Type::kInt32) ? kMaxIntShiftDistance : kMaxLongShiftDistance;
const uint32_t shift_value = rhs_imm & shift_mask;
// Are the INS (Insert Bit Field) and ROTR instructions supported?
bool has_ins_rotr = codegen_->GetInstructionSetFeatures().IsMipsIsaRevGreaterThanEqual2();
switch (type) {
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
Register dst = locations->Out().AsRegister<Register>();
Register lhs = locations->InAt(0).AsRegister<Register>();
if (use_imm) {
@@ -2372,7 +2372,7 @@
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
Register dst_high = locations->Out().AsRegisterPairHigh<Register>();
Register dst_low = locations->Out().AsRegisterPairLow<Register>();
Register lhs_high = locations->InAt(0).AsRegisterPairHigh<Register>();
@@ -2536,9 +2536,9 @@
}
void LocationsBuilderMIPS::VisitArrayGet(HArrayGet* instruction) {
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
bool object_array_get_with_read_barrier =
- kEmitCompilerReadBarrier && (type == Primitive::kPrimNot);
+ kEmitCompilerReadBarrier && (type == DataType::Type::kReference);
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(instruction,
object_array_get_with_read_barrier
@@ -2549,7 +2549,7 @@
}
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(instruction->InputAt(1)));
- if (Primitive::IsFloatingPointType(type)) {
+ if (DataType::IsFloatingPointType(type)) {
locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap);
} else {
// The output overlaps in the case of an object array get with
@@ -2588,11 +2588,11 @@
uint32_t data_offset = CodeGenerator::GetArrayDataOffset(instruction);
auto null_checker = GetImplicitNullChecker(instruction, codegen_);
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
const bool maybe_compressed_char_at = mirror::kUseStringCompression &&
instruction->IsStringCharAt();
switch (type) {
- case Primitive::kPrimBoolean: {
+ case DataType::Type::kBool: {
Register out = out_loc.AsRegister<Register>();
if (index.IsConstant()) {
size_t offset =
@@ -2605,7 +2605,7 @@
break;
}
- case Primitive::kPrimByte: {
+ case DataType::Type::kInt8: {
Register out = out_loc.AsRegister<Register>();
if (index.IsConstant()) {
size_t offset =
@@ -2618,7 +2618,7 @@
break;
}
- case Primitive::kPrimShort: {
+ case DataType::Type::kInt16: {
Register out = out_loc.AsRegister<Register>();
if (index.IsConstant()) {
size_t offset =
@@ -2631,7 +2631,7 @@
break;
}
- case Primitive::kPrimChar: {
+ case DataType::Type::kUint16: {
Register out = out_loc.AsRegister<Register>();
if (maybe_compressed_char_at) {
uint32_t count_offset = mirror::String::CountOffset().Uint32Value();
@@ -2683,7 +2683,7 @@
break;
}
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
DCHECK_EQ(sizeof(mirror::HeapReference<mirror::Object>), sizeof(int32_t));
Register out = out_loc.AsRegister<Register>();
if (index.IsConstant()) {
@@ -2697,7 +2697,7 @@
break;
}
- case Primitive::kPrimNot: {
+ case DataType::Type::kReference: {
static_assert(
sizeof(mirror::HeapReference<mirror::Object>) == sizeof(int32_t),
"art::mirror::HeapReference<art::mirror::Object> and int32_t have different sizes.");
@@ -2757,7 +2757,7 @@
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
Register out = out_loc.AsRegisterPairLow<Register>();
if (index.IsConstant()) {
size_t offset =
@@ -2770,7 +2770,7 @@
break;
}
- case Primitive::kPrimFloat: {
+ case DataType::Type::kFloat32: {
FRegister out = out_loc.AsFpuRegister<FRegister>();
if (index.IsConstant()) {
size_t offset =
@@ -2783,7 +2783,7 @@
break;
}
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat64: {
FRegister out = out_loc.AsFpuRegister<FRegister>();
if (index.IsConstant()) {
size_t offset =
@@ -2796,7 +2796,7 @@
break;
}
- case Primitive::kPrimVoid:
+ case DataType::Type::kVoid:
LOG(FATAL) << "Unreachable type " << instruction->GetType();
UNREACHABLE();
}
@@ -2841,7 +2841,7 @@
}
void LocationsBuilderMIPS::VisitArraySet(HArraySet* instruction) {
- Primitive::Type value_type = instruction->GetComponentType();
+ DataType::Type value_type = instruction->GetComponentType();
bool needs_write_barrier =
CodeGenerator::StoreNeedsWriteBarrier(value_type, instruction->GetValue());
@@ -2855,7 +2855,7 @@
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(instruction->InputAt(1)));
- if (Primitive::IsFloatingPointType(instruction->InputAt(2)->GetType())) {
+ if (DataType::IsFloatingPointType(instruction->InputAt(2)->GetType())) {
locations->SetInAt(2, FpuRegisterOrConstantForStore(instruction->InputAt(2)));
} else {
locations->SetInAt(2, RegisterOrZeroConstant(instruction->InputAt(2)));
@@ -2871,7 +2871,7 @@
Register obj = locations->InAt(0).AsRegister<Register>();
Location index = locations->InAt(1);
Location value_location = locations->InAt(2);
- Primitive::Type value_type = instruction->GetComponentType();
+ DataType::Type value_type = instruction->GetComponentType();
bool may_need_runtime_call_for_type_check = instruction->NeedsTypeCheck();
bool needs_write_barrier =
CodeGenerator::StoreNeedsWriteBarrier(value_type, instruction->GetValue());
@@ -2879,8 +2879,8 @@
Register base_reg = index.IsConstant() ? obj : TMP;
switch (value_type) {
- case Primitive::kPrimBoolean:
- case Primitive::kPrimByte: {
+ case DataType::Type::kBool:
+ case DataType::Type::kInt8: {
uint32_t data_offset = mirror::Array::DataOffset(sizeof(uint8_t)).Uint32Value();
if (index.IsConstant()) {
data_offset += index.GetConstant()->AsIntConstant()->GetValue() << TIMES_1;
@@ -2897,8 +2897,8 @@
break;
}
- case Primitive::kPrimShort:
- case Primitive::kPrimChar: {
+ case DataType::Type::kInt16:
+ case DataType::Type::kUint16: {
uint32_t data_offset = mirror::Array::DataOffset(sizeof(uint16_t)).Uint32Value();
if (index.IsConstant()) {
data_offset += index.GetConstant()->AsIntConstant()->GetValue() << TIMES_2;
@@ -2915,7 +2915,7 @@
break;
}
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
uint32_t data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Uint32Value();
if (index.IsConstant()) {
data_offset += index.GetConstant()->AsIntConstant()->GetValue() << TIMES_4;
@@ -2932,7 +2932,7 @@
break;
}
- case Primitive::kPrimNot: {
+ case DataType::Type::kReference: {
if (value_location.IsConstant()) {
// Just setting null.
uint32_t data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Uint32Value();
@@ -3047,7 +3047,7 @@
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
uint32_t data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Uint32Value();
if (index.IsConstant()) {
data_offset += index.GetConstant()->AsIntConstant()->GetValue() << TIMES_8;
@@ -3064,7 +3064,7 @@
break;
}
- case Primitive::kPrimFloat: {
+ case DataType::Type::kFloat32: {
uint32_t data_offset = mirror::Array::DataOffset(sizeof(float)).Uint32Value();
if (index.IsConstant()) {
data_offset += index.GetConstant()->AsIntConstant()->GetValue() << TIMES_4;
@@ -3081,7 +3081,7 @@
break;
}
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat64: {
uint32_t data_offset = mirror::Array::DataOffset(sizeof(double)).Uint32Value();
if (index.IsConstant()) {
data_offset += index.GetConstant()->AsIntConstant()->GetValue() << TIMES_8;
@@ -3098,7 +3098,7 @@
break;
}
- case Primitive::kPrimVoid:
+ case DataType::Type::kVoid:
LOG(FATAL) << "Unreachable type " << instruction->GetType();
UNREACHABLE();
}
@@ -3383,31 +3383,31 @@
}
void LocationsBuilderMIPS::VisitCompare(HCompare* compare) {
- Primitive::Type in_type = compare->InputAt(0)->GetType();
+ DataType::Type in_type = compare->InputAt(0)->GetType();
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(compare, LocationSummary::kNoCall);
switch (in_type) {
- case Primitive::kPrimBoolean:
- case Primitive::kPrimByte:
- case Primitive::kPrimShort:
- case Primitive::kPrimChar:
- case Primitive::kPrimInt:
+ case DataType::Type::kBool:
+ case DataType::Type::kInt8:
+ case DataType::Type::kInt16:
+ case DataType::Type::kUint16:
+ case DataType::Type::kInt32:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RequiresRegister());
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RequiresRegister());
// Output overlaps because it is written before doing the low comparison.
locations->SetOut(Location::RequiresRegister(), Location::kOutputOverlap);
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
locations->SetInAt(0, Location::RequiresFpuRegister());
locations->SetInAt(1, Location::RequiresFpuRegister());
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
@@ -3421,18 +3421,18 @@
void InstructionCodeGeneratorMIPS::VisitCompare(HCompare* instruction) {
LocationSummary* locations = instruction->GetLocations();
Register res = locations->Out().AsRegister<Register>();
- Primitive::Type in_type = instruction->InputAt(0)->GetType();
+ DataType::Type in_type = instruction->InputAt(0)->GetType();
bool isR6 = codegen_->GetInstructionSetFeatures().IsR6();
// 0 if: left == right
// 1 if: left > right
// -1 if: left < right
switch (in_type) {
- case Primitive::kPrimBoolean:
- case Primitive::kPrimByte:
- case Primitive::kPrimShort:
- case Primitive::kPrimChar:
- case Primitive::kPrimInt: {
+ case DataType::Type::kBool:
+ case DataType::Type::kInt8:
+ case DataType::Type::kInt16:
+ case DataType::Type::kUint16:
+ case DataType::Type::kInt32: {
Register lhs = locations->InAt(0).AsRegister<Register>();
Register rhs = locations->InAt(1).AsRegister<Register>();
__ Slt(TMP, lhs, rhs);
@@ -3440,7 +3440,7 @@
__ Subu(res, res, TMP);
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
MipsLabel done;
Register lhs_high = locations->InAt(0).AsRegisterPairHigh<Register>();
Register lhs_low = locations->InAt(0).AsRegisterPairLow<Register>();
@@ -3458,7 +3458,7 @@
break;
}
- case Primitive::kPrimFloat: {
+ case DataType::Type::kFloat32: {
bool gt_bias = instruction->IsGtBias();
FRegister lhs = locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = locations->InAt(1).AsFpuRegister<FRegister>();
@@ -3498,7 +3498,7 @@
__ Bind(&done);
break;
}
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat64: {
bool gt_bias = instruction->IsGtBias();
FRegister lhs = locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = locations->InAt(1).AsFpuRegister<FRegister>();
@@ -3548,13 +3548,13 @@
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(instruction);
switch (instruction->InputAt(0)->GetType()) {
default:
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(instruction->InputAt(1)));
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
locations->SetInAt(0, Location::RequiresFpuRegister());
locations->SetInAt(1, Location::RequiresFpuRegister());
break;
@@ -3569,7 +3569,7 @@
return;
}
- Primitive::Type type = instruction->InputAt(0)->GetType();
+ DataType::Type type = instruction->InputAt(0)->GetType();
LocationSummary* locations = instruction->GetLocations();
switch (type) {
@@ -3578,12 +3578,12 @@
GenerateIntCompare(instruction->GetCondition(), locations);
return;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
GenerateLongCompare(instruction->GetCondition(), locations);
return;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
GenerateFpCompare(instruction->GetCondition(), instruction->IsGtBias(), type, locations);
return;
}
@@ -3591,7 +3591,7 @@
void InstructionCodeGeneratorMIPS::DivRemOneOrMinusOne(HBinaryOperation* instruction) {
DCHECK(instruction->IsDiv() || instruction->IsRem());
- DCHECK_EQ(instruction->GetResultType(), Primitive::kPrimInt);
+ DCHECK_EQ(instruction->GetResultType(), DataType::Type::kInt32);
LocationSummary* locations = instruction->GetLocations();
Location second = locations->InAt(1);
@@ -3615,7 +3615,7 @@
void InstructionCodeGeneratorMIPS::DivRemByPowerOfTwo(HBinaryOperation* instruction) {
DCHECK(instruction->IsDiv() || instruction->IsRem());
- DCHECK_EQ(instruction->GetResultType(), Primitive::kPrimInt);
+ DCHECK_EQ(instruction->GetResultType(), DataType::Type::kInt32);
LocationSummary* locations = instruction->GetLocations();
Location second = locations->InAt(1);
@@ -3664,7 +3664,7 @@
void InstructionCodeGeneratorMIPS::GenerateDivRemWithAnyConstant(HBinaryOperation* instruction) {
DCHECK(instruction->IsDiv() || instruction->IsRem());
- DCHECK_EQ(instruction->GetResultType(), Primitive::kPrimInt);
+ DCHECK_EQ(instruction->GetResultType(), DataType::Type::kInt32);
LocationSummary* locations = instruction->GetLocations();
Location second = locations->InAt(1);
@@ -3715,7 +3715,7 @@
void InstructionCodeGeneratorMIPS::GenerateDivRemIntegral(HBinaryOperation* instruction) {
DCHECK(instruction->IsDiv() || instruction->IsRem());
- DCHECK_EQ(instruction->GetResultType(), Primitive::kPrimInt);
+ DCHECK_EQ(instruction->GetResultType(), DataType::Type::kInt32);
LocationSummary* locations = instruction->GetLocations();
Register out = locations->Out().AsRegister<Register>();
@@ -3754,21 +3754,21 @@
}
void LocationsBuilderMIPS::VisitDiv(HDiv* div) {
- Primitive::Type type = div->GetResultType();
- LocationSummary::CallKind call_kind = (type == Primitive::kPrimLong)
+ DataType::Type type = div->GetResultType();
+ LocationSummary::CallKind call_kind = (type == DataType::Type::kInt64)
? LocationSummary::kCallOnMainOnly
: LocationSummary::kNoCall;
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(div, call_kind);
switch (type) {
- case Primitive::kPrimInt:
+ case DataType::Type::kInt32:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(div->InputAt(1)));
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
break;
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
InvokeRuntimeCallingConvention calling_convention;
locations->SetInAt(0, Location::RegisterPairLocation(
calling_convention.GetRegisterAt(0), calling_convention.GetRegisterAt(1)));
@@ -3778,8 +3778,8 @@
break;
}
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
locations->SetInAt(0, Location::RequiresFpuRegister());
locations->SetInAt(1, Location::RequiresFpuRegister());
locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap);
@@ -3791,24 +3791,24 @@
}
void InstructionCodeGeneratorMIPS::VisitDiv(HDiv* instruction) {
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
LocationSummary* locations = instruction->GetLocations();
switch (type) {
- case Primitive::kPrimInt:
+ case DataType::Type::kInt32:
GenerateDivRemIntegral(instruction);
break;
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
codegen_->InvokeRuntime(kQuickLdiv, instruction, instruction->GetDexPc());
CheckEntrypointTypes<kQuickLdiv, int64_t, int64_t, int64_t>();
break;
}
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64: {
FRegister dst = locations->Out().AsFpuRegister<FRegister>();
FRegister lhs = locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = locations->InAt(1).AsFpuRegister<FRegister>();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ DivS(dst, lhs, rhs);
} else {
__ DivD(dst, lhs, rhs);
@@ -3829,14 +3829,14 @@
SlowPathCodeMIPS* slow_path = new (GetGraph()->GetArena()) DivZeroCheckSlowPathMIPS(instruction);
codegen_->AddSlowPath(slow_path);
Location value = instruction->GetLocations()->InAt(0);
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
switch (type) {
- case Primitive::kPrimBoolean:
- case Primitive::kPrimByte:
- case Primitive::kPrimChar:
- case Primitive::kPrimShort:
- case Primitive::kPrimInt: {
+ case DataType::Type::kBool:
+ case DataType::Type::kInt8:
+ case DataType::Type::kUint16:
+ case DataType::Type::kInt16:
+ case DataType::Type::kInt32: {
if (value.IsConstant()) {
if (value.GetConstant()->AsIntConstant()->GetValue() == 0) {
__ B(slow_path->GetEntryLabel());
@@ -3850,7 +3850,7 @@
}
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
if (value.IsConstant()) {
if (value.GetConstant()->AsLongConstant()->GetValue() == 0) {
__ B(slow_path->GetEntryLabel());
@@ -4786,13 +4786,13 @@
void InstructionCodeGeneratorMIPS::GenerateFpCompare(IfCondition cond,
bool gt_bias,
- Primitive::Type type,
+ DataType::Type type,
LocationSummary* locations) {
Register dst = locations->Out().AsRegister<Register>();
FRegister lhs = locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = locations->InAt(1).AsFpuRegister<FRegister>();
bool isR6 = codegen_->GetInstructionSetFeatures().IsR6();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
if (isR6) {
switch (cond) {
case kCondEQ:
@@ -4899,7 +4899,7 @@
}
}
} else {
- DCHECK_EQ(type, Primitive::kPrimDouble);
+ DCHECK_EQ(type, DataType::Type::kFloat64);
if (isR6) {
switch (cond) {
case kCondEQ:
@@ -5010,13 +5010,13 @@
bool InstructionCodeGeneratorMIPS::MaterializeFpCompareR2(IfCondition cond,
bool gt_bias,
- Primitive::Type type,
+ DataType::Type type,
LocationSummary* input_locations,
int cc) {
FRegister lhs = input_locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = input_locations->InAt(1).AsFpuRegister<FRegister>();
CHECK(!codegen_->GetInstructionSetFeatures().IsR6());
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
switch (cond) {
case kCondEQ:
__ CeqS(cc, lhs, rhs);
@@ -5057,7 +5057,7 @@
UNREACHABLE();
}
} else {
- DCHECK_EQ(type, Primitive::kPrimDouble);
+ DCHECK_EQ(type, DataType::Type::kFloat64);
switch (cond) {
case kCondEQ:
__ CeqD(cc, lhs, rhs);
@@ -5102,13 +5102,13 @@
bool InstructionCodeGeneratorMIPS::MaterializeFpCompareR6(IfCondition cond,
bool gt_bias,
- Primitive::Type type,
+ DataType::Type type,
LocationSummary* input_locations,
FRegister dst) {
FRegister lhs = input_locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = input_locations->InAt(1).AsFpuRegister<FRegister>();
CHECK(codegen_->GetInstructionSetFeatures().IsR6());
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
switch (cond) {
case kCondEQ:
__ CmpEqS(dst, lhs, rhs);
@@ -5149,7 +5149,7 @@
UNREACHABLE();
}
} else {
- DCHECK_EQ(type, Primitive::kPrimDouble);
+ DCHECK_EQ(type, DataType::Type::kFloat64);
switch (cond) {
case kCondEQ:
__ CmpEqD(dst, lhs, rhs);
@@ -5194,13 +5194,13 @@
void InstructionCodeGeneratorMIPS::GenerateFpCompareAndBranch(IfCondition cond,
bool gt_bias,
- Primitive::Type type,
+ DataType::Type type,
LocationSummary* locations,
MipsLabel* label) {
FRegister lhs = locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = locations->InAt(1).AsFpuRegister<FRegister>();
bool isR6 = codegen_->GetInstructionSetFeatures().IsR6();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
if (isR6) {
switch (cond) {
case kCondEQ:
@@ -5295,7 +5295,7 @@
}
}
} else {
- DCHECK_EQ(type, Primitive::kPrimDouble);
+ DCHECK_EQ(type, DataType::Type::kFloat64);
if (isR6) {
switch (cond) {
case kCondEQ:
@@ -5437,7 +5437,7 @@
// The condition instruction has not been materialized, use its inputs as
// the comparison and its condition as the branch condition.
HCondition* condition = cond->AsCondition();
- Primitive::Type type = condition->InputAt(0)->GetType();
+ DataType::Type type = condition->InputAt(0)->GetType();
LocationSummary* locations = cond->GetLocations();
IfCondition if_cond = condition->GetCondition();
MipsLabel* branch_target = true_target;
@@ -5451,11 +5451,11 @@
default:
GenerateIntCompareAndBranch(if_cond, locations, branch_target);
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
GenerateLongCompareAndBranch(if_cond, locations, branch_target);
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
GenerateFpCompareAndBranch(if_cond, condition->IsGtBias(), type, locations, branch_target);
break;
}
@@ -5520,8 +5520,9 @@
HInstruction* cond = select->InputAt(/* condition_input_index */ 2);
HCondition* condition = cond->AsCondition();
- Primitive::Type cond_type = materialized ? Primitive::kPrimInt : condition->InputAt(0)->GetType();
- Primitive::Type dst_type = select->GetType();
+ DataType::Type cond_type =
+ materialized ? DataType::Type::kInt32 : condition->InputAt(0)->GetType();
+ DataType::Type dst_type = select->GetType();
HConstant* cst_true_value = select->GetTrueValue()->AsConstant();
HConstant* cst_false_value = select->GetFalseValue()->AsConstant();
@@ -5563,7 +5564,7 @@
use_const_for_true_in = is_true_value_zero_constant;
}
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
// Moving long on int condition.
if (is_r6) {
if (is_true_value_zero_constant) {
@@ -5586,8 +5587,8 @@
use_const_for_true_in = is_true_value_zero_constant;
}
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
// Moving float/double on int condition.
if (is_r6) {
if (materialized) {
@@ -5618,12 +5619,12 @@
break;
}
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
// We don't materialize long comparison now
// and use conditional branches instead.
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
switch (dst_type) {
default:
// Moving int on float/double condition.
@@ -5651,7 +5652,7 @@
use_const_for_true_in = is_true_value_zero_constant;
}
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
// Moving long on float/double condition.
if (is_r6) {
if (is_true_value_zero_constant) {
@@ -5676,8 +5677,8 @@
use_const_for_true_in = is_true_value_zero_constant;
}
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
// Moving float/double on float/double condition.
if (is_r6) {
can_move_conditionally = true;
@@ -5713,7 +5714,7 @@
locations_to_set->SetInAt(0, Location::ConstantLocation(cst_false_value));
} else {
locations_to_set->SetInAt(0,
- Primitive::IsFloatingPointType(dst_type)
+ DataType::IsFloatingPointType(dst_type)
? Location::RequiresFpuRegister()
: Location::RequiresRegister());
}
@@ -5721,7 +5722,7 @@
locations_to_set->SetInAt(1, Location::ConstantLocation(cst_true_value));
} else {
locations_to_set->SetInAt(1,
- Primitive::IsFloatingPointType(dst_type)
+ DataType::IsFloatingPointType(dst_type)
? Location::RequiresFpuRegister()
: Location::RequiresRegister());
}
@@ -5734,7 +5735,7 @@
if (is_out_same_as_first_in) {
locations_to_set->SetOut(Location::SameAsFirstInput());
} else {
- locations_to_set->SetOut(Primitive::IsFloatingPointType(dst_type)
+ locations_to_set->SetOut(DataType::IsFloatingPointType(dst_type)
? Location::RequiresFpuRegister()
: Location::RequiresRegister());
}
@@ -5752,9 +5753,9 @@
HInstruction* cond = select->InputAt(/* condition_input_index */ 2);
Register cond_reg = TMP;
int cond_cc = 0;
- Primitive::Type cond_type = Primitive::kPrimInt;
+ DataType::Type cond_type = DataType::Type::kInt32;
bool cond_inverted = false;
- Primitive::Type dst_type = select->GetType();
+ DataType::Type dst_type = select->GetType();
if (IsBooleanValueOrMaterializedCondition(cond)) {
cond_reg = locations->InAt(/* condition_input_index */ 2).AsRegister<Register>();
@@ -5765,11 +5766,11 @@
cond_type = condition->InputAt(0)->GetType();
switch (cond_type) {
default:
- DCHECK_NE(cond_type, Primitive::kPrimLong);
+ DCHECK_NE(cond_type, DataType::Type::kInt64);
cond_inverted = MaterializeIntCompare(if_cond, cond_locations, cond_reg);
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
cond_inverted = MaterializeFpCompareR2(if_cond,
condition->IsGtBias(),
cond_type,
@@ -5799,7 +5800,7 @@
__ Movn(dst.AsRegister<Register>(), src_reg, cond_reg);
}
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
if (cond_inverted) {
__ Movz(dst.AsRegisterPairLow<Register>(), src_reg, cond_reg);
__ Movz(dst.AsRegisterPairHigh<Register>(), src_reg_high, cond_reg);
@@ -5808,14 +5809,14 @@
__ Movn(dst.AsRegisterPairHigh<Register>(), src_reg_high, cond_reg);
}
break;
- case Primitive::kPrimFloat:
+ case DataType::Type::kFloat32:
if (cond_inverted) {
__ MovzS(dst.AsFpuRegister<FRegister>(), src.AsFpuRegister<FRegister>(), cond_reg);
} else {
__ MovnS(dst.AsFpuRegister<FRegister>(), src.AsFpuRegister<FRegister>(), cond_reg);
}
break;
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat64:
if (cond_inverted) {
__ MovzD(dst.AsFpuRegister<FRegister>(), src.AsFpuRegister<FRegister>(), cond_reg);
} else {
@@ -5824,11 +5825,11 @@
break;
}
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
LOG(FATAL) << "Unreachable";
UNREACHABLE();
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
switch (dst_type) {
default:
if (cond_inverted) {
@@ -5837,7 +5838,7 @@
__ Movt(dst.AsRegister<Register>(), src_reg, cond_cc);
}
break;
- case Primitive::kPrimLong:
+ case DataType::Type::kInt64:
if (cond_inverted) {
__ Movf(dst.AsRegisterPairLow<Register>(), src_reg, cond_cc);
__ Movf(dst.AsRegisterPairHigh<Register>(), src_reg_high, cond_cc);
@@ -5846,14 +5847,14 @@
__ Movt(dst.AsRegisterPairHigh<Register>(), src_reg_high, cond_cc);
}
break;
- case Primitive::kPrimFloat:
+ case DataType::Type::kFloat32:
if (cond_inverted) {
__ MovfS(dst.AsFpuRegister<FRegister>(), src.AsFpuRegister<FRegister>(), cond_cc);
} else {
__ MovtS(dst.AsFpuRegister<FRegister>(), src.AsFpuRegister<FRegister>(), cond_cc);
}
break;
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat64:
if (cond_inverted) {
__ MovfD(dst.AsFpuRegister<FRegister>(), src.AsFpuRegister<FRegister>(), cond_cc);
} else {
@@ -5873,9 +5874,9 @@
HInstruction* cond = select->InputAt(/* condition_input_index */ 2);
Register cond_reg = TMP;
FRegister fcond_reg = FTMP;
- Primitive::Type cond_type = Primitive::kPrimInt;
+ DataType::Type cond_type = DataType::Type::kInt32;
bool cond_inverted = false;
- Primitive::Type dst_type = select->GetType();
+ DataType::Type dst_type = select->GetType();
if (IsBooleanValueOrMaterializedCondition(cond)) {
cond_reg = locations->InAt(/* condition_input_index */ 2).AsRegister<Register>();
@@ -5886,11 +5887,11 @@
cond_type = condition->InputAt(0)->GetType();
switch (cond_type) {
default:
- DCHECK_NE(cond_type, Primitive::kPrimLong);
+ DCHECK_NE(cond_type, DataType::Type::kInt64);
cond_inverted = MaterializeIntCompare(if_cond, cond_locations, cond_reg);
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
cond_inverted = MaterializeFpCompareR6(if_cond,
condition->IsGtBias(),
cond_type,
@@ -5909,7 +5910,7 @@
switch (dst_type) {
default:
- if (Primitive::IsFloatingPointType(cond_type)) {
+ if (DataType::IsFloatingPointType(cond_type)) {
__ Mfc1(cond_reg, fcond_reg);
}
if (true_src.IsConstant()) {
@@ -5936,8 +5937,8 @@
__ Or(dst.AsRegister<Register>(), AT, TMP);
}
break;
- case Primitive::kPrimLong: {
- if (Primitive::IsFloatingPointType(cond_type)) {
+ case DataType::Type::kInt64: {
+ if (DataType::IsFloatingPointType(cond_type)) {
__ Mfc1(cond_reg, fcond_reg);
}
Register dst_lo = dst.AsRegisterPairLow<Register>();
@@ -5966,8 +5967,8 @@
}
break;
}
- case Primitive::kPrimFloat: {
- if (!Primitive::IsFloatingPointType(cond_type)) {
+ case DataType::Type::kFloat32: {
+ if (!DataType::IsFloatingPointType(cond_type)) {
// sel*.fmt tests bit 0 of the condition register, account for that.
__ Sltu(TMP, ZERO, cond_reg);
__ Mtc1(TMP, fcond_reg);
@@ -6001,8 +6002,8 @@
}
break;
}
- case Primitive::kPrimDouble: {
- if (!Primitive::IsFloatingPointType(cond_type)) {
+ case DataType::Type::kFloat64: {
+ if (!DataType::IsFloatingPointType(cond_type)) {
// sel*.fmt tests bit 0 of the condition register, account for that.
__ Sltu(TMP, ZERO, cond_reg);
__ Mtc1(TMP, fcond_reg);
@@ -6090,11 +6091,11 @@
}
void LocationsBuilderMIPS::HandleFieldGet(HInstruction* instruction, const FieldInfo& field_info) {
- Primitive::Type field_type = field_info.GetFieldType();
- bool is_wide = (field_type == Primitive::kPrimLong) || (field_type == Primitive::kPrimDouble);
+ DataType::Type field_type = field_info.GetFieldType();
+ bool is_wide = (field_type == DataType::Type::kInt64) || (field_type == DataType::Type::kFloat64);
bool generate_volatile = field_info.IsVolatile() && is_wide;
bool object_field_get_with_read_barrier =
- kEmitCompilerReadBarrier && (field_type == Primitive::kPrimNot);
+ kEmitCompilerReadBarrier && (field_type == DataType::Type::kReference);
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(
instruction,
generate_volatile
@@ -6111,18 +6112,18 @@
InvokeRuntimeCallingConvention calling_convention;
// need A0 to hold base + offset
locations->AddTemp(Location::RegisterLocation(calling_convention.GetRegisterAt(0)));
- if (field_type == Primitive::kPrimLong) {
- locations->SetOut(calling_convention.GetReturnLocation(Primitive::kPrimLong));
+ if (field_type == DataType::Type::kInt64) {
+ locations->SetOut(calling_convention.GetReturnLocation(DataType::Type::kInt64));
} else {
// Use Location::Any() to prevent situations when running out of available fp registers.
locations->SetOut(Location::Any());
// Need some temp core regs since FP results are returned in core registers
- Location reg = calling_convention.GetReturnLocation(Primitive::kPrimLong);
+ Location reg = calling_convention.GetReturnLocation(DataType::Type::kInt64);
locations->AddTemp(Location::RegisterLocation(reg.AsRegisterPairLow<Register>()));
locations->AddTemp(Location::RegisterLocation(reg.AsRegisterPairHigh<Register>()));
}
} else {
- if (Primitive::IsFloatingPointType(instruction->GetType())) {
+ if (DataType::IsFloatingPointType(instruction->GetType())) {
locations->SetOut(Location::RequiresFpuRegister());
} else {
// The output overlaps in the case of an object field get with
@@ -6146,7 +6147,7 @@
void InstructionCodeGeneratorMIPS::HandleFieldGet(HInstruction* instruction,
const FieldInfo& field_info,
uint32_t dex_pc) {
- Primitive::Type type = field_info.GetFieldType();
+ DataType::Type type = field_info.GetFieldType();
LocationSummary* locations = instruction->GetLocations();
Location obj_loc = locations->InAt(0);
Register obj = obj_loc.AsRegister<Register>();
@@ -6157,28 +6158,28 @@
auto null_checker = GetImplicitNullChecker(instruction, codegen_);
switch (type) {
- case Primitive::kPrimBoolean:
+ case DataType::Type::kBool:
load_type = kLoadUnsignedByte;
break;
- case Primitive::kPrimByte:
+ case DataType::Type::kInt8:
load_type = kLoadSignedByte;
break;
- case Primitive::kPrimShort:
+ case DataType::Type::kInt16:
load_type = kLoadSignedHalfword;
break;
- case Primitive::kPrimChar:
+ case DataType::Type::kUint16:
load_type = kLoadUnsignedHalfword;
break;
- case Primitive::kPrimInt:
- case Primitive::kPrimFloat:
- case Primitive::kPrimNot:
+ case DataType::Type::kInt32:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kReference:
load_type = kLoadWord;
break;
- case Primitive::kPrimLong:
- case Primitive::kPrimDouble:
+ case DataType::Type::kInt64:
+ case DataType::Type::kFloat64:
load_type = kLoadDoubleword;
break;
- case Primitive::kPrimVoid:
+ case DataType::Type::kVoid:
LOG(FATAL) << "Unreachable type " << type;
UNREACHABLE();
}
@@ -6191,7 +6192,7 @@
codegen_->RecordPcInfo(instruction, instruction->GetDexPc());
codegen_->InvokeRuntime(kQuickA64Load, instruction, dex_pc);
CheckEntrypointTypes<kQuickA64Load, int64_t, volatile const int64_t*>();
- if (type == Primitive::kPrimDouble) {
+ if (type == DataType::Type::kFloat64) {
// FP results are returned in core registers. Need to move them.
if (dst_loc.IsFpuRegister()) {
__ Mtc1(locations->GetTemp(1).AsRegister<Register>(), dst_loc.AsFpuRegister<FRegister>());
@@ -6210,7 +6211,7 @@
}
}
} else {
- if (type == Primitive::kPrimNot) {
+ if (type == DataType::Type::kReference) {
// /* HeapReference<Object> */ dst = *(obj + offset)
if (kEmitCompilerReadBarrier && kUseBakerReadBarrier) {
Location temp_loc =
@@ -6236,9 +6237,9 @@
// reference, if heap poisoning is enabled).
codegen_->MaybeGenerateReadBarrierSlow(instruction, dst_loc, dst_loc, obj_loc, offset);
}
- } else if (!Primitive::IsFloatingPointType(type)) {
+ } else if (!DataType::IsFloatingPointType(type)) {
Register dst;
- if (type == Primitive::kPrimLong) {
+ if (type == DataType::Type::kInt64) {
DCHECK(dst_loc.IsRegisterPair());
dst = dst_loc.AsRegisterPairLow<Register>();
} else {
@@ -6249,7 +6250,7 @@
} else {
DCHECK(dst_loc.IsFpuRegister());
FRegister dst = dst_loc.AsFpuRegister<FRegister>();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ LoadSFromOffset(dst, obj, offset, null_checker);
} else {
__ LoadDFromOffset(dst, obj, offset, null_checker);
@@ -6259,14 +6260,14 @@
// Memory barriers, in the case of references, are handled in the
// previous switch statement.
- if (is_volatile && (type != Primitive::kPrimNot)) {
+ if (is_volatile && (type != DataType::Type::kReference)) {
GenerateMemoryBarrier(MemBarrierKind::kLoadAny);
}
}
void LocationsBuilderMIPS::HandleFieldSet(HInstruction* instruction, const FieldInfo& field_info) {
- Primitive::Type field_type = field_info.GetFieldType();
- bool is_wide = (field_type == Primitive::kPrimLong) || (field_type == Primitive::kPrimDouble);
+ DataType::Type field_type = field_info.GetFieldType();
+ bool is_wide = (field_type == DataType::Type::kInt64) || (field_type == DataType::Type::kFloat64);
bool generate_volatile = field_info.IsVolatile() && is_wide;
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(
instruction, generate_volatile ? LocationSummary::kCallOnMainOnly : LocationSummary::kNoCall);
@@ -6276,7 +6277,7 @@
InvokeRuntimeCallingConvention calling_convention;
// need A0 to hold base + offset
locations->AddTemp(Location::RegisterLocation(calling_convention.GetRegisterAt(0)));
- if (field_type == Primitive::kPrimLong) {
+ if (field_type == DataType::Type::kInt64) {
locations->SetInAt(1, Location::RegisterPairLocation(
calling_convention.GetRegisterAt(2), calling_convention.GetRegisterAt(3)));
} else {
@@ -6287,7 +6288,7 @@
locations->AddTemp(Location::RegisterLocation(calling_convention.GetRegisterAt(3)));
}
} else {
- if (Primitive::IsFloatingPointType(field_type)) {
+ if (DataType::IsFloatingPointType(field_type)) {
locations->SetInAt(1, FpuRegisterOrConstantForStore(instruction->InputAt(1)));
} else {
locations->SetInAt(1, RegisterOrZeroConstant(instruction->InputAt(1)));
@@ -6299,7 +6300,7 @@
const FieldInfo& field_info,
uint32_t dex_pc,
bool value_can_be_null) {
- Primitive::Type type = field_info.GetFieldType();
+ DataType::Type type = field_info.GetFieldType();
LocationSummary* locations = instruction->GetLocations();
Register obj = locations->InAt(0).AsRegister<Register>();
Location value_location = locations->InAt(1);
@@ -6310,24 +6311,24 @@
auto null_checker = GetImplicitNullChecker(instruction, codegen_);
switch (type) {
- case Primitive::kPrimBoolean:
- case Primitive::kPrimByte:
+ case DataType::Type::kBool:
+ case DataType::Type::kInt8:
store_type = kStoreByte;
break;
- case Primitive::kPrimShort:
- case Primitive::kPrimChar:
+ case DataType::Type::kInt16:
+ case DataType::Type::kUint16:
store_type = kStoreHalfword;
break;
- case Primitive::kPrimInt:
- case Primitive::kPrimFloat:
- case Primitive::kPrimNot:
+ case DataType::Type::kInt32:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kReference:
store_type = kStoreWord;
break;
- case Primitive::kPrimLong:
- case Primitive::kPrimDouble:
+ case DataType::Type::kInt64:
+ case DataType::Type::kFloat64:
store_type = kStoreDoubleword;
break;
- case Primitive::kPrimVoid:
+ case DataType::Type::kVoid:
LOG(FATAL) << "Unreachable type " << type;
UNREACHABLE();
}
@@ -6342,7 +6343,7 @@
// Do implicit Null check.
__ Lw(ZERO, locations->GetTemp(0).AsRegister<Register>(), 0);
codegen_->RecordPcInfo(instruction, instruction->GetDexPc());
- if (type == Primitive::kPrimDouble) {
+ if (type == DataType::Type::kFloat64) {
// Pass FP parameters in core registers.
if (value_location.IsFpuRegister()) {
__ Mfc1(locations->GetTemp(1).AsRegister<Register>(),
@@ -6373,9 +6374,9 @@
if (value_location.IsConstant()) {
int64_t value = CodeGenerator::GetInt64ValueOf(value_location.GetConstant());
__ StoreConstToOffset(store_type, value, obj, offset, TMP, null_checker);
- } else if (!Primitive::IsFloatingPointType(type)) {
+ } else if (!DataType::IsFloatingPointType(type)) {
Register src;
- if (type == Primitive::kPrimLong) {
+ if (type == DataType::Type::kInt64) {
src = value_location.AsRegisterPairLow<Register>();
} else {
src = value_location.AsRegister<Register>();
@@ -6384,7 +6385,7 @@
// Note that in the case where `value` is a null reference,
// we do not enter this block, as a null reference does not
// need poisoning.
- DCHECK_EQ(type, Primitive::kPrimNot);
+ DCHECK_EQ(type, DataType::Type::kReference);
__ PoisonHeapReference(TMP, src);
__ StoreToOffset(store_type, TMP, obj, offset, null_checker);
} else {
@@ -6392,7 +6393,7 @@
}
} else {
FRegister src = value_location.AsFpuRegister<FRegister>();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ StoreSToOffset(src, obj, offset, null_checker);
} else {
__ StoreDToOffset(src, obj, offset, null_checker);
@@ -8010,15 +8011,15 @@
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(mul, LocationSummary::kNoCall);
switch (mul->GetResultType()) {
- case Primitive::kPrimInt:
- case Primitive::kPrimLong:
+ case DataType::Type::kInt32:
+ case DataType::Type::kInt64:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RequiresRegister());
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
locations->SetInAt(0, Location::RequiresFpuRegister());
locations->SetInAt(1, Location::RequiresFpuRegister());
locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap);
@@ -8030,12 +8031,12 @@
}
void InstructionCodeGeneratorMIPS::VisitMul(HMul* instruction) {
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
LocationSummary* locations = instruction->GetLocations();
bool isR6 = codegen_->GetInstructionSetFeatures().IsR6();
switch (type) {
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
Register dst = locations->Out().AsRegister<Register>();
Register lhs = locations->InAt(0).AsRegister<Register>();
Register rhs = locations->InAt(1).AsRegister<Register>();
@@ -8047,7 +8048,7 @@
}
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
Register dst_high = locations->Out().AsRegisterPairHigh<Register>();
Register dst_low = locations->Out().AsRegisterPairLow<Register>();
Register lhs_high = locations->InAt(0).AsRegisterPairHigh<Register>();
@@ -8084,12 +8085,12 @@
}
break;
}
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64: {
FRegister dst = locations->Out().AsFpuRegister<FRegister>();
FRegister lhs = locations->InAt(0).AsFpuRegister<FRegister>();
FRegister rhs = locations->InAt(1).AsFpuRegister<FRegister>();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ MulS(dst, lhs, rhs);
} else {
__ MulD(dst, lhs, rhs);
@@ -8105,14 +8106,14 @@
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(neg, LocationSummary::kNoCall);
switch (neg->GetResultType()) {
- case Primitive::kPrimInt:
- case Primitive::kPrimLong:
+ case DataType::Type::kInt32:
+ case DataType::Type::kInt64:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
break;
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble:
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64:
locations->SetInAt(0, Location::RequiresFpuRegister());
locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap);
break;
@@ -8123,17 +8124,17 @@
}
void InstructionCodeGeneratorMIPS::VisitNeg(HNeg* instruction) {
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
LocationSummary* locations = instruction->GetLocations();
switch (type) {
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
Register dst = locations->Out().AsRegister<Register>();
Register src = locations->InAt(0).AsRegister<Register>();
__ Subu(dst, ZERO, src);
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
Register dst_high = locations->Out().AsRegisterPairHigh<Register>();
Register dst_low = locations->Out().AsRegisterPairLow<Register>();
Register src_high = locations->InAt(0).AsRegisterPairHigh<Register>();
@@ -8144,11 +8145,11 @@
__ Subu(dst_high, dst_high, TMP);
break;
}
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64: {
FRegister dst = locations->Out().AsFpuRegister<FRegister>();
FRegister src = locations->InAt(0).AsFpuRegister<FRegister>();
- if (type == Primitive::kPrimFloat) {
+ if (type == DataType::Type::kFloat32) {
__ NegS(dst, src);
} else {
__ NegD(dst, src);
@@ -8164,7 +8165,7 @@
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kCallOnMainOnly);
InvokeRuntimeCallingConvention calling_convention;
- locations->SetOut(calling_convention.GetReturnLocation(Primitive::kPrimNot));
+ locations->SetOut(calling_convention.GetReturnLocation(DataType::Type::kReference));
locations->SetInAt(0, Location::RegisterLocation(calling_convention.GetRegisterAt(0)));
locations->SetInAt(1, Location::RegisterLocation(calling_convention.GetRegisterAt(1)));
}
@@ -8188,7 +8189,7 @@
} else {
locations->SetInAt(0, Location::RegisterLocation(calling_convention.GetRegisterAt(0)));
}
- locations->SetOut(calling_convention.GetReturnLocation(Primitive::kPrimNot));
+ locations->SetOut(calling_convention.GetReturnLocation(DataType::Type::kReference));
}
void InstructionCodeGeneratorMIPS::VisitNewInstance(HNewInstance* instruction) {
@@ -8216,18 +8217,18 @@
}
void InstructionCodeGeneratorMIPS::VisitNot(HNot* instruction) {
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
LocationSummary* locations = instruction->GetLocations();
switch (type) {
- case Primitive::kPrimInt: {
+ case DataType::Type::kInt32: {
Register dst = locations->Out().AsRegister<Register>();
Register src = locations->InAt(0).AsRegister<Register>();
__ Nor(dst, src, ZERO);
break;
}
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
Register dst_high = locations->Out().AsRegisterPairHigh<Register>();
Register dst_low = locations->Out().AsRegisterPairLow<Register>();
Register src_high = locations->InAt(0).AsRegisterPairHigh<Register>();
@@ -8339,19 +8340,20 @@
}
void LocationsBuilderMIPS::VisitRem(HRem* rem) {
- Primitive::Type type = rem->GetResultType();
- LocationSummary::CallKind call_kind =
- (type == Primitive::kPrimInt) ? LocationSummary::kNoCall : LocationSummary::kCallOnMainOnly;
+ DataType::Type type = rem->GetResultType();
+ LocationSummary::CallKind call_kind = (type == DataType::Type::kInt32)
+ ? LocationSummary::kNoCall
+ : LocationSummary::kCallOnMainOnly;
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(rem, call_kind);
switch (type) {
- case Primitive::kPrimInt:
+ case DataType::Type::kInt32:
locations->SetInAt(0, Location::RequiresRegister());
locations->SetInAt(1, Location::RegisterOrConstant(rem->InputAt(1)));
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
break;
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
InvokeRuntimeCallingConvention calling_convention;
locations->SetInAt(0, Location::RegisterPairLocation(
calling_convention.GetRegisterAt(0), calling_convention.GetRegisterAt(1)));
@@ -8361,8 +8363,8 @@
break;
}
- case Primitive::kPrimFloat:
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat32:
+ case DataType::Type::kFloat64: {
InvokeRuntimeCallingConvention calling_convention;
locations->SetInAt(0, Location::FpuRegisterLocation(calling_convention.GetFpuRegisterAt(0)));
locations->SetInAt(1, Location::FpuRegisterLocation(calling_convention.GetFpuRegisterAt(1)));
@@ -8376,23 +8378,23 @@
}
void InstructionCodeGeneratorMIPS::VisitRem(HRem* instruction) {
- Primitive::Type type = instruction->GetType();
+ DataType::Type type = instruction->GetType();
switch (type) {
- case Primitive::kPrimInt:
+ case DataType::Type::kInt32:
GenerateDivRemIntegral(instruction);
break;
- case Primitive::kPrimLong: {
+ case DataType::Type::kInt64: {
codegen_->InvokeRuntime(kQuickLmod, instruction, instruction->GetDexPc());
CheckEntrypointTypes<kQuickLmod, int64_t, int64_t, int64_t>();
break;
}
- case Primitive::kPrimFloat: {
+ case DataType::Type::kFloat32: {
codegen_->InvokeRuntime(kQuickFmodf, instruction, instruction->GetDexPc());
CheckEntrypointTypes<kQuickFmodf, float, float, float>();
break;
}
- case Primitive::kPrimDouble: {
+ case DataType::Type::kFloat64: {
codegen_->InvokeRuntime(kQuickFmod, instruction, instruction->GetDexPc());
CheckEntrypointTypes<kQuickFmod, double, double, double>();
break;
@@ -8421,7 +8423,7 @@
void LocationsBuilderMIPS::VisitReturn(HReturn* ret) {
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(ret);
- Primitive::Type return_type = ret->InputAt(0)->GetType();
+ DataType::Type return_type = ret->InputAt(0)->GetType();
locations->SetInAt(0, MipsReturnLocation(return_type));
}
@@ -8597,33 +8599,33 @@
}
void LocationsBuilderMIPS::VisitTypeConversion(HTypeConversion* conversion) {
- Primitive::Type input_type = conversion->GetInputType();
- Primitive::Type result_type = conversion->GetResultType();
+ DataType::Type input_type = conversion->GetInputType();
+ DataType::Type result_type = conversion->GetResultType();
DCHECK_NE(input_type, result_type);
bool isR6 = codegen_->GetInstructionSetFeatures().IsR6();
- if ((input_type == Primitive::kPrimNot) || (input_type == Primitive::kPrimVoid) ||
- (result_type == Primitive::kPrimNot) || (result_type == Primitive::kPrimVoid)) {
+ if ((input_type == DataType::Type::kReference) || (input_type == DataType::Type::kVoid) ||
+ (result_type == DataType::Type::kReference) || (result_type == DataType::Type::kVoid)) {
LOG(FATAL) << "Unexpected type conversion from " << input_type << " to " << result_type;
}
LocationSummary::CallKind call_kind = LocationSummary::kNoCall;
if (!isR6 &&
- ((Primitive::IsFloatingPointType(result_type) && input_type == Primitive::kPrimLong) ||
- (result_type == Primitive::kPrimLong && Primitive::IsFloatingPointType(input_type)))) {
+ ((DataType::IsFloatingPointType(result_type) && input_type == DataType::Type::kInt64) ||
+ (result_type == DataType::Type::kInt64 && DataType::IsFloatingPointType(input_type)))) {
call_kind = LocationSummary::kCallOnMainOnly;
}
LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(conversion, call_kind);
if (call_kind == LocationSummary::kNoCall) {
- if (Primitive::IsFloatingPointType(input_type)) {
+ if (DataType::IsFloatingPointType(input_type)) {
locations->SetInAt(0, Location::RequiresFpuRegister());
} else {
locations->SetInAt(0, Location::RequiresRegister());
}
- if (Primitive::IsFloatingPointType(result_type)) {
+ if (DataType::IsFloatingPointType(result_type)) {
locations->SetOut(Location::RequiresFpuRegister(), Location::kNoOutputOverlap);
} else {
locations->SetOut(Location::RequiresRegister(), Location::kNoOutputOverlap);
@@ -8631,10 +8633,10 @@
} else {
InvokeRuntimeCallingConvention calling_convention;
- if (Primitive::IsFloatingPointType(input_type)) {
+ if (DataType::IsFloatingPointType(input_type)) {
locations->SetInAt(0, Location::FpuRegisterLocation(calling_convention.GetFpuRegisterAt(0)));
} else {
- DCHECK_EQ(input_type, Primitive::kPrimLong);
+ DCHECK_EQ(input_type, DataType::Type::kInt64);
locations->SetInAt(0, Location::RegisterPairLocation(
calling_convention.GetRegisterAt(0), calling_convention.GetRegisterAt(1)));
}
@@ -8645,14 +8647,14 @@
void InstructionCodeGeneratorMIPS::VisitTypeConversion(HTypeConversion* conversion) {
LocationSummary* locations = conversion->GetLocations();
- Primitive::Type result_type = conversion->GetResultType();
- Primitive::Type input_type = conversion->GetInputType();
+ DataType::Type result_type = conversion->GetResultType();
+ DataType::Type input_type = conversion->GetInputType();
bool has_sign_extension = codegen_->GetInstructionSetFeatures().IsMipsIsaRevGreaterThanEqual2();
bool isR6 = codegen_->GetInstructionSetFeatures().IsR6();
DCHECK_NE(input_type, result_type);
- if (result_type == Primitive::kPrimLong && Primitive::IsIntegralType(input_type)) {
+ if (result_type == DataType::Type::kInt64 && DataType::IsIntegralType(input_type)) {
Register dst_high = locations->Out().AsRegisterPairHigh<Register>();
Register dst_low = locations->Out().AsRegisterPairLow<Register>();
Register src = locations->InAt(0).AsRegister<Register>();
@@ -8661,17 +8663,17 @@
__ Move(dst_low, src);
}
__ Sra(dst_high, src, 31);
- } else if (Primitive::IsIntegralType(result_type) && Primitive::IsIntegralType(input_type)) {
+ } else if (DataType::IsIntegralType(result_type) && DataType::IsIntegralType(input_type)) {
Register dst = locations->Out().AsRegister<Register>();
- Register src = (input_type == Primitive::kPrimLong)
+ Register src = (input_type == DataType::Type::kInt64)
? locations->InAt(0).AsRegisterPairLow<Register>()
: locations->InAt(0).AsRegister<Register>();
switch (result_type) {
- case Primitive::kPrimChar:
+ case DataType::Type::kUint16:
__ Andi(dst, src, 0xFFFF);
break;
- case Primitive::kPrimByte:
+ case DataType::Type::kInt8:
if (has_sign_extension) {
__ Seb(dst, src);
} else {
@@ -8679,7 +8681,7 @@
__ Sra(dst, dst, 24);
}
break;
- case Primitive::kPrimShort:
+ case DataType::Type::kInt16:
if (has_sign_extension) {
__ Seh(dst, src);
} else {
@@ -8687,7 +8689,7 @@
__ Sra(dst, dst, 16);
}
break;
- case Primitive::kPrimInt:
+ case DataType::Type::kInt32:
if (dst != src) {
__ Move(dst, src);
}
@@ -8697,8 +8699,8 @@
LOG(FATAL) << "Unexpected type conversion from " << input_type
<< " to " << result_type;
}
- } else if (Primitive::IsFloatingPointType(result_type) && Primitive::IsIntegralType(input_type)) {
- if (input_type == Primitive::kPrimLong) {
+ } else if (DataType::IsFloatingPointType(result_type) && DataType::IsIntegralType(input_type)) {
+ if (input_type == DataType::Type::kInt64) {
if (isR6) {
// cvt.s.l/cvt.d.l requires MIPSR2+ with FR=1. MIPS32R6 is implemented as a secondary
// architecture on top of MIPS64R6, which has FR=1, and therefore can use the instruction.
@@ -8707,16 +8709,16 @@
FRegister dst = locations->Out().AsFpuRegister<FRegister>();
__ Mtc1(src_low, FTMP);
__ Mthc1(src_high, FTMP);
- if (result_type == Primitive::kPrimFloat) {
+ if (result_type == DataType::Type::kFloat32) {
__ Cvtsl(dst, FTMP);
} else {
__ Cvtdl(dst, FTMP);
}
} else {
- QuickEntrypointEnum entrypoint = (result_type == Primitive::kPrimFloat) ? kQuickL2f
- : kQuickL2d;
+ QuickEntrypointEnum entrypoint =
+ (result_type == DataType::Type::kFloat32) ? kQuickL2f : kQuickL2d;
codegen_->InvokeRuntime(entrypoint, conversion, conversion->GetDexPc());
- if (result_type == Primitive::kPrimFloat) {
+ if (result_type == DataType::Type::kFloat32) {
CheckEntrypointTypes<kQuickL2f, float, int64_t>();
} else {
CheckEntrypointTypes<kQuickL2d, double, int64_t>();
@@ -8726,14 +8728,14 @@
Register src = locations->InAt(0).AsRegister<Register>();
FRegister dst = locations->Out().AsFpuRegister<FRegister>();
__ Mtc1(src, FTMP);
- if (result_type == Primitive::kPrimFloat) {
+ if (result_type == DataType::Type::kFloat32) {
__ Cvtsw(dst, FTMP);
} else {
__ Cvtdw(dst, FTMP);
}
}
- } else if (Primitive::IsIntegralType(result_type) && Primitive::IsFloatingPointType(input_type)) {
- CHECK(result_type == Primitive::kPrimInt || result_type == Primitive::kPrimLong);
+ } else if (DataType::IsIntegralType(result_type) && DataType::IsFloatingPointType(input_type)) {
+ CHECK(result_type == DataType::Type::kInt32 || result_type == DataType::Type::kInt64);
// When NAN2008=1 (R6), the truncate instruction caps the output at the minimum/maximum
// value of the output type if the input is outside of the range after the truncation or
@@ -8751,7 +8753,7 @@
// instruction, which will handle such an input the same way irrespective of NAN2008.
// Otherwise the input is compared to itself to determine whether it is a NaN or not
// in order to return either zero or the minimum value.
- if (result_type == Primitive::kPrimLong) {
+ if (result_type == DataType::Type::kInt64) {
if (isR6) {
// trunc.l.s/trunc.l.d requires MIPSR2+ with FR=1. MIPS32R6 is implemented as a secondary
// architecture on top of MIPS64R6, which has FR=1, and therefore can use the instruction.
@@ -8759,7 +8761,7 @@
Register dst_high = locations->Out().AsRegisterPairHigh<Register>();
Register dst_low = locations->Out().AsRegisterPairLow<Register>();
- if (input_type == Primitive::kPrimFloat) {
+ if (input_type == DataType::Type::kFloat32) {
__ TruncLS(FTMP, src);
} else {
__ TruncLD(FTMP, src);
@@ -8767,10 +8769,10 @@
__ Mfc1(dst_low, FTMP);
__ Mfhc1(dst_high, FTMP);
} else {
- QuickEntrypointEnum entrypoint = (input_type == Primitive::kPrimFloat) ? kQuickF2l
- : kQuickD2l;
+ QuickEntrypointEnum entrypoint =
+ (input_type == DataType::Type::kFloat32) ? kQuickF2l : kQuickD2l;
codegen_->InvokeRuntime(entrypoint, conversion, conversion->GetDexPc());
- if (input_type == Primitive::kPrimFloat) {
+ if (input_type == DataType::Type::kFloat32) {
CheckEntrypointTypes<kQuickF2l, int64_t, float>();
} else {
CheckEntrypointTypes<kQuickD2l, int64_t, double>();
@@ -8783,7 +8785,7 @@
MipsLabel done;
if (!isR6) {
- if (input_type == Primitive::kPrimFloat) {
+ if (input_type == DataType::Type::kFloat32) {
uint32_t min_val = bit_cast<uint32_t, float>(std::numeric_limits<int32_t>::min());
__ LoadConst32(TMP, min_val);
__ Mtc1(TMP, FTMP);
@@ -8794,14 +8796,14 @@
__ MoveToFpuHigh(TMP, FTMP);
}
- if (input_type == Primitive::kPrimFloat) {
+ if (input_type == DataType::Type::kFloat32) {
__ ColeS(0, FTMP, src);
} else {
__ ColeD(0, FTMP, src);
}
__ Bc1t(0, &truncate);
- if (input_type == Primitive::kPrimFloat) {
+ if (input_type == DataType::Type::kFloat32) {
__ CeqS(0, src, src);
} else {
__ CeqD(0, src, src);
@@ -8814,7 +8816,7 @@
__ Bind(&truncate);
}
- if (input_type == Primitive::kPrimFloat) {
+ if (input_type == DataType::Type::kFloat32) {
__ TruncWS(FTMP, src);
} else {
__ TruncWD(FTMP, src);
@@ -8825,11 +8827,11 @@
__ Bind(&done);
}
}
- } else if (Primitive::IsFloatingPointType(result_type) &&
- Primitive::IsFloatingPointType(input_type)) {
+ } else if (DataType::IsFloatingPointType(result_type) &&
+ DataType::IsFloatingPointType(input_type)) {
FRegister dst = locations->Out().AsFpuRegister<FRegister>();
FRegister src = locations->InAt(0).AsFpuRegister<FRegister>();
- if (result_type == Primitive::kPrimFloat) {
+ if (result_type == DataType::Type::kFloat32) {
__ Cvtsd(dst, src);
} else {
__ Cvtds(dst, src);