[llvm] [CodeGen] Skip unsafe splits in RenameIndependentSubregs (PR #190925)

[Karl Hylen via llvm-commits]

================
@@ -0,0 +1,255 @@
+//===- RenameIndependentSubregsTest.cpp ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CodeGen/RenameIndependentSubregs.h"
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/CodeGen/LiveIntervals.h"
+#include "llvm/CodeGen/MIRParser/MIRParser.h"
+#include "llvm/CodeGen/MachineFunctionAnalysis.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/Module.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetMachine.h"
+#include "gtest/gtest.h"
+
+#include <memory>
+
+using namespace llvm;
+
+namespace {
+
+class RenameIndependentSubregsTest : public testing::Test {
+protected:
+  LLVMContext Context;
+  std::unique_ptr<TargetMachine> TM;
+  std::unique_ptr<Module> M;
+  std::unique_ptr<MachineModuleInfo> MMI;
+  std::unique_ptr<MIRParser> MIR;
+
+  LoopAnalysisManager LAM;
+  MachineFunctionAnalysisManager MFAM;
+  FunctionAnalysisManager FAM;
+  CGSCCAnalysisManager CGAM;
+  ModuleAnalysisManager MAM;
+
+  static void SetUpTestCase() {
+    InitializeAllTargets();
+    InitializeAllTargetMCs();
+  }
+
+  void SetUp() override {
+    auto &RegisteredOptions = cl::getRegisteredOptions();
+    auto It = RegisteredOptions.find("enable-subreg-liveness");
+    if (It == RegisteredOptions.end())
+      GTEST_SKIP();
+
+    // Force-enable subreg liveness tracking, as AArch64 doesn't enable it by
+    // default
+    if (It->second->addOccurrence(0, It->second->ArgStr, "", false))
+      GTEST_SKIP();
+
+    Triple TT("aarch64-none-linux-gnu");
+    std::string Error;
+    const Target *T = TargetRegistry::lookupTarget("", TT, Error);
+    if (!T)
+      GTEST_SKIP();
+
+    TargetOptions TMOptions;
+    TM.reset(
+        T->createTargetMachine(TT, "generic", "", TMOptions, std::nullopt));
+    if (!TM)
+      GTEST_SKIP();
+
+    MMI = std::make_unique<MachineModuleInfo>(TM.get());
+
+    PassBuilder PB(TM.get());
+    PB.registerModuleAnalyses(MAM);
+    PB.registerCGSCCAnalyses(CGAM);
+    PB.registerFunctionAnalyses(FAM);
+    PB.registerLoopAnalyses(LAM);
+    PB.registerMachineFunctionAnalyses(MFAM);
+    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM, &MFAM);
+    MAM.registerPass([&] { return MachineModuleAnalysis(*MMI); });
+  }
+
+  bool parseMIR(StringRef MIRCode) {
+    std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRCode);
+    MIR = createMIRParser(std::move(MBuffer), Context);
+    if (!MIR)
+      return false;
+
+    M = MIR->parseIRModule();
+    if (!M)
+      return false;
+    M->setDataLayout(TM->createDataLayout());
+
+    if (MIR->parseMachineFunctions(*M, MAM)) {
+      M.reset();
+      return false;
+    }
+    return true;
+  }
+
+  MachineFunction &getMF(StringRef Name) {
+    return FAM.getResult<MachineFunctionAnalysis>(*M->getFunction(Name))
+        .getMF();
+  }
+
+  static StringRef getTestMIR() {
+    return R"MIR(
+--- |
----------------
Hylen wrote:

Thanks, that makes sense. We'll try to provide such a solution instead.

https://github.com/llvm/llvm-project/pull/190925