lib/CodeGen/TargetLoweringObjectFileImpl.cpp

   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/MC/MCValue.h"
  35 #include "llvm/Support/Dwarf.h"
  36 #include "llvm/Support/ELF.h"
  37 #include "llvm/Support/ErrorHandling.h"
  38 #include "llvm/Support/raw_ostream.h"
  39 #include "llvm/Target/TargetLowering.h"
  40 #include "llvm/Target/TargetMachine.h"
  41 #include "llvm/Target/TargetSubtargetInfo.h"
  42 using namespace llvm;
  43 using namespace dwarf;
  44
  45 //===----------------------------------------------------------------------===//
  46 //                                  ELF
  47 //===----------------------------------------------------------------------===//
  48
  49 MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
  50     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
  51     MachineModuleInfo *MMI) const {
  52   unsigned Encoding = getPersonalityEncoding();
  53   if ((Encoding & 0x80) == dwarf::DW_EH_PE_indirect)
  54     return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
  55                                           TM.getSymbol(GV, Mang)->getName());
  56   if ((Encoding & 0x70) == dwarf::DW_EH_PE_absptr)
  57     return TM.getSymbol(GV, Mang);
  58   report_fatal_error("We do not support this DWARF encoding yet!");
  59 }
  60
  61 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
  62                                                        const TargetMachine &TM,
  63                                                        const MCSymbol *Sym) const {
  64   SmallString<64> NameData("DW.ref.");
  65   NameData += Sym->getName();
  66   MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
  67   Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
  68   Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
  69   StringRef Prefix = ".data.";
  70   NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
  71   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
  72   const MCSection *Sec = getContext().getELFSection(NameData,
  73                                                     ELF::SHT_PROGBITS,
  74                                                     Flags,
  75                                                     0, Label->getName());
  76   unsigned Size = TM.getDataLayout()->getPointerSize();
  77   Streamer.SwitchSection(Sec);
  78   Streamer.EmitValueToAlignment(TM.getDataLayout()->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 const 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.isDataNoRel())
 237     return ".data";
 238   if (Kind.isDataRelLocal())
 239     return ".data.rel.local";
 240   if (Kind.isDataRel())
 241     return ".data.rel";
 242   if (Kind.isReadOnlyWithRelLocal())
 243     return ".data.rel.ro.local";
 244   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 245   return ".data.rel.ro";
 246 }
 247
 248 static const MCSectionELF *
 249 selectELFSectionForGlobal(MCContext &Ctx, const GlobalValue *GV,
 250                           SectionKind Kind, Mangler &Mang,
 251                           const TargetMachine &TM, bool EmitUniqueSection,
 252                           unsigned Flags, unsigned *NextUniqueID) {
 253   unsigned EntrySize = 0;
 254   if (Kind.isMergeableCString()) {
 255     if (Kind.isMergeable2ByteCString()) {
 256       EntrySize = 2;
 257     } else if (Kind.isMergeable4ByteCString()) {
 258       EntrySize = 4;
 259     } else {
 260       EntrySize = 1;
 261       assert(Kind.isMergeable1ByteCString() && "unknown string width");
 262     }
 263   } else if (Kind.isMergeableConst()) {
 264     if (Kind.isMergeableConst4()) {
 265       EntrySize = 4;
 266     } else if (Kind.isMergeableConst8()) {
 267       EntrySize = 8;
 268     } else {
 269       assert(Kind.isMergeableConst16() && "unknown data width");
 270       EntrySize = 16;
 271     }
 272   }
 273
 274   StringRef Group = "";
 275   if (const Comdat *C = getELFComdat(GV)) {
 276     Flags |= ELF::SHF_GROUP;
 277     Group = C->getName();
 278   }
 279
 280   bool UniqueSectionNames = TM.getUniqueSectionNames();
 281   SmallString<128> Name;
 282   if (Kind.isMergeableCString()) {
 283     // We also need alignment here.
 284     // FIXME: this is getting the alignment of the character, not the
 285     // alignment of the global!
 286     unsigned Align =
 287         TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV));
 288
 289     std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
 290     Name = SizeSpec + utostr(Align);
 291   } else if (Kind.isMergeableConst()) {
 292     Name = ".rodata.cst";
 293     Name += utostr(EntrySize);
 294   } else {
 295     Name = getSectionPrefixForGlobal(Kind);
 296   }
 297
 298   if (EmitUniqueSection && UniqueSectionNames) {
 299     Name.push_back('.');
 300     TM.getNameWithPrefix(Name, GV, Mang, true);
 301   }
 302   unsigned UniqueID = ~0;
 303   if (EmitUniqueSection && !UniqueSectionNames) {
 304     UniqueID = *NextUniqueID;
 305     (*NextUniqueID)++;
 306   }
 307   return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
 308                            EntrySize, Group, UniqueID);
 309 }
 310
 311 const MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
 312     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
 313     const TargetMachine &TM) const {
 314   unsigned Flags = getELFSectionFlags(Kind);
 315
 316   // If we have -ffunction-section or -fdata-section then we should emit the
 317   // global value to a uniqued section specifically for it.
 318   bool EmitUniqueSection = false;
 319   if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
 320     if (Kind.isText())
 321       EmitUniqueSection = TM.getFunctionSections();
 322     else
 323       EmitUniqueSection = TM.getDataSections();
 324   }
 325   EmitUniqueSection |= GV->hasComdat();
 326
 327   return selectELFSectionForGlobal(getContext(), GV, Kind, Mang, TM,
 328                                    EmitUniqueSection, Flags, &NextUniqueID);
 329 }
 330
 331 const MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
 332     const Function &F, Mangler &Mang, const TargetMachine &TM) const {
 333   // If the function can be removed, produce a unique section so that
 334   // the table doesn't prevent the removal.
 335   const Comdat *C = F.getComdat();
 336   bool EmitUniqueSection = TM.getFunctionSections() || C;
 337   if (!EmitUniqueSection)
 338     return ReadOnlySection;
 339
 340   return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
 341                                    Mang, TM, EmitUniqueSection, ELF::SHF_ALLOC,
 342                                    &NextUniqueID);
 343 }
 344
 345 bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection(
 346     bool UsesLabelDifference, const Function &F) const {
 347   // We can always create relative relocations, so use another section
 348   // that can be marked non-executable.
 349   return false;
 350 }
 351
 352 /// getSectionForConstant - Given a mergeable constant with the
 353 /// specified size and relocation information, return a section that it
 354 /// should be placed in.
 355 const MCSection *
 356 TargetLoweringObjectFileELF::getSectionForConstant(SectionKind Kind,
 357                                                    const Constant *C) const {
 358   if (Kind.isMergeableConst4() && MergeableConst4Section)
 359     return MergeableConst4Section;
 360   if (Kind.isMergeableConst8() && MergeableConst8Section)
 361     return MergeableConst8Section;
 362   if (Kind.isMergeableConst16() && MergeableConst16Section)
 363     return MergeableConst16Section;
 364   if (Kind.isReadOnly())
 365     return ReadOnlySection;
 366
 367   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
 368   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 369   return DataRelROSection;
 370 }
 371
 372 static const MCSectionELF *getStaticStructorSection(MCContext &Ctx,
 373                                                     bool UseInitArray,
 374                                                     bool IsCtor,
 375                                                     unsigned Priority,
 376                                                     const MCSymbol *KeySym) {
 377   std::string Name;
 378   unsigned Type;
 379   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
 380   StringRef COMDAT = KeySym ? KeySym->getName() : "";
 381
 382   if (KeySym)
 383     Flags |= ELF::SHF_GROUP;
 384
 385   if (UseInitArray) {
 386     if (IsCtor) {
 387       Type = ELF::SHT_INIT_ARRAY;
 388       Name = ".init_array";
 389     } else {
 390       Type = ELF::SHT_FINI_ARRAY;
 391       Name = ".fini_array";
 392     }
 393     if (Priority != 65535) {
 394       Name += '.';
 395       Name += utostr(Priority);
 396     }
 397   } else {
 398     // The default scheme is .ctor / .dtor, so we have to invert the priority
 399     // numbering.
 400     if (IsCtor)
 401       Name = ".ctors";
 402     else
 403       Name = ".dtors";
 404     if (Priority != 65535) {
 405       Name += '.';
 406       Name += utostr(65535 - Priority);
 407     }
 408     Type = ELF::SHT_PROGBITS;
 409   }
 410
 411   return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
 412 }
 413
 414 const MCSection *TargetLoweringObjectFileELF::getStaticCtorSection(
 415     unsigned Priority, const MCSymbol *KeySym) const {
 416   return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
 417                                   KeySym);
 418 }
 419
 420 const MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
 421     unsigned Priority, const MCSymbol *KeySym) const {
 422   return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
 423                                   KeySym);
 424 }
 425
 426 void
 427 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
 428   UseInitArray = UseInitArray_;
 429   if (!UseInitArray)
 430     return;
 431
 432   StaticCtorSection = getContext().getELFSection(
 433       ".init_array", ELF::SHT_INIT_ARRAY, ELF::SHF_WRITE | ELF::SHF_ALLOC);
 434   StaticDtorSection = getContext().getELFSection(
 435       ".fini_array", ELF::SHT_FINI_ARRAY, ELF::SHF_WRITE | ELF::SHF_ALLOC);
 436 }
 437
 438 //===----------------------------------------------------------------------===//
 439 //                                 MachO
 440 //===----------------------------------------------------------------------===//
 441
 442 TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO()
 443   : TargetLoweringObjectFile() {
 444   SupportIndirectSymViaGOTPCRel = true;
 445 }
 446
 447 /// getDepLibFromLinkerOpt - Extract the dependent library name from a linker
 448 /// option string. Returns StringRef() if the option does not specify a library.
 449 StringRef TargetLoweringObjectFileMachO::
 450 getDepLibFromLinkerOpt(StringRef LinkerOption) const {
 451   const char *LibCmd = "-l";
 452   if (LinkerOption.startswith(LibCmd))
 453     return LinkerOption.substr(strlen(LibCmd));
 454   return StringRef();
 455 }
 456
 457 /// emitModuleFlags - Perform code emission for module flags.
 458 void TargetLoweringObjectFileMachO::
 459 emitModuleFlags(MCStreamer &Streamer,
 460                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
 461                 Mangler &Mang, const TargetMachine &TM) const {
 462   unsigned VersionVal = 0;
 463   unsigned ImageInfoFlags = 0;
 464   MDNode *LinkerOptions = nullptr;
 465   StringRef SectionVal;
 466
 467   for (ArrayRef<Module::ModuleFlagEntry>::iterator
 468          i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
 469     const Module::ModuleFlagEntry &MFE = *i;
 470
 471     // Ignore flags with 'Require' behavior.
 472     if (MFE.Behavior == Module::Require)
 473       continue;
 474
 475     StringRef Key = MFE.Key->getString();
 476     Metadata *Val = MFE.Val;
 477
 478     if (Key == "Objective-C Image Info Version") {
 479       VersionVal = mdconst::extract<ConstantInt>(Val)->getZExtValue();
 480     } else if (Key == "Objective-C Garbage Collection" ||
 481                Key == "Objective-C GC Only" ||
 482                Key == "Objective-C Is Simulated" ||
 483                Key == "Objective-C Image Swift Version") {
 484       ImageInfoFlags |= mdconst::extract<ConstantInt>(Val)->getZExtValue();
 485     } else if (Key == "Objective-C Image Info Section") {
 486       SectionVal = cast<MDString>(Val)->getString();
 487     } else if (Key == "Linker Options") {
 488       LinkerOptions = cast<MDNode>(Val);
 489     }
 490   }
 491
 492   // Emit the linker options if present.
 493   if (LinkerOptions) {
 494     for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
 495       MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
 496       SmallVector<std::string, 4> StrOptions;
 497
 498       // Convert to strings.
 499       for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
 500         MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
 501         StrOptions.push_back(MDOption->getString());
 502       }
 503
 504       Streamer.EmitLinkerOptions(StrOptions);
 505     }
 506   }
 507
 508   // The section is mandatory. If we don't have it, then we don't have GC info.
 509   if (SectionVal.empty()) return;
 510
 511   StringRef Segment, Section;
 512   unsigned TAA = 0, StubSize = 0;
 513   bool TAAParsed;
 514   std::string ErrorCode =
 515     MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
 516                                           TAA, TAAParsed, StubSize);
 517   if (!ErrorCode.empty())
 518     // If invalid, report the error with report_fatal_error.
 519     report_fatal_error("Invalid section specifier '" + Section + "': " +
 520                        ErrorCode + ".");
 521
 522   // Get the section.
 523   const MCSectionMachO *S =
 524     getContext().getMachOSection(Segment, Section, TAA, StubSize,
 525                                  SectionKind::getDataNoRel());
 526   Streamer.SwitchSection(S);
 527   Streamer.EmitLabel(getContext().
 528                      GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
 529   Streamer.EmitIntValue(VersionVal, 4);
 530   Streamer.EmitIntValue(ImageInfoFlags, 4);
 531   Streamer.AddBlankLine();
 532 }
 533
 534 static void checkMachOComdat(const GlobalValue *GV) {
 535   const Comdat *C = GV->getComdat();
 536   if (!C)
 537     return;
 538
 539   report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
 540                      "' cannot be lowered.");
 541 }
 542
 543 const MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
 544     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
 545     const TargetMachine &TM) const {
 546   // Parse the section specifier and create it if valid.
 547   StringRef Segment, Section;
 548   unsigned TAA = 0, StubSize = 0;
 549   bool TAAParsed;
 550
 551   checkMachOComdat(GV);
 552
 553   std::string ErrorCode =
 554     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
 555                                           TAA, TAAParsed, StubSize);
 556   if (!ErrorCode.empty()) {
 557     // If invalid, report the error with report_fatal_error.
 558     report_fatal_error("Global variable '" + GV->getName() +
 559                        "' has an invalid section specifier '" +
 560                        GV->getSection() + "': " + ErrorCode + ".");
 561   }
 562
 563   // Get the section.
 564   const MCSectionMachO *S =
 565     getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
 566
 567   // If TAA wasn't set by ParseSectionSpecifier() above,
 568   // use the value returned by getMachOSection() as a default.
 569   if (!TAAParsed)
 570     TAA = S->getTypeAndAttributes();
 571
 572   // Okay, now that we got the section, verify that the TAA & StubSize agree.
 573   // If the user declared multiple globals with different section flags, we need
 574   // to reject it here.
 575   if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
 576     // If invalid, report the error with report_fatal_error.
 577     report_fatal_error("Global variable '" + GV->getName() +
 578                        "' section type or attributes does not match previous"
 579                        " section specifier");
 580   }
 581
 582   return S;
 583 }
 584
 585 const MCSection *TargetLoweringObjectFileMachO::
 586 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 587                        Mangler &Mang, const TargetMachine &TM) const {
 588   checkMachOComdat(GV);
 589
 590   // Handle thread local data.
 591   if (Kind.isThreadBSS()) return TLSBSSSection;
 592   if (Kind.isThreadData()) return TLSDataSection;
 593
 594   if (Kind.isText())
 595     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
 596
 597   // If this is weak/linkonce, put this in a coalescable section, either in text
 598   // or data depending on if it is writable.
 599   if (GV->isWeakForLinker()) {
 600     if (Kind.isReadOnly())
 601       return ConstTextCoalSection;
 602     return DataCoalSection;
 603   }
 604
 605   // FIXME: Alignment check should be handled by section classifier.
 606   if (Kind.isMergeable1ByteCString() &&
 607       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
 608     return CStringSection;
 609
 610   // Do not put 16-bit arrays in the UString section if they have an
 611   // externally visible label, this runs into issues with certain linker
 612   // versions.
 613   if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
 614       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
 615     return UStringSection;
 616
 617   // With MachO only variables whose corresponding symbol starts with 'l' or
 618   // 'L' can be merged, so we only try merging GVs with private linkage.
 619   if (GV->hasPrivateLinkage() && Kind.isMergeableConst()) {
 620     if (Kind.isMergeableConst4())
 621       return FourByteConstantSection;
 622     if (Kind.isMergeableConst8())
 623       return EightByteConstantSection;
 624     if (Kind.isMergeableConst16())
 625       return SixteenByteConstantSection;
 626   }
 627
 628   // Otherwise, if it is readonly, but not something we can specially optimize,
 629   // just drop it in .const.
 630   if (Kind.isReadOnly())
 631     return ReadOnlySection;
 632
 633   // If this is marked const, put it into a const section.  But if the dynamic
 634   // linker needs to write to it, put it in the data segment.
 635   if (Kind.isReadOnlyWithRel())
 636     return ConstDataSection;
 637
 638   // Put zero initialized globals with strong external linkage in the
 639   // DATA, __common section with the .zerofill directive.
 640   if (Kind.isBSSExtern())
 641     return DataCommonSection;
 642
 643   // Put zero initialized globals with local linkage in __DATA,__bss directive
 644   // with the .zerofill directive (aka .lcomm).
 645   if (Kind.isBSSLocal())
 646     return DataBSSSection;
 647
 648   // Otherwise, just drop the variable in the normal data section.
 649   return DataSection;
 650 }
 651
 652 const MCSection *
 653 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind,
 654                                                      const Constant *C) const {
 655   // If this constant requires a relocation, we have to put it in the data
 656   // segment, not in the text segment.
 657   if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
 658     return ConstDataSection;
 659
 660   if (Kind.isMergeableConst4())
 661     return FourByteConstantSection;
 662   if (Kind.isMergeableConst8())
 663     return EightByteConstantSection;
 664   if (Kind.isMergeableConst16())
 665     return SixteenByteConstantSection;
 666   return ReadOnlySection;  // .const
 667 }
 668
 669 const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
 670     const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
 671     const TargetMachine &TM, MachineModuleInfo *MMI,
 672     MCStreamer &Streamer) const {
 673   // The mach-o version of this method defaults to returning a stub reference.
 674
 675   if (Encoding & DW_EH_PE_indirect) {
 676     MachineModuleInfoMachO &MachOMMI =
 677       MMI->getObjFileInfo<MachineModuleInfoMachO>();
 678
 679     MCSymbol *SSym =
 680         getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM);
 681
 682     // Add information about the stub reference to MachOMMI so that the stub
 683     // gets emitted by the asmprinter.
 684     MachineModuleInfoImpl::StubValueTy &StubSym =
 685       GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
 686                                   MachOMMI.getGVStubEntry(SSym);
 687     if (!StubSym.getPointer()) {
 688       MCSymbol *Sym = TM.getSymbol(GV, Mang);
 689       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
 690     }
 691
 692     return TargetLoweringObjectFile::
 693       getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
 694                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
 695   }
 696
 697   return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, Mang,
 698                                                            TM, MMI, Streamer);
 699 }
 700
 701 MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
 702     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
 703     MachineModuleInfo *MMI) const {
 704   // The mach-o version of this method defaults to returning a stub reference.
 705   MachineModuleInfoMachO &MachOMMI =
 706     MMI->getObjFileInfo<MachineModuleInfoMachO>();
 707
 708   MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM);
 709
 710   // Add information about the stub reference to MachOMMI so that the stub
 711   // gets emitted by the asmprinter.
 712   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
 713   if (!StubSym.getPointer()) {
 714     MCSymbol *Sym = TM.getSymbol(GV, Mang);
 715     StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
 716   }
 717
 718   return SSym;
 719 }
 720
 721 const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
 722     const MCSymbol *Sym, const MCValue &MV, int64_t Offset,
 723     MachineModuleInfo *MMI, MCStreamer &Streamer) const {
 724   // Although MachO 32-bit targets do not explictly have a GOTPCREL relocation
 725   // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
 726   // through a non_lazy_ptr stub instead. One advantage is that it allows the
 727   // computation of deltas to final external symbols. Example:
 728   //
 729   //    _extgotequiv:
 730   //       .long   _extfoo
 731   //
 732   //    _delta:
 733   //       .long   _extgotequiv-_delta
 734   //
 735   // is transformed to:
 736   //
 737   //    _delta:
 738   //       .long   L_extfoo$non_lazy_ptr-(_delta+0)
 739   //
 740   //       .section        __IMPORT,__pointers,non_lazy_symbol_pointers
 741   //    L_extfoo$non_lazy_ptr:
 742   //       .indirect_symbol        _extfoo
 743   //       .long   0
 744   //
 745   MachineModuleInfoMachO &MachOMMI =
 746     MMI->getObjFileInfo<MachineModuleInfoMachO>();
 747   MCContext &Ctx = getContext();
 748
 749   // The offset must consider the original displacement from the base symbol
 750   // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
 751   Offset = -MV.getConstant();
 752   const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
 753
 754   // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
 755   // non_lazy_ptr stubs.
 756   SmallString<128> Name;
 757   StringRef Suffix = "$non_lazy_ptr";
 758   Name += DL->getPrivateGlobalPrefix();
 759   Name += Sym->getName();
 760   Name += Suffix;
 761   MCSymbol *Stub = Ctx.GetOrCreateSymbol(Name);
 762
 763   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
 764   if (!StubSym.getPointer())
 765     StubSym = MachineModuleInfoImpl::
 766       StubValueTy(const_cast<MCSymbol *>(Sym), true /* access indirectly */);
 767
 768   const MCExpr *BSymExpr =
 769     MCSymbolRefExpr::Create(BaseSym, MCSymbolRefExpr::VK_None, Ctx);
 770   const MCExpr *LHS =
 771     MCSymbolRefExpr::Create(Stub, MCSymbolRefExpr::VK_None, Ctx);
 772
 773   if (!Offset)
 774     return MCBinaryExpr::CreateSub(LHS, BSymExpr, Ctx);
 775
 776   const MCExpr *RHS =
 777     MCBinaryExpr::CreateAdd(BSymExpr, MCConstantExpr::Create(Offset, Ctx), Ctx);
 778   return MCBinaryExpr::CreateSub(LHS, RHS, Ctx);
 779 }
 780
 781 //===----------------------------------------------------------------------===//
 782 //                                  COFF
 783 //===----------------------------------------------------------------------===//
 784
 785 static unsigned
 786 getCOFFSectionFlags(SectionKind K) {
 787   unsigned Flags = 0;
 788
 789   if (K.isMetadata())
 790     Flags |=
 791       COFF::IMAGE_SCN_MEM_DISCARDABLE;
 792   else if (K.isText())
 793     Flags |=
 794       COFF::IMAGE_SCN_MEM_EXECUTE |
 795       COFF::IMAGE_SCN_MEM_READ |
 796       COFF::IMAGE_SCN_CNT_CODE;
 797   else if (K.isBSS())
 798     Flags |=
 799       COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
 800       COFF::IMAGE_SCN_MEM_READ |
 801       COFF::IMAGE_SCN_MEM_WRITE;
 802   else if (K.isThreadLocal())
 803     Flags |=
 804       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 805       COFF::IMAGE_SCN_MEM_READ |
 806       COFF::IMAGE_SCN_MEM_WRITE;
 807   else if (K.isReadOnly() || K.isReadOnlyWithRel())
 808     Flags |=
 809       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 810       COFF::IMAGE_SCN_MEM_READ;
 811   else if (K.isWriteable())
 812     Flags |=
 813       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 814       COFF::IMAGE_SCN_MEM_READ |
 815       COFF::IMAGE_SCN_MEM_WRITE;
 816
 817   return Flags;
 818 }
 819
 820 static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
 821   const Comdat *C = GV->getComdat();
 822   assert(C && "expected GV to have a Comdat!");
 823
 824   StringRef ComdatGVName = C->getName();
 825   const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
 826   if (!ComdatGV)
 827     report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
 828                        "' does not exist.");
 829
 830   if (ComdatGV->getComdat() != C)
 831     report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
 832                        "' is not a key for its COMDAT.");
 833
 834   return ComdatGV;
 835 }
 836
 837 static int getSelectionForCOFF(const GlobalValue *GV) {
 838   if (const Comdat *C = GV->getComdat()) {
 839     const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
 840     if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
 841       ComdatKey = GA->getBaseObject();
 842     if (ComdatKey == GV) {
 843       switch (C->getSelectionKind()) {
 844       case Comdat::Any:
 845         return COFF::IMAGE_COMDAT_SELECT_ANY;
 846       case Comdat::ExactMatch:
 847         return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
 848       case Comdat::Largest:
 849         return COFF::IMAGE_COMDAT_SELECT_LARGEST;
 850       case Comdat::NoDuplicates:
 851         return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
 852       case Comdat::SameSize:
 853         return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
 854       }
 855     } else {
 856       return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
 857     }
 858   } else if (GV->isWeakForLinker()) {
 859     return COFF::IMAGE_COMDAT_SELECT_ANY;
 860   }
 861   return 0;
 862 }
 863
 864 const 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
 907 const MCSection *TargetLoweringObjectFileCOFF::
 908 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 909                        Mangler &Mang, const TargetMachine &TM) const {
 910   // If we have -ffunction-sections then we should emit the global value to a
 911   // uniqued section specifically for it.
 912   bool EmitUniquedSection;
 913   if (Kind.isText())
 914     EmitUniquedSection = TM.getFunctionSections();
 915   else
 916     EmitUniquedSection = TM.getDataSections();
 917
 918   if ((EmitUniquedSection && !Kind.isCommon()) || GV->hasComdat()) {
 919     const char *Name = getCOFFSectionNameForUniqueGlobal(Kind);
 920     unsigned Characteristics = getCOFFSectionFlags(Kind);
 921
 922     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
 923     int Selection = getSelectionForCOFF(GV);
 924     if (!Selection)
 925       Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
 926     const GlobalValue *ComdatGV;
 927     if (GV->hasComdat())
 928       ComdatGV = getComdatGVForCOFF(GV);
 929     else
 930       ComdatGV = GV;
 931
 932     if (!ComdatGV->hasPrivateLinkage()) {
 933       MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
 934       StringRef COMDATSymName = Sym->getName();
 935       return getContext().getCOFFSection(Name, Characteristics, Kind,
 936                                          COMDATSymName, Selection);
 937     } else {
 938       SmallString<256> TmpData;
 939       getNameWithPrefix(TmpData, GV, /*CannotUsePrivateLabel=*/true, Mang, TM);
 940       return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
 941                                          Selection);
 942     }
 943   }
 944
 945   if (Kind.isText())
 946     return TextSection;
 947
 948   if (Kind.isThreadLocal())
 949     return TLSDataSection;
 950
 951   if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
 952     return ReadOnlySection;
 953
 954   // Note: we claim that common symbols are put in BSSSection, but they are
 955   // really emitted with the magic .comm directive, which creates a symbol table
 956   // entry but not a section.
 957   if (Kind.isBSS() || Kind.isCommon())
 958     return BSSSection;
 959
 960   return DataSection;
 961 }
 962
 963 void TargetLoweringObjectFileCOFF::getNameWithPrefix(
 964     SmallVectorImpl<char> &OutName, const GlobalValue *GV,
 965     bool CannotUsePrivateLabel, Mangler &Mang, const TargetMachine &TM) const {
 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 const 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 StringRef TargetLoweringObjectFileCOFF::
1000 getDepLibFromLinkerOpt(StringRef LinkerOption) const {
1001   const char *LibCmd = "/DEFAULTLIB:";
1002   if (LinkerOption.startswith(LibCmd))
1003     return LinkerOption.substr(strlen(LibCmd));
1004   return StringRef();
1005 }
1006
1007 void TargetLoweringObjectFileCOFF::
1008 emitModuleFlags(MCStreamer &Streamer,
1009                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
1010                 Mangler &Mang, const TargetMachine &TM) const {
1011   MDNode *LinkerOptions = nullptr;
1012
1013   // Look for the "Linker Options" flag, since it's the only one we support.
1014   for (ArrayRef<Module::ModuleFlagEntry>::iterator
1015        i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
1016     const Module::ModuleFlagEntry &MFE = *i;
1017     StringRef Key = MFE.Key->getString();
1018     Metadata *Val = MFE.Val;
1019     if (Key == "Linker Options") {
1020       LinkerOptions = cast<MDNode>(Val);
1021       break;
1022     }
1023   }
1024   if (!LinkerOptions)
1025     return;
1026
1027   // Emit the linker options to the linker .drectve section.  According to the
1028   // spec, this section is a space-separated string containing flags for linker.
1029   const MCSection *Sec = getDrectveSection();
1030   Streamer.SwitchSection(Sec);
1031   for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
1032     MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
1033     for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
1034       MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
1035       // Lead with a space for consistency with our dllexport implementation.
1036       std::string Directive(" ");
1037       Directive.append(MDOption->getString());
1038       Streamer.EmitBytes(Directive);
1039     }
1040   }
1041 }
1042
1043 const MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
1044     unsigned Priority, const MCSymbol *KeySym) const {
1045   return getContext().getAssociativeCOFFSection(
1046       cast<MCSectionCOFF>(StaticCtorSection), KeySym);
1047 }
1048
1049 const MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
1050     unsigned Priority, const MCSymbol *KeySym) const {
1051   return getContext().getAssociativeCOFFSection(
1052       cast<MCSectionCOFF>(StaticDtorSection), KeySym);
1053 }