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/ADT/SmallString.h" 17 #include "llvm/ADT/StringExtras.h" 18 #include "llvm/ADT/Triple.h" 19 #include "llvm/CodeGen/MachineModuleInfoImpls.h" 20 #include "llvm/IR/Constants.h" 21 #include "llvm/IR/DataLayout.h" 22 #include "llvm/IR/DerivedTypes.h" 23 #include "llvm/IR/Function.h" 24 #include "llvm/IR/GlobalVariable.h" 25 #include "llvm/IR/Mangler.h" 26 #include "llvm/IR/Module.h" 27 #include "llvm/MC/MCContext.h" 28 #include "llvm/MC/MCExpr.h" 29 #include "llvm/MC/MCSectionCOFF.h" 30 #include "llvm/MC/MCSectionELF.h" 31 #include "llvm/MC/MCSectionMachO.h" 32 #include "llvm/MC/MCStreamer.h" 33 #include "llvm/MC/MCSymbol.h" 34 #include "llvm/Support/Dwarf.h" 35 #include "llvm/Support/ELF.h" 36 #include "llvm/Support/ErrorHandling.h" 37 #include "llvm/Support/raw_ostream.h" 38 #include "llvm/Target/TargetLowering.h" 39 #include "llvm/Target/TargetMachine.h" 40 using namespace llvm; 41 using namespace dwarf; 42 43 //===----------------------------------------------------------------------===// 44 // ELF 45 //===----------------------------------------------------------------------===// 46 47 MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol( 48 const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM, 49 MachineModuleInfo *MMI) const { 50 unsigned Encoding = getPersonalityEncoding(); 51 if ((Encoding & 0x80) == dwarf::DW_EH_PE_indirect) 52 return getContext().GetOrCreateSymbol(StringRef("DW.ref.") + 53 TM.getSymbol(GV, Mang)->getName()); 54 if ((Encoding & 0x70) == dwarf::DW_EH_PE_absptr) 55 return TM.getSymbol(GV, Mang); 56 report_fatal_error("We do not support this DWARF encoding yet!"); 57 } 58 59 void TargetLoweringObjectFileELF::emitPersonalityValue(MCStreamer &Streamer, 60 const TargetMachine &TM, 61 const MCSymbol *Sym) const { 62 SmallString<64> NameData("DW.ref."); 63 NameData += Sym->getName(); 64 MCSymbol *Label = getContext().GetOrCreateSymbol(NameData); 65 Streamer.EmitSymbolAttribute(Label, MCSA_Hidden); 66 Streamer.EmitSymbolAttribute(Label, MCSA_Weak); 67 StringRef Prefix = ".data."; 68 NameData.insert(NameData.begin(), Prefix.begin(), Prefix.end()); 69 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP; 70 const MCSection *Sec = getContext().getELFSection(NameData, 71 ELF::SHT_PROGBITS, 72 Flags, 73 SectionKind::getDataRel(), 74 0, Label->getName()); 75 unsigned Size = TM.getDataLayout()->getPointerSize(); 76 Streamer.SwitchSection(Sec); 77 Streamer.EmitValueToAlignment(TM.getDataLayout()->getPointerABIAlignment()); 78 Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject); 79 const MCExpr *E = MCConstantExpr::Create(Size, getContext()); 80 Streamer.EmitELFSize(Label, E); 81 Streamer.EmitLabel(Label); 82 83 Streamer.EmitSymbolValue(Sym, Size); 84 } 85 86 const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference( 87 const GlobalValue *GV, unsigned Encoding, Mangler &Mang, 88 const TargetMachine &TM, MachineModuleInfo *MMI, 89 MCStreamer &Streamer) const { 90 91 if (Encoding & dwarf::DW_EH_PE_indirect) { 92 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>(); 93 94 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", Mang, TM); 95 96 // Add information about the stub reference to ELFMMI so that the stub 97 // gets emitted by the asmprinter. 98 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym); 99 if (!StubSym.getPointer()) { 100 MCSymbol *Sym = TM.getSymbol(GV, Mang); 101 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 102 } 103 104 return TargetLoweringObjectFile:: 105 getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()), 106 Encoding & ~dwarf::DW_EH_PE_indirect, Streamer); 107 } 108 109 return TargetLoweringObjectFile:: 110 getTTypeGlobalReference(GV, Encoding, Mang, TM, MMI, Streamer); 111 } 112 113 static SectionKind 114 getELFKindForNamedSection(StringRef Name, SectionKind K) { 115 // N.B.: The defaults used in here are no the same ones used in MC. 116 // We follow gcc, MC follows gas. For example, given ".section .eh_frame", 117 // both gas and MC will produce a section with no flags. Given 118 // section(".eh_frame") gcc will produce: 119 // 120 // .section .eh_frame,"a",@progbits 121 if (Name.empty() || Name[0] != '.') return K; 122 123 // Some lame default implementation based on some magic section names. 124 if (Name == ".bss" || 125 Name.startswith(".bss.") || 126 Name.startswith(".gnu.linkonce.b.") || 127 Name.startswith(".llvm.linkonce.b.") || 128 Name == ".sbss" || 129 Name.startswith(".sbss.") || 130 Name.startswith(".gnu.linkonce.sb.") || 131 Name.startswith(".llvm.linkonce.sb.")) 132 return SectionKind::getBSS(); 133 134 if (Name == ".tdata" || 135 Name.startswith(".tdata.") || 136 Name.startswith(".gnu.linkonce.td.") || 137 Name.startswith(".llvm.linkonce.td.")) 138 return SectionKind::getThreadData(); 139 140 if (Name == ".tbss" || 141 Name.startswith(".tbss.") || 142 Name.startswith(".gnu.linkonce.tb.") || 143 Name.startswith(".llvm.linkonce.tb.")) 144 return SectionKind::getThreadBSS(); 145 146 return K; 147 } 148 149 150 static unsigned getELFSectionType(StringRef Name, SectionKind K) { 151 152 if (Name == ".init_array") 153 return ELF::SHT_INIT_ARRAY; 154 155 if (Name == ".fini_array") 156 return ELF::SHT_FINI_ARRAY; 157 158 if (Name == ".preinit_array") 159 return ELF::SHT_PREINIT_ARRAY; 160 161 if (K.isBSS() || K.isThreadBSS()) 162 return ELF::SHT_NOBITS; 163 164 return ELF::SHT_PROGBITS; 165 } 166 167 168 static unsigned 169 getELFSectionFlags(SectionKind K) { 170 unsigned Flags = 0; 171 172 if (!K.isMetadata()) 173 Flags |= ELF::SHF_ALLOC; 174 175 if (K.isText()) 176 Flags |= ELF::SHF_EXECINSTR; 177 178 if (K.isWriteable()) 179 Flags |= ELF::SHF_WRITE; 180 181 if (K.isThreadLocal()) 182 Flags |= ELF::SHF_TLS; 183 184 // K.isMergeableConst() is left out to honour PR4650 185 if (K.isMergeableCString() || K.isMergeableConst4() || 186 K.isMergeableConst8() || K.isMergeableConst16()) 187 Flags |= ELF::SHF_MERGE; 188 189 if (K.isMergeableCString()) 190 Flags |= ELF::SHF_STRINGS; 191 192 return Flags; 193 } 194 195 static const Comdat *getELFComdat(const GlobalValue *GV) { 196 const Comdat *C = GV->getComdat(); 197 if (!C) 198 return nullptr; 199 200 if (C->getSelectionKind() != Comdat::Any) 201 report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" + 202 C->getName() + "' cannot be lowered."); 203 204 return C; 205 } 206 207 const MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal( 208 const GlobalValue *GV, SectionKind Kind, Mangler &Mang, 209 const TargetMachine &TM) const { 210 StringRef SectionName = GV->getSection(); 211 212 // Infer section flags from the section name if we can. 213 Kind = getELFKindForNamedSection(SectionName, Kind); 214 215 StringRef Group = ""; 216 unsigned Flags = getELFSectionFlags(Kind); 217 if (const Comdat *C = getELFComdat(GV)) { 218 Group = C->getName(); 219 Flags |= ELF::SHF_GROUP; 220 } 221 return getContext().getELFSection(SectionName, 222 getELFSectionType(SectionName, Kind), Flags, 223 Kind, /*EntrySize=*/0, Group); 224 } 225 226 /// getSectionPrefixForGlobal - Return the section prefix name used by options 227 /// FunctionsSections and DataSections. 228 static StringRef getSectionPrefixForGlobal(SectionKind Kind) { 229 if (Kind.isText()) return ".text."; 230 if (Kind.isReadOnly()) return ".rodata."; 231 if (Kind.isBSS()) return ".bss."; 232 233 if (Kind.isThreadData()) return ".tdata."; 234 if (Kind.isThreadBSS()) return ".tbss."; 235 236 if (Kind.isDataNoRel()) return ".data."; 237 if (Kind.isDataRelLocal()) return ".data.rel.local."; 238 if (Kind.isDataRel()) return ".data.rel."; 239 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local."; 240 241 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 242 return ".data.rel.ro."; 243 } 244 245 const MCSection *TargetLoweringObjectFileELF:: 246 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 247 Mangler &Mang, const TargetMachine &TM) const { 248 // If we have -ffunction-section or -fdata-section then we should emit the 249 // global value to a uniqued section specifically for it. 250 bool EmitUniquedSection; 251 if (Kind.isText()) 252 EmitUniquedSection = TM.getFunctionSections(); 253 else 254 EmitUniquedSection = TM.getDataSections(); 255 256 // If this global is linkonce/weak and the target handles this by emitting it 257 // into a 'uniqued' section name, create and return the section now. 258 if ((GV->isWeakForLinker() || EmitUniquedSection || GV->hasComdat()) && 259 !Kind.isCommon()) { 260 StringRef Prefix = getSectionPrefixForGlobal(Kind); 261 262 SmallString<128> Name(Prefix); 263 TM.getNameWithPrefix(Name, GV, Mang, true); 264 265 StringRef Group = ""; 266 unsigned Flags = getELFSectionFlags(Kind); 267 if (GV->isWeakForLinker() || GV->hasComdat()) { 268 if (const Comdat *C = getELFComdat(GV)) 269 Group = C->getName(); 270 else 271 Group = Name.substr(Prefix.size()); 272 Flags |= ELF::SHF_GROUP; 273 } 274 275 return getContext().getELFSection(Name.str(), 276 getELFSectionType(Name.str(), Kind), 277 Flags, Kind, 0, Group); 278 } 279 280 if (Kind.isText()) return TextSection; 281 282 if (Kind.isMergeable1ByteCString() || 283 Kind.isMergeable2ByteCString() || 284 Kind.isMergeable4ByteCString()) { 285 286 // We also need alignment here. 287 // FIXME: this is getting the alignment of the character, not the 288 // alignment of the global! 289 unsigned Align = 290 TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)); 291 292 const char *SizeSpec = ".rodata.str1."; 293 if (Kind.isMergeable2ByteCString()) 294 SizeSpec = ".rodata.str2."; 295 else if (Kind.isMergeable4ByteCString()) 296 SizeSpec = ".rodata.str4."; 297 else 298 assert(Kind.isMergeable1ByteCString() && "unknown string width"); 299 300 301 std::string Name = SizeSpec + utostr(Align); 302 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, 303 ELF::SHF_ALLOC | 304 ELF::SHF_MERGE | 305 ELF::SHF_STRINGS, 306 Kind); 307 } 308 309 if (Kind.isMergeableConst()) { 310 if (Kind.isMergeableConst4() && MergeableConst4Section) 311 return MergeableConst4Section; 312 if (Kind.isMergeableConst8() && MergeableConst8Section) 313 return MergeableConst8Section; 314 if (Kind.isMergeableConst16() && MergeableConst16Section) 315 return MergeableConst16Section; 316 return ReadOnlySection; // .const 317 } 318 319 if (Kind.isReadOnly()) return ReadOnlySection; 320 321 if (Kind.isThreadData()) return TLSDataSection; 322 if (Kind.isThreadBSS()) return TLSBSSSection; 323 324 // Note: we claim that common symbols are put in BSSSection, but they are 325 // really emitted with the magic .comm directive, which creates a symbol table 326 // entry but not a section. 327 if (Kind.isBSS() || Kind.isCommon()) return BSSSection; 328 329 if (Kind.isDataNoRel()) return DataSection; 330 if (Kind.isDataRelLocal()) return DataRelLocalSection; 331 if (Kind.isDataRel()) return DataRelSection; 332 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection; 333 334 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 335 return DataRelROSection; 336 } 337 338 /// getSectionForConstant - Given a mergeable constant with the 339 /// specified size and relocation information, return a section that it 340 /// should be placed in. 341 const MCSection *TargetLoweringObjectFileELF:: 342 getSectionForConstant(SectionKind Kind) const { 343 if (Kind.isMergeableConst4() && MergeableConst4Section) 344 return MergeableConst4Section; 345 if (Kind.isMergeableConst8() && MergeableConst8Section) 346 return MergeableConst8Section; 347 if (Kind.isMergeableConst16() && MergeableConst16Section) 348 return MergeableConst16Section; 349 if (Kind.isReadOnly()) 350 return ReadOnlySection; 351 352 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection; 353 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 354 return DataRelROSection; 355 } 356 357 const MCSection *TargetLoweringObjectFileELF::getStaticCtorSection( 358 unsigned Priority, const MCSymbol *KeySym) const { 359 // The default scheme is .ctor / .dtor, so we have to invert the priority 360 // numbering. 361 if (Priority == 65535) 362 return StaticCtorSection; 363 364 if (UseInitArray) { 365 std::string Name = std::string(".init_array.") + utostr(Priority); 366 return getContext().getELFSection(Name, ELF::SHT_INIT_ARRAY, 367 ELF::SHF_ALLOC | ELF::SHF_WRITE, 368 SectionKind::getDataRel()); 369 } else { 370 std::string Name = std::string(".ctors.") + utostr(65535 - Priority); 371 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, 372 ELF::SHF_ALLOC |ELF::SHF_WRITE, 373 SectionKind::getDataRel()); 374 } 375 } 376 377 const MCSection *TargetLoweringObjectFileELF::getStaticDtorSection( 378 unsigned Priority, const MCSymbol *KeySym) const { 379 // The default scheme is .ctor / .dtor, so we have to invert the priority 380 // numbering. 381 if (Priority == 65535) 382 return StaticDtorSection; 383 384 if (UseInitArray) { 385 std::string Name = std::string(".fini_array.") + utostr(Priority); 386 return getContext().getELFSection(Name, ELF::SHT_FINI_ARRAY, 387 ELF::SHF_ALLOC | ELF::SHF_WRITE, 388 SectionKind::getDataRel()); 389 } else { 390 std::string Name = std::string(".dtors.") + utostr(65535 - Priority); 391 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, 392 ELF::SHF_ALLOC |ELF::SHF_WRITE, 393 SectionKind::getDataRel()); 394 } 395 } 396 397 void 398 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) { 399 UseInitArray = UseInitArray_; 400 if (!UseInitArray) 401 return; 402 403 StaticCtorSection = 404 getContext().getELFSection(".init_array", ELF::SHT_INIT_ARRAY, 405 ELF::SHF_WRITE | 406 ELF::SHF_ALLOC, 407 SectionKind::getDataRel()); 408 StaticDtorSection = 409 getContext().getELFSection(".fini_array", ELF::SHT_FINI_ARRAY, 410 ELF::SHF_WRITE | 411 ELF::SHF_ALLOC, 412 SectionKind::getDataRel()); 413 } 414 415 //===----------------------------------------------------------------------===// 416 // MachO 417 //===----------------------------------------------------------------------===// 418 419 /// getDepLibFromLinkerOpt - Extract the dependent library name from a linker 420 /// option string. Returns StringRef() if the option does not specify a library. 421 StringRef TargetLoweringObjectFileMachO:: 422 getDepLibFromLinkerOpt(StringRef LinkerOption) const { 423 const char *LibCmd = "-l"; 424 if (LinkerOption.startswith(LibCmd)) 425 return LinkerOption.substr(strlen(LibCmd)); 426 return StringRef(); 427 } 428 429 /// emitModuleFlags - Perform code emission for module flags. 430 void TargetLoweringObjectFileMachO:: 431 emitModuleFlags(MCStreamer &Streamer, 432 ArrayRef<Module::ModuleFlagEntry> ModuleFlags, 433 Mangler &Mang, const TargetMachine &TM) const { 434 unsigned VersionVal = 0; 435 unsigned ImageInfoFlags = 0; 436 MDNode *LinkerOptions = nullptr; 437 StringRef SectionVal; 438 439 for (ArrayRef<Module::ModuleFlagEntry>::iterator 440 i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) { 441 const Module::ModuleFlagEntry &MFE = *i; 442 443 // Ignore flags with 'Require' behavior. 444 if (MFE.Behavior == Module::Require) 445 continue; 446 447 StringRef Key = MFE.Key->getString(); 448 Value *Val = MFE.Val; 449 450 if (Key == "Objective-C Image Info Version") { 451 VersionVal = cast<ConstantInt>(Val)->getZExtValue(); 452 } else if (Key == "Objective-C Garbage Collection" || 453 Key == "Objective-C GC Only" || 454 Key == "Objective-C Is Simulated") { 455 ImageInfoFlags |= cast<ConstantInt>(Val)->getZExtValue(); 456 } else if (Key == "Objective-C Image Info Section") { 457 SectionVal = cast<MDString>(Val)->getString(); 458 } else if (Key == "Linker Options") { 459 LinkerOptions = cast<MDNode>(Val); 460 } 461 } 462 463 // Emit the linker options if present. 464 if (LinkerOptions) { 465 for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { 466 MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i)); 467 SmallVector<std::string, 4> StrOptions; 468 469 // Convert to strings. 470 for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { 471 MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); 472 StrOptions.push_back(MDOption->getString()); 473 } 474 475 Streamer.EmitLinkerOptions(StrOptions); 476 } 477 } 478 479 // The section is mandatory. If we don't have it, then we don't have GC info. 480 if (SectionVal.empty()) return; 481 482 StringRef Segment, Section; 483 unsigned TAA = 0, StubSize = 0; 484 bool TAAParsed; 485 std::string ErrorCode = 486 MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section, 487 TAA, TAAParsed, StubSize); 488 if (!ErrorCode.empty()) 489 // If invalid, report the error with report_fatal_error. 490 report_fatal_error("Invalid section specifier '" + Section + "': " + 491 ErrorCode + "."); 492 493 // Get the section. 494 const MCSectionMachO *S = 495 getContext().getMachOSection(Segment, Section, TAA, StubSize, 496 SectionKind::getDataNoRel()); 497 Streamer.SwitchSection(S); 498 Streamer.EmitLabel(getContext(). 499 GetOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO"))); 500 Streamer.EmitIntValue(VersionVal, 4); 501 Streamer.EmitIntValue(ImageInfoFlags, 4); 502 Streamer.AddBlankLine(); 503 } 504 505 static void checkMachOComdat(const GlobalValue *GV) { 506 const Comdat *C = GV->getComdat(); 507 if (!C) 508 return; 509 510 report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() + 511 "' cannot be lowered."); 512 } 513 514 const MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal( 515 const GlobalValue *GV, SectionKind Kind, Mangler &Mang, 516 const TargetMachine &TM) const { 517 // Parse the section specifier and create it if valid. 518 StringRef Segment, Section; 519 unsigned TAA = 0, StubSize = 0; 520 bool TAAParsed; 521 522 checkMachOComdat(GV); 523 524 std::string ErrorCode = 525 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section, 526 TAA, TAAParsed, StubSize); 527 if (!ErrorCode.empty()) { 528 // If invalid, report the error with report_fatal_error. 529 report_fatal_error("Global variable '" + GV->getName() + 530 "' has an invalid section specifier '" + 531 GV->getSection() + "': " + ErrorCode + "."); 532 } 533 534 // Get the section. 535 const MCSectionMachO *S = 536 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind); 537 538 // If TAA wasn't set by ParseSectionSpecifier() above, 539 // use the value returned by getMachOSection() as a default. 540 if (!TAAParsed) 541 TAA = S->getTypeAndAttributes(); 542 543 // Okay, now that we got the section, verify that the TAA & StubSize agree. 544 // If the user declared multiple globals with different section flags, we need 545 // to reject it here. 546 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) { 547 // If invalid, report the error with report_fatal_error. 548 report_fatal_error("Global variable '" + GV->getName() + 549 "' section type or attributes does not match previous" 550 " section specifier"); 551 } 552 553 return S; 554 } 555 556 bool TargetLoweringObjectFileMachO::isSectionAtomizableBySymbols( 557 const MCSection &Section) const { 558 const MCSectionMachO &SMO = static_cast<const MCSectionMachO&>(Section); 559 560 // Sections holding 1 byte strings are atomized based on the data 561 // they contain. 562 // Sections holding 2 byte strings require symbols in order to be 563 // atomized. 564 // There is no dedicated section for 4 byte strings. 565 if (SMO.getKind().isMergeable1ByteCString()) 566 return false; 567 568 if (SMO.getSegmentName() == "__DATA" && 569 SMO.getSectionName() == "__cfstring") 570 return false; 571 572 switch (SMO.getType()) { 573 default: 574 return true; 575 576 // These sections are atomized at the element boundaries without using 577 // symbols. 578 case MachO::S_4BYTE_LITERALS: 579 case MachO::S_8BYTE_LITERALS: 580 case MachO::S_16BYTE_LITERALS: 581 case MachO::S_LITERAL_POINTERS: 582 case MachO::S_NON_LAZY_SYMBOL_POINTERS: 583 case MachO::S_LAZY_SYMBOL_POINTERS: 584 case MachO::S_MOD_INIT_FUNC_POINTERS: 585 case MachO::S_MOD_TERM_FUNC_POINTERS: 586 case MachO::S_INTERPOSING: 587 return false; 588 } 589 } 590 591 const MCSection *TargetLoweringObjectFileMachO:: 592 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 593 Mangler &Mang, const TargetMachine &TM) const { 594 checkMachOComdat(GV); 595 596 // Handle thread local data. 597 if (Kind.isThreadBSS()) return TLSBSSSection; 598 if (Kind.isThreadData()) return TLSDataSection; 599 600 if (Kind.isText()) 601 return GV->isWeakForLinker() ? TextCoalSection : TextSection; 602 603 // If this is weak/linkonce, put this in a coalescable section, either in text 604 // or data depending on if it is writable. 605 if (GV->isWeakForLinker()) { 606 if (Kind.isReadOnly()) 607 return ConstTextCoalSection; 608 return DataCoalSection; 609 } 610 611 // FIXME: Alignment check should be handled by section classifier. 612 if (Kind.isMergeable1ByteCString() && 613 TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 614 return CStringSection; 615 616 // Do not put 16-bit arrays in the UString section if they have an 617 // externally visible label, this runs into issues with certain linker 618 // versions. 619 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() && 620 TM.getDataLayout()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 621 return UStringSection; 622 623 if (Kind.isMergeableConst()) { 624 if (Kind.isMergeableConst4()) 625 return FourByteConstantSection; 626 if (Kind.isMergeableConst8()) 627 return EightByteConstantSection; 628 if (Kind.isMergeableConst16()) 629 return SixteenByteConstantSection; 630 } 631 632 // Otherwise, if it is readonly, but not something we can specially optimize, 633 // just drop it in .const. 634 if (Kind.isReadOnly()) 635 return ReadOnlySection; 636 637 // If this is marked const, put it into a const section. But if the dynamic 638 // linker needs to write to it, put it in the data segment. 639 if (Kind.isReadOnlyWithRel()) 640 return ConstDataSection; 641 642 // Put zero initialized globals with strong external linkage in the 643 // DATA, __common section with the .zerofill directive. 644 if (Kind.isBSSExtern()) 645 return DataCommonSection; 646 647 // Put zero initialized globals with local linkage in __DATA,__bss directive 648 // with the .zerofill directive (aka .lcomm). 649 if (Kind.isBSSLocal()) 650 return DataBSSSection; 651 652 // Otherwise, just drop the variable in the normal data section. 653 return DataSection; 654 } 655 656 const MCSection * 657 TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const { 658 // If this constant requires a relocation, we have to put it in the data 659 // segment, not in the text segment. 660 if (Kind.isDataRel() || Kind.isReadOnlyWithRel()) 661 return ConstDataSection; 662 663 if (Kind.isMergeableConst4()) 664 return FourByteConstantSection; 665 if (Kind.isMergeableConst8()) 666 return EightByteConstantSection; 667 if (Kind.isMergeableConst16()) 668 return SixteenByteConstantSection; 669 return ReadOnlySection; // .const 670 } 671 672 const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference( 673 const GlobalValue *GV, unsigned Encoding, Mangler &Mang, 674 const TargetMachine &TM, MachineModuleInfo *MMI, 675 MCStreamer &Streamer) const { 676 // The mach-o version of this method defaults to returning a stub reference. 677 678 if (Encoding & DW_EH_PE_indirect) { 679 MachineModuleInfoMachO &MachOMMI = 680 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 681 682 MCSymbol *SSym = 683 getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM); 684 685 // Add information about the stub reference to MachOMMI so that the stub 686 // gets emitted by the asmprinter. 687 MachineModuleInfoImpl::StubValueTy &StubSym = 688 GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) : 689 MachOMMI.getGVStubEntry(SSym); 690 if (!StubSym.getPointer()) { 691 MCSymbol *Sym = TM.getSymbol(GV, Mang); 692 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 693 } 694 695 return TargetLoweringObjectFile:: 696 getTTypeReference(MCSymbolRefExpr::Create(SSym, getContext()), 697 Encoding & ~dwarf::DW_EH_PE_indirect, Streamer); 698 } 699 700 return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, Mang, 701 TM, MMI, Streamer); 702 } 703 704 MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol( 705 const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM, 706 MachineModuleInfo *MMI) const { 707 // The mach-o version of this method defaults to returning a stub reference. 708 MachineModuleInfoMachO &MachOMMI = 709 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 710 711 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM); 712 713 // Add information about the stub reference to MachOMMI so that the stub 714 // gets emitted by the asmprinter. 715 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym); 716 if (!StubSym.getPointer()) { 717 MCSymbol *Sym = TM.getSymbol(GV, Mang); 718 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 719 } 720 721 return SSym; 722 } 723 724 //===----------------------------------------------------------------------===// 725 // COFF 726 //===----------------------------------------------------------------------===// 727 728 static unsigned 729 getCOFFSectionFlags(SectionKind K) { 730 unsigned Flags = 0; 731 732 if (K.isMetadata()) 733 Flags |= 734 COFF::IMAGE_SCN_MEM_DISCARDABLE; 735 else if (K.isText()) 736 Flags |= 737 COFF::IMAGE_SCN_MEM_EXECUTE | 738 COFF::IMAGE_SCN_MEM_READ | 739 COFF::IMAGE_SCN_CNT_CODE; 740 else if (K.isBSS ()) 741 Flags |= 742 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA | 743 COFF::IMAGE_SCN_MEM_READ | 744 COFF::IMAGE_SCN_MEM_WRITE; 745 else if (K.isThreadLocal()) 746 Flags |= 747 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 748 COFF::IMAGE_SCN_MEM_READ | 749 COFF::IMAGE_SCN_MEM_WRITE; 750 else if (K.isReadOnly()) 751 Flags |= 752 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 753 COFF::IMAGE_SCN_MEM_READ; 754 else if (K.isWriteable()) 755 Flags |= 756 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 757 COFF::IMAGE_SCN_MEM_READ | 758 COFF::IMAGE_SCN_MEM_WRITE; 759 760 return Flags; 761 } 762 763 static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) { 764 const Comdat *C = GV->getComdat(); 765 assert(C && "expected GV to have a Comdat!"); 766 767 StringRef ComdatGVName = C->getName(); 768 const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName); 769 if (!ComdatGV) 770 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName + 771 "' does not exist."); 772 773 if (ComdatGV->getComdat() != C) 774 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName + 775 "' is not a key for it's COMDAT."); 776 777 return ComdatGV; 778 } 779 780 static int getSelectionForCOFF(const GlobalValue *GV) { 781 if (const Comdat *C = GV->getComdat()) { 782 const GlobalValue *ComdatKey = getComdatGVForCOFF(GV); 783 if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey)) 784 ComdatKey = GA->getBaseObject(); 785 if (ComdatKey == GV) { 786 switch (C->getSelectionKind()) { 787 case Comdat::Any: 788 return COFF::IMAGE_COMDAT_SELECT_ANY; 789 case Comdat::ExactMatch: 790 return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH; 791 case Comdat::Largest: 792 return COFF::IMAGE_COMDAT_SELECT_LARGEST; 793 case Comdat::NoDuplicates: 794 return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES; 795 case Comdat::SameSize: 796 return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE; 797 } 798 } else { 799 return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE; 800 } 801 } else if (GV->isWeakForLinker()) { 802 return COFF::IMAGE_COMDAT_SELECT_ANY; 803 } 804 return 0; 805 } 806 807 const MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal( 808 const GlobalValue *GV, SectionKind Kind, Mangler &Mang, 809 const TargetMachine &TM) const { 810 int Selection = 0; 811 unsigned Characteristics = getCOFFSectionFlags(Kind); 812 StringRef Name = GV->getSection(); 813 StringRef COMDATSymName = ""; 814 if ((GV->isWeakForLinker() || GV->hasComdat()) && !Kind.isCommon()) { 815 Selection = getSelectionForCOFF(GV); 816 const GlobalValue *ComdatGV; 817 if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) 818 ComdatGV = getComdatGVForCOFF(GV); 819 else 820 ComdatGV = GV; 821 822 if (!ComdatGV->hasPrivateLinkage()) { 823 MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang); 824 COMDATSymName = Sym->getName(); 825 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 826 } else { 827 Selection = 0; 828 } 829 } 830 return getContext().getCOFFSection(Name, 831 Characteristics, 832 Kind, 833 COMDATSymName, 834 Selection); 835 } 836 837 static const char *getCOFFSectionNameForUniqueGlobal(SectionKind Kind) { 838 if (Kind.isText()) 839 return ".text"; 840 if (Kind.isBSS()) 841 return ".bss"; 842 if (Kind.isThreadLocal()) 843 return ".tls$"; 844 if (Kind.isWriteable()) 845 return ".data"; 846 return ".rdata"; 847 } 848 849 850 const MCSection *TargetLoweringObjectFileCOFF:: 851 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 852 Mangler &Mang, const TargetMachine &TM) const { 853 // If we have -ffunction-sections then we should emit the global value to a 854 // uniqued section specifically for it. 855 bool EmitUniquedSection; 856 if (Kind.isText()) 857 EmitUniquedSection = TM.getFunctionSections(); 858 else 859 EmitUniquedSection = TM.getDataSections(); 860 861 // If this global is linkonce/weak and the target handles this by emitting it 862 // into a 'uniqued' section name, create and return the section now. 863 // Section names depend on the name of the symbol which is not feasible if the 864 // symbol has private linkage. 865 if ((GV->isWeakForLinker() || EmitUniquedSection || GV->hasComdat()) && 866 !Kind.isCommon()) { 867 const char *Name = getCOFFSectionNameForUniqueGlobal(Kind); 868 unsigned Characteristics = getCOFFSectionFlags(Kind); 869 870 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 871 int Selection = getSelectionForCOFF(GV); 872 if (!Selection) 873 Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES; 874 const GlobalValue *ComdatGV; 875 if (GV->hasComdat()) 876 ComdatGV = getComdatGVForCOFF(GV); 877 else 878 ComdatGV = GV; 879 880 if (!ComdatGV->hasPrivateLinkage()) { 881 MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang); 882 StringRef COMDATSymName = Sym->getName(); 883 return getContext().getCOFFSection(Name, Characteristics, Kind, 884 COMDATSymName, Selection); 885 } 886 } 887 888 if (Kind.isText()) 889 return TextSection; 890 891 if (Kind.isThreadLocal()) 892 return TLSDataSection; 893 894 if (Kind.isReadOnly()) 895 return ReadOnlySection; 896 897 // Note: we claim that common symbols are put in BSSSection, but they are 898 // really emitted with the magic .comm directive, which creates a symbol table 899 // entry but not a section. 900 if (Kind.isBSS() || Kind.isCommon()) 901 return BSSSection; 902 903 return DataSection; 904 } 905 906 StringRef TargetLoweringObjectFileCOFF:: 907 getDepLibFromLinkerOpt(StringRef LinkerOption) const { 908 const char *LibCmd = "/DEFAULTLIB:"; 909 if (LinkerOption.startswith(LibCmd)) 910 return LinkerOption.substr(strlen(LibCmd)); 911 return StringRef(); 912 } 913 914 void TargetLoweringObjectFileCOFF:: 915 emitModuleFlags(MCStreamer &Streamer, 916 ArrayRef<Module::ModuleFlagEntry> ModuleFlags, 917 Mangler &Mang, const TargetMachine &TM) const { 918 MDNode *LinkerOptions = nullptr; 919 920 // Look for the "Linker Options" flag, since it's the only one we support. 921 for (ArrayRef<Module::ModuleFlagEntry>::iterator 922 i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) { 923 const Module::ModuleFlagEntry &MFE = *i; 924 StringRef Key = MFE.Key->getString(); 925 Value *Val = MFE.Val; 926 if (Key == "Linker Options") { 927 LinkerOptions = cast<MDNode>(Val); 928 break; 929 } 930 } 931 if (!LinkerOptions) 932 return; 933 934 // Emit the linker options to the linker .drectve section. According to the 935 // spec, this section is a space-separated string containing flags for linker. 936 const MCSection *Sec = getDrectveSection(); 937 Streamer.SwitchSection(Sec); 938 for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) { 939 MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i)); 940 for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) { 941 MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii)); 942 StringRef Op = MDOption->getString(); 943 // Lead with a space for consistency with our dllexport implementation. 944 std::string Escaped(" "); 945 if (Op.find(" ") != StringRef::npos) { 946 // The PE-COFF spec says args with spaces must be quoted. It doesn't say 947 // how to escape quotes, but it probably uses this algorithm: 948 // http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx 949 // FIXME: Reuse escaping code from Support/Windows/Program.inc 950 Escaped.push_back('\"'); 951 Escaped.append(Op); 952 Escaped.push_back('\"'); 953 } else { 954 Escaped.append(Op); 955 } 956 Streamer.EmitBytes(Escaped); 957 } 958 } 959 } 960 961 static const MCSection *getAssociativeCOFFSection(MCContext &Ctx, 962 const MCSection *Sec, 963 const MCSymbol *KeySym) { 964 // Return the normal section if we don't have to be associative. 965 if (!KeySym) 966 return Sec; 967 968 // Make an associative section with the same name and kind as the normal 969 // section. 970 const MCSectionCOFF *SecCOFF = cast<MCSectionCOFF>(Sec); 971 unsigned Characteristics = 972 SecCOFF->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT; 973 return Ctx.getCOFFSection(SecCOFF->getSectionName(), Characteristics, 974 SecCOFF->getKind(), KeySym->getName(), 975 COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE); 976 } 977 978 const MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection( 979 unsigned Priority, const MCSymbol *KeySym) const { 980 return getAssociativeCOFFSection(getContext(), StaticCtorSection, KeySym); 981 } 982 983 const MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection( 984 unsigned Priority, const MCSymbol *KeySym) const { 985 return getAssociativeCOFFSection(getContext(), StaticDtorSection, KeySym); 986 } 987