[COFF] Add support for .secidx directives

[timurrrr]

Summary

This is extracted from D2232, i.e. needed to generate line table information.

[• rafael]

Are these llvm extensions to the gas syntax? If so, please document
them in docs/Extensions.rst.

[• rafael]

lib/MC/MCAssembler.cpp

963

Data.size() is always 4. The initialization use 4 zero bytes, so this always returns false, no? If so, why is this part of the relaxation?

[echristo]

Is gas unable to do this sort of thing? If it is able it'd be good to copy the syntax from there.

test/MC/COFF/secref.s

9

What about cross section relocations?

test/MC/COFF/static_offset.s

16

If you could explain the numbers here in a comment it would be appreciated.

[timurrrr]

Mostly addressed the review comments (questions to follow).

Re: gas - I'm not very familiar with it, but I couldn't find any equivalent of .secref and .offset there.

[timurrrr]

Also added some docs (to be tried with doxygen, "compiling...").

Re: gas - was looking here https://sourceware.org/binutils/docs/as/Pseudo-Ops.html

lib/MC/MCAssembler.cpp

963

Data.size() is always 4. The initialization use 4 zero bytes, so this always returns false, no?

Yeah - good catch.
I've updated the code accordingly.

If so, why is this part of the relaxation?

I'm not very familiar with the code, so might be doing this wrong.
Do you recommend to move writing the actual bytes of the AddrDelta?
If so, where do this belongs?

test/MC/COFF/secref.s

9

Added more tests

test/MC/COFF/static_offset.s

16

OK, done.
I've also one ret rather three nops as in real-world examples .offset will likely be 4-byte aligned.

[• rafael]

lib/MC/MCAssembler.cpp

947

Since the size is fixed, this shouldn't need to be part of the relaxation.

Relaxation exits for things that can change size depending on where other stuff is. For example, a short branch can become a long one and a uleb might need another byte if things more far apart.

What prevents this from being just a data fragment with a relocation to get the correct value?

Follow how llvm-mc implements:

---

foo:

.zero 4
.zero 4

bar:

zed = bar - foo

[timurrrr]

2013/12/20 Rafael Ávila de Espíndola <[e-mail]>:

Comment at: lib/MC/MCAssembler.cpp:947
@@ -939,1 +946,3 @@

+bool MCAssembler::relaxCoffStaticOffsetFragment(

+ MCAsmLayout &Layout, MCCoffStaticOffsetFragment &LDF) {

Since the size is fixed, this shouldn't need to be part of the relaxation.

Relaxation exits for things that can change size depending on where other stuff is. For example, a short
branch can become a long one and a uleb might need another byte if things more far apart.

Sorry, I am still very unfamiliar with the MC part of the codebase, I
mostly worked on the Clang part last year.
Thanks for the clarification, I've also looked at the code and I think
now I have at least a vague idea of what relaxations are :)

What prevents this from being just a data fragment with a relocation to get the correct value?

It's just that I'm not familiar with the codebase.

Follow how llvm-mc implements:

---

foo:

.zero 4
.zero 4

bar:

zed = bar - foo

Thanks for the pointer, looking.

[timurrrr]

In fact, I think I can just use

.int To-From

instead of

.offset from From to To

I'll reduce the patch accordingly soon.
Thanks a lot for the pointer!

[timurrrr]

Removed the .offset directive part as it's indeed not needed.

Also, renamed "section reference" to "section index".

[rnk]

LGTM

[timurrrr]

Should I wait for Eric to review?

[rnk]

No need to wait, post-commit should be fine. This seems pretty obviously good, unless there's some gas directive we could be reusing.

[• rafael]

LGTM too.

[timurrrr]

Cool!
r197826, thanks for the review!

docs/Extensions.rst

 ================================
 
 X86/COFF-Dependent
 ------------------
 
 Relocations
 ^^^^^^^^^^^
 
-The following additional relocation type is supported:
+The following additional relocation types are supported:
 
 **@IMGREL** (AT&T syntax only) generates an image-relative relocation that
 corresponds to the COFF relocation types ``IMAGE_REL_I386_DIR32NB`` (32-bit) or
 ``IMAGE_REL_AMD64_ADDR32NB`` (64-bit).
 
 .. code-block:: gas
 
   .text
   fun:
     mov foo@IMGREL(%ebx, %ecx, 4), %eax
 
   .section .pdata
     .long fun@IMGREL
     .long (fun@imgrel + 0x3F)
     .long $unwind$fun@imgrel
 
+**.secrel32** generates a relocation that corresponds to the COFF relocation
+types ``IMAGE_REL_I386_SECREL`` (32-bit) or ``IMAGE_REL_AMD64_SECREL`` (64-bit).
+
+**.secref** relocation generates an index of the section that contains
+the target.  It corresponds to the COFF relocation types
+``IMAGE_REL_I386_SECTION`` (32-bit) or ``IMAGE_REL_AMD64_SECTION`` (64-bit).
+
+.. code-block:: gas
+
+  .section .debug$S,"rn"
+    .long 4
+    .long 242
+    .long 40
+    .secrel32 _function_name
+    .secref   _function_name
+    ...
 
 ``.linkonce`` Directive
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 
    ``.linkonce [ comdat type [ section identifier ] ]``
 
.. code-block:: gas
   .globl Symbol1
   Symbol1:
   .long 1
 
   .section secName, "dr", discard, "Symbol2"
   .globl Symbol2
   Symbol2:
   .long 1
+
+``.offset`` Directive
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+
+   ``.offset from from_label to to_label``
+
+Generates a 4-byte offset between labels ``from_label`` and ``to_label`` that
+must be statically known, e.g. located in the same section in this object file.

include/llvm/MC/MCAssembler.h

enum FragmentType {
     FT_Align,
     FT_Data,
     FT_CompactEncodedInst,
     FT_Fill,
     FT_Relaxable,
     FT_Org,
     FT_Dwarf,
     FT_DwarfFrame,
+    FT_CoffStaticOffset,
     FT_LEB
   };
 
 private:
   FragmentType Kind;
 
   /// Parent - The data for the section this fragment is in.
   MCSectionData *Parent;
public:
 
   /// @}
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_DwarfFrame;
   }
 };
 
+class MCCoffStaticOffsetFragment : public MCFragment {
+  virtual void anchor();
+
+  /// AddrDelta - The expression for the offset between two labels.
+  const MCExpr *AddrDelta;
+
+  SmallString<8> Contents;
+
+public:
+  MCCoffStaticOffsetFragment(const MCExpr &AddrDelta, MCSectionData *SD = 0)
+      : MCFragment(FT_CoffStaticOffset, SD), AddrDelta(&AddrDelta) {
+    Contents.assign(4u, '\0');
+  }
+
+  /// @name Accessors
+  /// @{
+
+  const MCExpr &getAddrDelta() const { return *AddrDelta; }
+
+  SmallString<8> &getContents() { return Contents; }
+  const SmallString<8> &getContents() const { return Contents; }
+
+  /// @}
+
+  static bool classof(const MCFragment *F) {
+    return F->getKind() == MCFragment::FT_CoffStaticOffset;
+  }
+};
+
 // FIXME: Should this be a separate class, or just merged into MCSection? Since
 // we anticipate the fast path being through an MCAssembler, the only reason to
 // keep it out is for API abstraction.
 class MCSectionData : public ilist_node<MCSectionData> {
   friend class MCAsmLayout;
 
   MCSectionData(const MCSectionData&) LLVM_DELETED_FUNCTION;
   void operator=(const MCSectionData&) LLVM_DELETED_FUNCTION;
private:
 
   bool relaxInstruction(MCAsmLayout &Layout, MCRelaxableFragment &IF);
 
   bool relaxLEB(MCAsmLayout &Layout, MCLEBFragment &IF);
 
   bool relaxDwarfLineAddr(MCAsmLayout &Layout, MCDwarfLineAddrFragment &DF);
   bool relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
                                    MCDwarfCallFrameFragment &DF);
+  bool relaxCoffStaticOffsetFragment(MCAsmLayout &Layout,
+                                     MCCoffStaticOffsetFragment &LDF);
 
   /// finishLayout - Finalize a layout, including fragment lowering.
   void finishLayout(MCAsmLayout &Layout);
 
   uint64_t handleFixup(const MCAsmLayout &Layout,
                        MCFragment &F, const MCFixup &Fixup);
 
 public:

include/llvm/MC/MCStreamer.h

public:
   /// EmitCOFFSymbolType - Emit the type of the symbol.
   ///
   /// @param Type - A COFF type identifier (see COFF::SymbolType in X86COFF.h)
   virtual void EmitCOFFSymbolType(int Type) = 0;
 
   /// EndCOFFSymbolDef - Marks the end of the symbol definition.
   virtual void EndCOFFSymbolDef() = 0;
 
+  /// EmitCOFFSectionReference - Emits a COFF section number.
+  ///
+  /// @param Symbol - Symbol the section number relocation should point to.
+  virtual void EmitCOFFSectionReference(MCSymbol const *Symbol);
+
   /// EmitCOFFSecRel32 - Emits a COFF section relative relocation.
   ///
-  /// @param Symbol - Symbol the section relative realocation should point to.
+  /// @param Symbol - Symbol the section relative relocation should point to.
   virtual void EmitCOFFSecRel32(MCSymbol const *Symbol);
 
+  /// EmitCOFFStaticOffset - Emits statically-known difference between two
+  /// labels in the same section.
+  virtual void EmitCOFFStaticOffset(const MCSymbol *From, const MCSymbol *To);
+
   /// EmitELFSize - Emit an ELF .size directive.
   ///
   /// This corresponds to an assembler statement such as:
   ///  .size symbol, expression
   ///
   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) = 0;
 
   /// EmitCommonSymbol - Emit a common symbol.

lib/MC/MCAsmStreamer.cpp

public:
 
   virtual bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute);
 
   virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
   virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol);
   virtual void EmitCOFFSymbolStorageClass(int StorageClass);
   virtual void EmitCOFFSymbolType(int Type);
   virtual void EndCOFFSymbolDef();
+  virtual void EmitCOFFSectionReference(MCSymbol const *Symbol);
   virtual void EmitCOFFSecRel32(MCSymbol const *Symbol);
+  virtual void EmitCOFFStaticOffset(const MCSymbol *From, const MCSymbol *To);
   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value);
   virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                 unsigned ByteAlignment);
 
   /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
   ///
   /// @param Symbol - The common symbol to emit.
   /// @param Size - The size of the common symbol.
void MCAsmStreamer::EmitCOFFSymbolType (int Type) {
   EmitEOL();
 }
 
 void MCAsmStreamer::EndCOFFSymbolDef() {
   OS << "\t.endef";
   EmitEOL();
 }
 
+void MCAsmStreamer::EmitCOFFSectionReference(MCSymbol const *Symbol) {
+  OS << "\t.secref\t" << *Symbol;
+  EmitEOL();
+}
+
 void MCAsmStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
-  OS << "\t.secrel32\t" << *Symbol << '\n';
+  OS << "\t.secrel32\t" << *Symbol;
+  EmitEOL();
+}
+
+void MCAsmStreamer::EmitCOFFStaticOffset(const MCSymbol *From,
+                                         const MCSymbol *To) {
+  OS << "\t.offset from " << *From << " to " << *To;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
   assert(MAI->hasDotTypeDotSizeDirective());
   OS << "\t.size\t" << *Symbol << ", " << *Value << '\n';
 }
 

lib/MC/MCAssembler.cpp

if (Size < 0 || Size >= 0x40000000)
                          "' (at offset '" + Twine(FragmentOffset) + "')");
     return Size;
   }
 
   case MCFragment::FT_Dwarf:
     return cast<MCDwarfLineAddrFragment>(F).getContents().size();
   case MCFragment::FT_DwarfFrame:
     return cast<MCDwarfCallFrameFragment>(F).getContents().size();
+  case MCFragment::FT_CoffStaticOffset:
+    return cast<MCCoffStaticOffsetFragment>(F).getContents().size();
   }
 
   llvm_unreachable("invalid fragment kind");
 }
 
 void MCAsmLayout::layoutFragment(MCFragment *F) {
   MCFragment *Prev = F->getPrevNode();
 
case MCFragment::FT_Dwarf: {
     OW->WriteBytes(OF.getContents().str());
     break;
   }
   case MCFragment::FT_DwarfFrame: {
     const MCDwarfCallFrameFragment &CF = cast<MCDwarfCallFrameFragment>(F);
     OW->WriteBytes(CF.getContents().str());
     break;
   }
+  case MCFragment::FT_CoffStaticOffset: {
+    const MCCoffStaticOffsetFragment &LDF = cast<MCCoffStaticOffsetFragment>(F);
+    OW->WriteBytes(LDF.getContents().str());
+    break;
+  }
   }
 
   assert(OW->getStream().tell() - Start == FragmentSize &&
          "The stream should advance by fragment size");
 }
 
 void MCAssembler::writeSectionData(const MCSectionData *SD,
                                    const MCAsmLayout &Layout) const {
bool MCAssembler::relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
   SmallString<8> &Data = DF.getContents();
   Data.clear();
   raw_svector_ostream OSE(Data);
   MCDwarfFrameEmitter::EncodeAdvanceLoc(Context, AddrDelta, OSE);
   OSE.flush();
   return OldSize != Data.size();
 }
 
+bool MCAssembler::relaxCoffStaticOffsetFragment(
+    MCAsmLayout &Layout, MCCoffStaticOffsetFragment &LDF) {
+  MCContext &Context = Layout.getAssembler().getContext();
+  int64_t AddrDelta = 0;
+  bool IsAbs = LDF.getAddrDelta().EvaluateAsAbsolute(AddrDelta, Layout);
+  (void)IsAbs;
+  assert(IsAbs && "Couldn't statically evaluate the offset between two labels");
+  assert(LDF.getContents().size() == 4);
+  SmallString<8> &Data = LDF.getContents();
+  Data.clear();
+  raw_svector_ostream OSE(Data);
+  OSE << uint8_t( AddrDelta        & 0xff);
+  OSE << uint8_t((AddrDelta >> 8)  & 0xff);
+  OSE << uint8_t((AddrDelta >> 16) & 0xff);
+  OSE << uint8_t((AddrDelta >> 24) & 0xff);
+  OSE.flush();
+  return false;
+}
+
 bool MCAssembler::layoutSectionOnce(MCAsmLayout &Layout, MCSectionData &SD) {
   // Holds the first fragment which needed relaxing during this layout. It will
   // remain NULL if none were relaxed.
   // When a fragment is relaxed, all the fragments following it should get
   // invalidated because their offset is going to change.
   MCFragment *FirstRelaxedFragment = NULL;
 
   // Attempt to relax all the fragments in the section.
case MCFragment::FT_Dwarf:
       RelaxedFrag = relaxDwarfLineAddr(Layout,
                                        *cast<MCDwarfLineAddrFragment>(I));
       break;
     case MCFragment::FT_DwarfFrame:
       RelaxedFrag =
         relaxDwarfCallFrameFragment(Layout,
                                     *cast<MCDwarfCallFrameFragment>(I));
       break;
+    case MCFragment::FT_CoffStaticOffset:
+      RelaxedFrag = relaxCoffStaticOffsetFragment(
+          Layout, *cast<MCCoffStaticOffsetFragment>(I));
+      break;
     case MCFragment::FT_LEB:
       RelaxedFrag = relaxLEB(Layout, *cast<MCLEBFragment>(I));
       break;
     }
     if (RelaxedFrag && !FirstRelaxedFragment)
       FirstRelaxedFragment = I;
   }
   if (FirstRelaxedFragment) {
void MCFragment::dump() {
   case MCFragment::FT_Data:  OS << "MCDataFragment"; break;
   case MCFragment::FT_CompactEncodedInst:
     OS << "MCCompactEncodedInstFragment"; break;
   case MCFragment::FT_Fill:  OS << "MCFillFragment"; break;
   case MCFragment::FT_Relaxable:  OS << "MCRelaxableFragment"; break;
   case MCFragment::FT_Org:   OS << "MCOrgFragment"; break;
   case MCFragment::FT_Dwarf: OS << "MCDwarfFragment"; break;
   case MCFragment::FT_DwarfFrame: OS << "MCDwarfCallFrameFragment"; break;
+  case MCFragment::FT_CoffStaticOffset:
+    OS << "MCCoffStaticOffsetFragment"; break;
   case MCFragment::FT_LEB:   OS << "MCLEBFragment"; break;
   }
 
   OS << "<MCFragment " << (void*) this << " LayoutOrder:" << LayoutOrder
      << " Offset:" << Offset
      << " HasInstructions:" << hasInstructions() 
      << " BundlePadding:" << static_cast<unsigned>(getBundlePadding()) << ">";
 
case MCFragment::FT_Dwarf:  {
     break;
   }
   case MCFragment::FT_DwarfFrame:  {
     const MCDwarfCallFrameFragment *CF = cast<MCDwarfCallFrameFragment>(this);
     OS << "\n       ";
     OS << " AddrDelta:" << CF->getAddrDelta();
     break;
   }
+  case MCFragment::FT_CoffStaticOffset:  {
+    const MCCoffStaticOffsetFragment *LDF =
+        cast<MCCoffStaticOffsetFragment>(this);
+    OS << "\n       ";
+    OS << " Offset:" << LDF->getAddrDelta();
+    break;
+  }
   case MCFragment::FT_LEB: {
     const MCLEBFragment *LF = cast<MCLEBFragment>(this);
     OS << "\n       ";
     OS << " Value:" << LF->getValue() << " Signed:" << LF->isSigned();
     break;
   }
   }
   OS << ">";

 void MCCompactEncodedInstFragment::anchor() { }
 void MCRelaxableFragment::anchor() { }
 void MCAlignFragment::anchor() { }
 void MCFillFragment::anchor() { }
 void MCOrgFragment::anchor() { }
 void MCLEBFragment::anchor() { }
 void MCDwarfLineAddrFragment::anchor() { }
 void MCDwarfCallFrameFragment::anchor() { }
+void MCCoffStaticOffsetFragment::anchor() { }

lib/MC/MCParser/COFFAsmParser.cpp

virtual void Initialize(MCAsmParser &Parser) {
     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveData>(".data");
     addDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveBSS>(".bss");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSection>(".section");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveDef>(".def");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveScl>(".scl");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveType>(".type");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveEndef>(".endef");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveSecRel32>(".secrel32");
+    addDirectiveHandler<&COFFAsmParser::ParseDirectiveSecRef>(".secref");
+    addDirectiveHandler<&COFFAsmParser::ParseDirectiveOffset>(".offset");
     addDirectiveHandler<&COFFAsmParser::ParseDirectiveLinkOnce>(".linkonce");
 
     // Win64 EH directives.
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartProc>(
                                                                    ".seh_proc");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProc>(
                                                                 ".seh_endproc");
     addDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartChained>(
class COFFAsmParser : public MCAsmParserExtension {
   }
 
   bool ParseDirectiveSection(StringRef, SMLoc);
   bool ParseDirectiveDef(StringRef, SMLoc);
   bool ParseDirectiveScl(StringRef, SMLoc);
   bool ParseDirectiveType(StringRef, SMLoc);
   bool ParseDirectiveEndef(StringRef, SMLoc);
   bool ParseDirectiveSecRel32(StringRef, SMLoc);
+  bool ParseDirectiveSecRef(StringRef, SMLoc);
+  bool ParseDirectiveOffset(StringRef, SMLoc);
   bool parseCOMDATTypeAndAssoc(COFF::COMDATType &Type,
                                const MCSectionCOFF *&Assoc);
   bool ParseDirectiveLinkOnce(StringRef, SMLoc);
 
   // Win64 EH directives.
   bool ParseSEHDirectiveStartProc(StringRef, SMLoc);
   bool ParseSEHDirectiveEndProc(StringRef, SMLoc);
   bool ParseSEHDirectiveStartChained(StringRef, SMLoc);
bool COFFAsmParser::ParseDirectiveEndef(StringRef, SMLoc) {
   Lex();
   getStreamer().EndCOFFSymbolDef();
   return false;
 }
 
 bool COFFAsmParser::ParseDirectiveSecRel32(StringRef, SMLoc) {
   StringRef SymbolID;
   if (getParser().parseIdentifier(SymbolID))
-    return true;
+    return TokError("expected identifier in directive");
 
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return TokError("unexpected token in directive");
 
   MCSymbol *Symbol = getContext().GetOrCreateSymbol(SymbolID);
 
   Lex();
   getStreamer().EmitCOFFSecRel32(Symbol);
   return false;
 }
 
+bool COFFAsmParser::ParseDirectiveSecRef(StringRef, SMLoc) {
+  StringRef SymbolID;
+  if (getParser().parseIdentifier(SymbolID))
+    return TokError("expected identifier in directive");
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  MCSymbol *Symbol = getContext().GetOrCreateSymbol(SymbolID);
+
+  Lex();
+  getStreamer().EmitCOFFSectionReference(Symbol);
+  return false;
+}
+
+bool COFFAsmParser::ParseDirectiveOffset(StringRef, SMLoc) {
+  StringRef FromSymbolID, ToSymbolID;
+  if (getLexer().getTok().getString() != "from")
+    return TokError("expected 'from'");
+  Lex();
+
+  if (getParser().parseIdentifier(FromSymbolID))
+    return TokError("expected a label");
+
+  if (getLexer().getTok().getString() != "to")
+    return TokError("expected 'to'");
+  Lex();
+
+  if (getParser().parseIdentifier(ToSymbolID))
+    return TokError("expected a label");
+
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in directive");
+
+  MCSymbol *FromSymbol = getContext().GetOrCreateSymbol(FromSymbolID),
+           *ToSymbol = getContext().GetOrCreateSymbol(ToSymbolID);
+
+  Lex();
+  getStreamer().EmitCOFFStaticOffset(FromSymbol, ToSymbol);
+  return false;
+}
+
 /// ::= [ identifier [ identifier ] ]
 bool COFFAsmParser::parseCOMDATTypeAndAssoc(COFF::COMDATType &Type,
                                             const MCSectionCOFF *&Assoc) {
   StringRef TypeId = getTok().getIdentifier();
 
   Type = StringSwitch<COFF::COMDATType>(TypeId)
     .Case("one_only", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES)
     .Case("discard", COFF::IMAGE_COMDAT_SELECT_ANY)

lib/MC/MCStreamer.cpp

 
 void MCStreamer::EmitWin64EHEndProlog() {
   EnsureValidW64UnwindInfo();
   MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo;
   CurFrame->PrologEnd = getContext().CreateTempSymbol();
   EmitLabel(CurFrame->PrologEnd);
 }
 
+void MCStreamer::EmitCOFFSectionReference(MCSymbol const *Symbol) {
+  llvm_unreachable("This file format doesn't support this directive");
+}
+
 void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
   llvm_unreachable("This file format doesn't support this directive");
 }
 
+void MCStreamer::EmitCOFFStaticOffset(const MCSymbol *From,
+                                      const MCSymbol *To) {
+  llvm_unreachable("This file format doesn't support this directive");
+}
+
 /// 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 MCStreamer::EmitRawTextImpl(StringRef String) {
   errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
   " something must not be fully mc'ized\n";
   abort();
 }

lib/MC/WinCOFFStreamer.cpp

public:
   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
   virtual void EmitThumbFunc(MCSymbol *Func);
   virtual bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute);
   virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
   virtual void BeginCOFFSymbolDef(MCSymbol const *Symbol);
   virtual void EmitCOFFSymbolStorageClass(int StorageClass);
   virtual void EmitCOFFSymbolType(int Type);
   virtual void EndCOFFSymbolDef();
+  virtual void EmitCOFFSectionReference(MCSymbol const *Symbol);
   virtual void EmitCOFFSecRel32(MCSymbol const *Symbol);
+  virtual void EmitCOFFStaticOffset(const MCSymbol *From, const MCSymbol *To);
   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value);
   virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                 unsigned ByteAlignment);
   virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                      unsigned ByteAlignment);
   virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
                             uint64_t Size,unsigned ByteAlignment);
   virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
getAssembler().getOrCreateSymbolData(*CurSymbol).modifyFlags(
     COFF::SF_TypeMask);
 }
 
 void WinCOFFStreamer::EndCOFFSymbolDef() {
   assert(CurSymbol != NULL && "BeginCOFFSymbolDef must be called first!");
   CurSymbol = NULL;
 }
 
+void WinCOFFStreamer::EmitCOFFSectionReference(MCSymbol const *Symbol)
+{
+  MCDataFragment *DF = getOrCreateDataFragment();
+
+  DF->getFixups().push_back(
+      MCFixup::Create(DF->getContents().size(),
+                      MCSymbolRefExpr::Create (Symbol, getContext ()),
+                      FK_SecRel_2));
+  DF->getContents().resize(DF->getContents().size() + 4, 0);
+}
+
 void WinCOFFStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol)
 {
   MCDataFragment *DF = getOrCreateDataFragment();
 
   DF->getFixups().push_back(
       MCFixup::Create(DF->getContents().size(),
                       MCSymbolRefExpr::Create (Symbol, getContext ()),
                       FK_SecRel_4));
   DF->getContents().resize(DF->getContents().size() + 4, 0);
 }
 
+void WinCOFFStreamer::EmitCOFFStaticOffset(const MCSymbol *From,
+                                           const MCSymbol *To) {
+  const MCExpr *AddrDelta = BuildSymbolDiff(getContext(), To, From);
+  int64_t Res;
+  if (AddrDelta->EvaluateAsAbsolute(Res, getAssembler())) {
+    EmitIntValue(Res, 4);
+    return;
+  }
+  AddrDelta = ForceExpAbs(AddrDelta);
+  insert(new MCCoffStaticOffsetFragment(*AddrDelta));
+}
+
 void WinCOFFStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
   llvm_unreachable("not implemented");
 }
 
 void WinCOFFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                        unsigned ByteAlignment) {
   assert((Symbol->isInSection()
          ? Symbol->getSection().getVariant() == MCSection::SV_COFF

lib/Target/X86/MCTargetDesc/X86WinCOFFObjectWriter.cpp

case X86::reloc_signed_4byte:
     if (Modifier == MCSymbolRefExpr::VK_COFF_IMGREL32)
       return Is64Bit ? COFF::IMAGE_REL_AMD64_ADDR32NB :
                        COFF::IMAGE_REL_I386_DIR32NB;
     return Is64Bit ? COFF::IMAGE_REL_AMD64_ADDR32 : COFF::IMAGE_REL_I386_DIR32;
   case FK_Data_8:
     if (Is64Bit)
       return COFF::IMAGE_REL_AMD64_ADDR64;
     llvm_unreachable("unsupported relocation type");
+  case FK_SecRel_2:
+    return Is64Bit ? COFF::IMAGE_REL_AMD64_SECTION
+                   : COFF::IMAGE_REL_I386_SECTION;
   case FK_SecRel_4:
     return Is64Bit ? COFF::IMAGE_REL_AMD64_SECREL : COFF::IMAGE_REL_I386_SECREL;
   default:
     llvm_unreachable("unsupported relocation type");
   }
 }
 
 MCObjectWriter *llvm::createX86WinCOFFObjectWriter(raw_ostream &OS,
                                                    bool Is64Bit) {
   MCWinCOFFObjectTargetWriter *MOTW = new X86WinCOFFObjectWriter(Is64Bit);
   return createWinCOFFObjectWriter(MOTW, OS);
 }

test/MC/COFF/secref.s

+// RUN: llvm-mc -filetype=obj -triple i686-pc-win32 %s | llvm-readobj -s -sr | FileCheck %s
+
+// check that we produce the correct relocation for .secref
+
+Lfoo:
+  .secref Lfoo
+  .secref Lbar
+
+.section spam
+Lbar:
+  ret
+
+// CHECK:       Relocations [
+// CHECK-NEXT:    0x0 IMAGE_REL_I386_SECTION .text
+// CHECK-NEXT:    0x4 IMAGE_REL_I386_SECTION spam
+// CHECK-NEXT:  ]

test/MC/COFF/static_offset.s

+// RUN: llvm-mc -filetype=obj -triple i686-pc-win32 %s | llvm-readobj -s -sd | FileCheck %s
+
+// check that we produce the correct static offset for .offset
+
+Lfoo:
+  .offset from L1 to L2
+L1:
+  nop
+  nop
+  nop
+  ret
+L2:
+  .offset from L1 to L2
+
+// CHECK:       SectionData (
+// 4 is the offset between L1 and L2,
+// 0x90 is the instruction code for 'nop', 0xC3 is a 'ret'.
+// CHECK-NEXT:    0000: 04000000 909090C3 04000000
+// CHECK-NEXT:  )