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

llvm/include/llvm/MC/MCInstrAnalysis.h

@@ -177,17 +177,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 MCSubtargetInfo *STI = nullptr) const;
-
-  /// Given an instruction that accesses a memory address, try to compute
-  /// the target address. Return true on success, and the address in \p Target.
-  virtual bool evaluateInstruction(const MCInst &Inst, uint64_t Addr,
-                                   uint64_t Size, uint64_t &Target,
-                                   const MCSubtargetInfo &STI) const;
+  /// Given an instruction that accesses memory, computes a memory address, or
+  // branches to another address, try to get the address these instructions
+  // target. 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,15 +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 MCSubtargetInfo *STI) const {
-  return false;
-}
-
-bool MCInstrAnalysis::evaluateInstruction(const MCInst &Inst, uint64_t Addr,
-                                          uint64_t Size, uint64_t &Target,
-                                          const MCSubtargetInfo &STI) 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

@@ -393,9 +393,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 MCSubtargetInfo *STI) 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

@@ -136,9 +136,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 MCSubtargetInfo *STI) 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

@@ -412,9 +412,9 @@ class ARMMCInstrAnalysis : public MCInstrAnalysis {
     return MCInstrAnalysis::isConditionalBranch(Inst);
   }
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target,
-                      const MCSubtargetInfo *STI) 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

@@ -76,9 +76,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 MCSubtargetInfo *STI) 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

@@ -112,9 +112,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 MCSubtargetInfo *STI) 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

@@ -716,9 +716,9 @@ class HexagonMCInstrAnalysis : public MCInstrAnalysis {
     return MCInstrAnalysis::isConditionalBranch(Inst);
   }
 
-  bool evaluateBranch(MCInst const &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target,
-                      const MCSubtargetInfo *STI) 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

@@ -93,9 +93,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 MCSubtargetInfo *STI) 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

@@ -99,9 +99,9 @@ class LoongArchMCInstrAnalysis : public MCInstrAnalysis {
   explicit LoongArchMCInstrAnalysis(const MCInstrInfo *Info)
       : MCInstrAnalysis(Info) {}
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target,
-                      const MCSubtargetInfo *STI) 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

@@ -230,9 +230,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 MCSubtargetInfo *STI) 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

@@ -455,9 +455,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 MCSubtargetInfo *STI) 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

@@ -209,9 +209,9 @@ class RISCVMCInstrAnalysis : public MCInstrAnalysis {
     }
   }
 
-  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
-                      uint64_t &Target,
-                      const MCSubtargetInfo *STI) 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)

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

@@ -424,7 +424,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

@@ -382,7 +382,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

@@ -514,9 +514,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 MCSubtargetInfo *STI) 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,7 +641,7 @@ X86MCInstrAnalysis::findPltEntries(uint64_t PltSectionVA,
   }
 }
 
-bool X86MCInstrAnalysis::evaluateBranch(
+bool X86MCInstrAnalysis::findTargetAddress(
     const MCInst &Inst, uint64_t Addr, uint64_t Size, uint64_t &Target,
     const MCSubtargetInfo *STI = nullptr) const {
   if (Inst.getNumOperands() == 0 ||

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

@@ -180,7 +180,7 @@ bool FileAnalysis::willTrapOnCFIViolation(const Instr &InstrMeta) const {
   if (!InstrDesc.isCall())
     return false;
   uint64_t Target;
-  if (!MIA->evaluateBranch(InstrMeta.Instruction, InstrMeta.VMAddress,
+  if (!MIA->findTargetAddress(InstrMeta.Instruction, InstrMeta.VMAddress,
                            InstrMeta.InstructionSize, Target))
     return false;
   return TrapOnFailFunctionAddresses.contains(Target);
@@ -215,7 +215,7 @@ FileAnalysis::getDefiniteNextInstruction(const Instr &InstrMeta) const {
       return nullptr;
 
     uint64_t Target;
-    if (!MIA->evaluateBranch(InstrMeta.Instruction, InstrMeta.VMAddress,
+    if (!MIA->findTargetAddress(InstrMeta.Instruction, InstrMeta.VMAddress,
                              InstrMeta.InstructionSize, Target))
       return nullptr;
 
@@ -508,7 +508,7 @@ void FileAnalysis::parseSectionContents(ArrayRef<uint8_t> SectionBytes,
       continue;
 
     uint64_t Target;
-    if (MIA->evaluateBranch(Instruction, VMAddress, InstructionSize, Target)) {
+    if (MIA->findTargetAddress(Instruction, VMAddress, InstructionSize, Target)) {
       // If the target can be evaluated, it's not indirect.
       StaticBranchTargetings[Target].push_back(VMAddress);
       continue;

llvm/tools/llvm-cfi-verify/lib/GraphBuilder.cpp

@@ -137,7 +137,7 @@ void GraphBuilder::buildFlowsToUndefined(const FileAnalysis &Analysis,
   } else if (BranchNode.Fallthrough && !BranchNode.Target) {
     // We already know the fallthrough, evaluate the target.
     uint64_t Target;
-    if (!Analysis.getMCInstrAnalysis()->evaluateBranch(
+    if (!Analysis.getMCInstrAnalysis()->findTargetAddress(
             BranchInstrMeta.Instruction, BranchInstrMeta.VMAddress,
             BranchInstrMeta.InstructionSize, Target)) {
       errs() << "Failed to get branch target for conditional branch at address "
@@ -254,7 +254,7 @@ void GraphBuilder::buildFlowGraphImpl(const FileAnalysis &Analysis,
     // Evaluate the branch target to ascertain whether this XRef is the result
     // of a fallthrough or the target of a branch.
     uint64_t BranchTarget;
-    if (!Analysis.getMCInstrAnalysis()->evaluateBranch(
+    if (!Analysis.getMCInstrAnalysis()->findTargetAddress(
             ParentMeta.Instruction, ParentMeta.VMAddress,
             ParentMeta.InstructionSize, BranchTarget)) {
       errs() << "Failed to evaluate branch target for instruction at address "

llvm/tools/llvm-objdump/llvm-objdump.cpp

@@ -1520,7 +1520,7 @@ collectLocalBranchTargets(ArrayRef<uint8_t> Bytes, MCInstrAnalysis *MIA,
     if (MIA) {
       if (Disassembled) {
         uint64_t Target;
-        bool BranchTargetKnown = MIA->evaluateBranch(Inst, Index, Size, Target);
+        bool BranchTargetKnown = MIA->findTargetAddress(Inst, Index, Size, Target);
         if (BranchTargetKnown && (Target >= Start && Target < End) &&
             !Targets.count(Target)) {
           // On PowerPC and AIX, a function call is encoded as a branch to 0.
@@ -2355,7 +2355,7 @@ disassembleObject(ObjectFile &Obj, const ObjectFile &DbgObj,
           if (Disassembled && DT->InstrAnalysis) {
             llvm::raw_ostream *TargetOS = &FOS;
             uint64_t Target;
-            bool PrintTarget = DT->InstrAnalysis->evaluateBranch(
+            bool PrintTarget = DT->InstrAnalysis->findTargetAddress(
                 Inst, SectionAddr + Index, Size, Target,
                 DT->SubtargetInfo.get());
             if (!PrintTarget) {

llvm/tools/llvm-profgen/ProfiledBinary.cpp

@@ -564,7 +564,7 @@ bool ProfiledBinary::dissassembleSymbol(std::size_t SI, ArrayRef<uint8_t> Bytes,
       // Record potential call targets for tail frame inference later-on.
       if (InferMissingFrames && FRange) {
         uint64_t Target = 0;
-        MIA->evaluateBranch(Inst, Address, Size, Target);
+        MIA->findTargetAddress(Inst, Address, Size, Target);
         if (MCDesc.isCall()) {
           // Indirect call targets are unknown at this point. Recording the
           // unknown target (zero) for further LBR-based refinement.

llvm/tools/sancov/sancov.cpp

@@ -767,7 +767,7 @@ static void getObjectCoveragePoints(const object::ObjectFile &O,
       uint64_t CovPoint = getPreviousInstructionPc(Addr + Size, TheTriple);
       uint64_t Target;
       if (MIA->isCall(Inst) &&
-          MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target) &&
+          MIA->findTargetAddress(Inst, SectionAddr + Index, Size, Target) &&
           SanCovAddrs.find(Target) != SanCovAddrs.end())
         Addrs->insert(CovPoint);
     }