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