TargetLoweringObjectFile.cpp revision 848c29396271b8255653b6c6b61b5482bd72c293 
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/Function.h"
19#include "llvm/GlobalVariable.h"
20#include "llvm/MC/MCContext.h"
21#include "llvm/MC/MCSectionMachO.h"
22#include "llvm/MC/MCSectionELF.h"
23#include "llvm/Target/TargetData.h"
24#include "llvm/Target/TargetMachine.h"
25#include "llvm/Target/TargetOptions.h"
26#include "llvm/Support/Mangler.h"
27#include "llvm/ADT/SmallString.h"
28#include "llvm/ADT/StringExtras.h"
29using namespace llvm;
30
31//===----------------------------------------------------------------------===//
32//                              Generic Code
33//===----------------------------------------------------------------------===//
34
35TargetLoweringObjectFile::TargetLoweringObjectFile() : Ctx(0) {
36  TextSection = 0;
37  DataSection = 0;
38  BSSSection = 0;
39  ReadOnlySection = 0;
40  StaticCtorSection = 0;
41  StaticDtorSection = 0;
42  LSDASection = 0;
43  EHFrameSection = 0;
44
45  DwarfAbbrevSection = 0;
46  DwarfInfoSection = 0;
47  DwarfLineSection = 0;
48  DwarfFrameSection = 0;
49  DwarfPubNamesSection = 0;
50  DwarfPubTypesSection = 0;
51  DwarfDebugInlineSection = 0;
52  DwarfStrSection = 0;
53  DwarfLocSection = 0;
54  DwarfARangesSection = 0;
55  DwarfRangesSection = 0;
56  DwarfMacroInfoSection = 0;
57}
58
59TargetLoweringObjectFile::~TargetLoweringObjectFile() {
60}
61
62static bool isSuitableForBSS(const GlobalVariable *GV) {
63  Constant *C = GV->getInitializer();
64
65  // Must have zero initializer.
66  if (!C->isNullValue())
67    return false;
68
69  // Leave constant zeros in readonly constant sections, so they can be shared.
70  if (GV->isConstant())
71    return false;
72
73  // If the global has an explicit section specified, don't put it in BSS.
74  if (!GV->getSection().empty())
75    return false;
76
77  // If -nozero-initialized-in-bss is specified, don't ever use BSS.
78  if (NoZerosInBSS)
79    return false;
80
81  // Otherwise, put it in BSS!
82  return true;
83}
84
85/// IsNullTerminatedString - Return true if the specified constant (which is
86/// known to have a type that is an array of 1/2/4 byte elements) ends with a
87/// nul value and contains no other nuls in it.
88static bool IsNullTerminatedString(const Constant *C) {
89  const ArrayType *ATy = cast<ArrayType>(C->getType());
90
91  // First check: is we have constant array of i8 terminated with zero
92  if (const ConstantArray *CVA = dyn_cast<ConstantArray>(C)) {
93    if (ATy->getNumElements() == 0) return false;
94
95    ConstantInt *Null =
96      dyn_cast<ConstantInt>(CVA->getOperand(ATy->getNumElements()-1));
97    if (Null == 0 || Null->getZExtValue() != 0)
98      return false; // Not null terminated.
99
100    // Verify that the null doesn't occur anywhere else in the string.
101    for (unsigned i = 0, e = ATy->getNumElements()-1; i != e; ++i)
102      // Reject constantexpr elements etc.
103      if (!isa<ConstantInt>(CVA->getOperand(i)) ||
104          CVA->getOperand(i) == Null)
105        return false;
106    return true;
107  }
108
109  // Another possibility: [1 x i8] zeroinitializer
110  if (isa<ConstantAggregateZero>(C))
111    return ATy->getNumElements() == 1;
112
113  return false;
114}
115
116/// getKindForGlobal - This is a top-level target-independent classifier for
117/// a global variable.  Given an global variable and information from TM, it
118/// classifies the global in a variety of ways that make various target
119/// implementations simpler.  The target implementation is free to ignore this
120/// extra info of course.
121SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV,
122                                                       const TargetMachine &TM){
123  assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
124         "Can only be used for global definitions");
125
126  Reloc::Model ReloModel = TM.getRelocationModel();
127
128  // Early exit - functions should be always in text sections.
129  const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
130  if (GVar == 0)
131    return SectionKind::getText();
132
133  // Handle thread-local data first.
134  if (GVar->isThreadLocal()) {
135    if (isSuitableForBSS(GVar))
136      return SectionKind::getThreadBSS();
137    return SectionKind::getThreadData();
138  }
139
140  // Variable can be easily put to BSS section.
141  if (isSuitableForBSS(GVar))
142    return SectionKind::getBSS();
143
144  Constant *C = GVar->getInitializer();
145
146  // If the global is marked constant, we can put it into a mergable section,
147  // a mergable string section, or general .data if it contains relocations.
148  if (GVar->isConstant()) {
149    // If the initializer for the global contains something that requires a
150    // relocation, then we may have to drop this into a wriable data section
151    // even though it is marked const.
152    switch (C->getRelocationInfo()) {
153    default: llvm_unreachable("unknown relocation info kind");
154    case Constant::NoRelocation:
155      // If initializer is a null-terminated string, put it in a "cstring"
156      // section of the right width.
157      if (const ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
158        if (const IntegerType *ITy =
159              dyn_cast<IntegerType>(ATy->getElementType())) {
160          if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
161               ITy->getBitWidth() == 32) &&
162              IsNullTerminatedString(C)) {
163            if (ITy->getBitWidth() == 8)
164              return SectionKind::getMergeable1ByteCString();
165            if (ITy->getBitWidth() == 16)
166              return SectionKind::getMergeable2ByteCString();
167
168            assert(ITy->getBitWidth() == 32 && "Unknown width");
169            return SectionKind::getMergeable4ByteCString();
170          }
171        }
172      }
173
174      // Otherwise, just drop it into a mergable constant section.  If we have
175      // a section for this size, use it, otherwise use the arbitrary sized
176      // mergable section.
177      switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
178      case 4:  return SectionKind::getMergeableConst4();
179      case 8:  return SectionKind::getMergeableConst8();
180      case 16: return SectionKind::getMergeableConst16();
181      default: return SectionKind::getMergeableConst();
182      }
183
184    case Constant::LocalRelocation:
185      // In static relocation model, the linker will resolve all addresses, so
186      // the relocation entries will actually be constants by the time the app
187      // starts up.  However, we can't put this into a mergable section, because
188      // the linker doesn't take relocations into consideration when it tries to
189      // merge entries in the section.
190      if (ReloModel == Reloc::Static)
191        return SectionKind::getReadOnly();
192
193      // Otherwise, the dynamic linker needs to fix it up, put it in the
194      // writable data.rel.local section.
195      return SectionKind::getReadOnlyWithRelLocal();
196
197    case Constant::GlobalRelocations:
198      // In static relocation model, the linker will resolve all addresses, so
199      // the relocation entries will actually be constants by the time the app
200      // starts up.  However, we can't put this into a mergable section, because
201      // the linker doesn't take relocations into consideration when it tries to
202      // merge entries in the section.
203      if (ReloModel == Reloc::Static)
204        return SectionKind::getReadOnly();
205
206      // Otherwise, the dynamic linker needs to fix it up, put it in the
207      // writable data.rel section.
208      return SectionKind::getReadOnlyWithRel();
209    }
210  }
211
212  // Okay, this isn't a constant.  If the initializer for the global is going
213  // to require a runtime relocation by the dynamic linker, put it into a more
214  // specific section to improve startup time of the app.  This coalesces these
215  // globals together onto fewer pages, improving the locality of the dynamic
216  // linker.
217  if (ReloModel == Reloc::Static)
218    return SectionKind::getDataNoRel();
219
220  switch (C->getRelocationInfo()) {
221  default: llvm_unreachable("unknown relocation info kind");
222  case Constant::NoRelocation:
223    return SectionKind::getDataNoRel();
224  case Constant::LocalRelocation:
225    return SectionKind::getDataRelLocal();
226  case Constant::GlobalRelocations:
227    return SectionKind::getDataRel();
228  }
229}
230
231/// SectionForGlobal - This method computes the appropriate section to emit
232/// the specified global variable or function definition.  This should not
233/// be passed external (or available externally) globals.
234const MCSection *TargetLoweringObjectFile::
235SectionForGlobal(const GlobalValue *GV, SectionKind Kind, Mangler *Mang,
236                 const TargetMachine &TM) const {
237  // Select section name.
238  if (GV->hasSection())
239    return getExplicitSectionGlobal(GV, Kind, Mang, TM);
240
241
242  // Use default section depending on the 'type' of global
243  return SelectSectionForGlobal(GV, Kind, Mang, TM);
244}
245
246
247// Lame default implementation. Calculate the section name for global.
248const MCSection *
249TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
250                                                 SectionKind Kind,
251                                                 Mangler *Mang,
252                                                 const TargetMachine &TM) const{
253  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
254
255  if (Kind.isText())
256    return getTextSection();
257
258  if (Kind.isBSS() && BSSSection != 0)
259    return BSSSection;
260
261  if (Kind.isReadOnly() && ReadOnlySection != 0)
262    return ReadOnlySection;
263
264  return getDataSection();
265}
266
267/// getSectionForConstant - Given a mergable constant with the
268/// specified size and relocation information, return a section that it
269/// should be placed in.
270const MCSection *
271TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind) const {
272  if (Kind.isReadOnly() && ReadOnlySection != 0)
273    return ReadOnlySection;
274
275  return DataSection;
276}
277
278
279
280//===----------------------------------------------------------------------===//
281//                                  ELF
282//===----------------------------------------------------------------------===//
283typedef StringMap<const MCSectionELF*> ELFUniqueMapTy;
284
285TargetLoweringObjectFileELF::~TargetLoweringObjectFileELF() {
286  // If we have the section uniquing map, free it.
287  delete (ELFUniqueMapTy*)UniquingMap;
288}
289
290const MCSection *TargetLoweringObjectFileELF::
291getELFSection(StringRef Section, unsigned Type, unsigned Flags,
292              SectionKind Kind, bool IsExplicit) const {
293  if (UniquingMap == 0)
294    UniquingMap = new ELFUniqueMapTy();
295  ELFUniqueMapTy &Map = *(ELFUniqueMapTy*)UniquingMap;
296
297  // Do the lookup, if we have a hit, return it.
298  const MCSectionELF *&Entry = Map[Section];
299  if (Entry) return Entry;
300
301  return Entry = MCSectionELF::Create(Section, Type, Flags, Kind, IsExplicit,
302                                      getContext());
303}
304
305void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
306                                             const TargetMachine &TM) {
307  if (UniquingMap != 0)
308    ((ELFUniqueMapTy*)UniquingMap)->clear();
309  TargetLoweringObjectFile::Initialize(Ctx, TM);
310
311  BSSSection =
312    getELFSection(".bss", MCSectionELF::SHT_NOBITS,
313                  MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
314                  SectionKind::getBSS());
315
316  TextSection =
317    getELFSection(".text", MCSectionELF::SHT_PROGBITS,
318                  MCSectionELF::SHF_EXECINSTR | MCSectionELF::SHF_ALLOC,
319                  SectionKind::getText());
320
321  DataSection =
322    getELFSection(".data", MCSectionELF::SHT_PROGBITS,
323                  MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
324                  SectionKind::getDataRel());
325
326  ReadOnlySection =
327    getELFSection(".rodata", MCSectionELF::SHT_PROGBITS,
328                  MCSectionELF::SHF_ALLOC,
329                  SectionKind::getReadOnly());
330
331  TLSDataSection =
332    getELFSection(".tdata", MCSectionELF::SHT_PROGBITS,
333                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
334                  MCSectionELF::SHF_WRITE, SectionKind::getThreadData());
335
336  TLSBSSSection =
337    getELFSection(".tbss", MCSectionELF::SHT_NOBITS,
338                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
339                  MCSectionELF::SHF_WRITE, SectionKind::getThreadBSS());
340
341  DataRelSection =
342    getELFSection(".data.rel", MCSectionELF::SHT_PROGBITS,
343                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
344                  SectionKind::getDataRel());
345
346  DataRelLocalSection =
347    getELFSection(".data.rel.local", MCSectionELF::SHT_PROGBITS,
348                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
349                  SectionKind::getDataRelLocal());
350
351  DataRelROSection =
352    getELFSection(".data.rel.ro", MCSectionELF::SHT_PROGBITS,
353                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
354                  SectionKind::getReadOnlyWithRel());
355
356  DataRelROLocalSection =
357    getELFSection(".data.rel.ro.local", MCSectionELF::SHT_PROGBITS,
358                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
359                  SectionKind::getReadOnlyWithRelLocal());
360
361  MergeableConst4Section =
362    getELFSection(".rodata.cst4", MCSectionELF::SHT_PROGBITS,
363                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
364                  SectionKind::getMergeableConst4());
365
366  MergeableConst8Section =
367    getELFSection(".rodata.cst8", MCSectionELF::SHT_PROGBITS,
368                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
369                  SectionKind::getMergeableConst8());
370
371  MergeableConst16Section =
372    getELFSection(".rodata.cst16", MCSectionELF::SHT_PROGBITS,
373                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
374                  SectionKind::getMergeableConst16());
375
376  StaticCtorSection =
377    getELFSection(".ctors", MCSectionELF::SHT_PROGBITS,
378                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
379                  SectionKind::getDataRel());
380
381  StaticDtorSection =
382    getELFSection(".dtors", MCSectionELF::SHT_PROGBITS,
383                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
384                  SectionKind::getDataRel());
385
386  // Exception Handling Sections.
387
388  // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
389  // it contains relocatable pointers.  In PIC mode, this is probably a big
390  // runtime hit for C++ apps.  Either the contents of the LSDA need to be
391  // adjusted or this should be a data section.
392  LSDASection =
393    getELFSection(".gcc_except_table", MCSectionELF::SHT_PROGBITS,
394                  MCSectionELF::SHF_ALLOC, SectionKind::getReadOnly());
395  EHFrameSection =
396    getELFSection(".eh_frame", MCSectionELF::SHT_PROGBITS,
397                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
398                  SectionKind::getDataRel());
399
400  // Debug Info Sections.
401  DwarfAbbrevSection =
402    getELFSection(".debug_abbrev", MCSectionELF::SHT_PROGBITS, 0,
403                  SectionKind::getMetadata());
404  DwarfInfoSection =
405    getELFSection(".debug_info", MCSectionELF::SHT_PROGBITS, 0,
406                  SectionKind::getMetadata());
407  DwarfLineSection =
408    getELFSection(".debug_line", MCSectionELF::SHT_PROGBITS, 0,
409                  SectionKind::getMetadata());
410  DwarfFrameSection =
411    getELFSection(".debug_frame", MCSectionELF::SHT_PROGBITS, 0,
412                  SectionKind::getMetadata());
413  DwarfPubNamesSection =
414    getELFSection(".debug_pubnames", MCSectionELF::SHT_PROGBITS, 0,
415                  SectionKind::getMetadata());
416  DwarfPubTypesSection =
417    getELFSection(".debug_pubtypes", MCSectionELF::SHT_PROGBITS, 0,
418                  SectionKind::getMetadata());
419  DwarfStrSection =
420    getELFSection(".debug_str", MCSectionELF::SHT_PROGBITS, 0,
421                  SectionKind::getMetadata());
422  DwarfLocSection =
423    getELFSection(".debug_loc", MCSectionELF::SHT_PROGBITS, 0,
424                  SectionKind::getMetadata());
425  DwarfARangesSection =
426    getELFSection(".debug_aranges", MCSectionELF::SHT_PROGBITS, 0,
427                  SectionKind::getMetadata());
428  DwarfRangesSection =
429    getELFSection(".debug_ranges", MCSectionELF::SHT_PROGBITS, 0,
430                  SectionKind::getMetadata());
431  DwarfMacroInfoSection =
432    getELFSection(".debug_macinfo", MCSectionELF::SHT_PROGBITS, 0,
433                  SectionKind::getMetadata());
434}
435
436
437static SectionKind
438getELFKindForNamedSection(const char *Name, SectionKind K) {
439  if (Name[0] != '.') return K;
440
441  // Some lame default implementation based on some magic section names.
442  if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
443      strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
444      strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
445      strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
446    return SectionKind::getBSS();
447
448  if (strcmp(Name, ".tdata") == 0 ||
449      strncmp(Name, ".tdata.", 7) == 0 ||
450      strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
451      strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
452    return SectionKind::getThreadData();
453
454  if (strcmp(Name, ".tbss") == 0 ||
455      strncmp(Name, ".tbss.", 6) == 0 ||
456      strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
457      strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
458    return SectionKind::getThreadBSS();
459
460  return K;
461}
462
463
464static unsigned
465getELFSectionType(const char *Name, SectionKind K) {
466
467  if (strcmp(Name, ".init_array") == 0)
468    return MCSectionELF::SHT_INIT_ARRAY;
469
470  if (strcmp(Name, ".fini_array") == 0)
471    return MCSectionELF::SHT_FINI_ARRAY;
472
473  if (strcmp(Name, ".preinit_array") == 0)
474    return MCSectionELF::SHT_PREINIT_ARRAY;
475
476  if (K.isBSS() || K.isThreadBSS())
477    return MCSectionELF::SHT_NOBITS;
478
479  return MCSectionELF::SHT_PROGBITS;
480}
481
482
483static unsigned
484getELFSectionFlags(SectionKind K) {
485  unsigned Flags = 0;
486
487  if (!K.isMetadata())
488    Flags |= MCSectionELF::SHF_ALLOC;
489
490  if (K.isText())
491    Flags |= MCSectionELF::SHF_EXECINSTR;
492
493  if (K.isWriteable())
494    Flags |= MCSectionELF::SHF_WRITE;
495
496  if (K.isThreadLocal())
497    Flags |= MCSectionELF::SHF_TLS;
498
499  // K.isMergeableConst() is left out to honour PR4650
500  if (K.isMergeableCString() || K.isMergeableConst4() ||
501      K.isMergeableConst8() || K.isMergeableConst16())
502    Flags |= MCSectionELF::SHF_MERGE;
503
504  if (K.isMergeableCString())
505    Flags |= MCSectionELF::SHF_STRINGS;
506
507  return Flags;
508}
509
510
511const MCSection *TargetLoweringObjectFileELF::
512getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
513                         Mangler *Mang, const TargetMachine &TM) const {
514  const char *SectionName = GV->getSection().c_str();
515
516  // Infer section flags from the section name if we can.
517  Kind = getELFKindForNamedSection(SectionName, Kind);
518
519  return getELFSection(SectionName,
520                       getELFSectionType(SectionName, Kind),
521                       getELFSectionFlags(Kind), Kind, true);
522}
523
524static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
525  if (Kind.isText())                 return ".gnu.linkonce.t.";
526  if (Kind.isReadOnly())             return ".gnu.linkonce.r.";
527
528  if (Kind.isThreadData())           return ".gnu.linkonce.td.";
529  if (Kind.isThreadBSS())            return ".gnu.linkonce.tb.";
530
531  if (Kind.isBSS())                  return ".gnu.linkonce.b.";
532  if (Kind.isDataNoRel())            return ".gnu.linkonce.d.";
533  if (Kind.isDataRelLocal())         return ".gnu.linkonce.d.rel.local.";
534  if (Kind.isDataRel())              return ".gnu.linkonce.d.rel.";
535  if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
536
537  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
538  return ".gnu.linkonce.d.rel.ro.";
539}
540
541const MCSection *TargetLoweringObjectFileELF::
542SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
543                       Mangler *Mang, const TargetMachine &TM) const {
544
545  // If this global is linkonce/weak and the target handles this by emitting it
546  // into a 'uniqued' section name, create and return the section now.
547  if (GV->isWeakForLinker()) {
548    const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
549    std::string Name = Mang->makeNameProper(GV->getNameStr());
550
551    return getELFSection((Prefix+Name).c_str(),
552                         getELFSectionType((Prefix+Name).c_str(), Kind),
553                         getELFSectionFlags(Kind),
554                         Kind);
555  }
556
557  if (Kind.isText()) return TextSection;
558
559  if (Kind.isMergeable1ByteCString() ||
560      Kind.isMergeable2ByteCString() ||
561      Kind.isMergeable4ByteCString()) {
562
563    // We also need alignment here.
564    // FIXME: this is getting the alignment of the character, not the
565    // alignment of the global!
566    unsigned Align =
567      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
568
569    const char *SizeSpec = ".rodata.str1.";
570    if (Kind.isMergeable2ByteCString())
571      SizeSpec = ".rodata.str2.";
572    else if (Kind.isMergeable4ByteCString())
573      SizeSpec = ".rodata.str4.";
574    else
575      assert(Kind.isMergeable1ByteCString() && "unknown string width");
576
577
578    std::string Name = SizeSpec + utostr(Align);
579    return getELFSection(Name.c_str(), MCSectionELF::SHT_PROGBITS,
580                         MCSectionELF::SHF_ALLOC |
581                         MCSectionELF::SHF_MERGE |
582                         MCSectionELF::SHF_STRINGS,
583                         Kind);
584  }
585
586  if (Kind.isMergeableConst()) {
587    if (Kind.isMergeableConst4() && MergeableConst4Section)
588      return MergeableConst4Section;
589    if (Kind.isMergeableConst8() && MergeableConst8Section)
590      return MergeableConst8Section;
591    if (Kind.isMergeableConst16() && MergeableConst16Section)
592      return MergeableConst16Section;
593    return ReadOnlySection;  // .const
594  }
595
596  if (Kind.isReadOnly())             return ReadOnlySection;
597
598  if (Kind.isThreadData())           return TLSDataSection;
599  if (Kind.isThreadBSS())            return TLSBSSSection;
600
601  if (Kind.isBSS())                  return BSSSection;
602
603  if (Kind.isDataNoRel())            return DataSection;
604  if (Kind.isDataRelLocal())         return DataRelLocalSection;
605  if (Kind.isDataRel())              return DataRelSection;
606  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
607
608  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
609  return DataRelROSection;
610}
611
612/// getSectionForConstant - Given a mergeable constant with the
613/// specified size and relocation information, return a section that it
614/// should be placed in.
615const MCSection *TargetLoweringObjectFileELF::
616getSectionForConstant(SectionKind Kind) const {
617  if (Kind.isMergeableConst4() && MergeableConst4Section)
618    return MergeableConst4Section;
619  if (Kind.isMergeableConst8() && MergeableConst8Section)
620    return MergeableConst8Section;
621  if (Kind.isMergeableConst16() && MergeableConst16Section)
622    return MergeableConst16Section;
623  if (Kind.isReadOnly())
624    return ReadOnlySection;
625
626  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
627  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
628  return DataRelROSection;
629}
630
631//===----------------------------------------------------------------------===//
632//                                 MachO
633//===----------------------------------------------------------------------===//
634
635typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy;
636
637TargetLoweringObjectFileMachO::~TargetLoweringObjectFileMachO() {
638  // If we have the MachO uniquing map, free it.
639  delete (MachOUniqueMapTy*)UniquingMap;
640}
641
642
643const MCSectionMachO *TargetLoweringObjectFileMachO::
644getMachOSection(const StringRef &Segment, const StringRef &Section,
645                unsigned TypeAndAttributes,
646                unsigned Reserved2, SectionKind Kind) const {
647  // We unique sections by their segment/section pair.  The returned section
648  // may not have the same flags as the requested section, if so this should be
649  // diagnosed by the client as an error.
650
651  // Create the map if it doesn't already exist.
652  if (UniquingMap == 0)
653    UniquingMap = new MachOUniqueMapTy();
654  MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)UniquingMap;
655
656  // Form the name to look up.
657  SmallString<64> Name;
658  Name.append(Segment.begin(), Segment.end());
659  Name.push_back(',');
660  Name.append(Section.begin(), Section.end());
661
662  // Do the lookup, if we have a hit, return it.
663  const MCSectionMachO *&Entry = Map[StringRef(Name.data(), Name.size())];
664  if (Entry) return Entry;
665
666  // Otherwise, return a new section.
667  return Entry = MCSectionMachO::Create(Segment, Section, TypeAndAttributes,
668                                        Reserved2, Kind, getContext());
669}
670
671
672void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
673                                               const TargetMachine &TM) {
674  if (UniquingMap != 0)
675    ((MachOUniqueMapTy*)UniquingMap)->clear();
676  TargetLoweringObjectFile::Initialize(Ctx, TM);
677
678  TextSection // .text
679    = getMachOSection("__TEXT", "__text",
680                      MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
681                      SectionKind::getText());
682  DataSection // .data
683    = getMachOSection("__DATA", "__data", 0, SectionKind::getDataRel());
684
685  CStringSection // .cstring
686    = getMachOSection("__TEXT", "__cstring", MCSectionMachO::S_CSTRING_LITERALS,
687                      SectionKind::getMergeable1ByteCString());
688  UStringSection
689    = getMachOSection("__TEXT","__ustring", 0,
690                      SectionKind::getMergeable2ByteCString());
691  FourByteConstantSection // .literal4
692    = getMachOSection("__TEXT", "__literal4", MCSectionMachO::S_4BYTE_LITERALS,
693                      SectionKind::getMergeableConst4());
694  EightByteConstantSection // .literal8
695    = getMachOSection("__TEXT", "__literal8", MCSectionMachO::S_8BYTE_LITERALS,
696                      SectionKind::getMergeableConst8());
697
698  // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
699  // to using it in -static mode.
700  SixteenByteConstantSection = 0;
701  if (TM.getRelocationModel() != Reloc::Static &&
702      TM.getTargetData()->getPointerSize() == 32)
703    SixteenByteConstantSection =   // .literal16
704      getMachOSection("__TEXT", "__literal16",MCSectionMachO::S_16BYTE_LITERALS,
705                      SectionKind::getMergeableConst16());
706
707  ReadOnlySection  // .const
708    = getMachOSection("__TEXT", "__const", 0, SectionKind::getReadOnly());
709
710  TextCoalSection
711    = getMachOSection("__TEXT", "__textcoal_nt",
712                      MCSectionMachO::S_COALESCED |
713                      MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
714                      SectionKind::getText());
715  ConstTextCoalSection
716    = getMachOSection("__TEXT", "__const_coal", MCSectionMachO::S_COALESCED,
717                      SectionKind::getText());
718  ConstDataCoalSection
719    = getMachOSection("__DATA","__const_coal", MCSectionMachO::S_COALESCED,
720                      SectionKind::getText());
721  ConstDataSection  // .const_data
722    = getMachOSection("__DATA", "__const", 0,
723                      SectionKind::getReadOnlyWithRel());
724  DataCoalSection
725    = getMachOSection("__DATA","__datacoal_nt", MCSectionMachO::S_COALESCED,
726                      SectionKind::getDataRel());
727
728
729  LazySymbolPointerSection
730    = getMachOSection("__DATA", "__la_symbol_ptr",
731                      MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
732                      SectionKind::getMetadata());
733  NonLazySymbolPointerSection
734    = getMachOSection("__DATA", "__nl_symbol_ptr",
735                      MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
736                      SectionKind::getMetadata());
737
738  if (TM.getRelocationModel() == Reloc::Static) {
739    StaticCtorSection
740      = getMachOSection("__TEXT", "__constructor", 0,SectionKind::getDataRel());
741    StaticDtorSection
742      = getMachOSection("__TEXT", "__destructor", 0, SectionKind::getDataRel());
743  } else {
744    StaticCtorSection
745      = getMachOSection("__DATA", "__mod_init_func",
746                        MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
747                        SectionKind::getDataRel());
748    StaticDtorSection
749      = getMachOSection("__DATA", "__mod_term_func",
750                        MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
751                        SectionKind::getDataRel());
752  }
753
754  // Exception Handling.
755  LSDASection = getMachOSection("__DATA", "__gcc_except_tab", 0,
756                                SectionKind::getDataRel());
757  EHFrameSection =
758    getMachOSection("__TEXT", "__eh_frame",
759                    MCSectionMachO::S_COALESCED |
760                    MCSectionMachO::S_ATTR_NO_TOC |
761                    MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
762                    MCSectionMachO::S_ATTR_LIVE_SUPPORT,
763                    SectionKind::getReadOnly());
764
765  // Debug Information.
766  DwarfAbbrevSection =
767    getMachOSection("__DWARF", "__debug_abbrev", MCSectionMachO::S_ATTR_DEBUG,
768                    SectionKind::getMetadata());
769  DwarfInfoSection =
770    getMachOSection("__DWARF", "__debug_info", MCSectionMachO::S_ATTR_DEBUG,
771                    SectionKind::getMetadata());
772  DwarfLineSection =
773    getMachOSection("__DWARF", "__debug_line", MCSectionMachO::S_ATTR_DEBUG,
774                    SectionKind::getMetadata());
775  DwarfFrameSection =
776    getMachOSection("__DWARF", "__debug_frame", MCSectionMachO::S_ATTR_DEBUG,
777                    SectionKind::getMetadata());
778  DwarfPubNamesSection =
779    getMachOSection("__DWARF", "__debug_pubnames", MCSectionMachO::S_ATTR_DEBUG,
780                    SectionKind::getMetadata());
781  DwarfPubTypesSection =
782    getMachOSection("__DWARF", "__debug_pubtypes", MCSectionMachO::S_ATTR_DEBUG,
783                    SectionKind::getMetadata());
784  DwarfStrSection =
785    getMachOSection("__DWARF", "__debug_str", MCSectionMachO::S_ATTR_DEBUG,
786                    SectionKind::getMetadata());
787  DwarfLocSection =
788    getMachOSection("__DWARF", "__debug_loc", MCSectionMachO::S_ATTR_DEBUG,
789                    SectionKind::getMetadata());
790  DwarfARangesSection =
791    getMachOSection("__DWARF", "__debug_aranges", MCSectionMachO::S_ATTR_DEBUG,
792                    SectionKind::getMetadata());
793  DwarfRangesSection =
794    getMachOSection("__DWARF", "__debug_ranges", MCSectionMachO::S_ATTR_DEBUG,
795                    SectionKind::getMetadata());
796  DwarfMacroInfoSection =
797    getMachOSection("__DWARF", "__debug_macinfo", MCSectionMachO::S_ATTR_DEBUG,
798                    SectionKind::getMetadata());
799  DwarfDebugInlineSection =
800    getMachOSection("__DWARF", "__debug_inlined", MCSectionMachO::S_ATTR_DEBUG,
801                    SectionKind::getMetadata());
802}
803
804const MCSection *TargetLoweringObjectFileMachO::
805getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
806                         Mangler *Mang, const TargetMachine &TM) const {
807  // Parse the section specifier and create it if valid.
808  StringRef Segment, Section;
809  unsigned TAA, StubSize;
810  std::string ErrorCode =
811    MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
812                                          TAA, StubSize);
813  if (!ErrorCode.empty()) {
814    // If invalid, report the error with llvm_report_error.
815    llvm_report_error("Global variable '" + GV->getNameStr() +
816                      "' has an invalid section specifier '" + GV->getSection()+
817                      "': " + ErrorCode + ".");
818    // Fall back to dropping it into the data section.
819    return DataSection;
820  }
821
822  // Get the section.
823  const MCSectionMachO *S =
824    getMachOSection(Segment, Section, TAA, StubSize, Kind);
825
826  // Okay, now that we got the section, verify that the TAA & StubSize agree.
827  // If the user declared multiple globals with different section flags, we need
828  // to reject it here.
829  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
830    // If invalid, report the error with llvm_report_error.
831    llvm_report_error("Global variable '" + GV->getNameStr() +
832                      "' section type or attributes does not match previous"
833                      " section specifier");
834  }
835
836  return S;
837}
838
839const MCSection *TargetLoweringObjectFileMachO::
840SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
841                       Mangler *Mang, const TargetMachine &TM) const {
842  assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
843
844  if (Kind.isText())
845    return GV->isWeakForLinker() ? TextCoalSection : TextSection;
846
847  // If this is weak/linkonce, put this in a coalescable section, either in text
848  // or data depending on if it is writable.
849  if (GV->isWeakForLinker()) {
850    if (Kind.isReadOnly())
851      return ConstTextCoalSection;
852    return DataCoalSection;
853  }
854
855  // FIXME: Alignment check should be handled by section classifier.
856  if (Kind.isMergeable1ByteCString() ||
857      Kind.isMergeable2ByteCString()) {
858    if (TM.getTargetData()->getPreferredAlignment(
859                                              cast<GlobalVariable>(GV)) < 32) {
860      if (Kind.isMergeable1ByteCString())
861        return CStringSection;
862      assert(Kind.isMergeable2ByteCString());
863      return UStringSection;
864    }
865  }
866
867  if (Kind.isMergeableConst()) {
868    if (Kind.isMergeableConst4())
869      return FourByteConstantSection;
870    if (Kind.isMergeableConst8())
871      return EightByteConstantSection;
872    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
873      return SixteenByteConstantSection;
874  }
875
876  // Otherwise, if it is readonly, but not something we can specially optimize,
877  // just drop it in .const.
878  if (Kind.isReadOnly())
879    return ReadOnlySection;
880
881  // If this is marked const, put it into a const section.  But if the dynamic
882  // linker needs to write to it, put it in the data segment.
883  if (Kind.isReadOnlyWithRel())
884    return ConstDataSection;
885
886  // Otherwise, just drop the variable in the normal data section.
887  return DataSection;
888}
889
890const MCSection *
891TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
892  // If this constant requires a relocation, we have to put it in the data
893  // segment, not in the text segment.
894  if (Kind.isDataRel())
895    return ConstDataSection;
896
897  if (Kind.isMergeableConst4())
898    return FourByteConstantSection;
899  if (Kind.isMergeableConst8())
900    return EightByteConstantSection;
901  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
902    return SixteenByteConstantSection;
903  return ReadOnlySection;  // .const
904}
905
906/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
907/// not to emit the UsedDirective for some symbols in llvm.used.
908// FIXME: REMOVE this (rdar://7071300)
909bool TargetLoweringObjectFileMachO::
910shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
911  /// On Darwin, internally linked data beginning with "L" or "l" does not have
912  /// the directive emitted (this occurs in ObjC metadata).
913  if (!GV) return false;
914
915  // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
916  if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
917    // FIXME: ObjC metadata is currently emitted as internal symbols that have
918    // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
919    // this horrible hack can go away.
920    const std::string &Name = Mang->getMangledName(GV);
921    if (Name[0] == 'L' || Name[0] == 'l')
922      return false;
923  }
924
925  return true;
926}
927
928
929//===----------------------------------------------------------------------===//
930//                                  COFF
931//===----------------------------------------------------------------------===//
932
933typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy;
934
935TargetLoweringObjectFileCOFF::~TargetLoweringObjectFileCOFF() {
936  delete (COFFUniqueMapTy*)UniquingMap;
937}
938
939
940const MCSection *TargetLoweringObjectFileCOFF::
941getCOFFSection(const char *Name, bool isDirective, SectionKind Kind) const {
942  // Create the map if it doesn't already exist.
943  if (UniquingMap == 0)
944    UniquingMap = new MachOUniqueMapTy();
945  COFFUniqueMapTy &Map = *(COFFUniqueMapTy*)UniquingMap;
946
947  // Do the lookup, if we have a hit, return it.
948  const MCSectionCOFF *&Entry = Map[Name];
949  if (Entry) return Entry;
950
951  return Entry = MCSectionCOFF::Create(Name, isDirective, Kind, getContext());
952}
953
954void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
955                                              const TargetMachine &TM) {
956  if (UniquingMap != 0)
957    ((COFFUniqueMapTy*)UniquingMap)->clear();
958  TargetLoweringObjectFile::Initialize(Ctx, TM);
959  TextSection = getCOFFSection("\t.text", true, SectionKind::getText());
960  DataSection = getCOFFSection("\t.data", true, SectionKind::getDataRel());
961  StaticCtorSection =
962    getCOFFSection(".ctors", false, SectionKind::getDataRel());
963  StaticDtorSection =
964    getCOFFSection(".dtors", false, SectionKind::getDataRel());
965
966
967  // Debug info.
968  // FIXME: Don't use 'directive' mode here.
969  DwarfAbbrevSection =
970    getCOFFSection("\t.section\t.debug_abbrev,\"dr\"",
971                   true, SectionKind::getMetadata());
972  DwarfInfoSection =
973    getCOFFSection("\t.section\t.debug_info,\"dr\"",
974                   true, SectionKind::getMetadata());
975  DwarfLineSection =
976    getCOFFSection("\t.section\t.debug_line,\"dr\"",
977                   true, SectionKind::getMetadata());
978  DwarfFrameSection =
979    getCOFFSection("\t.section\t.debug_frame,\"dr\"",
980                   true, SectionKind::getMetadata());
981  DwarfPubNamesSection =
982    getCOFFSection("\t.section\t.debug_pubnames,\"dr\"",
983                   true, SectionKind::getMetadata());
984  DwarfPubTypesSection =
985    getCOFFSection("\t.section\t.debug_pubtypes,\"dr\"",
986                   true, SectionKind::getMetadata());
987  DwarfStrSection =
988    getCOFFSection("\t.section\t.debug_str,\"dr\"",
989                   true, SectionKind::getMetadata());
990  DwarfLocSection =
991    getCOFFSection("\t.section\t.debug_loc,\"dr\"",
992                   true, SectionKind::getMetadata());
993  DwarfARangesSection =
994    getCOFFSection("\t.section\t.debug_aranges,\"dr\"",
995                   true, SectionKind::getMetadata());
996  DwarfRangesSection =
997    getCOFFSection("\t.section\t.debug_ranges,\"dr\"",
998                   true, SectionKind::getMetadata());
999  DwarfMacroInfoSection =
1000    getCOFFSection("\t.section\t.debug_macinfo,\"dr\"",
1001                   true, SectionKind::getMetadata());
1002}
1003
1004const MCSection *TargetLoweringObjectFileCOFF::
1005getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
1006                         Mangler *Mang, const TargetMachine &TM) const {
1007  return getCOFFSection(GV->getSection().c_str(), false, Kind);
1008}
1009
1010static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
1011  if (Kind.isText())
1012    return ".text$linkonce";
1013  if (Kind.isWriteable())
1014    return ".data$linkonce";
1015  return ".rdata$linkonce";
1016}
1017
1018
1019const MCSection *TargetLoweringObjectFileCOFF::
1020SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
1021                       Mangler *Mang, const TargetMachine &TM) const {
1022  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
1023
1024  // If this global is linkonce/weak and the target handles this by emitting it
1025  // into a 'uniqued' section name, create and return the section now.
1026  if (GV->isWeakForLinker()) {
1027    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
1028    std::string Name = Mang->makeNameProper(GV->getNameStr());
1029    return getCOFFSection((Prefix+Name).c_str(), false, Kind);
1030  }
1031
1032  if (Kind.isText())
1033    return getTextSection();
1034
1035  return getDataSection();
1036}
1037
1038