[IAS] Support '.word foo-.' on targets that permit this (e.g. Mips).

[dsanders]

Summary

This is necessary to support DW_EH_PE_pcrel encoded TType references in the
exception handling LSDA on Mips.

Previously for Mips, IAS would emit an R_MIPS_32 relocation given
'.word foo-.' making it functionally equivalent to '.word foo'. It now
emits a R_MIPS_PC32 relocation. Despite the name, R_MIPS_PC32 has
historically been used on data sections and the 'PC' in this context is
the address of the data being fixed up.

[• rafael]

What is Mips specific about this? With

.word foo-.

We already produce a R_X86_64_PC16 for example.

[dsanders]

We already produce a R_X86_64_PC16 for example.

Hmm. Maybe I'm fixing this in the wrong place.
Do you know how it does this? The current implementation of EmitValueImpl() calls MCFixup::getKindForSize() with the isPCRel argument equal to false and I don't see anything that turns FK_Data_2 fixups into PC-relative equivalents.

[• rafael]

I fixed the tip of the iceberg in r238751. It should be somewhat easy
to add the other sizes.

[dsanders]

Thanks. That's much simpler than what I was doing. I'll go through the others.

[dsanders]

Abandoned this patch since there's a much better way to do it.

include/llvm/MC/MCStreamer.h

 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/SMLoc.h"
 #include <string>
 
 namespace llvm {
 class MCAsmBackend;
 class MCCodeEmitter;
 class MCContext;
+class MCDataFragment;
 class MCExpr;
 class MCInst;
 class MCInstPrinter;
 class MCSection;
 class MCStreamer;
 class MCSymbol;
 class MCSymbolRefExpr;
 class MCSubtargetInfo;
public:
   /// @{
 
   /// \brief Emit the bytes in \p Data into the output.
   ///
   /// This is used to implement assembler directives such as .byte, .ascii,
   /// etc.
   virtual void EmitBytes(StringRef Data);
 
+  /// Select an appropriate fixup for the given expression \p Value.
+  ///
+  /// This is used to implement assembler directives such as .word, .quad,
+  /// etc. Some targets can accept place-relative expressions.
+  ///
+  /// For example 'foo-.' on Mips can be supported with R_MIPS_PC32.
+  ///
+  /// \param Frag - The fragment the value will be written to.
+  /// \param Offset - The offset of the value within the fragment.
+  /// \param Value - The value to emit.
+  /// \param Size - The size of the integer (in bytes) to emit. This must
+  /// match a native machine width.
+  /// \param Loc - The location of the expression for error reporting.
+  virtual MCFixup GetFixupForValue(const MCFragment *Frag, uint64_t Offset,
+                                   const MCExpr *Value, unsigned Size,
+                                   const SMLoc &Loc = SMLoc());
+
   /// \brief Emit the expression \p Value into the output as a native
   /// integer of the given \p Size bytes.
   ///
   /// This is used to implement assembler directives such as .word, .quad,
   /// etc.
   ///
   /// \param Value - The value to emit.
   /// \param Size - The size of the integer (in bytes) to emit. This must

lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
 
   // Avoid fixups when possible.
   int64_t AbsValue;
   if (Value->EvaluateAsAbsolute(AbsValue, getAssembler())) {
     EmitIntValue(AbsValue, Size);
     return;
   }
   DF->getFixups().push_back(
-      MCFixup::create(DF->getContents().size(), Value,
-                      MCFixup::getKindForSize(Size, false), Loc));
+      GetFixupForValue(DF, DF->getContents().size(), Value, Size, Loc));
   DF->getContents().resize(DF->getContents().size() + Size, 0);
 }
 
 void MCObjectStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
   // We need to create a local symbol to avoid relocations.
   Frame.Begin = getContext().createTempSymbol();
   EmitLabel(Frame.Begin);
 }

lib/MC/MCStreamer.cpp

 /// client having to pass in a MCExpr for constant integers.
 void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
   SmallString<128> Tmp;
   raw_svector_ostream OSE(Tmp);
   encodeSLEB128(Value, OSE);
   EmitBytes(OSE.str());
 }
 
+MCFixup MCStreamer::GetFixupForValue(const MCFragment *, uint64_t Offset,
+                                     const MCExpr *Value, unsigned Size,
+                                     const SMLoc &Loc) {
+  return MCFixup::create(Offset, Value, MCFixup::getKindForSize(Size, false),
+                         Loc);
+}
+
 void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size,
                            const SMLoc &Loc) {
   EmitValueImpl(Value, Size, Loc);
 }
 
 void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
                                  bool IsSectionRelative) {
   assert((!IsSectionRelative || Size == 4) &&

lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

unsigned MipsELFObjectWriter::GetRelocType(const MCValue &Target,
   case Mips::fixup_Mips_32:
   case FK_Data_4:
     Type = ELF::R_MIPS_32;
     break;
   case Mips::fixup_Mips_64:
   case FK_Data_8:
     Type = ELF::R_MIPS_64;
     break;
+  case FK_PCRel_4:
+    Type = ELF::R_MIPS_PC32;
+    break;
   case FK_GPRel_4:
     if (isN64()) {
       Type = setRType((unsigned)ELF::R_MIPS_GPREL32, Type);
       Type = setRType2((unsigned)ELF::R_MIPS_64, Type);
       Type = setRType3((unsigned)ELF::R_MIPS_NONE, Type);
     }
     else
       Type = ELF::R_MIPS_GPREL32;

lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h

public:
   /// EmitInstruction.
   void EmitLabel(MCSymbol *Symbol) override;
 
   /// Overriding this function allows us to dismiss all labels that are
   /// candidates for marking as microMIPS when .section directive is processed.
   void SwitchSection(MCSection *Section,
                      const MCExpr *Subsection = nullptr) override;
 
+  /// Overriding to add support for place-relative values using R_MIPS_PC32.
+  MCFixup GetFixupForValue(const MCFragment *Frag, uint64_t Offset,
+                           const MCExpr *Value, unsigned Size,
+                           const SMLoc &Loc) override;
+
   /// Overriding this function allows us to dismiss all labels that are
   /// candidates for marking as microMIPS when .word directive is emitted.
   void EmitValueImpl(const MCExpr *Value, unsigned Size,
                      const SMLoc &Loc) override;
 
   /// Emits all the option records stored up until the point it's called.
   void EmitMipsOptionRecords();
 

lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp

 }
 
 void MipsELFStreamer::SwitchSection(MCSection *Section,
                                     const MCExpr *Subsection) {
   MCELFStreamer::SwitchSection(Section, Subsection);
   Labels.clear();
 }
 
+MCFixup MipsELFStreamer::GetFixupForValue(const MCFragment *Frag,
+                                          uint64_t Offset, const MCExpr *Value,
+                                          unsigned Size, const SMLoc &Loc) {
+  // Look for expressions of the form 'foo - bar' where bar is equivalent to the
+  // current position in the fragment. We can handle these with R_MIPS_PC32 when
+  // Size is 4. The 'PC' in this context is the position of the value.
+  if (const MCBinaryExpr *BinOp = dyn_cast<MCBinaryExpr>(Value)) {
+    if (BinOp->getOpcode() == MCBinaryExpr::Sub) {
+      const MCSymbolRefExpr *LHS = dyn_cast<MCSymbolRefExpr>(BinOp->getLHS());
+      const MCSymbolRefExpr *RHS = dyn_cast<MCSymbolRefExpr>(BinOp->getRHS());
+      if (LHS && RHS) {
+        // Check the RHS is in the same fragment at the current position.
+        const MCSymbolData &SymData = RHS->getSymbol().getData();
+        if (Frag == SymData.getFragment() && SymData.getOffset() == Offset &&
+            Size == 4)
+          return MCFixup::create(Offset, LHS,
+                                 MCFixup::getKindForSize(Size, true), Loc);
+      }
+    }
+  }
+
+  return MCELFStreamer::GetFixupForValue(Frag, Offset, Value, Size, Loc);
+}
+
 void MipsELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
                                     const SMLoc &Loc) {
   MCELFStreamer::EmitValueImpl(Value, Size, Loc);
   Labels.clear();
 }
 
 void MipsELFStreamer::EmitMipsOptionRecords() {
   for (const auto &I : MipsOptionRecords)

test/MC/Mips/data-relocations.s

+# RUN: llvm-mc %s -triple=mipsel-unknown-linux -filetype=obj | llvm-readobj -r | FileCheck %s
+        .extern foo
+        .data
+        .word foo    # CHECK: 0x0 R_MIPS_32 foo 0x0
+        .word foo-.  # CHECK: 0x4 R_MIPS_PC32 foo 0x0