gisel-ab 0.9.0__py3-none-any.whl

gisel_ab/cpp/aarch64_generated_ctor.cpp

@@ -0,0 +1,23 @@
+// The AArch64 A/B ours build replaces only the legalizer constructor. The
+// remaining target library, including custom legalization, stays official.
+
+#include "AArch64Subtarget.h"
+#include "GISel/AArch64LegalizerInfo.h"
+#include "llvm/CodeGen/GlobalISel/MIPatternMatch.h"
+#include "llvm/CodeGen/TargetLowering.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+#include "llvm/Target/TargetMachine.h"
+
+using namespace llvm;
+using namespace LegalizeActions;
+using namespace LegalizeMutations;
+using namespace LegalityPredicates;
+using namespace MIPatternMatch;
+
+AArch64LegalizerInfo::AArch64LegalizerInfo(const AArch64Subtarget &ST)
+    : ST(&ST) {
+  using namespace TargetOpcode;
+  const AArch64Subtarget &Subtarget = ST;
+  const TargetMachine &TM = ST.getTargetLowering()->getTargetMachine();
+#include "AArch64LegalizerInfo.inc"
+}

gisel_ab/cpp/aarch64_query_runner.cpp

@@ -0,0 +1,380 @@
+//===- aarch64_query_runner.cpp - answer fixed AArch64 queries ------------===//
+
+#include "AArch64Subtarget.h"
+#include "AArch64TargetMachine.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/AtomicOrdering.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+#include "llvm/TargetParser/Triple.h"
+#include <fstream>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "query-recovery.h"
+using namespace llvm;
+using namespace TargetOpcode;
+using namespace LegalizeActions;
+using namespace LegalizeMutations;
+using namespace LegalityPredicates;
+
+#include "GISel/AArch64LegalizerInfo.h"
+using Legalizer = AArch64LegalizerInfo;
+
+namespace {
+
+static std::optional<AtomicOrdering> parseOrdering(StringRef Text) {
+  return StringSwitch<std::optional<AtomicOrdering>>(Text)
+      .Case("NotAtomic", AtomicOrdering::NotAtomic)
+      .Case("Unordered", AtomicOrdering::Unordered)
+      .Case("Monotonic", AtomicOrdering::Monotonic)
+      .Case("Acquire", AtomicOrdering::Acquire)
+      .Case("Release", AtomicOrdering::Release)
+      .Case("AcquireRelease", AtomicOrdering::AcquireRelease)
+      .Case("SequentiallyConsistent", AtomicOrdering::SequentiallyConsistent)
+      .Default(std::nullopt);
+}
+
+struct Config {
+  const char *ID;
+  const char *Features;
+  CodeModel::Model CM;
+};
+
+static const Config Configs[] = {
+    {"baseline", "", CodeModel::Large},
+    {"small-cm", "", CodeModel::Small},
+    {"fullfp16", "+fullfp16", CodeModel::Large},
+    {"sve", "+sve", CodeModel::Large},
+    {"bf16", "+bf16", CodeModel::Large},
+    {"cssc", "+cssc", CodeModel::Large},
+    {"rcpc3", "+rcpc3", CodeModel::Large},
+    {"lse", "+lse", CodeModel::Large},
+    {"outline-atomics", "+outline-atomics", CodeModel::Large},
+};
+
+struct Sigma {
+  std::unique_ptr<TargetMachine> TM;
+  const AArch64Subtarget *STI = nullptr;
+  std::unique_ptr<Legalizer> L;
+};
+
+static std::string jsonString(StringRef S) {
+  std::string Out = "\"";
+  for (char C : S) {
+    if (C == '\"' || C == '\\') {
+      Out += '\\';
+      Out += C;
+    } else if (C == '\n') {
+      Out += "\\n";
+    } else {
+      Out += C;
+    }
+  }
+  Out += '"';
+  return Out;
+}
+
+static std::string lltStr(LLT Ty) {
+  if (!Ty.isValid())
+    return "LLT_invalid";
+  if (Ty.isPointer())
+    return "p" + std::to_string(Ty.getAddressSpace()) + ":" +
+           std::to_string(Ty.getSizeInBits());
+  if (Ty.isVector()) {
+    std::string Elem = lltStr(Ty.getElementType());
+    return (Ty.isScalable() ? "nxv" : "v") +
+           std::to_string(Ty.getElementCount().getKnownMinValue()) + Elem;
+  }
+  if (Ty.isBFloat16())
+    return "bf16";
+  if (Ty.isFloat())
+    return "f" + std::to_string(Ty.getScalarSizeInBits());
+  if (Ty.isInteger())
+    return "i" + std::to_string(Ty.getScalarSizeInBits());
+  return "s" + std::to_string(Ty.getScalarSizeInBits());
+}
+
+static const char *actionName(LegalizeAction A) {
+  switch (A) {
+  case Legal: return "Legal";
+  case NarrowScalar: return "NarrowScalar";
+  case WidenScalar: return "WidenScalar";
+  case FewerElements: return "FewerElements";
+  case MoreElements: return "MoreElements";
+  case Bitcast: return "Bitcast";
+  case Lower: return "Lower";
+  case Libcall: return "Libcall";
+  case Unsupported: return "Unsupported";
+  case Custom: return "Custom";
+  default: return "?";
+  }
+}
+
+static unsigned opcodeFor(StringRef Name) {
+#undef HANDLE_TARGET_OPCODE
+#undef HANDLE_TARGET_OPCODE_MARKER
+  return StringSwitch<unsigned>(Name)
+#define HANDLE_TARGET_OPCODE(OPC) .Case(#OPC, TargetOpcode::OPC)
+#define HANDLE_TARGET_OPCODE_MARKER(IDENT, OP)
+#include "llvm/Support/TargetOpcodes.def"
+#undef HANDLE_TARGET_OPCODE
+#undef HANDLE_TARGET_OPCODE_MARKER
+      .Default(0);
+}
+
+// `p0:*` is the configuration-dependent pointer width; the subtarget decides
+// it (LP64 -> 64, ILP32 -> 32), exactly as it does for RISC-V's XLen.
+static std::optional<LLT> parseLLT(StringRef S, unsigned PointerBits = 0) {
+  if (S == "bf16")
+    return LLT::bfloat16();
+  if (S.starts_with("nxv") || S.starts_with("v")) {
+    bool Scalable = S.starts_with("nxv");
+    S = S.drop_front(Scalable ? 3 : 1);
+    size_t I = 0;
+    while (I < S.size() && S[I] >= '0' && S[I] <= '9')
+      ++I;
+    unsigned N = 0;
+    if (I == 0 || S.substr(0, I).getAsInteger(10, N))
+      return std::nullopt;
+    auto Elem = parseLLT(S.drop_front(I), PointerBits);
+    if (!Elem)
+      return std::nullopt;
+    return LLT::vector(Scalable ? ElementCount::getScalable(N)
+                                : ElementCount::getFixed(N), *Elem);
+  }
+  if (S.starts_with("p")) {
+    size_t Colon = S.find(':');
+    unsigned AS = 0;
+    if (Colon == StringRef::npos ||
+        S.substr(1, Colon - 1).getAsInteger(10, AS))
+      return std::nullopt;
+    if (S.drop_front(Colon + 1) == "*") {
+      if (!PointerBits)
+        return std::nullopt;
+      return LLT::pointer(AS, PointerBits);
+    }
+    unsigned Bits = 0;
+    if (S.drop_front(Colon + 1).getAsInteger(10, Bits))
+      return std::nullopt;
+    return LLT::pointer(AS, Bits);
+  }
+  char Kind = S.empty() ? '?' : S[0];
+  unsigned Bits = 0;
+  if (S.drop_front().getAsInteger(10, Bits))
+    return std::nullopt;
+  switch (Kind) {
+  case 's': return LLT::scalar(Bits);
+  case 'i': return LLT::integer(Bits);
+  case 'f': return LLT::floatIEEE(Bits);
+  default: return std::nullopt;
+  }
+}
+
+static bool makeSigma(const Config &C, Sigma &S) {
+  Triple TT("aarch64");
+  std::string Err;
+  const Target *T = TargetRegistry::lookupTarget("", TT, Err);
+  if (!T) {
+    errs() << "no target: " << Err << "\n";
+    return false;
+  }
+  TargetOptions Opts;
+  S.TM.reset(T->createTargetMachine(TT, "generic", C.Features, Opts,
+                                    std::nullopt, C.CM));
+  if (!S.TM)
+    return false;
+  static LLVMContext Ctx;
+  static Module M("t", Ctx);
+  if (!M.getFunction("f"))
+    Function::Create(FunctionType::get(Type::getVoidTy(Ctx), false),
+                     Function::ExternalLinkage, "f", &M);
+  S.STI = static_cast<const AArch64Subtarget *>(
+      S.TM->getSubtargetImpl(*M.getFunction("f")));
+  if (!S.STI)
+    return false;
+  S.L = std::make_unique<Legalizer>(*S.STI);
+  return true;
+}
+
+static int answerLine(StringRef Line, const StringMap<Sigma *> &Sigmas,
+                      raw_ostream &Out) {
+  Expected<json::Value> Parsed = json::parse(Line);
+  if (!Parsed)
+    return 2;
+  json::Object *Obj = Parsed->getAsObject();
+  if (!Obj)
+    return 2;
+  auto ConfigName = Obj->getString("config");
+  auto Name = Obj->getString("name");
+  json::Array *TypeArr = Obj->getArray("types");
+  if (!ConfigName || !Name || !TypeArr)
+    return 2;
+  auto It = Sigmas.find(*ConfigName);
+  if (It == Sigmas.end())
+    return 2;
+  Sigma &S = *It->second;
+  unsigned PtrBits = S.TM->createDataLayout().getPointerSizeInBits(0);
+  SmallVector<LLT, 4> Types;
+  // Keep the caller's spelling.  A target without LLT::setUseExtended (RISC-V)
+  // maps `f16` and `s16` to the same scalar(16), so re-spelling the parsed type
+  // would collapse two distinct query keys in the answer file.  The key must
+  // survive the round trip; only the answer is up to the legalizer.
+  SmallVector<std::string, 4> TypeText;
+  for (const json::Value &V : *TypeArr) {
+    auto Text = V.getAsString();
+    if (!Text)
+      return 2;
+    auto Ty = parseLLT(*Text, PtrBits);
+    if (!Ty)
+      return 2;
+    Types.push_back(*Ty);
+    TypeText.push_back(Text->str());
+  }
+
+  // Immediate operands are part of the query: a rule may read Q.Immediates
+  // (e.g. LegalizePredicates::immIs).  Dropping them makes the rule index the
+  // empty array and abort, which would look like an answer difference.
+  SmallVector<int64_t, 2> Imms;
+  if (json::Array *ImmArr = Obj->getArray("imms"))
+    for (const json::Value &V : *ImmArr) {
+      auto I = V.getAsInteger();
+      if (!I)
+        return 2;
+      Imms.push_back(*I);
+    }
+  std::string ImmsText = "[";
+  for (size_t I = 0; I != Imms.size(); ++I) {
+    if (I)
+      ImmsText += ",";
+    ImmsText += std::to_string(Imms[I]);
+  }
+  ImmsText += "]";
+
+  SmallVector<LegalityQuery::MemDesc, 1> MMOs;
+  std::string MemText = "null";
+  if (json::Array *Mem = Obj->getArray("mem")) {
+    if (Mem->size() != 2 && Mem->size() != 4)
+      return 2;
+    auto TyText = (*Mem)[0].getAsString();
+    auto Align = (*Mem)[1].getAsInteger();
+    if (!TyText || !Align)
+      return 2;
+    auto Ty = parseLLT(*TyText, PtrBits);
+    if (!Ty)
+      return 2;
+    AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
+    AtomicOrdering Failure = AtomicOrdering::NotAtomic;
+    std::optional<StringRef> OrderingText;
+    std::optional<StringRef> FailureText;
+    if (Mem->size() == 4) {
+      OrderingText = (*Mem)[2].getAsString();
+      FailureText = (*Mem)[3].getAsString();
+      auto ParsedOrdering = OrderingText ? parseOrdering(*OrderingText)
+                                         : std::nullopt;
+      auto ParsedFailure = FailureText ? parseOrdering(*FailureText)
+                                       : std::nullopt;
+      if (!ParsedOrdering || !ParsedFailure)
+        return 2;
+      Ordering = *ParsedOrdering;
+      Failure = *ParsedFailure;
+    }
+    MMOs.push_back(LegalityQuery::MemDesc(*Ty, *Align, Ordering, Failure));
+    MemText = "[" + jsonString(*TyText) + "," +
+              std::to_string(*Align);
+    if (Mem->size() == 4)
+      MemText += "," + jsonString(*OrderingText) + "," +
+                 jsonString(*FailureText);
+    MemText += "]";
+  }
+
+  unsigned Opcode = opcodeFor(*Name);
+  if (!Opcode)
+    return 2;
+  LegalityQuery Q(Opcode, Types, MMOs, Imms);
+  LegalizeActionStep Step = S.L->getAction(Q);
+  Out << "{\"config\":" << jsonString(*ConfigName)
+      << ",\"name\":" << jsonString(*Name) << ",\"types\":[";
+  for (size_t I = 0; I != Types.size(); ++I) {
+    if (I)
+      Out << ',';
+    Out << jsonString(TypeText[I]);
+  }
+  Out << "],\"mem\":" << MemText << ",\"imms\":" << ImmsText
+      << ",\"action\":" << jsonString(actionName(Step.Action))
+      << ",\"type_idx\":" << (unsigned)Step.TypeIdx
+      << ",\"new_type\":" << jsonString(lltStr(Step.NewType)) << "}\n";
+  return 0;
+}
+
+} // namespace
+
+int main(int Argc, char **Argv) {
+  ab::disableCoreDumps();
+  StringRef Queries;
+  for (int I = 1; I < Argc; ++I) {
+    StringRef A(Argv[I]);
+    if (A == "--queries" && I + 1 < Argc)
+      Queries = Argv[++I];
+    else if (A == "-h" || A == "--help")
+      return 0;
+    else
+      return 2;
+  }
+  if (Queries.empty())
+    return 2;
+
+  LLVMInitializeAArch64TargetInfo();
+  LLVMInitializeAArch64Target();
+  LLVMInitializeAArch64TargetMC();
+
+  StringMap<Sigma *> Sigmas;
+  std::vector<std::unique_ptr<Sigma>> Storage;
+  for (const Config &C : Configs) {
+    auto S = std::make_unique<Sigma>();
+    if (!makeSigma(C, *S))
+      return 2;
+    Sigmas[C.ID] = S.get();
+    Storage.push_back(std::move(S));
+  }
+
+  std::ifstream In(Queries.str());
+  if (!In)
+    return 2;
+  std::string Line;
+  unsigned N = 0;
+  while (std::getline(In, Line)) {
+    if (Line.empty())
+      continue;
+    int Rc = 0;
+    if (!ab::runQuery([&] { Rc = answerLine(Line, Sigmas, outs()); })) {
+      // The query aborted inside LLVM.  The legalizer is built and const, so
+      // the only loss is memory allocated by the abandoned call.
+      ab::writeUnanswerable(Line, outs());
+      outs().flush();
+      ++N;
+      continue;
+    }
+    if (Rc)
+      return Rc;
+    // Flush per answer: a real crash would still lose a buffered tail, and
+    // run-queries.py restarts after it.
+    outs().flush();
+    ++N;
+  }
+  errs() << "answered " << N << " queries\n";
+  return 0;
+}

gisel_ab/cpp/arm_generated_ctor.cpp

@@ -0,0 +1,18 @@
+// The ARM A/B ours build replaces only the legalizer constructor.  The rest of
+// the target library stays official.
+
+#include "ARMLegalizerInfo.h"
+#include "ARMSubtarget.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+
+using namespace llvm;
+using namespace LegalizeActions;
+using namespace LegalizeMutations;
+using namespace LegalityPredicates;
+
+// The class keeps a reference to the subtarget; the official constructor
+// initialises it in its member-init list, and so must this one.
+ARMLegalizerInfo::ARMLegalizerInfo(const ARMSubtarget &ST) : ST(ST) {
+  using namespace TargetOpcode;
+#include "ARMLegalizerInfo.inc"
+}

gisel_ab/cpp/arm_query_runner.cpp

@@ -0,0 +1,58 @@
+//===- arm_query_runner.cpp - answer JSONL queries with ARM's rules ------===//
+//
+// Built twice: `official` links the target library's constructor, `ours` also
+// links a replacement constructor object that includes the generated `.inc`.
+// The two binaries differ only in which definition of the constructor the
+// linker picks, so an answer difference is a rule difference.
+//
+// The configuration axes are the ones the constructor itself reads:
+// `ST.useSoftFloat()`, `ST.hasVFP2Base()`, `ST.hasVFP4Base()`, `ST.hasNEON()`,
+// `ST.hasV5TOps()`, the hardware-divide gate, and the AEABI gate.  Thumb1 is
+// deliberately absent: the constructor returns before registering a rule, so
+// the generated table -- which has no way to spell "this subtarget has no
+// rules" -- would disagree on every query by construction.  That gap is
+// recorded in docs/REPORT-cxx-corpus.md rather than papered over.
+//===----------------------------------------------------------------------===//
+
+#include "ARMLegalizerInfo.h"
+#include "ARMSubtarget.h"
+#include "llvm/Support/TargetSelect.h"
+
+using namespace llvm;
+
+using TargetSubtarget = ARMSubtarget;
+using TargetLegalizer = ARMLegalizerInfo;
+
+#include "query_runner_common.h"
+
+namespace {
+
+static void initializeTarget() {
+  LLVMInitializeARMTargetInfo();
+  LLVMInitializeARMTarget();
+  LLVMInitializeARMTargetMC();
+}
+
+static ArrayRef<Config> configs() {
+  // `armv7a-neon` is a Cortex-A7 (VFP4 + NEON + hardware divide); `a5` has no
+  // VFP4; `nodiv` drops the divide instructions; `arm1176` is NEON-less;
+  // `armv4t` has neither V5T nor VFP2; `thumbv7m` is M-profile (no FPU);
+  // `armv7-soft` forces the soft-float ABI on a Cortex-A7.
+  static const Config Table[] = {
+      {"armv7a-neon", "armv7-unknown-linux-gnueabihf", "cortex-a7", "", std::nullopt},
+      {"armv7a-nodiv", "armv7-unknown-linux-gnueabihf", "cortex-a7", "-hwdiv,-hwdiv-arm", std::nullopt},
+      {"armv7a-a5", "armv7-unknown-linux-gnueabihf", "cortex-a5", "", std::nullopt},
+      {"armv6-arm1176", "armv6-unknown-linux-gnueabihf", "arm1176jzf-s", "", std::nullopt},
+      {"armv4t", "armv4t-unknown-linux-gnueabi", "arm7tdmi", "+soft-float", std::nullopt},
+      {"thumbv7m", "thumbv7m-unknown-none-eabi", "cortex-m3", "", std::nullopt},
+      {"armv7-soft", "armv7-unknown-linux-gnueabi", "generic", "+soft-float", std::nullopt},
+  };
+  return Table;
+}
+
+static std::unique_ptr<TargetLegalizer>
+makeLegalizer(const TargetSubtarget &ST, TargetMachine &) {
+  return std::make_unique<TargetLegalizer>(ST);
+}
+
+} // namespace

gisel_ab/cpp/m68k_generated_ctor.cpp

@@ -0,0 +1,21 @@
+// The M68k A/B ours build replaces only the legalizer constructor.  The rest
+// of the target library, including custom legalization, stays official.
+
+#include "GISel/M68kLegalizerInfo.h"
+#include "M68kSubtarget.h"
+#include "llvm/CodeGen/GlobalISel/MIPatternMatch.h"
+#include "llvm/CodeGen/TargetLowering.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+#include "llvm/Target/TargetMachine.h"
+
+using namespace llvm;
+using namespace LegalizeActions;
+using namespace LegalizeMutations;
+using namespace LegalityPredicates;
+using namespace MIPatternMatch;
+
+M68kLegalizerInfo::M68kLegalizerInfo(const M68kSubtarget &ST) {
+  using namespace TargetOpcode;
+  const M68kSubtarget &Subtarget = ST;
+#include "M68kLegalizerInfo.inc"
+}

gisel_ab/cpp/m68k_query_runner.cpp

@@ -0,0 +1,43 @@
+//===- m68k_query_runner.cpp - answer JSONL queries with M68k's legalizer -===//
+//
+// Built twice: `official` links the target library's constructor, `ours` also
+// links a replacement constructor object that includes the generated `.inc`.
+// The two binaries differ only in which definition of the constructor the
+// linker picks, so an answer difference is a rule difference.
+//===----------------------------------------------------------------------===//
+
+#include "GISel/M68kLegalizerInfo.h"
+#include "M68kSubtarget.h"
+#include "M68kTargetMachine.h"
+#include "llvm/Support/TargetSelect.h"
+
+using namespace llvm;
+
+using TargetSubtarget = M68kSubtarget;
+using TargetLegalizer = M68kLegalizerInfo;
+
+#include "query_runner_common.h"
+
+namespace {
+
+static void initializeTarget() {
+  LLVMInitializeM68kTargetInfo();
+  LLVMInitializeM68kTarget();
+  LLVMInitializeM68kTargetMC();
+}
+
+static ArrayRef<Config> configs() {
+  // M68k's constructor reads no subtarget feature, so the configuration axis
+  // is one point.  `M68040` is the CPU the GlobalISel MIR tests run on.
+  static const Config Table[] = {
+      {"default", "m68k", "M68040", "", std::nullopt},
+  };
+  return Table;
+}
+
+static std::unique_ptr<TargetLegalizer>
+makeLegalizer(const TargetSubtarget &ST, TargetMachine &) {
+  return std::make_unique<TargetLegalizer>(ST);
+}
+
+} // namespace

gisel_ab/cpp/mips_generated_ctor.cpp

@@ -0,0 +1,16 @@
+// The Mips A/B ours build replaces only the legalizer constructor.  The rest
+// of the target library stays official.
+
+#include "MipsLegalizerInfo.h"
+#include "MipsSubtarget.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+
+using namespace llvm;
+using namespace LegalizeActions;
+using namespace LegalizeMutations;
+using namespace LegalityPredicates;
+
+MipsLegalizerInfo::MipsLegalizerInfo(const MipsSubtarget &ST) {
+  using namespace TargetOpcode;
+#include "MipsLegalizerInfo.inc"
+}

gisel_ab/cpp/mips_query_runner.cpp

@@ -0,0 +1,52 @@
+//===- mips_query_runner.cpp - answer JSONL queries with Mips' rules -----===//
+//
+// Built twice: `official` links the target library's constructor, `ours` also
+// links a replacement constructor object that includes the generated `.inc`.
+// The two binaries differ only in which definition of the constructor the
+// linker picks, so an answer difference is a rule difference.
+//
+// The constructor reads three subtarget predicates: `ST.hasMSA()` (the vector
+// rules), `ST.hasMips32r2()` (G_BSWAP legal vs. lower), and
+// `ST.systemSupportsUnalignedAccess()` (which memory sizes need an aligned
+// access).  The five configurations below are those three axes on the
+// 32-bit flavours the legalizer assumes (`p0` is `pointer(0, 32)`).
+//===----------------------------------------------------------------------===//
+
+#include "MipsLegalizerInfo.h"
+#include "MipsSubtarget.h"
+#include "llvm/Support/TargetSelect.h"
+
+using namespace llvm;
+
+using TargetSubtarget = MipsSubtarget;
+using TargetLegalizer = MipsLegalizerInfo;
+
+#include "query_runner_common.h"
+
+namespace {
+
+static void initializeTarget() {
+  LLVMInitializeMipsTargetInfo();
+  LLVMInitializeMipsTarget();
+  LLVMInitializeMipsTargetMC();
+}
+
+static ArrayRef<Config> configs() {
+  // MSA needs the 64-bit FP register file (`+fp64`) or the subtarget reports
+  // it unavailable.
+  static const Config Table[] = {
+      {"mips32", "mips-unknown-linux-gnu", "mips32", "", std::nullopt},
+      {"mips32r2", "mips-unknown-linux-gnu", "mips32r2", "", std::nullopt},
+      {"mips32r6", "mips-unknown-linux-gnu", "mips32r6", "", std::nullopt},
+      {"mips32r5-msa", "mips-unknown-linux-gnu", "mips32r5", "+msa,+fp64", std::nullopt},
+      {"mips32r6-msa", "mips-unknown-linux-gnu", "mips32r6", "+msa,+fp64", std::nullopt},
+  };
+  return Table;
+}
+
+static std::unique_ptr<TargetLegalizer>
+makeLegalizer(const TargetSubtarget &ST, TargetMachine &) {
+  return std::make_unique<TargetLegalizer>(ST);
+}
+
+} // namespace

gisel_ab/cpp/ppc_generated_ctor.cpp

@@ -0,0 +1,16 @@
+// The PowerPC A/B ours build replaces only the legalizer constructor.  The
+// rest of the target library stays official.
+
+#include "GISel/PPCLegalizerInfo.h"
+#include "PPCSubtarget.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+
+using namespace llvm;
+using namespace LegalizeActions;
+using namespace LegalizeMutations;
+using namespace LegalityPredicates;
+
+PPCLegalizerInfo::PPCLegalizerInfo(const PPCSubtarget &ST) {
+  using namespace TargetOpcode;
+#include "PowerPCLegalizerInfo.inc"
+}

gisel_ab/cpp/ppc_query_runner.cpp

@@ -0,0 +1,46 @@
+//===- ppc_query_runner.cpp - answer JSONL queries with PowerPC's rules ---===//
+//
+// Built twice: `official` links the target library's constructor, `ours` also
+// links a replacement constructor object that includes the generated `.inc`.
+// The two binaries differ only in which definition of the constructor the
+// linker picks, so an answer difference is a rule difference.
+//
+// The constructor reads no subtarget feature: every rule is about types, so
+// the configuration axis is one point, like M68k.
+//===----------------------------------------------------------------------===//
+
+#include "GISel/PPCLegalizerInfo.h"
+#include "PPCSubtarget.h"
+#include "PPCTargetMachine.h"
+#include "llvm/Support/TargetSelect.h"
+
+using namespace llvm;
+
+using TargetSubtarget = PPCSubtarget;
+using TargetLegalizer = PPCLegalizerInfo;
+
+#include "query_runner_common.h"
+
+namespace {
+
+static void initializeTarget() {
+  LLVMInitializePowerPCTargetInfo();
+  LLVMInitializePowerPCTarget();
+  LLVMInitializePowerPCTargetMC();
+}
+
+static ArrayRef<Config> configs() {
+  // The legalizer assumes the 64-bit register file (P0 is `pointer(0, 64)`),
+  // so the triple is ppc64le; the CPU does not change a rule.
+  static const Config Table[] = {
+      {"default", "powerpc64le-unknown-linux-gnu", "", "", std::nullopt},
+  };
+  return Table;
+}
+
+static std::unique_ptr<TargetLegalizer>
+makeLegalizer(const TargetSubtarget &ST, TargetMachine &) {
+  return std::make_unique<TargetLegalizer>(ST);
+}
+
+} // namespace