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