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, const TargetMachine &TM) const {
180 assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
181 "Can only be used for global definitions");
183 SectionKind::Kind GVKind = SectionKindForGlobal(GV, TM);
185 SectionKind Kind = SectionKind::get(GVKind, GV->isWeakForLinker(),
189 // Select section name.
190 if (GV->hasSection()) {
191 // If the target has special section hacks for specifically named globals,
193 if (const Section *TS = getSpecialCasedSectionGlobals(GV, Kind))
196 // If the target has magic semantics for certain section names, make sure to
197 // pick up the flags. This allows the user to write things with attribute
198 // section and still get the appropriate section flags printed.
199 GVKind = getKindForNamedSection(GV->getSection().c_str(), GVKind);
201 return getOrCreateSection(GV->getSection().c_str(), false, GVKind);
205 // Use default section depending on the 'type' of global
206 return SelectSectionForGlobal(GV, Kind, TM);
209 // Lame default implementation. Calculate the section name for global.
211 TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
213 const TargetMachine &TM) const{
214 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
217 return getTextSection();
219 if (Kind.isBSS() && BSSSection_ != 0)
222 if (Kind.isReadOnly() && ReadOnlySection != 0)
223 return ReadOnlySection;
225 return getDataSection();
228 /// getSectionForMergableConstant - Given a mergable constant with the
229 /// specified size and relocation information, return a section that it
230 /// should be placed in.
232 TargetLoweringObjectFile::
233 getSectionForMergeableConstant(SectionKind Kind) const {
234 if (Kind.isReadOnly() && ReadOnlySection != 0)
235 return ReadOnlySection;
241 const Section *TargetLoweringObjectFile::
242 getOrCreateSection(const char *Name, bool isDirective,
243 SectionKind::Kind Kind) const {
244 Section &S = Sections[Name];
246 // This is newly-created section, set it up properly.
247 if (S.Name.empty()) {
248 S.Kind = SectionKind::get(Kind, false /*weak*/, !isDirective);
257 //===----------------------------------------------------------------------===//
259 //===----------------------------------------------------------------------===//
261 TargetLoweringObjectFileELF::TargetLoweringObjectFileELF(bool atIsCommentChar,
263 : AtIsCommentChar(atIsCommentChar) {
266 BSSSection_ = getOrCreateSection("\t.bss", true, SectionKind::BSS);
268 // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
269 // FIXME: Does .section .bss work everywhere??
270 BSSSection_ = getOrCreateSection("\t.bss", false, SectionKind::BSS);
273 TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
274 DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
276 getOrCreateSection("\t.rodata", false, SectionKind::ReadOnly);
278 getOrCreateSection("\t.tdata", false, SectionKind::ThreadData);
279 CStringSection_ = getOrCreateSection("\t.rodata.str", true,
280 SectionKind::MergeableCString);
282 TLSBSSSection = getOrCreateSection("\t.tbss", false, SectionKind::ThreadBSS);
284 DataRelSection = getOrCreateSection("\t.data.rel", false,
285 SectionKind::DataRel);
286 DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
287 SectionKind::DataRelLocal);
288 DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
289 SectionKind::ReadOnlyWithRel);
290 DataRelROLocalSection =
291 getOrCreateSection("\t.data.rel.ro.local", false,
292 SectionKind::ReadOnlyWithRelLocal);
294 MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
295 SectionKind::MergeableConst4);
296 MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
297 SectionKind::MergeableConst8);
298 MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
299 SectionKind::MergeableConst16);
303 SectionKind::Kind TargetLoweringObjectFileELF::
304 getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
305 if (Name[0] != '.') return K;
307 // Some lame default implementation based on some magic section names.
308 if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
309 strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
310 strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
311 strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
312 return SectionKind::BSS;
314 if (strcmp(Name, ".tdata") == 0 ||
315 strncmp(Name, ".tdata.", 7) == 0 ||
316 strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
317 strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
318 return SectionKind::ThreadData;
320 if (strcmp(Name, ".tbss") == 0 ||
321 strncmp(Name, ".tbss.", 6) == 0 ||
322 strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
323 strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
324 return SectionKind::ThreadBSS;
329 void TargetLoweringObjectFileELF::
330 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
334 if (!Kind.isMetadata())
338 if (Kind.isWriteable())
340 if (Kind.isMergeableConst() || Kind.isMergeableCString())
342 if (Kind.isMergeableCString())
344 if (Kind.isThreadLocal())
350 // If comment string is '@', e.g. as on ARM - use '%' instead
360 KindStr = "progbits";
362 Str.append(KindStr, KindStr+strlen(KindStr));
364 if (Kind.isMergeableCString()) {
365 // TODO: Eventually handle multiple byte character strings. For now, all
366 // mergable C strings are single byte.
369 } else if (Kind.isMergeableConst4()) {
372 } else if (Kind.isMergeableConst8()) {
375 } else if (Kind.isMergeableConst16()) {
383 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
384 if (Kind.isText()) return ".gnu.linkonce.t.";
385 if (Kind.isReadOnly()) return ".gnu.linkonce.r.";
387 if (Kind.isThreadData()) return ".gnu.linkonce.td.";
388 if (Kind.isThreadBSS()) return ".gnu.linkonce.tb.";
390 if (Kind.isBSS()) return ".gnu.linkonce.b.";
391 if (Kind.isDataNoRel()) return ".gnu.linkonce.d.";
392 if (Kind.isDataRelLocal()) return ".gnu.linkonce.d.rel.local.";
393 if (Kind.isDataRel()) return ".gnu.linkonce.d.rel.";
394 if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
396 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
397 return ".gnu.linkonce.d.rel.ro.";
400 const Section *TargetLoweringObjectFileELF::
401 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
402 const TargetMachine &TM) const {
404 // If this global is linkonce/weak and the target handles this by emitting it
405 // into a 'uniqued' section name, create and return the section now.
407 const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
408 // FIXME: Use mangler interface (PR4584).
409 std::string Name = Prefix+GV->getNameStr();
410 return getOrCreateSection(Name.c_str(), false, Kind.getKind());
413 if (Kind.isText()) return TextSection;
414 if (Kind.isMergeableCString()) {
415 //Constant *C = cast<GlobalVariable>(GV)->getInitializer();
417 // FIXME: This is completely wrong. Why is it comparing the size of the
418 // character type to 1?
419 /// cast<ArrayType>(C->getType())->getNumElements();
422 assert(CStringSection_ && "Should have string section prefix");
424 // We also need alignment here.
425 // FIXME: this is getting the alignment of the character, not the
426 // alignment of the global!
428 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
430 std::string Name = CStringSection_->getName() + utostr(Size) + '.' +
432 return getOrCreateSection(Name.c_str(), false,
433 SectionKind::MergeableCString);
436 return ReadOnlySection;
439 if (Kind.isMergeableConst()) {
440 if (Kind.isMergeableConst4())
441 return MergeableConst4Section;
442 if (Kind.isMergeableConst8())
443 return MergeableConst8Section;
444 if (Kind.isMergeableConst16())
445 return MergeableConst16Section;
446 return ReadOnlySection; // .const
449 if (Kind.isReadOnly()) return ReadOnlySection;
451 if (Kind.isThreadData()) return TLSDataSection;
452 if (Kind.isThreadBSS()) return TLSBSSSection;
454 if (Kind.isBSS()) return BSSSection_;
456 if (Kind.isDataNoRel()) return DataSection;
457 if (Kind.isDataRelLocal()) return DataRelLocalSection;
458 if (Kind.isDataRel()) return DataRelSection;
459 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
461 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
462 return DataRelROSection;
465 /// getSectionForMergeableConstant - Given a mergeable constant with the
466 /// specified size and relocation information, return a section that it
467 /// should be placed in.
468 const Section *TargetLoweringObjectFileELF::
469 getSectionForMergeableConstant(SectionKind Kind) const {
470 if (Kind.isMergeableConst4())
471 return MergeableConst4Section;
472 if (Kind.isMergeableConst8())
473 return MergeableConst8Section;
474 if (Kind.isMergeableConst16())
475 return MergeableConst16Section;
476 if (Kind.isReadOnly())
477 return ReadOnlySection;
479 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
480 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
481 return DataRelROSection;
484 //===----------------------------------------------------------------------===//
486 //===----------------------------------------------------------------------===//
488 TargetLoweringObjectFileMachO::
489 TargetLoweringObjectFileMachO() {
490 TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
491 DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
493 CStringSection_ = getOrCreateSection("\t.cstring", true,
494 SectionKind::MergeableCString);
495 FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
496 SectionKind::MergeableConst4);
497 EightByteConstantSection = getOrCreateSection("\t.literal8\n", true,
498 SectionKind::MergeableConst8);
499 SixteenByteConstantSection =
500 getOrCreateSection("\t.literal16\n", true, SectionKind::MergeableConst16);
502 ReadOnlySection = getOrCreateSection("\t.const", true, SectionKind::ReadOnly);
505 getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
506 false, SectionKind::Text);
507 ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
508 false, SectionKind::Text);
509 ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
510 false, SectionKind::Text);
511 ConstDataSection = getOrCreateSection("\t.const_data", true,
512 SectionKind::ReadOnlyWithRel);
513 DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
514 false, SectionKind::DataRel);
518 TargetLoweringObjectFileMachO::SelectSectionForGlobal(const GlobalValue *GV,
520 const TargetMachine &TM) const {
521 assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
524 return Kind.isWeak() ? TextCoalSection : TextSection;
526 // If this is weak/linkonce, put this in a coalescable section, either in text
527 // or data depending on if it is writable.
529 if (Kind.isReadOnly())
530 return ConstTextCoalSection;
531 return DataCoalSection;
534 // FIXME: Alignment check should be handled by section classifier.
535 if (Kind.isMergeableCString()) {
536 Constant *C = cast<GlobalVariable>(GV)->getInitializer();
537 const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
538 const TargetData &TD = *TM.getTargetData();
539 unsigned Size = TD.getTypeAllocSize(Ty);
541 unsigned Align = TD.getPreferredAlignment(cast<GlobalVariable>(GV));
543 return CStringSection_;
546 return ReadOnlySection;
549 if (Kind.isMergeableConst()) {
550 if (Kind.isMergeableConst4())
551 return FourByteConstantSection;
552 if (Kind.isMergeableConst8())
553 return EightByteConstantSection;
554 if (Kind.isMergeableConst16())
555 return SixteenByteConstantSection;
556 return ReadOnlySection; // .const
559 // FIXME: ROData -> const in -static mode that is relocatable but they happen
560 // by the static linker. Why not mergeable?
561 if (Kind.isReadOnly())
562 return ReadOnlySection;
564 // If this is marked const, put it into a const section. But if the dynamic
565 // linker needs to write to it, put it in the data segment.
566 if (Kind.isReadOnlyWithRel())
567 return ConstDataSection;
569 // Otherwise, just drop the variable in the normal data section.
574 TargetLoweringObjectFileMachO::
575 getSectionForMergeableConstant(SectionKind Kind) const {
576 // If this constant requires a relocation, we have to put it in the data
577 // segment, not in the text segment.
578 if (Kind.isDataRel())
579 return ConstDataSection;
581 if (Kind.isMergeableConst4())
582 return FourByteConstantSection;
583 if (Kind.isMergeableConst8())
584 return EightByteConstantSection;
585 if (Kind.isMergeableConst16())
586 return SixteenByteConstantSection;
587 return ReadOnlySection; // .const
590 //===----------------------------------------------------------------------===//
592 //===----------------------------------------------------------------------===//
594 TargetLoweringObjectFileCOFF::TargetLoweringObjectFileCOFF() {
595 TextSection = getOrCreateSection("_text", true, SectionKind::Text);
596 DataSection = getOrCreateSection("_data", true, SectionKind::DataRel);
599 void TargetLoweringObjectFileCOFF::
600 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
601 // FIXME: Inefficient.
602 std::string Res = ",\"";
605 if (Kind.isWriteable())
609 Str.append(Res.begin(), Res.end());
612 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
614 return ".text$linkonce";
615 if (Kind.isWriteable())
616 return ".data$linkonce";
617 return ".rdata$linkonce";
621 const Section *TargetLoweringObjectFileCOFF::
622 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
623 const TargetMachine &TM) const {
624 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
626 // If this global is linkonce/weak and the target handles this by emitting it
627 // into a 'uniqued' section name, create and return the section now.
629 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
630 // FIXME: Use mangler interface (PR4584).
631 std::string Name = Prefix+GV->getNameStr();
632 return getOrCreateSection(Name.c_str(), false, Kind.getKind());
636 return getTextSection();
639 if (const Section *S = BSSSection_)
642 if (Kind.isReadOnly() && ReadOnlySection != 0)
643 return ReadOnlySection;
645 return getDataSection();