feat: add support for F and D RISC-V extensions

Author: arromanoff

README.md

@@ -50,3 +50,18 @@ llvm-bleach currently comes with documentation for all of 3 distributed tools:
 - [mctomir](./docs/mctomir.md) - machine code to MIR lifter
 - [bleach-config-gen](./docs/bleach-config-gen.md) - helper tool to generate
   architecture configs for llvm-bleach from available templates.
+
+### Platform Support
+
+#### RISC-V
+
+Currently llvm-bleach supports rv64/rv32 basic instruction sets for I configurations.
+Supported extensions include:
+
+- M - Integer multiplication and division
+- F - Single-precision floating-point operations
+- D - Double-precision floating-point operations
+
+> [!NOTE]
+> mctomir tool for lifting machine code to LLVM MIR potentially supports all
+> architectures supported by LLVM but is not yet propperly tested

include/mctomir/mctomir-transform.h

@@ -116,6 +116,8 @@ class translator_t final {
                              uint64_t size);
   MachineBasicBlock *get_or_create_mbb_for_address(uint64_t address,
                                                    MachineFunction &mfunc);
+  void fill_operands(MachineInstrBuilder &builder, const MCInst &inst,
+                     const MCInstrDesc &desc, bool is_branch);
   void add_operand_to_mib(MachineInstrBuilder &mib, const MCOperand &mc_op,
                           unsigned op_idx, const MCInstrDesc &desc);
   MachineInstr *create_machine_instr(const translated_inst &tinst,

lib/lifter/lifter.cpp

@@ -102,13 +102,16 @@ void create_basic_blocks_for_mfunc(MachineFunction &src, MachineFunction &dst,
   std::unordered_map<MachineBasicBlock *, MachineBasicBlock *> block_map;
   // One cannot simply loop over mfunc as we insert new blocks into it
   for (auto &mbb : src) {
+    assert(all_of(mbb.successors(),
+                  [&](auto *succ) { return succ->getParent() == &src; }));
     auto [new_mblock, new_block] = clone_basic_block(mbb, dst);
     m2b.insert({new_mblock, new_block});
-    block_map.insert({&mbb, new_mblock});
+    block_map.try_emplace(&mbb, new_mblock);
   }
   for (auto &mbb : dst) {
-    for (auto *succ : mbb.successors())
+    for (auto *succ : mbb.successors()) {
       replace_uses_of_block_with(mbb, *succ, *block_map.at(succ));
+    }
   }
   for (auto &block : dst.getFunction()) {
     for (auto &inst : block)
@@ -124,18 +127,6 @@ void create_basic_blocks_for_mfunc(MachineFunction &src, MachineFunction &dst,
       return succ->getParent() == mbb.getParent();
     });
   }));
-
-  for (auto &mbb : dst) {
-    for (auto &minst : mbb) {
-      if (minst.isBranch()) {
-        auto dst_mbb = llvm::find_if(minst.operands(),
-                                     [](auto &op) { return op.isMBB(); });
-        assert(dst_mbb != minst.operands_end());
-        assert(!block_map.count(dst_mbb->getMBB()));
-        assert(dst_mbb->getMBB()->getParent() == &dst);
-      }
-    }
-  }
 }
 
 void fill_module_with_instrs(Module &m, const instr_impl &instrs) {
@@ -284,8 +275,9 @@ void load_registers(BasicBlock &block, BasicBlock::iterator pos, reg2vals &rmap,
   for (auto &&[idx, rclass] : reg_stats | views::enumerate) {
     auto *array_type = state.getElementType(idx);
     auto *arr_idx = ConstantInt::get(ctx, APInt(32, idx));
-    auto *array_ptr = builder.CreateGEP(
-        &state, state_arg, ArrayRef<Value *>{arr_idx}, rclass.get_name());
+    auto *array_ptr = builder.CreateGEP(&state, state_arg,
+                                        ArrayRef<Value *>{const_zero, arr_idx},
+                                        rclass.get_name());
     for (auto &&[reg_idx, val] : rmap | views::filter([&rclass](auto r) {
                                    return rclass.contains(r.first);
                                  }) | views::enumerate) {
@@ -642,8 +634,13 @@ auto generate_branch(const MachineInstr &minst, BasicBlock &bb,
   auto name = get_instruction_name(minst, *iinfo);
   auto *m = bb.getParent()->getParent();
   auto *func = m->getFunction(name);
-  if (!func)
-    throw std::runtime_error("Could not find \"" + name + "\" in module");
+  if (!func) {
+    std::string instr;
+    raw_string_ostream ss(instr);
+    minst.print(ss);
+    throw std::runtime_error("Could not find \"" + name +
+                             "\" in module: " + instr);
+  }
   auto op_to_val = [&](auto &mop) {
     return operand_to_value(mop, bb, target_machine, rmap, reg_stats, insts);
   };
@@ -788,8 +785,8 @@ static auto generate_load_store_from_stack(
   auto *offset = [&] -> Value * {
     if (offset_it == uses.end())
       return ConstantInt::get(ctx, APInt(64, 0));
-    return ConstantInt::get(ctx,
-                            APInt(64, -offset_it->getImm() / reg_bytesize));
+    auto off = -offset_it->getImm() / reg_bytesize;
+    return ConstantInt::get(ctx, APInt(64, off));
   }();
   auto *sp =
       get_stack_pointer_value(instrs, rmap, builder, target_machine, reg_stats);
@@ -806,15 +803,21 @@ static auto generate_load_store_from_stack(
   auto *iinfo = target_machine.getMCInstrInfo();
   auto name = get_instruction_name(minst, *iinfo);
   auto *m = bb.getParent()->getParent();
-  auto *func = m->getFunction(name);
-  if (!func)
-    throw std::runtime_error("Could not find \"" + name + "\" in module");
+
   auto *inserted = [&] -> Value * {
     // Loading value from stack
     if (minst.mayLoad()) {
       if (minst.mayStore())
         throw std::runtime_error("Unsupported stack manipulation. Instruction "
                                  "can both load and store");
+      auto *func = m->getFunction(name);
+      if (!func) {
+        std::string instr;
+        raw_string_ostream ss(instr);
+        minst.print(ss);
+        throw std::runtime_error("Could not find \"" + name +
+                                 "\" in module: " + instr);
+      }
       auto *ret_type = func->getFunctionType()->getReturnType();
       return builder.CreateLoad(ret_type, addr);
     }
@@ -829,8 +832,9 @@ static auto generate_load_store_from_stack(
     return builder.CreateStore(value, addr);
   }();
   // save result to register
-  if (!minst.defs().empty())
+  if (!minst.defs().empty()) {
     builder.CreateStore(inserted, rmap.at(minst.defs().begin()->getReg()));
+  }
   return inserted;
 }
 
@@ -929,18 +933,16 @@ static bool is_return(const MachineInstr &minst, const instr_impl &instrs,
 static bool is_call(const MachineInstr &minst, const TargetMachine &tmachine) {
   if (minst.isCall())
     return true;
-  if (minst.isPseudo())
-    return false;
   // TODO: create mia only once
   MCInst inst;
   inst.setOpcode(minst.getOpcode());
   std::unique_ptr<MCInstrAnalysis> mia(
       tmachine.getTarget().createMCInstrAnalysis(tmachine.getMCInstrInfo()));
   assert(mia);
-  return mia->isCall(inst) && std::find_if(minst.operands_begin(),
-                                           minst.operands_end(), [](auto &o) {
-                                             return o.isGlobal();
-                                           }) != minst.operands_end();
+  return (mia->isCall(inst) || minst.isUnconditionalBranch()) &&
+         std::find_if(minst.operands_begin(), minst.operands_end(),
+                      [](auto &o) { return o.isGlobal(); }) !=
+             minst.operands_end();
 }
 static bool is_indirect_branch(const MachineInstr &minst,
                                const instr_impl &instrs,
@@ -955,7 +957,9 @@ static bool is_indirect_branch(const MachineInstr &minst,
 
 static bool is_branch(const MachineInstr &minst,
                       const TargetMachine &tmachine) {
-  if (minst.isBranch())
+  if (minst.isBranch() &&
+      std::find_if(minst.operands_begin(), minst.operands_end(),
+                   [](auto &o) { return o.isMBB(); }) != minst.operands_end())
     return true;
   // TODO: create mia only once
   MCInst inst;
@@ -1017,18 +1021,21 @@ auto generate_instruction(const MachineInstr &minst, BasicBlock &bb,
   if (is_call(minst, target_machine))
     return generate_call(minst, builder, bb, rmap, target_machine, state,
                          reg_stats, functions_nop);
-  if (minst.mayLoadOrStore()) {
-    // Instructions that are not considered stack manipulation are generated
-    // just like any other instruction
-    if (is_stack_manipulation(minst, sptrack))
-      return generate_load_store_from_stack(minst, builder, bb, rmap, instrs,
-                                            target_machine, state, reg_stats);
+  if (is_stack_manipulation(minst, sptrack)) {
+    return generate_load_store_from_stack(minst, builder, bb, rmap, instrs,
+                                          target_machine, state, reg_stats);
   }
+
   // TODO: track stack pointerS
   auto *m = bb.getParent()->getParent();
   auto *func = m->getFunction(name);
-  if (!func)
-    throw std::runtime_error("Could not find \"" + name + "\" in module");
+  if (!func) {
+    std::string instr;
+    raw_string_ostream ss(instr);
+    minst.print(ss);
+    throw std::runtime_error("Could not find \"" + name +
+                             "\" in module: " + instr);
+  }
   auto uses = minst.uses();
   bool uses_sp = ranges::find_if(uses, [&](auto &u) {
                    return u.isReg() && sptrack.is_stack_pointer(u.getReg());
@@ -1037,8 +1044,7 @@ auto generate_instruction(const MachineInstr &minst, BasicBlock &bb,
       !minst.defs().empty() && minst.defs().begin()->isReg() && uses_sp;
   if (is_stack_pointer_manipulation) {
     auto dst = minst.defs().begin()->getReg();
-    if (sptrack.is_stack_pointer(dst))
-      sptrack.add(dst);
+    sptrack.add(dst);
     return generate_stack_pointer_modification(
         minst, builder, bb, target_machine, rmap, instrs, reg_stats);
   }
@@ -1091,8 +1097,12 @@ void fill_ir_for_bb(MachineBasicBlock &mbb, reg2vals &rmap,
   auto last = std::prev(mbb.end());
   if (!is_branch(*last, target_machine) &&
       !is_return(*last, instrs, target_machine)) {
-    auto succ = std::next(mbb.getIterator());
-    builder.CreateBr(m2b[std::addressof(*succ)]);
+    if (is_call(*last, target_machine)) {
+      builder.CreateRetVoid();
+    } else {
+      auto succ = std::next(mbb.getIterator());
+      builder.CreateBr(m2b[std::addressof(*succ)]);
+    }
   }
 }
 

lib/mctomir/mctomir-transform.cpp

@@ -3,13 +3,18 @@
 #include <cstdint>
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/ADT/StringExtras.h>
+#include <llvm/CodeGen/GlobalISel/GISelValueTracking.h>
+#include <llvm/CodeGen/GlobalISel/InstructionSelector.h>
 #include <llvm/CodeGen/MIRParser/MIRParser.h>
 #include <llvm/CodeGen/MIRPrinter.h>
 #include <llvm/CodeGen/MachineInstrBuilder.h>
+#include <llvm/CodeGen/TargetOpcodes.h>
 #include <llvm/IR/LegacyPassManager.h>
+#include <llvm/MC/MCInstrAnalysis.h>
 #include <llvm/MC/TargetRegistry.h>
 #include <llvm/Object/ELFObjectFile.h>
 #include <llvm/Object/ObjectFile.h>
+#include <llvm/Support/CodeGenCoverage.h>
 #include <llvm/Support/Error.h>
 #include <llvm/Support/ErrorHandling.h>
 #include <llvm/Target/TargetMachine.h>
@@ -266,6 +271,31 @@ Error translator_t::translate_instructions() {
   return Error::success();
 }
 
+static bool is_tail_call(const MCInst &instr, const MachineBasicBlock *current,
+                         const MachineBasicBlock *target,
+                         const MCInstrAnalysis &mi_analysis) {
+  return mi_analysis.isUnconditionalBranch(instr) &&
+         target->getParent() != current->getParent();
+}
+static bool is_call(const MCInst &instr, const MachineBasicBlock *current,
+                    const MachineBasicBlock *target,
+                    const MCInstrAnalysis &mi_analysis) {
+  return mi_analysis.isCall(instr) ||
+         is_tail_call(instr, current, target, mi_analysis);
+}
+
+void translator_t::fill_operands(MachineInstrBuilder &builder,
+                                 const MCInst &inst, const MCInstrDesc &desc,
+                                 bool is_branch) {
+  for (unsigned i = 0; i < inst.getNumOperands(); ++i) {
+    if (is_branch && (i == inst.getNumOperands() - 1) &&
+        inst.getOperand(i).isImm())
+      break;
+    const MCOperand &mc_op = inst.getOperand(i);
+    add_operand_to_mib(builder, mc_op, i, desc);
+  }
+}
+
 MachineInstr *translator_t::create_machine_instr(const translated_inst &tinst,
                                                  MachineBasicBlock *mbb) {
   if (!tii || !mbb)
@@ -276,36 +306,40 @@ MachineInstr *translator_t::create_machine_instr(const translated_inst &tinst,
   const MCInstrDesc &desc = tii->get(opcode);
   uint64_t target;
   bool is_branch = res.mi_analysis->evaluateBranch(inst, 0, 4, target);
-  MachineInstrBuilder mib = BuildMI(*mbb, mbb->end(), DebugLoc(), desc);
-
-  for (unsigned i = 0; i < inst.getNumOperands(); ++i) {
-    if (is_branch && (i == inst.getNumOperands() - 1) &&
-        inst.getOperand(i).isImm())
-      break;
-    const MCOperand &mc_op = inst.getOperand(i);
-    add_operand_to_mib(mib, mc_op, i, desc);
-  }
 
   if (is_branch) {
-    // TODO(Ilyagavilin): deduce operands in other way
-    if (inst.getNumOperands() > 0 &&
-        inst.getOperand(inst.getNumOperands() - 1).isImm()) {
-      auto target_it = address_to_mbb.find(target + tinst.address);
-      if (target_it != address_to_mbb.end()) {
-        if (res.mi_analysis->isCall(inst))
-          mib.addGlobalAddress(&target_it->second->getParent()->getFunction(),
-                               0);
-        else
-          mib.addMBB(target_it->second);
-      } else {
-        std::string instr;
-        raw_string_ostream ss(instr);
-        mib->print(ss);
-        std::cerr << "Warning: destination not found for instruction:\n\t"
-                  << instr << '\n';
+    assert(inst.getNumOperands() > 0 &&
+           inst.getOperand(inst.getNumOperands() - 1).isImm());
+    auto target_it = address_to_mbb.find(target + tinst.address);
+    if (target_it != address_to_mbb.end()) {
+      if (mctomir::is_call(inst, mbb, target_it->second, *res.mi_analysis)) {
+        bool is_tail = mctomir::is_tail_call(inst, mbb, target_it->second,
+                                             *res.mi_analysis);
+
+        auto mib = is_tail ? BuildMI(*mbb, mbb->end(), DebugLoc(),
+                                     tii->get(TargetOpcode::G_BR))
+                           : BuildMI(*mbb, mbb->end(), DebugLoc(), desc);
+        if (!is_tail)
+          fill_operands(mib, inst, desc, is_branch);
+        mib.addGlobalAddress(&target_it->second->getParent()->getFunction(), 0);
+
+        return mib.getInstr();
       }
+      MachineInstrBuilder mib = BuildMI(*mbb, mbb->end(), DebugLoc(), desc);
+      fill_operands(mib, inst, desc, is_branch);
+      mib.addMBB(target_it->second);
+      mbb->addSuccessor(target_it->second);
+      return mib.getInstr();
+    } else {
+      std::string instr;
+      raw_string_ostream ss(instr);
+      std::cerr << "Warning: destination not found for instruction:\n\t"
+                << instr << '\n';
     }
   }
+  MachineInstrBuilder mib = BuildMI(*mbb, mbb->end(), DebugLoc(), desc);
+
+  fill_operands(mib, inst, desc, is_branch);
 
   return mib.getInstr();
 }
@@ -356,12 +390,14 @@ Error translator_t::link_machine_basic_blocks() {
         if (res.mi_analysis->evaluateBranch(last_inst, last_t_inst->address, 0,
                                             target)) {
           auto target_it = address_to_mbb.find(target);
-          if (target_it != address_to_mbb.end()) {
-            mbb->addSuccessor(target_it->second);
+          if (target_it != address_to_mbb.end() &&
+              !mctomir::is_call(last_inst, mbb, target_it->second,
+                                *res.mi_analysis)) {
+            // mbb->addSuccessor(target_it->second);
           } else {
             MachineBasicBlock *target_mbb =
                 get_or_create_mbb_for_address(target, *finfo.mfunc);
-            mbb->addSuccessor(target_mbb);
+            // mbb->addSuccessor(target_mbb);
           }
         }
         if (!res.mi_analysis->isUnconditionalBranch(last_inst) &&