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/Module.h"
     26 #include "llvm/MC/MCContext.h"
     27 #include "llvm/MC/MCExpr.h"
     28 #include "llvm/MC/MCSectionCOFF.h"
     29 #include "llvm/MC/MCSectionELF.h"
     30 #include "llvm/MC/MCSectionMachO.h"
     31 #include "llvm/MC/MCStreamer.h"
     32 #include "llvm/MC/MCSymbol.h"
     33 #include "llvm/Support/Dwarf.h"
     34 #include "llvm/Support/ELF.h"
     35 #include "llvm/Support/ErrorHandling.h"
     36 #include "llvm/Support/raw_ostream.h"
     37 #include "llvm/Target/Mangler.h"
     38 #include "llvm/Target/TargetMachine.h"
     39 using namespace llvm;
     40 using namespace dwarf;
     41 
     42 //===----------------------------------------------------------------------===//
     43 //                                  ELF
     44 //===----------------------------------------------------------------------===//
     45 
     46 MCSymbol *
     47 TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
     48                                                      Mangler *Mang,
     49                                                 MachineModuleInfo *MMI) const {
     50   unsigned Encoding = getPersonalityEncoding();
     51   switch (Encoding & 0x70) {
     52   default:
     53     report_fatal_error("We do not support this DWARF encoding yet!");
     54   case dwarf::DW_EH_PE_absptr:
     55     return  Mang->getSymbol(GV);
     56   case dwarf::DW_EH_PE_pcrel: {
     57     return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
     58                                           Mang->getSymbol(GV)->getName());
     59   }
     60   }
     61 }
     62 
     63 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
     64                                                        const TargetMachine &TM,
     65                                                        const MCSymbol *Sym) const {
     66   SmallString<64> NameData("DW.ref.");
     67   NameData += Sym->getName();
     68   MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
     69   Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
     70   Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
     71   StringRef Prefix = ".data.";
     72   NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
     73   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
     74   const MCSection *Sec = getContext().getELFSection(NameData,
     75                                                     ELF::SHT_PROGBITS,
     76                                                     Flags,
     77                                                     SectionKind::getDataRel(),
     78                                                     0, Label->getName());
     79   unsigned Size = TM.getDataLayout()->getPointerSize();
     80   Streamer.SwitchSection(Sec);
     81   Streamer.EmitValueToAlignment(TM.getDataLayout()->getPointerABIAlignment());
     82   Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
     83   const MCExpr *E = MCConstantExpr::Create(Size, getContext());
     84   Streamer.EmitELFSize(Label, E);
     85   Streamer.EmitLabel(Label);
     86 
     87   Streamer.EmitSymbolValue(Sym, Size);
     88 }
     89 
     90 const MCExpr *TargetLoweringObjectFileELF::
     91 getTTypeGlobalReference(const GlobalValue *GV, Mangler *Mang,
     92                         MachineModuleInfo *MMI, unsigned Encoding,
     93                         MCStreamer &Streamer) const {
     94 
     95   if (Encoding & dwarf::DW_EH_PE_indirect) {
     96     MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
     97 
     98     SmallString<128> Name;
     99     Mang->getNameWithPrefix(Name, GV, true);
    100     Name += ".DW.stub";
    101 
    102     // Add information about the stub reference to ELFMMI so that the stub
    103     // gets emitted by the asmprinter.
    104     MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
    105     MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
    106     if (StubSym.getPointer() == 0) {
    107       MCSymbol *Sym = Mang->getSymbol(GV);
    108       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    109     }
    110 
    111     return TargetLoweringObjectFile::
    112       getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
    113                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
    114   }
    115 
    116   return TargetLoweringObjectFile::
    117     getTTypeGlobalReference(GV, Mang, MMI, Encoding, Streamer);
    118 }
    119 
    120 static SectionKind
    121 getELFKindForNamedSection(StringRef Name, SectionKind K) {
    122   // N.B.: The defaults used in here are no the same ones used in MC.
    123   // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
    124   // both gas and MC will produce a section with no flags. Given
    125   // section(".eh_frame") gcc will produce:
    126   //
    127   //   .section   .eh_frame,"a",@progbits
    128   if (Name.empty() || Name[0] != '.') return K;
    129 
    130   // Some lame default implementation based on some magic section names.
    131   if (Name == ".bss" ||
    132       Name.startswith(".bss.") ||
    133       Name.startswith(".gnu.linkonce.b.") ||
    134       Name.startswith(".llvm.linkonce.b.") ||
    135       Name == ".sbss" ||
    136       Name.startswith(".sbss.") ||
    137       Name.startswith(".gnu.linkonce.sb.") ||
    138       Name.startswith(".llvm.linkonce.sb."))
    139     return SectionKind::getBSS();
    140 
    141   if (Name == ".tdata" ||
    142       Name.startswith(".tdata.") ||
    143       Name.startswith(".gnu.linkonce.td.") ||
    144       Name.startswith(".llvm.linkonce.td."))
    145     return SectionKind::getThreadData();
    146 
    147   if (Name == ".tbss" ||
    148       Name.startswith(".tbss.") ||
    149       Name.startswith(".gnu.linkonce.tb.") ||
    150       Name.startswith(".llvm.linkonce.tb."))
    151     return SectionKind::getThreadBSS();
    152 
    153   return K;
    154 }
    155 
    156 
    157 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
    158 
    159   if (Name == ".init_array")
    160     return ELF::SHT_INIT_ARRAY;
    161 
    162   if (Name == ".fini_array")
    163     return ELF::SHT_FINI_ARRAY;
    164 
    165   if (Name == ".preinit_array")
    166     return ELF::SHT_PREINIT_ARRAY;
    167 
    168   if (K.isBSS() || K.isThreadBSS())
    169     return ELF::SHT_NOBITS;
    170 
    171   return ELF::SHT_PROGBITS;
    172 }
    173 
    174 
    175 static unsigned
    176 getELFSectionFlags(SectionKind K) {
    177   unsigned Flags = 0;
    178 
    179   if (!K.isMetadata())
    180     Flags |= ELF::SHF_ALLOC;
    181 
    182   if (K.isText())
    183     Flags |= ELF::SHF_EXECINSTR;
    184 
    185   if (K.isWriteable())
    186     Flags |= ELF::SHF_WRITE;
    187 
    188   if (K.isThreadLocal())
    189     Flags |= ELF::SHF_TLS;
    190 
    191   // K.isMergeableConst() is left out to honour PR4650
    192   if (K.isMergeableCString() || K.isMergeableConst4() ||
    193       K.isMergeableConst8() || K.isMergeableConst16())
    194     Flags |= ELF::SHF_MERGE;
    195 
    196   if (K.isMergeableCString())
    197     Flags |= ELF::SHF_STRINGS;
    198 
    199   return Flags;
    200 }
    201 
    202 
    203 const MCSection *TargetLoweringObjectFileELF::
    204 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
    205                          Mangler *Mang, const TargetMachine &TM) const {
    206   StringRef SectionName = GV->getSection();
    207 
    208   // Infer section flags from the section name if we can.
    209   Kind = getELFKindForNamedSection(SectionName, Kind);
    210 
    211   return getContext().getELFSection(SectionName,
    212                                     getELFSectionType(SectionName, Kind),
    213                                     getELFSectionFlags(Kind), Kind);
    214 }
    215 
    216 /// getSectionPrefixForGlobal - Return the section prefix name used by options
    217 /// FunctionsSections and DataSections.
    218 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
    219   if (Kind.isText())                 return ".text.";
    220   if (Kind.isReadOnly())             return ".rodata.";
    221   if (Kind.isBSS())                  return ".bss.";
    222 
    223   if (Kind.isThreadData())           return ".tdata.";
    224   if (Kind.isThreadBSS())            return ".tbss.";
    225 
    226   if (Kind.isDataNoRel())            return ".data.";
    227   if (Kind.isDataRelLocal())         return ".data.rel.local.";
    228   if (Kind.isDataRel())              return ".data.rel.";
    229   if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
    230 
    231   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    232   return ".data.rel.ro.";
    233 }
    234 
    235 
    236 const MCSection *TargetLoweringObjectFileELF::
    237 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
    238                        Mangler *Mang, const TargetMachine &TM) const {
    239   // If we have -ffunction-section or -fdata-section then we should emit the
    240   // global value to a uniqued section specifically for it.
    241   bool EmitUniquedSection;
    242   if (Kind.isText())
    243     EmitUniquedSection = TM.getFunctionSections();
    244   else
    245     EmitUniquedSection = TM.getDataSections();
    246 
    247   // If this global is linkonce/weak and the target handles this by emitting it
    248   // into a 'uniqued' section name, create and return the section now.
    249   if ((GV->isWeakForLinker() || EmitUniquedSection) &&
    250       !Kind.isCommon()) {
    251     const char *Prefix;
    252     Prefix = getSectionPrefixForGlobal(Kind);
    253 
    254     SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
    255     MCSymbol *Sym = Mang->getSymbol(GV);
    256     Name.append(Sym->getName().begin(), Sym->getName().end());
    257     StringRef Group = "";
    258     unsigned Flags = getELFSectionFlags(Kind);
    259     if (GV->isWeakForLinker()) {
    260       Group = Sym->getName();
    261       Flags |= ELF::SHF_GROUP;
    262     }
    263 
    264     return getContext().getELFSection(Name.str(),
    265                                       getELFSectionType(Name.str(), Kind),
    266                                       Flags, Kind, 0, Group);
    267   }
    268 
    269   if (Kind.isText()) return TextSection;
    270 
    271   if (Kind.isMergeable1ByteCString() ||
    272       Kind.isMergeable2ByteCString() ||
    273       Kind.isMergeable4ByteCString()) {
    274 
    275     // We also need alignment here.
    276     // FIXME: this is getting the alignment of the character, not the
    277     // alignment of the global!
    278     unsigned Align =
    279       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV));
    280 
    281     const char *SizeSpec = ".rodata.str1.";
    282     if (Kind.isMergeable2ByteCString())
    283       SizeSpec = ".rodata.str2.";
    284     else if (Kind.isMergeable4ByteCString())
    285       SizeSpec = ".rodata.str4.";
    286     else
    287       assert(Kind.isMergeable1ByteCString() && "unknown string width");
    288 
    289 
    290     std::string Name = SizeSpec + utostr(Align);
    291     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
    292                                       ELF::SHF_ALLOC |
    293                                       ELF::SHF_MERGE |
    294                                       ELF::SHF_STRINGS,
    295                                       Kind);
    296   }
    297 
    298   if (Kind.isMergeableConst()) {
    299     if (Kind.isMergeableConst4() && MergeableConst4Section)
    300       return MergeableConst4Section;
    301     if (Kind.isMergeableConst8() && MergeableConst8Section)
    302       return MergeableConst8Section;
    303     if (Kind.isMergeableConst16() && MergeableConst16Section)
    304       return MergeableConst16Section;
    305     return ReadOnlySection;  // .const
    306   }
    307 
    308   if (Kind.isReadOnly())             return ReadOnlySection;
    309 
    310   if (Kind.isThreadData())           return TLSDataSection;
    311   if (Kind.isThreadBSS())            return TLSBSSSection;
    312 
    313   // Note: we claim that common symbols are put in BSSSection, but they are
    314   // really emitted with the magic .comm directive, which creates a symbol table
    315   // entry but not a section.
    316   if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
    317 
    318   if (Kind.isDataNoRel())            return DataSection;
    319   if (Kind.isDataRelLocal())         return DataRelLocalSection;
    320   if (Kind.isDataRel())              return DataRelSection;
    321   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
    322 
    323   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    324   return DataRelROSection;
    325 }
    326 
    327 /// getSectionForConstant - Given a mergeable constant with the
    328 /// specified size and relocation information, return a section that it
    329 /// should be placed in.
    330 const MCSection *TargetLoweringObjectFileELF::
    331 getSectionForConstant(SectionKind Kind) const {
    332   if (Kind.isMergeableConst4() && MergeableConst4Section)
    333     return MergeableConst4Section;
    334   if (Kind.isMergeableConst8() && MergeableConst8Section)
    335     return MergeableConst8Section;
    336   if (Kind.isMergeableConst16() && MergeableConst16Section)
    337     return MergeableConst16Section;
    338   if (Kind.isReadOnly())
    339     return ReadOnlySection;
    340 
    341   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
    342   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
    343   return DataRelROSection;
    344 }
    345 
    346 const MCSection *
    347 TargetLoweringObjectFileELF::getStaticCtorSection(unsigned Priority) const {
    348   // The default scheme is .ctor / .dtor, so we have to invert the priority
    349   // numbering.
    350   if (Priority == 65535)
    351     return StaticCtorSection;
    352 
    353   if (UseInitArray) {
    354     std::string Name = std::string(".init_array.") + utostr(Priority);
    355     return getContext().getELFSection(Name, ELF::SHT_INIT_ARRAY,
    356                                       ELF::SHF_ALLOC | ELF::SHF_WRITE,
    357                                       SectionKind::getDataRel());
    358   } else {
    359     std::string Name = std::string(".ctors.") + utostr(65535 - Priority);
    360     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
    361                                       ELF::SHF_ALLOC |ELF::SHF_WRITE,
    362                                       SectionKind::getDataRel());
    363   }
    364 }
    365 
    366 const MCSection *
    367 TargetLoweringObjectFileELF::getStaticDtorSection(unsigned Priority) const {
    368   // The default scheme is .ctor / .dtor, so we have to invert the priority
    369   // numbering.
    370   if (Priority == 65535)
    371     return StaticDtorSection;
    372 
    373   if (UseInitArray) {
    374     std::string Name = std::string(".fini_array.") + utostr(Priority);
    375     return getContext().getELFSection(Name, ELF::SHT_FINI_ARRAY,
    376                                       ELF::SHF_ALLOC | ELF::SHF_WRITE,
    377                                       SectionKind::getDataRel());
    378   } else {
    379     std::string Name = std::string(".dtors.") + utostr(65535 - Priority);
    380     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
    381                                       ELF::SHF_ALLOC |ELF::SHF_WRITE,
    382                                       SectionKind::getDataRel());
    383   }
    384 }
    385 
    386 void
    387 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
    388   UseInitArray = UseInitArray_;
    389   if (!UseInitArray)
    390     return;
    391 
    392   StaticCtorSection =
    393     getContext().getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
    394                                ELF::SHF_WRITE |
    395                                ELF::SHF_ALLOC,
    396                                SectionKind::getDataRel());
    397   StaticDtorSection =
    398     getContext().getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
    399                                ELF::SHF_WRITE |
    400                                ELF::SHF_ALLOC,
    401                                SectionKind::getDataRel());
    402 }
    403 
    404 //===----------------------------------------------------------------------===//
    405 //                                 MachO
    406 //===----------------------------------------------------------------------===//
    407 
    408 /// emitModuleFlags - Perform code emission for module flags.
    409 void TargetLoweringObjectFileMachO::
    410 emitModuleFlags(MCStreamer &Streamer,
    411                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
    412                 Mangler *Mang, const TargetMachine &TM) const {
    413   unsigned VersionVal = 0;
    414   unsigned ImageInfoFlags = 0;
    415   MDNode *LinkerOptions = 0;
    416   StringRef SectionVal;
    417 
    418   for (ArrayRef<Module::ModuleFlagEntry>::iterator
    419          i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
    420     const Module::ModuleFlagEntry &MFE = *i;
    421 
    422     // Ignore flags with 'Require' behavior.
    423     if (MFE.Behavior == Module::Require)
    424       continue;
    425 
    426     StringRef Key = MFE.Key->getString();
    427     Value *Val = MFE.Val;
    428 
    429     if (Key == "Objective-C Image Info Version") {
    430       VersionVal = cast<ConstantInt>(Val)->getZExtValue();
    431     } else if (Key == "Objective-C Garbage Collection" ||
    432                Key == "Objective-C GC Only" ||
    433                Key == "Objective-C Is Simulated") {
    434       ImageInfoFlags |= cast<ConstantInt>(Val)->getZExtValue();
    435     } else if (Key == "Objective-C Image Info Section") {
    436       SectionVal = cast<MDString>(Val)->getString();
    437     } else if (Key == "Linker Options") {
    438       LinkerOptions = cast<MDNode>(Val);
    439     }
    440   }
    441 
    442   // Emit the linker options if present.
    443   if (LinkerOptions) {
    444     for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
    445       MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
    446       SmallVector<std::string, 4> StrOptions;
    447 
    448       // Convert to strings.
    449       for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
    450         MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
    451         StrOptions.push_back(MDOption->getString());
    452       }
    453 
    454       Streamer.EmitLinkerOptions(StrOptions);
    455     }
    456   }
    457 
    458   // The section is mandatory. If we don't have it, then we don't have GC info.
    459   if (SectionVal.empty()) return;
    460 
    461   StringRef Segment, Section;
    462   unsigned TAA = 0, StubSize = 0;
    463   bool TAAParsed;
    464   std::string ErrorCode =
    465     MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
    466                                           TAA, TAAParsed, StubSize);
    467   if (!ErrorCode.empty())
    468     // If invalid, report the error with report_fatal_error.
    469     report_fatal_error("Invalid section specifier '" + Section + "': " +
    470                        ErrorCode + ".");
    471 
    472   // Get the section.
    473   const MCSectionMachO *S =
    474     getContext().getMachOSection(Segment, Section, TAA, StubSize,
    475                                  SectionKind::getDataNoRel());
    476   Streamer.SwitchSection(S);
    477   Streamer.EmitLabel(getContext().
    478                      GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
    479   Streamer.EmitIntValue(VersionVal, 4);
    480   Streamer.EmitIntValue(ImageInfoFlags, 4);
    481   Streamer.AddBlankLine();
    482 }
    483 
    484 const MCSection *TargetLoweringObjectFileMachO::
    485 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
    486                          Mangler *Mang, const TargetMachine &TM) const {
    487   // Parse the section specifier and create it if valid.
    488   StringRef Segment, Section;
    489   unsigned TAA = 0, StubSize = 0;
    490   bool TAAParsed;
    491   std::string ErrorCode =
    492     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
    493                                           TAA, TAAParsed, StubSize);
    494   if (!ErrorCode.empty()) {
    495     // If invalid, report the error with report_fatal_error.
    496     report_fatal_error("Global variable '" + GV->getName() +
    497                        "' has an invalid section specifier '" +
    498                        GV->getSection() + "': " + ErrorCode + ".");
    499   }
    500 
    501   // Get the section.
    502   const MCSectionMachO *S =
    503     getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
    504 
    505   // If TAA wasn't set by ParseSectionSpecifier() above,
    506   // use the value returned by getMachOSection() as a default.
    507   if (!TAAParsed)
    508     TAA = S->getTypeAndAttributes();
    509 
    510   // Okay, now that we got the section, verify that the TAA & StubSize agree.
    511   // If the user declared multiple globals with different section flags, we need
    512   // to reject it here.
    513   if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
    514     // If invalid, report the error with report_fatal_error.
    515     report_fatal_error("Global variable '" + GV->getName() +
    516                        "' section type or attributes does not match previous"
    517                        " section specifier");
    518   }
    519 
    520   return S;
    521 }
    522 
    523 const MCSection *TargetLoweringObjectFileMachO::
    524 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
    525                        Mangler *Mang, const TargetMachine &TM) const {
    526 
    527   // Handle thread local data.
    528   if (Kind.isThreadBSS()) return TLSBSSSection;
    529   if (Kind.isThreadData()) return TLSDataSection;
    530 
    531   if (Kind.isText())
    532     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
    533 
    534   // If this is weak/linkonce, put this in a coalescable section, either in text
    535   // or data depending on if it is writable.
    536   if (GV->isWeakForLinker()) {
    537     if (Kind.isReadOnly())
    538       return ConstTextCoalSection;
    539     return DataCoalSection;
    540   }
    541 
    542   // FIXME: Alignment check should be handled by section classifier.
    543   if (Kind.isMergeable1ByteCString() &&
    544       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
    545     return CStringSection;
    546 
    547   // Do not put 16-bit arrays in the UString section if they have an
    548   // externally visible label, this runs into issues with certain linker
    549   // versions.
    550   if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
    551       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
    552     return UStringSection;
    553 
    554   if (Kind.isMergeableConst()) {
    555     if (Kind.isMergeableConst4())
    556       return FourByteConstantSection;
    557     if (Kind.isMergeableConst8())
    558       return EightByteConstantSection;
    559     if (Kind.isMergeableConst16() && SixteenByteConstantSection)
    560       return SixteenByteConstantSection;
    561   }
    562 
    563   // Otherwise, if it is readonly, but not something we can specially optimize,
    564   // just drop it in .const.
    565   if (Kind.isReadOnly())
    566     return ReadOnlySection;
    567 
    568   // If this is marked const, put it into a const section.  But if the dynamic
    569   // linker needs to write to it, put it in the data segment.
    570   if (Kind.isReadOnlyWithRel())
    571     return ConstDataSection;
    572 
    573   // Put zero initialized globals with strong external linkage in the
    574   // DATA, __common section with the .zerofill directive.
    575   if (Kind.isBSSExtern())
    576     return DataCommonSection;
    577 
    578   // Put zero initialized globals with local linkage in __DATA,__bss directive
    579   // with the .zerofill directive (aka .lcomm).
    580   if (Kind.isBSSLocal())
    581     return DataBSSSection;
    582 
    583   // Otherwise, just drop the variable in the normal data section.
    584   return DataSection;
    585 }
    586 
    587 const MCSection *
    588 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
    589   // If this constant requires a relocation, we have to put it in the data
    590   // segment, not in the text segment.
    591   if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
    592     return ConstDataSection;
    593 
    594   if (Kind.isMergeableConst4())
    595     return FourByteConstantSection;
    596   if (Kind.isMergeableConst8())
    597     return EightByteConstantSection;
    598   if (Kind.isMergeableConst16() && SixteenByteConstantSection)
    599     return SixteenByteConstantSection;
    600   return ReadOnlySection;  // .const
    601 }
    602 
    603 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
    604 /// not to emit the UsedDirective for some symbols in llvm.used.
    605 // FIXME: REMOVE this (rdar://7071300)
    606 bool TargetLoweringObjectFileMachO::
    607 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
    608   /// On Darwin, internally linked data beginning with "L" or "l" does not have
    609   /// the directive emitted (this occurs in ObjC metadata).
    610   if (!GV) return false;
    611 
    612   // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
    613   if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
    614     // FIXME: ObjC metadata is currently emitted as internal symbols that have
    615     // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
    616     // this horrible hack can go away.
    617     MCSymbol *Sym = Mang->getSymbol(GV);
    618     if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
    619       return false;
    620   }
    621 
    622   return true;
    623 }
    624 
    625 const MCExpr *TargetLoweringObjectFileMachO::
    626 getTTypeGlobalReference(const GlobalValue *GV, Mangler *Mang,
    627                         MachineModuleInfo *MMI, unsigned Encoding,
    628                         MCStreamer &Streamer) const {
    629   // The mach-o version of this method defaults to returning a stub reference.
    630 
    631   if (Encoding & DW_EH_PE_indirect) {
    632     MachineModuleInfoMachO &MachOMMI =
    633       MMI->getObjFileInfo<MachineModuleInfoMachO>();
    634 
    635     SmallString<128> Name;
    636     Mang->getNameWithPrefix(Name, GV, true);
    637     Name += "$non_lazy_ptr";
    638 
    639     // Add information about the stub reference to MachOMMI so that the stub
    640     // gets emitted by the asmprinter.
    641     MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
    642     MachineModuleInfoImpl::StubValueTy &StubSym =
    643       GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
    644                                   MachOMMI.getGVStubEntry(SSym);
    645     if (StubSym.getPointer() == 0) {
    646       MCSymbol *Sym = Mang->getSymbol(GV);
    647       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    648     }
    649 
    650     return TargetLoweringObjectFile::
    651       getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
    652                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
    653   }
    654 
    655   return TargetLoweringObjectFile::
    656     getTTypeGlobalReference(GV, Mang, MMI, Encoding, Streamer);
    657 }
    658 
    659 MCSymbol *TargetLoweringObjectFileMachO::
    660 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
    661                         MachineModuleInfo *MMI) const {
    662   // The mach-o version of this method defaults to returning a stub reference.
    663   MachineModuleInfoMachO &MachOMMI =
    664     MMI->getObjFileInfo<MachineModuleInfoMachO>();
    665 
    666   SmallString<128> Name;
    667   Mang->getNameWithPrefix(Name, GV, true);
    668   Name += "$non_lazy_ptr";
    669 
    670   // Add information about the stub reference to MachOMMI so that the stub
    671   // gets emitted by the asmprinter.
    672   MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
    673   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
    674   if (StubSym.getPointer() == 0) {
    675     MCSymbol *Sym = Mang->getSymbol(GV);
    676     StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
    677   }
    678 
    679   return SSym;
    680 }
    681 
    682 //===----------------------------------------------------------------------===//
    683 //                                  COFF
    684 //===----------------------------------------------------------------------===//
    685 
    686 static unsigned
    687 getCOFFSectionFlags(SectionKind K) {
    688   unsigned Flags = 0;
    689 
    690   if (K.isMetadata())
    691     Flags |=
    692       COFF::IMAGE_SCN_MEM_DISCARDABLE;
    693   else if (K.isText())
    694     Flags |=
    695       COFF::IMAGE_SCN_MEM_EXECUTE |
    696       COFF::IMAGE_SCN_MEM_READ |
    697       COFF::IMAGE_SCN_CNT_CODE;
    698   else if (K.isBSS ())
    699     Flags |=
    700       COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
    701       COFF::IMAGE_SCN_MEM_READ |
    702       COFF::IMAGE_SCN_MEM_WRITE;
    703   else if (K.isThreadLocal())
    704     Flags |=
    705       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    706       COFF::IMAGE_SCN_MEM_READ |
    707       COFF::IMAGE_SCN_MEM_WRITE;
    708   else if (K.isReadOnly())
    709     Flags |=
    710       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    711       COFF::IMAGE_SCN_MEM_READ;
    712   else if (K.isWriteable())
    713     Flags |=
    714       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
    715       COFF::IMAGE_SCN_MEM_READ |
    716       COFF::IMAGE_SCN_MEM_WRITE;
    717 
    718   return Flags;
    719 }
    720 
    721 const MCSection *TargetLoweringObjectFileCOFF::
    722 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
    723                          Mangler *Mang, const TargetMachine &TM) const {
    724   int Selection = 0;
    725   unsigned Characteristics = getCOFFSectionFlags(Kind);
    726   SmallString<128> Name(GV->getSection().c_str());
    727   if (GV->isWeakForLinker()) {
    728     Selection = COFF::IMAGE_COMDAT_SELECT_ANY;
    729     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
    730     MCSymbol *Sym = Mang->getSymbol(GV);
    731     Name.append("$");
    732     Name.append(Sym->getName().begin() + 1, Sym->getName().end());
    733   }
    734   return getContext().getCOFFSection(Name,
    735                                      Characteristics,
    736                                      Selection,
    737                                      Kind);
    738 }
    739 
    740 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
    741   if (Kind.isText())
    742     return ".text$";
    743   if (Kind.isBSS ())
    744     return ".bss$";
    745   if (Kind.isThreadLocal()) {
    746     // 'LLVM' is just an arbitary string to ensure that the section name gets
    747     // sorted in between '.tls$AAA' and '.tls$ZZZ' by the linker.
    748     return ".tls$LLVM";
    749   }
    750   if (Kind.isWriteable())
    751     return ".data$";
    752   return ".rdata$";
    753 }
    754 
    755 
    756 const MCSection *TargetLoweringObjectFileCOFF::
    757 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
    758                        Mangler *Mang, const TargetMachine &TM) const {
    759 
    760   // If this global is linkonce/weak and the target handles this by emitting it
    761   // into a 'uniqued' section name, create and return the section now.
    762   if (GV->isWeakForLinker()) {
    763     const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
    764     SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
    765     MCSymbol *Sym = Mang->getSymbol(GV);
    766     Name.append(Sym->getName().begin() + 1, Sym->getName().end());
    767 
    768     unsigned Characteristics = getCOFFSectionFlags(Kind);
    769 
    770     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
    771 
    772     return getContext().getCOFFSection(Name.str(), Characteristics,
    773                           COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
    774   }
    775 
    776   if (Kind.isText())
    777     return getTextSection();
    778 
    779   if (Kind.isThreadLocal())
    780     return getTLSDataSection();
    781 
    782   return getDataSection();
    783 }
    784 
    785