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/MCStreamer.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/Target/Mangler.h"
29 #include "llvm/Target/TargetData.h"
30 #include "llvm/Target/TargetMachine.h"
31 #include "llvm/Target/TargetOptions.h"
32 #include "llvm/Support/Dwarf.h"
33 #include "llvm/Support/ELF.h"
34 #include "llvm/Support/ErrorHandling.h"
35 #include "llvm/Support/raw_ostream.h"
36 #include "llvm/ADT/SmallString.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/ADT/Triple.h"
40 using namespace dwarf;
42 //===----------------------------------------------------------------------===//
44 //===----------------------------------------------------------------------===//
47 TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
49 MachineModuleInfo *MMI) const {
50 unsigned Encoding = getPersonalityEncoding();
51 switch (Encoding & 0x70) {
53 report_fatal_error("We do not support this DWARF encoding yet!");
54 case dwarf::DW_EH_PE_absptr:
55 return Mang->getSymbol(GV);
56 case dwarf::DW_EH_PE_pcrel: {
57 return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
58 Mang->getSymbol(GV)->getName());
63 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
64 const TargetMachine &TM,
65 const MCSymbol *Sym) const {
66 SmallString<64> NameData("DW.ref.");
67 NameData += Sym->getName();
68 MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
69 Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
70 Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
71 StringRef Prefix = ".data.";
72 NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
73 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
74 const MCSection *Sec = getContext().getELFSection(NameData,
77 SectionKind::getDataRel(),
79 Streamer.SwitchSection(Sec);
80 Streamer.EmitValueToAlignment(8);
81 Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
82 const MCExpr *E = MCConstantExpr::Create(8, getContext());
83 Streamer.EmitELFSize(Label, E);
84 Streamer.EmitLabel(Label);
86 unsigned Size = TM.getTargetData()->getPointerSize();
87 Streamer.EmitSymbolValue(Sym, Size);
91 getELFKindForNamedSection(StringRef Name, SectionKind K) {
92 // N.B.: The defaults used in here are no the same ones used in MC.
93 // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
94 // both gas and MC will produce a section with no flags. Given
95 // section(".eh_frame") gcc will produce
96 // .section .eh_frame,"a",@progbits
97 if (Name.empty() || Name[0] != '.') return K;
99 // Some lame default implementation based on some magic section names.
100 if (Name == ".bss" ||
101 Name.startswith(".bss.") ||
102 Name.startswith(".gnu.linkonce.b.") ||
103 Name.startswith(".llvm.linkonce.b.") ||
105 Name.startswith(".sbss.") ||
106 Name.startswith(".gnu.linkonce.sb.") ||
107 Name.startswith(".llvm.linkonce.sb."))
108 return SectionKind::getBSS();
110 if (Name == ".tdata" ||
111 Name.startswith(".tdata.") ||
112 Name.startswith(".gnu.linkonce.td.") ||
113 Name.startswith(".llvm.linkonce.td."))
114 return SectionKind::getThreadData();
116 if (Name == ".tbss" ||
117 Name.startswith(".tbss.") ||
118 Name.startswith(".gnu.linkonce.tb.") ||
119 Name.startswith(".llvm.linkonce.tb."))
120 return SectionKind::getThreadBSS();
126 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
128 if (Name == ".init_array")
129 return ELF::SHT_INIT_ARRAY;
131 if (Name == ".fini_array")
132 return ELF::SHT_FINI_ARRAY;
134 if (Name == ".preinit_array")
135 return ELF::SHT_PREINIT_ARRAY;
137 if (K.isBSS() || K.isThreadBSS())
138 return ELF::SHT_NOBITS;
140 return ELF::SHT_PROGBITS;
145 getELFSectionFlags(SectionKind K) {
149 Flags |= ELF::SHF_ALLOC;
152 Flags |= ELF::SHF_EXECINSTR;
155 Flags |= ELF::SHF_WRITE;
157 if (K.isThreadLocal())
158 Flags |= ELF::SHF_TLS;
160 // K.isMergeableConst() is left out to honour PR4650
161 if (K.isMergeableCString() || K.isMergeableConst4() ||
162 K.isMergeableConst8() || K.isMergeableConst16())
163 Flags |= ELF::SHF_MERGE;
165 if (K.isMergeableCString())
166 Flags |= ELF::SHF_STRINGS;
172 const MCSection *TargetLoweringObjectFileELF::
173 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
174 Mangler *Mang, const TargetMachine &TM) const {
175 StringRef SectionName = GV->getSection();
177 // Infer section flags from the section name if we can.
178 Kind = getELFKindForNamedSection(SectionName, Kind);
180 return getContext().getELFSection(SectionName,
181 getELFSectionType(SectionName, Kind),
182 getELFSectionFlags(Kind), Kind);
185 /// getSectionPrefixForGlobal - Return the section prefix name used by options
186 /// FunctionsSections and DataSections.
187 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
188 if (Kind.isText()) return ".text.";
189 if (Kind.isReadOnly()) return ".rodata.";
191 if (Kind.isThreadData()) return ".tdata.";
192 if (Kind.isThreadBSS()) return ".tbss.";
194 if (Kind.isDataNoRel()) return ".data.";
195 if (Kind.isDataRelLocal()) return ".data.rel.local.";
196 if (Kind.isDataRel()) return ".data.rel.";
197 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
199 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
200 return ".data.rel.ro.";
204 const MCSection *TargetLoweringObjectFileELF::
205 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
206 Mangler *Mang, const TargetMachine &TM) const {
207 // If we have -ffunction-section or -fdata-section then we should emit the
208 // global value to a uniqued section specifically for it.
209 bool EmitUniquedSection;
211 EmitUniquedSection = TM.getFunctionSections();
213 EmitUniquedSection = TM.getDataSections();
215 // If this global is linkonce/weak and the target handles this by emitting it
216 // into a 'uniqued' section name, create and return the section now.
217 if ((GV->isWeakForLinker() || EmitUniquedSection) &&
218 !Kind.isCommon() && !Kind.isBSS()) {
220 Prefix = getSectionPrefixForGlobal(Kind);
222 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
223 MCSymbol *Sym = Mang->getSymbol(GV);
224 Name.append(Sym->getName().begin(), Sym->getName().end());
225 StringRef Group = "";
226 unsigned Flags = getELFSectionFlags(Kind);
227 if (GV->isWeakForLinker()) {
228 Group = Sym->getName();
229 Flags |= ELF::SHF_GROUP;
232 return getContext().getELFSection(Name.str(),
233 getELFSectionType(Name.str(), Kind),
234 Flags, Kind, 0, Group);
237 if (Kind.isText()) return TextSection;
239 if (Kind.isMergeable1ByteCString() ||
240 Kind.isMergeable2ByteCString() ||
241 Kind.isMergeable4ByteCString()) {
243 // We also need alignment here.
244 // FIXME: this is getting the alignment of the character, not the
245 // alignment of the global!
247 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
249 const char *SizeSpec = ".rodata.str1.";
250 if (Kind.isMergeable2ByteCString())
251 SizeSpec = ".rodata.str2.";
252 else if (Kind.isMergeable4ByteCString())
253 SizeSpec = ".rodata.str4.";
255 assert(Kind.isMergeable1ByteCString() && "unknown string width");
258 std::string Name = SizeSpec + utostr(Align);
259 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
266 if (Kind.isMergeableConst()) {
267 if (Kind.isMergeableConst4() && MergeableConst4Section)
268 return MergeableConst4Section;
269 if (Kind.isMergeableConst8() && MergeableConst8Section)
270 return MergeableConst8Section;
271 if (Kind.isMergeableConst16() && MergeableConst16Section)
272 return MergeableConst16Section;
273 return ReadOnlySection; // .const
276 if (Kind.isReadOnly()) return ReadOnlySection;
278 if (Kind.isThreadData()) return TLSDataSection;
279 if (Kind.isThreadBSS()) return TLSBSSSection;
281 // Note: we claim that common symbols are put in BSSSection, but they are
282 // really emitted with the magic .comm directive, which creates a symbol table
283 // entry but not a section.
284 if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
286 if (Kind.isDataNoRel()) return DataSection;
287 if (Kind.isDataRelLocal()) return DataRelLocalSection;
288 if (Kind.isDataRel()) return DataRelSection;
289 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
291 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
292 return DataRelROSection;
295 /// getSectionForConstant - Given a mergeable constant with the
296 /// specified size and relocation information, return a section that it
297 /// should be placed in.
298 const MCSection *TargetLoweringObjectFileELF::
299 getSectionForConstant(SectionKind Kind) const {
300 if (Kind.isMergeableConst4() && MergeableConst4Section)
301 return MergeableConst4Section;
302 if (Kind.isMergeableConst8() && MergeableConst8Section)
303 return MergeableConst8Section;
304 if (Kind.isMergeableConst16() && MergeableConst16Section)
305 return MergeableConst16Section;
306 if (Kind.isReadOnly())
307 return ReadOnlySection;
309 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
310 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
311 return DataRelROSection;
314 const MCExpr *TargetLoweringObjectFileELF::
315 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
316 MachineModuleInfo *MMI,
317 unsigned Encoding, MCStreamer &Streamer) const {
319 if (Encoding & dwarf::DW_EH_PE_indirect) {
320 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
322 SmallString<128> Name;
323 Mang->getNameWithPrefix(Name, GV, true);
326 // Add information about the stub reference to ELFMMI so that the stub
327 // gets emitted by the asmprinter.
328 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
329 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
330 if (StubSym.getPointer() == 0) {
331 MCSymbol *Sym = Mang->getSymbol(GV);
332 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
335 return TargetLoweringObjectFile::
336 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
339 return TargetLoweringObjectFile::
340 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
343 //===----------------------------------------------------------------------===//
345 //===----------------------------------------------------------------------===//
347 const MCSection *TargetLoweringObjectFileMachO::
348 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
349 Mangler *Mang, const TargetMachine &TM) const {
350 // Parse the section specifier and create it if valid.
351 StringRef Segment, Section;
352 unsigned TAA = 0, StubSize = 0;
354 std::string ErrorCode =
355 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
356 TAA, TAAParsed, StubSize);
357 if (!ErrorCode.empty()) {
358 // If invalid, report the error with report_fatal_error.
359 report_fatal_error("Global variable '" + GV->getName() +
360 "' has an invalid section specifier '" +
361 GV->getSection() + "': " + ErrorCode + ".");
365 const MCSectionMachO *S =
366 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
368 // If TAA wasn't set by ParseSectionSpecifier() above,
369 // use the value returned by getMachOSection() as a default.
371 TAA = S->getTypeAndAttributes();
373 // Okay, now that we got the section, verify that the TAA & StubSize agree.
374 // If the user declared multiple globals with different section flags, we need
375 // to reject it here.
376 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
377 // If invalid, report the error with report_fatal_error.
378 report_fatal_error("Global variable '" + GV->getName() +
379 "' section type or attributes does not match previous"
380 " section specifier");
386 const MCSection *TargetLoweringObjectFileMachO::
387 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
388 Mangler *Mang, const TargetMachine &TM) const {
390 // Handle thread local data.
391 if (Kind.isThreadBSS()) return TLSBSSSection;
392 if (Kind.isThreadData()) return TLSDataSection;
395 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
397 // If this is weak/linkonce, put this in a coalescable section, either in text
398 // or data depending on if it is writable.
399 if (GV->isWeakForLinker()) {
400 if (Kind.isReadOnly())
401 return ConstTextCoalSection;
402 return DataCoalSection;
405 // FIXME: Alignment check should be handled by section classifier.
406 if (Kind.isMergeable1ByteCString() &&
407 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
408 return CStringSection;
410 // Do not put 16-bit arrays in the UString section if they have an
411 // externally visible label, this runs into issues with certain linker
413 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
414 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
415 return UStringSection;
417 if (Kind.isMergeableConst()) {
418 if (Kind.isMergeableConst4())
419 return FourByteConstantSection;
420 if (Kind.isMergeableConst8())
421 return EightByteConstantSection;
422 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
423 return SixteenByteConstantSection;
426 // Otherwise, if it is readonly, but not something we can specially optimize,
427 // just drop it in .const.
428 if (Kind.isReadOnly())
429 return ReadOnlySection;
431 // If this is marked const, put it into a const section. But if the dynamic
432 // linker needs to write to it, put it in the data segment.
433 if (Kind.isReadOnlyWithRel())
434 return ConstDataSection;
436 // Put zero initialized globals with strong external linkage in the
437 // DATA, __common section with the .zerofill directive.
438 if (Kind.isBSSExtern())
439 return DataCommonSection;
441 // Put zero initialized globals with local linkage in __DATA,__bss directive
442 // with the .zerofill directive (aka .lcomm).
443 if (Kind.isBSSLocal())
444 return DataBSSSection;
446 // Otherwise, just drop the variable in the normal data section.
451 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
452 // If this constant requires a relocation, we have to put it in the data
453 // segment, not in the text segment.
454 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
455 return ConstDataSection;
457 if (Kind.isMergeableConst4())
458 return FourByteConstantSection;
459 if (Kind.isMergeableConst8())
460 return EightByteConstantSection;
461 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
462 return SixteenByteConstantSection;
463 return ReadOnlySection; // .const
466 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
467 /// not to emit the UsedDirective for some symbols in llvm.used.
468 // FIXME: REMOVE this (rdar://7071300)
469 bool TargetLoweringObjectFileMachO::
470 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
471 /// On Darwin, internally linked data beginning with "L" or "l" does not have
472 /// the directive emitted (this occurs in ObjC metadata).
473 if (!GV) return false;
475 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
476 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
477 // FIXME: ObjC metadata is currently emitted as internal symbols that have
478 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
479 // this horrible hack can go away.
480 MCSymbol *Sym = Mang->getSymbol(GV);
481 if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
488 const MCExpr *TargetLoweringObjectFileMachO::
489 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
490 MachineModuleInfo *MMI, unsigned Encoding,
491 MCStreamer &Streamer) const {
492 // The mach-o version of this method defaults to returning a stub reference.
494 if (Encoding & DW_EH_PE_indirect) {
495 MachineModuleInfoMachO &MachOMMI =
496 MMI->getObjFileInfo<MachineModuleInfoMachO>();
498 SmallString<128> Name;
499 Mang->getNameWithPrefix(Name, GV, true);
500 Name += "$non_lazy_ptr";
502 // Add information about the stub reference to MachOMMI so that the stub
503 // gets emitted by the asmprinter.
504 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
505 MachineModuleInfoImpl::StubValueTy &StubSym =
506 GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
507 MachOMMI.getGVStubEntry(SSym);
508 if (StubSym.getPointer() == 0) {
509 MCSymbol *Sym = Mang->getSymbol(GV);
510 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
513 return TargetLoweringObjectFile::
514 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
517 return TargetLoweringObjectFile::
518 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
521 MCSymbol *TargetLoweringObjectFileMachO::
522 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
523 MachineModuleInfo *MMI) const {
524 // The mach-o version of this method defaults to returning a stub reference.
525 MachineModuleInfoMachO &MachOMMI =
526 MMI->getObjFileInfo<MachineModuleInfoMachO>();
528 SmallString<128> Name;
529 Mang->getNameWithPrefix(Name, GV, true);
530 Name += "$non_lazy_ptr";
532 // Add information about the stub reference to MachOMMI so that the stub
533 // gets emitted by the asmprinter.
534 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
535 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
536 if (StubSym.getPointer() == 0) {
537 MCSymbol *Sym = Mang->getSymbol(GV);
538 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
544 //===----------------------------------------------------------------------===//
546 //===----------------------------------------------------------------------===//
549 getCOFFSectionFlags(SectionKind K) {
554 COFF::IMAGE_SCN_MEM_DISCARDABLE;
557 COFF::IMAGE_SCN_MEM_EXECUTE |
558 COFF::IMAGE_SCN_MEM_READ |
559 COFF::IMAGE_SCN_CNT_CODE;
562 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
563 COFF::IMAGE_SCN_MEM_READ |
564 COFF::IMAGE_SCN_MEM_WRITE;
565 else if (K.isReadOnly())
567 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
568 COFF::IMAGE_SCN_MEM_READ;
569 else if (K.isWriteable())
571 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
572 COFF::IMAGE_SCN_MEM_READ |
573 COFF::IMAGE_SCN_MEM_WRITE;
578 const MCSection *TargetLoweringObjectFileCOFF::
579 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
580 Mangler *Mang, const TargetMachine &TM) const {
581 return getContext().getCOFFSection(GV->getSection(),
582 getCOFFSectionFlags(Kind),
586 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
591 if (Kind.isWriteable())
597 const MCSection *TargetLoweringObjectFileCOFF::
598 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
599 Mangler *Mang, const TargetMachine &TM) const {
600 assert(!Kind.isThreadLocal() && "Doesn't support TLS");
602 // If this global is linkonce/weak and the target handles this by emitting it
603 // into a 'uniqued' section name, create and return the section now.
604 if (GV->isWeakForLinker()) {
605 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
606 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
607 MCSymbol *Sym = Mang->getSymbol(GV);
608 Name.append(Sym->getName().begin() + 1, Sym->getName().end());
610 unsigned Characteristics = getCOFFSectionFlags(Kind);
612 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
614 return getContext().getCOFFSection(Name.str(), Characteristics,
615 COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
619 return getTextSection();
621 return getDataSection();