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