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