Change SectionKind to be a property that is true of a *section*, it
should have no state that is specific to particular globals in the
section. In this case, it means the removal of the "isWeak" and
"ExplicitSection" bits. MCSection uses the new form of SectionKind.
To handle isWeak, I introduced a new SectionInfo class, which is
SectionKind + isWeak, and it is used by the part of the code generator
that does classification of a specific global.
The ExplicitSection disappears. It is moved onto MCSection as a new
"IsDirective" bit. Since the Name of a section is either a section
or directive, it makes sense to keep this bit in MCSection. Ultimately
the creator of MCSection should canonicalize (e.g.) .text to whatever
the actual section is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77803 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Target/Alpha/AlphaISelLowering.cpp b/lib/Target/Alpha/AlphaISelLowering.cpp
index c5f24dc..001723a2 100644
--- a/lib/Target/Alpha/AlphaISelLowering.cpp
+++ b/lib/Target/Alpha/AlphaISelLowering.cpp
@@ -36,8 +36,10 @@
public:
void Initialize(MCContext &Ctx, const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM);
- TextSection = getOrCreateSection("_text", true, SectionKind::Text);
- DataSection = getOrCreateSection("_data", true, SectionKind::DataRel);
+ TextSection = getOrCreateSection("_text", true,
+ SectionKind::get(SectionKind::Text));
+ DataSection = getOrCreateSection("_data", true,
+ SectionKind::get(SectionKind::DataRel));
}
};
}
diff --git a/lib/Target/PIC16/PIC16AsmPrinter.cpp b/lib/Target/PIC16/PIC16AsmPrinter.cpp
index 604d105..596ec7a 100644
--- a/lib/Target/PIC16/PIC16AsmPrinter.cpp
+++ b/lib/Target/PIC16/PIC16AsmPrinter.cpp
@@ -73,7 +73,7 @@
const MCSection *fCodeSection =
getObjFileLowering().getOrCreateSection(codeSection, false,
- SectionKind::Text);
+ SectionKind::get(SectionKind::Text));
// Start the Code Section.
O << "\n";
SwitchToSection(fCodeSection);
@@ -350,7 +350,7 @@
const MCSection *fPDataSection =
getObjFileLowering().getOrCreateSection(SectionName, false,
- SectionKind::DataRel);
+ SectionKind::get(SectionKind::DataRel));
SwitchToSection(fPDataSection);
// Emit function frame label
diff --git a/lib/Target/PIC16/PIC16TargetObjectFile.cpp b/lib/Target/PIC16/PIC16TargetObjectFile.cpp
index 5a2d4d8..91e98b2 100644
--- a/lib/Target/PIC16/PIC16TargetObjectFile.cpp
+++ b/lib/Target/PIC16/PIC16TargetObjectFile.cpp
@@ -19,24 +19,27 @@
TargetLoweringObjectFile::Initialize(Ctx, tm);
TM = &tm;
- BSSSection_ = getOrCreateSection("udata.# UDATA", false, SectionKind::BSS);
+ BSSSection_ = getOrCreateSection("udata.# UDATA", false,
+ SectionKind::get(SectionKind::BSS));
ReadOnlySection = getOrCreateSection("romdata.# ROMDATA", false,
- SectionKind::ReadOnly);
- DataSection = getOrCreateSection("idata.# IDATA", false,SectionKind::DataRel);
+ SectionKind::get(SectionKind::ReadOnly));
+ DataSection = getOrCreateSection("idata.# IDATA", false,
+ SectionKind::get(SectionKind::DataRel));
// Need because otherwise a .text symbol is emitted by DwarfWriter
// in BeginModule, and gpasm cribbs for that .text symbol.
- TextSection = getOrCreateSection("", true, SectionKind::Text);
+ TextSection = getOrCreateSection("", true,
+ SectionKind::get(SectionKind::Text));
ROSections.push_back(new PIC16Section(ReadOnlySection));
// FIXME: I don't know what the classification of these sections really is.
ExternalVarDecls = new PIC16Section(getOrCreateSection("ExternalVarDecls",
false,
- SectionKind::Metadata));
+ SectionKind::get(SectionKind::Metadata)));
ExternalVarDefs = new PIC16Section(getOrCreateSection("ExternalVarDefs",
false,
- SectionKind::Metadata));
+ SectionKind::get(SectionKind::Metadata)));
}
@@ -66,7 +69,7 @@
std::string name = PAN::getUdataSectionName(BSSSections.size());
const MCSection *NewSection = getOrCreateSection(name.c_str(), false,
// FIXME.
- SectionKind::Metadata);
+ SectionKind::get(SectionKind::Metadata));
FoundBSS = new PIC16Section(NewSection);
@@ -108,7 +111,7 @@
std::string name = PAN::getIdataSectionName(IDATASections.size());
const MCSection *NewSection = getOrCreateSection(name.c_str(), false,
// FIXME.
- SectionKind::Metadata);
+ SectionKind::get(SectionKind::Metadata));
FoundIDATA = new PIC16Section(NewSection);
@@ -144,7 +147,7 @@
const MCSection *NewSection = getOrCreateSection(name.c_str(),
// FIXME.
false,
- SectionKind::Metadata);
+ SectionKind::get(SectionKind::Metadata));
FoundAutoSec = new PIC16Section(NewSection);
@@ -163,14 +166,14 @@
// multiple data sections if required.
const MCSection *
PIC16TargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV1,
- SectionKind Kind,
+ SectionInfo Info,
Mangler *Mang,
const TargetMachine &TM) const {
// We select the section based on the initializer here, so it really
// has to be a GlobalVariable.
const GlobalVariable *GV = dyn_cast<GlobalVariable>(GV1);
if (!GV)
- return TargetLoweringObjectFile::SelectSectionForGlobal(GV1, Kind, Mang,TM);
+ return TargetLoweringObjectFile::SelectSectionForGlobal(GV1, Info, Mang,TM);
// Record External Var Decls.
if (GV->isDeclaration()) {
@@ -204,7 +207,7 @@
return getROSectionForGlobal(GV);
// Else let the default implementation take care of it.
- return TargetLoweringObjectFile::SelectSectionForGlobal(GV, Kind, Mang,TM);
+ return TargetLoweringObjectFile::SelectSectionForGlobal(GV, Info, Mang,TM);
}
PIC16TargetObjectFile::~PIC16TargetObjectFile() {
@@ -226,7 +229,7 @@
const MCSection *
PIC16TargetObjectFile::getSpecialCasedSectionGlobals(const GlobalValue *GV,
Mangler *Mang,
- SectionKind Kind) const {
+ SectionInfo Info) const {
// If GV has a sectin name or section address create that section now.
if (GV->hasSection()) {
if (const GlobalVariable *GVar = cast<GlobalVariable>(GV)) {
@@ -297,7 +300,7 @@
PIC16Section *NewBSS = FoundBSS;
if (NewBSS == NULL) {
const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
- SectionKind::BSS);
+ SectionKind::get(SectionKind::BSS));
NewBSS = new PIC16Section(NewSection);
BSSSections.push_back(NewBSS);
}
@@ -350,7 +353,7 @@
if (NewIDATASec == NULL) {
const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
// FIXME:
- SectionKind::Metadata);
+ SectionKind::get(SectionKind::Metadata));
NewIDATASec = new PIC16Section(NewSection);
IDATASections.push_back(NewIDATASec);
}
@@ -389,7 +392,7 @@
PIC16Section *NewRomSec = FoundROSec;
if (NewRomSec == NULL) {
const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
- SectionKind::ReadOnly);
+ SectionKind::get(SectionKind::ReadOnly));
NewRomSec = new PIC16Section(NewSection);
ROSections.push_back(NewRomSec);
}
diff --git a/lib/Target/PIC16/PIC16TargetObjectFile.h b/lib/Target/PIC16/PIC16TargetObjectFile.h
index c296954..831f924 100644
--- a/lib/Target/PIC16/PIC16TargetObjectFile.h
+++ b/lib/Target/PIC16/PIC16TargetObjectFile.h
@@ -62,9 +62,9 @@
/// section assignment of a global.
virtual const MCSection *
getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
- SectionKind Kind) const;
+ SectionInfo Info) const;
virtual const MCSection *SelectSectionForGlobal(const GlobalValue *GV,
- SectionKind Kind,
+ SectionInfo Info,
Mangler *Mang,
const TargetMachine&) const;
private:
diff --git a/lib/Target/TargetLoweringObjectFile.cpp b/lib/Target/TargetLoweringObjectFile.cpp
index 025e3f2..b9e585d 100644
--- a/lib/Target/TargetLoweringObjectFile.cpp
+++ b/lib/Target/TargetLoweringObjectFile.cpp
@@ -81,26 +81,31 @@
return false;
}
-static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
- const TargetMachine &TM) {
+/// SectionKindForGlobal - This is a top-level target-independent classifier for
+/// a global variable. Given an global variable and information from TM, it
+/// classifies the global in a variety of ways that make various target
+/// implementations simpler. The target implementation is free to ignore this
+/// extra info of course.
+static SectionKind SectionKindForGlobal(const GlobalValue *GV,
+ const TargetMachine &TM) {
Reloc::Model ReloModel = TM.getRelocationModel();
// Early exit - functions should be always in text sections.
const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
if (GVar == 0)
- return SectionKind::Text;
+ return SectionKind::get(SectionKind::Text);
// Handle thread-local data first.
if (GVar->isThreadLocal()) {
if (isSuitableForBSS(GVar))
- return SectionKind::ThreadBSS;
- return SectionKind::ThreadData;
+ return SectionKind::get(SectionKind::ThreadBSS);
+ return SectionKind::get(SectionKind::ThreadData);
}
// Variable can be easily put to BSS section.
if (isSuitableForBSS(GVar))
- return SectionKind::BSS;
+ return SectionKind::get(SectionKind::BSS);
Constant *C = GVar->getInitializer();
@@ -116,16 +121,16 @@
// If initializer is a null-terminated string, put it in a "cstring"
// section if the target has it.
if (isConstantString(C))
- return SectionKind::MergeableCString;
+ return SectionKind::get(SectionKind::MergeableCString);
// Otherwise, just drop it into a mergable constant section. If we have
// a section for this size, use it, otherwise use the arbitrary sized
// mergable section.
switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
- case 4: return SectionKind::MergeableConst4;
- case 8: return SectionKind::MergeableConst8;
- case 16: return SectionKind::MergeableConst16;
- default: return SectionKind::MergeableConst;
+ case 4: return SectionKind::get(SectionKind::MergeableConst4);
+ case 8: return SectionKind::get(SectionKind::MergeableConst8);
+ case 16: return SectionKind::get(SectionKind::MergeableConst16);
+ default: return SectionKind::get(SectionKind::MergeableConst);
}
case Constant::LocalRelocation:
@@ -135,11 +140,11 @@
// the linker doesn't take relocations into consideration when it tries to
// merge entries in the section.
if (ReloModel == Reloc::Static)
- return SectionKind::ReadOnly;
+ return SectionKind::get(SectionKind::ReadOnly);
// Otherwise, the dynamic linker needs to fix it up, put it in the
// writable data.rel.local section.
- return SectionKind::ReadOnlyWithRelLocal;
+ return SectionKind::get(SectionKind::ReadOnlyWithRelLocal);
case Constant::GlobalRelocations:
// In static relocation model, the linker will resolve all addresses, so
@@ -148,11 +153,11 @@
// the linker doesn't take relocations into consideration when it tries to
// merge entries in the section.
if (ReloModel == Reloc::Static)
- return SectionKind::ReadOnly;
+ return SectionKind::get(SectionKind::ReadOnly);
// Otherwise, the dynamic linker needs to fix it up, put it in the
// writable data.rel section.
- return SectionKind::ReadOnlyWithRel;
+ return SectionKind::get(SectionKind::ReadOnlyWithRel);
}
}
@@ -162,16 +167,16 @@
// globals together onto fewer pages, improving the locality of the dynamic
// linker.
if (ReloModel == Reloc::Static)
- return SectionKind::DataNoRel;
+ return SectionKind::get(SectionKind::DataNoRel);
switch (C->getRelocationInfo()) {
default: llvm_unreachable("unknown relocation info kind");
case Constant::NoRelocation:
- return SectionKind::DataNoRel;
+ return SectionKind::get(SectionKind::DataNoRel);
case Constant::LocalRelocation:
- return SectionKind::DataRelLocal;
+ return SectionKind::get(SectionKind::DataRelLocal);
case Constant::GlobalRelocations:
- return SectionKind::DataRel;
+ return SectionKind::get(SectionKind::DataRel);
}
}
@@ -184,47 +189,44 @@
assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
"Can only be used for global definitions");
- SectionKind::Kind GVKind = SectionKindForGlobal(GV, TM);
+ SectionKind Kind = SectionKindForGlobal(GV, TM);
+ SectionInfo Info = SectionInfo::get(Kind, GV->isWeakForLinker());
- SectionKind Kind = SectionKind::get(GVKind, GV->isWeakForLinker(),
- GV->hasSection());
-
-
// Select section name.
if (GV->hasSection()) {
// If the target has special section hacks for specifically named globals,
// return them now.
- if (const MCSection *TS = getSpecialCasedSectionGlobals(GV, Mang, Kind))
+ if (const MCSection *TS = getSpecialCasedSectionGlobals(GV, Mang, Info))
return TS;
// If the target has magic semantics for certain section names, make sure to
// pick up the flags. This allows the user to write things with attribute
// section and still get the appropriate section flags printed.
- GVKind = getKindForNamedSection(GV->getSection().c_str(), GVKind);
+ Kind = getKindForNamedSection(GV->getSection().c_str(), Kind);
- return getOrCreateSection(GV->getSection().c_str(), false, GVKind);
+ return getOrCreateSection(GV->getSection().c_str(), false, Kind);
}
// Use default section depending on the 'type' of global
- return SelectSectionForGlobal(GV, Kind, Mang, TM);
+ return SelectSectionForGlobal(GV, Info, Mang, TM);
}
// Lame default implementation. Calculate the section name for global.
const MCSection *
TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
- SectionKind Kind,
+ SectionInfo Info,
Mangler *Mang,
const TargetMachine &TM) const{
- assert(!Kind.isThreadLocal() && "Doesn't support TLS");
+ assert(!Info.isThreadLocal() && "Doesn't support TLS");
- if (Kind.isText())
+ if (Info.isText())
return getTextSection();
- if (Kind.isBSS() && BSSSection_ != 0)
+ if (Info.isBSS() && BSSSection_ != 0)
return BSSSection_;
- if (Kind.isReadOnly() && ReadOnlySection != 0)
+ if (Info.isReadOnly() && ReadOnlySection != 0)
return ReadOnlySection;
return getDataSection();
@@ -244,12 +246,10 @@
const MCSection *TargetLoweringObjectFile::
-getOrCreateSection(const char *Name, bool isDirective,
- SectionKind::Kind Kind) const {
+getOrCreateSection(const char *Name, bool isDirective, SectionKind Kind) const {
if (MCSection *S = Ctx->GetSection(Name))
return S;
- SectionKind K = SectionKind::get(Kind, false /*weak*/, !isDirective);
- return MCSection::Create(Name, K, *Ctx);
+ return MCSection::Create(Name, isDirective, Kind, *Ctx);
}
@@ -262,45 +262,55 @@
const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM);
if (!HasCrazyBSS)
- BSSSection_ = getOrCreateSection("\t.bss", true, SectionKind::BSS);
+ BSSSection_ = getOrCreateSection("\t.bss", true,
+ SectionKind::get(SectionKind::BSS));
else
// PPC/Linux doesn't support the .bss directive, it needs .section .bss.
// FIXME: Does .section .bss work everywhere??
- BSSSection_ = getOrCreateSection("\t.bss", false, SectionKind::BSS);
+ // FIXME2: this should just be handle by the section printer. We should get
+ // away from syntactic view of the sections and MCSection should just be a
+ // semantic view.
+ BSSSection_ = getOrCreateSection("\t.bss", false,
+ SectionKind::get(SectionKind::BSS));
- TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
- DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
+ TextSection = getOrCreateSection("\t.text", true,
+ SectionKind::get(SectionKind::Text));
+ DataSection = getOrCreateSection("\t.data", true,
+ SectionKind::get(SectionKind::DataRel));
ReadOnlySection =
- getOrCreateSection("\t.rodata", false, SectionKind::ReadOnly);
+ getOrCreateSection("\t.rodata", false,
+ SectionKind::get(SectionKind::ReadOnly));
TLSDataSection =
- getOrCreateSection("\t.tdata", false, SectionKind::ThreadData);
+ getOrCreateSection("\t.tdata", false,
+ SectionKind::get(SectionKind::ThreadData));
CStringSection_ = getOrCreateSection("\t.rodata.str", true,
- SectionKind::MergeableCString);
+ SectionKind::get(SectionKind::MergeableCString));
- TLSBSSSection = getOrCreateSection("\t.tbss", false, SectionKind::ThreadBSS);
+ TLSBSSSection = getOrCreateSection("\t.tbss", false,
+ SectionKind::get(SectionKind::ThreadBSS));
DataRelSection = getOrCreateSection("\t.data.rel", false,
- SectionKind::DataRel);
+ SectionKind::get(SectionKind::DataRel));
DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
- SectionKind::DataRelLocal);
+ SectionKind::get(SectionKind::DataRelLocal));
DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
- SectionKind::ReadOnlyWithRel);
+ SectionKind::get(SectionKind::ReadOnlyWithRel));
DataRelROLocalSection =
getOrCreateSection("\t.data.rel.ro.local", false,
- SectionKind::ReadOnlyWithRelLocal);
+ SectionKind::get(SectionKind::ReadOnlyWithRelLocal));
MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
- SectionKind::MergeableConst4);
+ SectionKind::get(SectionKind::MergeableConst4));
MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
- SectionKind::MergeableConst8);
+ SectionKind::get(SectionKind::MergeableConst8));
MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
- SectionKind::MergeableConst16);
+ SectionKind::get(SectionKind::MergeableConst16));
}
-SectionKind::Kind TargetLoweringObjectFileELF::
-getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
+SectionKind TargetLoweringObjectFileELF::
+getKindForNamedSection(const char *Name, SectionKind K) const {
if (Name[0] != '.') return K;
// Some lame default implementation based on some magic section names.
@@ -308,19 +318,19 @@
strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
- return SectionKind::BSS;
+ return SectionKind::get(SectionKind::BSS);
if (strcmp(Name, ".tdata") == 0 ||
strncmp(Name, ".tdata.", 7) == 0 ||
strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
- return SectionKind::ThreadData;
+ return SectionKind::get(SectionKind::ThreadData);
if (strcmp(Name, ".tbss") == 0 ||
strncmp(Name, ".tbss.", 6) == 0 ||
strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
- return SectionKind::ThreadBSS;
+ return SectionKind::get(SectionKind::ThreadBSS);
return K;
}
@@ -400,20 +410,20 @@
}
const MCSection *TargetLoweringObjectFileELF::
-SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
Mangler *Mang, const TargetMachine &TM) const {
// If this global is linkonce/weak and the target handles this by emitting it
// into a 'uniqued' section name, create and return the section now.
- if (Kind.isWeak()) {
- const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
+ if (Info.isWeak()) {
+ const char *Prefix = getSectionPrefixForUniqueGlobal(Info);
std::string Name = Mang->makeNameProper(GV->getNameStr());
- return getOrCreateSection((Prefix+Name).c_str(), false, Kind.getKind());
+ return getOrCreateSection((Prefix+Name).c_str(), false, Info);
}
- if (Kind.isText()) return TextSection;
+ if (Info.isText()) return TextSection;
- if (Kind.isMergeableCString()) {
+ if (Info.isMergeableCString()) {
assert(CStringSection_ && "Should have string section prefix");
// We also need alignment here.
@@ -424,32 +434,32 @@
std::string Name = CStringSection_->getName() + "1." + utostr(Align);
return getOrCreateSection(Name.c_str(), false,
- SectionKind::MergeableCString);
+ SectionKind::get(SectionKind::MergeableCString));
}
- if (Kind.isMergeableConst()) {
- if (Kind.isMergeableConst4())
+ if (Info.isMergeableConst()) {
+ if (Info.isMergeableConst4())
return MergeableConst4Section;
- if (Kind.isMergeableConst8())
+ if (Info.isMergeableConst8())
return MergeableConst8Section;
- if (Kind.isMergeableConst16())
+ if (Info.isMergeableConst16())
return MergeableConst16Section;
return ReadOnlySection; // .const
}
- if (Kind.isReadOnly()) return ReadOnlySection;
+ if (Info.isReadOnly()) return ReadOnlySection;
- if (Kind.isThreadData()) return TLSDataSection;
- if (Kind.isThreadBSS()) return TLSBSSSection;
+ if (Info.isThreadData()) return TLSDataSection;
+ if (Info.isThreadBSS()) return TLSBSSSection;
- if (Kind.isBSS()) return BSSSection_;
+ if (Info.isBSS()) return BSSSection_;
- if (Kind.isDataNoRel()) return DataSection;
- if (Kind.isDataRelLocal()) return DataRelLocalSection;
- if (Kind.isDataRel()) return DataRelSection;
- if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
+ if (Info.isDataNoRel()) return DataSection;
+ if (Info.isDataRelLocal()) return DataRelLocalSection;
+ if (Info.isDataRel()) return DataRelSection;
+ if (Info.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
- assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
+ assert(Info.isReadOnlyWithRel() && "Unknown section kind");
return DataRelROSection;
}
@@ -479,58 +489,65 @@
void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM);
- TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
- DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
+ TextSection = getOrCreateSection("\t.text", true,
+ SectionKind::get(SectionKind::Text));
+ DataSection = getOrCreateSection("\t.data", true,
+ SectionKind::get(SectionKind::DataRel));
CStringSection_ = getOrCreateSection("\t.cstring", true,
- SectionKind::MergeableCString);
+ SectionKind::get(SectionKind::MergeableCString));
FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
- SectionKind::MergeableConst4);
+ SectionKind::get(SectionKind::MergeableConst4));
EightByteConstantSection = getOrCreateSection("\t.literal8\n", true,
- SectionKind::MergeableConst8);
+ SectionKind::get(SectionKind::MergeableConst8));
// ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
// to using it in -static mode.
if (TM.getRelocationModel() != Reloc::Static &&
TM.getTargetData()->getPointerSize() == 32)
SixteenByteConstantSection =
- getOrCreateSection("\t.literal16\n", true, SectionKind::MergeableConst16);
+ getOrCreateSection("\t.literal16\n", true,
+ SectionKind::get(SectionKind::MergeableConst16));
else
SixteenByteConstantSection = 0;
- ReadOnlySection = getOrCreateSection("\t.const", true, SectionKind::ReadOnly);
+ ReadOnlySection = getOrCreateSection("\t.const", true,
+ SectionKind::get(SectionKind::ReadOnly));
TextCoalSection =
getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
- false, SectionKind::Text);
+ false, SectionKind::get(SectionKind::Text));
ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
- false, SectionKind::Text);
+ false,
+ SectionKind::get(SectionKind::Text));
ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
- false, SectionKind::Text);
+ false,
+ SectionKind::get(SectionKind::Text));
ConstDataSection = getOrCreateSection("\t.const_data", true,
- SectionKind::ReadOnlyWithRel);
+ SectionKind::get(SectionKind::ReadOnlyWithRel));
DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
- false, SectionKind::DataRel);
+ false,
+ SectionKind::get(SectionKind::DataRel));
}
const MCSection *TargetLoweringObjectFileMachO::
-SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
Mangler *Mang, const TargetMachine &TM) const {
- assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
+ assert(!Info.isThreadLocal() && "Darwin doesn't support TLS");
- if (Kind.isText())
- return Kind.isWeak() ? TextCoalSection : TextSection;
+ if (Info.isText())
+ return Info.isWeak() ? TextCoalSection : TextSection;
// If this is weak/linkonce, put this in a coalescable section, either in text
// or data depending on if it is writable.
- if (Kind.isWeak()) {
- if (Kind.isReadOnly())
+ if (Info.isWeak()) {
+ if (Info.isReadOnly())
return ConstTextCoalSection;
return DataCoalSection;
}
// FIXME: Alignment check should be handled by section classifier.
- if (Kind.isMergeableCString()) {
+ if (Info.isMergeableCString()) {
Constant *C = cast<GlobalVariable>(GV)->getInitializer();
const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
const TargetData &TD = *TM.getTargetData();
@@ -544,24 +561,24 @@
return ReadOnlySection;
}
- if (Kind.isMergeableConst()) {
- if (Kind.isMergeableConst4())
+ if (Info.isMergeableConst()) {
+ if (Info.isMergeableConst4())
return FourByteConstantSection;
- if (Kind.isMergeableConst8())
+ if (Info.isMergeableConst8())
return EightByteConstantSection;
- if (Kind.isMergeableConst16() && SixteenByteConstantSection)
+ if (Info.isMergeableConst16() && SixteenByteConstantSection)
return SixteenByteConstantSection;
return ReadOnlySection; // .const
}
// FIXME: ROData -> const in -static mode that is relocatable but they happen
// by the static linker. Why not mergeable?
- if (Kind.isReadOnly())
+ if (Info.isReadOnly())
return ReadOnlySection;
// If this is marked const, put it into a const section. But if the dynamic
// linker needs to write to it, put it in the data segment.
- if (Kind.isReadOnlyWithRel())
+ if (Info.isReadOnlyWithRel())
return ConstDataSection;
// Otherwise, just drop the variable in the normal data section.
@@ -615,8 +632,10 @@
void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM);
- TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
- DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
+ TextSection = getOrCreateSection("\t.text", true,
+ SectionKind::get(SectionKind::Text));
+ DataSection = getOrCreateSection("\t.data", true,
+ SectionKind::get(SectionKind::DataRel));
}
void TargetLoweringObjectFileCOFF::
@@ -642,26 +661,25 @@
const MCSection *TargetLoweringObjectFileCOFF::
-SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
Mangler *Mang, const TargetMachine &TM) const {
- assert(!Kind.isThreadLocal() && "Doesn't support TLS");
+ assert(!Info.isThreadLocal() && "Doesn't support TLS");
// If this global is linkonce/weak and the target handles this by emitting it
// into a 'uniqued' section name, create and return the section now.
- if (Kind.isWeak()) {
- const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
- // FIXME: Use mangler interface (PR4584).
- std::string Name = Prefix+GV->getNameStr();
- return getOrCreateSection(Name.c_str(), false, Kind.getKind());
+ if (Info.isWeak()) {
+ const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Info);
+ std::string Name = Mang->makeNameProper(GV->getNameStr());
+ return getOrCreateSection((Prefix+Name).c_str(), false, Info);
}
- if (Kind.isText())
+ if (Info.isText())
return getTextSection();
- if (Kind.isBSS() && BSSSection_ != 0)
+ if (Info.isBSS() && BSSSection_ != 0)
return BSSSection_;
- if (Kind.isReadOnly() && ReadOnlySection != 0)
+ if (Info.isReadOnly() && ReadOnlySection != 0)
return ReadOnlySection;
return getDataSection();
diff --git a/lib/Target/XCore/XCoreTargetObjectFile.cpp b/lib/Target/XCore/XCoreTargetObjectFile.cpp
index a9b46ed..0f2c6a3 100644
--- a/lib/Target/XCore/XCoreTargetObjectFile.cpp
+++ b/lib/Target/XCore/XCoreTargetObjectFile.cpp
@@ -16,9 +16,12 @@
void XCoreTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM){
TargetLoweringObjectFileELF::Initialize(Ctx, TM);
- TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
- DataSection = getOrCreateSection("\t.dp.data", false, SectionKind::DataRel);
- BSSSection_ = getOrCreateSection("\t.dp.bss", false, SectionKind::BSS);
+ TextSection = getOrCreateSection("\t.text", true,
+ SectionKind::get(SectionKind::Text));
+ DataSection = getOrCreateSection("\t.dp.data", false,
+ SectionKind::get(SectionKind::DataRel));
+ BSSSection_ = getOrCreateSection("\t.dp.bss", false,
+ SectionKind::get(SectionKind::BSS));
// TLS globals are lowered in the backend to arrays indexed by the current
// thread id. After lowering they require no special handling by the linker
@@ -29,8 +32,8 @@
if (TM.getSubtarget<XCoreSubtarget>().isXS1A())
// FIXME: Why is this writable ("datarel")???
ReadOnlySection = getOrCreateSection("\t.dp.rodata", false,
- SectionKind::DataRel);
+ SectionKind::get(SectionKind::DataRel));
else
ReadOnlySection = getOrCreateSection("\t.cp.rodata", false,
- SectionKind::ReadOnly);
+ SectionKind::get(SectionKind::ReadOnly));
}