tmp

default.nix

@@ -33,5 +33,6 @@ stdenv.mkDerivation {
     filecheck
     yq
   ];
+  checkInputs = with pkgs; [gtest];
   doCheck = true;
 }

include/bleach/lifter/block-ir-builder.hpp

@@ -9,6 +9,7 @@
 
 namespace llvm {
 class MachineBasicBlock;
+class BasicBlock;
 }
 
 namespace bleach::lifter {
@@ -59,5 +60,13 @@ class mbb2bb final : private DenseMap<const MachineBasicBlock *, BasicBlock *> {
 void fill_ir_for_bb(MachineBasicBlock &mbb, Function &func, reg2vals &rmap,
                     const instr_impl &instrs, const LLVMTargetMachine &tm,
                     const target &tgt, const mbb2bb &m2b);
+struct basic_block {
+  MachineBasicBlock *mbb;
+  BasicBlock *bb;
+};
+
+void copy_instructions(const MachineBasicBlock &src, MachineBasicBlock &dst);
+
+basic_block clone_basic_block(MachineBasicBlock &src, BasicBlock &dummy);
 
 } // namespace bleach::lifter

lib/lifter/block-ir-builder.cpp

@@ -18,11 +18,6 @@ namespace bleach::lifter {
 namespace ranges = std::ranges;
 using namespace llvm;
 
-struct basic_block {
-  MachineBasicBlock *mbb;
-  BasicBlock *bb;
-};
-
 void copy_instructions(const MachineBasicBlock &src, MachineBasicBlock &dst) {
   auto *mf = dst.getParent();
   assert(mf);

test/CMakeLists.txt

@@ -1 +1,2 @@
 add_subdirectory(tools)
+add_subdirectory(lib)

test/lib/CMakeLists.txt

@@ -0,0 +1,3 @@
+find_package(GTest REQUIRED)
+include(GoogleTest)
+add_subdirectory(lifter)

test/lib/lifter/CMakeLists.txt

@@ -0,0 +1,10 @@
+bleach_add_llvm_based_tool(unit-test-lifter SOURCES lifter.cpp
+  LLVM_COMPONENTS
+  support
+  codegen
+  AllTargetsInfos
+  AllTargetsAsmParsers
+  AllTargetsCodeGens
+)
+target_link_libraries(unit-test-lifter PRIVATE GTest::gtest_main bleach-lifter)
+gtest_discover_tests(unit-test-lifter)

test/lib/lifter/inputs/foo.mir

@@ -0,0 +1,26 @@
+--- |
+  ; ModuleID = 'foo.ll'
+  target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
+  target triple = "riscv64-unknown-linux-gnu"
+
+  ; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) uwtable
+  define dso_local signext void @foo(i64 noundef signext %0, i64 noundef signext %1) local_unnamed_addr #0 {
+   ret void 
+  }
+...
+---
+name:            foo
+alignment:       2
+tracksRegLiveness: true
+liveins:
+  - { reg: '$x10' }
+  - { reg: '$x11' }
+body:             |
+  bb.0 (%ir-block.2):
+    liveins: $x10, $x11
+
+    renamable $x10 = ADDW renamable $x11, killed renamable $x10
+    renamable $x11 = ADDW $x10, $x10
+    renamable $x11 = SUBW killed renamable $x11, renamable $x10 
+
+...

test/lib/lifter/lifter.cpp

@@ -0,0 +1,116 @@
+#include "bleach/lifter/block-ir-builder.hpp"
+
+#include <gtest/gtest.h>
+
+#include <llvm/CodeGen/MachineFunction.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <llvm/IR/Module.h>
+#include <llvm/Target/TargetMachine.h>
+#include <llvm/Support/Error.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/Support/SmallVectorMemoryBuffer.h>
+#include <llvm/CodeGen/MIRParser/MIRParser.h>
+#include <llvm/CodeGen/CommandFlags.h>
+#include <llvm/CodeGen/MachineModuleInfo.h>
+#include <llvm/Support/SourceMgr.h>
+#include <llvm/TargetParser/Host.h>
+
+namespace {
+using namespace llvm;
+
+constexpr std::string_view foo_mir = R"(
+--- |
+  ; ModuleID = 'foo.ll'
+  target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
+  target triple = "riscv64-unknown-linux-gnu"
+  
+  ; Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) uwtable
+  define dso_local signext void @foo(i64 noundef signext %0, i64 noundef signext %1) local_unnamed_addr #0 {
+   ret void 
+  }
+...
+---
+name:            foo
+alignment:       2
+tracksRegLiveness: true
+liveins:
+  - { reg: '$x10' }
+  - { reg: '$x11' }
+body:             |
+  bb.0 (%ir-block.2):
+    liveins: $x10, $x11
+
+    renamable $x10 = ADDW renamable $x11, killed renamable $x10
+    renamable $x11 = ADDW $x10, $x10
+    renamable $x11 = SUBW killed renamable $x11, renamable $x10 
+
+...
+)";
+
+codegen::RegisterCodeGenFlags cfg;
+
+auto parse_mir(LLVMContext &ctx) {
+  SMDiagnostic err;
+  auto mir_parser =
+      createMIRParser(std::make_unique<SmallVectorMemoryBuffer>(SmallVector<char>(foo_mir.begin(), foo_mir.end())), ctx);
+  if (!mir_parser)
+    throw std::runtime_error(err.getMessage().str());
+
+  Triple triple;
+  std::unique_ptr<LLVMTargetMachine> target_machine;
+  auto set_data_layout = [&](StringRef data_layout_target_triple,
+                             StringRef) -> std::optional<std::string> {
+    auto target_triple_str = data_layout_target_triple.str();
+    if (!target_triple_str.empty())
+      target_triple_str = Triple::normalize(target_triple_str);
+    triple = Triple(target_triple_str);
+    if (triple.getTriple().empty()) {
+      triple.setTriple(sys::getDefaultTargetTriple());
+    }
+    auto tm = codegen::createTargetMachineForTriple(triple.str());
+    if (auto err_tm= tm.takeError())
+      throw std::runtime_error(toString(std::move(err_tm)));
+    target_machine = std::unique_ptr<LLVMTargetMachine>(
+        static_cast<LLVMTargetMachine *>(tm->release()));
+    return target_machine->createDataLayout().getStringRepresentation();
+  };
+  auto m = mir_parser->parseIRModule(set_data_layout);
+  auto machine_module_info =
+      std::make_unique<MachineModuleInfo>(target_machine.get());
+  assert(m);
+  if (mir_parser->parseMachineFunctions(*m, *machine_module_info))
+    throw std::runtime_error("Failed to parse machine functions");
+
+  return std::make_pair(std::move(m), std::move(machine_module_info));
+}
+
+TEST(lifter_basic, clone_basic_block) {
+  InitializeAllTargetInfos();
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  LLVMContext ctx;
+  auto [m, machine_module_info] = parse_mir(ctx);
+  for (auto &f : *m) {
+    auto &mf = machine_module_info->getOrCreateMachineFunction(f);
+    mf.dump();
+    for (auto &mbb: mf) {
+      auto *dummy_bb = BasicBlock::Create(ctx, "dummy", &f);
+      auto [copy_mbb, copy_bb] = bleach::lifter::clone_basic_block(mbb, *dummy_bb);
+      for (auto &&[inst, copy_inst] : zip(mbb, *copy_mbb)) {
+        std::string str1;
+        raw_string_ostream os1 (str1);
+        std::string str2;
+        raw_string_ostream os2 (str2);
+        inst.print(os1);
+        inst.print(os2);
+        std::cout << "original: " << str1 << "\n";
+        std::cout << "copied: " << str2 << "\n";
+        EXPECT_EQ(str1, str2);
+      }
+    }
+  }
+
+}
+}

test/lib/lifter/mf-helper.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <llvm/CodeGen/MachineFunction.h>
+#include <llvm/IR/Function.h>
+#include <llvm/Target/TargetMachine.h>
+
+