diff --git a/include/llvm/Target/TargetAsmInfo.h b/include/llvm/Target/TargetAsmInfo.h index ee33f140c54..1baae518c59 100644 --- a/include/llvm/Target/TargetAsmInfo.h +++ b/include/llvm/Target/TargetAsmInfo.h @@ -16,6 +16,7 @@ #ifndef LLVM_TARGET_ASM_INFO_H #define LLVM_TARGET_ASM_INFO_H +#include "llvm/ADT/StringMap.h" #include "llvm/Support/DataTypes.h" #include @@ -45,6 +46,7 @@ namespace llvm { namespace SectionFlags { enum Flags { + Invalid = -1UL, None = 0, Code = 1 << 0, ///< Section contains code Writeable = 1 << 1, ///< Section is writeable @@ -73,40 +75,67 @@ namespace llvm { class CallInst; class GlobalValue; + class Section { + friend class TargetAsmInfo; + friend class StringMapEntry
; + + std::string Name; + unsigned Flags; + + explicit Section(unsigned F = SectionFlags::Invalid):Flags(F) { } + public: + bool isNamed() const { return Flags & SectionFlags::Named; } + unsigned getEntitySize() const { return (Flags >> 24) & 0xFF; } + const std::string& getName() const { return Name; } + }; + /// TargetAsmInfo - This class is intended to be used as a base class for asm /// properties and features specific to the target. class TargetAsmInfo { + private: + mutable StringMap
Sections; protected: //===------------------------------------------------------------------===// // Properties to be set by the target writer, used to configure asm printer. // - + /// TextSection - Section directive for standard text. /// const char *TextSection; // Defaults to ".text". - + const Section *TextSection_; + /// DataSection - Section directive for standard data. /// const char *DataSection; // Defaults to ".data". + const Section *DataSection_; /// BSSSection - Section directive for uninitialized data. Null if this /// target doesn't support a BSS section. /// const char *BSSSection; // Default to ".bss". + const Section *BSSSection_; + + /// ReadOnlySection - This is the directive that is emitted to switch to a + /// read-only section for constant data (e.g. data declared const, + /// jump tables). + const char *ReadOnlySection; // Defaults to NULL + const Section *ReadOnlySection_; /// TLSDataSection - Section directive for Thread Local data. /// const char *TLSDataSection;// Defaults to ".section .tdata,"awT",@progbits". + const Section *TLSDataSection_; /// TLSBSSSection - Section directive for Thread Local uninitialized data. /// Null if this target doesn't support a BSS section. /// const char *TLSBSSSection;// Default to ".section .tbss,"awT",@nobits". + const Section *TLSBSSSection_; /// ZeroFillDirective - Directive for emitting a global to the ZeroFill /// section on this target. Null if this target doesn't support zerofill. const char *ZeroFillDirective; // Default is null. - + /// NonexecutableStackDirective - Directive for declaring to the /// linker and beyond that the emitted code does not require stack /// memory to be executable. @@ -274,6 +303,7 @@ namespace llvm { /// other null bytes) on this target. This is commonly supported as /// ".cstring". const char *CStringSection; // Defaults to NULL + const Section *CStringSection_; /// StaticCtorsSection - This is the directive that is emitted to switch to /// a section to emit the static constructor list. @@ -289,13 +319,11 @@ namespace llvm { /// SixteenByteConstantSection - These are special sections where we place /// 4-, 8-, and 16- byte constant literals. const char *FourByteConstantSection; + const Section *FourByteConstantSection_; const char *EightByteConstantSection; + const Section *EightByteConstantSection_; const char *SixteenByteConstantSection; - - /// ReadOnlySection - This is the directive that is emitted to switch to a - /// read-only section for constant data (e.g. data declared const, - /// jump tables). - const char *ReadOnlySection; // Defaults to NULL + const Section *SixteenByteConstantSection_; //===--- Global Variable Emission Directives --------------------------===// @@ -449,6 +477,11 @@ namespace llvm { TargetAsmInfo(); virtual ~TargetAsmInfo(); + const Section* getNamedSection(const char *Name, + unsigned Flags = SectionFlags::None) const; + const Section* getUnnamedSection(const char *Directive, + unsigned Flags = SectionFlags::None) const; + /// Measure the specified inline asm to determine an approximation of its /// length. virtual unsigned getInlineAsmLength(const char *Str) const; @@ -490,25 +523,46 @@ namespace llvm { virtual std::string PrintSectionFlags(unsigned flags) const { return ""; } - virtual std::string SelectSectionForGlobal(const GlobalValue *GV) const; + virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const; // Accessors. // const char *getTextSection() const { return TextSection; } + const Section *getTextSection_() const { + return TextSection_; + } const char *getDataSection() const { return DataSection; } + const Section *getDataSection_() const { + return DataSection_; + } const char *getBSSSection() const { return BSSSection; } + const Section *getBSSSection_() const { + return BSSSection_; + } + const char *getReadOnlySection() const { + return ReadOnlySection; + } + const Section *getReadOnlySection_() const { + return ReadOnlySection_; + } const char *getTLSDataSection() const { return TLSDataSection; } + const Section *getTLSDataSection_() const { + return TLSDataSection_; + } const char *getTLSBSSSection() const { return TLSBSSSection; } + const Section *getTLSBSSSection_() const { + return TLSBSSSection_; + } const char *getZeroFillDirective() const { return ZeroFillDirective; } @@ -626,6 +680,9 @@ namespace llvm { const char *getCStringSection() const { return CStringSection; } + const Section *getCStringSection_() const { + return CStringSection_; + } const char *getStaticCtorsSection() const { return StaticCtorsSection; } @@ -635,14 +692,20 @@ namespace llvm { const char *getFourByteConstantSection() const { return FourByteConstantSection; } + const Section *getFourByteConstantSection_() const { + return FourByteConstantSection_; + } const char *getEightByteConstantSection() const { return EightByteConstantSection; } + const Section *getEightByteConstantSection_() const { + return EightByteConstantSection_; + } const char *getSixteenByteConstantSection() const { return SixteenByteConstantSection; } - const char *getReadOnlySection() const { - return ReadOnlySection; + const Section *getSixteenByteConstantSection_() const { + return SixteenByteConstantSection_; } const char *getGlobalDirective() const { return GlobalDirective; diff --git a/lib/Target/TargetAsmInfo.cpp b/lib/Target/TargetAsmInfo.cpp index 0c74d5ad606..3c58244a3fe 100644 --- a/lib/Target/TargetAsmInfo.cpp +++ b/lib/Target/TargetAsmInfo.cpp @@ -27,10 +27,17 @@ using namespace llvm; TargetAsmInfo::TargetAsmInfo() : TextSection("\t.text"), + TextSection_(0), DataSection("\t.data"), + DataSection_(0), BSSSection("\t.bss"), + BSSSection_(0), + ReadOnlySection(0), + ReadOnlySection_(0), TLSDataSection("\t.section .tdata,\"awT\",@progbits"), + TLSDataSection_(0), TLSBSSSection("\t.section .tbss,\"awT\",@nobits"), + TLSBSSSection_(0), ZeroFillDirective(0), NonexecutableStackDirective(0), NeedsSet(false), @@ -71,12 +78,15 @@ TargetAsmInfo::TargetAsmInfo() : JumpTableDataSection("\t.section .rodata"), JumpTableDirective(0), CStringSection(0), + CStringSection_(0), StaticCtorsSection("\t.section .ctors,\"aw\",@progbits"), StaticDtorsSection("\t.section .dtors,\"aw\",@progbits"), FourByteConstantSection(0), + FourByteConstantSection_(0), EightByteConstantSection(0), + EightByteConstantSection_(0), SixteenByteConstantSection(0), - ReadOnlySection(0), + SixteenByteConstantSection_(0), GlobalDirective("\t.globl\t"), SetDirective(0), LCOMMDirective(0), @@ -112,6 +122,8 @@ TargetAsmInfo::TargetAsmInfo() : DwarfEHFrameSection(".eh_frame"), DwarfExceptionSection(".gcc_except_table"), AsmTransCBE(0) { + TextSection_ = getUnnamedSection(TextSection); + DataSection_ = getUnnamedSection(DataSection); } TargetAsmInfo::~TargetAsmInfo() { @@ -257,51 +269,51 @@ TargetAsmInfo::SectionFlagsForGlobal(const GlobalValue *GV, std::string TargetAsmInfo::SectionForGlobal(const GlobalValue *GV) const { - unsigned Flags = SectionFlagsForGlobal(GV, GV->getSection().c_str()); - - std::string Name; - - // FIXME: Should we use some hashing based on section name and just check - // flags? - + const Section* S; // Select section name if (GV->hasSection()) { // Honour section already set, if any - Name = GV->getSection(); + unsigned Flags = SectionFlagsForGlobal(GV, + GV->getSection().c_str()); + S = getNamedSection(GV->getSection().c_str(), Flags); } else { // Use default section depending on the 'type' of global - Name = SelectSectionForGlobal(GV); + S = SelectSectionForGlobal(GV); } + std::string Name = S->Name; + // If section is named we need to switch into it via special '.section' // directive and also append funky flags. Otherwise - section name is just // some magic assembler directive. - if (Flags & SectionFlags::Named) - Name = getSwitchToSectionDirective() + Name + PrintSectionFlags(Flags); + if (S->isNamed()) + Name = getSwitchToSectionDirective() + Name + PrintSectionFlags(S->Flags); return Name; } // Lame default implementation. Calculate the section name for global. -std::string +const Section* TargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { SectionKind::Kind Kind = SectionKindForGlobal(GV); - if (GV->isWeakForLinker()) - return UniqueSectionForGlobal(GV, Kind); - else { + if (GV->isWeakForLinker()) { + std::string Name = UniqueSectionForGlobal(GV, Kind); + unsigned Flags = SectionFlagsForGlobal(GV, Name.c_str()); + return getNamedSection(Name.c_str(), Flags); + } else { if (Kind == SectionKind::Text) - return getTextSection(); - else if (Kind == SectionKind::BSS && getBSSSection()) - return getBSSSection(); - else if (getReadOnlySection() && + return getTextSection_(); + else if (Kind == SectionKind::BSS && getBSSSection_()) + return getBSSSection_(); + else if (getReadOnlySection_() && (Kind == SectionKind::ROData || Kind == SectionKind::RODataMergeConst || Kind == SectionKind::RODataMergeStr)) - return getReadOnlySection(); + return getReadOnlySection_(); } - return getDataSection(); + return getDataSection_(); } std::string @@ -326,3 +338,29 @@ TargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV, assert(0 && "Unknown section kind"); } } + +const Section* +TargetAsmInfo::getNamedSection(const char *Name, unsigned Flags) const { + Section& S = Sections[Name]; + + // This is newly-created section, set it up properly. + if (S.Flags == SectionFlags::Invalid) { + S.Flags = Flags | SectionFlags::Named; + S.Name = Name; + } + + return &S; +} + +const Section* +TargetAsmInfo::getUnnamedSection(const char *Directive, unsigned Flags) const { + Section& S = Sections[Directive]; + + // This is newly-created section, set it up properly. + if (S.Flags == SectionFlags::Invalid) { + S.Flags = Flags & ~SectionFlags::Named; + S.Name = Directive; + } + + return &S; +} diff --git a/lib/Target/X86/X86TargetAsmInfo.cpp b/lib/Target/X86/X86TargetAsmInfo.cpp index 43d60cbd8f4..bcee8703faf 100644 --- a/lib/Target/X86/X86TargetAsmInfo.cpp +++ b/lib/Target/X86/X86TargetAsmInfo.cpp @@ -142,12 +142,31 @@ X86DarwinTargetAsmInfo::X86DarwinTargetAsmInfo(const X86TargetMachine &TM): ConstantPoolSection = "\t.const\n"; JumpTableDataSection = "\t.const\n"; CStringSection = "\t.cstring"; + CStringSection_ = getUnnamedSection("\t.cstring", + SectionFlags::Mergeable | SectionFlags::Strings); FourByteConstantSection = "\t.literal4\n"; - EightByteConstantSection = "\t.literal8\n"; + FourByteConstantSection_ = getUnnamedSection("\t.literal4\n", + SectionFlags::Mergeable); + EightByteConstantSection_ = getUnnamedSection("\t.literal8\n", + SectionFlags::Mergeable); // FIXME: Why don't always use this section? - if (is64Bit) + if (is64Bit) { SixteenByteConstantSection = "\t.literal16\n"; + SixteenByteConstantSection_ = getUnnamedSection("\t.literal16\n", + SectionFlags::Mergeable); + } ReadOnlySection = "\t.const\n"; + ReadOnlySection_ = getUnnamedSection("\t.const\n", SectionFlags::None); + TextCoalSection = + getUnnamedSection(".section __TEXT,__textcoal_nt,coalesced,pure_instructions", + SectionFlags::Code); + ConstDataCoalSection = + getUnnamedSection(".section __DATA,__const_coal,coalesced", + SectionFlags::None); + ConstDataSection = getUnnamedSection(".const_data", SectionFlags::None); + DataCoalSection = getUnnamedSection(".section __DATA,__datacoal_nt,coalesced", + SectionFlags::Writeable); + LCOMMDirective = "\t.lcomm\t"; SwitchToSectionDirective = "\t.section "; StringConstantPrefix = "\1LC"; @@ -221,7 +240,7 @@ X86DarwinTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason, return DW_EH_PE_absptr; } -std::string +const Section* X86DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { SectionKind::Kind Kind = SectionKindForGlobal(GV); bool isWeak = GV->isWeakForLinker(); @@ -229,29 +248,19 @@ X86DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { switch (Kind) { case SectionKind::Text: if (isWeak) - return ".section __TEXT,__textcoal_nt,coalesced,pure_instructions"; + return TextCoalSection; else - return getTextSection(); + return getTextSection_(); case SectionKind::Data: case SectionKind::ThreadData: case SectionKind::BSS: case SectionKind::ThreadBSS: - if (cast(GV)->isConstant()) { - if (isWeak) - return ".section __DATA,__const_coal,coalesced"; - else - return ".const_data"; - } else { - if (isWeak) - return ".section __DATA,__datacoal_nt,coalesced"; - else - return getDataSection(); - } - case SectionKind::ROData: - if (isWeak) - return ".section __DATA,__const_coal,coalesced"; + if (cast(GV)->isConstant()) + return (isWeak ? ConstDataCoalSection : ConstDataSection); else - return getReadOnlySection(); + return (isWeak ? DataCoalSection : getDataSection_()); + case SectionKind::ROData: + return (isWeak ? ConstDataCoalSection : getReadOnlySection_()); case SectionKind::RODataMergeStr: return MergeableStringSection(cast(GV)); case SectionKind::RODataMergeConst: @@ -263,34 +272,37 @@ X86DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { // FIXME: Do we have any extra special weird cases? } -std::string +const Section* X86DarwinTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const { - unsigned Flags = SectionFlagsForGlobal(GV, GV->getSection().c_str()); - unsigned Size = SectionFlags::getEntitySize(Flags); + const TargetData *TD = X86TM->getTargetData(); + Constant *C = cast(GV)->getInitializer(); + const Type *Type = cast(C)->getType()->getElementType(); + unsigned Size = TD->getABITypeSize(Type); if (Size) { const TargetData *TD = X86TM->getTargetData(); unsigned Align = TD->getPreferredAlignment(GV); if (Align <= 32) - return getCStringSection(); + return getCStringSection_(); } - return getReadOnlySection(); + return getReadOnlySection_(); } -std::string +const Section* X86DarwinTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const { - unsigned Flags = SectionFlagsForGlobal(GV, GV->getSection().c_str()); - unsigned Size = SectionFlags::getEntitySize(Flags); + const TargetData *TD = X86TM->getTargetData(); + Constant *C = cast(GV)->getInitializer(); + unsigned Size = TD->getABITypeSize(C->getType()); if (Size == 4) - return FourByteConstantSection; + return FourByteConstantSection_; else if (Size == 8) - return EightByteConstantSection; + return EightByteConstantSection_; else if (Size == 16 && X86TM->getSubtarget().is64Bit()) - return SixteenByteConstantSection; + return SixteenByteConstantSection_; - return getReadOnlySection(); + return getReadOnlySection_(); } std::string @@ -300,44 +312,20 @@ X86DarwinTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV, return ""; } -unsigned -X86DarwinTargetAsmInfo::SectionFlagsForGlobal(const GlobalValue *GV, - const char* name) const { - unsigned Flags = - TargetAsmInfo::SectionFlagsForGlobal(GV, - GV->getSection().c_str()); - - // If there was decision to put stuff into mergeable section - calculate - // entity size - if (Flags & SectionFlags::Mergeable) { - const TargetData *TD = X86TM->getTargetData(); - Constant *C = cast(GV)->getInitializer(); - const Type *Type; - - if (Flags & SectionFlags::Strings) { - const ConstantArray *CVA = cast(C); - Type = CVA->getType()->getElementType(); - } else - Type = C->getType(); - - unsigned Size = TD->getABITypeSize(Type); - if (Size > 16 || - !(Flags & SectionFlags::Strings || - (Size == 4 || Size == 8 || Size == 16))) { - // Not suitable for mergeable - Size = 0; - Flags &= ~SectionFlags::Mergeable; - } - Flags = SectionFlags::setEntitySize(Flags, Size); - } - - return Flags; -} - X86ELFTargetAsmInfo::X86ELFTargetAsmInfo(const X86TargetMachine &TM): X86TargetAsmInfo(TM) { bool is64Bit = X86TM->getSubtarget().is64Bit(); + TextSection_ = getUnnamedSection("\t.text", SectionFlags::Code); + DataSection_ = getUnnamedSection("\t.data", SectionFlags::Writeable); + BSSSection_ = getUnnamedSection("\t.bss", + SectionFlags::Writeable | SectionFlags::BSS); + ReadOnlySection_ = getUnnamedSection("\t.rodata", SectionFlags::None); + TLSDataSection_ = getNamedSection("\t.tdata", + SectionFlags::Writeable | SectionFlags::TLS); + TLSBSSSection_ = getNamedSection("\t.tbss", + SectionFlags::Writeable | SectionFlags::TLS | SectionFlags::BSS); + ReadOnlySection = ".rodata"; FourByteConstantSection = "\t.section\t.rodata.cst4,\"aM\",@progbits,4"; EightByteConstantSection = "\t.section\t.rodata.cst8,\"aM\",@progbits,8"; @@ -417,9 +405,9 @@ X86ELFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason, } } -std::string +const Section* X86ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { - SectionKind::Kind kind = SectionKindForGlobal(GV); + SectionKind::Kind Kind = SectionKindForGlobal(GV); if (const Function *F = dyn_cast(GV)) { switch (F->getLinkage()) { @@ -427,32 +415,36 @@ X86ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { case Function::InternalLinkage: case Function::DLLExportLinkage: case Function::ExternalLinkage: - return getTextSection(); + return getTextSection_(); case Function::WeakLinkage: case Function::LinkOnceLinkage: - return UniqueSectionForGlobal(F, kind); + std::string Name = UniqueSectionForGlobal(GV, Kind); + unsigned Flags = SectionFlagsForGlobal(GV, Name.c_str()); + return getNamedSection(Name.c_str(), Flags); } } else if (const GlobalVariable *GVar = dyn_cast(GV)) { - if (GVar->isWeakForLinker()) - return UniqueSectionForGlobal(GVar, kind); - else { - switch (kind) { + if (GVar->isWeakForLinker()) { + std::string Name = UniqueSectionForGlobal(GVar, Kind); + unsigned Flags = SectionFlagsForGlobal(GVar, Name.c_str()); + return getNamedSection(Name.c_str(), Flags); + } else { + switch (Kind) { case SectionKind::Data: - return getDataSection(); + return getDataSection_(); case SectionKind::BSS: // ELF targets usually have BSS sections - return getBSSSection(); + return getBSSSection_(); case SectionKind::ROData: - return getReadOnlySection(); + return getReadOnlySection_(); case SectionKind::RODataMergeStr: return MergeableStringSection(GVar); case SectionKind::RODataMergeConst: return MergeableConstSection(GVar); case SectionKind::ThreadData: // ELF targets usually support TLS stuff - return getTLSDataSection(); + return getTLSDataSection_(); case SectionKind::ThreadBSS: - return getTLSBSSSection(); + return getTLSBSSSection_(); default: assert(0 && "Unsuported section kind for global"); } @@ -461,87 +453,52 @@ X86ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV) const { assert(0 && "Unsupported global"); } -std::string +const Section* X86ELFTargetAsmInfo::MergeableConstSection(const GlobalVariable *GV) const { - unsigned Flags = SectionFlagsForGlobal(GV, GV->getSection().c_str()); - unsigned Size = SectionFlags::getEntitySize(Flags); + const TargetData *TD = X86TM->getTargetData(); + Constant *C = cast(GV)->getInitializer(); + const Type *Type = C->getType(); // FIXME: string here is temporary, until stuff will fully land in. // We cannot use {Four,Eight,Sixteen}ByteConstantSection here, since it's // currently directly used by asmprinter. - if (Size == 4 || Size == 8 || Size == 16) - return ".rodata.cst" + utostr(Size); + unsigned Size = TD->getABITypeSize(Type); + if (Size == 4 || Size == 8 || Size == 16) { + std::string Name = ".rodata.cst" + utostr(Size); - return getReadOnlySection(); + return getNamedSection(Name.c_str(), + SectionFlags::setEntitySize(SectionFlags::Mergeable, + Size)); + } + + return getReadOnlySection_(); } -std::string +const Section* X86ELFTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const { - unsigned Flags = SectionFlagsForGlobal(GV, GV->getSection().c_str()); - unsigned Size = SectionFlags::getEntitySize(Flags); + const TargetData *TD = X86TM->getTargetData(); + Constant *C = cast(GV)->getInitializer(); + const ConstantArray *CVA = cast(C); + const Type *Type = CVA->getType()->getElementType(); - if (Size) { + unsigned Size = TD->getABITypeSize(Type); + if (Size <= 16) { // We also need alignment here const TargetData *TD = X86TM->getTargetData(); unsigned Align = TD->getPreferredAlignment(GV); if (Align < Size) Align = Size; - return getCStringSection() + utostr(Size) + '.' + utostr(Align); + std::string Name = getCStringSection() + utostr(Size) + '.' + utostr(Align); + unsigned Flags = SectionFlags::setEntitySize(SectionFlags::Mergeable | + SectionFlags::Strings, + Size); + return getNamedSection(Name.c_str(), Flags); } - return getReadOnlySection(); + return getReadOnlySection_(); } -unsigned -X86ELFTargetAsmInfo::SectionFlagsForGlobal(const GlobalValue *GV, - const char* name) const { - unsigned Flags = - TargetAsmInfo::SectionFlagsForGlobal(GV, - GV->getSection().c_str()); - - // If there was decision to put stuff into mergeable section - calculate - // entity size - if (Flags & SectionFlags::Mergeable) { - const TargetData *TD = X86TM->getTargetData(); - Constant *C = cast(GV)->getInitializer(); - const Type *Type; - - if (Flags & SectionFlags::Strings) { - const ConstantArray *CVA = cast(C); - Type = CVA->getType()->getElementType(); - } else - Type = C->getType(); - - unsigned Size = TD->getABITypeSize(Type); - // FIXME: size check here ugly, and will hopefully have gone, when we will - // have sane interface for attaching flags to sections. - if (Size > 16 || - !(Flags & SectionFlags::Strings || - (Size == 4 || Size == 8 || Size == 16))) { - // Not suitable for mergeable - Size = 0; - Flags &= ~SectionFlags::Mergeable; - } - Flags = SectionFlags::setEntitySize(Flags, Size); - } - - // FIXME: This is hacky and will be removed when switching from std::string - // sections into 'general' ones - - // Mark section as named, when needed (so, we we will need .section directive - // to switch into it). - unsigned TypeFlags = Flags & SectionFlags::TypeFlags; - if (!TypeFlags /* Read-only section */ || - (TypeFlags & (SectionFlags::Mergeable | - SectionFlags::TLS | - SectionFlags::Linkonce))) - Flags |= SectionFlags::Named; - - return Flags; -} - - std::string X86ELFTargetAsmInfo::PrintSectionFlags(unsigned flags) const { std::string Flags = ",\""; @@ -663,25 +620,6 @@ X86COFFTargetAsmInfo::UniqueSectionForGlobal(const GlobalValue* GV, } } -unsigned -X86COFFTargetAsmInfo::SectionFlagsForGlobal(const GlobalValue *GV, - const char* name) const { - unsigned Flags = - TargetAsmInfo::SectionFlagsForGlobal(GV, - GV->getSection().c_str()); - - // Mark section as named, when needed (so, we we will need .section directive - // to switch into it). - unsigned TypeFlags = Flags & SectionFlags::TypeFlags; - if (!TypeFlags /* Read-only section */ || - (TypeFlags & (SectionFlags::Mergeable | - SectionFlags::TLS | - SectionFlags::Linkonce))) - Flags |= SectionFlags::Named; - - return Flags; -} - std::string X86COFFTargetAsmInfo::PrintSectionFlags(unsigned flags) const { std::string Flags = ",\""; diff --git a/lib/Target/X86/X86TargetAsmInfo.h b/lib/Target/X86/X86TargetAsmInfo.h index bf68bf136d5..2fc2d65af7c 100644 --- a/lib/Target/X86/X86TargetAsmInfo.h +++ b/lib/Target/X86/X86TargetAsmInfo.h @@ -34,16 +34,19 @@ namespace llvm { }; struct X86DarwinTargetAsmInfo : public X86TargetAsmInfo { + const Section* TextCoalSection; + const Section* ConstDataCoalSection; + const Section* ConstDataSection; + const Section* DataCoalSection; + explicit X86DarwinTargetAsmInfo(const X86TargetMachine &TM); virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, bool Global) const; - virtual std::string SelectSectionForGlobal(const GlobalValue *GV) const; - virtual unsigned SectionFlagsForGlobal(const GlobalValue *GV, - const char* name) const; + virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const; virtual std::string UniqueSectionForGlobal(const GlobalValue* GV, SectionKind::Kind kind) const; - std::string MergeableConstSection(const GlobalVariable *GV) const; - std::string MergeableStringSection(const GlobalVariable *GV) const; + const Section* MergeableConstSection(const GlobalVariable *GV) const; + const Section* MergeableStringSection(const GlobalVariable *GV) const; }; struct X86ELFTargetAsmInfo : public X86TargetAsmInfo { @@ -51,20 +54,16 @@ namespace llvm { virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, bool Global) const; - virtual std::string SelectSectionForGlobal(const GlobalValue *GV) const; - virtual unsigned SectionFlagsForGlobal(const GlobalValue *GV, - const char* name) const; + virtual const Section* SelectSectionForGlobal(const GlobalValue *GV) const; virtual std::string PrintSectionFlags(unsigned flags) const; - std::string MergeableConstSection(const GlobalVariable *GV) const; - std::string MergeableStringSection(const GlobalVariable *GV) const; + const Section* MergeableConstSection(const GlobalVariable *GV) const; + const Section* MergeableStringSection(const GlobalVariable *GV) const ; }; struct X86COFFTargetAsmInfo : public X86TargetAsmInfo { explicit X86COFFTargetAsmInfo(const X86TargetMachine &TM); virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, bool Global) const; - virtual unsigned SectionFlagsForGlobal(const GlobalValue *GV, - const char* name) const; virtual std::string UniqueSectionForGlobal(const GlobalValue* GV, SectionKind::Kind kind) const; virtual std::string PrintSectionFlags(unsigned flags) const;