xref: /llvm-project/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp (revision e42af3699bf6d7d14efd6cb0bb976aa0588549a9) 
1 //===-- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info --===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements classes used to handle lowerings specific to common
11 // object file formats.
12 //
13 //===----------------------------------------------------------------------===//
14 
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"
40 using namespace llvm;
41 using namespace dwarf;
42 
43 //===----------------------------------------------------------------------===//
44 //                                  ELF
45 //===----------------------------------------------------------------------===//
46 
47 MCSymbol *
48 TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
49                                                      Mangler *Mang,
50                                                 MachineModuleInfo *MMI) const {
51   unsigned Encoding = getPersonalityEncoding();
52   switch (Encoding & 0x70) {
53   default:
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());
60   }
61   }
62 }
63 
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,
76                                                     ELF::SHT_PROGBITS,
77                                                     Flags,
78                                                     SectionKind::getDataRel(),
79                                                     0, Label->getName());
80   unsigned Size = TM.getDataLayout()->getPointerSize();
81   Streamer.SwitchSection(Sec);
82   Streamer.EmitValueToAlignment(TM.getDataLayout()->getPointerABIAlignment());
83   Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
84   const MCExpr *E = MCConstantExpr::Create(Size, getContext());
85   Streamer.EmitELFSize(Label, E);
86   Streamer.EmitLabel(Label);
87 
88   Streamer.EmitSymbolValue(Sym, Size);
89 }
90 
91 const MCExpr *TargetLoweringObjectFileELF::
92 getTTypeGlobalReference(const GlobalValue *GV, Mangler *Mang,
93                         MachineModuleInfo *MMI, unsigned Encoding,
94                         MCStreamer &Streamer) const {
95 
96   if (Encoding & dwarf::DW_EH_PE_indirect) {
97     MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
98 
99     SmallString<128> Name;
100     Mang->getNameWithPrefix(Name, GV, true);
101     Name += ".DW.stub";
102 
103     // Add information about the stub reference to ELFMMI so that the stub
104     // gets emitted by the asmprinter.
105     MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
106     MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
107     if (StubSym.getPointer() == 0) {
108       MCSymbol *Sym = Mang->getSymbol(GV);
109       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
110     }
111 
112     return TargetLoweringObjectFile::
113       getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
114                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
115   }
116 
117   return TargetLoweringObjectFile::
118     getTTypeGlobalReference(GV, Mang, MMI, Encoding, Streamer);
119 }
120 
121 static SectionKind
122 getELFKindForNamedSection(StringRef Name, SectionKind K) {
123   // N.B.: The defaults used in here are no the same ones used in MC.
124   // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
125   // both gas and MC will produce a section with no flags. Given
126   // section(".eh_frame") gcc will produce:
127   //
128   //   .section   .eh_frame,"a",@progbits
129   if (Name.empty() || Name[0] != '.') return K;
130 
131   // Some lame default implementation based on some magic section names.
132   if (Name == ".bss" ||
133       Name.startswith(".bss.") ||
134       Name.startswith(".gnu.linkonce.b.") ||
135       Name.startswith(".llvm.linkonce.b.") ||
136       Name == ".sbss" ||
137       Name.startswith(".sbss.") ||
138       Name.startswith(".gnu.linkonce.sb.") ||
139       Name.startswith(".llvm.linkonce.sb."))
140     return SectionKind::getBSS();
141 
142   if (Name == ".tdata" ||
143       Name.startswith(".tdata.") ||
144       Name.startswith(".gnu.linkonce.td.") ||
145       Name.startswith(".llvm.linkonce.td."))
146     return SectionKind::getThreadData();
147 
148   if (Name == ".tbss" ||
149       Name.startswith(".tbss.") ||
150       Name.startswith(".gnu.linkonce.tb.") ||
151       Name.startswith(".llvm.linkonce.tb."))
152     return SectionKind::getThreadBSS();
153 
154   return K;
155 }
156 
157 
158 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
159 
160   if (Name == ".init_array")
161     return ELF::SHT_INIT_ARRAY;
162 
163   if (Name == ".fini_array")
164     return ELF::SHT_FINI_ARRAY;
165 
166   if (Name == ".preinit_array")
167     return ELF::SHT_PREINIT_ARRAY;
168 
169   if (K.isBSS() || K.isThreadBSS())
170     return ELF::SHT_NOBITS;
171 
172   return ELF::SHT_PROGBITS;
173 }
174 
175 
176 static unsigned
177 getELFSectionFlags(SectionKind K) {
178   unsigned Flags = 0;
179 
180   if (!K.isMetadata())
181     Flags |= ELF::SHF_ALLOC;
182 
183   if (K.isText())
184     Flags |= ELF::SHF_EXECINSTR;
185 
186   if (K.isWriteable())
187     Flags |= ELF::SHF_WRITE;
188 
189   if (K.isThreadLocal())
190     Flags |= ELF::SHF_TLS;
191 
192   // K.isMergeableConst() is left out to honour PR4650
193   if (K.isMergeableCString() || K.isMergeableConst4() ||
194       K.isMergeableConst8() || K.isMergeableConst16())
195     Flags |= ELF::SHF_MERGE;
196 
197   if (K.isMergeableCString())
198     Flags |= ELF::SHF_STRINGS;
199 
200   return Flags;
201 }
202 
203 
204 const MCSection *TargetLoweringObjectFileELF::
205 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
206                          Mangler *Mang, const TargetMachine &TM) const {
207   StringRef SectionName = GV->getSection();
208 
209   // Infer section flags from the section name if we can.
210   Kind = getELFKindForNamedSection(SectionName, Kind);
211 
212   return getContext().getELFSection(SectionName,
213                                     getELFSectionType(SectionName, Kind),
214                                     getELFSectionFlags(Kind), Kind);
215 }
216 
217 /// getSectionPrefixForGlobal - Return the section prefix name used by options
218 /// FunctionsSections and DataSections.
219 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
220   if (Kind.isText())                 return ".text.";
221   if (Kind.isReadOnly())             return ".rodata.";
222   if (Kind.isBSS())                  return ".bss.";
223 
224   if (Kind.isThreadData())           return ".tdata.";
225   if (Kind.isThreadBSS())            return ".tbss.";
226 
227   if (Kind.isDataNoRel())            return ".data.";
228   if (Kind.isDataRelLocal())         return ".data.rel.local.";
229   if (Kind.isDataRel())              return ".data.rel.";
230   if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
231 
232   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
233   return ".data.rel.ro.";
234 }
235 
236 
237 const MCSection *TargetLoweringObjectFileELF::
238 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
239                        Mangler *Mang, const TargetMachine &TM) const {
240   // If we have -ffunction-section or -fdata-section then we should emit the
241   // global value to a uniqued section specifically for it.
242   bool EmitUniquedSection;
243   if (Kind.isText())
244     EmitUniquedSection = TM.getFunctionSections();
245   else
246     EmitUniquedSection = TM.getDataSections();
247 
248   // If this global is linkonce/weak and the target handles this by emitting it
249   // into a 'uniqued' section name, create and return the section now.
250   if ((GV->isWeakForLinker() || EmitUniquedSection) &&
251       !Kind.isCommon()) {
252     const char *Prefix;
253     Prefix = getSectionPrefixForGlobal(Kind);
254 
255     SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
256     MCSymbol *Sym = Mang->getSymbol(GV);
257     Name.append(Sym->getName().begin(), Sym->getName().end());
258     StringRef Group = "";
259     unsigned Flags = getELFSectionFlags(Kind);
260     if (GV->isWeakForLinker()) {
261       Group = Sym->getName();
262       Flags |= ELF::SHF_GROUP;
263     }
264 
265     return getContext().getELFSection(Name.str(),
266                                       getELFSectionType(Name.str(), Kind),
267                                       Flags, Kind, 0, Group);
268   }
269 
270   if (Kind.isText()) return TextSection;
271 
272   if (Kind.isMergeable1ByteCString() ||
273       Kind.isMergeable2ByteCString() ||
274       Kind.isMergeable4ByteCString()) {
275 
276     // We also need alignment here.
277     // FIXME: this is getting the alignment of the character, not the
278     // alignment of the global!
279     unsigned Align =
280       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV));
281 
282     const char *SizeSpec = ".rodata.str1.";
283     if (Kind.isMergeable2ByteCString())
284       SizeSpec = ".rodata.str2.";
285     else if (Kind.isMergeable4ByteCString())
286       SizeSpec = ".rodata.str4.";
287     else
288       assert(Kind.isMergeable1ByteCString() && "unknown string width");
289 
290 
291     std::string Name = SizeSpec + utostr(Align);
292     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
293                                       ELF::SHF_ALLOC |
294                                       ELF::SHF_MERGE |
295                                       ELF::SHF_STRINGS,
296                                       Kind);
297   }
298 
299   if (Kind.isMergeableConst()) {
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     return ReadOnlySection;  // .const
307   }
308 
309   if (Kind.isReadOnly())             return ReadOnlySection;
310 
311   if (Kind.isThreadData())           return TLSDataSection;
312   if (Kind.isThreadBSS())            return TLSBSSSection;
313 
314   // Note: we claim that common symbols are put in BSSSection, but they are
315   // really emitted with the magic .comm directive, which creates a symbol table
316   // entry but not a section.
317   if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
318 
319   if (Kind.isDataNoRel())            return DataSection;
320   if (Kind.isDataRelLocal())         return DataRelLocalSection;
321   if (Kind.isDataRel())              return DataRelSection;
322   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
323 
324   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
325   return DataRelROSection;
326 }
327 
328 /// getSectionForConstant - Given a mergeable constant with the
329 /// specified size and relocation information, return a section that it
330 /// should be placed in.
331 const MCSection *TargetLoweringObjectFileELF::
332 getSectionForConstant(SectionKind Kind) const {
333   if (Kind.isMergeableConst4() && MergeableConst4Section)
334     return MergeableConst4Section;
335   if (Kind.isMergeableConst8() && MergeableConst8Section)
336     return MergeableConst8Section;
337   if (Kind.isMergeableConst16() && MergeableConst16Section)
338     return MergeableConst16Section;
339   if (Kind.isReadOnly())
340     return ReadOnlySection;
341 
342   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
343   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
344   return DataRelROSection;
345 }
346 
347 const MCSection *
348 TargetLoweringObjectFileELF::getStaticCtorSection(unsigned Priority) const {
349   // The default scheme is .ctor / .dtor, so we have to invert the priority
350   // numbering.
351   if (Priority == 65535)
352     return StaticCtorSection;
353 
354   if (UseInitArray) {
355     std::string Name = std::string(".init_array.") + utostr(Priority);
356     return getContext().getELFSection(Name, ELF::SHT_INIT_ARRAY,
357                                       ELF::SHF_ALLOC | ELF::SHF_WRITE,
358                                       SectionKind::getDataRel());
359   } else {
360     std::string Name = std::string(".ctors.") + utostr(65535 - Priority);
361     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
362                                       ELF::SHF_ALLOC |ELF::SHF_WRITE,
363                                       SectionKind::getDataRel());
364   }
365 }
366 
367 const MCSection *
368 TargetLoweringObjectFileELF::getStaticDtorSection(unsigned Priority) const {
369   // The default scheme is .ctor / .dtor, so we have to invert the priority
370   // numbering.
371   if (Priority == 65535)
372     return StaticDtorSection;
373 
374   if (UseInitArray) {
375     std::string Name = std::string(".fini_array.") + utostr(Priority);
376     return getContext().getELFSection(Name, ELF::SHT_FINI_ARRAY,
377                                       ELF::SHF_ALLOC | ELF::SHF_WRITE,
378                                       SectionKind::getDataRel());
379   } else {
380     std::string Name = std::string(".dtors.") + utostr(65535 - Priority);
381     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
382                                       ELF::SHF_ALLOC |ELF::SHF_WRITE,
383                                       SectionKind::getDataRel());
384   }
385 }
386 
387 void
388 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
389   UseInitArray = UseInitArray_;
390   if (!UseInitArray)
391     return;
392 
393   StaticCtorSection =
394     getContext().getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
395                                ELF::SHF_WRITE |
396                                ELF::SHF_ALLOC,
397                                SectionKind::getDataRel());
398   StaticDtorSection =
399     getContext().getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
400                                ELF::SHF_WRITE |
401                                ELF::SHF_ALLOC,
402                                SectionKind::getDataRel());
403 }
404 
405 //===----------------------------------------------------------------------===//
406 //                                 MachO
407 //===----------------------------------------------------------------------===//
408 
409 /// emitModuleFlags - Emit the module flags that specify the garbage collection
410 /// information.
411 void TargetLoweringObjectFileMachO::
412 emitModuleFlags(MCStreamer &Streamer,
413                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
414                 Mangler *Mang, const TargetMachine &TM) const {
415   unsigned VersionVal = 0;
416   unsigned ImageInfoFlags = 0;
417   StringRef SectionVal;
418 
419   for (ArrayRef<Module::ModuleFlagEntry>::iterator
420          i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
421     const Module::ModuleFlagEntry &MFE = *i;
422 
423     // Ignore flags with 'Require' behavior.
424     if (MFE.Behavior == Module::Require)
425       continue;
426 
427     StringRef Key = MFE.Key->getString();
428     Value *Val = MFE.Val;
429 
430     if (Key == "Objective-C Image Info Version")
431       VersionVal = cast<ConstantInt>(Val)->getZExtValue();
432     else if (Key == "Objective-C Garbage Collection" ||
433              Key == "Objective-C GC Only" ||
434              Key == "Objective-C Is Simulated")
435       ImageInfoFlags |= cast<ConstantInt>(Val)->getZExtValue();
436     else if (Key == "Objective-C Image Info Section")
437       SectionVal = cast<MDString>(Val)->getString();
438   }
439 
440   // The section is mandatory. If we don't have it, then we don't have GC info.
441   if (SectionVal.empty()) return;
442 
443   StringRef Segment, Section;
444   unsigned TAA = 0, StubSize = 0;
445   bool TAAParsed;
446   std::string ErrorCode =
447     MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
448                                           TAA, TAAParsed, StubSize);
449   if (!ErrorCode.empty())
450     // If invalid, report the error with report_fatal_error.
451     report_fatal_error("Invalid section specifier '" + Section + "': " +
452                        ErrorCode + ".");
453 
454   // Get the section.
455   const MCSectionMachO *S =
456     getContext().getMachOSection(Segment, Section, TAA, StubSize,
457                                  SectionKind::getDataNoRel());
458   Streamer.SwitchSection(S);
459   Streamer.EmitLabel(getContext().
460                      GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
461   Streamer.EmitIntValue(VersionVal, 4);
462   Streamer.EmitIntValue(ImageInfoFlags, 4);
463   Streamer.AddBlankLine();
464 }
465 
466 const MCSection *TargetLoweringObjectFileMachO::
467 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
468                          Mangler *Mang, const TargetMachine &TM) const {
469   // Parse the section specifier and create it if valid.
470   StringRef Segment, Section;
471   unsigned TAA = 0, StubSize = 0;
472   bool TAAParsed;
473   std::string ErrorCode =
474     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
475                                           TAA, TAAParsed, StubSize);
476   if (!ErrorCode.empty()) {
477     // If invalid, report the error with report_fatal_error.
478     report_fatal_error("Global variable '" + GV->getName() +
479                        "' has an invalid section specifier '" +
480                        GV->getSection() + "': " + ErrorCode + ".");
481   }
482 
483   // Get the section.
484   const MCSectionMachO *S =
485     getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
486 
487   // If TAA wasn't set by ParseSectionSpecifier() above,
488   // use the value returned by getMachOSection() as a default.
489   if (!TAAParsed)
490     TAA = S->getTypeAndAttributes();
491 
492   // Okay, now that we got the section, verify that the TAA & StubSize agree.
493   // If the user declared multiple globals with different section flags, we need
494   // to reject it here.
495   if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
496     // If invalid, report the error with report_fatal_error.
497     report_fatal_error("Global variable '" + GV->getName() +
498                        "' section type or attributes does not match previous"
499                        " section specifier");
500   }
501 
502   return S;
503 }
504 
505 const MCSection *TargetLoweringObjectFileMachO::
506 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
507                        Mangler *Mang, const TargetMachine &TM) const {
508 
509   // Handle thread local data.
510   if (Kind.isThreadBSS()) return TLSBSSSection;
511   if (Kind.isThreadData()) return TLSDataSection;
512 
513   if (Kind.isText())
514     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
515 
516   // If this is weak/linkonce, put this in a coalescable section, either in text
517   // or data depending on if it is writable.
518   if (GV->isWeakForLinker()) {
519     if (Kind.isReadOnly())
520       return ConstTextCoalSection;
521     return DataCoalSection;
522   }
523 
524   // FIXME: Alignment check should be handled by section classifier.
525   if (Kind.isMergeable1ByteCString() &&
526       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
527     return CStringSection;
528 
529   // Do not put 16-bit arrays in the UString section if they have an
530   // externally visible label, this runs into issues with certain linker
531   // versions.
532   if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
533       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
534     return UStringSection;
535 
536   if (Kind.isMergeableConst()) {
537     if (Kind.isMergeableConst4())
538       return FourByteConstantSection;
539     if (Kind.isMergeableConst8())
540       return EightByteConstantSection;
541     if (Kind.isMergeableConst16() && SixteenByteConstantSection)
542       return SixteenByteConstantSection;
543   }
544 
545   // Otherwise, if it is readonly, but not something we can specially optimize,
546   // just drop it in .const.
547   if (Kind.isReadOnly())
548     return ReadOnlySection;
549 
550   // If this is marked const, put it into a const section.  But if the dynamic
551   // linker needs to write to it, put it in the data segment.
552   if (Kind.isReadOnlyWithRel())
553     return ConstDataSection;
554 
555   // Put zero initialized globals with strong external linkage in the
556   // DATA, __common section with the .zerofill directive.
557   if (Kind.isBSSExtern())
558     return DataCommonSection;
559 
560   // Put zero initialized globals with local linkage in __DATA,__bss directive
561   // with the .zerofill directive (aka .lcomm).
562   if (Kind.isBSSLocal())
563     return DataBSSSection;
564 
565   // Otherwise, just drop the variable in the normal data section.
566   return DataSection;
567 }
568 
569 const MCSection *
570 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
571   // If this constant requires a relocation, we have to put it in the data
572   // segment, not in the text segment.
573   if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
574     return ConstDataSection;
575 
576   if (Kind.isMergeableConst4())
577     return FourByteConstantSection;
578   if (Kind.isMergeableConst8())
579     return EightByteConstantSection;
580   if (Kind.isMergeableConst16() && SixteenByteConstantSection)
581     return SixteenByteConstantSection;
582   return ReadOnlySection;  // .const
583 }
584 
585 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
586 /// not to emit the UsedDirective for some symbols in llvm.used.
587 // FIXME: REMOVE this (rdar://7071300)
588 bool TargetLoweringObjectFileMachO::
589 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
590   /// On Darwin, internally linked data beginning with "L" or "l" does not have
591   /// the directive emitted (this occurs in ObjC metadata).
592   if (!GV) return false;
593 
594   // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
595   if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
596     // FIXME: ObjC metadata is currently emitted as internal symbols that have
597     // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
598     // this horrible hack can go away.
599     MCSymbol *Sym = Mang->getSymbol(GV);
600     if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
601       return false;
602   }
603 
604   return true;
605 }
606 
607 const MCExpr *TargetLoweringObjectFileMachO::
608 getTTypeGlobalReference(const GlobalValue *GV, Mangler *Mang,
609                         MachineModuleInfo *MMI, unsigned Encoding,
610                         MCStreamer &Streamer) const {
611   // The mach-o version of this method defaults to returning a stub reference.
612 
613   if (Encoding & DW_EH_PE_indirect) {
614     MachineModuleInfoMachO &MachOMMI =
615       MMI->getObjFileInfo<MachineModuleInfoMachO>();
616 
617     SmallString<128> Name;
618     Mang->getNameWithPrefix(Name, GV, true);
619     Name += "$non_lazy_ptr";
620 
621     // Add information about the stub reference to MachOMMI so that the stub
622     // gets emitted by the asmprinter.
623     MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
624     MachineModuleInfoImpl::StubValueTy &StubSym =
625       GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
626                                   MachOMMI.getGVStubEntry(SSym);
627     if (StubSym.getPointer() == 0) {
628       MCSymbol *Sym = Mang->getSymbol(GV);
629       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
630     }
631 
632     return TargetLoweringObjectFile::
633       getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
634                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
635   }
636 
637   return TargetLoweringObjectFile::
638     getTTypeGlobalReference(GV, Mang, MMI, Encoding, Streamer);
639 }
640 
641 MCSymbol *TargetLoweringObjectFileMachO::
642 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
643                         MachineModuleInfo *MMI) const {
644   // The mach-o version of this method defaults to returning a stub reference.
645   MachineModuleInfoMachO &MachOMMI =
646     MMI->getObjFileInfo<MachineModuleInfoMachO>();
647 
648   SmallString<128> Name;
649   Mang->getNameWithPrefix(Name, GV, true);
650   Name += "$non_lazy_ptr";
651 
652   // Add information about the stub reference to MachOMMI so that the stub
653   // gets emitted by the asmprinter.
654   MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
655   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
656   if (StubSym.getPointer() == 0) {
657     MCSymbol *Sym = Mang->getSymbol(GV);
658     StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
659   }
660 
661   return SSym;
662 }
663 
664 //===----------------------------------------------------------------------===//
665 //                                  COFF
666 //===----------------------------------------------------------------------===//
667 
668 static unsigned
669 getCOFFSectionFlags(SectionKind K) {
670   unsigned Flags = 0;
671 
672   if (K.isMetadata())
673     Flags |=
674       COFF::IMAGE_SCN_MEM_DISCARDABLE;
675   else if (K.isText())
676     Flags |=
677       COFF::IMAGE_SCN_MEM_EXECUTE |
678       COFF::IMAGE_SCN_MEM_READ |
679       COFF::IMAGE_SCN_CNT_CODE;
680   else if (K.isBSS ())
681     Flags |=
682       COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
683       COFF::IMAGE_SCN_MEM_READ |
684       COFF::IMAGE_SCN_MEM_WRITE;
685   else if (K.isThreadLocal())
686     Flags |=
687       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
688       COFF::IMAGE_SCN_MEM_READ |
689       COFF::IMAGE_SCN_MEM_WRITE;
690   else if (K.isReadOnly())
691     Flags |=
692       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
693       COFF::IMAGE_SCN_MEM_READ;
694   else if (K.isWriteable())
695     Flags |=
696       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
697       COFF::IMAGE_SCN_MEM_READ |
698       COFF::IMAGE_SCN_MEM_WRITE;
699 
700   return Flags;
701 }
702 
703 const MCSection *TargetLoweringObjectFileCOFF::
704 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
705                          Mangler *Mang, const TargetMachine &TM) const {
706   int Selection = 0;
707   unsigned Characteristics = getCOFFSectionFlags(Kind);
708   SmallString<128> Name(GV->getSection().c_str());
709   if (GV->isWeakForLinker()) {
710     Selection = COFF::IMAGE_COMDAT_SELECT_ANY;
711     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
712     MCSymbol *Sym = Mang->getSymbol(GV);
713     Name.append("$");
714     Name.append(Sym->getName().begin() + 1, Sym->getName().end());
715   }
716   return getContext().getCOFFSection(Name,
717                                      Characteristics,
718                                      Selection,
719                                      Kind);
720 }
721 
722 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
723   if (Kind.isText())
724     return ".text$";
725   if (Kind.isBSS ())
726     return ".bss$";
727   if (Kind.isThreadLocal())
728     return ".tls$";
729   if (Kind.isWriteable())
730     return ".data$";
731   return ".rdata$";
732 }
733 
734 
735 const MCSection *TargetLoweringObjectFileCOFF::
736 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
737                        Mangler *Mang, const TargetMachine &TM) const {
738 
739   // If this global is linkonce/weak and the target handles this by emitting it
740   // into a 'uniqued' section name, create and return the section now.
741   if (GV->isWeakForLinker()) {
742     const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
743     SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
744     MCSymbol *Sym = Mang->getSymbol(GV);
745     Name.append(Sym->getName().begin() + 1, Sym->getName().end());
746 
747     unsigned Characteristics = getCOFFSectionFlags(Kind);
748 
749     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
750 
751     return getContext().getCOFFSection(Name.str(), Characteristics,
752                           COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
753   }
754 
755   if (Kind.isText())
756     return getTextSection();
757 
758   if (Kind.isThreadLocal())
759     return getTLSDataSection();
760 
761   return getDataSection();
762 }
763 
764