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/MCSymbol.h"
27 #include "llvm/Target/Mangler.h"
28 #include "llvm/Target/TargetData.h"
29 #include "llvm/Target/TargetMachine.h"
30 #include "llvm/Target/TargetOptions.h"
31 #include "llvm/Support/Dwarf.h"
32 #include "llvm/Support/ELF.h"
33 #include "llvm/Support/ErrorHandling.h"
34 #include "llvm/Support/raw_ostream.h"
35 #include "llvm/ADT/SmallString.h"
36 #include "llvm/ADT/StringExtras.h"
37 #include "llvm/ADT/Triple.h"
39 using namespace dwarf
;
41 //===----------------------------------------------------------------------===//
43 //===----------------------------------------------------------------------===//
45 void TargetLoweringObjectFileELF::Initialize(MCContext
&Ctx
,
46 const TargetMachine
&TM
) {
47 TargetLoweringObjectFile::Initialize(Ctx
, TM
);
50 getContext().getELFSection(".bss", ELF::SHT_NOBITS
,
51 ELF::SHF_WRITE
|ELF::SHF_ALLOC
,
52 SectionKind::getBSS());
55 getContext().getELFSection(".text", ELF::SHT_PROGBITS
,
58 SectionKind::getText());
61 getContext().getELFSection(".data", ELF::SHT_PROGBITS
,
62 ELF::SHF_WRITE
|ELF::SHF_ALLOC
,
63 SectionKind::getDataRel());
66 getContext().getELFSection(".rodata", ELF::SHT_PROGBITS
,
68 SectionKind::getReadOnly());
71 getContext().getELFSection(".tdata", ELF::SHT_PROGBITS
,
72 ELF::SHF_ALLOC
| ELF::SHF_TLS
|
74 SectionKind::getThreadData());
77 getContext().getELFSection(".tbss", ELF::SHT_NOBITS
,
78 ELF::SHF_ALLOC
| ELF::SHF_TLS
|
80 SectionKind::getThreadBSS());
83 getContext().getELFSection(".data.rel", ELF::SHT_PROGBITS
,
84 ELF::SHF_ALLOC
|ELF::SHF_WRITE
,
85 SectionKind::getDataRel());
88 getContext().getELFSection(".data.rel.local", ELF::SHT_PROGBITS
,
89 ELF::SHF_ALLOC
|ELF::SHF_WRITE
,
90 SectionKind::getDataRelLocal());
93 getContext().getELFSection(".data.rel.ro", ELF::SHT_PROGBITS
,
94 ELF::SHF_ALLOC
|ELF::SHF_WRITE
,
95 SectionKind::getReadOnlyWithRel());
97 DataRelROLocalSection
=
98 getContext().getELFSection(".data.rel.ro.local", ELF::SHT_PROGBITS
,
99 ELF::SHF_ALLOC
|ELF::SHF_WRITE
,
100 SectionKind::getReadOnlyWithRelLocal());
102 MergeableConst4Section
=
103 getContext().getELFSection(".rodata.cst4", ELF::SHT_PROGBITS
,
104 ELF::SHF_ALLOC
|ELF::SHF_MERGE
,
105 SectionKind::getMergeableConst4());
107 MergeableConst8Section
=
108 getContext().getELFSection(".rodata.cst8", ELF::SHT_PROGBITS
,
109 ELF::SHF_ALLOC
|ELF::SHF_MERGE
,
110 SectionKind::getMergeableConst8());
112 MergeableConst16Section
=
113 getContext().getELFSection(".rodata.cst16", ELF::SHT_PROGBITS
,
114 ELF::SHF_ALLOC
|ELF::SHF_MERGE
,
115 SectionKind::getMergeableConst16());
118 getContext().getELFSection(".ctors", ELF::SHT_PROGBITS
,
119 ELF::SHF_ALLOC
|ELF::SHF_WRITE
,
120 SectionKind::getDataRel());
123 getContext().getELFSection(".dtors", ELF::SHT_PROGBITS
,
124 ELF::SHF_ALLOC
|ELF::SHF_WRITE
,
125 SectionKind::getDataRel());
127 // Exception Handling Sections.
129 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
130 // it contains relocatable pointers. In PIC mode, this is probably a big
131 // runtime hit for C++ apps. Either the contents of the LSDA need to be
132 // adjusted or this should be a data section.
134 getContext().getELFSection(".gcc_except_table", ELF::SHT_PROGBITS
,
136 SectionKind::getReadOnly());
137 // Debug Info Sections.
139 getContext().getELFSection(".debug_abbrev", ELF::SHT_PROGBITS
, 0,
140 SectionKind::getMetadata());
142 getContext().getELFSection(".debug_info", ELF::SHT_PROGBITS
, 0,
143 SectionKind::getMetadata());
145 getContext().getELFSection(".debug_line", ELF::SHT_PROGBITS
, 0,
146 SectionKind::getMetadata());
148 getContext().getELFSection(".debug_frame", ELF::SHT_PROGBITS
, 0,
149 SectionKind::getMetadata());
150 DwarfPubNamesSection
=
151 getContext().getELFSection(".debug_pubnames", ELF::SHT_PROGBITS
, 0,
152 SectionKind::getMetadata());
153 DwarfPubTypesSection
=
154 getContext().getELFSection(".debug_pubtypes", ELF::SHT_PROGBITS
, 0,
155 SectionKind::getMetadata());
157 getContext().getELFSection(".debug_str", ELF::SHT_PROGBITS
, 0,
158 SectionKind::getMetadata());
160 getContext().getELFSection(".debug_loc", ELF::SHT_PROGBITS
, 0,
161 SectionKind::getMetadata());
162 DwarfARangesSection
=
163 getContext().getELFSection(".debug_aranges", ELF::SHT_PROGBITS
, 0,
164 SectionKind::getMetadata());
166 getContext().getELFSection(".debug_ranges", ELF::SHT_PROGBITS
, 0,
167 SectionKind::getMetadata());
168 DwarfMacroInfoSection
=
169 getContext().getELFSection(".debug_macinfo", ELF::SHT_PROGBITS
, 0,
170 SectionKind::getMetadata());
173 const MCSection
*TargetLoweringObjectFileELF::getEHFrameSection() const {
174 return getContext().getELFSection(".eh_frame", ELF::SHT_PROGBITS
,
176 SectionKind::getDataRel());
180 getELFKindForNamedSection(StringRef Name
, SectionKind K
) {
181 if (Name
.empty() || Name
[0] != '.') return K
;
183 // Some lame default implementation based on some magic section names.
184 if (Name
== ".bss" ||
185 Name
.startswith(".bss.") ||
186 Name
.startswith(".gnu.linkonce.b.") ||
187 Name
.startswith(".llvm.linkonce.b.") ||
189 Name
.startswith(".sbss.") ||
190 Name
.startswith(".gnu.linkonce.sb.") ||
191 Name
.startswith(".llvm.linkonce.sb."))
192 return SectionKind::getBSS();
194 if (Name
== ".tdata" ||
195 Name
.startswith(".tdata.") ||
196 Name
.startswith(".gnu.linkonce.td.") ||
197 Name
.startswith(".llvm.linkonce.td."))
198 return SectionKind::getThreadData();
200 if (Name
== ".tbss" ||
201 Name
.startswith(".tbss.") ||
202 Name
.startswith(".gnu.linkonce.tb.") ||
203 Name
.startswith(".llvm.linkonce.tb."))
204 return SectionKind::getThreadBSS();
210 static unsigned getELFSectionType(StringRef Name
, SectionKind K
) {
212 if (Name
== ".init_array")
213 return ELF::SHT_INIT_ARRAY
;
215 if (Name
== ".fini_array")
216 return ELF::SHT_FINI_ARRAY
;
218 if (Name
== ".preinit_array")
219 return ELF::SHT_PREINIT_ARRAY
;
221 if (K
.isBSS() || K
.isThreadBSS())
222 return ELF::SHT_NOBITS
;
224 return ELF::SHT_PROGBITS
;
229 getELFSectionFlags(SectionKind K
) {
233 Flags
|= ELF::SHF_ALLOC
;
236 Flags
|= ELF::SHF_EXECINSTR
;
239 Flags
|= ELF::SHF_WRITE
;
241 if (K
.isThreadLocal())
242 Flags
|= ELF::SHF_TLS
;
244 // K.isMergeableConst() is left out to honour PR4650
245 if (K
.isMergeableCString() || K
.isMergeableConst4() ||
246 K
.isMergeableConst8() || K
.isMergeableConst16())
247 Flags
|= ELF::SHF_MERGE
;
249 if (K
.isMergeableCString())
250 Flags
|= ELF::SHF_STRINGS
;
256 const MCSection
*TargetLoweringObjectFileELF::
257 getExplicitSectionGlobal(const GlobalValue
*GV
, SectionKind Kind
,
258 Mangler
*Mang
, const TargetMachine
&TM
) const {
259 StringRef SectionName
= GV
->getSection();
261 // Infer section flags from the section name if we can.
262 Kind
= getELFKindForNamedSection(SectionName
, Kind
);
264 return getContext().getELFSection(SectionName
,
265 getELFSectionType(SectionName
, Kind
),
266 getELFSectionFlags(Kind
), Kind
);
269 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind
) {
270 if (Kind
.isText()) return ".gnu.linkonce.t.";
271 if (Kind
.isReadOnly()) return ".gnu.linkonce.r.";
273 if (Kind
.isThreadData()) return ".gnu.linkonce.td.";
274 if (Kind
.isThreadBSS()) return ".gnu.linkonce.tb.";
276 if (Kind
.isDataNoRel()) return ".gnu.linkonce.d.";
277 if (Kind
.isDataRelLocal()) return ".gnu.linkonce.d.rel.local.";
278 if (Kind
.isDataRel()) return ".gnu.linkonce.d.rel.";
279 if (Kind
.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
281 assert(Kind
.isReadOnlyWithRel() && "Unknown section kind");
282 return ".gnu.linkonce.d.rel.ro.";
285 /// getSectionPrefixForGlobal - Return the section prefix name used by options
286 /// FunctionsSections and DataSections.
287 static const char *getSectionPrefixForGlobal(SectionKind Kind
) {
288 if (Kind
.isText()) return ".text.";
289 if (Kind
.isReadOnly()) return ".rodata.";
291 if (Kind
.isThreadData()) return ".tdata.";
292 if (Kind
.isThreadBSS()) return ".tbss.";
294 if (Kind
.isDataNoRel()) return ".data.";
295 if (Kind
.isDataRelLocal()) return ".data.rel.local.";
296 if (Kind
.isDataRel()) return ".data.rel.";
297 if (Kind
.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
299 assert(Kind
.isReadOnlyWithRel() && "Unknown section kind");
300 return ".data.rel.ro.";
304 const MCSection
*TargetLoweringObjectFileELF::
305 SelectSectionForGlobal(const GlobalValue
*GV
, SectionKind Kind
,
306 Mangler
*Mang
, const TargetMachine
&TM
) const {
307 // If we have -ffunction-section or -fdata-section then we should emit the
308 // global value to a uniqued section specifically for it.
309 bool EmitUniquedSection
;
311 EmitUniquedSection
= TM
.getFunctionSections();
313 EmitUniquedSection
= TM
.getDataSections();
315 // If this global is linkonce/weak and the target handles this by emitting it
316 // into a 'uniqued' section name, create and return the section now.
317 if ((GV
->isWeakForLinker() || EmitUniquedSection
) &&
318 !Kind
.isCommon() && !Kind
.isBSS()) {
320 if (GV
->isWeakForLinker())
321 Prefix
= getSectionPrefixForUniqueGlobal(Kind
);
323 assert(EmitUniquedSection
);
324 Prefix
= getSectionPrefixForGlobal(Kind
);
327 SmallString
<128> Name(Prefix
, Prefix
+strlen(Prefix
));
328 MCSymbol
*Sym
= Mang
->getSymbol(GV
);
329 Name
.append(Sym
->getName().begin(), Sym
->getName().end());
330 return getContext().getELFSection(Name
.str(),
331 getELFSectionType(Name
.str(), Kind
),
332 getELFSectionFlags(Kind
), Kind
);
335 if (Kind
.isText()) return TextSection
;
337 if (Kind
.isMergeable1ByteCString() ||
338 Kind
.isMergeable2ByteCString() ||
339 Kind
.isMergeable4ByteCString()) {
341 // We also need alignment here.
342 // FIXME: this is getting the alignment of the character, not the
343 // alignment of the global!
345 TM
.getTargetData()->getPreferredAlignment(cast
<GlobalVariable
>(GV
));
347 const char *SizeSpec
= ".rodata.str1.";
348 if (Kind
.isMergeable2ByteCString())
349 SizeSpec
= ".rodata.str2.";
350 else if (Kind
.isMergeable4ByteCString())
351 SizeSpec
= ".rodata.str4.";
353 assert(Kind
.isMergeable1ByteCString() && "unknown string width");
356 std::string Name
= SizeSpec
+ utostr(Align
);
357 return getContext().getELFSection(Name
, ELF::SHT_PROGBITS
,
364 if (Kind
.isMergeableConst()) {
365 if (Kind
.isMergeableConst4() && MergeableConst4Section
)
366 return MergeableConst4Section
;
367 if (Kind
.isMergeableConst8() && MergeableConst8Section
)
368 return MergeableConst8Section
;
369 if (Kind
.isMergeableConst16() && MergeableConst16Section
)
370 return MergeableConst16Section
;
371 return ReadOnlySection
; // .const
374 if (Kind
.isReadOnly()) return ReadOnlySection
;
376 if (Kind
.isThreadData()) return TLSDataSection
;
377 if (Kind
.isThreadBSS()) return TLSBSSSection
;
379 // Note: we claim that common symbols are put in BSSSection, but they are
380 // really emitted with the magic .comm directive, which creates a symbol table
381 // entry but not a section.
382 if (Kind
.isBSS() || Kind
.isCommon()) return BSSSection
;
384 if (Kind
.isDataNoRel()) return DataSection
;
385 if (Kind
.isDataRelLocal()) return DataRelLocalSection
;
386 if (Kind
.isDataRel()) return DataRelSection
;
387 if (Kind
.isReadOnlyWithRelLocal()) return DataRelROLocalSection
;
389 assert(Kind
.isReadOnlyWithRel() && "Unknown section kind");
390 return DataRelROSection
;
393 /// getSectionForConstant - Given a mergeable constant with the
394 /// specified size and relocation information, return a section that it
395 /// should be placed in.
396 const MCSection
*TargetLoweringObjectFileELF::
397 getSectionForConstant(SectionKind Kind
) const {
398 if (Kind
.isMergeableConst4() && MergeableConst4Section
)
399 return MergeableConst4Section
;
400 if (Kind
.isMergeableConst8() && MergeableConst8Section
)
401 return MergeableConst8Section
;
402 if (Kind
.isMergeableConst16() && MergeableConst16Section
)
403 return MergeableConst16Section
;
404 if (Kind
.isReadOnly())
405 return ReadOnlySection
;
407 if (Kind
.isReadOnlyWithRelLocal()) return DataRelROLocalSection
;
408 assert(Kind
.isReadOnlyWithRel() && "Unknown section kind");
409 return DataRelROSection
;
412 const MCExpr
*TargetLoweringObjectFileELF::
413 getExprForDwarfGlobalReference(const GlobalValue
*GV
, Mangler
*Mang
,
414 MachineModuleInfo
*MMI
,
415 unsigned Encoding
, MCStreamer
&Streamer
) const {
417 if (Encoding
& dwarf::DW_EH_PE_indirect
) {
418 MachineModuleInfoELF
&ELFMMI
= MMI
->getObjFileInfo
<MachineModuleInfoELF
>();
420 SmallString
<128> Name
;
421 Mang
->getNameWithPrefix(Name
, GV
, true);
424 // Add information about the stub reference to ELFMMI so that the stub
425 // gets emitted by the asmprinter.
426 MCSymbol
*SSym
= getContext().GetOrCreateSymbol(Name
.str());
427 MachineModuleInfoImpl::StubValueTy
&StubSym
= ELFMMI
.getGVStubEntry(SSym
);
428 if (StubSym
.getPointer() == 0) {
429 MCSymbol
*Sym
= Mang
->getSymbol(GV
);
430 StubSym
= MachineModuleInfoImpl::StubValueTy(Sym
, !GV
->hasLocalLinkage());
433 return TargetLoweringObjectFile::
434 getExprForDwarfReference(SSym
, Mang
, MMI
,
435 Encoding
& ~dwarf::DW_EH_PE_indirect
, Streamer
);
438 return TargetLoweringObjectFile::
439 getExprForDwarfGlobalReference(GV
, Mang
, MMI
, Encoding
, Streamer
);
442 //===----------------------------------------------------------------------===//
444 //===----------------------------------------------------------------------===//
446 void TargetLoweringObjectFileMachO::Initialize(MCContext
&Ctx
,
447 const TargetMachine
&TM
) {
448 // _foo.eh symbols are currently always exported so that the linker knows
449 // about them. This is not necessary on 10.6 and later, but it
450 // doesn't hurt anything.
451 // FIXME: I need to get this from Triple.
452 IsFunctionEHSymbolGlobal
= true;
453 IsFunctionEHFrameSymbolPrivate
= false;
454 SupportsWeakOmittedEHFrame
= false;
456 Triple
T(((LLVMTargetMachine
&)TM
).getTargetTriple());
457 if (T
.getOS() == Triple::Darwin
) {
458 switch (T
.getDarwinMajorNumber()) {
459 case 7: // 10.3 Panther.
460 case 8: // 10.4 Tiger.
461 CommDirectiveSupportsAlignment
= false;
463 case 9: // 10.5 Leopard.
464 case 10: // 10.6 SnowLeopard.
469 TargetLoweringObjectFile::Initialize(Ctx
, TM
);
472 = getContext().getMachOSection("__TEXT", "__text",
473 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS
,
474 SectionKind::getText());
476 = getContext().getMachOSection("__DATA", "__data", 0,
477 SectionKind::getDataRel());
479 TLSDataSection
// .tdata
480 = getContext().getMachOSection("__DATA", "__thread_data",
481 MCSectionMachO::S_THREAD_LOCAL_REGULAR
,
482 SectionKind::getDataRel());
483 TLSBSSSection
// .tbss
484 = getContext().getMachOSection("__DATA", "__thread_bss",
485 MCSectionMachO::S_THREAD_LOCAL_ZEROFILL
,
486 SectionKind::getThreadBSS());
488 // TODO: Verify datarel below.
489 TLSTLVSection
// .tlv
490 = getContext().getMachOSection("__DATA", "__thread_vars",
491 MCSectionMachO::S_THREAD_LOCAL_VARIABLES
,
492 SectionKind::getDataRel());
495 = getContext().getMachOSection("__DATA", "__thread_init",
496 MCSectionMachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS
,
497 SectionKind::getDataRel());
499 CStringSection
// .cstring
500 = getContext().getMachOSection("__TEXT", "__cstring",
501 MCSectionMachO::S_CSTRING_LITERALS
,
502 SectionKind::getMergeable1ByteCString());
504 = getContext().getMachOSection("__TEXT","__ustring", 0,
505 SectionKind::getMergeable2ByteCString());
506 FourByteConstantSection
// .literal4
507 = getContext().getMachOSection("__TEXT", "__literal4",
508 MCSectionMachO::S_4BYTE_LITERALS
,
509 SectionKind::getMergeableConst4());
510 EightByteConstantSection
// .literal8
511 = getContext().getMachOSection("__TEXT", "__literal8",
512 MCSectionMachO::S_8BYTE_LITERALS
,
513 SectionKind::getMergeableConst8());
515 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
516 // to using it in -static mode.
517 SixteenByteConstantSection
= 0;
518 if (TM
.getRelocationModel() != Reloc::Static
&&
519 TM
.getTargetData()->getPointerSize() == 32)
520 SixteenByteConstantSection
= // .literal16
521 getContext().getMachOSection("__TEXT", "__literal16",
522 MCSectionMachO::S_16BYTE_LITERALS
,
523 SectionKind::getMergeableConst16());
525 ReadOnlySection
// .const
526 = getContext().getMachOSection("__TEXT", "__const", 0,
527 SectionKind::getReadOnly());
530 = getContext().getMachOSection("__TEXT", "__textcoal_nt",
531 MCSectionMachO::S_COALESCED
|
532 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS
,
533 SectionKind::getText());
535 = getContext().getMachOSection("__TEXT", "__const_coal",
536 MCSectionMachO::S_COALESCED
,
537 SectionKind::getReadOnly());
538 ConstDataSection
// .const_data
539 = getContext().getMachOSection("__DATA", "__const", 0,
540 SectionKind::getReadOnlyWithRel());
542 = getContext().getMachOSection("__DATA","__datacoal_nt",
543 MCSectionMachO::S_COALESCED
,
544 SectionKind::getDataRel());
546 = getContext().getMachOSection("__DATA","__common",
547 MCSectionMachO::S_ZEROFILL
,
548 SectionKind::getBSS());
550 = getContext().getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL
,
551 SectionKind::getBSS());
554 LazySymbolPointerSection
555 = getContext().getMachOSection("__DATA", "__la_symbol_ptr",
556 MCSectionMachO::S_LAZY_SYMBOL_POINTERS
,
557 SectionKind::getMetadata());
558 NonLazySymbolPointerSection
559 = getContext().getMachOSection("__DATA", "__nl_symbol_ptr",
560 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS
,
561 SectionKind::getMetadata());
563 if (TM
.getRelocationModel() == Reloc::Static
) {
565 = getContext().getMachOSection("__TEXT", "__constructor", 0,
566 SectionKind::getDataRel());
568 = getContext().getMachOSection("__TEXT", "__destructor", 0,
569 SectionKind::getDataRel());
572 = getContext().getMachOSection("__DATA", "__mod_init_func",
573 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS
,
574 SectionKind::getDataRel());
576 = getContext().getMachOSection("__DATA", "__mod_term_func",
577 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS
,
578 SectionKind::getDataRel());
581 // Exception Handling.
582 LSDASection
= getContext().getMachOSection("__TEXT", "__gcc_except_tab", 0,
583 SectionKind::getReadOnlyWithRel());
584 // Debug Information.
586 getContext().getMachOSection("__DWARF", "__debug_abbrev",
587 MCSectionMachO::S_ATTR_DEBUG
,
588 SectionKind::getMetadata());
590 getContext().getMachOSection("__DWARF", "__debug_info",
591 MCSectionMachO::S_ATTR_DEBUG
,
592 SectionKind::getMetadata());
594 getContext().getMachOSection("__DWARF", "__debug_line",
595 MCSectionMachO::S_ATTR_DEBUG
,
596 SectionKind::getMetadata());
598 getContext().getMachOSection("__DWARF", "__debug_frame",
599 MCSectionMachO::S_ATTR_DEBUG
,
600 SectionKind::getMetadata());
601 DwarfPubNamesSection
=
602 getContext().getMachOSection("__DWARF", "__debug_pubnames",
603 MCSectionMachO::S_ATTR_DEBUG
,
604 SectionKind::getMetadata());
605 DwarfPubTypesSection
=
606 getContext().getMachOSection("__DWARF", "__debug_pubtypes",
607 MCSectionMachO::S_ATTR_DEBUG
,
608 SectionKind::getMetadata());
610 getContext().getMachOSection("__DWARF", "__debug_str",
611 MCSectionMachO::S_ATTR_DEBUG
,
612 SectionKind::getMetadata());
614 getContext().getMachOSection("__DWARF", "__debug_loc",
615 MCSectionMachO::S_ATTR_DEBUG
,
616 SectionKind::getMetadata());
617 DwarfARangesSection
=
618 getContext().getMachOSection("__DWARF", "__debug_aranges",
619 MCSectionMachO::S_ATTR_DEBUG
,
620 SectionKind::getMetadata());
622 getContext().getMachOSection("__DWARF", "__debug_ranges",
623 MCSectionMachO::S_ATTR_DEBUG
,
624 SectionKind::getMetadata());
625 DwarfMacroInfoSection
=
626 getContext().getMachOSection("__DWARF", "__debug_macinfo",
627 MCSectionMachO::S_ATTR_DEBUG
,
628 SectionKind::getMetadata());
629 DwarfDebugInlineSection
=
630 getContext().getMachOSection("__DWARF", "__debug_inlined",
631 MCSectionMachO::S_ATTR_DEBUG
,
632 SectionKind::getMetadata());
634 TLSExtraDataSection
= TLSTLVSection
;
637 const MCSection
*TargetLoweringObjectFileMachO::getEHFrameSection() const {
638 return getContext().getMachOSection("__TEXT", "__eh_frame",
639 MCSectionMachO::S_COALESCED
|
640 MCSectionMachO::S_ATTR_NO_TOC
|
641 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS
|
642 MCSectionMachO::S_ATTR_LIVE_SUPPORT
,
643 SectionKind::getReadOnly());
646 const MCSection
*TargetLoweringObjectFileMachO::
647 getExplicitSectionGlobal(const GlobalValue
*GV
, SectionKind Kind
,
648 Mangler
*Mang
, const TargetMachine
&TM
) const {
649 // Parse the section specifier and create it if valid.
650 StringRef Segment
, Section
;
651 unsigned TAA
, StubSize
;
652 std::string ErrorCode
=
653 MCSectionMachO::ParseSectionSpecifier(GV
->getSection(), Segment
, Section
,
655 if (!ErrorCode
.empty()) {
656 // If invalid, report the error with report_fatal_error.
657 report_fatal_error("Global variable '" + GV
->getNameStr() +
658 "' has an invalid section specifier '" + GV
->getSection()+
659 "': " + ErrorCode
+ ".");
660 // Fall back to dropping it into the data section.
665 const MCSectionMachO
*S
=
666 getContext().getMachOSection(Segment
, Section
, TAA
, StubSize
, Kind
);
668 // Okay, now that we got the section, verify that the TAA & StubSize agree.
669 // If the user declared multiple globals with different section flags, we need
670 // to reject it here.
671 if (S
->getTypeAndAttributes() != TAA
|| S
->getStubSize() != StubSize
) {
672 // If invalid, report the error with report_fatal_error.
673 report_fatal_error("Global variable '" + GV
->getNameStr() +
674 "' section type or attributes does not match previous"
675 " section specifier");
681 const MCSection
*TargetLoweringObjectFileMachO::
682 SelectSectionForGlobal(const GlobalValue
*GV
, SectionKind Kind
,
683 Mangler
*Mang
, const TargetMachine
&TM
) const {
685 // Handle thread local data.
686 if (Kind
.isThreadBSS()) return TLSBSSSection
;
687 if (Kind
.isThreadData()) return TLSDataSection
;
690 return GV
->isWeakForLinker() ? TextCoalSection
: TextSection
;
692 // If this is weak/linkonce, put this in a coalescable section, either in text
693 // or data depending on if it is writable.
694 if (GV
->isWeakForLinker()) {
695 if (Kind
.isReadOnly())
696 return ConstTextCoalSection
;
697 return DataCoalSection
;
700 // FIXME: Alignment check should be handled by section classifier.
701 if (Kind
.isMergeable1ByteCString() &&
702 TM
.getTargetData()->getPreferredAlignment(cast
<GlobalVariable
>(GV
)) < 32)
703 return CStringSection
;
705 // Do not put 16-bit arrays in the UString section if they have an
706 // externally visible label, this runs into issues with certain linker
708 if (Kind
.isMergeable2ByteCString() && !GV
->hasExternalLinkage() &&
709 TM
.getTargetData()->getPreferredAlignment(cast
<GlobalVariable
>(GV
)) < 32)
710 return UStringSection
;
712 if (Kind
.isMergeableConst()) {
713 if (Kind
.isMergeableConst4())
714 return FourByteConstantSection
;
715 if (Kind
.isMergeableConst8())
716 return EightByteConstantSection
;
717 if (Kind
.isMergeableConst16() && SixteenByteConstantSection
)
718 return SixteenByteConstantSection
;
721 // Otherwise, if it is readonly, but not something we can specially optimize,
722 // just drop it in .const.
723 if (Kind
.isReadOnly())
724 return ReadOnlySection
;
726 // If this is marked const, put it into a const section. But if the dynamic
727 // linker needs to write to it, put it in the data segment.
728 if (Kind
.isReadOnlyWithRel())
729 return ConstDataSection
;
731 // Put zero initialized globals with strong external linkage in the
732 // DATA, __common section with the .zerofill directive.
733 if (Kind
.isBSSExtern())
734 return DataCommonSection
;
736 // Put zero initialized globals with local linkage in __DATA,__bss directive
737 // with the .zerofill directive (aka .lcomm).
738 if (Kind
.isBSSLocal())
739 return DataBSSSection
;
741 // Otherwise, just drop the variable in the normal data section.
746 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind
) const {
747 // If this constant requires a relocation, we have to put it in the data
748 // segment, not in the text segment.
749 if (Kind
.isDataRel() || Kind
.isReadOnlyWithRel())
750 return ConstDataSection
;
752 if (Kind
.isMergeableConst4())
753 return FourByteConstantSection
;
754 if (Kind
.isMergeableConst8())
755 return EightByteConstantSection
;
756 if (Kind
.isMergeableConst16() && SixteenByteConstantSection
)
757 return SixteenByteConstantSection
;
758 return ReadOnlySection
; // .const
761 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
762 /// not to emit the UsedDirective for some symbols in llvm.used.
763 // FIXME: REMOVE this (rdar://7071300)
764 bool TargetLoweringObjectFileMachO::
765 shouldEmitUsedDirectiveFor(const GlobalValue
*GV
, Mangler
*Mang
) const {
766 /// On Darwin, internally linked data beginning with "L" or "l" does not have
767 /// the directive emitted (this occurs in ObjC metadata).
768 if (!GV
) return false;
770 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
771 if (GV
->hasLocalLinkage() && !isa
<Function
>(GV
)) {
772 // FIXME: ObjC metadata is currently emitted as internal symbols that have
773 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
774 // this horrible hack can go away.
775 MCSymbol
*Sym
= Mang
->getSymbol(GV
);
776 if (Sym
->getName()[0] == 'L' || Sym
->getName()[0] == 'l')
783 const MCExpr
*TargetLoweringObjectFileMachO::
784 getExprForDwarfGlobalReference(const GlobalValue
*GV
, Mangler
*Mang
,
785 MachineModuleInfo
*MMI
, unsigned Encoding
,
786 MCStreamer
&Streamer
) const {
787 // The mach-o version of this method defaults to returning a stub reference.
789 if (Encoding
& DW_EH_PE_indirect
) {
790 MachineModuleInfoMachO
&MachOMMI
=
791 MMI
->getObjFileInfo
<MachineModuleInfoMachO
>();
793 SmallString
<128> Name
;
794 Mang
->getNameWithPrefix(Name
, GV
, true);
795 Name
+= "$non_lazy_ptr";
797 // Add information about the stub reference to MachOMMI so that the stub
798 // gets emitted by the asmprinter.
799 MCSymbol
*SSym
= getContext().GetOrCreateSymbol(Name
.str());
800 MachineModuleInfoImpl::StubValueTy
&StubSym
= MachOMMI
.getGVStubEntry(SSym
);
801 if (StubSym
.getPointer() == 0) {
802 MCSymbol
*Sym
= Mang
->getSymbol(GV
);
803 StubSym
= MachineModuleInfoImpl::StubValueTy(Sym
, !GV
->hasLocalLinkage());
806 return TargetLoweringObjectFile::
807 getExprForDwarfReference(SSym
, Mang
, MMI
,
808 Encoding
& ~dwarf::DW_EH_PE_indirect
, Streamer
);
811 return TargetLoweringObjectFile::
812 getExprForDwarfGlobalReference(GV
, Mang
, MMI
, Encoding
, Streamer
);
815 unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {
816 return DW_EH_PE_indirect
| DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;
819 unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {
820 return DW_EH_PE_pcrel
;
823 unsigned TargetLoweringObjectFileMachO::getFDEEncoding() const {
824 return DW_EH_PE_pcrel
;
827 unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {
828 return DW_EH_PE_indirect
| DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;
831 //===----------------------------------------------------------------------===//
833 //===----------------------------------------------------------------------===//
835 void TargetLoweringObjectFileCOFF::Initialize(MCContext
&Ctx
,
836 const TargetMachine
&TM
) {
837 TargetLoweringObjectFile::Initialize(Ctx
, TM
);
839 getContext().getCOFFSection(".text",
840 COFF::IMAGE_SCN_CNT_CODE
|
841 COFF::IMAGE_SCN_MEM_EXECUTE
|
842 COFF::IMAGE_SCN_MEM_READ
,
843 SectionKind::getText());
845 getContext().getCOFFSection(".data",
846 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
847 COFF::IMAGE_SCN_MEM_READ
|
848 COFF::IMAGE_SCN_MEM_WRITE
,
849 SectionKind::getDataRel());
851 getContext().getCOFFSection(".rdata",
852 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
853 COFF::IMAGE_SCN_MEM_READ
,
854 SectionKind::getReadOnly());
856 getContext().getCOFFSection(".ctors",
857 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
858 COFF::IMAGE_SCN_MEM_READ
|
859 COFF::IMAGE_SCN_MEM_WRITE
,
860 SectionKind::getDataRel());
862 getContext().getCOFFSection(".dtors",
863 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
864 COFF::IMAGE_SCN_MEM_READ
|
865 COFF::IMAGE_SCN_MEM_WRITE
,
866 SectionKind::getDataRel());
868 // FIXME: We're emitting LSDA info into a readonly section on COFF, even
869 // though it contains relocatable pointers. In PIC mode, this is probably a
870 // big runtime hit for C++ apps. Either the contents of the LSDA need to be
871 // adjusted or this should be a data section.
873 getContext().getCOFFSection(".gcc_except_table",
874 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
875 COFF::IMAGE_SCN_MEM_READ
,
876 SectionKind::getReadOnly());
879 getContext().getCOFFSection(".debug_abbrev",
880 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
881 COFF::IMAGE_SCN_MEM_READ
,
882 SectionKind::getMetadata());
884 getContext().getCOFFSection(".debug_info",
885 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
886 COFF::IMAGE_SCN_MEM_READ
,
887 SectionKind::getMetadata());
889 getContext().getCOFFSection(".debug_line",
890 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
891 COFF::IMAGE_SCN_MEM_READ
,
892 SectionKind::getMetadata());
894 getContext().getCOFFSection(".debug_frame",
895 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
896 COFF::IMAGE_SCN_MEM_READ
,
897 SectionKind::getMetadata());
898 DwarfPubNamesSection
=
899 getContext().getCOFFSection(".debug_pubnames",
900 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
901 COFF::IMAGE_SCN_MEM_READ
,
902 SectionKind::getMetadata());
903 DwarfPubTypesSection
=
904 getContext().getCOFFSection(".debug_pubtypes",
905 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
906 COFF::IMAGE_SCN_MEM_READ
,
907 SectionKind::getMetadata());
909 getContext().getCOFFSection(".debug_str",
910 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
911 COFF::IMAGE_SCN_MEM_READ
,
912 SectionKind::getMetadata());
914 getContext().getCOFFSection(".debug_loc",
915 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
916 COFF::IMAGE_SCN_MEM_READ
,
917 SectionKind::getMetadata());
918 DwarfARangesSection
=
919 getContext().getCOFFSection(".debug_aranges",
920 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
921 COFF::IMAGE_SCN_MEM_READ
,
922 SectionKind::getMetadata());
924 getContext().getCOFFSection(".debug_ranges",
925 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
926 COFF::IMAGE_SCN_MEM_READ
,
927 SectionKind::getMetadata());
928 DwarfMacroInfoSection
=
929 getContext().getCOFFSection(".debug_macinfo",
930 COFF::IMAGE_SCN_MEM_DISCARDABLE
|
931 COFF::IMAGE_SCN_MEM_READ
,
932 SectionKind::getMetadata());
935 getContext().getCOFFSection(".drectve",
936 COFF::IMAGE_SCN_LNK_INFO
,
937 SectionKind::getMetadata());
940 const MCSection
*TargetLoweringObjectFileCOFF::getEHFrameSection() const {
941 return getContext().getCOFFSection(".eh_frame",
942 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
943 COFF::IMAGE_SCN_MEM_READ
|
944 COFF::IMAGE_SCN_MEM_WRITE
,
945 SectionKind::getDataRel());
950 getCOFFSectionFlags(SectionKind K
) {
955 COFF::IMAGE_SCN_MEM_DISCARDABLE
;
958 COFF::IMAGE_SCN_MEM_EXECUTE
|
959 COFF::IMAGE_SCN_MEM_READ
|
960 COFF::IMAGE_SCN_CNT_CODE
;
963 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA
|
964 COFF::IMAGE_SCN_MEM_READ
|
965 COFF::IMAGE_SCN_MEM_WRITE
;
966 else if (K
.isReadOnly())
968 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
969 COFF::IMAGE_SCN_MEM_READ
;
970 else if (K
.isWriteable())
972 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA
|
973 COFF::IMAGE_SCN_MEM_READ
|
974 COFF::IMAGE_SCN_MEM_WRITE
;
979 const MCSection
*TargetLoweringObjectFileCOFF::
980 getExplicitSectionGlobal(const GlobalValue
*GV
, SectionKind Kind
,
981 Mangler
*Mang
, const TargetMachine
&TM
) const {
982 return getContext().getCOFFSection(GV
->getSection(),
983 getCOFFSectionFlags(Kind
),
987 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind
) {
992 if (Kind
.isWriteable())
998 const MCSection
*TargetLoweringObjectFileCOFF::
999 SelectSectionForGlobal(const GlobalValue
*GV
, SectionKind Kind
,
1000 Mangler
*Mang
, const TargetMachine
&TM
) const {
1001 assert(!Kind
.isThreadLocal() && "Doesn't support TLS");
1003 // If this global is linkonce/weak and the target handles this by emitting it
1004 // into a 'uniqued' section name, create and return the section now.
1005 if (GV
->isWeakForLinker()) {
1006 const char *Prefix
= getCOFFSectionPrefixForUniqueGlobal(Kind
);
1007 SmallString
<128> Name(Prefix
, Prefix
+strlen(Prefix
));
1008 MCSymbol
*Sym
= Mang
->getSymbol(GV
);
1009 Name
.append(Sym
->getName().begin() + 1, Sym
->getName().end());
1011 unsigned Characteristics
= getCOFFSectionFlags(Kind
);
1013 Characteristics
|= COFF::IMAGE_SCN_LNK_COMDAT
;
1015 return getContext().getCOFFSection(Name
.str(), Characteristics
,
1016 COFF::IMAGE_COMDAT_SELECT_ANY
, Kind
);
1020 return getTextSection();
1022 return getDataSection();