TargetLoweringObjectFileImpl.cpp revision 38af06736e6d46ef3d417e40b9843ca1658fc8e7 
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  getSymbol(*Mang, GV);
56  case dwarf::DW_EH_PE_pcrel: {
57    return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
58                                          getSymbol(*Mang, 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 = getSymbol(*Mang, 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 = getSymbol(*Mang, 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
527  // Handle thread local data.
528  if (Kind.isThreadBSS()) return TLSBSSSection;
529  if (Kind.isThreadData()) return TLSDataSection;
530
531  if (Kind.isText())
532    return GV->isWeakForLinker() ? TextCoalSection : TextSection;
533
534  // If this is weak/linkonce, put this in a coalescable section, either in text
535  // or data depending on if it is writable.
536  if (GV->isWeakForLinker()) {
537    if (Kind.isReadOnly())
538      return ConstTextCoalSection;
539    return DataCoalSection;
540  }
541
542  // FIXME: Alignment check should be handled by section classifier.
543  if (Kind.isMergeable1ByteCString() &&
544      TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
545    return CStringSection;
546
547  // Do not put 16-bit arrays in the UString section if they have an
548  // externally visible label, this runs into issues with certain linker
549  // versions.
550  if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
551      TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
552    return UStringSection;
553
554  if (Kind.isMergeableConst()) {
555    if (Kind.isMergeableConst4())
556      return FourByteConstantSection;
557    if (Kind.isMergeableConst8())
558      return EightByteConstantSection;
559    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
560      return SixteenByteConstantSection;
561  }
562
563  // Otherwise, if it is readonly, but not something we can specially optimize,
564  // just drop it in .const.
565  if (Kind.isReadOnly())
566    return ReadOnlySection;
567
568  // If this is marked const, put it into a const section.  But if the dynamic
569  // linker needs to write to it, put it in the data segment.
570  if (Kind.isReadOnlyWithRel())
571    return ConstDataSection;
572
573  // Put zero initialized globals with strong external linkage in the
574  // DATA, __common section with the .zerofill directive.
575  if (Kind.isBSSExtern())
576    return DataCommonSection;
577
578  // Put zero initialized globals with local linkage in __DATA,__bss directive
579  // with the .zerofill directive (aka .lcomm).
580  if (Kind.isBSSLocal())
581    return DataBSSSection;
582
583  // Otherwise, just drop the variable in the normal data section.
584  return DataSection;
585}
586
587const MCSection *
588TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
589  // If this constant requires a relocation, we have to put it in the data
590  // segment, not in the text segment.
591  if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
592    return ConstDataSection;
593
594  if (Kind.isMergeableConst4())
595    return FourByteConstantSection;
596  if (Kind.isMergeableConst8())
597    return EightByteConstantSection;
598  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
599    return SixteenByteConstantSection;
600  return ReadOnlySection;  // .const
601}
602
603/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
604/// not to emit the UsedDirective for some symbols in llvm.used.
605// FIXME: REMOVE this (rdar://7071300)
606bool TargetLoweringObjectFileMachO::
607shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
608  /// On Darwin, internally linked data beginning with "L" or "l" does not have
609  /// the directive emitted (this occurs in ObjC metadata).
610  if (!GV) return false;
611
612  // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
613  if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
614    // FIXME: ObjC metadata is currently emitted as internal symbols that have
615    // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
616    // this horrible hack can go away.
617    MCSymbol *Sym = getSymbol(*Mang, GV);
618    if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
619      return false;
620  }
621
622  return true;
623}
624
625const MCExpr *TargetLoweringObjectFileMachO::
626getTTypeGlobalReference(const GlobalValue *GV, Mangler *Mang,
627                        MachineModuleInfo *MMI, unsigned Encoding,
628                        MCStreamer &Streamer) const {
629  // The mach-o version of this method defaults to returning a stub reference.
630
631  if (Encoding & DW_EH_PE_indirect) {
632    MachineModuleInfoMachO &MachOMMI =
633      MMI->getObjFileInfo<MachineModuleInfoMachO>();
634
635    SmallString<128> Name;
636    Mang->getNameWithPrefix(Name, GV, true);
637    Name += "$non_lazy_ptr";
638
639    // Add information about the stub reference to MachOMMI so that the stub
640    // gets emitted by the asmprinter.
641    MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
642    MachineModuleInfoImpl::StubValueTy &StubSym =
643      GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
644                                  MachOMMI.getGVStubEntry(SSym);
645    if (StubSym.getPointer() == 0) {
646      MCSymbol *Sym = getSymbol(*Mang, GV);
647      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
648    }
649
650    return TargetLoweringObjectFile::
651      getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
652                        Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
653  }
654
655  return TargetLoweringObjectFile::
656    getTTypeGlobalReference(GV, Mang, MMI, Encoding, Streamer);
657}
658
659MCSymbol *TargetLoweringObjectFileMachO::
660getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
661                        MachineModuleInfo *MMI) const {
662  // The mach-o version of this method defaults to returning a stub reference.
663  MachineModuleInfoMachO &MachOMMI =
664    MMI->getObjFileInfo<MachineModuleInfoMachO>();
665
666  SmallString<128> Name;
667  Mang->getNameWithPrefix(Name, GV, true);
668  Name += "$non_lazy_ptr";
669
670  // Add information about the stub reference to MachOMMI so that the stub
671  // gets emitted by the asmprinter.
672  MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
673  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
674  if (StubSym.getPointer() == 0) {
675    MCSymbol *Sym = getSymbol(*Mang, GV);
676    StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
677  }
678
679  return SSym;
680}
681
682//===----------------------------------------------------------------------===//
683//                                  COFF
684//===----------------------------------------------------------------------===//
685
686static unsigned
687getCOFFSectionFlags(SectionKind K) {
688  unsigned Flags = 0;
689
690  if (K.isMetadata())
691    Flags |=
692      COFF::IMAGE_SCN_MEM_DISCARDABLE;
693  else if (K.isText())
694    Flags |=
695      COFF::IMAGE_SCN_MEM_EXECUTE |
696      COFF::IMAGE_SCN_MEM_READ |
697      COFF::IMAGE_SCN_CNT_CODE;
698  else if (K.isBSS ())
699    Flags |=
700      COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
701      COFF::IMAGE_SCN_MEM_READ |
702      COFF::IMAGE_SCN_MEM_WRITE;
703  else if (K.isThreadLocal())
704    Flags |=
705      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
706      COFF::IMAGE_SCN_MEM_READ |
707      COFF::IMAGE_SCN_MEM_WRITE;
708  else if (K.isReadOnly())
709    Flags |=
710      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
711      COFF::IMAGE_SCN_MEM_READ;
712  else if (K.isWriteable())
713    Flags |=
714      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
715      COFF::IMAGE_SCN_MEM_READ |
716      COFF::IMAGE_SCN_MEM_WRITE;
717
718  return Flags;
719}
720
721const MCSection *TargetLoweringObjectFileCOFF::
722getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
723                         Mangler *Mang, const TargetMachine &TM) const {
724  int Selection = 0;
725  unsigned Characteristics = getCOFFSectionFlags(Kind);
726  StringRef Name = GV->getSection();
727  StringRef COMDATSymName = "";
728  if (GV->isWeakForLinker()) {
729    Selection = COFF::IMAGE_COMDAT_SELECT_ANY;
730    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
731    MCSymbol *Sym = getSymbol(*Mang, GV);
732    COMDATSymName = Sym->getName();
733  }
734  return getContext().getCOFFSection(Name,
735                                     Characteristics,
736                                     Kind,
737                                     COMDATSymName,
738                                     Selection);
739}
740
741static const char *getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
742  if (Kind.isText())
743    return ".text";
744  if (Kind.isBSS ())
745    return ".bss";
746  if (Kind.isThreadLocal())
747    return ".tls";
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 *Name = getCOFFSectionNameForUniqueGlobal(Kind);
762    unsigned Characteristics = getCOFFSectionFlags(Kind);
763
764    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
765    MCSymbol *Sym = getSymbol(*Mang, GV);
766    return getContext().getCOFFSection(Name, Characteristics,
767                                       Kind, Sym->getName(),
768                                       COFF::IMAGE_COMDAT_SELECT_ANY);
769  }
770
771  if (Kind.isText())
772    return TextSection;
773
774  if (Kind.isThreadLocal())
775    return TLSDataSection;
776
777  if (Kind.isReadOnly())
778    return ReadOnlySection;
779
780  if (Kind.isBSS())
781    return BSSSection;
782
783  return DataSection;
784}
785
786void TargetLoweringObjectFileCOFF::
787emitModuleFlags(MCStreamer &Streamer,
788                ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
789                Mangler *Mang, const TargetMachine &TM) const {
790  MDNode *LinkerOptions = 0;
791
792  // Look for the "Linker Options" flag, since it's the only one we support.
793  for (ArrayRef<Module::ModuleFlagEntry>::iterator
794       i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
795    const Module::ModuleFlagEntry &MFE = *i;
796    StringRef Key = MFE.Key->getString();
797    Value *Val = MFE.Val;
798    if (Key == "Linker Options") {
799      LinkerOptions = cast<MDNode>(Val);
800      break;
801    }
802  }
803  if (!LinkerOptions)
804    return;
805
806  // Emit the linker options to the linker .drectve section.  According to the
807  // spec, this section is a space-separated string containing flags for linker.
808  const MCSection *Sec = getDrectveSection();
809  Streamer.SwitchSection(Sec);
810  for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
811    MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
812    for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
813      MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
814      StringRef Op = MDOption->getString();
815      // Lead with a space for consistency with our dllexport implementation.
816      std::string Escaped(" ");
817      if (Op.find(" ") != StringRef::npos) {
818        // The PE-COFF spec says args with spaces must be quoted.  It doesn't say
819        // how to escape quotes, but it probably uses this algorithm:
820        // http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx
821        // FIXME: Reuse escaping code from Support/Windows/Program.inc
822        Escaped.push_back('\"');
823        Escaped.append(Op);
824        Escaped.push_back('\"');
825      } else {
826        Escaped.append(Op);
827      }
828      Streamer.EmitBytes(Escaped);
829    }
830  }
831}
832