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 //===----------------------------------------------------------------------===//
46 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
47 const TargetMachine &TM) {
48 TargetLoweringObjectFile::Initialize(Ctx, TM);
51 getContext().getELFSection(".bss", ELF::SHT_NOBITS,
52 ELF::SHF_WRITE |ELF::SHF_ALLOC,
53 SectionKind::getBSS());
56 getContext().getELFSection(".text", ELF::SHT_PROGBITS,
59 SectionKind::getText());
62 getContext().getELFSection(".data", ELF::SHT_PROGBITS,
63 ELF::SHF_WRITE |ELF::SHF_ALLOC,
64 SectionKind::getDataRel());
67 getContext().getELFSection(".rodata", ELF::SHT_PROGBITS,
69 SectionKind::getReadOnly());
72 getContext().getELFSection(".tdata", ELF::SHT_PROGBITS,
73 ELF::SHF_ALLOC | ELF::SHF_TLS |
75 SectionKind::getThreadData());
78 getContext().getELFSection(".tbss", ELF::SHT_NOBITS,
79 ELF::SHF_ALLOC | ELF::SHF_TLS |
81 SectionKind::getThreadBSS());
84 getContext().getELFSection(".data.rel", ELF::SHT_PROGBITS,
85 ELF::SHF_ALLOC |ELF::SHF_WRITE,
86 SectionKind::getDataRel());
89 getContext().getELFSection(".data.rel.local", ELF::SHT_PROGBITS,
90 ELF::SHF_ALLOC |ELF::SHF_WRITE,
91 SectionKind::getDataRelLocal());
94 getContext().getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
95 ELF::SHF_ALLOC |ELF::SHF_WRITE,
96 SectionKind::getReadOnlyWithRel());
98 DataRelROLocalSection =
99 getContext().getELFSection(".data.rel.ro.local", ELF::SHT_PROGBITS,
100 ELF::SHF_ALLOC |ELF::SHF_WRITE,
101 SectionKind::getReadOnlyWithRelLocal());
103 MergeableConst4Section =
104 getContext().getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
105 ELF::SHF_ALLOC |ELF::SHF_MERGE,
106 SectionKind::getMergeableConst4());
108 MergeableConst8Section =
109 getContext().getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
110 ELF::SHF_ALLOC |ELF::SHF_MERGE,
111 SectionKind::getMergeableConst8());
113 MergeableConst16Section =
114 getContext().getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
115 ELF::SHF_ALLOC |ELF::SHF_MERGE,
116 SectionKind::getMergeableConst16());
119 getContext().getELFSection(".ctors", ELF::SHT_PROGBITS,
120 ELF::SHF_ALLOC |ELF::SHF_WRITE,
121 SectionKind::getDataRel());
124 getContext().getELFSection(".dtors", ELF::SHT_PROGBITS,
125 ELF::SHF_ALLOC |ELF::SHF_WRITE,
126 SectionKind::getDataRel());
128 // Exception Handling Sections.
130 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
131 // it contains relocatable pointers. In PIC mode, this is probably a big
132 // runtime hit for C++ apps. Either the contents of the LSDA need to be
133 // adjusted or this should be a data section.
135 getContext().getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
137 SectionKind::getReadOnly());
138 // Debug Info Sections.
140 getContext().getELFSection(".debug_abbrev", ELF::SHT_PROGBITS, 0,
141 SectionKind::getMetadata());
143 getContext().getELFSection(".debug_info", ELF::SHT_PROGBITS, 0,
144 SectionKind::getMetadata());
146 getContext().getELFSection(".debug_line", ELF::SHT_PROGBITS, 0,
147 SectionKind::getMetadata());
149 getContext().getELFSection(".debug_frame", ELF::SHT_PROGBITS, 0,
150 SectionKind::getMetadata());
151 DwarfPubNamesSection =
152 getContext().getELFSection(".debug_pubnames", ELF::SHT_PROGBITS, 0,
153 SectionKind::getMetadata());
154 DwarfPubTypesSection =
155 getContext().getELFSection(".debug_pubtypes", ELF::SHT_PROGBITS, 0,
156 SectionKind::getMetadata());
158 getContext().getELFSection(".debug_str", ELF::SHT_PROGBITS, 0,
159 SectionKind::getMetadata());
161 getContext().getELFSection(".debug_loc", ELF::SHT_PROGBITS, 0,
162 SectionKind::getMetadata());
163 DwarfARangesSection =
164 getContext().getELFSection(".debug_aranges", ELF::SHT_PROGBITS, 0,
165 SectionKind::getMetadata());
167 getContext().getELFSection(".debug_ranges", ELF::SHT_PROGBITS, 0,
168 SectionKind::getMetadata());
169 DwarfMacroInfoSection =
170 getContext().getELFSection(".debug_macinfo", ELF::SHT_PROGBITS, 0,
171 SectionKind::getMetadata());
174 const MCSection *TargetLoweringObjectFileELF::getEHFrameSection() const {
175 return getContext().getELFSection(".eh_frame", ELF::SHT_PROGBITS,
177 SectionKind::getDataRel());
181 TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
183 MachineModuleInfo *MMI) const {
184 unsigned Encoding = getPersonalityEncoding();
185 switch (Encoding & 0x70) {
187 report_fatal_error("We do not support this DWARF encoding yet!");
188 case dwarf::DW_EH_PE_absptr:
189 return Mang->getSymbol(GV);
191 case dwarf::DW_EH_PE_pcrel: {
192 Twine FullName = StringRef("DW.ref.") + Mang->getSymbol(GV)->getName();
193 return getContext().GetOrCreateSymbol(FullName);
199 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
200 const TargetMachine &TM,
201 const MCSymbol *Sym) const {
202 Twine FullName = StringRef("DW.ref.") + Sym->getName();
203 MCSymbol *Label = getContext().GetOrCreateSymbol(FullName);
204 Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
205 Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
206 Twine SectionName = StringRef(".data.") + Label->getName();
207 SmallString<64> NameData;
208 SectionName.toVector(NameData);
209 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
210 const MCSection *Sec = getContext().getELFSection(NameData,
213 SectionKind::getDataRel(),
214 0, Label->getName());
215 Streamer.SwitchSection(Sec);
216 Streamer.EmitValueToAlignment(8);
217 Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
218 const MCExpr *E = MCConstantExpr::Create(8, getContext());
219 Streamer.EmitELFSize(Label, E);
220 Streamer.EmitLabel(Label);
222 unsigned Size = TM.getTargetData()->getPointerSize();
223 Streamer.EmitSymbolValue(Sym, Size);
227 getELFKindForNamedSection(StringRef Name, SectionKind K) {
228 // N.B.: The defaults used in here are no the same ones used in MC.
229 // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
230 // both gas and MC will produce a section with no flags. Given
231 // section(".eh_frame") gcc will produce
232 // .section .eh_frame,"a",@progbits
233 if (Name.empty() || Name[0] != '.') return K;
235 // Some lame default implementation based on some magic section names.
236 if (Name == ".bss" ||
237 Name.startswith(".bss.") ||
238 Name.startswith(".gnu.linkonce.b.") ||
239 Name.startswith(".llvm.linkonce.b.") ||
241 Name.startswith(".sbss.") ||
242 Name.startswith(".gnu.linkonce.sb.") ||
243 Name.startswith(".llvm.linkonce.sb."))
244 return SectionKind::getBSS();
246 if (Name == ".tdata" ||
247 Name.startswith(".tdata.") ||
248 Name.startswith(".gnu.linkonce.td.") ||
249 Name.startswith(".llvm.linkonce.td."))
250 return SectionKind::getThreadData();
252 if (Name == ".tbss" ||
253 Name.startswith(".tbss.") ||
254 Name.startswith(".gnu.linkonce.tb.") ||
255 Name.startswith(".llvm.linkonce.tb."))
256 return SectionKind::getThreadBSS();
262 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
264 if (Name == ".init_array")
265 return ELF::SHT_INIT_ARRAY;
267 if (Name == ".fini_array")
268 return ELF::SHT_FINI_ARRAY;
270 if (Name == ".preinit_array")
271 return ELF::SHT_PREINIT_ARRAY;
273 if (K.isBSS() || K.isThreadBSS())
274 return ELF::SHT_NOBITS;
276 return ELF::SHT_PROGBITS;
281 getELFSectionFlags(SectionKind K) {
285 Flags |= ELF::SHF_ALLOC;
288 Flags |= ELF::SHF_EXECINSTR;
291 Flags |= ELF::SHF_WRITE;
293 if (K.isThreadLocal())
294 Flags |= ELF::SHF_TLS;
296 // K.isMergeableConst() is left out to honour PR4650
297 if (K.isMergeableCString() || K.isMergeableConst4() ||
298 K.isMergeableConst8() || K.isMergeableConst16())
299 Flags |= ELF::SHF_MERGE;
301 if (K.isMergeableCString())
302 Flags |= ELF::SHF_STRINGS;
308 const MCSection *TargetLoweringObjectFileELF::
309 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
310 Mangler *Mang, const TargetMachine &TM) const {
311 StringRef SectionName = GV->getSection();
313 // Infer section flags from the section name if we can.
314 Kind = getELFKindForNamedSection(SectionName, Kind);
316 return getContext().getELFSection(SectionName,
317 getELFSectionType(SectionName, Kind),
318 getELFSectionFlags(Kind), Kind);
321 /// getSectionPrefixForGlobal - Return the section prefix name used by options
322 /// FunctionsSections and DataSections.
323 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
324 if (Kind.isText()) return ".text.";
325 if (Kind.isReadOnly()) return ".rodata.";
327 if (Kind.isThreadData()) return ".tdata.";
328 if (Kind.isThreadBSS()) return ".tbss.";
330 if (Kind.isDataNoRel()) return ".data.";
331 if (Kind.isDataRelLocal()) return ".data.rel.local.";
332 if (Kind.isDataRel()) return ".data.rel.";
333 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
335 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
336 return ".data.rel.ro.";
340 const MCSection *TargetLoweringObjectFileELF::
341 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
342 Mangler *Mang, const TargetMachine &TM) const {
343 // If we have -ffunction-section or -fdata-section then we should emit the
344 // global value to a uniqued section specifically for it.
345 bool EmitUniquedSection;
347 EmitUniquedSection = TM.getFunctionSections();
349 EmitUniquedSection = TM.getDataSections();
351 // If this global is linkonce/weak and the target handles this by emitting it
352 // into a 'uniqued' section name, create and return the section now.
353 if ((GV->isWeakForLinker() || EmitUniquedSection) &&
354 !Kind.isCommon() && !Kind.isBSS()) {
356 Prefix = getSectionPrefixForGlobal(Kind);
358 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
359 MCSymbol *Sym = Mang->getSymbol(GV);
360 Name.append(Sym->getName().begin(), Sym->getName().end());
361 StringRef Group = "";
362 unsigned Flags = getELFSectionFlags(Kind);
363 if (GV->isWeakForLinker()) {
364 Group = Sym->getName();
365 Flags |= ELF::SHF_GROUP;
368 return getContext().getELFSection(Name.str(),
369 getELFSectionType(Name.str(), Kind),
370 Flags, Kind, 0, Group);
373 if (Kind.isText()) return TextSection;
375 if (Kind.isMergeable1ByteCString() ||
376 Kind.isMergeable2ByteCString() ||
377 Kind.isMergeable4ByteCString()) {
379 // We also need alignment here.
380 // FIXME: this is getting the alignment of the character, not the
381 // alignment of the global!
383 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
385 const char *SizeSpec = ".rodata.str1.";
386 if (Kind.isMergeable2ByteCString())
387 SizeSpec = ".rodata.str2.";
388 else if (Kind.isMergeable4ByteCString())
389 SizeSpec = ".rodata.str4.";
391 assert(Kind.isMergeable1ByteCString() && "unknown string width");
394 std::string Name = SizeSpec + utostr(Align);
395 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
402 if (Kind.isMergeableConst()) {
403 if (Kind.isMergeableConst4() && MergeableConst4Section)
404 return MergeableConst4Section;
405 if (Kind.isMergeableConst8() && MergeableConst8Section)
406 return MergeableConst8Section;
407 if (Kind.isMergeableConst16() && MergeableConst16Section)
408 return MergeableConst16Section;
409 return ReadOnlySection; // .const
412 if (Kind.isReadOnly()) return ReadOnlySection;
414 if (Kind.isThreadData()) return TLSDataSection;
415 if (Kind.isThreadBSS()) return TLSBSSSection;
417 // Note: we claim that common symbols are put in BSSSection, but they are
418 // really emitted with the magic .comm directive, which creates a symbol table
419 // entry but not a section.
420 if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
422 if (Kind.isDataNoRel()) return DataSection;
423 if (Kind.isDataRelLocal()) return DataRelLocalSection;
424 if (Kind.isDataRel()) return DataRelSection;
425 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
427 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
428 return DataRelROSection;
431 /// getSectionForConstant - Given a mergeable constant with the
432 /// specified size and relocation information, return a section that it
433 /// should be placed in.
434 const MCSection *TargetLoweringObjectFileELF::
435 getSectionForConstant(SectionKind Kind) const {
436 if (Kind.isMergeableConst4() && MergeableConst4Section)
437 return MergeableConst4Section;
438 if (Kind.isMergeableConst8() && MergeableConst8Section)
439 return MergeableConst8Section;
440 if (Kind.isMergeableConst16() && MergeableConst16Section)
441 return MergeableConst16Section;
442 if (Kind.isReadOnly())
443 return ReadOnlySection;
445 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
446 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
447 return DataRelROSection;
450 const MCExpr *TargetLoweringObjectFileELF::
451 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
452 MachineModuleInfo *MMI,
453 unsigned Encoding, MCStreamer &Streamer) const {
455 if (Encoding & dwarf::DW_EH_PE_indirect) {
456 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
458 SmallString<128> Name;
459 Mang->getNameWithPrefix(Name, GV, true);
462 // Add information about the stub reference to ELFMMI so that the stub
463 // gets emitted by the asmprinter.
464 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
465 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
466 if (StubSym.getPointer() == 0) {
467 MCSymbol *Sym = Mang->getSymbol(GV);
468 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
471 return TargetLoweringObjectFile::
472 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
475 return TargetLoweringObjectFile::
476 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
479 //===----------------------------------------------------------------------===//
481 //===----------------------------------------------------------------------===//
483 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
484 const TargetMachine &TM) {
485 IsFunctionEHFrameSymbolPrivate = false;
486 SupportsWeakOmittedEHFrame = false;
488 // .comm doesn't support alignment before Leopard.
489 Triple T(((LLVMTargetMachine&)TM).getTargetTriple());
490 if (T.isMacOSX() && T.isMacOSXVersionLT(10, 5))
491 CommDirectiveSupportsAlignment = false;
493 TargetLoweringObjectFile::Initialize(Ctx, TM);
496 = getContext().getMachOSection("__TEXT", "__text",
497 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
498 SectionKind::getText());
500 = getContext().getMachOSection("__DATA", "__data", 0,
501 SectionKind::getDataRel());
503 TLSDataSection // .tdata
504 = getContext().getMachOSection("__DATA", "__thread_data",
505 MCSectionMachO::S_THREAD_LOCAL_REGULAR,
506 SectionKind::getDataRel());
507 TLSBSSSection // .tbss
508 = getContext().getMachOSection("__DATA", "__thread_bss",
509 MCSectionMachO::S_THREAD_LOCAL_ZEROFILL,
510 SectionKind::getThreadBSS());
512 // TODO: Verify datarel below.
513 TLSTLVSection // .tlv
514 = getContext().getMachOSection("__DATA", "__thread_vars",
515 MCSectionMachO::S_THREAD_LOCAL_VARIABLES,
516 SectionKind::getDataRel());
519 = getContext().getMachOSection("__DATA", "__thread_init",
520 MCSectionMachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
521 SectionKind::getDataRel());
523 CStringSection // .cstring
524 = getContext().getMachOSection("__TEXT", "__cstring",
525 MCSectionMachO::S_CSTRING_LITERALS,
526 SectionKind::getMergeable1ByteCString());
528 = getContext().getMachOSection("__TEXT","__ustring", 0,
529 SectionKind::getMergeable2ByteCString());
530 FourByteConstantSection // .literal4
531 = getContext().getMachOSection("__TEXT", "__literal4",
532 MCSectionMachO::S_4BYTE_LITERALS,
533 SectionKind::getMergeableConst4());
534 EightByteConstantSection // .literal8
535 = getContext().getMachOSection("__TEXT", "__literal8",
536 MCSectionMachO::S_8BYTE_LITERALS,
537 SectionKind::getMergeableConst8());
539 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
540 // to using it in -static mode.
541 SixteenByteConstantSection = 0;
542 if (TM.getRelocationModel() != Reloc::Static &&
543 TM.getTargetData()->getPointerSize() == 32)
544 SixteenByteConstantSection = // .literal16
545 getContext().getMachOSection("__TEXT", "__literal16",
546 MCSectionMachO::S_16BYTE_LITERALS,
547 SectionKind::getMergeableConst16());
549 ReadOnlySection // .const
550 = getContext().getMachOSection("__TEXT", "__const", 0,
551 SectionKind::getReadOnly());
554 = getContext().getMachOSection("__TEXT", "__textcoal_nt",
555 MCSectionMachO::S_COALESCED |
556 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
557 SectionKind::getText());
559 = getContext().getMachOSection("__TEXT", "__const_coal",
560 MCSectionMachO::S_COALESCED,
561 SectionKind::getReadOnly());
562 ConstDataSection // .const_data
563 = getContext().getMachOSection("__DATA", "__const", 0,
564 SectionKind::getReadOnlyWithRel());
566 = getContext().getMachOSection("__DATA","__datacoal_nt",
567 MCSectionMachO::S_COALESCED,
568 SectionKind::getDataRel());
570 = getContext().getMachOSection("__DATA","__common",
571 MCSectionMachO::S_ZEROFILL,
572 SectionKind::getBSS());
574 = getContext().getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,
575 SectionKind::getBSS());
578 LazySymbolPointerSection
579 = getContext().getMachOSection("__DATA", "__la_symbol_ptr",
580 MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
581 SectionKind::getMetadata());
582 NonLazySymbolPointerSection
583 = getContext().getMachOSection("__DATA", "__nl_symbol_ptr",
584 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
585 SectionKind::getMetadata());
587 if (TM.getRelocationModel() == Reloc::Static) {
589 = getContext().getMachOSection("__TEXT", "__constructor", 0,
590 SectionKind::getDataRel());
592 = getContext().getMachOSection("__TEXT", "__destructor", 0,
593 SectionKind::getDataRel());
596 = getContext().getMachOSection("__DATA", "__mod_init_func",
597 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
598 SectionKind::getDataRel());
600 = getContext().getMachOSection("__DATA", "__mod_term_func",
601 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
602 SectionKind::getDataRel());
605 // Exception Handling.
606 LSDASection = getContext().getMachOSection("__TEXT", "__gcc_except_tab", 0,
607 SectionKind::getReadOnlyWithRel());
608 // Debug Information.
610 getContext().getMachOSection("__DWARF", "__debug_abbrev",
611 MCSectionMachO::S_ATTR_DEBUG,
612 SectionKind::getMetadata());
614 getContext().getMachOSection("__DWARF", "__debug_info",
615 MCSectionMachO::S_ATTR_DEBUG,
616 SectionKind::getMetadata());
618 getContext().getMachOSection("__DWARF", "__debug_line",
619 MCSectionMachO::S_ATTR_DEBUG,
620 SectionKind::getMetadata());
622 getContext().getMachOSection("__DWARF", "__debug_frame",
623 MCSectionMachO::S_ATTR_DEBUG,
624 SectionKind::getMetadata());
625 DwarfPubNamesSection =
626 getContext().getMachOSection("__DWARF", "__debug_pubnames",
627 MCSectionMachO::S_ATTR_DEBUG,
628 SectionKind::getMetadata());
629 DwarfPubTypesSection =
630 getContext().getMachOSection("__DWARF", "__debug_pubtypes",
631 MCSectionMachO::S_ATTR_DEBUG,
632 SectionKind::getMetadata());
634 getContext().getMachOSection("__DWARF", "__debug_str",
635 MCSectionMachO::S_ATTR_DEBUG,
636 SectionKind::getMetadata());
638 getContext().getMachOSection("__DWARF", "__debug_loc",
639 MCSectionMachO::S_ATTR_DEBUG,
640 SectionKind::getMetadata());
641 DwarfARangesSection =
642 getContext().getMachOSection("__DWARF", "__debug_aranges",
643 MCSectionMachO::S_ATTR_DEBUG,
644 SectionKind::getMetadata());
646 getContext().getMachOSection("__DWARF", "__debug_ranges",
647 MCSectionMachO::S_ATTR_DEBUG,
648 SectionKind::getMetadata());
649 DwarfMacroInfoSection =
650 getContext().getMachOSection("__DWARF", "__debug_macinfo",
651 MCSectionMachO::S_ATTR_DEBUG,
652 SectionKind::getMetadata());
653 DwarfDebugInlineSection =
654 getContext().getMachOSection("__DWARF", "__debug_inlined",
655 MCSectionMachO::S_ATTR_DEBUG,
656 SectionKind::getMetadata());
658 TLSExtraDataSection = TLSTLVSection;
661 const MCSection *TargetLoweringObjectFileMachO::getEHFrameSection() const {
662 return getContext().getMachOSection("__TEXT", "__eh_frame",
663 MCSectionMachO::S_COALESCED |
664 MCSectionMachO::S_ATTR_NO_TOC |
665 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
666 MCSectionMachO::S_ATTR_LIVE_SUPPORT,
667 SectionKind::getReadOnly());
670 const MCSection *TargetLoweringObjectFileMachO::
671 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
672 Mangler *Mang, const TargetMachine &TM) const {
673 // Parse the section specifier and create it if valid.
674 StringRef Segment, Section;
675 unsigned TAA = 0, StubSize = 0;
677 std::string ErrorCode =
678 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
679 TAA, TAAParsed, StubSize);
680 if (!ErrorCode.empty()) {
681 // If invalid, report the error with report_fatal_error.
682 report_fatal_error("Global variable '" + GV->getNameStr() +
683 "' has an invalid section specifier '" + GV->getSection()+
684 "': " + ErrorCode + ".");
685 // Fall back to dropping it into the data section.
690 const MCSectionMachO *S =
691 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
693 // If TAA wasn't set by ParseSectionSpecifier() above,
694 // use the value returned by getMachOSection() as a default.
696 TAA = S->getTypeAndAttributes();
698 // Okay, now that we got the section, verify that the TAA & StubSize agree.
699 // If the user declared multiple globals with different section flags, we need
700 // to reject it here.
701 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
702 // If invalid, report the error with report_fatal_error.
703 report_fatal_error("Global variable '" + GV->getNameStr() +
704 "' section type or attributes does not match previous"
705 " section specifier");
711 const MCSection *TargetLoweringObjectFileMachO::
712 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
713 Mangler *Mang, const TargetMachine &TM) const {
715 // Handle thread local data.
716 if (Kind.isThreadBSS()) return TLSBSSSection;
717 if (Kind.isThreadData()) return TLSDataSection;
720 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
722 // If this is weak/linkonce, put this in a coalescable section, either in text
723 // or data depending on if it is writable.
724 if (GV->isWeakForLinker()) {
725 if (Kind.isReadOnly())
726 return ConstTextCoalSection;
727 return DataCoalSection;
730 // FIXME: Alignment check should be handled by section classifier.
731 if (Kind.isMergeable1ByteCString() &&
732 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
733 return CStringSection;
735 // Do not put 16-bit arrays in the UString section if they have an
736 // externally visible label, this runs into issues with certain linker
738 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
739 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
740 return UStringSection;
742 if (Kind.isMergeableConst()) {
743 if (Kind.isMergeableConst4())
744 return FourByteConstantSection;
745 if (Kind.isMergeableConst8())
746 return EightByteConstantSection;
747 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
748 return SixteenByteConstantSection;
751 // Otherwise, if it is readonly, but not something we can specially optimize,
752 // just drop it in .const.
753 if (Kind.isReadOnly())
754 return ReadOnlySection;
756 // If this is marked const, put it into a const section. But if the dynamic
757 // linker needs to write to it, put it in the data segment.
758 if (Kind.isReadOnlyWithRel())
759 return ConstDataSection;
761 // Put zero initialized globals with strong external linkage in the
762 // DATA, __common section with the .zerofill directive.
763 if (Kind.isBSSExtern())
764 return DataCommonSection;
766 // Put zero initialized globals with local linkage in __DATA,__bss directive
767 // with the .zerofill directive (aka .lcomm).
768 if (Kind.isBSSLocal())
769 return DataBSSSection;
771 // Otherwise, just drop the variable in the normal data section.
776 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
777 // If this constant requires a relocation, we have to put it in the data
778 // segment, not in the text segment.
779 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
780 return ConstDataSection;
782 if (Kind.isMergeableConst4())
783 return FourByteConstantSection;
784 if (Kind.isMergeableConst8())
785 return EightByteConstantSection;
786 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
787 return SixteenByteConstantSection;
788 return ReadOnlySection; // .const
791 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
792 /// not to emit the UsedDirective for some symbols in llvm.used.
793 // FIXME: REMOVE this (rdar://7071300)
794 bool TargetLoweringObjectFileMachO::
795 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
796 /// On Darwin, internally linked data beginning with "L" or "l" does not have
797 /// the directive emitted (this occurs in ObjC metadata).
798 if (!GV) return false;
800 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
801 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
802 // FIXME: ObjC metadata is currently emitted as internal symbols that have
803 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
804 // this horrible hack can go away.
805 MCSymbol *Sym = Mang->getSymbol(GV);
806 if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
813 const MCExpr *TargetLoweringObjectFileMachO::
814 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
815 MachineModuleInfo *MMI, unsigned Encoding,
816 MCStreamer &Streamer) const {
817 // The mach-o version of this method defaults to returning a stub reference.
819 if (Encoding & DW_EH_PE_indirect) {
820 MachineModuleInfoMachO &MachOMMI =
821 MMI->getObjFileInfo<MachineModuleInfoMachO>();
823 SmallString<128> Name;
824 Mang->getNameWithPrefix(Name, GV, true);
825 Name += "$non_lazy_ptr";
827 // Add information about the stub reference to MachOMMI so that the stub
828 // gets emitted by the asmprinter.
829 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
830 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
831 if (StubSym.getPointer() == 0) {
832 MCSymbol *Sym = Mang->getSymbol(GV);
833 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
836 return TargetLoweringObjectFile::
837 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
840 return TargetLoweringObjectFile::
841 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
844 MCSymbol *TargetLoweringObjectFileMachO::
845 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
846 MachineModuleInfo *MMI) const {
847 // The mach-o version of this method defaults to returning a stub reference.
848 MachineModuleInfoMachO &MachOMMI =
849 MMI->getObjFileInfo<MachineModuleInfoMachO>();
851 SmallString<128> Name;
852 Mang->getNameWithPrefix(Name, GV, true);
853 Name += "$non_lazy_ptr";
855 // Add information about the stub reference to MachOMMI so that the stub
856 // gets emitted by the asmprinter.
857 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
858 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
859 if (StubSym.getPointer() == 0) {
860 MCSymbol *Sym = Mang->getSymbol(GV);
861 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
867 unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {
868 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
871 unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {
872 return DW_EH_PE_pcrel;
875 unsigned TargetLoweringObjectFileMachO::getFDEEncoding(bool CFI) const {
876 return DW_EH_PE_pcrel;
879 unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {
880 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
883 //===----------------------------------------------------------------------===//
885 //===----------------------------------------------------------------------===//
887 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
888 const TargetMachine &TM) {
889 TargetLoweringObjectFile::Initialize(Ctx, TM);
891 getContext().getCOFFSection(".text",
892 COFF::IMAGE_SCN_CNT_CODE |
893 COFF::IMAGE_SCN_MEM_EXECUTE |
894 COFF::IMAGE_SCN_MEM_READ,
895 SectionKind::getText());
897 getContext().getCOFFSection(".data",
898 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
899 COFF::IMAGE_SCN_MEM_READ |
900 COFF::IMAGE_SCN_MEM_WRITE,
901 SectionKind::getDataRel());
903 getContext().getCOFFSection(".rdata",
904 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
905 COFF::IMAGE_SCN_MEM_READ,
906 SectionKind::getReadOnly());
908 getContext().getCOFFSection(".ctors",
909 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
910 COFF::IMAGE_SCN_MEM_READ |
911 COFF::IMAGE_SCN_MEM_WRITE,
912 SectionKind::getDataRel());
914 getContext().getCOFFSection(".dtors",
915 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
916 COFF::IMAGE_SCN_MEM_READ |
917 COFF::IMAGE_SCN_MEM_WRITE,
918 SectionKind::getDataRel());
920 // FIXME: We're emitting LSDA info into a readonly section on COFF, even
921 // though it contains relocatable pointers. In PIC mode, this is probably a
922 // big runtime hit for C++ apps. Either the contents of the LSDA need to be
923 // adjusted or this should be a data section.
925 getContext().getCOFFSection(".gcc_except_table",
926 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
927 COFF::IMAGE_SCN_MEM_READ,
928 SectionKind::getReadOnly());
931 getContext().getCOFFSection(".debug_abbrev",
932 COFF::IMAGE_SCN_MEM_DISCARDABLE |
933 COFF::IMAGE_SCN_MEM_READ,
934 SectionKind::getMetadata());
936 getContext().getCOFFSection(".debug_info",
937 COFF::IMAGE_SCN_MEM_DISCARDABLE |
938 COFF::IMAGE_SCN_MEM_READ,
939 SectionKind::getMetadata());
941 getContext().getCOFFSection(".debug_line",
942 COFF::IMAGE_SCN_MEM_DISCARDABLE |
943 COFF::IMAGE_SCN_MEM_READ,
944 SectionKind::getMetadata());
946 getContext().getCOFFSection(".debug_frame",
947 COFF::IMAGE_SCN_MEM_DISCARDABLE |
948 COFF::IMAGE_SCN_MEM_READ,
949 SectionKind::getMetadata());
950 DwarfPubNamesSection =
951 getContext().getCOFFSection(".debug_pubnames",
952 COFF::IMAGE_SCN_MEM_DISCARDABLE |
953 COFF::IMAGE_SCN_MEM_READ,
954 SectionKind::getMetadata());
955 DwarfPubTypesSection =
956 getContext().getCOFFSection(".debug_pubtypes",
957 COFF::IMAGE_SCN_MEM_DISCARDABLE |
958 COFF::IMAGE_SCN_MEM_READ,
959 SectionKind::getMetadata());
961 getContext().getCOFFSection(".debug_str",
962 COFF::IMAGE_SCN_MEM_DISCARDABLE |
963 COFF::IMAGE_SCN_MEM_READ,
964 SectionKind::getMetadata());
966 getContext().getCOFFSection(".debug_loc",
967 COFF::IMAGE_SCN_MEM_DISCARDABLE |
968 COFF::IMAGE_SCN_MEM_READ,
969 SectionKind::getMetadata());
970 DwarfARangesSection =
971 getContext().getCOFFSection(".debug_aranges",
972 COFF::IMAGE_SCN_MEM_DISCARDABLE |
973 COFF::IMAGE_SCN_MEM_READ,
974 SectionKind::getMetadata());
976 getContext().getCOFFSection(".debug_ranges",
977 COFF::IMAGE_SCN_MEM_DISCARDABLE |
978 COFF::IMAGE_SCN_MEM_READ,
979 SectionKind::getMetadata());
980 DwarfMacroInfoSection =
981 getContext().getCOFFSection(".debug_macinfo",
982 COFF::IMAGE_SCN_MEM_DISCARDABLE |
983 COFF::IMAGE_SCN_MEM_READ,
984 SectionKind::getMetadata());
987 getContext().getCOFFSection(".drectve",
988 COFF::IMAGE_SCN_LNK_INFO,
989 SectionKind::getMetadata());
992 getContext().getCOFFSection(".pdata",
993 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
994 COFF::IMAGE_SCN_MEM_READ |
995 COFF::IMAGE_SCN_MEM_WRITE,
996 SectionKind::getDataRel());
999 getContext().getCOFFSection(".xdata",
1000 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1001 COFF::IMAGE_SCN_MEM_READ |
1002 COFF::IMAGE_SCN_MEM_WRITE,
1003 SectionKind::getDataRel());
1006 const MCSection *TargetLoweringObjectFileCOFF::getEHFrameSection() const {
1007 return getContext().getCOFFSection(".eh_frame",
1008 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1009 COFF::IMAGE_SCN_MEM_READ |
1010 COFF::IMAGE_SCN_MEM_WRITE,
1011 SectionKind::getDataRel());
1014 const MCSection *TargetLoweringObjectFileCOFF::getWin64EHFuncTableSection(
1015 StringRef suffix) const {
1017 return PDataSection;
1018 return getContext().getCOFFSection((".pdata"+suffix).str(),
1019 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1020 COFF::IMAGE_SCN_MEM_READ |
1021 COFF::IMAGE_SCN_MEM_WRITE,
1022 SectionKind::getDataRel());
1025 const MCSection *TargetLoweringObjectFileCOFF::getWin64EHTableSection(
1026 StringRef suffix) const {
1028 return XDataSection;
1029 return getContext().getCOFFSection((".xdata"+suffix).str(),
1030 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1031 COFF::IMAGE_SCN_MEM_READ |
1032 COFF::IMAGE_SCN_MEM_WRITE,
1033 SectionKind::getDataRel());
1038 getCOFFSectionFlags(SectionKind K) {
1043 COFF::IMAGE_SCN_MEM_DISCARDABLE;
1044 else if (K.isText())
1046 COFF::IMAGE_SCN_MEM_EXECUTE |
1047 COFF::IMAGE_SCN_MEM_READ |
1048 COFF::IMAGE_SCN_CNT_CODE;
1049 else if (K.isBSS ())
1051 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
1052 COFF::IMAGE_SCN_MEM_READ |
1053 COFF::IMAGE_SCN_MEM_WRITE;
1054 else if (K.isReadOnly())
1056 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1057 COFF::IMAGE_SCN_MEM_READ;
1058 else if (K.isWriteable())
1060 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1061 COFF::IMAGE_SCN_MEM_READ |
1062 COFF::IMAGE_SCN_MEM_WRITE;
1067 const MCSection *TargetLoweringObjectFileCOFF::
1068 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
1069 Mangler *Mang, const TargetMachine &TM) const {
1070 return getContext().getCOFFSection(GV->getSection(),
1071 getCOFFSectionFlags(Kind),
1075 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
1080 if (Kind.isWriteable())
1086 const MCSection *TargetLoweringObjectFileCOFF::
1087 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
1088 Mangler *Mang, const TargetMachine &TM) const {
1089 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
1091 // If this global is linkonce/weak and the target handles this by emitting it
1092 // into a 'uniqued' section name, create and return the section now.
1093 if (GV->isWeakForLinker()) {
1094 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
1095 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
1096 MCSymbol *Sym = Mang->getSymbol(GV);
1097 Name.append(Sym->getName().begin() + 1, Sym->getName().end());
1099 unsigned Characteristics = getCOFFSectionFlags(Kind);
1101 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1103 return getContext().getCOFFSection(Name.str(), Characteristics,
1104 COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
1108 return getTextSection();
1110 return getDataSection();