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/Constants.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/Function.h"
  19 #include "llvm/GlobalVariable.h"
  20 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  21 #include "llvm/MC/MCContext.h"
  22 #include "llvm/MC/MCExpr.h"
  23 #include "llvm/MC/MCSectionMachO.h"
  24 #include "llvm/MC/MCSectionELF.h"
  25 #include "llvm/MC/MCSectionCOFF.h"
  26 #include "llvm/MC/MCStreamer.h"
  27 #include "llvm/MC/MCSymbol.h"
  28 #include "llvm/Target/Mangler.h"
  29 #include "llvm/Target/TargetData.h"
  30 #include "llvm/Target/TargetMachine.h"
  31 #include "llvm/Target/TargetOptions.h"
  32 #include "llvm/Support/Dwarf.h"
  33 #include "llvm/Support/ELF.h"
  34 #include "llvm/Support/ErrorHandling.h"
  35 #include "llvm/Support/raw_ostream.h"
  36 #include "llvm/ADT/SmallString.h"
  37 #include "llvm/ADT/StringExtras.h"
  38 #include "llvm/ADT/Triple.h"
  39 using namespace llvm;
  40 using namespace dwarf;
  41
  42 //===----------------------------------------------------------------------===//
  43 //                                  ELF
  44 //===----------------------------------------------------------------------===//
  45
  46 TargetLoweringObjectFileELF::TargetLoweringObjectFileELF()
  47   : TargetLoweringObjectFile(),
  48     TLSDataSection(0),
  49     TLSBSSSection(0),
  50     DataRelSection(0),
  51     DataRelLocalSection(0),
  52     DataRelROSection(0),
  53     DataRelROLocalSection(0),
  54     MergeableConst4Section(0),
  55     MergeableConst8Section(0),
  56     MergeableConst16Section(0) {
  57 }
  58
  59 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
  60                                              const TargetMachine &TM) {
  61   TargetLoweringObjectFile::Initialize(Ctx, TM);
  62
  63   BSSSection =
  64     getContext().getELFSection(".bss", ELF::SHT_NOBITS,
  65                                ELF::SHF_WRITE |ELF::SHF_ALLOC,
  66                                SectionKind::getBSS());
  67
  68   TextSection =
  69     getContext().getELFSection(".text", ELF::SHT_PROGBITS,
  70                                ELF::SHF_EXECINSTR |
  71                                ELF::SHF_ALLOC,
  72                                SectionKind::getText());
  73
  74   DataSection =
  75     getContext().getELFSection(".data", ELF::SHT_PROGBITS,
  76                                ELF::SHF_WRITE |ELF::SHF_ALLOC,
  77                                SectionKind::getDataRel());
  78
  79   ReadOnlySection =
  80     getContext().getELFSection(".rodata", ELF::SHT_PROGBITS,
  81                                ELF::SHF_ALLOC,
  82                                SectionKind::getReadOnly());
  83
  84   TLSDataSection =
  85     getContext().getELFSection(".tdata", ELF::SHT_PROGBITS,
  86                                ELF::SHF_ALLOC | ELF::SHF_TLS |
  87                                ELF::SHF_WRITE,
  88                                SectionKind::getThreadData());
  89
  90   TLSBSSSection =
  91     getContext().getELFSection(".tbss", ELF::SHT_NOBITS,
  92                                ELF::SHF_ALLOC | ELF::SHF_TLS |
  93                                ELF::SHF_WRITE,
  94                                SectionKind::getThreadBSS());
  95
  96   DataRelSection =
  97     getContext().getELFSection(".data.rel", ELF::SHT_PROGBITS,
  98                                ELF::SHF_ALLOC |ELF::SHF_WRITE,
  99                                SectionKind::getDataRel());
 100
 101   DataRelLocalSection =
 102     getContext().getELFSection(".data.rel.local", ELF::SHT_PROGBITS,
 103                                ELF::SHF_ALLOC |ELF::SHF_WRITE,
 104                                SectionKind::getDataRelLocal());
 105
 106   DataRelROSection =
 107     getContext().getELFSection(".data.rel.ro", ELF::SHT_PROGBITS,
 108                                ELF::SHF_ALLOC |ELF::SHF_WRITE,
 109                                SectionKind::getReadOnlyWithRel());
 110
 111   DataRelROLocalSection =
 112     getContext().getELFSection(".data.rel.ro.local", ELF::SHT_PROGBITS,
 113                                ELF::SHF_ALLOC |ELF::SHF_WRITE,
 114                                SectionKind::getReadOnlyWithRelLocal());
 115
 116   MergeableConst4Section =
 117     getContext().getELFSection(".rodata.cst4", ELF::SHT_PROGBITS,
 118                                ELF::SHF_ALLOC |ELF::SHF_MERGE,
 119                                SectionKind::getMergeableConst4());
 120
 121   MergeableConst8Section =
 122     getContext().getELFSection(".rodata.cst8", ELF::SHT_PROGBITS,
 123                                ELF::SHF_ALLOC |ELF::SHF_MERGE,
 124                                SectionKind::getMergeableConst8());
 125
 126   MergeableConst16Section =
 127     getContext().getELFSection(".rodata.cst16", ELF::SHT_PROGBITS,
 128                                ELF::SHF_ALLOC |ELF::SHF_MERGE,
 129                                SectionKind::getMergeableConst16());
 130
 131   StaticCtorSection =
 132     getContext().getELFSection(".ctors", ELF::SHT_PROGBITS,
 133                                ELF::SHF_ALLOC |ELF::SHF_WRITE,
 134                                SectionKind::getDataRel());
 135
 136   StaticDtorSection =
 137     getContext().getELFSection(".dtors", ELF::SHT_PROGBITS,
 138                                ELF::SHF_ALLOC |ELF::SHF_WRITE,
 139                                SectionKind::getDataRel());
 140
 141   // Exception Handling Sections.
 142
 143   // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
 144   // it contains relocatable pointers.  In PIC mode, this is probably a big
 145   // runtime hit for C++ apps.  Either the contents of the LSDA need to be
 146   // adjusted or this should be a data section.
 147   LSDASection =
 148     getContext().getELFSection(".gcc_except_table", ELF::SHT_PROGBITS,
 149                                ELF::SHF_ALLOC,
 150                                SectionKind::getReadOnly());
 151   // Debug Info Sections.
 152   DwarfAbbrevSection =
 153     getContext().getELFSection(".debug_abbrev", ELF::SHT_PROGBITS, 0,
 154                                SectionKind::getMetadata());
 155   DwarfInfoSection =
 156     getContext().getELFSection(".debug_info", ELF::SHT_PROGBITS, 0,
 157                                SectionKind::getMetadata());
 158   DwarfLineSection =
 159     getContext().getELFSection(".debug_line", ELF::SHT_PROGBITS, 0,
 160                                SectionKind::getMetadata());
 161   DwarfFrameSection =
 162     getContext().getELFSection(".debug_frame", ELF::SHT_PROGBITS, 0,
 163                                SectionKind::getMetadata());
 164   DwarfPubNamesSection =
 165     getContext().getELFSection(".debug_pubnames", ELF::SHT_PROGBITS, 0,
 166                                SectionKind::getMetadata());
 167   DwarfPubTypesSection =
 168     getContext().getELFSection(".debug_pubtypes", ELF::SHT_PROGBITS, 0,
 169                                SectionKind::getMetadata());
 170   DwarfStrSection =
 171     getContext().getELFSection(".debug_str", ELF::SHT_PROGBITS, 0,
 172                                SectionKind::getMetadata());
 173   DwarfLocSection =
 174     getContext().getELFSection(".debug_loc", ELF::SHT_PROGBITS, 0,
 175                                SectionKind::getMetadata());
 176   DwarfARangesSection =
 177     getContext().getELFSection(".debug_aranges", ELF::SHT_PROGBITS, 0,
 178                                SectionKind::getMetadata());
 179   DwarfRangesSection =
 180     getContext().getELFSection(".debug_ranges", ELF::SHT_PROGBITS, 0,
 181                                SectionKind::getMetadata());
 182   DwarfMacroInfoSection =
 183     getContext().getELFSection(".debug_macinfo", ELF::SHT_PROGBITS, 0,
 184                                SectionKind::getMetadata());
 185 }
 186
 187 const MCSection *TargetLoweringObjectFileELF::getEHFrameSection() const {
 188   return getContext().getELFSection(".eh_frame", ELF::SHT_PROGBITS,
 189                                     ELF::SHF_ALLOC,
 190                                     SectionKind::getDataRel());
 191 }
 192
 193 MCSymbol *
 194 TargetLoweringObjectFileELF::getCFIPersonalitySymbol(const GlobalValue *GV,
 195                                                      Mangler *Mang,
 196                                                 MachineModuleInfo *MMI) const {
 197   unsigned Encoding = getPersonalityEncoding();
 198   switch (Encoding & 0x70) {
 199   default:
 200     report_fatal_error("We do not support this DWARF encoding yet!");
 201   case dwarf::DW_EH_PE_absptr:
 202     return  Mang->getSymbol(GV);
 203     break;
 204   case dwarf::DW_EH_PE_pcrel: {
 205     return getContext().GetOrCreateSymbol(StringRef("DW.ref.") +
 206                                           Mang->getSymbol(GV)->getName());
 207     break;
 208   }
 209   }
 210 }
 211
 212 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer,
 213                                                        const TargetMachine &TM,
 214                                                        const MCSymbol *Sym) const {
 215   SmallString<64> NameData("DW.ref.");
 216   NameData += Sym->getName();
 217   MCSymbol *Label = getContext().GetOrCreateSymbol(NameData);
 218   Streamer.EmitSymbolAttribute(Label, MCSA_Hidden);
 219   Streamer.EmitSymbolAttribute(Label, MCSA_Weak);
 220   StringRef Prefix = ".data.";
 221   NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end());
 222   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP;
 223   const MCSection *Sec = getContext().getELFSection(NameData,
 224                                                     ELF::SHT_PROGBITS,
 225                                                     Flags,
 226                                                     SectionKind::getDataRel(),
 227                                                     0, Label->getName());
 228   Streamer.SwitchSection(Sec);
 229   Streamer.EmitValueToAlignment(8);
 230   Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject);
 231   const MCExpr *E = MCConstantExpr::Create(8, getContext());
 232   Streamer.EmitELFSize(Label, E);
 233   Streamer.EmitLabel(Label);
 234
 235   unsigned Size = TM.getTargetData()->getPointerSize();
 236   Streamer.EmitSymbolValue(Sym, Size);
 237 }
 238
 239 static SectionKind
 240 getELFKindForNamedSection(StringRef Name, SectionKind K) {
 241   // N.B.: The defaults used in here are no the same ones used in MC.
 242   // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
 243   // both gas and MC will produce a section with no flags. Given
 244   // section(".eh_frame") gcc will produce
 245   // .section   .eh_frame,"a",@progbits
 246   if (Name.empty() || Name[0] != '.') return K;
 247
 248   // Some lame default implementation based on some magic section names.
 249   if (Name == ".bss" ||
 250       Name.startswith(".bss.") ||
 251       Name.startswith(".gnu.linkonce.b.") ||
 252       Name.startswith(".llvm.linkonce.b.") ||
 253       Name == ".sbss" ||
 254       Name.startswith(".sbss.") ||
 255       Name.startswith(".gnu.linkonce.sb.") ||
 256       Name.startswith(".llvm.linkonce.sb."))
 257     return SectionKind::getBSS();
 258
 259   if (Name == ".tdata" ||
 260       Name.startswith(".tdata.") ||
 261       Name.startswith(".gnu.linkonce.td.") ||
 262       Name.startswith(".llvm.linkonce.td."))
 263     return SectionKind::getThreadData();
 264
 265   if (Name == ".tbss" ||
 266       Name.startswith(".tbss.") ||
 267       Name.startswith(".gnu.linkonce.tb.") ||
 268       Name.startswith(".llvm.linkonce.tb."))
 269     return SectionKind::getThreadBSS();
 270
 271   return K;
 272 }
 273
 274
 275 static unsigned getELFSectionType(StringRef Name, SectionKind K) {
 276
 277   if (Name == ".init_array")
 278     return ELF::SHT_INIT_ARRAY;
 279
 280   if (Name == ".fini_array")
 281     return ELF::SHT_FINI_ARRAY;
 282
 283   if (Name == ".preinit_array")
 284     return ELF::SHT_PREINIT_ARRAY;
 285
 286   if (K.isBSS() || K.isThreadBSS())
 287     return ELF::SHT_NOBITS;
 288
 289   return ELF::SHT_PROGBITS;
 290 }
 291
 292
 293 static unsigned
 294 getELFSectionFlags(SectionKind K) {
 295   unsigned Flags = 0;
 296
 297   if (!K.isMetadata())
 298     Flags |= ELF::SHF_ALLOC;
 299
 300   if (K.isText())
 301     Flags |= ELF::SHF_EXECINSTR;
 302
 303   if (K.isWriteable())
 304     Flags |= ELF::SHF_WRITE;
 305
 306   if (K.isThreadLocal())
 307     Flags |= ELF::SHF_TLS;
 308
 309   // K.isMergeableConst() is left out to honour PR4650
 310   if (K.isMergeableCString() || K.isMergeableConst4() ||
 311       K.isMergeableConst8() || K.isMergeableConst16())
 312     Flags |= ELF::SHF_MERGE;
 313
 314   if (K.isMergeableCString())
 315     Flags |= ELF::SHF_STRINGS;
 316
 317   return Flags;
 318 }
 319
 320
 321 const MCSection *TargetLoweringObjectFileELF::
 322 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 323                          Mangler *Mang, const TargetMachine &TM) const {
 324   StringRef SectionName = GV->getSection();
 325
 326   // Infer section flags from the section name if we can.
 327   Kind = getELFKindForNamedSection(SectionName, Kind);
 328
 329   return getContext().getELFSection(SectionName,
 330                                     getELFSectionType(SectionName, Kind),
 331                                     getELFSectionFlags(Kind), Kind);
 332 }
 333
 334 /// getSectionPrefixForGlobal - Return the section prefix name used by options
 335 /// FunctionsSections and DataSections.
 336 static const char *getSectionPrefixForGlobal(SectionKind Kind) {
 337   if (Kind.isText())                 return ".text.";
 338   if (Kind.isReadOnly())             return ".rodata.";
 339
 340   if (Kind.isThreadData())           return ".tdata.";
 341   if (Kind.isThreadBSS())            return ".tbss.";
 342
 343   if (Kind.isDataNoRel())            return ".data.";
 344   if (Kind.isDataRelLocal())         return ".data.rel.local.";
 345   if (Kind.isDataRel())              return ".data.rel.";
 346   if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local.";
 347
 348   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 349   return ".data.rel.ro.";
 350 }
 351
 352
 353 const MCSection *TargetLoweringObjectFileELF::
 354 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 355                        Mangler *Mang, const TargetMachine &TM) const {
 356   // If we have -ffunction-section or -fdata-section then we should emit the
 357   // global value to a uniqued section specifically for it.
 358   bool EmitUniquedSection;
 359   if (Kind.isText())
 360     EmitUniquedSection = TM.getFunctionSections();
 361   else
 362     EmitUniquedSection = TM.getDataSections();
 363
 364   // If this global is linkonce/weak and the target handles this by emitting it
 365   // into a 'uniqued' section name, create and return the section now.
 366   if ((GV->isWeakForLinker() || EmitUniquedSection) &&
 367       !Kind.isCommon() && !Kind.isBSS()) {
 368     const char *Prefix;
 369     Prefix = getSectionPrefixForGlobal(Kind);
 370
 371     SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
 372     MCSymbol *Sym = Mang->getSymbol(GV);
 373     Name.append(Sym->getName().begin(), Sym->getName().end());
 374     StringRef Group = "";
 375     unsigned Flags = getELFSectionFlags(Kind);
 376     if (GV->isWeakForLinker()) {
 377       Group = Sym->getName();
 378       Flags |= ELF::SHF_GROUP;
 379     }
 380
 381     return getContext().getELFSection(Name.str(),
 382                                       getELFSectionType(Name.str(), Kind),
 383                                       Flags, Kind, 0, Group);
 384   }
 385
 386   if (Kind.isText()) return TextSection;
 387
 388   if (Kind.isMergeable1ByteCString() ||
 389       Kind.isMergeable2ByteCString() ||
 390       Kind.isMergeable4ByteCString()) {
 391
 392     // We also need alignment here.
 393     // FIXME: this is getting the alignment of the character, not the
 394     // alignment of the global!
 395     unsigned Align =
 396       TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
 397
 398     const char *SizeSpec = ".rodata.str1.";
 399     if (Kind.isMergeable2ByteCString())
 400       SizeSpec = ".rodata.str2.";
 401     else if (Kind.isMergeable4ByteCString())
 402       SizeSpec = ".rodata.str4.";
 403     else
 404       assert(Kind.isMergeable1ByteCString() && "unknown string width");
 405
 406
 407     std::string Name = SizeSpec + utostr(Align);
 408     return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
 409                                       ELF::SHF_ALLOC |
 410                                       ELF::SHF_MERGE |
 411                                       ELF::SHF_STRINGS,
 412                                       Kind);
 413   }
 414
 415   if (Kind.isMergeableConst()) {
 416     if (Kind.isMergeableConst4() && MergeableConst4Section)
 417       return MergeableConst4Section;
 418     if (Kind.isMergeableConst8() && MergeableConst8Section)
 419       return MergeableConst8Section;
 420     if (Kind.isMergeableConst16() && MergeableConst16Section)
 421       return MergeableConst16Section;
 422     return ReadOnlySection;  // .const
 423   }
 424
 425   if (Kind.isReadOnly())             return ReadOnlySection;
 426
 427   if (Kind.isThreadData())           return TLSDataSection;
 428   if (Kind.isThreadBSS())            return TLSBSSSection;
 429
 430   // Note: we claim that common symbols are put in BSSSection, but they are
 431   // really emitted with the magic .comm directive, which creates a symbol table
 432   // entry but not a section.
 433   if (Kind.isBSS() || Kind.isCommon()) return BSSSection;
 434
 435   if (Kind.isDataNoRel())            return DataSection;
 436   if (Kind.isDataRelLocal())         return DataRelLocalSection;
 437   if (Kind.isDataRel())              return DataRelSection;
 438   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
 439
 440   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 441   return DataRelROSection;
 442 }
 443
 444 /// getSectionForConstant - Given a mergeable constant with the
 445 /// specified size and relocation information, return a section that it
 446 /// should be placed in.
 447 const MCSection *TargetLoweringObjectFileELF::
 448 getSectionForConstant(SectionKind Kind) const {
 449   if (Kind.isMergeableConst4() && MergeableConst4Section)
 450     return MergeableConst4Section;
 451   if (Kind.isMergeableConst8() && MergeableConst8Section)
 452     return MergeableConst8Section;
 453   if (Kind.isMergeableConst16() && MergeableConst16Section)
 454     return MergeableConst16Section;
 455   if (Kind.isReadOnly())
 456     return ReadOnlySection;
 457
 458   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
 459   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 460   return DataRelROSection;
 461 }
 462
 463 const MCExpr *TargetLoweringObjectFileELF::
 464 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
 465                                MachineModuleInfo *MMI,
 466                                unsigned Encoding, MCStreamer &Streamer) const {
 467
 468   if (Encoding & dwarf::DW_EH_PE_indirect) {
 469     MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
 470
 471     SmallString<128> Name;
 472     Mang->getNameWithPrefix(Name, GV, true);
 473     Name += ".DW.stub";
 474
 475     // Add information about the stub reference to ELFMMI so that the stub
 476     // gets emitted by the asmprinter.
 477     MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
 478     MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
 479     if (StubSym.getPointer() == 0) {
 480       MCSymbol *Sym = Mang->getSymbol(GV);
 481       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
 482     }
 483
 484     return TargetLoweringObjectFile::
 485       getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
 486   }
 487
 488   return TargetLoweringObjectFile::
 489     getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
 490 }
 491
 492 //===----------------------------------------------------------------------===//
 493 //                                 MachO
 494 //===----------------------------------------------------------------------===//
 495
 496 TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO()
 497   : TargetLoweringObjectFile(),
 498     TLSDataSection(0),
 499     TLSBSSSection(0),
 500     TLSTLVSection(0),
 501     TLSThreadInitSection(0),
 502     CStringSection(0),
 503     UStringSection(0),
 504     TextCoalSection(0),
 505     ConstTextCoalSection(0),
 506     ConstDataSection(0),
 507     DataCoalSection(0),
 508     DataCommonSection(0),
 509     DataBSSSection(0),
 510     FourByteConstantSection(0),
 511     EightByteConstantSection(0),
 512     SixteenByteConstantSection(0),
 513     LazySymbolPointerSection(0),
 514     NonLazySymbolPointerSection(0) {
 515 }
 516
 517 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
 518                                                const TargetMachine &TM) {
 519   IsFunctionEHFrameSymbolPrivate = false;
 520   SupportsWeakOmittedEHFrame = false;
 521
 522   // .comm doesn't support alignment before Leopard.
 523   Triple T(((LLVMTargetMachine&)TM).getTargetTriple());
 524   if (T.isMacOSX() && T.isMacOSXVersionLT(10, 5))
 525     CommDirectiveSupportsAlignment = false;
 526
 527   TargetLoweringObjectFile::Initialize(Ctx, TM);
 528
 529   TextSection // .text
 530     = getContext().getMachOSection("__TEXT", "__text",
 531                                    MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 532                                    SectionKind::getText());
 533   DataSection // .data
 534     = getContext().getMachOSection("__DATA", "__data", 0,
 535                                    SectionKind::getDataRel());
 536
 537   TLSDataSection // .tdata
 538     = getContext().getMachOSection("__DATA", "__thread_data",
 539                                    MCSectionMachO::S_THREAD_LOCAL_REGULAR,
 540                                    SectionKind::getDataRel());
 541   TLSBSSSection // .tbss
 542     = getContext().getMachOSection("__DATA", "__thread_bss",
 543                                    MCSectionMachO::S_THREAD_LOCAL_ZEROFILL,
 544                                    SectionKind::getThreadBSS());
 545
 546   // TODO: Verify datarel below.
 547   TLSTLVSection // .tlv
 548     = getContext().getMachOSection("__DATA", "__thread_vars",
 549                                    MCSectionMachO::S_THREAD_LOCAL_VARIABLES,
 550                                    SectionKind::getDataRel());
 551
 552   TLSThreadInitSection
 553     = getContext().getMachOSection("__DATA", "__thread_init",
 554                           MCSectionMachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
 555                           SectionKind::getDataRel());
 556
 557   CStringSection // .cstring
 558     = getContext().getMachOSection("__TEXT", "__cstring",
 559                                    MCSectionMachO::S_CSTRING_LITERALS,
 560                                    SectionKind::getMergeable1ByteCString());
 561   UStringSection
 562     = getContext().getMachOSection("__TEXT","__ustring", 0,
 563                                    SectionKind::getMergeable2ByteCString());
 564   FourByteConstantSection // .literal4
 565     = getContext().getMachOSection("__TEXT", "__literal4",
 566                                    MCSectionMachO::S_4BYTE_LITERALS,
 567                                    SectionKind::getMergeableConst4());
 568   EightByteConstantSection // .literal8
 569     = getContext().getMachOSection("__TEXT", "__literal8",
 570                                    MCSectionMachO::S_8BYTE_LITERALS,
 571                                    SectionKind::getMergeableConst8());
 572
 573   // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
 574   // to using it in -static mode.
 575   SixteenByteConstantSection = 0;
 576   if (TM.getRelocationModel() != Reloc::Static &&
 577       TM.getTargetData()->getPointerSize() == 32)
 578     SixteenByteConstantSection =   // .literal16
 579       getContext().getMachOSection("__TEXT", "__literal16",
 580                                    MCSectionMachO::S_16BYTE_LITERALS,
 581                                    SectionKind::getMergeableConst16());
 582
 583   ReadOnlySection  // .const
 584     = getContext().getMachOSection("__TEXT", "__const", 0,
 585                                    SectionKind::getReadOnly());
 586
 587   TextCoalSection
 588     = getContext().getMachOSection("__TEXT", "__textcoal_nt",
 589                                    MCSectionMachO::S_COALESCED |
 590                                    MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 591                                    SectionKind::getText());
 592   ConstTextCoalSection
 593     = getContext().getMachOSection("__TEXT", "__const_coal",
 594                                    MCSectionMachO::S_COALESCED,
 595                                    SectionKind::getReadOnly());
 596   ConstDataSection  // .const_data
 597     = getContext().getMachOSection("__DATA", "__const", 0,
 598                                    SectionKind::getReadOnlyWithRel());
 599   DataCoalSection
 600     = getContext().getMachOSection("__DATA","__datacoal_nt",
 601                                    MCSectionMachO::S_COALESCED,
 602                                    SectionKind::getDataRel());
 603   DataCommonSection
 604     = getContext().getMachOSection("__DATA","__common",
 605                                    MCSectionMachO::S_ZEROFILL,
 606                                    SectionKind::getBSS());
 607   DataBSSSection
 608     = getContext().getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL,
 609                                    SectionKind::getBSS());
 610
 611
 612   LazySymbolPointerSection
 613     = getContext().getMachOSection("__DATA", "__la_symbol_ptr",
 614                                    MCSectionMachO::S_LAZY_SYMBOL_POINTERS,
 615                                    SectionKind::getMetadata());
 616   NonLazySymbolPointerSection
 617     = getContext().getMachOSection("__DATA", "__nl_symbol_ptr",
 618                                    MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS,
 619                                    SectionKind::getMetadata());
 620
 621   if (TM.getRelocationModel() == Reloc::Static) {
 622     StaticCtorSection
 623       = getContext().getMachOSection("__TEXT", "__constructor", 0,
 624                                      SectionKind::getDataRel());
 625     StaticDtorSection
 626       = getContext().getMachOSection("__TEXT", "__destructor", 0,
 627                                      SectionKind::getDataRel());
 628   } else {
 629     StaticCtorSection
 630       = getContext().getMachOSection("__DATA", "__mod_init_func",
 631                                      MCSectionMachO::S_MOD_INIT_FUNC_POINTERS,
 632                                      SectionKind::getDataRel());
 633     StaticDtorSection
 634       = getContext().getMachOSection("__DATA", "__mod_term_func",
 635                                      MCSectionMachO::S_MOD_TERM_FUNC_POINTERS,
 636                                      SectionKind::getDataRel());
 637   }
 638
 639   // Exception Handling.
 640   LSDASection = getContext().getMachOSection("__TEXT", "__gcc_except_tab", 0,
 641                                              SectionKind::getReadOnlyWithRel());
 642
 643   if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6))
 644     CompactUnwindSection =
 645       getContext().getMachOSection("__LD", "__compact_unwind",
 646                                    MCSectionMachO::S_ATTR_DEBUG,
 647                                    SectionKind::getReadOnly());
 648
 649   // Debug Information.
 650   DwarfAbbrevSection =
 651     getContext().getMachOSection("__DWARF", "__debug_abbrev",
 652                                  MCSectionMachO::S_ATTR_DEBUG,
 653                                  SectionKind::getMetadata());
 654   DwarfInfoSection =
 655     getContext().getMachOSection("__DWARF", "__debug_info",
 656                                  MCSectionMachO::S_ATTR_DEBUG,
 657                                  SectionKind::getMetadata());
 658   DwarfLineSection =
 659     getContext().getMachOSection("__DWARF", "__debug_line",
 660                                  MCSectionMachO::S_ATTR_DEBUG,
 661                                  SectionKind::getMetadata());
 662   DwarfFrameSection =
 663     getContext().getMachOSection("__DWARF", "__debug_frame",
 664                                  MCSectionMachO::S_ATTR_DEBUG,
 665                                  SectionKind::getMetadata());
 666   DwarfPubNamesSection =
 667     getContext().getMachOSection("__DWARF", "__debug_pubnames",
 668                                  MCSectionMachO::S_ATTR_DEBUG,
 669                                  SectionKind::getMetadata());
 670   DwarfPubTypesSection =
 671     getContext().getMachOSection("__DWARF", "__debug_pubtypes",
 672                                  MCSectionMachO::S_ATTR_DEBUG,
 673                                  SectionKind::getMetadata());
 674   DwarfStrSection =
 675     getContext().getMachOSection("__DWARF", "__debug_str",
 676                                  MCSectionMachO::S_ATTR_DEBUG,
 677                                  SectionKind::getMetadata());
 678   DwarfLocSection =
 679     getContext().getMachOSection("__DWARF", "__debug_loc",
 680                                  MCSectionMachO::S_ATTR_DEBUG,
 681                                  SectionKind::getMetadata());
 682   DwarfARangesSection =
 683     getContext().getMachOSection("__DWARF", "__debug_aranges",
 684                                  MCSectionMachO::S_ATTR_DEBUG,
 685                                  SectionKind::getMetadata());
 686   DwarfRangesSection =
 687     getContext().getMachOSection("__DWARF", "__debug_ranges",
 688                                  MCSectionMachO::S_ATTR_DEBUG,
 689                                  SectionKind::getMetadata());
 690   DwarfMacroInfoSection =
 691     getContext().getMachOSection("__DWARF", "__debug_macinfo",
 692                                  MCSectionMachO::S_ATTR_DEBUG,
 693                                  SectionKind::getMetadata());
 694   DwarfDebugInlineSection =
 695     getContext().getMachOSection("__DWARF", "__debug_inlined",
 696                                  MCSectionMachO::S_ATTR_DEBUG,
 697                                  SectionKind::getMetadata());
 698
 699   TLSExtraDataSection = TLSTLVSection;
 700 }
 701
 702 const MCSection *TargetLoweringObjectFileMachO::getEHFrameSection() const {
 703   return getContext().getMachOSection("__TEXT", "__eh_frame",
 704                                       MCSectionMachO::S_COALESCED |
 705                                       MCSectionMachO::S_ATTR_NO_TOC |
 706                                       MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS |
 707                                       MCSectionMachO::S_ATTR_LIVE_SUPPORT,
 708                                       SectionKind::getReadOnly());
 709 }
 710
 711 const MCSection *TargetLoweringObjectFileMachO::
 712 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 713                          Mangler *Mang, const TargetMachine &TM) const {
 714   // Parse the section specifier and create it if valid.
 715   StringRef Segment, Section;
 716   unsigned TAA = 0, StubSize = 0;
 717   bool TAAParsed;
 718   std::string ErrorCode =
 719     MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section,
 720                                           TAA, TAAParsed, StubSize);
 721   if (!ErrorCode.empty()) {
 722     // If invalid, report the error with report_fatal_error.
 723     report_fatal_error("Global variable '" + GV->getNameStr() +
 724                       "' has an invalid section specifier '" + GV->getSection()+
 725                       "': " + ErrorCode + ".");
 726     // Fall back to dropping it into the data section.
 727     return DataSection;
 728   }
 729
 730   // Get the section.
 731   const MCSectionMachO *S =
 732     getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind);
 733
 734   // If TAA wasn't set by ParseSectionSpecifier() above,
 735   // use the value returned by getMachOSection() as a default.
 736   if (!TAAParsed)
 737     TAA = S->getTypeAndAttributes();
 738
 739   // Okay, now that we got the section, verify that the TAA & StubSize agree.
 740   // If the user declared multiple globals with different section flags, we need
 741   // to reject it here.
 742   if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) {
 743     // If invalid, report the error with report_fatal_error.
 744     report_fatal_error("Global variable '" + GV->getNameStr() +
 745                       "' section type or attributes does not match previous"
 746                       " section specifier");
 747   }
 748
 749   return S;
 750 }
 751
 752 const MCSection *TargetLoweringObjectFileMachO::
 753 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 754                        Mangler *Mang, const TargetMachine &TM) const {
 755
 756   // Handle thread local data.
 757   if (Kind.isThreadBSS()) return TLSBSSSection;
 758   if (Kind.isThreadData()) return TLSDataSection;
 759
 760   if (Kind.isText())
 761     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
 762
 763   // If this is weak/linkonce, put this in a coalescable section, either in text
 764   // or data depending on if it is writable.
 765   if (GV->isWeakForLinker()) {
 766     if (Kind.isReadOnly())
 767       return ConstTextCoalSection;
 768     return DataCoalSection;
 769   }
 770
 771   // FIXME: Alignment check should be handled by section classifier.
 772   if (Kind.isMergeable1ByteCString() &&
 773       TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
 774     return CStringSection;
 775
 776   // Do not put 16-bit arrays in the UString section if they have an
 777   // externally visible label, this runs into issues with certain linker
 778   // versions.
 779   if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() &&
 780       TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32)
 781     return UStringSection;
 782
 783   if (Kind.isMergeableConst()) {
 784     if (Kind.isMergeableConst4())
 785       return FourByteConstantSection;
 786     if (Kind.isMergeableConst8())
 787       return EightByteConstantSection;
 788     if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 789       return SixteenByteConstantSection;
 790   }
 791
 792   // Otherwise, if it is readonly, but not something we can specially optimize,
 793   // just drop it in .const.
 794   if (Kind.isReadOnly())
 795     return ReadOnlySection;
 796
 797   // If this is marked const, put it into a const section.  But if the dynamic
 798   // linker needs to write to it, put it in the data segment.
 799   if (Kind.isReadOnlyWithRel())
 800     return ConstDataSection;
 801
 802   // Put zero initialized globals with strong external linkage in the
 803   // DATA, __common section with the .zerofill directive.
 804   if (Kind.isBSSExtern())
 805     return DataCommonSection;
 806
 807   // Put zero initialized globals with local linkage in __DATA,__bss directive
 808   // with the .zerofill directive (aka .lcomm).
 809   if (Kind.isBSSLocal())
 810     return DataBSSSection;
 811
 812   // Otherwise, just drop the variable in the normal data section.
 813   return DataSection;
 814 }
 815
 816 const MCSection *
 817 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
 818   // If this constant requires a relocation, we have to put it in the data
 819   // segment, not in the text segment.
 820   if (Kind.isDataRel() || Kind.isReadOnlyWithRel())
 821     return ConstDataSection;
 822
 823   if (Kind.isMergeableConst4())
 824     return FourByteConstantSection;
 825   if (Kind.isMergeableConst8())
 826     return EightByteConstantSection;
 827   if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 828     return SixteenByteConstantSection;
 829   return ReadOnlySection;  // .const
 830 }
 831
 832 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
 833 /// not to emit the UsedDirective for some symbols in llvm.used.
 834 // FIXME: REMOVE this (rdar://7071300)
 835 bool TargetLoweringObjectFileMachO::
 836 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
 837   /// On Darwin, internally linked data beginning with "L" or "l" does not have
 838   /// the directive emitted (this occurs in ObjC metadata).
 839   if (!GV) return false;
 840
 841   // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
 842   if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
 843     // FIXME: ObjC metadata is currently emitted as internal symbols that have
 844     // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
 845     // this horrible hack can go away.
 846     MCSymbol *Sym = Mang->getSymbol(GV);
 847     if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l')
 848       return false;
 849   }
 850
 851   return true;
 852 }
 853
 854 const MCExpr *TargetLoweringObjectFileMachO::
 855 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
 856                                MachineModuleInfo *MMI, unsigned Encoding,
 857                                MCStreamer &Streamer) const {
 858   // The mach-o version of this method defaults to returning a stub reference.
 859
 860   if (Encoding & DW_EH_PE_indirect) {
 861     MachineModuleInfoMachO &MachOMMI =
 862       MMI->getObjFileInfo<MachineModuleInfoMachO>();
 863
 864     SmallString<128> Name;
 865     Mang->getNameWithPrefix(Name, GV, true);
 866     Name += "$non_lazy_ptr";
 867
 868     // Add information about the stub reference to MachOMMI so that the stub
 869     // gets emitted by the asmprinter.
 870     MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
 871     MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
 872     if (StubSym.getPointer() == 0) {
 873       MCSymbol *Sym = Mang->getSymbol(GV);
 874       StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
 875     }
 876
 877     return TargetLoweringObjectFile::
 878       getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
 879   }
 880
 881   return TargetLoweringObjectFile::
 882     getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer);
 883 }
 884
 885 MCSymbol *TargetLoweringObjectFileMachO::
 886 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang,
 887                         MachineModuleInfo *MMI) const {
 888   // The mach-o version of this method defaults to returning a stub reference.
 889   MachineModuleInfoMachO &MachOMMI =
 890     MMI->getObjFileInfo<MachineModuleInfoMachO>();
 891
 892   SmallString<128> Name;
 893   Mang->getNameWithPrefix(Name, GV, true);
 894   Name += "$non_lazy_ptr";
 895
 896   // Add information about the stub reference to MachOMMI so that the stub
 897   // gets emitted by the asmprinter.
 898   MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str());
 899   MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
 900   if (StubSym.getPointer() == 0) {
 901     MCSymbol *Sym = Mang->getSymbol(GV);
 902     StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
 903   }
 904
 905   return SSym;
 906 }
 907
 908 unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const {
 909   return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
 910 }
 911
 912 unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const {
 913   return DW_EH_PE_pcrel;
 914 }
 915
 916 unsigned TargetLoweringObjectFileMachO::getFDEEncoding(bool CFI) const {
 917   return DW_EH_PE_pcrel;
 918 }
 919
 920 unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const {
 921   return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4;
 922 }
 923
 924 //===----------------------------------------------------------------------===//
 925 //                                  COFF
 926 //===----------------------------------------------------------------------===//
 927
 928 TargetLoweringObjectFileCOFF::TargetLoweringObjectFileCOFF()
 929   : TargetLoweringObjectFile(),
 930     DrectveSection(0),
 931     PDataSection(0),
 932     XDataSection(0) {
 933 }
 934
 935 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
 936                                               const TargetMachine &TM) {
 937   TargetLoweringObjectFile::Initialize(Ctx, TM);
 938   TextSection =
 939     getContext().getCOFFSection(".text",
 940                                 COFF::IMAGE_SCN_CNT_CODE |
 941                                 COFF::IMAGE_SCN_MEM_EXECUTE |
 942                                 COFF::IMAGE_SCN_MEM_READ,
 943                                 SectionKind::getText());
 944   DataSection =
 945     getContext().getCOFFSection(".data",
 946                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 947                                 COFF::IMAGE_SCN_MEM_READ |
 948                                 COFF::IMAGE_SCN_MEM_WRITE,
 949                                 SectionKind::getDataRel());
 950   ReadOnlySection =
 951     getContext().getCOFFSection(".rdata",
 952                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 953                                 COFF::IMAGE_SCN_MEM_READ,
 954                                 SectionKind::getReadOnly());
 955   StaticCtorSection =
 956     getContext().getCOFFSection(".ctors",
 957                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 958                                 COFF::IMAGE_SCN_MEM_READ |
 959                                 COFF::IMAGE_SCN_MEM_WRITE,
 960                                 SectionKind::getDataRel());
 961   StaticDtorSection =
 962     getContext().getCOFFSection(".dtors",
 963                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 964                                 COFF::IMAGE_SCN_MEM_READ |
 965                                 COFF::IMAGE_SCN_MEM_WRITE,
 966                                 SectionKind::getDataRel());
 967
 968   // FIXME: We're emitting LSDA info into a readonly section on COFF, even
 969   // though it contains relocatable pointers.  In PIC mode, this is probably a
 970   // big runtime hit for C++ apps.  Either the contents of the LSDA need to be
 971   // adjusted or this should be a data section.
 972   LSDASection =
 973     getContext().getCOFFSection(".gcc_except_table",
 974                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
 975                                 COFF::IMAGE_SCN_MEM_READ,
 976                                 SectionKind::getReadOnly());
 977   // Debug info.
 978   DwarfAbbrevSection =
 979     getContext().getCOFFSection(".debug_abbrev",
 980                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
 981                                 COFF::IMAGE_SCN_MEM_READ,
 982                                 SectionKind::getMetadata());
 983   DwarfInfoSection =
 984     getContext().getCOFFSection(".debug_info",
 985                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
 986                                 COFF::IMAGE_SCN_MEM_READ,
 987                                 SectionKind::getMetadata());
 988   DwarfLineSection =
 989     getContext().getCOFFSection(".debug_line",
 990                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
 991                                 COFF::IMAGE_SCN_MEM_READ,
 992                                 SectionKind::getMetadata());
 993   DwarfFrameSection =
 994     getContext().getCOFFSection(".debug_frame",
 995                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
 996                                 COFF::IMAGE_SCN_MEM_READ,
 997                                 SectionKind::getMetadata());
 998   DwarfPubNamesSection =
 999     getContext().getCOFFSection(".debug_pubnames",
1000                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1001                                 COFF::IMAGE_SCN_MEM_READ,
1002                                 SectionKind::getMetadata());
1003   DwarfPubTypesSection =
1004     getContext().getCOFFSection(".debug_pubtypes",
1005                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1006                                 COFF::IMAGE_SCN_MEM_READ,
1007                                 SectionKind::getMetadata());
1008   DwarfStrSection =
1009     getContext().getCOFFSection(".debug_str",
1010                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1011                                 COFF::IMAGE_SCN_MEM_READ,
1012                                 SectionKind::getMetadata());
1013   DwarfLocSection =
1014     getContext().getCOFFSection(".debug_loc",
1015                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1016                                 COFF::IMAGE_SCN_MEM_READ,
1017                                 SectionKind::getMetadata());
1018   DwarfARangesSection =
1019     getContext().getCOFFSection(".debug_aranges",
1020                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1021                                 COFF::IMAGE_SCN_MEM_READ,
1022                                 SectionKind::getMetadata());
1023   DwarfRangesSection =
1024     getContext().getCOFFSection(".debug_ranges",
1025                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1026                                 COFF::IMAGE_SCN_MEM_READ,
1027                                 SectionKind::getMetadata());
1028   DwarfMacroInfoSection =
1029     getContext().getCOFFSection(".debug_macinfo",
1030                                 COFF::IMAGE_SCN_MEM_DISCARDABLE |
1031                                 COFF::IMAGE_SCN_MEM_READ,
1032                                 SectionKind::getMetadata());
1033
1034   DrectveSection =
1035     getContext().getCOFFSection(".drectve",
1036                                 COFF::IMAGE_SCN_LNK_INFO,
1037                                 SectionKind::getMetadata());
1038
1039   PDataSection =
1040     getContext().getCOFFSection(".pdata",
1041                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1042                                 COFF::IMAGE_SCN_MEM_READ |
1043                                 COFF::IMAGE_SCN_MEM_WRITE,
1044                                 SectionKind::getDataRel());
1045
1046   XDataSection =
1047     getContext().getCOFFSection(".xdata",
1048                                 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1049                                 COFF::IMAGE_SCN_MEM_READ |
1050                                 COFF::IMAGE_SCN_MEM_WRITE,
1051                                 SectionKind::getDataRel());
1052 }
1053
1054 const MCSection *TargetLoweringObjectFileCOFF::getEHFrameSection() const {
1055   return getContext().getCOFFSection(".eh_frame",
1056                                      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1057                                      COFF::IMAGE_SCN_MEM_READ |
1058                                      COFF::IMAGE_SCN_MEM_WRITE,
1059                                      SectionKind::getDataRel());
1060 }
1061
1062 const MCSection *TargetLoweringObjectFileCOFF::getWin64EHFuncTableSection(
1063                                                        StringRef suffix) const {
1064   if (suffix == "")
1065     return PDataSection;
1066   return getContext().getCOFFSection((".pdata"+suffix).str(),
1067                                      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1068                                      COFF::IMAGE_SCN_MEM_READ |
1069                                      COFF::IMAGE_SCN_MEM_WRITE,
1070                                      SectionKind::getDataRel());
1071 }
1072
1073 const MCSection *TargetLoweringObjectFileCOFF::getWin64EHTableSection(
1074                                                        StringRef suffix) const {
1075   if (suffix == "")
1076     return XDataSection;
1077   return getContext().getCOFFSection((".xdata"+suffix).str(),
1078                                      COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1079                                      COFF::IMAGE_SCN_MEM_READ |
1080                                      COFF::IMAGE_SCN_MEM_WRITE,
1081                                      SectionKind::getDataRel());
1082 }
1083
1084
1085 static unsigned
1086 getCOFFSectionFlags(SectionKind K) {
1087   unsigned Flags = 0;
1088
1089   if (K.isMetadata())
1090     Flags |=
1091       COFF::IMAGE_SCN_MEM_DISCARDABLE;
1092   else if (K.isText())
1093     Flags |=
1094       COFF::IMAGE_SCN_MEM_EXECUTE |
1095       COFF::IMAGE_SCN_MEM_READ |
1096       COFF::IMAGE_SCN_CNT_CODE;
1097   else if (K.isBSS ())
1098     Flags |=
1099       COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
1100       COFF::IMAGE_SCN_MEM_READ |
1101       COFF::IMAGE_SCN_MEM_WRITE;
1102   else if (K.isReadOnly())
1103     Flags |=
1104       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1105       COFF::IMAGE_SCN_MEM_READ;
1106   else if (K.isWriteable())
1107     Flags |=
1108       COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1109       COFF::IMAGE_SCN_MEM_READ |
1110       COFF::IMAGE_SCN_MEM_WRITE;
1111
1112   return Flags;
1113 }
1114
1115 const MCSection *TargetLoweringObjectFileCOFF::
1116 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
1117                          Mangler *Mang, const TargetMachine &TM) const {
1118   return getContext().getCOFFSection(GV->getSection(),
1119                                      getCOFFSectionFlags(Kind),
1120                                      Kind);
1121 }
1122
1123 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
1124   if (Kind.isText())
1125     return ".text$";
1126   if (Kind.isBSS ())
1127     return ".bss$";
1128   if (Kind.isWriteable())
1129     return ".data$";
1130   return ".rdata$";
1131 }
1132
1133
1134 const MCSection *TargetLoweringObjectFileCOFF::
1135 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
1136                        Mangler *Mang, const TargetMachine &TM) const {
1137   assert(!Kind.isThreadLocal() && "Doesn't support TLS");
1138
1139   // If this global is linkonce/weak and the target handles this by emitting it
1140   // into a 'uniqued' section name, create and return the section now.
1141   if (GV->isWeakForLinker()) {
1142     const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
1143     SmallString<128> Name(Prefix, Prefix+strlen(Prefix));
1144     MCSymbol *Sym = Mang->getSymbol(GV);
1145     Name.append(Sym->getName().begin() + 1, Sym->getName().end());
1146
1147     unsigned Characteristics = getCOFFSectionFlags(Kind);
1148
1149     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
1150
1151     return getContext().getCOFFSection(Name.str(), Characteristics,
1152                           COFF::IMAGE_COMDAT_SELECT_ANY, Kind);
1153   }
1154
1155   if (Kind.isText())
1156     return getTextSection();
1157
1158   return getDataSection();
1159 }
1160