[MC][LoongArch] Make .reloc support arbitrary relocation types

[wangleiat]

Summary

Similar to D76746 (ARM), D76754 (AArch64), D77018 (RISCV) and
llvmorg-11-init-6967-g152d14da64c (x86)

Depends on D132108

[xen0n]

Only one minor nit. Thanks.

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

27–28

could simplify a bit, to auto Type = ...

[wangleiat]

Address @xen0n's comment.

[thakis]

llvm/test/MC/LoongArch/Relocations/reloc-directive-err.s

1

zsh on macOS complains about |&:

/Users/thakis/src/llvm-project/out/gn/obj/llvm/test/MC/LoongArch/Relocations/Output/reloc-directive-err.s.script: line 1: syntax error near unexpected token `&'

I'll tweak this test, but going forward, please don't use |& in tests.

llvm/lib/Target/LoongArch/MCTargetDesc/LoongArchAsmBackend.h

 #include "MCTargetDesc/LoongArchMCTargetDesc.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace llvm {
 
 class LoongArchAsmBackend : public MCAsmBackend {
+  const MCSubtargetInfo &STI;
   uint8_t OSABI;
   bool Is64Bit;
 
 public:
   LoongArchAsmBackend(const MCSubtargetInfo &STI, uint8_t OSABI, bool Is64Bit)
-      : MCAsmBackend(support::little), OSABI(OSABI), Is64Bit(Is64Bit) {}
+      : MCAsmBackend(support::little), STI(STI), OSABI(OSABI),
+        Is64Bit(Is64Bit) {}
   ~LoongArchAsmBackend() override {}
 
   void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
                   const MCValue &Target, MutableArrayRef<char> Data,
                   uint64_t Value, bool IsResolved,
                   const MCSubtargetInfo *STI) const override;
 
   bool shouldForceRelocation(const MCAssembler &Asm, const MCFixup &Fixup,
                              const MCValue &Target) override;
 
   bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
                             const MCRelaxableFragment *DF,
                             const MCAsmLayout &Layout) const override {
     return false;
   }
 
   unsigned getNumFixupKinds() const override {
     return LoongArch::NumTargetFixupKinds;
   }
 
+  Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
+
   const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override;
 
   void relaxInstruction(MCInst &Inst,
                         const MCSubtargetInfo &STI) const override {}
 
   bool writeNopData(raw_ostream &OS, uint64_t Count,
                     const MCSubtargetInfo *STI) const override;
 
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override;
 };
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_LOONGARCH_MCTARGETDESC_LOONGARCHASMBACKEND_H

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

 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/EndianStream.h"
 
 #define DEBUG_TYPE "loongarch-asmbackend"
 
 using namespace llvm;
 
+Optional<MCFixupKind> LoongArchAsmBackend::getFixupKind(StringRef Name) const {
+  if (STI.getTargetTriple().isOSBinFormatELF()) {
+    auto Type = llvm::StringSwitch<unsigned>(Name)
+#define ELF_RELOC(X, Y) .Case(#X, Y)
+#include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
+#undef ELF_RELOC
+                    .Case("BFD_RELOC_NONE", ELF::R_LARCH_NONE)
+                    .Case("BFD_RELOC_32", ELF::R_LARCH_32)
+                    .Case("BFD_RELOC_64", ELF::R_LARCH_64)
+                    .Default(-1u);
+    if (Type != -1u)
+      return static_cast<MCFixupKind>(FirstLiteralRelocationKind + Type);
+  }
+  return None;
+}
+
 const MCFixupKindInfo &
 LoongArchAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
   const static MCFixupKindInfo Infos[] = {
       // This table *must* be in the order that the fixup_* kinds are defined in
       // LoongArchFixupKinds.h.
       //
       // {name, offset, bits, flags}
       {"fixup_loongarch_b26", 0, 26, 0},
       {"fixup_loongarch_pcala_hi20", 5, 20, MCFixupKindInfo::FKF_IsPCRel},
       {"fixup_loongarch_pcala_lo12", 10, 12, MCFixupKindInfo::FKF_IsPCRel},
       // TODO: Add more fixup kinds.
   };
 
   static_assert((array_lengthof(Infos)) == LoongArch::NumTargetFixupKinds,
                 "Not all fixup kinds added to Infos array");
 
+  // Fixup kinds from .reloc directive are like R_LARCH_NONE. They
+  // do not require any extra processing.
+  if (Kind >= FirstLiteralRelocationKind)
+    return MCAsmBackend::getFixupKindInfo(FK_NONE);
+
   if (Kind < FirstTargetFixupKind)
     return MCAsmBackend::getFixupKindInfo(Kind);
 
   assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
          "Invalid kind!");
   return Infos[Kind - FirstTargetFixupKind];
 }
 
 void LoongArchAsmBackend::applyFixup(const MCAssembler &Asm,
                                      const MCFixup &Fixup,
                                      const MCValue &Target,
                                      MutableArrayRef<char> Data, uint64_t Value,
                                      bool IsResolved,
                                      const MCSubtargetInfo *STI) const {
   // TODO: Apply the Value for given Fixup into the provided data fragment.
   return;
 }
 
 bool LoongArchAsmBackend::shouldForceRelocation(const MCAssembler &Asm,
                                                 const MCFixup &Fixup,
                                                 const MCValue &Target) {
+  if (Fixup.getKind() >= FirstLiteralRelocationKind)
+    return true;
   // TODO: Determine which relocation require special processing at linking
   // time.
   return false;
 }
 
 bool LoongArchAsmBackend::writeNopData(raw_ostream &OS, uint64_t Count,
                                        const MCSubtargetInfo *STI) const {
   // Check for byte count not multiple of instruction word size

llvm/test/MC/LoongArch/Relocations/reloc-directive-err.s

+# RUN: llvm-mc --triple=loongarch64 %s |& FileCheck --check-prefix=PRINT %s
+# RUN: not llvm-mc --filetype=obj --triple=loongarch64 %s -o /dev/null |& FileCheck %s
+
+# PRINT: .reloc 0, R_INVALID, 0
+# CHECK: {{.*}}.s:[[# @LINE+1]]:11: error: unknown relocation name
+.reloc 0, R_INVALID, 0

llvm/test/MC/LoongArch/Relocations/reloc-directive.s

+# RUN: llvm-mc --triple=loongarch64 %s | FileCheck --check-prefix=PRINT %s
+# RUN: llvm-mc --filetype=obj --triple=loongarch64 %s \
+# RUN:     | llvm-readobj -r - | FileCheck %s
+
+# PRINT: .reloc 8, R_LARCH_NONE, .data
+# PRINT: .reloc 4, R_LARCH_NONE, foo+4
+# PRINT: .reloc 0, R_LARCH_NONE, 8
+# PRINT: .reloc 0, R_LARCH_32, .data+2
+# PRINT: .reloc 0, R_LARCH_TLS_DTPMOD32, foo+3
+# PRINT: .reloc 0, R_LARCH_IRELATIVE, 5
+# PRINT:      .reloc 0, BFD_RELOC_NONE, 9
+# PRINT-NEXT: .reloc 0, BFD_RELOC_32, 9
+# PRINT-NEXT: .reloc 0, BFD_RELOC_64, 9
+
+.text
+  ret
+  nop
+  nop
+  .reloc 8, R_LARCH_NONE, .data
+  .reloc 4, R_LARCH_NONE, foo+4
+  .reloc 0, R_LARCH_NONE, 8
+
+  .reloc 0, R_LARCH_32, .data+2
+  .reloc 0, R_LARCH_TLS_DTPMOD32, foo+3
+  .reloc 0, R_LARCH_IRELATIVE, 5
+
+  .reloc 0, BFD_RELOC_NONE, 9
+  .reloc 0, BFD_RELOC_32, 9
+  .reloc 0, BFD_RELOC_64, 9
+
+.data
+.globl foo
+foo:
+  .word 0
+  .word 0
+  .word 0
+
+# CHECK:      0x8 R_LARCH_NONE .data 0x0
+# CHECK-NEXT: 0x4 R_LARCH_NONE foo 0x4
+# CHECK-NEXT: 0x0 R_LARCH_NONE - 0x8
+# CHECK-NEXT: 0x0 R_LARCH_32 .data 0x2
+# CHECK-NEXT: 0x0 R_LARCH_TLS_DTPMOD32 foo 0x3
+# CHECK-NEXT: 0x0 R_LARCH_IRELATIVE - 0x5
+# CHECK-NEXT: 0x0 R_LARCH_NONE - 0x9
+# CHECK-NEXT: 0x0 R_LARCH_32 - 0x9
+# CHECK-NEXT: 0x0 R_LARCH_64 - 0x9