Add support for LLVM 15-21

mrexodia · mrexodia · commit f3d8e7d428c4 · 2025-10-27T01:35:20.000+01:00
Add back support for LLVM 15
diff --git a/include/remill/Arch/Arch.h b/include/remill/Arch/Arch.h
@@ -25,7 +25,11 @@
 #pragma clang diagnostic ignored "-Wswitch-enum"
 
 #include <llvm/ADT/SmallVector.h>
+#if LLVM_VERSION_MAJOR < 16
+#include <llvm/ADT/Triple.h>
+#else
 #include <llvm/TargetParser/Triple.h>
+#endif // LLVM_VERSION_MAJOR
 #include <llvm/IR/DataLayout.h>
 #include <llvm/IR/IRBuilder.h>
 #include <remill/BC/InstructionLifter.h>
diff --git a/lib/Arch/AArch64/Arch.cpp b/lib/Arch/AArch64/Arch.cpp
@@ -21,7 +21,6 @@
 #include <llvm/IR/Function.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/Module.h>
-#include <llvm/TargetParser/Triple.h>
 
 #include <algorithm>
 #include <cctype>
diff --git a/lib/Arch/Arch.cpp b/lib/Arch/Arch.cpp
@@ -20,7 +20,6 @@
 #include <glog/logging.h>
 #include <llvm/ADT/APInt.h>
 #include <llvm/ADT/SmallVector.h>
-#include <llvm/IR/AttributeMask.h>
 #include <llvm/IR/BasicBlock.h>
 #include <llvm/IR/Function.h>
 #include <llvm/IR/IRBuilder.h>
@@ -695,18 +694,10 @@ void Arch::PrepareModuleDataLayout(llvm::Module *mod) const {
   // compile this bitcode back into machine code, we may want to use those
   // features, and clang will complain if we try to do so if these metadata
   // remain present.
-  auto &context = mod->getContext();
-
-  llvm::AttributeSet target_attribs;
-
-  target_attribs = target_attribs.addAttribute(context, "target-features");
-  target_attribs = target_attribs.addAttribute(context, "target-cpu");
 
   for (llvm::Function &func : *mod) {
-    auto attribs = func.getAttributes();
-    attribs = attribs.removeFnAttributes(context,
-                                         llvm::AttributeMask(target_attribs));
-    func.setAttributes(attribs);
+    func.removeFnAttr("target-features");
+    func.removeFnAttr("target-cpu");
   }
 }
 
diff --git a/lib/Arch/Name.cpp b/lib/Arch/Name.cpp
@@ -15,8 +15,7 @@
  */
 
 #include "remill/Arch/Name.h"
-
-#include <llvm/TargetParser/Triple.h>
+#include "remill/Arch/Arch.h"
 
 namespace remill {
 
diff --git a/lib/Arch/Sleigh/AArch32Arch.cpp b/lib/Arch/Sleigh/AArch32Arch.cpp
@@ -22,7 +22,6 @@
 #include <llvm/IR/Function.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/Module.h>
-#include <llvm/TargetParser/Triple.h>
 #include <remill/Arch/AArch32/ArchContext.h>
 
 #include <iomanip>
diff --git a/lib/Arch/Sleigh/ARMBase.cpp b/lib/Arch/Sleigh/ARMBase.cpp
@@ -4,7 +4,6 @@
 #include <llvm/IR/Function.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/Module.h>
-#include <llvm/TargetParser/Triple.h>
 #include <remill/Arch/AArch32/AArch32Base.h>
 #include <remill/Arch/Name.h>
 #include <remill/BC/ABI.h>
diff --git a/lib/Arch/Sleigh/X86Arch.cpp b/lib/Arch/Sleigh/X86Arch.cpp
@@ -20,7 +20,6 @@
 #include <llvm/IR/Function.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/Module.h>
-#include <llvm/TargetParser/Triple.h>
 #include <remill/Arch/Context.h>
 #include <remill/Arch/Name.h>
 #include <remill/Arch/X86/X86Base.h>
diff --git a/lib/Arch/X86/Arch.cpp b/lib/Arch/X86/Arch.cpp
@@ -20,7 +20,6 @@
 #include <llvm/IR/Function.h>
 #include <llvm/IR/IRBuilder.h>
 #include <llvm/IR/Module.h>
-#include <llvm/TargetParser/Triple.h>
 #include <remill/Arch/ArchBase.h>  // For `Arch` and `ArchImpl`.
 #include <remill/Arch/X86/X86Base.h>
 
diff --git a/lib/BC/InstructionLifter.cpp b/lib/BC/InstructionLifter.cpp
@@ -358,11 +358,11 @@ llvm::Value *InstructionLifter::LoadWordRegValOrZero(llvm::BasicBlock *block,
 
   CHECK(val_type) << "Register " << reg_name << " expected to be an integer.";
 
-  auto val_size = val_type->getBitWidth();
-  auto word_size = word_type->getBitWidth();
+  auto val_size = val_type->getIntegerBitWidth();
+  auto word_size = word_type->getIntegerBitWidth();
   CHECK_LE(val_size, word_size)
       << "Register " << reg_name << " expected to be no larger than the "
-      << "machine word size (" << word_type->getBitWidth() << " bits).";
+      << "machine word size (" << word_type->getIntegerBitWidth() << " bits).";
 
   if (val_size < word_size) {
     val = new llvm::ZExtInst(val, word_type, llvm::Twine::createNull(), block);
@@ -595,15 +595,19 @@ llvm::Value *InstructionLifter::LiftRegisterOperand(Instruction &inst,
     if (val_size < arg_size) {
       if (arg_type->isIntegerTy()) {
         CHECK(val_type->isIntegerTy())
-            << "Expected " << arch_reg.name << " to be an integral type "
+            << "Expected " << arch_reg.name << " to be an integral type ("
+            << "val_type: " << LLVMThingToString(val_type) << ", "
+            << "arg_type: " << LLVMThingToString(arg_type) << ") "
             << "for instruction at " << std::hex << inst.pc;
 
         val =
             new llvm::ZExtInst(val, arg_type, llvm::Twine::createNull(), block);
 
       } else if (arg_type->isFloatingPointTy()) {
         CHECK(val_type->isFloatingPointTy())
-            << "Expected " << arch_reg.name << " to be a floating point type "
+            << "Expected " << arch_reg.name << " to be a floating point type ("
+            << "val_type: " << LLVMThingToString(val_type) << ", "
+            << "arg_type: " << LLVMThingToString(arg_type) << ") "
             << "for instruction at " << std::hex << inst.pc;
 
         val = new llvm::FPExtInst(val, arg_type, llvm::Twine::createNull(),
@@ -613,15 +617,19 @@ llvm::Value *InstructionLifter::LiftRegisterOperand(Instruction &inst,
     } else if (val_size > arg_size) {
       if (arg_type->isIntegerTy()) {
         CHECK(val_type->isIntegerTy())
-            << "Expected " << arch_reg.name << " to be an integral type "
+            << "Expected " << arch_reg.name << " to be an integral type ("
+            << "val_type: " << LLVMThingToString(val_type) << ", "
+            << "arg_type: " << LLVMThingToString(arg_type) << ") "
             << "for instruction at " << std::hex << inst.pc;
 
         val = new llvm::TruncInst(val, arg_type, llvm::Twine::createNull(),
                                   block);
 
       } else if (arg_type->isFloatingPointTy()) {
         CHECK(val_type->isFloatingPointTy())
-            << "Expected " << arch_reg.name << " to be a floating point type "
+            << "Expected " << arch_reg.name << " to be a floating point type ("
+            << "val_type: " << LLVMThingToString(val_type) << ", "
+            << "arg_type: " << LLVMThingToString(arg_type) << ") "
             << "for instruction at " << std::hex << inst.pc;
 
         val = new llvm::FPTruncInst(val, arg_type, llvm::Twine::createNull(),
@@ -876,8 +884,8 @@ InstructionLifter::LiftOperand(Instruction &inst, llvm::BasicBlock *block,
 
     case Operand::kTypeShiftRegister:
       CHECK(Operand::kActionRead == arch_op.action)
-          << "Can't write to a shift register operand "
-          << "for instruction at " << std::hex << inst.pc;
+          << "Can't write to a shift register operand " << "for instruction at "
+          << std::hex << inst.pc;
 
       return LiftShiftRegisterOperand(inst, block, state_ptr, arg, arch_op);
 
diff --git a/lib/BC/Optimizer.cpp b/lib/BC/Optimizer.cpp
@@ -35,7 +35,6 @@
 #include <llvm/Pass.h>
 #include <llvm/Passes/OptimizationLevel.h>
 #include <llvm/Passes/PassBuilder.h>
-#include <llvm/TargetParser/Triple.h>
 #include <llvm/Transforms/IPO.h>
 #include <llvm/Transforms/IPO/Inliner.h>
 #include <llvm/Transforms/IPO/ModuleInliner.h>
@@ -67,7 +66,9 @@ void OptimizeBareModule(llvm::Module *module, OptimizationGuide guide) {
 
 
   llvm::PipelineTuningOptions opts;
+#if LLVM_VERSION_MAJOR >= 16
   opts.InlinerThreshold = 250;
+#endif // LLVM_VERSION_MAJOR
   llvm::PassBuilder pb(nullptr, opts);
 
   pb.registerModuleAnalyses(mam);
diff --git a/lib/BC/TraceLifter.cpp b/lib/BC/TraceLifter.cpp
@@ -254,7 +254,7 @@ bool TraceLifter::Impl::Lift(
 
   // Get a trace head that the manager knows about, or that we
   // will eventually tell the trace manager about.
-  auto get_trace_decl = [=](uint64_t trace_addr) -> llvm::Function * {
+  auto get_trace_decl = [this](uint64_t trace_addr) -> llvm::Function * {
     if (auto trace = GetLiftedTraceDeclaration(trace_addr)) {
       return trace;
     } else if (trace_work_list.count(trace_addr)) {
diff --git a/lib/BC/Util.cpp b/lib/BC/Util.cpp
@@ -708,7 +708,7 @@ LiftedFunctionArgs(llvm::BasicBlock *block, const IntrinsicTable &intrinsics) {
 void ForEachISel(llvm::Module *module, ISelCallback callback) {
   for (auto &global : module->globals()) {
     const auto &name = global.getName();
-    if (name.startswith("ISEL_") || name.startswith("COND_")) {
+    if (name.find("ISEL_") == 0 || name.find("COND_") == 0) {
       llvm::Function *sem = nullptr;
       if (global.hasInitializer()) {
         sem = llvm::dyn_cast<llvm::Function>(
@@ -1144,6 +1144,7 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#if LLVM_VERSION_MAJOR <= 17
       case llvm::Instruction::And: {
         auto ret = llvm::ConstantExpr::getAnd(
             MoveConstantIntoModule(ce->getOperand(0), dest_module, value_map,
@@ -1162,6 +1163,7 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#endif // LLVM_VERSION_MAJOR
       case llvm::Instruction::Xor: {
         auto ret = llvm::ConstantExpr::getXor(
             MoveConstantIntoModule(ce->getOperand(0), dest_module, value_map,
@@ -1171,6 +1173,7 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#if LLVM_VERSION_MAJOR <= 18
       case llvm::Instruction::ICmp: {
         auto ret = llvm::ConstantExpr::getICmp(
             ce->getPredicate(),
@@ -1181,6 +1184,8 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#endif // LLVM_VERSION_MAJOR
+#if LLVM_VERSION_MAJOR <= 18
       case llvm::Instruction::ZExt: {
         auto ret = llvm::ConstantExpr::getZExt(
             MoveConstantIntoModule(ce->getOperand(0), dest_module, value_map,
@@ -1189,6 +1194,8 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#endif // LLVM_VERSION_MAJOR
+#if LLVM_VERSION_MAJOR <= 17
       case llvm::Instruction::SExt: {
         auto ret = llvm::ConstantExpr::getSExt(
             MoveConstantIntoModule(ce->getOperand(0), dest_module, value_map,
@@ -1197,6 +1204,7 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#endif // LLVM_VERSION_MAJOR
       case llvm::Instruction::Trunc: {
         auto ret = llvm::ConstantExpr::getTrunc(
             MoveConstantIntoModule(ce->getOperand(0), dest_module, value_map,
@@ -1205,6 +1213,7 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#if LLVM_VERSION_MAJOR <= 18
       case llvm::Instruction::Shl: {
         const auto b = llvm::dyn_cast<llvm::ShlOperator>(ce);
         auto ret = llvm::ConstantExpr::getShl(
@@ -1216,6 +1225,8 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#endif
+#if LLVM_VERSION_MAJOR <= 17
       case llvm::Instruction::LShr: {
         const auto b = llvm::dyn_cast<llvm::LShrOperator>(ce);
         auto ret = llvm::ConstantExpr::getLShr(
@@ -1238,6 +1249,7 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
         moved_c = ret;
         return ret;
       }
+#endif // LLVM_VERSION_MAJOR
       case llvm::Instruction::Mul: {
         const auto b = llvm::dyn_cast<llvm::MulOperator>(ce);
         auto ret = llvm::ConstantExpr::getMul(
@@ -1291,11 +1303,16 @@ MoveConstantIntoModule(llvm::Constant *c, llvm::Module *dest_module,
           indices[i] = MoveConstantIntoModule(ce->getOperand(i + 1u),
                                               dest_module, value_map, type_map);
         }
+#if LLVM_VERSION_MAJOR >= 19
+        auto in_range = g->getInRange();
+#else
+        auto in_range = g->getInRangeIndex();
+#endif // LLVM_VERSION_MAJOR
         auto ret = llvm::ConstantExpr::getGetElementPtr(
             source_type,
             MoveConstantIntoModule(ce->getOperand(0), dest_module, value_map,
                                    type_map),
-            indices, g->isInBounds(), g->getInRangeIndex());
+            indices, g->isInBounds(), in_range);
         moved_c = ret;
         return ret;
       }
diff --git a/lib/OS/OS.cpp b/lib/OS/OS.cpp
@@ -15,10 +15,10 @@
  */
 
 #include "remill/OS/OS.h"
+#include "remill/Arch/Arch.h"
 
 #include <gflags/gflags.h>
 #include <glog/logging.h>
-#include <llvm/TargetParser/Triple.h>
 
 namespace remill {
 
diff --git a/test_runner_lib/TestRunner.cpp b/test_runner_lib/TestRunner.cpp
@@ -46,7 +46,7 @@ namespace test_runner {
 namespace {
 static bool FuncIsIntrinsicPrefixedBy(const llvm::Function *func,
                                       const char *prefix) {
-  return func->isDeclaration() && func->getName().startswith(prefix);
+  return func->isDeclaration() && func->getName().find(prefix) == 0;
 }
 }  // namespace
 
@@ -73,11 +73,10 @@ void *MissingFunctionStub(const std::string &name) {
   return nullptr;
 }
 
-MemoryHandler::MemoryHandler(llvm::support::endianness endian_)
-    : endian(endian_) {}
+MemoryHandler::MemoryHandler(llvm::endianness endian_) : endian(endian_) {}
 
 MemoryHandler::MemoryHandler(
-    llvm::support::endianness endian_,
+    llvm::endianness endian_,
     std::unordered_map<uint64_t, uint8_t> initial_state)
     : state(std::move(initial_state)),
       endian(endian_) {}
diff --git a/test_runner_lib/include/test_runner/TestRunner.h b/test_runner_lib/include/test_runner/TestRunner.h
@@ -35,6 +35,12 @@
 #include <string>
 #include <unordered_map>
 
+#if LLVM_VERSION_MAJOR < 18
+namespace llvm {
+  using endianness = support::endianness;
+}
+#endif // LLVM_VERSION_MAJOR
+
 namespace test_runner {
 
 
@@ -48,12 +54,12 @@ class MemoryHandler {
   std::unordered_map<uint64_t, uint8_t> state;
 
   random_bytes_engine rbe;
-  llvm::support::endianness endian;
+  llvm::endianness endian;
 
  public:
-  MemoryHandler(llvm::support::endianness endian_);
+  MemoryHandler(llvm::endianness endian_);
 
-  MemoryHandler(llvm::support::endianness endian_,
+  MemoryHandler(llvm::endianness endian_,
                 std::unordered_map<uint64_t, uint8_t> initial_state);
 
   uint8_t read_byte(uint64_t addr);
