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/GlobalVariable.h"
19 #include "llvm/Target/TargetMachine.h"
20 #include "llvm/Target/TargetData.h"
21 #include "llvm/Target/TargetOptions.h"
22 #include "llvm/ADT/StringExtras.h"
25 //===----------------------------------------------------------------------===//
27 //===----------------------------------------------------------------------===//
29 TargetLoweringObjectFile::TargetLoweringObjectFile() {
39 TargetLoweringObjectFile::~TargetLoweringObjectFile() {
42 static bool isSuitableForBSS(const GlobalVariable *GV) {
43 Constant *C = GV->getInitializer();
45 // Must have zero initializer.
46 if (!C->isNullValue())
49 // Leave constant zeros in readonly constant sections, so they can be shared.
53 // If the global has an explicit section specified, don't put it in BSS.
54 if (!GV->getSection().empty())
57 // If -nozero-initialized-in-bss is specified, don't ever use BSS.
61 // Otherwise, put it in BSS!
65 static bool isConstantString(const Constant *C) {
66 // First check: is we have constant array of i8 terminated with zero
67 const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
68 // Check, if initializer is a null-terminated string
69 if (CVA && CVA->isCString())
72 // Another possibility: [1 x i8] zeroinitializer
73 if (isa<ConstantAggregateZero>(C))
74 if (const ArrayType *Ty = dyn_cast<ArrayType>(C->getType()))
75 return (Ty->getElementType() == Type::Int8Ty &&
76 Ty->getNumElements() == 1);
81 static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
82 const TargetMachine &TM) {
83 Reloc::Model ReloModel = TM.getRelocationModel();
85 // Early exit - functions should be always in text sections.
86 const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
88 return SectionKind::Text;
91 // Handle thread-local data first.
92 if (GVar->isThreadLocal()) {
93 if (isSuitableForBSS(GVar))
94 return SectionKind::ThreadBSS;
95 return SectionKind::ThreadData;
98 // Variable can be easily put to BSS section.
99 if (isSuitableForBSS(GVar))
100 return SectionKind::BSS;
102 Constant *C = GVar->getInitializer();
104 // If the global is marked constant, we can put it into a mergable section,
105 // a mergable string section, or general .data if it contains relocations.
106 if (GVar->isConstant()) {
107 // If the initializer for the global contains something that requires a
108 // relocation, then we may have to drop this into a wriable data section
109 // even though it is marked const.
110 switch (C->getRelocationInfo()) {
111 default: llvm_unreachable("unknown relocation info kind");
112 case Constant::NoRelocation:
113 // If initializer is a null-terminated string, put it in a "cstring"
114 // section if the target has it.
115 if (isConstantString(C))
116 return SectionKind::MergeableCString;
118 // Otherwise, just drop it into a mergable constant section. If we have
119 // a section for this size, use it, otherwise use the arbitrary sized
121 switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
122 case 4: return SectionKind::MergeableConst4;
123 case 8: return SectionKind::MergeableConst8;
124 case 16: return SectionKind::MergeableConst16;
125 default: return SectionKind::MergeableConst;
128 case Constant::LocalRelocation:
129 // In static relocation model, the linker will resolve all addresses, so
130 // the relocation entries will actually be constants by the time the app
131 // starts up. However, we can't put this into a mergable section, because
132 // the linker doesn't take relocations into consideration when it tries to
133 // merge entries in the section.
134 if (ReloModel == Reloc::Static)
135 return SectionKind::ReadOnly;
137 // Otherwise, the dynamic linker needs to fix it up, put it in the
138 // writable data.rel.local section.
139 return SectionKind::ReadOnlyWithRelLocal;
141 case Constant::GlobalRelocations:
142 // In static relocation model, the linker will resolve all addresses, so
143 // the relocation entries will actually be constants by the time the app
144 // starts up. However, we can't put this into a mergable section, because
145 // the linker doesn't take relocations into consideration when it tries to
146 // merge entries in the section.
147 if (ReloModel == Reloc::Static)
148 return SectionKind::ReadOnly;
150 // Otherwise, the dynamic linker needs to fix it up, put it in the
151 // writable data.rel section.
152 return SectionKind::ReadOnlyWithRel;
156 // Okay, this isn't a constant. If the initializer for the global is going
157 // to require a runtime relocation by the dynamic linker, put it into a more
158 // specific section to improve startup time of the app. This coalesces these
159 // globals together onto fewer pages, improving the locality of the dynamic
161 if (ReloModel == Reloc::Static)
162 return SectionKind::DataNoRel;
164 switch (C->getRelocationInfo()) {
165 default: llvm_unreachable("unknown relocation info kind");
166 case Constant::NoRelocation:
167 return SectionKind::DataNoRel;
168 case Constant::LocalRelocation:
169 return SectionKind::DataRelLocal;
170 case Constant::GlobalRelocations:
171 return SectionKind::DataRel;
175 /// SectionForGlobal - This method computes the appropriate section to emit
176 /// the specified global variable or function definition. This should not
177 /// be passed external (or available externally) globals.
178 const Section *TargetLoweringObjectFile::
179 SectionForGlobal(const GlobalValue *GV, Mangler *Mang,
180 const TargetMachine &TM) const {
181 assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
182 "Can only be used for global definitions");
184 SectionKind::Kind GVKind = SectionKindForGlobal(GV, TM);
186 SectionKind Kind = SectionKind::get(GVKind, GV->isWeakForLinker(),
190 // Select section name.
191 if (GV->hasSection()) {
192 // If the target has special section hacks for specifically named globals,
194 if (const Section *TS = getSpecialCasedSectionGlobals(GV, Mang, Kind))
197 // If the target has magic semantics for certain section names, make sure to
198 // pick up the flags. This allows the user to write things with attribute
199 // section and still get the appropriate section flags printed.
200 GVKind = getKindForNamedSection(GV->getSection().c_str(), GVKind);
202 return getOrCreateSection(GV->getSection().c_str(), false, GVKind);
206 // Use default section depending on the 'type' of global
207 return SelectSectionForGlobal(GV, Kind, Mang, TM);
210 // Lame default implementation. Calculate the section name for global.
212 TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
215 const TargetMachine &TM) const{
216 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
219 return getTextSection();
221 if (Kind.isBSS() && BSSSection_ != 0)
224 if (Kind.isReadOnly() && ReadOnlySection != 0)
225 return ReadOnlySection;
227 return getDataSection();
230 /// getSectionForMergableConstant - Given a mergable constant with the
231 /// specified size and relocation information, return a section that it
232 /// should be placed in.
234 TargetLoweringObjectFile::
235 getSectionForMergeableConstant(SectionKind Kind) const {
236 if (Kind.isReadOnly() && ReadOnlySection != 0)
237 return ReadOnlySection;
243 const Section *TargetLoweringObjectFile::
244 getOrCreateSection(const char *Name, bool isDirective,
245 SectionKind::Kind Kind) const {
246 Section &S = Sections[Name];
248 // This is newly-created section, set it up properly.
249 if (S.Name.empty()) {
250 S.Kind = SectionKind::get(Kind, false /*weak*/, !isDirective);
259 //===----------------------------------------------------------------------===//
261 //===----------------------------------------------------------------------===//
263 TargetLoweringObjectFileELF::TargetLoweringObjectFileELF(bool atIsCommentChar,
265 : AtIsCommentChar(atIsCommentChar) {
268 BSSSection_ = getOrCreateSection("\t.bss", true, SectionKind::BSS);
270 // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
271 // FIXME: Does .section .bss work everywhere??
272 BSSSection_ = getOrCreateSection("\t.bss", false, SectionKind::BSS);
275 TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
276 DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
278 getOrCreateSection("\t.rodata", false, SectionKind::ReadOnly);
280 getOrCreateSection("\t.tdata", false, SectionKind::ThreadData);
281 CStringSection_ = getOrCreateSection("\t.rodata.str", true,
282 SectionKind::MergeableCString);
284 TLSBSSSection = getOrCreateSection("\t.tbss", false, SectionKind::ThreadBSS);
286 DataRelSection = getOrCreateSection("\t.data.rel", false,
287 SectionKind::DataRel);
288 DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
289 SectionKind::DataRelLocal);
290 DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
291 SectionKind::ReadOnlyWithRel);
292 DataRelROLocalSection =
293 getOrCreateSection("\t.data.rel.ro.local", false,
294 SectionKind::ReadOnlyWithRelLocal);
296 MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
297 SectionKind::MergeableConst4);
298 MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
299 SectionKind::MergeableConst8);
300 MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
301 SectionKind::MergeableConst16);
305 SectionKind::Kind TargetLoweringObjectFileELF::
306 getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
307 if (Name[0] != '.') return K;
309 // Some lame default implementation based on some magic section names.
310 if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
311 strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
312 strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
313 strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
314 return SectionKind::BSS;
316 if (strcmp(Name, ".tdata") == 0 ||
317 strncmp(Name, ".tdata.", 7) == 0 ||
318 strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
319 strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
320 return SectionKind::ThreadData;
322 if (strcmp(Name, ".tbss") == 0 ||
323 strncmp(Name, ".tbss.", 6) == 0 ||
324 strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
325 strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
326 return SectionKind::ThreadBSS;
331 void TargetLoweringObjectFileELF::
332 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
336 if (!Kind.isMetadata())
340 if (Kind.isWriteable())
342 if (Kind.isMergeableConst() || Kind.isMergeableCString())
344 if (Kind.isMergeableCString())
346 if (Kind.isThreadLocal())
352 // If comment string is '@', e.g. as on ARM - use '%' instead
359 if (Kind.isBSS() || Kind.isThreadBSS())
362 KindStr = "progbits";
364 Str.append(KindStr, KindStr+strlen(KindStr));
366 if (Kind.isMergeableCString()) {
367 // TODO: Eventually handle multiple byte character strings. For now, all
368 // mergable C strings are single byte.
371 } else if (Kind.isMergeableConst4()) {
374 } else if (Kind.isMergeableConst8()) {
377 } else if (Kind.isMergeableConst16()) {
385 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
386 if (Kind.isText()) return ".gnu.linkonce.t.";
387 if (Kind.isReadOnly()) return ".gnu.linkonce.r.";
389 if (Kind.isThreadData()) return ".gnu.linkonce.td.";
390 if (Kind.isThreadBSS()) return ".gnu.linkonce.tb.";
392 if (Kind.isBSS()) return ".gnu.linkonce.b.";
393 if (Kind.isDataNoRel()) return ".gnu.linkonce.d.";
394 if (Kind.isDataRelLocal()) return ".gnu.linkonce.d.rel.local.";
395 if (Kind.isDataRel()) return ".gnu.linkonce.d.rel.";
396 if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
398 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
399 return ".gnu.linkonce.d.rel.ro.";
402 const Section *TargetLoweringObjectFileELF::
403 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
404 Mangler *Mang, const TargetMachine &TM) const {
406 // If this global is linkonce/weak and the target handles this by emitting it
407 // into a 'uniqued' section name, create and return the section now.
409 const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
410 // FIXME: Use mangler interface (PR4584).
411 std::string Name = Prefix+GV->getNameStr();
412 return getOrCreateSection(Name.c_str(), false, Kind.getKind());
415 if (Kind.isText()) return TextSection;
417 if (Kind.isMergeableCString()) {
418 assert(CStringSection_ && "Should have string section prefix");
420 // We also need alignment here.
421 // FIXME: this is getting the alignment of the character, not the
422 // alignment of the global!
424 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
426 std::string Name = CStringSection_->getName() + "1." + utostr(Align);
427 return getOrCreateSection(Name.c_str(), false,
428 SectionKind::MergeableCString);
431 if (Kind.isMergeableConst()) {
432 if (Kind.isMergeableConst4())
433 return MergeableConst4Section;
434 if (Kind.isMergeableConst8())
435 return MergeableConst8Section;
436 if (Kind.isMergeableConst16())
437 return MergeableConst16Section;
438 return ReadOnlySection; // .const
441 if (Kind.isReadOnly()) return ReadOnlySection;
443 if (Kind.isThreadData()) return TLSDataSection;
444 if (Kind.isThreadBSS()) return TLSBSSSection;
446 if (Kind.isBSS()) return BSSSection_;
448 if (Kind.isDataNoRel()) return DataSection;
449 if (Kind.isDataRelLocal()) return DataRelLocalSection;
450 if (Kind.isDataRel()) return DataRelSection;
451 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
453 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
454 return DataRelROSection;
457 /// getSectionForMergeableConstant - Given a mergeable constant with the
458 /// specified size and relocation information, return a section that it
459 /// should be placed in.
460 const Section *TargetLoweringObjectFileELF::
461 getSectionForMergeableConstant(SectionKind Kind) const {
462 if (Kind.isMergeableConst4())
463 return MergeableConst4Section;
464 if (Kind.isMergeableConst8())
465 return MergeableConst8Section;
466 if (Kind.isMergeableConst16())
467 return MergeableConst16Section;
468 if (Kind.isReadOnly())
469 return ReadOnlySection;
471 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
472 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
473 return DataRelROSection;
476 //===----------------------------------------------------------------------===//
478 //===----------------------------------------------------------------------===//
480 TargetLoweringObjectFileMachO::
481 TargetLoweringObjectFileMachO(const TargetMachine &TM) {
482 TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
483 DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
485 CStringSection_ = getOrCreateSection("\t.cstring", true,
486 SectionKind::MergeableCString);
487 FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
488 SectionKind::MergeableConst4);
489 EightByteConstantSection = getOrCreateSection("\t.literal8\n", true,
490 SectionKind::MergeableConst8);
492 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
493 // to using it in -static mode.
494 if (TM.getRelocationModel() != Reloc::Static &&
495 TM.getTargetData()->getPointerSize() == 32)
496 SixteenByteConstantSection =
497 getOrCreateSection("\t.literal16\n", true, SectionKind::MergeableConst16);
499 SixteenByteConstantSection = 0;
501 ReadOnlySection = getOrCreateSection("\t.const", true, SectionKind::ReadOnly);
504 getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
505 false, SectionKind::Text);
506 ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
507 false, SectionKind::Text);
508 ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
509 false, SectionKind::Text);
510 ConstDataSection = getOrCreateSection("\t.const_data", true,
511 SectionKind::ReadOnlyWithRel);
512 DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
513 false, SectionKind::DataRel);
516 const Section *TargetLoweringObjectFileMachO::
517 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
518 Mangler *Mang, const TargetMachine &TM) const {
519 assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
522 return Kind.isWeak() ? TextCoalSection : TextSection;
524 // If this is weak/linkonce, put this in a coalescable section, either in text
525 // or data depending on if it is writable.
527 if (Kind.isReadOnly())
528 return ConstTextCoalSection;
529 return DataCoalSection;
532 // FIXME: Alignment check should be handled by section classifier.
533 if (Kind.isMergeableCString()) {
534 Constant *C = cast<GlobalVariable>(GV)->getInitializer();
535 const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
536 const TargetData &TD = *TM.getTargetData();
537 unsigned Size = TD.getTypeAllocSize(Ty);
539 unsigned Align = TD.getPreferredAlignment(cast<GlobalVariable>(GV));
541 return CStringSection_;
544 return ReadOnlySection;
547 if (Kind.isMergeableConst()) {
548 if (Kind.isMergeableConst4())
549 return FourByteConstantSection;
550 if (Kind.isMergeableConst8())
551 return EightByteConstantSection;
552 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
553 return SixteenByteConstantSection;
554 return ReadOnlySection; // .const
557 // FIXME: ROData -> const in -static mode that is relocatable but they happen
558 // by the static linker. Why not mergeable?
559 if (Kind.isReadOnly())
560 return ReadOnlySection;
562 // If this is marked const, put it into a const section. But if the dynamic
563 // linker needs to write to it, put it in the data segment.
564 if (Kind.isReadOnlyWithRel())
565 return ConstDataSection;
567 // Otherwise, just drop the variable in the normal data section.
572 TargetLoweringObjectFileMachO::
573 getSectionForMergeableConstant(SectionKind Kind) const {
574 // If this constant requires a relocation, we have to put it in the data
575 // segment, not in the text segment.
576 if (Kind.isDataRel())
577 return ConstDataSection;
579 if (Kind.isMergeableConst4())
580 return FourByteConstantSection;
581 if (Kind.isMergeableConst8())
582 return EightByteConstantSection;
583 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
584 return SixteenByteConstantSection;
585 return ReadOnlySection; // .const
588 //===----------------------------------------------------------------------===//
590 //===----------------------------------------------------------------------===//
592 TargetLoweringObjectFileCOFF::TargetLoweringObjectFileCOFF() {
593 TextSection = getOrCreateSection("_text", true, SectionKind::Text);
594 DataSection = getOrCreateSection("_data", true, SectionKind::DataRel);
597 void TargetLoweringObjectFileCOFF::
598 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
599 // FIXME: Inefficient.
600 std::string Res = ",\"";
603 if (Kind.isWriteable())
607 Str.append(Res.begin(), Res.end());
610 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
612 return ".text$linkonce";
613 if (Kind.isWriteable())
614 return ".data$linkonce";
615 return ".rdata$linkonce";
619 const Section *TargetLoweringObjectFileCOFF::
620 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
621 Mangler *Mang, const TargetMachine &TM) const {
622 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
624 // If this global is linkonce/weak and the target handles this by emitting it
625 // into a 'uniqued' section name, create and return the section now.
627 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
628 // FIXME: Use mangler interface (PR4584).
629 std::string Name = Prefix+GV->getNameStr();
630 return getOrCreateSection(Name.c_str(), false, Kind.getKind());
634 return getTextSection();
637 if (const Section *S = BSSSection_)
640 if (Kind.isReadOnly() && ReadOnlySection != 0)
641 return ReadOnlySection;
643 return getDataSection();