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)));
}
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);
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);
const MCSection *NewSection = getOrCreateSection(name.c_str(),
// FIXME.
false,
- SectionKind::Metadata);
+ SectionKind::get(SectionKind::Metadata));
FoundAutoSec = new PIC16Section(NewSection);
// 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()) {
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() {
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)) {
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);
}
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);
}
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);
}
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();
// 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:
// 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
// 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);
}
}
// 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);
}
}
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();
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);
}
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.
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;
}
}
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.
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;
}
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();
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.
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::
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();
projects / oota-llvm.git / commitdiff