TargetLoweringObjectFile.cpp revision 18a4c16726db2b8874c7b84d04650dda80746074 
1//===-- llvm/Target/TargetLoweringObjectFile.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/Target/TargetLoweringObjectFile.h"
16#include "llvm/Constants.h"
17#include "llvm/DerivedTypes.h"
18#include "llvm/GlobalVariable.h"
19#include "llvm/MC/MCContext.h"
20#include "llvm/MC/MCSection.h"
21#include "llvm/Target/TargetMachine.h"
22#include "llvm/Target/TargetData.h"
23#include "llvm/Target/TargetOptions.h"
24#include "llvm/Support/Mangler.h"
25#include "llvm/ADT/StringExtras.h"
26using namespace llvm;
27
28//===----------------------------------------------------------------------===//
29//                              Generic Code
30//===----------------------------------------------------------------------===//
31
32TargetLoweringObjectFile::TargetLoweringObjectFile() : Ctx(0) {
33  TextSection = 0;
34  DataSection = 0;
35  BSSSection = 0;
36  ReadOnlySection = 0;
37  StaticCtorSection = 0;
38  StaticDtorSection = 0;
39  LSDASection = 0;
40  EHFrameSection = 0;
41
42  DwarfAbbrevSection = 0;
43  DwarfInfoSection = 0;
44  DwarfLineSection = 0;
45  DwarfFrameSection = 0;
46  DwarfPubNamesSection = 0;
47  DwarfPubTypesSection = 0;
48  DwarfDebugInlineSection = 0;
49  DwarfStrSection = 0;
50  DwarfLocSection = 0;
51  DwarfARangesSection = 0;
52  DwarfRangesSection = 0;
53  DwarfMacroInfoSection = 0;
54}
55
56TargetLoweringObjectFile::~TargetLoweringObjectFile() {
57}
58
59static bool isSuitableForBSS(const GlobalVariable *GV) {
60  Constant *C = GV->getInitializer();
61
62  // Must have zero initializer.
63  if (!C->isNullValue())
64    return false;
65
66  // Leave constant zeros in readonly constant sections, so they can be shared.
67  if (GV->isConstant())
68    return false;
69
70  // If the global has an explicit section specified, don't put it in BSS.
71  if (!GV->getSection().empty())
72    return false;
73
74  // If -nozero-initialized-in-bss is specified, don't ever use BSS.
75  if (NoZerosInBSS)
76    return false;
77
78  // Otherwise, put it in BSS!
79  return true;
80}
81
82static bool isConstantString(const Constant *C) {
83  // First check: is we have constant array of i8 terminated with zero
84  const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
85  // Check, if initializer is a null-terminated string
86  if (CVA && CVA->isCString())
87    return true;
88
89  // Another possibility: [1 x i8] zeroinitializer
90  if (isa<ConstantAggregateZero>(C))
91    if (const ArrayType *Ty = dyn_cast<ArrayType>(C->getType()))
92      return (Ty->getElementType() == Type::Int8Ty &&
93              Ty->getNumElements() == 1);
94
95  return false;
96}
97
98/// SectionKindForGlobal - This is a top-level target-independent classifier for
99/// a global variable.  Given an global variable and information from TM, it
100/// classifies the global in a variety of ways that make various target
101/// implementations simpler.  The target implementation is free to ignore this
102/// extra info of course.
103static SectionKind SectionKindForGlobal(const GlobalValue *GV,
104                                        const TargetMachine &TM) {
105  Reloc::Model ReloModel = TM.getRelocationModel();
106
107  // Early exit - functions should be always in text sections.
108  const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
109  if (GVar == 0)
110    return SectionKind::getText();
111
112
113  // Handle thread-local data first.
114  if (GVar->isThreadLocal()) {
115    if (isSuitableForBSS(GVar))
116      return SectionKind::getThreadBSS();
117    return SectionKind::getThreadData();
118  }
119
120  // Variable can be easily put to BSS section.
121  if (isSuitableForBSS(GVar))
122    return SectionKind::getBSS();
123
124  Constant *C = GVar->getInitializer();
125
126  // If the global is marked constant, we can put it into a mergable section,
127  // a mergable string section, or general .data if it contains relocations.
128  if (GVar->isConstant()) {
129    // If the initializer for the global contains something that requires a
130    // relocation, then we may have to drop this into a wriable data section
131    // even though it is marked const.
132    switch (C->getRelocationInfo()) {
133    default: llvm_unreachable("unknown relocation info kind");
134    case Constant::NoRelocation:
135      // If initializer is a null-terminated string, put it in a "cstring"
136      // section if the target has it.
137      if (isConstantString(C))
138        return SectionKind::getMergeableCString();
139
140      // Otherwise, just drop it into a mergable constant section.  If we have
141      // a section for this size, use it, otherwise use the arbitrary sized
142      // mergable section.
143      switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
144      case 4:  return SectionKind::getMergeableConst4();
145      case 8:  return SectionKind::getMergeableConst8();
146      case 16: return SectionKind::getMergeableConst16();
147      default: return SectionKind::getMergeableConst();
148      }
149
150    case Constant::LocalRelocation:
151      // In static relocation model, the linker will resolve all addresses, so
152      // the relocation entries will actually be constants by the time the app
153      // starts up.  However, we can't put this into a mergable section, because
154      // the linker doesn't take relocations into consideration when it tries to
155      // merge entries in the section.
156      if (ReloModel == Reloc::Static)
157        return SectionKind::getReadOnly();
158
159      // Otherwise, the dynamic linker needs to fix it up, put it in the
160      // writable data.rel.local section.
161      return SectionKind::getReadOnlyWithRelLocal();
162
163    case Constant::GlobalRelocations:
164      // In static relocation model, the linker will resolve all addresses, so
165      // the relocation entries will actually be constants by the time the app
166      // starts up.  However, we can't put this into a mergable section, because
167      // the linker doesn't take relocations into consideration when it tries to
168      // merge entries in the section.
169      if (ReloModel == Reloc::Static)
170        return SectionKind::getReadOnly();
171
172      // Otherwise, the dynamic linker needs to fix it up, put it in the
173      // writable data.rel section.
174      return SectionKind::getReadOnlyWithRel();
175    }
176  }
177
178  // Okay, this isn't a constant.  If the initializer for the global is going
179  // to require a runtime relocation by the dynamic linker, put it into a more
180  // specific section to improve startup time of the app.  This coalesces these
181  // globals together onto fewer pages, improving the locality of the dynamic
182  // linker.
183  if (ReloModel == Reloc::Static)
184    return SectionKind::getDataNoRel();
185
186  switch (C->getRelocationInfo()) {
187  default: llvm_unreachable("unknown relocation info kind");
188  case Constant::NoRelocation:
189    return SectionKind::getDataNoRel();
190  case Constant::LocalRelocation:
191    return SectionKind::getDataRelLocal();
192  case Constant::GlobalRelocations:
193    return SectionKind::getDataRel();
194  }
195}
196
197/// SectionForGlobal - This method computes the appropriate section to emit
198/// the specified global variable or function definition.  This should not
199/// be passed external (or available externally) globals.
200const MCSection *TargetLoweringObjectFile::
201SectionForGlobal(const GlobalValue *GV, Mangler *Mang,
202                 const TargetMachine &TM) const {
203  assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
204         "Can only be used for global definitions");
205
206  SectionKind Kind = SectionKindForGlobal(GV, TM);
207
208  // Select section name.
209  if (GV->hasSection()) {
210    // If the target has special section hacks for specifically named globals,
211    // return them now.
212    if (const MCSection *TS = getSpecialCasedSectionGlobals(GV, Mang, Kind))
213      return TS;
214
215    // If the target has magic semantics for certain section names, make sure to
216    // pick up the flags.  This allows the user to write things with attribute
217    // section and still get the appropriate section flags printed.
218    Kind = getKindForNamedSection(GV->getSection().c_str(), Kind);
219
220    return getOrCreateSection(GV->getSection().c_str(), false, Kind);
221  }
222
223
224  // Use default section depending on the 'type' of global
225  return SelectSectionForGlobal(GV, Kind, Mang, TM);
226}
227
228// Lame default implementation. Calculate the section name for global.
229const MCSection *
230TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
231                                                 SectionKind Kind,
232                                                 Mangler *Mang,
233                                                 const TargetMachine &TM) const{
234  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
235
236  if (Kind.isText())
237    return getTextSection();
238
239  if (Kind.isBSS() && BSSSection != 0)
240    return BSSSection;
241
242  if (Kind.isReadOnly() && ReadOnlySection != 0)
243    return ReadOnlySection;
244
245  return getDataSection();
246}
247
248/// getSectionForConstant - Given a mergable constant with the
249/// specified size and relocation information, return a section that it
250/// should be placed in.
251const MCSection *
252TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind) const {
253  if (Kind.isReadOnly() && ReadOnlySection != 0)
254    return ReadOnlySection;
255
256  return DataSection;
257}
258
259
260const MCSection *TargetLoweringObjectFile::
261getOrCreateSection(const char *Name, bool isDirective, SectionKind Kind) const {
262  if (MCSection *S = Ctx->GetSection(Name))
263    return S;
264  return MCSection::Create(Name, isDirective, Kind, *Ctx);
265}
266
267
268
269//===----------------------------------------------------------------------===//
270//                                  ELF
271//===----------------------------------------------------------------------===//
272
273void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
274                                             const TargetMachine &TM) {
275  TargetLoweringObjectFile::Initialize(Ctx, TM);
276  if (!HasCrazyBSS)
277    BSSSection = getOrCreateSection("\t.bss", true, SectionKind::getBSS());
278  else
279    // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
280    // FIXME: Does .section .bss work everywhere??
281    // FIXME2: this should just be handle by the section printer.  We should get
282    // away from syntactic view of the sections and MCSection should just be a
283    // semantic view.
284    BSSSection = getOrCreateSection("\t.bss", false, SectionKind::getBSS());
285
286
287  TextSection = getOrCreateSection("\t.text", true, SectionKind::getText());
288  DataSection = getOrCreateSection("\t.data", true, SectionKind::getDataRel());
289  ReadOnlySection =
290    getOrCreateSection("\t.rodata", false, SectionKind::getReadOnly());
291  TLSDataSection =
292    getOrCreateSection("\t.tdata", false, SectionKind::getThreadData());
293  CStringSection = getOrCreateSection("\t.rodata.str", true,
294                               SectionKind::getMergeableCString());
295
296  TLSBSSSection = getOrCreateSection("\t.tbss", false,
297                                     SectionKind::getThreadBSS());
298
299  DataRelSection = getOrCreateSection("\t.data.rel", false,
300                                      SectionKind::getDataRel());
301  DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
302                                   SectionKind::getDataRelLocal());
303  DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
304                                SectionKind::getReadOnlyWithRel());
305  DataRelROLocalSection =
306    getOrCreateSection("\t.data.rel.ro.local", false,
307                       SectionKind::getReadOnlyWithRelLocal());
308
309  MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
310                                SectionKind::getMergeableConst4());
311  MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
312                                SectionKind::getMergeableConst8());
313  MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
314                               SectionKind::getMergeableConst16());
315
316  StaticCtorSection =
317    getOrCreateSection(".ctors", false, SectionKind::getDataRel());
318  StaticDtorSection =
319    getOrCreateSection(".dtors", false, SectionKind::getDataRel());
320
321  // Exception Handling Sections.
322
323  // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
324  // it contains relocatable pointers.  In PIC mode, this is probably a big
325  // runtime hit for C++ apps.  Either the contents of the LSDA need to be
326  // adjusted or this should be a data section.
327  LSDASection =
328    getOrCreateSection(".gcc_except_table", false, SectionKind::getReadOnly());
329  EHFrameSection =
330    getOrCreateSection(".eh_frame", false, SectionKind::getDataRel());
331
332  // Debug Info Sections.
333  DwarfAbbrevSection =
334    getOrCreateSection(".debug_abbrev", false, SectionKind::getMetadata());
335  DwarfInfoSection =
336    getOrCreateSection(".debug_info", false, SectionKind::getMetadata());
337  DwarfLineSection =
338    getOrCreateSection(".debug_line", false, SectionKind::getMetadata());
339  DwarfFrameSection =
340    getOrCreateSection(".debug_frame", false, SectionKind::getMetadata());
341  DwarfPubNamesSection =
342    getOrCreateSection(".debug_pubnames", false, SectionKind::getMetadata());
343  DwarfPubTypesSection =
344    getOrCreateSection(".debug_pubtypes", false, SectionKind::getMetadata());
345  DwarfStrSection =
346    getOrCreateSection(".debug_str", false, SectionKind::getMetadata());
347  DwarfLocSection =
348    getOrCreateSection(".debug_loc", false, SectionKind::getMetadata());
349  DwarfARangesSection =
350    getOrCreateSection(".debug_aranges", false, SectionKind::getMetadata());
351  DwarfRangesSection =
352    getOrCreateSection(".debug_ranges", false, SectionKind::getMetadata());
353  DwarfMacroInfoSection =
354    getOrCreateSection(".debug_macinfo", false, SectionKind::getMetadata());
355}
356
357
358SectionKind TargetLoweringObjectFileELF::
359getKindForNamedSection(const char *Name, SectionKind K) const {
360  if (Name[0] != '.') return K;
361
362  // Some lame default implementation based on some magic section names.
363  if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
364      strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
365      strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
366      strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
367    return SectionKind::getBSS();
368
369  if (strcmp(Name, ".tdata") == 0 ||
370      strncmp(Name, ".tdata.", 7) == 0 ||
371      strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
372      strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
373    return SectionKind::getThreadData();
374
375  if (strcmp(Name, ".tbss") == 0 ||
376      strncmp(Name, ".tbss.", 6) == 0 ||
377      strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
378      strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
379    return SectionKind::getThreadBSS();
380
381  return K;
382}
383
384void TargetLoweringObjectFileELF::
385getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
386  Str.push_back(',');
387  Str.push_back('"');
388
389  if (!Kind.isMetadata())
390    Str.push_back('a');
391  if (Kind.isText())
392    Str.push_back('x');
393  if (Kind.isWriteable())
394    Str.push_back('w');
395  if (Kind.isMergeableCString() ||
396      Kind.isMergeableConst4() ||
397      Kind.isMergeableConst8() ||
398      Kind.isMergeableConst16())
399    Str.push_back('M');
400  if (Kind.isMergeableCString())
401    Str.push_back('S');
402  if (Kind.isThreadLocal())
403    Str.push_back('T');
404
405  Str.push_back('"');
406  Str.push_back(',');
407
408  // If comment string is '@', e.g. as on ARM - use '%' instead
409  if (AtIsCommentChar)
410    Str.push_back('%');
411  else
412    Str.push_back('@');
413
414  const char *KindStr;
415  if (Kind.isBSS() || Kind.isThreadBSS())
416    KindStr = "nobits";
417  else
418    KindStr = "progbits";
419
420  Str.append(KindStr, KindStr+strlen(KindStr));
421
422  if (Kind.isMergeableCString()) {
423    // TODO: Eventually handle multiple byte character strings.  For now, all
424    // mergable C strings are single byte.
425    Str.push_back(',');
426    Str.push_back('1');
427  } else if (Kind.isMergeableConst4()) {
428    Str.push_back(',');
429    Str.push_back('4');
430  } else if (Kind.isMergeableConst8()) {
431    Str.push_back(',');
432    Str.push_back('8');
433  } else if (Kind.isMergeableConst16()) {
434    Str.push_back(',');
435    Str.push_back('1');
436    Str.push_back('6');
437  }
438}
439
440
441static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
442  if (Kind.isText())                 return ".gnu.linkonce.t.";
443  if (Kind.isReadOnly())             return ".gnu.linkonce.r.";
444
445  if (Kind.isThreadData())           return ".gnu.linkonce.td.";
446  if (Kind.isThreadBSS())            return ".gnu.linkonce.tb.";
447
448  if (Kind.isBSS())                  return ".gnu.linkonce.b.";
449  if (Kind.isDataNoRel())            return ".gnu.linkonce.d.";
450  if (Kind.isDataRelLocal())         return ".gnu.linkonce.d.rel.local.";
451  if (Kind.isDataRel())              return ".gnu.linkonce.d.rel.";
452  if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
453
454  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
455  return ".gnu.linkonce.d.rel.ro.";
456}
457
458const MCSection *TargetLoweringObjectFileELF::
459SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
460                       Mangler *Mang, const TargetMachine &TM) const {
461
462  // If this global is linkonce/weak and the target handles this by emitting it
463  // into a 'uniqued' section name, create and return the section now.
464  if (GV->isWeakForLinker()) {
465    const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
466    std::string Name = Mang->makeNameProper(GV->getNameStr());
467    return getOrCreateSection((Prefix+Name).c_str(), false, Kind);
468  }
469
470  if (Kind.isText()) return TextSection;
471
472  if (Kind.isMergeableCString()) {
473   assert(CStringSection && "Should have string section prefix");
474
475    // We also need alignment here.
476    // FIXME: this is getting the alignment of the character, not the
477    // alignment of the global!
478    unsigned Align =
479      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
480
481    std::string Name = CStringSection->getName() + "1." + utostr(Align);
482    return getOrCreateSection(Name.c_str(), false,
483                              SectionKind::getMergeableCString());
484  }
485
486  if (Kind.isMergeableConst()) {
487    if (Kind.isMergeableConst4())
488      return MergeableConst4Section;
489    if (Kind.isMergeableConst8())
490      return MergeableConst8Section;
491    if (Kind.isMergeableConst16())
492      return MergeableConst16Section;
493    return ReadOnlySection;  // .const
494  }
495
496  if (Kind.isReadOnly())             return ReadOnlySection;
497
498  if (Kind.isThreadData())           return TLSDataSection;
499  if (Kind.isThreadBSS())            return TLSBSSSection;
500
501  if (Kind.isBSS())                  return BSSSection;
502
503  if (Kind.isDataNoRel())            return DataSection;
504  if (Kind.isDataRelLocal())         return DataRelLocalSection;
505  if (Kind.isDataRel())              return DataRelSection;
506  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
507
508  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
509  return DataRelROSection;
510}
511
512/// getSectionForConstant - Given a mergeable constant with the
513/// specified size and relocation information, return a section that it
514/// should be placed in.
515const MCSection *TargetLoweringObjectFileELF::
516getSectionForConstant(SectionKind Kind) const {
517  if (Kind.isMergeableConst4())
518    return MergeableConst4Section;
519  if (Kind.isMergeableConst8())
520    return MergeableConst8Section;
521  if (Kind.isMergeableConst16())
522    return MergeableConst16Section;
523  if (Kind.isReadOnly())
524    return ReadOnlySection;
525
526  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
527  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
528  return DataRelROSection;
529}
530
531//===----------------------------------------------------------------------===//
532//                                 MachO
533//===----------------------------------------------------------------------===//
534
535void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
536                                               const TargetMachine &TM) {
537  TargetLoweringObjectFile::Initialize(Ctx, TM);
538  TextSection = getOrCreateSection("\t.text", true,
539                                   SectionKind::getText());
540  DataSection = getOrCreateSection("\t.data", true,
541                                   SectionKind::getDataRel());
542
543  CStringSection = getOrCreateSection("\t.cstring", true,
544                               SectionKind::getMergeableCString());
545  FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
546                                SectionKind::getMergeableConst4());
547  EightByteConstantSection = getOrCreateSection("\t.literal8\n", true,
548                                SectionKind::getMergeableConst8());
549
550  // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
551  // to using it in -static mode.
552  if (TM.getRelocationModel() != Reloc::Static &&
553      TM.getTargetData()->getPointerSize() == 32)
554    SixteenByteConstantSection =
555      getOrCreateSection("\t.literal16\n", true,
556                         SectionKind::getMergeableConst16());
557  else
558    SixteenByteConstantSection = 0;
559
560  ReadOnlySection = getOrCreateSection("\t.const", true,
561                                       SectionKind::getReadOnly());
562
563  TextCoalSection =
564  getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
565                     false, SectionKind::getText());
566  ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
567                                            false,
568                                           SectionKind::getText());
569  ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
570                                            false,
571                                          SectionKind::getText());
572  ConstDataSection = getOrCreateSection("\t.const_data", true,
573                                SectionKind::getReadOnlyWithRel());
574  DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
575                                       false,
576                                       SectionKind::getDataRel());
577
578  if (TM.getRelocationModel() == Reloc::Static) {
579    StaticCtorSection =
580      getOrCreateSection(".constructor", true, SectionKind::getDataRel());
581    StaticDtorSection =
582      getOrCreateSection(".destructor", true, SectionKind::getDataRel());
583  } else {
584    StaticCtorSection =
585      getOrCreateSection(".mod_init_func", true, SectionKind::getDataRel());
586    StaticDtorSection =
587      getOrCreateSection(".mod_term_func", true, SectionKind::getDataRel());
588  }
589
590  // Exception Handling.
591  LSDASection = getOrCreateSection("__DATA,__gcc_except_tab", false,
592                                   SectionKind::getDataRel());
593  EHFrameSection =
594    getOrCreateSection("__TEXT,__eh_frame,coalesced,no_toc+strip_static_syms"
595                       "+live_support", false, SectionKind::getReadOnly());
596
597  // Debug Information.
598  // FIXME: Don't use 'directive' syntax: need flags for debug/regular??
599  // FIXME: Need __DWARF segment.
600  DwarfAbbrevSection =
601    getOrCreateSection(".section __DWARF,__debug_abbrev,regular,debug", true,
602                       SectionKind::getMetadata());
603  DwarfInfoSection =
604    getOrCreateSection(".section __DWARF,__debug_info,regular,debug", true,
605                       SectionKind::getMetadata());
606  DwarfLineSection =
607    getOrCreateSection(".section __DWARF,__debug_line,regular,debug", true,
608                       SectionKind::getMetadata());
609  DwarfFrameSection =
610    getOrCreateSection(".section __DWARF,__debug_frame,regular,debug", true,
611                       SectionKind::getMetadata());
612  DwarfPubNamesSection =
613    getOrCreateSection(".section __DWARF,__debug_pubnames,regular,debug", true,
614                       SectionKind::getMetadata());
615  DwarfPubTypesSection =
616    getOrCreateSection(".section __DWARF,__debug_pubtypes,regular,debug", true,
617                       SectionKind::getMetadata());
618  DwarfStrSection =
619    getOrCreateSection(".section __DWARF,__debug_str,regular,debug", true,
620                       SectionKind::getMetadata());
621  DwarfLocSection =
622    getOrCreateSection(".section __DWARF,__debug_loc,regular,debug", true,
623                       SectionKind::getMetadata());
624  DwarfARangesSection =
625    getOrCreateSection(".section __DWARF,__debug_aranges,regular,debug", true,
626                       SectionKind::getMetadata());
627  DwarfRangesSection =
628    getOrCreateSection(".section __DWARF,__debug_ranges,regular,debug", true,
629                       SectionKind::getMetadata());
630  DwarfMacroInfoSection =
631    getOrCreateSection(".section __DWARF,__debug_macinfo,regular,debug", true,
632                       SectionKind::getMetadata());
633  DwarfDebugInlineSection =
634    getOrCreateSection(".section __DWARF,__debug_inlined,regular,debug", true,
635                       SectionKind::getMetadata());
636}
637
638const MCSection *TargetLoweringObjectFileMachO::
639SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
640                       Mangler *Mang, const TargetMachine &TM) const {
641  assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
642
643  if (Kind.isText())
644    return GV->isWeakForLinker() ? TextCoalSection : TextSection;
645
646  // If this is weak/linkonce, put this in a coalescable section, either in text
647  // or data depending on if it is writable.
648  if (GV->isWeakForLinker()) {
649    if (Kind.isReadOnly())
650      return ConstTextCoalSection;
651    return DataCoalSection;
652  }
653
654  // FIXME: Alignment check should be handled by section classifier.
655  if (Kind.isMergeableCString()) {
656    Constant *C = cast<GlobalVariable>(GV)->getInitializer();
657    const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
658    const TargetData &TD = *TM.getTargetData();
659    unsigned Size = TD.getTypeAllocSize(Ty);
660    if (Size) {
661      unsigned Align = TD.getPreferredAlignment(cast<GlobalVariable>(GV));
662      if (Align <= 32)
663        return CStringSection;
664    }
665
666    return ReadOnlySection;
667  }
668
669  if (Kind.isMergeableConst()) {
670    if (Kind.isMergeableConst4())
671      return FourByteConstantSection;
672    if (Kind.isMergeableConst8())
673      return EightByteConstantSection;
674    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
675      return SixteenByteConstantSection;
676    return ReadOnlySection;  // .const
677  }
678
679  // FIXME: ROData -> const in -static mode that is relocatable but they happen
680  // by the static linker.  Why not mergeable?
681  if (Kind.isReadOnly())
682    return ReadOnlySection;
683
684  // If this is marked const, put it into a const section.  But if the dynamic
685  // linker needs to write to it, put it in the data segment.
686  if (Kind.isReadOnlyWithRel())
687    return ConstDataSection;
688
689  // Otherwise, just drop the variable in the normal data section.
690  return DataSection;
691}
692
693const MCSection *
694TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
695  // If this constant requires a relocation, we have to put it in the data
696  // segment, not in the text segment.
697  if (Kind.isDataRel())
698    return ConstDataSection;
699
700  if (Kind.isMergeableConst4())
701    return FourByteConstantSection;
702  if (Kind.isMergeableConst8())
703    return EightByteConstantSection;
704  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
705    return SixteenByteConstantSection;
706  return ReadOnlySection;  // .const
707}
708
709/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
710/// not to emit the UsedDirective for some symbols in llvm.used.
711// FIXME: REMOVE this (rdar://7071300)
712bool TargetLoweringObjectFileMachO::
713shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
714  /// On Darwin, internally linked data beginning with "L" or "l" does not have
715  /// the directive emitted (this occurs in ObjC metadata).
716  if (!GV) return false;
717
718  // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
719  if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
720    // FIXME: ObjC metadata is currently emitted as internal symbols that have
721    // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
722    // this horrible hack can go away.
723    const std::string &Name = Mang->getMangledName(GV);
724    if (Name[0] == 'L' || Name[0] == 'l')
725      return false;
726  }
727
728  return true;
729}
730
731
732//===----------------------------------------------------------------------===//
733//                                  COFF
734//===----------------------------------------------------------------------===//
735
736void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
737                                              const TargetMachine &TM) {
738  TargetLoweringObjectFile::Initialize(Ctx, TM);
739  TextSection = getOrCreateSection("\t.text", true,
740                                   SectionKind::getText());
741  DataSection = getOrCreateSection("\t.data", true,
742                                   SectionKind::getDataRel());
743  StaticCtorSection =
744    getOrCreateSection(".ctors", false, SectionKind::getDataRel());
745  StaticDtorSection =
746    getOrCreateSection(".dtors", false, SectionKind::getDataRel());
747
748
749  // Debug info.
750  // FIXME: Don't use 'directive' mode here.
751  DwarfAbbrevSection =
752    getOrCreateSection("\t.section\t.debug_abbrev,\"dr\"",
753                       true, SectionKind::getMetadata());
754  DwarfInfoSection =
755    getOrCreateSection("\t.section\t.debug_info,\"dr\"",
756                       true, SectionKind::getMetadata());
757  DwarfLineSection =
758    getOrCreateSection("\t.section\t.debug_line,\"dr\"",
759                       true, SectionKind::getMetadata());
760  DwarfFrameSection =
761    getOrCreateSection("\t.section\t.debug_frame,\"dr\"",
762                       true, SectionKind::getMetadata());
763  DwarfPubNamesSection =
764    getOrCreateSection("\t.section\t.debug_pubnames,\"dr\"",
765                       true, SectionKind::getMetadata());
766  DwarfPubTypesSection =
767    getOrCreateSection("\t.section\t.debug_pubtypes,\"dr\"",
768                       true, SectionKind::getMetadata());
769  DwarfStrSection =
770    getOrCreateSection("\t.section\t.debug_str,\"dr\"",
771                       true, SectionKind::getMetadata());
772  DwarfLocSection =
773    getOrCreateSection("\t.section\t.debug_loc,\"dr\"",
774                       true, SectionKind::getMetadata());
775  DwarfARangesSection =
776    getOrCreateSection("\t.section\t.debug_aranges,\"dr\"",
777                       true, SectionKind::getMetadata());
778  DwarfRangesSection =
779    getOrCreateSection("\t.section\t.debug_ranges,\"dr\"",
780                       true, SectionKind::getMetadata());
781  DwarfMacroInfoSection =
782    getOrCreateSection("\t.section\t.debug_macinfo,\"dr\"",
783                       true, SectionKind::getMetadata());
784}
785
786void TargetLoweringObjectFileCOFF::
787getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
788  // FIXME: Inefficient.
789  std::string Res = ",\"";
790  if (Kind.isText())
791    Res += 'x';
792  if (Kind.isWriteable())
793    Res += 'w';
794  Res += "\"";
795
796  Str.append(Res.begin(), Res.end());
797}
798
799static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
800  if (Kind.isText())
801    return ".text$linkonce";
802  if (Kind.isWriteable())
803    return ".data$linkonce";
804  return ".rdata$linkonce";
805}
806
807
808const MCSection *TargetLoweringObjectFileCOFF::
809SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
810                       Mangler *Mang, const TargetMachine &TM) const {
811  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
812
813  // If this global is linkonce/weak and the target handles this by emitting it
814  // into a 'uniqued' section name, create and return the section now.
815  if (GV->isWeakForLinker()) {
816    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
817    std::string Name = Mang->makeNameProper(GV->getNameStr());
818    return getOrCreateSection((Prefix+Name).c_str(), false, Kind);
819  }
820
821  if (Kind.isText())
822    return getTextSection();
823
824  return getDataSection();
825}
826
827