TargetLoweringObjectFileImpl.cpp revision d4a19b6a72d19a6f90b676aac37118664b7b7a84
1//===-- llvm/CodeGen/TargetLoweringObjectFileImpl.cpp - Object File Info --===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements classes used to handle lowerings specific to common 11// object file formats. 12// 13//===----------------------------------------------------------------------===// 14 15#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" 16#include "llvm/Constants.h" 17#include "llvm/DerivedTypes.h" 18#include "llvm/Function.h" 19#include "llvm/GlobalVariable.h" 20#include "llvm/CodeGen/MachineModuleInfoImpls.h" 21#include "llvm/MC/MCContext.h" 22#include "llvm/MC/MCExpr.h" 23#include "llvm/MC/MCSectionMachO.h" 24#include "llvm/MC/MCSectionELF.h" 25#include "llvm/MC/MCSectionCOFF.h" 26#include "llvm/MC/MCStreamer.h" 27#include "llvm/MC/MCSymbol.h" 28#include "llvm/Target/Mangler.h" 29#include "llvm/Target/TargetData.h" 30#include "llvm/Target/TargetMachine.h" 31#include "llvm/Target/TargetOptions.h" 32#include "llvm/Support/Dwarf.h" 33#include "llvm/Support/ELF.h" 34#include "llvm/Support/ErrorHandling.h" 35#include "llvm/Support/raw_ostream.h" 36#include "llvm/ADT/SmallString.h" 37#include "llvm/ADT/StringExtras.h" 38#include "llvm/ADT/Triple.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 Streamer.SwitchSection(Sec); 80 Streamer.EmitValueToAlignment(8); 81 Streamer.EmitSymbolAttribute(Label, MCSA_ELF_TypeObject); 82 const MCExpr *E = MCConstantExpr::Create(8, getContext()); 83 Streamer.EmitELFSize(Label, E); 84 Streamer.EmitLabel(Label); 85 86 unsigned Size = TM.getTargetData()->getPointerSize(); 87 Streamer.EmitSymbolValue(Sym, Size); 88} 89 90static SectionKind 91getELFKindForNamedSection(StringRef Name, SectionKind K) { 92 // N.B.: The defaults used in here are no the same ones used in MC. 93 // We follow gcc, MC follows gas. For example, given ".section .eh_frame", 94 // both gas and MC will produce a section with no flags. Given 95 // section(".eh_frame") gcc will produce 96 // .section .eh_frame,"a",@progbits 97 if (Name.empty() || Name[0] != '.') return K; 98 99 // Some lame default implementation based on some magic section names. 100 if (Name == ".bss" || 101 Name.startswith(".bss.") || 102 Name.startswith(".gnu.linkonce.b.") || 103 Name.startswith(".llvm.linkonce.b.") || 104 Name == ".sbss" || 105 Name.startswith(".sbss.") || 106 Name.startswith(".gnu.linkonce.sb.") || 107 Name.startswith(".llvm.linkonce.sb.")) 108 return SectionKind::getBSS(); 109 110 if (Name == ".tdata" || 111 Name.startswith(".tdata.") || 112 Name.startswith(".gnu.linkonce.td.") || 113 Name.startswith(".llvm.linkonce.td.")) 114 return SectionKind::getThreadData(); 115 116 if (Name == ".tbss" || 117 Name.startswith(".tbss.") || 118 Name.startswith(".gnu.linkonce.tb.") || 119 Name.startswith(".llvm.linkonce.tb.")) 120 return SectionKind::getThreadBSS(); 121 122 return K; 123} 124 125 126static unsigned getELFSectionType(StringRef Name, SectionKind K) { 127 128 if (Name == ".init_array") 129 return ELF::SHT_INIT_ARRAY; 130 131 if (Name == ".fini_array") 132 return ELF::SHT_FINI_ARRAY; 133 134 if (Name == ".preinit_array") 135 return ELF::SHT_PREINIT_ARRAY; 136 137 if (K.isBSS() || K.isThreadBSS()) 138 return ELF::SHT_NOBITS; 139 140 return ELF::SHT_PROGBITS; 141} 142 143 144static unsigned 145getELFSectionFlags(SectionKind K) { 146 unsigned Flags = 0; 147 148 if (!K.isMetadata()) 149 Flags |= ELF::SHF_ALLOC; 150 151 if (K.isText()) 152 Flags |= ELF::SHF_EXECINSTR; 153 154 if (K.isWriteable()) 155 Flags |= ELF::SHF_WRITE; 156 157 if (K.isThreadLocal()) 158 Flags |= ELF::SHF_TLS; 159 160 // K.isMergeableConst() is left out to honour PR4650 161 if (K.isMergeableCString() || K.isMergeableConst4() || 162 K.isMergeableConst8() || K.isMergeableConst16()) 163 Flags |= ELF::SHF_MERGE; 164 165 if (K.isMergeableCString()) 166 Flags |= ELF::SHF_STRINGS; 167 168 return Flags; 169} 170 171 172const MCSection *TargetLoweringObjectFileELF:: 173getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 174 Mangler *Mang, const TargetMachine &TM) const { 175 StringRef SectionName = GV->getSection(); 176 177 // Infer section flags from the section name if we can. 178 Kind = getELFKindForNamedSection(SectionName, Kind); 179 180 return getContext().getELFSection(SectionName, 181 getELFSectionType(SectionName, Kind), 182 getELFSectionFlags(Kind), Kind); 183} 184 185/// getSectionPrefixForGlobal - Return the section prefix name used by options 186/// FunctionsSections and DataSections. 187static const char *getSectionPrefixForGlobal(SectionKind Kind) { 188 if (Kind.isText()) return ".text."; 189 if (Kind.isReadOnly()) return ".rodata."; 190 191 if (Kind.isThreadData()) return ".tdata."; 192 if (Kind.isThreadBSS()) return ".tbss."; 193 194 if (Kind.isDataNoRel()) return ".data."; 195 if (Kind.isDataRelLocal()) return ".data.rel.local."; 196 if (Kind.isDataRel()) return ".data.rel."; 197 if (Kind.isReadOnlyWithRelLocal()) return ".data.rel.ro.local."; 198 199 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 200 return ".data.rel.ro."; 201} 202 203 204const MCSection *TargetLoweringObjectFileELF:: 205SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 206 Mangler *Mang, const TargetMachine &TM) const { 207 // If we have -ffunction-section or -fdata-section then we should emit the 208 // global value to a uniqued section specifically for it. 209 bool EmitUniquedSection; 210 if (Kind.isText()) 211 EmitUniquedSection = TM.getFunctionSections(); 212 else 213 EmitUniquedSection = TM.getDataSections(); 214 215 // If this global is linkonce/weak and the target handles this by emitting it 216 // into a 'uniqued' section name, create and return the section now. 217 if ((GV->isWeakForLinker() || EmitUniquedSection) && 218 !Kind.isCommon() && !Kind.isBSS()) { 219 const char *Prefix; 220 Prefix = getSectionPrefixForGlobal(Kind); 221 222 SmallString<128> Name(Prefix, Prefix+strlen(Prefix)); 223 MCSymbol *Sym = Mang->getSymbol(GV); 224 Name.append(Sym->getName().begin(), Sym->getName().end()); 225 StringRef Group = ""; 226 unsigned Flags = getELFSectionFlags(Kind); 227 if (GV->isWeakForLinker()) { 228 Group = Sym->getName(); 229 Flags |= ELF::SHF_GROUP; 230 } 231 232 return getContext().getELFSection(Name.str(), 233 getELFSectionType(Name.str(), Kind), 234 Flags, Kind, 0, Group); 235 } 236 237 if (Kind.isText()) return TextSection; 238 239 if (Kind.isMergeable1ByteCString() || 240 Kind.isMergeable2ByteCString() || 241 Kind.isMergeable4ByteCString()) { 242 243 // We also need alignment here. 244 // FIXME: this is getting the alignment of the character, not the 245 // alignment of the global! 246 unsigned Align = 247 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)); 248 249 const char *SizeSpec = ".rodata.str1."; 250 if (Kind.isMergeable2ByteCString()) 251 SizeSpec = ".rodata.str2."; 252 else if (Kind.isMergeable4ByteCString()) 253 SizeSpec = ".rodata.str4."; 254 else 255 assert(Kind.isMergeable1ByteCString() && "unknown string width"); 256 257 258 std::string Name = SizeSpec + utostr(Align); 259 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, 260 ELF::SHF_ALLOC | 261 ELF::SHF_MERGE | 262 ELF::SHF_STRINGS, 263 Kind); 264 } 265 266 if (Kind.isMergeableConst()) { 267 if (Kind.isMergeableConst4() && MergeableConst4Section) 268 return MergeableConst4Section; 269 if (Kind.isMergeableConst8() && MergeableConst8Section) 270 return MergeableConst8Section; 271 if (Kind.isMergeableConst16() && MergeableConst16Section) 272 return MergeableConst16Section; 273 return ReadOnlySection; // .const 274 } 275 276 if (Kind.isReadOnly()) return ReadOnlySection; 277 278 if (Kind.isThreadData()) return TLSDataSection; 279 if (Kind.isThreadBSS()) return TLSBSSSection; 280 281 // Note: we claim that common symbols are put in BSSSection, but they are 282 // really emitted with the magic .comm directive, which creates a symbol table 283 // entry but not a section. 284 if (Kind.isBSS() || Kind.isCommon()) return BSSSection; 285 286 if (Kind.isDataNoRel()) return DataSection; 287 if (Kind.isDataRelLocal()) return DataRelLocalSection; 288 if (Kind.isDataRel()) return DataRelSection; 289 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection; 290 291 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 292 return DataRelROSection; 293} 294 295/// getSectionForConstant - Given a mergeable constant with the 296/// specified size and relocation information, return a section that it 297/// should be placed in. 298const MCSection *TargetLoweringObjectFileELF:: 299getSectionForConstant(SectionKind Kind) const { 300 if (Kind.isMergeableConst4() && MergeableConst4Section) 301 return MergeableConst4Section; 302 if (Kind.isMergeableConst8() && MergeableConst8Section) 303 return MergeableConst8Section; 304 if (Kind.isMergeableConst16() && MergeableConst16Section) 305 return MergeableConst16Section; 306 if (Kind.isReadOnly()) 307 return ReadOnlySection; 308 309 if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection; 310 assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); 311 return DataRelROSection; 312} 313 314const MCExpr *TargetLoweringObjectFileELF:: 315getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang, 316 MachineModuleInfo *MMI, 317 unsigned Encoding, MCStreamer &Streamer) const { 318 319 if (Encoding & dwarf::DW_EH_PE_indirect) { 320 MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>(); 321 322 SmallString<128> Name; 323 Mang->getNameWithPrefix(Name, GV, true); 324 Name += ".DW.stub"; 325 326 // Add information about the stub reference to ELFMMI so that the stub 327 // gets emitted by the asmprinter. 328 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str()); 329 MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym); 330 if (StubSym.getPointer() == 0) { 331 MCSymbol *Sym = Mang->getSymbol(GV); 332 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 333 } 334 335 return TargetLoweringObjectFile:: 336 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer); 337 } 338 339 return TargetLoweringObjectFile:: 340 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer); 341} 342 343const MCSection * 344TargetLoweringObjectFileELF::getStaticCtorSection(unsigned Priority) const { 345 // The default scheme is .ctor / .dtor, so we have to invert the priority 346 // numbering. 347 if (Priority == 65535) 348 return StaticCtorSection; 349 350 std::string Name = std::string(".ctors.") + utostr(65535 - Priority); 351 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, 352 ELF::SHF_ALLOC |ELF::SHF_WRITE, 353 SectionKind::getDataRel()); 354} 355 356const MCSection * 357TargetLoweringObjectFileELF::getStaticDtorSection(unsigned Priority) const { 358 // The default scheme is .ctor / .dtor, so we have to invert the priority 359 // numbering. 360 if (Priority == 65535) 361 return StaticDtorSection; 362 363 std::string Name = std::string(".dtors.") + utostr(65535 - Priority); 364 return getContext().getELFSection(Name, ELF::SHT_PROGBITS, 365 ELF::SHF_ALLOC |ELF::SHF_WRITE, 366 SectionKind::getDataRel()); 367} 368 369//===----------------------------------------------------------------------===// 370// MachO 371//===----------------------------------------------------------------------===// 372 373const MCSection *TargetLoweringObjectFileMachO:: 374getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 375 Mangler *Mang, const TargetMachine &TM) const { 376 // Parse the section specifier and create it if valid. 377 StringRef Segment, Section; 378 unsigned TAA = 0, StubSize = 0; 379 bool TAAParsed; 380 std::string ErrorCode = 381 MCSectionMachO::ParseSectionSpecifier(GV->getSection(), Segment, Section, 382 TAA, TAAParsed, StubSize); 383 if (!ErrorCode.empty()) { 384 // If invalid, report the error with report_fatal_error. 385 report_fatal_error("Global variable '" + GV->getName() + 386 "' has an invalid section specifier '" + 387 GV->getSection() + "': " + ErrorCode + "."); 388 } 389 390 // Get the section. 391 const MCSectionMachO *S = 392 getContext().getMachOSection(Segment, Section, TAA, StubSize, Kind); 393 394 // If TAA wasn't set by ParseSectionSpecifier() above, 395 // use the value returned by getMachOSection() as a default. 396 if (!TAAParsed) 397 TAA = S->getTypeAndAttributes(); 398 399 // Okay, now that we got the section, verify that the TAA & StubSize agree. 400 // If the user declared multiple globals with different section flags, we need 401 // to reject it here. 402 if (S->getTypeAndAttributes() != TAA || S->getStubSize() != StubSize) { 403 // If invalid, report the error with report_fatal_error. 404 report_fatal_error("Global variable '" + GV->getName() + 405 "' section type or attributes does not match previous" 406 " section specifier"); 407 } 408 409 return S; 410} 411 412const MCSection *TargetLoweringObjectFileMachO:: 413SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 414 Mangler *Mang, const TargetMachine &TM) const { 415 416 // Handle thread local data. 417 if (Kind.isThreadBSS()) return TLSBSSSection; 418 if (Kind.isThreadData()) return TLSDataSection; 419 420 if (Kind.isText()) 421 return GV->isWeakForLinker() ? TextCoalSection : TextSection; 422 423 // If this is weak/linkonce, put this in a coalescable section, either in text 424 // or data depending on if it is writable. 425 if (GV->isWeakForLinker()) { 426 if (Kind.isReadOnly()) 427 return ConstTextCoalSection; 428 return DataCoalSection; 429 } 430 431 // FIXME: Alignment check should be handled by section classifier. 432 if (Kind.isMergeable1ByteCString() && 433 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 434 return CStringSection; 435 436 // Do not put 16-bit arrays in the UString section if they have an 437 // externally visible label, this runs into issues with certain linker 438 // versions. 439 if (Kind.isMergeable2ByteCString() && !GV->hasExternalLinkage() && 440 TM.getTargetData()->getPreferredAlignment(cast<GlobalVariable>(GV)) < 32) 441 return UStringSection; 442 443 if (Kind.isMergeableConst()) { 444 if (Kind.isMergeableConst4()) 445 return FourByteConstantSection; 446 if (Kind.isMergeableConst8()) 447 return EightByteConstantSection; 448 if (Kind.isMergeableConst16() && SixteenByteConstantSection) 449 return SixteenByteConstantSection; 450 } 451 452 // Otherwise, if it is readonly, but not something we can specially optimize, 453 // just drop it in .const. 454 if (Kind.isReadOnly()) 455 return ReadOnlySection; 456 457 // If this is marked const, put it into a const section. But if the dynamic 458 // linker needs to write to it, put it in the data segment. 459 if (Kind.isReadOnlyWithRel()) 460 return ConstDataSection; 461 462 // Put zero initialized globals with strong external linkage in the 463 // DATA, __common section with the .zerofill directive. 464 if (Kind.isBSSExtern()) 465 return DataCommonSection; 466 467 // Put zero initialized globals with local linkage in __DATA,__bss directive 468 // with the .zerofill directive (aka .lcomm). 469 if (Kind.isBSSLocal()) 470 return DataBSSSection; 471 472 // Otherwise, just drop the variable in the normal data section. 473 return DataSection; 474} 475 476const MCSection * 477TargetLoweringObjectFileMachO::getSectionForConstant(SectionKind Kind) const { 478 // If this constant requires a relocation, we have to put it in the data 479 // segment, not in the text segment. 480 if (Kind.isDataRel() || Kind.isReadOnlyWithRel()) 481 return ConstDataSection; 482 483 if (Kind.isMergeableConst4()) 484 return FourByteConstantSection; 485 if (Kind.isMergeableConst8()) 486 return EightByteConstantSection; 487 if (Kind.isMergeableConst16() && SixteenByteConstantSection) 488 return SixteenByteConstantSection; 489 return ReadOnlySection; // .const 490} 491 492/// shouldEmitUsedDirectiveFor - This hook allows targets to selectively decide 493/// not to emit the UsedDirective for some symbols in llvm.used. 494// FIXME: REMOVE this (rdar://7071300) 495bool TargetLoweringObjectFileMachO:: 496shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const { 497 /// On Darwin, internally linked data beginning with "L" or "l" does not have 498 /// the directive emitted (this occurs in ObjC metadata). 499 if (!GV) return false; 500 501 // Check whether the mangled name has the "Private" or "LinkerPrivate" prefix. 502 if (GV->hasLocalLinkage() && !isa<Function>(GV)) { 503 // FIXME: ObjC metadata is currently emitted as internal symbols that have 504 // \1L and \0l prefixes on them. Fix them to be Private/LinkerPrivate and 505 // this horrible hack can go away. 506 MCSymbol *Sym = Mang->getSymbol(GV); 507 if (Sym->getName()[0] == 'L' || Sym->getName()[0] == 'l') 508 return false; 509 } 510 511 return true; 512} 513 514const MCExpr *TargetLoweringObjectFileMachO:: 515getExprForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang, 516 MachineModuleInfo *MMI, unsigned Encoding, 517 MCStreamer &Streamer) const { 518 // The mach-o version of this method defaults to returning a stub reference. 519 520 if (Encoding & DW_EH_PE_indirect) { 521 MachineModuleInfoMachO &MachOMMI = 522 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 523 524 SmallString<128> Name; 525 Mang->getNameWithPrefix(Name, GV, true); 526 Name += "$non_lazy_ptr"; 527 528 // Add information about the stub reference to MachOMMI so that the stub 529 // gets emitted by the asmprinter. 530 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str()); 531 MachineModuleInfoImpl::StubValueTy &StubSym = 532 GV->hasHiddenVisibility() ? MachOMMI.getHiddenGVStubEntry(SSym) : 533 MachOMMI.getGVStubEntry(SSym); 534 if (StubSym.getPointer() == 0) { 535 MCSymbol *Sym = Mang->getSymbol(GV); 536 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 537 } 538 539 return TargetLoweringObjectFile:: 540 getExprForDwarfReference(SSym, Encoding & ~dwarf::DW_EH_PE_indirect, Streamer); 541 } 542 543 return TargetLoweringObjectFile:: 544 getExprForDwarfGlobalReference(GV, Mang, MMI, Encoding, Streamer); 545} 546 547MCSymbol *TargetLoweringObjectFileMachO:: 548getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang, 549 MachineModuleInfo *MMI) const { 550 // The mach-o version of this method defaults to returning a stub reference. 551 MachineModuleInfoMachO &MachOMMI = 552 MMI->getObjFileInfo<MachineModuleInfoMachO>(); 553 554 SmallString<128> Name; 555 Mang->getNameWithPrefix(Name, GV, true); 556 Name += "$non_lazy_ptr"; 557 558 // Add information about the stub reference to MachOMMI so that the stub 559 // gets emitted by the asmprinter. 560 MCSymbol *SSym = getContext().GetOrCreateSymbol(Name.str()); 561 MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym); 562 if (StubSym.getPointer() == 0) { 563 MCSymbol *Sym = Mang->getSymbol(GV); 564 StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage()); 565 } 566 567 return SSym; 568} 569 570//===----------------------------------------------------------------------===// 571// COFF 572//===----------------------------------------------------------------------===// 573 574static unsigned 575getCOFFSectionFlags(SectionKind K) { 576 unsigned Flags = 0; 577 578 if (K.isMetadata()) 579 Flags |= 580 COFF::IMAGE_SCN_MEM_DISCARDABLE; 581 else if (K.isText()) 582 Flags |= 583 COFF::IMAGE_SCN_MEM_EXECUTE | 584 COFF::IMAGE_SCN_MEM_READ | 585 COFF::IMAGE_SCN_CNT_CODE; 586 else if (K.isBSS ()) 587 Flags |= 588 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA | 589 COFF::IMAGE_SCN_MEM_READ | 590 COFF::IMAGE_SCN_MEM_WRITE; 591 else if (K.isThreadLocal()) 592 Flags |= 593 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 594 COFF::IMAGE_SCN_MEM_READ | 595 COFF::IMAGE_SCN_MEM_WRITE; 596 else if (K.isReadOnly()) 597 Flags |= 598 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 599 COFF::IMAGE_SCN_MEM_READ; 600 else if (K.isWriteable()) 601 Flags |= 602 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | 603 COFF::IMAGE_SCN_MEM_READ | 604 COFF::IMAGE_SCN_MEM_WRITE; 605 606 return Flags; 607} 608 609const MCSection *TargetLoweringObjectFileCOFF:: 610getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 611 Mangler *Mang, const TargetMachine &TM) const { 612 return getContext().getCOFFSection(GV->getSection(), 613 getCOFFSectionFlags(Kind), 614 Kind); 615} 616 617static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) { 618 if (Kind.isText()) 619 return ".text$"; 620 if (Kind.isBSS ()) 621 return ".bss$"; 622 if (Kind.isThreadLocal()) 623 return ".tls$"; 624 if (Kind.isWriteable()) 625 return ".data$"; 626 return ".rdata$"; 627} 628 629 630const MCSection *TargetLoweringObjectFileCOFF:: 631SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 632 Mangler *Mang, const TargetMachine &TM) const { 633 634 // If this global is linkonce/weak and the target handles this by emitting it 635 // into a 'uniqued' section name, create and return the section now. 636 if (GV->isWeakForLinker()) { 637 const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind); 638 SmallString<128> Name(Prefix, Prefix+strlen(Prefix)); 639 MCSymbol *Sym = Mang->getSymbol(GV); 640 Name.append(Sym->getName().begin() + 1, Sym->getName().end()); 641 642 unsigned Characteristics = getCOFFSectionFlags(Kind); 643 644 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 645 646 return getContext().getCOFFSection(Name.str(), Characteristics, 647 COFF::IMAGE_COMDAT_SELECT_ANY, Kind); 648 } 649 650 if (Kind.isText()) 651 return getTextSection(); 652 653 if (Kind.isThreadLocal()) 654 return getTLSDataSection(); 655 656 return getDataSection(); 657} 658 659