RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-03 22:01:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

make SectionKind be a first-class pod struct instead of just

Browse Source 
an enum.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77096 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2009-07-25 23:21:55 +00:00
parent 7d509134dc
commit 460d51e0c0
10 changed files with 87 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Target/DarwinTargetAsmInfo.h
View File

@ -35,7 +35,7 @@ namespace llvm {
explicit DarwinTargetAsmInfo(const TargetMachine &TM); explicit DarwinTargetAsmInfo(const TargetMachine &TM);
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV, virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) const; SectionKind Kind) const;
virtual bool emitUsedDirectiveFor(const GlobalValue *GV, virtual bool emitUsedDirectiveFor(const GlobalValue *GV,
Mangler *Mang) const; Mangler *Mang) const;

4
include/llvm/Target/ELFTargetAsmInfo.h
View File

@ -37,10 +37,10 @@ namespace llvm {
/// ".tbss" gets the TLS bit set etc. /// ".tbss" gets the TLS bit set etc.
virtual unsigned getFlagsForNamedSection(const char *Section) const; virtual unsigned getFlagsForNamedSection(const char *Section) const;
const char *getSectionPrefixForUniqueGlobal(SectionKind::Kind Kind) const; const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) const;
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV, virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) const; SectionKind Kind) const;
virtual std::string printSectionFlags(unsigned flags) const; virtual std::string printSectionFlags(unsigned flags) const;
const Section* DataRelSection; const Section* DataRelSection;

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

@ -31,7 +31,9 @@ namespace llvm {
}; };
} }
namespace SectionKind { /// SectionKind - This is a simple POD value that classifies the properties of
/// a section.
struct SectionKind {
enum Kind { enum Kind {
Unknown = 0, ///< Custom section. Unknown = 0, ///< Custom section.
Text, ///< Text section. Text, ///< Text section.
@ -53,9 +55,12 @@ namespace llvm {
/// Thread local data. /// Thread local data.
ThreadData, ///< Initialized TLS data objects ThreadData, ///< Initialized TLS data objects
ThreadBSS ///< Uninitialized TLS data objects ThreadBSS ///< Uninitialized TLS data objects
}; } K; // This is private.
// FIXME: Eliminate.
Kind getKind() const { return K; }
static inline bool isReadOnly(Kind K) { bool isReadOnly() const {
return (K == SectionKind::ROData || return (K == SectionKind::ROData ||
K == SectionKind::DataRelRO || K == SectionKind::DataRelRO ||
K == SectionKind::DataRelROLocal || K == SectionKind::DataRelROLocal ||
@ -63,20 +68,20 @@ namespace llvm {
K == SectionKind::RODataMergeStr); K == SectionKind::RODataMergeStr);
} }
static inline bool isBSS(Kind K) { bool isBSS() const {
return K == BSS || K == ThreadBSS; return K == BSS || K == ThreadBSS;
} }
static inline bool isTLS(Kind K) { bool isTLS() const {
return K == ThreadData || K == ThreadBSS; return K == ThreadData || K == ThreadBSS;
} }
static inline bool isCode(Kind K) { bool isCode() const {
return K == Text; return K == Text;
} }
static inline bool isWritable(Kind K) { bool isWritable() const {
return isTLS(K) || return isTLS() ||
K == SectionKind::Data || K == SectionKind::Data ||
K == SectionKind::DataRel || K == SectionKind::DataRel ||
K == SectionKind::DataRelLocal || K == SectionKind::DataRelLocal ||
@ -84,7 +89,24 @@ namespace llvm {
K == SectionKind::DataRelROLocal || K == SectionKind::DataRelROLocal ||
K == SectionKind::BSS; K == SectionKind::BSS;
} }
}
static SectionKind get(Kind K) {
SectionKind Res = { K };
return Res;
}
static SectionKind getText() { return get(Text); }
static SectionKind getBSS() { return get(BSS); }
static SectionKind getData() { return get(Data); }
static SectionKind getDataRel() { return get(DataRel); }
static SectionKind getDataRelLocal() { return get(DataRelLocal); }
static SectionKind getROData() { return get(ROData); }
static SectionKind getDataRelRO() { return get(DataRelRO); }
static SectionKind getDataRelROLocal() { return get(DataRelROLocal); }
static SectionKind getRODataMergeStr() { return get(RODataMergeStr); }
static SectionKind getRODataMergeConst() { return get(RODataMergeConst); }
static SectionKind getThreadData() { return get(ThreadData); }
static SectionKind getThreadBSS() { return get(ThreadBSS); }
};
namespace SectionFlags { namespace SectionFlags {
const unsigned Invalid = -1U; const unsigned Invalid = -1U;
@ -109,8 +131,9 @@ namespace llvm {
return (Flags >> 24) & 0xFF; return (Flags >> 24) & 0xFF;
} }
// FIXME: Why does this return a value?
static inline unsigned setEntitySize(unsigned Flags, unsigned Size) { static inline unsigned setEntitySize(unsigned Flags, unsigned Size) {
return ((Flags & ~EntitySize) | ((Size & 0xFF) << 24)); return (Flags & ~EntitySize) | ((Size & 0xFF) << 24);
} }
struct KeyInfo { struct KeyInfo {
@ -604,7 +627,7 @@ namespace llvm {
/// global. This is important for globals that need to be merged across /// global. This is important for globals that need to be merged across
/// translation units. /// translation units.
virtual const char * virtual const char *
getSectionPrefixForUniqueGlobal(SectionKind::Kind Kind) const { getSectionPrefixForUniqueGlobal(SectionKind Kind) const {
return 0; return 0;
} }
@ -628,7 +651,7 @@ namespace llvm {
/// getFlagsForNamedSection. /// getFlagsForNamedSection.
virtual const Section * virtual const Section *
getSpecialCasedSectionGlobals(const GlobalValue *GV, getSpecialCasedSectionGlobals(const GlobalValue *GV,
SectionKind::Kind Kind) const{ SectionKind Kind) const {
return 0; return 0;
} }
@ -637,7 +660,7 @@ namespace llvm {
// FIXME: Eliminate this. // FIXME: Eliminate this.
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV, virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) const; SectionKind Kind) const;
/// getSLEB128Size - Compute the number of bytes required for a signed /// getSLEB128Size - Compute the number of bytes required for a signed
/// leb128 value. /// leb128 value.

4
lib/Target/DarwinTargetAsmInfo.cpp
View File

@ -126,12 +126,12 @@ bool DarwinTargetAsmInfo::emitUsedDirectiveFor(const GlobalValue* GV,
const Section* const Section*
DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV, DarwinTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) const { SectionKind Kind) const {
// FIXME: Use sectionflags:linkonce instead of isWeakForLinker() here. // FIXME: Use sectionflags:linkonce instead of isWeakForLinker() here.
bool isWeak = GV->isWeakForLinker(); bool isWeak = GV->isWeakForLinker();
bool isNonStatic = TM.getRelocationModel() != Reloc::Static; bool isNonStatic = TM.getRelocationModel() != Reloc::Static;
switch (Kind) { switch (Kind.getKind()) {
case SectionKind::ThreadData: case SectionKind::ThreadData:
case SectionKind::ThreadBSS: case SectionKind::ThreadBSS:
llvm_unreachable("Darwin doesn't support TLS"); llvm_unreachable("Darwin doesn't support TLS");

8
lib/Target/ELFTargetAsmInfo.cpp
View File

@ -48,7 +48,7 @@ ELFTargetAsmInfo::ELFTargetAsmInfo(const TargetMachine &TM)
const Section* const Section*
ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV, ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) const { SectionKind Kind) const {
if (const Function *F = dyn_cast<Function>(GV)) { if (const Function *F = dyn_cast<Function>(GV)) {
switch (F->getLinkage()) { switch (F->getLinkage()) {
default: llvm_unreachable("Unknown linkage type!"); default: llvm_unreachable("Unknown linkage type!");
@ -62,7 +62,7 @@ ELFTargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV,
} }
const GlobalVariable *GVar = cast<GlobalVariable>(GV); const GlobalVariable *GVar = cast<GlobalVariable>(GV);
switch (Kind) { switch (Kind.getKind()) {
default: llvm_unreachable("Unsuported section kind for global"); default: llvm_unreachable("Unsuported section kind for global");
case SectionKind::BSS: case SectionKind::BSS:
return getBSSSection_(); return getBSSSection_();
@ -147,8 +147,8 @@ unsigned ELFTargetAsmInfo::getFlagsForNamedSection(const char *Name) const {
const char * const char *
ELFTargetAsmInfo::getSectionPrefixForUniqueGlobal(SectionKind::Kind Kind) const{ ELFTargetAsmInfo::getSectionPrefixForUniqueGlobal(SectionKind Kind) const{
switch (Kind) { switch (Kind.getKind()) {
default: llvm_unreachable("Unknown section kind"); default: llvm_unreachable("Unknown section kind");
case SectionKind::Text: return ".gnu.linkonce.t."; case SectionKind::Text: return ".gnu.linkonce.t.";
case SectionKind::Data: return ".gnu.linkonce.d."; case SectionKind::Data: return ".gnu.linkonce.d.";

4
lib/Target/PIC16/PIC16TargetAsmInfo.cpp
View File

@ -187,7 +187,7 @@ PIC16TargetAsmInfo::getSectionForAuto(const GlobalVariable *GV) const {
// multiple data sections if required. // multiple data sections if required.
const Section* const Section*
PIC16TargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV1, PIC16TargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV1,
SectionKind::Kind Kind) const { SectionKind Kind) const {
// We select the section based on the initializer here, so it really // We select the section based on the initializer here, so it really
// has to be a GlobalVariable. // has to be a GlobalVariable.
const GlobalVariable *GV = dyn_cast<GlobalVariable>(GV1); const GlobalVariable *GV = dyn_cast<GlobalVariable>(GV1);
@ -247,7 +247,7 @@ PIC16TargetAsmInfo::~PIC16TargetAsmInfo() {
/// section assignment of a global. /// section assignment of a global.
const Section * const Section *
PIC16TargetAsmInfo::getSpecialCasedSectionGlobals(const GlobalValue *GV, PIC16TargetAsmInfo::getSpecialCasedSectionGlobals(const GlobalValue *GV,
SectionKind::Kind Kind) const{ SectionKind Kind) const {
// If GV has a sectin name or section address create that section now. // If GV has a sectin name or section address create that section now.
if (GV->hasSection()) { if (GV->hasSection()) {
if (const GlobalVariable *GVar = cast<GlobalVariable>(GV)) { if (const GlobalVariable *GVar = cast<GlobalVariable>(GV)) {

4
lib/Target/PIC16/PIC16TargetAsmInfo.h
View File

@ -75,7 +75,7 @@ namespace llvm {
const Section *CreateROSectionForGlobal(const GlobalVariable *GV, const Section *CreateROSectionForGlobal(const GlobalVariable *GV,
std::string Addr = "") const; std::string Addr = "") const;
virtual const Section *SelectSectionForGlobal(const GlobalValue *GV, virtual const Section *SelectSectionForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) const; SectionKind Kind) const;
const Section *CreateSectionForGlobal(const GlobalVariable *GV, const Section *CreateSectionForGlobal(const GlobalVariable *GV,
const std::string &Addr = "") const; const std::string &Addr = "") const;
public: public:
@ -97,7 +97,7 @@ namespace llvm {
/// section assignment of a global. /// section assignment of a global.
virtual const Section * virtual const Section *
getSpecialCasedSectionGlobals(const GlobalValue *GV, getSpecialCasedSectionGlobals(const GlobalValue *GV,
SectionKind::Kind Kind) const; SectionKind Kind) const;
}; };

58
lib/Target/TargetAsmInfo.cpp
View File

@ -174,8 +174,12 @@ static bool isSuitableForBSS(const GlobalVariable *GV) {
if (!GV->getSection().empty()) if (!GV->getSection().empty())
return false; return false;
// Otherwise, put it in BSS unless the target really doesn't want us to. // If -nozero-initialized-in-bss is specified, don't ever use BSS.
return !NoZerosInBSS; if (NoZerosInBSS)
return false;
// Otherwise, put it in BSS!
return true;
} }
static bool isConstantString(const Constant *C) { static bool isConstantString(const Constant *C) {
@ -195,39 +199,39 @@ static bool isConstantString(const Constant *C) {
} }
static unsigned SectionFlagsForGlobal(const GlobalValue *GV, static unsigned SectionFlagsForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) { SectionKind Kind) {
// Decode flags from global and section kind. // Decode flags from global and section kind.
unsigned Flags = SectionFlags::None; unsigned Flags = SectionFlags::None;
if (GV->isWeakForLinker()) if (GV->isWeakForLinker())
Flags |= SectionFlags::Linkonce; Flags |= SectionFlags::Linkonce;
if (SectionKind::isBSS(Kind)) if (Kind.isBSS())
Flags |= SectionFlags::BSS; Flags |= SectionFlags::BSS;
if (SectionKind::isTLS(Kind)) if (Kind.isTLS())
Flags |= SectionFlags::TLS; Flags |= SectionFlags::TLS;
if (SectionKind::isCode(Kind)) if (Kind.isCode())
Flags |= SectionFlags::Code; Flags |= SectionFlags::Code;
if (SectionKind::isWritable(Kind)) if (Kind.isWritable())
Flags |= SectionFlags::Writable; Flags |= SectionFlags::Writable;
return Flags; return Flags;
} }
static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV, static SectionKind SectionKindForGlobal(const GlobalValue *GV,
Reloc::Model ReloModel) { Reloc::Model ReloModel) {
// Early exit - functions should be always in text sections. // Early exit - functions should be always in text sections.
const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV); const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
if (GVar == 0) if (GVar == 0)
return SectionKind::Text; return SectionKind::getText();
bool isThreadLocal = GVar->isThreadLocal(); bool isThreadLocal = GVar->isThreadLocal();
// Variable can be easily put to BSS section. // Variable can be easily put to BSS section.
if (isSuitableForBSS(GVar)) if (isSuitableForBSS(GVar))
return isThreadLocal ? SectionKind::ThreadBSS : SectionKind::BSS; return isThreadLocal ? SectionKind::getThreadBSS() : SectionKind::getBSS();
// If this is thread-local, put it in the general "thread_data" section. // If this is thread-local, put it in the general "thread_data" section.
if (isThreadLocal) if (isThreadLocal)
return SectionKind::ThreadData; return SectionKind::getThreadData();
Constant *C = GVar->getInitializer(); Constant *C = GVar->getInitializer();
@ -243,32 +247,32 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
// If initializer is a null-terminated string, put it in a "cstring" // If initializer is a null-terminated string, put it in a "cstring"
// section if the target has it. // section if the target has it.
if (isConstantString(C)) if (isConstantString(C))
return SectionKind::RODataMergeStr; return SectionKind::getRODataMergeStr();
// Otherwise, just drop it into a mergable constant section. // Otherwise, just drop it into a mergable constant section.
return SectionKind::RODataMergeConst; return SectionKind::getRODataMergeConst();
case Constant::LocalRelocation: case Constant::LocalRelocation:
// In static relocation model, the linker will resolve all addresses, so // In static relocation model, the linker will resolve all addresses, so
// the relocation entries will actually be constants by the time the app // the relocation entries will actually be constants by the time the app
// starts up. // starts up.
if (ReloModel == Reloc::Static) if (ReloModel == Reloc::Static)
return SectionKind::ROData; return SectionKind::getROData();
// Otherwise, the dynamic linker needs to fix it up, put it in the // Otherwise, the dynamic linker needs to fix it up, put it in the
// writable data.rel.local section. // writable data.rel.local section.
return SectionKind::DataRelROLocal; return SectionKind::getDataRelROLocal();
case Constant::GlobalRelocations: case Constant::GlobalRelocations:
// In static relocation model, the linker will resolve all addresses, so // In static relocation model, the linker will resolve all addresses, so
// the relocation entries will actually be constants by the time the app // the relocation entries will actually be constants by the time the app
// starts up. // starts up.
if (ReloModel == Reloc::Static) if (ReloModel == Reloc::Static)
return SectionKind::ROData; return SectionKind::getROData();
// Otherwise, the dynamic linker needs to fix it up, put it in the // Otherwise, the dynamic linker needs to fix it up, put it in the
// writable data.rel section. // writable data.rel section.
return SectionKind::DataRelRO; return SectionKind::getDataRelRO();
} }
} }
@ -278,13 +282,13 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
// globals together onto fewer pages, improving the locality of the dynamic // globals together onto fewer pages, improving the locality of the dynamic
// linker. // linker.
if (ReloModel == Reloc::Static) if (ReloModel == Reloc::Static)
return SectionKind::Data; return SectionKind::getData();
switch (C->getRelocationInfo()) { switch (C->getRelocationInfo()) {
default: llvm_unreachable("unknown relocation info kind"); default: llvm_unreachable("unknown relocation info kind");
case Constant::NoRelocation: return SectionKind::Data; case Constant::NoRelocation: return SectionKind::getData();
case Constant::LocalRelocation: return SectionKind::DataRelLocal; case Constant::LocalRelocation: return SectionKind::getDataRelLocal();
case Constant::GlobalRelocations: return SectionKind::DataRel; case Constant::GlobalRelocations: return SectionKind::getDataRel();
} }
} }
@ -295,7 +299,7 @@ const Section *TargetAsmInfo::SectionForGlobal(const GlobalValue *GV) const {
assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() && assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
"Can only be used for global definitions"); "Can only be used for global definitions");
SectionKind::Kind Kind = SectionKindForGlobal(GV, TM.getRelocationModel()); SectionKind Kind = SectionKindForGlobal(GV, TM.getRelocationModel());
// Select section name. // Select section name.
if (GV->hasSection()) { if (GV->hasSection()) {
@ -337,15 +341,15 @@ const Section *TargetAsmInfo::SectionForGlobal(const GlobalValue *GV) const {
// Lame default implementation. Calculate the section name for global. // Lame default implementation. Calculate the section name for global.
const Section* const Section*
TargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV, TargetAsmInfo::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind::Kind Kind) const { SectionKind Kind) const {
if (SectionKind::isCode(Kind)) if (Kind.isCode())
return getTextSection(); return getTextSection();
if (SectionKind::isBSS(SectionKind::BSS)) if (Kind.isBSS())
if (const Section *S = getBSSSection_()) if (const Section *S = getBSSSection_())
return S; return S;
if (SectionKind::isReadOnly(Kind)) if (Kind.isReadOnly())
if (const Section *S = getReadOnlySection()) if (const Section *S = getReadOnlySection())
return S; return S;

22
lib/Target/X86/X86TargetAsmInfo.cpp
View File

@ -266,22 +266,12 @@ X86COFFTargetAsmInfo::PreferredEHDataFormat(DwarfEncoding::Target Reason,
} }
const char *X86COFFTargetAsmInfo:: const char *X86COFFTargetAsmInfo::
getSectionPrefixForUniqueGlobal(SectionKind::Kind Kind) const { getSectionPrefixForUniqueGlobal(SectionKind Kind) const {
switch (Kind) { if (Kind.isCode())
default: llvm_unreachable("Unknown section kind"); return ".text$linkonce";
case SectionKind::Text: return ".text$linkonce"; if (Kind.isWritable())
case SectionKind::Data: return ".data$linkonce";
case SectionKind::DataRelLocal: return ".rdata$linkonce";
case SectionKind::DataRel:
case SectionKind::BSS:
case SectionKind::ThreadData:
case SectionKind::ThreadBSS: return ".data$linkonce";
case SectionKind::ROData:
case SectionKind::DataRelRO:
case SectionKind::DataRelROLocal:
case SectionKind::RODataMergeConst:
case SectionKind::RODataMergeStr: return ".rdata$linkonce";
}
} }
std::string X86COFFTargetAsmInfo::printSectionFlags(unsigned flags) const { std::string X86COFFTargetAsmInfo::printSectionFlags(unsigned flags) const {

2
lib/Target/X86/X86TargetAsmInfo.h
View File

@ -54,7 +54,7 @@ namespace llvm {
virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason, virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
bool Global) const; bool Global) const;
virtual const char * virtual const char *
getSectionPrefixForUniqueGlobal(SectionKind::Kind kind) const; getSectionPrefixForUniqueGlobal(SectionKind kind) const;
virtual std::string printSectionFlags(unsigned flags) const; virtual std::string printSectionFlags(unsigned flags) const;
}; };