CodeGen: Stick constant pool entries in COMDAT sections for WinCOFF

[majnemer]

Summary

COFF lacks a feature that other object file formats support: mergeable
sections.

To work around this, MSVC sticks constant pool entries in special COMDAT
sections so that each constant is in it's own section. This permits
unused constants to be dropped and it also allows duplicate constants in
different translation units to get merged together.

This fixes PR20262.

[grosbach]

No feedback on the Windows specific aspects, as I don't know how that stuff works well enough to comment.

Some general comments inline. A couple of cleanup changes that should be split out into separate patches and an API cleanup to get better layering.

include/llvm/ADT/StringExtras.h

56

These changes are distinct and should be a separate patch.

Also, documentation comment needs updated to match.

include/llvm/CodeGen/MachineConstantPool.h

124

Moving this to a helper function makes sense, but should be a separate patch.

It should take a datalayout argument, too, not the target machine.

include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

47

Having these take an MCStreamer reference is really awkward. If that's necessary, it implies something isn't right about the layering elsewhere.

lib/Target/X86/X86TargetObjectFile.cpp

166

OK, here's the layering issue. These functions should be strictly lookup, but here we're mutating things by calling an output function on the streamer. This function isn't the right place for figuring out the symbol names and emitting them to the streamer. GetCPISymbol() is a better place for that.

[majnemer]

Address review comments.

[majnemer]

include/llvm/ADT/StringExtras.h

56

Done.

include/llvm/CodeGen/MachineConstantPool.h

124

Done.

include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

47

Fixed.

lib/Target/X86/X86TargetObjectFile.cpp

166

Fixed.

[grosbach]

Rather terrifying how MSVC does this stuff, but patch LGTM.

Minor nit inline.

lib/Target/X86/X86TargetObjectFile.cpp

165

"Sym" is unused.

I think you can just directly do:

return getContext().getCOFFSection(".rdata", Characteristics, Kind, COMDATSymName, COFF::IMAGE_COMDAT_SELECT_ANY));

[majnemer]

Closed by commit rL213006 (authored by @majnemer).

include/llvm/ADT/StringExtras.h

 /// BufferEnd, returning a pointer to the start of the string.  This can be used
 /// like this: (note that the buffer must be large enough to handle any number):
 ///    char Buffer[40];
 ///    printf("0x%s", utohex_buffer(X, Buffer+40));
 ///
 /// This should only be used with unsigned types.
 ///
 template<typename IntTy>
-static inline char *utohex_buffer(IntTy X, char *BufferEnd) {
+static inline char *utohex_buffer(IntTy X, char *BufferEnd, bool LowerCase = false) {
   char *BufPtr = BufferEnd;
   *--BufPtr = 0;      // Null terminate buffer.
   if (X == 0) {
     *--BufPtr = '0';  // Handle special case.
     return BufPtr;
   }
 
   while (X) {
     unsigned char Mod = static_cast<unsigned char>(X) & 15;
-    *--BufPtr = hexdigit(Mod);
+    *--BufPtr = hexdigit(Mod, LowerCase);
     X >>= 4;
   }
   return BufPtr;
 }
 
-static inline std::string utohexstr(uint64_t X) {
+static inline std::string utohexstr(uint64_t X, bool LowerCase = false) {
   char Buffer[17];
-  return utohex_buffer(X, Buffer+17);
+  return utohex_buffer(X, Buffer+17, LowerCase);
 }
 
 static inline std::string utostr_32(uint32_t X, bool isNeg = false) {
   char Buffer[11];
   char *BufPtr = Buffer+11;
 
   if (X == 0) *--BufPtr = '0';  // Handle special case...
 

include/llvm/CodeGen/AsmPrinter.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_ASMPRINTER_H
 #define LLVM_CODEGEN_ASMPRINTER_H
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/IR/InlineAsm.h"
+#include "llvm/MC/SectionKind.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 class AsmPrinterHandler;
 class BlockAddress;
 class ByteStreamer;
 class GCStrategy;

include/llvm/CodeGen/MachineConstantPool.h

 /// constant pool to keep track of constants referenced by a function.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_MACHINECONSTANTPOOL_H
 #define LLVM_CODEGEN_MACHINECONSTANTPOOL_H
 
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/MC/SectionKind.h"
 #include <cassert>
 #include <climits>
 #include <vector>
 
 namespace llvm {
 
 class Constant;
 class FoldingSetNodeID;
public:
   /// 
   ///  0: This constant pool entry is guaranteed to never have a relocation
   ///     applied to it (because it holds a simple constant like '4').
   ///  1: This entry has relocations, but the entries are guaranteed to be
   ///     resolvable by the static linker, so the dynamic linker will never see
   ///     them.
   ///  2: This entry may have arbitrary relocations. 
   unsigned getRelocationInfo() const;
+
+  SectionKind getSectionKind(const TargetMachine &TM) const;
 };
   
 /// The MachineConstantPool class keeps track of constants referenced by a
 /// function which must be spilled to memory.  This is used for constants which
 /// are unable to be used directly as operands to instructions, which typically
 /// include floating point and large integer constants.
 ///
 /// Instructions reference the address of these constant pool constants through

include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 public:
   virtual ~TargetLoweringObjectFileELF() {}
 
   void emitPersonalityValue(MCStreamer &Streamer, const TargetMachine &TM,
                             const MCSymbol *Sym) const override;
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
-  const MCSection *getSectionForConstant(SectionKind Kind,
-                                         const Constant *C) const override;
+  const MCSection *getSectionForConstant(SectionKind Kind, const Constant *C,
+                                         MCStreamer &Streamer) const override;
 
   const MCSection *getExplicitSectionGlobal(const GlobalValue *GV,
                                         SectionKind Kind, Mangler &Mang,
                                         const TargetMachine &TM) const override;
 
   const MCSection *SelectSectionForGlobal(const GlobalValue *GV,
                                         SectionKind Kind, Mangler &Mang,
                                         const TargetMachine &TM) const override;
SelectSectionForGlobal(const GlobalValue *GV,
                            SectionKind Kind, Mangler &Mang,
                            const TargetMachine &TM) const override;
 
   const MCSection *
     getExplicitSectionGlobal(const GlobalValue *GV,
                              SectionKind Kind, Mangler &Mang,
                              const TargetMachine &TM) const override;
 
-  const MCSection *getSectionForConstant(SectionKind Kind,
-                                         const Constant *C) const override;
+  const MCSection *getSectionForConstant(SectionKind Kind, const Constant *C,
+                                         MCStreamer &Streamer) const override;
 
   /// The mach-o version of this method defaults to returning a stub reference.
   const MCExpr *
   getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
                           Mangler &Mang, const TargetMachine &TM,
                           MachineModuleInfo *MMI,
                           MCStreamer &Streamer) const override;
 

include/llvm/MC/MCSectionCOFF.h

class MCSectionCOFF : public MCSection {
 
     /// Characteristics - This is the Characteristics field of a section,
     /// drawn from the enums below.
     mutable unsigned Characteristics;
 
     /// 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.
-    const MCSymbol *COMDATSymbol;
+    MCSymbol *COMDATSymbol;
 
     /// Selection - This is the Selection field for the section symbol, if
     /// it is a COMDAT section (Characteristics & IMAGE_SCN_LNK_COMDAT) != 0
     mutable int Selection;
 
   private:
     friend class MCContext;
     MCSectionCOFF(StringRef Section, unsigned Characteristics,
-                  const MCSymbol *COMDATSymbol, int Selection, SectionKind K)
+                  MCSymbol *COMDATSymbol, int Selection, SectionKind K)
         : MCSection(SV_COFF, K), SectionName(Section),
           Characteristics(Characteristics), COMDATSymbol(COMDATSymbol),
           Selection(Selection) {
       assert ((Characteristics & 0x00F00000) == 0 &&
         "alignment must not be set upon section creation");
     }
     ~MCSectionCOFF();
 
   public:
     /// ShouldOmitSectionDirective - Decides whether a '.section' directive
     /// should be printed before the section name
     bool ShouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
 
     StringRef getSectionName() const { return SectionName; }
     std::string getLabelBeginName() const override {
       return SectionName.str() + "_begin";
     }
     std::string getLabelEndName() const override {
       return SectionName.str() + "_end";
     }
     unsigned getCharacteristics() const { return Characteristics; }
-    const MCSymbol *getCOMDATSymbol() const { return COMDATSymbol; }
+    MCSymbol *getCOMDATSymbol() const { return COMDATSymbol; }
     int getSelection() const { return Selection; }
 
     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;

include/llvm/Target/TargetLoweringObjectFile.h

public:
   /// Emit the module flags that the platform cares about.
   virtual void emitModuleFlags(MCStreamer &Streamer,
                                ArrayRef<Module::ModuleFlagEntry> Flags,
                                Mangler &Mang, const TargetMachine &TM) const {}
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   virtual const MCSection *getSectionForConstant(SectionKind Kind,
-                                                 const Constant *C) const;
+                                                 const Constant *C,
+                                                 MCStreamer &Streamer) const;
 
   /// Classify the specified global variable into a set of target independent
   /// categories embodied in SectionKind.
   static SectionKind getKindForGlobal(const GlobalValue *GV,
                                       const TargetMachine &TM);
 
   /// This method computes the appropriate section to emit the specified global
   /// variable or function definition. This should not be passed external (or

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

void AsmPrinter::EmitConstantPool() {
 
   // Calculate sections for constant pool entries. We collect entries to go into
   // the same section together to reduce amount of section switch statements.
   SmallVector<SectionCPs, 4> CPSections;
   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
     const MachineConstantPoolEntry &CPE = CP[i];
     unsigned Align = CPE.getAlignment();
 
-    SectionKind Kind;
-    switch (CPE.getRelocationInfo()) {
-    default: llvm_unreachable("Unknown section kind");
-    case 2: Kind = SectionKind::getReadOnlyWithRel(); break;
-    case 1:
-      Kind = SectionKind::getReadOnlyWithRelLocal();
-      break;
-    case 0:
-    switch (TM.getDataLayout()->getTypeAllocSize(CPE.getType())) {
-    case 4:  Kind = SectionKind::getMergeableConst4(); break;
-    case 8:  Kind = SectionKind::getMergeableConst8(); break;
-    case 16: Kind = SectionKind::getMergeableConst16();break;
-    default: Kind = SectionKind::getMergeableConst(); break;
-    }
-    }
+    SectionKind Kind = CPE.getSectionKind(TM);
 
     const Constant *C = nullptr;
     if (!CPE.isMachineConstantPoolEntry())
       C = CPE.Val.ConstVal;
 
-    const MCSection *S = getObjFileLowering().getSectionForConstant(Kind, C);
+    const MCSection *S =
+        getObjFileLowering().getSectionForConstant(Kind, C, OutStreamer);
 
     // The number of sections are small, just do a linear search from the
     // last section to the first.
     bool Found = false;
     unsigned SecIdx = CPSections.size();
     while (SecIdx != 0) {
       if (CPSections[--SecIdx].S == S) {
         Found = true;
         break;
       }
     }
     if (!Found) {
       SecIdx = CPSections.size();
       CPSections.push_back(SectionCPs(S, Align));
     }
 
     if (Align > CPSections[SecIdx].Alignment)
       CPSections[SecIdx].Alignment = Align;
     CPSections[SecIdx].CPEs.push_back(i);
   }
 
   // Now print stuff into the calculated sections.
+  const MCSection *CurSection = nullptr;
   for (unsigned i = 0, e = CPSections.size(); i != e; ++i) {
-    OutStreamer.SwitchSection(CPSections[i].S);
-    EmitAlignment(Log2_32(CPSections[i].Alignment));
-
     unsigned Offset = 0;
     for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) {
       unsigned CPI = CPSections[i].CPEs[j];
+      MCSymbol *Sym = GetCPISymbol(CPI);
+      if (!Sym->isUndefined())
+        continue;
+
+      if (CurSection != CPSections[i].S) {
+        OutStreamer.SwitchSection(CPSections[i].S);
+        EmitAlignment(Log2_32(CPSections[i].Alignment));
+        CurSection = CPSections[i].S;
+      }
+
       MachineConstantPoolEntry CPE = CP[CPI];
 
       // Emit inter-object padding for alignment.
       unsigned AlignMask = CPE.getAlignment() - 1;
       unsigned NewOffset = (Offset + AlignMask) & ~AlignMask;
       OutStreamer.EmitZeros(NewOffset - Offset);
 
       Type *Ty = CPE.getType();
       Offset = NewOffset + TM.getDataLayout()->getTypeAllocSize(Ty);
-      OutStreamer.EmitLabel(GetCPISymbol(CPI));
 
+      OutStreamer.EmitLabel(Sym);
       if (CPE.isMachineConstantPoolEntry())
         EmitMachineConstantPoolValue(CPE.Val.MachineCPVal);
       else
         EmitGlobalConstant(CPE.Val.ConstVal);
     }
   }
 }
 
if (// In PIC mode, we need to emit the jump table to the same section as the
       // for the function.
       F->isWeakForLinker()) {
     OutStreamer.SwitchSection(
         getObjFileLowering().SectionForGlobal(F, *Mang, TM));
   } else {
     // Otherwise, drop it in the readonly section.
     const MCSection *ReadOnlySection =
         getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly(),
-                                                   /*C=*/nullptr);
+                                                   /*C=*/nullptr, OutStreamer);
     OutStreamer.SwitchSection(ReadOnlySection);
     JTInDiffSection = true;
   }
 
   EmitAlignment(Log2_32(MJTI->getEntryAlignment(*TM.getDataLayout())));
 
   // Jump tables in code sections are marked with a data_region directive
   // where that's supported.

lib/CodeGen/MachineFunction.cpp

 
 
 unsigned MachineConstantPoolEntry::getRelocationInfo() const {
   if (isMachineConstantPoolEntry())
     return Val.MachineCPVal->getRelocationInfo();
   return Val.ConstVal->getRelocationInfo();
 }
 
+SectionKind
+MachineConstantPoolEntry::getSectionKind(const TargetMachine &TM) const {
+  SectionKind Kind;
+  switch (getRelocationInfo()) {
+  default:
+    llvm_unreachable("Unknown section kind");
+  case 2:
+    Kind = SectionKind::getReadOnlyWithRel();
+    break;
+  case 1:
+    Kind = SectionKind::getReadOnlyWithRelLocal();
+    break;
+  case 0:
+    switch (TM.getDataLayout()->getTypeAllocSize(getType())) {
+    case 4:
+      Kind = SectionKind::getMergeableConst4();
+      break;
+    case 8:
+      Kind = SectionKind::getMergeableConst8();
+      break;
+    case 16:
+      Kind = SectionKind::getMergeableConst16();
+      break;
+    default:
+      Kind = SectionKind::getMergeableConst();
+      break;
+    }
+  }
+  return Kind;
+}
+
 MachineConstantPool::~MachineConstantPool() {
   for (unsigned i = 0, e = Constants.size(); i != e; ++i)
     if (Constants[i].isMachineConstantPoolEntry())
       delete Constants[i].Val.MachineCPVal;
   for (DenseSet<MachineConstantPoolValue*>::iterator I =
        MachineCPVsSharingEntries.begin(), E = MachineCPVsSharingEntries.end();
        I != E; ++I)
     delete *I;

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
   return DataRelROSection;
 }
 
 /// getSectionForConstant - Given a mergeable constant with the
 /// specified size and relocation information, return a section that it
 /// should be placed in.
 const MCSection *
 TargetLoweringObjectFileELF::getSectionForConstant(SectionKind Kind,
-                                                   const Constant *C) const {
+                                                   const Constant *C,
+                                                   MCStreamer &Streamer) const {
   if (Kind.isMergeableConst4() && MergeableConst4Section)
     return MergeableConst4Section;
   if (Kind.isMergeableConst8() && MergeableConst8Section)
     return MergeableConst8Section;
   if (Kind.isMergeableConst16() && MergeableConst16Section)
     return MergeableConst16Section;
   if (Kind.isReadOnly())
     return ReadOnlySection;
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
   // with the .zerofill directive (aka .lcomm).
   if (Kind.isBSSLocal())
     return DataBSSSection;
 
   // Otherwise, just drop the variable in the normal data section.
   return DataSection;
 }
 
-const MCSection *
-TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind,
-                                                     const Constant *C) const {
+const MCSection *TargetLoweringObjectFileMachO::getSectionForConstant(
+    SectionKind Kind, const Constant *C, MCStreamer &Streamer) const {
   // If this constant requires a relocation, we have to put it in the data
   // segment, not in the text segment.
   if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
     return ConstDataSection;
 
   if (Kind.isMergeableConst4())
     return FourByteConstantSection;
   if (Kind.isMergeableConst8())

lib/MC/MCContext.cpp

const MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
   // Do the lookup, if we have a hit, return it.
 
   SectionGroupTriple T(Section, COMDATSymName, Selection);
   auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
   auto Iter = IterBool.first;
   if (!IterBool.second)
     return Iter->second;
 
-  const MCSymbol *COMDATSymbol = nullptr;
+  MCSymbol *COMDATSymbol = nullptr;
   if (!COMDATSymName.empty())
     COMDATSymbol = GetOrCreateSymbol(COMDATSymName);
 
   StringRef CachedName = std::get<0>(Iter->first);
   MCSectionCOFF *Result = new (*this)
       MCSectionCOFF(CachedName, Characteristics, COMDATSymbol, Selection, Kind);
 
   Iter->second = Result;

lib/Target/NVPTX/NVPTXTargetObjectFile.h

void Initialize(MCContext &ctx, const TargetMachine &TM) override {
     DwarfARangesSection =
         new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
     DwarfRangesSection =
         new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
     DwarfMacroInfoSection =
         new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
   }
 
-  const MCSection *getSectionForConstant(SectionKind Kind,
-                                         const Constant *C) const override {
+  const MCSection *getSectionForConstant(SectionKind Kind, const Constant *C,
+                                         MCStreamer &Streamer) const override {
     return ReadOnlySection;
   }
 
   const MCSection *getExplicitSectionGlobal(const GlobalValue *GV,
                                        SectionKind Kind, Mangler &Mang,
                                        const TargetMachine &TM) const override {
     return DataSection;
   }
 
 };
 
 } // end namespace llvm
 
 #endif

lib/Target/TargetLoweringObjectFile.cpp

if (Kind.isReadOnly() && ReadOnlySection != nullptr)
     return ReadOnlySection;
 
   return getDataSection();
 }
 
 /// getSectionForConstant - Given a mergable constant with the
 /// specified size and relocation information, return a section that it
 /// should be placed in.
-const MCSection *
-TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind,
-                                                const Constant *C) const {
+const MCSection *TargetLoweringObjectFile::getSectionForConstant(
+    SectionKind Kind, const Constant *C, MCStreamer &Streamer) const {
   if (Kind.isReadOnly() && ReadOnlySection != nullptr)
     return ReadOnlySection;
 
   return DataSection;
 }
 
 /// getTTypeGlobalReference - Return an MCExpr to use for a
 /// reference to the specified global variable from exception

lib/Target/X86/X86AsmPrinter.h

 //===-- X86AsmPrinter.h - X86 implementation of AsmPrinter ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef X86ASMPRINTER_H
 #define X86ASMPRINTER_H
 
 #include "X86Subtarget.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/StackMaps.h"
 #include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 class MCStreamer;
 class MCSymbol;
 
 class LLVM_LIBRARY_VISIBILITY X86AsmPrinter : public AsmPrinter {
   const X86Subtarget *Subtarget;
   StackMaps SM;
+  DenseSet<const Constant *> EmittedConstantPoolValues;
 
   void GenerateExportDirective(const MCSymbol *Sym, bool IsData);
 
  public:
   explicit X86AsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
     : AsmPrinter(TM, Streamer), SM(*this) {
     Subtarget = &TM.getSubtarget<X86Subtarget>();
   }
public:
 
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                        unsigned AsmVariant, const char *ExtraCode,
                        raw_ostream &OS) override;
   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
                              unsigned AsmVariant, const char *ExtraCode,
                              raw_ostream &OS) override;
 
+  /// \brief Return the symbol for the specified constant pool entry.
+  MCSymbol *GetCPISymbol(unsigned CPID) const override;
+
   bool runOnMachineFunction(MachineFunction &F) override;
 };
 
 } // end namespace llvm
 
 #endif

lib/Target/X86/X86AsmPrinter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "X86AsmPrinter.h"
 #include "InstPrinter/X86ATTInstPrinter.h"
 #include "MCTargetDesc/X86BaseInfo.h"
 #include "X86InstrInfo.h"
 #include "X86MachineFunctionInfo.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/MachineValueType.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/COFF.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TargetRegistry.h"
 using namespace llvm;
else
     // pointers need to be indirect and pc-rel. We accomplish this by
     // using NLPs; however, sometimes the types are local to the file.
     // We need to fill in the value for the NLP in those cases.
     OutStreamer.EmitValue(
         MCSymbolRefExpr::Create(MCSym.getPointer(), OutStreamer.getContext()),
         4 /*size*/);
 }
 
+MCSymbol *X86AsmPrinter::GetCPISymbol(unsigned CPID) const {
+  if (Subtarget->isTargetKnownWindowsMSVC()) {
+    const MachineConstantPoolEntry &CPE =
+        MF->getConstantPool()->getConstants()[CPID];
+    if (!CPE.isMachineConstantPoolEntry()) {
+      SectionKind Kind = CPE.getSectionKind(TM);
+      const Constant *C = CPE.Val.ConstVal;
+      const MCSectionCOFF *S = cast<MCSectionCOFF>(
+          getObjFileLowering().getSectionForConstant(Kind, C, OutStreamer));
+      if (MCSymbol *Sym = S->getCOMDATSymbol())
+        return Sym;
+    }
+  }
+
+  return AsmPrinter::GetCPISymbol(CPID);
+}
+
 void X86AsmPrinter::GenerateExportDirective(const MCSymbol *Sym, bool IsData) {
   SmallString<128> Directive;
   raw_svector_ostream OS(Directive);
   StringRef Name = Sym->getName();
 
   if (Subtarget->isTargetKnownWindowsMSVC())
     OS << " /EXPORT:";
   else

lib/Target/X86/X86TargetObjectFile.h

 //===-- X86TargetObjectFile.h - X86 Object Info -----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_X86_TARGETOBJECTFILE_H
 #define LLVM_TARGET_X86_TARGETOBJECTFILE_H
 
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 
   /// X86_64MachoTargetObjectFile - This TLOF implementation is used for Darwin
   /// x86-64.
   class X86_64MachoTargetObjectFile : public TargetLoweringObjectFileMachO {
class X86LinuxTargetObjectFile : public TargetLoweringObjectFileELF {
     const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const override;
   };
 
   /// \brief This implementation is used for Windows targets on x86 and x86-64.
   class X86WindowsTargetObjectFile : public TargetLoweringObjectFileCOFF {
     const MCExpr *
     getExecutableRelativeSymbol(const ConstantExpr *CE, Mangler &Mang,
                                 const TargetMachine &TM) const override;
+
+    /// \brief Given a mergeable constant with the specified size and relocation
+    /// information, return a section that it should be placed in.
+    const MCSection *getSectionForConstant(SectionKind Kind, const Constant *C,
+                                           MCStreamer &Streamer) const override;
   };
 
 } // end namespace llvm
 
 #endif

lib/Target/X86/X86TargetObjectFile.cpp

 //===-- X86TargetObjectFile.cpp - X86 Object Info -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86TargetObjectFile.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Target/TargetLowering.h"
 
 using namespace llvm;
 using namespace dwarf;
 
 const MCExpr *X86_64MachoTargetObjectFile::getTTypeGlobalReference(
const MCExpr *X86WindowsTargetObjectFile::getExecutableRelativeSymbol(
   // An image-relative, thread-local, symbol makes no sense.
   if (GVLHS->isThreadLocal())
     return nullptr;
 
   return MCSymbolRefExpr::Create(TM.getSymbol(GVLHS, Mang),
                                  MCSymbolRefExpr::VK_COFF_IMGREL32,
                                  getContext());
 }
+
+static std::string APIntToHexString(const APInt &AI, unsigned Width) {
+  std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
+  unsigned Size = HexString.size();
+  assert(Width >= Size && "hex string is too large!");
+  HexString.insert(HexString.begin(), Width - Size, '0');
+
+  return HexString;
+}
+
+
+static std::string scalarConstantToHexString(const Constant *C) {
+  Type *Ty = C->getType();
+  if (Ty->isFloatTy()) {
+    const auto *CFP = cast<ConstantFP>(C);
+    return APIntToHexString(CFP->getValueAPF().bitcastToAPInt(), /*Width=*/8);
+  } else if (Ty->isDoubleTy()) {
+    const auto *CFP = cast<ConstantFP>(C);
+    return APIntToHexString(CFP->getValueAPF().bitcastToAPInt(), /*Width=*/16);
+  } else if (const auto *ITy = dyn_cast<IntegerType>(Ty)) {
+    const auto *CI = cast<ConstantInt>(C);
+    return APIntToHexString(CI->getValue(), (ITy->getBitWidth() / 8) * 2);
+  }
+  llvm_unreachable("unexpected constant pool element type!");
+}
+
+const MCSection *X86WindowsTargetObjectFile::getSectionForConstant(
+    SectionKind Kind, const Constant *C, MCStreamer &Streamer) const {
+  if (Kind.isReadOnly()) {
+    if (C) {
+      Type *Ty = C->getType();
+      SmallString<32> COMDATSymName;
+      if (Ty->isFloatTy() || Ty->isDoubleTy()) {
+        COMDATSymName = "__real@";
+        COMDATSymName += scalarConstantToHexString(C);
+      } else if (const auto *VTy = dyn_cast<VectorType>(Ty)) {
+        uint64_t NumBits = VTy->getBitWidth();
+        if (NumBits == 128 || NumBits == 256) {
+          const auto *CDV = cast<ConstantDataVector>(C);
+          COMDATSymName = NumBits == 128 ? "__xmm@" : "__ymm@";
+          for (int I = CDV->getNumElements() - 1, E = -1; I != E; --I)
+            COMDATSymName +=
+                scalarConstantToHexString(CDV->getElementAsConstant(I));
+        }
+      }
+      if (!COMDATSymName.empty()) {
+        unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+                                   COFF::IMAGE_SCN_MEM_READ |
+                                   COFF::IMAGE_SCN_LNK_COMDAT;
+        const MCSectionCOFF *S =
+            cast<MCSectionCOFF>(getContext().getCOFFSection(
+                ".rdata", Characteristics, Kind, COMDATSymName,
+                COFF::IMAGE_COMDAT_SELECT_ANY));
+        MCSymbol *Sym = S->getCOMDATSymbol();
+        if (Sym->isUndefined())
+          Streamer.EmitSymbolAttribute(Sym, MCSA_Global);
+        return S;
+      }
+    }
+
+    if (ReadOnlySection)
+      return ReadOnlySection;
+  }
+
+  return DataSection;
+}

lib/Target/XCore/XCoreTargetObjectFile.h

const MCSection *
                                SectionKind Kind, Mangler &Mang,
                                const TargetMachine &TM) const override;
 
     const MCSection *
       SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
                              Mangler &Mang,
                              const TargetMachine &TM) const override;
 
-    const MCSection *getSectionForConstant(SectionKind Kind,
-                                           const Constant *C) const override;
+    const MCSection *getSectionForConstant(SectionKind Kind, const Constant *C,
+                                           MCStreamer &Streamer) const override;
   };
 } // end namespace llvm
 
 #endif

lib/Target/XCore/XCoreTargetObjectFile.cpp

if (TM.getCodeModel() == CodeModel::Small ||
     if (Kind.isDataRel())               return DataSectionLarge;
     if (Kind.isReadOnlyWithRel())       return DataRelROSectionLarge;
   }
 
   assert((Kind.isThreadLocal() || Kind.isCommon()) && "Unknown section kind");
   report_fatal_error("Target does not support TLS or Common sections");
 }
 
-const MCSection *
-XCoreTargetObjectFile::getSectionForConstant(SectionKind Kind,
-                                             const Constant *C) const {
+const MCSection *XCoreTargetObjectFile::getSectionForConstant(
+    SectionKind Kind, const Constant *C, MCStreamer &Streamer) const {
   if (Kind.isMergeableConst4())           return MergeableConst4Section;
   if (Kind.isMergeableConst8())           return MergeableConst8Section;
   if (Kind.isMergeableConst16())          return MergeableConst16Section;
   assert((Kind.isReadOnly() || Kind.isReadOnlyWithRel()) &&
          "Unknown section kind");
   // We assume the size of the object is never greater than CodeModelLargeSize.
   // To handle CodeModelLargeSize changes to AsmPrinter would be required.
   return ReadOnlySection;
 }

test/CodeGen/X86/constant-pool-sharing.ll

-; RUN: llc < %s -mtriple=x86_64-linux -mcpu=corei7 | FileCheck %s
-; RUN: llc < %s -mtriple=x86_64-win32 -mcpu=corei7 | FileCheck %s
+; RUN: llc < %s -mtriple=x86_64-linux -mcpu=corei7 | FileCheck %s --check-prefix=COMMON --check-prefix=LINUX
+; RUN: llc < %s -mtriple=x86_64-win32 -mcpu=corei7 | FileCheck %s --check-prefix=COMMON --check-prefix=MSVC
 
 ; llc should share constant pool entries between this integer vector
 ; and this floating-point vector since they have the same encoding.
 
-; CHECK:  LCPI0_0(%rip), %xmm0
-; CHECK:  movaps        %xmm0, ({{%rdi|%rcx}})
-; CHECK:  movaps        %xmm0, ({{%rsi|%rdx}})
+; LINUX:   LCPI0_0(%rip), %xmm0
+; MSVC:    __xmm@40000000400000004000000040000000(%rip), %xmm0
+; COMMON:  movaps        %xmm0, ({{%rdi|%rcx}})
+; COMMON:  movaps        %xmm0, ({{%rsi|%rdx}})
 
 define void @foo(<4 x i32>* %p, <4 x float>* %q, i1 %t) nounwind {
 entry:
   br label %loop
 loop:
   store <4 x i32><i32 1073741824, i32 1073741824, i32 1073741824, i32 1073741824>, <4 x i32>* %p
   store <4 x float><float 2.0, float 2.0, float 2.0, float 2.0>, <4 x float>* %q
   br i1 %t, label %loop, label %ret
 ret:
   ret void
 }