Implement .reloc (constant offset only) with support for R_MIPS_NONE and R_MIPS_32.

[dsanders]

Summary

Support for R_MIPS_NONE allows us to parse MIPS16's usage of .reloc.
R_MIPS_32 was included to be able to better test the directive.

Targets can add their relocations by overriding MCAsmBackend::getFixupKind().

[dsanders]

ping

[majnemer]

include/llvm/MC/MCObjectStreamer.h

127–128

Will there be any direct calls of this? If not, I'd just drop the default argument.

include/llvm/MC/MCStreamer.h

692

Shouldn't this return true because nothing was emitted?

lib/MC/MCAsmStreamer.cpp

242–243

Will there be any direct calls of this? If not, I'd just drop the default argument.

lib/MC/MCParser/AsmParser.cpp

4611–4614

Not all targets support an addend, this should be predicated on a hook.

[dsanders]

Thanks

include/llvm/MC/MCObjectStreamer.h

127–128

Probably not, I'll drop the default part. MIPS16 might use it at some point in the future but I can always bring it back later if it's required.

include/llvm/MC/MCStreamer.h

692

I think false makes the most sense. Returning true would cause all targets to silently accept and ignore any relocation name. By returning false, we emit an error message about the unknown/unsupported name.

lib/MC/MCParser/AsmParser.cpp

4611–4614

This isn't the addend, it's the section offset the relocation is applied to. I believe you're thinking of the expression that's parsed on line 4547. If that's the case, I agree. I'll also make that expression optional like it should be.

[majnemer]

include/llvm/MC/MCStreamer.h

692

Your comment says:

Returns true if the relocation could not be emitted because Name is not known.

All relocations cannot be emitted by this implementation because Name will never be known, hence the function should return true.

If you'd be happier with it returning false, that's fine but please change the comment to be consistent. Also, this case needs a test.

[dsanders]

include/llvm/MC/MCStreamer.h

692

That'll teach me to use true to indicate failure. Sorry, you're absolutely right that I'm returning success instead of failure in this implementation. I'll fix this.

[dsanders]

Fix all review comments except for the addend hook which I'm still thinking
about:

• Loc argument no longer optional.
• Fixed accidental success/fail inversion in MCStreamer::EmitRelocDirective. I've retained true==failure despite my misgivings about it since it's consistent with the other Emit*() functions.
• .reloc expression is now optional.

[dsanders]

lib/MC/MCParser/AsmParser.cpp

4611–4614

Do you know any cases where the addend isn't supported? The GAS documentation says that ELF REL targets such as 386 don't support addends but I'm finding they work. Similarly, addends are also working for MIPS O32 which is also a REL target.

[majnemer]

What happens when you do:

.text
.long .text+2
.reloc 0, R_MIPS_32, .text+3

lib/MC/MCParser/AsmParser.cpp

368

It'd be nicer if this could be closer to DK_VALUE. I'd just leave it on it's own line.

488–489

Could this be moved near the handler for .value ?

4611–4614

NT targets use REL relocations and they work with mingw assemblers. Perhaps the comment is out of date.

lib/Target/Mips/MCTargetDesc/MipsFixupKinds.h

27

Would it be more consistent to name this fixup_Mips_NONE ?

[dsanders]

In D13659#276919, @majnemer wrote:

What happens when you do:

.text
.long .text+2
.reloc 0, R_MIPS_32, .text+3

I get:

Disassembly of section .text:

00000000 <.text>:
   0:	00000005 	lsa	zero,zero,zero,0x1
			0: R_MIPS_32	.text
			0: R_MIPS_32	.text
	...

The two addends are summed and stored in the section while two R_MIPS_32 relocs for .text are emitted.

lib/MC/MCParser/AsmParser.cpp

368

Ok

488–489

Ok

4611–4614

Seems like it. Shall we leave this patch as always accepting addends and follow-up later if we find a case that doesn't work?

lib/Target/Mips/MCTargetDesc/MipsFixupKinds.h

27

I agree. There's a couple inconsistencies below but there's no need to add more

[majnemer]

lib/MC/MCObjectStreamer.cpp

447–448

I don't believe you have a test case which exercises this case. I'm a little confused as to why we need to create a symbol here. GNU as doesn't seem to do this:

$ cat t.s
.text
.long 0
.reloc .text, R_X86_64_32
$ as t.s -o t.o
$ objdump -r t.o
t.o:     file format elf64-x86-64

RELOCATION RECORDS FOR [.text]:
OFFSET           TYPE              VALUE                                                                                                                                                   
0000000000000000 R_X86_64_32       *ABS*

lib/MC/MCParser/AsmParser.cpp

4603

It might be nice to have a comment here describing the syntax using pseudo-EBNF. We do this for some directives like parseDirectiveRept and it makes it a little easier to see the "big idea".

4628–4629

I think we should evaluateAsRelocatable the Expr to sanity check the expression. Stuff like .text + .text should fail with a nice message.

[dsanders]

lib/MC/MCObjectStreamer.cpp

447–448

It's the:

.reloc 12, R_MIPS_NONE # ASM: .reloc 12, R_MIPS_NONE{{$}}

The temporary symbol arose from experimentation. Leaving Expr as nullptr leads to a crash and using '0' causes the reloc to be omitted in the output. Using a temporary symbol like this causes both 'objdump -dr' and 'llvm-readobj -sections -section-data -r'* output to match between the integrated assembler and gas.

*llvm-readobj does show differences compared to gas but they aren't related to the reloc or the text section.

lib/MC/MCParser/AsmParser.cpp

4603

I noticed this when I moved the implementation near parseDirectiveValue. I've already added one in my working copy.

4628–4629

Ok, that makes sense.

[dsanders]

Moved .reloc related things near to .value related things.
s/fixup_Mips_None/fixup_Mips_NONE/g
Check that the expression is relocatable.

[majnemer]

Thanks for quickly working through the feedback :)

This LGTM but I'd be more comfortable with somebody else concurring, perhaps @grosbach or @rafael.

lib/MC/MCObjectStreamer.cpp

446

You could reduce indentation by returning true if getFixupKind fails.

[dsanders]

I committed this in r252888 since I have an LGTM from David and there have been no further comments in the last two weeks.

lib/MC/MCObjectStreamer.cpp

446

I made this change in the commit.

[dsanders]

@majnemer: Nearly forgot to say: Thanks for the reviews.

include/llvm/MC/MCAsmBackend.h

public:
   bool hasDataInCodeSupport() const { return HasDataInCodeSupport; }
 
   /// \name Target Fixup Interfaces
   /// @{
 
   /// Get the number of target specific fixup kinds.
   virtual unsigned getNumFixupKinds() const = 0;
 
+  /// Map a relocation name used in .reloc to a fixup kind.
+  /// Returns true and sets MappedKind if Name is successfully mapped.
+  /// Otherwise returns false and leaves MappedKind unchanged.
+  virtual bool getFixupKind(StringRef Name, MCFixupKind &MappedKind) const;
+
   /// Get information on a fixup kind.
   virtual const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const;
 
   /// Target hook to adjust the literal value of a fixup if necessary.
   /// IsResolved signals whether the caller believes a relocation is needed; the
   /// target can modify the value. The default does nothing.
   virtual void processFixupValue(const MCAssembler &Asm,
                                  const MCAsmLayout &Layout,

include/llvm/MC/MCObjectStreamer.h

void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                              StringRef FileName) override;
   void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
                                 const MCSymbol *Label,
                                 unsigned PointerSize);
   void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
                                  const MCSymbol *Label);
   void EmitGPRel32Value(const MCExpr *Value) override;
   void EmitGPRel64Value(const MCExpr *Value) override;
+  bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
+                          const MCExpr *Expr, SMLoc Loc) override;
   void EmitFill(uint64_t NumBytes, uint8_t FillValue) override;
   void EmitZeros(uint64_t NumBytes) override;
   void FinishImpl() override;
 
   /// Emit the absolute difference between two symbols if possible.
   ///
   /// Emit the absolute difference between \c Hi and \c Lo, as long as we can
   /// compute it.  Currently, that requires that both symbols are in the same

include/llvm/MC/MCStreamer.h

public:
   virtual void EmitWinCFIPushFrame(bool Code);
   virtual void EmitWinCFIEndProlog();
 
   virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except);
   virtual void EmitWinEHHandlerData();
 
   virtual void EmitSyntaxDirective();
 
+  /// \brief Emit a .reloc directive.
+  /// Returns true if the relocation could not be emitted because Name is not
+  /// known.
+  virtual bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
+                                  const MCExpr *Expr, SMLoc Loc) {
+    return true;
+  }
+
   /// \brief Emit the given \p Instruction into the current section.
   virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 
   /// \brief Set the bundle alignment mode from now on in the section.
   /// The argument is the power of 2 to which the alignment is set. The
   /// value 0 means turn the bundle alignment off.
   virtual void EmitBundleAlignMode(unsigned AlignPow2);
 

lib/MC/MCAsmBackend.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 using namespace llvm;
 
 MCAsmBackend::MCAsmBackend() : HasDataInCodeSupport(false) {}
 
 MCAsmBackend::~MCAsmBackend() {}
 
+bool MCAsmBackend::getFixupKind(StringRef Name, MCFixupKind &MappedKind) const {
+  return false;
+}
+
 const MCFixupKindInfo &MCAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
   static const MCFixupKindInfo Builtins[] = {
       {"FK_Data_1", 0, 8, 0},
       {"FK_Data_2", 0, 16, 0},
       {"FK_Data_4", 0, 32, 0},
       {"FK_Data_8", 0, 64, 0},
       {"FK_PCRel_1", 0, 8, MCFixupKindInfo::FKF_IsPCRel},
       {"FK_PCRel_2", 0, 16, MCFixupKindInfo::FKF_IsPCRel},

lib/MC/MCAsmStreamer.cpp

public:
   void EmitWinEHHandlerData() override;
 
   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
   void EmitBundleAlignMode(unsigned AlignPow2) override;
   void EmitBundleLock(bool AlignToEnd) override;
   void EmitBundleUnlock() override;
 
+  bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
+                          const MCExpr *Expr, SMLoc Loc) override;
+
   /// EmitRawText - If this file is backed by an assembly streamer, this dumps
   /// the specified string in the output .s file.  This capability is
   /// indicated by the hasRawTextSupport() predicate.
   void EmitRawTextImpl(StringRef String) override;
 
   void FinishImpl() override;
 };
 
void MCAsmStreamer::EmitBundleLock(bool AlignToEnd) {
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitBundleUnlock() {
   OS << "\t.bundle_unlock";
   EmitEOL();
 }
 
+bool MCAsmStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
+                                       const MCExpr *Expr, SMLoc) {
+  OS << "\t.reloc ";
+  Offset.print(OS, MAI);
+  OS << ", " << Name;
+  if (Expr) {
+    OS << ", ";
+    Expr->print(OS, MAI);
+  }
+  EmitEOL();
+  return false;
+}
+
 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
 /// the specified string in the output .s file.  This capability is
 /// indicated by the hasRawTextSupport() predicate.
 void MCAsmStreamer::EmitRawTextImpl(StringRef String) {
   if (!String.empty() && String.back() == '\n')
     String = String.substr(0, String.size()-1);
   OS << String;
   EmitEOL();

lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::EmitGPRel64Value(const MCExpr *Value) {
   MCDataFragment *DF = getOrCreateDataFragment();
   flushPendingLabels(DF, DF->getContents().size());
 
   DF->getFixups().push_back(MCFixup::create(DF->getContents().size(), 
                                             Value, FK_GPRel_4));
   DF->getContents().resize(DF->getContents().size() + 8, 0);
 }
 
+bool MCObjectStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
+                                          const MCExpr *Expr, SMLoc Loc) {
+  int64_t OffsetValue;
+  if (!Offset.evaluateAsAbsolute(OffsetValue))
+    llvm_unreachable("Offset is not absolute");
+
+  MCDataFragment *DF = getOrCreateDataFragment();
+  flushPendingLabels(DF, DF->getContents().size());
+
+  MCFixupKind Kind;
+  if (Assembler->getBackend().getFixupKind(Name, Kind)) {
+    if (Expr == nullptr)
+      Expr = MCSymbolRefExpr::create(getContext().createTempSymbol(), getContext());
+    DF->getFixups().push_back(MCFixup::create(OffsetValue, Expr, Kind, Loc));
+    return false;
+  }
+  return true;
+}
+
 void MCObjectStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
   // FIXME: A MCFillFragment would be more memory efficient but MCExpr has
   //        problems evaluating expressions across multiple fragments.
   MCDataFragment *DF = getOrCreateDataFragment();
   flushPendingLabels(DF, DF->getContents().size());
   DF->getContents().append(NumBytes, FillValue);
 }
 

lib/MC/MCParser/AsmParser.cpp

enum DirectiveKind {
     DK_CFI_OFFSET, DK_CFI_REL_OFFSET, DK_CFI_PERSONALITY, DK_CFI_LSDA,
     DK_CFI_REMEMBER_STATE, DK_CFI_RESTORE_STATE, DK_CFI_SAME_VALUE,
     DK_CFI_RESTORE, DK_CFI_ESCAPE, DK_CFI_SIGNAL_FRAME, DK_CFI_UNDEFINED,
     DK_CFI_REGISTER, DK_CFI_WINDOW_SAVE,
     DK_MACROS_ON, DK_MACROS_OFF,
     DK_MACRO, DK_EXITM, DK_ENDM, DK_ENDMACRO, DK_PURGEM,
     DK_SLEB128, DK_ULEB128,
     DK_ERR, DK_ERROR, DK_WARNING,
-    DK_END
+    DK_END, DK_RELOC
   };
 
   /// \brief Maps directive name --> DirectiveKind enum, for
   /// directives parsed by this class.
   StringMap<DirectiveKind> DirectiveKindMap;
 
   // ".ascii", ".asciz", ".string"
   bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
private:
   bool parseDirectiveEnd(SMLoc DirectiveLoc);
 
   // ".err" or ".error"
   bool parseDirectiveError(SMLoc DirectiveLoc, bool WithMessage);
 
   // ".warning"
   bool parseDirectiveWarning(SMLoc DirectiveLoc);
 
+  // ".reloc"
+  bool parseDirectiveReloc(SMLoc DirectiveLoc);
+
   void initializeDirectiveKindMap();
 };
 }
 
 namespace llvm {
 
 extern MCAsmParserExtension *createDarwinAsmParser();
 extern MCAsmParserExtension *createELFAsmParser();
if (IDVal[0] == '.' && IDVal != ".") {
     case DK_END:
       return parseDirectiveEnd(IDLoc);
     case DK_ERR:
       return parseDirectiveError(IDLoc, false);
     case DK_ERROR:
       return parseDirectiveError(IDLoc, true);
     case DK_WARNING:
       return parseDirectiveWarning(IDLoc);
+    case DK_RELOC:
+      return parseDirectiveReloc(IDLoc);
     }
 
     return Error(IDLoc, "unknown directive");
   }
 
   // __asm _emit or __asm __emit
   if (ParsingInlineAsm && (IDVal == "_emit" || IDVal == "__emit" ||
                            IDVal == "_EMIT" || IDVal == "__EMIT"))
void AsmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".macro"] = DK_MACRO;
   DirectiveKindMap[".exitm"] = DK_EXITM;
   DirectiveKindMap[".endm"] = DK_ENDM;
   DirectiveKindMap[".endmacro"] = DK_ENDMACRO;
   DirectiveKindMap[".purgem"] = DK_PURGEM;
   DirectiveKindMap[".err"] = DK_ERR;
   DirectiveKindMap[".error"] = DK_ERROR;
   DirectiveKindMap[".warning"] = DK_WARNING;
+  DirectiveKindMap[".reloc"] = DK_RELOC;
 }
 
 MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   AsmToken EndToken, StartToken = getTok();
 
   unsigned NestLevel = 0;
   for (;;) {
     // Check whether we have reached the end of the file.
bool AsmParser::parseDirectiveMSAlign(SMLoc IDLoc, ParseStatementInfo &Info) {
   uint64_t IntValue = MCE->getValue();
   if (!isPowerOf2_64(IntValue))
     return Error(ExprLoc, "literal value not a power of two greater then zero");
 
   Info.AsmRewrites->emplace_back(AOK_Align, IDLoc, 5, Log2_64(IntValue));
   return false;
 }
 
+bool AsmParser::parseDirectiveReloc(SMLoc DirectiveLoc) {
+  const MCExpr *Offset;
+  const MCExpr *Expr = nullptr;
+
+  SMLoc OffsetLoc = Lexer.getTok().getLoc();
+  if (parseExpression(Offset))
+    return true;
+
+  // We can only deal with constant expressions at the moment.
+  int64_t OffsetValue;
+  if (!Offset->evaluateAsAbsolute(OffsetValue))
+    return Error(OffsetLoc, "expression is not a constant value");
+
+  if (Lexer.isNot(AsmToken::Comma))
+    return TokError("expected comma");
+  Lexer.Lex();
+
+  if (Lexer.isNot(AsmToken::Identifier))
+    return TokError("expected relocation name");
+  SMLoc NameLoc = Lexer.getTok().getLoc();
+  StringRef Name = Lexer.getTok().getIdentifier();
+  Lexer.Lex();
+
+  if (Lexer.is(AsmToken::Comma)) {
+    Lexer.Lex();
+    if (parseExpression(Expr))
+      return true;
+  }
+
+  if (Lexer.isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in .reloc directive");
+
+  if (getStreamer().EmitRelocDirective(*Offset, Name, Expr, DirectiveLoc))
+    return Error(NameLoc, "unknown relocation name");
+
+  return false;
+}
+
 // We are comparing pointers, but the pointers are relative to a single string.
 // Thus, this should always be deterministic.
 static int rewritesSort(const AsmRewrite *AsmRewriteA,
                         const AsmRewrite *AsmRewriteB) {
   if (AsmRewriteA->Loc.getPointer() < AsmRewriteB->Loc.getPointer())
     return -1;
   if (AsmRewriteB->Loc.getPointer() < AsmRewriteA->Loc.getPointer())
     return 1;

lib/Target/Mips/MCTargetDesc/MipsAsmBackend.h

MipsAsmBackend(const Target &T, Triple::OSType OSType, bool IsLittle,
                  bool Is64Bit)
       : MCAsmBackend(), OSType(OSType), IsLittle(IsLittle), Is64Bit(Is64Bit) {}
 
   MCObjectWriter *createObjectWriter(raw_pwrite_stream &OS) const override;
 
   void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
                   uint64_t Value, bool IsPCRel) const override;
 
+  bool getFixupKind(StringRef Name, MCFixupKind &MappedKind) const override;
   const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override;
 
   unsigned getNumFixupKinds() const override {
     return Mips::NumTargetFixupKinds;
   }
 
   /// @name Target Relaxation Interfaces
   /// @{

lib/Target/Mips/MCTargetDesc/MipsAsmBackend.cpp

void MipsAsmBackend::applyFixup(const MCFixup &Fixup, char *Data,
   for (unsigned i = 0; i != NumBytes; ++i) {
     unsigned Idx = IsLittle ? (microMipsLEByteOrder ? calculateMMLEIndex(i)
                                                     : i)
                             : (FullSize - 1 - i);
     Data[Offset + Idx] = (uint8_t)((CurVal >> (i*8)) & 0xff);
   }
 }
 
+bool MipsAsmBackend::getFixupKind(StringRef Name, MCFixupKind &MappedKind) const {
+  if (Name == "R_MIPS_NONE") {
+    MappedKind = (MCFixupKind)Mips::fixup_Mips_None;
+    return true;
+  }
+  if (Name == "R_MIPS_32") {
+    MappedKind = FK_Data_4;
+    return true;
+  }
+  return MCAsmBackend::getFixupKind(Name, MappedKind);
+}
+
 const MCFixupKindInfo &MipsAsmBackend::
 getFixupKindInfo(MCFixupKind Kind) const {
   const static MCFixupKindInfo LittleEndianInfos[Mips::NumTargetFixupKinds] = {
     // This table *must* be in same the order of fixup_* kinds in
     // MipsFixupKinds.h.
     //
     // name                    offset  bits  flags
+    { "fixup_Mips_None",         0,      0,   0 },
     { "fixup_Mips_16",           0,     16,   0 },
     { "fixup_Mips_32",           0,     32,   0 },
     { "fixup_Mips_REL32",        0,     32,   0 },
     { "fixup_Mips_26",           0,     26,   0 },
     { "fixup_Mips_HI16",         0,     16,   0 },
     { "fixup_Mips_LO16",         0,     16,   0 },
     { "fixup_Mips_GPREL16",      0,     16,   0 },
     { "fixup_Mips_LITERAL",      0,     16,   0 },
const static MCFixupKindInfo LittleEndianInfos[Mips::NumTargetFixupKinds] = {
     { "fixup_MICROMIPS_TLS_TPREL_LO16",  0,     16,   0 }
   };
 
   const static MCFixupKindInfo BigEndianInfos[Mips::NumTargetFixupKinds] = {
     // This table *must* be in same the order of fixup_* kinds in
     // MipsFixupKinds.h.
     //
     // name                    offset  bits  flags
+    { "fixup_Mips_None",         0,      0,   0 },
     { "fixup_Mips_16",          16,     16,   0 },
     { "fixup_Mips_32",           0,     32,   0 },
     { "fixup_Mips_REL32",        0,     32,   0 },
     { "fixup_Mips_26",           6,     26,   0 },
     { "fixup_Mips_HI16",        16,     16,   0 },
     { "fixup_Mips_LO16",        16,     16,   0 },
     { "fixup_Mips_GPREL16",     16,     16,   0 },
     { "fixup_Mips_LITERAL",     16,     16,   0 },

lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

 
 unsigned MipsELFObjectWriter::GetRelocType(const MCValue &Target,
                                            const MCFixup &Fixup,
                                            bool IsPCRel) const {
   // Determine the type of the relocation.
   unsigned Kind = (unsigned)Fixup.getKind();
 
   switch (Kind) {
+  case Mips::fixup_Mips_None:
+    return ELF::R_MIPS_NONE;
   case Mips::fixup_Mips_16:
   case FK_Data_2:
     return IsPCRel ? ELF::R_MIPS_PC16 : ELF::R_MIPS_16;
   case Mips::fixup_Mips_32:
   case FK_Data_4:
     return IsPCRel ? ELF::R_MIPS_PC32 : ELF::R_MIPS_32;
   }
 

lib/Target/Mips/MCTargetDesc/MipsFixupKinds.h

namespace Mips {
   // one can have multiple fixup types for a given relocation and thus need
   // to be uniquely named.
   //
   // This table *must* be in the same order of
   // MCFixupKindInfo Infos[Mips::NumTargetFixupKinds]
   // in MipsAsmBackend.cpp.
   //
   enum Fixups {
+    // Branch fixups resulting in R_MIPS_NONE.
+    fixup_Mips_None = FirstTargetFixupKind,
+
     // Branch fixups resulting in R_MIPS_16.
-    fixup_Mips_16 = FirstTargetFixupKind,
+    fixup_Mips_16,
 
     // Pure 32 bit data fixup resulting in - R_MIPS_32.
     fixup_Mips_32,
 
     // Full 32 bit data relative data fixup resulting in - R_MIPS_REL32.
     fixup_Mips_REL32,
 
     // Jump 26 bit fixup resulting in - R_MIPS_26.

test/MC/Mips/reloc-directive.s

+# RUN: llvm-mc -triple mips-unknown-linux < %s -show-encoding -target-abi=o32 \
+# RUN:     | FileCheck -check-prefix=ASM %s
+# RUN: llvm-mc -triple mips64-unknown-linux < %s -show-encoding -target-abi=n32 \
+# RUN:     | FileCheck -check-prefix=ASM %s
+# RUN: llvm-mc -triple mips64-unknown-linux < %s -show-encoding -target-abi=n64 \
+# RUN:     | FileCheck -check-prefix=ASM %s
+# RUN: llvm-mc -triple mips-unknown-linux < %s -show-encoding -target-abi=o32 \
+# RUN:     -filetype=obj | llvm-readobj -sections -section-data -r | \
+# RUN:     FileCheck -check-prefix=OBJ-O32 %s
+# RUN: llvm-mc -triple mips64-unknown-linux < %s -show-encoding -target-abi=n32 \
+# RUN:     -filetype=obj | llvm-readobj -sections -section-data -r | \
+# RUN:     FileCheck -check-prefix=OBJ-N32 %s
+# RUN: llvm-mc -triple mips64-unknown-linux < %s -show-encoding -target-abi=n64 \
+# RUN:     -filetype=obj | llvm-readobj -sections -section-data -r | \
+# RUN:     FileCheck -check-prefix=OBJ-N64 %s
+  .text
+foo:
+  .reloc 4, R_MIPS_NONE, foo   # ASM: .reloc 4, R_MIPS_NONE, foo
+  .reloc 0, R_MIPS_NONE, foo+4 # ASM: .reloc 0, R_MIPS_NONE, foo+4
+  .reloc 8, R_MIPS_32, foo+8   # ASM: .reloc 8, R_MIPS_32, foo+8
+  nop
+  nop
+  nop
+  .reloc 12, R_MIPS_NONE       # ASM: .reloc 12, R_MIPS_NONE{{$}}
+        nop
+
+# OBJ-O32-LABEL: Name: .text
+# OBJ-O32:       0000: 00000000 00000000 00000008
+# OBJ-O32-LABEL: }
+# OBJ-O32-LABEL: Relocations [
+# OBJ-O32:       0x0 R_MIPS_NONE foo 0x0
+# OBJ-O32:       0x4 R_MIPS_NONE foo 0x0
+# OBJ-O32:       0x8 R_MIPS_32 .text 0x0
+# OBJ-O32:       0xC R_MIPS_NONE -   0x0
+
+# FIXME: We can't get N32 correct at the moment. If we use a mips-* triple then
+#        we incorrectly drop the addend. If we use a mips64-* triple then we
+#        incorrectly use the 3-reloc encoding (and ELF64). mips64-* triples
+#        are closest to being correct so we use them for now.
+#        This should be corrected once the triple bugfixes allow us to be ABI
+#        dependent rather than triple dependent.
+# OBJ-N32-LABEL: Name: .text
+# OBJ-N32:       0000: 00000000 00000000 00000000
+# OBJ-N32-LABEL: }
+# OBJ-N32-LABEL: Relocations [
+# OBJ-N32:       0x0 R_MIPS_NONE/R_MIPS_NONE/R_MIPS_NONE foo 0x4
+# OBJ-N32:       0x4 R_MIPS_NONE/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# OBJ-N32:       0x8 R_MIPS_32/R_MIPS_NONE/R_MIPS_NONE .text 0x8
+# OBJ-N32:       0xC R_MIPS_NONE/R_MIPS_NONE/R_MIPS_NONE -   0x0
+
+# OBJ-N64-LABEL: Name: .text
+# OBJ-N64:       0000: 00000000 00000000 00000000
+# OBJ-N64-LABEL: }
+# OBJ-N64-LABEL: Relocations [
+# OBJ-N64:       0x0 R_MIPS_NONE/R_MIPS_NONE/R_MIPS_NONE foo 0x4
+# OBJ-N64:       0x4 R_MIPS_NONE/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# OBJ-N64:       0x8 R_MIPS_32/R_MIPS_NONE/R_MIPS_NONE .text 0x8
+# OBJ-N64:       0xC R_MIPS_NONE/R_MIPS_NONE/R_MIPS_NONE -   0x0