maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

First sketch of special section objects 

llvm-svn: 53320
This commit is contained in:
Anton Korobeynikov 2008-07-09 13:28:49 +00:00
parent 03dc8bf4d6
commit daee281590
4 changed files with 242 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
llvm/include/llvm/Target/TargetAsmInfo.h
View File

@ -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 <string>
@ -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<Section>;
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<Section> 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;

82
llvm/lib/Target/TargetAsmInfo.cpp
View File

@ -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;
}

256
llvm/lib/Target/X86/X86TargetAsmInfo.cpp
View File

@ -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<GlobalVariable>(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<GlobalVariable>(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<GlobalVariable>(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<GlobalVariable>(GV)->getInitializer();
const Type *Type = cast<ConstantArray>(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<GlobalVariable>(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<X86Subtarget>().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<GlobalVariable>(GV)->getInitializer();
const Type *Type;
if (Flags & SectionFlags::Strings) {
const ConstantArray *CVA = cast<ConstantArray>(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<X86Subtarget>().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<Function>(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<GlobalVariable>(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<GlobalVariable>(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<GlobalVariable>(GV)->getInitializer();
const ConstantArray *CVA = cast<ConstantArray>(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<GlobalVariable>(GV)->getInitializer();
const Type *Type;
if (Flags & SectionFlags::Strings) {
const ConstantArray *CVA = cast<ConstantArray>(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 = ",\"";

23
llvm/lib/Target/X86/X86TargetAsmInfo.h
View File

@ -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;