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/Module.h"
21 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
22 #include "llvm/MC/MCContext.h"
23 #include "llvm/MC/MCExpr.h"
24 #include "llvm/MC/MCSectionMachO.h"
25 #include "llvm/MC/MCSectionELF.h"
26 #include "llvm/MC/MCSectionCOFF.h"
27 #include "llvm/MC/MCStreamer.h"
28 #include "llvm/MC/MCSymbol.h"
29 #include "llvm/Target/Mangler.h"
30 #include "llvm/DataLayout.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetOptions.h"
33 #include "llvm/Support/Dwarf.h"
34 #include "llvm/Support/ELF.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include "llvm/Support/raw_ostream.h"
37 #include "llvm/ADT/SmallString.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/ADT/Triple.h"
41 using namespace dwarf;
43 //===----------------------------------------------------------------------===//
45 //===----------------------------------------------------------------------===//
48 TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
50 MachineModuleInfo *MMI) const {
51 unsigned Encoding = getPersonalityEncoding();
52 switch (Encoding & 0x70) {
54 report_fatal_error("We do not support this DWARF encoding yet!");
55 case dwarf::DW_EH_PE_absptr:
56 return Mang->getSymbol(GV);
57 case dwarf::DW_EH_PE_pcrel: {
58 return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
59 Mang->getSymbol(GV)->getName());
64 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
65 const TargetMachine &TM,
66 const MCSymbol *Sym) const {
67 SmallString<64> NameData("DW.ref.");
68 NameData += Sym->getName();
69 MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
70 Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
71 Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
72 StringRef Prefix = ".data.";
73 NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
74 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
75 const MCSection *Sec = getContext().getELFSection(NameData,
78 SectionKind::getDataRel(),
80 unsigned Size = TM.getDataLayout()->getPointerSize(0);
81 Streamer.SwitchSection(Sec);
82 Streamer.EmitValueToAlignment(TM.getDataLayout()->getPointerABIAlignment(0));
83 Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
84 const MCExpr *E = MCConstantExpr::Create(Size, getContext());
85 Streamer.EmitELFSize(Label, E);
86 Streamer.EmitLabel(Label);
88 Streamer.EmitSymbolValue(Sym, Size);
92 getELFKindForNamedSection(StringRef Name, SectionKind K) {
93 // N.B.: The defaults used in here are no the same ones used in MC.
94 // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
95 // both gas and MC will produce a section with no flags. Given
96 // section(".eh_frame") gcc will produce:
98 // .section .eh_frame,"a",@progbits
99 if (Name.empty() || Name[0] != '.') return K;
101 // Some lame default implementation based on some magic section names.
102 if (Name == ".bss" ||
103 Name.startswith(".bss.") ||
104 Name.startswith(".gnu.linkonce.b.") ||
105 Name.startswith(".llvm.linkonce.b.") ||
107 Name.startswith(".sbss.") ||
108 Name.startswith(".gnu.linkonce.sb.") ||
109 Name.startswith(".llvm.linkonce.sb."))
110 return SectionKind::getBSS();
112 if (Name == ".tdata" ||
113 Name.startswith(".tdata.") ||
114 Name.startswith(".gnu.linkonce.td.") ||
115 Name.startswith(".llvm.linkonce.td."))
116 return SectionKind::getThreadData();
118 if (Name == ".tbss" ||
119 Name.startswith(".tbss.") ||
120 Name.startswith(".gnu.linkonce.tb.") ||
121 Name.startswith(".llvm.linkonce.tb."))
122 return SectionKind::getThreadBSS();
128 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
130 if (Name == ".init_array")
131 return ELF::SHT_INIT_ARRAY;
133 if (Name == ".fini_array")
134 return ELF::SHT_FINI_ARRAY;
136 if (Name == ".preinit_array")
137 return ELF::SHT_PREINIT_ARRAY;
139 if (K.isBSS() || K.isThreadBSS())
140 return ELF::SHT_NOBITS;
142 return ELF::SHT_PROGBITS;
147 getELFSectionFlags(SectionKind K) {
151 Flags |= ELF::SHF_ALLOC;
154 Flags |= ELF::SHF_EXECINSTR;
157 Flags |= ELF::SHF_WRITE;
159 if (K.isThreadLocal())
160 Flags |= ELF::SHF_TLS;
162 // K.isMergeableConst() is left out to honour PR4650
163 if (K.isMergeableCString() || K.isMergeableConst4() ||
164 K.isMergeableConst8() || K.isMergeableConst16())
165 Flags |= ELF::SHF_MERGE;
167 if (K.isMergeableCString())
168 Flags |= ELF::SHF_STRINGS;
174 const MCSection *TargetLoweringObjectFileELF::
175 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
176 Mangler *Mang, const TargetMachine &TM) const {
177 StringRef SectionName = GV->getSection();
179 // Infer section flags from the section name if we can.
180 Kind = getELFKindForNamedSection(SectionName, Kind);
182 return getContext().getELFSection(SectionName,
183 getELFSectionType(SectionName, Kind),
184 getELFSectionFlags(Kind), Kind);
187 /// getSectionPrefixForGlobal - Return the section prefix name used by options
188 /// FunctionsSections and DataSections.
189 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
190 if (Kind.isText()) return ".text.";
191 if (Kind.isReadOnly()) return ".rodata.";
192 if (Kind.isBSS()) return ".bss.";
194 if (Kind.isThreadData()) return ".tdata.";
195 if (Kind.isThreadBSS()) return ".tbss.";
197 if (Kind.isDataNoRel()) return ".data.";
198 if (Kind.isDataRelLocal()) return ".data.rel.local.";
199 if (Kind.isDataRel()) return ".data.rel.";
200 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
202 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
203 return ".data.rel.ro.";
207 const MCSection *TargetLoweringObjectFileELF::
208 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
209 Mangler *Mang, const TargetMachine &TM) const {
210 // If we have -ffunction-section or -fdata-section then we should emit the
211 // global value to a uniqued section specifically for it.
212 bool EmitUniquedSection;
214 EmitUniquedSection = TM.getFunctionSections();
216 EmitUniquedSection = TM.getDataSections();
218 // If this global is linkonce/weak and the target handles this by emitting it
219 // into a 'uniqued' section name, create and return the section now.
220 if ((GV->isWeakForLinker() || EmitUniquedSection) &&
223 Prefix = getSectionPrefixForGlobal(Kind);
225 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
226 MCSymbol *Sym = Mang->getSymbol(GV);
227 Name.append(Sym->getName().begin(), Sym->getName().end());
228 StringRef Group = "";
229 unsigned Flags = getELFSectionFlags(Kind);
230 if (GV->isWeakForLinker()) {
231 Group = Sym->getName();
232 Flags |= ELF::SHF_GROUP;
235 return getContext().getELFSection(Name.str(),
236 getELFSectionType(Name.str(), Kind),
237 Flags, Kind, 0, Group);
240 if (Kind.isText()) return TextSection;
242 if (Kind.isMergeable1ByteCString() ||
243 Kind.isMergeable2ByteCString() ||
244 Kind.isMergeable4ByteCString()) {
246 // We also need alignment here.
247 // FIXME: this is getting the alignment of the character, not the
248 // alignment of the global!
250 TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV));
252 const char *SizeSpec = ".rodata.str1.";
253 if (Kind.isMergeable2ByteCString())
254 SizeSpec = ".rodata.str2.";
255 else if (Kind.isMergeable4ByteCString())
256 SizeSpec = ".rodata.str4.";
258 assert(Kind.isMergeable1ByteCString() && "unknown string width");
261 std::string Name = SizeSpec + utostr(Align);
262 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
269 if (Kind.isMergeableConst()) {
270 if (Kind.isMergeableConst4() && MergeableConst4Section)
271 return MergeableConst4Section;
272 if (Kind.isMergeableConst8() && MergeableConst8Section)
273 return MergeableConst8Section;
274 if (Kind.isMergeableConst16() && MergeableConst16Section)
275 return MergeableConst16Section;
276 return ReadOnlySection; // .const
279 if (Kind.isReadOnly()) return ReadOnlySection;
281 if (Kind.isThreadData()) return TLSDataSection;
282 if (Kind.isThreadBSS()) return TLSBSSSection;
284 // Note: we claim that common symbols are put in BSSSection, but they are
285 // really emitted with the magic .comm directive, which creates a symbol table
286 // entry but not a section.
287 if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
289 if (Kind.isDataNoRel()) return DataSection;
290 if (Kind.isDataRelLocal()) return DataRelLocalSection;
291 if (Kind.isDataRel()) return DataRelSection;
292 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
294 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
295 return DataRelROSection;
298 /// getSectionForConstant - Given a mergeable constant with the
299 /// specified size and relocation information, return a section that it
300 /// should be placed in.
301 const MCSection *TargetLoweringObjectFileELF::
302 getSectionForConstant(SectionKind Kind) const {
303 if (Kind.isMergeableConst4() && MergeableConst4Section)
304 return MergeableConst4Section;
305 if (Kind.isMergeableConst8() && MergeableConst8Section)
306 return MergeableConst8Section;
307 if (Kind.isMergeableConst16() && MergeableConst16Section)
308 return MergeableConst16Section;
309 if (Kind.isReadOnly())
310 return ReadOnlySection;
312 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
313 assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
314 return DataRelROSection;
317 const MCExpr *TargetLoweringObjectFileELF::
318 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
319 MachineModuleInfo *MMI,
320 unsigned Encoding, MCStreamer &Streamer) const {
322 if (Encoding & dwarf::DW_EH_PE_indirect) {
323 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
325 SmallString<128> Name;
326 Mang->getNameWithPrefix(Name, GV, true);
329 // Add information about the stub reference to ELFMMI so that the stub
330 // gets emitted by the asmprinter.
331 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
332 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
333 if (StubSym.getPointer() == 0) {
334 MCSymbol *Sym = Mang->getSymbol(GV);
335 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
338 return TargetLoweringObjectFile::
339 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
342 return TargetLoweringObjectFile::
343 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
347 TargetLoweringObjectFileELF::getStaticCtorSection(unsigned Priority) const {
348 // The default scheme is .ctor / .dtor, so we have to invert the priority
350 if (Priority == 65535)
351 return StaticCtorSection;
354 std::string Name = std::string(".init_array.") + utostr(Priority);
355 return getContext().getELFSection(Name, ELF::SHT_INIT_ARRAY,
356 ELF::SHF_ALLOC | ELF::SHF_WRITE,
357 SectionKind::getDataRel());
359 std::string Name = std::string(".ctors.") + utostr(65535 - Priority);
360 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
361 ELF::SHF_ALLOC |ELF::SHF_WRITE,
362 SectionKind::getDataRel());
367 TargetLoweringObjectFileELF::getStaticDtorSection(unsigned Priority) const {
368 // The default scheme is .ctor / .dtor, so we have to invert the priority
370 if (Priority == 65535)
371 return StaticDtorSection;
374 std::string Name = std::string(".fini_array.") + utostr(Priority);
375 return getContext().getELFSection(Name, ELF::SHT_FINI_ARRAY,
376 ELF::SHF_ALLOC | ELF::SHF_WRITE,
377 SectionKind::getDataRel());
379 std::string Name = std::string(".dtors.") + utostr(65535 - Priority);
380 return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
381 ELF::SHF_ALLOC |ELF::SHF_WRITE,
382 SectionKind::getDataRel());
387 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
388 UseInitArray = UseInitArray_;
393 getContext().getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
396 SectionKind::getDataRel());
398 getContext().getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
401 SectionKind::getDataRel());
404 //===----------------------------------------------------------------------===//
406 //===----------------------------------------------------------------------===//
408 /// emitModuleFlags - Emit the module flags that specify the garbage collection
410 void TargetLoweringObjectFileMachO::
411 emitModuleFlags(MCStreamer &Streamer,
412 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
413 Mangler *Mang, const TargetMachine &TM) const {
414 unsigned VersionVal = 0;
415 unsigned ImageInfoFlags = 0;
416 StringRef SectionVal;
418 for (ArrayRef<Module::ModuleFlagEntry>::iterator
419 i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
420 const Module::ModuleFlagEntry &MFE = *i;
422 // Ignore flags with 'Require' behavior.
423 if (MFE.Behavior == Module::Require)
426 StringRef Key = MFE.Key->getString();
427 Value *Val = MFE.Val;
429 if (Key == "Objective-C Image Info Version")
430 VersionVal = cast<ConstantInt>(Val)->getZExtValue();
431 else if (Key == "Objective-C Garbage Collection" ||
432 Key == "Objective-C GC Only" ||
433 Key == "Objective-C Is Simulated")
434 ImageInfoFlags |= cast<ConstantInt>(Val)->getZExtValue();
435 else if (Key == "Objective-C Image Info Section")
436 SectionVal = cast<MDString>(Val)->getString();
439 // The section is mandatory. If we don't have it, then we don't have GC info.
440 if (SectionVal.empty()) return;
442 StringRef Segment, Section;
443 unsigned TAA = 0, StubSize = 0;
445 std::string ErrorCode =
446 MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
447 TAA, TAAParsed, StubSize);
448 if (!ErrorCode.empty())
449 // If invalid, report the error with report_fatal_error.
450 report_fatal_error("Invalid section specifier '" + Section + "': " +
454 const MCSectionMachO *S =
455 getContext().getMachOSection(Segment, Section, TAA, StubSize,
456 SectionKind::getDataNoRel());
457 Streamer.SwitchSection(S);
458 Streamer.EmitLabel(getContext().
459 GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
460 Streamer.EmitIntValue(VersionVal, 4);
461 Streamer.EmitIntValue(ImageInfoFlags, 4);
462 Streamer.AddBlankLine();
465 const MCSection *TargetLoweringObjectFileMachO::
466 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
467 Mangler *Mang, const TargetMachine &TM) const {
468 // Parse the section specifier and create it if valid.
469 StringRef Segment, Section;
470 unsigned TAA = 0, StubSize = 0;
472 std::string ErrorCode =
473 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
474 TAA, TAAParsed, StubSize);
475 if (!ErrorCode.empty()) {
476 // If invalid, report the error with report_fatal_error.
477 report_fatal_error("Global variable '" + GV->getName() +
478 "' has an invalid section specifier '" +
479 GV->getSection() + "': " + ErrorCode + ".");
483 const MCSectionMachO *S =
484 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
486 // If TAA wasn't set by ParseSectionSpecifier() above,
487 // use the value returned by getMachOSection() as a default.
489 TAA = S->getTypeAndAttributes();
491 // Okay, now that we got the section, verify that the TAA & StubSize agree.
492 // If the user declared multiple globals with different section flags, we need
493 // to reject it here.
494 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
495 // If invalid, report the error with report_fatal_error.
496 report_fatal_error("Global variable '" + GV->getName() +
497 "' section type or attributes does not match previous"
498 " section specifier");
504 const MCSection *TargetLoweringObjectFileMachO::
505 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
506 Mangler *Mang, const TargetMachine &TM) const {
508 // Handle thread local data.
509 if (Kind.isThreadBSS()) return TLSBSSSection;
510 if (Kind.isThreadData()) return TLSDataSection;
513 return GV->isWeakForLinker() ? TextCoalSection : TextSection;
515 // If this is weak/linkonce, put this in a coalescable section, either in text
516 // or data depending on if it is writable.
517 if (GV->isWeakForLinker()) {
518 if (Kind.isReadOnly())
519 return ConstTextCoalSection;
520 return DataCoalSection;
523 // FIXME: Alignment check should be handled by section classifier.
524 if (Kind.isMergeable1ByteCString() &&
525 TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
526 return CStringSection;
528 // Do not put 16-bit arrays in the UString section if they have an
529 // externally visible label, this runs into issues with certain linker
531 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
532 TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
533 return UStringSection;
535 if (Kind.isMergeableConst()) {
536 if (Kind.isMergeableConst4())
537 return FourByteConstantSection;
538 if (Kind.isMergeableConst8())
539 return EightByteConstantSection;
540 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
541 return SixteenByteConstantSection;
544 // Otherwise, if it is readonly, but not something we can specially optimize,
545 // just drop it in .const.
546 if (Kind.isReadOnly())
547 return ReadOnlySection;
549 // If this is marked const, put it into a const section. But if the dynamic
550 // linker needs to write to it, put it in the data segment.
551 if (Kind.isReadOnlyWithRel())
552 return ConstDataSection;
554 // Put zero initialized globals with strong external linkage in the
555 // DATA, __common section with the .zerofill directive.
556 if (Kind.isBSSExtern())
557 return DataCommonSection;
559 // Put zero initialized globals with local linkage in __DATA,__bss directive
560 // with the .zerofill directive (aka .lcomm).
561 if (Kind.isBSSLocal())
562 return DataBSSSection;
564 // Otherwise, just drop the variable in the normal data section.
569 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
570 // If this constant requires a relocation, we have to put it in the data
571 // segment, not in the text segment.
572 if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
573 return ConstDataSection;
575 if (Kind.isMergeableConst4())
576 return FourByteConstantSection;
577 if (Kind.isMergeableConst8())
578 return EightByteConstantSection;
579 if (Kind.isMergeableConst16() && SixteenByteConstantSection)
580 return SixteenByteConstantSection;
581 return ReadOnlySection; // .const
584 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
585 /// not to emit the UsedDirective for some symbols in llvm.used.
586 // FIXME: REMOVE this (rdar://7071300)
587 bool TargetLoweringObjectFileMachO::
588 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
589 /// On Darwin, internally linked data beginning with "L" or "l" does not have
590 /// the directive emitted (this occurs in ObjC metadata).
591 if (!GV) return false;
593 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
594 if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
595 // FIXME: ObjC metadata is currently emitted as internal symbols that have
596 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and
597 // this horrible hack can go away.
598 MCSymbol *Sym = Mang->getSymbol(GV);
599 if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
606 const MCExpr *TargetLoweringObjectFileMachO::
607 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
608 MachineModuleInfo *MMI, unsigned Encoding,
609 MCStreamer &Streamer) const {
610 // The mach-o version of this method defaults to returning a stub reference.
612 if (Encoding & DW_EH_PE_indirect) {
613 MachineModuleInfoMachO &MachOMMI =
614 MMI->getObjFileInfo<MachineModuleInfoMachO>();
616 SmallString<128> Name;
617 Mang->getNameWithPrefix(Name, GV, true);
618 Name += "$non_lazy_ptr";
620 // Add information about the stub reference to MachOMMI so that the stub
621 // gets emitted by the asmprinter.
622 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
623 MachineModuleInfoImpl::StubValueTy &StubSym =
624 GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
625 MachOMMI.getGVStubEntry(SSym);
626 if (StubSym.getPointer() == 0) {
627 MCSymbol *Sym = Mang->getSymbol(GV);
628 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
631 return TargetLoweringObjectFile::
632 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
635 return TargetLoweringObjectFile::
636 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
639 MCSymbol *TargetLoweringObjectFileMachO::
640 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
641 MachineModuleInfo *MMI) const {
642 // The mach-o version of this method defaults to returning a stub reference.
643 MachineModuleInfoMachO &MachOMMI =
644 MMI->getObjFileInfo<MachineModuleInfoMachO>();
646 SmallString<128> Name;
647 Mang->getNameWithPrefix(Name, GV, true);
648 Name += "$non_lazy_ptr";
650 // Add information about the stub reference to MachOMMI so that the stub
651 // gets emitted by the asmprinter.
652 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
653 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
654 if (StubSym.getPointer() == 0) {
655 MCSymbol *Sym = Mang->getSymbol(GV);
656 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
662 //===----------------------------------------------------------------------===//
664 //===----------------------------------------------------------------------===//
667 getCOFFSectionFlags(SectionKind K) {
672 COFF::IMAGE_SCN_MEM_DISCARDABLE;
675 COFF::IMAGE_SCN_MEM_EXECUTE |
676 COFF::IMAGE_SCN_MEM_READ |
677 COFF::IMAGE_SCN_CNT_CODE;
680 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
681 COFF::IMAGE_SCN_MEM_READ |
682 COFF::IMAGE_SCN_MEM_WRITE;
683 else if (K.isThreadLocal())
685 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
686 COFF::IMAGE_SCN_MEM_READ |
687 COFF::IMAGE_SCN_MEM_WRITE;
688 else if (K.isReadOnly())
690 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
691 COFF::IMAGE_SCN_MEM_READ;
692 else if (K.isWriteable())
694 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
695 COFF::IMAGE_SCN_MEM_READ |
696 COFF::IMAGE_SCN_MEM_WRITE;
701 const MCSection *TargetLoweringObjectFileCOFF::
702 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
703 Mangler *Mang, const TargetMachine &TM) const {
704 return getContext().getCOFFSection(GV->getSection(),
705 getCOFFSectionFlags(Kind),
709 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
714 if (Kind.isThreadLocal())
716 if (Kind.isWriteable())
722 const MCSection *TargetLoweringObjectFileCOFF::
723 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
724 Mangler *Mang, const TargetMachine &TM) const {
726 // If this global is linkonce/weak and the target handles this by emitting it
727 // into a 'uniqued' section name, create and return the section now.
728 if (GV->isWeakForLinker()) {
729 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
730 SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
731 MCSymbol *Sym = Mang->getSymbol(GV);
732 Name.append(Sym->getName().begin() + 1, Sym->getName().end());
734 unsigned Characteristics = getCOFFSectionFlags(Kind);
736 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
738 return getContext().getCOFFSection(Name.str(), Characteristics,
739 COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
743 return getTextSection();
745 if (Kind.isThreadLocal())
746 return getTLSDataSection();
748 return getDataSection();