TargetLoweringObjectFile.cpp revision b808588a3a5febe931896b3779d159ba90d836f7 
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, HasCrazyBSS,
302                                      IsExplicit, getContext());
303}
304
305void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
306                                             const TargetMachine &TM) {
307  TargetLoweringObjectFile::Initialize(Ctx, TM);
308
309  BSSSection =
310    getELFSection(".bss", MCSectionELF::SHT_NOBITS,
311                  MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
312                  SectionKind::getBSS());
313
314  TextSection =
315    getELFSection(".text", MCSectionELF::SHT_PROGBITS,
316                  MCSectionELF::SHF_EXECINSTR | MCSectionELF::SHF_ALLOC,
317                  SectionKind::getText());
318
319  DataSection =
320    getELFSection(".data", MCSectionELF::SHT_PROGBITS,
321                  MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
322                  SectionKind::getDataRel());
323
324  ReadOnlySection =
325    getELFSection(".rodata", MCSectionELF::SHT_PROGBITS,
326                  MCSectionELF::SHF_ALLOC,
327                  SectionKind::getReadOnly());
328
329  TLSDataSection =
330    getELFSection(".tdata", MCSectionELF::SHT_PROGBITS,
331                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
332                  MCSectionELF::SHF_WRITE, SectionKind::getThreadData());
333
334  TLSBSSSection =
335    getELFSection(".tbss", MCSectionELF::SHT_NOBITS,
336                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
337                  MCSectionELF::SHF_WRITE, SectionKind::getThreadBSS());
338
339  DataRelSection =
340    getELFSection(".data.rel", MCSectionELF::SHT_PROGBITS,
341                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
342                  SectionKind::getDataRel());
343
344  DataRelLocalSection =
345    getELFSection(".data.rel.local", MCSectionELF::SHT_PROGBITS,
346                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
347                  SectionKind::getDataRelLocal());
348
349  DataRelROSection =
350    getELFSection(".data.rel.ro", MCSectionELF::SHT_PROGBITS,
351                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
352                  SectionKind::getReadOnlyWithRel());
353
354  DataRelROLocalSection =
355    getELFSection(".data.rel.ro.local", MCSectionELF::SHT_PROGBITS,
356                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
357                  SectionKind::getReadOnlyWithRelLocal());
358
359  MergeableConst4Section =
360    getELFSection(".rodata.cst4", MCSectionELF::SHT_PROGBITS,
361                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
362                  SectionKind::getMergeableConst4());
363
364  MergeableConst8Section =
365    getELFSection(".rodata.cst8", MCSectionELF::SHT_PROGBITS,
366                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
367                  SectionKind::getMergeableConst8());
368
369  MergeableConst16Section =
370    getELFSection(".rodata.cst16", MCSectionELF::SHT_PROGBITS,
371                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
372                  SectionKind::getMergeableConst16());
373
374  StaticCtorSection =
375    getELFSection(".ctors", MCSectionELF::SHT_PROGBITS,
376                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
377                  SectionKind::getDataRel());
378
379  StaticDtorSection =
380    getELFSection(".dtors", MCSectionELF::SHT_PROGBITS,
381                  MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
382                  SectionKind::getDataRel());
383
384  // Exception Handling Sections.
385
386  // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
387  // it contains relocatable pointers.  In PIC mode, this is probably a big
388  // runtime hit for C++ apps.  Either the contents of the LSDA need to be
389  // adjusted or this should be a data section.
390  LSDASection =
391    getELFSection(".gcc_except_table", MCSectionELF::SHT_PROGBITS,
392                  MCSectionELF::SHF_ALLOC, SectionKind::getReadOnly());
393  EHFrameSection =
394    getELFSection(".eh_frame", MCSectionELF::SHT_PROGBITS,
395                  MCSectionELF::SHF_ALLOC, SectionKind::getDataRel());
396
397  // Debug Info Sections.
398  DwarfAbbrevSection =
399    getELFSection(".debug_abbrev", MCSectionELF::SHT_PROGBITS, 0,
400                  SectionKind::getMetadata());
401  DwarfInfoSection =
402    getELFSection(".debug_info", MCSectionELF::SHT_PROGBITS, 0,
403                  SectionKind::getMetadata());
404  DwarfLineSection =
405    getELFSection(".debug_line", MCSectionELF::SHT_PROGBITS, 0,
406                  SectionKind::getMetadata());
407  DwarfFrameSection =
408    getELFSection(".debug_frame", MCSectionELF::SHT_PROGBITS, 0,
409                  SectionKind::getMetadata());
410  DwarfPubNamesSection =
411    getELFSection(".debug_pubnames", MCSectionELF::SHT_PROGBITS, 0,
412                  SectionKind::getMetadata());
413  DwarfPubTypesSection =
414    getELFSection(".debug_pubtypes", MCSectionELF::SHT_PROGBITS, 0,
415                  SectionKind::getMetadata());
416  DwarfStrSection =
417    getELFSection(".debug_str", MCSectionELF::SHT_PROGBITS, 0,
418                  SectionKind::getMetadata());
419  DwarfLocSection =
420    getELFSection(".debug_loc", MCSectionELF::SHT_PROGBITS, 0,
421                  SectionKind::getMetadata());
422  DwarfARangesSection =
423    getELFSection(".debug_aranges", MCSectionELF::SHT_PROGBITS, 0,
424                  SectionKind::getMetadata());
425  DwarfRangesSection =
426    getELFSection(".debug_ranges", MCSectionELF::SHT_PROGBITS, 0,
427                  SectionKind::getMetadata());
428  DwarfMacroInfoSection =
429    getELFSection(".debug_macinfo", MCSectionELF::SHT_PROGBITS, 0,
430                  SectionKind::getMetadata());
431}
432
433
434static SectionKind
435getELFKindForNamedSection(const char *Name, SectionKind K) {
436  if (Name[0] != '.') return K;
437
438  // Some lame default implementation based on some magic section names.
439  if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
440      strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
441      strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
442      strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
443    return SectionKind::getBSS();
444
445  if (strcmp(Name, ".tdata") == 0 ||
446      strncmp(Name, ".tdata.", 7) == 0 ||
447      strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
448      strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
449    return SectionKind::getThreadData();
450
451  if (strcmp(Name, ".tbss") == 0 ||
452      strncmp(Name, ".tbss.", 6) == 0 ||
453      strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
454      strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
455    return SectionKind::getThreadBSS();
456
457  return K;
458}
459
460
461static unsigned
462getELFSectionType(const char *Name, SectionKind K) {
463
464  if (strncmp(Name, ".init_array", 11) == 0)
465    return MCSectionELF::SHT_INIT_ARRAY;
466
467  if (strncmp(Name, ".fini_array", 11) == 0)
468    return MCSectionELF::SHT_FINI_ARRAY;
469
470  if (strncmp(Name, ".preinit_array", 14) == 0)
471    return MCSectionELF::SHT_PREINIT_ARRAY;
472
473  if (K.isBSS() || K.isThreadBSS())
474    return MCSectionELF::SHT_NOBITS;
475
476  return MCSectionELF::SHT_PROGBITS;
477}
478
479
480static unsigned
481getELFSectionFlags(SectionKind K) {
482  unsigned Flags = 0;
483
484  if (!K.isMetadata())
485    Flags |= MCSectionELF::SHF_ALLOC;
486
487  if (K.isWriteable())
488    Flags |= MCSectionELF::SHF_WRITE;
489
490  if (K.isThreadLocal())
491    Flags |= MCSectionELF::SHF_TLS;
492
493  // K.isMergeableConst() is left out to honour PR4650
494  if (K.isMergeableCString() || K.isMergeableConst4() ||
495      K.isMergeableConst8() || K.isMergeableConst16())
496    Flags |= MCSectionELF::SHF_MERGE;
497
498  if (K.isMergeableCString())
499    Flags |= MCSectionELF::SHF_STRINGS;
500
501  return Flags;
502}
503
504
505const MCSection *TargetLoweringObjectFileELF::
506getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
507                         Mangler *Mang, const TargetMachine &TM) const {
508  const char *SectionName = GV->getSection().c_str();
509
510  // Infer section flags from the section name if we can.
511  Kind = getELFKindForNamedSection(SectionName, Kind);
512
513  return getELFSection(SectionName,
514                       getELFSectionType(SectionName, Kind),
515                       getELFSectionFlags(Kind), Kind, true);
516}
517
518static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
519  if (Kind.isText())                 return ".gnu.linkonce.t.";
520  if (Kind.isReadOnly())             return ".gnu.linkonce.r.";
521
522  if (Kind.isThreadData())           return ".gnu.linkonce.td.";
523  if (Kind.isThreadBSS())            return ".gnu.linkonce.tb.";
524
525  if (Kind.isBSS())                  return ".gnu.linkonce.b.";
526  if (Kind.isDataNoRel())            return ".gnu.linkonce.d.";
527  if (Kind.isDataRelLocal())         return ".gnu.linkonce.d.rel.local.";
528  if (Kind.isDataRel())              return ".gnu.linkonce.d.rel.";
529  if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
530
531  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
532  return ".gnu.linkonce.d.rel.ro.";
533}
534
535const MCSection *TargetLoweringObjectFileELF::
536SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
537                       Mangler *Mang, const TargetMachine &TM) const {
538
539  // If this global is linkonce/weak and the target handles this by emitting it
540  // into a 'uniqued' section name, create and return the section now.
541  if (GV->isWeakForLinker()) {
542    const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
543    std::string Name = Mang->makeNameProper(GV->getNameStr());
544
545    return getELFSection((Prefix+Name).c_str(),
546                         getELFSectionType((Prefix+Name).c_str(), Kind),
547                         getELFSectionFlags(Kind),
548                         Kind);
549  }
550
551  if (Kind.isText()) return TextSection;
552
553  if (Kind.isMergeable1ByteCString() ||
554      Kind.isMergeable2ByteCString() ||
555      Kind.isMergeable4ByteCString()) {
556
557    // We also need alignment here.
558    // FIXME: this is getting the alignment of the character, not the
559    // alignment of the global!
560    unsigned Align =
561      TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
562
563    const char *SizeSpec = ".rodata.str1.";
564    if (Kind.isMergeable2ByteCString())
565      SizeSpec = ".rodata.str2.";
566    else if (Kind.isMergeable4ByteCString())
567      SizeSpec = ".rodata.str4.";
568    else
569      assert(Kind.isMergeable1ByteCString() && "unknown string width");
570
571
572    std::string Name = SizeSpec + utostr(Align);
573    return getELFSection(Name.c_str(), MCSectionELF::SHT_PROGBITS,
574                         MCSectionELF::SHF_ALLOC |
575                         MCSectionELF::SHF_MERGE |
576                         MCSectionELF::SHF_STRINGS,
577                         Kind);
578  }
579
580  if (Kind.isMergeableConst()) {
581    if (Kind.isMergeableConst4())
582      return MergeableConst4Section;
583    if (Kind.isMergeableConst8())
584      return MergeableConst8Section;
585    if (Kind.isMergeableConst16())
586      return MergeableConst16Section;
587    return ReadOnlySection;  // .const
588  }
589
590  if (Kind.isReadOnly())             return ReadOnlySection;
591
592  if (Kind.isThreadData())           return TLSDataSection;
593  if (Kind.isThreadBSS())            return TLSBSSSection;
594
595  if (Kind.isBSS())                  return BSSSection;
596
597  if (Kind.isDataNoRel())            return DataSection;
598  if (Kind.isDataRelLocal())         return DataRelLocalSection;
599  if (Kind.isDataRel())              return DataRelSection;
600  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
601
602  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
603  return DataRelROSection;
604}
605
606/// getSectionForConstant - Given a mergeable constant with the
607/// specified size and relocation information, return a section that it
608/// should be placed in.
609const MCSection *TargetLoweringObjectFileELF::
610getSectionForConstant(SectionKind Kind) const {
611  if (Kind.isMergeableConst4())
612    return MergeableConst4Section;
613  if (Kind.isMergeableConst8())
614    return MergeableConst8Section;
615  if (Kind.isMergeableConst16())
616    return MergeableConst16Section;
617  if (Kind.isReadOnly())
618    return ReadOnlySection;
619
620  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
621  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
622  return DataRelROSection;
623}
624
625//===----------------------------------------------------------------------===//
626//                                 MachO
627//===----------------------------------------------------------------------===//
628
629typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy;
630
631TargetLoweringObjectFileMachO::~TargetLoweringObjectFileMachO() {
632  // If we have the MachO uniquing map, free it.
633  delete (MachOUniqueMapTy*)UniquingMap;
634}
635
636
637const MCSectionMachO *TargetLoweringObjectFileMachO::
638getMachOSection(const StringRef &Segment, const StringRef &Section,
639                unsigned TypeAndAttributes,
640                unsigned Reserved2, SectionKind Kind) const {
641  // We unique sections by their segment/section pair.  The returned section
642  // may not have the same flags as the requested section, if so this should be
643  // diagnosed by the client as an error.
644
645  // Create the map if it doesn't already exist.
646  if (UniquingMap == 0)
647    UniquingMap = new MachOUniqueMapTy();
648  MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)UniquingMap;
649
650  // Form the name to look up.
651  SmallString<64> Name;
652  Name.append(Segment.begin(), Segment.end());
653  Name.push_back(',');
654  Name.append(Section.begin(), Section.end());
655
656  // Do the lookup, if we have a hit, return it.
657  const MCSectionMachO *&Entry = Map[StringRef(Name.data(), Name.size())];
658  if (Entry) return Entry;
659
660  // Otherwise, return a new section.
661  return Entry = MCSectionMachO::Create(Segment, Section, TypeAndAttributes,
662                                        Reserved2, Kind, getContext());
663}
664
665
666void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
667                                               const TargetMachine &TM) {
668  TargetLoweringObjectFile::Initialize(Ctx, TM);
669
670  TextSection // .text
671    = getMachOSection("__TEXT", "__text",
672                      MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
673                      SectionKind::getText());
674  DataSection // .data
675    = getMachOSection("__DATA", "__data", 0, SectionKind::getDataRel());
676
677  CStringSection // .cstring
678    = getMachOSection("__TEXT", "__cstring", MCSectionMachO::S_CSTRING_LITERALS,
679                      SectionKind::getMergeable1ByteCString());
680  UStringSection
681    = getMachOSection("__TEXT","__ustring", 0,
682                      SectionKind::getMergeable2ByteCString());
683  FourByteConstantSection // .literal4
684    = getMachOSection("__TEXT", "__literal4", MCSectionMachO::S_4BYTE_LITERALS,
685                      SectionKind::getMergeableConst4());
686  EightByteConstantSection // .literal8
687    = getMachOSection("__TEXT", "__literal8", MCSectionMachO::S_8BYTE_LITERALS,
688                      SectionKind::getMergeableConst8());
689
690  // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
691  // to using it in -static mode.
692  SixteenByteConstantSection = 0;
693  if (TM.getRelocationModel() != Reloc::Static &&
694      TM.getTargetData()->getPointerSize() == 32)
695    SixteenByteConstantSection =   // .literal16
696      getMachOSection("__TEXT", "__literal16",MCSectionMachO::S_16BYTE_LITERALS,
697                      SectionKind::getMergeableConst16());
698
699  ReadOnlySection  // .const
700    = getMachOSection("__TEXT", "__const", 0, SectionKind::getReadOnly());
701
702  TextCoalSection
703    = getMachOSection("__TEXT", "__textcoal_nt",
704                      MCSectionMachO::S_COALESCED |
705                      MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
706                      SectionKind::getText());
707  ConstTextCoalSection
708    = getMachOSection("__TEXT", "__const_coal", MCSectionMachO::S_COALESCED,
709                      SectionKind::getText());
710  ConstDataCoalSection
711    = getMachOSection("__DATA","__const_coal", MCSectionMachO::S_COALESCED,
712                      SectionKind::getText());
713  ConstDataSection  // .const_data
714    = getMachOSection("__DATA", "__const", 0,
715                      SectionKind::getReadOnlyWithRel());
716  DataCoalSection
717    = getMachOSection("__DATA","__datacoal_nt", MCSectionMachO::S_COALESCED,
718                      SectionKind::getDataRel());
719
720
721  LazySymbolPointerSection
722    = getMachOSection("__DATA", "__la_symbol_ptr",
723                      MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
724                      SectionKind::getMetadata());
725  NonLazySymbolPointerSection
726    = getMachOSection("__DATA", "__nl_symbol_ptr",
727                      MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
728                      SectionKind::getMetadata());
729
730  if (TM.getRelocationModel() == Reloc::Static) {
731    StaticCtorSection
732      = getMachOSection("__TEXT", "__constructor", 0,SectionKind::getDataRel());
733    StaticDtorSection
734      = getMachOSection("__TEXT", "__destructor", 0, SectionKind::getDataRel());
735  } else {
736    StaticCtorSection
737      = getMachOSection("__DATA", "__mod_init_func",
738                        MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
739                        SectionKind::getDataRel());
740    StaticDtorSection
741      = getMachOSection("__DATA", "__mod_term_func",
742                        MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
743                        SectionKind::getDataRel());
744  }
745
746  // Exception Handling.
747  LSDASection = getMachOSection("__DATA", "__gcc_except_tab", 0,
748                                SectionKind::getDataRel());
749  EHFrameSection =
750    getMachOSection("__TEXT", "__eh_frame",
751                    MCSectionMachO::S_COALESCED |
752                    MCSectionMachO::S_ATTR_NO_TOC |
753                    MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
754                    MCSectionMachO::S_ATTR_LIVE_SUPPORT,
755                    SectionKind::getReadOnly());
756
757  // Debug Information.
758  DwarfAbbrevSection =
759    getMachOSection("__DWARF", "__debug_abbrev", MCSectionMachO::S_ATTR_DEBUG,
760                    SectionKind::getMetadata());
761  DwarfInfoSection =
762    getMachOSection("__DWARF", "__debug_info", MCSectionMachO::S_ATTR_DEBUG,
763                    SectionKind::getMetadata());
764  DwarfLineSection =
765    getMachOSection("__DWARF", "__debug_line", MCSectionMachO::S_ATTR_DEBUG,
766                    SectionKind::getMetadata());
767  DwarfFrameSection =
768    getMachOSection("__DWARF", "__debug_frame", MCSectionMachO::S_ATTR_DEBUG,
769                    SectionKind::getMetadata());
770  DwarfPubNamesSection =
771    getMachOSection("__DWARF", "__debug_pubnames", MCSectionMachO::S_ATTR_DEBUG,
772                    SectionKind::getMetadata());
773  DwarfPubTypesSection =
774    getMachOSection("__DWARF", "__debug_pubtypes", MCSectionMachO::S_ATTR_DEBUG,
775                    SectionKind::getMetadata());
776  DwarfStrSection =
777    getMachOSection("__DWARF", "__debug_str", MCSectionMachO::S_ATTR_DEBUG,
778                    SectionKind::getMetadata());
779  DwarfLocSection =
780    getMachOSection("__DWARF", "__debug_loc", MCSectionMachO::S_ATTR_DEBUG,
781                    SectionKind::getMetadata());
782  DwarfARangesSection =
783    getMachOSection("__DWARF", "__debug_aranges", MCSectionMachO::S_ATTR_DEBUG,
784                    SectionKind::getMetadata());
785  DwarfRangesSection =
786    getMachOSection("__DWARF", "__debug_ranges", MCSectionMachO::S_ATTR_DEBUG,
787                    SectionKind::getMetadata());
788  DwarfMacroInfoSection =
789    getMachOSection("__DWARF", "__debug_macinfo", MCSectionMachO::S_ATTR_DEBUG,
790                    SectionKind::getMetadata());
791  DwarfDebugInlineSection =
792    getMachOSection("__DWARF", "__debug_inlined", MCSectionMachO::S_ATTR_DEBUG,
793                    SectionKind::getMetadata());
794}
795
796const MCSection *TargetLoweringObjectFileMachO::
797getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
798                         Mangler *Mang, const TargetMachine &TM) const {
799  // Parse the section specifier and create it if valid.
800  StringRef Segment, Section;
801  unsigned TAA, StubSize;
802  std::string ErrorCode =
803    MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
804                                          TAA, StubSize);
805  if (!ErrorCode.empty()) {
806    // If invalid, report the error with llvm_report_error.
807    llvm_report_error("Global variable '" + GV->getNameStr() +
808                      "' has an invalid section specifier '" + GV->getSection()+
809                      "': " + ErrorCode + ".");
810    // Fall back to dropping it into the data section.
811    return DataSection;
812  }
813
814  // Get the section.
815  const MCSectionMachO *S =
816    getMachOSection(Segment, Section, TAA, StubSize, Kind);
817
818  // Okay, now that we got the section, verify that the TAA & StubSize agree.
819  // If the user declared multiple globals with different section flags, we need
820  // to reject it here.
821  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
822    // If invalid, report the error with llvm_report_error.
823    llvm_report_error("Global variable '" + GV->getNameStr() +
824                      "' section type or attributes does not match previous"
825                      " section specifier");
826  }
827
828  return S;
829}
830
831const MCSection *TargetLoweringObjectFileMachO::
832SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
833                       Mangler *Mang, const TargetMachine &TM) const {
834  assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
835
836  if (Kind.isText())
837    return GV->isWeakForLinker() ? TextCoalSection : TextSection;
838
839  // If this is weak/linkonce, put this in a coalescable section, either in text
840  // or data depending on if it is writable.
841  if (GV->isWeakForLinker()) {
842    if (Kind.isReadOnly())
843      return ConstTextCoalSection;
844    return DataCoalSection;
845  }
846
847  // FIXME: Alignment check should be handled by section classifier.
848  if (Kind.isMergeable1ByteCString() ||
849      Kind.isMergeable2ByteCString()) {
850    if (TM.getTargetData()->getPreferredAlignment(
851                                              cast<GlobalVariable>(GV)) < 32) {
852      if (Kind.isMergeable1ByteCString())
853        return CStringSection;
854      assert(Kind.isMergeable2ByteCString());
855      return UStringSection;
856    }
857  }
858
859  if (Kind.isMergeableConst()) {
860    if (Kind.isMergeableConst4())
861      return FourByteConstantSection;
862    if (Kind.isMergeableConst8())
863      return EightByteConstantSection;
864    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
865      return SixteenByteConstantSection;
866  }
867
868  // Otherwise, if it is readonly, but not something we can specially optimize,
869  // just drop it in .const.
870  if (Kind.isReadOnly())
871    return ReadOnlySection;
872
873  // If this is marked const, put it into a const section.  But if the dynamic
874  // linker needs to write to it, put it in the data segment.
875  if (Kind.isReadOnlyWithRel())
876    return ConstDataSection;
877
878  // Otherwise, just drop the variable in the normal data section.
879  return DataSection;
880}
881
882const MCSection *
883TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
884  // If this constant requires a relocation, we have to put it in the data
885  // segment, not in the text segment.
886  if (Kind.isDataRel())
887    return ConstDataSection;
888
889  if (Kind.isMergeableConst4())
890    return FourByteConstantSection;
891  if (Kind.isMergeableConst8())
892    return EightByteConstantSection;
893  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
894    return SixteenByteConstantSection;
895  return ReadOnlySection;  // .const
896}
897
898/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
899/// not to emit the UsedDirective for some symbols in llvm.used.
900// FIXME: REMOVE this (rdar://7071300)
901bool TargetLoweringObjectFileMachO::
902shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
903  /// On Darwin, internally linked data beginning with "L" or "l" does not have
904  /// the directive emitted (this occurs in ObjC metadata).
905  if (!GV) return false;
906
907  // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
908  if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
909    // FIXME: ObjC metadata is currently emitted as internal symbols that have
910    // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
911    // this horrible hack can go away.
912    const std::string &Name = Mang->getMangledName(GV);
913    if (Name[0] == 'L' || Name[0] == 'l')
914      return false;
915  }
916
917  return true;
918}
919
920
921//===----------------------------------------------------------------------===//
922//                                  COFF
923//===----------------------------------------------------------------------===//
924
925typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy;
926
927TargetLoweringObjectFileCOFF::~TargetLoweringObjectFileCOFF() {
928  delete (COFFUniqueMapTy*)UniquingMap;
929}
930
931
932const MCSection *TargetLoweringObjectFileCOFF::
933getCOFFSection(const char *Name, bool isDirective, SectionKind Kind) const {
934  // Create the map if it doesn't already exist.
935  if (UniquingMap == 0)
936    UniquingMap = new MachOUniqueMapTy();
937  COFFUniqueMapTy &Map = *(COFFUniqueMapTy*)UniquingMap;
938
939  // Do the lookup, if we have a hit, return it.
940  const MCSectionCOFF *&Entry = Map[Name];
941  if (Entry) return Entry;
942
943  return Entry = MCSectionCOFF::Create(Name, isDirective, Kind, getContext());
944}
945
946void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
947                                              const TargetMachine &TM) {
948  TargetLoweringObjectFile::Initialize(Ctx, TM);
949  TextSection = getCOFFSection("\t.text", true, SectionKind::getText());
950  DataSection = getCOFFSection("\t.data", true, SectionKind::getDataRel());
951  StaticCtorSection =
952    getCOFFSection(".ctors", false, SectionKind::getDataRel());
953  StaticDtorSection =
954    getCOFFSection(".dtors", false, SectionKind::getDataRel());
955
956
957  // Debug info.
958  // FIXME: Don't use 'directive' mode here.
959  DwarfAbbrevSection =
960    getCOFFSection("\t.section\t.debug_abbrev,\"dr\"",
961                   true, SectionKind::getMetadata());
962  DwarfInfoSection =
963    getCOFFSection("\t.section\t.debug_info,\"dr\"",
964                   true, SectionKind::getMetadata());
965  DwarfLineSection =
966    getCOFFSection("\t.section\t.debug_line,\"dr\"",
967                   true, SectionKind::getMetadata());
968  DwarfFrameSection =
969    getCOFFSection("\t.section\t.debug_frame,\"dr\"",
970                   true, SectionKind::getMetadata());
971  DwarfPubNamesSection =
972    getCOFFSection("\t.section\t.debug_pubnames,\"dr\"",
973                   true, SectionKind::getMetadata());
974  DwarfPubTypesSection =
975    getCOFFSection("\t.section\t.debug_pubtypes,\"dr\"",
976                   true, SectionKind::getMetadata());
977  DwarfStrSection =
978    getCOFFSection("\t.section\t.debug_str,\"dr\"",
979                   true, SectionKind::getMetadata());
980  DwarfLocSection =
981    getCOFFSection("\t.section\t.debug_loc,\"dr\"",
982                   true, SectionKind::getMetadata());
983  DwarfARangesSection =
984    getCOFFSection("\t.section\t.debug_aranges,\"dr\"",
985                   true, SectionKind::getMetadata());
986  DwarfRangesSection =
987    getCOFFSection("\t.section\t.debug_ranges,\"dr\"",
988                   true, SectionKind::getMetadata());
989  DwarfMacroInfoSection =
990    getCOFFSection("\t.section\t.debug_macinfo,\"dr\"",
991                   true, SectionKind::getMetadata());
992}
993
994const MCSection *TargetLoweringObjectFileCOFF::
995getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
996                         Mangler *Mang, const TargetMachine &TM) const {
997  return getCOFFSection(GV->getSection().c_str(), false, Kind);
998}
999
1000static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
1001  if (Kind.isText())
1002    return ".text$linkonce";
1003  if (Kind.isWriteable())
1004    return ".data$linkonce";
1005  return ".rdata$linkonce";
1006}
1007
1008
1009const MCSection *TargetLoweringObjectFileCOFF::
1010SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
1011                       Mangler *Mang, const TargetMachine &TM) const {
1012  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
1013
1014  // If this global is linkonce/weak and the target handles this by emitting it
1015  // into a 'uniqued' section name, create and return the section now.
1016  if (GV->isWeakForLinker()) {
1017    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
1018    std::string Name = Mang->makeNameProper(GV->getNameStr());
1019    return getCOFFSection((Prefix+Name).c_str(), false, Kind);
1020  }
1021
1022  if (Kind.isText())
1023    return getTextSection();
1024
1025  return getDataSection();
1026}
1027
1028