diff options
Diffstat (limited to 'backend/unittests/CodeGen')
22 files changed, 142 insertions, 189 deletions
diff --git a/backend/unittests/CodeGen/CoreTypesTest.cpp b/backend/unittests/CodeGen/CoreTypesTest.cpp index b19d6b4..8ad0ce6 100644 --- a/backend/unittests/CodeGen/CoreTypesTest.cpp +++ b/backend/unittests/CodeGen/CoreTypesTest.cpp @@ -5,12 +5,10 @@ #include "rcc/CodeGen/Register.h" #include "rcc/CodeGen/StableID.h" -#include <array> #include <cstdint> #include <iostream> #include <string_view> #include <type_traits> -#include <unordered_set> namespace { @@ -32,126 +30,92 @@ private: }; void testLowLevelTypes(TestContext &Context) { - const rcc::LLT Invalid; - Context.expect(!Invalid.isValid(), "default LLT must be invalid"); - Context.expect(Invalid.toString() == "LLT_invalid", "invalid LLT spelling must be stable"); - - const rcc::LLT Token = rcc::LLT::token(); - Context.expect(Token.isToken(), "token LLT must preserve its kind"); - Context.expect(Token.scalarBitWidth() == 0, "token LLT must have no bit width"); - Context.expect(Token.toString() == "s0", "token LLT must use the MIR token spelling"); - - auto Any = rcc::LLT::makeAnyScalar(3); - auto Integer = rcc::LLT::makeInteger(3); - Context.expect(Any && Integer, "arbitrary positive scalar widths must be accepted"); - if (Any && Integer) { - Context.expect(Any->isAnyScalar(), "bag-of-bits LLT must preserve its kind"); - Context.expect(Integer->isInteger(), "integer LLT must preserve its kind"); - Context.expect(*Any != *Integer, "bag-of-bits and integer LLTs must remain distinct"); - Context.expect(Any->toString() == "s3", "bag-of-bits LLT spelling must include its width"); - Context.expect(Integer->toString() == "i3", "integer LLT spelling must include its width"); + const rcc::LowLevelType Invalid; + Context.expect(!Invalid.isValid(), "default LowLevelType must be invalid"); + Context.expect(Invalid.toString() == "LLT_invalid", + "invalid LowLevelType spelling must be stable"); + + const rcc::LowLevelType Token = rcc::LowLevelType::token(); + Context.expect(Token.isToken(), "token LowLevelType must preserve its kind"); + Context.expect(Token.scalarBitWidth() == 0, "token LowLevelType must have no bit width"); + Context.expect(Token.toString() == "s0", "token LowLevelType must use the MIR token spelling"); + + auto Scalar = rcc::LowLevelType::makeCategoryNeutralScalar(3); + auto SameScalar = rcc::LowLevelType::makeCategoryNeutralScalar(3); + Context.expect(Scalar && SameScalar, "arbitrary positive scalar widths must be accepted"); + if (Scalar && SameScalar) { + Context.expect(Scalar->isCategoryNeutralScalar(), + "scalar LowLevelType must preserve its category-neutral kind"); + Context.expect(*Scalar == *SameScalar, + "equal-width scalars must have one canonical low-level type"); + Context.expect(Scalar->toString() == "s3", + "scalar LowLevelType spelling must include its width"); } - Context.expect(!rcc::LLT::makeInteger(0), "zero-width integer LLT must be rejected"); - Context.expect(!rcc::LLT::makeInteger(std::uint64_t{1} << 16), - "integer LLT wider than the encoding must be rejected"); - - constexpr std::array FloatCases{ - std::pair{rcc::FloatSemantics::IEEEHalf, std::uint32_t{16}}, - std::pair{rcc::FloatSemantics::BFloat, std::uint32_t{16}}, - std::pair{rcc::FloatSemantics::IEEESingle, std::uint32_t{32}}, - std::pair{rcc::FloatSemantics::IEEEDouble, std::uint32_t{64}}, - std::pair{rcc::FloatSemantics::IEEEQuad, std::uint32_t{128}}, - std::pair{rcc::FloatSemantics::PPCDoubleDouble, std::uint32_t{128}}, - std::pair{rcc::FloatSemantics::Float8E5M2, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::Float8E5M2FNUZ, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::Float8E4M3, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::Float8E4M3FN, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::Float8E4M3FNUZ, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::Float8E4M3B11FNUZ, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::Float8E3M4, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::FloatTF32, std::uint32_t{19}}, - std::pair{rcc::FloatSemantics::Float8E8M0FNU, std::uint32_t{8}}, - std::pair{rcc::FloatSemantics::Float6E3M2FN, std::uint32_t{6}}, - std::pair{rcc::FloatSemantics::Float6E2M3FN, std::uint32_t{6}}, - std::pair{rcc::FloatSemantics::Float4E2M1FN, std::uint32_t{4}}, - std::pair{rcc::FloatSemantics::X87DoubleExtended, std::uint32_t{80}}, - }; - - std::unordered_set<rcc::LLT> FloatTypes; - for (const auto &[Semantics, BitWidth] : FloatCases) { - auto Type = rcc::LLT::makeFloat(Semantics); - Context.expect(Type.has_value(), "known floating-point semantics must be accepted"); - if (!Type) - continue; - Context.expect(Type->scalarBitWidth() == BitWidth, - "float LLT must preserve its semantics bit width"); - Context.expect(Type->floatSemantics() == Semantics, - "float LLT must preserve exact floating-point semantics"); - FloatTypes.insert(*Type); - } - Context.expect(FloatTypes.size() == FloatCases.size(), - "distinct floating-point semantics must produce distinct LLTs"); - Context.expect(!rcc::LLT::makeFloat(rcc::FloatSemantics::Count), - "unknown floating-point semantics must be rejected"); + Context.expect(!rcc::LowLevelType::makeCategoryNeutralScalar(0), + "zero-width scalar LowLevelType must be rejected"); + Context.expect(!rcc::LowLevelType::makeCategoryNeutralScalar(std::uint64_t{1} << 16), + "scalar LowLevelType wider than the encoding must be rejected"); - auto Pointer = rcc::LLT::makePointer(rcc::LLT::MaxAddressSpace, 64); + auto Pointer = rcc::LowLevelType::makePointer(rcc::LowLevelType::MaxAddressSpace, 64); Context.expect(Pointer.has_value(), "maximum encodable pointer address space must be accepted"); if (Pointer) { - Context.expect(Pointer->isPointer(), "pointer LLT must preserve its kind"); - Context.expect(Pointer->addressSpace() == rcc::LLT::MaxAddressSpace, - "pointer LLT must preserve its address space"); + Context.expect(Pointer->isPointer(), "pointer LowLevelType must preserve its kind"); + Context.expect(Pointer->addressSpace() == rcc::LowLevelType::MaxAddressSpace, + "pointer LowLevelType must preserve its address space"); Context.expect(Pointer->toString() == "p16777215:64", - "pointer LLT spelling must preserve address space and width"); + "pointer LowLevelType spelling must preserve address space and width"); } - Context.expect(!rcc::LLT::makePointer(std::uint64_t{1} << 24, 64), + Context.expect(!rcc::LowLevelType::makePointer(std::uint64_t{1} << 24, 64), "pointer address spaces wider than the encoding must be rejected"); - auto I33 = rcc::LLT::makeInteger(33); + auto I33 = rcc::LowLevelType::makeCategoryNeutralScalar(33); if (!I33) { Context.expect(false, "i33 construction must succeed before vector tests"); return; } - auto FixedVector = rcc::LLT::makeFixedVector(4, *I33); - Context.expect(FixedVector.has_value(), "fixed integer vector LLT must be accepted"); + auto FixedVector = rcc::LowLevelType::makeFixedVector(4, *I33); + Context.expect(FixedVector.has_value(), "fixed integer vector LowLevelType must be accepted"); if (FixedVector) { - Context.expect(FixedVector->isVector(), "fixed vector LLT must preserve vector kind"); + Context.expect(FixedVector->isVector(), "fixed vector LowLevelType must preserve vector kind"); Context.expect(!FixedVector->isScalableVector(), - "fixed vector LLT must not be marked scalable"); + "fixed vector LowLevelType must not be marked scalable"); Context.expect(FixedVector->minimumElementCount() == 4, - "fixed vector LLT must preserve element count"); + "fixed vector LowLevelType must preserve element count"); Context.expect(FixedVector->scalarElementType() == I33, - "fixed vector LLT must preserve its scalar element type"); - Context.expect(FixedVector->toString() == "<4 x i33>", - "fixed vector LLT spelling must be stable"); + "fixed vector LowLevelType must preserve its scalar element type"); + Context.expect(FixedVector->toString() == "<4 x s33>", + "fixed vector LowLevelType spelling must be stable"); } - auto BFloat = rcc::LLT::makeFloat(rcc::FloatSemantics::BFloat); - if (!BFloat) { - Context.expect(false, "bfloat construction must succeed before vector tests"); + auto S16 = rcc::LowLevelType::makeCategoryNeutralScalar(16); + if (!S16) { + Context.expect(false, "s16 construction must succeed before vector tests"); return; } - auto ScalableVector = rcc::LLT::makeScalableVector(1, *BFloat); + auto ScalableVector = rcc::LowLevelType::makeScalableVector(1, *S16); Context.expect(ScalableVector.has_value(), "scalable vector with one minimum lane must work"); if (ScalableVector) { Context.expect(ScalableVector->isScalableVector(), - "scalable vector LLT must preserve scalability"); - Context.expect(ScalableVector->isFloatVector() && !ScalableVector->isFloat(), - "float vectors must not be classified as scalar floats"); - Context.expect(ScalableVector->floatSemantics() == rcc::FloatSemantics::BFloat, - "float vectors must preserve exact floating-point semantics"); - Context.expect(ScalableVector->toString() == "<vscale x 1 x bf16>", - "scalable float vector spelling must preserve exact semantics"); + "scalable vector LowLevelType must preserve scalability"); + Context.expect(ScalableVector->isVectorValue(), + "category-neutral vectors must preserve their value kind"); + Context.expect(ScalableVector->scalarElementType() == S16, + "scalable vectors must preserve their element type"); + Context.expect(ScalableVector->toString() == "<vscale x 1 x s16>", + "scalable vector spelling must preserve its shape"); } - Context.expect(!rcc::LLT::makeFixedVector(1, *I33), "single-lane fixed vectors must be rejected"); - Context.expect(!rcc::LLT::makeScalableVector(0, *I33), + Context.expect(!rcc::LowLevelType::makeFixedVector(1, *I33), + "single-lane fixed vectors must be rejected"); + Context.expect(!rcc::LowLevelType::makeScalableVector(0, *I33), "zero-lane scalable vectors must be rejected"); - Context.expect(!rcc::LLT::makeFixedVector(4, Token), "token vector elements must be rejected"); + Context.expect(!rcc::LowLevelType::makeFixedVector(4, Token), + "token vector elements must be rejected"); if (FixedVector) { - Context.expect(!rcc::LLT::makeFixedVector(4, *FixedVector), - "nested LLT vectors must be rejected"); + Context.expect(!rcc::LowLevelType::makeFixedVector(4, *FixedVector), + "nested LowLevelType vectors must be rejected"); } } diff --git a/backend/unittests/CodeGen/GenericOpcodesTest.cpp b/backend/unittests/CodeGen/GenericOpcodesTest.cpp index 73c1c36..f946c90 100644 --- a/backend/unittests/CodeGen/GenericOpcodesTest.cpp +++ b/backend/unittests/CodeGen/GenericOpcodesTest.cpp @@ -53,7 +53,8 @@ private: return std::move(*Operand); } -[[nodiscard]] rcc::Register createVirtualRegister(rcc::MachineFunction &Function, rcc::LLT Type) { +[[nodiscard]] rcc::Register createVirtualRegister(rcc::MachineFunction &Function, + rcc::LowLevelType Type) { auto Reg = Function.registerInfo().createVirtualRegister(Type); if (!Reg) std::terminate(); @@ -284,16 +285,19 @@ void testShapesAndTypes(TestContext &Context) { if (!Set || !Function) return; - auto I32 = rcc::LLT::makeInteger(32); - auto I64 = rcc::LLT::makeInteger(64); - auto I1 = rcc::LLT::makeInteger(1); - auto S16 = rcc::LLT::makeAnyScalar(16); - auto F32 = rcc::LLT::makeFloat(rcc::FloatSemantics::IEEESingle); - auto F64 = rcc::LLT::makeFloat(rcc::FloatSemantics::IEEEDouble); - auto P64 = rcc::LLT::makePointer(0, 64); - auto V2I32 = I32 ? rcc::LLT::makeFixedVector(2, *I32) : rcc::Expected<rcc::LLT>{}; - auto V4I32 = I32 ? rcc::LLT::makeFixedVector(4, *I32) : rcc::Expected<rcc::LLT>{}; - auto V2P64 = P64 ? rcc::LLT::makeFixedVector(2, *P64) : rcc::Expected<rcc::LLT>{}; + auto I32 = rcc::LowLevelType::makeCategoryNeutralScalar(32); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); + auto I1 = rcc::LowLevelType::makeCategoryNeutralScalar(1); + auto S16 = rcc::LowLevelType::makeCategoryNeutralScalar(16); + auto F32 = rcc::LowLevelType::makeCategoryNeutralScalar(32); + auto F64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); + auto P64 = rcc::LowLevelType::makePointer(0, 64); + auto V2I32 = + I32 ? rcc::LowLevelType::makeFixedVector(2, *I32) : rcc::Expected<rcc::LowLevelType>{}; + auto V4I32 = + I32 ? rcc::LowLevelType::makeFixedVector(4, *I32) : rcc::Expected<rcc::LowLevelType>{}; + auto V2P64 = + P64 ? rcc::LowLevelType::makeFixedVector(2, *P64) : rcc::Expected<rcc::LowLevelType>{}; if (!I1 || !I32 || !I64 || !S16 || !F32 || !F64 || !P64 || !V2I32 || !V4I32 || !V2P64) std::terminate(); auto Dst32 = (*Function)->registerInfo().createVirtualRegister(*I32); @@ -324,7 +328,7 @@ void testShapesAndTypes(TestContext &Context) { AddOperands.back() = registerOperand(*Wide, false); Context.expect(!Set->validateExplicitOperands(rcc::opcode(rcc::GenericOpcode::G_ADD), AddOperands, (*Function)->registerInfo()), - "G_ADD must reject a source from a different LLT equality group"); + "G_ADD must reject a source from a different LowLevelType equality group"); auto ZeroImmediate = rcc::APInt::fromUnsigned(64, 0); std::vector<rcc::MachineOperand> PointerConstant; @@ -483,10 +487,6 @@ void testShapesAndTypes(TestContext &Context) { FloatingLoad, (*Function)->registerInfo()) .has_value(), "G_FPEXTLOAD must accept a scalar floating result and pointer address"); - FloatingLoad[0] = registerOperand(*Wide, true); - Context.expect(!Set->validateExplicitOperands(rcc::opcode(rcc::GenericOpcode::G_FPEXTLOAD), - FloatingLoad, (*Function)->registerInfo()), - "G_FPEXTLOAD must reject an integer result"); const std::array<std::uint64_t, 1> FloatWords{0}; auto FloatBits = rcc::APFloat::create(rcc::FloatSemantics::IEEESingle, FloatWords); @@ -513,7 +513,7 @@ void testShapesAndTypes(TestContext &Context) { Context.expect(Set->validateExplicitOperands(rcc::opcode(rcc::GenericOpcode::G_FCONSTANT), FConstantOperands, (*Function)->registerInfo()) .has_value(), - "G_FCONSTANT must accept a bit-width-compatible LLVM scalar LLT"); + "G_FCONSTANT must accept a bit-width-compatible LLVM scalar LowLevelType"); } void testInstructionMemorySemantics(TestContext &Context) { @@ -524,12 +524,12 @@ void testInstructionMemorySemantics(TestContext &Context) { if (!Set || !Function) return; - const rcc::LLT I1 = *rcc::LLT::makeInteger(1); - const rcc::LLT I32 = *rcc::LLT::makeInteger(32); - const rcc::LLT I64 = *rcc::LLT::makeInteger(64); - const rcc::LLT F64 = *rcc::LLT::makeFloat(rcc::FloatSemantics::IEEEDouble); - const rcc::LLT P0 = *rcc::LLT::makePointer(0, 64); - const rcc::LLT P1 = *rcc::LLT::makePointer(1, 64); + const rcc::LowLevelType I1 = *rcc::LowLevelType::makeCategoryNeutralScalar(1); + const rcc::LowLevelType I32 = *rcc::LowLevelType::makeCategoryNeutralScalar(32); + const rcc::LowLevelType I64 = *rcc::LowLevelType::makeCategoryNeutralScalar(64); + const rcc::LowLevelType F64 = *rcc::LowLevelType::makeCategoryNeutralScalar(64); + const rcc::LowLevelType P0 = *rcc::LowLevelType::makePointer(0, 64); + const rcc::LowLevelType P1 = *rcc::LowLevelType::makePointer(1, 64); const rcc::Register Dst32 = createVirtualRegister(**Function, I32); const rcc::Register Dst64 = createVirtualRegister(**Function, I64); const rcc::Register Src32 = createVirtualRegister(**Function, I32); @@ -555,7 +555,7 @@ void testInstructionMemorySemantics(TestContext &Context) { createInstruction(**Function, rcc::GenericOpcode::G_LOAD, std::move(OversizedLoadOperands)); addMemOperand(**Function, OversizedLoad, memoryDescription({rcc::MemoryAccessFlag::Load}, 8)); Context.expect(!Set->validateInstruction(OversizedLoad, (*Function)->registerInfo()), - "G_LOAD must reject an MMO larger than its result LLT"); + "G_LOAD must reject an MMO larger than its result LowLevelType"); std::vector<rcc::MachineOperand> WrongAddressSpaceOperands; WrongAddressSpaceOperands.push_back(registerOperand(Dst64, true)); @@ -648,18 +648,6 @@ void testInstructionMemorySemantics(TestContext &Context) { Context.expect(Set->validateInstruction(FloatingAtomic, (*Function)->registerInfo()).has_value(), "floating atomic RMW must accept a scalar floating value and RMW MMO"); - std::vector<rcc::MachineOperand> WrongFloatingAtomicOperands; - WrongFloatingAtomicOperands.push_back(registerOperand(Dst64, true)); - WrongFloatingAtomicOperands.push_back(registerOperand(Address0, false)); - WrongFloatingAtomicOperands.push_back(registerOperand(Src64, false)); - rcc::MachineInstr &WrongFloatingAtomic = createInstruction( - **Function, rcc::GenericOpcode::G_ATOMICRMW_FADD, std::move(WrongFloatingAtomicOperands)); - addMemOperand(**Function, WrongFloatingAtomic, - memoryDescription({rcc::MemoryAccessFlag::Load, rcc::MemoryAccessFlag::Store}, 8, 0, - rcc::AtomicOperation::ReadModifyWrite)); - Context.expect(!Set->validateInstruction(WrongFloatingAtomic, (*Function)->registerInfo()), - "floating atomic RMW must reject integer value registers"); - std::vector<rcc::MachineOperand> PrefetchOperands; PrefetchOperands.push_back(registerOperand(Address0, false)); PrefetchOperands.push_back(rcc::MachineOperand::immediate(0)); diff --git a/backend/unittests/CodeGen/GlobalISel/GISelMITest.h b/backend/unittests/CodeGen/GlobalISel/GISelMITest.h index 5b16535..20e8854 100644 --- a/backend/unittests/CodeGen/GlobalISel/GISelMITest.h +++ b/backend/unittests/CodeGen/GlobalISel/GISelMITest.h @@ -58,8 +58,8 @@ struct FunctionFixture final { [[nodiscard]] inline rcc::Register createRegister(TestContext &Context, rcc::MachineFunction &Function, std::uint32_t Bits) { - auto Type = rcc::LLT::makeInteger(Bits); - Context.expect(Type.has_value(), "integer LLT construction must succeed"); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(Bits); + Context.expect(Type.has_value(), "integer LowLevelType construction must succeed"); if (!Type) return {}; auto Reg = Function.registerInfo().createVirtualRegister(*Type); @@ -69,8 +69,8 @@ createRegister(TestContext &Context, rcc::MachineFunction &Function, std::uint32 [[nodiscard]] inline rcc::Register createFloatRegister(TestContext &Context, rcc::MachineFunction &Function) { - auto Type = rcc::LLT::makeFloat(rcc::FloatSemantics::IEEEDouble); - Context.expect(Type.has_value(), "floating LLT construction must succeed"); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); + Context.expect(Type.has_value(), "floating LowLevelType construction must succeed"); if (!Type) return {}; auto Reg = Function.registerInfo().createVirtualRegister(*Type); diff --git a/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp b/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp index 30c2b89..6d9fa3c 100644 --- a/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp +++ b/backend/unittests/CodeGen/GlobalISel/InstructionSelectTest.cpp @@ -252,9 +252,9 @@ void testExtendedRV64GCPipeline(TestContext &Context) { "extended pipeline fixture must be complete"); if (!Target || !Fixture.Function || Fixture.Entry == nullptr) return; - auto I1 = rcc::LLT::makeInteger(1); - auto I64 = rcc::LLT::makeInteger(64); - auto Pointer = rcc::LLT::makePointer(0, 64); + auto I1 = rcc::LowLevelType::makeCategoryNeutralScalar(1); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); + auto Pointer = rcc::LowLevelType::makePointer(0, 64); if (!I1 || !I64 || !Pointer) return; const rcc::Register Left = createRegister(Context, *Fixture.Function, 64); diff --git a/backend/unittests/CodeGen/InstructionDescriptorTest.cpp b/backend/unittests/CodeGen/InstructionDescriptorTest.cpp index 687e723..d263725 100644 --- a/backend/unittests/CodeGen/InstructionDescriptorTest.cpp +++ b/backend/unittests/CodeGen/InstructionDescriptorTest.cpp @@ -197,7 +197,7 @@ void testOperandValidation(TestContext &Context) { if (!Function) return; - auto I64 = rcc::LLT::makeInteger(64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Destination = (*Function)->registerInfo().createVirtualRegister(*I64); auto Source = (*Function)->registerInfo().createVirtualRegister(*I64); Context.expect(Destination && Source, "descriptor test virtual registers must be allocated"); @@ -261,7 +261,7 @@ void testInstructionValidation(TestContext &Context) { if (!InstructionSet || !Function) return; - auto I64 = rcc::LLT::makeInteger(64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = (*Function)->registerInfo().createVirtualRegister(*I64); Context.expect(Reg.has_value(), "instruction validation register must be allocated"); if (!Reg) diff --git a/backend/unittests/CodeGen/LiveTestSupport.h b/backend/unittests/CodeGen/LiveTestSupport.h index 071e572..f6a3566 100644 --- a/backend/unittests/CodeGen/LiveTestSupport.h +++ b/backend/unittests/CodeGen/LiveTestSupport.h @@ -152,7 +152,7 @@ createFunction(std::string Name, std::uint64_t ID, std::size_t BlockCount) { } [[nodiscard]] inline rcc::Expected<rcc::Register> createVReg(rcc::MachineFunction &Function) { - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!Type) return std::unexpected(Type.error()); auto Reg = Function.registerInfo().createVirtualRegister(*Type); diff --git a/backend/unittests/CodeGen/MachineAnalysesTest.cpp b/backend/unittests/CodeGen/MachineAnalysesTest.cpp index 997d031..53cd847 100644 --- a/backend/unittests/CodeGen/MachineAnalysesTest.cpp +++ b/backend/unittests/CodeGen/MachineAnalysesTest.cpp @@ -228,8 +228,8 @@ void testMemoryDependence(TestContext &Context, const rcc::TargetDescription &Ta } auto Block = appendBlock(**Function); auto OtherBlock = appendBlock(**Function); - auto I64 = rcc::LLT::makeInteger(64); - auto Pointer = rcc::LLT::makePointer(0, 64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); + auto Pointer = rcc::LowLevelType::makePointer(0, 64); auto Value = I64 ? (*Function)->registerInfo().createVirtualRegister(*I64) : rcc::Expected<rcc::Register>{std::unexpected(I64.error())}; auto Address = Pointer ? (*Function)->registerInfo().createVirtualRegister(*Pointer) @@ -397,7 +397,7 @@ void testCFGUpdaterPHIs(TestContext &Context, const rcc::TargetDescription &Targ return; } - auto I64 = rcc::LLT::makeInteger(64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Destination = I64 ? (*Function)->registerInfo().createVirtualRegister(*I64) : rcc::Expected<rcc::Register>{std::unexpected(I64.error())}; auto SourceValue = I64 ? (*Function)->registerInfo().createVirtualRegister(*I64) @@ -475,7 +475,7 @@ void testCFGUpdaterFailureAtomicity(TestContext &Context, const rcc::TargetDescr if (!SplitUpdater.addSuccessor(**Source, **Merge, rcc::BranchProbability::one())) return; - auto I64 = rcc::LLT::makeInteger(64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Destination = I64 ? (*SplitFunction)->registerInfo().createVirtualRegister(*I64) : rcc::Expected<rcc::Register>{std::unexpected(I64.error())}; auto Value = I64 ? (*SplitFunction)->registerInfo().createVirtualRegister(*I64) diff --git a/backend/unittests/CodeGen/MachineFunctionClonerTest.cpp b/backend/unittests/CodeGen/MachineFunctionClonerTest.cpp index e5acc04..82bcce1 100644 --- a/backend/unittests/CodeGen/MachineFunctionClonerTest.cpp +++ b/backend/unittests/CodeGen/MachineFunctionClonerTest.cpp @@ -305,7 +305,7 @@ struct SourceFixture final { auto HistoricalInstruction = Function.createInstruction(rcc::Opcode::fromValue(NopOpcode)); Context.expect(HistoricalBlock && HistoricalInstruction, "source arena history must be created"); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Tombstone = Function.registerInfo().createVirtualRegister(*Type); Context.expect(Tombstone && Function.registerInfo().eraseVirtualRegister(*Tombstone).has_value(), "source vreg history must contain a tombstone"); diff --git a/backend/unittests/CodeGen/MachineIRBuilderTest.cpp b/backend/unittests/CodeGen/MachineIRBuilderTest.cpp index 44a0e32..17e9874 100644 --- a/backend/unittests/CodeGen/MachineIRBuilderTest.cpp +++ b/backend/unittests/CodeGen/MachineIRBuilderTest.cpp @@ -186,7 +186,7 @@ void testTransactionalBuild(TestContext &Context) { if (Block == nullptr) return; - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Destination = Function->registerInfo().createVirtualRegister(*Type); auto Source = Function->registerInfo().createVirtualRegister(*Type); Context.expect(Destination && Source, "builder virtual registers must be allocated"); @@ -331,7 +331,7 @@ void testImplicitAndMemoryValidation(TestContext &Context) { if (Block == nullptr || OtherBlock == nullptr) return; - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Destination = Function->registerInfo().createVirtualRegister(*Type); auto Source = Function->registerInfo().createVirtualRegister(*Type); Context.expect(Destination && Source, "implicit test virtual registers must be allocated"); @@ -497,7 +497,7 @@ void testStaleCursorsAndOwnedOperands(TestContext &Context) { if (Block == nullptr) return; - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Destination = Function->registerInfo().createVirtualRegister(*Type); auto Source = Function->registerInfo().createVirtualRegister(*Type); if (!Destination || !Source) diff --git a/backend/unittests/CodeGen/MachineIRCoreTest.cpp b/backend/unittests/CodeGen/MachineIRCoreTest.cpp index 6365e59..875eeb8 100644 --- a/backend/unittests/CodeGen/MachineIRCoreTest.cpp +++ b/backend/unittests/CodeGen/MachineIRCoreTest.cpp @@ -116,7 +116,8 @@ void testOperandKinds(TestContext &Context) { Context.expect(!rcc::APFloat::create(rcc::FloatSemantics::IEEEHalf, TooManyHalfWords), "floating immediate word-count mismatch must be rejected"); - auto Virtual = Function->registerInfo().createVirtualRegister(*rcc::LLT::makeInteger(32)); + auto Virtual = Function->registerInfo().createVirtualRegister( + *rcc::LowLevelType::makeCategoryNeutralScalar(32)); Context.expect(Virtual.has_value(), "operand test virtual register must be created"); if (!Virtual) return; @@ -205,7 +206,7 @@ void testRegisterInfoAndOperandMovement(TestContext &Context) { if (Block == nullptr) return; - auto I32 = rcc::LLT::makeInteger(32); + auto I32 = rcc::LowLevelType::makeCategoryNeutralScalar(32); Context.expect(I32.has_value(), "i32 construction for MRI test must succeed"); if (!I32) return; @@ -317,7 +318,7 @@ void testRegisterInfoAndOperandMovement(TestContext &Context) { Context.expect(V0Info && V0Info->get().Type == I32 && V0Info->get().Bank == rcc::RegisterBankID::fromValue(3) && V0Info->get().RegClass == rcc::RegisterClassID::fromValue(4), - "MRI virtual register properties must evolve without losing LLT"); + "MRI virtual register properties must evolve without losing LowLevelType"); Context.expect(MRI.addLiveIn(*PhysReg, *V0).has_value(), "MRI must record function physical live-ins"); diff --git a/backend/unittests/CodeGen/MachineOptimizationTest.cpp b/backend/unittests/CodeGen/MachineOptimizationTest.cpp index bb2c0e1..cffd4e1 100644 --- a/backend/unittests/CodeGen/MachineOptimizationTest.cpp +++ b/backend/unittests/CodeGen/MachineOptimizationTest.cpp @@ -169,10 +169,10 @@ void setPostRAProperties(rcc::MachineFunction &Function) { } [[nodiscard]] rcc::Register makeGPR(TestContext &Context, rcc::MachineFunction &Function) { - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = Type ? Function.registerInfo().createVirtualRegister(*Type) - : rcc::Expected<rcc::Register>(std::unexpected( - rcc::Error(rcc::ErrorCode::InternalError, "test LLT creation failed"))); + : rcc::Expected<rcc::Register>(std::unexpected(rcc::Error( + rcc::ErrorCode::InternalError, "test LowLevelType creation failed"))); Context.expect(Reg.has_value(), "optimization virtual register creation must succeed"); if (!Reg) return {}; diff --git a/backend/unittests/CodeGen/MachineSchedulingTest.cpp b/backend/unittests/CodeGen/MachineSchedulingTest.cpp index 5162fb8..a3d1de9 100644 --- a/backend/unittests/CodeGen/MachineSchedulingTest.cpp +++ b/backend/unittests/CodeGen/MachineSchedulingTest.cpp @@ -178,10 +178,10 @@ makeSchedulingModel(const rcc::TargetSchedulingHooks *Hooks = nullptr) { } [[nodiscard]] rcc::Register makeGPR(TestContext &Context, rcc::MachineFunction &Function) { - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = Type ? Function.registerInfo().createVirtualRegister(*Type) - : rcc::Expected<rcc::Register>(std::unexpected( - rcc::Error(rcc::ErrorCode::InternalError, "test LLT creation failed"))); + : rcc::Expected<rcc::Register>(std::unexpected(rcc::Error( + rcc::ErrorCode::InternalError, "test LowLevelType creation failed"))); Context.expect(Reg.has_value(), "scheduler virtual register creation must succeed"); if (!Reg) return {}; diff --git a/backend/unittests/CodeGen/MachineValueTypesTest.cpp b/backend/unittests/CodeGen/MachineValueTypesTest.cpp index 819d6cb..315d56e 100644 --- a/backend/unittests/CodeGen/MachineValueTypesTest.cpp +++ b/backend/unittests/CodeGen/MachineValueTypesTest.cpp @@ -184,9 +184,9 @@ void testMachineMemOperand(TestContext &Context) { "failure ordering stronger than success must be rejected"); auto BadAddressSpace = makeBasicLoadDescription(); - BadAddressSpace.AddressSpace = rcc::LLT::MaxAddressSpace + 1; + BadAddressSpace.AddressSpace = rcc::LowLevelType::MaxAddressSpace + 1; Context.expect(!rcc::MachineMemOperand::create(BadAddressSpace), - "MMO address space wider than LLT encoding must be rejected"); + "MMO address space wider than LowLevelType encoding must be rejected"); auto EmptySymbol = makeBasicLoadDescription(); EmptySymbol.Base = rcc::MemoryBase::externalSymbol(""); diff --git a/backend/unittests/CodeGen/MachineVerifierTargetTest.cpp b/backend/unittests/CodeGen/MachineVerifierTargetTest.cpp index 3eb926d..3cc2b56 100644 --- a/backend/unittests/CodeGen/MachineVerifierTargetTest.cpp +++ b/backend/unittests/CodeGen/MachineVerifierTargetTest.cpp @@ -186,7 +186,7 @@ void testValidTargetFacts(TestContext &Context, const rcc::TargetDescription &Ta if (!Fixture.Function) return; - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = Fixture.Function->registerInfo().createVirtualRegister(*Type); if (!Reg) return; @@ -233,7 +233,7 @@ void testSubRegisterProjection(TestContext &Context, const rcc::TargetDescriptio if (!Fixture.Function) return; - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = Fixture.Function->registerInfo().createVirtualRegister(*Type); if (!Reg) return; @@ -282,7 +282,7 @@ void testUnknownAndMalformedTargetFacts(TestContext &Context, } { auto Fixture = createFunction(Context, "unknown_bank", 5); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!Fixture.Function || !Type) return; auto Reg = Fixture.Function->registerInfo().createVirtualRegister(*Type); @@ -295,7 +295,7 @@ void testUnknownAndMalformedTargetFacts(TestContext &Context, } { auto Fixture = createFunction(Context, "wide_bank_value", 6); - auto Type = rcc::LLT::makeInteger(128); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(128); if (!Fixture.Function || !Type) return; auto Reg = Fixture.Function->registerInfo().createVirtualRegister(*Type); @@ -325,7 +325,7 @@ void testUnknownAndMalformedTargetFacts(TestContext &Context, } { auto Fixture = createFunction(Context, "bad_allocation_hint", 9); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = Fixture.Function->registerInfo().createVirtualRegister(*Type); Context.expect(Reg && classify(Fixture.Function->registerInfo(), *Reg, @@ -340,7 +340,7 @@ void testUnknownAndMalformedTargetFacts(TestContext &Context, } { auto Fixture = createFunction(Context, "reserved_allocation_hint", 14); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = Fixture.Function->registerInfo().createVirtualRegister(*Type); const auto G0 = phys(rcc::test::TestRegister::G0); Context.expect(Reg && @@ -355,7 +355,7 @@ void testUnknownAndMalformedTargetFacts(TestContext &Context, } { auto Fixture = createFunction(Context, "incompatible_function_livein", 15); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Reg = Fixture.Function->registerInfo().createVirtualRegister(*Type); Context.expect( Reg && @@ -416,7 +416,7 @@ void testRegMaskEarlyClobberAndTies(TestContext &Context, const rcc::TargetDescr } { auto Fixture = createFunction(Context, "incompatible_tie", 12); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto GPR = Fixture.Function->registerInfo().createVirtualRegister(*Type); auto FPR = Fixture.Function->registerInfo().createVirtualRegister(*Type); if (!GPR || !FPR) diff --git a/backend/unittests/CodeGen/MachineVerifierTest.cpp b/backend/unittests/CodeGen/MachineVerifierTest.cpp index c8c512f..5327148 100644 --- a/backend/unittests/CodeGen/MachineVerifierTest.cpp +++ b/backend/unittests/CodeGen/MachineVerifierTest.cpp @@ -196,7 +196,7 @@ buildNoOperand(TestContext &Context, rcc::MachineIRBuilder &Builder, std::uint32 if (Entry == nullptr || Exit == nullptr) return false; - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Value = Function.registerInfo().createVirtualRegister(*Type); Context.expect(Value.has_value(), "typed verifier virtual register must be allocated"); if (!Value) @@ -338,7 +338,7 @@ createPhiTestFunction(TestContext &Context, const rcc::TargetDescription &Target return nullptr; } - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto Destination = Type ? Function->registerInfo().createVirtualRegister(*Type) : rcc::Expected<rcc::Register>{std::unexpected(Type.error())}; auto LeftValue = Type ? Function->registerInfo().createVirtualRegister(*Type) @@ -411,7 +411,7 @@ void testPropertyFailures(TestContext &Context) { auto Target = createTarget(); if (!Target) return; - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); auto SSA = createFunction(Context, "ssa", 6); rcc::MachineBasicBlock *SSABlock = SSA ? createBlock(Context, *SSA) : nullptr; @@ -503,7 +503,7 @@ void testPropertyFailures(TestContext &Context) { void testSelectedStateAndPseudoDeadline(TestContext &Context) { auto Target = createTarget(); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!Target) return; diff --git a/backend/unittests/CodeGen/PHIEliminationTest.cpp b/backend/unittests/CodeGen/PHIEliminationTest.cpp index 9bc9a57..bbc834f 100644 --- a/backend/unittests/CodeGen/PHIEliminationTest.cpp +++ b/backend/unittests/CodeGen/PHIEliminationTest.cpp @@ -90,7 +90,7 @@ void testParallelPHIsAndPlacement(TestContext &Context, const rcc::TargetDescrip auto Fixture = createFunction(Context, "parallel_phis", 1, 3); if (!Fixture.Function || Fixture.Blocks.size() != 3) return; - auto I64 = rcc::LLT::makeInteger(64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!I64) return; auto &Function = *Fixture.Function; @@ -209,7 +209,7 @@ void testParallelPHIsAndPlacement(TestContext &Context, const rcc::TargetDescrip Context.expect(FreshInfo.has_value(), "fresh PHI vreg must remain registered"); if (!FreshInfo) return; - Context.expect(FreshInfo->get().Type == I64, "fresh PHI vreg must clone its LLT"); + Context.expect(FreshInfo->get().Type == I64, "fresh PHI vreg must clone its LowLevelType"); Context.expect(FreshInfo->get().Bank == rcc::test::TestRegisterBank::GPR, "fresh PHI vreg must clone its register bank"); Context.expect(FreshInfo->get().RegClass == rcc::test::TestRegisterClass::GPR64, @@ -241,7 +241,7 @@ void testCriticalEdgeAndPhysicalLiveIn(TestContext &Context, const rcc::TargetDe auto Fixture = createFunction(Context, "critical_edge", 2, 4); if (!Fixture.Function || Fixture.Blocks.size() != 4) return; - auto I64 = rcc::LLT::makeInteger(64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!I64) return; auto &Function = *Fixture.Function; @@ -343,7 +343,7 @@ void testUndefAndFailureAtomicity(TestContext &Context, const rcc::TargetDescrip auto Fixture = createFunction(Context, "undef_phi", ID, 2); if (!Fixture.Function || Fixture.Blocks.size() != 2) return Fixture; - auto I64 = rcc::LLT::makeInteger(64); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!I64) return Fixture; auto Source = createVReg(*Fixture.Function, *I64, rcc::test::TestRegisterBank::GPR, @@ -406,9 +406,9 @@ void testUndefAndFailureAtomicity(TestContext &Context, const rcc::TargetDescrip } void testMalformedPHIs(TestContext &Context, const rcc::TargetDescription &Target) { - auto BuildBadPhi = [&](std::uint64_t ID, rcc::LLT DestinationType, + auto BuildBadPhi = [&](std::uint64_t ID, rcc::LowLevelType DestinationType, rcc::RegisterBankID DestinationBank, rcc::RegisterClassID DestinationClass, - rcc::LLT SourceType, rcc::RegisterBankID SourceBank, + rcc::LowLevelType SourceType, rcc::RegisterBankID SourceBank, rcc::RegisterClassID SourceClass, rcc::SubRegIndex SourceSubReg = {}) { auto Fixture = createFunction(Context, "bad_phi", ID, 2); if (!Fixture.Function || Fixture.Blocks.size() != 2) @@ -438,8 +438,8 @@ void testMalformedPHIs(TestContext &Context, const rcc::TargetDescription &Targe return Fixture; }; - auto I64 = rcc::LLT::makeInteger(64); - auto I32 = rcc::LLT::makeInteger(32); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); + auto I32 = rcc::LowLevelType::makeCategoryNeutralScalar(32); if (!I64 || !I32) return; auto BadType = diff --git a/backend/unittests/CodeGen/RegisterAllocationTest.cpp b/backend/unittests/CodeGen/RegisterAllocationTest.cpp index 7dd0dd0..443d00a 100644 --- a/backend/unittests/CodeGen/RegisterAllocationTest.cpp +++ b/backend/unittests/CodeGen/RegisterAllocationTest.cpp @@ -352,7 +352,7 @@ struct FunctionFixture final { [[nodiscard]] rcc::Expected<rcc::Register> createVReg(rcc::MachineFunction &Function, rcc::RegisterClassID Class = rcc::test::TestRegisterClass::GPR64) { - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!Type) return std::unexpected(Type.error()); auto Reg = Function.registerInfo().createVirtualRegister(*Type); diff --git a/backend/unittests/CodeGen/RegisterAllocationTestSupport.h b/backend/unittests/CodeGen/RegisterAllocationTestSupport.h index d93b14e..7f0a641 100644 --- a/backend/unittests/CodeGen/RegisterAllocationTestSupport.h +++ b/backend/unittests/CodeGen/RegisterAllocationTestSupport.h @@ -201,7 +201,7 @@ struct FunctionFixture final { [[nodiscard]] inline Expected<Register> createVReg(MachineFunction &Function, RegisterClassID Class = TestRegisterClass::GPR64) { - auto Type = LLT::makeInteger(64); + auto Type = LowLevelType::makeCategoryNeutralScalar(64); if (!Type) return std::unexpected(Type.error()); auto Reg = Function.registerInfo().createVirtualRegister(*Type); diff --git a/backend/unittests/CodeGen/SSAExitTestSupport.h b/backend/unittests/CodeGen/SSAExitTestSupport.h index 5729293..cf77d36 100644 --- a/backend/unittests/CodeGen/SSAExitTestSupport.h +++ b/backend/unittests/CodeGen/SSAExitTestSupport.h @@ -360,7 +360,7 @@ struct FunctionFixture final { } [[nodiscard]] inline rcc::Expected<rcc::Register> -createVReg(rcc::MachineFunction &Function, rcc::LLT Type, rcc::RegisterBankID Bank, +createVReg(rcc::MachineFunction &Function, rcc::LowLevelType Type, rcc::RegisterBankID Bank, rcc::RegisterClassID Class, std::uint8_t TargetFlags = 0, std::optional<rcc::PhysicalRegister> Hint = std::nullopt) { auto Reg = Function.registerInfo().createVirtualRegister(Type); diff --git a/backend/unittests/CodeGen/TargetCallLoweringTest.cpp b/backend/unittests/CodeGen/TargetCallLoweringTest.cpp index c5170d0..22a2b0c 100644 --- a/backend/unittests/CodeGen/TargetCallLoweringTest.cpp +++ b/backend/unittests/CodeGen/TargetCallLoweringTest.cpp @@ -42,8 +42,8 @@ private: return *Value; } -[[nodiscard]] rcc::LLT integer(std::uint32_t Bits) { - const auto Type = rcc::LLT::makeInteger(Bits); +[[nodiscard]] rcc::LowLevelType integer(std::uint32_t Bits) { + const auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(Bits); if (!Type) std::terminate(); return *Type; @@ -207,7 +207,7 @@ void testPlanValidation(TestContext &Context) { auto BadByVal = emptyPlanDescription(rcc::CallLoweringPlanKind::Call); auto ByValAssignment = registerAssignment(); - ByValAssignment.ValueType = *rcc::LLT::makePointer(0, 64); + ByValAssignment.ValueType = *rcc::LowLevelType::makePointer(0, 64); ByValAssignment.LocationType = ByValAssignment.ValueType; ByValAssignment.CustomFlags.set(rcc::CCAssignmentFlag::ByVal); BadByVal.ArgumentAssignments.push_back(ByValAssignment); @@ -219,7 +219,7 @@ void testPlanValidation(TestContext &Context) { auto OverlappingByVal = emptyPlanDescription(rcc::CallLoweringPlanKind::Call); OverlappingByVal.CallFrame.SizeBytes = 32; auto FirstByVal = registerAssignment(); - FirstByVal.ValueType = *rcc::LLT::makePointer(0, 64); + FirstByVal.ValueType = *rcc::LowLevelType::makePointer(0, 64); FirstByVal.LocationType = FirstByVal.ValueType; FirstByVal.CustomFlags.set(rcc::CCAssignmentFlag::ByVal); auto SecondByVal = FirstByVal; diff --git a/backend/unittests/CodeGen/TargetRegisterInfoTest.cpp b/backend/unittests/CodeGen/TargetRegisterInfoTest.cpp index 2c44237..bb9a0fc 100644 --- a/backend/unittests/CodeGen/TargetRegisterInfoTest.cpp +++ b/backend/unittests/CodeGen/TargetRegisterInfoTest.cpp @@ -250,7 +250,7 @@ void testTargetDescriptionConstraints(TestContext &Context) { rcc::test::TestRegisterBank::GPR)); auto Function = rcc::MachineFunction::create("constraints", rcc::MachineFunctionStableID::fromValue(1)); - auto Type = rcc::LLT::makeInteger(64); + auto Type = rcc::LowLevelType::makeCategoryNeutralScalar(64); if (!SubclassTarget || !Function || !Type) return; @@ -301,7 +301,7 @@ void testTargetDescriptionConstraints(TestContext &Context) { (*Function)->registerInfo()), "physical register operands must reject nonzero subregister indices"); - auto WideType = rcc::LLT::makeInteger(128); + auto WideType = rcc::LowLevelType::makeCategoryNeutralScalar(128); if (!WideType) return; auto WideReg = (*Function)->registerInfo().createVirtualRegister(*WideType); diff --git a/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp b/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp index e3ad4eb..d23a2eb 100644 --- a/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp +++ b/backend/unittests/CodeGen/TwoAddressInstructionPassTest.cpp @@ -19,8 +19,8 @@ void testTwoAddressAndSubregisterPseudos(TestContext &Context, const rcc::Target auto Fixture = createFunction(Context, "two_address", 5, 1); if (!Fixture.Function || Fixture.Blocks.empty()) return; - auto I64 = rcc::LLT::makeInteger(64); - auto I32 = rcc::LLT::makeInteger(32); + auto I64 = rcc::LowLevelType::makeCategoryNeutralScalar(64); + auto I32 = rcc::LowLevelType::makeCategoryNeutralScalar(32); if (!I64 || !I32) return; auto &Function = *Fixture.Function; |