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