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();
258 if (Name == ".eh_frame")
259 return SectionKind::getReadOnlyWithRel();
265 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
267 if (Name == ".init_array")
268 return ELF::SHT_INIT_ARRAY;
270 if (Name == ".fini_array")
271 return ELF::SHT_FINI_ARRAY;
273 if (Name == ".preinit_array")
274 return ELF::SHT_PREINIT_ARRAY;
276 if (K.isBSS() || K.isThreadBSS())
277 return ELF::SHT_NOBITS;
279 return ELF::SHT_PROGBITS;
284 getELFSectionFlags(SectionKind K) {
288 Flags |= ELF::SHF_ALLOC;
291 Flags |= ELF::SHF_EXECINSTR;
293 if (K.isWriteable() && !K.isReadOnlyWithRel())
294 Flags |= ELF::SHF_WRITE;
296 if (K.isThreadLocal())
297 Flags |= ELF::SHF_TLS;
299 // K.isMergeableConst() is left out to honour PR4650
300 if (K.isMergeableCString() || K.isMergeableConst4() ||
301 K.isMergeableConst8() || K.isMergeableConst16())
302 Flags |= ELF::SHF_MERGE;
304 if (K.isMergeableCString())
305 Flags |= ELF::SHF_STRINGS;
311 const MCSection *TargetLoweringObjectFileELF::
312 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
313 Mangler *Mang, const TargetMachine &TM) const {
314 StringRef SectionName = GV->getSection();
316 // Infer section flags from the section name if we can.
317 Kind = getELFKindForNamedSection(SectionName, Kind);
319 return getContext().getELFSection(SectionName,
320 getELFSectionType(SectionName, Kind),
321 getELFSectionFlags(Kind), Kind);
324 /// getSectionPrefixForGlobal - Return the section prefix name used by options
325 /// FunctionsSections and DataSections.
326 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
327 if (Kind.isText()) return ".text.";
328 if (Kind.isReadOnly()) return ".rodata.";
330 if (Kind.isThreadData()) return ".tdata.";
331 if (Kind.isThreadBSS()) return ".tbss.";
333 if (Kind.isDataNoRel()) return ".data.";
334 if (Kind.isDataRelLocal()) return ".data.rel.local.";
335 if (Kind.isDataRel()) return ".data.rel.";
336 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
338 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
339 return ".data.rel.ro.";
343 const MCSection *TargetLoweringObjectFileELF::
344 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
345 Mangler *Mang, const TargetMachine &TM) const {
346 // If we have -ffunction-section or -fdata-section then we should emit the
347 // global value to a uniqued section specifically for it.
348 bool EmitUniquedSection;
350 EmitUniquedSection = TM.getFunctionSections();
352 EmitUniquedSection = TM.getDataSections();
354 // If this global is linkonce/weak and the target handles this by emitting it
355 // into a 'uniqued' section name, create and return the section now.
356 if ((GV->isWeakForLinker() || EmitUniquedSection) &&
357 !Kind.isCommon() && !Kind.isBSS()) {
359 Prefix = getSectionPrefixForGlobal(Kind);
361 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
362 MCSymbol *Sym = Mang->getSymbol(GV);
363 Name.append(Sym->getName().begin(), Sym->getName().end());
364 StringRef Group = "";
365 unsigned Flags = getELFSectionFlags(Kind);
366 if (GV->isWeakForLinker()) {
367 Group = Sym->getName();
368 Flags |= ELF::SHF_GROUP;
371 return getContext().getELFSection(Name.str(),
372 getELFSectionType(Name.str(), Kind),
373 Flags, Kind, 0, Group);
376 if (Kind.isText()) return TextSection;
378 if (Kind.isMergeable1ByteCString() ||
379 Kind.isMergeable2ByteCString() ||
380 Kind.isMergeable4ByteCString()) {
382 // We also need alignment here.
383 // FIXME: this is getting the alignment of the character, not the
384 // alignment of the global!
386 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
388 const char *SizeSpec = ".rodata.str1.";
389 if (Kind.isMergeable2ByteCString())
390 SizeSpec = ".rodata.str2.";
391 else if (Kind.isMergeable4ByteCString())
392 SizeSpec = ".rodata.str4.";
394 assert(Kind.isMergeable1ByteCString() && "unknown string width");
397 std::string Name = SizeSpec + utostr(Align);
398 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
405 if (Kind.isMergeableConst()) {
406 if (Kind.isMergeableConst4() && MergeableConst4Section)
407 return MergeableConst4Section;
408 if (Kind.isMergeableConst8() && MergeableConst8Section)
409 return MergeableConst8Section;
410 if (Kind.isMergeableConst16() && MergeableConst16Section)
411 return MergeableConst16Section;
412 return ReadOnlySection; // .const
415 if (Kind.isReadOnly()) return ReadOnlySection;
417 if (Kind.isThreadData()) return TLSDataSection;
418 if (Kind.isThreadBSS()) return TLSBSSSection;
420 // Note: we claim that common symbols are put in BSSSection, but they are
421 // really emitted with the magic .comm directive, which creates a symbol table
422 // entry but not a section.
423 if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
425 if (Kind.isDataNoRel()) return DataSection;
426 if (Kind.isDataRelLocal()) return DataRelLocalSection;
427 if (Kind.isDataRel()) return DataRelSection;
428 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
430 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
431 return DataRelROSection;
434 /// getSectionForConstant - Given a mergeable constant with the
435 /// specified size and relocation information, return a section that it
436 /// should be placed in.
437 const MCSection *TargetLoweringObjectFileELF::
438 getSectionForConstant(SectionKind Kind) const {
439 if (Kind.isMergeableConst4() && MergeableConst4Section)
440 return MergeableConst4Section;
441 if (Kind.isMergeableConst8() && MergeableConst8Section)
442 return MergeableConst8Section;
443 if (Kind.isMergeableConst16() && MergeableConst16Section)
444 return MergeableConst16Section;
445 if (Kind.isReadOnly())
446 return ReadOnlySection;
448 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
449 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
450 return DataRelROSection;
453 const MCExpr *TargetLoweringObjectFileELF::
454 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
455 MachineModuleInfo *MMI,
456 unsigned Encoding, MCStreamer &Streamer) const {
458 if (Encoding & dwarf::DW_EH_PE_indirect) {
459 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
461 SmallString<128> Name;
462 Mang->getNameWithPrefix(Name, GV, true);
465 // Add information about the stub reference to ELFMMI so that the stub
466 // gets emitted by the asmprinter.
467 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
468 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
469 if (StubSym.getPointer() == 0) {
470 MCSymbol *Sym = Mang->getSymbol(GV);
471 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
474 return TargetLoweringObjectFile::
475 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
478 return TargetLoweringObjectFile::
479 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
482 //===----------------------------------------------------------------------===//
484 //===----------------------------------------------------------------------===//
486 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
487 const TargetMachine &TM) {
488 IsFunctionEHFrameSymbolPrivate = false;
489 SupportsWeakOmittedEHFrame = false;
491 // .comm doesn't support alignment before Leopard.
492 Triple T(((LLVMTargetMachine&)TM).getTargetTriple());
493 if (T.isMacOSX() && T.isMacOSXVersionLT(10, 5))
494 CommDirectiveSupportsAlignment = false;
496 TargetLoweringObjectFile::Initialize(Ctx, TM);
499 = getContext().getMachOSection("__TEXT", "__text",
500 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
501 SectionKind::getText());
503 = getContext().getMachOSection("__DATA", "__data", 0,
504 SectionKind::getDataRel());
506 TLSDataSection // .tdata
507 = getContext().getMachOSection("__DATA", "__thread_data",
508 MCSectionMachO::S_THREAD_LOCAL_REGULAR,
509 SectionKind::getDataRel());
510 TLSBSSSection // .tbss
511 = getContext().getMachOSection("__DATA", "__thread_bss",
512 MCSectionMachO::S_THREAD_LOCAL_ZEROFILL,
513 SectionKind::getThreadBSS());
515 // TODO: Verify datarel below.
516 TLSTLVSection // .tlv
517 = getContext().getMachOSection("__DATA", "__thread_vars",
518 MCSectionMachO::S_THREAD_LOCAL_VARIABLES,
519 SectionKind::getDataRel());
522 = getContext().getMachOSection("__DATA", "__thread_init",
523 MCSectionMachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
524 SectionKind::getDataRel());
526 CStringSection // .cstring
527 = getContext().getMachOSection("__TEXT", "__cstring",
528 MCSectionMachO::S_CSTRING_LITERALS,
529 SectionKind::getMergeable1ByteCString());
531 = getContext().getMachOSection("__TEXT","__ustring", 0,
532 SectionKind::getMergeable2ByteCString());
533 FourByteConstantSection // .literal4
534 = getContext().getMachOSection("__TEXT", "__literal4",
535 MCSectionMachO::S_4BYTE_LITERALS,
536 SectionKind::getMergeableConst4());
537 EightByteConstantSection // .literal8
538 = getContext().getMachOSection("__TEXT", "__literal8",
539 MCSectionMachO::S_8BYTE_LITERALS,
540 SectionKind::getMergeableConst8());
542 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
543 // to using it in -static mode.
544 SixteenByteConstantSection = 0;
545 if (TM.getRelocationModel() != Reloc::Static &&
546 TM.getTargetData()->getPointerSize() == 32)
547 SixteenByteConstantSection = // .literal16
548 getContext().getMachOSection("__TEXT", "__literal16",
549 MCSectionMachO::S_16BYTE_LITERALS,
550 SectionKind::getMergeableConst16());
552 ReadOnlySection // .const
553 = getContext().getMachOSection("__TEXT", "__const", 0,
554 SectionKind::getReadOnly());
557 = getContext().getMachOSection("__TEXT", "__textcoal_nt",
558 MCSectionMachO::S_COALESCED |
559 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
560 SectionKind::getText());
562 = getContext().getMachOSection("__TEXT", "__const_coal",
563 MCSectionMachO::S_COALESCED,
564 SectionKind::getReadOnly());
565 ConstDataSection // .const_data
566 = getContext().getMachOSection("__DATA", "__const", 0,
567 SectionKind::getReadOnlyWithRel());
569 = getContext().getMachOSection("__DATA","__datacoal_nt",
570 MCSectionMachO::S_COALESCED,
571 SectionKind::getDataRel());
573 = getContext().getMachOSection("__DATA","__common",
574 MCSectionMachO::S_ZEROFILL,
575 SectionKind::getBSS());
577 = getContext().getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,
578 SectionKind::getBSS());
581 LazySymbolPointerSection
582 = getContext().getMachOSection("__DATA", "__la_symbol_ptr",
583 MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
584 SectionKind::getMetadata());
585 NonLazySymbolPointerSection
586 = getContext().getMachOSection("__DATA", "__nl_symbol_ptr",
587 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
588 SectionKind::getMetadata());
590 if (TM.getRelocationModel() == Reloc::Static) {
592 = getContext().getMachOSection("__TEXT", "__constructor", 0,
593 SectionKind::getDataRel());
595 = getContext().getMachOSection("__TEXT", "__destructor", 0,
596 SectionKind::getDataRel());
599 = getContext().getMachOSection("__DATA", "__mod_init_func",
600 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
601 SectionKind::getDataRel());
603 = getContext().getMachOSection("__DATA", "__mod_term_func",
604 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
605 SectionKind::getDataRel());
608 // Exception Handling.
609 LSDASection = getContext().getMachOSection("__TEXT", "__gcc_except_tab", 0,
610 SectionKind::getReadOnlyWithRel());
611 // Debug Information.
613 getContext().getMachOSection("__DWARF", "__debug_abbrev",
614 MCSectionMachO::S_ATTR_DEBUG,
615 SectionKind::getMetadata());
617 getContext().getMachOSection("__DWARF", "__debug_info",
618 MCSectionMachO::S_ATTR_DEBUG,
619 SectionKind::getMetadata());
621 getContext().getMachOSection("__DWARF", "__debug_line",
622 MCSectionMachO::S_ATTR_DEBUG,
623 SectionKind::getMetadata());
625 getContext().getMachOSection("__DWARF", "__debug_frame",
626 MCSectionMachO::S_ATTR_DEBUG,
627 SectionKind::getMetadata());
628 DwarfPubNamesSection =
629 getContext().getMachOSection("__DWARF", "__debug_pubnames",
630 MCSectionMachO::S_ATTR_DEBUG,
631 SectionKind::getMetadata());
632 DwarfPubTypesSection =
633 getContext().getMachOSection("__DWARF", "__debug_pubtypes",
634 MCSectionMachO::S_ATTR_DEBUG,
635 SectionKind::getMetadata());
637 getContext().getMachOSection("__DWARF", "__debug_str",
638 MCSectionMachO::S_ATTR_DEBUG,
639 SectionKind::getMetadata());
641 getContext().getMachOSection("__DWARF", "__debug_loc",
642 MCSectionMachO::S_ATTR_DEBUG,
643 SectionKind::getMetadata());
644 DwarfARangesSection =
645 getContext().getMachOSection("__DWARF", "__debug_aranges",
646 MCSectionMachO::S_ATTR_DEBUG,
647 SectionKind::getMetadata());
649 getContext().getMachOSection("__DWARF", "__debug_ranges",
650 MCSectionMachO::S_ATTR_DEBUG,
651 SectionKind::getMetadata());
652 DwarfMacroInfoSection =
653 getContext().getMachOSection("__DWARF", "__debug_macinfo",
654 MCSectionMachO::S_ATTR_DEBUG,
655 SectionKind::getMetadata());
656 DwarfDebugInlineSection =
657 getContext().getMachOSection("__DWARF", "__debug_inlined",
658 MCSectionMachO::S_ATTR_DEBUG,
659 SectionKind::getMetadata());
661 TLSExtraDataSection = TLSTLVSection;
664 const MCSection *TargetLoweringObjectFileMachO::getEHFrameSection() const {
665 return getContext().getMachOSection("__TEXT", "__eh_frame",
666 MCSectionMachO::S_COALESCED |
667 MCSectionMachO::S_ATTR_NO_TOC |
668 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
669 MCSectionMachO::S_ATTR_LIVE_SUPPORT,
670 SectionKind::getReadOnly());
673 const MCSection *TargetLoweringObjectFileMachO::
674 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
675 Mangler *Mang, const TargetMachine &TM) const {
676 // Parse the section specifier and create it if valid.
677 StringRef Segment, Section;
678 unsigned TAA = 0, StubSize = 0;
680 std::string ErrorCode =
681 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
682 TAA, TAAParsed, StubSize);
683 if (!ErrorCode.empty()) {
684 // If invalid, report the error with report_fatal_error.
685 report_fatal_error("Global variable '" + GV->getNameStr() +
686 "' has an invalid section specifier '" + GV->getSection()+
687 "': " + ErrorCode + ".");
688 // Fall back to dropping it into the data section.
693 const MCSectionMachO *S =
694 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
696 // If TAA wasn't set by ParseSectionSpecifier() above,
697 // use the value returned by getMachOSection() as a default.
699 TAA = S->getTypeAndAttributes();
701 // Okay, now that we got the section, verify that the TAA & StubSize agree.
702 // If the user declared multiple globals with different section flags, we need
703 // to reject it here.
704 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
705 // If invalid, report the error with report_fatal_error.
706 report_fatal_error("Global variable '" + GV->getNameStr() +
707 "' section type or attributes does not match previous"
708 " section specifier");
714 const MCSection *TargetLoweringObjectFileMachO::
715 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
716 Mangler *Mang, const TargetMachine &TM) const {
718 // Handle thread local data.
719 if (Kind.isThreadBSS()) return TLSBSSSection;
720 if (Kind.isThreadData()) return TLSDataSection;
723 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
725 // If this is weak/linkonce, put this in a coalescable section, either in text
726 // or data depending on if it is writable.
727 if (GV->isWeakForLinker()) {
728 if (Kind.isReadOnly())
729 return ConstTextCoalSection;
730 return DataCoalSection;
733 // FIXME: Alignment check should be handled by section classifier.
734 if (Kind.isMergeable1ByteCString() &&
735 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
736 return CStringSection;
738 // Do not put 16-bit arrays in the UString section if they have an
739 // externally visible label, this runs into issues with certain linker
741 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
742 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
743 return UStringSection;
745 if (Kind.isMergeableConst()) {
746 if (Kind.isMergeableConst4())
747 return FourByteConstantSection;
748 if (Kind.isMergeableConst8())
749 return EightByteConstantSection;
750 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
751 return SixteenByteConstantSection;
754 // Otherwise, if it is readonly, but not something we can specially optimize,
755 // just drop it in .const.
756 if (Kind.isReadOnly())
757 return ReadOnlySection;
759 // If this is marked const, put it into a const section. But if the dynamic
760 // linker needs to write to it, put it in the data segment.
761 if (Kind.isReadOnlyWithRel())
762 return ConstDataSection;
764 // Put zero initialized globals with strong external linkage in the
765 // DATA, __common section with the .zerofill directive.
766 if (Kind.isBSSExtern())
767 return DataCommonSection;
769 // Put zero initialized globals with local linkage in __DATA,__bss directive
770 // with the .zerofill directive (aka .lcomm).
771 if (Kind.isBSSLocal())
772 return DataBSSSection;
774 // Otherwise, just drop the variable in the normal data section.
779 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
780 // If this constant requires a relocation, we have to put it in the data
781 // segment, not in the text segment.
782 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
783 return ConstDataSection;
785 if (Kind.isMergeableConst4())
786 return FourByteConstantSection;
787 if (Kind.isMergeableConst8())
788 return EightByteConstantSection;
789 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
790 return SixteenByteConstantSection;
791 return ReadOnlySection; // .const
794 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
795 /// not to emit the UsedDirective for some symbols in llvm.used.
796 // FIXME: REMOVE this (rdar://7071300)
797 bool TargetLoweringObjectFileMachO::
798 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
799 /// On Darwin, internally linked data beginning with "L" or "l" does not have
800 /// the directive emitted (this occurs in ObjC metadata).
801 if (!GV) return false;
803 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
804 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
805 // FIXME: ObjC metadata is currently emitted as internal symbols that have
806 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
807 // this horrible hack can go away.
808 MCSymbol *Sym = Mang->getSymbol(GV);
809 if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
816 const MCExpr *TargetLoweringObjectFileMachO::
817 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
818 MachineModuleInfo *MMI, unsigned Encoding,
819 MCStreamer &Streamer) const {
820 // The mach-o version of this method defaults to returning a stub reference.
822 if (Encoding & DW_EH_PE_indirect) {
823 MachineModuleInfoMachO &MachOMMI =
824 MMI->getObjFileInfo<MachineModuleInfoMachO>();
826 SmallString<128> Name;
827 Mang->getNameWithPrefix(Name, GV, true);
828 Name += "$non_lazy_ptr";
830 // Add information about the stub reference to MachOMMI so that the stub
831 // gets emitted by the asmprinter.
832 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
833 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
834 if (StubSym.getPointer() == 0) {
835 MCSymbol *Sym = Mang->getSymbol(GV);
836 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
839 return TargetLoweringObjectFile::
840 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
843 return TargetLoweringObjectFile::
844 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
847 MCSymbol *TargetLoweringObjectFileMachO::
848 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
849 MachineModuleInfo *MMI) const {
850 // The mach-o version of this method defaults to returning a stub reference.
851 MachineModuleInfoMachO &MachOMMI =
852 MMI->getObjFileInfo<MachineModuleInfoMachO>();
854 SmallString<128> Name;
855 Mang->getNameWithPrefix(Name, GV, true);
856 Name += "$non_lazy_ptr";
858 // Add information about the stub reference to MachOMMI so that the stub
859 // gets emitted by the asmprinter.
860 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
861 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
862 if (StubSym.getPointer() == 0) {
863 MCSymbol *Sym = Mang->getSymbol(GV);
864 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
870 unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {
871 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
874 unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {
875 return DW_EH_PE_pcrel;
878 unsigned TargetLoweringObjectFileMachO::getFDEEncoding(bool CFI) const {
879 return DW_EH_PE_pcrel;
882 unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {
883 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
886 //===----------------------------------------------------------------------===//
888 //===----------------------------------------------------------------------===//
890 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
891 const TargetMachine &TM) {
892 TargetLoweringObjectFile::Initialize(Ctx, TM);
894 getContext().getCOFFSection(".text",
895 COFF::IMAGE_SCN_CNT_CODE |
896 COFF::IMAGE_SCN_MEM_EXECUTE |
897 COFF::IMAGE_SCN_MEM_READ,
898 SectionKind::getText());
900 getContext().getCOFFSection(".data",
901 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
902 COFF::IMAGE_SCN_MEM_READ |
903 COFF::IMAGE_SCN_MEM_WRITE,
904 SectionKind::getDataRel());
906 getContext().getCOFFSection(".rdata",
907 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
908 COFF::IMAGE_SCN_MEM_READ,
909 SectionKind::getReadOnly());
911 getContext().getCOFFSection(".ctors",
912 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
913 COFF::IMAGE_SCN_MEM_READ |
914 COFF::IMAGE_SCN_MEM_WRITE,
915 SectionKind::getDataRel());
917 getContext().getCOFFSection(".dtors",
918 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
919 COFF::IMAGE_SCN_MEM_READ |
920 COFF::IMAGE_SCN_MEM_WRITE,
921 SectionKind::getDataRel());
923 // FIXME: We're emitting LSDA info into a readonly section on COFF, even
924 // though it contains relocatable pointers. In PIC mode, this is probably a
925 // big runtime hit for C++ apps. Either the contents of the LSDA need to be
926 // adjusted or this should be a data section.
928 getContext().getCOFFSection(".gcc_except_table",
929 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
930 COFF::IMAGE_SCN_MEM_READ,
931 SectionKind::getReadOnly());
934 getContext().getCOFFSection(".debug_abbrev",
935 COFF::IMAGE_SCN_MEM_DISCARDABLE |
936 COFF::IMAGE_SCN_MEM_READ,
937 SectionKind::getMetadata());
939 getContext().getCOFFSection(".debug_info",
940 COFF::IMAGE_SCN_MEM_DISCARDABLE |
941 COFF::IMAGE_SCN_MEM_READ,
942 SectionKind::getMetadata());
944 getContext().getCOFFSection(".debug_line",
945 COFF::IMAGE_SCN_MEM_DISCARDABLE |
946 COFF::IMAGE_SCN_MEM_READ,
947 SectionKind::getMetadata());
949 getContext().getCOFFSection(".debug_frame",
950 COFF::IMAGE_SCN_MEM_DISCARDABLE |
951 COFF::IMAGE_SCN_MEM_READ,
952 SectionKind::getMetadata());
953 DwarfPubNamesSection =
954 getContext().getCOFFSection(".debug_pubnames",
955 COFF::IMAGE_SCN_MEM_DISCARDABLE |
956 COFF::IMAGE_SCN_MEM_READ,
957 SectionKind::getMetadata());
958 DwarfPubTypesSection =
959 getContext().getCOFFSection(".debug_pubtypes",
960 COFF::IMAGE_SCN_MEM_DISCARDABLE |
961 COFF::IMAGE_SCN_MEM_READ,
962 SectionKind::getMetadata());
964 getContext().getCOFFSection(".debug_str",
965 COFF::IMAGE_SCN_MEM_DISCARDABLE |
966 COFF::IMAGE_SCN_MEM_READ,
967 SectionKind::getMetadata());
969 getContext().getCOFFSection(".debug_loc",
970 COFF::IMAGE_SCN_MEM_DISCARDABLE |
971 COFF::IMAGE_SCN_MEM_READ,
972 SectionKind::getMetadata());
973 DwarfARangesSection =
974 getContext().getCOFFSection(".debug_aranges",
975 COFF::IMAGE_SCN_MEM_DISCARDABLE |
976 COFF::IMAGE_SCN_MEM_READ,
977 SectionKind::getMetadata());
979 getContext().getCOFFSection(".debug_ranges",
980 COFF::IMAGE_SCN_MEM_DISCARDABLE |
981 COFF::IMAGE_SCN_MEM_READ,
982 SectionKind::getMetadata());
983 DwarfMacroInfoSection =
984 getContext().getCOFFSection(".debug_macinfo",
985 COFF::IMAGE_SCN_MEM_DISCARDABLE |
986 COFF::IMAGE_SCN_MEM_READ,
987 SectionKind::getMetadata());
990 getContext().getCOFFSection(".drectve",
991 COFF::IMAGE_SCN_LNK_INFO,
992 SectionKind::getMetadata());
995 getContext().getCOFFSection(".pdata",
996 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
997 COFF::IMAGE_SCN_MEM_READ |
998 COFF::IMAGE_SCN_MEM_WRITE,
999 SectionKind::getDataRel());
1002 getContext().getCOFFSection(".xdata",
1003 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1004 COFF::IMAGE_SCN_MEM_READ |
1005 COFF::IMAGE_SCN_MEM_WRITE,
1006 SectionKind::getDataRel());
1009 const MCSection *TargetLoweringObjectFileCOFF::getEHFrameSection() const {
1010 return getContext().getCOFFSection(".eh_frame",
1011 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1012 COFF::IMAGE_SCN_MEM_READ |
1013 COFF::IMAGE_SCN_MEM_WRITE,
1014 SectionKind::getDataRel());
1019 getCOFFSectionFlags(SectionKind K) {
1024 COFF::IMAGE_SCN_MEM_DISCARDABLE;
1025 else if (K.isText())
1027 COFF::IMAGE_SCN_MEM_EXECUTE |
1028 COFF::IMAGE_SCN_MEM_READ |
1029 COFF::IMAGE_SCN_CNT_CODE;
1030 else if (K.isBSS ())
1032 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
1033 COFF::IMAGE_SCN_MEM_READ |
1034 COFF::IMAGE_SCN_MEM_WRITE;
1035 else if (K.isReadOnly())
1037 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1038 COFF::IMAGE_SCN_MEM_READ;
1039 else if (K.isWriteable())
1041 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1042 COFF::IMAGE_SCN_MEM_READ |
1043 COFF::IMAGE_SCN_MEM_WRITE;
1048 const MCSection *TargetLoweringObjectFileCOFF::
1049 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
1050 Mangler *Mang, const TargetMachine &TM) const {
1051 return getContext().getCOFFSection(GV->getSection(),
1052 getCOFFSectionFlags(Kind),
1056 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
1061 if (Kind.isWriteable())
1067 const MCSection *TargetLoweringObjectFileCOFF::
1068 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
1069 Mangler *Mang, const TargetMachine &TM) const {
1070 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
1072 // If this global is linkonce/weak and the target handles this by emitting it
1073 // into a 'uniqued' section name, create and return the section now.
1074 if (GV->isWeakForLinker()) {
1075 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
1076 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
1077 MCSymbol *Sym = Mang->getSymbol(GV);
1078 Name.append(Sym->getName().begin() + 1, Sym->getName().end());
1080 unsigned Characteristics = getCOFFSectionFlags(Kind);
1082 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1084 return getContext().getCOFFSection(Name.str(), Characteristics,
1085 COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
1089 return getTextSection();
1091 return getDataSection();