[feature][riscv] handle target address calculation in llvm-objdump disassembly for riscv

bolt/include/bolt/Core/MCPlusBuilder.h

@@ -1096,7 +1096,7 @@ class MCPlusBuilder {
   /// targets. Return true on success, and the address in Target.
   virtual bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
                               uint64_t &Target) const {
-    return Analysis->evaluateBranch(Inst, Addr, Size, Target);
+    return Analysis->findTargetAddress(Inst, Addr, Size, Target);
   }
 
   /// Return true if one of the operands of the \p Inst instruction uses

llvm/include/llvm/MC/MCInstrAnalysis.h

@@ -19,6 +19,7 @@
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/Compiler.h"
 #include <cstdint>
 #include <vector>
@@ -180,11 +181,12 @@ class LLVM_ABI MCInstrAnalysis {
     return false;
   }
 
-  /// Given a branch instruction try to get the address the branch
-  /// targets. Return true on success, and the address in Target.
-  virtual bool
-  evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                 uint64_t &Target) const;
+  /// Given an instruction that accesses memory or
+  /// that branches to another address, try to get the address it targets.
+  /// Return true on success, and the address in \p Target.
+  virtual bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                                 uint64_t &Target,
+                                 const MCSubtargetInfo *STI = nullptr) const;
 
   /// Given an instruction tries to get the address of a memory operand. Returns
   /// the address on success.

llvm/lib/MC/MCInstrAnalysis.cpp

@@ -24,9 +24,9 @@ bool MCInstrAnalysis::clearsSuperRegisters(const MCRegisterInfo &MRI,
   return false;
 }
 
-bool MCInstrAnalysis::evaluateBranch(const MCInst & /*Inst*/, uint64_t /*Addr*/,
-                                     uint64_t /*Size*/,
-                                     uint64_t & /*Target*/) const {
+bool MCInstrAnalysis::findTargetAddress(const MCInst &Inst, uint64_t Addr,
+                                        uint64_t Size, uint64_t &Target,
+                                        const MCSubtargetInfo *STI) const {
   return false;
 }
 

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp

@@ -394,8 +394,9 @@ class AArch64MCInstrAnalysis : public MCInstrAnalysis {
 public:
   AArch64MCInstrAnalysis(const MCInstrInfo *Info) : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     // Search for a PC-relative argument.
     // This will handle instructions like bcc (where the first argument is the
     // condition code) and cbz (where it is a register).

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp

@@ -137,8 +137,9 @@ class AMDGPUMCInstrAnalysis : public MCInstrAnalysis {
   explicit AMDGPUMCInstrAnalysis(const MCInstrInfo *Info)
       : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     if (Inst.getNumOperands() == 0 || !Inst.getOperand(0).isImm() ||
         Info->get(Inst.getOpcode()).operands()[0].OperandType !=
             MCOI::OPERAND_PCREL)

llvm/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp

@@ -407,8 +407,9 @@ class ARMMCInstrAnalysis : public MCInstrAnalysis {
     return MCInstrAnalysis::isConditionalBranch(Inst);
   }
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     const MCInstrDesc &Desc = Info->get(Inst.getOpcode());
 
     // Find the PC-relative immediate operand in the instruction.

llvm/lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp

@@ -77,8 +77,9 @@ class BPFMCInstrAnalysis : public MCInstrAnalysis {
   explicit BPFMCInstrAnalysis(const MCInstrInfo *Info)
       : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     // The target is the 3rd operand of cond inst and the 1st of uncond inst.
     int32_t Imm;
     if (isConditionalBranch(Inst)) {

llvm/lib/Target/CSKY/MCTargetDesc/CSKYMCTargetDesc.cpp

@@ -111,8 +111,9 @@ class CSKYMCInstrAnalysis : public MCInstrAnalysis {
   explicit CSKYMCInstrAnalysis(const MCInstrInfo *Info)
       : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     if (isConditionalBranch(Inst) || isUnconditionalBranch(Inst)) {
       int64_t Imm;
       Imm = Inst.getOperand(Inst.getNumOperands() - 1).getImm();

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp

@@ -730,8 +730,9 @@ class HexagonMCInstrAnalysis : public MCInstrAnalysis {
     return MCInstrAnalysis::isConditionalBranch(Inst);
   }
 
-  bool evaluateBranch(MCInst const &Inst, uint64_t Addr,
-                      uint64_t Size, uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     if (!(isCall(Inst) || isUnconditionalBranch(Inst) ||
           isConditionalBranch(Inst)))
       return false;

llvm/lib/Target/Lanai/MCTargetDesc/LanaiMCTargetDesc.cpp

@@ -94,8 +94,9 @@ class LanaiMCInstrAnalysis : public MCInstrAnalysis {
   explicit LanaiMCInstrAnalysis(const MCInstrInfo *Info)
       : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     if (Inst.getNumOperands() == 0)
       return false;
     if (!isConditionalBranch(Inst) && !isUnconditionalBranch(Inst) &&

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchMCTargetDesc.cpp

@@ -171,8 +171,9 @@ class LoongArchMCInstrAnalysis : public MCInstrAnalysis {
     }
   }
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     unsigned NumOps = Inst.getNumOperands();
     if ((isBranch(Inst) && !isIndirectBranch(Inst)) ||
         Inst.getOpcode() == LoongArch::BL) {

llvm/lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp

@@ -226,8 +226,9 @@ class MipsMCInstrAnalysis : public MCInstrAnalysis {
 public:
   MipsMCInstrAnalysis(const MCInstrInfo *Info) : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     unsigned NumOps = Inst.getNumOperands();
     if (NumOps == 0)
       return false;

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

@@ -454,8 +454,9 @@ class PPCMCInstrAnalysis : public MCInstrAnalysis {
   explicit PPCMCInstrAnalysis(const MCInstrInfo *Info)
       : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     unsigned NumOps = Inst.getNumOperands();
     if (NumOps == 0 ||
         Info->get(Inst.getOpcode()).operands()[NumOps - 1].OperandType !=

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCTargetDesc.cpp

@@ -32,6 +32,7 @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <bitset>
+#include <cstdint>
 
 #define GET_INSTRINFO_MC_DESC
 #define ENABLE_INSTR_PREDICATE_VERIFIER
@@ -184,6 +185,17 @@ class RISCVMCInstrAnalysis : public MCInstrAnalysis {
     }
 
     switch (Inst.getOpcode()) {
+    case RISCV::C_LUI:
+    case RISCV::LUI: {
+      setGPRState(Inst.getOperand(0).getReg(),
+                  SignExtend64<32>(Inst.getOperand(1).getImm() << 12));
+      break;
+    }
+    case RISCV::AUIPC: {
+      setGPRState(Inst.getOperand(0).getReg(),
+                  Addr + SignExtend64<32>(Inst.getOperand(1).getImm() << 12));
+      break;
+    }
     default: {
       // Clear the state of all defined registers for instructions that we don't
       // explicitly support.
@@ -195,15 +207,12 @@ class RISCVMCInstrAnalysis : public MCInstrAnalysis {
       }
       break;
     }
-    case RISCV::AUIPC:
-      setGPRState(Inst.getOperand(0).getReg(),
-                  Addr + SignExtend64<32>(Inst.getOperand(1).getImm() << 12));
-      break;
     }
   }
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override {
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override {
     if (isConditionalBranch(Inst)) {
       int64_t Imm;
       if (Size == 2)
@@ -215,6 +224,8 @@ class RISCVMCInstrAnalysis : public MCInstrAnalysis {
     }
 
     switch (Inst.getOpcode()) {
+    default:
+      return false;
     case RISCV::C_J:
     case RISCV::C_JAL:
     case RISCV::QC_E_J:
@@ -231,8 +242,85 @@ class RISCVMCInstrAnalysis : public MCInstrAnalysis {
       }
       return false;
     }
+    case RISCV::C_ADDI:
+    case RISCV::ADDI: {
+      if (!STI)
+        return false;
+      unsigned int ArchRegWidth =
+          STI->getTargetTriple().getArchPointerBitWidth();
+      MCRegister Reg = Inst.getOperand(1).getReg();
+      auto TargetRegState = getGPRState(Reg);
+      if (TargetRegState && Reg != RISCV::X0) {
+        Target = *TargetRegState + Inst.getOperand(2).getImm();
+        Target &= maskTrailingOnes<uint64_t>(ArchRegWidth);
+        return true;
+      }
+      break;
+    }
+    case RISCV::C_ADDIW:
+    case RISCV::ADDIW: {
+      MCRegister Reg = Inst.getOperand(1).getReg();
+      auto TargetRegState = getGPRState(Reg);
+      if (TargetRegState && Reg != RISCV::X0) {
+        Target = *TargetRegState + Inst.getOperand(2).getImm();
+        Target = SignExtend64<32>(Target);
+        return true;
+      }
+      break;
+    }
+    case RISCV::LB:
+    case RISCV::LH:
+    case RISCV::LD:
+    case RISCV::LW:
+    case RISCV::LBU:
+    case RISCV::LHU:
+    case RISCV::LWU:
+    case RISCV::SB:
+    case RISCV::SH:
+    case RISCV::SW:
+    case RISCV::SD:
+    case RISCV::FLH:
+    case RISCV::FLW:
+    case RISCV::FLD:
+    case RISCV::FSH:
+    case RISCV::FSW:
+    case RISCV::FSD:
+    case RISCV::C_LD:
+    case RISCV::C_SD:
+    case RISCV::C_FLD:
+    case RISCV::C_FSD:
+    case RISCV::C_SW:
+    case RISCV::C_LW:
+    case RISCV::C_FSW:
+    case RISCV::C_FLW:
+    case RISCV::C_LBU:
+    case RISCV::C_LH:
+    case RISCV::C_LHU:
+    case RISCV::C_SB:
+    case RISCV::C_SH:
+    case RISCV::C_LWSP:
+    case RISCV::C_SWSP:
+    case RISCV::C_LDSP:
+    case RISCV::C_SDSP:
+    case RISCV::C_FLWSP:
+    case RISCV::C_FSWSP:
+    case RISCV::C_FLDSP:
+    case RISCV::C_FSDSP:
+    case RISCV::C_LD_RV32:
+    case RISCV::C_SD_RV32:
+    case RISCV::C_SDSP_RV32:
+    case RISCV::LD_RV32:
+    case RISCV::C_LDSP_RV32:
+    case RISCV::SD_RV32: {
+      MCRegister Reg = Inst.getOperand(1).getReg();
+      auto TargetRegState = getGPRState(Reg);
+      if (TargetRegState) {
+        Target = *TargetRegState + Inst.getOperand(2).getImm();
+        return true;
+      }
+      break;
+    }
     }
-
     return false;
   }
 
@@ -389,12 +477,11 @@ LLVMInitializeRISCVTargetMC() {
     TargetRegistry::RegisterELFStreamer(*T, createRISCVELFStreamer);
     TargetRegistry::RegisterObjectTargetStreamer(
         *T, createRISCVObjectTargetStreamer);
-    TargetRegistry::RegisterMCInstrAnalysis(*T, createRISCVInstrAnalysis);
-
     // Register the asm target streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createRISCVAsmTargetStreamer);
     // Register the null target streamer.
     TargetRegistry::RegisterNullTargetStreamer(*T,
                                                createRISCVNullTargetStreamer);
+    TargetRegistry::RegisterMCInstrAnalysis(*T, createRISCVInstrAnalysis);
   }
 }

llvm/lib/Target/X86/MCTargetDesc/X86ATTInstPrinter.cpp

@@ -441,7 +441,7 @@ void X86ATTInstPrinter::printMemReference(const MCInst *MI, unsigned Op,
   // binary object.
   if (SymbolizeOperands && MIA) {
     uint64_t Target;
-    if (MIA->evaluateBranch(*MI, 0, 0, Target))
+    if (MIA->findTargetAddress(*MI, 0, 0, Target))
       return;
     if (MIA->evaluateMemoryOperandAddress(*MI, /*STI=*/nullptr, 0, 0))
       return;

llvm/lib/Target/X86/MCTargetDesc/X86IntelInstPrinter.cpp

@@ -383,7 +383,7 @@ void X86IntelInstPrinter::printMemReference(const MCInst *MI, unsigned Op,
   // binary object.
   if (SymbolizeOperands && MIA) {
     uint64_t Target;
-    if (MIA->evaluateBranch(*MI, 0, 0, Target))
+    if (MIA->findTargetAddress(*MI, 0, 0, Target))
       return;
     if (MIA->evaluateMemoryOperandAddress(*MI, /*STI=*/nullptr, 0, 0))
       return;

llvm/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

@@ -515,8 +515,9 @@ class X86MCInstrAnalysis : public MCInstrAnalysis {
   findPltEntries(uint64_t PltSectionVA, ArrayRef<uint8_t> PltContents,
                  const MCSubtargetInfo &STI) const override;
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target) const override;
+  bool findTargetAddress(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                         uint64_t &Target,
+                         const MCSubtargetInfo *STI) const override;
   std::optional<uint64_t>
   evaluateMemoryOperandAddress(const MCInst &Inst, const MCSubtargetInfo *STI,
                                uint64_t Addr, uint64_t Size) const override;
@@ -641,8 +642,9 @@ X86MCInstrAnalysis::findPltEntries(uint64_t PltSectionVA,
   }
 }
 
-bool X86MCInstrAnalysis::evaluateBranch(const MCInst &Inst, uint64_t Addr,
-                                        uint64_t Size, uint64_t &Target) const {
+bool X86MCInstrAnalysis::findTargetAddress(
+    const MCInst &Inst, uint64_t Addr, uint64_t Size, uint64_t &Target,
+    const MCSubtargetInfo *STI = nullptr) const {
   if (Inst.getNumOperands() == 0 ||
       Info->get(Inst.getOpcode()).operands()[0].OperandType !=
           MCOI::OPERAND_PCREL)

llvm/test/tools/llvm-objdump/RISCV/lit.local.cfg

@@ -0,0 +1,2 @@
+if "RISCV" not in config.targets_to_build:
+    config.unsupported = True