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