TargetLoweringObjectFileImpl.cpp revision b464d3ff72790260e8c2068afe856fd7299a6834 
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/Target/TargetData.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  Streamer.SwitchSection(Sec);
81  Streamer.EmitValueToAlignment(8);
82  Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
83  const MCExpr *E = MCConstantExpr::Create(8, getContext());
84  Streamer.EmitELFSize(Label, E);
85  Streamer.EmitLabel(Label);
86
87  unsigned Size = TM.getTargetData()->getPointerSize();
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  // .section	.eh_frame,"a",@progbits
98  if (Name.empty() || Name[0] != '.') return K;
99
100  // Some lame default implementation based on some magic section names.
101  if (Name == ".bss" ||
102      Name.startswith(".bss.") ||
103      Name.startswith(".gnu.linkonce.b.") ||
104      Name.startswith(".llvm.linkonce.b.") ||
105      Name == ".sbss" ||
106      Name.startswith(".sbss.") ||
107      Name.startswith(".gnu.linkonce.sb.") ||
108      Name.startswith(".llvm.linkonce.sb."))
109    return SectionKind::getBSS();
110
111  if (Name == ".tdata" ||
112      Name.startswith(".tdata.") ||
113      Name.startswith(".gnu.linkonce.td.") ||
114      Name.startswith(".llvm.linkonce.td."))
115    return SectionKind::getThreadData();
116
117  if (Name == ".tbss" ||
118      Name.startswith(".tbss.") ||
119      Name.startswith(".gnu.linkonce.tb.") ||
120      Name.startswith(".llvm.linkonce.tb."))
121    return SectionKind::getThreadBSS();
122
123  return K;
124}
125
126
127static unsigned getELFSectionType(StringRef Name, SectionKind K) {
128
129  if (Name == ".init_array")
130    return ELF::SHT_INIT_ARRAY;
131
132  if (Name == ".fini_array")
133    return ELF::SHT_FINI_ARRAY;
134
135  if (Name == ".preinit_array")
136    return ELF::SHT_PREINIT_ARRAY;
137
138  if (K.isBSS() || K.isThreadBSS())
139    return ELF::SHT_NOBITS;
140
141  return ELF::SHT_PROGBITS;
142}
143
144
145static unsigned
146getELFSectionFlags(SectionKind K) {
147  unsigned Flags = 0;
148
149  if (!K.isMetadata())
150    Flags |= ELF::SHF_ALLOC;
151
152  if (K.isText())
153    Flags |= ELF::SHF_EXECINSTR;
154
155  if (K.isWriteable())
156    Flags |= ELF::SHF_WRITE;
157
158  if (K.isThreadLocal())
159    Flags |= ELF::SHF_TLS;
160
161  // K.isMergeableConst() is left out to honour PR4650
162  if (K.isMergeableCString() || K.isMergeableConst4() ||
163      K.isMergeableConst8() || K.isMergeableConst16())
164    Flags |= ELF::SHF_MERGE;
165
166  if (K.isMergeableCString())
167    Flags |= ELF::SHF_STRINGS;
168
169  return Flags;
170}
171
172
173const MCSection *TargetLoweringObjectFileELF::
174getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
175                         Mangler *Mang, const TargetMachine &TM) const {
176  StringRef SectionName = GV->getSection();
177
178  // Infer section flags from the section name if we can.
179  Kind = getELFKindForNamedSection(SectionName, Kind);
180
181  return getContext().getELFSection(SectionName,
182                                    getELFSectionType(SectionName, Kind),
183                                    getELFSectionFlags(Kind), Kind);
184}
185
186/// getSectionPrefixForGlobal - Return the section prefix name used by options
187/// FunctionsSections and DataSections.
188static const char *getSectionPrefixForGlobal(SectionKind Kind) {
189  if (Kind.isText())                 return ".text.";
190  if (Kind.isReadOnly())             return ".rodata.";
191
192  if (Kind.isThreadData())           return ".tdata.";
193  if (Kind.isThreadBSS())            return ".tbss.";
194
195  if (Kind.isDataNoRel())            return ".data.";
196  if (Kind.isDataRelLocal())         return ".data.rel.local.";
197  if (Kind.isDataRel())              return ".data.rel.";
198  if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
199
200  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
201  return ".data.rel.ro.";
202}
203
204
205const MCSection *TargetLoweringObjectFileELF::
206SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
207                       Mangler *Mang, const TargetMachine &TM) const {
208  // If we have -ffunction-section or -fdata-section then we should emit the
209  // global value to a uniqued section specifically for it.
210  bool EmitUniquedSection;
211  if (Kind.isText())
212    EmitUniquedSection = TM.getFunctionSections();
213  else
214    EmitUniquedSection = TM.getDataSections();
215
216  // If this global is linkonce/weak and the target handles this by emitting it
217  // into a 'uniqued' section name, create and return the section now.
218  if ((GV->isWeakForLinker() || EmitUniquedSection) &&
219      !Kind.isCommon() && !Kind.isBSS()) {
220    const char *Prefix;
221    Prefix = getSectionPrefixForGlobal(Kind);
222
223    SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
224    MCSymbol *Sym = Mang->getSymbol(GV);
225    Name.append(Sym->getName().begin(), Sym->getName().end());
226    StringRef Group = "";
227    unsigned Flags = getELFSectionFlags(Kind);
228    if (GV->isWeakForLinker()) {
229      Group = Sym->getName();
230      Flags |= ELF::SHF_GROUP;
231    }
232
233    return getContext().getELFSection(Name.str(),
234                                      getELFSectionType(Name.str(), Kind),
235                                      Flags, Kind, 0, Group);
236  }
237
238  if (Kind.isText()) return TextSection;
239
240  if (Kind.isMergeable1ByteCString() ||
241      Kind.isMergeable2ByteCString() ||
242      Kind.isMergeable4ByteCString()) {
243
244    // We also need alignment here.
245    // FIXME: this is getting the alignment of the character, not the
246    // alignment of the global!
247    unsigned Align =
248      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
249
250    const char *SizeSpec = ".rodata.str1.";
251    if (Kind.isMergeable2ByteCString())
252      SizeSpec = ".rodata.str2.";
253    else if (Kind.isMergeable4ByteCString())
254      SizeSpec = ".rodata.str4.";
255    else
256      assert(Kind.isMergeable1ByteCString() && "unknown string width");
257
258
259    std::string Name = SizeSpec + utostr(Align);
260    return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
261                                      ELF::SHF_ALLOC |
262                                      ELF::SHF_MERGE |
263                                      ELF::SHF_STRINGS,
264                                      Kind);
265  }
266
267  if (Kind.isMergeableConst()) {
268    if (Kind.isMergeableConst4() && MergeableConst4Section)
269      return MergeableConst4Section;
270    if (Kind.isMergeableConst8() && MergeableConst8Section)
271      return MergeableConst8Section;
272    if (Kind.isMergeableConst16() && MergeableConst16Section)
273      return MergeableConst16Section;
274    return ReadOnlySection;  // .const
275  }
276
277  if (Kind.isReadOnly())             return ReadOnlySection;
278
279  if (Kind.isThreadData())           return TLSDataSection;
280  if (Kind.isThreadBSS())            return TLSBSSSection;
281
282  // Note: we claim that common symbols are put in BSSSection, but they are
283  // really emitted with the magic .comm directive, which creates a symbol table
284  // entry but not a section.
285  if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
286
287  if (Kind.isDataNoRel())            return DataSection;
288  if (Kind.isDataRelLocal())         return DataRelLocalSection;
289  if (Kind.isDataRel())              return DataRelSection;
290  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
291
292  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
293  return DataRelROSection;
294}
295
296/// getSectionForConstant - Given a mergeable constant with the
297/// specified size and relocation information, return a section that it
298/// should be placed in.
299const MCSection *TargetLoweringObjectFileELF::
300getSectionForConstant(SectionKind Kind) const {
301  if (Kind.isMergeableConst4() && MergeableConst4Section)
302    return MergeableConst4Section;
303  if (Kind.isMergeableConst8() && MergeableConst8Section)
304    return MergeableConst8Section;
305  if (Kind.isMergeableConst16() && MergeableConst16Section)
306    return MergeableConst16Section;
307  if (Kind.isReadOnly())
308    return ReadOnlySection;
309
310  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
311  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
312  return DataRelROSection;
313}
314
315const MCExpr *TargetLoweringObjectFileELF::
316getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
317                               MachineModuleInfo *MMI,
318                               unsigned Encoding, MCStreamer &Streamer) const {
319
320  if (Encoding & dwarf::DW_EH_PE_indirect) {
321    MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
322
323    SmallString<128> Name;
324    Mang->getNameWithPrefix(Name, GV, true);
325    Name += ".DW.stub";
326
327    // Add information about the stub reference to ELFMMI so that the stub
328    // gets emitted by the asmprinter.
329    MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
330    MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
331    if (StubSym.getPointer() == 0) {
332      MCSymbol *Sym = Mang->getSymbol(GV);
333      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
334    }
335
336    return TargetLoweringObjectFile::
337      getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
338  }
339
340  return TargetLoweringObjectFile::
341    getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
342}
343
344const MCSection *
345TargetLoweringObjectFileELF::getStaticCtorSection(unsigned Priority) const {
346  // The default scheme is .ctor / .dtor, so we have to invert the priority
347  // numbering.
348  if (Priority == 65535)
349    return StaticCtorSection;
350
351  std::string Name = std::string(".ctors.") + utostr(65535 - Priority);
352  return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
353                                    ELF::SHF_ALLOC |ELF::SHF_WRITE,
354                                    SectionKind::getDataRel());
355}
356
357const MCSection *
358TargetLoweringObjectFileELF::getStaticDtorSection(unsigned Priority) const {
359  // The default scheme is .ctor / .dtor, so we have to invert the priority
360  // numbering.
361  if (Priority == 65535)
362    return StaticDtorSection;
363
364  std::string Name = std::string(".dtors.") + utostr(65535 - Priority);
365  return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
366                                    ELF::SHF_ALLOC |ELF::SHF_WRITE,
367                                    SectionKind::getDataRel());
368}
369
370//===----------------------------------------------------------------------===//
371//                                 MachO
372//===----------------------------------------------------------------------===//
373
374/// emitModuleFlags - Emit the module flags that specify the garbage collection
375/// information.
376void TargetLoweringObjectFileMachO::
377emitModuleFlags(MCStreamer &Streamer, NamedMDNode *ModFlags,
378                Mangler *Mang, const TargetMachine &TM) const {
379  StringRef Version("Objective-C Image Info Version");
380  StringRef SectionSpec("Objective-C Image Info Section");
381  StringRef GC("Objective-C Garbage Collection");
382  StringRef GCOnly("Objective-C GC Only");
383
384  unsigned VersionVal = 0;
385  unsigned GCFlags = 0;
386  StringRef Section;
387
388  for (unsigned i = 0, e = ModFlags->getNumOperands(); i != e; ++i) {
389    MDNode *Flag = ModFlags->getOperand(i);
390    Value *Behavior = Flag->getOperand(0);
391
392    // Ignore flags with 'Require' behavior.
393    if (cast<ConstantInt>(Behavior)->getZExtValue() == Module::Require)
394      continue;
395
396    Value *Key = Flag->getOperand(1);
397    Value *Val = Flag->getOperand(2);
398
399    StringRef KeyStr = cast<MDString>(Key)->getString();
400
401    if (KeyStr == Version)
402      VersionVal = cast<ConstantInt>(Val)->getZExtValue();
403    else if (KeyStr == GC || KeyStr == GCOnly)
404      GCFlags |= cast<ConstantInt>(Val)->getZExtValue();
405    else if (KeyStr == SectionSpec)
406      Section = cast<MDString>(Val)->getString();
407  }
408
409  // The section is mandatory. If we don't have it, then we don't have image
410  // info information.
411  if (Section.empty()) return;
412
413  uint32_t Values[2] = { VersionVal, GCFlags };
414  Module *M = ModFlags->getParent();
415  Constant *Init = ConstantDataArray::get(M->getContext(), Values);
416  GlobalVariable *GV = new GlobalVariable(*M, Init->getType(), false,
417                                          GlobalValue::InternalLinkage, Init,
418                                          "\01L_OBJC_IMAGE_INFO");
419  GV->setSection(Section);
420
421  MCSymbol *GVSym = Mang->getSymbol(GV);
422  SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
423  const MCSection *TheSection = SectionForGlobal(GV, GVKind, Mang, TM);
424
425  Streamer.SwitchSection(TheSection);
426  Streamer.EmitLabel(GVSym);
427
428  Streamer.EmitIntValue(VersionVal, 4);
429  Streamer.EmitIntValue(GCFlags, 4);
430  Streamer.AddBlankLine();
431}
432
433const MCSection *TargetLoweringObjectFileMachO::
434getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
435                         Mangler *Mang, const TargetMachine &TM) const {
436  // Parse the section specifier and create it if valid.
437  StringRef Segment, Section;
438  unsigned TAA = 0, StubSize = 0;
439  bool TAAParsed;
440  std::string ErrorCode =
441    MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
442                                          TAA, TAAParsed, StubSize);
443  if (!ErrorCode.empty()) {
444    // If invalid, report the error with report_fatal_error.
445    report_fatal_error("Global variable '" + GV->getName() +
446                       "' has an invalid section specifier '" +
447                       GV->getSection() + "': " + ErrorCode + ".");
448  }
449
450  // Get the section.
451  const MCSectionMachO *S =
452    getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
453
454  // If TAA wasn't set by ParseSectionSpecifier() above,
455  // use the value returned by getMachOSection() as a default.
456  if (!TAAParsed)
457    TAA = S->getTypeAndAttributes();
458
459  // Okay, now that we got the section, verify that the TAA & StubSize agree.
460  // If the user declared multiple globals with different section flags, we need
461  // to reject it here.
462  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
463    // If invalid, report the error with report_fatal_error.
464    report_fatal_error("Global variable '" + GV->getName() +
465                       "' section type or attributes does not match previous"
466                       " section specifier");
467  }
468
469  return S;
470}
471
472const MCSection *TargetLoweringObjectFileMachO::
473SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
474                       Mangler *Mang, const TargetMachine &TM) const {
475
476  // Handle thread local data.
477  if (Kind.isThreadBSS()) return TLSBSSSection;
478  if (Kind.isThreadData()) return TLSDataSection;
479
480  if (Kind.isText())
481    return GV->isWeakForLinker() ? TextCoalSection : TextSection;
482
483  // If this is weak/linkonce, put this in a coalescable section, either in text
484  // or data depending on if it is writable.
485  if (GV->isWeakForLinker()) {
486    if (Kind.isReadOnly())
487      return ConstTextCoalSection;
488    return DataCoalSection;
489  }
490
491  // FIXME: Alignment check should be handled by section classifier.
492  if (Kind.isMergeable1ByteCString() &&
493      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
494    return CStringSection;
495
496  // Do not put 16-bit arrays in the UString section if they have an
497  // externally visible label, this runs into issues with certain linker
498  // versions.
499  if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
500      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
501    return UStringSection;
502
503  if (Kind.isMergeableConst()) {
504    if (Kind.isMergeableConst4())
505      return FourByteConstantSection;
506    if (Kind.isMergeableConst8())
507      return EightByteConstantSection;
508    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
509      return SixteenByteConstantSection;
510  }
511
512  // Otherwise, if it is readonly, but not something we can specially optimize,
513  // just drop it in .const.
514  if (Kind.isReadOnly())
515    return ReadOnlySection;
516
517  // If this is marked const, put it into a const section.  But if the dynamic
518  // linker needs to write to it, put it in the data segment.
519  if (Kind.isReadOnlyWithRel())
520    return ConstDataSection;
521
522  // Put zero initialized globals with strong external linkage in the
523  // DATA, __common section with the .zerofill directive.
524  if (Kind.isBSSExtern())
525    return DataCommonSection;
526
527  // Put zero initialized globals with local linkage in __DATA,__bss directive
528  // with the .zerofill directive (aka .lcomm).
529  if (Kind.isBSSLocal())
530    return DataBSSSection;
531
532  // Otherwise, just drop the variable in the normal data section.
533  return DataSection;
534}
535
536const MCSection *
537TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
538  // If this constant requires a relocation, we have to put it in the data
539  // segment, not in the text segment.
540  if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
541    return ConstDataSection;
542
543  if (Kind.isMergeableConst4())
544    return FourByteConstantSection;
545  if (Kind.isMergeableConst8())
546    return EightByteConstantSection;
547  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
548    return SixteenByteConstantSection;
549  return ReadOnlySection;  // .const
550}
551
552/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
553/// not to emit the UsedDirective for some symbols in llvm.used.
554// FIXME: REMOVE this (rdar://7071300)
555bool TargetLoweringObjectFileMachO::
556shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
557  /// On Darwin, internally linked data beginning with "L" or "l" does not have
558  /// the directive emitted (this occurs in ObjC metadata).
559  if (!GV) return false;
560
561  // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
562  if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
563    // FIXME: ObjC metadata is currently emitted as internal symbols that have
564    // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
565    // this horrible hack can go away.
566    MCSymbol *Sym = Mang->getSymbol(GV);
567    if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
568      return false;
569  }
570
571  return true;
572}
573
574const MCExpr *TargetLoweringObjectFileMachO::
575getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
576                               MachineModuleInfo *MMI, unsigned Encoding,
577                               MCStreamer &Streamer) const {
578  // The mach-o version of this method defaults to returning a stub reference.
579
580  if (Encoding & DW_EH_PE_indirect) {
581    MachineModuleInfoMachO &MachOMMI =
582      MMI->getObjFileInfo<MachineModuleInfoMachO>();
583
584    SmallString<128> Name;
585    Mang->getNameWithPrefix(Name, GV, true);
586    Name += "$non_lazy_ptr";
587
588    // Add information about the stub reference to MachOMMI so that the stub
589    // gets emitted by the asmprinter.
590    MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
591    MachineModuleInfoImpl::StubValueTy &StubSym =
592      GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
593                                  MachOMMI.getGVStubEntry(SSym);
594    if (StubSym.getPointer() == 0) {
595      MCSymbol *Sym = Mang->getSymbol(GV);
596      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
597    }
598
599    return TargetLoweringObjectFile::
600      getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
601  }
602
603  return TargetLoweringObjectFile::
604    getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
605}
606
607MCSymbol *TargetLoweringObjectFileMachO::
608getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
609                        MachineModuleInfo *MMI) const {
610  // The mach-o version of this method defaults to returning a stub reference.
611  MachineModuleInfoMachO &MachOMMI =
612    MMI->getObjFileInfo<MachineModuleInfoMachO>();
613
614  SmallString<128> Name;
615  Mang->getNameWithPrefix(Name, GV, true);
616  Name += "$non_lazy_ptr";
617
618  // Add information about the stub reference to MachOMMI so that the stub
619  // gets emitted by the asmprinter.
620  MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
621  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
622  if (StubSym.getPointer() == 0) {
623    MCSymbol *Sym = Mang->getSymbol(GV);
624    StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
625  }
626
627  return SSym;
628}
629
630//===----------------------------------------------------------------------===//
631//                                  COFF
632//===----------------------------------------------------------------------===//
633
634static unsigned
635getCOFFSectionFlags(SectionKind K) {
636  unsigned Flags = 0;
637
638  if (K.isMetadata())
639    Flags |=
640      COFF::IMAGE_SCN_MEM_DISCARDABLE;
641  else if (K.isText())
642    Flags |=
643      COFF::IMAGE_SCN_MEM_EXECUTE |
644      COFF::IMAGE_SCN_MEM_READ |
645      COFF::IMAGE_SCN_CNT_CODE;
646  else if (K.isBSS ())
647    Flags |=
648      COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
649      COFF::IMAGE_SCN_MEM_READ |
650      COFF::IMAGE_SCN_MEM_WRITE;
651  else if (K.isThreadLocal())
652    Flags |=
653      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
654      COFF::IMAGE_SCN_MEM_READ |
655      COFF::IMAGE_SCN_MEM_WRITE;
656  else if (K.isReadOnly())
657    Flags |=
658      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
659      COFF::IMAGE_SCN_MEM_READ;
660  else if (K.isWriteable())
661    Flags |=
662      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
663      COFF::IMAGE_SCN_MEM_READ |
664      COFF::IMAGE_SCN_MEM_WRITE;
665
666  return Flags;
667}
668
669const MCSection *TargetLoweringObjectFileCOFF::
670getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
671                         Mangler *Mang, const TargetMachine &TM) const {
672  return getContext().getCOFFSection(GV->getSection(),
673                                     getCOFFSectionFlags(Kind),
674                                     Kind);
675}
676
677static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
678  if (Kind.isText())
679    return ".text$";
680  if (Kind.isBSS ())
681    return ".bss$";
682  if (Kind.isThreadLocal())
683    return ".tls$";
684  if (Kind.isWriteable())
685    return ".data$";
686  return ".rdata$";
687}
688
689
690const MCSection *TargetLoweringObjectFileCOFF::
691SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
692                       Mangler *Mang, const TargetMachine &TM) const {
693
694  // If this global is linkonce/weak and the target handles this by emitting it
695  // into a 'uniqued' section name, create and return the section now.
696  if (GV->isWeakForLinker()) {
697    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
698    SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
699    MCSymbol *Sym = Mang->getSymbol(GV);
700    Name.append(Sym->getName().begin() + 1, Sym->getName().end());
701
702    unsigned Characteristics = getCOFFSectionFlags(Kind);
703
704    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
705
706    return getContext().getCOFFSection(Name.str(), Characteristics,
707                          COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
708  }
709
710  if (Kind.isText())
711    return getTextSection();
712
713  if (Kind.isThreadLocal())
714    return getTLSDataSection();
715
716  return getDataSection();
717}
718
719