TargetLoweringObjectFileImpl.cpp revision 4de5872dede6e3dd80f7ab3df5df4fe0e33e3b2e 
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/Constants.h"
17#include "llvm/DerivedTypes.h"
18#include "llvm/Function.h"
19#include "llvm/GlobalVariable.h"
20#include "llvm/Module.h"
21#include "llvm/CodeGen/MachineModuleInfoImpls.h"
22#include "llvm/MC/MCContext.h"
23#include "llvm/MC/MCExpr.h"
24#include "llvm/MC/MCSectionMachO.h"
25#include "llvm/MC/MCSectionELF.h"
26#include "llvm/MC/MCSectionCOFF.h"
27#include "llvm/MC/MCStreamer.h"
28#include "llvm/MC/MCSymbol.h"
29#include "llvm/Target/Mangler.h"
30#include "llvm/DataLayout.h"
31#include "llvm/Target/TargetMachine.h"
32#include "llvm/Target/TargetOptions.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/ADT/SmallString.h"
38#include "llvm/ADT/StringExtras.h"
39#include "llvm/ADT/Triple.h"
40using namespace llvm;
41using namespace dwarf;
42
43//===----------------------------------------------------------------------===//
44//                                  ELF
45//===----------------------------------------------------------------------===//
46
47MCSymbol *
48TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
49                                                     Mangler *Mang,
50                                                MachineModuleInfo *MMI) const {
51  unsigned Encoding = getPersonalityEncoding();
52  switch (Encoding & 0x70) {
53  default:
54    report_fatal_error("We do not support this DWARF encoding yet!");
55  case dwarf::DW_EH_PE_absptr:
56    return  Mang->getSymbol(GV);
57  case dwarf::DW_EH_PE_pcrel: {
58    return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
59                                          Mang->getSymbol(GV)->getName());
60  }
61  }
62}
63
64void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
65                                                       const TargetMachine &TM,
66                                                       const MCSymbol *Sym) const {
67  SmallString<64> NameData("DW.ref.");
68  NameData += Sym->getName();
69  MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
70  Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
71  Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
72  StringRef Prefix = ".data.";
73  NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
74  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
75  const MCSection *Sec = getContext().getELFSection(NameData,
76                                                    ELF::SHT_PROGBITS,
77                                                    Flags,
78                                                    SectionKind::getDataRel(),
79                                                    0, Label->getName());
80  unsigned Size = TM.getDataLayout()->getPointerSize();
81  Streamer.SwitchSection(Sec);
82  Streamer.EmitValueToAlignment(TM.getDataLayout()->getPointerABIAlignment());
83  Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
84  const MCExpr *E = MCConstantExpr::Create(Size, getContext());
85  Streamer.EmitELFSize(Label, E);
86  Streamer.EmitLabel(Label);
87
88  Streamer.EmitSymbolValue(Sym, Size);
89}
90
91static SectionKind
92getELFKindForNamedSection(StringRef Name, SectionKind K) {
93  // N.B.: The defaults used in here are no the same ones used in MC.
94  // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
95  // both gas and MC will produce a section with no flags. Given
96  // section(".eh_frame") gcc will produce:
97  //
98  //   .section   .eh_frame,"a",@progbits
99  if (Name.empty() || Name[0] != '.') return K;
100
101  // Some lame default implementation based on some magic section names.
102  if (Name == ".bss" ||
103      Name.startswith(".bss.") ||
104      Name.startswith(".gnu.linkonce.b.") ||
105      Name.startswith(".llvm.linkonce.b.") ||
106      Name == ".sbss" ||
107      Name.startswith(".sbss.") ||
108      Name.startswith(".gnu.linkonce.sb.") ||
109      Name.startswith(".llvm.linkonce.sb."))
110    return SectionKind::getBSS();
111
112  if (Name == ".tdata" ||
113      Name.startswith(".tdata.") ||
114      Name.startswith(".gnu.linkonce.td.") ||
115      Name.startswith(".llvm.linkonce.td."))
116    return SectionKind::getThreadData();
117
118  if (Name == ".tbss" ||
119      Name.startswith(".tbss.") ||
120      Name.startswith(".gnu.linkonce.tb.") ||
121      Name.startswith(".llvm.linkonce.tb."))
122    return SectionKind::getThreadBSS();
123
124  return K;
125}
126
127
128static unsigned getELFSectionType(StringRef Name, SectionKind K) {
129
130  if (Name == ".init_array")
131    return ELF::SHT_INIT_ARRAY;
132
133  if (Name == ".fini_array")
134    return ELF::SHT_FINI_ARRAY;
135
136  if (Name == ".preinit_array")
137    return ELF::SHT_PREINIT_ARRAY;
138
139  if (K.isBSS() || K.isThreadBSS())
140    return ELF::SHT_NOBITS;
141
142  return ELF::SHT_PROGBITS;
143}
144
145
146static unsigned
147getELFSectionFlags(SectionKind K) {
148  unsigned Flags = 0;
149
150  if (!K.isMetadata())
151    Flags |= ELF::SHF_ALLOC;
152
153  if (K.isText())
154    Flags |= ELF::SHF_EXECINSTR;
155
156  if (K.isWriteable())
157    Flags |= ELF::SHF_WRITE;
158
159  if (K.isThreadLocal())
160    Flags |= ELF::SHF_TLS;
161
162  // K.isMergeableConst() is left out to honour PR4650
163  if (K.isMergeableCString() || K.isMergeableConst4() ||
164      K.isMergeableConst8() || K.isMergeableConst16())
165    Flags |= ELF::SHF_MERGE;
166
167  if (K.isMergeableCString())
168    Flags |= ELF::SHF_STRINGS;
169
170  return Flags;
171}
172
173
174const MCSection *TargetLoweringObjectFileELF::
175getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
176                         Mangler *Mang, const TargetMachine &TM) const {
177  StringRef SectionName = GV->getSection();
178
179  // Infer section flags from the section name if we can.
180  Kind = getELFKindForNamedSection(SectionName, Kind);
181
182  return getContext().getELFSection(SectionName,
183                                    getELFSectionType(SectionName, Kind),
184                                    getELFSectionFlags(Kind), Kind);
185}
186
187/// getSectionPrefixForGlobal - Return the section prefix name used by options
188/// FunctionsSections and DataSections.
189static const char *getSectionPrefixForGlobal(SectionKind Kind) {
190  if (Kind.isText())                 return ".text.";
191  if (Kind.isReadOnly())             return ".rodata.";
192  if (Kind.isBSS())                  return ".bss.";
193
194  if (Kind.isThreadData())           return ".tdata.";
195  if (Kind.isThreadBSS())            return ".tbss.";
196
197  if (Kind.isDataNoRel())            return ".data.";
198  if (Kind.isDataRelLocal())         return ".data.rel.local.";
199  if (Kind.isDataRel())              return ".data.rel.";
200  if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
201
202  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
203  return ".data.rel.ro.";
204}
205
206
207const MCSection *TargetLoweringObjectFileELF::
208SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
209                       Mangler *Mang, const TargetMachine &TM) const {
210  // If we have -ffunction-section or -fdata-section then we should emit the
211  // global value to a uniqued section specifically for it.
212  bool EmitUniquedSection;
213  if (Kind.isText())
214    EmitUniquedSection = TM.getFunctionSections();
215  else
216    EmitUniquedSection = TM.getDataSections();
217
218  // If this global is linkonce/weak and the target handles this by emitting it
219  // into a 'uniqued' section name, create and return the section now.
220  if ((GV->isWeakForLinker() || EmitUniquedSection) &&
221      !Kind.isCommon()) {
222    const char *Prefix;
223    Prefix = getSectionPrefixForGlobal(Kind);
224
225    SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
226    MCSymbol *Sym = Mang->getSymbol(GV);
227    Name.append(Sym->getName().begin(), Sym->getName().end());
228    StringRef Group = "";
229    unsigned Flags = getELFSectionFlags(Kind);
230    if (GV->isWeakForLinker()) {
231      Group = Sym->getName();
232      Flags |= ELF::SHF_GROUP;
233    }
234
235    return getContext().getELFSection(Name.str(),
236                                      getELFSectionType(Name.str(), Kind),
237                                      Flags, Kind, 0, Group);
238  }
239
240  if (Kind.isText()) return TextSection;
241
242  if (Kind.isMergeable1ByteCString() ||
243      Kind.isMergeable2ByteCString() ||
244      Kind.isMergeable4ByteCString()) {
245
246    // We also need alignment here.
247    // FIXME: this is getting the alignment of the character, not the
248    // alignment of the global!
249    unsigned Align =
250      TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV));
251
252    const char *SizeSpec = ".rodata.str1.";
253    if (Kind.isMergeable2ByteCString())
254      SizeSpec = ".rodata.str2.";
255    else if (Kind.isMergeable4ByteCString())
256      SizeSpec = ".rodata.str4.";
257    else
258      assert(Kind.isMergeable1ByteCString() && "unknown string width");
259
260
261    std::string Name = SizeSpec + utostr(Align);
262    return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
263                                      ELF::SHF_ALLOC |
264                                      ELF::SHF_MERGE |
265                                      ELF::SHF_STRINGS,
266                                      Kind);
267  }
268
269  if (Kind.isMergeableConst()) {
270    if (Kind.isMergeableConst4() && MergeableConst4Section)
271      return MergeableConst4Section;
272    if (Kind.isMergeableConst8() && MergeableConst8Section)
273      return MergeableConst8Section;
274    if (Kind.isMergeableConst16() && MergeableConst16Section)
275      return MergeableConst16Section;
276    return ReadOnlySection;  // .const
277  }
278
279  if (Kind.isReadOnly())             return ReadOnlySection;
280
281  if (Kind.isThreadData())           return TLSDataSection;
282  if (Kind.isThreadBSS())            return TLSBSSSection;
283
284  // Note: we claim that common symbols are put in BSSSection, but they are
285  // really emitted with the magic .comm directive, which creates a symbol table
286  // entry but not a section.
287  if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
288
289  if (Kind.isDataNoRel())            return DataSection;
290  if (Kind.isDataRelLocal())         return DataRelLocalSection;
291  if (Kind.isDataRel())              return DataRelSection;
292  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
293
294  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
295  return DataRelROSection;
296}
297
298/// getSectionForConstant - Given a mergeable constant with the
299/// specified size and relocation information, return a section that it
300/// should be placed in.
301const MCSection *TargetLoweringObjectFileELF::
302getSectionForConstant(SectionKind Kind) const {
303  if (Kind.isMergeableConst4() && MergeableConst4Section)
304    return MergeableConst4Section;
305  if (Kind.isMergeableConst8() && MergeableConst8Section)
306    return MergeableConst8Section;
307  if (Kind.isMergeableConst16() && MergeableConst16Section)
308    return MergeableConst16Section;
309  if (Kind.isReadOnly())
310    return ReadOnlySection;
311
312  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
313  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
314  return DataRelROSection;
315}
316
317const MCExpr *TargetLoweringObjectFileELF::
318getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
319                               MachineModuleInfo *MMI,
320                               unsigned Encoding, MCStreamer &Streamer) const {
321
322  if (Encoding & dwarf::DW_EH_PE_indirect) {
323    MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
324
325    SmallString<128> Name;
326    Mang->getNameWithPrefix(Name, GV, true);
327    Name += ".DW.stub";
328
329    // Add information about the stub reference to ELFMMI so that the stub
330    // gets emitted by the asmprinter.
331    MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
332    MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
333    if (StubSym.getPointer() == 0) {
334      MCSymbol *Sym = Mang->getSymbol(GV);
335      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
336    }
337
338    return TargetLoweringObjectFile::
339      getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
340  }
341
342  return TargetLoweringObjectFile::
343    getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
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 - Emit the module flags that specify the garbage collection
409/// information.
410void TargetLoweringObjectFileMachO::
411emitModuleFlags(MCStreamer &Streamer,
412                ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
413                Mangler *Mang, const TargetMachine &TM) const {
414  unsigned VersionVal = 0;
415  unsigned ImageInfoFlags = 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  }
438
439  // The section is mandatory. If we don't have it, then we don't have GC info.
440  if (SectionVal.empty()) return;
441
442  StringRef Segment, Section;
443  unsigned TAA = 0, StubSize = 0;
444  bool TAAParsed;
445  std::string ErrorCode =
446    MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
447                                          TAA, TAAParsed, StubSize);
448  if (!ErrorCode.empty())
449    // If invalid, report the error with report_fatal_error.
450    report_fatal_error("Invalid section specifier '" + Section + "': " +
451                       ErrorCode + ".");
452
453  // Get the section.
454  const MCSectionMachO *S =
455    getContext().getMachOSection(Segment, Section, TAA, StubSize,
456                                 SectionKind::getDataNoRel());
457  Streamer.SwitchSection(S);
458  Streamer.EmitLabel(getContext().
459                     GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
460  Streamer.EmitIntValue(VersionVal, 4);
461  Streamer.EmitIntValue(ImageInfoFlags, 4);
462  Streamer.AddBlankLine();
463}
464
465const MCSection *TargetLoweringObjectFileMachO::
466getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
467                         Mangler *Mang, const TargetMachine &TM) const {
468  // Parse the section specifier and create it if valid.
469  StringRef Segment, Section;
470  unsigned TAA = 0, StubSize = 0;
471  bool TAAParsed;
472  std::string ErrorCode =
473    MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
474                                          TAA, TAAParsed, StubSize);
475  if (!ErrorCode.empty()) {
476    // If invalid, report the error with report_fatal_error.
477    report_fatal_error("Global variable '" + GV->getName() +
478                       "' has an invalid section specifier '" +
479                       GV->getSection() + "': " + ErrorCode + ".");
480  }
481
482  // Get the section.
483  const MCSectionMachO *S =
484    getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
485
486  // If TAA wasn't set by ParseSectionSpecifier() above,
487  // use the value returned by getMachOSection() as a default.
488  if (!TAAParsed)
489    TAA = S->getTypeAndAttributes();
490
491  // Okay, now that we got the section, verify that the TAA & StubSize agree.
492  // If the user declared multiple globals with different section flags, we need
493  // to reject it here.
494  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
495    // If invalid, report the error with report_fatal_error.
496    report_fatal_error("Global variable '" + GV->getName() +
497                       "' section type or attributes does not match previous"
498                       " section specifier");
499  }
500
501  return S;
502}
503
504const MCSection *TargetLoweringObjectFileMachO::
505SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
506                       Mangler *Mang, const TargetMachine &TM) const {
507
508  // Handle thread local data.
509  if (Kind.isThreadBSS()) return TLSBSSSection;
510  if (Kind.isThreadData()) return TLSDataSection;
511
512  if (Kind.isText())
513    return GV->isWeakForLinker() ? TextCoalSection : TextSection;
514
515  // If this is weak/linkonce, put this in a coalescable section, either in text
516  // or data depending on if it is writable.
517  if (GV->isWeakForLinker()) {
518    if (Kind.isReadOnly())
519      return ConstTextCoalSection;
520    return DataCoalSection;
521  }
522
523  // FIXME: Alignment check should be handled by section classifier.
524  if (Kind.isMergeable1ByteCString() &&
525      TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
526    return CStringSection;
527
528  // Do not put 16-bit arrays in the UString section if they have an
529  // externally visible label, this runs into issues with certain linker
530  // versions.
531  if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
532      TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
533    return UStringSection;
534
535  if (Kind.isMergeableConst()) {
536    if (Kind.isMergeableConst4())
537      return FourByteConstantSection;
538    if (Kind.isMergeableConst8())
539      return EightByteConstantSection;
540    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
541      return SixteenByteConstantSection;
542  }
543
544  // Otherwise, if it is readonly, but not something we can specially optimize,
545  // just drop it in .const.
546  if (Kind.isReadOnly())
547    return ReadOnlySection;
548
549  // If this is marked const, put it into a const section.  But if the dynamic
550  // linker needs to write to it, put it in the data segment.
551  if (Kind.isReadOnlyWithRel())
552    return ConstDataSection;
553
554  // Put zero initialized globals with strong external linkage in the
555  // DATA, __common section with the .zerofill directive.
556  if (Kind.isBSSExtern())
557    return DataCommonSection;
558
559  // Put zero initialized globals with local linkage in __DATA,__bss directive
560  // with the .zerofill directive (aka .lcomm).
561  if (Kind.isBSSLocal())
562    return DataBSSSection;
563
564  // Otherwise, just drop the variable in the normal data section.
565  return DataSection;
566}
567
568const MCSection *
569TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
570  // If this constant requires a relocation, we have to put it in the data
571  // segment, not in the text segment.
572  if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
573    return ConstDataSection;
574
575  if (Kind.isMergeableConst4())
576    return FourByteConstantSection;
577  if (Kind.isMergeableConst8())
578    return EightByteConstantSection;
579  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
580    return SixteenByteConstantSection;
581  return ReadOnlySection;  // .const
582}
583
584/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
585/// not to emit the UsedDirective for some symbols in llvm.used.
586// FIXME: REMOVE this (rdar://7071300)
587bool TargetLoweringObjectFileMachO::
588shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
589  /// On Darwin, internally linked data beginning with "L" or "l" does not have
590  /// the directive emitted (this occurs in ObjC metadata).
591  if (!GV) return false;
592
593  // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
594  if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
595    // FIXME: ObjC metadata is currently emitted as internal symbols that have
596    // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
597    // this horrible hack can go away.
598    MCSymbol *Sym = Mang->getSymbol(GV);
599    if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
600      return false;
601  }
602
603  return true;
604}
605
606const MCExpr *TargetLoweringObjectFileMachO::
607getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
608                               MachineModuleInfo *MMI, unsigned Encoding,
609                               MCStreamer &Streamer) const {
610  // The mach-o version of this method defaults to returning a stub reference.
611
612  if (Encoding & DW_EH_PE_indirect) {
613    MachineModuleInfoMachO &MachOMMI =
614      MMI->getObjFileInfo<MachineModuleInfoMachO>();
615
616    SmallString<128> Name;
617    Mang->getNameWithPrefix(Name, GV, true);
618    Name += "$non_lazy_ptr";
619
620    // Add information about the stub reference to MachOMMI so that the stub
621    // gets emitted by the asmprinter.
622    MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
623    MachineModuleInfoImpl::StubValueTy &StubSym =
624      GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
625                                  MachOMMI.getGVStubEntry(SSym);
626    if (StubSym.getPointer() == 0) {
627      MCSymbol *Sym = Mang->getSymbol(GV);
628      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
629    }
630
631    return TargetLoweringObjectFile::
632      getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
633  }
634
635  return TargetLoweringObjectFile::
636    getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
637}
638
639MCSymbol *TargetLoweringObjectFileMachO::
640getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
641                        MachineModuleInfo *MMI) const {
642  // The mach-o version of this method defaults to returning a stub reference.
643  MachineModuleInfoMachO &MachOMMI =
644    MMI->getObjFileInfo<MachineModuleInfoMachO>();
645
646  SmallString<128> Name;
647  Mang->getNameWithPrefix(Name, GV, true);
648  Name += "$non_lazy_ptr";
649
650  // Add information about the stub reference to MachOMMI so that the stub
651  // gets emitted by the asmprinter.
652  MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
653  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
654  if (StubSym.getPointer() == 0) {
655    MCSymbol *Sym = Mang->getSymbol(GV);
656    StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
657  }
658
659  return SSym;
660}
661
662//===----------------------------------------------------------------------===//
663//                                  COFF
664//===----------------------------------------------------------------------===//
665
666static unsigned
667getCOFFSectionFlags(SectionKind K) {
668  unsigned Flags = 0;
669
670  if (K.isMetadata())
671    Flags |=
672      COFF::IMAGE_SCN_MEM_DISCARDABLE;
673  else if (K.isText())
674    Flags |=
675      COFF::IMAGE_SCN_MEM_EXECUTE |
676      COFF::IMAGE_SCN_MEM_READ |
677      COFF::IMAGE_SCN_CNT_CODE;
678  else if (K.isBSS ())
679    Flags |=
680      COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
681      COFF::IMAGE_SCN_MEM_READ |
682      COFF::IMAGE_SCN_MEM_WRITE;
683  else if (K.isThreadLocal())
684    Flags |=
685      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
686      COFF::IMAGE_SCN_MEM_READ |
687      COFF::IMAGE_SCN_MEM_WRITE;
688  else if (K.isReadOnly())
689    Flags |=
690      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
691      COFF::IMAGE_SCN_MEM_READ;
692  else if (K.isWriteable())
693    Flags |=
694      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
695      COFF::IMAGE_SCN_MEM_READ |
696      COFF::IMAGE_SCN_MEM_WRITE;
697
698  return Flags;
699}
700
701const MCSection *TargetLoweringObjectFileCOFF::
702getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
703                         Mangler *Mang, const TargetMachine &TM) const {
704  int Selection = 0;
705  unsigned Characteristics = getCOFFSectionFlags(Kind);
706  SmallString<128> Name(GV->getSection().c_str());
707  if (GV->isWeakForLinker()) {
708    Selection = COFF::IMAGE_COMDAT_SELECT_ANY;
709    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
710    MCSymbol *Sym = Mang->getSymbol(GV);
711    Name.append("$");
712    Name.append(Sym->getName().begin() + 1, Sym->getName().end());
713  }
714  return getContext().getCOFFSection(Name,
715                                     Characteristics,
716                                     Selection,
717                                     Kind);
718}
719
720static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
721  if (Kind.isText())
722    return ".text$";
723  if (Kind.isBSS ())
724    return ".bss$";
725  if (Kind.isThreadLocal())
726    return ".tls$";
727  if (Kind.isWriteable())
728    return ".data$";
729  return ".rdata$";
730}
731
732
733const MCSection *TargetLoweringObjectFileCOFF::
734SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
735                       Mangler *Mang, const TargetMachine &TM) const {
736
737  // If this global is linkonce/weak and the target handles this by emitting it
738  // into a 'uniqued' section name, create and return the section now.
739  if (GV->isWeakForLinker()) {
740    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
741    SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
742    MCSymbol *Sym = Mang->getSymbol(GV);
743    Name.append(Sym->getName().begin() + 1, Sym->getName().end());
744
745    unsigned Characteristics = getCOFFSectionFlags(Kind);
746
747    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
748
749    return getContext().getCOFFSection(Name.str(), Characteristics,
750                          COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
751  }
752
753  if (Kind.isText())
754    return getTextSection();
755
756  if (Kind.isThreadLocal())
757    return getTLSDataSection();
758
759  return getDataSection();
760}
761
762