TargetLoweringObjectFile.cpp revision 4bb253c60f895131371aa2ad1bfa5a2bea213f78 
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/Target/TargetMachine.h"
20#include "llvm/Target/TargetData.h"
21#include "llvm/Target/TargetOptions.h"
22#include "llvm/ADT/StringExtras.h"
23using namespace llvm;
24
25//===----------------------------------------------------------------------===//
26//                              Generic Code
27//===----------------------------------------------------------------------===//
28
29TargetLoweringObjectFile::TargetLoweringObjectFile() {
30  TextSection = 0;
31  DataSection = 0;
32  BSSSection_ = 0;
33  ReadOnlySection = 0;
34  TLSDataSection = 0;
35  TLSBSSSection = 0;
36  CStringSection_ = 0;
37}
38
39TargetLoweringObjectFile::~TargetLoweringObjectFile() {
40}
41
42static bool isSuitableForBSS(const GlobalVariable *GV) {
43  Constant *C = GV->getInitializer();
44
45  // Must have zero initializer.
46  if (!C->isNullValue())
47    return false;
48
49  // Leave constant zeros in readonly constant sections, so they can be shared.
50  if (GV->isConstant())
51    return false;
52
53  // If the global has an explicit section specified, don't put it in BSS.
54  if (!GV->getSection().empty())
55    return false;
56
57  // If -nozero-initialized-in-bss is specified, don't ever use BSS.
58  if (NoZerosInBSS)
59    return false;
60
61  // Otherwise, put it in BSS!
62  return true;
63}
64
65static bool isConstantString(const Constant *C) {
66  // First check: is we have constant array of i8 terminated with zero
67  const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
68  // Check, if initializer is a null-terminated string
69  if (CVA && CVA->isCString())
70    return true;
71
72  // Another possibility: [1 x i8] zeroinitializer
73  if (isa<ConstantAggregateZero>(C))
74    if (const ArrayType *Ty = dyn_cast<ArrayType>(C->getType()))
75      return (Ty->getElementType() == Type::Int8Ty &&
76              Ty->getNumElements() == 1);
77
78  return false;
79}
80
81static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
82                                              const TargetMachine &TM) {
83  Reloc::Model ReloModel = TM.getRelocationModel();
84
85  // Early exit - functions should be always in text sections.
86  const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
87  if (GVar == 0)
88    return SectionKind::Text;
89
90
91  // Handle thread-local data first.
92  if (GVar->isThreadLocal()) {
93    if (isSuitableForBSS(GVar))
94      return SectionKind::ThreadBSS;
95    return SectionKind::ThreadData;
96  }
97
98  // Variable can be easily put to BSS section.
99  if (isSuitableForBSS(GVar))
100    return SectionKind::BSS;
101
102  Constant *C = GVar->getInitializer();
103
104  // If the global is marked constant, we can put it into a mergable section,
105  // a mergable string section, or general .data if it contains relocations.
106  if (GVar->isConstant()) {
107    // If the initializer for the global contains something that requires a
108    // relocation, then we may have to drop this into a wriable data section
109    // even though it is marked const.
110    switch (C->getRelocationInfo()) {
111    default: llvm_unreachable("unknown relocation info kind");
112    case Constant::NoRelocation:
113      // If initializer is a null-terminated string, put it in a "cstring"
114      // section if the target has it.
115      if (isConstantString(C))
116        return SectionKind::MergeableCString;
117
118      // Otherwise, just drop it into a mergable constant section.  If we have
119      // a section for this size, use it, otherwise use the arbitrary sized
120      // mergable section.
121      switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
122      case 4:  return SectionKind::MergeableConst4;
123      case 8:  return SectionKind::MergeableConst8;
124      case 16: return SectionKind::MergeableConst16;
125      default: return SectionKind::MergeableConst;
126      }
127
128    case Constant::LocalRelocation:
129      // In static relocation model, the linker will resolve all addresses, so
130      // the relocation entries will actually be constants by the time the app
131      // starts up.  However, we can't put this into a mergable section, because
132      // the linker doesn't take relocations into consideration when it tries to
133      // merge entries in the section.
134      if (ReloModel == Reloc::Static)
135        return SectionKind::ReadOnly;
136
137      // Otherwise, the dynamic linker needs to fix it up, put it in the
138      // writable data.rel.local section.
139      return SectionKind::ReadOnlyWithRelLocal;
140
141    case Constant::GlobalRelocations:
142      // In static relocation model, the linker will resolve all addresses, so
143      // the relocation entries will actually be constants by the time the app
144      // starts up.  However, we can't put this into a mergable section, because
145      // the linker doesn't take relocations into consideration when it tries to
146      // merge entries in the section.
147      if (ReloModel == Reloc::Static)
148        return SectionKind::ReadOnly;
149
150      // Otherwise, the dynamic linker needs to fix it up, put it in the
151      // writable data.rel section.
152      return SectionKind::ReadOnlyWithRel;
153    }
154  }
155
156  // Okay, this isn't a constant.  If the initializer for the global is going
157  // to require a runtime relocation by the dynamic linker, put it into a more
158  // specific section to improve startup time of the app.  This coalesces these
159  // globals together onto fewer pages, improving the locality of the dynamic
160  // linker.
161  if (ReloModel == Reloc::Static)
162    return SectionKind::DataNoRel;
163
164  switch (C->getRelocationInfo()) {
165  default: llvm_unreachable("unknown relocation info kind");
166  case Constant::NoRelocation:
167    return SectionKind::DataNoRel;
168  case Constant::LocalRelocation:
169    return SectionKind::DataRelLocal;
170  case Constant::GlobalRelocations:
171    return SectionKind::DataRel;
172  }
173}
174
175/// SectionForGlobal - This method computes the appropriate section to emit
176/// the specified global variable or function definition.  This should not
177/// be passed external (or available externally) globals.
178const Section *TargetLoweringObjectFile::
179SectionForGlobal(const GlobalValue *GV, const TargetMachine &TM) const {
180  assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
181         "Can only be used for global definitions");
182
183  SectionKind::Kind GVKind = SectionKindForGlobal(GV, TM);
184
185  SectionKind Kind = SectionKind::get(GVKind, GV->isWeakForLinker(),
186                                      GV->hasSection());
187
188
189  // Select section name.
190  if (GV->hasSection()) {
191    // If the target has special section hacks for specifically named globals,
192    // return them now.
193    if (const Section *TS = getSpecialCasedSectionGlobals(GV, Kind))
194      return TS;
195
196    // If the target has magic semantics for certain section names, make sure to
197    // pick up the flags.  This allows the user to write things with attribute
198    // section and still get the appropriate section flags printed.
199    GVKind = getKindForNamedSection(GV->getSection().c_str(), GVKind);
200
201    return getOrCreateSection(GV->getSection().c_str(), false, GVKind);
202  }
203
204
205  // Use default section depending on the 'type' of global
206  return SelectSectionForGlobal(GV, Kind, TM);
207}
208
209// Lame default implementation. Calculate the section name for global.
210const Section*
211TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
212                                                 SectionKind Kind,
213                                                 const TargetMachine &TM) const{
214  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
215
216  if (Kind.isText())
217    return getTextSection();
218
219  if (Kind.isBSS() && BSSSection_ != 0)
220    return BSSSection_;
221
222  if (Kind.isReadOnly() && ReadOnlySection != 0)
223    return ReadOnlySection;
224
225  return getDataSection();
226}
227
228/// getSectionForMergableConstant - Given a mergable constant with the
229/// specified size and relocation information, return a section that it
230/// should be placed in.
231const Section *
232TargetLoweringObjectFile::
233getSectionForMergeableConstant(SectionKind Kind) const {
234  if (Kind.isReadOnly() && ReadOnlySection != 0)
235    return ReadOnlySection;
236
237  return DataSection;
238}
239
240
241const Section *TargetLoweringObjectFile::
242getOrCreateSection(const char *Name, bool isDirective,
243                   SectionKind::Kind Kind) const {
244  Section &S = Sections[Name];
245
246  // This is newly-created section, set it up properly.
247  if (S.Name.empty()) {
248    S.Kind = SectionKind::get(Kind, false /*weak*/, !isDirective);
249    S.Name = Name;
250  }
251
252  return &S;
253}
254
255
256
257//===----------------------------------------------------------------------===//
258//                                  ELF
259//===----------------------------------------------------------------------===//
260
261TargetLoweringObjectFileELF::TargetLoweringObjectFileELF(bool atIsCommentChar,
262                                                         bool HasCrazyBSS)
263  : AtIsCommentChar(atIsCommentChar) {
264
265  if (!HasCrazyBSS)
266    BSSSection_ = getOrCreateSection("\t.bss", true, SectionKind::BSS);
267  else
268    // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
269    // FIXME: Does .section .bss work everywhere??
270    BSSSection_ = getOrCreateSection("\t.bss", false, SectionKind::BSS);
271
272
273  TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
274  DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
275  ReadOnlySection =
276    getOrCreateSection("\t.rodata", false, SectionKind::ReadOnly);
277  TLSDataSection =
278    getOrCreateSection("\t.tdata", false, SectionKind::ThreadData);
279  CStringSection_ = getOrCreateSection("\t.rodata.str", true,
280                                       SectionKind::MergeableCString);
281
282  TLSBSSSection = getOrCreateSection("\t.tbss", false, SectionKind::ThreadBSS);
283
284  DataRelSection = getOrCreateSection("\t.data.rel", false,
285                                      SectionKind::DataRel);
286  DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
287                                           SectionKind::DataRelLocal);
288  DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
289                                        SectionKind::ReadOnlyWithRel);
290  DataRelROLocalSection =
291    getOrCreateSection("\t.data.rel.ro.local", false,
292                       SectionKind::ReadOnlyWithRelLocal);
293
294  MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
295                                              SectionKind::MergeableConst4);
296  MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
297                                              SectionKind::MergeableConst8);
298  MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
299                                               SectionKind::MergeableConst16);
300}
301
302
303SectionKind::Kind TargetLoweringObjectFileELF::
304getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
305  if (Name[0] != '.') return K;
306
307  // Some lame default implementation based on some magic section names.
308  if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
309      strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
310      strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
311      strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
312    return SectionKind::BSS;
313
314  if (strcmp(Name, ".tdata") == 0 ||
315      strncmp(Name, ".tdata.", 7) == 0 ||
316      strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
317      strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
318    return SectionKind::ThreadData;
319
320  if (strcmp(Name, ".tbss") == 0 ||
321      strncmp(Name, ".tbss.", 6) == 0 ||
322      strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
323      strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
324    return SectionKind::ThreadBSS;
325
326  return K;
327}
328
329void TargetLoweringObjectFileELF::
330getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
331  Str.push_back(',');
332  Str.push_back('"');
333
334  if (!Kind.isMetadata())
335    Str.push_back('a');
336  if (Kind.isText())
337    Str.push_back('x');
338  if (Kind.isWriteable())
339    Str.push_back('w');
340  if (Kind.isMergeableConst() || Kind.isMergeableCString())
341    Str.push_back('M');
342  if (Kind.isMergeableCString())
343    Str.push_back('S');
344  if (Kind.isThreadLocal())
345    Str.push_back('T');
346
347  Str.push_back('"');
348  Str.push_back(',');
349
350  // If comment string is '@', e.g. as on ARM - use '%' instead
351  if (AtIsCommentChar)
352    Str.push_back('%');
353  else
354    Str.push_back('@');
355
356  const char *KindStr;
357  if (Kind.isBSS())
358    KindStr = "nobits";
359  else
360    KindStr = "progbits";
361
362  Str.append(KindStr, KindStr+strlen(KindStr));
363
364  if (Kind.isMergeableCString()) {
365    // TODO: Eventually handle multiple byte character strings.  For now, all
366    // mergable C strings are single byte.
367    Str.push_back(',');
368    Str.push_back('1');
369  } else if (Kind.isMergeableConst4()) {
370    Str.push_back(',');
371    Str.push_back('4');
372  } else if (Kind.isMergeableConst8()) {
373    Str.push_back(',');
374    Str.push_back('8');
375  } else if (Kind.isMergeableConst16()) {
376    Str.push_back(',');
377    Str.push_back('1');
378    Str.push_back('6');
379  }
380}
381
382
383static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
384  if (Kind.isText())                 return ".gnu.linkonce.t.";
385  if (Kind.isReadOnly())             return ".gnu.linkonce.r.";
386
387  if (Kind.isThreadData())           return ".gnu.linkonce.td.";
388  if (Kind.isThreadBSS())            return ".gnu.linkonce.tb.";
389
390  if (Kind.isBSS())                  return ".gnu.linkonce.b.";
391  if (Kind.isDataNoRel())            return ".gnu.linkonce.d.";
392  if (Kind.isDataRelLocal())         return ".gnu.linkonce.d.rel.local.";
393  if (Kind.isDataRel())              return ".gnu.linkonce.d.rel.";
394  if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
395
396  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
397  return ".gnu.linkonce.d.rel.ro.";
398}
399
400const Section *TargetLoweringObjectFileELF::
401SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
402                       const TargetMachine &TM) const {
403
404  // If this global is linkonce/weak and the target handles this by emitting it
405  // into a 'uniqued' section name, create and return the section now.
406  if (Kind.isWeak()) {
407    const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
408    // FIXME: Use mangler interface (PR4584).
409    std::string Name = Prefix+GV->getNameStr();
410    return getOrCreateSection(Name.c_str(), false, Kind.getKind());
411  }
412
413  if (Kind.isText()) return TextSection;
414  if (Kind.isMergeableCString()) {
415    //Constant *C = cast<GlobalVariable>(GV)->getInitializer();
416
417    // FIXME: This is completely wrong.  Why is it comparing the size of the
418    // character type to 1?
419    /// cast<ArrayType>(C->getType())->getNumElements();
420    uint64_t Size = 1;
421    if (Size <= 16) {
422      assert(CStringSection_ && "Should have string section prefix");
423
424      // We also need alignment here.
425      // FIXME: this is getting the alignment of the character, not the
426      // alignment of the global!
427      unsigned Align =
428        TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
429
430      std::string Name = CStringSection_->getName() + utostr(Size) + '.' +
431      utostr(Align);
432      return getOrCreateSection(Name.c_str(), false,
433                                SectionKind::MergeableCString);
434    }
435
436    return ReadOnlySection;
437  }
438
439  if (Kind.isMergeableConst()) {
440    if (Kind.isMergeableConst4())
441      return MergeableConst4Section;
442    if (Kind.isMergeableConst8())
443      return MergeableConst8Section;
444    if (Kind.isMergeableConst16())
445      return MergeableConst16Section;
446    return ReadOnlySection;  // .const
447  }
448
449  if (Kind.isReadOnly())             return ReadOnlySection;
450
451  if (Kind.isThreadData())           return TLSDataSection;
452  if (Kind.isThreadBSS())            return TLSBSSSection;
453
454  if (Kind.isBSS())                  return BSSSection_;
455
456  if (Kind.isDataNoRel())            return DataSection;
457  if (Kind.isDataRelLocal())         return DataRelLocalSection;
458  if (Kind.isDataRel())              return DataRelSection;
459  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
460
461  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
462  return DataRelROSection;
463}
464
465/// getSectionForMergeableConstant - Given a mergeable constant with the
466/// specified size and relocation information, return a section that it
467/// should be placed in.
468const Section *TargetLoweringObjectFileELF::
469getSectionForMergeableConstant(SectionKind Kind) const {
470  if (Kind.isMergeableConst4())
471    return MergeableConst4Section;
472  if (Kind.isMergeableConst8())
473    return MergeableConst8Section;
474  if (Kind.isMergeableConst16())
475    return MergeableConst16Section;
476  if (Kind.isReadOnly())
477    return ReadOnlySection;
478
479  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
480  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
481  return DataRelROSection;
482}
483
484//===----------------------------------------------------------------------===//
485//                                 MachO
486//===----------------------------------------------------------------------===//
487
488TargetLoweringObjectFileMachO::
489TargetLoweringObjectFileMachO(const TargetMachine &TM) {
490  TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
491  DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
492
493  CStringSection_ = getOrCreateSection("\t.cstring", true,
494                                       SectionKind::MergeableCString);
495  FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
496                                               SectionKind::MergeableConst4);
497  EightByteConstantSection = getOrCreateSection("\t.literal8\n", true,
498                                                SectionKind::MergeableConst8);
499
500  // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
501  // to using it in -static mode.
502  if (TM.getRelocationModel() != Reloc::Static &&
503      TM.getTargetData()->getPointerSize() == 32)
504    SixteenByteConstantSection =
505      getOrCreateSection("\t.literal16\n", true, SectionKind::MergeableConst16);
506  else
507    SixteenByteConstantSection = 0;
508
509  ReadOnlySection = getOrCreateSection("\t.const", true, SectionKind::ReadOnly);
510
511  TextCoalSection =
512  getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
513                     false, SectionKind::Text);
514  ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
515                                            false, SectionKind::Text);
516  ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
517                                            false, SectionKind::Text);
518  ConstDataSection = getOrCreateSection("\t.const_data", true,
519                                        SectionKind::ReadOnlyWithRel);
520  DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
521                                       false, SectionKind::DataRel);
522}
523
524const Section *
525TargetLoweringObjectFileMachO::SelectSectionForGlobal(const GlobalValue *GV,
526                                                      SectionKind Kind,
527                                                const TargetMachine &TM) const {
528  assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
529
530  if (Kind.isText())
531    return Kind.isWeak() ? TextCoalSection : TextSection;
532
533  // If this is weak/linkonce, put this in a coalescable section, either in text
534  // or data depending on if it is writable.
535  if (Kind.isWeak()) {
536    if (Kind.isReadOnly())
537      return ConstTextCoalSection;
538    return DataCoalSection;
539  }
540
541  // FIXME: Alignment check should be handled by section classifier.
542  if (Kind.isMergeableCString()) {
543    Constant *C = cast<GlobalVariable>(GV)->getInitializer();
544    const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
545    const TargetData &TD = *TM.getTargetData();
546    unsigned Size = TD.getTypeAllocSize(Ty);
547    if (Size) {
548      unsigned Align = TD.getPreferredAlignment(cast<GlobalVariable>(GV));
549      if (Align <= 32)
550        return CStringSection_;
551    }
552
553    return ReadOnlySection;
554  }
555
556  if (Kind.isMergeableConst()) {
557    if (Kind.isMergeableConst4())
558      return FourByteConstantSection;
559    if (Kind.isMergeableConst8())
560      return EightByteConstantSection;
561    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
562      return SixteenByteConstantSection;
563    return ReadOnlySection;  // .const
564  }
565
566  // FIXME: ROData -> const in -static mode that is relocatable but they happen
567  // by the static linker.  Why not mergeable?
568  if (Kind.isReadOnly())
569    return ReadOnlySection;
570
571  // If this is marked const, put it into a const section.  But if the dynamic
572  // linker needs to write to it, put it in the data segment.
573  if (Kind.isReadOnlyWithRel())
574    return ConstDataSection;
575
576  // Otherwise, just drop the variable in the normal data section.
577  return DataSection;
578}
579
580const Section *
581TargetLoweringObjectFileMachO::
582getSectionForMergeableConstant(SectionKind Kind) const {
583  // If this constant requires a relocation, we have to put it in the data
584  // segment, not in the text segment.
585  if (Kind.isDataRel())
586    return ConstDataSection;
587
588  if (Kind.isMergeableConst4())
589    return FourByteConstantSection;
590  if (Kind.isMergeableConst8())
591    return EightByteConstantSection;
592  if (Kind.isMergeableConst16() && SixteenByteConstantSection)
593    return SixteenByteConstantSection;
594  return ReadOnlySection;  // .const
595}
596
597//===----------------------------------------------------------------------===//
598//                                  COFF
599//===----------------------------------------------------------------------===//
600
601TargetLoweringObjectFileCOFF::TargetLoweringObjectFileCOFF() {
602  TextSection = getOrCreateSection("_text", true, SectionKind::Text);
603  DataSection = getOrCreateSection("_data", true, SectionKind::DataRel);
604}
605
606void TargetLoweringObjectFileCOFF::
607getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
608  // FIXME: Inefficient.
609  std::string Res = ",\"";
610  if (Kind.isText())
611    Res += 'x';
612  if (Kind.isWriteable())
613    Res += 'w';
614  Res += "\"";
615
616  Str.append(Res.begin(), Res.end());
617}
618
619static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
620  if (Kind.isText())
621    return ".text$linkonce";
622  if (Kind.isWriteable())
623    return ".data$linkonce";
624  return ".rdata$linkonce";
625}
626
627
628const Section *TargetLoweringObjectFileCOFF::
629SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
630                       const TargetMachine &TM) const {
631  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
632
633  // If this global is linkonce/weak and the target handles this by emitting it
634  // into a 'uniqued' section name, create and return the section now.
635  if (Kind.isWeak()) {
636    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
637    // FIXME: Use mangler interface (PR4584).
638    std::string Name = Prefix+GV->getNameStr();
639    return getOrCreateSection(Name.c_str(), false, Kind.getKind());
640  }
641
642  if (Kind.isText())
643    return getTextSection();
644
645  if (Kind.isBSS())
646    if (const Section *S = BSSSection_)
647      return S;
648
649  if (Kind.isReadOnly() && ReadOnlySection != 0)
650    return ReadOnlySection;
651
652  return getDataSection();
653}
654
655