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 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(Sym);
408 if (StubSym.getPointer() == 0) {
410 Mang->getNameWithPrefix(Name, GV, false);
412 if (GV->hasPrivateLinkage())
413 StubSym = MachineModuleInfoImpl::
414 StubValueTy(getContext().GetOrCreateTemporarySymbol(Name.str()),
417 StubSym = MachineModuleInfoImpl::
418 StubValueTy(getContext().GetOrCreateSymbol(Name.str()),
419 !GV->hasInternalLinkage());
422 return TargetLoweringObjectFile::
423 getSymbolForDwarfReference(Sym, MMI,
424 Encoding & ~dwarf::DW_EH_PE_indirect);
427 return TargetLoweringObjectFile::
428 getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);
431 //===----------------------------------------------------------------------===//
433 //===----------------------------------------------------------------------===//
435 typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy;
437 TargetLoweringObjectFileMachO::~TargetLoweringObjectFileMachO() {
438 // If we have the MachO uniquing map, free it.
439 delete (MachOUniqueMapTy*)UniquingMap;
443 const MCSectionMachO *TargetLoweringObjectFileMachO::
444 getMachOSection(StringRef Segment, StringRef Section,
445 unsigned TypeAndAttributes,
446 unsigned Reserved2, SectionKind Kind) const {
447 // We unique sections by their segment/section pair. The returned section
448 // may not have the same flags as the requested section, if so this should be
449 // diagnosed by the client as an error.
451 // Create the map if it doesn't already exist.
452 if (UniquingMap == 0)
453 UniquingMap = new MachOUniqueMapTy();
454 MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)UniquingMap;
456 // Form the name to look up.
457 SmallString<64> Name;
462 // Do the lookup, if we have a hit, return it.
463 const MCSectionMachO *&Entry = Map[Name.str()];
464 if (Entry) return Entry;
466 // Otherwise, return a new section.
467 return Entry = MCSectionMachO::Create(Segment, Section, TypeAndAttributes,
468 Reserved2, Kind, getContext());
472 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
473 const TargetMachine &TM) {
474 // _foo.eh symbols are currently always exported so that the linker knows
475 // about them. This is not necessary on 10.6 and later, but it
476 // doesn't hurt anything.
477 // FIXME: I need to get this from Triple.
478 IsFunctionEHSymbolGlobal = true;
479 IsFunctionEHFrameSymbolPrivate = false;
480 SupportsWeakOmittedEHFrame = false;
482 if (UniquingMap != 0)
483 ((MachOUniqueMapTy*)UniquingMap)->clear();
484 TargetLoweringObjectFile::Initialize(Ctx, TM);
487 = getMachOSection("__TEXT", "__text",
488 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
489 SectionKind::getText());
491 = getMachOSection("__DATA", "__data", 0, SectionKind::getDataRel());
493 CStringSection // .cstring
494 = getMachOSection("__TEXT", "__cstring", MCSectionMachO::S_CSTRING_LITERALS,
495 SectionKind::getMergeable1ByteCString());
497 = getMachOSection("__TEXT","__ustring", 0,
498 SectionKind::getMergeable2ByteCString());
499 FourByteConstantSection // .literal4
500 = getMachOSection("__TEXT", "__literal4", MCSectionMachO::S_4BYTE_LITERALS,
501 SectionKind::getMergeableConst4());
502 EightByteConstantSection // .literal8
503 = getMachOSection("__TEXT", "__literal8", MCSectionMachO::S_8BYTE_LITERALS,
504 SectionKind::getMergeableConst8());
506 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
507 // to using it in -static mode.
508 SixteenByteConstantSection = 0;
509 if (TM.getRelocationModel() != Reloc::Static &&
510 TM.getTargetData()->getPointerSize() == 32)
511 SixteenByteConstantSection = // .literal16
512 getMachOSection("__TEXT", "__literal16",MCSectionMachO::S_16BYTE_LITERALS,
513 SectionKind::getMergeableConst16());
515 ReadOnlySection // .const
516 = getMachOSection("__TEXT", "__const", 0, SectionKind::getReadOnly());
519 = getMachOSection("__TEXT", "__textcoal_nt",
520 MCSectionMachO::S_COALESCED |
521 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
522 SectionKind::getText());
524 = getMachOSection("__TEXT", "__const_coal", MCSectionMachO::S_COALESCED,
525 SectionKind::getText());
527 = getMachOSection("__DATA","__const_coal", MCSectionMachO::S_COALESCED,
528 SectionKind::getText());
529 ConstDataSection // .const_data
530 = getMachOSection("__DATA", "__const", 0,
531 SectionKind::getReadOnlyWithRel());
533 = getMachOSection("__DATA","__datacoal_nt", MCSectionMachO::S_COALESCED,
534 SectionKind::getDataRel());
536 = getMachOSection("__DATA","__common", MCSectionMachO::S_ZEROFILL,
537 SectionKind::getBSS());
539 = getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,
540 SectionKind::getBSS());
543 LazySymbolPointerSection
544 = getMachOSection("__DATA", "__la_symbol_ptr",
545 MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
546 SectionKind::getMetadata());
547 NonLazySymbolPointerSection
548 = getMachOSection("__DATA", "__nl_symbol_ptr",
549 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
550 SectionKind::getMetadata());
552 if (TM.getRelocationModel() == Reloc::Static) {
554 = getMachOSection("__TEXT", "__constructor", 0,SectionKind::getDataRel());
556 = getMachOSection("__TEXT", "__destructor", 0, SectionKind::getDataRel());
559 = getMachOSection("__DATA", "__mod_init_func",
560 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
561 SectionKind::getDataRel());
563 = getMachOSection("__DATA", "__mod_term_func",
564 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
565 SectionKind::getDataRel());
568 // Exception Handling.
569 LSDASection = getMachOSection("__DATA", "__gcc_except_tab", 0,
570 SectionKind::getDataRel());
572 getMachOSection("__TEXT", "__eh_frame",
573 MCSectionMachO::S_COALESCED |
574 MCSectionMachO::S_ATTR_NO_TOC |
575 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
576 MCSectionMachO::S_ATTR_LIVE_SUPPORT,
577 SectionKind::getReadOnly());
579 // Debug Information.
581 getMachOSection("__DWARF", "__debug_abbrev", MCSectionMachO::S_ATTR_DEBUG,
582 SectionKind::getMetadata());
584 getMachOSection("__DWARF", "__debug_info", MCSectionMachO::S_ATTR_DEBUG,
585 SectionKind::getMetadata());
587 getMachOSection("__DWARF", "__debug_line", MCSectionMachO::S_ATTR_DEBUG,
588 SectionKind::getMetadata());
590 getMachOSection("__DWARF", "__debug_frame", MCSectionMachO::S_ATTR_DEBUG,
591 SectionKind::getMetadata());
592 DwarfPubNamesSection =
593 getMachOSection("__DWARF", "__debug_pubnames", MCSectionMachO::S_ATTR_DEBUG,
594 SectionKind::getMetadata());
595 DwarfPubTypesSection =
596 getMachOSection("__DWARF", "__debug_pubtypes", MCSectionMachO::S_ATTR_DEBUG,
597 SectionKind::getMetadata());
599 getMachOSection("__DWARF", "__debug_str", MCSectionMachO::S_ATTR_DEBUG,
600 SectionKind::getMetadata());
602 getMachOSection("__DWARF", "__debug_loc", MCSectionMachO::S_ATTR_DEBUG,
603 SectionKind::getMetadata());
604 DwarfARangesSection =
605 getMachOSection("__DWARF", "__debug_aranges", MCSectionMachO::S_ATTR_DEBUG,
606 SectionKind::getMetadata());
608 getMachOSection("__DWARF", "__debug_ranges", MCSectionMachO::S_ATTR_DEBUG,
609 SectionKind::getMetadata());
610 DwarfMacroInfoSection =
611 getMachOSection("__DWARF", "__debug_macinfo", MCSectionMachO::S_ATTR_DEBUG,
612 SectionKind::getMetadata());
613 DwarfDebugInlineSection =
614 getMachOSection("__DWARF", "__debug_inlined", MCSectionMachO::S_ATTR_DEBUG,
615 SectionKind::getMetadata());
618 const MCSection *TargetLoweringObjectFileMachO::
619 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
620 Mangler *Mang, const TargetMachine &TM) const {
621 // Parse the section specifier and create it if valid.
622 StringRef Segment, Section;
623 unsigned TAA, StubSize;
624 std::string ErrorCode =
625 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
627 if (!ErrorCode.empty()) {
628 // If invalid, report the error with llvm_report_error.
629 llvm_report_error("Global variable '" + GV->getNameStr() +
630 "' has an invalid section specifier '" + GV->getSection()+
631 "': " + ErrorCode + ".");
632 // Fall back to dropping it into the data section.
637 const MCSectionMachO *S =
638 getMachOSection(Segment, Section, TAA, StubSize, Kind);
640 // Okay, now that we got the section, verify that the TAA & StubSize agree.
641 // If the user declared multiple globals with different section flags, we need
642 // to reject it here.
643 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
644 // If invalid, report the error with llvm_report_error.
645 llvm_report_error("Global variable '" + GV->getNameStr() +
646 "' section type or attributes does not match previous"
647 " section specifier");
653 const MCSection *TargetLoweringObjectFileMachO::
654 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
655 Mangler *Mang, const TargetMachine &TM) const {
656 assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
659 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
661 // If this is weak/linkonce, put this in a coalescable section, either in text
662 // or data depending on if it is writable.
663 if (GV->isWeakForLinker()) {
664 if (Kind.isReadOnly())
665 return ConstTextCoalSection;
666 return DataCoalSection;
669 // FIXME: Alignment check should be handled by section classifier.
670 if (Kind.isMergeable1ByteCString() &&
671 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
672 return CStringSection;
674 // Do not put 16-bit arrays in the UString section if they have an
675 // externally visible label, this runs into issues with certain linker
677 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
678 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
679 return UStringSection;
681 if (Kind.isMergeableConst()) {
682 if (Kind.isMergeableConst4())
683 return FourByteConstantSection;
684 if (Kind.isMergeableConst8())
685 return EightByteConstantSection;
686 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
687 return SixteenByteConstantSection;
690 // Otherwise, if it is readonly, but not something we can specially optimize,
691 // just drop it in .const.
692 if (Kind.isReadOnly())
693 return ReadOnlySection;
695 // If this is marked const, put it into a const section. But if the dynamic
696 // linker needs to write to it, put it in the data segment.
697 if (Kind.isReadOnlyWithRel())
698 return ConstDataSection;
700 // Put zero initialized globals with strong external linkage in the
701 // DATA, __common section with the .zerofill directive.
702 if (Kind.isBSSExtern())
703 return DataCommonSection;
705 // Put zero initialized globals with local linkage in __DATA,__bss directive
706 // with the .zerofill directive (aka .lcomm).
707 if (Kind.isBSSLocal())
708 return DataBSSSection;
710 // Otherwise, just drop the variable in the normal data section.
715 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
716 // If this constant requires a relocation, we have to put it in the data
717 // segment, not in the text segment.
718 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
719 return ConstDataSection;
721 if (Kind.isMergeableConst4())
722 return FourByteConstantSection;
723 if (Kind.isMergeableConst8())
724 return EightByteConstantSection;
725 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
726 return SixteenByteConstantSection;
727 return ReadOnlySection; // .const
730 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
731 /// not to emit the UsedDirective for some symbols in llvm.used.
732 // FIXME: REMOVE this (rdar://7071300)
733 bool TargetLoweringObjectFileMachO::
734 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
735 /// On Darwin, internally linked data beginning with "L" or "l" does not have
736 /// the directive emitted (this occurs in ObjC metadata).
737 if (!GV) return false;
739 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
740 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
741 // FIXME: ObjC metadata is currently emitted as internal symbols that have
742 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
743 // this horrible hack can go away.
744 SmallString<64> Name;
745 Mang->getNameWithPrefix(Name, GV, false);
746 if (Name[0] == 'L' || Name[0] == 'l')
753 const MCExpr *TargetLoweringObjectFileMachO::
754 getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
755 MachineModuleInfo *MMI, unsigned Encoding) const {
756 // The mach-o version of this method defaults to returning a stub reference.
758 if (Encoding & DW_EH_PE_indirect) {
759 MachineModuleInfoMachO &MachOMMI =
760 MMI->getObjFileInfo<MachineModuleInfoMachO>();
762 SmallString<128> Name;
763 Mang->getNameWithPrefix(Name, GV, true);
764 Name += "$non_lazy_ptr";
766 // Add information about the stub reference to MachOMMI so that the stub
767 // gets emitted by the asmprinter.
768 MCSymbol *Sym = getContext().GetOrCreateTemporarySymbol(Name.str());
769 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Sym);
770 if (StubSym.getPointer() == 0) {
772 Mang->getNameWithPrefix(Name, GV, false);
774 if (GV->hasPrivateLinkage())
775 StubSym = MachineModuleInfoImpl::
776 StubValueTy(getContext().GetOrCreateTemporarySymbol(Name.str()),
779 StubSym = MachineModuleInfoImpl::
780 StubValueTy(getContext().GetOrCreateSymbol(Name.str()),
781 !GV->hasInternalLinkage());
784 return TargetLoweringObjectFile::
785 getSymbolForDwarfReference(Sym, MMI,
786 Encoding & ~dwarf::DW_EH_PE_indirect);
789 return TargetLoweringObjectFile::
790 getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);
793 unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {
794 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
797 unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {
798 return DW_EH_PE_pcrel;
801 unsigned TargetLoweringObjectFileMachO::getFDEEncoding() const {
802 return DW_EH_PE_pcrel;
805 unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {
806 return DW_EH_PE_absptr;
809 //===----------------------------------------------------------------------===//
811 //===----------------------------------------------------------------------===//
813 typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy;
815 TargetLoweringObjectFileCOFF::~TargetLoweringObjectFileCOFF() {
816 delete (COFFUniqueMapTy*)UniquingMap;
820 const MCSection *TargetLoweringObjectFileCOFF::
821 getCOFFSection(StringRef Name, bool isDirective, SectionKind Kind) const {
822 // Create the map if it doesn't already exist.
823 if (UniquingMap == 0)
824 UniquingMap = new MachOUniqueMapTy();
825 COFFUniqueMapTy &Map = *(COFFUniqueMapTy*)UniquingMap;
827 // Do the lookup, if we have a hit, return it.
828 const MCSectionCOFF *&Entry = Map[Name];
829 if (Entry) return Entry;
831 return Entry = MCSectionCOFF::Create(Name, isDirective, Kind, getContext());
834 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
835 const TargetMachine &TM) {
836 if (UniquingMap != 0)
837 ((COFFUniqueMapTy*)UniquingMap)->clear();
838 TargetLoweringObjectFile::Initialize(Ctx, TM);
839 TextSection = getCOFFSection("\t.text", true, SectionKind::getText());
840 DataSection = getCOFFSection("\t.data", true, SectionKind::getDataRel());
842 getCOFFSection(".ctors", false, SectionKind::getDataRel());
844 getCOFFSection(".dtors", false, SectionKind::getDataRel());
846 // FIXME: We're emitting LSDA info into a readonly section on COFF, even
847 // though it contains relocatable pointers. In PIC mode, this is probably a
848 // big runtime hit for C++ apps. Either the contents of the LSDA need to be
849 // adjusted or this should be a data section.
851 getCOFFSection(".gcc_except_table", false, SectionKind::getReadOnly());
853 getCOFFSection(".eh_frame", false, SectionKind::getDataRel());
856 // FIXME: Don't use 'directive' mode here.
858 getCOFFSection("\t.section\t.debug_abbrev,\"dr\"",
859 true, SectionKind::getMetadata());
861 getCOFFSection("\t.section\t.debug_info,\"dr\"",
862 true, SectionKind::getMetadata());
864 getCOFFSection("\t.section\t.debug_line,\"dr\"",
865 true, SectionKind::getMetadata());
867 getCOFFSection("\t.section\t.debug_frame,\"dr\"",
868 true, SectionKind::getMetadata());
869 DwarfPubNamesSection =
870 getCOFFSection("\t.section\t.debug_pubnames,\"dr\"",
871 true, SectionKind::getMetadata());
872 DwarfPubTypesSection =
873 getCOFFSection("\t.section\t.debug_pubtypes,\"dr\"",
874 true, SectionKind::getMetadata());
876 getCOFFSection("\t.section\t.debug_str,\"dr\"",
877 true, SectionKind::getMetadata());
879 getCOFFSection("\t.section\t.debug_loc,\"dr\"",
880 true, SectionKind::getMetadata());
881 DwarfARangesSection =
882 getCOFFSection("\t.section\t.debug_aranges,\"dr\"",
883 true, SectionKind::getMetadata());
885 getCOFFSection("\t.section\t.debug_ranges,\"dr\"",
886 true, SectionKind::getMetadata());
887 DwarfMacroInfoSection =
888 getCOFFSection("\t.section\t.debug_macinfo,\"dr\"",
889 true, SectionKind::getMetadata());
892 const MCSection *TargetLoweringObjectFileCOFF::
893 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
894 Mangler *Mang, const TargetMachine &TM) const {
895 return getCOFFSection(GV->getSection(), false, Kind);
898 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
900 return ".text$linkonce";
901 if (Kind.isWriteable())
902 return ".data$linkonce";
903 return ".rdata$linkonce";
907 const MCSection *TargetLoweringObjectFileCOFF::
908 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
909 Mangler *Mang, const TargetMachine &TM) const {
910 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
912 // If this global is linkonce/weak and the target handles this by emitting it
913 // into a 'uniqued' section name, create and return the section now.
914 if (GV->isWeakForLinker()) {
915 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
916 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
917 Mang->getNameWithPrefix(Name, GV, false);
918 return getCOFFSection(Name.str(), false, Kind);
922 return getTextSection();
924 return getDataSection();