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