TargetLoweringObjectFileImpl.cpp revision 7afec9cc0ff1654619d30b6f30e2a4d13369c8bf 
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/CodeGen/MachineModuleInfoImpls.h"
21#include "llvm/MC/MCContext.h"
22#include "llvm/MC/MCExpr.h"
23#include "llvm/MC/MCSectionMachO.h"
24#include "llvm/MC/MCSectionELF.h"
25#include "llvm/MC/MCSectionCOFF.h"
26#include "llvm/MC/MCStreamer.h"
27#include "llvm/MC/MCSymbol.h"
28#include "llvm/Target/Mangler.h"
29#include "llvm/Target/TargetData.h"
30#include "llvm/Target/TargetMachine.h"
31#include "llvm/Target/TargetOptions.h"
32#include "llvm/Support/Dwarf.h"
33#include "llvm/Support/ELF.h"
34#include "llvm/Support/ErrorHandling.h"
35#include "llvm/Support/raw_ostream.h"
36#include "llvm/ADT/SmallString.h"
37#include "llvm/ADT/StringExtras.h"
38#include "llvm/ADT/Triple.h"
39using namespace llvm;
40using namespace dwarf;
41
42//===----------------------------------------------------------------------===//
43//                                  ELF
44//===----------------------------------------------------------------------===//
45
46void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
47                                             const TargetMachine &TM) {
48  TargetLoweringObjectFile::Initialize(Ctx, TM);
49
50  BSSSection =
51    getContext().getELFSection(".bss", ELF::SHT_NOBITS,
52                               ELF::SHF_WRITE |ELF::SHF_ALLOC,
53                               SectionKind::getBSS());
54
55  TextSection =
56    getContext().getELFSection(".text", ELF::SHT_PROGBITS,
57                               ELF::SHF_EXECINSTR |
58                               ELF::SHF_ALLOC,
59                               SectionKind::getText());
60
61  DataSection =
62    getContext().getELFSection(".data", ELF::SHT_PROGBITS,
63                               ELF::SHF_WRITE |ELF::SHF_ALLOC,
64                               SectionKind::getDataRel());
65
66  ReadOnlySection =
67    getContext().getELFSection(".rodata", ELF::SHT_PROGBITS,
68                               ELF::SHF_ALLOC,
69                               SectionKind::getReadOnly());
70
71  TLSDataSection =
72    getContext().getELFSection(".tdata", ELF::SHT_PROGBITS,
73                               ELF::SHF_ALLOC | ELF::SHF_TLS |
74                               ELF::SHF_WRITE,
75                               SectionKind::getThreadData());
76
77  TLSBSSSection =
78    getContext().getELFSection(".tbss", ELF::SHT_NOBITS,
79                               ELF::SHF_ALLOC | ELF::SHF_TLS |
80                               ELF::SHF_WRITE,
81                               SectionKind::getThreadBSS());
82
83  DataRelSection =
84    getContext().getELFSection(".data.rel", ELF::SHT_PROGBITS,
85                               ELF::SHF_ALLOC |ELF::SHF_WRITE,
86                               SectionKind::getDataRel());
87
88  DataRelLocalSection =
89    getContext().getELFSection(".data.rel.local", ELF::SHT_PROGBITS,
90                               ELF::SHF_ALLOC |ELF::SHF_WRITE,
91                               SectionKind::getDataRelLocal());
92
93  DataRelROSection =
94    getContext().getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
95                               ELF::SHF_ALLOC |ELF::SHF_WRITE,
96                               SectionKind::getReadOnlyWithRel());
97
98  DataRelROLocalSection =
99    getContext().getELFSection(".data.rel.ro.local", ELF::SHT_PROGBITS,
100                               ELF::SHF_ALLOC |ELF::SHF_WRITE,
101                               SectionKind::getReadOnlyWithRelLocal());
102
103  MergeableConst4Section =
104    getContext().getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
105                               ELF::SHF_ALLOC |ELF::SHF_MERGE,
106                               SectionKind::getMergeableConst4());
107
108  MergeableConst8Section =
109    getContext().getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
110                               ELF::SHF_ALLOC |ELF::SHF_MERGE,
111                               SectionKind::getMergeableConst8());
112
113  MergeableConst16Section =
114    getContext().getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
115                               ELF::SHF_ALLOC |ELF::SHF_MERGE,
116                               SectionKind::getMergeableConst16());
117
118  StaticCtorSection =
119    getContext().getELFSection(".ctors", ELF::SHT_PROGBITS,
120                               ELF::SHF_ALLOC |ELF::SHF_WRITE,
121                               SectionKind::getDataRel());
122
123  StaticDtorSection =
124    getContext().getELFSection(".dtors", ELF::SHT_PROGBITS,
125                               ELF::SHF_ALLOC |ELF::SHF_WRITE,
126                               SectionKind::getDataRel());
127
128  // Exception Handling Sections.
129
130  // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
131  // it contains relocatable pointers.  In PIC mode, this is probably a big
132  // runtime hit for C++ apps.  Either the contents of the LSDA need to be
133  // adjusted or this should be a data section.
134  LSDASection =
135    getContext().getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
136                               ELF::SHF_ALLOC,
137                               SectionKind::getReadOnly());
138  // Debug Info Sections.
139  DwarfAbbrevSection =
140    getContext().getELFSection(".debug_abbrev", ELF::SHT_PROGBITS, 0,
141                               SectionKind::getMetadata());
142  DwarfInfoSection =
143    getContext().getELFSection(".debug_info", ELF::SHT_PROGBITS, 0,
144                               SectionKind::getMetadata());
145  DwarfLineSection =
146    getContext().getELFSection(".debug_line", ELF::SHT_PROGBITS, 0,
147                               SectionKind::getMetadata());
148  DwarfFrameSection =
149    getContext().getELFSection(".debug_frame", ELF::SHT_PROGBITS, 0,
150                               SectionKind::getMetadata());
151  DwarfPubNamesSection =
152    getContext().getELFSection(".debug_pubnames", ELF::SHT_PROGBITS, 0,
153                               SectionKind::getMetadata());
154  DwarfPubTypesSection =
155    getContext().getELFSection(".debug_pubtypes", ELF::SHT_PROGBITS, 0,
156                               SectionKind::getMetadata());
157  DwarfStrSection =
158    getContext().getELFSection(".debug_str", ELF::SHT_PROGBITS, 0,
159                               SectionKind::getMetadata());
160  DwarfLocSection =
161    getContext().getELFSection(".debug_loc", ELF::SHT_PROGBITS, 0,
162                               SectionKind::getMetadata());
163  DwarfARangesSection =
164    getContext().getELFSection(".debug_aranges", ELF::SHT_PROGBITS, 0,
165                               SectionKind::getMetadata());
166  DwarfRangesSection =
167    getContext().getELFSection(".debug_ranges", ELF::SHT_PROGBITS, 0,
168                               SectionKind::getMetadata());
169  DwarfMacroInfoSection =
170    getContext().getELFSection(".debug_macinfo", ELF::SHT_PROGBITS, 0,
171                               SectionKind::getMetadata());
172}
173
174const MCSection *TargetLoweringObjectFileELF::getEHFrameSection() const {
175  return getContext().getELFSection(".eh_frame", ELF::SHT_PROGBITS,
176                                    ELF::SHF_ALLOC,
177                                    SectionKind::getDataRel());
178}
179
180MCSymbol *
181TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
182                                                     unsigned Encoding,
183                                                     Mangler *Mang,
184                                                MachineModuleInfo *MMI) const {
185  switch (Encoding & 0x70) {
186  default:
187    report_fatal_error("We do not support this DWARF encoding yet!");
188  case dwarf::DW_EH_PE_absptr:
189    return  Mang->getSymbol(GV);
190    break;
191  case dwarf::DW_EH_PE_pcrel: {
192    Twine FullName = StringRef("DW.ref.") + Mang->getSymbol(GV)->getName();
193    return getContext().GetOrCreateSymbol(FullName);
194    break;
195  }
196  }
197}
198
199void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
200                                                       const TargetMachine &TM,
201                                                       const MCSymbol *Sym) const {
202  Twine FullName = StringRef("DW.ref.") + Sym->getName();
203  MCSymbol *Label = getContext().GetOrCreateSymbol(FullName);
204  Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
205  Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
206  Twine SectionName = StringRef(".data.") + Label->getName();
207  SmallString<64> NameData;
208  SectionName.toVector(NameData);
209  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
210  const MCSection *Sec = getContext().getELFSection(NameData,
211                                                    ELF::SHT_PROGBITS,
212                                                    Flags,
213                                                    SectionKind::getDataRel(),
214                                                    0, Label->getName());
215  Streamer.SwitchSection(Sec);
216  Streamer.EmitValueToAlignment(8);
217  Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
218  const MCExpr *E = MCConstantExpr::Create(8, getContext());
219  Streamer.EmitELFSize(Label, E);
220  Streamer.EmitLabel(Label);
221
222  unsigned Size = TM.getTargetData()->getPointerSize();
223  Streamer.EmitSymbolValue(Sym, Size);
224}
225
226static SectionKind
227getELFKindForNamedSection(StringRef Name, SectionKind K) {
228  // FIXME: Why is this here? Codegen is should not be in the business
229  // of figuring section flags. If the user wrote section(".eh_frame"),
230  // we should just pass that to MC which will defer to the assembly
231  // or use its default if producing an object file.
232  if (Name.empty() || Name[0] != '.') return K;
233
234  // Some lame default implementation based on some magic section names.
235  if (Name == ".bss" ||
236      Name.startswith(".bss.") ||
237      Name.startswith(".gnu.linkonce.b.") ||
238      Name.startswith(".llvm.linkonce.b.") ||
239      Name == ".sbss" ||
240      Name.startswith(".sbss.") ||
241      Name.startswith(".gnu.linkonce.sb.") ||
242      Name.startswith(".llvm.linkonce.sb."))
243    return SectionKind::getBSS();
244
245  if (Name == ".tdata" ||
246      Name.startswith(".tdata.") ||
247      Name.startswith(".gnu.linkonce.td.") ||
248      Name.startswith(".llvm.linkonce.td."))
249    return SectionKind::getThreadData();
250
251  if (Name == ".tbss" ||
252      Name.startswith(".tbss.") ||
253      Name.startswith(".gnu.linkonce.tb.") ||
254      Name.startswith(".llvm.linkonce.tb."))
255    return SectionKind::getThreadBSS();
256
257  if (Name == ".eh_frame")
258    return SectionKind::getDataRel();
259
260  return K;
261}
262
263
264static unsigned getELFSectionType(StringRef Name, SectionKind K) {
265
266  if (Name == ".init_array")
267    return ELF::SHT_INIT_ARRAY;
268
269  if (Name == ".fini_array")
270    return ELF::SHT_FINI_ARRAY;
271
272  if (Name == ".preinit_array")
273    return ELF::SHT_PREINIT_ARRAY;
274
275  if (K.isBSS() || K.isThreadBSS())
276    return ELF::SHT_NOBITS;
277
278  return ELF::SHT_PROGBITS;
279}
280
281
282static unsigned
283getELFSectionFlags(SectionKind K) {
284  unsigned Flags = 0;
285
286  if (!K.isMetadata())
287    Flags |= ELF::SHF_ALLOC;
288
289  if (K.isText())
290    Flags |= ELF::SHF_EXECINSTR;
291
292  if (K.isWriteable())
293    Flags |= ELF::SHF_WRITE;
294
295  if (K.isThreadLocal())
296    Flags |= ELF::SHF_TLS;
297
298  // K.isMergeableConst() is left out to honour PR4650
299  if (K.isMergeableCString() || K.isMergeableConst4() ||
300      K.isMergeableConst8() || K.isMergeableConst16())
301    Flags |= ELF::SHF_MERGE;
302
303  if (K.isMergeableCString())
304    Flags |= ELF::SHF_STRINGS;
305
306  return Flags;
307}
308
309
310const MCSection *TargetLoweringObjectFileELF::
311getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
312                         Mangler *Mang, const TargetMachine &TM) const {
313  StringRef SectionName = GV->getSection();
314
315  // Infer section flags from the section name if we can.
316  Kind = getELFKindForNamedSection(SectionName, Kind);
317
318  return getContext().getELFSection(SectionName,
319                                    getELFSectionType(SectionName, Kind),
320                                    getELFSectionFlags(Kind), Kind);
321}
322
323/// getSectionPrefixForGlobal - Return the section prefix name used by options
324/// FunctionsSections and DataSections.
325static const char *getSectionPrefixForGlobal(SectionKind Kind) {
326  if (Kind.isText())                 return ".text.";
327  if (Kind.isReadOnly())             return ".rodata.";
328
329  if (Kind.isThreadData())           return ".tdata.";
330  if (Kind.isThreadBSS())            return ".tbss.";
331
332  if (Kind.isDataNoRel())            return ".data.";
333  if (Kind.isDataRelLocal())         return ".data.rel.local.";
334  if (Kind.isDataRel())              return ".data.rel.";
335  if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
336
337  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
338  return ".data.rel.ro.";
339}
340
341
342const MCSection *TargetLoweringObjectFileELF::
343SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
344                       Mangler *Mang, const TargetMachine &TM) const {
345  // If we have -ffunction-section or -fdata-section then we should emit the
346  // global value to a uniqued section specifically for it.
347  bool EmitUniquedSection;
348  if (Kind.isText())
349    EmitUniquedSection = TM.getFunctionSections();
350  else
351    EmitUniquedSection = TM.getDataSections();
352
353  // If this global is linkonce/weak and the target handles this by emitting it
354  // into a 'uniqued' section name, create and return the section now.
355  if ((GV->isWeakForLinker() || EmitUniquedSection) &&
356      !Kind.isCommon() && !Kind.isBSS()) {
357    const char *Prefix;
358    Prefix = getSectionPrefixForGlobal(Kind);
359
360    SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
361    MCSymbol *Sym = Mang->getSymbol(GV);
362    Name.append(Sym->getName().begin(), Sym->getName().end());
363    StringRef Group = "";
364    unsigned Flags = getELFSectionFlags(Kind);
365    if (GV->isWeakForLinker()) {
366      Group = Sym->getName();
367      Flags |= ELF::SHF_GROUP;
368    }
369
370    return getContext().getELFSection(Name.str(),
371                                      getELFSectionType(Name.str(), Kind),
372                                      Flags, Kind, 0, Group);
373  }
374
375  if (Kind.isText()) return TextSection;
376
377  if (Kind.isMergeable1ByteCString() ||
378      Kind.isMergeable2ByteCString() ||
379      Kind.isMergeable4ByteCString()) {
380
381    // We also need alignment here.
382    // FIXME: this is getting the alignment of the character, not the
383    // alignment of the global!
384    unsigned Align =
385      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
386
387    const char *SizeSpec = ".rodata.str1.";
388    if (Kind.isMergeable2ByteCString())
389      SizeSpec = ".rodata.str2.";
390    else if (Kind.isMergeable4ByteCString())
391      SizeSpec = ".rodata.str4.";
392    else
393      assert(Kind.isMergeable1ByteCString() && "unknown string width");
394
395
396    std::string Name = SizeSpec + utostr(Align);
397    return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
398                                      ELF::SHF_ALLOC |
399                                      ELF::SHF_MERGE |
400                                      ELF::SHF_STRINGS,
401                                      Kind);
402  }
403
404  if (Kind.isMergeableConst()) {
405    if (Kind.isMergeableConst4() && MergeableConst4Section)
406      return MergeableConst4Section;
407    if (Kind.isMergeableConst8() && MergeableConst8Section)
408      return MergeableConst8Section;
409    if (Kind.isMergeableConst16() && MergeableConst16Section)
410      return MergeableConst16Section;
411    return ReadOnlySection;  // .const
412  }
413
414  if (Kind.isReadOnly())             return ReadOnlySection;
415
416  if (Kind.isThreadData())           return TLSDataSection;
417  if (Kind.isThreadBSS())            return TLSBSSSection;
418
419  // Note: we claim that common symbols are put in BSSSection, but they are
420  // really emitted with the magic .comm directive, which creates a symbol table
421  // entry but not a section.
422  if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
423
424  if (Kind.isDataNoRel())            return DataSection;
425  if (Kind.isDataRelLocal())         return DataRelLocalSection;
426  if (Kind.isDataRel())              return DataRelSection;
427  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
428
429  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
430  return DataRelROSection;
431}
432
433/// getSectionForConstant - Given a mergeable constant with the
434/// specified size and relocation information, return a section that it
435/// should be placed in.
436const MCSection *TargetLoweringObjectFileELF::
437getSectionForConstant(SectionKind Kind) const {
438  if (Kind.isMergeableConst4() && MergeableConst4Section)
439    return MergeableConst4Section;
440  if (Kind.isMergeableConst8() && MergeableConst8Section)
441    return MergeableConst8Section;
442  if (Kind.isMergeableConst16() && MergeableConst16Section)
443    return MergeableConst16Section;
444  if (Kind.isReadOnly())
445    return ReadOnlySection;
446
447  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
448  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
449  return DataRelROSection;
450}
451
452const MCExpr *TargetLoweringObjectFileELF::
453getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
454                               MachineModuleInfo *MMI,
455                               unsigned Encoding, MCStreamer &Streamer) const {
456
457  if (Encoding & dwarf::DW_EH_PE_indirect) {
458    MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
459
460    SmallString<128> Name;
461    Mang->getNameWithPrefix(Name, GV, true);
462    Name += ".DW.stub";
463
464    // Add information about the stub reference to ELFMMI so that the stub
465    // gets emitted by the asmprinter.
466    MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
467    MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
468    if (StubSym.getPointer() == 0) {
469      MCSymbol *Sym = Mang->getSymbol(GV);
470      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
471    }
472
473    return TargetLoweringObjectFile::
474      getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
475  }
476
477  return TargetLoweringObjectFile::
478    getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
479}
480
481//===----------------------------------------------------------------------===//
482//                                 MachO
483//===----------------------------------------------------------------------===//
484
485void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
486                                               const TargetMachine &TM) {
487  // _foo.eh symbols are currently always exported so that the linker knows
488  // about them.  This is not necessary on 10.6 and later, but it
489  // doesn't hurt anything.
490  // FIXME: I need to get this from Triple.
491  IsFunctionEHSymbolGlobal = true;
492  IsFunctionEHFrameSymbolPrivate = false;
493  SupportsWeakOmittedEHFrame = false;
494
495  // .comm doesn't support alignment before Leopard.
496  Triple T(((LLVMTargetMachine&)TM).getTargetTriple());
497  if (T.isMacOSX() && T.isMacOSXVersionLT(10, 5))
498    CommDirectiveSupportsAlignment = false;
499
500  TargetLoweringObjectFile::Initialize(Ctx, TM);
501
502  TextSection // .text
503    = getContext().getMachOSection("__TEXT", "__text",
504                                   MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
505                                   SectionKind::getText());
506  DataSection // .data
507    = getContext().getMachOSection("__DATA", "__data", 0,
508                                   SectionKind::getDataRel());
509
510  TLSDataSection // .tdata
511    = getContext().getMachOSection("__DATA", "__thread_data",
512                                   MCSectionMachO::S_THREAD_LOCAL_REGULAR,
513                                   SectionKind::getDataRel());
514  TLSBSSSection // .tbss
515    = getContext().getMachOSection("__DATA", "__thread_bss",
516                                   MCSectionMachO::S_THREAD_LOCAL_ZEROFILL,
517                                   SectionKind::getThreadBSS());
518
519  // TODO: Verify datarel below.
520  TLSTLVSection // .tlv
521    = getContext().getMachOSection("__DATA", "__thread_vars",
522                                   MCSectionMachO::S_THREAD_LOCAL_VARIABLES,
523                                   SectionKind::getDataRel());
524
525  TLSThreadInitSection
526    = getContext().getMachOSection("__DATA", "__thread_init",
527                          MCSectionMachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
528                          SectionKind::getDataRel());
529
530  CStringSection // .cstring
531    = getContext().getMachOSection("__TEXT", "__cstring",
532                                   MCSectionMachO::S_CSTRING_LITERALS,
533                                   SectionKind::getMergeable1ByteCString());
534  UStringSection
535    = getContext().getMachOSection("__TEXT","__ustring", 0,
536                                   SectionKind::getMergeable2ByteCString());
537  FourByteConstantSection // .literal4
538    = getContext().getMachOSection("__TEXT", "__literal4",
539                                   MCSectionMachO::S_4BYTE_LITERALS,
540                                   SectionKind::getMergeableConst4());
541  EightByteConstantSection // .literal8
542    = getContext().getMachOSection("__TEXT", "__literal8",
543                                   MCSectionMachO::S_8BYTE_LITERALS,
544                                   SectionKind::getMergeableConst8());
545
546  // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
547  // to using it in -static mode.
548  SixteenByteConstantSection = 0;
549  if (TM.getRelocationModel() != Reloc::Static &&
550      TM.getTargetData()->getPointerSize() == 32)
551    SixteenByteConstantSection =   // .literal16
552      getContext().getMachOSection("__TEXT", "__literal16",
553                                   MCSectionMachO::S_16BYTE_LITERALS,
554                                   SectionKind::getMergeableConst16());
555
556  ReadOnlySection  // .const
557    = getContext().getMachOSection("__TEXT", "__const", 0,
558                                   SectionKind::getReadOnly());
559
560  TextCoalSection
561    = getContext().getMachOSection("__TEXT", "__textcoal_nt",
562                                   MCSectionMachO::S_COALESCED |
563                                   MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
564                                   SectionKind::getText());
565  ConstTextCoalSection
566    = getContext().getMachOSection("__TEXT", "__const_coal",
567                                   MCSectionMachO::S_COALESCED,
568                                   SectionKind::getReadOnly());
569  ConstDataSection  // .const_data
570    = getContext().getMachOSection("__DATA", "__const", 0,
571                                   SectionKind::getReadOnlyWithRel());
572  DataCoalSection
573    = getContext().getMachOSection("__DATA","__datacoal_nt",
574                                   MCSectionMachO::S_COALESCED,
575                                   SectionKind::getDataRel());
576  DataCommonSection
577    = getContext().getMachOSection("__DATA","__common",
578                                   MCSectionMachO::S_ZEROFILL,
579                                   SectionKind::getBSS());
580  DataBSSSection
581    = getContext().getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,
582                                   SectionKind::getBSS());
583
584
585  LazySymbolPointerSection
586    = getContext().getMachOSection("__DATA", "__la_symbol_ptr",
587                                   MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
588                                   SectionKind::getMetadata());
589  NonLazySymbolPointerSection
590    = getContext().getMachOSection("__DATA", "__nl_symbol_ptr",
591                                   MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
592                                   SectionKind::getMetadata());
593
594  if (TM.getRelocationModel() == Reloc::Static) {
595    StaticCtorSection
596      = getContext().getMachOSection("__TEXT", "__constructor", 0,
597                                     SectionKind::getDataRel());
598    StaticDtorSection
599      = getContext().getMachOSection("__TEXT", "__destructor", 0,
600                                     SectionKind::getDataRel());
601  } else {
602    StaticCtorSection
603      = getContext().getMachOSection("__DATA", "__mod_init_func",
604                                     MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
605                                     SectionKind::getDataRel());
606    StaticDtorSection
607      = getContext().getMachOSection("__DATA", "__mod_term_func",
608                                     MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
609                                     SectionKind::getDataRel());
610  }
611
612  // Exception Handling.
613  LSDASection = getContext().getMachOSection("__TEXT", "__gcc_except_tab", 0,
614                                             SectionKind::getReadOnlyWithRel());
615  // Debug Information.
616  DwarfAbbrevSection =
617    getContext().getMachOSection("__DWARF", "__debug_abbrev",
618                                 MCSectionMachO::S_ATTR_DEBUG,
619                                 SectionKind::getMetadata());
620  DwarfInfoSection =
621    getContext().getMachOSection("__DWARF", "__debug_info",
622                                 MCSectionMachO::S_ATTR_DEBUG,
623                                 SectionKind::getMetadata());
624  DwarfLineSection =
625    getContext().getMachOSection("__DWARF", "__debug_line",
626                                 MCSectionMachO::S_ATTR_DEBUG,
627                                 SectionKind::getMetadata());
628  DwarfFrameSection =
629    getContext().getMachOSection("__DWARF", "__debug_frame",
630                                 MCSectionMachO::S_ATTR_DEBUG,
631                                 SectionKind::getMetadata());
632  DwarfPubNamesSection =
633    getContext().getMachOSection("__DWARF", "__debug_pubnames",
634                                 MCSectionMachO::S_ATTR_DEBUG,
635                                 SectionKind::getMetadata());
636  DwarfPubTypesSection =
637    getContext().getMachOSection("__DWARF", "__debug_pubtypes",
638                                 MCSectionMachO::S_ATTR_DEBUG,
639                                 SectionKind::getMetadata());
640  DwarfStrSection =
641    getContext().getMachOSection("__DWARF", "__debug_str",
642                                 MCSectionMachO::S_ATTR_DEBUG,
643                                 SectionKind::getMetadata());
644  DwarfLocSection =
645    getContext().getMachOSection("__DWARF", "__debug_loc",
646                                 MCSectionMachO::S_ATTR_DEBUG,
647                                 SectionKind::getMetadata());
648  DwarfARangesSection =
649    getContext().getMachOSection("__DWARF", "__debug_aranges",
650                                 MCSectionMachO::S_ATTR_DEBUG,
651                                 SectionKind::getMetadata());
652  DwarfRangesSection =
653    getContext().getMachOSection("__DWARF", "__debug_ranges",
654                                 MCSectionMachO::S_ATTR_DEBUG,
655                                 SectionKind::getMetadata());
656  DwarfMacroInfoSection =
657    getContext().getMachOSection("__DWARF", "__debug_macinfo",
658                                 MCSectionMachO::S_ATTR_DEBUG,
659                                 SectionKind::getMetadata());
660  DwarfDebugInlineSection =
661    getContext().getMachOSection("__DWARF", "__debug_inlined",
662                                 MCSectionMachO::S_ATTR_DEBUG,
663                                 SectionKind::getMetadata());
664
665  TLSExtraDataSection = TLSTLVSection;
666}
667
668const MCSection *TargetLoweringObjectFileMachO::getEHFrameSection() const {
669  return getContext().getMachOSection("__TEXT", "__eh_frame",
670                                      MCSectionMachO::S_COALESCED |
671                                      MCSectionMachO::S_ATTR_NO_TOC |
672                                      MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
673                                      MCSectionMachO::S_ATTR_LIVE_SUPPORT,
674                                      SectionKind::getReadOnly());
675}
676
677const MCSection *TargetLoweringObjectFileMachO::
678getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
679                         Mangler *Mang, const TargetMachine &TM) const {
680  // Parse the section specifier and create it if valid.
681  StringRef Segment, Section;
682  unsigned TAA = 0, StubSize = 0;
683  bool TAAParsed;
684  std::string ErrorCode =
685    MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
686                                          TAA, TAAParsed, StubSize);
687  if (!ErrorCode.empty()) {
688    // If invalid, report the error with report_fatal_error.
689    report_fatal_error("Global variable '" + GV->getNameStr() +
690                      "' has an invalid section specifier '" + GV->getSection()+
691                      "': " + ErrorCode + ".");
692    // Fall back to dropping it into the data section.
693    return DataSection;
694  }
695
696  // Get the section.
697  const MCSectionMachO *S =
698    getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
699
700  // If TAA wasn't set by ParseSectionSpecifier() above,
701  // use the value returned by getMachOSection() as a default.
702  if (!TAAParsed)
703    TAA = S->getTypeAndAttributes();
704
705  // Okay, now that we got the section, verify that the TAA & StubSize agree.
706  // If the user declared multiple globals with different section flags, we need
707  // to reject it here.
708  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
709    // If invalid, report the error with report_fatal_error.
710    report_fatal_error("Global variable '" + GV->getNameStr() +
711                      "' section type or attributes does not match previous"
712                      " section specifier");
713  }
714
715  return S;
716}
717
718const MCSection *TargetLoweringObjectFileMachO::
719SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
720                       Mangler *Mang, const TargetMachine &TM) const {
721
722  // Handle thread local data.
723  if (Kind.isThreadBSS()) return TLSBSSSection;
724  if (Kind.isThreadData()) return TLSDataSection;
725
726  if (Kind.isText())
727    return GV->isWeakForLinker() ? TextCoalSection : TextSection;
728
729  // If this is weak/linkonce, put this in a coalescable section, either in text
730  // or data depending on if it is writable.
731  if (GV->isWeakForLinker()) {
732    if (Kind.isReadOnly())
733      return ConstTextCoalSection;
734    return DataCoalSection;
735  }
736
737  // FIXME: Alignment check should be handled by section classifier.
738  if (Kind.isMergeable1ByteCString() &&
739      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
740    return CStringSection;
741
742  // Do not put 16-bit arrays in the UString section if they have an
743  // externally visible label, this runs into issues with certain linker
744  // versions.
745  if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
746      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
747    return UStringSection;
748
749  if (Kind.isMergeableConst()) {
750    if (Kind.isMergeableConst4())
751      return FourByteConstantSection;
752    if (Kind.isMergeableConst8())
753      return EightByteConstantSection;
754    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
755      return SixteenByteConstantSection;
756  }
757
758  // Otherwise, if it is readonly, but not something we can specially optimize,
759  // just drop it in .const.
760  if (Kind.isReadOnly())
761    return ReadOnlySection;
762
763  // If this is marked const, put it into a const section.  But if the dynamic
764  // linker needs to write to it, put it in the data segment.
765  if (Kind.isReadOnlyWithRel())
766    return ConstDataSection;
767
768  // Put zero initialized globals with strong external linkage in the
769  // DATA, __common section with the .zerofill directive.
770  if (Kind.isBSSExtern())
771    return DataCommonSection;
772
773  // Put zero initialized globals with local linkage in __DATA,__bss directive
774  // with the .zerofill directive (aka .lcomm).
775  if (Kind.isBSSLocal())
776    return DataBSSSection;
777
778  // Otherwise, just drop the variable in the normal data section.
779  return DataSection;
780}
781
782const MCSection *
783TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
784  // If this constant requires a relocation, we have to put it in the data
785  // segment, not in the text segment.
786  if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
787    return ConstDataSection;
788
789  if (Kind.isMergeableConst4())
790    return FourByteConstantSection;
791  if (Kind.isMergeableConst8())
792    return EightByteConstantSection;
793  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
794    return SixteenByteConstantSection;
795  return ReadOnlySection;  // .const
796}
797
798/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
799/// not to emit the UsedDirective for some symbols in llvm.used.
800// FIXME: REMOVE this (rdar://7071300)
801bool TargetLoweringObjectFileMachO::
802shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
803  /// On Darwin, internally linked data beginning with "L" or "l" does not have
804  /// the directive emitted (this occurs in ObjC metadata).
805  if (!GV) return false;
806
807  // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
808  if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
809    // FIXME: ObjC metadata is currently emitted as internal symbols that have
810    // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
811    // this horrible hack can go away.
812    MCSymbol *Sym = Mang->getSymbol(GV);
813    if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
814      return false;
815  }
816
817  return true;
818}
819
820const MCExpr *TargetLoweringObjectFileMachO::
821getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
822                               MachineModuleInfo *MMI, unsigned Encoding,
823                               MCStreamer &Streamer) const {
824  // The mach-o version of this method defaults to returning a stub reference.
825
826  if (Encoding & DW_EH_PE_indirect) {
827    MachineModuleInfoMachO &MachOMMI =
828      MMI->getObjFileInfo<MachineModuleInfoMachO>();
829
830    SmallString<128> Name;
831    Mang->getNameWithPrefix(Name, GV, true);
832    Name += "$non_lazy_ptr";
833
834    // Add information about the stub reference to MachOMMI so that the stub
835    // gets emitted by the asmprinter.
836    MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
837    MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
838    if (StubSym.getPointer() == 0) {
839      MCSymbol *Sym = Mang->getSymbol(GV);
840      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
841    }
842
843    return TargetLoweringObjectFile::
844      getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
845  }
846
847  return TargetLoweringObjectFile::
848    getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
849}
850
851MCSymbol *TargetLoweringObjectFileMachO::
852getCFIPersonalitySymbol(const GlobalValue *GV, unsigned Encoding, Mangler *Mang,
853                        MachineModuleInfo *MMI) const {
854  // The mach-o version of this method defaults to returning a stub reference.
855  MachineModuleInfoMachO &MachOMMI =
856    MMI->getObjFileInfo<MachineModuleInfoMachO>();
857
858  SmallString<128> Name;
859  Mang->getNameWithPrefix(Name, GV, true);
860  Name += "$non_lazy_ptr";
861
862  // Add information about the stub reference to MachOMMI so that the stub
863  // gets emitted by the asmprinter.
864  MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
865  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
866  if (StubSym.getPointer() == 0) {
867    MCSymbol *Sym = Mang->getSymbol(GV);
868    StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
869  }
870
871  return SSym;
872}
873
874unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {
875  return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
876}
877
878unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {
879  return DW_EH_PE_pcrel;
880}
881
882unsigned TargetLoweringObjectFileMachO::getFDEEncoding() const {
883  return DW_EH_PE_pcrel;
884}
885
886unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {
887  return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
888}
889
890//===----------------------------------------------------------------------===//
891//                                  COFF
892//===----------------------------------------------------------------------===//
893
894void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
895                                              const TargetMachine &TM) {
896  TargetLoweringObjectFile::Initialize(Ctx, TM);
897  TextSection =
898    getContext().getCOFFSection(".text",
899                                COFF::IMAGE_SCN_CNT_CODE |
900                                COFF::IMAGE_SCN_MEM_EXECUTE |
901                                COFF::IMAGE_SCN_MEM_READ,
902                                SectionKind::getText());
903  DataSection =
904    getContext().getCOFFSection(".data",
905                                COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
906                                COFF::IMAGE_SCN_MEM_READ |
907                                COFF::IMAGE_SCN_MEM_WRITE,
908                                SectionKind::getDataRel());
909  ReadOnlySection =
910    getContext().getCOFFSection(".rdata",
911                                COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
912                                COFF::IMAGE_SCN_MEM_READ,
913                                SectionKind::getReadOnly());
914  StaticCtorSection =
915    getContext().getCOFFSection(".ctors",
916                                COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
917                                COFF::IMAGE_SCN_MEM_READ |
918                                COFF::IMAGE_SCN_MEM_WRITE,
919                                SectionKind::getDataRel());
920  StaticDtorSection =
921    getContext().getCOFFSection(".dtors",
922                                COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
923                                COFF::IMAGE_SCN_MEM_READ |
924                                COFF::IMAGE_SCN_MEM_WRITE,
925                                SectionKind::getDataRel());
926
927  // FIXME: We're emitting LSDA info into a readonly section on COFF, even
928  // though it contains relocatable pointers.  In PIC mode, this is probably a
929  // big runtime hit for C++ apps.  Either the contents of the LSDA need to be
930  // adjusted or this should be a data section.
931  LSDASection =
932    getContext().getCOFFSection(".gcc_except_table",
933                                COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
934                                COFF::IMAGE_SCN_MEM_READ,
935                                SectionKind::getReadOnly());
936  // Debug info.
937  DwarfAbbrevSection =
938    getContext().getCOFFSection(".debug_abbrev",
939                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
940                                COFF::IMAGE_SCN_MEM_READ,
941                                SectionKind::getMetadata());
942  DwarfInfoSection =
943    getContext().getCOFFSection(".debug_info",
944                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
945                                COFF::IMAGE_SCN_MEM_READ,
946                                SectionKind::getMetadata());
947  DwarfLineSection =
948    getContext().getCOFFSection(".debug_line",
949                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
950                                COFF::IMAGE_SCN_MEM_READ,
951                                SectionKind::getMetadata());
952  DwarfFrameSection =
953    getContext().getCOFFSection(".debug_frame",
954                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
955                                COFF::IMAGE_SCN_MEM_READ,
956                                SectionKind::getMetadata());
957  DwarfPubNamesSection =
958    getContext().getCOFFSection(".debug_pubnames",
959                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
960                                COFF::IMAGE_SCN_MEM_READ,
961                                SectionKind::getMetadata());
962  DwarfPubTypesSection =
963    getContext().getCOFFSection(".debug_pubtypes",
964                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
965                                COFF::IMAGE_SCN_MEM_READ,
966                                SectionKind::getMetadata());
967  DwarfStrSection =
968    getContext().getCOFFSection(".debug_str",
969                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
970                                COFF::IMAGE_SCN_MEM_READ,
971                                SectionKind::getMetadata());
972  DwarfLocSection =
973    getContext().getCOFFSection(".debug_loc",
974                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
975                                COFF::IMAGE_SCN_MEM_READ,
976                                SectionKind::getMetadata());
977  DwarfARangesSection =
978    getContext().getCOFFSection(".debug_aranges",
979                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
980                                COFF::IMAGE_SCN_MEM_READ,
981                                SectionKind::getMetadata());
982  DwarfRangesSection =
983    getContext().getCOFFSection(".debug_ranges",
984                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
985                                COFF::IMAGE_SCN_MEM_READ,
986                                SectionKind::getMetadata());
987  DwarfMacroInfoSection =
988    getContext().getCOFFSection(".debug_macinfo",
989                                COFF::IMAGE_SCN_MEM_DISCARDABLE |
990                                COFF::IMAGE_SCN_MEM_READ,
991                                SectionKind::getMetadata());
992
993  DrectveSection =
994    getContext().getCOFFSection(".drectve",
995                                COFF::IMAGE_SCN_LNK_INFO,
996                                SectionKind::getMetadata());
997}
998
999const MCSection *TargetLoweringObjectFileCOFF::getEHFrameSection() const {
1000  return getContext().getCOFFSection(".eh_frame",
1001                                     COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1002                                     COFF::IMAGE_SCN_MEM_READ |
1003                                     COFF::IMAGE_SCN_MEM_WRITE,
1004                                     SectionKind::getDataRel());
1005}
1006
1007
1008static unsigned
1009getCOFFSectionFlags(SectionKind K) {
1010  unsigned Flags = 0;
1011
1012  if (K.isMetadata())
1013    Flags |=
1014      COFF::IMAGE_SCN_MEM_DISCARDABLE;
1015  else if (K.isText())
1016    Flags |=
1017      COFF::IMAGE_SCN_MEM_EXECUTE |
1018      COFF::IMAGE_SCN_MEM_READ |
1019      COFF::IMAGE_SCN_CNT_CODE;
1020  else if (K.isBSS ())
1021    Flags |=
1022      COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
1023      COFF::IMAGE_SCN_MEM_READ |
1024      COFF::IMAGE_SCN_MEM_WRITE;
1025  else if (K.isReadOnly())
1026    Flags |=
1027      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1028      COFF::IMAGE_SCN_MEM_READ;
1029  else if (K.isWriteable())
1030    Flags |=
1031      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1032      COFF::IMAGE_SCN_MEM_READ |
1033      COFF::IMAGE_SCN_MEM_WRITE;
1034
1035  return Flags;
1036}
1037
1038const MCSection *TargetLoweringObjectFileCOFF::
1039getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
1040                         Mangler *Mang, const TargetMachine &TM) const {
1041  return getContext().getCOFFSection(GV->getSection(),
1042                                     getCOFFSectionFlags(Kind),
1043                                     Kind);
1044}
1045
1046static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
1047  if (Kind.isText())
1048    return ".text$";
1049  if (Kind.isBSS ())
1050    return ".bss$";
1051  if (Kind.isWriteable())
1052    return ".data$";
1053  return ".rdata$";
1054}
1055
1056
1057const MCSection *TargetLoweringObjectFileCOFF::
1058SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
1059                       Mangler *Mang, const TargetMachine &TM) const {
1060  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
1061
1062  // If this global is linkonce/weak and the target handles this by emitting it
1063  // into a 'uniqued' section name, create and return the section now.
1064  if (GV->isWeakForLinker()) {
1065    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
1066    SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
1067    MCSymbol *Sym = Mang->getSymbol(GV);
1068    Name.append(Sym->getName().begin() + 1, Sym->getName().end());
1069
1070    unsigned Characteristics = getCOFFSectionFlags(Kind);
1071
1072    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1073
1074    return getContext().getCOFFSection(Name.str(), Characteristics,
1075                          COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
1076  }
1077
1078  if (Kind.isText())
1079    return getTextSection();
1080
1081  return getDataSection();
1082}
1083
1084