[MC] Create unique .pdata sections for every .text section

[rnk]

Summary

This adds a unique ID to the COFF section uniquing map, similar to the
one we have for ELF. The unique id is not currently exposed via the
assembler because we don't have a use case for it yet. Users generally
create .pdata with the .seh_* family of directives, and the assembler
internally needs to produce .pdata and .xdata sections corresponding to
the code section.

The map to remember which .pdata section to use for a given .text
section is maintained in the MCContext, since this is something the
assembler needs to maintain to implement .seh_* directives. I'm open to
suggestisons for a better home.

[• rafael]

Just a few quick comments for now.

include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

143

Why start with 1? Not that it is really important, but ELF start with 0.

include/llvm/MC/MCContext.h

91

Can't this just be a field in MCSectionCOFF like it is for ELF?

414

Can you move this out of the context? It looks similar to ELF relocation sections. We handle that mapping in the elf writer and we only createELFRelSection in the context.

[rnk]

Thanks for the input, I'll try moving this to MCWinCOFFStreamer.

include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

143

What is the generic unique ID for ELF? What unique ID do I get if I write .text?

I assumed it was zero, but if it's ~0U, then sure I can start this at zero.

include/llvm/MC/MCContext.h

91

This should have more comments. It exists to map from text section to the unique id of its corresponding pdata section, so that if a text section contains more than one function using SEH, we can reuse the same pdata section for it. This matters for C++ funclets, which should also have a test.

414

IIUC, ELF relocation sections are below the abstraction level of the assembler. They're something created automatically based on your symbol references.

While we could push .pdata down to that level, the .xdata section is not below that level. The user needs to be able to put their LSDA there. It is a real section opened up by .seh_handlerdata that can be pushed and popped.

I could maintain this mapping in MCWinCOFFStreamer, though, and that would be close to what you're thinking of?

Another twist is that lib/CodeGen/AsmPrinter/WinException.cpp needs to switch to the .xdata section. On 32-bit x86, it doesn't use the .seh_handlerdata directive to do it. Should I have getXDataSectionForTextSection be a method of MCStreamer, or have WinException downcast the MCStreamer to an MCWinCOFFStreamer?

[rnk]

• Remove DenseMap in favor of MCSectionCOFF field

[rnk]

Revert unintentional change

[rnk]

This addresses some of your concerns, but it still makes MCStreamer aware of some COFF-specific details. Do you think I have to hide them? If so, what's the best way to do that, given that "target neutral" code in lib/CodeGen/AsmPrinter/WinException.cpp and lib/MC/MCAsmStreamer.cpp use this?

[llvm-commits]

Looking again, sorry for the long delay.

[• rafael]

include/llvm/MC/MCSectionCOFF.h

36

one-to-many, no?

39

So, this is not the unique id of this section, it is the id of the related .xdata and .pdata, correct?

Why do you have to implement it like that? For ELF we store the unique id of the section itself. Then when you want to construct a .xdata or .pdata for this .text you can just use the existing unique id, no? So for example, you would end up with 3 section, .text, .xdata and .pdata all of which have an unique id of 42.

Maybe the name unique id is confusing. It is not really unique, it is really just an disambiguator when the rest (name, flags) are the same.

[rnk]

include/llvm/MC/MCSectionCOFF.h

36

For every object-file level .text section, there should be one .pdata section and one .xdata section. Maybe I'll just spell that out.

39

But these two .text sections will have the same unique ID (~0U, the generic section id):

.section        .text,"xr",discard,f
.section        .text,"xr",associative,f

And we need a separate .pdata section for each, and they look like:

.section        .pdata,"xr",associative,f
.section        .pdata,"xr",associative,f

However, they are created implicitly when assembling the .seh_* directives.

We could assign all sections with the generic ID a non-generic unique ID on creation. We would insert two entries into the uniquing map: one with the generic ID, and one with the specific ID.

At the end of the day, I feel like it's better to just maintain this WinCFI unique ID in the .text section.

[• rafael]

Comment at: include/llvm/MC/MCSectionCOFF.h:36
@@ +35,3 @@
+ / The unique IDs used with the .pdata and .xdata sections created internally
+ / by the assembler. This ID is used to ensure that there is a one-to-one

+ /// mapping from .text section to .pdata and .xdata sections. This data is

rafael wrote:

one-to-many, no?

For every object-file level .text section, there should be one .pdata section and one .xdata section. Maybe I'll just spell that out.

Yes, please :-)

Maybe the name unique id is confusing. It is not really unique, it is really just an disambiguator when the rest (name, flags) are the same.

But these two .text sections will have the same unique ID (~0U, the generic section id):

.section        .text,"xr",discard,f
.section        .text,"xr",associative,f

And we need a separate .pdata section for each, and they look like:

.section        .pdata,"xr",associative,f
.section        .pdata,"xr",associative,f

However, they are created implicitly when assembling the .seh_* directives.

We could assign all sections with the generic ID a non-generic unique ID on creation. We would insert two entries into the uniquing map: one with the generic ID, and one with the specific ID.

At the end of the day, I feel like it's better to just maintain this WinCFI unique ID in the .text section.

I see. I guess you could also store two MCSectionELF pointers, but
since UniqueID is not user visible it is probably fine to use as is.
Please add the above explanation as a comment.

LGTM with that.

Cheers,
Rafael

include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

public:
 
   void getNameWithPrefix(SmallVectorImpl<char> &OutName, const GlobalValue *GV,
                          Mangler &Mang, const TargetMachine &TM) const override;
 };
 
 
 
 class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
+  mutable unsigned NextUniqueID = 0;
+
 public:
   ~TargetLoweringObjectFileCOFF() override {}
 
   MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
                                       Mangler &Mang,
                                       const TargetMachine &TM) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,

include/llvm/MC/MCContext.h

private:
     /// Bindings of names to symbols.
     SymbolTable Symbols;
 
     /// ELF sections can have a corresponding symbol. This maps one to the
     /// other.
     DenseMap<const MCSectionELF *, MCSymbolELF *> SectionSymbols;
 
     /// A mapping from a local label number and an instance count to a symbol.
     /// For example, in the assembly
     ///     1:
     ///     2:
     ///     1:
     /// We have three labels represented by the pairs (1, 0), (2, 0) and (1, 1)
     DenseMap<std::pair<unsigned, unsigned>, MCSymbol *> LocalSymbols;
 
     /// Keeps tracks of names that were used both for used declared and
     /// artificial symbols. The value is "true" if the name has been used for a
struct ELFSectionKey {
         return UniqueID < Other.UniqueID;
       }
     };
 
     struct COFFSectionKey {
       std::string SectionName;
       StringRef GroupName;
       int SelectionKey;
+      unsigned UniqueID;
       COFFSectionKey(StringRef SectionName, StringRef GroupName,
-                     int SelectionKey)
+                     int SelectionKey, unsigned UniqueID)
           : SectionName(SectionName), GroupName(GroupName),
-            SelectionKey(SelectionKey) {}
+            SelectionKey(SelectionKey), UniqueID(UniqueID) {}
       bool operator<(const COFFSectionKey &Other) const {
         if (SectionName != Other.SectionName)
           return SectionName < Other.SectionName;
         if (GroupName != Other.GroupName)
           return GroupName < Other.GroupName;
+        if (SelectionKey != Other.SelectionKey)
           return SelectionKey < Other.SelectionKey;
+        return UniqueID < Other.UniqueID;
       }
     };
 
     StringMap<MCSectionMachO *> MachOUniquingMap;
     std::map<ELFSectionKey, MCSectionELF *> ELFUniquingMap;
     std::map<COFFSectionKey, MCSectionCOFF *> COFFUniquingMap;
     StringMap<bool> ELFRelSecNames;
 
public:
     /// APIs.
     const SymbolTable &getSymbols() const { return Symbols; }
 
     /// @}
 
     /// \name Section Management
     /// @{
 
+    enum : unsigned {
+      /// Pass this value as the UniqueID during section creation to get the
+      /// generic section with the given name and characteristics. The usual
+      /// sections such as .text use this ID.
+      GenericSectionID = ~0U
+    };
+
     /// Return the MCSection for the specified mach-o section.  This requires
     /// the operands to be valid.
     MCSectionMachO *getMachOSection(StringRef Segment, StringRef Section,
                                     unsigned TypeAndAttributes,
                                     unsigned Reserved2, SectionKind K,
                                     const char *BeginSymName = nullptr);
 
     MCSectionMachO *getMachOSection(StringRef Segment, StringRef Section,
public:
 
     void renameELFSection(MCSectionELF *Section, StringRef Name);
 
     MCSectionELF *createELFGroupSection(const MCSymbolELF *Group);
 
     MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                   SectionKind Kind, StringRef COMDATSymName,
                                   int Selection,
+                                  unsigned UniqueID = GenericSectionID,
                                   const char *BeginSymName = nullptr);
 
     MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                   SectionKind Kind,
                                   const char *BeginSymName = nullptr);
 
     MCSectionCOFF *getCOFFSection(StringRef Section);
 
     /// Gets or creates a section equivalent to Sec that is associated with the
     /// section containing KeySym. For example, to create a debug info section
     /// associated with an inline function, pass the normal debug info section
     /// as Sec and the function symbol as KeySym.
-    MCSectionCOFF *getAssociativeCOFFSection(MCSectionCOFF *Sec,
-                                             const MCSymbol *KeySym);
+    MCSectionCOFF *
+    getAssociativeCOFFSection(MCSectionCOFF *Sec, const MCSymbol *KeySym,
+                              unsigned UniqueID = GenericSectionID);
 
     // Create and save a copy of STI and return a reference to the copy.
     MCSubtargetInfo &getSubtargetCopy(const MCSubtargetInfo &STI);
 
     /// @}
 
     /// \name Dwarf Management
     /// @{
 
     /// \brief Get the compilation directory for DW_AT_comp_dir
     /// The compilation directory should be set with \c setCompilationDir before
     /// calling this function. If it is unset, an empty string will be returned.

include/llvm/MC/MCSectionCOFF.h

class MCSectionCOFF final : public MCSection {
 
   // FIXME: The following fields should not be mutable, but are for now so the
   // asm parser can honor the .linkonce directive.
 
   /// This is the Characteristics field of a section, drawn from the enums
   /// below.
   mutable unsigned Characteristics;
 
+  /// The unique IDs used with the .pdata and .xdata sections created internally
+  /// by the assembler. This ID is used to ensure that there is a one-to-one
+  /// mapping from .text section to .pdata and .xdata sections. This data is
+  /// mutable because this ID is not notionally part of the section.
+  mutable unsigned WinCFISectionID = ~0U;
+
   /// The COMDAT symbol of this section. Only valid if this is a COMDAT section.
   /// Two COMDAT sections are merged if they have the same COMDAT symbol.
   MCSymbol *COMDATSymbol;
 
   /// This is the Selection field for the section symbol, if it is a COMDAT
   /// section (Characteristics & IMAGE_SCN_LNK_COMDAT) != 0
   mutable int Selection;
 
public:
 
   void setSelection(int Selection) const;
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
 
+  unsigned getOrAssignWinCFISectionID(unsigned *NextID) const {
+    if (WinCFISectionID == ~0U)
+      WinCFISectionID = (*NextID)++;
+    return WinCFISectionID;
+  }
+
   static bool classof(const MCSection *S) { return S->getVariant() == SV_COFF; }
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCStreamer.h

class MCStreamer {
   /// \brief Tracks an index to represent the order a symbol was emitted in.
   /// Zero means we did not emit that symbol.
   DenseMap<const MCSymbol *, unsigned> SymbolOrdering;
 
   /// \brief This is stack of current and previous section values saved by
   /// PushSection.
   SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;
 
+  /// The next unique ID to use when creating a WinCFI-related section (.pdata
+  /// or .xdata). This ID ensures that we have a one-to-one mapping from
+  /// code section to unwind info section, which MSVC's incremental linker
+  /// requires.
+  unsigned NextWinCFIID = 0;
+
 protected:
   MCStreamer(MCContext &Ctx);
 
   virtual void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
   virtual void EmitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame);
 
   WinEH::FrameInfo *getCurrentWinFrameInfo() {
     return CurrentWinFrameInfo;
public:
   virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset);
   virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset);
   virtual void EmitWinCFIPushFrame(bool Code);
   virtual void EmitWinCFIEndProlog();
 
   virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except);
   virtual void EmitWinEHHandlerData();
 
+  /// Get the .pdata section used for the given section. Typically the given
+  /// section is either the main .text section or some other COMDAT .text
+  /// section, but it may be any section containing code.
+  MCSection *getAssociatedPDataSection(const MCSection *TextSec);
+
+  /// Get the .xdata section used for the given section.
+  MCSection *getAssociatedXDataSection(const MCSection *TextSec);
+
   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;

include/llvm/MC/MCWinEH.h

 //===- MCWinEH.h - Windows Unwinding Support --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCWINEH_H
 #define LLVM_MC_MCWINEH_H
 
 #include <vector>
 
 namespace llvm {
-class MCContext;
 class MCSection;
 class MCStreamer;
 class MCSymbol;
-class StringRef;
 
 namespace WinEH {
 struct Instruction {
   const MCSymbol *Label;
   const unsigned Offset;
   const unsigned Register;
   const unsigned Operation;
 
   Instruction(unsigned Op, MCSymbol *L, unsigned Reg, unsigned Off)
     : Label(L), Offset(Off), Register(Reg), Operation(Op) {}
 };
 
 struct FrameInfo {
-  const MCSymbol *Begin;
-  const MCSymbol *End;
-  const MCSymbol *ExceptionHandler;
-  const MCSymbol *Function;
-  const MCSymbol *PrologEnd;
-  const MCSymbol *Symbol;
+  const MCSymbol *Begin = nullptr;
+  const MCSymbol *End = nullptr;
+  const MCSymbol *ExceptionHandler = nullptr;
+  const MCSymbol *Function = nullptr;
+  const MCSymbol *PrologEnd = nullptr;
+  const MCSymbol *Symbol = nullptr;
+  const MCSection *TextSection = nullptr;
 
-  bool HandlesUnwind;
-  bool HandlesExceptions;
+  bool HandlesUnwind = false;
+  bool HandlesExceptions = false;
 
-  int LastFrameInst;
-  const FrameInfo *ChainedParent;
+  int LastFrameInst = -1;
+  const FrameInfo *ChainedParent = nullptr;
   std::vector<Instruction> Instructions;
 
-  FrameInfo()
-    : Begin(nullptr), End(nullptr), ExceptionHandler(nullptr),
-      Function(nullptr), PrologEnd(nullptr), Symbol(nullptr),
-      HandlesUnwind(false), HandlesExceptions(false), LastFrameInst(-1),
-      ChainedParent(nullptr), Instructions() {}
+  FrameInfo() = default;
   FrameInfo(const MCSymbol *Function, const MCSymbol *BeginFuncEHLabel)
-    : Begin(BeginFuncEHLabel), End(nullptr), ExceptionHandler(nullptr),
-      Function(Function), PrologEnd(nullptr), Symbol(nullptr),
-      HandlesUnwind(false), HandlesExceptions(false), LastFrameInst(-1),
-      ChainedParent(nullptr), Instructions() {}
+      : Begin(BeginFuncEHLabel), Function(Function) {}
   FrameInfo(const MCSymbol *Function, const MCSymbol *BeginFuncEHLabel,
             const FrameInfo *ChainedParent)
-    : Begin(BeginFuncEHLabel), End(nullptr), ExceptionHandler(nullptr),
-      Function(Function), PrologEnd(nullptr), Symbol(nullptr),
-      HandlesUnwind(false), HandlesExceptions(false), LastFrameInst(-1),
-      ChainedParent(ChainedParent), Instructions() {}
+      : Begin(BeginFuncEHLabel), Function(Function),
+        ChainedParent(ChainedParent) {}
 };
 
 class UnwindEmitter {
 public:
-  static MCSection *getPDataSection(const MCSymbol *Function,
-                                    MCContext &Context);
-  static MCSection *getXDataSection(const MCSymbol *Function,
-                                    MCContext &Context);
+  virtual ~UnwindEmitter();
 
-  virtual ~UnwindEmitter() { }
-
-  //
-  // This emits the unwind info sections (.pdata and .xdata in PE/COFF).
-  //
+  /// This emits the unwind info sections (.pdata and .xdata in PE/COFF).
   virtual void Emit(MCStreamer &Streamer) const = 0;
   virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI) const = 0;
 };
 }
 }
 
 #endif

lib/CodeGen/AsmPrinter/WinException.cpp

void WinException::endFunction(const MachineFunction *MF) {
 
   // endFunclet will emit the necessary .xdata tables for x64 SEH.
   if (Per == EHPersonality::MSVC_Win64SEH && MMI->hasEHFunclets())
     return;
 
   if (shouldEmitPersonality || shouldEmitLSDA) {
     Asm->OutStreamer->PushSection();
 
-    // Just switch sections to the right xdata section. This use of CurrentFnSym
-    // assumes that we only emit the LSDA when ending the parent function.
-    MCSection *XData = WinEH::UnwindEmitter::getXDataSection(Asm->CurrentFnSym,
-                                                             Asm->OutContext);
+    // Just switch sections to the right xdata section.
+    MCSection *XData = Asm->OutStreamer->getAssociatedXDataSection(
+        Asm->OutStreamer->getCurrentSectionOnly());
     Asm->OutStreamer->SwitchSection(XData);
 
     // Emit the tables appropriate to the personality function in use. If we
     // don't recognize the personality, assume it uses an Itanium-style LSDA.
     if (Per == EHPersonality::MSVC_Win64SEH)
       emitCSpecificHandlerTable(MF);
     else if (Per == EHPersonality::MSVC_X86SEH)
       emitExceptHandlerTable(MF);

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (const Function *F = dyn_cast<Function>(GV)) {
       }
     }
   }
 
   if (EmitUniqueSection && UniqueSectionNames) {
     Name.push_back('.');
     TM.getNameWithPrefix(Name, GV, Mang, true);
   }
-  unsigned UniqueID = ~0;
+  unsigned UniqueID = MCContext::GenericSectionID;
   if (EmitUniqueSection && !UniqueSectionNames) {
     UniqueID = *NextUniqueID;
     (*NextUniqueID)++;
   }
   return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
                            EntrySize, Group, UniqueID);
 }
 
if (GV->hasComdat()) {
     if (!ComdatGV->hasPrivateLinkage()) {
       MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
       COMDATSymName = Sym->getName();
       Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
     } else {
       Selection = 0;
     }
   }
-  return getContext().getCOFFSection(Name,
-                                     Characteristics,
-                                     Kind,
-                                     COMDATSymName,
+
+  return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
                                      Selection);
 }
 
 static const char *getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
   if (Kind.isText())
     return ".text";
   if (Kind.isBSS())
     return ".bss";
if ((EmitUniquedSection && !Kind.isCommon()) || GV->hasComdat()) {
     if (!Selection)
       Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
     const GlobalValue *ComdatGV;
     if (GV->hasComdat())
       ComdatGV = getComdatGVForCOFF(GV);
     else
       ComdatGV = GV;
 
+    unsigned UniqueID = MCContext::GenericSectionID;
+    if (EmitUniquedSection)
+      UniqueID = NextUniqueID++;
+
     if (!ComdatGV->hasPrivateLinkage()) {
       MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
       StringRef COMDATSymName = Sym->getName();
       return getContext().getCOFFSection(Name, Characteristics, Kind,
-                                         COMDATSymName, Selection);
+                                         COMDATSymName, Selection, UniqueID);
     } else {
       SmallString<256> TmpData;
       Mang.getNameWithPrefix(TmpData, GV, /*CannotUsePrivateLabel=*/true);
       return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
-                                         Selection);
+                                         Selection, UniqueID);
     }
   }
 
   if (Kind.isText())
     return TextSection;
 
   if (Kind.isThreadLocal())
     return TLSDataSection;
MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
 
   MCSymbol *Sym = TM.getSymbol(&F, Mang);
   StringRef COMDATSymName = Sym->getName();
 
   SectionKind Kind = SectionKind::getReadOnly();
   const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
   unsigned Characteristics = getCOFFSectionFlags(Kind);
   Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
+  unsigned UniqueID = NextUniqueID++;
 
   return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
-                                     COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE);
+                                     COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
 }
 
 void TargetLoweringObjectFileCOFF::
 emitModuleFlags(MCStreamer &Streamer,
                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
                 Mangler &Mang, const TargetMachine &TM) const {
   MDNode *LinkerOptions = nullptr;
 
for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
       Streamer.EmitBytes(Directive);
     }
   }
 }
 
 MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
     unsigned Priority, const MCSymbol *KeySym) const {
   return getContext().getAssociativeCOFFSection(
-      cast<MCSectionCOFF>(StaticCtorSection), KeySym);
+      cast<MCSectionCOFF>(StaticCtorSection), KeySym, 0);
 }
 
 MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
     unsigned Priority, const MCSymbol *KeySym) const {
   return getContext().getAssociativeCOFFSection(
-      cast<MCSectionCOFF>(StaticDtorSection), KeySym);
+      cast<MCSectionCOFF>(StaticDtorSection), KeySym, 0);
 }
 
 void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal(
     raw_ostream &OS, const GlobalValue *GV, const Mangler &Mang) const {
   if (!GV->hasDLLExportStorageClass() || GV->isDeclaration())
     return;
 
   const Triple &TT = getTargetTriple();

lib/MC/MCAsmStreamer.cpp

 void MCAsmStreamer::EmitWinEHHandlerData() {
   MCStreamer::EmitWinEHHandlerData();
 
   // Switch sections. Don't call SwitchSection directly, because that will
   // cause the section switch to be visible in the emitted assembly.
   // We only do this so the section switch that terminates the handler
   // data block is visible.
   WinEH::FrameInfo *CurFrame = getCurrentWinFrameInfo();
-  MCSection *XData =
-      WinEH::UnwindEmitter::getXDataSection(CurFrame->Function, getContext());
+  MCSection *TextSec = &CurFrame->Function->getSection();
+  MCSection *XData = getAssociatedXDataSection(TextSec);
   SwitchSectionNoChange(XData);
 
   OS << "\t.seh_handlerdata";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitWinCFIPushReg(unsigned Register) {
   MCStreamer::EmitWinCFIPushReg(Register);

lib/MC/MCContext.cpp

MCSectionELF *Result = new (ELFAllocator.Allocate())
                    Group, ~0, nullptr, nullptr);
   return Result;
 }
 
 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
                                          unsigned Characteristics,
                                          SectionKind Kind,
                                          StringRef COMDATSymName, int Selection,
+                                         unsigned UniqueID,
                                          const char *BeginSymName) {
   MCSymbol *COMDATSymbol = nullptr;
   if (!COMDATSymName.empty()) {
     COMDATSymbol = getOrCreateSymbol(COMDATSymName);
     COMDATSymName = COMDATSymbol->getName();
   }
 
+
   // Do the lookup, if we have a hit, return it.
-  COFFSectionKey T{Section, COMDATSymName, Selection};
+  COFFSectionKey T{Section, COMDATSymName, Selection, UniqueID};
   auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
   auto Iter = IterBool.first;
-  if (!IterBool.second)
+  if (!IterBool.second) {
     return Iter->second;
+  }
 
   MCSymbol *Begin = nullptr;
   if (BeginSymName)
     Begin = createTempSymbol(BeginSymName, false);
 
   StringRef CachedName = Iter->first.SectionName;
   MCSectionCOFF *Result = new (COFFAllocator.Allocate()) MCSectionCOFF(
       CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin);
 
   Iter->second = Result;
   return Result;
 }
 
 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
                                          unsigned Characteristics,
                                          SectionKind Kind,
                                          const char *BeginSymName) {
-  return getCOFFSection(Section, Characteristics, Kind, "", 0, BeginSymName);
+  return getCOFFSection(Section, Characteristics, Kind, "", 0, GenericSectionID,
+                        BeginSymName);
 }
 
 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section) {
-  COFFSectionKey T{Section, "", 0};
+  COFFSectionKey T{Section, "", 0, GenericSectionID};
   auto Iter = COFFUniquingMap.find(T);
   if (Iter == COFFUniquingMap.end())
     return nullptr;
   return Iter->second;
 }
 
 MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec,
-                                                    const MCSymbol *KeySym) {
-  // Return the normal section if we don't have to be associative.
-  if (!KeySym)
+                                                    const MCSymbol *KeySym,
+                                                    unsigned UniqueID) {
+  // Return the normal section if we don't have to be associative or unique.
+  if (!KeySym && UniqueID == GenericSectionID)
     return Sec;
 
-  // Make an associative section with the same name and kind as the normal
-  // section.
-  unsigned Characteristics =
-      Sec->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT;
+  // If we have a key symbol, make an associative section with the same name and
+  // kind as the normal section.
+  unsigned Characteristics = Sec->getCharacteristics();
+  if (KeySym) {
+    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
+    return getCOFFSection(Sec->getSectionName(), Characteristics,
+                          Sec->getKind(), KeySym->getName(),
+                          COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
+  }
+
   return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(),
-                        KeySym->getName(),
-                        COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE);
+                        "", 0, UniqueID);
 }
 
 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
   return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
 }
 
 //===----------------------------------------------------------------------===//
 // Dwarf Management

lib/MC/MCStreamer.cpp

 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWin64EH.h"
+#include "llvm/Support/COFF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 using namespace llvm;
 
 // Pin the vtables to this file.
 MCTargetStreamer::~MCTargetStreamer() {}
void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
   if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
     report_fatal_error("Starting a function before ending the previous one!");
 
   MCSymbol *StartProc = getContext().createTempSymbol();
   EmitLabel(StartProc);
 
   WinFrameInfos.push_back(new WinEH::FrameInfo(Symbol, StartProc));
   CurrentWinFrameInfo = WinFrameInfos.back();
+  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
 }
 
 void MCStreamer::EmitWinCFIEndProc() {
   EnsureValidWinFrameInfo();
   if (CurrentWinFrameInfo->ChainedParent)
     report_fatal_error("Not all chained regions terminated!");
 
   MCSymbol *Label = getContext().createTempSymbol();
   EmitLabel(Label);
   CurrentWinFrameInfo->End = Label;
 }
 
 void MCStreamer::EmitWinCFIStartChained() {
   EnsureValidWinFrameInfo();
 
   MCSymbol *StartProc = getContext().createTempSymbol();
   EmitLabel(StartProc);
 
   WinFrameInfos.push_back(new WinEH::FrameInfo(CurrentWinFrameInfo->Function,
                                                StartProc, CurrentWinFrameInfo));
   CurrentWinFrameInfo = WinFrameInfos.back();
+  CurrentWinFrameInfo->TextSection = getCurrentSectionOnly();
 }
 
 void MCStreamer::EmitWinCFIEndChained() {
   EnsureValidWinFrameInfo();
   if (!CurrentWinFrameInfo->ChainedParent)
     report_fatal_error("End of a chained region outside a chained region!");
 
   MCSymbol *Label = getContext().createTempSymbol();

 }
 
 void MCStreamer::EmitWinEHHandlerData() {
   EnsureValidWinFrameInfo();
   if (CurrentWinFrameInfo->ChainedParent)
     report_fatal_error("Chained unwind areas can't have handlers!");
 }
 
+static MCSection *getWinCFISection(MCContext &Context, unsigned *NextWinCFIID,
+                                   MCSection *MainCFISec,
+                                   const MCSection *TextSec) {
+  // If this is the main .text section, use the main unwind info section.
+  if (TextSec == Context.getObjectFileInfo()->getTextSection())
+    return MainCFISec;
+
+  const auto *TextSecCOFF = cast<MCSectionCOFF>(TextSec);
+  unsigned UniqueID = TextSecCOFF->getOrAssignWinCFISectionID(NextWinCFIID);
+
+  // If this section is COMDAT, this unwind section should be COMDAT associative
+  // with its group.
+  const MCSymbol *KeySym = nullptr;
+  if (TextSecCOFF->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT)
+    KeySym = TextSecCOFF->getCOMDATSymbol();
+
+  return Context.getAssociativeCOFFSection(cast<MCSectionCOFF>(MainCFISec),
+                                           KeySym, UniqueID);
+}
+
+MCSection *MCStreamer::getAssociatedPDataSection(const MCSection *TextSec) {
+  return getWinCFISection(getContext(), &NextWinCFIID,
+                          getContext().getObjectFileInfo()->getPDataSection(),
+                          TextSec);
+}
+
+MCSection *MCStreamer::getAssociatedXDataSection(const MCSection *TextSec) {
+  return getWinCFISection(getContext(), &NextWinCFIID,
+                          getContext().getObjectFileInfo()->getXDataSection(),
+                          TextSec);
+}
+
 void MCStreamer::EmitSyntaxDirective() {}
 
 void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
   EnsureValidWinFrameInfo();
 
   MCSymbol *Label = getContext().createTempSymbol();
   EmitLabel(Label);
 

lib/MC/MCWin64EH.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Win64EH.h"
 
-namespace llvm {
+using namespace llvm;
 
 // NOTE: All relocations generated here are 4-byte image-relative.
 
 static uint8_t CountOfUnwindCodes(std::vector<WinEH::Instruction> &Insns) {
   uint8_t Count = 0;
   for (const auto &I : Insns) {
     switch (static_cast<Win64EH::UnwindOpcodes>(I.Operation)) {
     case Win64EH::UOP_PushNonVol:
static void EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info) {
   else if (numCodes == 0) {
     // The minimum size of an UNWIND_INFO struct is 8 bytes. If we're not
     // a chained unwind info, if there is no handler, and if there are fewer
     // than 2 slots used in the unwind code array, we have to pad to 8 bytes.
     streamer.EmitIntValue(0, 4);
   }
 }
 
-namespace Win64EH {
-void UnwindEmitter::Emit(MCStreamer &Streamer) const {
-  MCContext &Context = Streamer.getContext();
-
+void llvm::Win64EH::UnwindEmitter::Emit(MCStreamer &Streamer) const {
   // Emit the unwind info structs first.
-  for (const auto &CFI : Streamer.getWinFrameInfos()) {
-    MCSection *XData = getXDataSection(CFI->Function, Context);
+  for (WinEH::FrameInfo *CFI : Streamer.getWinFrameInfos()) {
+    MCSection *XData = Streamer.getAssociatedXDataSection(CFI->TextSection);
     Streamer.SwitchSection(XData);
-    EmitUnwindInfo(Streamer, CFI);
+    ::EmitUnwindInfo(Streamer, CFI);
   }
 
   // Now emit RUNTIME_FUNCTION entries.
-  for (const auto &CFI : Streamer.getWinFrameInfos()) {
-    MCSection *PData = getPDataSection(CFI->Function, Context);
+  for (WinEH::FrameInfo *CFI : Streamer.getWinFrameInfos()) {
+    MCSection *PData = Streamer.getAssociatedPDataSection(CFI->TextSection);
     Streamer.SwitchSection(PData);
     EmitRuntimeFunction(Streamer, CFI);
   }
 }
 
-void UnwindEmitter::EmitUnwindInfo(MCStreamer &Streamer,
-                                   WinEH::FrameInfo *info) const {
+void llvm::Win64EH::UnwindEmitter::EmitUnwindInfo(
+    MCStreamer &Streamer, WinEH::FrameInfo *info) const {
   // Switch sections (the static function above is meant to be called from
   // here and from Emit().
-  MCContext &context = Streamer.getContext();
-  MCSection *xdataSect = getXDataSection(info->Function, context);
-  Streamer.SwitchSection(xdataSect);
+  MCSection *XData = Streamer.getAssociatedXDataSection(info->TextSection);
+  Streamer.SwitchSection(XData);
 
-  llvm::EmitUnwindInfo(Streamer, info);
-}
+  ::EmitUnwindInfo(Streamer, info);
 }
-} // End of namespace llvm
 

lib/MC/MCWinEH.cpp

 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/COFF.h"
 
 namespace llvm {
 namespace WinEH {
 
-/// We can't have one section for all .pdata or .xdata because the Microsoft
-/// linker seems to want all code relocations to refer to the same object file
-/// section. If the code described is comdat, create a new comdat section
-/// associated with that comdat. If the code described is not in the main .text
-/// section, make a new section for it. Otherwise use the main unwind info
-/// section.
-static MCSection *getUnwindInfoSection(StringRef SecName,
-                                       MCSectionCOFF *UnwindSec,
-                                       const MCSymbol *Function,
-                                       MCContext &Context) {
-  if (Function && Function->isInSection()) {
-    // If Function is in a COMDAT, get or create an unwind info section in that
-    // COMDAT group.
-    const MCSectionCOFF *FunctionSection =
-        cast<MCSectionCOFF>(&Function->getSection());
-    if (FunctionSection->getCharacteristics() & COFF::IMAGE_SCN_LNK_COMDAT) {
-      return Context.getAssociativeCOFFSection(
-          UnwindSec, FunctionSection->getCOMDATSymbol());
-    }
-
-    // If Function is in a section other than .text, create a new .pdata section.
-    // Otherwise use the plain .pdata section.
-    if (const auto *Section = dyn_cast<MCSectionCOFF>(FunctionSection)) {
-      StringRef CodeSecName = Section->getSectionName();
-      if (CodeSecName == ".text")
-        return UnwindSec;
-
-      if (CodeSecName.startswith(".text$"))
-        CodeSecName = CodeSecName.substr(6);
-
-      return Context.getCOFFSection((SecName + Twine('$') + CodeSecName).str(),
-                                    COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
-                                        COFF::IMAGE_SCN_MEM_READ,
-                                    SectionKind::getData());
-    }
-  }
-
-  return UnwindSec;
-
-}
-
-MCSection *UnwindEmitter::getPDataSection(const MCSymbol *Function,
-                                          MCContext &Context) {
-  MCSectionCOFF *PData =
-      cast<MCSectionCOFF>(Context.getObjectFileInfo()->getPDataSection());
-  return getUnwindInfoSection(".pdata", PData, Function, Context);
-}
-
-MCSection *UnwindEmitter::getXDataSection(const MCSymbol *Function,
-                                          MCContext &Context) {
-  MCSectionCOFF *XData =
-      cast<MCSectionCOFF>(Context.getObjectFileInfo()->getXDataSection());
-  return getUnwindInfoSection(".xdata", XData, Function, Context);
-}
+UnwindEmitter::~UnwindEmitter() {}
 
 }
 }
 

test/MC/COFF/seh-section-2.s

+# RUN: llvm-mc -filetype=obj -triple x86_64-pc-win32 %s | llvm-readobj -symbols | FileCheck %s
+
+# This assembly should make an object with two .text sections, two .xdata
+# sections, and two .pdata sections.
+
+        .def     f;
+        .scl    2;
+        .type   32;
+        .endef
+        .section        .text,"xr",discard,f
+        .globl  f
+        .p2align        4, 0x90
+f:                                      # @f
+.Ltmp0:
+.seh_proc f
+# BB#0:
+        subq    $40, %rsp
+.Ltmp1:
+        .seh_stackalloc 40
+.Ltmp2:
+        .seh_endprologue
+        callq   g
+        nop
+        addq    $40, %rsp
+        retq
+        .seh_handlerdata
+        .section        .text,"xr",discard,f
+.Ltmp3:
+        .seh_endproc
+
+        .def     g;
+        .scl    3;
+        .type   32;
+        .endef
+        .section        .text,"xr",associative,f
+        .p2align        4, 0x90
+g:                                      # @g
+.Ltmp4:
+.seh_proc g
+# BB#0:
+.Ltmp5:
+        .seh_endprologue
+        retq
+        .seh_handlerdata
+        .section        .text,"xr",associative,f
+.Ltmp6:
+        .seh_endproc
+
+
+# CHECK: Symbols [
+# CHECK:   Symbol {
+# CHECK:     Name: .text
+# CHECK:     Section: .text (4)
+# CHECK:     AuxSymbolCount: 1
+# CHECK:     AuxSectionDef {
+# CHECK:       Length: 15
+# CHECK:       RelocationCount: 1
+# CHECK:       LineNumberCount: 0
+# CHECK:       Checksum: 0xE17CBB7
+# CHECK:       Number: 4
+# CHECK:       Selection: Any (0x2)
+# CHECK:     }
+# CHECK:   }
+# CHECK:   Symbol {
+# CHECK:     Name: .xdata
+# CHECK:     Value: 0
+# CHECK:     Section: .xdata (5)
+# CHECK:     BaseType: Null (0x0)
+# CHECK:     ComplexType: Null (0x0)
+# CHECK:     StorageClass: Static (0x3)
+# CHECK:     AuxSymbolCount: 1
+# CHECK:     AuxSectionDef {
+# CHECK:       Length: 8
+# CHECK:       RelocationCount: 0
+# CHECK:       LineNumberCount: 0
+# CHECK:       Checksum: 0xFC539D1
+# CHECK:       Number: 4
+# CHECK:       Selection: Associative (0x5)
+# CHECK:       AssocSection: .text (4)
+# CHECK:     }
+# CHECK:   }
+# CHECK:   Symbol {
+# CHECK:     Name: .text
+# CHECK:     Value: 0
+# CHECK:     Section: .text (6)
+# CHECK:     BaseType: Null (0x0)
+# CHECK:     ComplexType: Null (0x0)
+# CHECK:     StorageClass: Static (0x3)
+# CHECK:     AuxSymbolCount: 1
+# CHECK:     AuxSectionDef {
+# CHECK:       Length: 1
+# CHECK:       RelocationCount: 0
+# CHECK:       LineNumberCount: 0
+# CHECK:       Checksum: 0x26D930A
+# CHECK:       Number: 4
+# CHECK:       Selection: Associative (0x5)
+# CHECK:       AssocSection: .text (4)
+# CHECK:     }
+# CHECK:   }
+# CHECK:   Symbol {
+# CHECK:     Name: .xdata
+# CHECK:     Value: 0
+# CHECK:     Section: .xdata (7)
+# CHECK:     BaseType: Null (0x0)
+# CHECK:     ComplexType: Null (0x0)
+# CHECK:     StorageClass: Static (0x3)
+# CHECK:     AuxSymbolCount: 1
+# CHECK:     AuxSectionDef {
+# CHECK:       Length: 8
+# CHECK:       RelocationCount: 0
+# CHECK:       LineNumberCount: 0
+# CHECK:       Checksum: 0xCCAA009E
+# CHECK:       Number: 4
+# CHECK:       Selection: Associative (0x5)
+# CHECK:       AssocSection: .text (4)
+# CHECK:     }
+# CHECK:   }
+# CHECK:   Symbol {
+# CHECK:     Name: .pdata
+# CHECK:     Value: 0
+# CHECK:     Section: .pdata (8)
+# CHECK:     BaseType: Null (0x0)
+# CHECK:     ComplexType: Null (0x0)
+# CHECK:     StorageClass: Static (0x3)
+# CHECK:     AuxSymbolCount: 1
+# CHECK:     AuxSectionDef {
+# CHECK:       Length: 12
+# CHECK:       RelocationCount: 3
+# CHECK:       LineNumberCount: 0
+# CHECK:       Checksum: 0xD92012AC
+# CHECK:       Number: 4
+# CHECK:       Selection: Associative (0x5)
+# CHECK:       AssocSection: .text (4)
+# CHECK:     }
+# CHECK:   }
+# CHECK:   Symbol {
+# CHECK:     Name: .pdata
+# CHECK:     Value: 0
+# CHECK:     Section: .pdata (9)
+# CHECK:     BaseType: Null (0x0)
+# CHECK:     ComplexType: Null (0x0)
+# CHECK:     StorageClass: Static (0x3)
+# CHECK:     AuxSymbolCount: 1
+# CHECK:     AuxSectionDef {
+# CHECK:       Length: 12
+# CHECK:       RelocationCount: 3
+# CHECK:       LineNumberCount: 0
+# CHECK:       Checksum: 0xCCAA009E
+# CHECK:       Number: 4
+# CHECK:       Selection: Associative (0x5)
+# CHECK:       AssocSection: .text (4)
+# CHECK:     }
+# CHECK:   }
+# CHECK: ]

test/MC/COFF/seh-section.s

 // This test ensures functions in custom sections get unwind info emitted in a
-// distinct .xdata section. Ideally we'd just emit a second .xdata section with
-// the same name and characteristics, but MC uniques sections by name and
-// characteristics, so that is not possible.
+// distinct .xdata section.
 // RUN: llvm-mc -filetype=obj -triple x86_64-pc-win32 %s | llvm-readobj -s -sd | FileCheck %s
 
-// CHECK:      Name: .xdata$foo
+// CHECK:      Name: .xdata
 // CHECK-NEXT: VirtualSize
 // CHECK-NEXT: VirtualAddress
 // CHECK-NEXT: RawDataSize: 8
 // CHECK-NEXT: PointerToRawData
 // CHECK-NEXT: PointerToRelocations
 // CHECK-NEXT: PointerToLineNumbers
 // CHECK-NEXT: RelocationCount: 0
 // CHECK-NEXT: LineNumberCount: 0
 // CHECK-NEXT: Characteristics [
 // CHECK-NEXT:   IMAGE_SCN_ALIGN_4BYTES
 // CHECK-NEXT:   IMAGE_SCN_CNT_INITIALIZED_DATA
 // CHECK-NEXT:   IMAGE_SCN_MEM_READ
 // CHECK-NEXT: ]
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 01050200 05500402
 // CHECK-NEXT: )
 
-// CHECK:      Name: .xdata$.mytext
+// CHECK:      Name: .xdata
 // CHECK-NEXT: VirtualSize
 // CHECK-NEXT: VirtualAddress
 // CHECK-NEXT: RawDataSize: 8
 // CHECK-NEXT: PointerToRawData
 // CHECK-NEXT: PointerToRelocations
 // CHECK-NEXT: PointerToLineNumbers
 // CHECK-NEXT: RelocationCount: 0
 // CHECK-NEXT: LineNumberCount: 0