contrib/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

   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 //===----------------------------------------------------------------------===//
 405 //                                 MachO
 406 //===----------------------------------------------------------------------===//
 407
 408 /// emitModuleFlags - Perform code emission for module flags.
 409 void TargetLoweringObjectFileMachO::
 410 emitModuleFlags(MCStreamer &Streamer,
 411                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
 412                 Mangler *Mang, const TargetMachine &TM) const {
 413   unsigned VersionVal = 0;
 414   unsigned ImageInfoFlags = 0;
 415   MDNode *LinkerOptions = 0;
 416   StringRef SectionVal;
 417
 418   for (ArrayRef<Module::ModuleFlagEntry>::iterator
 419          i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
 420     const Module::ModuleFlagEntry &MFE = *i;
 421
 422     // Ignore flags with 'Require' behavior.
 423     if (MFE.Behavior == Module::Require)
 424       continue;
 425
 426     StringRef Key = MFE.Key->getString();
 427     Value *Val = MFE.Val;
 428
 429     if (Key == "Objective-C Image Info Version") {
 430       VersionVal = cast<ConstantInt>(Val)->getZExtValue();
 431     } else if (Key == "Objective-C Garbage Collection" ||
 432                Key == "Objective-C GC Only" ||
 433                Key == "Objective-C Is Simulated") {
 434       ImageInfoFlags |= cast<ConstantInt>(Val)->getZExtValue();
 435     } else if (Key == "Objective-C Image Info Section") {
 436       SectionVal = cast<MDString>(Val)->getString();
 437     } else if (Key == "Linker Options") {
 438       LinkerOptions = cast<MDNode>(Val);
 439     }
 440   }
 441
 442   // Emit the linker options if present.
 443   if (LinkerOptions) {
 444     for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
 445       MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
 446       SmallVector<std::string, 4> StrOptions;
 447
 448       // Convert to strings.
 449       for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
 450         MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
 451         StrOptions.push_back(MDOption->getString());
 452       }
 453
 454       Streamer.EmitLinkerOptions(StrOptions);
 455     }
 456   }
 457
 458   // The section is mandatory. If we don't have it, then we don't have GC info.
 459   if (SectionVal.empty()) return;
 460
 461   StringRef Segment, Section;
 462   unsigned TAA = 0, StubSize = 0;
 463   bool TAAParsed;
 464   std::string ErrorCode =
 465     MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section,
 466                                           TAA, TAAParsed, StubSize);
 467   if (!ErrorCode.empty())
 468     // If invalid, report the error with report_fatal_error.
 469     report_fatal_error("Invalid section specifier '" + Section + "': " +
 470                        ErrorCode + ".");
 471
 472   // Get the section.
 473   const MCSectionMachO *S =
 474     getContext().getMachOSection(Segment, Section, TAA, StubSize,
 475                                  SectionKind::getDataNoRel());
 476   Streamer.SwitchSection(S);
 477   Streamer.EmitLabel(getContext().
 478                      GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO")));
 479   Streamer.EmitIntValue(VersionVal, 4);
 480   Streamer.EmitIntValue(ImageInfoFlags, 4);
 481   Streamer.AddBlankLine();
 482 }
 483
 484 const MCSection *TargetLoweringObjectFileMachO::
 485 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 486                          Mangler *Mang, const TargetMachine &TM) const {
 487   // Parse the section specifier and create it if valid.
 488   StringRef Segment, Section;
 489   unsigned TAA = 0, StubSize = 0;
 490   bool TAAParsed;
 491   std::string ErrorCode =
 492     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
 493                                           TAA, TAAParsed, StubSize);
 494   if (!ErrorCode.empty()) {
 495     // If invalid, report the error with report_fatal_error.
 496     report_fatal_error("Global variable '" + GV->getName() +
 497                        "' has an invalid section specifier '" +
 498                        GV->getSection() + "': " + ErrorCode + ".");
 499   }
 500
 501   // Get the section.
 502   const MCSectionMachO *S =
 503     getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
 504
 505   // If TAA wasn't set by ParseSectionSpecifier() above,
 506   // use the value returned by getMachOSection() as a default.
 507   if (!TAAParsed)
 508     TAA = S->getTypeAndAttributes();
 509
 510   // Okay, now that we got the section, verify that the TAA & StubSize agree.
 511   // If the user declared multiple globals with different section flags, we need
 512   // to reject it here.
 513   if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
 514     // If invalid, report the error with report_fatal_error.
 515     report_fatal_error("Global variable '" + GV->getName() +
 516                        "' section type or attributes does not match previous"
 517                        " section specifier");
 518   }
 519
 520   return S;
 521 }
 522
 523 const MCSection *TargetLoweringObjectFileMachO::
 524 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 525                        Mangler *Mang, const TargetMachine &TM) const {
 526   if (Kind.isText())
 527     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
 528
 529   // If this is weak/linkonce, put this in a coalescable section, either in text
 530   // or data depending on if it is writable.
 531   if (GV->isWeakForLinker()) {
 532     if (Kind.isReadOnly())
 533       return ConstTextCoalSection;
 534     return DataCoalSection;
 535   }
 536
 537   // FIXME: Alignment check should be handled by section classifier.
 538   if (Kind.isMergeable1ByteCString() &&
 539       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
 540     return CStringSection;
 541
 542   // Do not put 16-bit arrays in the UString section if they have an
 543   // externally visible label, this runs into issues with certain linker
 544   // versions.
 545   if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
 546       TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
 547     return UStringSection;
 548
 549   if (Kind.isMergeableConst()) {
 550     if (Kind.isMergeableConst4())
 551       return FourByteConstantSection;
 552     if (Kind.isMergeableConst8())
 553       return EightByteConstantSection;
 554     if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 555       return SixteenByteConstantSection;
 556   }
 557
 558   // Otherwise, if it is readonly, but not something we can specially optimize,
 559   // just drop it in .const.
 560   if (Kind.isReadOnly())
 561     return ReadOnlySection;
 562
 563   // If this is marked const, put it into a const section.  But if the dynamic
 564   // linker needs to write to it, put it in the data segment.
 565   if (Kind.isReadOnlyWithRel())
 566     return ConstDataSection;
 567
 568   // Put zero initialized globals with strong external linkage in the
 569   // DATA, __common section with the .zerofill directive.
 570   if (Kind.isBSSExtern())
 571     return DataCommonSection;
 572
 573   // Put zero initialized globals with local linkage in __DATA,__bss directive
 574   // with the .zerofill directive (aka .lcomm).
 575   if (Kind.isBSSLocal())
 576     return DataBSSSection;
 577
 578   // Handle thread local data.
 579   if (Kind.isThreadBSS()) return TLSBSSSection;
 580   if (Kind.isThreadData()) return TLSDataSection;
 581
 582   // Otherwise, just drop the variable in the normal data section.
 583   return DataSection;
 584 }
 585
 586 const MCSection *
 587 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
 588   // If this constant requires a relocation, we have to put it in the data
 589   // segment, not in the text segment.
 590   if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
 591     return ConstDataSection;
 592
 593   if (Kind.isMergeableConst4())
 594     return FourByteConstantSection;
 595   if (Kind.isMergeableConst8())
 596     return EightByteConstantSection;
 597   if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 598     return SixteenByteConstantSection;
 599   return ReadOnlySection;  // .const
 600 }
 601
 602 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
 603 /// not to emit the UsedDirective for some symbols in llvm.used.
 604 // FIXME: REMOVE this (rdar://7071300)
 605 bool TargetLoweringObjectFileMachO::
 606 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
 607   /// On Darwin, internally linked data beginning with "L" or "l" does not have
 608   /// the directive emitted (this occurs in ObjC metadata).
 609   if (!GV) return false;
 610
 611   // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
 612   if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
 613     // FIXME: ObjC metadata is currently emitted as internal symbols that have
 614     // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
 615     // this horrible hack can go away.
 616     MCSymbol *Sym = Mang->getSymbol(GV);
 617     if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
 618       return false;
 619   }
 620
 621   return true;
 622 }
 623
 624 const MCExpr *TargetLoweringObjectFileMachO::
 625 getTTypeGlobalReference(const GlobalValue *GV, Mangler *Mang,
 626                         MachineModuleInfo *MMI, unsigned Encoding,
 627                         MCStreamer &Streamer) const {
 628   // The mach-o version of this method defaults to returning a stub reference.
 629
 630   if (Encoding & DW_EH_PE_indirect) {
 631     MachineModuleInfoMachO &MachOMMI =
 632       MMI->getObjFileInfo<MachineModuleInfoMachO>();
 633
 634     SmallString<128> Name;
 635     Mang->getNameWithPrefix(Name, GV, true);
 636     Name += "$non_lazy_ptr";
 637
 638     // Add information about the stub reference to MachOMMI so that the stub
 639     // gets emitted by the asmprinter.
 640     MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
 641     MachineModuleInfoImpl::StubValueTy &StubSym =
 642       GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) :
 643                                   MachOMMI.getGVStubEntry(SSym);
 644     if (StubSym.getPointer() == 0) {
 645       MCSymbol *Sym = Mang->getSymbol(GV);
 646       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
 647     }
 648
 649     return TargetLoweringObjectFile::
 650       getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()),
 651                         Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
 652   }
 653
 654   return TargetLoweringObjectFile::
 655     getTTypeGlobalReference(GV, Mang, MMI, Encoding, Streamer);
 656 }
 657
 658 MCSymbol *TargetLoweringObjectFileMachO::
 659 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
 660                         MachineModuleInfo *MMI) const {
 661   // The mach-o version of this method defaults to returning a stub reference.
 662   MachineModuleInfoMachO &MachOMMI =
 663     MMI->getObjFileInfo<MachineModuleInfoMachO>();
 664
 665   SmallString<128> Name;
 666   Mang->getNameWithPrefix(Name, GV, true);
 667   Name += "$non_lazy_ptr";
 668
 669   // Add information about the stub reference to MachOMMI so that the stub
 670   // gets emitted by the asmprinter.
 671   MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
 672   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
 673   if (StubSym.getPointer() == 0) {
 674     MCSymbol *Sym = Mang->getSymbol(GV);
 675     StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
 676   }
 677
 678   return SSym;
 679 }
 680
 681 //===----------------------------------------------------------------------===//
 682 //                                  COFF
 683 //===----------------------------------------------------------------------===//
 684
 685 static unsigned
 686 getCOFFSectionFlags(SectionKind K) {
 687   unsigned Flags = 0;
 688
 689   if (K.isMetadata())
 690     Flags |=
 691       COFF::IMAGE_SCN_MEM_DISCARDABLE;
 692   else if (K.isText())
 693     Flags |=
 694       COFF::IMAGE_SCN_MEM_EXECUTE |
 695       COFF::IMAGE_SCN_MEM_READ |
 696       COFF::IMAGE_SCN_CNT_CODE;
 697   else if (K.isBSS ())
 698     Flags |=
 699       COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
 700       COFF::IMAGE_SCN_MEM_READ |
 701       COFF::IMAGE_SCN_MEM_WRITE;
 702   else if (K.isThreadLocal())
 703     Flags |=
 704       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 705       COFF::IMAGE_SCN_MEM_READ |
 706       COFF::IMAGE_SCN_MEM_WRITE;
 707   else if (K.isReadOnly())
 708     Flags |=
 709       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 710       COFF::IMAGE_SCN_MEM_READ;
 711   else if (K.isWriteable())
 712     Flags |=
 713       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 714       COFF::IMAGE_SCN_MEM_READ |
 715       COFF::IMAGE_SCN_MEM_WRITE;
 716
 717   return Flags;
 718 }
 719
 720 const MCSection *TargetLoweringObjectFileCOFF::
 721 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 722                          Mangler *Mang, const TargetMachine &TM) const {
 723   int Selection = 0;
 724   unsigned Characteristics = getCOFFSectionFlags(Kind);
 725   SmallString<128> Name(GV->getSection().c_str());
 726   if (GV->isWeakForLinker()) {
 727     Selection = COFF::IMAGE_COMDAT_SELECT_ANY;
 728     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
 729     MCSymbol *Sym = Mang->getSymbol(GV);
 730     Name.append("$");
 731     Name.append(Sym->getName().begin() + 1, Sym->getName().end());
 732   }
 733   return getContext().getCOFFSection(Name,
 734                                      Characteristics,
 735                                      Selection,
 736                                      Kind);
 737 }
 738
 739 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
 740   if (Kind.isText())
 741     return ".text$";
 742   if (Kind.isBSS ())
 743     return ".bss$";
 744   if (Kind.isThreadLocal()) {
 745     // 'LLVM' is just an arbitary string to ensure that the section name gets
 746     // sorted in between '.tls$AAA' and '.tls$ZZZ' by the linker.
 747     return ".tls$LLVM";
 748   }
 749   if (Kind.isWriteable())
 750     return ".data$";
 751   return ".rdata$";
 752 }
 753
 754
 755 const MCSection *TargetLoweringObjectFileCOFF::
 756 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 757                        Mangler *Mang, const TargetMachine &TM) const {
 758
 759   // If this global is linkonce/weak and the target handles this by emitting it
 760   // into a 'uniqued' section name, create and return the section now.
 761   if (GV->isWeakForLinker()) {
 762     const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
 763     SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
 764     MCSymbol *Sym = Mang->getSymbol(GV);
 765     Name.append(Sym->getName().begin() + 1, Sym->getName().end());
 766
 767     unsigned Characteristics = getCOFFSectionFlags(Kind);
 768
 769     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
 770
 771     return getContext().getCOFFSection(Name.str(), Characteristics,
 772                           COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
 773   }
 774
 775   if (Kind.isText())
 776     return getTextSection();
 777
 778   if (Kind.isThreadLocal())
 779     return getTLSDataSection();
 780
 781   return getDataSection();
 782 }
 783
 784 void TargetLoweringObjectFileCOFF::
 785 emitModuleFlags(MCStreamer &Streamer,
 786                 ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
 787                 Mangler *Mang, const TargetMachine &TM) const {
 788   MDNode *LinkerOptions = 0;
 789
 790   // Look for the "Linker Options" flag, since it's the only one we support.
 791   for (ArrayRef<Module::ModuleFlagEntry>::iterator
 792        i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
 793     const Module::ModuleFlagEntry &MFE = *i;
 794     StringRef Key = MFE.Key->getString();
 795     Value *Val = MFE.Val;
 796     if (Key == "Linker Options") {
 797       LinkerOptions = cast<MDNode>(Val);
 798       break;
 799     }
 800   }
 801   if (!LinkerOptions)
 802     return;
 803
 804   // Emit the linker options to the linker .drectve section.  According to the
 805   // spec, this section is a space-separated string containing flags for linker.
 806   const MCSection *Sec = getDrectveSection();
 807   Streamer.SwitchSection(Sec);
 808   for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
 809     MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
 810     for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
 811       MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
 812       StringRef Op = MDOption->getString();
 813       // Lead with a space for consistency with our dllexport implementation.
 814       std::string Escaped(" ");
 815       if (Op.find(" ") != StringRef::npos) {
 816         // The PE-COFF spec says args with spaces must be quoted.  It doesn't say
 817         // how to escape quotes, but it probably uses this algorithm:
 818         // http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx
 819         // FIXME: Reuse escaping code from Support/Windows/Program.inc
 820         Escaped.push_back('\"');
 821         Escaped.append(Op);
 822         Escaped.push_back('\"');
 823       } else {
 824         Escaped.append(Op);
 825       }
 826       Streamer.EmitBytes(Escaped);
 827     }
 828   }
 829 }