TargetLoweringObjectFileImpl.cpp revision 344779 
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/SmallVector.h"
18#include "llvm/ADT/StringExtras.h"
19#include "llvm/ADT/StringRef.h"
20#include "llvm/ADT/Triple.h"
21#include "llvm/BinaryFormat/COFF.h"
22#include "llvm/BinaryFormat/Dwarf.h"
23#include "llvm/BinaryFormat/ELF.h"
24#include "llvm/BinaryFormat/MachO.h"
25#include "llvm/CodeGen/MachineModuleInfo.h"
26#include "llvm/CodeGen/MachineModuleInfoImpls.h"
27#include "llvm/IR/Comdat.h"
28#include "llvm/IR/Constants.h"
29#include "llvm/IR/DataLayout.h"
30#include "llvm/IR/DerivedTypes.h"
31#include "llvm/IR/Function.h"
32#include "llvm/IR/GlobalAlias.h"
33#include "llvm/IR/GlobalObject.h"
34#include "llvm/IR/GlobalValue.h"
35#include "llvm/IR/GlobalVariable.h"
36#include "llvm/IR/Mangler.h"
37#include "llvm/IR/Metadata.h"
38#include "llvm/IR/Module.h"
39#include "llvm/IR/Type.h"
40#include "llvm/MC/MCAsmInfo.h"
41#include "llvm/MC/MCContext.h"
42#include "llvm/MC/MCExpr.h"
43#include "llvm/MC/MCSectionCOFF.h"
44#include "llvm/MC/MCSectionELF.h"
45#include "llvm/MC/MCSectionMachO.h"
46#include "llvm/MC/MCSectionWasm.h"
47#include "llvm/MC/MCStreamer.h"
48#include "llvm/MC/MCSymbol.h"
49#include "llvm/MC/MCSymbolELF.h"
50#include "llvm/MC/MCValue.h"
51#include "llvm/MC/SectionKind.h"
52#include "llvm/ProfileData/InstrProf.h"
53#include "llvm/Support/Casting.h"
54#include "llvm/Support/CodeGen.h"
55#include "llvm/Support/Format.h"
56#include "llvm/Support/ErrorHandling.h"
57#include "llvm/Support/raw_ostream.h"
58#include "llvm/Target/TargetMachine.h"
59#include <cassert>
60#include <string>
61
62using namespace llvm;
63using namespace dwarf;
64
65static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
66                             StringRef &Section) {
67  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
68  M.getModuleFlagsMetadata(ModuleFlags);
69
70  for (const auto &MFE: ModuleFlags) {
71    // Ignore flags with 'Require' behaviour.
72    if (MFE.Behavior == Module::Require)
73      continue;
74
75    StringRef Key = MFE.Key->getString();
76    if (Key == "Objective-C Image Info Version") {
77      Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
78    } else if (Key == "Objective-C Garbage Collection" ||
79               Key == "Objective-C GC Only" ||
80               Key == "Objective-C Is Simulated" ||
81               Key == "Objective-C Class Properties" ||
82               Key == "Objective-C Image Swift Version") {
83      Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
84    } else if (Key == "Objective-C Image Info Section") {
85      Section = cast<MDString>(MFE.Val)->getString();
86    }
87  }
88}
89
90//===----------------------------------------------------------------------===//
91//                                  ELF
92//===----------------------------------------------------------------------===//
93
94void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
95                                             const TargetMachine &TgtM) {
96  TargetLoweringObjectFile::Initialize(Ctx, TgtM);
97  TM = &TgtM;
98
99  CodeModel::Model CM = TgtM.getCodeModel();
100
101  switch (TgtM.getTargetTriple().getArch()) {
102  case Triple::arm:
103  case Triple::armeb:
104  case Triple::thumb:
105  case Triple::thumbeb:
106    if (Ctx.getAsmInfo()->getExceptionHandlingType() == ExceptionHandling::ARM)
107      break;
108    // Fallthrough if not using EHABI
109    LLVM_FALLTHROUGH;
110  case Triple::ppc:
111  case Triple::x86:
112    PersonalityEncoding = isPositionIndependent()
113                              ? dwarf::DW_EH_PE_indirect |
114                                    dwarf::DW_EH_PE_pcrel |
115                                    dwarf::DW_EH_PE_sdata4
116                              : dwarf::DW_EH_PE_absptr;
117    LSDAEncoding = isPositionIndependent()
118                       ? dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4
119                       : dwarf::DW_EH_PE_absptr;
120    TTypeEncoding = isPositionIndependent()
121                        ? dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
122                              dwarf::DW_EH_PE_sdata4
123                        : dwarf::DW_EH_PE_absptr;
124    break;
125  case Triple::x86_64:
126    if (isPositionIndependent()) {
127      PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
128        ((CM == CodeModel::Small || CM == CodeModel::Medium)
129         ? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
130      LSDAEncoding = dwarf::DW_EH_PE_pcrel |
131        (CM == CodeModel::Small
132         ? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8);
133      TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
134        ((CM == CodeModel::Small || CM == CodeModel::Medium)
135         ? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4);
136    } else {
137      PersonalityEncoding =
138        (CM == CodeModel::Small || CM == CodeModel::Medium)
139        ? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
140      LSDAEncoding = (CM == CodeModel::Small)
141        ? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
142      TTypeEncoding = (CM == CodeModel::Small)
143        ? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr;
144    }
145    break;
146  case Triple::hexagon:
147    PersonalityEncoding = dwarf::DW_EH_PE_absptr;
148    LSDAEncoding = dwarf::DW_EH_PE_absptr;
149    TTypeEncoding = dwarf::DW_EH_PE_absptr;
150    if (isPositionIndependent()) {
151      PersonalityEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
152      LSDAEncoding |= dwarf::DW_EH_PE_pcrel;
153      TTypeEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel;
154    }
155    break;
156  case Triple::aarch64:
157  case Triple::aarch64_be:
158    // The small model guarantees static code/data size < 4GB, but not where it
159    // will be in memory. Most of these could end up >2GB away so even a signed
160    // pc-relative 32-bit address is insufficient, theoretically.
161    if (isPositionIndependent()) {
162      PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
163        dwarf::DW_EH_PE_sdata8;
164      LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8;
165      TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
166        dwarf::DW_EH_PE_sdata8;
167    } else {
168      PersonalityEncoding = dwarf::DW_EH_PE_absptr;
169      LSDAEncoding = dwarf::DW_EH_PE_absptr;
170      TTypeEncoding = dwarf::DW_EH_PE_absptr;
171    }
172    break;
173  case Triple::lanai:
174    LSDAEncoding = dwarf::DW_EH_PE_absptr;
175    PersonalityEncoding = dwarf::DW_EH_PE_absptr;
176    TTypeEncoding = dwarf::DW_EH_PE_absptr;
177    break;
178  case Triple::mips:
179  case Triple::mipsel:
180  case Triple::mips64:
181  case Triple::mips64el:
182    // MIPS uses indirect pointer to refer personality functions and types, so
183    // that the eh_frame section can be read-only. DW.ref.personality will be
184    // generated for relocation.
185    PersonalityEncoding = dwarf::DW_EH_PE_indirect;
186    // FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't
187    //        identify N64 from just a triple.
188    TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
189                    dwarf::DW_EH_PE_sdata4;
190    // We don't support PC-relative LSDA references in GAS so we use the default
191    // DW_EH_PE_absptr for those.
192
193    // FreeBSD must be explicit about the data size and using pcrel since it's
194    // assembler/linker won't do the automatic conversion that the Linux tools
195    // do.
196    if (TgtM.getTargetTriple().isOSFreeBSD()) {
197      PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
198      LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
199    }
200    break;
201  case Triple::ppc64:
202  case Triple::ppc64le:
203    PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
204      dwarf::DW_EH_PE_udata8;
205    LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8;
206    TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
207      dwarf::DW_EH_PE_udata8;
208    break;
209  case Triple::sparcel:
210  case Triple::sparc:
211    if (isPositionIndependent()) {
212      LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
213      PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
214        dwarf::DW_EH_PE_sdata4;
215      TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
216        dwarf::DW_EH_PE_sdata4;
217    } else {
218      LSDAEncoding = dwarf::DW_EH_PE_absptr;
219      PersonalityEncoding = dwarf::DW_EH_PE_absptr;
220      TTypeEncoding = dwarf::DW_EH_PE_absptr;
221    }
222    break;
223  case Triple::sparcv9:
224    LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
225    if (isPositionIndependent()) {
226      PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
227        dwarf::DW_EH_PE_sdata4;
228      TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
229        dwarf::DW_EH_PE_sdata4;
230    } else {
231      PersonalityEncoding = dwarf::DW_EH_PE_absptr;
232      TTypeEncoding = dwarf::DW_EH_PE_absptr;
233    }
234    break;
235  case Triple::systemz:
236    // All currently-defined code models guarantee that 4-byte PC-relative
237    // values will be in range.
238    if (isPositionIndependent()) {
239      PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
240        dwarf::DW_EH_PE_sdata4;
241      LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
242      TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel |
243        dwarf::DW_EH_PE_sdata4;
244    } else {
245      PersonalityEncoding = dwarf::DW_EH_PE_absptr;
246      LSDAEncoding = dwarf::DW_EH_PE_absptr;
247      TTypeEncoding = dwarf::DW_EH_PE_absptr;
248    }
249    break;
250  default:
251    break;
252  }
253}
254
255void TargetLoweringObjectFileELF::emitModuleMetadata(MCStreamer &Streamer,
256                                                     Module &M) const {
257  auto &C = getContext();
258
259  if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
260    auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS,
261                              ELF::SHF_EXCLUDE);
262
263    Streamer.SwitchSection(S);
264
265    for (const auto &Operand : LinkerOptions->operands()) {
266      if (cast<MDNode>(Operand)->getNumOperands() != 2)
267        report_fatal_error("invalid llvm.linker.options");
268      for (const auto &Option : cast<MDNode>(Operand)->operands()) {
269        Streamer.EmitBytes(cast<MDString>(Option)->getString());
270        Streamer.EmitIntValue(0, 1);
271      }
272    }
273  }
274
275  unsigned Version = 0;
276  unsigned Flags = 0;
277  StringRef Section;
278
279  GetObjCImageInfo(M, Version, Flags, Section);
280  if (!Section.empty()) {
281    auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
282    Streamer.SwitchSection(S);
283    Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
284    Streamer.EmitIntValue(Version, 4);
285    Streamer.EmitIntValue(Flags, 4);
286    Streamer.AddBlankLine();
287  }
288
289  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
290  M.getModuleFlagsMetadata(ModuleFlags);
291
292  MDNode *CFGProfile = nullptr;
293
294  for (const auto &MFE : ModuleFlags) {
295    StringRef Key = MFE.Key->getString();
296    if (Key == "CG Profile") {
297      CFGProfile = cast<MDNode>(MFE.Val);
298      break;
299    }
300  }
301
302  if (!CFGProfile)
303    return;
304
305  auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
306    if (!MDO)
307      return nullptr;
308    auto V = cast<ValueAsMetadata>(MDO);
309    const Function *F = cast<Function>(V->getValue());
310    return TM->getSymbol(F);
311  };
312
313  for (const auto &Edge : CFGProfile->operands()) {
314    MDNode *E = cast<MDNode>(Edge);
315    const MCSymbol *From = GetSym(E->getOperand(0));
316    const MCSymbol *To = GetSym(E->getOperand(1));
317    // Skip null functions. This can happen if functions are dead stripped after
318    // the CGProfile pass has been run.
319    if (!From || !To)
320      continue;
321    uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
322                         ->getValue()
323                         ->getUniqueInteger()
324                         .getZExtValue();
325    Streamer.emitCGProfileEntry(
326        MCSymbolRefExpr::create(From, MCSymbolRefExpr::VK_None, C),
327        MCSymbolRefExpr::create(To, MCSymbolRefExpr::VK_None, C), Count);
328  }
329}
330
331MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
332    const GlobalValue *GV, const TargetMachine &TM,
333    MachineModuleInfo *MMI) const {
334  unsigned Encoding = getPersonalityEncoding();
335  if ((Encoding & 0x80) == DW_EH_PE_indirect)
336    return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
337                                          TM.getSymbol(GV)->getName());
338  if ((Encoding & 0x70) == DW_EH_PE_absptr)
339    return TM.getSymbol(GV);
340  report_fatal_error("We do not support this DWARF encoding yet!");
341}
342
343void TargetLoweringObjectFileELF::emitPersonalityValue(
344    MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const {
345  SmallString<64> NameData("DW.ref.");
346  NameData += Sym->getName();
347  MCSymbolELF *Label =
348      cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData));
349  Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
350  Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
351  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
352  MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(),
353                                                   ELF::SHT_PROGBITS, Flags, 0);
354  unsigned Size = DL.getPointerSize();
355  Streamer.SwitchSection(Sec);
356  Streamer.EmitValueToAlignment(DL.getPointerABIAlignment(0));
357  Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
358  const MCExpr *E = MCConstantExpr::create(Size, getContext());
359  Streamer.emitELFSize(Label, E);
360  Streamer.EmitLabel(Label);
361
362  Streamer.EmitSymbolValue(Sym, Size);
363}
364
365const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
366    const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
367    MachineModuleInfo *MMI, MCStreamer &Streamer) const {
368  if (Encoding & DW_EH_PE_indirect) {
369    MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
370
371    MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
372
373    // Add information about the stub reference to ELFMMI so that the stub
374    // gets emitted by the asmprinter.
375    MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
376    if (!StubSym.getPointer()) {
377      MCSymbol *Sym = TM.getSymbol(GV);
378      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
379    }
380
381    return TargetLoweringObjectFile::
382      getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
383                        Encoding & ~DW_EH_PE_indirect, Streamer);
384  }
385
386  return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
387                                                           MMI, Streamer);
388}
389
390static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) {
391  // N.B.: The defaults used in here are not the same ones used in MC.
392  // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
393  // both gas and MC will produce a section with no flags. Given
394  // section(".eh_frame") gcc will produce:
395  //
396  //   .section   .eh_frame,"a",@progbits
397
398  if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF,
399                                      /*AddSegmentInfo=*/false))
400    return SectionKind::getMetadata();
401
402  if (Name.empty() || Name[0] != '.') return K;
403
404  // Default implementation based on some magic section names.
405  if (Name == ".bss" ||
406      Name.startswith(".bss.") ||
407      Name.startswith(".gnu.linkonce.b.") ||
408      Name.startswith(".llvm.linkonce.b.") ||
409      Name == ".sbss" ||
410      Name.startswith(".sbss.") ||
411      Name.startswith(".gnu.linkonce.sb.") ||
412      Name.startswith(".llvm.linkonce.sb."))
413    return SectionKind::getBSS();
414
415  if (Name == ".tdata" ||
416      Name.startswith(".tdata.") ||
417      Name.startswith(".gnu.linkonce.td.") ||
418      Name.startswith(".llvm.linkonce.td."))
419    return SectionKind::getThreadData();
420
421  if (Name == ".tbss" ||
422      Name.startswith(".tbss.") ||
423      Name.startswith(".gnu.linkonce.tb.") ||
424      Name.startswith(".llvm.linkonce.tb."))
425    return SectionKind::getThreadBSS();
426
427  return K;
428}
429
430static unsigned getELFSectionType(StringRef Name, SectionKind K) {
431  // Use SHT_NOTE for section whose name starts with ".note" to allow
432  // emitting ELF notes from C variable declaration.
433  // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609
434  if (Name.startswith(".note"))
435    return ELF::SHT_NOTE;
436
437  if (Name == ".init_array")
438    return ELF::SHT_INIT_ARRAY;
439
440  if (Name == ".fini_array")
441    return ELF::SHT_FINI_ARRAY;
442
443  if (Name == ".preinit_array")
444    return ELF::SHT_PREINIT_ARRAY;
445
446  if (K.isBSS() || K.isThreadBSS())
447    return ELF::SHT_NOBITS;
448
449  return ELF::SHT_PROGBITS;
450}
451
452static unsigned getELFSectionFlags(SectionKind K) {
453  unsigned Flags = 0;
454
455  if (!K.isMetadata())
456    Flags |= ELF::SHF_ALLOC;
457
458  if (K.isText())
459    Flags |= ELF::SHF_EXECINSTR;
460
461  if (K.isExecuteOnly())
462    Flags |= ELF::SHF_ARM_PURECODE;
463
464  if (K.isWriteable())
465    Flags |= ELF::SHF_WRITE;
466
467  if (K.isThreadLocal())
468    Flags |= ELF::SHF_TLS;
469
470  if (K.isMergeableCString() || K.isMergeableConst())
471    Flags |= ELF::SHF_MERGE;
472
473  if (K.isMergeableCString())
474    Flags |= ELF::SHF_STRINGS;
475
476  return Flags;
477}
478
479static const Comdat *getELFComdat(const GlobalValue *GV) {
480  const Comdat *C = GV->getComdat();
481  if (!C)
482    return nullptr;
483
484  if (C->getSelectionKind() != Comdat::Any)
485    report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" +
486                       C->getName() + "' cannot be lowered.");
487
488  return C;
489}
490
491static const MCSymbolELF *getAssociatedSymbol(const GlobalObject *GO,
492                                              const TargetMachine &TM) {
493  MDNode *MD = GO->getMetadata(LLVMContext::MD_associated);
494  if (!MD)
495    return nullptr;
496
497  const MDOperand &Op = MD->getOperand(0);
498  if (!Op.get())
499    return nullptr;
500
501  auto *VM = dyn_cast<ValueAsMetadata>(Op);
502  if (!VM)
503    report_fatal_error("MD_associated operand is not ValueAsMetadata");
504
505  GlobalObject *OtherGO = dyn_cast<GlobalObject>(VM->getValue());
506  return OtherGO ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGO)) : nullptr;
507}
508
509static unsigned getEntrySizeForKind(SectionKind Kind) {
510  if (Kind.isMergeable1ByteCString())
511    return 1;
512  else if (Kind.isMergeable2ByteCString())
513    return 2;
514  else if (Kind.isMergeable4ByteCString())
515    return 4;
516  else if (Kind.isMergeableConst4())
517    return 4;
518  else if (Kind.isMergeableConst8())
519    return 8;
520  else if (Kind.isMergeableConst16())
521    return 16;
522  else if (Kind.isMergeableConst32())
523    return 32;
524  else {
525    // We shouldn't have mergeable C strings or mergeable constants that we
526    // didn't handle above.
527    assert(!Kind.isMergeableCString() && "unknown string width");
528    assert(!Kind.isMergeableConst() && "unknown data width");
529    return 0;
530  }
531}
532
533MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
534    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
535  StringRef SectionName = GO->getSection();
536
537  // Check if '#pragma clang section' name is applicable.
538  // Note that pragma directive overrides -ffunction-section, -fdata-section
539  // and so section name is exactly as user specified and not uniqued.
540  const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO);
541  if (GV && GV->hasImplicitSection()) {
542    auto Attrs = GV->getAttributes();
543    if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) {
544      SectionName = Attrs.getAttribute("bss-section").getValueAsString();
545    } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) {
546      SectionName = Attrs.getAttribute("rodata-section").getValueAsString();
547    } else if (Attrs.hasAttribute("data-section") && Kind.isData()) {
548      SectionName = Attrs.getAttribute("data-section").getValueAsString();
549    }
550  }
551  const Function *F = dyn_cast<Function>(GO);
552  if (F && F->hasFnAttribute("implicit-section-name")) {
553    SectionName = F->getFnAttribute("implicit-section-name").getValueAsString();
554  }
555
556  // Infer section flags from the section name if we can.
557  Kind = getELFKindForNamedSection(SectionName, Kind);
558
559  StringRef Group = "";
560  unsigned Flags = getELFSectionFlags(Kind);
561  if (const Comdat *C = getELFComdat(GO)) {
562    Group = C->getName();
563    Flags |= ELF::SHF_GROUP;
564  }
565
566  // A section can have at most one associated section. Put each global with
567  // MD_associated in a unique section.
568  unsigned UniqueID = MCContext::GenericSectionID;
569  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
570  if (AssociatedSymbol) {
571    UniqueID = NextUniqueID++;
572    Flags |= ELF::SHF_LINK_ORDER;
573  }
574
575  MCSectionELF *Section = getContext().getELFSection(
576      SectionName, getELFSectionType(SectionName, Kind), Flags,
577      getEntrySizeForKind(Kind), Group, UniqueID, AssociatedSymbol);
578  // Make sure that we did not get some other section with incompatible sh_link.
579  // This should not be possible due to UniqueID code above.
580  assert(Section->getAssociatedSymbol() == AssociatedSymbol &&
581         "Associated symbol mismatch between sections");
582  return Section;
583}
584
585/// Return the section prefix name used by options FunctionsSections and
586/// DataSections.
587static StringRef getSectionPrefixForGlobal(SectionKind Kind) {
588  if (Kind.isText())
589    return ".text";
590  if (Kind.isReadOnly())
591    return ".rodata";
592  if (Kind.isBSS())
593    return ".bss";
594  if (Kind.isThreadData())
595    return ".tdata";
596  if (Kind.isThreadBSS())
597    return ".tbss";
598  if (Kind.isData())
599    return ".data";
600  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
601  return ".data.rel.ro";
602}
603
604static MCSectionELF *selectELFSectionForGlobal(
605    MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
606    const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags,
607    unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) {
608
609  StringRef Group = "";
610  if (const Comdat *C = getELFComdat(GO)) {
611    Flags |= ELF::SHF_GROUP;
612    Group = C->getName();
613  }
614
615  // Get the section entry size based on the kind.
616  unsigned EntrySize = getEntrySizeForKind(Kind);
617
618  SmallString<128> Name;
619  if (Kind.isMergeableCString()) {
620    // We also need alignment here.
621    // FIXME: this is getting the alignment of the character, not the
622    // alignment of the global!
623    unsigned Align = GO->getParent()->getDataLayout().getPreferredAlignment(
624        cast<GlobalVariable>(GO));
625
626    std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
627    Name = SizeSpec + utostr(Align);
628  } else if (Kind.isMergeableConst()) {
629    Name = ".rodata.cst";
630    Name += utostr(EntrySize);
631  } else {
632    Name = getSectionPrefixForGlobal(Kind);
633  }
634
635  if (const auto *F = dyn_cast<Function>(GO)) {
636    const auto &OptionalPrefix = F->getSectionPrefix();
637    if (OptionalPrefix)
638      Name += *OptionalPrefix;
639  }
640
641  unsigned UniqueID = MCContext::GenericSectionID;
642  if (EmitUniqueSection) {
643    if (TM.getUniqueSectionNames()) {
644      Name.push_back('.');
645      TM.getNameWithPrefix(Name, GO, Mang, true /*MayAlwaysUsePrivate*/);
646    } else {
647      UniqueID = *NextUniqueID;
648      (*NextUniqueID)++;
649    }
650  }
651  // Use 0 as the unique ID for execute-only text.
652  if (Kind.isExecuteOnly())
653    UniqueID = 0;
654  return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags,
655                           EntrySize, Group, UniqueID, AssociatedSymbol);
656}
657
658MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
659    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
660  unsigned Flags = getELFSectionFlags(Kind);
661
662  // If we have -ffunction-section or -fdata-section then we should emit the
663  // global value to a uniqued section specifically for it.
664  bool EmitUniqueSection = false;
665  if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) {
666    if (Kind.isText())
667      EmitUniqueSection = TM.getFunctionSections();
668    else
669      EmitUniqueSection = TM.getDataSections();
670  }
671  EmitUniqueSection |= GO->hasComdat();
672
673  const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM);
674  if (AssociatedSymbol) {
675    EmitUniqueSection = true;
676    Flags |= ELF::SHF_LINK_ORDER;
677  }
678
679  MCSectionELF *Section = selectELFSectionForGlobal(
680      getContext(), GO, Kind, getMangler(), TM, EmitUniqueSection, Flags,
681      &NextUniqueID, AssociatedSymbol);
682  assert(Section->getAssociatedSymbol() == AssociatedSymbol);
683  return Section;
684}
685
686MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
687    const Function &F, const TargetMachine &TM) const {
688  // If the function can be removed, produce a unique section so that
689  // the table doesn't prevent the removal.
690  const Comdat *C = F.getComdat();
691  bool EmitUniqueSection = TM.getFunctionSections() || C;
692  if (!EmitUniqueSection)
693    return ReadOnlySection;
694
695  return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
696                                   getMangler(), TM, EmitUniqueSection,
697                                   ELF::SHF_ALLOC, &NextUniqueID,
698                                   /* AssociatedSymbol */ nullptr);
699}
700
701bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection(
702    bool UsesLabelDifference, const Function &F) const {
703  // We can always create relative relocations, so use another section
704  // that can be marked non-executable.
705  return false;
706}
707
708/// Given a mergeable constant with the specified size and relocation
709/// information, return a section that it should be placed in.
710MCSection *TargetLoweringObjectFileELF::getSectionForConstant(
711    const DataLayout &DL, SectionKind Kind, const Constant *C,
712    unsigned &Align) const {
713  if (Kind.isMergeableConst4() && MergeableConst4Section)
714    return MergeableConst4Section;
715  if (Kind.isMergeableConst8() && MergeableConst8Section)
716    return MergeableConst8Section;
717  if (Kind.isMergeableConst16() && MergeableConst16Section)
718    return MergeableConst16Section;
719  if (Kind.isMergeableConst32() && MergeableConst32Section)
720    return MergeableConst32Section;
721  if (Kind.isReadOnly())
722    return ReadOnlySection;
723
724  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
725  return DataRelROSection;
726}
727
728static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
729                                              bool IsCtor, unsigned Priority,
730                                              const MCSymbol *KeySym) {
731  std::string Name;
732  unsigned Type;
733  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
734  StringRef COMDAT = KeySym ? KeySym->getName() : "";
735
736  if (KeySym)
737    Flags |= ELF::SHF_GROUP;
738
739  if (UseInitArray) {
740    if (IsCtor) {
741      Type = ELF::SHT_INIT_ARRAY;
742      Name = ".init_array";
743    } else {
744      Type = ELF::SHT_FINI_ARRAY;
745      Name = ".fini_array";
746    }
747    if (Priority != 65535) {
748      Name += '.';
749      Name += utostr(Priority);
750    }
751  } else {
752    // The default scheme is .ctor / .dtor, so we have to invert the priority
753    // numbering.
754    if (IsCtor)
755      Name = ".ctors";
756    else
757      Name = ".dtors";
758    if (Priority != 65535)
759      raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
760    Type = ELF::SHT_PROGBITS;
761  }
762
763  return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT);
764}
765
766MCSection *TargetLoweringObjectFileELF::getStaticCtorSection(
767    unsigned Priority, const MCSymbol *KeySym) const {
768  return getStaticStructorSection(getContext(), UseInitArray, true, Priority,
769                                  KeySym);
770}
771
772MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
773    unsigned Priority, const MCSymbol *KeySym) const {
774  return getStaticStructorSection(getContext(), UseInitArray, false, Priority,
775                                  KeySym);
776}
777
778const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
779    const GlobalValue *LHS, const GlobalValue *RHS,
780    const TargetMachine &TM) const {
781  // We may only use a PLT-relative relocation to refer to unnamed_addr
782  // functions.
783  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
784    return nullptr;
785
786  // Basic sanity checks.
787  if (LHS->getType()->getPointerAddressSpace() != 0 ||
788      RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
789      RHS->isThreadLocal())
790    return nullptr;
791
792  return MCBinaryExpr::createSub(
793      MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeVariantKind,
794                              getContext()),
795      MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
796}
797
798MCSection *TargetLoweringObjectFileELF::getSectionForCommandLines() const {
799  // Use ".GCC.command.line" since this feature is to support clang's
800  // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the
801  // same name.
802  return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS,
803                                    ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
804}
805
806void
807TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) {
808  UseInitArray = UseInitArray_;
809  MCContext &Ctx = getContext();
810  if (!UseInitArray) {
811    StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS,
812                                          ELF::SHF_ALLOC | ELF::SHF_WRITE);
813
814    StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS,
815                                          ELF::SHF_ALLOC | ELF::SHF_WRITE);
816    return;
817  }
818
819  StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY,
820                                        ELF::SHF_WRITE | ELF::SHF_ALLOC);
821  StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY,
822                                        ELF::SHF_WRITE | ELF::SHF_ALLOC);
823}
824
825//===----------------------------------------------------------------------===//
826//                                 MachO
827//===----------------------------------------------------------------------===//
828
829TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO()
830  : TargetLoweringObjectFile() {
831  SupportIndirectSymViaGOTPCRel = true;
832}
833
834void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
835                                               const TargetMachine &TM) {
836  TargetLoweringObjectFile::Initialize(Ctx, TM);
837  if (TM.getRelocationModel() == Reloc::Static) {
838    StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0,
839                                            SectionKind::getData());
840    StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0,
841                                            SectionKind::getData());
842  } else {
843    StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
844                                            MachO::S_MOD_INIT_FUNC_POINTERS,
845                                            SectionKind::getData());
846    StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
847                                            MachO::S_MOD_TERM_FUNC_POINTERS,
848                                            SectionKind::getData());
849  }
850
851  PersonalityEncoding =
852      dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
853  LSDAEncoding = dwarf::DW_EH_PE_pcrel;
854  TTypeEncoding =
855      dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
856}
857
858void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer,
859                                                       Module &M) const {
860  // Emit the linker options if present.
861  if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
862    for (const auto &Option : LinkerOptions->operands()) {
863      SmallVector<std::string, 4> StrOptions;
864      for (const auto &Piece : cast<MDNode>(Option)->operands())
865        StrOptions.push_back(cast<MDString>(Piece)->getString());
866      Streamer.EmitLinkerOptions(StrOptions);
867    }
868  }
869
870  unsigned VersionVal = 0;
871  unsigned ImageInfoFlags = 0;
872  StringRef SectionVal;
873
874  GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal);
875
876  // The section is mandatory. If we don't have it, then we don't have GC info.
877  if (SectionVal.empty())
878    return;
879
880  StringRef Segment, Section;
881  unsigned TAA = 0, StubSize = 0;
882  bool TAAParsed;
883  std::string ErrorCode =
884    MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
885                                          TAA, TAAParsed, StubSize);
886  if (!ErrorCode.empty())
887    // If invalid, report the error with report_fatal_error.
888    report_fatal_error("Invalid section specifier '" + Section + "': " +
889                       ErrorCode + ".");
890
891  // Get the section.
892  MCSectionMachO *S = getContext().getMachOSection(
893      Segment, Section, TAA, StubSize, SectionKind::getData());
894  Streamer.SwitchSection(S);
895  Streamer.EmitLabel(getContext().
896                     getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
897  Streamer.EmitIntValue(VersionVal, 4);
898  Streamer.EmitIntValue(ImageInfoFlags, 4);
899  Streamer.AddBlankLine();
900}
901
902static void checkMachOComdat(const GlobalValue *GV) {
903  const Comdat *C = GV->getComdat();
904  if (!C)
905    return;
906
907  report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() +
908                     "' cannot be lowered.");
909}
910
911MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
912    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
913  // Parse the section specifier and create it if valid.
914  StringRef Segment, Section;
915  unsigned TAA = 0, StubSize = 0;
916  bool TAAParsed;
917
918  checkMachOComdat(GO);
919
920  std::string ErrorCode =
921    MCSectionMachO::ParseSectionSpecifier(GO->getSection(), Segment, Section,
922                                          TAA, TAAParsed, StubSize);
923  if (!ErrorCode.empty()) {
924    // If invalid, report the error with report_fatal_error.
925    report_fatal_error("Global variable '" + GO->getName() +
926                       "' has an invalid section specifier '" +
927                       GO->getSection() + "': " + ErrorCode + ".");
928  }
929
930  // Get the section.
931  MCSectionMachO *S =
932      getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
933
934  // If TAA wasn't set by ParseSectionSpecifier() above,
935  // use the value returned by getMachOSection() as a default.
936  if (!TAAParsed)
937    TAA = S->getTypeAndAttributes();
938
939  // Okay, now that we got the section, verify that the TAA & StubSize agree.
940  // If the user declared multiple globals with different section flags, we need
941  // to reject it here.
942  if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
943    // If invalid, report the error with report_fatal_error.
944    report_fatal_error("Global variable '" + GO->getName() +
945                       "' section type or attributes does not match previous"
946                       " section specifier");
947  }
948
949  return S;
950}
951
952MCSection *TargetLoweringObjectFileMachO::SelectSectionForGlobal(
953    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
954  checkMachOComdat(GO);
955
956  // Handle thread local data.
957  if (Kind.isThreadBSS()) return TLSBSSSection;
958  if (Kind.isThreadData()) return TLSDataSection;
959
960  if (Kind.isText())
961    return GO->isWeakForLinker() ? TextCoalSection : TextSection;
962
963  // If this is weak/linkonce, put this in a coalescable section, either in text
964  // or data depending on if it is writable.
965  if (GO->isWeakForLinker()) {
966    if (Kind.isReadOnly())
967      return ConstTextCoalSection;
968    if (Kind.isReadOnlyWithRel())
969      return ConstDataCoalSection;
970    return DataCoalSection;
971  }
972
973  // FIXME: Alignment check should be handled by section classifier.
974  if (Kind.isMergeable1ByteCString() &&
975      GO->getParent()->getDataLayout().getPreferredAlignment(
976          cast<GlobalVariable>(GO)) < 32)
977    return CStringSection;
978
979  // Do not put 16-bit arrays in the UString section if they have an
980  // externally visible label, this runs into issues with certain linker
981  // versions.
982  if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() &&
983      GO->getParent()->getDataLayout().getPreferredAlignment(
984          cast<GlobalVariable>(GO)) < 32)
985    return UStringSection;
986
987  // With MachO only variables whose corresponding symbol starts with 'l' or
988  // 'L' can be merged, so we only try merging GVs with private linkage.
989  if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) {
990    if (Kind.isMergeableConst4())
991      return FourByteConstantSection;
992    if (Kind.isMergeableConst8())
993      return EightByteConstantSection;
994    if (Kind.isMergeableConst16())
995      return SixteenByteConstantSection;
996  }
997
998  // Otherwise, if it is readonly, but not something we can specially optimize,
999  // just drop it in .const.
1000  if (Kind.isReadOnly())
1001    return ReadOnlySection;
1002
1003  // If this is marked const, put it into a const section.  But if the dynamic
1004  // linker needs to write to it, put it in the data segment.
1005  if (Kind.isReadOnlyWithRel())
1006    return ConstDataSection;
1007
1008  // Put zero initialized globals with strong external linkage in the
1009  // DATA, __common section with the .zerofill directive.
1010  if (Kind.isBSSExtern())
1011    return DataCommonSection;
1012
1013  // Put zero initialized globals with local linkage in __DATA,__bss directive
1014  // with the .zerofill directive (aka .lcomm).
1015  if (Kind.isBSSLocal())
1016    return DataBSSSection;
1017
1018  // Otherwise, just drop the variable in the normal data section.
1019  return DataSection;
1020}
1021
1022MCSection *TargetLoweringObjectFileMachO::getSectionForConstant(
1023    const DataLayout &DL, SectionKind Kind, const Constant *C,
1024    unsigned &Align) const {
1025  // If this constant requires a relocation, we have to put it in the data
1026  // segment, not in the text segment.
1027  if (Kind.isData() || Kind.isReadOnlyWithRel())
1028    return ConstDataSection;
1029
1030  if (Kind.isMergeableConst4())
1031    return FourByteConstantSection;
1032  if (Kind.isMergeableConst8())
1033    return EightByteConstantSection;
1034  if (Kind.isMergeableConst16())
1035    return SixteenByteConstantSection;
1036  return ReadOnlySection;  // .const
1037}
1038
1039const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
1040    const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
1041    MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1042  // The mach-o version of this method defaults to returning a stub reference.
1043
1044  if (Encoding & DW_EH_PE_indirect) {
1045    MachineModuleInfoMachO &MachOMMI =
1046      MMI->getObjFileInfo<MachineModuleInfoMachO>();
1047
1048    MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1049
1050    // Add information about the stub reference to MachOMMI so that the stub
1051    // gets emitted by the asmprinter.
1052    MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1053    if (!StubSym.getPointer()) {
1054      MCSymbol *Sym = TM.getSymbol(GV);
1055      StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1056    }
1057
1058    return TargetLoweringObjectFile::
1059      getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()),
1060                        Encoding & ~DW_EH_PE_indirect, Streamer);
1061  }
1062
1063  return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
1064                                                           MMI, Streamer);
1065}
1066
1067MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
1068    const GlobalValue *GV, const TargetMachine &TM,
1069    MachineModuleInfo *MMI) const {
1070  // The mach-o version of this method defaults to returning a stub reference.
1071  MachineModuleInfoMachO &MachOMMI =
1072    MMI->getObjFileInfo<MachineModuleInfoMachO>();
1073
1074  MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
1075
1076  // Add information about the stub reference to MachOMMI so that the stub
1077  // gets emitted by the asmprinter.
1078  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
1079  if (!StubSym.getPointer()) {
1080    MCSymbol *Sym = TM.getSymbol(GV);
1081    StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
1082  }
1083
1084  return SSym;
1085}
1086
1087const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel(
1088    const MCSymbol *Sym, const MCValue &MV, int64_t Offset,
1089    MachineModuleInfo *MMI, MCStreamer &Streamer) const {
1090  // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation
1091  // as 64-bit do, we replace the GOT equivalent by accessing the final symbol
1092  // through a non_lazy_ptr stub instead. One advantage is that it allows the
1093  // computation of deltas to final external symbols. Example:
1094  //
1095  //    _extgotequiv:
1096  //       .long   _extfoo
1097  //
1098  //    _delta:
1099  //       .long   _extgotequiv-_delta
1100  //
1101  // is transformed to:
1102  //
1103  //    _delta:
1104  //       .long   L_extfoo$non_lazy_ptr-(_delta+0)
1105  //
1106  //       .section        __IMPORT,__pointers,non_lazy_symbol_pointers
1107  //    L_extfoo$non_lazy_ptr:
1108  //       .indirect_symbol        _extfoo
1109  //       .long   0
1110  //
1111  // The indirect symbol table (and sections of non_lazy_symbol_pointers type)
1112  // may point to both local (same translation unit) and global (other
1113  // translation units) symbols. Example:
1114  //
1115  // .section __DATA,__pointers,non_lazy_symbol_pointers
1116  // L1:
1117  //    .indirect_symbol _myGlobal
1118  //    .long 0
1119  // L2:
1120  //    .indirect_symbol _myLocal
1121  //    .long _myLocal
1122  //
1123  // If the symbol is local, instead of the symbol's index, the assembler
1124  // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table.
1125  // Then the linker will notice the constant in the table and will look at the
1126  // content of the symbol.
1127  MachineModuleInfoMachO &MachOMMI =
1128    MMI->getObjFileInfo<MachineModuleInfoMachO>();
1129  MCContext &Ctx = getContext();
1130
1131  // The offset must consider the original displacement from the base symbol
1132  // since 32-bit targets don't have a GOTPCREL to fold the PC displacement.
1133  Offset = -MV.getConstant();
1134  const MCSymbol *BaseSym = &MV.getSymB()->getSymbol();
1135
1136  // Access the final symbol via sym$non_lazy_ptr and generate the appropriated
1137  // non_lazy_ptr stubs.
1138  SmallString<128> Name;
1139  StringRef Suffix = "$non_lazy_ptr";
1140  Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix();
1141  Name += Sym->getName();
1142  Name += Suffix;
1143  MCSymbol *Stub = Ctx.getOrCreateSymbol(Name);
1144
1145  MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub);
1146  if (!StubSym.getPointer()) {
1147    bool IsIndirectLocal = Sym->isDefined() && !Sym->isExternal();
1148    // With the assumption that IsIndirectLocal == GV->hasLocalLinkage().
1149    StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym),
1150                                                 !IsIndirectLocal);
1151  }
1152
1153  const MCExpr *BSymExpr =
1154    MCSymbolRefExpr::create(BaseSym, MCSymbolRefExpr::VK_None, Ctx);
1155  const MCExpr *LHS =
1156    MCSymbolRefExpr::create(Stub, MCSymbolRefExpr::VK_None, Ctx);
1157
1158  if (!Offset)
1159    return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx);
1160
1161  const MCExpr *RHS =
1162    MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx);
1163  return MCBinaryExpr::createSub(LHS, RHS, Ctx);
1164}
1165
1166static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
1167                               const MCSection &Section) {
1168  if (!AsmInfo.isSectionAtomizableBySymbols(Section))
1169    return true;
1170
1171  // If it is not dead stripped, it is safe to use private labels.
1172  const MCSectionMachO &SMO = cast<MCSectionMachO>(Section);
1173  if (SMO.hasAttribute(MachO::S_ATTR_NO_DEAD_STRIP))
1174    return true;
1175
1176  return false;
1177}
1178
1179void TargetLoweringObjectFileMachO::getNameWithPrefix(
1180    SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1181    const TargetMachine &TM) const {
1182  bool CannotUsePrivateLabel = true;
1183  if (auto *GO = GV->getBaseObject()) {
1184    SectionKind GOKind = TargetLoweringObjectFile::getKindForGlobal(GO, TM);
1185    const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM);
1186    CannotUsePrivateLabel =
1187        !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
1188  }
1189  getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1190}
1191
1192//===----------------------------------------------------------------------===//
1193//                                  COFF
1194//===----------------------------------------------------------------------===//
1195
1196static unsigned
1197getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) {
1198  unsigned Flags = 0;
1199  bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb;
1200
1201  if (K.isMetadata())
1202    Flags |=
1203      COFF::IMAGE_SCN_MEM_DISCARDABLE;
1204  else if (K.isText())
1205    Flags |=
1206      COFF::IMAGE_SCN_MEM_EXECUTE |
1207      COFF::IMAGE_SCN_MEM_READ |
1208      COFF::IMAGE_SCN_CNT_CODE |
1209      (isThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0);
1210  else if (K.isBSS())
1211    Flags |=
1212      COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
1213      COFF::IMAGE_SCN_MEM_READ |
1214      COFF::IMAGE_SCN_MEM_WRITE;
1215  else if (K.isThreadLocal())
1216    Flags |=
1217      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1218      COFF::IMAGE_SCN_MEM_READ |
1219      COFF::IMAGE_SCN_MEM_WRITE;
1220  else if (K.isReadOnly() || K.isReadOnlyWithRel())
1221    Flags |=
1222      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1223      COFF::IMAGE_SCN_MEM_READ;
1224  else if (K.isWriteable())
1225    Flags |=
1226      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1227      COFF::IMAGE_SCN_MEM_READ |
1228      COFF::IMAGE_SCN_MEM_WRITE;
1229
1230  return Flags;
1231}
1232
1233static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) {
1234  const Comdat *C = GV->getComdat();
1235  assert(C && "expected GV to have a Comdat!");
1236
1237  StringRef ComdatGVName = C->getName();
1238  const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName);
1239  if (!ComdatGV)
1240    report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1241                       "' does not exist.");
1242
1243  if (ComdatGV->getComdat() != C)
1244    report_fatal_error("Associative COMDAT symbol '" + ComdatGVName +
1245                       "' is not a key for its COMDAT.");
1246
1247  return ComdatGV;
1248}
1249
1250static int getSelectionForCOFF(const GlobalValue *GV) {
1251  if (const Comdat *C = GV->getComdat()) {
1252    const GlobalValue *ComdatKey = getComdatGVForCOFF(GV);
1253    if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey))
1254      ComdatKey = GA->getBaseObject();
1255    if (ComdatKey == GV) {
1256      switch (C->getSelectionKind()) {
1257      case Comdat::Any:
1258        return COFF::IMAGE_COMDAT_SELECT_ANY;
1259      case Comdat::ExactMatch:
1260        return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH;
1261      case Comdat::Largest:
1262        return COFF::IMAGE_COMDAT_SELECT_LARGEST;
1263      case Comdat::NoDuplicates:
1264        return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
1265      case Comdat::SameSize:
1266        return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE;
1267      }
1268    } else {
1269      return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
1270    }
1271  }
1272  return 0;
1273}
1274
1275MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
1276    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1277  int Selection = 0;
1278  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1279  StringRef Name = GO->getSection();
1280  StringRef COMDATSymName = "";
1281  if (GO->hasComdat()) {
1282    Selection = getSelectionForCOFF(GO);
1283    const GlobalValue *ComdatGV;
1284    if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
1285      ComdatGV = getComdatGVForCOFF(GO);
1286    else
1287      ComdatGV = GO;
1288
1289    if (!ComdatGV->hasPrivateLinkage()) {
1290      MCSymbol *Sym = TM.getSymbol(ComdatGV);
1291      COMDATSymName = Sym->getName();
1292      Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1293    } else {
1294      Selection = 0;
1295    }
1296  }
1297
1298  return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
1299                                     Selection);
1300}
1301
1302static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
1303  if (Kind.isText())
1304    return ".text";
1305  if (Kind.isBSS())
1306    return ".bss";
1307  if (Kind.isThreadLocal())
1308    return ".tls$";
1309  if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1310    return ".rdata";
1311  return ".data";
1312}
1313
1314MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
1315    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1316  // If we have -ffunction-sections then we should emit the global value to a
1317  // uniqued section specifically for it.
1318  bool EmitUniquedSection;
1319  if (Kind.isText())
1320    EmitUniquedSection = TM.getFunctionSections();
1321  else
1322    EmitUniquedSection = TM.getDataSections();
1323
1324  if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) {
1325    SmallString<256> Name = getCOFFSectionNameForUniqueGlobal(Kind);
1326
1327    unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1328
1329    Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1330    int Selection = getSelectionForCOFF(GO);
1331    if (!Selection)
1332      Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES;
1333    const GlobalValue *ComdatGV;
1334    if (GO->hasComdat())
1335      ComdatGV = getComdatGVForCOFF(GO);
1336    else
1337      ComdatGV = GO;
1338
1339    unsigned UniqueID = MCContext::GenericSectionID;
1340    if (EmitUniquedSection)
1341      UniqueID = NextUniqueID++;
1342
1343    if (!ComdatGV->hasPrivateLinkage()) {
1344      MCSymbol *Sym = TM.getSymbol(ComdatGV);
1345      StringRef COMDATSymName = Sym->getName();
1346
1347      // Append "$symbol" to the section name *before* IR-level mangling is
1348      // applied when targetting mingw. This is what GCC does, and the ld.bfd
1349      // COFF linker will not properly handle comdats otherwise.
1350      if (getTargetTriple().isWindowsGNUEnvironment())
1351        raw_svector_ostream(Name) << '$' << ComdatGV->getName();
1352
1353      return getContext().getCOFFSection(Name, Characteristics, Kind,
1354                                         COMDATSymName, Selection, UniqueID);
1355    } else {
1356      SmallString<256> TmpData;
1357      getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true);
1358      return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
1359                                         Selection, UniqueID);
1360    }
1361  }
1362
1363  if (Kind.isText())
1364    return TextSection;
1365
1366  if (Kind.isThreadLocal())
1367    return TLSDataSection;
1368
1369  if (Kind.isReadOnly() || Kind.isReadOnlyWithRel())
1370    return ReadOnlySection;
1371
1372  // Note: we claim that common symbols are put in BSSSection, but they are
1373  // really emitted with the magic .comm directive, which creates a symbol table
1374  // entry but not a section.
1375  if (Kind.isBSS() || Kind.isCommon())
1376    return BSSSection;
1377
1378  return DataSection;
1379}
1380
1381void TargetLoweringObjectFileCOFF::getNameWithPrefix(
1382    SmallVectorImpl<char> &OutName, const GlobalValue *GV,
1383    const TargetMachine &TM) const {
1384  bool CannotUsePrivateLabel = false;
1385  if (GV->hasPrivateLinkage() &&
1386      ((isa<Function>(GV) && TM.getFunctionSections()) ||
1387       (isa<GlobalVariable>(GV) && TM.getDataSections())))
1388    CannotUsePrivateLabel = true;
1389
1390  getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
1391}
1392
1393MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
1394    const Function &F, const TargetMachine &TM) const {
1395  // If the function can be removed, produce a unique section so that
1396  // the table doesn't prevent the removal.
1397  const Comdat *C = F.getComdat();
1398  bool EmitUniqueSection = TM.getFunctionSections() || C;
1399  if (!EmitUniqueSection)
1400    return ReadOnlySection;
1401
1402  // FIXME: we should produce a symbol for F instead.
1403  if (F.hasPrivateLinkage())
1404    return ReadOnlySection;
1405
1406  MCSymbol *Sym = TM.getSymbol(&F);
1407  StringRef COMDATSymName = Sym->getName();
1408
1409  SectionKind Kind = SectionKind::getReadOnly();
1410  StringRef SecName = getCOFFSectionNameForUniqueGlobal(Kind);
1411  unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
1412  Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1413  unsigned UniqueID = NextUniqueID++;
1414
1415  return getContext().getCOFFSection(
1416      SecName, Characteristics, Kind, COMDATSymName,
1417      COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
1418}
1419
1420void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer,
1421                                                      Module &M) const {
1422  if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
1423    // Emit the linker options to the linker .drectve section.  According to the
1424    // spec, this section is a space-separated string containing flags for
1425    // linker.
1426    MCSection *Sec = getDrectveSection();
1427    Streamer.SwitchSection(Sec);
1428    for (const auto &Option : LinkerOptions->operands()) {
1429      for (const auto &Piece : cast<MDNode>(Option)->operands()) {
1430        // Lead with a space for consistency with our dllexport implementation.
1431        std::string Directive(" ");
1432        Directive.append(cast<MDString>(Piece)->getString());
1433        Streamer.EmitBytes(Directive);
1434      }
1435    }
1436  }
1437
1438  unsigned Version = 0;
1439  unsigned Flags = 0;
1440  StringRef Section;
1441
1442  GetObjCImageInfo(M, Version, Flags, Section);
1443  if (Section.empty())
1444    return;
1445
1446  auto &C = getContext();
1447  auto *S = C.getCOFFSection(
1448      Section, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ,
1449      SectionKind::getReadOnly());
1450  Streamer.SwitchSection(S);
1451  Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
1452  Streamer.EmitIntValue(Version, 4);
1453  Streamer.EmitIntValue(Flags, 4);
1454  Streamer.AddBlankLine();
1455}
1456
1457void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
1458                                              const TargetMachine &TM) {
1459  TargetLoweringObjectFile::Initialize(Ctx, TM);
1460  const Triple &T = TM.getTargetTriple();
1461  if (T.isKnownWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1462    StaticCtorSection =
1463        Ctx.getCOFFSection(".CRT$XCU", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1464                                           COFF::IMAGE_SCN_MEM_READ,
1465                           SectionKind::getReadOnly());
1466    StaticDtorSection =
1467        Ctx.getCOFFSection(".CRT$XTX", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1468                                           COFF::IMAGE_SCN_MEM_READ,
1469                           SectionKind::getReadOnly());
1470  } else {
1471    StaticCtorSection = Ctx.getCOFFSection(
1472        ".ctors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1473                      COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
1474        SectionKind::getData());
1475    StaticDtorSection = Ctx.getCOFFSection(
1476        ".dtors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1477                      COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE,
1478        SectionKind::getData());
1479  }
1480}
1481
1482static MCSectionCOFF *getCOFFStaticStructorSection(MCContext &Ctx,
1483                                                   const Triple &T, bool IsCtor,
1484                                                   unsigned Priority,
1485                                                   const MCSymbol *KeySym,
1486                                                   MCSectionCOFF *Default) {
1487  if (T.isKnownWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) {
1488    // If the priority is the default, use .CRT$XCU, possibly associative.
1489    if (Priority == 65535)
1490      return Ctx.getAssociativeCOFFSection(Default, KeySym, 0);
1491
1492    // Otherwise, we need to compute a new section name. Low priorities should
1493    // run earlier. The linker will sort sections ASCII-betically, and we need a
1494    // string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we
1495    // make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really
1496    // low priorities need to sort before 'L', since the CRT uses that
1497    // internally, so we use ".CRT$XCA00001" for them.
1498    SmallString<24> Name;
1499    raw_svector_ostream OS(Name);
1500    OS << ".CRT$XC" << (Priority < 200 ? 'A' : 'T') << format("%05u", Priority);
1501    MCSectionCOFF *Sec = Ctx.getCOFFSection(
1502        Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ,
1503        SectionKind::getReadOnly());
1504    return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0);
1505  }
1506
1507  std::string Name = IsCtor ? ".ctors" : ".dtors";
1508  if (Priority != 65535)
1509    raw_string_ostream(Name) << format(".%05u", 65535 - Priority);
1510
1511  return Ctx.getAssociativeCOFFSection(
1512      Ctx.getCOFFSection(Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1513                                   COFF::IMAGE_SCN_MEM_READ |
1514                                   COFF::IMAGE_SCN_MEM_WRITE,
1515                         SectionKind::getData()),
1516      KeySym, 0);
1517}
1518
1519MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection(
1520    unsigned Priority, const MCSymbol *KeySym) const {
1521  return getCOFFStaticStructorSection(getContext(), getTargetTriple(), true,
1522                                      Priority, KeySym,
1523                                      cast<MCSectionCOFF>(StaticCtorSection));
1524}
1525
1526MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
1527    unsigned Priority, const MCSymbol *KeySym) const {
1528  return getCOFFStaticStructorSection(getContext(), getTargetTriple(), false,
1529                                      Priority, KeySym,
1530                                      cast<MCSectionCOFF>(StaticDtorSection));
1531}
1532
1533void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal(
1534    raw_ostream &OS, const GlobalValue *GV) const {
1535  emitLinkerFlagsForGlobalCOFF(OS, GV, getTargetTriple(), getMangler());
1536}
1537
1538void TargetLoweringObjectFileCOFF::emitLinkerFlagsForUsed(
1539    raw_ostream &OS, const GlobalValue *GV) const {
1540  emitLinkerFlagsForUsedCOFF(OS, GV, getTargetTriple(), getMangler());
1541}
1542
1543const MCExpr *TargetLoweringObjectFileCOFF::lowerRelativeReference(
1544    const GlobalValue *LHS, const GlobalValue *RHS,
1545    const TargetMachine &TM) const {
1546  const Triple &T = TM.getTargetTriple();
1547  if (!T.isKnownWindowsMSVCEnvironment() &&
1548      !T.isWindowsItaniumEnvironment() &&
1549      !T.isWindowsCoreCLREnvironment())
1550    return nullptr;
1551
1552  // Our symbols should exist in address space zero, cowardly no-op if
1553  // otherwise.
1554  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1555      RHS->getType()->getPointerAddressSpace() != 0)
1556    return nullptr;
1557
1558  // Both ptrtoint instructions must wrap global objects:
1559  // - Only global variables are eligible for image relative relocations.
1560  // - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable.
1561  // We expect __ImageBase to be a global variable without a section, externally
1562  // defined.
1563  //
1564  // It should look something like this: @__ImageBase = external constant i8
1565  if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) ||
1566      LHS->isThreadLocal() || RHS->isThreadLocal() ||
1567      RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() ||
1568      cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
1569    return nullptr;
1570
1571  return MCSymbolRefExpr::create(TM.getSymbol(LHS),
1572                                 MCSymbolRefExpr::VK_COFF_IMGREL32,
1573                                 getContext());
1574}
1575
1576static std::string APIntToHexString(const APInt &AI) {
1577  unsigned Width = (AI.getBitWidth() / 8) * 2;
1578  std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
1579  unsigned Size = HexString.size();
1580  assert(Width >= Size && "hex string is too large!");
1581  HexString.insert(HexString.begin(), Width - Size, '0');
1582
1583  return HexString;
1584}
1585
1586static std::string scalarConstantToHexString(const Constant *C) {
1587  Type *Ty = C->getType();
1588  if (isa<UndefValue>(C)) {
1589    return APIntToHexString(APInt::getNullValue(Ty->getPrimitiveSizeInBits()));
1590  } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
1591    return APIntToHexString(CFP->getValueAPF().bitcastToAPInt());
1592  } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
1593    return APIntToHexString(CI->getValue());
1594  } else {
1595    unsigned NumElements;
1596    if (isa<VectorType>(Ty))
1597      NumElements = Ty->getVectorNumElements();
1598    else
1599      NumElements = Ty->getArrayNumElements();
1600    std::string HexString;
1601    for (int I = NumElements - 1, E = -1; I != E; --I)
1602      HexString += scalarConstantToHexString(C->getAggregateElement(I));
1603    return HexString;
1604  }
1605}
1606
1607MCSection *TargetLoweringObjectFileCOFF::getSectionForConstant(
1608    const DataLayout &DL, SectionKind Kind, const Constant *C,
1609    unsigned &Align) const {
1610  if (Kind.isMergeableConst() && C &&
1611      getContext().getAsmInfo()->hasCOFFComdatConstants()) {
1612    // This creates comdat sections with the given symbol name, but unless
1613    // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol
1614    // will be created with a null storage class, which makes GNU binutils
1615    // error out.
1616    const unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1617                                     COFF::IMAGE_SCN_MEM_READ |
1618                                     COFF::IMAGE_SCN_LNK_COMDAT;
1619    std::string COMDATSymName;
1620    if (Kind.isMergeableConst4()) {
1621      if (Align <= 4) {
1622        COMDATSymName = "__real@" + scalarConstantToHexString(C);
1623        Align = 4;
1624      }
1625    } else if (Kind.isMergeableConst8()) {
1626      if (Align <= 8) {
1627        COMDATSymName = "__real@" + scalarConstantToHexString(C);
1628        Align = 8;
1629      }
1630    } else if (Kind.isMergeableConst16()) {
1631      // FIXME: These may not be appropriate for non-x86 architectures.
1632      if (Align <= 16) {
1633        COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
1634        Align = 16;
1635      }
1636    } else if (Kind.isMergeableConst32()) {
1637      if (Align <= 32) {
1638        COMDATSymName = "__ymm@" + scalarConstantToHexString(C);
1639        Align = 32;
1640      }
1641    }
1642
1643    if (!COMDATSymName.empty())
1644      return getContext().getCOFFSection(".rdata", Characteristics, Kind,
1645                                         COMDATSymName,
1646                                         COFF::IMAGE_COMDAT_SELECT_ANY);
1647  }
1648
1649  return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C, Align);
1650}
1651
1652
1653//===----------------------------------------------------------------------===//
1654//                                  Wasm
1655//===----------------------------------------------------------------------===//
1656
1657static const Comdat *getWasmComdat(const GlobalValue *GV) {
1658  const Comdat *C = GV->getComdat();
1659  if (!C)
1660    return nullptr;
1661
1662  if (C->getSelectionKind() != Comdat::Any)
1663    report_fatal_error("WebAssembly COMDATs only support "
1664                       "SelectionKind::Any, '" + C->getName() + "' cannot be "
1665                       "lowered.");
1666
1667  return C;
1668}
1669
1670static SectionKind getWasmKindForNamedSection(StringRef Name, SectionKind K) {
1671  // If we're told we have function data, then use that.
1672  if (K.isText())
1673    return SectionKind::getText();
1674
1675  // Otherwise, ignore whatever section type the generic impl detected and use
1676  // a plain data section.
1677  return SectionKind::getData();
1678}
1679
1680MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal(
1681    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1682  // We don't support explict section names for functions in the wasm object
1683  // format.  Each function has to be in its own unique section.
1684  if (isa<Function>(GO)) {
1685    return SelectSectionForGlobal(GO, Kind, TM);
1686  }
1687
1688  StringRef Name = GO->getSection();
1689
1690  Kind = getWasmKindForNamedSection(Name, Kind);
1691
1692  StringRef Group = "";
1693  if (const Comdat *C = getWasmComdat(GO)) {
1694    Group = C->getName();
1695  }
1696
1697  return getContext().getWasmSection(Name, Kind, Group,
1698                                     MCContext::GenericSectionID);
1699}
1700
1701static MCSectionWasm *selectWasmSectionForGlobal(
1702    MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang,
1703    const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
1704  StringRef Group = "";
1705  if (const Comdat *C = getWasmComdat(GO)) {
1706    Group = C->getName();
1707  }
1708
1709  bool UniqueSectionNames = TM.getUniqueSectionNames();
1710  SmallString<128> Name = getSectionPrefixForGlobal(Kind);
1711
1712  if (const auto *F = dyn_cast<Function>(GO)) {
1713    const auto &OptionalPrefix = F->getSectionPrefix();
1714    if (OptionalPrefix)
1715      Name += *OptionalPrefix;
1716  }
1717
1718  if (EmitUniqueSection && UniqueSectionNames) {
1719    Name.push_back('.');
1720    TM.getNameWithPrefix(Name, GO, Mang, true);
1721  }
1722  unsigned UniqueID = MCContext::GenericSectionID;
1723  if (EmitUniqueSection && !UniqueSectionNames) {
1724    UniqueID = *NextUniqueID;
1725    (*NextUniqueID)++;
1726  }
1727  return Ctx.getWasmSection(Name, Kind, Group, UniqueID);
1728}
1729
1730MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal(
1731    const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
1732
1733  if (Kind.isCommon())
1734    report_fatal_error("mergable sections not supported yet on wasm");
1735
1736  // If we have -ffunction-section or -fdata-section then we should emit the
1737  // global value to a uniqued section specifically for it.
1738  bool EmitUniqueSection = false;
1739  if (Kind.isText())
1740    EmitUniqueSection = TM.getFunctionSections();
1741  else
1742    EmitUniqueSection = TM.getDataSections();
1743  EmitUniqueSection |= GO->hasComdat();
1744
1745  return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM,
1746                                    EmitUniqueSection, &NextUniqueID);
1747}
1748
1749bool TargetLoweringObjectFileWasm::shouldPutJumpTableInFunctionSection(
1750    bool UsesLabelDifference, const Function &F) const {
1751  // We can always create relative relocations, so use another section
1752  // that can be marked non-executable.
1753  return false;
1754}
1755
1756const MCExpr *TargetLoweringObjectFileWasm::lowerRelativeReference(
1757    const GlobalValue *LHS, const GlobalValue *RHS,
1758    const TargetMachine &TM) const {
1759  // We may only use a PLT-relative relocation to refer to unnamed_addr
1760  // functions.
1761  if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
1762    return nullptr;
1763
1764  // Basic sanity checks.
1765  if (LHS->getType()->getPointerAddressSpace() != 0 ||
1766      RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() ||
1767      RHS->isThreadLocal())
1768    return nullptr;
1769
1770  return MCBinaryExpr::createSub(
1771      MCSymbolRefExpr::create(TM.getSymbol(LHS), MCSymbolRefExpr::VK_None,
1772                              getContext()),
1773      MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
1774}
1775
1776void TargetLoweringObjectFileWasm::InitializeWasm() {
1777  StaticCtorSection =
1778      getContext().getWasmSection(".init_array", SectionKind::getData());
1779
1780  // We don't use PersonalityEncoding and LSDAEncoding because we don't emit
1781  // .cfi directives. We use TTypeEncoding to encode typeinfo global variables.
1782  TTypeEncoding = dwarf::DW_EH_PE_absptr;
1783}
1784
1785MCSection *TargetLoweringObjectFileWasm::getStaticCtorSection(
1786    unsigned Priority, const MCSymbol *KeySym) const {
1787  return Priority == UINT16_MAX ?
1788         StaticCtorSection :
1789         getContext().getWasmSection(".init_array." + utostr(Priority),
1790                                     SectionKind::getData());
1791}
1792
1793MCSection *TargetLoweringObjectFileWasm::getStaticDtorSection(
1794    unsigned Priority, const MCSymbol *KeySym) const {
1795  llvm_unreachable("@llvm.global_dtors should have been lowered already");
1796  return nullptr;
1797}
1798