lib/Target/TargetLoweringObjectFile.cpp

   1 //===-- llvm/Target/TargetLoweringObjectFile.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/Target/TargetLoweringObjectFile.h"
  16 #include "llvm/Constants.h"
  17 #include "llvm/DerivedTypes.h"
  18 #include "llvm/GlobalVariable.h"
  19 #include "llvm/MC/MCContext.h"
  20 #include "llvm/MC/MCSection.h"
  21 #include "llvm/Target/TargetAsmInfo.h"
  22 #include "llvm/Target/TargetData.h"
  23 #include "llvm/Target/TargetMachine.h"
  24 #include "llvm/Target/TargetOptions.h"
  25 #include "llvm/Support/Mangler.h"
  26 #include "llvm/ADT/StringExtras.h"
  27 using namespace llvm;
  28
  29 //===----------------------------------------------------------------------===//
  30 //                              Generic Code
  31 //===----------------------------------------------------------------------===//
  32
  33 TargetLoweringObjectFile::TargetLoweringObjectFile() : Ctx(0) {
  34   TextSection = 0;
  35   DataSection = 0;
  36   BSSSection = 0;
  37   ReadOnlySection = 0;
  38   StaticCtorSection = 0;
  39   StaticDtorSection = 0;
  40   LSDASection = 0;
  41   EHFrameSection = 0;
  42
  43   DwarfAbbrevSection = 0;
  44   DwarfInfoSection = 0;
  45   DwarfLineSection = 0;
  46   DwarfFrameSection = 0;
  47   DwarfPubNamesSection = 0;
  48   DwarfPubTypesSection = 0;
  49   DwarfDebugInlineSection = 0;
  50   DwarfStrSection = 0;
  51   DwarfLocSection = 0;
  52   DwarfARangesSection = 0;
  53   DwarfRangesSection = 0;
  54   DwarfMacroInfoSection = 0;
  55 }
  56
  57 TargetLoweringObjectFile::~TargetLoweringObjectFile() {
  58 }
  59
  60 static bool isSuitableForBSS(const GlobalVariable *GV) {
  61   Constant *C = GV->getInitializer();
  62
  63   // Must have zero initializer.
  64   if (!C->isNullValue())
  65     return false;
  66
  67   // Leave constant zeros in readonly constant sections, so they can be shared.
  68   if (GV->isConstant())
  69     return false;
  70
  71   // If the global has an explicit section specified, don't put it in BSS.
  72   if (!GV->getSection().empty())
  73     return false;
  74
  75   // If -nozero-initialized-in-bss is specified, don't ever use BSS.
  76   if (NoZerosInBSS)
  77     return false;
  78
  79   // Otherwise, put it in BSS!
  80   return true;
  81 }
  82
  83 /// IsNullTerminatedString - Return true if the specified constant (which is
  84 /// known to have a type that is an array of 1/2/4 byte elements) ends with a
  85 /// nul value and contains no other nuls in it.
  86 static bool IsNullTerminatedString(const Constant *C) {
  87   const ArrayType *ATy = cast<ArrayType>(C->getType());
  88
  89   // First check: is we have constant array of i8 terminated with zero
  90   if (const ConstantArray *CVA = dyn_cast<ConstantArray>(C)) {
  91     if (ATy->getNumElements() == 0) return false;
  92
  93     ConstantInt *Null =
  94       dyn_cast<ConstantInt>(CVA->getOperand(ATy->getNumElements()-1));
  95     if (Null == 0 || Null->getZExtValue() != 0)
  96       return false; // Not null terminated.
  97
  98     // Verify that the null doesn't occur anywhere else in the string.
  99     for (unsigned i = 0, e = ATy->getNumElements()-1; i != e; ++i)
 100       // Reject constantexpr elements etc.
 101       if (!isa<ConstantInt>(CVA->getOperand(i)) ||
 102           CVA->getOperand(i) == Null)
 103         return false;
 104     return true;
 105   }
 106
 107   // Another possibility: [1 x i8] zeroinitializer
 108   if (isa<ConstantAggregateZero>(C))
 109     return ATy->getNumElements() == 1;
 110
 111   return false;
 112 }
 113
 114 /// getKindForGlobal - This is a top-level target-independent classifier for
 115 /// a global variable.  Given an global variable and information from TM, it
 116 /// classifies the global in a variety of ways that make various target
 117 /// implementations simpler.  The target implementation is free to ignore this
 118 /// extra info of course.
 119 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV,
 120                                                        const TargetMachine &TM){
 121   assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
 122          "Can only be used for global definitions");
 123
 124   Reloc::Model ReloModel = TM.getRelocationModel();
 125
 126   // Early exit - functions should be always in text sections.
 127   const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
 128   if (GVar == 0)
 129     return SectionKind::getText();
 130
 131
 132   // Handle thread-local data first.
 133   if (GVar->isThreadLocal()) {
 134     if (isSuitableForBSS(GVar))
 135       return SectionKind::getThreadBSS();
 136     return SectionKind::getThreadData();
 137   }
 138
 139   // Variable can be easily put to BSS section.
 140   if (isSuitableForBSS(GVar))
 141     return SectionKind::getBSS();
 142
 143   Constant *C = GVar->getInitializer();
 144
 145   // If the global is marked constant, we can put it into a mergable section,
 146   // a mergable string section, or general .data if it contains relocations.
 147   if (GVar->isConstant()) {
 148     // If the initializer for the global contains something that requires a
 149     // relocation, then we may have to drop this into a wriable data section
 150     // even though it is marked const.
 151     switch (C->getRelocationInfo()) {
 152     default: llvm_unreachable("unknown relocation info kind");
 153     case Constant::NoRelocation:
 154       // If initializer is a null-terminated string, put it in a "cstring"
 155       // section of the right width.
 156       if (const ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
 157         if (const IntegerType *ITy =
 158               dyn_cast<IntegerType>(ATy->getElementType())) {
 159           if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
 160                ITy->getBitWidth() == 32) &&
 161               IsNullTerminatedString(C)) {
 162             if (ITy->getBitWidth() == 8)
 163               return SectionKind::getMergeable1ByteCString();
 164             if (ITy->getBitWidth() == 16)
 165               return SectionKind::getMergeable2ByteCString();
 166
 167             assert(ITy->getBitWidth() == 32 && "Unknown width");
 168             return SectionKind::getMergeable4ByteCString();
 169           }
 170         }
 171       }
 172
 173       // Otherwise, just drop it into a mergable constant section.  If we have
 174       // a section for this size, use it, otherwise use the arbitrary sized
 175       // mergable section.
 176       switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
 177       case 4:  return SectionKind::getMergeableConst4();
 178       case 8:  return SectionKind::getMergeableConst8();
 179       case 16: return SectionKind::getMergeableConst16();
 180       default: return SectionKind::getMergeableConst();
 181       }
 182
 183     case Constant::LocalRelocation:
 184       // In static relocation model, the linker will resolve all addresses, so
 185       // the relocation entries will actually be constants by the time the app
 186       // starts up.  However, we can't put this into a mergable section, because
 187       // the linker doesn't take relocations into consideration when it tries to
 188       // merge entries in the section.
 189       if (ReloModel == Reloc::Static)
 190         return SectionKind::getReadOnly();
 191
 192       // Otherwise, the dynamic linker needs to fix it up, put it in the
 193       // writable data.rel.local section.
 194       return SectionKind::getReadOnlyWithRelLocal();
 195
 196     case Constant::GlobalRelocations:
 197       // In static relocation model, the linker will resolve all addresses, so
 198       // the relocation entries will actually be constants by the time the app
 199       // starts up.  However, we can't put this into a mergable section, because
 200       // the linker doesn't take relocations into consideration when it tries to
 201       // merge entries in the section.
 202       if (ReloModel == Reloc::Static)
 203         return SectionKind::getReadOnly();
 204
 205       // Otherwise, the dynamic linker needs to fix it up, put it in the
 206       // writable data.rel section.
 207       return SectionKind::getReadOnlyWithRel();
 208     }
 209   }
 210
 211   // Okay, this isn't a constant.  If the initializer for the global is going
 212   // to require a runtime relocation by the dynamic linker, put it into a more
 213   // specific section to improve startup time of the app.  This coalesces these
 214   // globals together onto fewer pages, improving the locality of the dynamic
 215   // linker.
 216   if (ReloModel == Reloc::Static)
 217     return SectionKind::getDataNoRel();
 218
 219   switch (C->getRelocationInfo()) {
 220   default: llvm_unreachable("unknown relocation info kind");
 221   case Constant::NoRelocation:
 222     return SectionKind::getDataNoRel();
 223   case Constant::LocalRelocation:
 224     return SectionKind::getDataRelLocal();
 225   case Constant::GlobalRelocations:
 226     return SectionKind::getDataRel();
 227   }
 228 }
 229
 230 /// SectionForGlobal - This method computes the appropriate section to emit
 231 /// the specified global variable or function definition.  This should not
 232 /// be passed external (or available externally) globals.
 233 const MCSection *TargetLoweringObjectFile::
 234 SectionForGlobal(const GlobalValue *GV, SectionKind Kind, Mangler *Mang,
 235                  const TargetMachine &TM) const {
 236   // Select section name.
 237   if (GV->hasSection())
 238     return getExplicitSectionGlobal(GV, Kind, Mang, TM);
 239
 240
 241   // Use default section depending on the 'type' of global
 242   return SelectSectionForGlobal(GV, Kind, Mang, TM);
 243 }
 244
 245
 246 // Lame default implementation. Calculate the section name for global.
 247 const MCSection *
 248 TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
 249                                                  SectionKind Kind,
 250                                                  Mangler *Mang,
 251                                                  const TargetMachine &TM) const{
 252   assert(!Kind.isThreadLocal() && "Doesn't support TLS");
 253
 254   if (Kind.isText())
 255     return getTextSection();
 256
 257   if (Kind.isBSS() && BSSSection != 0)
 258     return BSSSection;
 259
 260   if (Kind.isReadOnly() && ReadOnlySection != 0)
 261     return ReadOnlySection;
 262
 263   return getDataSection();
 264 }
 265
 266 /// getSectionForConstant - Given a mergable constant with the
 267 /// specified size and relocation information, return a section that it
 268 /// should be placed in.
 269 const MCSection *
 270 TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind) const {
 271   if (Kind.isReadOnly() && ReadOnlySection != 0)
 272     return ReadOnlySection;
 273
 274   return DataSection;
 275 }
 276
 277
 278
 279 //===----------------------------------------------------------------------===//
 280 //                                  ELF
 281 //===----------------------------------------------------------------------===//
 282
 283 const MCSection *TargetLoweringObjectFileELF::
 284 getELFSection(const char *Name, bool isDirective, SectionKind Kind) const {
 285   if (MCSection *S = getContext().GetSection(Name))
 286     return S;
 287   return MCSection::Create(Name, isDirective, Kind, getContext());
 288 }
 289
 290 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
 291                                              const TargetMachine &TM) {
 292   TargetLoweringObjectFile::Initialize(Ctx, TM);
 293   if (!HasCrazyBSS)
 294     BSSSection = getELFSection("\t.bss", true, SectionKind::getBSS());
 295   else
 296     // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
 297     // FIXME: Does .section .bss work everywhere??
 298     // FIXME2: this should just be handle by the section printer.  We should get
 299     // away from syntactic view of the sections and MCSection should just be a
 300     // semantic view.
 301     BSSSection = getELFSection("\t.bss", false, SectionKind::getBSS());
 302
 303
 304   TextSection = getELFSection("\t.text", true, SectionKind::getText());
 305   DataSection = getELFSection("\t.data", true, SectionKind::getDataRel());
 306   ReadOnlySection =
 307     getELFSection("\t.rodata", false, SectionKind::getReadOnly());
 308   TLSDataSection =
 309     getELFSection("\t.tdata", false, SectionKind::getThreadData());
 310
 311   TLSBSSSection = getELFSection("\t.tbss", false,
 312                                      SectionKind::getThreadBSS());
 313
 314   DataRelSection = getELFSection("\t.data.rel", false,
 315                                       SectionKind::getDataRel());
 316   DataRelLocalSection = getELFSection("\t.data.rel.local", false,
 317                                    SectionKind::getDataRelLocal());
 318   DataRelROSection = getELFSection("\t.data.rel.ro", false,
 319                                 SectionKind::getReadOnlyWithRel());
 320   DataRelROLocalSection =
 321     getELFSection("\t.data.rel.ro.local", false,
 322                        SectionKind::getReadOnlyWithRelLocal());
 323
 324   MergeableConst4Section = getELFSection(".rodata.cst4", false,
 325                                 SectionKind::getMergeableConst4());
 326   MergeableConst8Section = getELFSection(".rodata.cst8", false,
 327                                 SectionKind::getMergeableConst8());
 328   MergeableConst16Section = getELFSection(".rodata.cst16", false,
 329                                SectionKind::getMergeableConst16());
 330
 331   StaticCtorSection =
 332     getELFSection(".ctors", false, SectionKind::getDataRel());
 333   StaticDtorSection =
 334     getELFSection(".dtors", false, SectionKind::getDataRel());
 335
 336   // Exception Handling Sections.
 337
 338   // FIXME: We're emitting LSDA info into a readonly section on ELF, even though
 339   // it contains relocatable pointers.  In PIC mode, this is probably a big
 340   // runtime hit for C++ apps.  Either the contents of the LSDA need to be
 341   // adjusted or this should be a data section.
 342   LSDASection =
 343     getELFSection(".gcc_except_table", false, SectionKind::getReadOnly());
 344   EHFrameSection =
 345     getELFSection(".eh_frame", false, SectionKind::getDataRel());
 346
 347   // Debug Info Sections.
 348   DwarfAbbrevSection =
 349     getELFSection(".debug_abbrev", false, SectionKind::getMetadata());
 350   DwarfInfoSection =
 351     getELFSection(".debug_info", false, SectionKind::getMetadata());
 352   DwarfLineSection =
 353     getELFSection(".debug_line", false, SectionKind::getMetadata());
 354   DwarfFrameSection =
 355     getELFSection(".debug_frame", false, SectionKind::getMetadata());
 356   DwarfPubNamesSection =
 357     getELFSection(".debug_pubnames", false, SectionKind::getMetadata());
 358   DwarfPubTypesSection =
 359     getELFSection(".debug_pubtypes", false, SectionKind::getMetadata());
 360   DwarfStrSection =
 361     getELFSection(".debug_str", false, SectionKind::getMetadata());
 362   DwarfLocSection =
 363     getELFSection(".debug_loc", false, SectionKind::getMetadata());
 364   DwarfARangesSection =
 365     getELFSection(".debug_aranges", false, SectionKind::getMetadata());
 366   DwarfRangesSection =
 367     getELFSection(".debug_ranges", false, SectionKind::getMetadata());
 368   DwarfMacroInfoSection =
 369     getELFSection(".debug_macinfo", false, SectionKind::getMetadata());
 370 }
 371
 372
 373 static SectionKind
 374 getELFKindForNamedSection(const char *Name, SectionKind K) {
 375   if (Name[0] != '.') return K;
 376
 377   // Some lame default implementation based on some magic section names.
 378   if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
 379       strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
 380       strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
 381       strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
 382     return SectionKind::getBSS();
 383
 384   if (strcmp(Name, ".tdata") == 0 ||
 385       strncmp(Name, ".tdata.", 7) == 0 ||
 386       strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
 387       strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
 388     return SectionKind::getThreadData();
 389
 390   if (strcmp(Name, ".tbss") == 0 ||
 391       strncmp(Name, ".tbss.", 6) == 0 ||
 392       strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
 393       strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
 394     return SectionKind::getThreadBSS();
 395
 396   return K;
 397 }
 398
 399 const MCSection *TargetLoweringObjectFileELF::
 400 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 401                          Mangler *Mang, const TargetMachine &TM) const {
 402   // Infer section flags from the section name if we can.
 403   Kind = getELFKindForNamedSection(GV->getSection().c_str(), Kind);
 404
 405   return getELFSection(GV->getSection().c_str(), false, Kind);
 406 }
 407
 408
 409
 410 void TargetLoweringObjectFileELF::
 411 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str,
 412                         const TargetAsmInfo &TAI) const {
 413   // Handle the weird solaris syntax if desired.
 414   if (TAI.usesSunStyleELFSectionSwitchSyntax() &&
 415       !Kind.isMergeableConst() && !Kind.isMergeableCString()) {
 416     // FIXME: Inefficient.
 417     std::string Res;
 418     if (!Kind.isMetadata())
 419       Res += ",#alloc";
 420     if (Kind.isText())
 421       Res += ",#execinstr";
 422     if (Kind.isWriteable())
 423       Res += ",#write";
 424     if (Kind.isThreadLocal())
 425       Res += ",#tls";
 426     Str.append(Res.begin(), Res.end());
 427     return;
 428   }
 429
 430   Str.push_back(',');
 431   Str.push_back('"');
 432
 433   if (!Kind.isMetadata())
 434     Str.push_back('a');
 435   if (Kind.isText())
 436     Str.push_back('x');
 437   if (Kind.isWriteable())
 438     Str.push_back('w');
 439   if (Kind.isMergeable1ByteCString() ||
 440       Kind.isMergeable2ByteCString() ||
 441       Kind.isMergeable4ByteCString() ||
 442       Kind.isMergeableConst4() ||
 443       Kind.isMergeableConst8() ||
 444       Kind.isMergeableConst16())
 445     Str.push_back('M');
 446   if (Kind.isMergeable1ByteCString() ||
 447       Kind.isMergeable2ByteCString() ||
 448       Kind.isMergeable4ByteCString())
 449     Str.push_back('S');
 450   if (Kind.isThreadLocal())
 451     Str.push_back('T');
 452
 453   Str.push_back('"');
 454   Str.push_back(',');
 455
 456   // If comment string is '@', e.g. as on ARM - use '%' instead
 457   if (AtIsCommentChar)
 458     Str.push_back('%');
 459   else
 460     Str.push_back('@');
 461
 462   const char *KindStr;
 463   if (Kind.isBSS() || Kind.isThreadBSS())
 464     KindStr = "nobits";
 465   else
 466     KindStr = "progbits";
 467
 468   Str.append(KindStr, KindStr+strlen(KindStr));
 469
 470   if (Kind.isMergeable1ByteCString()) {
 471     Str.push_back(',');
 472     Str.push_back('1');
 473   } else if (Kind.isMergeable2ByteCString()) {
 474     Str.push_back(',');
 475     Str.push_back('2');
 476   } else if (Kind.isMergeable4ByteCString()) {
 477     Str.push_back(',');
 478     Str.push_back('4');
 479   } else if (Kind.isMergeableConst4()) {
 480     Str.push_back(',');
 481     Str.push_back('4');
 482   } else if (Kind.isMergeableConst8()) {
 483     Str.push_back(',');
 484     Str.push_back('8');
 485   } else if (Kind.isMergeableConst16()) {
 486     Str.push_back(',');
 487     Str.push_back('1');
 488     Str.push_back('6');
 489   }
 490 }
 491
 492
 493 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
 494   if (Kind.isText())                 return ".gnu.linkonce.t.";
 495   if (Kind.isReadOnly())             return ".gnu.linkonce.r.";
 496
 497   if (Kind.isThreadData())           return ".gnu.linkonce.td.";
 498   if (Kind.isThreadBSS())            return ".gnu.linkonce.tb.";
 499
 500   if (Kind.isBSS())                  return ".gnu.linkonce.b.";
 501   if (Kind.isDataNoRel())            return ".gnu.linkonce.d.";
 502   if (Kind.isDataRelLocal())         return ".gnu.linkonce.d.rel.local.";
 503   if (Kind.isDataRel())              return ".gnu.linkonce.d.rel.";
 504   if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
 505
 506   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 507   return ".gnu.linkonce.d.rel.ro.";
 508 }
 509
 510 const MCSection *TargetLoweringObjectFileELF::
 511 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 512                        Mangler *Mang, const TargetMachine &TM) const {
 513
 514   // If this global is linkonce/weak and the target handles this by emitting it
 515   // into a 'uniqued' section name, create and return the section now.
 516   if (GV->isWeakForLinker()) {
 517     const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
 518     std::string Name = Mang->makeNameProper(GV->getNameStr());
 519     return getELFSection((Prefix+Name).c_str(), false, Kind);
 520   }
 521
 522   if (Kind.isText()) return TextSection;
 523
 524   if (Kind.isMergeable1ByteCString() ||
 525       Kind.isMergeable2ByteCString() ||
 526       Kind.isMergeable4ByteCString()) {
 527
 528     // We also need alignment here.
 529     // FIXME: this is getting the alignment of the character, not the
 530     // alignment of the global!
 531     unsigned Align =
 532       TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
 533
 534     const char *SizeSpec = ".rodata.str1.";
 535     if (Kind.isMergeable2ByteCString())
 536       SizeSpec = ".rodata.str2.";
 537     else if (Kind.isMergeable4ByteCString())
 538       SizeSpec = ".rodata.str4.";
 539     else
 540       assert(Kind.isMergeable1ByteCString() && "unknown string width");
 541
 542
 543     std::string Name = SizeSpec + utostr(Align);
 544     return getELFSection(Name.c_str(), false, Kind);
 545   }
 546
 547   if (Kind.isMergeableConst()) {
 548     if (Kind.isMergeableConst4())
 549       return MergeableConst4Section;
 550     if (Kind.isMergeableConst8())
 551       return MergeableConst8Section;
 552     if (Kind.isMergeableConst16())
 553       return MergeableConst16Section;
 554     return ReadOnlySection;  // .const
 555   }
 556
 557   if (Kind.isReadOnly())             return ReadOnlySection;
 558
 559   if (Kind.isThreadData())           return TLSDataSection;
 560   if (Kind.isThreadBSS())            return TLSBSSSection;
 561
 562   if (Kind.isBSS())                  return BSSSection;
 563
 564   if (Kind.isDataNoRel())            return DataSection;
 565   if (Kind.isDataRelLocal())         return DataRelLocalSection;
 566   if (Kind.isDataRel())              return DataRelSection;
 567   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
 568
 569   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 570   return DataRelROSection;
 571 }
 572
 573 /// getSectionForConstant - Given a mergeable constant with the
 574 /// specified size and relocation information, return a section that it
 575 /// should be placed in.
 576 const MCSection *TargetLoweringObjectFileELF::
 577 getSectionForConstant(SectionKind Kind) const {
 578   if (Kind.isMergeableConst4())
 579     return MergeableConst4Section;
 580   if (Kind.isMergeableConst8())
 581     return MergeableConst8Section;
 582   if (Kind.isMergeableConst16())
 583     return MergeableConst16Section;
 584   if (Kind.isReadOnly())
 585     return ReadOnlySection;
 586
 587   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
 588   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 589   return DataRelROSection;
 590 }
 591
 592 //===----------------------------------------------------------------------===//
 593 //                                 MachO
 594 //===----------------------------------------------------------------------===//
 595
 596
 597 const MCSection *TargetLoweringObjectFileMachO::
 598 getMachOSection(const char *Name, bool isDirective, SectionKind Kind) const {
 599   if (MCSection *S = getContext().GetSection(Name))
 600     return S;
 601   return MCSection::Create(Name, isDirective, Kind, getContext());
 602 }
 603
 604
 605
 606 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
 607                                                const TargetMachine &TM) {
 608   TargetLoweringObjectFile::Initialize(Ctx, TM);
 609   TextSection = getMachOSection("\t.text", true, SectionKind::getText());
 610   DataSection = getMachOSection("\t.data", true, SectionKind::getDataRel());
 611
 612   CStringSection = getMachOSection("\t.cstring", true,
 613                                    SectionKind::getMergeable1ByteCString());
 614   UStringSection = getMachOSection("__TEXT,__ustring", false,
 615                                    SectionKind::getMergeable2ByteCString());
 616   FourByteConstantSection = getMachOSection("\t.literal4\n", true,
 617                                             SectionKind::getMergeableConst4());
 618   EightByteConstantSection = getMachOSection("\t.literal8\n", true,
 619                                              SectionKind::getMergeableConst8());
 620
 621   // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
 622   // to using it in -static mode.
 623   if (TM.getRelocationModel() != Reloc::Static &&
 624       TM.getTargetData()->getPointerSize() == 32)
 625     SixteenByteConstantSection =
 626       getMachOSection("\t.literal16\n", true,
 627                       SectionKind::getMergeableConst16());
 628   else
 629     SixteenByteConstantSection = 0;
 630
 631   ReadOnlySection = getMachOSection("\t.const", true,
 632                                     SectionKind::getReadOnly());
 633
 634   TextCoalSection =
 635     getMachOSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
 636                     false, SectionKind::getText());
 637   ConstTextCoalSection = getMachOSection("\t__TEXT,__const_coal,coalesced",
 638                                          false, SectionKind::getText());
 639   ConstDataCoalSection = getMachOSection("\t__DATA,__const_coal,coalesced",
 640                                          false, SectionKind::getText());
 641   ConstDataSection = getMachOSection("\t.const_data", true,
 642                                      SectionKind::getReadOnlyWithRel());
 643   DataCoalSection = getMachOSection("\t__DATA,__datacoal_nt,coalesced",
 644                                     false, SectionKind::getDataRel());
 645
 646   if (TM.getRelocationModel() == Reloc::Static) {
 647     StaticCtorSection =
 648       getMachOSection(".constructor", true, SectionKind::getDataRel());
 649     StaticDtorSection =
 650       getMachOSection(".destructor", true, SectionKind::getDataRel());
 651   } else {
 652     StaticCtorSection =
 653       getMachOSection(".mod_init_func", true, SectionKind::getDataRel());
 654     StaticDtorSection =
 655       getMachOSection(".mod_term_func", true, SectionKind::getDataRel());
 656   }
 657
 658   // Exception Handling.
 659   LSDASection = getMachOSection("__DATA,__gcc_except_tab", false,
 660                                 SectionKind::getDataRel());
 661   EHFrameSection =
 662     getMachOSection("__TEXT,__eh_frame,coalesced,no_toc+strip_static_syms"
 663                     "+live_support", false, SectionKind::getReadOnly());
 664
 665   // Debug Information.
 666   // FIXME: Don't use 'directive' syntax: need flags for debug/regular??
 667   // FIXME: Need __DWARF segment.
 668   DwarfAbbrevSection =
 669     getMachOSection(".section __DWARF,__debug_abbrev,regular,debug", true,
 670                     SectionKind::getMetadata());
 671   DwarfInfoSection =
 672     getMachOSection(".section __DWARF,__debug_info,regular,debug", true,
 673                     SectionKind::getMetadata());
 674   DwarfLineSection =
 675     getMachOSection(".section __DWARF,__debug_line,regular,debug", true,
 676                     SectionKind::getMetadata());
 677   DwarfFrameSection =
 678     getMachOSection(".section __DWARF,__debug_frame,regular,debug", true,
 679                     SectionKind::getMetadata());
 680   DwarfPubNamesSection =
 681     getMachOSection(".section __DWARF,__debug_pubnames,regular,debug", true,
 682                     SectionKind::getMetadata());
 683   DwarfPubTypesSection =
 684     getMachOSection(".section __DWARF,__debug_pubtypes,regular,debug", true,
 685                     SectionKind::getMetadata());
 686   DwarfStrSection =
 687     getMachOSection(".section __DWARF,__debug_str,regular,debug", true,
 688                     SectionKind::getMetadata());
 689   DwarfLocSection =
 690     getMachOSection(".section __DWARF,__debug_loc,regular,debug", true,
 691                     SectionKind::getMetadata());
 692   DwarfARangesSection =
 693     getMachOSection(".section __DWARF,__debug_aranges,regular,debug", true,
 694                     SectionKind::getMetadata());
 695   DwarfRangesSection =
 696     getMachOSection(".section __DWARF,__debug_ranges,regular,debug", true,
 697                     SectionKind::getMetadata());
 698   DwarfMacroInfoSection =
 699     getMachOSection(".section __DWARF,__debug_macinfo,regular,debug", true,
 700                     SectionKind::getMetadata());
 701   DwarfDebugInlineSection =
 702     getMachOSection(".section __DWARF,__debug_inlined,regular,debug", true,
 703                     SectionKind::getMetadata());
 704 }
 705
 706 const MCSection *TargetLoweringObjectFileMachO::
 707 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 708                          Mangler *Mang, const TargetMachine &TM) const {
 709   return getMachOSection(GV->getSection().c_str(), false, Kind);
 710 }
 711
 712 const MCSection *TargetLoweringObjectFileMachO::
 713 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 714                        Mangler *Mang, const TargetMachine &TM) const {
 715   assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
 716
 717   if (Kind.isText())
 718     return GV->isWeakForLinker() ? TextCoalSection : TextSection;
 719
 720   // If this is weak/linkonce, put this in a coalescable section, either in text
 721   // or data depending on if it is writable.
 722   if (GV->isWeakForLinker()) {
 723     if (Kind.isReadOnly())
 724       return ConstTextCoalSection;
 725     return DataCoalSection;
 726   }
 727
 728   // FIXME: Alignment check should be handled by section classifier.
 729   if (Kind.isMergeable1ByteCString() ||
 730       Kind.isMergeable2ByteCString()) {
 731     if (TM.getTargetData()->getPreferredAlignment(
 732                                               cast<GlobalVariable>(GV)) < 32) {
 733       if (Kind.isMergeable1ByteCString())
 734         return CStringSection;
 735       assert(Kind.isMergeable2ByteCString());
 736       return UStringSection;
 737     }
 738   }
 739
 740   if (Kind.isMergeableConst()) {
 741     if (Kind.isMergeableConst4())
 742       return FourByteConstantSection;
 743     if (Kind.isMergeableConst8())
 744       return EightByteConstantSection;
 745     if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 746       return SixteenByteConstantSection;
 747   }
 748
 749   // Otherwise, if it is readonly, but not something we can specially optimize,
 750   // just drop it in .const.
 751   if (Kind.isReadOnly())
 752     return ReadOnlySection;
 753
 754   // If this is marked const, put it into a const section.  But if the dynamic
 755   // linker needs to write to it, put it in the data segment.
 756   if (Kind.isReadOnlyWithRel())
 757     return ConstDataSection;
 758
 759   // Otherwise, just drop the variable in the normal data section.
 760   return DataSection;
 761 }
 762
 763 const MCSection *
 764 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const {
 765   // If this constant requires a relocation, we have to put it in the data
 766   // segment, not in the text segment.
 767   if (Kind.isDataRel())
 768     return ConstDataSection;
 769
 770   if (Kind.isMergeableConst4())
 771     return FourByteConstantSection;
 772   if (Kind.isMergeableConst8())
 773     return EightByteConstantSection;
 774   if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 775     return SixteenByteConstantSection;
 776   return ReadOnlySection;  // .const
 777 }
 778
 779 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide
 780 /// not to emit the UsedDirective for some symbols in llvm.used.
 781 // FIXME: REMOVE this (rdar://7071300)
 782 bool TargetLoweringObjectFileMachO::
 783 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
 784   /// On Darwin, internally linked data beginning with "L" or "l" does not have
 785   /// the directive emitted (this occurs in ObjC metadata).
 786   if (!GV) return false;
 787
 788   // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix.
 789   if (GV->hasLocalLinkage() && !isa<Function>(GV)) {
 790     // FIXME: ObjC metadata is currently emitted as internal symbols that have
 791     // \1L and \0l prefixes on them.  Fix them to be Private/LinkerPrivate and
 792     // this horrible hack can go away.
 793     const std::string &Name = Mang->getMangledName(GV);
 794     if (Name[0] == 'L' || Name[0] == 'l')
 795       return false;
 796   }
 797
 798   return true;
 799 }
 800
 801
 802 //===----------------------------------------------------------------------===//
 803 //                                  COFF
 804 //===----------------------------------------------------------------------===//
 805
 806
 807 const MCSection *TargetLoweringObjectFileCOFF::
 808 getCOFFSection(const char *Name, bool isDirective, SectionKind Kind) const {
 809   if (MCSection *S = getContext().GetSection(Name))
 810     return S;
 811   return MCSection::Create(Name, isDirective, Kind, getContext());
 812 }
 813
 814 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
 815                                               const TargetMachine &TM) {
 816   TargetLoweringObjectFile::Initialize(Ctx, TM);
 817   TextSection = getCOFFSection("\t.text", true, SectionKind::getText());
 818   DataSection = getCOFFSection("\t.data", true, SectionKind::getDataRel());
 819   StaticCtorSection =
 820     getCOFFSection(".ctors", false, SectionKind::getDataRel());
 821   StaticDtorSection =
 822     getCOFFSection(".dtors", false, SectionKind::getDataRel());
 823
 824
 825   // Debug info.
 826   // FIXME: Don't use 'directive' mode here.
 827   DwarfAbbrevSection =
 828     getCOFFSection("\t.section\t.debug_abbrev,\"dr\"",
 829                    true, SectionKind::getMetadata());
 830   DwarfInfoSection =
 831     getCOFFSection("\t.section\t.debug_info,\"dr\"",
 832                    true, SectionKind::getMetadata());
 833   DwarfLineSection =
 834     getCOFFSection("\t.section\t.debug_line,\"dr\"",
 835                    true, SectionKind::getMetadata());
 836   DwarfFrameSection =
 837     getCOFFSection("\t.section\t.debug_frame,\"dr\"",
 838                    true, SectionKind::getMetadata());
 839   DwarfPubNamesSection =
 840     getCOFFSection("\t.section\t.debug_pubnames,\"dr\"",
 841                    true, SectionKind::getMetadata());
 842   DwarfPubTypesSection =
 843     getCOFFSection("\t.section\t.debug_pubtypes,\"dr\"",
 844                    true, SectionKind::getMetadata());
 845   DwarfStrSection =
 846     getCOFFSection("\t.section\t.debug_str,\"dr\"",
 847                    true, SectionKind::getMetadata());
 848   DwarfLocSection =
 849     getCOFFSection("\t.section\t.debug_loc,\"dr\"",
 850                    true, SectionKind::getMetadata());
 851   DwarfARangesSection =
 852     getCOFFSection("\t.section\t.debug_aranges,\"dr\"",
 853                    true, SectionKind::getMetadata());
 854   DwarfRangesSection =
 855     getCOFFSection("\t.section\t.debug_ranges,\"dr\"",
 856                    true, SectionKind::getMetadata());
 857   DwarfMacroInfoSection =
 858     getCOFFSection("\t.section\t.debug_macinfo,\"dr\"",
 859                    true, SectionKind::getMetadata());
 860 }
 861
 862 const MCSection *TargetLoweringObjectFileCOFF::
 863 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
 864                          Mangler *Mang, const TargetMachine &TM) const {
 865   return getCOFFSection(GV->getSection().c_str(), false, Kind);
 866 }
 867
 868
 869 void TargetLoweringObjectFileCOFF::
 870 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str,
 871                         const TargetAsmInfo &TAI) const {
 872   // FIXME: Inefficient.
 873   std::string Res = ",\"";
 874   if (Kind.isText())
 875     Res += 'x';
 876   if (Kind.isWriteable())
 877     Res += 'w';
 878   Res += "\"";
 879
 880   Str.append(Res.begin(), Res.end());
 881 }
 882
 883 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
 884   if (Kind.isText())
 885     return ".text$linkonce";
 886   if (Kind.isWriteable())
 887     return ".data$linkonce";
 888   return ".rdata$linkonce";
 889 }
 890
 891
 892 const MCSection *TargetLoweringObjectFileCOFF::
 893 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 894                        Mangler *Mang, const TargetMachine &TM) const {
 895   assert(!Kind.isThreadLocal() && "Doesn't support TLS");
 896
 897   // If this global is linkonce/weak and the target handles this by emitting it
 898   // into a 'uniqued' section name, create and return the section now.
 899   if (GV->isWeakForLinker()) {
 900     const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
 901     std::string Name = Mang->makeNameProper(GV->getNameStr());
 902     return getCOFFSection((Prefix+Name).c_str(), false, Kind);
 903   }
 904
 905   if (Kind.isText())
 906     return getTextSection();
 907
 908   return getDataSection();
 909 }
 910