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