1 //===- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info ---===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements classes used to handle lowerings specific to common 10 // object file formats. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" 15 #include "llvm/ADT/SmallString.h" 16 #include "llvm/ADT/SmallVector.h" 17 #include "llvm/ADT/StringExtras.h" 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/ADT/Triple.h" 20 #include "llvm/BinaryFormat/COFF.h" 21 #include "llvm/BinaryFormat/Dwarf.h" 22 #include "llvm/BinaryFormat/ELF.h" 23 #include "llvm/BinaryFormat/MachO.h" 24 #include "llvm/CodeGen/MachineModuleInfo.h" 25 #include "llvm/CodeGen/MachineModuleInfoImpls.h" 26 #include "llvm/IR/Comdat.h" 27 #include "llvm/IR/Constants.h" 28 #include "llvm/IR/DataLayout.h" 29 #include "llvm/IR/DerivedTypes.h" 30 #include "llvm/IR/Function.h" 31 #include "llvm/IR/GlobalAlias.h" 32 #include "llvm/IR/GlobalObject.h" 33 #include "llvm/IR/GlobalValue.h" 34 #include "llvm/IR/GlobalVariable.h" 35 #include "llvm/IR/Mangler.h" 36 #include "llvm/IR/Metadata.h" 37 #include "llvm/IR/Module.h" 38 #include "llvm/IR/Type.h" 39 #include "llvm/MC/MCAsmInfo.h" 40 #include "llvm/MC/MCContext.h" 41 #include "llvm/MC/MCExpr.h" 42 #include "llvm/MC/MCSectionCOFF.h" 43 #include "llvm/MC/MCSectionELF.h" 44 #include "llvm/MC/MCSectionMachO.h" 45 #include "llvm/MC/MCSectionWasm.h" 46 #include "llvm/MC/MCSectionXCOFF.h" 47 #include "llvm/MC/MCStreamer.h" 48 #include "llvm/MC/MCSymbol.h" 49 #include "llvm/MC/MCSymbolELF.h" 50 #include "llvm/MC/MCValue.h" 51 #include "llvm/MC/SectionKind.h" 52 #include "llvm/ProfileData/InstrProf.h" 53 #include "llvm/Support/Casting.h" 54 #include "llvm/Support/CodeGen.h" 55 #include "llvm/Support/Format.h" 56 #include "llvm/Support/ErrorHandling.h" 57 #include "llvm/Support/raw_ostream.h" 58 #include "llvm/Target/TargetMachine.h" 59 #include <cassert> 60 #include <string> 61 62 using namespace llvm; 63 using namespace dwarf; 64 65 static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags, 66 StringRef &Section) { 67 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags; 68 M.getModuleFlagsMetadata(ModuleFlags); 69 70 for (const auto &MFE: ModuleFlags) { 71 // Ignore flags with 'Require' behaviour. 72 if (MFE.Behavior == Module::Require) 73 continue; 74 75 StringRef Key = MFE.Key->getString(); 76 if (Key == "Objective-C Image Info Version") { 77 Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue(); 78 } else if (Key == "Objective-C Garbage Collection" || 79 Key == "Objective-C GC Only" || 80 Key == "Objective-C Is Simulated" || 81 Key == "Objective-C Class Properties" || 82 Key == "Objective-C Image Swift Version") { 83 Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue(); 84 } else if (Key == "Objective-C Image Info Section") { 85 Section = cast<MDString>(MFE.Val)->getString(); 86 } 87 } 88 } 89 90 //===----------------------------------------------------------------------===// 91 // ELF 92 //===----------------------------------------------------------------------===// 93 94 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx, 95 const TargetMachine &TgtM) { 96 TargetLoweringObjectFile::Initialize(Ctx, TgtM); 97 TM = &TgtM; 98 99 CodeModel::Model CM = TgtM.getCodeModel(); 100 101 switch (TgtM.getTargetTriple().getArch()) { 102 case Triple::arm: 103 case Triple::armeb: 104 case Triple::thumb: 105 case Triple::thumbeb: 106 if (Ctx.getAsmInfo()->getExceptionHandlingType() == ExceptionHandling::ARM) 107 break; 108 // Fallthrough if not using EHABI 109 LLVM_FALLTHROUGH; 110 case Triple::ppc: 111 case Triple::x86: 112 PersonalityEncoding = isPositionIndependent() 113 ? dwarf::DW_EH_PE_indirect | 114 dwarf::DW_EH_PE_pcrel | 115 dwarf::DW_EH_PE_sdata4 116 : dwarf::DW_EH_PE_absptr; 117 LSDAEncoding = isPositionIndependent() 118 ? dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4 119 : dwarf::DW_EH_PE_absptr; 120 TTypeEncoding = isPositionIndependent() 121 ? dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 122 dwarf::DW_EH_PE_sdata4 123 : dwarf::DW_EH_PE_absptr; 124 break; 125 case Triple::x86_64: 126 if (isPositionIndependent()) { 127 PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 128 ((CM == CodeModel::Small || CM == CodeModel::Medium) 129 ? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8); 130 LSDAEncoding = dwarf::DW_EH_PE_pcrel | 131 (CM == CodeModel::Small 132 ? dwarf::DW_EH_PE_sdata4 : dwarf::DW_EH_PE_sdata8); 133 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 134 ((CM == CodeModel::Small || CM == CodeModel::Medium) 135 ? dwarf::DW_EH_PE_sdata8 : dwarf::DW_EH_PE_sdata4); 136 } else { 137 PersonalityEncoding = 138 (CM == CodeModel::Small || CM == CodeModel::Medium) 139 ? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr; 140 LSDAEncoding = (CM == CodeModel::Small) 141 ? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr; 142 TTypeEncoding = (CM == CodeModel::Small) 143 ? dwarf::DW_EH_PE_udata4 : dwarf::DW_EH_PE_absptr; 144 } 145 break; 146 case Triple::hexagon: 147 PersonalityEncoding = dwarf::DW_EH_PE_absptr; 148 LSDAEncoding = dwarf::DW_EH_PE_absptr; 149 TTypeEncoding = dwarf::DW_EH_PE_absptr; 150 if (isPositionIndependent()) { 151 PersonalityEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel; 152 LSDAEncoding |= dwarf::DW_EH_PE_pcrel; 153 TTypeEncoding |= dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel; 154 } 155 break; 156 case Triple::aarch64: 157 case Triple::aarch64_be: 158 case Triple::aarch64_32: 159 // The small model guarantees static code/data size < 4GB, but not where it 160 // will be in memory. Most of these could end up >2GB away so even a signed 161 // pc-relative 32-bit address is insufficient, theoretically. 162 if (isPositionIndependent()) { 163 PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 164 dwarf::DW_EH_PE_sdata8; 165 LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8; 166 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 167 dwarf::DW_EH_PE_sdata8; 168 } else { 169 PersonalityEncoding = dwarf::DW_EH_PE_absptr; 170 LSDAEncoding = dwarf::DW_EH_PE_absptr; 171 TTypeEncoding = dwarf::DW_EH_PE_absptr; 172 } 173 break; 174 case Triple::lanai: 175 LSDAEncoding = dwarf::DW_EH_PE_absptr; 176 PersonalityEncoding = dwarf::DW_EH_PE_absptr; 177 TTypeEncoding = dwarf::DW_EH_PE_absptr; 178 break; 179 case Triple::mips: 180 case Triple::mipsel: 181 case Triple::mips64: 182 case Triple::mips64el: 183 // MIPS uses indirect pointer to refer personality functions and types, so 184 // that the eh_frame section can be read-only. DW.ref.personality will be 185 // generated for relocation. 186 PersonalityEncoding = dwarf::DW_EH_PE_indirect; 187 // FIXME: The N64 ABI probably ought to use DW_EH_PE_sdata8 but we can't 188 // identify N64 from just a triple. 189 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 190 dwarf::DW_EH_PE_sdata4; 191 // We don't support PC-relative LSDA references in GAS so we use the default 192 // DW_EH_PE_absptr for those. 193 194 // FreeBSD must be explicit about the data size and using pcrel since it's 195 // assembler/linker won't do the automatic conversion that the Linux tools 196 // do. 197 if (TgtM.getTargetTriple().isOSFreeBSD()) { 198 PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 199 LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 200 } 201 break; 202 case Triple::ppc64: 203 case Triple::ppc64le: 204 PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 205 dwarf::DW_EH_PE_udata8; 206 LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8; 207 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 208 dwarf::DW_EH_PE_udata8; 209 break; 210 case Triple::sparcel: 211 case Triple::sparc: 212 if (isPositionIndependent()) { 213 LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 214 PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 215 dwarf::DW_EH_PE_sdata4; 216 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 217 dwarf::DW_EH_PE_sdata4; 218 } else { 219 LSDAEncoding = dwarf::DW_EH_PE_absptr; 220 PersonalityEncoding = dwarf::DW_EH_PE_absptr; 221 TTypeEncoding = dwarf::DW_EH_PE_absptr; 222 } 223 CallSiteEncoding = dwarf::DW_EH_PE_udata4; 224 break; 225 case Triple::riscv32: 226 case Triple::riscv64: 227 LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 228 PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 229 dwarf::DW_EH_PE_sdata4; 230 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 231 dwarf::DW_EH_PE_sdata4; 232 CallSiteEncoding = dwarf::DW_EH_PE_udata4; 233 break; 234 case Triple::sparcv9: 235 LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 236 if (isPositionIndependent()) { 237 PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 238 dwarf::DW_EH_PE_sdata4; 239 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 240 dwarf::DW_EH_PE_sdata4; 241 } else { 242 PersonalityEncoding = dwarf::DW_EH_PE_absptr; 243 TTypeEncoding = dwarf::DW_EH_PE_absptr; 244 } 245 break; 246 case Triple::systemz: 247 // All currently-defined code models guarantee that 4-byte PC-relative 248 // values will be in range. 249 if (isPositionIndependent()) { 250 PersonalityEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 251 dwarf::DW_EH_PE_sdata4; 252 LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 253 TTypeEncoding = dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | 254 dwarf::DW_EH_PE_sdata4; 255 } else { 256 PersonalityEncoding = dwarf::DW_EH_PE_absptr; 257 LSDAEncoding = dwarf::DW_EH_PE_absptr; 258 TTypeEncoding = dwarf::DW_EH_PE_absptr; 259 } 260 break; 261 default: 262 break; 263 } 264 } 265 266 void TargetLoweringObjectFileELF::emitModuleMetadata(MCStreamer &Streamer, 267 Module &M) const { 268 auto &C = getContext(); 269 270 if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) { 271 auto *S = C.getELFSection(".linker-options", ELF::SHT_LLVM_LINKER_OPTIONS, 272 ELF::SHF_EXCLUDE); 273 274 Streamer.SwitchSection(S); 275 276 for (const auto &Operand : LinkerOptions->operands()) { 277 if (cast<MDNode>(Operand)->getNumOperands() != 2) 278 report_fatal_error("invalid llvm.linker.options"); 279 for (const auto &Option : cast<MDNode>(Operand)->operands()) { 280 Streamer.EmitBytes(cast<MDString>(Option)->getString()); 281 Streamer.EmitIntValue(0, 1); 282 } 283 } 284 } 285 286 if (NamedMDNode *DependentLibraries = M.getNamedMetadata("llvm.dependent-libraries")) { 287 auto *S = C.getELFSection(".deplibs", ELF::SHT_LLVM_DEPENDENT_LIBRARIES, 288 ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, ""); 289 290 Streamer.SwitchSection(S); 291 292 for (const auto &Operand : DependentLibraries->operands()) { 293 Streamer.EmitBytes( 294 cast<MDString>(cast<MDNode>(Operand)->getOperand(0))->getString()); 295 Streamer.EmitIntValue(0, 1); 296 } 297 } 298 299 unsigned Version = 0; 300 unsigned Flags = 0; 301 StringRef Section; 302 303 GetObjCImageInfo(M, Version, Flags, Section); 304 if (!Section.empty()) { 305 auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC); 306 Streamer.SwitchSection(S); 307 Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO"))); 308 Streamer.EmitIntValue(Version, 4); 309 Streamer.EmitIntValue(Flags, 4); 310 Streamer.AddBlankLine(); 311 } 312 313 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags; 314 M.getModuleFlagsMetadata(ModuleFlags); 315 316 MDNode *CFGProfile = nullptr; 317 318 for (const auto &MFE : ModuleFlags) { 319 StringRef Key = MFE.Key->getString(); 320 if (Key == "CG Profile") { 321 CFGProfile = cast<MDNode>(MFE.Val); 322 break; 323 } 324 } 325 326 if (!CFGProfile) 327 return; 328 329 auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * { 330 if (!MDO) 331 return nullptr; 332 auto V = cast<ValueAsMetadata>(MDO); 333 const Function *F = cast<Function>(V->getValue()); 334 return TM->getSymbol(F); 335 }; 336 337 for (const auto &Edge : CFGProfile->operands()) { 338 MDNode *E = cast<MDNode>(Edge); 339 const MCSymbol *From = GetSym(E->getOperand(0)); 340 const MCSymbol *To = GetSym(E->getOperand(1)); 341 // Skip null functions. This can happen if functions are dead stripped after 342 // the CGProfile pass has been run. 343 if (!From || !To) 344 continue; 345 uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2)) 346 ->getValue() 347 ->getUniqueInteger() 348 .getZExtValue(); 349 Streamer.emitCGProfileEntry( 350 MCSymbolRefExpr::create(From, MCSymbolRefExpr::VK_None, C), 351 MCSymbolRefExpr::create(To, MCSymbolRefExpr::VK_None, C), Count); 352 } 353 } 354 355 MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol( 356 const GlobalValue *GV, const TargetMachine &TM, 357 MachineModuleInfo *MMI) const { 358 unsigned Encoding = getPersonalityEncoding(); 359 if ((Encoding & 0x80) == DW_EH_PE_indirect) 360 return getContext().getOrCreateSymbol(StringRef("DW.ref.") + 361 TM.getSymbol(GV)->getName()); 362 if ((Encoding & 0x70) == DW_EH_PE_absptr) 363 return TM.getSymbol(GV); 364 report_fatal_error("We do not support this DWARF encoding yet!"); 365 } 366 367 void TargetLoweringObjectFileELF::emitPersonalityValue( 368 MCStreamer &Streamer, const DataLayout &DL, const MCSymbol *Sym) const { 369 SmallString<64> NameData("DW.ref."); 370 NameData += Sym->getName(); 371 MCSymbolELF *Label = 372 cast<MCSymbolELF>(getContext().getOrCreateSymbol(NameData)); 373 Streamer.EmitSymbolAttribute(Label, MCSA_Hidden); 374 Streamer.EmitSymbolAttribute(Label, MCSA_Weak); 375 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE | ELF::SHF_GROUP; 376 MCSection *Sec = getContext().getELFNamedSection(".data", Label->getName(), 377 ELF::SHT_PROGBITS, Flags, 0); 378 unsigned Size = DL.getPointerSize(); 379 Streamer.SwitchSection(Sec); 380 Streamer.EmitValueToAlignment(DL.getPointerABIAlignment(0).value()); 381 Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject); 382 const MCExpr *E = MCConstantExpr::create(Size, getContext()); 383 Streamer.emitELFSize(Label, E); 384 Streamer.EmitLabel(Label); 385 386 Streamer.EmitSymbolValue(Sym, Size); 387 } 388 389 const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference( 390 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, 391 MachineModuleInfo *MMI, MCStreamer &Streamer) const { 392 if (Encoding & DW_EH_PE_indirect) { 393 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>(); 394 395 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM); 396 397 // Add information about the stub reference to ELFMMI so that the stub 398 // gets emitted by the asmprinter. 399 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym); 400 if (!StubSym.getPointer()) { 401 MCSymbol *Sym = TM.getSymbol(GV); 402 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 403 } 404 405 return TargetLoweringObjectFile:: 406 getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()), 407 Encoding & ~DW_EH_PE_indirect, Streamer); 408 } 409 410 return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM, 411 MMI, Streamer); 412 } 413 414 static SectionKind getELFKindForNamedSection(StringRef Name, SectionKind K) { 415 // N.B.: The defaults used in here are not the same ones used in MC. 416 // We follow gcc, MC follows gas. For example, given ".section .eh_frame", 417 // both gas and MC will produce a section with no flags. Given 418 // section(".eh_frame") gcc will produce: 419 // 420 // .section .eh_frame,"a",@progbits 421 422 if (Name == getInstrProfSectionName(IPSK_covmap, Triple::ELF, 423 /*AddSegmentInfo=*/false)) 424 return SectionKind::getMetadata(); 425 426 if (Name.empty() || Name[0] != '.') return K; 427 428 // Default implementation based on some magic section names. 429 if (Name == ".bss" || 430 Name.startswith(".bss.") || 431 Name.startswith(".gnu.linkonce.b.") || 432 Name.startswith(".llvm.linkonce.b.") || 433 Name == ".sbss" || 434 Name.startswith(".sbss.") || 435 Name.startswith(".gnu.linkonce.sb.") || 436 Name.startswith(".llvm.linkonce.sb.")) 437 return SectionKind::getBSS(); 438 439 if (Name == ".tdata" || 440 Name.startswith(".tdata.") || 441 Name.startswith(".gnu.linkonce.td.") || 442 Name.startswith(".llvm.linkonce.td.")) 443 return SectionKind::getThreadData(); 444 445 if (Name == ".tbss" || 446 Name.startswith(".tbss.") || 447 Name.startswith(".gnu.linkonce.tb.") || 448 Name.startswith(".llvm.linkonce.tb.")) 449 return SectionKind::getThreadBSS(); 450 451 return K; 452 } 453 454 static unsigned getELFSectionType(StringRef Name, SectionKind K) { 455 // Use SHT_NOTE for section whose name starts with ".note" to allow 456 // emitting ELF notes from C variable declaration. 457 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77609 458 if (Name.startswith(".note")) 459 return ELF::SHT_NOTE; 460 461 if (Name == ".init_array") 462 return ELF::SHT_INIT_ARRAY; 463 464 if (Name == ".fini_array") 465 return ELF::SHT_FINI_ARRAY; 466 467 if (Name == ".preinit_array") 468 return ELF::SHT_PREINIT_ARRAY; 469 470 if (K.isBSS() || K.isThreadBSS()) 471 return ELF::SHT_NOBITS; 472 473 return ELF::SHT_PROGBITS; 474 } 475 476 static unsigned getELFSectionFlags(SectionKind K) { 477 unsigned Flags = 0; 478 479 if (!K.isMetadata()) 480 Flags |= ELF::SHF_ALLOC; 481 482 if (K.isText()) 483 Flags |= ELF::SHF_EXECINSTR; 484 485 if (K.isExecuteOnly()) 486 Flags |= ELF::SHF_ARM_PURECODE; 487 488 if (K.isWriteable()) 489 Flags |= ELF::SHF_WRITE; 490 491 if (K.isThreadLocal()) 492 Flags |= ELF::SHF_TLS; 493 494 if (K.isMergeableCString() || K.isMergeableConst()) 495 Flags |= ELF::SHF_MERGE; 496 497 if (K.isMergeableCString()) 498 Flags |= ELF::SHF_STRINGS; 499 500 return Flags; 501 } 502 503 static const Comdat *getELFComdat(const GlobalValue *GV) { 504 const Comdat *C = GV->getComdat(); 505 if (!C) 506 return nullptr; 507 508 if (C->getSelectionKind() != Comdat::Any) 509 report_fatal_error("ELF COMDATs only support SelectionKind::Any, '" + 510 C->getName() + "' cannot be lowered."); 511 512 return C; 513 } 514 515 static const MCSymbolELF *getAssociatedSymbol(const GlobalObject *GO, 516 const TargetMachine &TM) { 517 MDNode *MD = GO->getMetadata(LLVMContext::MD_associated); 518 if (!MD) 519 return nullptr; 520 521 const MDOperand &Op = MD->getOperand(0); 522 if (!Op.get()) 523 return nullptr; 524 525 auto *VM = dyn_cast<ValueAsMetadata>(Op); 526 if (!VM) 527 report_fatal_error("MD_associated operand is not ValueAsMetadata"); 528 529 auto *OtherGV = dyn_cast<GlobalValue>(VM->getValue()); 530 return OtherGV ? dyn_cast<MCSymbolELF>(TM.getSymbol(OtherGV)) : nullptr; 531 } 532 533 static unsigned getEntrySizeForKind(SectionKind Kind) { 534 if (Kind.isMergeable1ByteCString()) 535 return 1; 536 else if (Kind.isMergeable2ByteCString()) 537 return 2; 538 else if (Kind.isMergeable4ByteCString()) 539 return 4; 540 else if (Kind.isMergeableConst4()) 541 return 4; 542 else if (Kind.isMergeableConst8()) 543 return 8; 544 else if (Kind.isMergeableConst16()) 545 return 16; 546 else if (Kind.isMergeableConst32()) 547 return 32; 548 else { 549 // We shouldn't have mergeable C strings or mergeable constants that we 550 // didn't handle above. 551 assert(!Kind.isMergeableCString() && "unknown string width"); 552 assert(!Kind.isMergeableConst() && "unknown data width"); 553 return 0; 554 } 555 } 556 557 MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal( 558 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 559 StringRef SectionName = GO->getSection(); 560 561 // Check if '#pragma clang section' name is applicable. 562 // Note that pragma directive overrides -ffunction-section, -fdata-section 563 // and so section name is exactly as user specified and not uniqued. 564 const GlobalVariable *GV = dyn_cast<GlobalVariable>(GO); 565 if (GV && GV->hasImplicitSection()) { 566 auto Attrs = GV->getAttributes(); 567 if (Attrs.hasAttribute("bss-section") && Kind.isBSS()) { 568 SectionName = Attrs.getAttribute("bss-section").getValueAsString(); 569 } else if (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly()) { 570 SectionName = Attrs.getAttribute("rodata-section").getValueAsString(); 571 } else if (Attrs.hasAttribute("data-section") && Kind.isData()) { 572 SectionName = Attrs.getAttribute("data-section").getValueAsString(); 573 } 574 } 575 const Function *F = dyn_cast<Function>(GO); 576 if (F && F->hasFnAttribute("implicit-section-name")) { 577 SectionName = F->getFnAttribute("implicit-section-name").getValueAsString(); 578 } 579 580 // Infer section flags from the section name if we can. 581 Kind = getELFKindForNamedSection(SectionName, Kind); 582 583 StringRef Group = ""; 584 unsigned Flags = getELFSectionFlags(Kind); 585 if (const Comdat *C = getELFComdat(GO)) { 586 Group = C->getName(); 587 Flags |= ELF::SHF_GROUP; 588 } 589 590 // A section can have at most one associated section. Put each global with 591 // MD_associated in a unique section. 592 unsigned UniqueID = MCContext::GenericSectionID; 593 const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM); 594 if (AssociatedSymbol) { 595 UniqueID = NextUniqueID++; 596 Flags |= ELF::SHF_LINK_ORDER; 597 } 598 599 MCSectionELF *Section = getContext().getELFSection( 600 SectionName, getELFSectionType(SectionName, Kind), Flags, 601 getEntrySizeForKind(Kind), Group, UniqueID, AssociatedSymbol); 602 // Make sure that we did not get some other section with incompatible sh_link. 603 // This should not be possible due to UniqueID code above. 604 assert(Section->getAssociatedSymbol() == AssociatedSymbol && 605 "Associated symbol mismatch between sections"); 606 return Section; 607 } 608 609 /// Return the section prefix name used by options FunctionsSections and 610 /// DataSections. 611 static StringRef getSectionPrefixForGlobal(SectionKind Kind) { 612 if (Kind.isText()) 613 return ".text"; 614 if (Kind.isReadOnly()) 615 return ".rodata"; 616 if (Kind.isBSS()) 617 return ".bss"; 618 if (Kind.isThreadData()) 619 return ".tdata"; 620 if (Kind.isThreadBSS()) 621 return ".tbss"; 622 if (Kind.isData()) 623 return ".data"; 624 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 625 return ".data.rel.ro"; 626 } 627 628 static MCSectionELF *selectELFSectionForGlobal( 629 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, 630 const TargetMachine &TM, bool EmitUniqueSection, unsigned Flags, 631 unsigned *NextUniqueID, const MCSymbolELF *AssociatedSymbol) { 632 633 StringRef Group = ""; 634 if (const Comdat *C = getELFComdat(GO)) { 635 Flags |= ELF::SHF_GROUP; 636 Group = C->getName(); 637 } 638 639 // Get the section entry size based on the kind. 640 unsigned EntrySize = getEntrySizeForKind(Kind); 641 642 SmallString<128> Name; 643 if (Kind.isMergeableCString()) { 644 // We also need alignment here. 645 // FIXME: this is getting the alignment of the character, not the 646 // alignment of the global! 647 unsigned Align = GO->getParent()->getDataLayout().getPreferredAlignment( 648 cast<GlobalVariable>(GO)); 649 650 std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + "."; 651 Name = SizeSpec + utostr(Align); 652 } else if (Kind.isMergeableConst()) { 653 Name = ".rodata.cst"; 654 Name += utostr(EntrySize); 655 } else { 656 Name = getSectionPrefixForGlobal(Kind); 657 } 658 659 if (const auto *F = dyn_cast<Function>(GO)) { 660 const auto &OptionalPrefix = F->getSectionPrefix(); 661 if (OptionalPrefix) 662 Name += *OptionalPrefix; 663 } 664 665 unsigned UniqueID = MCContext::GenericSectionID; 666 if (EmitUniqueSection) { 667 if (TM.getUniqueSectionNames()) { 668 Name.push_back('.'); 669 TM.getNameWithPrefix(Name, GO, Mang, true /*MayAlwaysUsePrivate*/); 670 } else { 671 UniqueID = *NextUniqueID; 672 (*NextUniqueID)++; 673 } 674 } 675 // Use 0 as the unique ID for execute-only text. 676 if (Kind.isExecuteOnly()) 677 UniqueID = 0; 678 return Ctx.getELFSection(Name, getELFSectionType(Name, Kind), Flags, 679 EntrySize, Group, UniqueID, AssociatedSymbol); 680 } 681 682 MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal( 683 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 684 unsigned Flags = getELFSectionFlags(Kind); 685 686 // If we have -ffunction-section or -fdata-section then we should emit the 687 // global value to a uniqued section specifically for it. 688 bool EmitUniqueSection = false; 689 if (!(Flags & ELF::SHF_MERGE) && !Kind.isCommon()) { 690 if (Kind.isText()) 691 EmitUniqueSection = TM.getFunctionSections(); 692 else 693 EmitUniqueSection = TM.getDataSections(); 694 } 695 EmitUniqueSection |= GO->hasComdat(); 696 697 const MCSymbolELF *AssociatedSymbol = getAssociatedSymbol(GO, TM); 698 if (AssociatedSymbol) { 699 EmitUniqueSection = true; 700 Flags |= ELF::SHF_LINK_ORDER; 701 } 702 703 MCSectionELF *Section = selectELFSectionForGlobal( 704 getContext(), GO, Kind, getMangler(), TM, EmitUniqueSection, Flags, 705 &NextUniqueID, AssociatedSymbol); 706 assert(Section->getAssociatedSymbol() == AssociatedSymbol); 707 return Section; 708 } 709 710 MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable( 711 const Function &F, const TargetMachine &TM) const { 712 // If the function can be removed, produce a unique section so that 713 // the table doesn't prevent the removal. 714 const Comdat *C = F.getComdat(); 715 bool EmitUniqueSection = TM.getFunctionSections() || C; 716 if (!EmitUniqueSection) 717 return ReadOnlySection; 718 719 return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(), 720 getMangler(), TM, EmitUniqueSection, 721 ELF::SHF_ALLOC, &NextUniqueID, 722 /* AssociatedSymbol */ nullptr); 723 } 724 725 bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection( 726 bool UsesLabelDifference, const Function &F) const { 727 // We can always create relative relocations, so use another section 728 // that can be marked non-executable. 729 return false; 730 } 731 732 /// Given a mergeable constant with the specified size and relocation 733 /// information, return a section that it should be placed in. 734 MCSection *TargetLoweringObjectFileELF::getSectionForConstant( 735 const DataLayout &DL, SectionKind Kind, const Constant *C, 736 unsigned &Align) const { 737 if (Kind.isMergeableConst4() && MergeableConst4Section) 738 return MergeableConst4Section; 739 if (Kind.isMergeableConst8() && MergeableConst8Section) 740 return MergeableConst8Section; 741 if (Kind.isMergeableConst16() && MergeableConst16Section) 742 return MergeableConst16Section; 743 if (Kind.isMergeableConst32() && MergeableConst32Section) 744 return MergeableConst32Section; 745 if (Kind.isReadOnly()) 746 return ReadOnlySection; 747 748 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 749 return DataRelROSection; 750 } 751 752 static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray, 753 bool IsCtor, unsigned Priority, 754 const MCSymbol *KeySym) { 755 std::string Name; 756 unsigned Type; 757 unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE; 758 StringRef COMDAT = KeySym ? KeySym->getName() : ""; 759 760 if (KeySym) 761 Flags |= ELF::SHF_GROUP; 762 763 if (UseInitArray) { 764 if (IsCtor) { 765 Type = ELF::SHT_INIT_ARRAY; 766 Name = ".init_array"; 767 } else { 768 Type = ELF::SHT_FINI_ARRAY; 769 Name = ".fini_array"; 770 } 771 if (Priority != 65535) { 772 Name += '.'; 773 Name += utostr(Priority); 774 } 775 } else { 776 // The default scheme is .ctor / .dtor, so we have to invert the priority 777 // numbering. 778 if (IsCtor) 779 Name = ".ctors"; 780 else 781 Name = ".dtors"; 782 if (Priority != 65535) 783 raw_string_ostream(Name) << format(".%05u", 65535 - Priority); 784 Type = ELF::SHT_PROGBITS; 785 } 786 787 return Ctx.getELFSection(Name, Type, Flags, 0, COMDAT); 788 } 789 790 MCSection *TargetLoweringObjectFileELF::getStaticCtorSection( 791 unsigned Priority, const MCSymbol *KeySym) const { 792 return getStaticStructorSection(getContext(), UseInitArray, true, Priority, 793 KeySym); 794 } 795 796 MCSection *TargetLoweringObjectFileELF::getStaticDtorSection( 797 unsigned Priority, const MCSymbol *KeySym) const { 798 return getStaticStructorSection(getContext(), UseInitArray, false, Priority, 799 KeySym); 800 } 801 802 const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference( 803 const GlobalValue *LHS, const GlobalValue *RHS, 804 const TargetMachine &TM) const { 805 // We may only use a PLT-relative relocation to refer to unnamed_addr 806 // functions. 807 if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy()) 808 return nullptr; 809 810 // Basic sanity checks. 811 if (LHS->getType()->getPointerAddressSpace() != 0 || 812 RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() || 813 RHS->isThreadLocal()) 814 return nullptr; 815 816 return MCBinaryExpr::createSub( 817 MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeVariantKind, 818 getContext()), 819 MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext()); 820 } 821 822 MCSection *TargetLoweringObjectFileELF::getSectionForCommandLines() const { 823 // Use ".GCC.command.line" since this feature is to support clang's 824 // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the 825 // same name. 826 return getContext().getELFSection(".GCC.command.line", ELF::SHT_PROGBITS, 827 ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, ""); 828 } 829 830 void 831 TargetLoweringObjectFileELF::InitializeELF(bool UseInitArray_) { 832 UseInitArray = UseInitArray_; 833 MCContext &Ctx = getContext(); 834 if (!UseInitArray) { 835 StaticCtorSection = Ctx.getELFSection(".ctors", ELF::SHT_PROGBITS, 836 ELF::SHF_ALLOC | ELF::SHF_WRITE); 837 838 StaticDtorSection = Ctx.getELFSection(".dtors", ELF::SHT_PROGBITS, 839 ELF::SHF_ALLOC | ELF::SHF_WRITE); 840 return; 841 } 842 843 StaticCtorSection = Ctx.getELFSection(".init_array", ELF::SHT_INIT_ARRAY, 844 ELF::SHF_WRITE | ELF::SHF_ALLOC); 845 StaticDtorSection = Ctx.getELFSection(".fini_array", ELF::SHT_FINI_ARRAY, 846 ELF::SHF_WRITE | ELF::SHF_ALLOC); 847 } 848 849 //===----------------------------------------------------------------------===// 850 // MachO 851 //===----------------------------------------------------------------------===// 852 853 TargetLoweringObjectFileMachO::TargetLoweringObjectFileMachO() 854 : TargetLoweringObjectFile() { 855 SupportIndirectSymViaGOTPCRel = true; 856 } 857 858 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx, 859 const TargetMachine &TM) { 860 TargetLoweringObjectFile::Initialize(Ctx, TM); 861 if (TM.getRelocationModel() == Reloc::Static) { 862 StaticCtorSection = Ctx.getMachOSection("__TEXT", "__constructor", 0, 863 SectionKind::getData()); 864 StaticDtorSection = Ctx.getMachOSection("__TEXT", "__destructor", 0, 865 SectionKind::getData()); 866 } else { 867 StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func", 868 MachO::S_MOD_INIT_FUNC_POINTERS, 869 SectionKind::getData()); 870 StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func", 871 MachO::S_MOD_TERM_FUNC_POINTERS, 872 SectionKind::getData()); 873 } 874 875 PersonalityEncoding = 876 dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 877 LSDAEncoding = dwarf::DW_EH_PE_pcrel; 878 TTypeEncoding = 879 dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4; 880 } 881 882 void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer, 883 Module &M) const { 884 // Emit the linker options if present. 885 if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) { 886 for (const auto &Option : LinkerOptions->operands()) { 887 SmallVector<std::string, 4> StrOptions; 888 for (const auto &Piece : cast<MDNode>(Option)->operands()) 889 StrOptions.push_back(cast<MDString>(Piece)->getString()); 890 Streamer.EmitLinkerOptions(StrOptions); 891 } 892 } 893 894 unsigned VersionVal = 0; 895 unsigned ImageInfoFlags = 0; 896 StringRef SectionVal; 897 898 GetObjCImageInfo(M, VersionVal, ImageInfoFlags, SectionVal); 899 900 // The section is mandatory. If we don't have it, then we don't have GC info. 901 if (SectionVal.empty()) 902 return; 903 904 StringRef Segment, Section; 905 unsigned TAA = 0, StubSize = 0; 906 bool TAAParsed; 907 std::string ErrorCode = 908 MCSectionMachO::ParseSectionSpecifier(SectionVal, Segment, Section, 909 TAA, TAAParsed, StubSize); 910 if (!ErrorCode.empty()) 911 // If invalid, report the error with report_fatal_error. 912 report_fatal_error("Invalid section specifier '" + Section + "': " + 913 ErrorCode + "."); 914 915 // Get the section. 916 MCSectionMachO *S = getContext().getMachOSection( 917 Segment, Section, TAA, StubSize, SectionKind::getData()); 918 Streamer.SwitchSection(S); 919 Streamer.EmitLabel(getContext(). 920 getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO"))); 921 Streamer.EmitIntValue(VersionVal, 4); 922 Streamer.EmitIntValue(ImageInfoFlags, 4); 923 Streamer.AddBlankLine(); 924 } 925 926 static void checkMachOComdat(const GlobalValue *GV) { 927 const Comdat *C = GV->getComdat(); 928 if (!C) 929 return; 930 931 report_fatal_error("MachO doesn't support COMDATs, '" + C->getName() + 932 "' cannot be lowered."); 933 } 934 935 MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal( 936 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 937 // Parse the section specifier and create it if valid. 938 StringRef Segment, Section; 939 unsigned TAA = 0, StubSize = 0; 940 bool TAAParsed; 941 942 checkMachOComdat(GO); 943 944 std::string ErrorCode = 945 MCSectionMachO::ParseSectionSpecifier(GO->getSection(), Segment, Section, 946 TAA, TAAParsed, StubSize); 947 if (!ErrorCode.empty()) { 948 // If invalid, report the error with report_fatal_error. 949 report_fatal_error("Global variable '" + GO->getName() + 950 "' has an invalid section specifier '" + 951 GO->getSection() + "': " + ErrorCode + "."); 952 } 953 954 // Get the section. 955 MCSectionMachO *S = 956 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind); 957 958 // If TAA wasn't set by ParseSectionSpecifier() above, 959 // use the value returned by getMachOSection() as a default. 960 if (!TAAParsed) 961 TAA = S->getTypeAndAttributes(); 962 963 // Okay, now that we got the section, verify that the TAA & StubSize agree. 964 // If the user declared multiple globals with different section flags, we need 965 // to reject it here. 966 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) { 967 // If invalid, report the error with report_fatal_error. 968 report_fatal_error("Global variable '" + GO->getName() + 969 "' section type or attributes does not match previous" 970 " section specifier"); 971 } 972 973 return S; 974 } 975 976 MCSection *TargetLoweringObjectFileMachO::SelectSectionForGlobal( 977 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 978 checkMachOComdat(GO); 979 980 // Handle thread local data. 981 if (Kind.isThreadBSS()) return TLSBSSSection; 982 if (Kind.isThreadData()) return TLSDataSection; 983 984 if (Kind.isText()) 985 return GO->isWeakForLinker() ? TextCoalSection : TextSection; 986 987 // If this is weak/linkonce, put this in a coalescable section, either in text 988 // or data depending on if it is writable. 989 if (GO->isWeakForLinker()) { 990 if (Kind.isReadOnly()) 991 return ConstTextCoalSection; 992 if (Kind.isReadOnlyWithRel()) 993 return ConstDataCoalSection; 994 return DataCoalSection; 995 } 996 997 // FIXME: Alignment check should be handled by section classifier. 998 if (Kind.isMergeable1ByteCString() && 999 GO->getParent()->getDataLayout().getPreferredAlignment( 1000 cast<GlobalVariable>(GO)) < 32) 1001 return CStringSection; 1002 1003 // Do not put 16-bit arrays in the UString section if they have an 1004 // externally visible label, this runs into issues with certain linker 1005 // versions. 1006 if (Kind.isMergeable2ByteCString() && !GO->hasExternalLinkage() && 1007 GO->getParent()->getDataLayout().getPreferredAlignment( 1008 cast<GlobalVariable>(GO)) < 32) 1009 return UStringSection; 1010 1011 // With MachO only variables whose corresponding symbol starts with 'l' or 1012 // 'L' can be merged, so we only try merging GVs with private linkage. 1013 if (GO->hasPrivateLinkage() && Kind.isMergeableConst()) { 1014 if (Kind.isMergeableConst4()) 1015 return FourByteConstantSection; 1016 if (Kind.isMergeableConst8()) 1017 return EightByteConstantSection; 1018 if (Kind.isMergeableConst16()) 1019 return SixteenByteConstantSection; 1020 } 1021 1022 // Otherwise, if it is readonly, but not something we can specially optimize, 1023 // just drop it in .const. 1024 if (Kind.isReadOnly()) 1025 return ReadOnlySection; 1026 1027 // If this is marked const, put it into a const section. But if the dynamic 1028 // linker needs to write to it, put it in the data segment. 1029 if (Kind.isReadOnlyWithRel()) 1030 return ConstDataSection; 1031 1032 // Put zero initialized globals with strong external linkage in the 1033 // DATA, __common section with the .zerofill directive. 1034 if (Kind.isBSSExtern()) 1035 return DataCommonSection; 1036 1037 // Put zero initialized globals with local linkage in __DATA,__bss directive 1038 // with the .zerofill directive (aka .lcomm). 1039 if (Kind.isBSSLocal()) 1040 return DataBSSSection; 1041 1042 // Otherwise, just drop the variable in the normal data section. 1043 return DataSection; 1044 } 1045 1046 MCSection *TargetLoweringObjectFileMachO::getSectionForConstant( 1047 const DataLayout &DL, SectionKind Kind, const Constant *C, 1048 unsigned &Align) const { 1049 // If this constant requires a relocation, we have to put it in the data 1050 // segment, not in the text segment. 1051 if (Kind.isData() || Kind.isReadOnlyWithRel()) 1052 return ConstDataSection; 1053 1054 if (Kind.isMergeableConst4()) 1055 return FourByteConstantSection; 1056 if (Kind.isMergeableConst8()) 1057 return EightByteConstantSection; 1058 if (Kind.isMergeableConst16()) 1059 return SixteenByteConstantSection; 1060 return ReadOnlySection; // .const 1061 } 1062 1063 const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference( 1064 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, 1065 MachineModuleInfo *MMI, MCStreamer &Streamer) const { 1066 // The mach-o version of this method defaults to returning a stub reference. 1067 1068 if (Encoding & DW_EH_PE_indirect) { 1069 MachineModuleInfoMachO &MachOMMI = 1070 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 1071 1072 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM); 1073 1074 // Add information about the stub reference to MachOMMI so that the stub 1075 // gets emitted by the asmprinter. 1076 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym); 1077 if (!StubSym.getPointer()) { 1078 MCSymbol *Sym = TM.getSymbol(GV); 1079 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 1080 } 1081 1082 return TargetLoweringObjectFile:: 1083 getTTypeReference(MCSymbolRefExpr::create(SSym, getContext()), 1084 Encoding & ~DW_EH_PE_indirect, Streamer); 1085 } 1086 1087 return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM, 1088 MMI, Streamer); 1089 } 1090 1091 MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol( 1092 const GlobalValue *GV, const TargetMachine &TM, 1093 MachineModuleInfo *MMI) const { 1094 // The mach-o version of this method defaults to returning a stub reference. 1095 MachineModuleInfoMachO &MachOMMI = 1096 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 1097 1098 MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM); 1099 1100 // Add information about the stub reference to MachOMMI so that the stub 1101 // gets emitted by the asmprinter. 1102 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym); 1103 if (!StubSym.getPointer()) { 1104 MCSymbol *Sym = TM.getSymbol(GV); 1105 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 1106 } 1107 1108 return SSym; 1109 } 1110 1111 const MCExpr *TargetLoweringObjectFileMachO::getIndirectSymViaGOTPCRel( 1112 const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV, 1113 int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const { 1114 // Although MachO 32-bit targets do not explicitly have a GOTPCREL relocation 1115 // as 64-bit do, we replace the GOT equivalent by accessing the final symbol 1116 // through a non_lazy_ptr stub instead. One advantage is that it allows the 1117 // computation of deltas to final external symbols. Example: 1118 // 1119 // _extgotequiv: 1120 // .long _extfoo 1121 // 1122 // _delta: 1123 // .long _extgotequiv-_delta 1124 // 1125 // is transformed to: 1126 // 1127 // _delta: 1128 // .long L_extfoo$non_lazy_ptr-(_delta+0) 1129 // 1130 // .section __IMPORT,__pointers,non_lazy_symbol_pointers 1131 // L_extfoo$non_lazy_ptr: 1132 // .indirect_symbol _extfoo 1133 // .long 0 1134 // 1135 // The indirect symbol table (and sections of non_lazy_symbol_pointers type) 1136 // may point to both local (same translation unit) and global (other 1137 // translation units) symbols. Example: 1138 // 1139 // .section __DATA,__pointers,non_lazy_symbol_pointers 1140 // L1: 1141 // .indirect_symbol _myGlobal 1142 // .long 0 1143 // L2: 1144 // .indirect_symbol _myLocal 1145 // .long _myLocal 1146 // 1147 // If the symbol is local, instead of the symbol's index, the assembler 1148 // places the constant INDIRECT_SYMBOL_LOCAL into the indirect symbol table. 1149 // Then the linker will notice the constant in the table and will look at the 1150 // content of the symbol. 1151 MachineModuleInfoMachO &MachOMMI = 1152 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 1153 MCContext &Ctx = getContext(); 1154 1155 // The offset must consider the original displacement from the base symbol 1156 // since 32-bit targets don't have a GOTPCREL to fold the PC displacement. 1157 Offset = -MV.getConstant(); 1158 const MCSymbol *BaseSym = &MV.getSymB()->getSymbol(); 1159 1160 // Access the final symbol via sym$non_lazy_ptr and generate the appropriated 1161 // non_lazy_ptr stubs. 1162 SmallString<128> Name; 1163 StringRef Suffix = "$non_lazy_ptr"; 1164 Name += MMI->getModule()->getDataLayout().getPrivateGlobalPrefix(); 1165 Name += Sym->getName(); 1166 Name += Suffix; 1167 MCSymbol *Stub = Ctx.getOrCreateSymbol(Name); 1168 1169 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(Stub); 1170 1171 if (!StubSym.getPointer()) 1172 StubSym = MachineModuleInfoImpl::StubValueTy(const_cast<MCSymbol *>(Sym), 1173 !GV->hasLocalLinkage()); 1174 1175 const MCExpr *BSymExpr = 1176 MCSymbolRefExpr::create(BaseSym, MCSymbolRefExpr::VK_None, Ctx); 1177 const MCExpr *LHS = 1178 MCSymbolRefExpr::create(Stub, MCSymbolRefExpr::VK_None, Ctx); 1179 1180 if (!Offset) 1181 return MCBinaryExpr::createSub(LHS, BSymExpr, Ctx); 1182 1183 const MCExpr *RHS = 1184 MCBinaryExpr::createAdd(BSymExpr, MCConstantExpr::create(Offset, Ctx), Ctx); 1185 return MCBinaryExpr::createSub(LHS, RHS, Ctx); 1186 } 1187 1188 static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo, 1189 const MCSection &Section) { 1190 if (!AsmInfo.isSectionAtomizableBySymbols(Section)) 1191 return true; 1192 1193 // If it is not dead stripped, it is safe to use private labels. 1194 const MCSectionMachO &SMO = cast<MCSectionMachO>(Section); 1195 if (SMO.hasAttribute(MachO::S_ATTR_NO_DEAD_STRIP)) 1196 return true; 1197 1198 return false; 1199 } 1200 1201 void TargetLoweringObjectFileMachO::getNameWithPrefix( 1202 SmallVectorImpl<char> &OutName, const GlobalValue *GV, 1203 const TargetMachine &TM) const { 1204 bool CannotUsePrivateLabel = true; 1205 if (auto *GO = GV->getBaseObject()) { 1206 SectionKind GOKind = TargetLoweringObjectFile::getKindForGlobal(GO, TM); 1207 const MCSection *TheSection = SectionForGlobal(GO, GOKind, TM); 1208 CannotUsePrivateLabel = 1209 !canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection); 1210 } 1211 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel); 1212 } 1213 1214 //===----------------------------------------------------------------------===// 1215 // COFF 1216 //===----------------------------------------------------------------------===// 1217 1218 static unsigned 1219 getCOFFSectionFlags(SectionKind K, const TargetMachine &TM) { 1220 unsigned Flags = 0; 1221 bool isThumb = TM.getTargetTriple().getArch() == Triple::thumb; 1222 1223 if (K.isMetadata()) 1224 Flags |= 1225 COFF::IMAGE_SCN_MEM_DISCARDABLE; 1226 else if (K.isText()) 1227 Flags |= 1228 COFF::IMAGE_SCN_MEM_EXECUTE | 1229 COFF::IMAGE_SCN_MEM_READ | 1230 COFF::IMAGE_SCN_CNT_CODE | 1231 (isThumb ? COFF::IMAGE_SCN_MEM_16BIT : (COFF::SectionCharacteristics)0); 1232 else if (K.isBSS()) 1233 Flags |= 1234 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA | 1235 COFF::IMAGE_SCN_MEM_READ | 1236 COFF::IMAGE_SCN_MEM_WRITE; 1237 else if (K.isThreadLocal()) 1238 Flags |= 1239 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1240 COFF::IMAGE_SCN_MEM_READ | 1241 COFF::IMAGE_SCN_MEM_WRITE; 1242 else if (K.isReadOnly() || K.isReadOnlyWithRel()) 1243 Flags |= 1244 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1245 COFF::IMAGE_SCN_MEM_READ; 1246 else if (K.isWriteable()) 1247 Flags |= 1248 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1249 COFF::IMAGE_SCN_MEM_READ | 1250 COFF::IMAGE_SCN_MEM_WRITE; 1251 1252 return Flags; 1253 } 1254 1255 static const GlobalValue *getComdatGVForCOFF(const GlobalValue *GV) { 1256 const Comdat *C = GV->getComdat(); 1257 assert(C && "expected GV to have a Comdat!"); 1258 1259 StringRef ComdatGVName = C->getName(); 1260 const GlobalValue *ComdatGV = GV->getParent()->getNamedValue(ComdatGVName); 1261 if (!ComdatGV) 1262 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName + 1263 "' does not exist."); 1264 1265 if (ComdatGV->getComdat() != C) 1266 report_fatal_error("Associative COMDAT symbol '" + ComdatGVName + 1267 "' is not a key for its COMDAT."); 1268 1269 return ComdatGV; 1270 } 1271 1272 static int getSelectionForCOFF(const GlobalValue *GV) { 1273 if (const Comdat *C = GV->getComdat()) { 1274 const GlobalValue *ComdatKey = getComdatGVForCOFF(GV); 1275 if (const auto *GA = dyn_cast<GlobalAlias>(ComdatKey)) 1276 ComdatKey = GA->getBaseObject(); 1277 if (ComdatKey == GV) { 1278 switch (C->getSelectionKind()) { 1279 case Comdat::Any: 1280 return COFF::IMAGE_COMDAT_SELECT_ANY; 1281 case Comdat::ExactMatch: 1282 return COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH; 1283 case Comdat::Largest: 1284 return COFF::IMAGE_COMDAT_SELECT_LARGEST; 1285 case Comdat::NoDuplicates: 1286 return COFF::IMAGE_COMDAT_SELECT_NODUPLICATES; 1287 case Comdat::SameSize: 1288 return COFF::IMAGE_COMDAT_SELECT_SAME_SIZE; 1289 } 1290 } else { 1291 return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE; 1292 } 1293 } 1294 return 0; 1295 } 1296 1297 MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal( 1298 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 1299 int Selection = 0; 1300 unsigned Characteristics = getCOFFSectionFlags(Kind, TM); 1301 StringRef Name = GO->getSection(); 1302 StringRef COMDATSymName = ""; 1303 if (GO->hasComdat()) { 1304 Selection = getSelectionForCOFF(GO); 1305 const GlobalValue *ComdatGV; 1306 if (Selection == COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) 1307 ComdatGV = getComdatGVForCOFF(GO); 1308 else 1309 ComdatGV = GO; 1310 1311 if (!ComdatGV->hasPrivateLinkage()) { 1312 MCSymbol *Sym = TM.getSymbol(ComdatGV); 1313 COMDATSymName = Sym->getName(); 1314 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 1315 } else { 1316 Selection = 0; 1317 } 1318 } 1319 1320 return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName, 1321 Selection); 1322 } 1323 1324 static StringRef getCOFFSectionNameForUniqueGlobal(SectionKind Kind) { 1325 if (Kind.isText()) 1326 return ".text"; 1327 if (Kind.isBSS()) 1328 return ".bss"; 1329 if (Kind.isThreadLocal()) 1330 return ".tls$"; 1331 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel()) 1332 return ".rdata"; 1333 return ".data"; 1334 } 1335 1336 MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal( 1337 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 1338 // If we have -ffunction-sections then we should emit the global value to a 1339 // uniqued section specifically for it. 1340 bool EmitUniquedSection; 1341 if (Kind.isText()) 1342 EmitUniquedSection = TM.getFunctionSections(); 1343 else 1344 EmitUniquedSection = TM.getDataSections(); 1345 1346 if ((EmitUniquedSection && !Kind.isCommon()) || GO->hasComdat()) { 1347 SmallString<256> Name = getCOFFSectionNameForUniqueGlobal(Kind); 1348 1349 unsigned Characteristics = getCOFFSectionFlags(Kind, TM); 1350 1351 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 1352 int Selection = getSelectionForCOFF(GO); 1353 if (!Selection) 1354 Selection = COFF::IMAGE_COMDAT_SELECT_NODUPLICATES; 1355 const GlobalValue *ComdatGV; 1356 if (GO->hasComdat()) 1357 ComdatGV = getComdatGVForCOFF(GO); 1358 else 1359 ComdatGV = GO; 1360 1361 unsigned UniqueID = MCContext::GenericSectionID; 1362 if (EmitUniquedSection) 1363 UniqueID = NextUniqueID++; 1364 1365 if (!ComdatGV->hasPrivateLinkage()) { 1366 MCSymbol *Sym = TM.getSymbol(ComdatGV); 1367 StringRef COMDATSymName = Sym->getName(); 1368 1369 // Append "$symbol" to the section name *before* IR-level mangling is 1370 // applied when targetting mingw. This is what GCC does, and the ld.bfd 1371 // COFF linker will not properly handle comdats otherwise. 1372 if (getTargetTriple().isWindowsGNUEnvironment()) 1373 raw_svector_ostream(Name) << '$' << ComdatGV->getName(); 1374 1375 return getContext().getCOFFSection(Name, Characteristics, Kind, 1376 COMDATSymName, Selection, UniqueID); 1377 } else { 1378 SmallString<256> TmpData; 1379 getMangler().getNameWithPrefix(TmpData, GO, /*CannotUsePrivateLabel=*/true); 1380 return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData, 1381 Selection, UniqueID); 1382 } 1383 } 1384 1385 if (Kind.isText()) 1386 return TextSection; 1387 1388 if (Kind.isThreadLocal()) 1389 return TLSDataSection; 1390 1391 if (Kind.isReadOnly() || Kind.isReadOnlyWithRel()) 1392 return ReadOnlySection; 1393 1394 // Note: we claim that common symbols are put in BSSSection, but they are 1395 // really emitted with the magic .comm directive, which creates a symbol table 1396 // entry but not a section. 1397 if (Kind.isBSS() || Kind.isCommon()) 1398 return BSSSection; 1399 1400 return DataSection; 1401 } 1402 1403 void TargetLoweringObjectFileCOFF::getNameWithPrefix( 1404 SmallVectorImpl<char> &OutName, const GlobalValue *GV, 1405 const TargetMachine &TM) const { 1406 bool CannotUsePrivateLabel = false; 1407 if (GV->hasPrivateLinkage() && 1408 ((isa<Function>(GV) && TM.getFunctionSections()) || 1409 (isa<GlobalVariable>(GV) && TM.getDataSections()))) 1410 CannotUsePrivateLabel = true; 1411 1412 getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel); 1413 } 1414 1415 MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable( 1416 const Function &F, const TargetMachine &TM) const { 1417 // If the function can be removed, produce a unique section so that 1418 // the table doesn't prevent the removal. 1419 const Comdat *C = F.getComdat(); 1420 bool EmitUniqueSection = TM.getFunctionSections() || C; 1421 if (!EmitUniqueSection) 1422 return ReadOnlySection; 1423 1424 // FIXME: we should produce a symbol for F instead. 1425 if (F.hasPrivateLinkage()) 1426 return ReadOnlySection; 1427 1428 MCSymbol *Sym = TM.getSymbol(&F); 1429 StringRef COMDATSymName = Sym->getName(); 1430 1431 SectionKind Kind = SectionKind::getReadOnly(); 1432 StringRef SecName = getCOFFSectionNameForUniqueGlobal(Kind); 1433 unsigned Characteristics = getCOFFSectionFlags(Kind, TM); 1434 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 1435 unsigned UniqueID = NextUniqueID++; 1436 1437 return getContext().getCOFFSection( 1438 SecName, Characteristics, Kind, COMDATSymName, 1439 COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID); 1440 } 1441 1442 void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer, 1443 Module &M) const { 1444 if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) { 1445 // Emit the linker options to the linker .drectve section. According to the 1446 // spec, this section is a space-separated string containing flags for 1447 // linker. 1448 MCSection *Sec = getDrectveSection(); 1449 Streamer.SwitchSection(Sec); 1450 for (const auto &Option : LinkerOptions->operands()) { 1451 for (const auto &Piece : cast<MDNode>(Option)->operands()) { 1452 // Lead with a space for consistency with our dllexport implementation. 1453 std::string Directive(" "); 1454 Directive.append(cast<MDString>(Piece)->getString()); 1455 Streamer.EmitBytes(Directive); 1456 } 1457 } 1458 } 1459 1460 unsigned Version = 0; 1461 unsigned Flags = 0; 1462 StringRef Section; 1463 1464 GetObjCImageInfo(M, Version, Flags, Section); 1465 if (Section.empty()) 1466 return; 1467 1468 auto &C = getContext(); 1469 auto *S = C.getCOFFSection( 1470 Section, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ, 1471 SectionKind::getReadOnly()); 1472 Streamer.SwitchSection(S); 1473 Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO"))); 1474 Streamer.EmitIntValue(Version, 4); 1475 Streamer.EmitIntValue(Flags, 4); 1476 Streamer.AddBlankLine(); 1477 } 1478 1479 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx, 1480 const TargetMachine &TM) { 1481 TargetLoweringObjectFile::Initialize(Ctx, TM); 1482 const Triple &T = TM.getTargetTriple(); 1483 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) { 1484 StaticCtorSection = 1485 Ctx.getCOFFSection(".CRT$XCU", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1486 COFF::IMAGE_SCN_MEM_READ, 1487 SectionKind::getReadOnly()); 1488 StaticDtorSection = 1489 Ctx.getCOFFSection(".CRT$XTX", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1490 COFF::IMAGE_SCN_MEM_READ, 1491 SectionKind::getReadOnly()); 1492 } else { 1493 StaticCtorSection = Ctx.getCOFFSection( 1494 ".ctors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1495 COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE, 1496 SectionKind::getData()); 1497 StaticDtorSection = Ctx.getCOFFSection( 1498 ".dtors", COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1499 COFF::IMAGE_SCN_MEM_READ | COFF::IMAGE_SCN_MEM_WRITE, 1500 SectionKind::getData()); 1501 } 1502 } 1503 1504 static MCSectionCOFF *getCOFFStaticStructorSection(MCContext &Ctx, 1505 const Triple &T, bool IsCtor, 1506 unsigned Priority, 1507 const MCSymbol *KeySym, 1508 MCSectionCOFF *Default) { 1509 if (T.isWindowsMSVCEnvironment() || T.isWindowsItaniumEnvironment()) { 1510 // If the priority is the default, use .CRT$XCU, possibly associative. 1511 if (Priority == 65535) 1512 return Ctx.getAssociativeCOFFSection(Default, KeySym, 0); 1513 1514 // Otherwise, we need to compute a new section name. Low priorities should 1515 // run earlier. The linker will sort sections ASCII-betically, and we need a 1516 // string that sorts between .CRT$XCA and .CRT$XCU. In the general case, we 1517 // make a name like ".CRT$XCT12345", since that runs before .CRT$XCU. Really 1518 // low priorities need to sort before 'L', since the CRT uses that 1519 // internally, so we use ".CRT$XCA00001" for them. 1520 SmallString<24> Name; 1521 raw_svector_ostream OS(Name); 1522 OS << ".CRT$X" << (IsCtor ? "C" : "T") << 1523 (Priority < 200 ? 'A' : 'T') << format("%05u", Priority); 1524 MCSectionCOFF *Sec = Ctx.getCOFFSection( 1525 Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ, 1526 SectionKind::getReadOnly()); 1527 return Ctx.getAssociativeCOFFSection(Sec, KeySym, 0); 1528 } 1529 1530 std::string Name = IsCtor ? ".ctors" : ".dtors"; 1531 if (Priority != 65535) 1532 raw_string_ostream(Name) << format(".%05u", 65535 - Priority); 1533 1534 return Ctx.getAssociativeCOFFSection( 1535 Ctx.getCOFFSection(Name, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1536 COFF::IMAGE_SCN_MEM_READ | 1537 COFF::IMAGE_SCN_MEM_WRITE, 1538 SectionKind::getData()), 1539 KeySym, 0); 1540 } 1541 1542 MCSection *TargetLoweringObjectFileCOFF::getStaticCtorSection( 1543 unsigned Priority, const MCSymbol *KeySym) const { 1544 return getCOFFStaticStructorSection(getContext(), getTargetTriple(), true, 1545 Priority, KeySym, 1546 cast<MCSectionCOFF>(StaticCtorSection)); 1547 } 1548 1549 MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection( 1550 unsigned Priority, const MCSymbol *KeySym) const { 1551 return getCOFFStaticStructorSection(getContext(), getTargetTriple(), false, 1552 Priority, KeySym, 1553 cast<MCSectionCOFF>(StaticDtorSection)); 1554 } 1555 1556 void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal( 1557 raw_ostream &OS, const GlobalValue *GV) const { 1558 emitLinkerFlagsForGlobalCOFF(OS, GV, getTargetTriple(), getMangler()); 1559 } 1560 1561 void TargetLoweringObjectFileCOFF::emitLinkerFlagsForUsed( 1562 raw_ostream &OS, const GlobalValue *GV) const { 1563 emitLinkerFlagsForUsedCOFF(OS, GV, getTargetTriple(), getMangler()); 1564 } 1565 1566 const MCExpr *TargetLoweringObjectFileCOFF::lowerRelativeReference( 1567 const GlobalValue *LHS, const GlobalValue *RHS, 1568 const TargetMachine &TM) const { 1569 const Triple &T = TM.getTargetTriple(); 1570 if (T.isOSCygMing()) 1571 return nullptr; 1572 1573 // Our symbols should exist in address space zero, cowardly no-op if 1574 // otherwise. 1575 if (LHS->getType()->getPointerAddressSpace() != 0 || 1576 RHS->getType()->getPointerAddressSpace() != 0) 1577 return nullptr; 1578 1579 // Both ptrtoint instructions must wrap global objects: 1580 // - Only global variables are eligible for image relative relocations. 1581 // - The subtrahend refers to the special symbol __ImageBase, a GlobalVariable. 1582 // We expect __ImageBase to be a global variable without a section, externally 1583 // defined. 1584 // 1585 // It should look something like this: @__ImageBase = external constant i8 1586 if (!isa<GlobalObject>(LHS) || !isa<GlobalVariable>(RHS) || 1587 LHS->isThreadLocal() || RHS->isThreadLocal() || 1588 RHS->getName() != "__ImageBase" || !RHS->hasExternalLinkage() || 1589 cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection()) 1590 return nullptr; 1591 1592 return MCSymbolRefExpr::create(TM.getSymbol(LHS), 1593 MCSymbolRefExpr::VK_COFF_IMGREL32, 1594 getContext()); 1595 } 1596 1597 static std::string APIntToHexString(const APInt &AI) { 1598 unsigned Width = (AI.getBitWidth() / 8) * 2; 1599 std::string HexString = AI.toString(16, /*Signed=*/false); 1600 transform(HexString.begin(), HexString.end(), HexString.begin(), tolower); 1601 unsigned Size = HexString.size(); 1602 assert(Width >= Size && "hex string is too large!"); 1603 HexString.insert(HexString.begin(), Width - Size, '0'); 1604 1605 return HexString; 1606 } 1607 1608 static std::string scalarConstantToHexString(const Constant *C) { 1609 Type *Ty = C->getType(); 1610 if (isa<UndefValue>(C)) { 1611 return APIntToHexString(APInt::getNullValue(Ty->getPrimitiveSizeInBits())); 1612 } else if (const auto *CFP = dyn_cast<ConstantFP>(C)) { 1613 return APIntToHexString(CFP->getValueAPF().bitcastToAPInt()); 1614 } else if (const auto *CI = dyn_cast<ConstantInt>(C)) { 1615 return APIntToHexString(CI->getValue()); 1616 } else { 1617 unsigned NumElements; 1618 if (isa<VectorType>(Ty)) 1619 NumElements = Ty->getVectorNumElements(); 1620 else 1621 NumElements = Ty->getArrayNumElements(); 1622 std::string HexString; 1623 for (int I = NumElements - 1, E = -1; I != E; --I) 1624 HexString += scalarConstantToHexString(C->getAggregateElement(I)); 1625 return HexString; 1626 } 1627 } 1628 1629 MCSection *TargetLoweringObjectFileCOFF::getSectionForConstant( 1630 const DataLayout &DL, SectionKind Kind, const Constant *C, 1631 unsigned &Align) const { 1632 if (Kind.isMergeableConst() && C && 1633 getContext().getAsmInfo()->hasCOFFComdatConstants()) { 1634 // This creates comdat sections with the given symbol name, but unless 1635 // AsmPrinter::GetCPISymbol actually makes the symbol global, the symbol 1636 // will be created with a null storage class, which makes GNU binutils 1637 // error out. 1638 const unsigned Characteristics = COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 1639 COFF::IMAGE_SCN_MEM_READ | 1640 COFF::IMAGE_SCN_LNK_COMDAT; 1641 std::string COMDATSymName; 1642 if (Kind.isMergeableConst4()) { 1643 if (Align <= 4) { 1644 COMDATSymName = "__real@" + scalarConstantToHexString(C); 1645 Align = 4; 1646 } 1647 } else if (Kind.isMergeableConst8()) { 1648 if (Align <= 8) { 1649 COMDATSymName = "__real@" + scalarConstantToHexString(C); 1650 Align = 8; 1651 } 1652 } else if (Kind.isMergeableConst16()) { 1653 // FIXME: These may not be appropriate for non-x86 architectures. 1654 if (Align <= 16) { 1655 COMDATSymName = "__xmm@" + scalarConstantToHexString(C); 1656 Align = 16; 1657 } 1658 } else if (Kind.isMergeableConst32()) { 1659 if (Align <= 32) { 1660 COMDATSymName = "__ymm@" + scalarConstantToHexString(C); 1661 Align = 32; 1662 } 1663 } 1664 1665 if (!COMDATSymName.empty()) 1666 return getContext().getCOFFSection(".rdata", Characteristics, Kind, 1667 COMDATSymName, 1668 COFF::IMAGE_COMDAT_SELECT_ANY); 1669 } 1670 1671 return TargetLoweringObjectFile::getSectionForConstant(DL, Kind, C, Align); 1672 } 1673 1674 1675 //===----------------------------------------------------------------------===// 1676 // Wasm 1677 //===----------------------------------------------------------------------===// 1678 1679 static const Comdat *getWasmComdat(const GlobalValue *GV) { 1680 const Comdat *C = GV->getComdat(); 1681 if (!C) 1682 return nullptr; 1683 1684 if (C->getSelectionKind() != Comdat::Any) 1685 report_fatal_error("WebAssembly COMDATs only support " 1686 "SelectionKind::Any, '" + C->getName() + "' cannot be " 1687 "lowered."); 1688 1689 return C; 1690 } 1691 1692 static SectionKind getWasmKindForNamedSection(StringRef Name, SectionKind K) { 1693 // If we're told we have function data, then use that. 1694 if (K.isText()) 1695 return SectionKind::getText(); 1696 1697 // Otherwise, ignore whatever section type the generic impl detected and use 1698 // a plain data section. 1699 return SectionKind::getData(); 1700 } 1701 1702 MCSection *TargetLoweringObjectFileWasm::getExplicitSectionGlobal( 1703 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 1704 // We don't support explict section names for functions in the wasm object 1705 // format. Each function has to be in its own unique section. 1706 if (isa<Function>(GO)) { 1707 return SelectSectionForGlobal(GO, Kind, TM); 1708 } 1709 1710 StringRef Name = GO->getSection(); 1711 1712 Kind = getWasmKindForNamedSection(Name, Kind); 1713 1714 StringRef Group = ""; 1715 if (const Comdat *C = getWasmComdat(GO)) { 1716 Group = C->getName(); 1717 } 1718 1719 MCSectionWasm* Section = 1720 getContext().getWasmSection(Name, Kind, Group, 1721 MCContext::GenericSectionID); 1722 1723 return Section; 1724 } 1725 1726 static MCSectionWasm *selectWasmSectionForGlobal( 1727 MCContext &Ctx, const GlobalObject *GO, SectionKind Kind, Mangler &Mang, 1728 const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) { 1729 StringRef Group = ""; 1730 if (const Comdat *C = getWasmComdat(GO)) { 1731 Group = C->getName(); 1732 } 1733 1734 bool UniqueSectionNames = TM.getUniqueSectionNames(); 1735 SmallString<128> Name = getSectionPrefixForGlobal(Kind); 1736 1737 if (const auto *F = dyn_cast<Function>(GO)) { 1738 const auto &OptionalPrefix = F->getSectionPrefix(); 1739 if (OptionalPrefix) 1740 Name += *OptionalPrefix; 1741 } 1742 1743 if (EmitUniqueSection && UniqueSectionNames) { 1744 Name.push_back('.'); 1745 TM.getNameWithPrefix(Name, GO, Mang, true); 1746 } 1747 unsigned UniqueID = MCContext::GenericSectionID; 1748 if (EmitUniqueSection && !UniqueSectionNames) { 1749 UniqueID = *NextUniqueID; 1750 (*NextUniqueID)++; 1751 } 1752 1753 return Ctx.getWasmSection(Name, Kind, Group, UniqueID); 1754 } 1755 1756 MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal( 1757 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 1758 1759 if (Kind.isCommon()) 1760 report_fatal_error("mergable sections not supported yet on wasm"); 1761 1762 // If we have -ffunction-section or -fdata-section then we should emit the 1763 // global value to a uniqued section specifically for it. 1764 bool EmitUniqueSection = false; 1765 if (Kind.isText()) 1766 EmitUniqueSection = TM.getFunctionSections(); 1767 else 1768 EmitUniqueSection = TM.getDataSections(); 1769 EmitUniqueSection |= GO->hasComdat(); 1770 1771 return selectWasmSectionForGlobal(getContext(), GO, Kind, getMangler(), TM, 1772 EmitUniqueSection, &NextUniqueID); 1773 } 1774 1775 bool TargetLoweringObjectFileWasm::shouldPutJumpTableInFunctionSection( 1776 bool UsesLabelDifference, const Function &F) const { 1777 // We can always create relative relocations, so use another section 1778 // that can be marked non-executable. 1779 return false; 1780 } 1781 1782 const MCExpr *TargetLoweringObjectFileWasm::lowerRelativeReference( 1783 const GlobalValue *LHS, const GlobalValue *RHS, 1784 const TargetMachine &TM) const { 1785 // We may only use a PLT-relative relocation to refer to unnamed_addr 1786 // functions. 1787 if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy()) 1788 return nullptr; 1789 1790 // Basic sanity checks. 1791 if (LHS->getType()->getPointerAddressSpace() != 0 || 1792 RHS->getType()->getPointerAddressSpace() != 0 || LHS->isThreadLocal() || 1793 RHS->isThreadLocal()) 1794 return nullptr; 1795 1796 return MCBinaryExpr::createSub( 1797 MCSymbolRefExpr::create(TM.getSymbol(LHS), MCSymbolRefExpr::VK_None, 1798 getContext()), 1799 MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext()); 1800 } 1801 1802 void TargetLoweringObjectFileWasm::InitializeWasm() { 1803 StaticCtorSection = 1804 getContext().getWasmSection(".init_array", SectionKind::getData()); 1805 1806 // We don't use PersonalityEncoding and LSDAEncoding because we don't emit 1807 // .cfi directives. We use TTypeEncoding to encode typeinfo global variables. 1808 TTypeEncoding = dwarf::DW_EH_PE_absptr; 1809 } 1810 1811 MCSection *TargetLoweringObjectFileWasm::getStaticCtorSection( 1812 unsigned Priority, const MCSymbol *KeySym) const { 1813 return Priority == UINT16_MAX ? 1814 StaticCtorSection : 1815 getContext().getWasmSection(".init_array." + utostr(Priority), 1816 SectionKind::getData()); 1817 } 1818 1819 MCSection *TargetLoweringObjectFileWasm::getStaticDtorSection( 1820 unsigned Priority, const MCSymbol *KeySym) const { 1821 llvm_unreachable("@llvm.global_dtors should have been lowered already"); 1822 return nullptr; 1823 } 1824 1825 //===----------------------------------------------------------------------===// 1826 // XCOFF 1827 //===----------------------------------------------------------------------===// 1828 MCSection *TargetLoweringObjectFileXCOFF::getExplicitSectionGlobal( 1829 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 1830 report_fatal_error("XCOFF explicit sections not yet implemented."); 1831 } 1832 1833 MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal( 1834 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 1835 assert(!TM.getFunctionSections() && !TM.getDataSections() && 1836 "XCOFF unique sections not yet implemented."); 1837 1838 // Common symbols go into a csect with matching name which will get mapped 1839 // into the .bss section. 1840 if (Kind.isBSSLocal() || Kind.isCommon()) { 1841 SmallString<128> Name; 1842 getNameWithPrefix(Name, GO, TM); 1843 XCOFF::StorageClass SC = 1844 TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO); 1845 return getContext().getXCOFFSection( 1846 Name, Kind.isBSSLocal() ? XCOFF::XMC_BS : XCOFF::XMC_RW, XCOFF::XTY_CM, 1847 SC, Kind, /* BeginSymbolName */ nullptr); 1848 } 1849 1850 if (Kind.isText()) 1851 return TextSection; 1852 1853 if (Kind.isData()) 1854 return DataSection; 1855 1856 report_fatal_error("XCOFF other section types not yet implemented."); 1857 } 1858 1859 bool TargetLoweringObjectFileXCOFF::shouldPutJumpTableInFunctionSection( 1860 bool UsesLabelDifference, const Function &F) const { 1861 report_fatal_error("TLOF XCOFF not yet implemented."); 1862 } 1863 1864 void TargetLoweringObjectFileXCOFF::Initialize(MCContext &Ctx, 1865 const TargetMachine &TgtM) { 1866 TargetLoweringObjectFile::Initialize(Ctx, TgtM); 1867 TTypeEncoding = 0; 1868 PersonalityEncoding = 0; 1869 LSDAEncoding = 0; 1870 } 1871 1872 MCSection *TargetLoweringObjectFileXCOFF::getStaticCtorSection( 1873 unsigned Priority, const MCSymbol *KeySym) const { 1874 report_fatal_error("XCOFF ctor section not yet implemented."); 1875 } 1876 1877 MCSection *TargetLoweringObjectFileXCOFF::getStaticDtorSection( 1878 unsigned Priority, const MCSymbol *KeySym) const { 1879 report_fatal_error("XCOFF dtor section not yet implemented."); 1880 } 1881 1882 const MCExpr *TargetLoweringObjectFileXCOFF::lowerRelativeReference( 1883 const GlobalValue *LHS, const GlobalValue *RHS, 1884 const TargetMachine &TM) const { 1885 report_fatal_error("XCOFF not yet implemented."); 1886 } 1887 1888 XCOFF::StorageClass TargetLoweringObjectFileXCOFF::getStorageClassForGlobal( 1889 const GlobalObject *GO) { 1890 switch (GO->getLinkage()) { 1891 case GlobalValue::InternalLinkage: 1892 return XCOFF::C_HIDEXT; 1893 case GlobalValue::ExternalLinkage: 1894 case GlobalValue::CommonLinkage: 1895 return XCOFF::C_EXT; 1896 case GlobalValue::ExternalWeakLinkage: 1897 return XCOFF::C_WEAKEXT; 1898 default: 1899 report_fatal_error( 1900 "Unhandled linkage when mapping linkage to StorageClass."); 1901 } 1902 } 1903