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/MCContext.h"
     28 #include "llvm/MC/MCExpr.h"
     29 #include "llvm/MC/MCSectionCOFF.h"
     30 #include "llvm/MC/MCSectionELF.h"
     31 #include "llvm/MC/MCSectionMachO.h"
     32 #include "llvm/MC/MCStreamer.h"
     33 #include "llvm/MC/MCSymbol.h"
     34 #include "llvm/Support/Dwarf.h"
     35 #include "llvm/Support/ELF.h"
     36 #include "llvm/Support/ErrorHandling.h"
     37 #include "llvm/Support/raw_ostream.h"
     38 #include "llvm/Target/TargetLowering.h"
     39 #include "llvm/Target/TargetMachine.h"
     40 using namespace llvm;
     41 using namespace dwarf;
     42 
     43 //===----------------------------------------------------------------------===//
     44 //                                  ELF
     45 //===----------------------------------------------------------------------===//
     46 
     47 MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
     48     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
     49     MachineModuleInfo *MMI) const {
     50   unsigned Encoding = getPersonalityEncoding();
     51   if ((Encoding & 0x80) == dwarf::DW_EH_PE_indirect)
     52     return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
     53                                           TM.getSymbol(GV, Mang)->getName());
     54   if ((Encoding & 0x70) == dwarf::DW_EH_PE_absptr)
     55     return TM.getSymbol(GV, Mang);
     56   report_fatal_error("We do not support this DWARF encoding yet!");
     57 }
     58 
     59 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
     60                                                        const TargetMachine &TM,
     61                                                        const MCSymbol *Sym) const {
     62   SmallString<64> NameData("DW.ref.");
     63   NameData += Sym->getName();
     64   MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
     65   Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
     66   Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
     67   StringRef Prefix = ".data.";
     68   NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
     69   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
     70   const MCSection *Sec = getContext().getELFSection(NameData,
     71                                                     ELF::SHT_PROGBITS,
     72                                                     Flags,
     73                                                     SectionKind::getDataRel(),
     74                                                     0, Label->getName());
     75   unsigned Size = TM.getDataLayout()->getPointerSize();
     76   Streamer.SwitchSection(Sec);
     77   Streamer.EmitValueToAlignment(TM.getDataLayout()->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   if (Name.empty() || Name[0] != '.') return K;
    122 
    123   // Some lame default implementation based on some magic section names.
    124   if (Name == ".bss" ||
    125       Name.startswith(".bss.") ||
    126       Name.startswith(".gnu.linkonce.b.") ||
    127       Name.startswith(".llvm.linkonce.b.") ||
    128       Name == ".sbss" ||
    129       Name.startswith(".sbss.") ||
    130       Name.startswith(".gnu.linkonce.sb.") ||
    131       Name.startswith(".llvm.linkonce.sb."))
    132     return SectionKind::getBSS();
    133 
    134   if (Name == ".tdata" ||
    135       Name.startswith(".tdata.") ||
    136       Name.startswith(".gnu.linkonce.td.") ||
    137       Name.startswith(".llvm.linkonce.td."))
    138     return SectionKind::getThreadData();
    139 
    140   if (Name == ".tbss" ||
    141       Name.startswith(".tbss.") ||
    142       Name.startswith(".gnu.linkonce.tb.") ||
    143       Name.startswith(".llvm.linkonce.tb."))
    144     return SectionKind::getThreadBSS();
    145 
    146   return K;
    147 }
    148 
    149 
    150 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
    151 
    152   if (Name == ".init_array")
    153     return ELF::SHT_INIT_ARRAY;
    154 
    155   if (Name == ".fini_array")
    156     return ELF::SHT_FINI_ARRAY;
    157 
    158   if (Name == ".preinit_array")
    159     return ELF::SHT_PREINIT_ARRAY;
    160 
    161   if (K.isBSS() || K.isThreadBSS())
    162     return ELF::SHT_NOBITS;
    163 
    164   return ELF::SHT_PROGBITS;
    165 }
    166 
    167 
    168 static unsigned
    169 getELFSectionFlags(SectionKind K) {
    170   unsigned Flags = 0;
    171 
    172   if (!K.isMetadata())
    173     Flags |= ELF::SHF_ALLOC;
    174 
    175   if (K.isText())
    176     Flags |= ELF::SHF_EXECINSTR;
    177 
    178   if (K.isWriteable())
    179     Flags |= ELF::SHF_WRITE;
    180 
    181   if (K.isThreadLocal())
    182     Flags |= ELF::SHF_TLS;
    183 
    184   // K.isMergeableConst() is left out to honour PR4650
    185   if (K.isMergeableCString() || K.isMergeableConst4() ||
    186       K.isMergeableConst8() || K.isMergeableConst16())
    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 const 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                                     Kind, /*EntrySize=*/0, Group);
    224 }
    225 
    226 /// getSectionPrefixForGlobal - Return the section prefix name used by options
    227 /// FunctionsSections and DataSections.
    228 static StringRef getSectionPrefixForGlobal(SectionKind Kind) {
    229   if (Kind.isText())                 return ".text.";
    230   if (Kind.isReadOnly())             return ".rodata.";
    231   if (Kind.isBSS())                  return ".bss.";
    232 
    233   if (Kind.isThreadData())           return ".tdata.";
    234   if (Kind.isThreadBSS())            return ".tbss.";
    235 
    236   if (Kind.isDataNoRel())            return ".data.";
    237   if (Kind.isDataRelLocal())         return ".data.rel.local.";
    238   if (Kind.isDataRel())              return ".data.rel.";
    239   if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
    240 
    241   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    242   return ".data.rel.ro.";
    243 }
    244 
    245 const MCSection *TargetLoweringObjectFileELF::
    246 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
    247                        Mangler &Mang, const TargetMachine &TM) const {
    248   // If we have -ffunction-section or -fdata-section then we should emit the
    249   // global value to a uniqued section specifically for it.
    250   bool EmitUniquedSection;
    251   if (Kind.isText())
    252     EmitUniquedSection = TM.getFunctionSections();
    253   else
    254     EmitUniquedSection = TM.getDataSections();
    255 
    256   // If this global is linkonce/weak and the target handles this by emitting it
    257   // into a 'uniqued' section name, create and return the section now.
    258   if ((GV->isWeakForLinker() || EmitUniquedSection || GV->hasComdat()) &&
    259       !Kind.isCommon()) {
    260     StringRef Prefix = getSectionPrefixForGlobal(Kind);
    261 
    262     SmallString<128> Name(Prefix);
    263     TM.getNameWithPrefix(Name, GV, Mang, true);
    264 
    265     StringRef Group = "";
    266     unsigned Flags = getELFSectionFlags(Kind);
    267     if (GV->isWeakForLinker() || GV->hasComdat()) {
    268       if (const Comdat *C = getELFComdat(GV))
    269         Group = C->getName();
    270       else
    271         Group = Name.substr(Prefix.size());
    272       Flags |= ELF::SHF_GROUP;
    273     }
    274 
    275     return getContext().getELFSection(Name.str(),
    276                                       getELFSectionType(Name.str(), Kind),
    277                                       Flags, Kind, 0, Group);
    278   }
    279 
    280   if (Kind.isText()) return TextSection;
    281 
    282   if (Kind.isMergeable1ByteCString() ||
    283       Kind.isMergeable2ByteCString() ||
    284       Kind.isMergeable4ByteCString()) {
    285 
    286     // We also need alignment here.
    287     // FIXME: this is getting the alignment of the character, not the
    288     // alignment of the global!
    289     unsigned Align =
    290       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV));
    291 
    292     const char *SizeSpec = ".rodata.str1.";
    293     if (Kind.isMergeable2ByteCString())
    294       SizeSpec = ".rodata.str2.";
    295     else if (Kind.isMergeable4ByteCString())
    296       SizeSpec = ".rodata.str4.";
    297     else
    298       assert(Kind.isMergeable1ByteCString() && "unknown string width");
    299 
    300 
    301     std::string Name = SizeSpec + utostr(Align);
    302     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
    303                                       ELF::SHF_ALLOC |
    304                                       ELF::SHF_MERGE |
    305                                       ELF::SHF_STRINGS,
    306                                       Kind);
    307   }
    308 
    309   if (Kind.isMergeableConst()) {
    310     if (Kind.isMergeableConst4() && MergeableConst4Section)
    311       return MergeableConst4Section;
    312     if (Kind.isMergeableConst8() && MergeableConst8Section)
    313       return MergeableConst8Section;
    314     if (Kind.isMergeableConst16() && MergeableConst16Section)
    315       return MergeableConst16Section;
    316     return ReadOnlySection;  // .const
    317   }
    318 
    319   if (Kind.isReadOnly())             return ReadOnlySection;
    320 
    321   if (Kind.isThreadData())           return TLSDataSection;
    322   if (Kind.isThreadBSS())            return TLSBSSSection;
    323 
    324   // Note: we claim that common symbols are put in BSSSection, but they are
    325   // really emitted with the magic .comm directive, which creates a symbol table
    326   // entry but not a section.
    327   if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
    328 
    329   if (Kind.isDataNoRel())            return DataSection;
    330   if (Kind.isDataRelLocal())         return DataRelLocalSection;
    331   if (Kind.isDataRel())              return DataRelSection;
    332   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
    333 
    334   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    335   return DataRelROSection;
    336 }
    337 
    338 /// getSectionForConstant - Given a mergeable constant with the
    339 /// specified size and relocation information, return a section that it
    340 /// should be placed in.
    341 const MCSection *TargetLoweringObjectFileELF::
    342 getSectionForConstant(SectionKind Kind) const {
    343   if (Kind.isMergeableConst4() && MergeableConst4Section)
    344     return MergeableConst4Section;
    345   if (Kind.isMergeableConst8() && MergeableConst8Section)
    346     return MergeableConst8Section;
    347   if (Kind.isMergeableConst16() && MergeableConst16Section)
    348     return MergeableConst16Section;
    349   if (Kind.isReadOnly())
    350     return ReadOnlySection;
    351 
    352   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
    353   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    354   return DataRelROSection;
    355 }
    356 
    357 const MCSection *TargetLoweringObjectFileELF::getStaticCtorSection(
    358     unsigned Priority, const MCSymbol *KeySym) const {
    359   // The default scheme is .ctor / .dtor, so we have to invert the priority
    360   // numbering.
    361   if (Priority == 65535)
    362     return StaticCtorSection;
    363 
    364   if (UseInitArray) {
    365     std::string Name = std::string(".init_array.") + utostr(Priority);
    366     return getContext().getELFSection(Name, ELF::SHT_INIT_ARRAY,
    367                                       ELF::SHF_ALLOC | ELF::SHF_WRITE,
    368                                       SectionKind::getDataRel());
    369   } else {
    370     std::string Name = std::string(".ctors.") + utostr(65535 - Priority);
    371     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
    372                                       ELF::SHF_ALLOC |ELF::SHF_WRITE,
    373                                       SectionKind::getDataRel());
    374   }
    375 }
    376 
    377 const MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
    378     unsigned Priority, const MCSymbol *KeySym) const {
    379   // The default scheme is .ctor / .dtor, so we have to invert the priority
    380   // numbering.
    381   if (Priority == 65535)
    382     return StaticDtorSection;
    383 
    384   if (UseInitArray) {
    385     std::string Name = std::string(".fini_array.") + utostr(Priority);
    386     return getContext().getELFSection(Name, ELF::SHT_FINI_ARRAY,
    387                                       ELF::SHF_ALLOC | ELF::SHF_WRITE,
    388                                       SectionKind::getDataRel());
    389   } else {
    390     std::string Name = std::string(".dtors.") + utostr(65535 - Priority);
    391     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
    392                                       ELF::SHF_ALLOC |ELF::SHF_WRITE,
    393                                       SectionKind::getDataRel());
    394   }
    395 }
    396 
    397 void
    398 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
    399   UseInitArray = UseInitArray_;
    400   if (!UseInitArray)
    401     return;
    402 
    403   StaticCtorSection =
    404     getContext().getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
    405                                ELF::SHF_WRITE |
    406                                ELF::SHF_ALLOC,
    407                                SectionKind::getDataRel());
    408   StaticDtorSection =
    409     getContext().getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
    410                                ELF::SHF_WRITE |
    411                                ELF::SHF_ALLOC,
    412                                SectionKind::getDataRel());
    413 }
    414 
    415 //===----------------------------------------------------------------------===//
    416 //                                 MachO
    417 //===----------------------------------------------------------------------===//
    418 
    419 /// getDepLibFromLinkerOpt - Extract the dependent library name from a linker
    420 /// option string. Returns StringRef() if the option does not specify a library.
    421 StringRef TargetLoweringObjectFileMachO::
    422 getDepLibFromLinkerOpt(StringRef LinkerOption) const {
    423   const char *LibCmd = "-l";
    424   if (LinkerOption.startswith(LibCmd))
    425     return LinkerOption.substr(strlen(LibCmd));
    426   return StringRef();
    427 }
    428 
    429 /// emitModuleFlags - Perform code emission for module flags.
    430 void TargetLoweringObjectFileMachO::
    431 emitModuleFlags(MCStreamer &Streamer,
    432                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
    433                 Mangler &Mang, const TargetMachine &TM) const {
    434   unsigned VersionVal = 0;
    435   unsigned ImageInfoFlags = 0;
    436   MDNode *LinkerOptions = nullptr;
    437   StringRef SectionVal;
    438 
    439   for (ArrayRef<Module::ModuleFlagEntry>::iterator
    440          i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
    441     const Module::ModuleFlagEntry &MFE = *i;
    442 
    443     // Ignore flags with 'Require' behavior.
    444     if (MFE.Behavior == Module::Require)
    445       continue;
    446 
    447     StringRef Key = MFE.Key->getString();
    448     Value *Val = MFE.Val;
    449 
    450     if (Key == "Objective-C Image Info Version") {
    451       VersionVal = cast<ConstantInt>(Val)->getZExtValue();
    452     } else if (Key == "Objective-C Garbage Collection" ||
    453                Key == "Objective-C GC Only" ||
    454                Key == "Objective-C Is Simulated") {
    455       ImageInfoFlags |= cast<ConstantInt>(Val)->getZExtValue();
    456     } else if (Key == "Objective-C Image Info Section") {
    457       SectionVal = cast<MDString>(Val)->getString();
    458     } else if (Key == "Linker Options") {
    459       LinkerOptions = cast<MDNode>(Val);
    460     }
    461   }
    462 
    463   // Emit the linker options if present.
    464   if (LinkerOptions) {
    465     for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
    466       MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
    467       SmallVector<std::string, 4> StrOptions;
    468 
    469       // Convert to strings.
    470       for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
    471         MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
    472         StrOptions.push_back(MDOption->getString());
    473       }
    474 
    475       Streamer.EmitLinkerOptions(StrOptions);
    476     }
    477   }
    478 
    479   // The section is mandatory. If we don't have it, then we don't have GC info.
    480   if (SectionVal.empty()) return;
    481 
    482   StringRef Segment, Section;
    483   unsigned TAA = 0, StubSize = 0;
    484   bool TAAParsed;
    485   std::string ErrorCode =
    486     MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
    487                                           TAA, TAAParsed, StubSize);
    488   if (!ErrorCode.empty())
    489     // If invalid, report the error with report_fatal_error.
    490     report_fatal_error("Invalid section specifier '" + Section + "': " +
    491                        ErrorCode + ".");
    492 
    493   // Get the section.
    494   const MCSectionMachO *S =
    495     getContext().getMachOSection(Segment, Section, TAA, StubSize,
    496                                  SectionKind::getDataNoRel());
    497   Streamer.SwitchSection(S);
    498   Streamer.EmitLabel(getContext().
    499                      GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
    500   Streamer.EmitIntValue(VersionVal, 4);
    501   Streamer.EmitIntValue(ImageInfoFlags, 4);
    502   Streamer.AddBlankLine();
    503 }
    504 
    505 static void checkMachOComdat(const GlobalValue *GV) {
    506   const Comdat *C = GV->getComdat();
    507   if (!C)
    508     return;
    509 
    510   report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
    511                      "' cannot be lowered.");
    512 }
    513 
    514 const MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
    515     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    516     const TargetMachine &TM) const {
    517   // Parse the section specifier and create it if valid.
    518   StringRef Segment, Section;
    519   unsigned TAA = 0, StubSize = 0;
    520   bool TAAParsed;
    521 
    522   checkMachOComdat(GV);
    523 
    524   std::string ErrorCode =
    525     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
    526                                           TAA, TAAParsed, StubSize);
    527   if (!ErrorCode.empty()) {
    528     // If invalid, report the error with report_fatal_error.
    529     report_fatal_error("Global variable '" + GV->getName() +
    530                        "' has an invalid section specifier '" +
    531                        GV->getSection() + "': " + ErrorCode + ".");
    532   }
    533 
    534   // Get the section.
    535   const MCSectionMachO *S =
    536     getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
    537 
    538   // If TAA wasn't set by ParseSectionSpecifier() above,
    539   // use the value returned by getMachOSection() as a default.
    540   if (!TAAParsed)
    541     TAA = S->getTypeAndAttributes();
    542 
    543   // Okay, now that we got the section, verify that the TAA & StubSize agree.
    544   // If the user declared multiple globals with different section flags, we need
    545   // to reject it here.
    546   if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
    547     // If invalid, report the error with report_fatal_error.
    548     report_fatal_error("Global variable '" + GV->getName() +
    549                        "' section type or attributes does not match previous"
    550                        " section specifier");
    551   }
    552 
    553   return S;
    554 }
    555 
    556 bool TargetLoweringObjectFileMachO::isSectionAtomizableBySymbols(
    557     const MCSection &Section) const {
    558     const MCSectionMachO &SMO = static_cast<const MCSectionMachO&>(Section);
    559 
    560     // Sections holding 1 byte strings are atomized based on the data
    561     // they contain.
    562     // Sections holding 2 byte strings require symbols in order to be
    563     // atomized.
    564     // There is no dedicated section for 4 byte strings.
    565     if (SMO.getKind().isMergeable1ByteCString())
    566       return false;
    567 
    568     if (SMO.getSegmentName() == "__DATA" &&
    569         SMO.getSectionName() == "__cfstring")
    570       return false;
    571 
    572     switch (SMO.getType()) {
    573     default:
    574       return true;
    575 
    576       // These sections are atomized at the element boundaries without using
    577       // symbols.
    578     case MachO::S_4BYTE_LITERALS:
    579     case MachO::S_8BYTE_LITERALS:
    580     case MachO::S_16BYTE_LITERALS:
    581     case MachO::S_LITERAL_POINTERS:
    582     case MachO::S_NON_LAZY_SYMBOL_POINTERS:
    583     case MachO::S_LAZY_SYMBOL_POINTERS:
    584     case MachO::S_MOD_INIT_FUNC_POINTERS:
    585     case MachO::S_MOD_TERM_FUNC_POINTERS:
    586     case MachO::S_INTERPOSING:
    587       return false;
    588     }
    589 }
    590 
    591 const MCSection *TargetLoweringObjectFileMachO::
    592 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
    593                        Mangler &Mang, const TargetMachine &TM) const {
    594   checkMachOComdat(GV);
    595 
    596   // Handle thread local data.
    597   if (Kind.isThreadBSS()) return TLSBSSSection;
    598   if (Kind.isThreadData()) return TLSDataSection;
    599 
    600   if (Kind.isText())
    601     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
    602 
    603   // If this is weak/linkonce, put this in a coalescable section, either in text
    604   // or data depending on if it is writable.
    605   if (GV->isWeakForLinker()) {
    606     if (Kind.isReadOnly())
    607       return ConstTextCoalSection;
    608     return DataCoalSection;
    609   }
    610 
    611   // FIXME: Alignment check should be handled by section classifier.
    612   if (Kind.isMergeable1ByteCString() &&
    613       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
    614     return CStringSection;
    615 
    616   // Do not put 16-bit arrays in the UString section if they have an
    617   // externally visible label, this runs into issues with certain linker
    618   // versions.
    619   if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
    620       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
    621     return UStringSection;
    622 
    623   if (Kind.isMergeableConst()) {
    624     if (Kind.isMergeableConst4())
    625       return FourByteConstantSection;
    626     if (Kind.isMergeableConst8())
    627       return EightByteConstantSection;
    628     if (Kind.isMergeableConst16())
    629       return SixteenByteConstantSection;
    630   }
    631 
    632   // Otherwise, if it is readonly, but not something we can specially optimize,
    633   // just drop it in .const.
    634   if (Kind.isReadOnly())
    635     return ReadOnlySection;
    636 
    637   // If this is marked const, put it into a const section.  But if the dynamic
    638   // linker needs to write to it, put it in the data segment.
    639   if (Kind.isReadOnlyWithRel())
    640     return ConstDataSection;
    641 
    642   // Put zero initialized globals with strong external linkage in the
    643   // DATA, __common section with the .zerofill directive.
    644   if (Kind.isBSSExtern())
    645     return DataCommonSection;
    646 
    647   // Put zero initialized globals with local linkage in __DATA,__bss directive
    648   // with the .zerofill directive (aka .lcomm).
    649   if (Kind.isBSSLocal())
    650     return DataBSSSection;
    651 
    652   // Otherwise, just drop the variable in the normal data section.
    653   return DataSection;
    654 }
    655 
    656 const MCSection *
    657 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) 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.isDataRel() || 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 =
    688       GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
    689                                   MachOMMI.getGVStubEntry(SSym);
    690     if (!StubSym.getPointer()) {
    691       MCSymbol *Sym = TM.getSymbol(GV, Mang);
    692       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    693     }
    694 
    695     return TargetLoweringObjectFile::
    696       getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
    697                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
    698   }
    699 
    700   return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, Mang,
    701                                                            TM, MMI, Streamer);
    702 }
    703 
    704 MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
    705     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
    706     MachineModuleInfo *MMI) const {
    707   // The mach-o version of this method defaults to returning a stub reference.
    708   MachineModuleInfoMachO &MachOMMI =
    709     MMI->getObjFileInfo<MachineModuleInfoMachO>();
    710 
    711   MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM);
    712 
    713   // Add information about the stub reference to MachOMMI so that the stub
    714   // gets emitted by the asmprinter.
    715   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
    716   if (!StubSym.getPointer()) {
    717     MCSymbol *Sym = TM.getSymbol(GV, Mang);
    718     StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    719   }
    720 
    721   return SSym;
    722 }
    723 
    724 //===----------------------------------------------------------------------===//
    725 //                                  COFF
    726 //===----------------------------------------------------------------------===//
    727 
    728 static unsigned
    729 getCOFFSectionFlags(SectionKind K) {
    730   unsigned Flags = 0;
    731 
    732   if (K.isMetadata())
    733     Flags |=
    734       COFF::IMAGE_SCN_MEM_DISCARDABLE;
    735   else if (K.isText())
    736     Flags |=
    737       COFF::IMAGE_SCN_MEM_EXECUTE |
    738       COFF::IMAGE_SCN_MEM_READ |
    739       COFF::IMAGE_SCN_CNT_CODE;
    740   else if (K.isBSS ())
    741     Flags |=
    742       COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
    743       COFF::IMAGE_SCN_MEM_READ |
    744       COFF::IMAGE_SCN_MEM_WRITE;
    745   else if (K.isThreadLocal())
    746     Flags |=
    747       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    748       COFF::IMAGE_SCN_MEM_READ |
    749       COFF::IMAGE_SCN_MEM_WRITE;
    750   else if (K.isReadOnly())
    751     Flags |=
    752       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    753       COFF::IMAGE_SCN_MEM_READ;
    754   else if (K.isWriteable())
    755     Flags |=
    756       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    757       COFF::IMAGE_SCN_MEM_READ |
    758       COFF::IMAGE_SCN_MEM_WRITE;
    759 
    760   return Flags;
    761 }
    762 
    763 static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
    764   const Comdat *C = GV->getComdat();
    765   assert(C && "expected GV to have a Comdat!");
    766 
    767   StringRef ComdatGVName = C->getName();
    768   const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
    769   if (!ComdatGV)
    770     report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
    771                        "' does not exist.");
    772 
    773   if (ComdatGV->getComdat() != C)
    774     report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
    775                        "' is not a key for it's COMDAT.");
    776 
    777   return ComdatGV;
    778 }
    779 
    780 static int getSelectionForCOFF(const GlobalValue *GV) {
    781   if (const Comdat *C = GV->getComdat()) {
    782     const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
    783     if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
    784       ComdatKey = GA->getBaseObject();
    785     if (ComdatKey == GV) {
    786       switch (C->getSelectionKind()) {
    787       case Comdat::Any:
    788         return COFF::IMAGE_COMDAT_SELECT_ANY;
    789       case Comdat::ExactMatch:
    790         return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
    791       case Comdat::Largest:
    792         return COFF::IMAGE_COMDAT_SELECT_LARGEST;
    793       case Comdat::NoDuplicates:
    794         return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
    795       case Comdat::SameSize:
    796         return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
    797       }
    798     } else {
    799       return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
    800     }
    801   } else if (GV->isWeakForLinker()) {
    802     return COFF::IMAGE_COMDAT_SELECT_ANY;
    803   }
    804   return 0;
    805 }
    806 
    807 const MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
    808     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
    809     const TargetMachine &TM) const {
    810   int Selection = 0;
    811   unsigned Characteristics = getCOFFSectionFlags(Kind);
    812   StringRef Name = GV->getSection();
    813   StringRef COMDATSymName = "";
    814   if ((GV->isWeakForLinker() || GV->hasComdat()) && !Kind.isCommon()) {
    815     Selection = getSelectionForCOFF(GV);
    816     const GlobalValue *ComdatGV;
    817     if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
    818       ComdatGV = getComdatGVForCOFF(GV);
    819     else
    820       ComdatGV = GV;
    821 
    822     if (!ComdatGV->hasPrivateLinkage()) {
    823       MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
    824       COMDATSymName = Sym->getName();
    825       Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
    826     } else {
    827       Selection = 0;
    828     }
    829   }
    830   return getContext().getCOFFSection(Name,
    831                                      Characteristics,
    832                                      Kind,
    833                                      COMDATSymName,
    834                                      Selection);
    835 }
    836 
    837 static const char *getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
    838   if (Kind.isText())
    839     return ".text";
    840   if (Kind.isBSS())
    841     return ".bss";
    842   if (Kind.isThreadLocal())
    843     return ".tls$";
    844   if (Kind.isWriteable())
    845     return ".data";
    846   return ".rdata";
    847 }
    848 
    849 
    850 const MCSection *TargetLoweringObjectFileCOFF::
    851 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
    852                        Mangler &Mang, const TargetMachine &TM) const {
    853   // If we have -ffunction-sections then we should emit the global value to a
    854   // uniqued section specifically for it.
    855   bool EmitUniquedSection;
    856   if (Kind.isText())
    857     EmitUniquedSection = TM.getFunctionSections();
    858   else
    859     EmitUniquedSection = TM.getDataSections();
    860 
    861   // If this global is linkonce/weak and the target handles this by emitting it
    862   // into a 'uniqued' section name, create and return the section now.
    863   // Section names depend on the name of the symbol which is not feasible if the
    864   // symbol has private linkage.
    865   if ((GV->isWeakForLinker() || EmitUniquedSection || GV->hasComdat()) &&
    866       !Kind.isCommon()) {
    867     const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
    868     unsigned Characteristics = getCOFFSectionFlags(Kind);
    869 
    870     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
    871     int Selection = getSelectionForCOFF(GV);
    872     if (!Selection)
    873       Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
    874     const GlobalValue *ComdatGV;
    875     if (GV->hasComdat())
    876       ComdatGV = getComdatGVForCOFF(GV);
    877     else
    878       ComdatGV = GV;
    879 
    880     if (!ComdatGV->hasPrivateLinkage()) {
    881       MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
    882       StringRef COMDATSymName = Sym->getName();
    883       return getContext().getCOFFSection(Name, Characteristics, Kind,
    884                                          COMDATSymName, Selection);
    885     }
    886   }
    887 
    888   if (Kind.isText())
    889     return TextSection;
    890 
    891   if (Kind.isThreadLocal())
    892     return TLSDataSection;
    893 
    894   if (Kind.isReadOnly())
    895     return ReadOnlySection;
    896 
    897   // Note: we claim that common symbols are put in BSSSection, but they are
    898   // really emitted with the magic .comm directive, which creates a symbol table
    899   // entry but not a section.
    900   if (Kind.isBSS() || Kind.isCommon())
    901     return BSSSection;
    902 
    903   return DataSection;
    904 }
    905 
    906 StringRef TargetLoweringObjectFileCOFF::
    907 getDepLibFromLinkerOpt(StringRef LinkerOption) const {
    908   const char *LibCmd = "/DEFAULTLIB:";
    909   if (LinkerOption.startswith(LibCmd))
    910     return LinkerOption.substr(strlen(LibCmd));
    911   return StringRef();
    912 }
    913 
    914 void TargetLoweringObjectFileCOFF::
    915 emitModuleFlags(MCStreamer &Streamer,
    916                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
    917                 Mangler &Mang, const TargetMachine &TM) const {
    918   MDNode *LinkerOptions = nullptr;
    919 
    920   // Look for the "Linker Options" flag, since it's the only one we support.
    921   for (ArrayRef<Module::ModuleFlagEntry>::iterator
    922        i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
    923     const Module::ModuleFlagEntry &MFE = *i;
    924     StringRef Key = MFE.Key->getString();
    925     Value *Val = MFE.Val;
    926     if (Key == "Linker Options") {
    927       LinkerOptions = cast<MDNode>(Val);
    928       break;
    929     }
    930   }
    931   if (!LinkerOptions)
    932     return;
    933 
    934   // Emit the linker options to the linker .drectve section.  According to the
    935   // spec, this section is a space-separated string containing flags for linker.
    936   const MCSection *Sec = getDrectveSection();
    937   Streamer.SwitchSection(Sec);
    938   for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
    939     MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
    940     for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
    941       MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
    942       StringRef Op = MDOption->getString();
    943       // Lead with a space for consistency with our dllexport implementation.
    944       std::string Escaped(" ");
    945       if (Op.find(" ") != StringRef::npos) {
    946         // The PE-COFF spec says args with spaces must be quoted.  It doesn't say
    947         // how to escape quotes, but it probably uses this algorithm:
    948         // http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx
    949         // FIXME: Reuse escaping code from Support/Windows/Program.inc
    950         Escaped.push_back('\"');
    951         Escaped.append(Op);
    952         Escaped.push_back('\"');
    953       } else {
    954         Escaped.append(Op);
    955       }
    956       Streamer.EmitBytes(Escaped);
    957     }
    958   }
    959 }
    960 
    961 static const MCSection *getAssociativeCOFFSection(MCContext &Ctx,
    962                                                   const MCSection *Sec,
    963                                                   const MCSymbol *KeySym) {
    964   // Return the normal section if we don't have to be associative.
    965   if (!KeySym)
    966     return Sec;
    967 
    968   // Make an associative section with the same name and kind as the normal
    969   // section.
    970   const MCSectionCOFF *SecCOFF = cast<MCSectionCOFF>(Sec);
    971   unsigned Characteristics =
    972       SecCOFF->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT;
    973   return Ctx.getCOFFSection(SecCOFF->getSectionName(), Characteristics,
    974                             SecCOFF->getKind(), KeySym->getName(),
    975                             COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE);
    976 }
    977 
    978 const MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
    979     unsigned Priority, const MCSymbol *KeySym) const {
    980   return getAssociativeCOFFSection(getContext(), StaticCtorSection, KeySym);
    981 }
    982 
    983 const MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
    984     unsigned Priority, const MCSymbol *KeySym) const {
    985   return getAssociativeCOFFSection(getContext(), StaticDtorSection, KeySym);
    986 }
    987