1 //===-- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info --===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements classes used to handle lowerings specific to common
11 // object file formats.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
16 #include "llvm/Constants.h"
17 #include "llvm/DerivedTypes.h"
18 #include "llvm/Function.h"
19 #include "llvm/GlobalVariable.h"
20 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCExpr.h"
23 #include "llvm/MC/MCSectionMachO.h"
24 #include "llvm/MC/MCSectionELF.h"
25 #include "llvm/MC/MCSectionCOFF.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/Target/Mangler.h"
29 #include "llvm/Target/TargetData.h"
30 #include "llvm/Target/TargetMachine.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Support/Dwarf.h"
33 #include "llvm/Support/ELF.h"
34 #include "llvm/Support/ErrorHandling.h"
35 #include "llvm/Support/raw_ostream.h"
36 #include "llvm/ADT/SmallString.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/ADT/Triple.h"
40 using namespace dwarf;
42 //===----------------------------------------------------------------------===//
44 //===----------------------------------------------------------------------===//
47 TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
49 MachineModuleInfo *MMI) const {
50 unsigned Encoding = getPersonalityEncoding();
51 switch (Encoding & 0x70) {
53 report_fatal_error("We do not support this DWARF encoding yet!");
54 case dwarf::DW_EH_PE_absptr:
55 return Mang->getSymbol(GV);
56 case dwarf::DW_EH_PE_pcrel: {
57 return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
58 Mang->getSymbol(GV)->getName());
63 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
64 const TargetMachine &TM,
65 const MCSymbol *Sym) const {
66 SmallString<64> NameData("DW.ref.");
67 NameData += Sym->getName();
68 MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
69 Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
70 Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
71 StringRef Prefix = ".data.";
72 NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
73 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
74 const MCSection *Sec = getContext().getELFSection(NameData,
77 SectionKind::getDataRel(),
79 Streamer.SwitchSection(Sec);
80 Streamer.EmitValueToAlignment(8);
81 Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
82 const MCExpr *E = MCConstantExpr::Create(8, getContext());
83 Streamer.EmitELFSize(Label, E);
84 Streamer.EmitLabel(Label);
86 unsigned Size = TM.getTargetData()->getPointerSize();
87 Streamer.EmitSymbolValue(Sym, Size);
91 getELFKindForNamedSection(StringRef Name, SectionKind K) {
92 // N.B.: The defaults used in here are no the same ones used in MC.
93 // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
94 // both gas and MC will produce a section with no flags. Given
95 // section(".eh_frame") gcc will produce
96 // .section .eh_frame,"a",@progbits
97 if (Name.empty() || Name[0] != '.') return K;
99 // Some lame default implementation based on some magic section names.
100 if (Name == ".bss" ||
101 Name.startswith(".bss.") ||
102 Name.startswith(".gnu.linkonce.b.") ||
103 Name.startswith(".llvm.linkonce.b.") ||
105 Name.startswith(".sbss.") ||
106 Name.startswith(".gnu.linkonce.sb.") ||
107 Name.startswith(".llvm.linkonce.sb."))
108 return SectionKind::getBSS();
110 if (Name == ".tdata" ||
111 Name.startswith(".tdata.") ||
112 Name.startswith(".gnu.linkonce.td.") ||
113 Name.startswith(".llvm.linkonce.td."))
114 return SectionKind::getThreadData();
116 if (Name == ".tbss" ||
117 Name.startswith(".tbss.") ||
118 Name.startswith(".gnu.linkonce.tb.") ||
119 Name.startswith(".llvm.linkonce.tb."))
120 return SectionKind::getThreadBSS();
126 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
128 if (Name == ".init_array")
129 return ELF::SHT_INIT_ARRAY;
131 if (Name == ".fini_array")
132 return ELF::SHT_FINI_ARRAY;
134 if (Name == ".preinit_array")
135 return ELF::SHT_PREINIT_ARRAY;
137 if (K.isBSS() || K.isThreadBSS())
138 return ELF::SHT_NOBITS;
140 return ELF::SHT_PROGBITS;
145 getELFSectionFlags(SectionKind K) {
149 Flags |= ELF::SHF_ALLOC;
152 Flags |= ELF::SHF_EXECINSTR;
155 Flags |= ELF::SHF_WRITE;
157 if (K.isThreadLocal())
158 Flags |= ELF::SHF_TLS;
160 // K.isMergeableConst() is left out to honour PR4650
161 if (K.isMergeableCString() || K.isMergeableConst4() ||
162 K.isMergeableConst8() || K.isMergeableConst16())
163 Flags |= ELF::SHF_MERGE;
165 if (K.isMergeableCString())
166 Flags |= ELF::SHF_STRINGS;
172 const MCSection *TargetLoweringObjectFileELF::
173 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
174 Mangler *Mang, const TargetMachine &TM) const {
175 StringRef SectionName = GV->getSection();
177 // Infer section flags from the section name if we can.
178 Kind = getELFKindForNamedSection(SectionName, Kind);
180 return getContext().getELFSection(SectionName,
181 getELFSectionType(SectionName, Kind),
182 getELFSectionFlags(Kind), Kind);
185 /// getSectionPrefixForGlobal - Return the section prefix name used by options
186 /// FunctionsSections and DataSections.
187 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
188 if (Kind.isText()) return ".text.";
189 if (Kind.isReadOnly()) return ".rodata.";
191 if (Kind.isThreadData()) return ".tdata.";
192 if (Kind.isThreadBSS()) return ".tbss.";
194 if (Kind.isDataNoRel()) return ".data.";
195 if (Kind.isDataRelLocal()) return ".data.rel.local.";
196 if (Kind.isDataRel()) return ".data.rel.";
197 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
199 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
200 return ".data.rel.ro.";
204 const MCSection *TargetLoweringObjectFileELF::
205 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
206 Mangler *Mang, const TargetMachine &TM) const {
207 // If we have -ffunction-section or -fdata-section then we should emit the
208 // global value to a uniqued section specifically for it.
209 bool EmitUniquedSection;
211 EmitUniquedSection = TM.getFunctionSections();
213 EmitUniquedSection = TM.getDataSections();
215 // If this global is linkonce/weak and the target handles this by emitting it
216 // into a 'uniqued' section name, create and return the section now.
217 if ((GV->isWeakForLinker() || EmitUniquedSection) &&
218 !Kind.isCommon() && !Kind.isBSS()) {
220 Prefix = getSectionPrefixForGlobal(Kind);
222 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
223 MCSymbol *Sym = Mang->getSymbol(GV);
224 Name.append(Sym->getName().begin(), Sym->getName().end());
225 StringRef Group = "";
226 unsigned Flags = getELFSectionFlags(Kind);
227 if (GV->isWeakForLinker()) {
228 Group = Sym->getName();
229 Flags |= ELF::SHF_GROUP;
232 return getContext().getELFSection(Name.str(),
233 getELFSectionType(Name.str(), Kind),
234 Flags, Kind, 0, Group);
237 if (Kind.isText()) return TextSection;
239 if (Kind.isMergeable1ByteCString() ||
240 Kind.isMergeable2ByteCString() ||
241 Kind.isMergeable4ByteCString()) {
243 // We also need alignment here.
244 // FIXME: this is getting the alignment of the character, not the
245 // alignment of the global!
247 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
249 const char *SizeSpec = ".rodata.str1.";
250 if (Kind.isMergeable2ByteCString())
251 SizeSpec = ".rodata.str2.";
252 else if (Kind.isMergeable4ByteCString())
253 SizeSpec = ".rodata.str4.";
255 assert(Kind.isMergeable1ByteCString() && "unknown string width");
258 std::string Name = SizeSpec + utostr(Align);
259 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
266 if (Kind.isMergeableConst()) {
267 if (Kind.isMergeableConst4() && MergeableConst4Section)
268 return MergeableConst4Section;
269 if (Kind.isMergeableConst8() && MergeableConst8Section)
270 return MergeableConst8Section;
271 if (Kind.isMergeableConst16() && MergeableConst16Section)
272 return MergeableConst16Section;
273 return ReadOnlySection; // .const
276 if (Kind.isReadOnly()) return ReadOnlySection;
278 if (Kind.isThreadData()) return TLSDataSection;
279 if (Kind.isThreadBSS()) return TLSBSSSection;
281 // Note: we claim that common symbols are put in BSSSection, but they are
282 // really emitted with the magic .comm directive, which creates a symbol table
283 // entry but not a section.
284 if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
286 if (Kind.isDataNoRel()) return DataSection;
287 if (Kind.isDataRelLocal()) return DataRelLocalSection;
288 if (Kind.isDataRel()) return DataRelSection;
289 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
291 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
292 return DataRelROSection;
295 /// getSectionForConstant - Given a mergeable constant with the
296 /// specified size and relocation information, return a section that it
297 /// should be placed in.
298 const MCSection *TargetLoweringObjectFileELF::
299 getSectionForConstant(SectionKind Kind) const {
300 if (Kind.isMergeableConst4() && MergeableConst4Section)
301 return MergeableConst4Section;
302 if (Kind.isMergeableConst8() && MergeableConst8Section)
303 return MergeableConst8Section;
304 if (Kind.isMergeableConst16() && MergeableConst16Section)
305 return MergeableConst16Section;
306 if (Kind.isReadOnly())
307 return ReadOnlySection;
309 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
310 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
311 return DataRelROSection;
314 const MCExpr *TargetLoweringObjectFileELF::
315 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
316 MachineModuleInfo *MMI,
317 unsigned Encoding, MCStreamer &Streamer) const {
319 if (Encoding & dwarf::DW_EH_PE_indirect) {
320 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
322 SmallString<128> Name;
323 Mang->getNameWithPrefix(Name, GV, true);
326 // Add information about the stub reference to ELFMMI so that the stub
327 // gets emitted by the asmprinter.
328 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
329 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
330 if (StubSym.getPointer() == 0) {
331 MCSymbol *Sym = Mang->getSymbol(GV);
332 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
335 return TargetLoweringObjectFile::
336 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
339 return TargetLoweringObjectFile::
340 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
344 TargetLoweringObjectFileELF::getStaticCtorSection(unsigned Priority) const {
345 // The default scheme is .ctor / .dtor, so we have to invert the priority
347 if (Priority == 65535)
348 return StaticCtorSection;
350 std::string Name = std::string(".ctors.") + utostr(65535 - Priority);
351 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
352 ELF::SHF_ALLOC |ELF::SHF_WRITE,
353 SectionKind::getDataRel());
357 TargetLoweringObjectFileELF::getStaticDtorSection(unsigned Priority) const {
358 // The default scheme is .ctor / .dtor, so we have to invert the priority
360 if (Priority == 65535)
361 return StaticDtorSection;
363 std::string Name = std::string(".dtors.") + utostr(65535 - Priority);
364 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
365 ELF::SHF_ALLOC |ELF::SHF_WRITE,
366 SectionKind::getDataRel());
369 //===----------------------------------------------------------------------===//
371 //===----------------------------------------------------------------------===//
373 const MCSection *TargetLoweringObjectFileMachO::
374 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
375 Mangler *Mang, const TargetMachine &TM) const {
376 // Parse the section specifier and create it if valid.
377 StringRef Segment, Section;
378 unsigned TAA = 0, StubSize = 0;
380 std::string ErrorCode =
381 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
382 TAA, TAAParsed, StubSize);
383 if (!ErrorCode.empty()) {
384 // If invalid, report the error with report_fatal_error.
385 report_fatal_error("Global variable '" + GV->getName() +
386 "' has an invalid section specifier '" +
387 GV->getSection() + "': " + ErrorCode + ".");
391 const MCSectionMachO *S =
392 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
394 // If TAA wasn't set by ParseSectionSpecifier() above,
395 // use the value returned by getMachOSection() as a default.
397 TAA = S->getTypeAndAttributes();
399 // Okay, now that we got the section, verify that the TAA & StubSize agree.
400 // If the user declared multiple globals with different section flags, we need
401 // to reject it here.
402 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
403 // If invalid, report the error with report_fatal_error.
404 report_fatal_error("Global variable '" + GV->getName() +
405 "' section type or attributes does not match previous"
406 " section specifier");
412 const MCSection *TargetLoweringObjectFileMachO::
413 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
414 Mangler *Mang, const TargetMachine &TM) const {
416 // Handle thread local data.
417 if (Kind.isThreadBSS()) return TLSBSSSection;
418 if (Kind.isThreadData()) return TLSDataSection;
421 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
423 // If this is weak/linkonce, put this in a coalescable section, either in text
424 // or data depending on if it is writable.
425 if (GV->isWeakForLinker()) {
426 if (Kind.isReadOnly())
427 return ConstTextCoalSection;
428 return DataCoalSection;
431 // FIXME: Alignment check should be handled by section classifier.
432 if (Kind.isMergeable1ByteCString() &&
433 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
434 return CStringSection;
436 // Do not put 16-bit arrays in the UString section if they have an
437 // externally visible label, this runs into issues with certain linker
439 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
440 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
441 return UStringSection;
443 if (Kind.isMergeableConst()) {
444 if (Kind.isMergeableConst4())
445 return FourByteConstantSection;
446 if (Kind.isMergeableConst8())
447 return EightByteConstantSection;
448 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
449 return SixteenByteConstantSection;
452 // Otherwise, if it is readonly, but not something we can specially optimize,
453 // just drop it in .const.
454 if (Kind.isReadOnly())
455 return ReadOnlySection;
457 // If this is marked const, put it into a const section. But if the dynamic
458 // linker needs to write to it, put it in the data segment.
459 if (Kind.isReadOnlyWithRel())
460 return ConstDataSection;
462 // Put zero initialized globals with strong external linkage in the
463 // DATA, __common section with the .zerofill directive.
464 if (Kind.isBSSExtern())
465 return DataCommonSection;
467 // Put zero initialized globals with local linkage in __DATA,__bss directive
468 // with the .zerofill directive (aka .lcomm).
469 if (Kind.isBSSLocal())
470 return DataBSSSection;
472 // Otherwise, just drop the variable in the normal data section.
477 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
478 // If this constant requires a relocation, we have to put it in the data
479 // segment, not in the text segment.
480 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
481 return ConstDataSection;
483 if (Kind.isMergeableConst4())
484 return FourByteConstantSection;
485 if (Kind.isMergeableConst8())
486 return EightByteConstantSection;
487 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
488 return SixteenByteConstantSection;
489 return ReadOnlySection; // .const
492 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
493 /// not to emit the UsedDirective for some symbols in llvm.used.
494 // FIXME: REMOVE this (rdar://7071300)
495 bool TargetLoweringObjectFileMachO::
496 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
497 /// On Darwin, internally linked data beginning with "L" or "l" does not have
498 /// the directive emitted (this occurs in ObjC metadata).
499 if (!GV) return false;
501 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
502 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
503 // FIXME: ObjC metadata is currently emitted as internal symbols that have
504 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
505 // this horrible hack can go away.
506 MCSymbol *Sym = Mang->getSymbol(GV);
507 if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
514 const MCExpr *TargetLoweringObjectFileMachO::
515 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
516 MachineModuleInfo *MMI, unsigned Encoding,
517 MCStreamer &Streamer) const {
518 // The mach-o version of this method defaults to returning a stub reference.
520 if (Encoding & DW_EH_PE_indirect) {
521 MachineModuleInfoMachO &MachOMMI =
522 MMI->getObjFileInfo<MachineModuleInfoMachO>();
524 SmallString<128> Name;
525 Mang->getNameWithPrefix(Name, GV, true);
526 Name += "$non_lazy_ptr";
528 // Add information about the stub reference to MachOMMI so that the stub
529 // gets emitted by the asmprinter.
530 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
531 MachineModuleInfoImpl::StubValueTy &StubSym =
532 GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
533 MachOMMI.getGVStubEntry(SSym);
534 if (StubSym.getPointer() == 0) {
535 MCSymbol *Sym = Mang->getSymbol(GV);
536 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
539 return TargetLoweringObjectFile::
540 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
543 return TargetLoweringObjectFile::
544 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
547 MCSymbol *TargetLoweringObjectFileMachO::
548 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
549 MachineModuleInfo *MMI) const {
550 // The mach-o version of this method defaults to returning a stub reference.
551 MachineModuleInfoMachO &MachOMMI =
552 MMI->getObjFileInfo<MachineModuleInfoMachO>();
554 SmallString<128> Name;
555 Mang->getNameWithPrefix(Name, GV, true);
556 Name += "$non_lazy_ptr";
558 // Add information about the stub reference to MachOMMI so that the stub
559 // gets emitted by the asmprinter.
560 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
561 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
562 if (StubSym.getPointer() == 0) {
563 MCSymbol *Sym = Mang->getSymbol(GV);
564 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
570 //===----------------------------------------------------------------------===//
572 //===----------------------------------------------------------------------===//
575 getCOFFSectionFlags(SectionKind K) {
580 COFF::IMAGE_SCN_MEM_DISCARDABLE;
583 COFF::IMAGE_SCN_MEM_EXECUTE |
584 COFF::IMAGE_SCN_MEM_READ |
585 COFF::IMAGE_SCN_CNT_CODE;
588 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
589 COFF::IMAGE_SCN_MEM_READ |
590 COFF::IMAGE_SCN_MEM_WRITE;
591 else if (K.isThreadLocal())
593 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
594 COFF::IMAGE_SCN_MEM_READ |
595 COFF::IMAGE_SCN_MEM_WRITE;
596 else if (K.isReadOnly())
598 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
599 COFF::IMAGE_SCN_MEM_READ;
600 else if (K.isWriteable())
602 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
603 COFF::IMAGE_SCN_MEM_READ |
604 COFF::IMAGE_SCN_MEM_WRITE;
609 const MCSection *TargetLoweringObjectFileCOFF::
610 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
611 Mangler *Mang, const TargetMachine &TM) const {
612 return getContext().getCOFFSection(GV->getSection(),
613 getCOFFSectionFlags(Kind),
617 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
622 if (Kind.isThreadLocal())
624 if (Kind.isWriteable())
630 const MCSection *TargetLoweringObjectFileCOFF::
631 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
632 Mangler *Mang, const TargetMachine &TM) const {
634 // If this global is linkonce/weak and the target handles this by emitting it
635 // into a 'uniqued' section name, create and return the section now.
636 if (GV->isWeakForLinker()) {
637 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
638 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
639 MCSymbol *Sym = Mang->getSymbol(GV);
640 Name.append(Sym->getName().begin() + 1, Sym->getName().end());
642 unsigned Characteristics = getCOFFSectionFlags(Kind);
644 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
646 return getContext().getCOFFSection(Name.str(), Characteristics,
647 COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
651 return getTextSection();
653 if (Kind.isThreadLocal())
654 return getTLSDataSection();
656 return getDataSection();