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/MCSymbol.h"
26 #include "llvm/Target/Mangler.h"
27 #include "llvm/Target/TargetData.h"
28 #include "llvm/Target/TargetMachine.h"
29 #include "llvm/Target/TargetOptions.h"
30 #include "llvm/Support/Dwarf.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/raw_ostream.h"
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/ADT/StringExtras.h"
36 using namespace dwarf;
38 //===----------------------------------------------------------------------===//
40 //===----------------------------------------------------------------------===//
41 typedef StringMap<const MCSectionELF*> ELFUniqueMapTy;
43 TargetLoweringObjectFileELF::~TargetLoweringObjectFileELF() {
44 // If we have the section uniquing map, free it.
45 delete (ELFUniqueMapTy*)UniquingMap;
48 const MCSection *TargetLoweringObjectFileELF::
49 getELFSection(StringRef Section, unsigned Type, unsigned Flags,
50 SectionKind Kind, bool IsExplicit) const {
52 UniquingMap = new ELFUniqueMapTy();
53 ELFUniqueMapTy &Map = *(ELFUniqueMapTy*)UniquingMap;
55 // Do the lookup, if we have a hit, return it.
56 const MCSectionELF *&Entry = Map[Section];
57 if (Entry) return Entry;
59 return Entry = MCSectionELF::Create(Section, Type, Flags, Kind, IsExplicit,
63 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
64 const TargetMachine &TM) {
66 ((ELFUniqueMapTy*)UniquingMap)->clear();
67 TargetLoweringObjectFile::Initialize(Ctx, TM);
70 getELFSection(".bss", MCSectionELF::SHT_NOBITS,
71 MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
72 SectionKind::getBSS());
75 getELFSection(".text", MCSectionELF::SHT_PROGBITS,
76 MCSectionELF::SHF_EXECINSTR | MCSectionELF::SHF_ALLOC,
77 SectionKind::getText());
80 getELFSection(".data", MCSectionELF::SHT_PROGBITS,
81 MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
82 SectionKind::getDataRel());
85 getELFSection(".rodata", MCSectionELF::SHT_PROGBITS,
86 MCSectionELF::SHF_ALLOC,
87 SectionKind::getReadOnly());
90 getELFSection(".tdata", MCSectionELF::SHT_PROGBITS,
91 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
92 MCSectionELF::SHF_WRITE, SectionKind::getThreadData());
95 getELFSection(".tbss", MCSectionELF::SHT_NOBITS,
96 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
97 MCSectionELF::SHF_WRITE, SectionKind::getThreadBSS());
100 getELFSection(".data.rel", MCSectionELF::SHT_PROGBITS,
101 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
102 SectionKind::getDataRel());
104 DataRelLocalSection =
105 getELFSection(".data.rel.local", MCSectionELF::SHT_PROGBITS,
106 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
107 SectionKind::getDataRelLocal());
110 getELFSection(".data.rel.ro", MCSectionELF::SHT_PROGBITS,
111 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
112 SectionKind::getReadOnlyWithRel());
114 DataRelROLocalSection =
115 getELFSection(".data.rel.ro.local", MCSectionELF::SHT_PROGBITS,
116 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
117 SectionKind::getReadOnlyWithRelLocal());
119 MergeableConst4Section =
120 getELFSection(".rodata.cst4", MCSectionELF::SHT_PROGBITS,
121 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
122 SectionKind::getMergeableConst4());
124 MergeableConst8Section =
125 getELFSection(".rodata.cst8", MCSectionELF::SHT_PROGBITS,
126 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
127 SectionKind::getMergeableConst8());
129 MergeableConst16Section =
130 getELFSection(".rodata.cst16", MCSectionELF::SHT_PROGBITS,
131 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
132 SectionKind::getMergeableConst16());
135 getELFSection(".ctors", MCSectionELF::SHT_PROGBITS,
136 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
137 SectionKind::getDataRel());
140 getELFSection(".dtors", MCSectionELF::SHT_PROGBITS,
141 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
142 SectionKind::getDataRel());
144 // Exception Handling Sections.
146 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
147 // it contains relocatable pointers. In PIC mode, this is probably a big
148 // runtime hit for C++ apps. Either the contents of the LSDA need to be
149 // adjusted or this should be a data section.
151 getELFSection(".gcc_except_table", MCSectionELF::SHT_PROGBITS,
152 MCSectionELF::SHF_ALLOC, SectionKind::getReadOnly());
154 getELFSection(".eh_frame", MCSectionELF::SHT_PROGBITS,
155 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
156 SectionKind::getDataRel());
158 // Debug Info Sections.
160 getELFSection(".debug_abbrev", MCSectionELF::SHT_PROGBITS, 0,
161 SectionKind::getMetadata());
163 getELFSection(".debug_info", MCSectionELF::SHT_PROGBITS, 0,
164 SectionKind::getMetadata());
166 getELFSection(".debug_line", MCSectionELF::SHT_PROGBITS, 0,
167 SectionKind::getMetadata());
169 getELFSection(".debug_frame", MCSectionELF::SHT_PROGBITS, 0,
170 SectionKind::getMetadata());
171 DwarfPubNamesSection =
172 getELFSection(".debug_pubnames", MCSectionELF::SHT_PROGBITS, 0,
173 SectionKind::getMetadata());
174 DwarfPubTypesSection =
175 getELFSection(".debug_pubtypes", MCSectionELF::SHT_PROGBITS, 0,
176 SectionKind::getMetadata());
178 getELFSection(".debug_str", MCSectionELF::SHT_PROGBITS, 0,
179 SectionKind::getMetadata());
181 getELFSection(".debug_loc", MCSectionELF::SHT_PROGBITS, 0,
182 SectionKind::getMetadata());
183 DwarfARangesSection =
184 getELFSection(".debug_aranges", MCSectionELF::SHT_PROGBITS, 0,
185 SectionKind::getMetadata());
187 getELFSection(".debug_ranges", MCSectionELF::SHT_PROGBITS, 0,
188 SectionKind::getMetadata());
189 DwarfMacroInfoSection =
190 getELFSection(".debug_macinfo", MCSectionELF::SHT_PROGBITS, 0,
191 SectionKind::getMetadata());
196 getELFKindForNamedSection(StringRef Name, SectionKind K) {
197 if (Name.empty() || Name[0] != '.') return K;
199 // Some lame default implementation based on some magic section names.
200 if (Name == ".bss" ||
201 Name.startswith(".bss.") ||
202 Name.startswith(".gnu.linkonce.b.") ||
203 Name.startswith(".llvm.linkonce.b.") ||
205 Name.startswith(".sbss.") ||
206 Name.startswith(".gnu.linkonce.sb.") ||
207 Name.startswith(".llvm.linkonce.sb."))
208 return SectionKind::getBSS();
210 if (Name == ".tdata" ||
211 Name.startswith(".tdata.") ||
212 Name.startswith(".gnu.linkonce.td.") ||
213 Name.startswith(".llvm.linkonce.td."))
214 return SectionKind::getThreadData();
216 if (Name == ".tbss" ||
217 Name.startswith(".tbss.") ||
218 Name.startswith(".gnu.linkonce.tb.") ||
219 Name.startswith(".llvm.linkonce.tb."))
220 return SectionKind::getThreadBSS();
226 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
228 if (Name == ".init_array")
229 return MCSectionELF::SHT_INIT_ARRAY;
231 if (Name == ".fini_array")
232 return MCSectionELF::SHT_FINI_ARRAY;
234 if (Name == ".preinit_array")
235 return MCSectionELF::SHT_PREINIT_ARRAY;
237 if (K.isBSS() || K.isThreadBSS())
238 return MCSectionELF::SHT_NOBITS;
240 return MCSectionELF::SHT_PROGBITS;
245 getELFSectionFlags(SectionKind K) {
249 Flags |= MCSectionELF::SHF_ALLOC;
252 Flags |= MCSectionELF::SHF_EXECINSTR;
255 Flags |= MCSectionELF::SHF_WRITE;
257 if (K.isThreadLocal())
258 Flags |= MCSectionELF::SHF_TLS;
260 // K.isMergeableConst() is left out to honour PR4650
261 if (K.isMergeableCString() || K.isMergeableConst4() ||
262 K.isMergeableConst8() || K.isMergeableConst16())
263 Flags |= MCSectionELF::SHF_MERGE;
265 if (K.isMergeableCString())
266 Flags |= MCSectionELF::SHF_STRINGS;
272 const MCSection *TargetLoweringObjectFileELF::
273 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
274 Mangler *Mang, const TargetMachine &TM) const {
275 StringRef SectionName = GV->getSection();
277 // Infer section flags from the section name if we can.
278 Kind = getELFKindForNamedSection(SectionName, Kind);
280 return getELFSection(SectionName,
281 getELFSectionType(SectionName, Kind),
282 getELFSectionFlags(Kind), Kind, true);
285 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
286 if (Kind.isText()) return ".gnu.linkonce.t.";
287 if (Kind.isReadOnly()) return ".gnu.linkonce.r.";
289 if (Kind.isThreadData()) return ".gnu.linkonce.td.";
290 if (Kind.isThreadBSS()) return ".gnu.linkonce.tb.";
292 if (Kind.isDataNoRel()) return ".gnu.linkonce.d.";
293 if (Kind.isDataRelLocal()) return ".gnu.linkonce.d.rel.local.";
294 if (Kind.isDataRel()) return ".gnu.linkonce.d.rel.";
295 if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
297 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
298 return ".gnu.linkonce.d.rel.ro.";
301 const MCSection *TargetLoweringObjectFileELF::
302 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
303 Mangler *Mang, const TargetMachine &TM) const {
305 // If this global is linkonce/weak and the target handles this by emitting it
306 // into a 'uniqued' section name, create and return the section now.
307 if (GV->isWeakForLinker() && !Kind.isCommon() && !Kind.isBSS()) {
308 const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
309 SmallString<128> Name;
310 Name.append(Prefix, Prefix+strlen(Prefix));
311 Mang->getNameWithPrefix(Name, GV, false);
312 return getELFSection(Name.str(), getELFSectionType(Name.str(), Kind),
313 getELFSectionFlags(Kind), Kind);
316 if (Kind.isText()) return TextSection;
318 if (Kind.isMergeable1ByteCString() ||
319 Kind.isMergeable2ByteCString() ||
320 Kind.isMergeable4ByteCString()) {
322 // We also need alignment here.
323 // FIXME: this is getting the alignment of the character, not the
324 // alignment of the global!
326 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
328 const char *SizeSpec = ".rodata.str1.";
329 if (Kind.isMergeable2ByteCString())
330 SizeSpec = ".rodata.str2.";
331 else if (Kind.isMergeable4ByteCString())
332 SizeSpec = ".rodata.str4.";
334 assert(Kind.isMergeable1ByteCString() && "unknown string width");
337 std::string Name = SizeSpec + utostr(Align);
338 return getELFSection(Name, MCSectionELF::SHT_PROGBITS,
339 MCSectionELF::SHF_ALLOC |
340 MCSectionELF::SHF_MERGE |
341 MCSectionELF::SHF_STRINGS,
345 if (Kind.isMergeableConst()) {
346 if (Kind.isMergeableConst4() && MergeableConst4Section)
347 return MergeableConst4Section;
348 if (Kind.isMergeableConst8() && MergeableConst8Section)
349 return MergeableConst8Section;
350 if (Kind.isMergeableConst16() && MergeableConst16Section)
351 return MergeableConst16Section;
352 return ReadOnlySection; // .const
355 if (Kind.isReadOnly()) return ReadOnlySection;
357 if (Kind.isThreadData()) return TLSDataSection;
358 if (Kind.isThreadBSS()) return TLSBSSSection;
360 // Note: we claim that common symbols are put in BSSSection, but they are
361 // really emitted with the magic .comm directive, which creates a symbol table
362 // entry but not a section.
363 if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
365 if (Kind.isDataNoRel()) return DataSection;
366 if (Kind.isDataRelLocal()) return DataRelLocalSection;
367 if (Kind.isDataRel()) return DataRelSection;
368 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
370 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
371 return DataRelROSection;
374 /// getSectionForConstant - Given a mergeable constant with the
375 /// specified size and relocation information, return a section that it
376 /// should be placed in.
377 const MCSection *TargetLoweringObjectFileELF::
378 getSectionForConstant(SectionKind Kind) const {
379 if (Kind.isMergeableConst4() && MergeableConst4Section)
380 return MergeableConst4Section;
381 if (Kind.isMergeableConst8() && MergeableConst8Section)
382 return MergeableConst8Section;
383 if (Kind.isMergeableConst16() && MergeableConst16Section)
384 return MergeableConst16Section;
385 if (Kind.isReadOnly())
386 return ReadOnlySection;
388 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
389 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
390 return DataRelROSection;
393 const MCExpr *TargetLoweringObjectFileELF::
394 getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
395 MachineModuleInfo *MMI, unsigned Encoding) const {
397 if (Encoding & dwarf::DW_EH_PE_indirect) {
398 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
400 SmallString<128> Name;
401 Mang->getNameWithPrefix(Name, GV, true);
404 // Add information about the stub reference to ELFMMI so that the stub
405 // gets emitted by the asmprinter.
406 MCSymbol *Sym = getContext().GetOrCreateTemporarySymbol(Name.str());
407 MCSymbol *&StubSym = ELFMMI.getGVStubEntry(Sym);
410 Mang->getNameWithPrefix(Name, GV, false);
411 if (GV->hasPrivateLinkage())
412 StubSym = getContext().GetOrCreateTemporarySymbol(Name.str());
414 StubSym = getContext().GetOrCreateSymbol(Name.str());
417 return TargetLoweringObjectFile::
418 getSymbolForDwarfReference(Sym, MMI,
419 Encoding & ~dwarf::DW_EH_PE_indirect);
422 return TargetLoweringObjectFile::
423 getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);
426 //===----------------------------------------------------------------------===//
428 //===----------------------------------------------------------------------===//
430 typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy;
432 TargetLoweringObjectFileMachO::~TargetLoweringObjectFileMachO() {
433 // If we have the MachO uniquing map, free it.
434 delete (MachOUniqueMapTy*)UniquingMap;
438 const MCSectionMachO *TargetLoweringObjectFileMachO::
439 getMachOSection(StringRef Segment, StringRef Section,
440 unsigned TypeAndAttributes,
441 unsigned Reserved2, SectionKind Kind) const {
442 // We unique sections by their segment/section pair. The returned section
443 // may not have the same flags as the requested section, if so this should be
444 // diagnosed by the client as an error.
446 // Create the map if it doesn't already exist.
447 if (UniquingMap == 0)
448 UniquingMap = new MachOUniqueMapTy();
449 MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)UniquingMap;
451 // Form the name to look up.
452 SmallString<64> Name;
457 // Do the lookup, if we have a hit, return it.
458 const MCSectionMachO *&Entry = Map[Name.str()];
459 if (Entry) return Entry;
461 // Otherwise, return a new section.
462 return Entry = MCSectionMachO::Create(Segment, Section, TypeAndAttributes,
463 Reserved2, Kind, getContext());
467 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
468 const TargetMachine &TM) {
469 if (UniquingMap != 0)
470 ((MachOUniqueMapTy*)UniquingMap)->clear();
471 TargetLoweringObjectFile::Initialize(Ctx, TM);
474 = getMachOSection("__TEXT", "__text",
475 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
476 SectionKind::getText());
478 = getMachOSection("__DATA", "__data", 0, SectionKind::getDataRel());
480 CStringSection // .cstring
481 = getMachOSection("__TEXT", "__cstring", MCSectionMachO::S_CSTRING_LITERALS,
482 SectionKind::getMergeable1ByteCString());
484 = getMachOSection("__TEXT","__ustring", 0,
485 SectionKind::getMergeable2ByteCString());
486 FourByteConstantSection // .literal4
487 = getMachOSection("__TEXT", "__literal4", MCSectionMachO::S_4BYTE_LITERALS,
488 SectionKind::getMergeableConst4());
489 EightByteConstantSection // .literal8
490 = getMachOSection("__TEXT", "__literal8", MCSectionMachO::S_8BYTE_LITERALS,
491 SectionKind::getMergeableConst8());
493 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
494 // to using it in -static mode.
495 SixteenByteConstantSection = 0;
496 if (TM.getRelocationModel() != Reloc::Static &&
497 TM.getTargetData()->getPointerSize() == 32)
498 SixteenByteConstantSection = // .literal16
499 getMachOSection("__TEXT", "__literal16",MCSectionMachO::S_16BYTE_LITERALS,
500 SectionKind::getMergeableConst16());
502 ReadOnlySection // .const
503 = getMachOSection("__TEXT", "__const", 0, SectionKind::getReadOnly());
506 = getMachOSection("__TEXT", "__textcoal_nt",
507 MCSectionMachO::S_COALESCED |
508 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
509 SectionKind::getText());
511 = getMachOSection("__TEXT", "__const_coal", MCSectionMachO::S_COALESCED,
512 SectionKind::getText());
514 = getMachOSection("__DATA","__const_coal", MCSectionMachO::S_COALESCED,
515 SectionKind::getText());
516 ConstDataSection // .const_data
517 = getMachOSection("__DATA", "__const", 0,
518 SectionKind::getReadOnlyWithRel());
520 = getMachOSection("__DATA","__datacoal_nt", MCSectionMachO::S_COALESCED,
521 SectionKind::getDataRel());
523 = getMachOSection("__DATA","__common", MCSectionMachO::S_ZEROFILL,
524 SectionKind::getBSS());
526 = getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,
527 SectionKind::getBSS());
530 LazySymbolPointerSection
531 = getMachOSection("__DATA", "__la_symbol_ptr",
532 MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
533 SectionKind::getMetadata());
534 NonLazySymbolPointerSection
535 = getMachOSection("__DATA", "__nl_symbol_ptr",
536 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
537 SectionKind::getMetadata());
539 if (TM.getRelocationModel() == Reloc::Static) {
541 = getMachOSection("__TEXT", "__constructor", 0,SectionKind::getDataRel());
543 = getMachOSection("__TEXT", "__destructor", 0, SectionKind::getDataRel());
546 = getMachOSection("__DATA", "__mod_init_func",
547 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
548 SectionKind::getDataRel());
550 = getMachOSection("__DATA", "__mod_term_func",
551 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
552 SectionKind::getDataRel());
555 // Exception Handling.
556 LSDASection = getMachOSection("__DATA", "__gcc_except_tab", 0,
557 SectionKind::getDataRel());
559 getMachOSection("__TEXT", "__eh_frame",
560 MCSectionMachO::S_COALESCED |
561 MCSectionMachO::S_ATTR_NO_TOC |
562 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
563 MCSectionMachO::S_ATTR_LIVE_SUPPORT,
564 SectionKind::getReadOnly());
566 // Debug Information.
568 getMachOSection("__DWARF", "__debug_abbrev", MCSectionMachO::S_ATTR_DEBUG,
569 SectionKind::getMetadata());
571 getMachOSection("__DWARF", "__debug_info", MCSectionMachO::S_ATTR_DEBUG,
572 SectionKind::getMetadata());
574 getMachOSection("__DWARF", "__debug_line", MCSectionMachO::S_ATTR_DEBUG,
575 SectionKind::getMetadata());
577 getMachOSection("__DWARF", "__debug_frame", MCSectionMachO::S_ATTR_DEBUG,
578 SectionKind::getMetadata());
579 DwarfPubNamesSection =
580 getMachOSection("__DWARF", "__debug_pubnames", MCSectionMachO::S_ATTR_DEBUG,
581 SectionKind::getMetadata());
582 DwarfPubTypesSection =
583 getMachOSection("__DWARF", "__debug_pubtypes", MCSectionMachO::S_ATTR_DEBUG,
584 SectionKind::getMetadata());
586 getMachOSection("__DWARF", "__debug_str", MCSectionMachO::S_ATTR_DEBUG,
587 SectionKind::getMetadata());
589 getMachOSection("__DWARF", "__debug_loc", MCSectionMachO::S_ATTR_DEBUG,
590 SectionKind::getMetadata());
591 DwarfARangesSection =
592 getMachOSection("__DWARF", "__debug_aranges", MCSectionMachO::S_ATTR_DEBUG,
593 SectionKind::getMetadata());
595 getMachOSection("__DWARF", "__debug_ranges", MCSectionMachO::S_ATTR_DEBUG,
596 SectionKind::getMetadata());
597 DwarfMacroInfoSection =
598 getMachOSection("__DWARF", "__debug_macinfo", MCSectionMachO::S_ATTR_DEBUG,
599 SectionKind::getMetadata());
600 DwarfDebugInlineSection =
601 getMachOSection("__DWARF", "__debug_inlined", MCSectionMachO::S_ATTR_DEBUG,
602 SectionKind::getMetadata());
605 const MCSection *TargetLoweringObjectFileMachO::
606 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
607 Mangler *Mang, const TargetMachine &TM) const {
608 // Parse the section specifier and create it if valid.
609 StringRef Segment, Section;
610 unsigned TAA, StubSize;
611 std::string ErrorCode =
612 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
614 if (!ErrorCode.empty()) {
615 // If invalid, report the error with llvm_report_error.
616 llvm_report_error("Global variable '" + GV->getNameStr() +
617 "' has an invalid section specifier '" + GV->getSection()+
618 "': " + ErrorCode + ".");
619 // Fall back to dropping it into the data section.
624 const MCSectionMachO *S =
625 getMachOSection(Segment, Section, TAA, StubSize, Kind);
627 // Okay, now that we got the section, verify that the TAA & StubSize agree.
628 // If the user declared multiple globals with different section flags, we need
629 // to reject it here.
630 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
631 // If invalid, report the error with llvm_report_error.
632 llvm_report_error("Global variable '" + GV->getNameStr() +
633 "' section type or attributes does not match previous"
634 " section specifier");
640 const MCSection *TargetLoweringObjectFileMachO::
641 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
642 Mangler *Mang, const TargetMachine &TM) const {
643 assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
646 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
648 // If this is weak/linkonce, put this in a coalescable section, either in text
649 // or data depending on if it is writable.
650 if (GV->isWeakForLinker()) {
651 if (Kind.isReadOnly())
652 return ConstTextCoalSection;
653 return DataCoalSection;
656 // FIXME: Alignment check should be handled by section classifier.
657 if (Kind.isMergeable1ByteCString() &&
658 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
659 return CStringSection;
661 // Do not put 16-bit arrays in the UString section if they have an
662 // externally visible label, this runs into issues with certain linker
664 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
665 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
666 return UStringSection;
668 if (Kind.isMergeableConst()) {
669 if (Kind.isMergeableConst4())
670 return FourByteConstantSection;
671 if (Kind.isMergeableConst8())
672 return EightByteConstantSection;
673 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
674 return SixteenByteConstantSection;
677 // Otherwise, if it is readonly, but not something we can specially optimize,
678 // just drop it in .const.
679 if (Kind.isReadOnly())
680 return ReadOnlySection;
682 // If this is marked const, put it into a const section. But if the dynamic
683 // linker needs to write to it, put it in the data segment.
684 if (Kind.isReadOnlyWithRel())
685 return ConstDataSection;
687 // Put zero initialized globals with strong external linkage in the
688 // DATA, __common section with the .zerofill directive.
689 if (Kind.isBSSExtern())
690 return DataCommonSection;
692 // Put zero initialized globals with local linkage in __DATA,__bss directive
693 // with the .zerofill directive (aka .lcomm).
694 if (Kind.isBSSLocal())
695 return DataBSSSection;
697 // Otherwise, just drop the variable in the normal data section.
702 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
703 // If this constant requires a relocation, we have to put it in the data
704 // segment, not in the text segment.
705 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
706 return ConstDataSection;
708 if (Kind.isMergeableConst4())
709 return FourByteConstantSection;
710 if (Kind.isMergeableConst8())
711 return EightByteConstantSection;
712 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
713 return SixteenByteConstantSection;
714 return ReadOnlySection; // .const
717 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
718 /// not to emit the UsedDirective for some symbols in llvm.used.
719 // FIXME: REMOVE this (rdar://7071300)
720 bool TargetLoweringObjectFileMachO::
721 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
722 /// On Darwin, internally linked data beginning with "L" or "l" does not have
723 /// the directive emitted (this occurs in ObjC metadata).
724 if (!GV) return false;
726 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
727 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
728 // FIXME: ObjC metadata is currently emitted as internal symbols that have
729 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
730 // this horrible hack can go away.
731 SmallString<64> Name;
732 Mang->getNameWithPrefix(Name, GV, false);
733 if (Name[0] == 'L' || Name[0] == 'l')
740 const MCExpr *TargetLoweringObjectFileMachO::
741 getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
742 MachineModuleInfo *MMI, unsigned Encoding) const {
743 // The mach-o version of this method defaults to returning a stub reference.
745 if (Encoding & DW_EH_PE_indirect) {
746 MachineModuleInfoMachO &MachOMMI =
747 MMI->getObjFileInfo<MachineModuleInfoMachO>();
749 SmallString<128> Name;
750 Mang->getNameWithPrefix(Name, GV, true);
751 Name += "$non_lazy_ptr";
753 // Add information about the stub reference to MachOMMI so that the stub
754 // gets emitted by the asmprinter.
755 MCSymbol *Sym = getContext().GetOrCreateTemporarySymbol(Name.str());
756 MCSymbol *&StubSym = MachOMMI.getGVStubEntry(Sym);
759 Mang->getNameWithPrefix(Name, GV, false);
760 if (GV->hasPrivateLinkage())
761 StubSym = getContext().GetOrCreateTemporarySymbol(Name.str());
763 StubSym = getContext().GetOrCreateSymbol(Name.str());
766 return TargetLoweringObjectFile::
767 getSymbolForDwarfReference(Sym, MMI,
768 Encoding & ~dwarf::DW_EH_PE_indirect);
771 return TargetLoweringObjectFile::
772 getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);
775 unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {
776 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
779 unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {
780 return DW_EH_PE_pcrel;
783 unsigned TargetLoweringObjectFileMachO::getFDEEncoding() const {
784 return DW_EH_PE_pcrel;
787 unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {
788 return DW_EH_PE_absptr;
791 //===----------------------------------------------------------------------===//
793 //===----------------------------------------------------------------------===//
795 typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy;
797 TargetLoweringObjectFileCOFF::~TargetLoweringObjectFileCOFF() {
798 delete (COFFUniqueMapTy*)UniquingMap;
802 const MCSection *TargetLoweringObjectFileCOFF::
803 getCOFFSection(StringRef Name, bool isDirective, SectionKind Kind) const {
804 // Create the map if it doesn't already exist.
805 if (UniquingMap == 0)
806 UniquingMap = new MachOUniqueMapTy();
807 COFFUniqueMapTy &Map = *(COFFUniqueMapTy*)UniquingMap;
809 // Do the lookup, if we have a hit, return it.
810 const MCSectionCOFF *&Entry = Map[Name];
811 if (Entry) return Entry;
813 return Entry = MCSectionCOFF::Create(Name, isDirective, Kind, getContext());
816 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
817 const TargetMachine &TM) {
818 if (UniquingMap != 0)
819 ((COFFUniqueMapTy*)UniquingMap)->clear();
820 TargetLoweringObjectFile::Initialize(Ctx, TM);
821 TextSection = getCOFFSection("\t.text", true, SectionKind::getText());
822 DataSection = getCOFFSection("\t.data", true, SectionKind::getDataRel());
824 getCOFFSection(".ctors", false, SectionKind::getDataRel());
826 getCOFFSection(".dtors", false, SectionKind::getDataRel());
828 // FIXME: We're emitting LSDA info into a readonly section on COFF, even
829 // though it contains relocatable pointers. In PIC mode, this is probably a
830 // big runtime hit for C++ apps. Either the contents of the LSDA need to be
831 // adjusted or this should be a data section.
833 getCOFFSection(".gcc_except_table", false, SectionKind::getReadOnly());
835 getCOFFSection(".eh_frame", false, SectionKind::getDataRel());
838 // FIXME: Don't use 'directive' mode here.
840 getCOFFSection("\t.section\t.debug_abbrev,\"dr\"",
841 true, SectionKind::getMetadata());
843 getCOFFSection("\t.section\t.debug_info,\"dr\"",
844 true, SectionKind::getMetadata());
846 getCOFFSection("\t.section\t.debug_line,\"dr\"",
847 true, SectionKind::getMetadata());
849 getCOFFSection("\t.section\t.debug_frame,\"dr\"",
850 true, SectionKind::getMetadata());
851 DwarfPubNamesSection =
852 getCOFFSection("\t.section\t.debug_pubnames,\"dr\"",
853 true, SectionKind::getMetadata());
854 DwarfPubTypesSection =
855 getCOFFSection("\t.section\t.debug_pubtypes,\"dr\"",
856 true, SectionKind::getMetadata());
858 getCOFFSection("\t.section\t.debug_str,\"dr\"",
859 true, SectionKind::getMetadata());
861 getCOFFSection("\t.section\t.debug_loc,\"dr\"",
862 true, SectionKind::getMetadata());
863 DwarfARangesSection =
864 getCOFFSection("\t.section\t.debug_aranges,\"dr\"",
865 true, SectionKind::getMetadata());
867 getCOFFSection("\t.section\t.debug_ranges,\"dr\"",
868 true, SectionKind::getMetadata());
869 DwarfMacroInfoSection =
870 getCOFFSection("\t.section\t.debug_macinfo,\"dr\"",
871 true, SectionKind::getMetadata());
874 const MCSection *TargetLoweringObjectFileCOFF::
875 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
876 Mangler *Mang, const TargetMachine &TM) const {
877 return getCOFFSection(GV->getSection(), false, Kind);
880 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
882 return ".text$linkonce";
883 if (Kind.isWriteable())
884 return ".data$linkonce";
885 return ".rdata$linkonce";
889 const MCSection *TargetLoweringObjectFileCOFF::
890 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
891 Mangler *Mang, const TargetMachine &TM) const {
892 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
894 // If this global is linkonce/weak and the target handles this by emitting it
895 // into a 'uniqued' section name, create and return the section now.
896 if (GV->isWeakForLinker()) {
897 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
898 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
899 Mang->getNameWithPrefix(Name, GV, false);
900 return getCOFFSection(Name.str(), false, Kind);
904 return getTextSection();
906 return getDataSection();