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