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