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