support for directive .reloc

[ahatanak]

Summary

The attached patch adds support for .reloc directives, which I believe hasn't been implemented yet.

https://sourceware.org/binutils/docs/as/Reloc.html#Reloc

The initial motivation for adding this support was to enable linker optimization for mips. .reloc serves as a hint to the linker to turn a function call using jalr (jump and link register) into a pc-relative bal (branch and link), if the callee is close enough to the jalr.

(before optimization)
lw $25,%call16(foo2)($28)
.reloc $L1,R_MIPS_JALR,foo2
$L1: jalr $25

(after optimization)
lw $25,%call16(foo2)($28)
bal foo2

I also made a change in ELFObjectFile.h that was necessary for mips to print the symbol against which a relocation is applied (needed this for the test case).

[joerg]

Can you update the patch to apply against trunk, please?

[mstojanovic]

I think this patch is no longer needed after rL252888 and recently rL347398 and rL348760.

include/llvm/MC/MCAsmBackend.h

   /// getNumFixupKinds - Get the number of target specific fixup kinds.
   virtual unsigned getNumFixupKinds() const = 0;
 
+  virtual unsigned getFixupKind(StringRef Reloc) const {
+    llvm_unreachable("not implemented");
+  }
+
   /// getFixupKindInfo - Get information on a fixup kind.
   virtual const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const;
 

include/llvm/MC/MCAssembler.h

   MCSymbol *End;
 };
 
+// Information about relocations generated by directive .reloc.
+struct RelocInfo {
+  RelocInfo(const MCExpr *Offset_, unsigned Kind_, const MCExpr *Value_,
+            MCSectionData *SectionData_, SMLoc Loc_)
+      : Offset(Offset_), Kind(Kind_), Value(Value_),
+        SectionData(SectionData_), Loc(Loc_) {}
+  // Offset expression.
+  const MCExpr *Offset;
+
+  // Relocation kind.
+  unsigned Kind;
+
+  // Value expression.
+  const MCExpr *Value;
+
+  // Section in which this .reloc appeared.
+  MCSectionData *SectionData;
+
+  SMLoc Loc;
+};
+
 class MCAssembler {
   friend class MCAsmLayout;
 

 
   iplist<MCSymbolData> Symbols;
 
+  /// List of .reloc directives.
+  SmallVector<RelocInfo, 4> Relocs;
+
   /// The map of sections to their associated assembler backend data.
   //
   // FIXME: Avoid this indirection?

   uint64_t handleFixup(const MCAsmLayout &Layout,
                        MCFragment &F, const MCFixup &Fixup);
 
+  /// Return the fragment to which RI's relocation is applied and the offset
+  /// relative to the beginning of the fragment.
+  std::pair<MCEncodedFragmentWithFixups *, uint32_t>
+  getFragmentAndOffset(const RelocInfo &RI);
+
 public:
   /// Compute the effective fragment size assuming it is laid out at the given
   /// \p SectionAddress and \p FragmentOffset.

     BundleAlignSize = Size;
   }
 
+  SmallVectorImpl<RelocInfo> &getRelocList() { return Relocs; }
+
   /// @name Section List Access
   /// @{
 

include/llvm/MC/MCObjectStreamer.h

                              const MCExpr *Subsection);
   virtual void EmitInstruction(const MCInst &Inst);
 
+  virtual void EmitReloc(const MCExpr *Offset, StringRef Reloc,
+                         const MCExpr *Expression, SMLoc Loc);
+
   /// \brief Emit an instruction to a special fragment, because this instruction
   /// can change its size during relaxation.
   virtual void EmitInstToFragment(const MCInst &Inst);

include/llvm/MC/MCStreamer.h

   /// a Thumb mode function (ARM target only).
   virtual void EmitThumbFunc(MCSymbol *Func) = 0;
 
+  // Emit .reloc directive.
+  virtual void EmitReloc(const MCExpr *Offset, StringRef Reloc,
+                         const MCExpr *Expression, SMLoc Loc) {
+    llvm_unreachable("not implemented");
+  }
+
   /// getOrCreateSymbolData - Get symbol data for given symbol.
   virtual MCSymbolData &getOrCreateSymbolData(MCSymbol *Symbol);
 

include/llvm/Object/ELFObjectFile.h

   }
   case ELF::EM_ARM:
   case ELF::EM_HEXAGON:
+  case ELF::EM_MIPS:
     res = *SymName;
     break;
   default:

lib/MC/MCAsmStreamer.cpp

   virtual void EmitLinkerOptions(ArrayRef<std::string> Options);
   virtual void EmitDataRegion(MCDataRegionType Kind);
   virtual void EmitThumbFunc(MCSymbol *Func);
+  virtual void EmitReloc(const MCExpr *Offset, StringRef Reloc,
+                         const MCExpr *Expression, SMLoc Loc);
 
   virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
   virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);

   EmitEOL();
 }
 
+void MCAsmStreamer::EmitReloc(const MCExpr *Offset, StringRef Reloc,
+                              const MCExpr *Expression, SMLoc Loc) {
+  OS << "\t.reloc\t" << *Offset << ", " << Reloc << ", " << *Expression << "\n";
+}
+
 void MCAsmStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
   OS << *Symbol << " = " << *Value;
   EmitEOL();

lib/MC/MCAssembler.cpp

   // example, to set the index fields in the symbol data).
   getWriter().ExecutePostLayoutBinding(*this, Layout);
 
+  // Add fixups generated by directive ".reloc".
+  for (SmallVectorImpl<RelocInfo>::const_iterator I = Relocs.begin(),
+       E = Relocs.end(); I != E; ++I) {
+    std::pair<MCEncodedFragmentWithFixups *, uint32_t> P =
+        getFragmentAndOffset(*I);
+    MCFixup Fixup = MCFixup::Create(P.second, I->Value, (MCFixupKind)I->Kind);
+    P.first->getFixups().push_back(Fixup);
+  }
+
   // Evaluate and apply the fixups, generating relocation entries as necessary.
   for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) {
     for (MCSectionData::iterator it2 = it->begin(),

   stats::ObjectBytes += OS.tell() - StartOffset;
 }
 
+std::pair<MCEncodedFragmentWithFixups *, uint32_t>
+MCAssembler::getFragmentAndOffset(const RelocInfo &RI) {
+  MCValue OffsetVal;
+  MCAsmLayout Layout(*this);
+
+  if (!RI.Offset->EvaluateAsRelocatable(OffsetVal, Layout))
+    getContext().FatalError(RI.Loc, "unable to evaluate offset");
+
+  MCSectionData *SD;
+  int64_t Offset = OffsetVal.getConstant();
+
+  if (OffsetVal.isAbsolute()) {
+    // If offset evaluates to an absolute, relocation is generated in the
+    // section in which the .reloc directive appeared.
+    assert(RI.SectionData);
+    SD = RI.SectionData;
+  } else {
+    // If offset evaluates to symbol+offset, relocation is generated in the
+    // given symbol's section.
+    MCSymbolData *SymData = &getSymbolData(OffsetVal.getSymA()->getSymbol());
+    Offset += Layout.getSymbolOffset(SymData);
+    SD = SymData->getFragment()->getParent();
+  }
+
+  if (Offset < 0)
+    getContext().FatalError(RI.Loc, "offset of .reloc cannot be negative");
+
+  MCEncodedFragmentWithFixups *F = 0;
+  uint64_t FragOffset;
+
+  // Find the fragment to which the relocation is applied.
+  for (MCSectionData::iterator I = SD->begin(), E = SD->end(); I != E; ++I) {
+    FragOffset = Layout.getFragmentOffset(&*I);
+
+    if (FragOffset <= (uint64_t)Offset &&
+        FragOffset + computeFragmentSize(Layout, *I) > (uint64_t)Offset) {
+      F = dyn_cast<MCEncodedFragmentWithFixups>(&*I);
+      break;
+    }
+  }
+
+  if (!F)
+    getContext().FatalError(RI.Loc, "cannot find a fragment to which this "
+                                    "relocation can be applied");
+
+  return std::make_pair(F, Offset - FragOffset);
+}
+
 bool MCAssembler::fixupNeedsRelaxation(const MCFixup &Fixup,
                                        const MCRelaxableFragment *DF,
                                        const MCAsmLayout &Layout) const {

lib/MC/MCObjectStreamer.cpp

   EmitInstToFragment(Inst);
 }
 
+void MCObjectStreamer::EmitReloc(const MCExpr *Offset, StringRef Reloc,
+                                 const MCExpr *Expression, SMLoc Loc) {
+  unsigned Kind = getAssembler().getBackend().getFixupKind(Reloc);
+  RelocInfo R(Offset, Kind, Expression, getCurrentSectionData(), Loc);
+  getAssembler().getRelocList().push_back(R);
+}
+
 void MCObjectStreamer::EmitInstToFragment(const MCInst &Inst) {
   // Always create a new, separate fragment here, because its size can change
   // during relaxation.

lib/MC/MCParser/AsmParser.cpp

     DK_INCLUDE, DK_INCBIN, DK_CODE16, DK_CODE16GCC, DK_REPT, DK_IRP, DK_IRPC,
     DK_IF, DK_IFB, DK_IFNB, DK_IFC, DK_IFNC, DK_IFDEF, DK_IFNDEF, DK_IFNOTDEF,
     DK_ELSEIF, DK_ELSE, DK_ENDIF,
-    DK_SPACE, DK_SKIP, DK_FILE, DK_LINE, DK_LOC, DK_STABS,
+    DK_SPACE, DK_SKIP, DK_FILE, DK_LINE, DK_LOC, DK_STABS, DK_RELOC,
     DK_CFI_SECTIONS, DK_CFI_STARTPROC, DK_CFI_ENDPROC, DK_CFI_DEF_CFA,
     DK_CFI_DEF_CFA_OFFSET, DK_CFI_ADJUST_CFA_OFFSET, DK_CFI_DEF_CFA_REGISTER,
     DK_CFI_OFFSET, DK_CFI_REL_OFFSET, DK_CFI_PERSONALITY, DK_CFI_LSDA,

   bool parseDirectiveLoc();
   bool parseDirectiveStabs();
 
+  // ".reloc"
+  bool parseDirectiveReloc();
+
   // .cfi directives
   bool parseDirectiveCFIRegister(SMLoc DirectiveLoc);
   bool parseDirectiveCFIWindowSave();

       return parseDirectiveLoc();
     case DK_STABS:
       return parseDirectiveStabs();
+    case DK_RELOC:
+      return parseDirectiveReloc();
     case DK_CFI_SECTIONS:
       return parseDirectiveCFISections();
     case DK_CFI_STARTPROC:

   return TokError("unsupported directive '.stabs'");
 }
 
+/// parseDirectiveReloc
+/// ::= .reloc expression, string, expression
+bool AsmParser::parseDirectiveReloc() {
+  const MCExpr *Offset, *Value;
+  StringRef RelocStr;
+
+  if (parseExpression(Offset))
+    return true;
+
+  if (getLexer().isNot(AsmToken::Comma))
+    return TokError("unexpected token in reloc directive");
+
+  Lex();
+
+  if (parseIdentifier(RelocStr))
+    return true;
+
+  if (getLexer().isNot(AsmToken::Comma))
+    return TokError("unexpected token in reloc directive");
+
+  Lex();
+
+  if (parseExpression(Value))
+    return true;
+
+  getStreamer().EmitReloc(Offset, RelocStr, Value, getLexer().getLoc());
+  return false;
+}
+
 /// parseDirectiveCFISections
 /// ::= .cfi_sections section [, section]
 bool AsmParser::parseDirectiveCFISections() {

   DirectiveKindMap[".line"] = DK_LINE;
   DirectiveKindMap[".loc"] = DK_LOC;
   DirectiveKindMap[".stabs"] = DK_STABS;
+  DirectiveKindMap[".reloc"] = DK_RELOC;
   DirectiveKindMap[".sleb128"] = DK_SLEB128;
   DirectiveKindMap[".uleb128"] = DK_ULEB128;
   DirectiveKindMap[".cfi_sections"] = DK_CFI_SECTIONS;

lib/Target/Mips/MCTargetDesc/MipsAsmBackend.cpp

 
 #include "MipsFixupKinds.h"
 #include "MCTargetDesc/MipsMCTargetDesc.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCDirectives.h"

       { "fixup_Mips_GOT_LO16",     0,     16,   0 },
       { "fixup_Mips_CALL_HI16",    0,     16,   0 },
       { "fixup_Mips_CALL_LO16",    0,     16,   0 },
+      { "fixup_Mips_JALR",         0,     16,   0 },
       { "fixup_MICROMIPS_26_S1",   0,     26,   0 },
       { "fixup_MICROMIPS_HI16",    0,     16,   0 },
       { "fixup_MICROMIPS_LO16",    0,     16,   0 },

     return Infos[Kind - FirstTargetFixupKind];
   }
 
+  unsigned getFixupKind(StringRef Reloc) const {
+    Mips::Fixups Kind = StringSwitch<Mips::Fixups>(Reloc)
+      .Case("R_MIPS_JALR", Mips::fixup_Mips_JALR)
+      .Default(Mips::LastTargetFixupKind);
+
+    assert(Kind != Mips::LastTargetFixupKind && "Unknown relocation.");
+
+    return Kind;
+  }
+
   /// @name Target Relaxation Interfaces
   /// @{
 

lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

   assert(Target.getSymA() && "SymA cannot be 0.");
   const MCSymbol &Sym = Target.getSymA()->getSymbol().AliasedSymbol();
 
+  if ((llvm::Mips::Fixups)Fixup.getKind() == Mips::fixup_Mips_JALR)
+    return &Sym;
+
   if (Sym.getSection().getKind().isMergeableCString() ||
       Sym.getSection().getKind().isMergeableConst())
     return &Sym;

   case Mips::fixup_Mips_CALL_LO16:
     Type = ELF::R_MIPS_CALL_LO16;
     break;
+  case Mips::fixup_Mips_JALR:
+    Type = ELF::R_MIPS_JALR;
+    break;
   case Mips::fixup_MICROMIPS_26_S1:
     Type = ELF::R_MICROMIPS_26_S1;
     break;

lib/Target/Mips/MCTargetDesc/MipsFixupKinds.h

     // resulting in - R_MIPS_CALL_LO16
     fixup_Mips_CALL_LO16,
 
+    // resulting in - R_MIPS_JALR
+    fixup_Mips_JALR,
+
     // resulting in - R_MICROMIPS_26_S1
     fixup_MICROMIPS_26_S1,
 

test/MC/Mips/reloc.s

+// RUN: llvm-mc -filetype=obj %s -o %t.o -arch=mips
+// RUN: llvm-objdump -r %t.o | FileCheck %s
+
+// CHECK:  RELOCATION RECORDS FOR [.rel.text]:
+// CHECK: 0  R_MIPS_JALR s2
+// CHECK: 4  R_MIPS_JALR s0
+// CHECK: 8  R_MIPS_JALR s5
+// CHECK: 12 R_MIPS_JALR s1
+
+// CHECK: RELOCATION RECORDS FOR [.rel.data]:
+// CHECK: 4  R_MIPS_JALR s8
+// CHECK: 12 R_MIPS_JALR s3
+// CHECK: 18 R_MIPS_JALR s4
+// CHECK: 20 R_MIPS_JALR s7
+
+.text
+.reloc 4, R_MIPS_JALR, s0
+.reloc s1+4, R_MIPS_JALR, s7
+.reloc 0, R_MIPS_JALR, s2
+.reloc s5-4, R_MIPS_JALR, s1
+s4:
+ .long 0,0,0,0
+s5:
+ .long 0,0,0,0
+s6:
+ .long 0,0,0,0
+s7:
+ .long 0,0,0,0
+s8:
+ .long 0,0,0,0
+
+.data
+.reloc 4, R_MIPS_JALR, s8
+.reloc s0+18, R_MIPS_JALR, s4
+.reloc s1-4, R_MIPS_JALR, s3
+.reloc s4+8, R_MIPS_JALR, s5
+s0:
+ .long 0,0,0,0
+s1:
+ .long 0,0,0,0
+s2:
+ .long 0,0,0,0
+ .long 0,0,0,0
+s3:
+ .long 0,0,0,0
+