1 //===-- llvm/CodeGen/TargetLoweringObjectFileImpl.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/CodeGen/TargetLoweringObjectFileImpl.h" 16 #include "llvm/Constants.h" 17 #include "llvm/DerivedTypes.h" 18 #include "llvm/Function.h" 19 #include "llvm/GlobalVariable.h" 20 #include "llvm/CodeGen/MachineModuleInfoImpls.h" 21 #include "llvm/MC/MCContext.h" 22 #include "llvm/MC/MCExpr.h" 23 #include "llvm/MC/MCSectionMachO.h" 24 #include "llvm/MC/MCSectionELF.h" 25 #include "llvm/MC/MCSectionCOFF.h" 26 #include "llvm/MC/MCSymbol.h" 27 #include "llvm/Target/Mangler.h" 28 #include "llvm/Target/TargetData.h" 29 #include "llvm/Target/TargetMachine.h" 30 #include "llvm/Target/TargetOptions.h" 31 #include "llvm/Support/Dwarf.h" 32 #include "llvm/Support/ELF.h" 33 #include "llvm/Support/ErrorHandling.h" 34 #include "llvm/Support/raw_ostream.h" 35 #include "llvm/ADT/SmallString.h" 36 #include "llvm/ADT/StringExtras.h" 37 #include "llvm/ADT/Triple.h" 38 using namespace llvm; 39 using namespace dwarf; 40 41 //===----------------------------------------------------------------------===// 42 // ELF 43 //===----------------------------------------------------------------------===// 44 45 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx, 46 const TargetMachine &TM) { 47 TargetLoweringObjectFile::Initialize(Ctx, TM); 48 49 BSSSection = 50 getContext().getELFSection(".bss", ELF::SHT_NOBITS, 51 ELF::SHF_WRITE |ELF::SHF_ALLOC, 52 SectionKind::getBSS()); 53 54 TextSection = 55 getContext().getELFSection(".text", ELF::SHT_PROGBITS, 56 ELF::SHF_EXECINSTR | 57 ELF::SHF_ALLOC, 58 SectionKind::getText()); 59 60 DataSection = 61 getContext().getELFSection(".data", ELF::SHT_PROGBITS, 62 ELF::SHF_WRITE |ELF::SHF_ALLOC, 63 SectionKind::getDataRel()); 64 65 ReadOnlySection = 66 getContext().getELFSection(".rodata", ELF::SHT_PROGBITS, 67 ELF::SHF_ALLOC, 68 SectionKind::getReadOnly()); 69 70 TLSDataSection = 71 getContext().getELFSection(".tdata", ELF::SHT_PROGBITS, 72 ELF::SHF_ALLOC | ELF::SHF_TLS | 73 ELF::SHF_WRITE, 74 SectionKind::getThreadData()); 75 76 TLSBSSSection = 77 getContext().getELFSection(".tbss", ELF::SHT_NOBITS, 78 ELF::SHF_ALLOC | ELF::SHF_TLS | 79 ELF::SHF_WRITE, 80 SectionKind::getThreadBSS()); 81 82 DataRelSection = 83 getContext().getELFSection(".data.rel", ELF::SHT_PROGBITS, 84 ELF::SHF_ALLOC |ELF::SHF_WRITE, 85 SectionKind::getDataRel()); 86 87 DataRelLocalSection = 88 getContext().getELFSection(".data.rel.local", ELF::SHT_PROGBITS, 89 ELF::SHF_ALLOC |ELF::SHF_WRITE, 90 SectionKind::getDataRelLocal()); 91 92 DataRelROSection = 93 getContext().getELFSection(".data.rel.ro", ELF::SHT_PROGBITS, 94 ELF::SHF_ALLOC |ELF::SHF_WRITE, 95 SectionKind::getReadOnlyWithRel()); 96 97 DataRelROLocalSection = 98 getContext().getELFSection(".data.rel.ro.local", ELF::SHT_PROGBITS, 99 ELF::SHF_ALLOC |ELF::SHF_WRITE, 100 SectionKind::getReadOnlyWithRelLocal()); 101 102 MergeableConst4Section = 103 getContext().getELFSection(".rodata.cst4", ELF::SHT_PROGBITS, 104 ELF::SHF_ALLOC |ELF::SHF_MERGE, 105 SectionKind::getMergeableConst4()); 106 107 MergeableConst8Section = 108 getContext().getELFSection(".rodata.cst8", ELF::SHT_PROGBITS, 109 ELF::SHF_ALLOC |ELF::SHF_MERGE, 110 SectionKind::getMergeableConst8()); 111 112 MergeableConst16Section = 113 getContext().getELFSection(".rodata.cst16", ELF::SHT_PROGBITS, 114 ELF::SHF_ALLOC |ELF::SHF_MERGE, 115 SectionKind::getMergeableConst16()); 116 117 StaticCtorSection = 118 getContext().getELFSection(".ctors", ELF::SHT_PROGBITS, 119 ELF::SHF_ALLOC |ELF::SHF_WRITE, 120 SectionKind::getDataRel()); 121 122 StaticDtorSection = 123 getContext().getELFSection(".dtors", ELF::SHT_PROGBITS, 124 ELF::SHF_ALLOC |ELF::SHF_WRITE, 125 SectionKind::getDataRel()); 126 127 // Exception Handling Sections. 128 129 // FIXME: We're emitting LSDA info into a readonly section on ELF, even though 130 // it contains relocatable pointers. In PIC mode, this is probably a big 131 // runtime hit for C++ apps. Either the contents of the LSDA need to be 132 // adjusted or this should be a data section. 133 LSDASection = 134 getContext().getELFSection(".gcc_except_table", ELF::SHT_PROGBITS, 135 ELF::SHF_ALLOC, 136 SectionKind::getReadOnly()); 137 // Debug Info Sections. 138 DwarfAbbrevSection = 139 getContext().getELFSection(".debug_abbrev", ELF::SHT_PROGBITS, 0, 140 SectionKind::getMetadata()); 141 DwarfInfoSection = 142 getContext().getELFSection(".debug_info", ELF::SHT_PROGBITS, 0, 143 SectionKind::getMetadata()); 144 DwarfLineSection = 145 getContext().getELFSection(".debug_line", ELF::SHT_PROGBITS, 0, 146 SectionKind::getMetadata()); 147 DwarfFrameSection = 148 getContext().getELFSection(".debug_frame", ELF::SHT_PROGBITS, 0, 149 SectionKind::getMetadata()); 150 DwarfPubNamesSection = 151 getContext().getELFSection(".debug_pubnames", ELF::SHT_PROGBITS, 0, 152 SectionKind::getMetadata()); 153 DwarfPubTypesSection = 154 getContext().getELFSection(".debug_pubtypes", ELF::SHT_PROGBITS, 0, 155 SectionKind::getMetadata()); 156 DwarfStrSection = 157 getContext().getELFSection(".debug_str", ELF::SHT_PROGBITS, 0, 158 SectionKind::getMetadata()); 159 DwarfLocSection = 160 getContext().getELFSection(".debug_loc", ELF::SHT_PROGBITS, 0, 161 SectionKind::getMetadata()); 162 DwarfARangesSection = 163 getContext().getELFSection(".debug_aranges", ELF::SHT_PROGBITS, 0, 164 SectionKind::getMetadata()); 165 DwarfRangesSection = 166 getContext().getELFSection(".debug_ranges", ELF::SHT_PROGBITS, 0, 167 SectionKind::getMetadata()); 168 DwarfMacroInfoSection = 169 getContext().getELFSection(".debug_macinfo", ELF::SHT_PROGBITS, 0, 170 SectionKind::getMetadata()); 171 } 172 173 const MCSection *TargetLoweringObjectFileELF::getEHFrameSection() const { 174 return getContext().getELFSection(".eh_frame", ELF::SHT_PROGBITS, 175 ELF::SHF_ALLOC, 176 SectionKind::getDataRel()); 177 } 178 179 static SectionKind 180 getELFKindForNamedSection(StringRef Name, SectionKind K) { 181 if (Name.empty() || Name[0] != '.') return K; 182 183 // Some lame default implementation based on some magic section names. 184 if (Name == ".bss" || 185 Name.startswith(".bss.") || 186 Name.startswith(".gnu.linkonce.b.") || 187 Name.startswith(".llvm.linkonce.b.") || 188 Name == ".sbss" || 189 Name.startswith(".sbss.") || 190 Name.startswith(".gnu.linkonce.sb.") || 191 Name.startswith(".llvm.linkonce.sb.")) 192 return SectionKind::getBSS(); 193 194 if (Name == ".tdata" || 195 Name.startswith(".tdata.") || 196 Name.startswith(".gnu.linkonce.td.") || 197 Name.startswith(".llvm.linkonce.td.")) 198 return SectionKind::getThreadData(); 199 200 if (Name == ".tbss" || 201 Name.startswith(".tbss.") || 202 Name.startswith(".gnu.linkonce.tb.") || 203 Name.startswith(".llvm.linkonce.tb.")) 204 return SectionKind::getThreadBSS(); 205 206 return K; 207 } 208 209 210 static unsigned getELFSectionType(StringRef Name, SectionKind K) { 211 212 if (Name == ".init_array") 213 return ELF::SHT_INIT_ARRAY; 214 215 if (Name == ".fini_array") 216 return ELF::SHT_FINI_ARRAY; 217 218 if (Name == ".preinit_array") 219 return ELF::SHT_PREINIT_ARRAY; 220 221 if (K.isBSS() || K.isThreadBSS()) 222 return ELF::SHT_NOBITS; 223 224 return ELF::SHT_PROGBITS; 225 } 226 227 228 static unsigned 229 getELFSectionFlags(SectionKind K) { 230 unsigned Flags = 0; 231 232 if (!K.isMetadata()) 233 Flags |= ELF::SHF_ALLOC; 234 235 if (K.isText()) 236 Flags |= ELF::SHF_EXECINSTR; 237 238 if (K.isWriteable()) 239 Flags |= ELF::SHF_WRITE; 240 241 if (K.isThreadLocal()) 242 Flags |= ELF::SHF_TLS; 243 244 // K.isMergeableConst() is left out to honour PR4650 245 if (K.isMergeableCString() || K.isMergeableConst4() || 246 K.isMergeableConst8() || K.isMergeableConst16()) 247 Flags |= ELF::SHF_MERGE; 248 249 if (K.isMergeableCString()) 250 Flags |= ELF::SHF_STRINGS; 251 252 return Flags; 253 } 254 255 256 const MCSection *TargetLoweringObjectFileELF:: 257 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 258 Mangler *Mang, const TargetMachine &TM) const { 259 StringRef SectionName = GV->getSection(); 260 261 // Infer section flags from the section name if we can. 262 Kind = getELFKindForNamedSection(SectionName, Kind); 263 264 return getContext().getELFSection(SectionName, 265 getELFSectionType(SectionName, Kind), 266 getELFSectionFlags(Kind), Kind); 267 } 268 269 static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) { 270 if (Kind.isText()) return ".gnu.linkonce.t."; 271 if (Kind.isReadOnly()) return ".gnu.linkonce.r."; 272 273 if (Kind.isThreadData()) return ".gnu.linkonce.td."; 274 if (Kind.isThreadBSS()) return ".gnu.linkonce.tb."; 275 276 if (Kind.isDataNoRel()) return ".gnu.linkonce.d."; 277 if (Kind.isDataRelLocal()) return ".gnu.linkonce.d.rel.local."; 278 if (Kind.isDataRel()) return ".gnu.linkonce.d.rel."; 279 if (Kind.isReadOnlyWithRelLocal()) return ".gnu.linkonce.d.rel.ro.local."; 280 281 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 282 return ".gnu.linkonce.d.rel.ro."; 283 } 284 285 /// getSectionPrefixForGlobal - Return the section prefix name used by options 286 /// FunctionsSections and DataSections. 287 static const char *getSectionPrefixForGlobal(SectionKind Kind) { 288 if (Kind.isText()) return ".text."; 289 if (Kind.isReadOnly()) return ".rodata."; 290 291 if (Kind.isThreadData()) return ".tdata."; 292 if (Kind.isThreadBSS()) return ".tbss."; 293 294 if (Kind.isDataNoRel()) return ".data."; 295 if (Kind.isDataRelLocal()) return ".data.rel.local."; 296 if (Kind.isDataRel()) return ".data.rel."; 297 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local."; 298 299 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 300 return ".data.rel.ro."; 301 } 302 303 304 const MCSection *TargetLoweringObjectFileELF:: 305 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 306 Mangler *Mang, const TargetMachine &TM) const { 307 // If we have -ffunction-section or -fdata-section then we should emit the 308 // global value to a uniqued section specifically for it. 309 bool EmitUniquedSection; 310 if (Kind.isText()) 311 EmitUniquedSection = TM.getFunctionSections(); 312 else 313 EmitUniquedSection = TM.getDataSections(); 314 315 // If this global is linkonce/weak and the target handles this by emitting it 316 // into a 'uniqued' section name, create and return the section now. 317 if ((GV->isWeakForLinker() || EmitUniquedSection) && 318 !Kind.isCommon() && !Kind.isBSS()) { 319 const char *Prefix; 320 if (GV->isWeakForLinker()) 321 Prefix = getSectionPrefixForUniqueGlobal(Kind); 322 else { 323 assert(EmitUniquedSection); 324 Prefix = getSectionPrefixForGlobal(Kind); 325 } 326 327 SmallString<128> Name(Prefix, Prefix+strlen(Prefix)); 328 MCSymbol *Sym = Mang->getSymbol(GV); 329 Name.append(Sym->getName().begin(), Sym->getName().end()); 330 return getContext().getELFSection(Name.str(), 331 getELFSectionType(Name.str(), Kind), 332 getELFSectionFlags(Kind), Kind); 333 } 334 335 if (Kind.isText()) return TextSection; 336 337 if (Kind.isMergeable1ByteCString() || 338 Kind.isMergeable2ByteCString() || 339 Kind.isMergeable4ByteCString()) { 340 341 // We also need alignment here. 342 // FIXME: this is getting the alignment of the character, not the 343 // alignment of the global! 344 unsigned Align = 345 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)); 346 347 const char *SizeSpec = ".rodata.str1."; 348 if (Kind.isMergeable2ByteCString()) 349 SizeSpec = ".rodata.str2."; 350 else if (Kind.isMergeable4ByteCString()) 351 SizeSpec = ".rodata.str4."; 352 else 353 assert(Kind.isMergeable1ByteCString() && "unknown string width"); 354 355 356 std::string Name = SizeSpec + utostr(Align); 357 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, 358 ELF::SHF_ALLOC | 359 ELF::SHF_MERGE | 360 ELF::SHF_STRINGS, 361 Kind); 362 } 363 364 if (Kind.isMergeableConst()) { 365 if (Kind.isMergeableConst4() && MergeableConst4Section) 366 return MergeableConst4Section; 367 if (Kind.isMergeableConst8() && MergeableConst8Section) 368 return MergeableConst8Section; 369 if (Kind.isMergeableConst16() && MergeableConst16Section) 370 return MergeableConst16Section; 371 return ReadOnlySection; // .const 372 } 373 374 if (Kind.isReadOnly()) return ReadOnlySection; 375 376 if (Kind.isThreadData()) return TLSDataSection; 377 if (Kind.isThreadBSS()) return TLSBSSSection; 378 379 // Note: we claim that common symbols are put in BSSSection, but they are 380 // really emitted with the magic .comm directive, which creates a symbol table 381 // entry but not a section. 382 if (Kind.isBSS() || Kind.isCommon()) return BSSSection; 383 384 if (Kind.isDataNoRel()) return DataSection; 385 if (Kind.isDataRelLocal()) return DataRelLocalSection; 386 if (Kind.isDataRel()) return DataRelSection; 387 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection; 388 389 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 390 return DataRelROSection; 391 } 392 393 /// getSectionForConstant - Given a mergeable constant with the 394 /// specified size and relocation information, return a section that it 395 /// should be placed in. 396 const MCSection *TargetLoweringObjectFileELF:: 397 getSectionForConstant(SectionKind Kind) const { 398 if (Kind.isMergeableConst4() && MergeableConst4Section) 399 return MergeableConst4Section; 400 if (Kind.isMergeableConst8() && MergeableConst8Section) 401 return MergeableConst8Section; 402 if (Kind.isMergeableConst16() && MergeableConst16Section) 403 return MergeableConst16Section; 404 if (Kind.isReadOnly()) 405 return ReadOnlySection; 406 407 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection; 408 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 409 return DataRelROSection; 410 } 411 412 const MCExpr *TargetLoweringObjectFileELF:: 413 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang, 414 MachineModuleInfo *MMI, 415 unsigned Encoding, MCStreamer &Streamer) const { 416 417 if (Encoding & dwarf::DW_EH_PE_indirect) { 418 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>(); 419 420 SmallString<128> Name; 421 Mang->getNameWithPrefix(Name, GV, true); 422 Name += ".DW.stub"; 423 424 // Add information about the stub reference to ELFMMI so that the stub 425 // gets emitted by the asmprinter. 426 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str()); 427 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym); 428 if (StubSym.getPointer() == 0) { 429 MCSymbol *Sym = Mang->getSymbol(GV); 430 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 431 } 432 433 return TargetLoweringObjectFile:: 434 getExprForDwarfReference(SSym, Mang, MMI, 435 Encoding & ~dwarf::DW_EH_PE_indirect, Streamer); 436 } 437 438 return TargetLoweringObjectFile:: 439 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer); 440 } 441 442 //===----------------------------------------------------------------------===// 443 // MachO 444 //===----------------------------------------------------------------------===// 445 446 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx, 447 const TargetMachine &TM) { 448 // _foo.eh symbols are currently always exported so that the linker knows 449 // about them. This is not necessary on 10.6 and later, but it 450 // doesn't hurt anything. 451 // FIXME: I need to get this from Triple. 452 IsFunctionEHSymbolGlobal = true; 453 IsFunctionEHFrameSymbolPrivate = false; 454 SupportsWeakOmittedEHFrame = false; 455 456 Triple T(((LLVMTargetMachine&)TM).getTargetTriple()); 457 if (T.getOS() == Triple::Darwin) { 458 switch (T.getDarwinMajorNumber()) { 459 case 7: // 10.3 Panther. 460 case 8: // 10.4 Tiger. 461 CommDirectiveSupportsAlignment = false; 462 break; 463 case 9: // 10.5 Leopard. 464 case 10: // 10.6 SnowLeopard. 465 break; 466 } 467 } 468 469 TargetLoweringObjectFile::Initialize(Ctx, TM); 470 471 TextSection // .text 472 = getContext().getMachOSection("__TEXT", "__text", 473 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, 474 SectionKind::getText()); 475 DataSection // .data 476 = getContext().getMachOSection("__DATA", "__data", 0, 477 SectionKind::getDataRel()); 478 479 TLSDataSection // .tdata 480 = getContext().getMachOSection("__DATA", "__thread_data", 481 MCSectionMachO::S_THREAD_LOCAL_REGULAR, 482 SectionKind::getDataRel()); 483 TLSBSSSection // .tbss 484 = getContext().getMachOSection("__DATA", "__thread_bss", 485 MCSectionMachO::S_THREAD_LOCAL_ZEROFILL, 486 SectionKind::getThreadBSS()); 487 488 // TODO: Verify datarel below. 489 TLSTLVSection // .tlv 490 = getContext().getMachOSection("__DATA", "__thread_vars", 491 MCSectionMachO::S_THREAD_LOCAL_VARIABLES, 492 SectionKind::getDataRel()); 493 494 TLSThreadInitSection 495 = getContext().getMachOSection("__DATA", "__thread_init", 496 MCSectionMachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS, 497 SectionKind::getDataRel()); 498 499 CStringSection // .cstring 500 = getContext().getMachOSection("__TEXT", "__cstring", 501 MCSectionMachO::S_CSTRING_LITERALS, 502 SectionKind::getMergeable1ByteCString()); 503 UStringSection 504 = getContext().getMachOSection("__TEXT","__ustring", 0, 505 SectionKind::getMergeable2ByteCString()); 506 FourByteConstantSection // .literal4 507 = getContext().getMachOSection("__TEXT", "__literal4", 508 MCSectionMachO::S_4BYTE_LITERALS, 509 SectionKind::getMergeableConst4()); 510 EightByteConstantSection // .literal8 511 = getContext().getMachOSection("__TEXT", "__literal8", 512 MCSectionMachO::S_8BYTE_LITERALS, 513 SectionKind::getMergeableConst8()); 514 515 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back 516 // to using it in -static mode. 517 SixteenByteConstantSection = 0; 518 if (TM.getRelocationModel() != Reloc::Static && 519 TM.getTargetData()->getPointerSize() == 32) 520 SixteenByteConstantSection = // .literal16 521 getContext().getMachOSection("__TEXT", "__literal16", 522 MCSectionMachO::S_16BYTE_LITERALS, 523 SectionKind::getMergeableConst16()); 524 525 ReadOnlySection // .const 526 = getContext().getMachOSection("__TEXT", "__const", 0, 527 SectionKind::getReadOnly()); 528 529 TextCoalSection 530 = getContext().getMachOSection("__TEXT", "__textcoal_nt", 531 MCSectionMachO::S_COALESCED | 532 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, 533 SectionKind::getText()); 534 ConstTextCoalSection 535 = getContext().getMachOSection("__TEXT", "__const_coal", 536 MCSectionMachO::S_COALESCED, 537 SectionKind::getReadOnly()); 538 ConstDataSection // .const_data 539 = getContext().getMachOSection("__DATA", "__const", 0, 540 SectionKind::getReadOnlyWithRel()); 541 DataCoalSection 542 = getContext().getMachOSection("__DATA","__datacoal_nt", 543 MCSectionMachO::S_COALESCED, 544 SectionKind::getDataRel()); 545 DataCommonSection 546 = getContext().getMachOSection("__DATA","__common", 547 MCSectionMachO::S_ZEROFILL, 548 SectionKind::getBSS()); 549 DataBSSSection 550 = getContext().getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL, 551 SectionKind::getBSS()); 552 553 554 LazySymbolPointerSection 555 = getContext().getMachOSection("__DATA", "__la_symbol_ptr", 556 MCSectionMachO::S_LAZY_SYMBOL_POINTERS, 557 SectionKind::getMetadata()); 558 NonLazySymbolPointerSection 559 = getContext().getMachOSection("__DATA", "__nl_symbol_ptr", 560 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS, 561 SectionKind::getMetadata()); 562 563 if (TM.getRelocationModel() == Reloc::Static) { 564 StaticCtorSection 565 = getContext().getMachOSection("__TEXT", "__constructor", 0, 566 SectionKind::getDataRel()); 567 StaticDtorSection 568 = getContext().getMachOSection("__TEXT", "__destructor", 0, 569 SectionKind::getDataRel()); 570 } else { 571 StaticCtorSection 572 = getContext().getMachOSection("__DATA", "__mod_init_func", 573 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS, 574 SectionKind::getDataRel()); 575 StaticDtorSection 576 = getContext().getMachOSection("__DATA", "__mod_term_func", 577 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS, 578 SectionKind::getDataRel()); 579 } 580 581 // Exception Handling. 582 LSDASection = getContext().getMachOSection("__TEXT", "__gcc_except_tab", 0, 583 SectionKind::getReadOnlyWithRel()); 584 // Debug Information. 585 DwarfAbbrevSection = 586 getContext().getMachOSection("__DWARF", "__debug_abbrev", 587 MCSectionMachO::S_ATTR_DEBUG, 588 SectionKind::getMetadata()); 589 DwarfInfoSection = 590 getContext().getMachOSection("__DWARF", "__debug_info", 591 MCSectionMachO::S_ATTR_DEBUG, 592 SectionKind::getMetadata()); 593 DwarfLineSection = 594 getContext().getMachOSection("__DWARF", "__debug_line", 595 MCSectionMachO::S_ATTR_DEBUG, 596 SectionKind::getMetadata()); 597 DwarfFrameSection = 598 getContext().getMachOSection("__DWARF", "__debug_frame", 599 MCSectionMachO::S_ATTR_DEBUG, 600 SectionKind::getMetadata()); 601 DwarfPubNamesSection = 602 getContext().getMachOSection("__DWARF", "__debug_pubnames", 603 MCSectionMachO::S_ATTR_DEBUG, 604 SectionKind::getMetadata()); 605 DwarfPubTypesSection = 606 getContext().getMachOSection("__DWARF", "__debug_pubtypes", 607 MCSectionMachO::S_ATTR_DEBUG, 608 SectionKind::getMetadata()); 609 DwarfStrSection = 610 getContext().getMachOSection("__DWARF", "__debug_str", 611 MCSectionMachO::S_ATTR_DEBUG, 612 SectionKind::getMetadata()); 613 DwarfLocSection = 614 getContext().getMachOSection("__DWARF", "__debug_loc", 615 MCSectionMachO::S_ATTR_DEBUG, 616 SectionKind::getMetadata()); 617 DwarfARangesSection = 618 getContext().getMachOSection("__DWARF", "__debug_aranges", 619 MCSectionMachO::S_ATTR_DEBUG, 620 SectionKind::getMetadata()); 621 DwarfRangesSection = 622 getContext().getMachOSection("__DWARF", "__debug_ranges", 623 MCSectionMachO::S_ATTR_DEBUG, 624 SectionKind::getMetadata()); 625 DwarfMacroInfoSection = 626 getContext().getMachOSection("__DWARF", "__debug_macinfo", 627 MCSectionMachO::S_ATTR_DEBUG, 628 SectionKind::getMetadata()); 629 DwarfDebugInlineSection = 630 getContext().getMachOSection("__DWARF", "__debug_inlined", 631 MCSectionMachO::S_ATTR_DEBUG, 632 SectionKind::getMetadata()); 633 634 TLSExtraDataSection = TLSTLVSection; 635 } 636 637 const MCSection *TargetLoweringObjectFileMachO::getEHFrameSection() const { 638 return getContext().getMachOSection("__TEXT", "__eh_frame", 639 MCSectionMachO::S_COALESCED | 640 MCSectionMachO::S_ATTR_NO_TOC | 641 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS | 642 MCSectionMachO::S_ATTR_LIVE_SUPPORT, 643 SectionKind::getReadOnly()); 644 } 645 646 const MCSection *TargetLoweringObjectFileMachO:: 647 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 648 Mangler *Mang, const TargetMachine &TM) const { 649 // Parse the section specifier and create it if valid. 650 StringRef Segment, Section; 651 unsigned TAA, StubSize; 652 std::string ErrorCode = 653 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section, 654 TAA, StubSize); 655 if (!ErrorCode.empty()) { 656 // If invalid, report the error with report_fatal_error. 657 report_fatal_error("Global variable '" + GV->getNameStr() + 658 "' has an invalid section specifier '" + GV->getSection()+ 659 "': " + ErrorCode + "."); 660 // Fall back to dropping it into the data section. 661 return DataSection; 662 } 663 664 // Get the section. 665 const MCSectionMachO *S = 666 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind); 667 668 // Okay, now that we got the section, verify that the TAA & StubSize agree. 669 // If the user declared multiple globals with different section flags, we need 670 // to reject it here. 671 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) { 672 // If invalid, report the error with report_fatal_error. 673 report_fatal_error("Global variable '" + GV->getNameStr() + 674 "' section type or attributes does not match previous" 675 " section specifier"); 676 } 677 678 return S; 679 } 680 681 const MCSection *TargetLoweringObjectFileMachO:: 682 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 683 Mangler *Mang, const TargetMachine &TM) const { 684 685 // Handle thread local data. 686 if (Kind.isThreadBSS()) return TLSBSSSection; 687 if (Kind.isThreadData()) return TLSDataSection; 688 689 if (Kind.isText()) 690 return GV->isWeakForLinker() ? TextCoalSection : TextSection; 691 692 // If this is weak/linkonce, put this in a coalescable section, either in text 693 // or data depending on if it is writable. 694 if (GV->isWeakForLinker()) { 695 if (Kind.isReadOnly()) 696 return ConstTextCoalSection; 697 return DataCoalSection; 698 } 699 700 // FIXME: Alignment check should be handled by section classifier. 701 if (Kind.isMergeable1ByteCString() && 702 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 703 return CStringSection; 704 705 // Do not put 16-bit arrays in the UString section if they have an 706 // externally visible label, this runs into issues with certain linker 707 // versions. 708 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() && 709 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 710 return UStringSection; 711 712 if (Kind.isMergeableConst()) { 713 if (Kind.isMergeableConst4()) 714 return FourByteConstantSection; 715 if (Kind.isMergeableConst8()) 716 return EightByteConstantSection; 717 if (Kind.isMergeableConst16() && SixteenByteConstantSection) 718 return SixteenByteConstantSection; 719 } 720 721 // Otherwise, if it is readonly, but not something we can specially optimize, 722 // just drop it in .const. 723 if (Kind.isReadOnly()) 724 return ReadOnlySection; 725 726 // If this is marked const, put it into a const section. But if the dynamic 727 // linker needs to write to it, put it in the data segment. 728 if (Kind.isReadOnlyWithRel()) 729 return ConstDataSection; 730 731 // Put zero initialized globals with strong external linkage in the 732 // DATA, __common section with the .zerofill directive. 733 if (Kind.isBSSExtern()) 734 return DataCommonSection; 735 736 // Put zero initialized globals with local linkage in __DATA,__bss directive 737 // with the .zerofill directive (aka .lcomm). 738 if (Kind.isBSSLocal()) 739 return DataBSSSection; 740 741 // Otherwise, just drop the variable in the normal data section. 742 return DataSection; 743 } 744 745 const MCSection * 746 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const { 747 // If this constant requires a relocation, we have to put it in the data 748 // segment, not in the text segment. 749 if (Kind.isDataRel() || Kind.isReadOnlyWithRel()) 750 return ConstDataSection; 751 752 if (Kind.isMergeableConst4()) 753 return FourByteConstantSection; 754 if (Kind.isMergeableConst8()) 755 return EightByteConstantSection; 756 if (Kind.isMergeableConst16() && SixteenByteConstantSection) 757 return SixteenByteConstantSection; 758 return ReadOnlySection; // .const 759 } 760 761 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide 762 /// not to emit the UsedDirective for some symbols in llvm.used. 763 // FIXME: REMOVE this (rdar://7071300) 764 bool TargetLoweringObjectFileMachO:: 765 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const { 766 /// On Darwin, internally linked data beginning with "L" or "l" does not have 767 /// the directive emitted (this occurs in ObjC metadata). 768 if (!GV) return false; 769 770 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix. 771 if (GV->hasLocalLinkage() && !isa<Function>(GV)) { 772 // FIXME: ObjC metadata is currently emitted as internal symbols that have 773 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and 774 // this horrible hack can go away. 775 MCSymbol *Sym = Mang->getSymbol(GV); 776 if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l') 777 return false; 778 } 779 780 return true; 781 } 782 783 const MCExpr *TargetLoweringObjectFileMachO:: 784 getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang, 785 MachineModuleInfo *MMI, unsigned Encoding, 786 MCStreamer &Streamer) const { 787 // The mach-o version of this method defaults to returning a stub reference. 788 789 if (Encoding & DW_EH_PE_indirect) { 790 MachineModuleInfoMachO &MachOMMI = 791 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 792 793 SmallString<128> Name; 794 Mang->getNameWithPrefix(Name, GV, true); 795 Name += "$non_lazy_ptr"; 796 797 // Add information about the stub reference to MachOMMI so that the stub 798 // gets emitted by the asmprinter. 799 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str()); 800 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym); 801 if (StubSym.getPointer() == 0) { 802 MCSymbol *Sym = Mang->getSymbol(GV); 803 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 804 } 805 806 return TargetLoweringObjectFile:: 807 getExprForDwarfReference(SSym, Mang, MMI, 808 Encoding & ~dwarf::DW_EH_PE_indirect, Streamer); 809 } 810 811 return TargetLoweringObjectFile:: 812 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer); 813 } 814 815 unsigned TargetLoweringObjectFileMachO::getPersonalityEncoding() const { 816 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4; 817 } 818 819 unsigned TargetLoweringObjectFileMachO::getLSDAEncoding() const { 820 return DW_EH_PE_pcrel; 821 } 822 823 unsigned TargetLoweringObjectFileMachO::getFDEEncoding() const { 824 return DW_EH_PE_pcrel; 825 } 826 827 unsigned TargetLoweringObjectFileMachO::getTTypeEncoding() const { 828 return DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4; 829 } 830 831 //===----------------------------------------------------------------------===// 832 // COFF 833 //===----------------------------------------------------------------------===// 834 835 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx, 836 const TargetMachine &TM) { 837 TargetLoweringObjectFile::Initialize(Ctx, TM); 838 TextSection = 839 getContext().getCOFFSection(".text", 840 COFF::IMAGE_SCN_CNT_CODE | 841 COFF::IMAGE_SCN_MEM_EXECUTE | 842 COFF::IMAGE_SCN_MEM_READ, 843 SectionKind::getText()); 844 DataSection = 845 getContext().getCOFFSection(".data", 846 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 847 COFF::IMAGE_SCN_MEM_READ | 848 COFF::IMAGE_SCN_MEM_WRITE, 849 SectionKind::getDataRel()); 850 ReadOnlySection = 851 getContext().getCOFFSection(".rdata", 852 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 853 COFF::IMAGE_SCN_MEM_READ, 854 SectionKind::getReadOnly()); 855 StaticCtorSection = 856 getContext().getCOFFSection(".ctors", 857 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 858 COFF::IMAGE_SCN_MEM_READ | 859 COFF::IMAGE_SCN_MEM_WRITE, 860 SectionKind::getDataRel()); 861 StaticDtorSection = 862 getContext().getCOFFSection(".dtors", 863 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 864 COFF::IMAGE_SCN_MEM_READ | 865 COFF::IMAGE_SCN_MEM_WRITE, 866 SectionKind::getDataRel()); 867 868 // FIXME: We're emitting LSDA info into a readonly section on COFF, even 869 // though it contains relocatable pointers. In PIC mode, this is probably a 870 // big runtime hit for C++ apps. Either the contents of the LSDA need to be 871 // adjusted or this should be a data section. 872 LSDASection = 873 getContext().getCOFFSection(".gcc_except_table", 874 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 875 COFF::IMAGE_SCN_MEM_READ, 876 SectionKind::getReadOnly()); 877 // Debug info. 878 DwarfAbbrevSection = 879 getContext().getCOFFSection(".debug_abbrev", 880 COFF::IMAGE_SCN_MEM_DISCARDABLE | 881 COFF::IMAGE_SCN_MEM_READ, 882 SectionKind::getMetadata()); 883 DwarfInfoSection = 884 getContext().getCOFFSection(".debug_info", 885 COFF::IMAGE_SCN_MEM_DISCARDABLE | 886 COFF::IMAGE_SCN_MEM_READ, 887 SectionKind::getMetadata()); 888 DwarfLineSection = 889 getContext().getCOFFSection(".debug_line", 890 COFF::IMAGE_SCN_MEM_DISCARDABLE | 891 COFF::IMAGE_SCN_MEM_READ, 892 SectionKind::getMetadata()); 893 DwarfFrameSection = 894 getContext().getCOFFSection(".debug_frame", 895 COFF::IMAGE_SCN_MEM_DISCARDABLE | 896 COFF::IMAGE_SCN_MEM_READ, 897 SectionKind::getMetadata()); 898 DwarfPubNamesSection = 899 getContext().getCOFFSection(".debug_pubnames", 900 COFF::IMAGE_SCN_MEM_DISCARDABLE | 901 COFF::IMAGE_SCN_MEM_READ, 902 SectionKind::getMetadata()); 903 DwarfPubTypesSection = 904 getContext().getCOFFSection(".debug_pubtypes", 905 COFF::IMAGE_SCN_MEM_DISCARDABLE | 906 COFF::IMAGE_SCN_MEM_READ, 907 SectionKind::getMetadata()); 908 DwarfStrSection = 909 getContext().getCOFFSection(".debug_str", 910 COFF::IMAGE_SCN_MEM_DISCARDABLE | 911 COFF::IMAGE_SCN_MEM_READ, 912 SectionKind::getMetadata()); 913 DwarfLocSection = 914 getContext().getCOFFSection(".debug_loc", 915 COFF::IMAGE_SCN_MEM_DISCARDABLE | 916 COFF::IMAGE_SCN_MEM_READ, 917 SectionKind::getMetadata()); 918 DwarfARangesSection = 919 getContext().getCOFFSection(".debug_aranges", 920 COFF::IMAGE_SCN_MEM_DISCARDABLE | 921 COFF::IMAGE_SCN_MEM_READ, 922 SectionKind::getMetadata()); 923 DwarfRangesSection = 924 getContext().getCOFFSection(".debug_ranges", 925 COFF::IMAGE_SCN_MEM_DISCARDABLE | 926 COFF::IMAGE_SCN_MEM_READ, 927 SectionKind::getMetadata()); 928 DwarfMacroInfoSection = 929 getContext().getCOFFSection(".debug_macinfo", 930 COFF::IMAGE_SCN_MEM_DISCARDABLE | 931 COFF::IMAGE_SCN_MEM_READ, 932 SectionKind::getMetadata()); 933 934 DrectveSection = 935 getContext().getCOFFSection(".drectve", 936 COFF::IMAGE_SCN_LNK_INFO, 937 SectionKind::getMetadata()); 938 } 939 940 const MCSection *TargetLoweringObjectFileCOFF::getEHFrameSection() const { 941 return getContext().getCOFFSection(".eh_frame", 942 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 943 COFF::IMAGE_SCN_MEM_READ | 944 COFF::IMAGE_SCN_MEM_WRITE, 945 SectionKind::getDataRel()); 946 } 947 948 949 static unsigned 950 getCOFFSectionFlags(SectionKind K) { 951 unsigned Flags = 0; 952 953 if (K.isMetadata()) 954 Flags |= 955 COFF::IMAGE_SCN_MEM_DISCARDABLE; 956 else if (K.isText()) 957 Flags |= 958 COFF::IMAGE_SCN_MEM_EXECUTE | 959 COFF::IMAGE_SCN_MEM_READ | 960 COFF::IMAGE_SCN_CNT_CODE; 961 else if (K.isBSS ()) 962 Flags |= 963 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA | 964 COFF::IMAGE_SCN_MEM_READ | 965 COFF::IMAGE_SCN_MEM_WRITE; 966 else if (K.isReadOnly()) 967 Flags |= 968 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 969 COFF::IMAGE_SCN_MEM_READ; 970 else if (K.isWriteable()) 971 Flags |= 972 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 973 COFF::IMAGE_SCN_MEM_READ | 974 COFF::IMAGE_SCN_MEM_WRITE; 975 976 return Flags; 977 } 978 979 const MCSection *TargetLoweringObjectFileCOFF:: 980 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 981 Mangler *Mang, const TargetMachine &TM) const { 982 return getContext().getCOFFSection(GV->getSection(), 983 getCOFFSectionFlags(Kind), 984 Kind); 985 } 986 987 static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) { 988 if (Kind.isText()) 989 return ".text$"; 990 if (Kind.isBSS ()) 991 return ".bss$"; 992 if (Kind.isWriteable()) 993 return ".data$"; 994 return ".rdata$"; 995 } 996 997 998 const MCSection *TargetLoweringObjectFileCOFF:: 999 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 1000 Mangler *Mang, const TargetMachine &TM) const { 1001 assert(!Kind.isThreadLocal() && "Doesn't support TLS"); 1002 1003 // If this global is linkonce/weak and the target handles this by emitting it 1004 // into a 'uniqued' section name, create and return the section now. 1005 if (GV->isWeakForLinker()) { 1006 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind); 1007 SmallString<128> Name(Prefix, Prefix+strlen(Prefix)); 1008 MCSymbol *Sym = Mang->getSymbol(GV); 1009 Name.append(Sym->getName().begin() + 1, Sym->getName().end()); 1010 1011 unsigned Characteristics = getCOFFSectionFlags(Kind); 1012 1013 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 1014 1015 return getContext().getCOFFSection(Name.str(), Characteristics, 1016 COFF::IMAGE_COMDAT_SELECT_ANY, Kind); 1017 } 1018 1019 if (Kind.isText()) 1020 return getTextSection(); 1021 1022 return getDataSection(); 1023 } 1024 1025