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