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