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