Home | History | Annotate | Download | only in CodeGen 
      1 //===-- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info --===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements classes used to handle lowerings specific to common
     11 // object file formats.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
     16 #include "llvm/ADT/SmallString.h"
     17 #include "llvm/ADT/StringExtras.h"
     18 #include "llvm/ADT/Triple.h"
     19 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
     20 #include "llvm/IR/Constants.h"
     21 #include "llvm/IR/DataLayout.h"
     22 #include "llvm/IR/DerivedTypes.h"
     23 #include "llvm/IR/Function.h"
     24 #include "llvm/IR/GlobalVariable.h"
     25 #include "llvm/IR/Mangler.h"
     26 #include "llvm/IR/Module.h"
     27 #include "llvm/MC/MCAsmInfo.h"
     28 #include "llvm/MC/MCContext.h"
     29 #include "llvm/MC/MCExpr.h"
     30 #include "llvm/MC/MCSectionCOFF.h"
     31 #include "llvm/MC/MCSectionELF.h"
     32 #include "llvm/MC/MCSectionMachO.h"
     33 #include "llvm/MC/MCStreamer.h"
     34 #include "llvm/MC/MCSymbolELF.h"
     35 #include "llvm/MC/MCValue.h"
     36 #include "llvm/ProfileData/InstrProf.h"
     37 #include "llvm/Support/COFF.h"
     38 #include "llvm/Support/Dwarf.h"
     39 #include "llvm/Support/ELF.h"
     40 #include "llvm/Support/ErrorHandling.h"
     41 #include "llvm/Support/raw_ostream.h"
     42 #include "llvm/Target/TargetLowering.h"
     43 #include "llvm/Target/TargetMachine.h"
     44 #include "llvm/Target/TargetSubtargetInfo.h"
     45 using namespace llvm;
     46 using namespace dwarf;
     47 
     48 //===----------------------------------------------------------------------===//
     49 //                                  ELF
     50 //===----------------------------------------------------------------------===//
     51 
     52 MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
     53     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
     54     MachineModuleInfo *MMI) const {
     55   unsigned Encoding = getPersonalityEncoding();
     56   if ((Encoding & 0x80) == dwarf::DW_EH_PE_indirect)
     57     return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
     58                                           TM.getSymbol(GV, Mang)->getName());
     59   if ((Encoding & 0x70) == dwarf::DW_EH_PE_absptr)
     60     return TM.getSymbol(GV, Mang);
     61   report_fatal_error("We do not support this DWARF encoding yet!");
     62 }
     63 
     64 void TargetLoweringObjectFileELF::emitPersonalityValue(
     65     MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
     66   SmallString<64> NameData("DW.ref.");
     67   NameData += Sym->getName();
     68   MCSymbolELF *Label =
     69       cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
     70   Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
     71   Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
     72   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
     73   MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
     74                                                    ELF::SHT_PROGBITS, Flags, 0);
     75   unsigned Size = DL.getPointerSize();
     76   Streamer.SwitchSection(Sec);
     77   Streamer.EmitValueToAlignment(DL.getPointerABIAlignment());
     78   Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
     79   const MCExpr *E = MCConstantExpr::create(Size, getContext());
     80   Streamer.emitELFSize(Label, E);
     81   Streamer.EmitLabel(Label);
     82 
     83   Streamer.EmitSymbolValue(Sym, Size);
     84 }
     85 
     86 const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
     87     const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
     88     const TargetMachine &TM, MachineModuleInfo *MMI,
     89     MCStreamer &Streamer) const {
     90 
     91   if (Encoding & dwarf::DW_EH_PE_indirect) {
     92     MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
     93 
     94     MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", Mang, TM);
     95 
     96     // Add information about the stub reference to ELFMMI so that the stub
     97     // gets emitted by the asmprinter.
     98     MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
     99     if (!StubSym.getPointer()) {
    100       MCSymbol *Sym = TM.getSymbol(GV, Mang);
    101       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    102     }
    103 
    104     return TargetLoweringObjectFile::
    105       getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
    106                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
    107   }
    108 
    109   return TargetLoweringObjectFile::
    110     getTTypeGlobalReference(GV, Encoding, Mang, TM, MMI, Streamer);
    111 }
    112 
    113 static SectionKind
    114 getELFKindForNamedSection(StringRef Name, SectionKind K) {
    115   // N.B.: The defaults used in here are no the same ones used in MC.
    116   // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
    117   // both gas and MC will produce a section with no flags. Given
    118   // section(".eh_frame") gcc will produce:
    119   //
    120   //   .section   .eh_frame,"a",@progbits
    121 
    122   if (Name == getInstrProfCoverageSectionName(false))
    123     return SectionKind::getMetadata();
    124 
    125   if (Name.empty() || Name[0] != '.') return K;
    126 
    127   // Some lame default implementation based on some magic section names.
    128   if (Name == ".bss" ||
    129       Name.startswith(".bss.") ||
    130       Name.startswith(".gnu.linkonce.b.") ||
    131       Name.startswith(".llvm.linkonce.b.") ||
    132       Name == ".sbss" ||
    133       Name.startswith(".sbss.") ||
    134       Name.startswith(".gnu.linkonce.sb.") ||
    135       Name.startswith(".llvm.linkonce.sb."))
    136     return SectionKind::getBSS();
    137 
    138   if (Name == ".tdata" ||
    139       Name.startswith(".tdata.") ||
    140       Name.startswith(".gnu.linkonce.td.") ||
    141       Name.startswith(".llvm.linkonce.td."))
    142     return SectionKind::getThreadData();
    143 
    144   if (Name == ".tbss" ||
    145       Name.startswith(".tbss.") ||
    146       Name.startswith(".gnu.linkonce.tb.") ||
    147       Name.startswith(".llvm.linkonce.tb."))
    148     return SectionKind::getThreadBSS();
    149 
    150   return K;
    151 }
    152 
    153 
    154 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
    155 
    156   if (Name == ".init_array")
    157     return ELF::SHT_INIT_ARRAY;
    158 
    159   if (Name == ".fini_array")
    160     return ELF::SHT_FINI_ARRAY;
    161 
    162   if (Name == ".preinit_array")
    163     return ELF::SHT_PREINIT_ARRAY;
    164 
    165   if (K.isBSS() || K.isThreadBSS())
    166     return ELF::SHT_NOBITS;
    167 
    168   return ELF::SHT_PROGBITS;
    169 }
    170 
    171 static unsigned getELFSectionFlags(SectionKind K) {
    172   unsigned Flags = 0;
    173 
    174   if (!K.isMetadata())
    175     Flags |= ELF::SHF_ALLOC;
    176 
    177   if (K.isText())
    178     Flags |= ELF::SHF_EXECINSTR;
    179 
    180   if (K.isWriteable())
    181     Flags |= ELF::SHF_WRITE;
    182 
    183   if (K.isThreadLocal())
    184     Flags |= ELF::SHF_TLS;
    185 
    186   if (K.isMergeableCString() || K.isMergeableConst())
    187     Flags |= ELF::SHF_MERGE;
    188 
    189   if (K.isMergeableCString())
    190     Flags |= ELF::SHF_STRINGS;
    191 
    192   return Flags;
    193 }
    194 
    195 static const Comdat *getELFComdat(const GlobalValue *GV) {
    196   const Comdat *C = GV->getComdat();
    197   if (!C)
    198     return nullptr;
    199 
    200   if (C->getSelectionKind() != Comdat::Any)
    201     report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
    202                        C->getName() + "' cannot be lowered.");
    203 
    204   return C;
    205 }
    206 
    207 MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
    208     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    209     const TargetMachine &TM) const {
    210   StringRef SectionName = GV->getSection();
    211 
    212   // Infer section flags from the section name if we can.
    213   Kind = getELFKindForNamedSection(SectionName, Kind);
    214 
    215   StringRef Group = "";
    216   unsigned Flags = getELFSectionFlags(Kind);
    217   if (const Comdat *C = getELFComdat(GV)) {
    218     Group = C->getName();
    219     Flags |= ELF::SHF_GROUP;
    220   }
    221   return getContext().getELFSection(SectionName,
    222                                     getELFSectionType(SectionName, Kind), Flags,
    223                                     /*EntrySize=*/0, Group);
    224 }
    225 
    226 /// Return the section prefix name used by options FunctionsSections and
    227 /// DataSections.
    228 static StringRef getSectionPrefixForGlobal(SectionKind Kind) {
    229   if (Kind.isText())
    230     return ".text";
    231   if (Kind.isReadOnly())
    232     return ".rodata";
    233   if (Kind.isBSS())
    234     return ".bss";
    235   if (Kind.isThreadData())
    236     return ".tdata";
    237   if (Kind.isThreadBSS())
    238     return ".tbss";
    239   if (Kind.isData())
    240     return ".data";
    241   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    242   return ".data.rel.ro";
    243 }
    244 
    245 static MCSectionELF *
    246 selectELFSectionForGlobal(MCContext &Ctx, const GlobalValue *GV,
    247                           SectionKind Kind, Mangler &Mang,
    248                           const TargetMachine &TM, bool EmitUniqueSection,
    249                           unsigned Flags, unsigned *NextUniqueID) {
    250   unsigned EntrySize = 0;
    251   if (Kind.isMergeableCString()) {
    252     if (Kind.isMergeable2ByteCString()) {
    253       EntrySize = 2;
    254     } else if (Kind.isMergeable4ByteCString()) {
    255       EntrySize = 4;
    256     } else {
    257       EntrySize = 1;
    258       assert(Kind.isMergeable1ByteCString() && "unknown string width");
    259     }
    260   } else if (Kind.isMergeableConst()) {
    261     if (Kind.isMergeableConst4()) {
    262       EntrySize = 4;
    263     } else if (Kind.isMergeableConst8()) {
    264       EntrySize = 8;
    265     } else if (Kind.isMergeableConst16()) {
    266       EntrySize = 16;
    267     } else {
    268       assert(Kind.isMergeableConst32() && "unknown data width");
    269       EntrySize = 32;
    270     }
    271   }
    272 
    273   StringRef Group = "";
    274   if (const Comdat *C = getELFComdat(GV)) {
    275     Flags |= ELF::SHF_GROUP;
    276     Group = C->getName();
    277   }
    278 
    279   bool UniqueSectionNames = TM.getUniqueSectionNames();
    280   SmallString<128> Name;
    281   if (Kind.isMergeableCString()) {
    282     // We also need alignment here.
    283     // FIXME: this is getting the alignment of the character, not the
    284     // alignment of the global!
    285     unsigned Align = GV->getParent()->getDataLayout().getPreferredAlignment(
    286         cast<GlobalVariable>(GV));
    287 
    288     std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
    289     Name = SizeSpec + utostr(Align);
    290   } else if (Kind.isMergeableConst()) {
    291     Name = ".rodata.cst";
    292     Name += utostr(EntrySize);
    293   } else {
    294     Name = getSectionPrefixForGlobal(Kind);
    295   }
    296   // FIXME: Extend the section prefix to include hotness catagories such as .hot
    297   //  or .unlikely for functions.
    298 
    299   if (EmitUniqueSection && UniqueSectionNames) {
    300     Name.push_back('.');
    301     TM.getNameWithPrefix(Name, GV, Mang, true);
    302   }
    303   unsigned UniqueID = MCContext::GenericSectionID;
    304   if (EmitUniqueSection && !UniqueSectionNames) {
    305     UniqueID = *NextUniqueID;
    306     (*NextUniqueID)++;
    307   }
    308   return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
    309                            EntrySize, Group, UniqueID);
    310 }
    311 
    312 MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
    313     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    314     const TargetMachine &TM) const {
    315   unsigned Flags = getELFSectionFlags(Kind);
    316 
    317   // If we have -ffunction-section or -fdata-section then we should emit the
    318   // global value to a uniqued section specifically for it.
    319   bool EmitUniqueSection = false;
    320   if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
    321     if (Kind.isText())
    322       EmitUniqueSection = TM.getFunctionSections();
    323     else
    324       EmitUniqueSection = TM.getDataSections();
    325   }
    326   EmitUniqueSection |= GV->hasComdat();
    327 
    328   return selectELFSectionForGlobal(getContext(), GV, Kind, Mang, TM,
    329                                    EmitUniqueSection, Flags, &NextUniqueID);
    330 }
    331 
    332 MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
    333     const Function &F, Mangler &Mang, const TargetMachine &TM) const {
    334   // If the function can be removed, produce a unique section so that
    335   // the table doesn't prevent the removal.
    336   const Comdat *C = F.getComdat();
    337   bool EmitUniqueSection = TM.getFunctionSections() || C;
    338   if (!EmitUniqueSection)
    339     return ReadOnlySection;
    340 
    341   return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
    342                                    Mang, TM, EmitUniqueSection, ELF::SHF_ALLOC,
    343                                    &NextUniqueID);
    344 }
    345 
    346 bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection(
    347     bool UsesLabelDifference, const Function &F) const {
    348   // We can always create relative relocations, so use another section
    349   // that can be marked non-executable.
    350   return false;
    351 }
    352 
    353 /// Given a mergeable constant with the specified size and relocation
    354 /// information, return a section that it should be placed in.
    355 MCSection *TargetLoweringObjectFileELF::getSectionForConstant(
    356     const DataLayout &DL, SectionKind Kind, const Constant *C,
    357     unsigned &Align) const {
    358   if (Kind.isMergeableConst4() && MergeableConst4Section)
    359     return MergeableConst4Section;
    360   if (Kind.isMergeableConst8() && MergeableConst8Section)
    361     return MergeableConst8Section;
    362   if (Kind.isMergeableConst16() && MergeableConst16Section)
    363     return MergeableConst16Section;
    364   if (Kind.isMergeableConst32() && MergeableConst32Section)
    365     return MergeableConst32Section;
    366   if (Kind.isReadOnly())
    367     return ReadOnlySection;
    368 
    369   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    370   return DataRelROSection;
    371 }
    372 
    373 static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
    374                                               bool IsCtor, unsigned Priority,
    375                                               const MCSymbol *KeySym) {
    376   std::string Name;
    377   unsigned Type;
    378   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
    379   StringRef COMDAT = KeySym ? KeySym->getName() : "";
    380 
    381   if (KeySym)
    382     Flags |= ELF::SHF_GROUP;
    383 
    384   if (UseInitArray) {
    385     if (IsCtor) {
    386       Type = ELF::SHT_INIT_ARRAY;
    387       Name = ".init_array";
    388     } else {
    389       Type = ELF::SHT_FINI_ARRAY;
    390       Name = ".fini_array";
    391     }
    392     if (Priority != 65535) {
    393       Name += '.';
    394       Name += utostr(Priority);
    395     }
    396   } else {
    397     // The default scheme is .ctor / .dtor, so we have to invert the priority
    398     // numbering.
    399     if (IsCtor)
    400       Name = ".ctors";
    401     else
    402       Name = ".dtors";
    403     if (Priority != 65535) {
    404       Name += '.';
    405       Name += utostr(65535 - Priority);
    406     }
    407     Type = ELF::SHT_PROGBITS;
    408   }
    409 
    410   return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
    411 }
    412 
    413 MCSection *TargetLoweringObjectFileELF::getStaticCtorSection(
    414     unsigned Priority, const MCSymbol *KeySym) const {
    415   return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
    416                                   KeySym);
    417 }
    418 
    419 MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
    420     unsigned Priority, const MCSymbol *KeySym) const {
    421   return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
    422                                   KeySym);
    423 }
    424 
    425 const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
    426     const GlobalValue *LHS, const GlobalValue *RHS, Mangler &Mang,
    427     const TargetMachine &TM) const {
    428   // We may only use a PLT-relative relocation to refer to unnamed_addr
    429   // functions.
    430   if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
    431     return nullptr;
    432 
    433   // Basic sanity checks.
    434   if (LHS->getType()->getPointerAddressSpace() != 0 ||
    435       RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
    436       RHS->isThreadLocal())
    437     return nullptr;
    438 
    439   return MCBinaryExpr::createSub(
    440       MCSymbolRefExpr::create(TM.getSymbol(LHS, Mang), PLTRelativeVariantKind,
    441                               getContext()),
    442       MCSymbolRefExpr::create(TM.getSymbol(RHS, Mang), getContext()),
    443       getContext());
    444 }
    445 
    446 void
    447 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
    448   UseInitArray = UseInitArray_;
    449   if (!UseInitArray)
    450     return;
    451 
    452   StaticCtorSection = getContext().getELFSection(
    453       ".init_array", ELF::SHT_INIT_ARRAY, ELF::SHF_WRITE | ELF::SHF_ALLOC);
    454   StaticDtorSection = getContext().getELFSection(
    455       ".fini_array", ELF::SHT_FINI_ARRAY, ELF::SHF_WRITE | ELF::SHF_ALLOC);
    456 }
    457 
    458 //===----------------------------------------------------------------------===//
    459 //                                 MachO
    460 //===----------------------------------------------------------------------===//
    461 
    462 TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO()
    463   : TargetLoweringObjectFile() {
    464   SupportIndirectSymViaGOTPCRel = true;
    465 }
    466 
    467 /// emitModuleFlags - Perform code emission for module flags.
    468 void TargetLoweringObjectFileMachO::
    469 emitModuleFlags(MCStreamer &Streamer,
    470                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
    471                 Mangler &Mang, const TargetMachine &TM) const {
    472   unsigned VersionVal = 0;
    473   unsigned ImageInfoFlags = 0;
    474   MDNode *LinkerOptions = nullptr;
    475   StringRef SectionVal;
    476 
    477   for (const auto &MFE : ModuleFlags) {
    478     // Ignore flags with 'Require' behavior.
    479     if (MFE.Behavior == Module::Require)
    480       continue;
    481 
    482     StringRef Key = MFE.Key->getString();
    483     Metadata *Val = MFE.Val;
    484 
    485     if (Key == "Objective-C Image Info Version") {
    486       VersionVal = mdconst::extract<ConstantInt>(Val)->getZExtValue();
    487     } else if (Key == "Objective-C Garbage Collection" ||
    488                Key == "Objective-C GC Only" ||
    489                Key == "Objective-C Is Simulated" ||
    490                Key == "Objective-C Class Properties" ||
    491                Key == "Objective-C Image Swift Version") {
    492       ImageInfoFlags |= mdconst::extract<ConstantInt>(Val)->getZExtValue();
    493     } else if (Key == "Objective-C Image Info Section") {
    494       SectionVal = cast<MDString>(Val)->getString();
    495     } else if (Key == "Linker Options") {
    496       LinkerOptions = cast<MDNode>(Val);
    497     }
    498   }
    499 
    500   // Emit the linker options if present.
    501   if (LinkerOptions) {
    502     for (const auto &Option : LinkerOptions->operands()) {
    503       SmallVector<std::string, 4> StrOptions;
    504       for (const auto &Piece : cast<MDNode>(Option)->operands())
    505         StrOptions.push_back(cast<MDString>(Piece)->getString());
    506       Streamer.EmitLinkerOptions(StrOptions);
    507     }
    508   }
    509 
    510   // The section is mandatory. If we don't have it, then we don't have GC info.
    511   if (SectionVal.empty()) return;
    512 
    513   StringRef Segment, Section;
    514   unsigned TAA = 0, StubSize = 0;
    515   bool TAAParsed;
    516   std::string ErrorCode =
    517     MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
    518                                           TAA, TAAParsed, StubSize);
    519   if (!ErrorCode.empty())
    520     // If invalid, report the error with report_fatal_error.
    521     report_fatal_error("Invalid section specifier '" + Section + "': " +
    522                        ErrorCode + ".");
    523 
    524   // Get the section.
    525   MCSectionMachO *S = getContext().getMachOSection(
    526       Segment, Section, TAA, StubSize, SectionKind::getData());
    527   Streamer.SwitchSection(S);
    528   Streamer.EmitLabel(getContext().
    529                      getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
    530   Streamer.EmitIntValue(VersionVal, 4);
    531   Streamer.EmitIntValue(ImageInfoFlags, 4);
    532   Streamer.AddBlankLine();
    533 }
    534 
    535 static void checkMachOComdat(const GlobalValue *GV) {
    536   const Comdat *C = GV->getComdat();
    537   if (!C)
    538     return;
    539 
    540   report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
    541                      "' cannot be lowered.");
    542 }
    543 
    544 MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
    545     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    546     const TargetMachine &TM) const {
    547   // Parse the section specifier and create it if valid.
    548   StringRef Segment, Section;
    549   unsigned TAA = 0, StubSize = 0;
    550   bool TAAParsed;
    551 
    552   checkMachOComdat(GV);
    553 
    554   std::string ErrorCode =
    555     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
    556                                           TAA, TAAParsed, StubSize);
    557   if (!ErrorCode.empty()) {
    558     // If invalid, report the error with report_fatal_error.
    559     report_fatal_error("Global variable '" + GV->getName() +
    560                        "' has an invalid section specifier '" +
    561                        GV->getSection() + "': " + ErrorCode + ".");
    562   }
    563 
    564   // Get the section.
    565   MCSectionMachO *S =
    566       getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
    567 
    568   // If TAA wasn't set by ParseSectionSpecifier() above,
    569   // use the value returned by getMachOSection() as a default.
    570   if (!TAAParsed)
    571     TAA = S->getTypeAndAttributes();
    572 
    573   // Okay, now that we got the section, verify that the TAA & StubSize agree.
    574   // If the user declared multiple globals with different section flags, we need
    575   // to reject it here.
    576   if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
    577     // If invalid, report the error with report_fatal_error.
    578     report_fatal_error("Global variable '" + GV->getName() +
    579                        "' section type or attributes does not match previous"
    580                        " section specifier");
    581   }
    582 
    583   return S;
    584 }
    585 
    586 MCSection *TargetLoweringObjectFileMachO::SelectSectionForGlobal(
    587     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    588     const TargetMachine &TM) const {
    589   checkMachOComdat(GV);
    590 
    591   // Handle thread local data.
    592   if (Kind.isThreadBSS()) return TLSBSSSection;
    593   if (Kind.isThreadData()) return TLSDataSection;
    594 
    595   if (Kind.isText())
    596     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
    597 
    598   // If this is weak/linkonce, put this in a coalescable section, either in text
    599   // or data depending on if it is writable.
    600   if (GV->isWeakForLinker()) {
    601     if (Kind.isReadOnly())
    602       return ConstTextCoalSection;
    603     return DataCoalSection;
    604   }
    605 
    606   // FIXME: Alignment check should be handled by section classifier.
    607   if (Kind.isMergeable1ByteCString() &&
    608       GV->getParent()->getDataLayout().getPreferredAlignment(
    609           cast<GlobalVariable>(GV)) < 32)
    610     return CStringSection;
    611 
    612   // Do not put 16-bit arrays in the UString section if they have an
    613   // externally visible label, this runs into issues with certain linker
    614   // versions.
    615   if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
    616       GV->getParent()->getDataLayout().getPreferredAlignment(
    617           cast<GlobalVariable>(GV)) < 32)
    618     return UStringSection;
    619 
    620   // With MachO only variables whose corresponding symbol starts with 'l' or
    621   // 'L' can be merged, so we only try merging GVs with private linkage.
    622   if (GV->hasPrivateLinkage() && Kind.isMergeableConst()) {
    623     if (Kind.isMergeableConst4())
    624       return FourByteConstantSection;
    625     if (Kind.isMergeableConst8())
    626       return EightByteConstantSection;
    627     if (Kind.isMergeableConst16())
    628       return SixteenByteConstantSection;
    629   }
    630 
    631   // Otherwise, if it is readonly, but not something we can specially optimize,
    632   // just drop it in .const.
    633   if (Kind.isReadOnly())
    634     return ReadOnlySection;
    635 
    636   // If this is marked const, put it into a const section.  But if the dynamic
    637   // linker needs to write to it, put it in the data segment.
    638   if (Kind.isReadOnlyWithRel())
    639     return ConstDataSection;
    640 
    641   // Put zero initialized globals with strong external linkage in the
    642   // DATA, __common section with the .zerofill directive.
    643   if (Kind.isBSSExtern())
    644     return DataCommonSection;
    645 
    646   // Put zero initialized globals with local linkage in __DATA,__bss directive
    647   // with the .zerofill directive (aka .lcomm).
    648   if (Kind.isBSSLocal())
    649     return DataBSSSection;
    650 
    651   // Otherwise, just drop the variable in the normal data section.
    652   return DataSection;
    653 }
    654 
    655 MCSection *TargetLoweringObjectFileMachO::getSectionForConstant(
    656     const DataLayout &DL, SectionKind Kind, const Constant *C,
    657     unsigned &Align) const {
    658   // If this constant requires a relocation, we have to put it in the data
    659   // segment, not in the text segment.
    660   if (Kind.isData() || Kind.isReadOnlyWithRel())
    661     return ConstDataSection;
    662 
    663   if (Kind.isMergeableConst4())
    664     return FourByteConstantSection;
    665   if (Kind.isMergeableConst8())
    666     return EightByteConstantSection;
    667   if (Kind.isMergeableConst16())
    668     return SixteenByteConstantSection;
    669   return ReadOnlySection;  // .const
    670 }
    671 
    672 const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
    673     const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
    674     const TargetMachine &TM, MachineModuleInfo *MMI,
    675     MCStreamer &Streamer) const {
    676   // The mach-o version of this method defaults to returning a stub reference.
    677 
    678   if (Encoding & DW_EH_PE_indirect) {
    679     MachineModuleInfoMachO &MachOMMI =
    680       MMI->getObjFileInfo<MachineModuleInfoMachO>();
    681 
    682     MCSymbol *SSym =
    683         getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM);
    684 
    685     // Add information about the stub reference to MachOMMI so that the stub
    686     // gets emitted by the asmprinter.
    687     MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
    688     if (!StubSym.getPointer()) {
    689       MCSymbol *Sym = TM.getSymbol(GV, Mang);
    690       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    691     }
    692 
    693     return TargetLoweringObjectFile::
    694       getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
    695                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
    696   }
    697 
    698   return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, Mang,
    699                                                            TM, MMI, Streamer);
    700 }
    701 
    702 MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
    703     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
    704     MachineModuleInfo *MMI) const {
    705   // The mach-o version of this method defaults to returning a stub reference.
    706   MachineModuleInfoMachO &MachOMMI =
    707     MMI->getObjFileInfo<MachineModuleInfoMachO>();
    708 
    709   MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM);
    710 
    711   // Add information about the stub reference to MachOMMI so that the stub
    712   // gets emitted by the asmprinter.
    713   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
    714   if (!StubSym.getPointer()) {
    715     MCSymbol *Sym = TM.getSymbol(GV, Mang);
    716     StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    717   }
    718 
    719   return SSym;
    720 }
    721 
    722 const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
    723     const MCSymbol *Sym, const MCValue &MV, int64_t Offset,
    724     MachineModuleInfo *MMI, MCStreamer &Streamer) const {
    725   // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
    726   // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
    727   // through a non_lazy_ptr stub instead. One advantage is that it allows the
    728   // computation of deltas to final external symbols. Example:
    729   //
    730   //    _extgotequiv:
    731   //       .long   _extfoo
    732   //
    733   //    _delta:
    734   //       .long   _extgotequiv-_delta
    735   //
    736   // is transformed to:
    737   //
    738   //    _delta:
    739   //       .long   L_extfoo$non_lazy_ptr-(_delta+0)
    740   //
    741   //       .section        __IMPORT,__pointers,non_lazy_symbol_pointers
    742   //    L_extfoo$non_lazy_ptr:
    743   //       .indirect_symbol        _extfoo
    744   //       .long   0
    745   //
    746   MachineModuleInfoMachO &MachOMMI =
    747     MMI->getObjFileInfo<MachineModuleInfoMachO>();
    748   MCContext &Ctx = getContext();
    749 
    750   // The offset must consider the original displacement from the base symbol
    751   // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
    752   Offset = -MV.getConstant();
    753   const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
    754 
    755   // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
    756   // non_lazy_ptr stubs.
    757   SmallString<128> Name;
    758   StringRef Suffix = "$non_lazy_ptr";
    759   Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
    760   Name += Sym->getName();
    761   Name += Suffix;
    762   MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
    763 
    764   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
    765   if (!StubSym.getPointer())
    766     StubSym = MachineModuleInfoImpl::
    767       StubValueTy(const_cast<MCSymbol *>(Sym), true /* access indirectly */);
    768 
    769   const MCExpr *BSymExpr =
    770     MCSymbolRefExpr::create(BaseSym, MCSymbolRefExpr::VK_None, Ctx);
    771   const MCExpr *LHS =
    772     MCSymbolRefExpr::create(Stub, MCSymbolRefExpr::VK_None, Ctx);
    773 
    774   if (!Offset)
    775     return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
    776 
    777   const MCExpr *RHS =
    778     MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx);
    779   return MCBinaryExpr::createSub(LHS, RHS, Ctx);
    780 }
    781 
    782 static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
    783                                const MCSection &Section) {
    784   if (!AsmInfo.isSectionAtomizableBySymbols(Section))
    785     return true;
    786 
    787   // If it is not dead stripped, it is safe to use private labels.
    788   const MCSectionMachO &SMO = cast<MCSectionMachO>(Section);
    789   if (SMO.hasAttribute(MachO::S_ATTR_NO_DEAD_STRIP))
    790     return true;
    791 
    792   return false;
    793 }
    794 
    795 void TargetLoweringObjectFileMachO::getNameWithPrefix(
    796     SmallVectorImpl<char> &OutName, const GlobalValue *GV, Mangler &Mang,
    797     const TargetMachine &TM) const {
    798   SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
    799   const MCSection *TheSection = SectionForGlobal(GV, GVKind, Mang, TM);
    800   bool CannotUsePrivateLabel =
    801       !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
    802   Mang.getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
    803 }
    804 
    805 //===----------------------------------------------------------------------===//
    806 //                                  COFF
    807 //===----------------------------------------------------------------------===//
    808 
    809 static unsigned
    810 getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) {
    811   unsigned Flags = 0;
    812   bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
    813 
    814   if (K.isMetadata())
    815     Flags |=
    816       COFF::IMAGE_SCN_MEM_DISCARDABLE;
    817   else if (K.isText())
    818     Flags |=
    819       COFF::IMAGE_SCN_MEM_EXECUTE |
    820       COFF::IMAGE_SCN_MEM_READ |
    821       COFF::IMAGE_SCN_CNT_CODE |
    822       (isThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0);
    823   else if (K.isBSS())
    824     Flags |=
    825       COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
    826       COFF::IMAGE_SCN_MEM_READ |
    827       COFF::IMAGE_SCN_MEM_WRITE;
    828   else if (K.isThreadLocal())
    829     Flags |=
    830       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    831       COFF::IMAGE_SCN_MEM_READ |
    832       COFF::IMAGE_SCN_MEM_WRITE;
    833   else if (K.isReadOnly() || K.isReadOnlyWithRel())
    834     Flags |=
    835       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    836       COFF::IMAGE_SCN_MEM_READ;
    837   else if (K.isWriteable())
    838     Flags |=
    839       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    840       COFF::IMAGE_SCN_MEM_READ |
    841       COFF::IMAGE_SCN_MEM_WRITE;
    842 
    843   return Flags;
    844 }
    845 
    846 static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
    847   const Comdat *C = GV->getComdat();
    848   assert(C && "expected GV to have a Comdat!");
    849 
    850   StringRef ComdatGVName = C->getName();
    851   const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
    852   if (!ComdatGV)
    853     report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
    854                        "' does not exist.");
    855 
    856   if (ComdatGV->getComdat() != C)
    857     report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
    858                        "' is not a key for its COMDAT.");
    859 
    860   return ComdatGV;
    861 }
    862 
    863 static int getSelectionForCOFF(const GlobalValue *GV) {
    864   if (const Comdat *C = GV->getComdat()) {
    865     const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
    866     if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
    867       ComdatKey = GA->getBaseObject();
    868     if (ComdatKey == GV) {
    869       switch (C->getSelectionKind()) {
    870       case Comdat::Any:
    871         return COFF::IMAGE_COMDAT_SELECT_ANY;
    872       case Comdat::ExactMatch:
    873         return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
    874       case Comdat::Largest:
    875         return COFF::IMAGE_COMDAT_SELECT_LARGEST;
    876       case Comdat::NoDuplicates:
    877         return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
    878       case Comdat::SameSize:
    879         return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
    880       }
    881     } else {
    882       return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
    883     }
    884   }
    885   return 0;
    886 }
    887 
    888 MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
    889     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    890     const TargetMachine &TM) const {
    891   int Selection = 0;
    892   unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
    893   StringRef Name = GV->getSection();
    894   StringRef COMDATSymName = "";
    895   if (GV->hasComdat()) {
    896     Selection = getSelectionForCOFF(GV);
    897     const GlobalValue *ComdatGV;
    898     if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
    899       ComdatGV = getComdatGVForCOFF(GV);
    900     else
    901       ComdatGV = GV;
    902 
    903     if (!ComdatGV->hasPrivateLinkage()) {
    904       MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
    905       COMDATSymName = Sym->getName();
    906       Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
    907     } else {
    908       Selection = 0;
    909     }
    910   }
    911 
    912   return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
    913                                      Selection);
    914 }
    915 
    916 static const char *getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
    917   if (Kind.isText())
    918     return ".text";
    919   if (Kind.isBSS())
    920     return ".bss";
    921   if (Kind.isThreadLocal())
    922     return ".tls$";
    923   if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
    924     return ".rdata";
    925   return ".data";
    926 }
    927 
    928 MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
    929     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    930     const TargetMachine &TM) const {
    931   // If we have -ffunction-sections then we should emit the global value to a
    932   // uniqued section specifically for it.
    933   bool EmitUniquedSection;
    934   if (Kind.isText())
    935     EmitUniquedSection = TM.getFunctionSections();
    936   else
    937     EmitUniquedSection = TM.getDataSections();
    938 
    939   if ((EmitUniquedSection && !Kind.isCommon()) || GV->hasComdat()) {
    940     const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
    941     unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
    942 
    943     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
    944     int Selection = getSelectionForCOFF(GV);
    945     if (!Selection)
    946       Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
    947     const GlobalValue *ComdatGV;
    948     if (GV->hasComdat())
    949       ComdatGV = getComdatGVForCOFF(GV);
    950     else
    951       ComdatGV = GV;
    952 
    953     unsigned UniqueID = MCContext::GenericSectionID;
    954     if (EmitUniquedSection)
    955       UniqueID = NextUniqueID++;
    956 
    957     if (!ComdatGV->hasPrivateLinkage()) {
    958       MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
    959       StringRef COMDATSymName = Sym->getName();
    960       return getContext().getCOFFSection(Name, Characteristics, Kind,
    961                                          COMDATSymName, Selection, UniqueID);
    962     } else {
    963       SmallString<256> TmpData;
    964       Mang.getNameWithPrefix(TmpData, GV, /*CannotUsePrivateLabel=*/true);
    965       return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
    966                                          Selection, UniqueID);
    967     }
    968   }
    969 
    970   if (Kind.isText())
    971     return TextSection;
    972 
    973   if (Kind.isThreadLocal())
    974     return TLSDataSection;
    975 
    976   if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
    977     return ReadOnlySection;
    978 
    979   // Note: we claim that common symbols are put in BSSSection, but they are
    980   // really emitted with the magic .comm directive, which creates a symbol table
    981   // entry but not a section.
    982   if (Kind.isBSS() || Kind.isCommon())
    983     return BSSSection;
    984 
    985   return DataSection;
    986 }
    987 
    988 void TargetLoweringObjectFileCOFF::getNameWithPrefix(
    989     SmallVectorImpl<char> &OutName, const GlobalValue *GV, Mangler &Mang,
    990     const TargetMachine &TM) const {
    991   bool CannotUsePrivateLabel = false;
    992   if (GV->hasPrivateLinkage() &&
    993       ((isa<Function>(GV) && TM.getFunctionSections()) ||
    994        (isa<GlobalVariable>(GV) && TM.getDataSections())))
    995     CannotUsePrivateLabel = true;
    996 
    997   Mang.getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
    998 }
    999 
   1000 MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
   1001     const Function &F, Mangler &Mang, const TargetMachine &TM) const {
   1002   // If the function can be removed, produce a unique section so that
   1003   // the table doesn't prevent the removal.
   1004   const Comdat *C = F.getComdat();
   1005   bool EmitUniqueSection = TM.getFunctionSections() || C;
   1006   if (!EmitUniqueSection)
   1007     return ReadOnlySection;
   1008 
   1009   // FIXME: we should produce a symbol for F instead.
   1010   if (F.hasPrivateLinkage())
   1011     return ReadOnlySection;
   1012 
   1013   MCSymbol *Sym = TM.getSymbol(&F, Mang);
   1014   StringRef COMDATSymName = Sym->getName();
   1015 
   1016   SectionKind Kind = SectionKind::getReadOnly();
   1017   const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
   1018   unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
   1019   Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
   1020   unsigned UniqueID = NextUniqueID++;
   1021 
   1022   return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
   1023                                      COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
   1024 }
   1025 
   1026 void TargetLoweringObjectFileCOFF::
   1027 emitModuleFlags(MCStreamer &Streamer,
   1028                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
   1029                 Mangler &Mang, const TargetMachine &TM) const {
   1030   MDNode *LinkerOptions = nullptr;
   1031 
   1032   for (const auto &MFE : ModuleFlags) {
   1033     StringRef Key = MFE.Key->getString();
   1034     if (Key == "Linker Options")
   1035       LinkerOptions = cast<MDNode>(MFE.Val);
   1036   }
   1037 
   1038   if (LinkerOptions) {
   1039     // Emit the linker options to the linker .drectve section.  According to the
   1040     // spec, this section is a space-separated string containing flags for
   1041     // linker.
   1042     MCSection *Sec = getDrectveSection();
   1043     Streamer.SwitchSection(Sec);
   1044     for (const auto &Option : LinkerOptions->operands()) {
   1045       for (const auto &Piece : cast<MDNode>(Option)->operands()) {
   1046         // Lead with a space for consistency with our dllexport implementation.
   1047         std::string Directive(" ");
   1048         Directive.append(cast<MDString>(Piece)->getString());
   1049         Streamer.EmitBytes(Directive);
   1050       }
   1051     }
   1052   }
   1053 }
   1054 
   1055 MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
   1056     unsigned Priority, const MCSymbol *KeySym) const {
   1057   return getContext().getAssociativeCOFFSection(
   1058       cast<MCSectionCOFF>(StaticCtorSection), KeySym, 0);
   1059 }
   1060 
   1061 MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
   1062     unsigned Priority, const MCSymbol *KeySym) const {
   1063   return getContext().getAssociativeCOFFSection(
   1064       cast<MCSectionCOFF>(StaticDtorSection), KeySym, 0);
   1065 }
   1066 
   1067 void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal(
   1068     raw_ostream &OS, const GlobalValue *GV, const Mangler &Mang) const {
   1069   if (!GV->hasDLLExportStorageClass() || GV->isDeclaration())
   1070     return;
   1071 
   1072   const Triple &TT = getTargetTriple();
   1073 
   1074   if (TT.isKnownWindowsMSVCEnvironment())
   1075     OS << " /EXPORT:";
   1076   else
   1077     OS << " -export:";
   1078 
   1079   if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
   1080     std::string Flag;
   1081     raw_string_ostream FlagOS(Flag);
   1082     Mang.getNameWithPrefix(FlagOS, GV, false);
   1083     FlagOS.flush();
   1084     if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
   1085       OS << Flag.substr(1);
   1086     else
   1087       OS << Flag;
   1088   } else {
   1089     Mang.getNameWithPrefix(OS, GV, false);
   1090   }
   1091 
   1092   if (!GV->getValueType()->isFunctionTy()) {
   1093     if (TT.isKnownWindowsMSVCEnvironment())
   1094       OS << ",DATA";
   1095     else
   1096       OS << ",data";
   1097   }
   1098 }
   1099