[MIR] Remove alternate layout and float APIs

12 files changed, 28 insertions, 78 deletions

diff --git a/backend/lib/CodeGen/LowLevelType.cpp b/backend/lib/CodeGen/LowLevelType.cpp
index a276e02..b124765 100644
--- a/backend/lib/CodeGen/LowLevelType.cpp
+++ b/backend/lib/CodeGen/LowLevelType.cpp
@@ -21,7 +21,6 @@ constexpr std::array FloatSemanticsTable{
     FloatSemanticsInfo{64, "IEEE double", "f64"},
     FloatSemanticsInfo{128, "IEEE quad", "f128"},
     FloatSemanticsInfo{128, "PPC double-double", "ppcf128"},
-    FloatSemanticsInfo{128, "legacy PPC double-double", "ppcf128-legacy"},
     FloatSemanticsInfo{8, "float8 E5M2", "f8e5m2"},
     FloatSemanticsInfo{8, "float8 E5M2 FNUZ", "f8e5m2fnuz"},
     FloatSemanticsInfo{8, "float8 E4M3", "f8e4m3"},
diff --git a/backend/lib/MIR/LLVMConstantSyntax.cpp b/backend/lib/MIR/LLVMConstantSyntax.cpp
index a2025dc..a687f80 100644
--- a/backend/lib/MIR/LLVMConstantSyntax.cpp
+++ b/backend/lib/MIR/LLVMConstantSyntax.cpp
@@ -307,8 +307,8 @@ private:
   return (BitWidth % 64U) == 0 || (Words.back() >> (BitWidth % 64U)) == 0;
 }
 
-[[nodiscard]] bool parseLegacyWideFloatHexWords(std::string_view Digits,
-                                                std::vector<std::uint64_t> &Words) {
+[[nodiscard]] bool parseWideFloatHexWords(std::string_view Digits,
+                                          std::vector<std::uint64_t> &Words) {
   if (Digits.empty() || Digits.size() > 32U || !std::ranges::all_of(Digits, isHexDigit))
     return false;
   Words.assign(2, 0);
@@ -466,8 +466,7 @@ makeSpecialFloatWords(FloatSemantics Semantics, const SpecialFloatLiteral &Liter
       setFloatBit(Words, 61);
     return Words;
   }
-  case FloatSemantics::PPCDoubleDouble:
-  case FloatSemantics::PPCDoubleDoubleLegacy: {
+  case FloatSemantics::PPCDoubleDouble: {
     std::vector<std::uint64_t> HighPart(1, 0);
     makeBinarySpecialFloat(HighPart, 64, 11, Literal);
     Words[0] = HighPart.front();
@@ -542,9 +541,8 @@ binaryFloatFormat(FloatSemantics Semantics) noexcept {
                              .StorageBitWidth = 80,
                              .HasExplicitIntegerBit = true};
   case FloatSemantics::PPCDoubleDouble:
-  case FloatSemantics::PPCDoubleDoubleLegacy:
-    // LLVM parses a decimal PPC double-double through its documented legacy
-    // 106-bit format and then materializes the canonical pair of doubles.
+    // Decimal PPC double-double literals use 106 bits of precision and are
+    // materialized as a canonical pair of doubles.
     return BinaryFloatFormat{.Precision = 106,
                              .MinExponent = -969,
                              .MaxExponent = 1023,
@@ -884,8 +882,7 @@ convertRationalToFloatWords(FloatSemantics Semantics, bool Negative, const BigUn
   auto Rounded = roundBinaryRational(*Format, Numerator, Denominator, BinaryScale);
   if (!Rounded)
     return std::unexpected(Rounded.error());
-  if (Semantics == FloatSemantics::PPCDoubleDouble ||
-      Semantics == FloatSemantics::PPCDoubleDoubleLegacy) {
+  if (Semantics == FloatSemantics::PPCDoubleDouble) {
     return packPPCDoubleDouble(*Rounded, Negative);
   }
   if (Format->HasExplicitIntegerBit)
@@ -1806,19 +1803,16 @@ Expected<GenericConstantData> ConstantParser::parseFloatingValue(GenericConstant
       ExpectedPrefix = 'L';
       break;
     case FloatSemantics::PPCDoubleDouble:
-    case FloatSemantics::PPCDoubleDoubleLegacy:
       ExpectedPrefix = 'M';
       break;
     default:
       break;
     }
     if (ExpectedPrefix != '\0') {
-      const bool IsLegacyWideFormat =
-          EffectiveType.Semantics == FloatSemantics::IEEEQuad ||
-          EffectiveType.Semantics == FloatSemantics::PPCDoubleDouble ||
-          EffectiveType.Semantics == FloatSemantics::PPCDoubleDoubleLegacy;
-      const bool Parsed = IsLegacyWideFormat ? parseLegacyWideFloatHexWords(Digits, Words)
-                                             : parseHexWords(Digits, BitWidth, Words);
+      const bool HasWideHexWords = EffectiveType.Semantics == FloatSemantics::IEEEQuad ||
+                                   EffectiveType.Semantics == FloatSemantics::PPCDoubleDouble;
+      const bool Parsed = HasWideHexWords ? parseWideFloatHexWords(Digits, Words)
+                                          : parseHexWords(Digits, BitWidth, Words);
       if (Prefix != ExpectedPrefix || !Parsed) {
         return fail<GenericConstantData>(
             "floating-point hexadecimal prefix does not match its type");
@@ -2378,7 +2372,6 @@ Expected<std::string> printType(const GenericConstantType &Type) {
     case FloatSemantics::IEEEQuad:
       return std::string("fp128");
     case FloatSemantics::PPCDoubleDouble:
-    case FloatSemantics::PPCDoubleDoubleLegacy:
       return std::string("ppc_fp128");
     case FloatSemantics::X87DoubleExtended:
       return std::string("x86_fp80");
@@ -2481,8 +2474,7 @@ struct PrintedBinaryFloat final {
   if (!Format)
     return std::nullopt;
 
-  if (Bits.semantics() == FloatSemantics::PPCDoubleDouble ||
-      Bits.semantics() == FloatSemantics::PPCDoubleDoubleLegacy) {
+  if (Bits.semantics() == FloatSemantics::PPCDoubleDouble) {
     if (Words.size() != 2 || Words[1] != 0)
       return std::nullopt;
     Format = binaryFloatFormat(FloatSemantics::IEEEDouble);
@@ -2942,7 +2934,6 @@ private:
                                                 std::uint64_t StoreSize) const noexcept;
 
   bool Explicit = false;
-  std::uint32_t LegacyPointerSizeInBits = 0;
   std::vector<LayoutAlignmentEntry> Alignments;
   std::vector<LayoutPointerEntry> Pointers;
   LayoutAlignment Aggregate{1, 8};
@@ -3010,7 +3001,6 @@ void DataLayoutInfo::setPointer(LayoutPointerEntry Entry) {
 
 Expected<DataLayoutInfo> DataLayoutInfo::parse(LLVMConstantSyntaxOptions Options) {
   DataLayoutInfo Result;
-  Result.LegacyPointerSizeInBits = Options.DefaultPointerSizeInBits;
   if (Options.DataLayout.empty())
     return Result;
   if (Options.DataLayout.size() > Options.MaximumTokenLength) {
@@ -3322,21 +3312,8 @@ LayoutAlignment DataLayoutInfo::vector(std::uint32_t BitWidth,
 
 Expected<LayoutPointerEntry> DataLayoutInfo::pointer(std::uint32_t AddressSpace) const {
   if (!Explicit) {
-    if (LegacyPointerSizeInBits == 0) {
-      return makeUnexpected(ErrorCode::InvalidArgument,
-                            "pointer size is required to lay out pointer constants");
-    }
-    const std::uint64_t Bytes = (static_cast<std::uint64_t>(LegacyPointerSizeInBits) + 7U) / 8U;
-    return LayoutPointerEntry{
-        .AddressSpace = AddressSpace,
-        .SizeInBits = LegacyPointerSizeInBits,
-        .IndexSizeInBits = LegacyPointerSizeInBits,
-        .Alignment = natural(Bytes),
-        .HasExternalState = false,
-        .HasUnstableRepresentation = false,
-        .NullIsAllOnes = false,
-        .AddressSpaceName = {},
-    };
+    return makeUnexpected(ErrorCode::InvalidArgument,
+                          "pointer size is required to lay out pointer constants");
   }
   auto Entry = std::ranges::find_if(Pointers, [AddressSpace](const LayoutPointerEntry &Candidate) {
     return Candidate.AddressSpace == AddressSpace;
diff --git a/backend/lib/MIR/MIParser.cpp b/backend/lib/MIR/MIParser.cpp
index f634119..3748187 100644
--- a/backend/lib/MIR/MIParser.cpp
+++ b/backend/lib/MIR/MIParser.cpp
@@ -621,16 +621,12 @@ bool MIParser::Impl::parseScalarLowLevelType(const MIToken &TypeToken, LLT &Resu
     Created = LLT::makeFloat(FloatSemantics::BFloat);
     break;
   case ScalarKind::Pointer:
-    if (Context.PointerSizeInBits) {
-      auto PointerSize = Context.PointerSizeInBits(static_cast<std::uint32_t>(Value));
-      if (!PointerSize)
-        return importError(TypeToken, PointerSize.error());
-      Created = LLT::makePointer(Value, *PointerSize);
-      break;
-    }
-    if (Context.DefaultPointerSizeInBits == 0)
+    if (!Context.PointerSizeInBits)
       return fail(TypeToken, "pointer low-level type requires an explicit pointer size");
-    Created = LLT::makePointer(Value, Context.DefaultPointerSizeInBits);
+    if (auto PointerSize = Context.PointerSizeInBits(static_cast<std::uint32_t>(Value)))
+      Created = LLT::makePointer(Value, *PointerSize);
+    else
+      return importError(TypeToken, PointerSize.error());
     break;
   }
   if (!Created)
@@ -1722,9 +1718,7 @@ bool MIParser::Impl::parseMemoryBase(MemoryBase &Result, std::int64_t &Offset) {
     advance();
     break;
   case MITokenKind::QuotedIRValue: {
-    LLVMConstantSyntaxOptions ConstantOptions;
-    ConstantOptions.DefaultPointerSizeInBits = Context.DefaultPointerSizeInBits;
-    auto Constant = parseLLVMConstant(BaseToken.stringValue(), ConstantOptions);
+    auto Constant = parseLLVMConstant(BaseToken.stringValue());
     if (!Constant)
       return importError(BaseToken, Constant.error());
     auto Base = MemoryBase::irConstant(std::move(*Constant));
diff --git a/backend/lib/MIR/MIPrinter.cpp b/backend/lib/MIR/MIPrinter.cpp
index 25a7a0c..6f88414 100644
--- a/backend/lib/MIR/MIPrinter.cpp
+++ b/backend/lib/MIR/MIPrinter.cpp
@@ -211,7 +211,6 @@ namespace {
   case FloatSemantics::IEEEQuad:
     return "f128";
   case FloatSemantics::PPCDoubleDouble:
-  case FloatSemantics::PPCDoubleDoubleLegacy:
   case FloatSemantics::Float8E5M2:
   case FloatSemantics::Float8E5M2FNUZ:
   case FloatSemantics::Float8E4M3:
diff --git a/backend/lib/MIR/MIRDataParser.cpp b/backend/lib/MIR/MIRDataParser.cpp
index 7e04ace..2ac1f2d 100644
--- a/backend/lib/MIR/MIRDataParser.cpp
+++ b/backend/lib/MIR/MIRDataParser.cpp
@@ -129,7 +129,6 @@ bool MIRDocumentParser::parseConstants(const yaml::Node &Root, MachineFunction &
     if (scalar(*ValueNode, ValueText, "LLVM constant"))
       return true;
     const LLVMConstantSyntaxOptions ConstantOptions{
-        .DefaultPointerSizeInBits = Context.DefaultPointerSizeInBits,
         .DataLayout = DataLayout,
         .NamedTypes = NamedTypes,
     };
diff --git a/backend/lib/MIR/MIRDocumentParser.cpp b/backend/lib/MIR/MIRDocumentParser.cpp
index 9c4728a..08627d5 100644
--- a/backend/lib/MIR/MIRDocumentParser.cpp
+++ b/backend/lib/MIR/MIRDocumentParser.cpp
@@ -72,18 +72,19 @@ const yaml::Node *MIRDocumentParser::mappingValue(const yaml::Node &Mapping,
 }
 
 std::string_view MIRDocumentParser::effectiveDataLayout() const noexcept {
+  if (!Options.DataLayout.empty())
+    return Options.DataLayout;
   if (ActiveDocument != nullptr) {
     if (const EmbeddedIRReferenceIndex *Embedded = ActiveDocument->embeddedIR()) {
       if (const auto DataLayout = Embedded->dataLayout())
         return *DataLayout;
     }
   }
-  return Options.DataLayout;
+  return {};
 }
 
 LLVMConstantSyntaxOptions MIRDocumentParser::pointerLayoutOptions() const noexcept {
   return {
-      .DefaultPointerSizeInBits = Options.DefaultPointerSizeInBits,
       .DataLayout = effectiveDataLayout(),
       .NamedTypes = {},
   };
@@ -243,14 +244,6 @@ MIRDocumentParseResult MIRDocumentParser::run() {
     FirstFunction = FirstContent + 1;
   }
 
-  if (const EmbeddedIRReferenceIndex *Embedded = Staging.embeddedIR()) {
-    if (const auto DataLayout = Embedded->dataLayout();
-        DataLayout && !Options.DataLayout.empty() && *DataLayout != Options.DataLayout) {
-      static_cast<void>(fail(Stream->documents()[FirstContent].Range,
-                             "explicit DataLayout does not match embedded LLVM IR data layout"));
-      return std::move(Result);
-    }
-  }
   if (!effectiveDataLayout().empty()) {
     auto PointerSize = llvmPointerSizeInBits(0, pointerLayoutOptions());
     if (!PointerSize) {
@@ -374,7 +367,6 @@ bool MIRDocumentParser::parseFunction(const yaml::Node &Root, MIRDocument &Docum
       .HasFakeUses = std::nullopt,
   };
   MIParserContext Context;
-  Context.DefaultPointerSizeInBits = Options.DefaultPointerSizeInBits;
   if (IRFunction != nullptr) {
     Context.HasIRBlock = [IRFunction](std::string_view BlockName) {
       return IRFunction->block(BlockName) != nullptr;
diff --git a/backend/lib/MIR/MIRDocumentPrinter.cpp b/backend/lib/MIR/MIRDocumentPrinter.cpp
index 5cc0173..06998bb 100644
--- a/backend/lib/MIR/MIRDocumentPrinter.cpp
+++ b/backend/lib/MIR/MIRDocumentPrinter.cpp
@@ -387,9 +387,6 @@ MIRDocumentPrinter::verifyOmittedEmbeddedIRLayout(const MachineFunction &Functio
   const EmbeddedIRReferenceIndex *Embedded = Document.embeddedIR();
   if (Embedded == nullptr)
     return {};
-  const auto EmbeddedDataLayout = Embedded->dataLayout();
-  if (!EmbeddedDataLayout)
-    return {};
 
   bool HasLayoutDependentContent = false;
   for (const VirtualRegisterInfo &RegisterInfo : Function.registerInfo().virtualRegisters()) {
@@ -412,14 +409,14 @@ MIRDocumentPrinter::verifyOmittedEmbeddedIRLayout(const MachineFunction &Functio
   if (!HasLayoutDependentContent)
     return {};
 
-  if (Options.DataLayout != *EmbeddedDataLayout) {
+  if (Options.DataLayout.empty()) {
     return makeUnexpected(
         ErrorCode::InvalidArgument,
-        "omitting embedded LLVM IR requires printer DataLayout to exactly match its data layout");
+        "omitting embedded LLVM IR with layout-dependent MIR requires an explicit printer "
+        "DataLayout");
   }
 
   const LLVMConstantSyntaxOptions LayoutOptions{
-      .DefaultPointerSizeInBits = Options.DefaultPointerSizeInBits,
       .DataLayout = Options.DataLayout,
       .NamedTypes = {},
   };
diff --git a/backend/lib/MIR/MIRFunctionParser.cpp b/backend/lib/MIR/MIRFunctionParser.cpp
index 7e8821b..8cf3abb 100644
--- a/backend/lib/MIR/MIRFunctionParser.cpp
+++ b/backend/lib/MIR/MIRFunctionParser.cpp
@@ -411,12 +411,12 @@ TextRange MIRDocumentParser::scalarDiagnosticRange(const yaml::Node &Scalar,
   if (!FoundContent)
     return Scalar.range();
 
-  const TextPosition Fallback = Scalar.range().Begin;
+  const TextPosition DefaultPosition = Scalar.range().Begin;
   const auto MapPosition = [this, FirstBodyLine, LastBodyLine, Indent,
-                            Fallback](TextPosition Position) {
+                            DefaultPosition](TextPosition Position) {
     const std::size_t SourceLine = FirstBodyLine + Position.Line - 1U;
     if (Position.Line == 0 || SourceLine > LastBodyLine || SourceLine > Result.Source.lineCount()) {
-      return Fallback;
+      return DefaultPosition;
     }
     const std::string_view SourceLineText = Result.Source.line(SourceLine);
     const std::size_t BodyColumn = Position.Column == 0 ? 0 : Position.Column - 1U;
@@ -440,8 +440,6 @@ bool MIRDocumentParser::parseBody(const yaml::Node &Root, MachineFunction &Funct
     BodyRange = Body->range();
   }
 
-  if (Options.DefaultPointerSizeInBits != 0)
-    Context.DefaultPointerSizeInBits = Options.DefaultPointerSizeInBits;
   if (!effectiveDataLayout().empty()) {
     const LLVMConstantSyntaxOptions PointerOptions = pointerLayoutOptions();
     Context.PointerSizeInBits = [PointerOptions](std::uint32_t AddressSpace) {
diff --git a/backend/lib/Tooling/ArtifactStore.cpp b/backend/lib/Tooling/ArtifactStore.cpp
index 76fc0df..db330b1 100644
--- a/backend/lib/Tooling/ArtifactStore.cpp
+++ b/backend/lib/Tooling/ArtifactStore.cpp
@@ -264,7 +264,6 @@ Expected<CanonicalMIR> parseAndCanonicalizeMIR(std::string SourceName, std::stri
   }
   mir::MIRDocumentParserOptions ParseOptions;
   ParseOptions.DataLayout = Invocation.DataLayout;
-  ParseOptions.DefaultPointerSizeInBits = 64;
   ParseOptions.VerifyMachineFunctions = true;
   mir::MIRDocumentParseResult Parsed =
       mir::parseMIRDocument(Target, std::move(SourceName), std::move(SourceText), ParseOptions);
@@ -279,7 +278,6 @@ Expected<CanonicalMIR> parseAndCanonicalizeMIR(std::string SourceName, std::stri
   PrintOptions.Mode = mir::MIPrintMode::Complete;
   PrintOptions.EmitEmbeddedIR = true;
   PrintOptions.DataLayout = Invocation.DataLayout;
-  PrintOptions.DefaultPointerSizeInBits = 64;
   auto Printed = mir::printMIRDocument(*Parsed.document(), Target, std::move(PrintOptions));
   if (!Printed)
     return std::unexpected(Printed.error());
diff --git a/backend/lib/Tooling/BackendDriver.cpp b/backend/lib/Tooling/BackendDriver.cpp
index 85a2cf9..2a2a500 100644
--- a/backend/lib/Tooling/BackendDriver.cpp
+++ b/backend/lib/Tooling/BackendDriver.cpp
@@ -54,7 +54,6 @@ namespace {
   Options.Mode = mir::MIPrintMode::Complete;
   Options.EmitEmbeddedIR = true;
   Options.DataLayout = Invocation.DataLayout;
-  Options.DefaultPointerSizeInBits = 64;
   auto Printed = mir::printMIRDocument(Document, Target, std::move(Options));
   if (!Printed)
     return std::unexpected(Printed.error());
diff --git a/backend/lib/Tooling/MIRFuzzer.cpp b/backend/lib/Tooling/MIRFuzzer.cpp
index e8a1a7a..ed5b2fa 100644
--- a/backend/lib/Tooling/MIRFuzzer.cpp
+++ b/backend/lib/Tooling/MIRFuzzer.cpp
@@ -215,7 +215,6 @@ private:
   PrintOptions.Mode = mir::MIPrintMode::Complete;
   PrintOptions.EmitEmbeddedIR = true;
   PrintOptions.DataLayout = Invocation.DataLayout;
-  PrintOptions.DefaultPointerSizeInBits = 64;
   auto Printed = mir::printMIRDocument(Parsed->Document, Target, std::move(PrintOptions));
   if (!Printed)
     return std::unexpected(Printed.error());
diff --git a/backend/lib/Tooling/PipelineDriver.cpp b/backend/lib/Tooling/PipelineDriver.cpp
index b7844cd..4dab499 100644
--- a/backend/lib/Tooling/PipelineDriver.cpp
+++ b/backend/lib/Tooling/PipelineDriver.cpp
@@ -153,7 +153,6 @@ captureSnapshot(FunctionRunResult &Result, const mir::MIRDocument &Document,
   PrintOptions.Mode = mir::MIPrintMode::Complete;
   PrintOptions.EmitEmbeddedIR = true;
   PrintOptions.DataLayout = Invocation.DataLayout;
-  PrintOptions.DefaultPointerSizeInBits = 64;
   auto Printed = mir::printMIRDocument(Document, Target, std::move(PrintOptions));
   if (!Printed)
     return std::unexpected(Printed.error());