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