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