1 //===-- llvm/Target/TargetLoweringObjectFile.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/Target/TargetLoweringObjectFile.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"
37 //===----------------------------------------------------------------------===//
39 //===----------------------------------------------------------------------===//
41 TargetLoweringObjectFile::TargetLoweringObjectFile() : Ctx(0) {
46 StaticCtorSection = 0;
47 StaticDtorSection = 0;
51 DwarfAbbrevSection = 0;
54 DwarfFrameSection = 0;
55 DwarfPubNamesSection = 0;
56 DwarfPubTypesSection = 0;
57 DwarfDebugInlineSection = 0;
60 DwarfARangesSection = 0;
61 DwarfRangesSection = 0;
62 DwarfMacroInfoSection = 0;
65 TargetLoweringObjectFile::~TargetLoweringObjectFile() {
68 static bool isSuitableForBSS(const GlobalVariable *GV) {
69 Constant *C = GV->getInitializer();
71 // Must have zero initializer.
72 if (!C->isNullValue())
75 // Leave constant zeros in readonly constant sections, so they can be shared.
79 // If the global has an explicit section specified, don't put it in BSS.
80 if (!GV->getSection().empty())
83 // If -nozero-initialized-in-bss is specified, don't ever use BSS.
87 // Otherwise, put it in BSS!
91 /// IsNullTerminatedString - Return true if the specified constant (which is
92 /// known to have a type that is an array of 1/2/4 byte elements) ends with a
93 /// nul value and contains no other nuls in it.
94 static bool IsNullTerminatedString(const Constant *C) {
95 const ArrayType *ATy = cast<ArrayType>(C->getType());
97 // First check: is we have constant array of i8 terminated with zero
98 if (const ConstantArray *CVA = dyn_cast<ConstantArray>(C)) {
99 if (ATy->getNumElements() == 0) return false;
102 dyn_cast<ConstantInt>(CVA->getOperand(ATy->getNumElements()-1));
103 if (Null == 0 || Null->getZExtValue() != 0)
104 return false; // Not null terminated.
106 // Verify that the null doesn't occur anywhere else in the string.
107 for (unsigned i = 0, e = ATy->getNumElements()-1; i != e; ++i)
108 // Reject constantexpr elements etc.
109 if (!isa<ConstantInt>(CVA->getOperand(i)) ||
110 CVA->getOperand(i) == Null)
115 // Another possibility: [1 x i8] zeroinitializer
116 if (isa<ConstantAggregateZero>(C))
117 return ATy->getNumElements() == 1;
122 /// getKindForGlobal - This is a top-level target-independent classifier for
123 /// a global variable. Given an global variable and information from TM, it
124 /// classifies the global in a variety of ways that make various target
125 /// implementations simpler. The target implementation is free to ignore this
126 /// extra info of course.
127 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV,
128 const TargetMachine &TM){
129 assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
130 "Can only be used for global definitions");
132 Reloc::Model ReloModel = TM.getRelocationModel();
134 // Early exit - functions should be always in text sections.
135 const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
137 return SectionKind::getText();
139 // Handle thread-local data first.
140 if (GVar->isThreadLocal()) {
141 if (isSuitableForBSS(GVar))
142 return SectionKind::getThreadBSS();
143 return SectionKind::getThreadData();
146 // Variables with common linkage always get classified as common.
147 if (GVar->hasCommonLinkage())
148 return SectionKind::getCommon();
150 // Variable can be easily put to BSS section.
151 if (isSuitableForBSS(GVar)) {
152 if (GVar->hasLocalLinkage())
153 return SectionKind::getBSSLocal();
154 else if (GVar->hasExternalLinkage())
155 return SectionKind::getBSSExtern();
156 return SectionKind::getBSS();
159 Constant *C = GVar->getInitializer();
161 // If the global is marked constant, we can put it into a mergable section,
162 // a mergable string section, or general .data if it contains relocations.
163 if (GVar->isConstant()) {
164 // If the initializer for the global contains something that requires a
165 // relocation, then we may have to drop this into a wriable data section
166 // even though it is marked const.
167 switch (C->getRelocationInfo()) {
168 default: assert(0 && "unknown relocation info kind");
169 case Constant::NoRelocation:
170 // If initializer is a null-terminated string, put it in a "cstring"
171 // section of the right width.
172 if (const ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
173 if (const IntegerType *ITy =
174 dyn_cast<IntegerType>(ATy->getElementType())) {
175 if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
176 ITy->getBitWidth() == 32) &&
177 IsNullTerminatedString(C)) {
178 if (ITy->getBitWidth() == 8)
179 return SectionKind::getMergeable1ByteCString();
180 if (ITy->getBitWidth() == 16)
181 return SectionKind::getMergeable2ByteCString();
183 assert(ITy->getBitWidth() == 32 && "Unknown width");
184 return SectionKind::getMergeable4ByteCString();
189 // Otherwise, just drop it into a mergable constant section. If we have
190 // a section for this size, use it, otherwise use the arbitrary sized
192 switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
193 case 4: return SectionKind::getMergeableConst4();
194 case 8: return SectionKind::getMergeableConst8();
195 case 16: return SectionKind::getMergeableConst16();
196 default: return SectionKind::getMergeableConst();
199 case Constant::LocalRelocation:
200 // In static relocation model, the linker will resolve all addresses, so
201 // the relocation entries will actually be constants by the time the app
202 // starts up. However, we can't put this into a mergable section, because
203 // the linker doesn't take relocations into consideration when it tries to
204 // merge entries in the section.
205 if (ReloModel == Reloc::Static)
206 return SectionKind::getReadOnly();
208 // Otherwise, the dynamic linker needs to fix it up, put it in the
209 // writable data.rel.local section.
210 return SectionKind::getReadOnlyWithRelLocal();
212 case Constant::GlobalRelocations:
213 // In static relocation model, the linker will resolve all addresses, so
214 // the relocation entries will actually be constants by the time the app
215 // starts up. However, we can't put this into a mergable section, because
216 // the linker doesn't take relocations into consideration when it tries to
217 // merge entries in the section.
218 if (ReloModel == Reloc::Static)
219 return SectionKind::getReadOnly();
221 // Otherwise, the dynamic linker needs to fix it up, put it in the
222 // writable data.rel section.
223 return SectionKind::getReadOnlyWithRel();
227 // Okay, this isn't a constant. If the initializer for the global is going
228 // to require a runtime relocation by the dynamic linker, put it into a more
229 // specific section to improve startup time of the app. This coalesces these
230 // globals together onto fewer pages, improving the locality of the dynamic
232 if (ReloModel == Reloc::Static)
233 return SectionKind::getDataNoRel();
235 switch (C->getRelocationInfo()) {
236 default: assert(0 && "unknown relocation info kind");
237 case Constant::NoRelocation:
238 return SectionKind::getDataNoRel();
239 case Constant::LocalRelocation:
240 return SectionKind::getDataRelLocal();
241 case Constant::GlobalRelocations:
242 return SectionKind::getDataRel();
246 /// SectionForGlobal - This method computes the appropriate section to emit
247 /// the specified global variable or function definition. This should not
248 /// be passed external (or available externally) globals.
249 const MCSection *TargetLoweringObjectFile::
250 SectionForGlobal(const GlobalValue *GV, SectionKind Kind, Mangler *Mang,
251 const TargetMachine &TM) const {
252 // Select section name.
253 if (GV->hasSection())
254 return getExplicitSectionGlobal(GV, Kind, Mang, TM);
257 // Use default section depending on the 'type' of global
258 return SelectSectionForGlobal(GV, Kind, Mang, TM);
262 // Lame default implementation. Calculate the section name for global.
264 TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
267 const TargetMachine &TM) const{
268 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
271 return getTextSection();
273 if (Kind.isBSS() && BSSSection != 0)
276 if (Kind.isReadOnly() && ReadOnlySection != 0)
277 return ReadOnlySection;
279 return getDataSection();
282 /// getSectionForConstant - Given a mergable constant with the
283 /// specified size and relocation information, return a section that it
284 /// should be placed in.
286 TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind) const {
287 if (Kind.isReadOnly() && ReadOnlySection != 0)
288 return ReadOnlySection;
293 /// getSymbolForDwarfGlobalReference - Return an MCExpr to use for a
294 /// reference to the specified global variable from exception
295 /// handling information.
296 const MCExpr *TargetLoweringObjectFile::
297 getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
298 MachineModuleInfo *MMI, unsigned Encoding) const {
299 // FIXME: Use GetGlobalValueSymbol.
300 SmallString<128> Name;
301 Mang->getNameWithPrefix(Name, GV, false);
302 const MCSymbol *Sym = getContext().GetOrCreateSymbol(Name.str());
304 return getSymbolForDwarfReference(Sym, MMI, Encoding);
307 const MCExpr *TargetLoweringObjectFile::
308 getSymbolForDwarfReference(const MCSymbol *Sym, MachineModuleInfo *MMI,
309 unsigned Encoding) const {
310 const MCExpr *Res = MCSymbolRefExpr::Create(Sym, getContext());
312 switch (Encoding & 0xF0) {
314 llvm_report_error("Do not support this DWARF encoding yet!");
316 case dwarf::DW_EH_PE_absptr:
317 // Do nothing special
319 case dwarf::DW_EH_PE_pcrel:
321 const MCExpr *PC = MCSymbolRefExpr::Create(".", getContext());
322 Res = MCBinaryExpr::CreateSub(Res, PC, getContext());
329 unsigned TargetLoweringObjectFile::getPersonalityEncoding() const {
330 return dwarf::DW_EH_PE_absptr;
333 unsigned TargetLoweringObjectFile::getLSDAEncoding() const {
334 return dwarf::DW_EH_PE_absptr;
337 unsigned TargetLoweringObjectFile::getFDEEncoding() const {
338 return dwarf::DW_EH_PE_absptr;
341 unsigned TargetLoweringObjectFile::getTTypeEncoding() const {
342 return dwarf::DW_EH_PE_absptr;
345 //===----------------------------------------------------------------------===//
347 //===----------------------------------------------------------------------===//
348 typedef StringMap<const MCSectionELF*> ELFUniqueMapTy;
350 TargetLoweringObjectFileELF::~TargetLoweringObjectFileELF() {
351 // If we have the section uniquing map, free it.
352 delete (ELFUniqueMapTy*)UniquingMap;
355 const MCSection *TargetLoweringObjectFileELF::
356 getELFSection(StringRef Section, unsigned Type, unsigned Flags,
357 SectionKind Kind, bool IsExplicit) const {
358 if (UniquingMap == 0)
359 UniquingMap = new ELFUniqueMapTy();
360 ELFUniqueMapTy &Map = *(ELFUniqueMapTy*)UniquingMap;
362 // Do the lookup, if we have a hit, return it.
363 const MCSectionELF *&Entry = Map[Section];
364 if (Entry) return Entry;
366 return Entry = MCSectionELF::Create(Section, Type, Flags, Kind, IsExplicit,
370 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
371 const TargetMachine &TM) {
372 if (UniquingMap != 0)
373 ((ELFUniqueMapTy*)UniquingMap)->clear();
374 TargetLoweringObjectFile::Initialize(Ctx, TM);
377 getELFSection(".bss", MCSectionELF::SHT_NOBITS,
378 MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
379 SectionKind::getBSS());
382 getELFSection(".text", MCSectionELF::SHT_PROGBITS,
383 MCSectionELF::SHF_EXECINSTR | MCSectionELF::SHF_ALLOC,
384 SectionKind::getText());
387 getELFSection(".data", MCSectionELF::SHT_PROGBITS,
388 MCSectionELF::SHF_WRITE | MCSectionELF::SHF_ALLOC,
389 SectionKind::getDataRel());
392 getELFSection(".rodata", MCSectionELF::SHT_PROGBITS,
393 MCSectionELF::SHF_ALLOC,
394 SectionKind::getReadOnly());
397 getELFSection(".tdata", MCSectionELF::SHT_PROGBITS,
398 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
399 MCSectionELF::SHF_WRITE, SectionKind::getThreadData());
402 getELFSection(".tbss", MCSectionELF::SHT_NOBITS,
403 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_TLS |
404 MCSectionELF::SHF_WRITE, SectionKind::getThreadBSS());
407 getELFSection(".data.rel", MCSectionELF::SHT_PROGBITS,
408 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
409 SectionKind::getDataRel());
411 DataRelLocalSection =
412 getELFSection(".data.rel.local", MCSectionELF::SHT_PROGBITS,
413 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
414 SectionKind::getDataRelLocal());
417 getELFSection(".data.rel.ro", MCSectionELF::SHT_PROGBITS,
418 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
419 SectionKind::getReadOnlyWithRel());
421 DataRelROLocalSection =
422 getELFSection(".data.rel.ro.local", MCSectionELF::SHT_PROGBITS,
423 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
424 SectionKind::getReadOnlyWithRelLocal());
426 MergeableConst4Section =
427 getELFSection(".rodata.cst4", MCSectionELF::SHT_PROGBITS,
428 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
429 SectionKind::getMergeableConst4());
431 MergeableConst8Section =
432 getELFSection(".rodata.cst8", MCSectionELF::SHT_PROGBITS,
433 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
434 SectionKind::getMergeableConst8());
436 MergeableConst16Section =
437 getELFSection(".rodata.cst16", MCSectionELF::SHT_PROGBITS,
438 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_MERGE,
439 SectionKind::getMergeableConst16());
442 getELFSection(".ctors", MCSectionELF::SHT_PROGBITS,
443 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
444 SectionKind::getDataRel());
447 getELFSection(".dtors", MCSectionELF::SHT_PROGBITS,
448 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
449 SectionKind::getDataRel());
451 // Exception Handling Sections.
453 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
454 // it contains relocatable pointers. In PIC mode, this is probably a big
455 // runtime hit for C++ apps. Either the contents of the LSDA need to be
456 // adjusted or this should be a data section.
458 getELFSection(".gcc_except_table", MCSectionELF::SHT_PROGBITS,
459 MCSectionELF::SHF_ALLOC, SectionKind::getReadOnly());
461 getELFSection(".eh_frame", MCSectionELF::SHT_PROGBITS,
462 MCSectionELF::SHF_ALLOC | MCSectionELF::SHF_WRITE,
463 SectionKind::getDataRel());
465 // Debug Info Sections.
467 getELFSection(".debug_abbrev", MCSectionELF::SHT_PROGBITS, 0,
468 SectionKind::getMetadata());
470 getELFSection(".debug_info", MCSectionELF::SHT_PROGBITS, 0,
471 SectionKind::getMetadata());
473 getELFSection(".debug_line", MCSectionELF::SHT_PROGBITS, 0,
474 SectionKind::getMetadata());
476 getELFSection(".debug_frame", MCSectionELF::SHT_PROGBITS, 0,
477 SectionKind::getMetadata());
478 DwarfPubNamesSection =
479 getELFSection(".debug_pubnames", MCSectionELF::SHT_PROGBITS, 0,
480 SectionKind::getMetadata());
481 DwarfPubTypesSection =
482 getELFSection(".debug_pubtypes", MCSectionELF::SHT_PROGBITS, 0,
483 SectionKind::getMetadata());
485 getELFSection(".debug_str", MCSectionELF::SHT_PROGBITS, 0,
486 SectionKind::getMetadata());
488 getELFSection(".debug_loc", MCSectionELF::SHT_PROGBITS, 0,
489 SectionKind::getMetadata());
490 DwarfARangesSection =
491 getELFSection(".debug_aranges", MCSectionELF::SHT_PROGBITS, 0,
492 SectionKind::getMetadata());
494 getELFSection(".debug_ranges", MCSectionELF::SHT_PROGBITS, 0,
495 SectionKind::getMetadata());
496 DwarfMacroInfoSection =
497 getELFSection(".debug_macinfo", MCSectionELF::SHT_PROGBITS, 0,
498 SectionKind::getMetadata());
503 getELFKindForNamedSection(StringRef Name, SectionKind K) {
504 if (Name.empty() || Name[0] != '.') return K;
506 // Some lame default implementation based on some magic section names.
507 if (Name == ".bss" ||
508 Name.startswith(".bss.") ||
509 Name.startswith(".gnu.linkonce.b.") ||
510 Name.startswith(".llvm.linkonce.b.") ||
512 Name.startswith(".sbss.") ||
513 Name.startswith(".gnu.linkonce.sb.") ||
514 Name.startswith(".llvm.linkonce.sb."))
515 return SectionKind::getBSS();
517 if (Name == ".tdata" ||
518 Name.startswith(".tdata.") ||
519 Name.startswith(".gnu.linkonce.td.") ||
520 Name.startswith(".llvm.linkonce.td."))
521 return SectionKind::getThreadData();
523 if (Name == ".tbss" ||
524 Name.startswith(".tbss.") ||
525 Name.startswith(".gnu.linkonce.tb.") ||
526 Name.startswith(".llvm.linkonce.tb."))
527 return SectionKind::getThreadBSS();
533 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
535 if (Name == ".init_array")
536 return MCSectionELF::SHT_INIT_ARRAY;
538 if (Name == ".fini_array")
539 return MCSectionELF::SHT_FINI_ARRAY;
541 if (Name == ".preinit_array")
542 return MCSectionELF::SHT_PREINIT_ARRAY;
544 if (K.isBSS() || K.isThreadBSS())
545 return MCSectionELF::SHT_NOBITS;
547 return MCSectionELF::SHT_PROGBITS;
552 getELFSectionFlags(SectionKind K) {
556 Flags |= MCSectionELF::SHF_ALLOC;
559 Flags |= MCSectionELF::SHF_EXECINSTR;
562 Flags |= MCSectionELF::SHF_WRITE;
564 if (K.isThreadLocal())
565 Flags |= MCSectionELF::SHF_TLS;
567 // K.isMergeableConst() is left out to honour PR4650
568 if (K.isMergeableCString() || K.isMergeableConst4() ||
569 K.isMergeableConst8() || K.isMergeableConst16())
570 Flags |= MCSectionELF::SHF_MERGE;
572 if (K.isMergeableCString())
573 Flags |= MCSectionELF::SHF_STRINGS;
579 const MCSection *TargetLoweringObjectFileELF::
580 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
581 Mangler *Mang, const TargetMachine &TM) const {
582 StringRef SectionName = GV->getSection();
584 // Infer section flags from the section name if we can.
585 Kind = getELFKindForNamedSection(SectionName, Kind);
587 return getELFSection(SectionName,
588 getELFSectionType(SectionName, Kind),
589 getELFSectionFlags(Kind), Kind, true);
592 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
593 if (Kind.isText()) return ".gnu.linkonce.t.";
594 if (Kind.isReadOnly()) return ".gnu.linkonce.r.";
596 if (Kind.isThreadData()) return ".gnu.linkonce.td.";
597 if (Kind.isThreadBSS()) return ".gnu.linkonce.tb.";
599 if (Kind.isDataNoRel()) return ".gnu.linkonce.d.";
600 if (Kind.isDataRelLocal()) return ".gnu.linkonce.d.rel.local.";
601 if (Kind.isDataRel()) return ".gnu.linkonce.d.rel.";
602 if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
604 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
605 return ".gnu.linkonce.d.rel.ro.";
608 const MCSection *TargetLoweringObjectFileELF::
609 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
610 Mangler *Mang, const TargetMachine &TM) const {
612 // If this global is linkonce/weak and the target handles this by emitting it
613 // into a 'uniqued' section name, create and return the section now.
614 if (GV->isWeakForLinker() && !Kind.isCommon() && !Kind.isBSS()) {
615 const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
616 SmallString<128> Name;
617 Name.append(Prefix, Prefix+strlen(Prefix));
618 Mang->getNameWithPrefix(Name, GV, false);
619 return getELFSection(Name.str(), getELFSectionType(Name.str(), Kind),
620 getELFSectionFlags(Kind), Kind);
623 if (Kind.isText()) return TextSection;
625 if (Kind.isMergeable1ByteCString() ||
626 Kind.isMergeable2ByteCString() ||
627 Kind.isMergeable4ByteCString()) {
629 // We also need alignment here.
630 // FIXME: this is getting the alignment of the character, not the
631 // alignment of the global!
633 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
635 const char *SizeSpec = ".rodata.str1.";
636 if (Kind.isMergeable2ByteCString())
637 SizeSpec = ".rodata.str2.";
638 else if (Kind.isMergeable4ByteCString())
639 SizeSpec = ".rodata.str4.";
641 assert(Kind.isMergeable1ByteCString() && "unknown string width");
644 std::string Name = SizeSpec + utostr(Align);
645 return getELFSection(Name, MCSectionELF::SHT_PROGBITS,
646 MCSectionELF::SHF_ALLOC |
647 MCSectionELF::SHF_MERGE |
648 MCSectionELF::SHF_STRINGS,
652 if (Kind.isMergeableConst()) {
653 if (Kind.isMergeableConst4() && MergeableConst4Section)
654 return MergeableConst4Section;
655 if (Kind.isMergeableConst8() && MergeableConst8Section)
656 return MergeableConst8Section;
657 if (Kind.isMergeableConst16() && MergeableConst16Section)
658 return MergeableConst16Section;
659 return ReadOnlySection; // .const
662 if (Kind.isReadOnly()) return ReadOnlySection;
664 if (Kind.isThreadData()) return TLSDataSection;
665 if (Kind.isThreadBSS()) return TLSBSSSection;
667 // Note: we claim that common symbols are put in BSSSection, but they are
668 // really emitted with the magic .comm directive, which creates a symbol table
669 // entry but not a section.
670 if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
672 if (Kind.isDataNoRel()) return DataSection;
673 if (Kind.isDataRelLocal()) return DataRelLocalSection;
674 if (Kind.isDataRel()) return DataRelSection;
675 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
677 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
678 return DataRelROSection;
681 /// getSectionForConstant - Given a mergeable constant with the
682 /// specified size and relocation information, return a section that it
683 /// should be placed in.
684 const MCSection *TargetLoweringObjectFileELF::
685 getSectionForConstant(SectionKind Kind) const {
686 if (Kind.isMergeableConst4() && MergeableConst4Section)
687 return MergeableConst4Section;
688 if (Kind.isMergeableConst8() && MergeableConst8Section)
689 return MergeableConst8Section;
690 if (Kind.isMergeableConst16() && MergeableConst16Section)
691 return MergeableConst16Section;
692 if (Kind.isReadOnly())
693 return ReadOnlySection;
695 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
696 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
697 return DataRelROSection;
700 const MCExpr *TargetLoweringObjectFileELF::
701 getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
702 MachineModuleInfo *MMI, unsigned Encoding) const {
704 if (Encoding & dwarf::DW_EH_PE_indirect) {
705 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
707 SmallString<128> Name;
708 Mang->getNameWithPrefix(Name, GV, true);
711 // Add information about the stub reference to ELFMMI so that the stub
712 // gets emitted by the asmprinter.
713 MCSymbol *Sym = getContext().GetOrCreateSymbol(Name.str());
714 MCSymbol *&StubSym = ELFMMI.getGVStubEntry(Sym);
717 Mang->getNameWithPrefix(Name, GV, false);
718 StubSym = getContext().GetOrCreateSymbol(Name.str());
721 return TargetLoweringObjectFile::
722 getSymbolForDwarfReference(Sym, MMI,
723 Encoding & ~dwarf::DW_EH_PE_indirect);
726 return TargetLoweringObjectFile::
727 getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);
730 //===----------------------------------------------------------------------===//
732 //===----------------------------------------------------------------------===//
734 typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy;
736 TargetLoweringObjectFileMachO::~TargetLoweringObjectFileMachO() {
737 // If we have the MachO uniquing map, free it.
738 delete (MachOUniqueMapTy*)UniquingMap;
742 const MCSectionMachO *TargetLoweringObjectFileMachO::
743 getMachOSection(StringRef Segment, StringRef Section,
744 unsigned TypeAndAttributes,
745 unsigned Reserved2, SectionKind Kind) const {
746 // We unique sections by their segment/section pair. The returned section
747 // may not have the same flags as the requested section, if so this should be
748 // diagnosed by the client as an error.
750 // Create the map if it doesn't already exist.
751 if (UniquingMap == 0)
752 UniquingMap = new MachOUniqueMapTy();
753 MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)UniquingMap;
755 // Form the name to look up.
756 SmallString<64> Name;
761 // Do the lookup, if we have a hit, return it.
762 const MCSectionMachO *&Entry = Map[Name.str()];
763 if (Entry) return Entry;
765 // Otherwise, return a new section.
766 return Entry = MCSectionMachO::Create(Segment, Section, TypeAndAttributes,
767 Reserved2, Kind, getContext());
771 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
772 const TargetMachine &TM) {
773 if (UniquingMap != 0)
774 ((MachOUniqueMapTy*)UniquingMap)->clear();
775 TargetLoweringObjectFile::Initialize(Ctx, TM);
778 = getMachOSection("__TEXT", "__text",
779 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
780 SectionKind::getText());
782 = getMachOSection("__DATA", "__data", 0, SectionKind::getDataRel());
784 CStringSection // .cstring
785 = getMachOSection("__TEXT", "__cstring", MCSectionMachO::S_CSTRING_LITERALS,
786 SectionKind::getMergeable1ByteCString());
788 = getMachOSection("__TEXT","__ustring", 0,
789 SectionKind::getMergeable2ByteCString());
790 FourByteConstantSection // .literal4
791 = getMachOSection("__TEXT", "__literal4", MCSectionMachO::S_4BYTE_LITERALS,
792 SectionKind::getMergeableConst4());
793 EightByteConstantSection // .literal8
794 = getMachOSection("__TEXT", "__literal8", MCSectionMachO::S_8BYTE_LITERALS,
795 SectionKind::getMergeableConst8());
797 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
798 // to using it in -static mode.
799 SixteenByteConstantSection = 0;
800 if (TM.getRelocationModel() != Reloc::Static &&
801 TM.getTargetData()->getPointerSize() == 32)
802 SixteenByteConstantSection = // .literal16
803 getMachOSection("__TEXT", "__literal16",MCSectionMachO::S_16BYTE_LITERALS,
804 SectionKind::getMergeableConst16());
806 ReadOnlySection // .const
807 = getMachOSection("__TEXT", "__const", 0, SectionKind::getReadOnly());
810 = getMachOSection("__TEXT", "__textcoal_nt",
811 MCSectionMachO::S_COALESCED |
812 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
813 SectionKind::getText());
815 = getMachOSection("__TEXT", "__const_coal", MCSectionMachO::S_COALESCED,
816 SectionKind::getText());
818 = getMachOSection("__DATA","__const_coal", MCSectionMachO::S_COALESCED,
819 SectionKind::getText());
820 ConstDataSection // .const_data
821 = getMachOSection("__DATA", "__const", 0,
822 SectionKind::getReadOnlyWithRel());
824 = getMachOSection("__DATA","__datacoal_nt", MCSectionMachO::S_COALESCED,
825 SectionKind::getDataRel());
827 = getMachOSection("__DATA","__common", MCSectionMachO::S_ZEROFILL,
828 SectionKind::getBSS());
830 = getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,
831 SectionKind::getBSS());
834 LazySymbolPointerSection
835 = getMachOSection("__DATA", "__la_symbol_ptr",
836 MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
837 SectionKind::getMetadata());
838 NonLazySymbolPointerSection
839 = getMachOSection("__DATA", "__nl_symbol_ptr",
840 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
841 SectionKind::getMetadata());
843 if (TM.getRelocationModel() == Reloc::Static) {
845 = getMachOSection("__TEXT", "__constructor", 0,SectionKind::getDataRel());
847 = getMachOSection("__TEXT", "__destructor", 0, SectionKind::getDataRel());
850 = getMachOSection("__DATA", "__mod_init_func",
851 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
852 SectionKind::getDataRel());
854 = getMachOSection("__DATA", "__mod_term_func",
855 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
856 SectionKind::getDataRel());
859 // Exception Handling.
860 LSDASection = getMachOSection("__DATA", "__gcc_except_tab", 0,
861 SectionKind::getDataRel());
863 getMachOSection("__TEXT", "__eh_frame",
864 MCSectionMachO::S_COALESCED |
865 MCSectionMachO::S_ATTR_NO_TOC |
866 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
867 MCSectionMachO::S_ATTR_LIVE_SUPPORT,
868 SectionKind::getReadOnly());
870 // Debug Information.
872 getMachOSection("__DWARF", "__debug_abbrev", MCSectionMachO::S_ATTR_DEBUG,
873 SectionKind::getMetadata());
875 getMachOSection("__DWARF", "__debug_info", MCSectionMachO::S_ATTR_DEBUG,
876 SectionKind::getMetadata());
878 getMachOSection("__DWARF", "__debug_line", MCSectionMachO::S_ATTR_DEBUG,
879 SectionKind::getMetadata());
881 getMachOSection("__DWARF", "__debug_frame", MCSectionMachO::S_ATTR_DEBUG,
882 SectionKind::getMetadata());
883 DwarfPubNamesSection =
884 getMachOSection("__DWARF", "__debug_pubnames", MCSectionMachO::S_ATTR_DEBUG,
885 SectionKind::getMetadata());
886 DwarfPubTypesSection =
887 getMachOSection("__DWARF", "__debug_pubtypes", MCSectionMachO::S_ATTR_DEBUG,
888 SectionKind::getMetadata());
890 getMachOSection("__DWARF", "__debug_str", MCSectionMachO::S_ATTR_DEBUG,
891 SectionKind::getMetadata());
893 getMachOSection("__DWARF", "__debug_loc", MCSectionMachO::S_ATTR_DEBUG,
894 SectionKind::getMetadata());
895 DwarfARangesSection =
896 getMachOSection("__DWARF", "__debug_aranges", MCSectionMachO::S_ATTR_DEBUG,
897 SectionKind::getMetadata());
899 getMachOSection("__DWARF", "__debug_ranges", MCSectionMachO::S_ATTR_DEBUG,
900 SectionKind::getMetadata());
901 DwarfMacroInfoSection =
902 getMachOSection("__DWARF", "__debug_macinfo", MCSectionMachO::S_ATTR_DEBUG,
903 SectionKind::getMetadata());
904 DwarfDebugInlineSection =
905 getMachOSection("__DWARF", "__debug_inlined", MCSectionMachO::S_ATTR_DEBUG,
906 SectionKind::getMetadata());
909 const MCSection *TargetLoweringObjectFileMachO::
910 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
911 Mangler *Mang, const TargetMachine &TM) const {
912 // Parse the section specifier and create it if valid.
913 StringRef Segment, Section;
914 unsigned TAA, StubSize;
915 std::string ErrorCode =
916 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
918 if (!ErrorCode.empty()) {
919 // If invalid, report the error with llvm_report_error.
920 llvm_report_error("Global variable '" + GV->getNameStr() +
921 "' has an invalid section specifier '" + GV->getSection()+
922 "': " + ErrorCode + ".");
923 // Fall back to dropping it into the data section.
928 const MCSectionMachO *S =
929 getMachOSection(Segment, Section, TAA, StubSize, Kind);
931 // Okay, now that we got the section, verify that the TAA & StubSize agree.
932 // If the user declared multiple globals with different section flags, we need
933 // to reject it here.
934 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
935 // If invalid, report the error with llvm_report_error.
936 llvm_report_error("Global variable '" + GV->getNameStr() +
937 "' section type or attributes does not match previous"
938 " section specifier");
944 const MCSection *TargetLoweringObjectFileMachO::
945 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
946 Mangler *Mang, const TargetMachine &TM) const {
947 assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
950 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
952 // If this is weak/linkonce, put this in a coalescable section, either in text
953 // or data depending on if it is writable.
954 if (GV->isWeakForLinker()) {
955 if (Kind.isReadOnly())
956 return ConstTextCoalSection;
957 return DataCoalSection;
960 // FIXME: Alignment check should be handled by section classifier.
961 if (Kind.isMergeable1ByteCString() ||
962 Kind.isMergeable2ByteCString()) {
963 if (TM.getTargetData()->getPreferredAlignment(
964 cast<GlobalVariable>(GV)) < 32) {
965 if (Kind.isMergeable1ByteCString())
966 return CStringSection;
967 assert(Kind.isMergeable2ByteCString());
968 return UStringSection;
972 if (Kind.isMergeableConst()) {
973 if (Kind.isMergeableConst4())
974 return FourByteConstantSection;
975 if (Kind.isMergeableConst8())
976 return EightByteConstantSection;
977 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
978 return SixteenByteConstantSection;
981 // Otherwise, if it is readonly, but not something we can specially optimize,
982 // just drop it in .const.
983 if (Kind.isReadOnly())
984 return ReadOnlySection;
986 // If this is marked const, put it into a const section. But if the dynamic
987 // linker needs to write to it, put it in the data segment.
988 if (Kind.isReadOnlyWithRel())
989 return ConstDataSection;
991 // Put zero initialized globals with strong external linkage in the
992 // DATA, __common section with the .zerofill directive.
993 if (Kind.isBSSExtern())
994 return DataCommonSection;
996 // Put zero initialized globals with local linkage in __DATA,__bss directive
997 // with the .zerofill directive (aka .lcomm).
998 if (Kind.isBSSLocal())
999 return DataBSSSection;
1001 // Otherwise, just drop the variable in the normal data section.
1006 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
1007 // If this constant requires a relocation, we have to put it in the data
1008 // segment, not in the text segment.
1009 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
1010 return ConstDataSection;
1012 if (Kind.isMergeableConst4())
1013 return FourByteConstantSection;
1014 if (Kind.isMergeableConst8())
1015 return EightByteConstantSection;
1016 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
1017 return SixteenByteConstantSection;
1018 return ReadOnlySection; // .const
1021 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
1022 /// not to emit the UsedDirective for some symbols in llvm.used.
1023 // FIXME: REMOVE this (rdar://7071300)
1024 bool TargetLoweringObjectFileMachO::
1025 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
1026 /// On Darwin, internally linked data beginning with "L" or "l" does not have
1027 /// the directive emitted (this occurs in ObjC metadata).
1028 if (!GV) return false;
1030 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
1031 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
1032 // FIXME: ObjC metadata is currently emitted as internal symbols that have
1033 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
1034 // this horrible hack can go away.
1035 SmallString<64> Name;
1036 Mang->getNameWithPrefix(Name, GV, false);
1037 if (Name[0] == 'L' || Name[0] == 'l')
1044 const MCExpr *TargetLoweringObjectFileMachO::
1045 getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
1046 MachineModuleInfo *MMI, unsigned Encoding) const {
1047 // The mach-o version of this method defaults to returning a stub reference.
1049 if (Encoding & dwarf::DW_EH_PE_indirect) {
1050 SmallString<128> Name;
1051 Mang->getNameWithPrefix(Name, GV, true);
1052 Name += "$non_lazy_ptr";
1053 MCSymbol *Sym = getContext().GetOrCreateSymbol(Name.str());
1055 return TargetLoweringObjectFile::
1056 getSymbolForDwarfReference(Sym, MMI,
1057 Encoding & ~dwarf::DW_EH_PE_indirect);
1060 return TargetLoweringObjectFile::
1061 getSymbolForDwarfGlobalReference(GV, Mang, MMI, Encoding);
1065 //===----------------------------------------------------------------------===//
1067 //===----------------------------------------------------------------------===//
1069 typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy;
1071 TargetLoweringObjectFileCOFF::~TargetLoweringObjectFileCOFF() {
1072 delete (COFFUniqueMapTy*)UniquingMap;
1076 const MCSection *TargetLoweringObjectFileCOFF::
1077 getCOFFSection(StringRef Name, bool isDirective, SectionKind Kind) const {
1078 // Create the map if it doesn't already exist.
1079 if (UniquingMap == 0)
1080 UniquingMap = new MachOUniqueMapTy();
1081 COFFUniqueMapTy &Map = *(COFFUniqueMapTy*)UniquingMap;
1083 // Do the lookup, if we have a hit, return it.
1084 const MCSectionCOFF *&Entry = Map[Name];
1085 if (Entry) return Entry;
1087 return Entry = MCSectionCOFF::Create(Name, isDirective, Kind, getContext());
1090 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
1091 const TargetMachine &TM) {
1092 if (UniquingMap != 0)
1093 ((COFFUniqueMapTy*)UniquingMap)->clear();
1094 TargetLoweringObjectFile::Initialize(Ctx, TM);
1095 TextSection = getCOFFSection("\t.text", true, SectionKind::getText());
1096 DataSection = getCOFFSection("\t.data", true, SectionKind::getDataRel());
1098 getCOFFSection(".ctors", false, SectionKind::getDataRel());
1100 getCOFFSection(".dtors", false, SectionKind::getDataRel());
1102 // FIXME: We're emitting LSDA info into a readonly section on COFF, even
1103 // though it contains relocatable pointers. In PIC mode, this is probably a
1104 // big runtime hit for C++ apps. Either the contents of the LSDA need to be
1105 // adjusted or this should be a data section.
1107 getCOFFSection(".gcc_except_table", false, SectionKind::getReadOnly());
1109 getCOFFSection(".eh_frame", false, SectionKind::getDataRel());
1112 // FIXME: Don't use 'directive' mode here.
1113 DwarfAbbrevSection =
1114 getCOFFSection("\t.section\t.debug_abbrev,\"dr\"",
1115 true, SectionKind::getMetadata());
1117 getCOFFSection("\t.section\t.debug_info,\"dr\"",
1118 true, SectionKind::getMetadata());
1120 getCOFFSection("\t.section\t.debug_line,\"dr\"",
1121 true, SectionKind::getMetadata());
1123 getCOFFSection("\t.section\t.debug_frame,\"dr\"",
1124 true, SectionKind::getMetadata());
1125 DwarfPubNamesSection =
1126 getCOFFSection("\t.section\t.debug_pubnames,\"dr\"",
1127 true, SectionKind::getMetadata());
1128 DwarfPubTypesSection =
1129 getCOFFSection("\t.section\t.debug_pubtypes,\"dr\"",
1130 true, SectionKind::getMetadata());
1132 getCOFFSection("\t.section\t.debug_str,\"dr\"",
1133 true, SectionKind::getMetadata());
1135 getCOFFSection("\t.section\t.debug_loc,\"dr\"",
1136 true, SectionKind::getMetadata());
1137 DwarfARangesSection =
1138 getCOFFSection("\t.section\t.debug_aranges,\"dr\"",
1139 true, SectionKind::getMetadata());
1140 DwarfRangesSection =
1141 getCOFFSection("\t.section\t.debug_ranges,\"dr\"",
1142 true, SectionKind::getMetadata());
1143 DwarfMacroInfoSection =
1144 getCOFFSection("\t.section\t.debug_macinfo,\"dr\"",
1145 true, SectionKind::getMetadata());
1148 const MCSection *TargetLoweringObjectFileCOFF::
1149 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
1150 Mangler *Mang, const TargetMachine &TM) const {
1151 return getCOFFSection(GV->getSection(), false, Kind);
1154 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
1156 return ".text$linkonce";
1157 if (Kind.isWriteable())
1158 return ".data$linkonce";
1159 return ".rdata$linkonce";
1163 const MCSection *TargetLoweringObjectFileCOFF::
1164 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
1165 Mangler *Mang, const TargetMachine &TM) const {
1166 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
1168 // If this global is linkonce/weak and the target handles this by emitting it
1169 // into a 'uniqued' section name, create and return the section now.
1170 if (GV->isWeakForLinker()) {
1171 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
1172 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
1173 Mang->getNameWithPrefix(Name, GV, false);
1174 return getCOFFSection(Name.str(), false, Kind);
1178 return getTextSection();
1180 return getDataSection();