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