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 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, 523 SectionKind::getText()); 524 ConstDataCoalSection 525 = getContext().getMachOSection("__DATA","__const_coal", 526 MCSectionMachO::S_COALESCED, 527 SectionKind::getReadOnly()); 528 ConstDataSection // .const_data 529 = getContext().getMachOSection("__DATA", "__const", 0, 530 SectionKind::getReadOnlyWithRel()); 531 DataCoalSection 532 = getContext().getMachOSection("__DATA","__datacoal_nt", 533 MCSectionMachO::S_COALESCED, 534 SectionKind::getDataRel()); 535 DataCommonSection 536 = getContext().getMachOSection("__DATA","__common", 537 MCSectionMachO::S_ZEROFILL, 538 SectionKind::getBSS()); 539 DataBSSSection 540 = getContext().getMachOSection("__DATA","__bss", MCSectionMachO::S_ZEROFILL, 541 SectionKind::getBSS()); 542 543 544 LazySymbolPointerSection 545 = getContext().getMachOSection("__DATA", "__la_symbol_ptr", 546 MCSectionMachO::S_LAZY_SYMBOL_POINTERS, 547 SectionKind::getMetadata()); 548 NonLazySymbolPointerSection 549 = getContext().getMachOSection("__DATA", "__nl_symbol_ptr", 550 MCSectionMachO::S_NON_LAZY_SYMBOL_POINTERS, 551 SectionKind::getMetadata()); 552 553 if (TM.getRelocationModel() == Reloc::Static) { 554 StaticCtorSection 555 = getContext().getMachOSection("__TEXT", "__constructor", 0, 556 SectionKind::getDataRel()); 557 StaticDtorSection 558 = getContext().getMachOSection("__TEXT", "__destructor", 0, 559 SectionKind::getDataRel()); 560 } else { 561 StaticCtorSection 562 = getContext().getMachOSection("__DATA", "__mod_init_func", 563 MCSectionMachO::S_MOD_INIT_FUNC_POINTERS, 564 SectionKind::getDataRel()); 565 StaticDtorSection 566 = getContext().getMachOSection("__DATA", "__mod_term_func", 567 MCSectionMachO::S_MOD_TERM_FUNC_POINTERS, 568 SectionKind::getDataRel()); 569 } 570 571 // Exception Handling. 572 LSDASection = getContext().getMachOSection("__TEXT", "__gcc_except_tab", 0, 573 SectionKind::getReadOnlyWithRel()); 574 EHFrameSection = 575 getContext().getMachOSection("__TEXT", "__eh_frame", 576 MCSectionMachO::S_COALESCED | 577 MCSectionMachO::S_ATTR_NO_TOC | 578 MCSectionMachO::S_ATTR_STRIP_STATIC_SYMS | 579 MCSectionMachO::S_ATTR_LIVE_SUPPORT, 580 SectionKind::getReadOnly()); 581 582 // Debug Information. 583 DwarfAbbrevSection = 584 getContext().getMachOSection("__DWARF", "__debug_abbrev", 585 MCSectionMachO::S_ATTR_DEBUG, 586 SectionKind::getMetadata()); 587 DwarfInfoSection = 588 getContext().getMachOSection("__DWARF", "__debug_info", 589 MCSectionMachO::S_ATTR_DEBUG, 590 SectionKind::getMetadata()); 591 DwarfLineSection = 592 getContext().getMachOSection("__DWARF", "__debug_line", 593 MCSectionMachO::S_ATTR_DEBUG, 594 SectionKind::getMetadata()); 595 DwarfFrameSection = 596 getContext().getMachOSection("__DWARF", "__debug_frame", 597 MCSectionMachO::S_ATTR_DEBUG, 598 SectionKind::getMetadata()); 599 DwarfPubNamesSection = 600 getContext().getMachOSection("__DWARF", "__debug_pubnames", 601 MCSectionMachO::S_ATTR_DEBUG, 602 SectionKind::getMetadata()); 603 DwarfPubTypesSection = 604 getContext().getMachOSection("__DWARF", "__debug_pubtypes", 605 MCSectionMachO::S_ATTR_DEBUG, 606 SectionKind::getMetadata()); 607 DwarfStrSection = 608 getContext().getMachOSection("__DWARF", "__debug_str", 609 MCSectionMachO::S_ATTR_DEBUG, 610 SectionKind::getMetadata()); 611 DwarfLocSection = 612 getContext().getMachOSection("__DWARF", "__debug_loc", 613 MCSectionMachO::S_ATTR_DEBUG, 614 SectionKind::getMetadata()); 615 DwarfARangesSection = 616 getContext().getMachOSection("__DWARF", "__debug_aranges", 617 MCSectionMachO::S_ATTR_DEBUG, 618 SectionKind::getMetadata()); 619 DwarfRangesSection = 620 getContext().getMachOSection("__DWARF", "__debug_ranges", 621 MCSectionMachO::S_ATTR_DEBUG, 622 SectionKind::getMetadata()); 623 DwarfMacroInfoSection = 624 getContext().getMachOSection("__DWARF", "__debug_macinfo", 625 MCSectionMachO::S_ATTR_DEBUG, 626 SectionKind::getMetadata()); 627 DwarfDebugInlineSection = 628 getContext().getMachOSection("__DWARF", "__debug_inlined", 629 MCSectionMachO::S_ATTR_DEBUG, 630 SectionKind::getMetadata()); 631 632 TLSExtraDataSection = TLSTLVSection; 633 } 634 635 const MCSection *TargetLoweringObjectFileMachO:: 636 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 637 Mangler *Mang, const TargetMachine &TM) const { 638 // Parse the section specifier and create it if valid. 639 StringRef Segment, Section; 640 unsigned TAA, StubSize; 641 std::string ErrorCode = 642 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section, 643 TAA, StubSize); 644 if (!ErrorCode.empty()) { 645 // If invalid, report the error with report_fatal_error. 646 report_fatal_error("Global variable '" + GV->getNameStr() + 647 "' has an invalid section specifier '" + GV->getSection()+ 648 "': " + ErrorCode + "."); 649 // Fall back to dropping it into the data section. 650 return DataSection; 651 } 652 653 // Get the section. 654 const MCSectionMachO *S = 655 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind); 656 657 // Okay, now that we got the section, verify that the TAA & StubSize agree. 658 // If the user declared multiple globals with different section flags, we need 659 // to reject it here. 660 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) { 661 // If invalid, report the error with report_fatal_error. 662 report_fatal_error("Global variable '" + GV->getNameStr() + 663 "' section type or attributes does not match previous" 664 " section specifier"); 665 } 666 667 return S; 668 } 669 670 const MCSection *TargetLoweringObjectFileMachO:: 671 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 672 Mangler *Mang, const TargetMachine &TM) const { 673 674 // Handle thread local data. 675 if (Kind.isThreadBSS()) return TLSBSSSection; 676 if (Kind.isThreadData()) return TLSDataSection; 677 678 if (Kind.isText()) 679 return GV->isWeakForLinker() ? TextCoalSection : TextSection; 680 681 // If this is weak/linkonce, put this in a coalescable section, either in text 682 // or data depending on if it is writable. 683 if (GV->isWeakForLinker()) { 684 if (Kind.isReadOnly()) 685 return ConstTextCoalSection; 686 return DataCoalSection; 687 } 688 689 // FIXME: Alignment check should be handled by section classifier. 690 if (Kind.isMergeable1ByteCString() && 691 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 692 return CStringSection; 693 694 // Do not put 16-bit arrays in the UString section if they have an 695 // externally visible label, this runs into issues with certain linker 696 // versions. 697 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() && 698 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 699 return UStringSection; 700 701 if (Kind.isMergeableConst()) { 702 if (Kind.isMergeableConst4()) 703 return FourByteConstantSection; 704 if (Kind.isMergeableConst8()) 705 return EightByteConstantSection; 706 if (Kind.isMergeableConst16() && SixteenByteConstantSection) 707 return SixteenByteConstantSection; 708 } 709 710 // Otherwise, if it is readonly, but not something we can specially optimize, 711 // just drop it in .const. 712 if (Kind.isReadOnly()) 713 return ReadOnlySection; 714 715 // If this is marked const, put it into a const section. But if the dynamic 716 // linker needs to write to it, put it in the data segment. 717 if (Kind.isReadOnlyWithRel()) 718 return ConstDataSection; 719 720 // Put zero initialized globals with strong external linkage in the 721 // DATA, __common section with the .zerofill directive. 722 if (Kind.isBSSExtern()) 723 return DataCommonSection; 724 725 // Put zero initialized globals with local linkage in __DATA,__bss directive 726 // with the .zerofill directive (aka .lcomm). 727 if (Kind.isBSSLocal()) 728 return DataBSSSection; 729 730 // Otherwise, just drop the variable in the normal data section. 731 return DataSection; 732 } 733 734 const MCSection * 735 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const { 736 // If this constant requires a relocation, we have to put it in the data 737 // segment, not in the text segment. 738 if (Kind.isDataRel() || Kind.isReadOnlyWithRel()) 739 return ConstDataSection; 740 741 if (Kind.isMergeableConst4()) 742 return FourByteConstantSection; 743 if (Kind.isMergeableConst8()) 744 return EightByteConstantSection; 745 if (Kind.isMergeableConst16() && SixteenByteConstantSection) 746 return SixteenByteConstantSection; 747 return ReadOnlySection; // .const 748 } 749 750 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide 751 /// not to emit the UsedDirective for some symbols in llvm.used. 752 // FIXME: REMOVE this (rdar://7071300) 753 bool TargetLoweringObjectFileMachO:: 754 shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const { 755 /// On Darwin, internally linked data beginning with "L" or "l" does not have 756 /// the directive emitted (this occurs in ObjC metadata). 757 if (!GV) return false; 758 759 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix. 760 if (GV->hasLocalLinkage() && !isa<Function>(GV)) { 761 // FIXME: ObjC metadata is currently emitted as internal symbols that have 762 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and 763 // 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 COFF::IMAGE_SCN_CNT_CODE | 830 COFF::IMAGE_SCN_MEM_EXECUTE | 831 COFF::IMAGE_SCN_MEM_READ, 832 SectionKind::getText()); 833 DataSection = 834 getContext().getCOFFSection(".data", 835 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 836 COFF::IMAGE_SCN_MEM_READ | 837 COFF::IMAGE_SCN_MEM_WRITE, 838 SectionKind::getDataRel()); 839 ReadOnlySection = 840 getContext().getCOFFSection(".rdata", 841 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 842 COFF::IMAGE_SCN_MEM_READ, 843 SectionKind::getReadOnly()); 844 StaticCtorSection = 845 getContext().getCOFFSection(".ctors", 846 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 847 COFF::IMAGE_SCN_MEM_READ | 848 COFF::IMAGE_SCN_MEM_WRITE, 849 SectionKind::getDataRel()); 850 StaticDtorSection = 851 getContext().getCOFFSection(".dtors", 852 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 853 COFF::IMAGE_SCN_MEM_READ | 854 COFF::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 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 864 COFF::IMAGE_SCN_MEM_READ, 865 SectionKind::getReadOnly()); 866 EHFrameSection = 867 getContext().getCOFFSection(".eh_frame", 868 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 869 COFF::IMAGE_SCN_MEM_READ | 870 COFF::IMAGE_SCN_MEM_WRITE, 871 SectionKind::getDataRel()); 872 873 // Debug info. 874 DwarfAbbrevSection = 875 getContext().getCOFFSection(".debug_abbrev", 876 COFF::IMAGE_SCN_MEM_DISCARDABLE | 877 COFF::IMAGE_SCN_MEM_READ, 878 SectionKind::getMetadata()); 879 DwarfInfoSection = 880 getContext().getCOFFSection(".debug_info", 881 COFF::IMAGE_SCN_MEM_DISCARDABLE | 882 COFF::IMAGE_SCN_MEM_READ, 883 SectionKind::getMetadata()); 884 DwarfLineSection = 885 getContext().getCOFFSection(".debug_line", 886 COFF::IMAGE_SCN_MEM_DISCARDABLE | 887 COFF::IMAGE_SCN_MEM_READ, 888 SectionKind::getMetadata()); 889 DwarfFrameSection = 890 getContext().getCOFFSection(".debug_frame", 891 COFF::IMAGE_SCN_MEM_DISCARDABLE | 892 COFF::IMAGE_SCN_MEM_READ, 893 SectionKind::getMetadata()); 894 DwarfPubNamesSection = 895 getContext().getCOFFSection(".debug_pubnames", 896 COFF::IMAGE_SCN_MEM_DISCARDABLE | 897 COFF::IMAGE_SCN_MEM_READ, 898 SectionKind::getMetadata()); 899 DwarfPubTypesSection = 900 getContext().getCOFFSection(".debug_pubtypes", 901 COFF::IMAGE_SCN_MEM_DISCARDABLE | 902 COFF::IMAGE_SCN_MEM_READ, 903 SectionKind::getMetadata()); 904 DwarfStrSection = 905 getContext().getCOFFSection(".debug_str", 906 COFF::IMAGE_SCN_MEM_DISCARDABLE | 907 COFF::IMAGE_SCN_MEM_READ, 908 SectionKind::getMetadata()); 909 DwarfLocSection = 910 getContext().getCOFFSection(".debug_loc", 911 COFF::IMAGE_SCN_MEM_DISCARDABLE | 912 COFF::IMAGE_SCN_MEM_READ, 913 SectionKind::getMetadata()); 914 DwarfARangesSection = 915 getContext().getCOFFSection(".debug_aranges", 916 COFF::IMAGE_SCN_MEM_DISCARDABLE | 917 COFF::IMAGE_SCN_MEM_READ, 918 SectionKind::getMetadata()); 919 DwarfRangesSection = 920 getContext().getCOFFSection(".debug_ranges", 921 COFF::IMAGE_SCN_MEM_DISCARDABLE | 922 COFF::IMAGE_SCN_MEM_READ, 923 SectionKind::getMetadata()); 924 DwarfMacroInfoSection = 925 getContext().getCOFFSection(".debug_macinfo", 926 COFF::IMAGE_SCN_MEM_DISCARDABLE | 927 COFF::IMAGE_SCN_MEM_READ, 928 SectionKind::getMetadata()); 929 930 DrectveSection = 931 getContext().getCOFFSection(".drectve", 932 COFF::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 COFF::IMAGE_SCN_MEM_DISCARDABLE; 943 else if (K.isText()) 944 Flags |= 945 COFF::IMAGE_SCN_MEM_EXECUTE | 946 COFF::IMAGE_SCN_CNT_CODE; 947 else if (K.isBSS ()) 948 Flags |= 949 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA | 950 COFF::IMAGE_SCN_MEM_READ | 951 COFF::IMAGE_SCN_MEM_WRITE; 952 else if (K.isReadOnly()) 953 Flags |= 954 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 955 COFF::IMAGE_SCN_MEM_READ; 956 else if (K.isWriteable()) 957 Flags |= 958 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 959 COFF::IMAGE_SCN_MEM_READ | 960 COFF::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 |= COFF::IMAGE_SCN_LNK_COMDAT; 1000 1001 return getContext().getCOFFSection(Name.str(), Characteristics, 1002 COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH, Kind); 1003 } 1004 1005 if (Kind.isText()) 1006 return getTextSection(); 1007 1008 return getDataSection(); 1009 } 1010 1011