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/Support/Mangler.h"
  20 #include "llvm/Target/TargetMachine.h"
  21 #include "llvm/Target/TargetData.h"
  22 #include "llvm/Target/TargetOptions.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 using namespace llvm;
  25
  26 //===----------------------------------------------------------------------===//
  27 //                              Generic Code
  28 //===----------------------------------------------------------------------===//
  29
  30 TargetLoweringObjectFile::TargetLoweringObjectFile() {
  31   TextSection = 0;
  32   DataSection = 0;
  33   BSSSection_ = 0;
  34   ReadOnlySection = 0;
  35   TLSDataSection = 0;
  36   TLSBSSSection = 0;
  37   CStringSection_ = 0;
  38 }
  39
  40 TargetLoweringObjectFile::~TargetLoweringObjectFile() {
  41 }
  42
  43 static bool isSuitableForBSS(const GlobalVariable *GV) {
  44   Constant *C = GV->getInitializer();
  45
  46   // Must have zero initializer.
  47   if (!C->isNullValue())
  48     return false;
  49
  50   // Leave constant zeros in readonly constant sections, so they can be shared.
  51   if (GV->isConstant())
  52     return false;
  53
  54   // If the global has an explicit section specified, don't put it in BSS.
  55   if (!GV->getSection().empty())
  56     return false;
  57
  58   // If -nozero-initialized-in-bss is specified, don't ever use BSS.
  59   if (NoZerosInBSS)
  60     return false;
  61
  62   // Otherwise, put it in BSS!
  63   return true;
  64 }
  65
  66 static bool isConstantString(const Constant *C) {
  67   // First check: is we have constant array of i8 terminated with zero
  68   const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
  69   // Check, if initializer is a null-terminated string
  70   if (CVA && CVA->isCString())
  71     return true;
  72
  73   // Another possibility: [1 x i8] zeroinitializer
  74   if (isa<ConstantAggregateZero>(C))
  75     if (const ArrayType *Ty = dyn_cast<ArrayType>(C->getType()))
  76       return (Ty->getElementType() == Type::Int8Ty &&
  77               Ty->getNumElements() == 1);
  78
  79   return false;
  80 }
  81
  82 static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
  83                                               const TargetMachine &TM) {
  84   Reloc::Model ReloModel = TM.getRelocationModel();
  85
  86   // Early exit - functions should be always in text sections.
  87   const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
  88   if (GVar == 0)
  89     return SectionKind::Text;
  90
  91
  92   // Handle thread-local data first.
  93   if (GVar->isThreadLocal()) {
  94     if (isSuitableForBSS(GVar))
  95       return SectionKind::ThreadBSS;
  96     return SectionKind::ThreadData;
  97   }
  98
  99   // Variable can be easily put to BSS section.
 100   if (isSuitableForBSS(GVar))
 101     return SectionKind::BSS;
 102
 103   Constant *C = GVar->getInitializer();
 104
 105   // If the global is marked constant, we can put it into a mergable section,
 106   // a mergable string section, or general .data if it contains relocations.
 107   if (GVar->isConstant()) {
 108     // If the initializer for the global contains something that requires a
 109     // relocation, then we may have to drop this into a wriable data section
 110     // even though it is marked const.
 111     switch (C->getRelocationInfo()) {
 112     default: llvm_unreachable("unknown relocation info kind");
 113     case Constant::NoRelocation:
 114       // If initializer is a null-terminated string, put it in a "cstring"
 115       // section if the target has it.
 116       if (isConstantString(C))
 117         return SectionKind::MergeableCString;
 118
 119       // Otherwise, just drop it into a mergable constant section.  If we have
 120       // a section for this size, use it, otherwise use the arbitrary sized
 121       // mergable section.
 122       switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
 123       case 4:  return SectionKind::MergeableConst4;
 124       case 8:  return SectionKind::MergeableConst8;
 125       case 16: return SectionKind::MergeableConst16;
 126       default: return SectionKind::MergeableConst;
 127       }
 128
 129     case Constant::LocalRelocation:
 130       // In static relocation model, the linker will resolve all addresses, so
 131       // the relocation entries will actually be constants by the time the app
 132       // starts up.  However, we can't put this into a mergable section, because
 133       // the linker doesn't take relocations into consideration when it tries to
 134       // merge entries in the section.
 135       if (ReloModel == Reloc::Static)
 136         return SectionKind::ReadOnly;
 137
 138       // Otherwise, the dynamic linker needs to fix it up, put it in the
 139       // writable data.rel.local section.
 140       return SectionKind::ReadOnlyWithRelLocal;
 141
 142     case Constant::GlobalRelocations:
 143       // In static relocation model, the linker will resolve all addresses, so
 144       // the relocation entries will actually be constants by the time the app
 145       // starts up.  However, we can't put this into a mergable section, because
 146       // the linker doesn't take relocations into consideration when it tries to
 147       // merge entries in the section.
 148       if (ReloModel == Reloc::Static)
 149         return SectionKind::ReadOnly;
 150
 151       // Otherwise, the dynamic linker needs to fix it up, put it in the
 152       // writable data.rel section.
 153       return SectionKind::ReadOnlyWithRel;
 154     }
 155   }
 156
 157   // Okay, this isn't a constant.  If the initializer for the global is going
 158   // to require a runtime relocation by the dynamic linker, put it into a more
 159   // specific section to improve startup time of the app.  This coalesces these
 160   // globals together onto fewer pages, improving the locality of the dynamic
 161   // linker.
 162   if (ReloModel == Reloc::Static)
 163     return SectionKind::DataNoRel;
 164
 165   switch (C->getRelocationInfo()) {
 166   default: llvm_unreachable("unknown relocation info kind");
 167   case Constant::NoRelocation:
 168     return SectionKind::DataNoRel;
 169   case Constant::LocalRelocation:
 170     return SectionKind::DataRelLocal;
 171   case Constant::GlobalRelocations:
 172     return SectionKind::DataRel;
 173   }
 174 }
 175
 176 /// SectionForGlobal - This method computes the appropriate section to emit
 177 /// the specified global variable or function definition.  This should not
 178 /// be passed external (or available externally) globals.
 179 const Section *TargetLoweringObjectFile::
 180 SectionForGlobal(const GlobalValue *GV, Mangler *Mang,
 181                  const TargetMachine &TM) const {
 182   assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
 183          "Can only be used for global definitions");
 184
 185   SectionKind::Kind GVKind = SectionKindForGlobal(GV, TM);
 186
 187   SectionKind Kind = SectionKind::get(GVKind, GV->isWeakForLinker(),
 188                                       GV->hasSection());
 189
 190
 191   // Select section name.
 192   if (GV->hasSection()) {
 193     // If the target has special section hacks for specifically named globals,
 194     // return them now.
 195     if (const Section *TS = getSpecialCasedSectionGlobals(GV, Mang, Kind))
 196       return TS;
 197
 198     // If the target has magic semantics for certain section names, make sure to
 199     // pick up the flags.  This allows the user to write things with attribute
 200     // section and still get the appropriate section flags printed.
 201     GVKind = getKindForNamedSection(GV->getSection().c_str(), GVKind);
 202
 203     return getOrCreateSection(GV->getSection().c_str(), false, GVKind);
 204   }
 205
 206
 207   // Use default section depending on the 'type' of global
 208   return SelectSectionForGlobal(GV, Kind, Mang, TM);
 209 }
 210
 211 // Lame default implementation. Calculate the section name for global.
 212 const Section*
 213 TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
 214                                                  SectionKind Kind,
 215                                                  Mangler *Mang,
 216                                                  const TargetMachine &TM) const{
 217   assert(!Kind.isThreadLocal() && "Doesn't support TLS");
 218
 219   if (Kind.isText())
 220     return getTextSection();
 221
 222   if (Kind.isBSS() && BSSSection_ != 0)
 223     return BSSSection_;
 224
 225   if (Kind.isReadOnly() && ReadOnlySection != 0)
 226     return ReadOnlySection;
 227
 228   return getDataSection();
 229 }
 230
 231 /// getSectionForMergableConstant - Given a mergable constant with the
 232 /// specified size and relocation information, return a section that it
 233 /// should be placed in.
 234 const Section *
 235 TargetLoweringObjectFile::
 236 getSectionForMergeableConstant(SectionKind Kind) const {
 237   if (Kind.isReadOnly() && ReadOnlySection != 0)
 238     return ReadOnlySection;
 239
 240   return DataSection;
 241 }
 242
 243
 244 const Section *TargetLoweringObjectFile::
 245 getOrCreateSection(const char *Name, bool isDirective,
 246                    SectionKind::Kind Kind) const {
 247   Section &S = Sections[Name];
 248
 249   // This is newly-created section, set it up properly.
 250   if (S.Name.empty()) {
 251     S.Kind = SectionKind::get(Kind, false /*weak*/, !isDirective);
 252     S.Name = Name;
 253   }
 254
 255   return &S;
 256 }
 257
 258
 259
 260 //===----------------------------------------------------------------------===//
 261 //                                  ELF
 262 //===----------------------------------------------------------------------===//
 263
 264 TargetLoweringObjectFileELF::TargetLoweringObjectFileELF(bool atIsCommentChar,
 265                                                          bool HasCrazyBSS)
 266   : AtIsCommentChar(atIsCommentChar) {
 267
 268   if (!HasCrazyBSS)
 269     BSSSection_ = getOrCreateSection("\t.bss", true, SectionKind::BSS);
 270   else
 271     // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
 272     // FIXME: Does .section .bss work everywhere??
 273     BSSSection_ = getOrCreateSection("\t.bss", false, SectionKind::BSS);
 274
 275
 276   TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
 277   DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
 278   ReadOnlySection =
 279     getOrCreateSection("\t.rodata", false, SectionKind::ReadOnly);
 280   TLSDataSection =
 281     getOrCreateSection("\t.tdata", false, SectionKind::ThreadData);
 282   CStringSection_ = getOrCreateSection("\t.rodata.str", true,
 283                                        SectionKind::MergeableCString);
 284
 285   TLSBSSSection = getOrCreateSection("\t.tbss", false, SectionKind::ThreadBSS);
 286
 287   DataRelSection = getOrCreateSection("\t.data.rel", false,
 288                                       SectionKind::DataRel);
 289   DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
 290                                            SectionKind::DataRelLocal);
 291   DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
 292                                         SectionKind::ReadOnlyWithRel);
 293   DataRelROLocalSection =
 294     getOrCreateSection("\t.data.rel.ro.local", false,
 295                        SectionKind::ReadOnlyWithRelLocal);
 296
 297   MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
 298                                               SectionKind::MergeableConst4);
 299   MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
 300                                               SectionKind::MergeableConst8);
 301   MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
 302                                                SectionKind::MergeableConst16);
 303 }
 304
 305
 306 SectionKind::Kind TargetLoweringObjectFileELF::
 307 getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
 308   if (Name[0] != '.') return K;
 309
 310   // Some lame default implementation based on some magic section names.
 311   if (strncmp(Name, ".gnu.linkonce.b.", 16) == 0 ||
 312       strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
 313       strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
 314       strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
 315     return SectionKind::BSS;
 316
 317   if (strcmp(Name, ".tdata") == 0 ||
 318       strncmp(Name, ".tdata.", 7) == 0 ||
 319       strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
 320       strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
 321     return SectionKind::ThreadData;
 322
 323   if (strcmp(Name, ".tbss") == 0 ||
 324       strncmp(Name, ".tbss.", 6) == 0 ||
 325       strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
 326       strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
 327     return SectionKind::ThreadBSS;
 328
 329   return K;
 330 }
 331
 332 void TargetLoweringObjectFileELF::
 333 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
 334   Str.push_back(',');
 335   Str.push_back('"');
 336
 337   if (!Kind.isMetadata())
 338     Str.push_back('a');
 339   if (Kind.isText())
 340     Str.push_back('x');
 341   if (Kind.isWriteable())
 342     Str.push_back('w');
 343   if (Kind.isMergeableCString() ||
 344       Kind.isMergeableConst4() ||
 345       Kind.isMergeableConst8() ||
 346       Kind.isMergeableConst16())
 347     Str.push_back('M');
 348   if (Kind.isMergeableCString())
 349     Str.push_back('S');
 350   if (Kind.isThreadLocal())
 351     Str.push_back('T');
 352
 353   Str.push_back('"');
 354   Str.push_back(',');
 355
 356   // If comment string is '@', e.g. as on ARM - use '%' instead
 357   if (AtIsCommentChar)
 358     Str.push_back('%');
 359   else
 360     Str.push_back('@');
 361
 362   const char *KindStr;
 363   if (Kind.isBSS() || Kind.isThreadBSS())
 364     KindStr = "nobits";
 365   else
 366     KindStr = "progbits";
 367
 368   Str.append(KindStr, KindStr+strlen(KindStr));
 369
 370   if (Kind.isMergeableCString()) {
 371     // TODO: Eventually handle multiple byte character strings.  For now, all
 372     // mergable C strings are single byte.
 373     Str.push_back(',');
 374     Str.push_back('1');
 375   } else if (Kind.isMergeableConst4()) {
 376     Str.push_back(',');
 377     Str.push_back('4');
 378   } else if (Kind.isMergeableConst8()) {
 379     Str.push_back(',');
 380     Str.push_back('8');
 381   } else if (Kind.isMergeableConst16()) {
 382     Str.push_back(',');
 383     Str.push_back('1');
 384     Str.push_back('6');
 385   }
 386 }
 387
 388
 389 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
 390   if (Kind.isText())                 return ".gnu.linkonce.t.";
 391   if (Kind.isReadOnly())             return ".gnu.linkonce.r.";
 392
 393   if (Kind.isThreadData())           return ".gnu.linkonce.td.";
 394   if (Kind.isThreadBSS())            return ".gnu.linkonce.tb.";
 395
 396   if (Kind.isBSS())                  return ".gnu.linkonce.b.";
 397   if (Kind.isDataNoRel())            return ".gnu.linkonce.d.";
 398   if (Kind.isDataRelLocal())         return ".gnu.linkonce.d.rel.local.";
 399   if (Kind.isDataRel())              return ".gnu.linkonce.d.rel.";
 400   if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local.";
 401
 402   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 403   return ".gnu.linkonce.d.rel.ro.";
 404 }
 405
 406 const Section *TargetLoweringObjectFileELF::
 407 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 408                        Mangler *Mang, const TargetMachine &TM) const {
 409
 410   // If this global is linkonce/weak and the target handles this by emitting it
 411   // into a 'uniqued' section name, create and return the section now.
 412   if (Kind.isWeak()) {
 413     const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
 414     std::string Name = Mang->makeNameProper(GV->getNameStr());
 415     return getOrCreateSection((Prefix+Name).c_str(), false, Kind.getKind());
 416   }
 417
 418   if (Kind.isText()) return TextSection;
 419
 420   if (Kind.isMergeableCString()) {
 421    assert(CStringSection_ && "Should have string section prefix");
 422
 423     // We also need alignment here.
 424     // FIXME: this is getting the alignment of the character, not the
 425     // alignment of the global!
 426     unsigned Align =
 427       TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV));
 428
 429     std::string Name = CStringSection_->getName() + "1." + utostr(Align);
 430     return getOrCreateSection(Name.c_str(), false,
 431                               SectionKind::MergeableCString);
 432   }
 433
 434   if (Kind.isMergeableConst()) {
 435     if (Kind.isMergeableConst4())
 436       return MergeableConst4Section;
 437     if (Kind.isMergeableConst8())
 438       return MergeableConst8Section;
 439     if (Kind.isMergeableConst16())
 440       return MergeableConst16Section;
 441     return ReadOnlySection;  // .const
 442   }
 443
 444   if (Kind.isReadOnly())             return ReadOnlySection;
 445
 446   if (Kind.isThreadData())           return TLSDataSection;
 447   if (Kind.isThreadBSS())            return TLSBSSSection;
 448
 449   if (Kind.isBSS())                  return BSSSection_;
 450
 451   if (Kind.isDataNoRel())            return DataSection;
 452   if (Kind.isDataRelLocal())         return DataRelLocalSection;
 453   if (Kind.isDataRel())              return DataRelSection;
 454   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
 455
 456   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 457   return DataRelROSection;
 458 }
 459
 460 /// getSectionForMergeableConstant - Given a mergeable constant with the
 461 /// specified size and relocation information, return a section that it
 462 /// should be placed in.
 463 const Section *TargetLoweringObjectFileELF::
 464 getSectionForMergeableConstant(SectionKind Kind) const {
 465   if (Kind.isMergeableConst4())
 466     return MergeableConst4Section;
 467   if (Kind.isMergeableConst8())
 468     return MergeableConst8Section;
 469   if (Kind.isMergeableConst16())
 470     return MergeableConst16Section;
 471   if (Kind.isReadOnly())
 472     return ReadOnlySection;
 473
 474   if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
 475   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
 476   return DataRelROSection;
 477 }
 478
 479 //===----------------------------------------------------------------------===//
 480 //                                 MachO
 481 //===----------------------------------------------------------------------===//
 482
 483 TargetLoweringObjectFileMachO::
 484 TargetLoweringObjectFileMachO(const TargetMachine &TM) {
 485   TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
 486   DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
 487
 488   CStringSection_ = getOrCreateSection("\t.cstring", true,
 489                                        SectionKind::MergeableCString);
 490   FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
 491                                                SectionKind::MergeableConst4);
 492   EightByteConstantSection = getOrCreateSection("\t.literal8\n", true,
 493                                                 SectionKind::MergeableConst8);
 494
 495   // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
 496   // to using it in -static mode.
 497   if (TM.getRelocationModel() != Reloc::Static &&
 498       TM.getTargetData()->getPointerSize() == 32)
 499     SixteenByteConstantSection =
 500       getOrCreateSection("\t.literal16\n", true, SectionKind::MergeableConst16);
 501   else
 502     SixteenByteConstantSection = 0;
 503
 504   ReadOnlySection = getOrCreateSection("\t.const", true, SectionKind::ReadOnly);
 505
 506   TextCoalSection =
 507   getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
 508                      false, SectionKind::Text);
 509   ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
 510                                             false, SectionKind::Text);
 511   ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
 512                                             false, SectionKind::Text);
 513   ConstDataSection = getOrCreateSection("\t.const_data", true,
 514                                         SectionKind::ReadOnlyWithRel);
 515   DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
 516                                        false, SectionKind::DataRel);
 517 }
 518
 519 const Section *TargetLoweringObjectFileMachO::
 520 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 521                        Mangler *Mang, const TargetMachine &TM) const {
 522   assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
 523
 524   if (Kind.isText())
 525     return Kind.isWeak() ? TextCoalSection : TextSection;
 526
 527   // If this is weak/linkonce, put this in a coalescable section, either in text
 528   // or data depending on if it is writable.
 529   if (Kind.isWeak()) {
 530     if (Kind.isReadOnly())
 531       return ConstTextCoalSection;
 532     return DataCoalSection;
 533   }
 534
 535   // FIXME: Alignment check should be handled by section classifier.
 536   if (Kind.isMergeableCString()) {
 537     Constant *C = cast<GlobalVariable>(GV)->getInitializer();
 538     const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
 539     const TargetData &TD = *TM.getTargetData();
 540     unsigned Size = TD.getTypeAllocSize(Ty);
 541     if (Size) {
 542       unsigned Align = TD.getPreferredAlignment(cast<GlobalVariable>(GV));
 543       if (Align <= 32)
 544         return CStringSection_;
 545     }
 546
 547     return ReadOnlySection;
 548   }
 549
 550   if (Kind.isMergeableConst()) {
 551     if (Kind.isMergeableConst4())
 552       return FourByteConstantSection;
 553     if (Kind.isMergeableConst8())
 554       return EightByteConstantSection;
 555     if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 556       return SixteenByteConstantSection;
 557     return ReadOnlySection;  // .const
 558   }
 559
 560   // FIXME: ROData -> const in -static mode that is relocatable but they happen
 561   // by the static linker.  Why not mergeable?
 562   if (Kind.isReadOnly())
 563     return ReadOnlySection;
 564
 565   // If this is marked const, put it into a const section.  But if the dynamic
 566   // linker needs to write to it, put it in the data segment.
 567   if (Kind.isReadOnlyWithRel())
 568     return ConstDataSection;
 569
 570   // Otherwise, just drop the variable in the normal data section.
 571   return DataSection;
 572 }
 573
 574 const Section *
 575 TargetLoweringObjectFileMachO::
 576 getSectionForMergeableConstant(SectionKind Kind) const {
 577   // If this constant requires a relocation, we have to put it in the data
 578   // segment, not in the text segment.
 579   if (Kind.isDataRel())
 580     return ConstDataSection;
 581
 582   if (Kind.isMergeableConst4())
 583     return FourByteConstantSection;
 584   if (Kind.isMergeableConst8())
 585     return EightByteConstantSection;
 586   if (Kind.isMergeableConst16() && SixteenByteConstantSection)
 587     return SixteenByteConstantSection;
 588   return ReadOnlySection;  // .const
 589 }
 590
 591 //===----------------------------------------------------------------------===//
 592 //                                  COFF
 593 //===----------------------------------------------------------------------===//
 594
 595 TargetLoweringObjectFileCOFF::TargetLoweringObjectFileCOFF() {
 596   TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
 597   DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
 598 }
 599
 600 void TargetLoweringObjectFileCOFF::
 601 getSectionFlagsAsString(SectionKind Kind, SmallVectorImpl<char> &Str) const {
 602   // FIXME: Inefficient.
 603   std::string Res = ",\"";
 604   if (Kind.isText())
 605     Res += 'x';
 606   if (Kind.isWriteable())
 607     Res += 'w';
 608   Res += "\"";
 609
 610   Str.append(Res.begin(), Res.end());
 611 }
 612
 613 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
 614   if (Kind.isText())
 615     return ".text$linkonce";
 616   if (Kind.isWriteable())
 617     return ".data$linkonce";
 618   return ".rdata$linkonce";
 619 }
 620
 621
 622 const Section *TargetLoweringObjectFileCOFF::
 623 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 624                        Mangler *Mang, const TargetMachine &TM) const {
 625   assert(!Kind.isThreadLocal() && "Doesn't support TLS");
 626
 627   // If this global is linkonce/weak and the target handles this by emitting it
 628   // into a 'uniqued' section name, create and return the section now.
 629   if (Kind.isWeak()) {
 630     const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
 631     // FIXME: Use mangler interface (PR4584).
 632     std::string Name = Prefix+GV->getNameStr();
 633     return getOrCreateSection(Name.c_str(), false, Kind.getKind());
 634   }
 635
 636   if (Kind.isText())
 637     return getTextSection();
 638
 639   if (Kind.isBSS())
 640     if (const Section *S = BSSSection_)
 641       return S;
 642
 643   if (Kind.isReadOnly() && ReadOnlySection != 0)
 644     return ReadOnlySection;
 645
 646   return getDataSection();
 647 }
 648