6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-05-20 05:38:50 +00:00
Code Issues Projects Releases Wiki Activity

Change SectionKind to be a property that is true of a *section*, it

Browse Source 
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
This commit is contained in:
Chris Lattner 2009-08-01 21:11:14 +00:00
parent d7f10d3361
commit 968ff11967
11 changed files with 242 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/llvm/MC/MCSection.h
View File

@ -28,16 +28,27 @@ namespace llvm {
/// creates these. /// creates these.
class MCSection { class MCSection {
std::string Name; std::string Name;
/// IsDirective - This is true if the section name is a directive, not
/// something that should be printed with ".section".
///
/// FIXME: This is a hack. Switch to a semantic view of the section instead
/// of a syntactic one.
bool IsDirective;
MCSection(const MCSection&); // DO NOT IMPLEMENT MCSection(const MCSection&); // DO NOT IMPLEMENT
void operator=(const MCSection&); // DO NOT IMPLEMENT void operator=(const MCSection&); // DO NOT IMPLEMENT
protected: protected:
MCSection(const StringRef &Name, SectionKind K, MCContext &Ctx); MCSection(const StringRef &Name, bool IsDirective, SectionKind K,
MCContext &Ctx);
SectionKind Kind; SectionKind Kind;
public: public:
virtual ~MCSection(); virtual ~MCSection();
static MCSection *Create(const StringRef &Name, SectionKind K, bool isDirective() const { return IsDirective; }
MCContext &Ctx);
static MCSection *Create(const StringRef &Name, bool IsDirective,
SectionKind K, MCContext &Ctx);
const std::string &getName() const { return Name; } const std::string &getName() const { return Name; }
SectionKind getKind() const { return Kind; } SectionKind getKind() const { return Kind; }

68
include/llvm/Target/TargetLoweringObjectFile.h
View File

@ -122,25 +122,14 @@ public:
}; };
private: protected:
Kind K : 6; Kind K : 6;
/// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
/// weak, weak_odr, etc). This is orthogonal from the categorization.
bool Weak : 1;
/// ExplicitSection - This is true if the global had a section explicitly
/// specified on it.
bool ExplicitSection : 1;
public: public:
// FIXME: REMOVE. // FIXME: REMOVE.
Kind getKind() const { return K; } Kind getKind() const { return K; }
bool isWeak() const { return Weak; }
bool hasExplicitSection() const { return ExplicitSection; }
bool isMetadata() const { return K == Metadata; } bool isMetadata() const { return K == Metadata; }
bool isText() const { return K == Text; } bool isText() const { return K == Text; }
@ -193,17 +182,42 @@ public:
return K == ReadOnlyWithRelLocal; return K == ReadOnlyWithRelLocal;
} }
static SectionKind get(Kind K, bool isWeak = false, static SectionKind get(Kind K) {
bool hasExplicitSection = false) {
SectionKind Res; SectionKind Res;
Res.K = K; Res.K = K;
Res.Weak = isWeak;
Res.ExplicitSection = hasExplicitSection;
return Res; return Res;
} }
}; };
/// SectionInfo - This class is a target-independent classification of a global
/// which is used to simplify target-specific code by exposing common
/// predicates.
class SectionInfo : public SectionKind {
/// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
/// weak, weak_odr, etc). This is orthogonal from the categorization.
bool Weak : 1;
public:
/// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
/// weak, weak_odr, etc). This is orthogonal from the categorization.
bool isWeak() const { return Weak; }
static SectionInfo get(Kind K, bool isWeak = false) {
SectionInfo Res;
Res.K = K;
Res.Weak = isWeak;
return Res;
}
static SectionInfo get(SectionKind K, bool isWeak = false) {
SectionInfo Res;
*(SectionKind*)&Res = K;
Res.Weak = isWeak;
return Res;
}
};
class TargetLoweringObjectFile { class TargetLoweringObjectFile {
MCContext *Ctx; MCContext *Ctx;
protected: protected:
@ -243,7 +257,7 @@ public:
// FIXME: NONPUB. // FIXME: NONPUB.
const MCSection *getOrCreateSection(const char *Name, const MCSection *getOrCreateSection(const char *Name,
bool isDirective, bool isDirective,
SectionKind::Kind K) const; SectionKind K) const;
public: public:
virtual ~TargetLoweringObjectFile(); virtual ~TargetLoweringObjectFile();
@ -277,8 +291,8 @@ public:
/// section flags based on the name of the section specified for a global /// section flags based on the name of the section specified for a global
/// variable, it can implement this. This is used on ELF systems so that /// variable, it can implement this. This is used on ELF systems so that
/// ".tbss" gets the TLS bit set etc. /// ".tbss" gets the TLS bit set etc.
virtual SectionKind::Kind getKindForNamedSection(const char *Section, virtual SectionKind getKindForNamedSection(const char *Section,
SectionKind::Kind K) const{ SectionKind K) const {
return K; return K;
} }
@ -295,7 +309,7 @@ public:
/// getFlagsForNamedSection. /// getFlagsForNamedSection.
virtual const MCSection * virtual const MCSection *
getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang, getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
SectionKind Kind) const { SectionInfo Kind) const {
return 0; return 0;
} }
@ -308,7 +322,7 @@ public:
protected: protected:
virtual const MCSection * virtual const MCSection *
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
Mangler *Mang, const TargetMachine &TM) const; Mangler *Mang, const TargetMachine &TM) const;
}; };
@ -335,13 +349,13 @@ public:
virtual const MCSection * virtual const MCSection *
getSectionForMergeableConstant(SectionKind Kind) const; getSectionForMergeableConstant(SectionKind Kind) const;
virtual SectionKind::Kind getKindForNamedSection(const char *Section, virtual SectionKind getKindForNamedSection(const char *Section,
SectionKind::Kind K) const; SectionKind K) const;
void getSectionFlagsAsString(SectionKind Kind, void getSectionFlagsAsString(SectionKind Kind,
SmallVectorImpl<char> &Str) const; SmallVectorImpl<char> &Str) const;
virtual const MCSection * virtual const MCSection *
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
Mangler *Mang, const TargetMachine &TM) const; Mangler *Mang, const TargetMachine &TM) const;
protected: protected:
const MCSection *DataRelSection; const MCSection *DataRelSection;
@ -370,7 +384,7 @@ public:
virtual void Initialize(MCContext &Ctx, const TargetMachine &TM); virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
virtual const MCSection * virtual const MCSection *
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
Mangler *Mang, const TargetMachine &TM) const; Mangler *Mang, const TargetMachine &TM) const;
virtual const MCSection * virtual const MCSection *
@ -393,7 +407,7 @@ public:
SmallVectorImpl<char> &Str) const; SmallVectorImpl<char> &Str) const;
virtual const MCSection * virtual const MCSection *
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
Mangler *Mang, const TargetMachine &TM) const; Mangler *Mang, const TargetMachine &TM) const;
}; };

17
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -151,7 +151,7 @@ void AsmPrinter::SwitchToSection(const MCSection *NS) {
// If section is named we need to switch into it via special '.section' // If section is named we need to switch into it via special '.section'
// directive and also append funky flags. Otherwise - section name is just // directive and also append funky flags. Otherwise - section name is just
// some magic assembler directive. // some magic assembler directive.
if (NS->getKind().hasExplicitSection()) { if (!NS->isDirective()) {
SmallString<32> FlagsStr; SmallString<32> FlagsStr;
getObjFileLowering().getSectionFlagsAsString(NS->getKind(), FlagsStr); getObjFileLowering().getSectionFlagsAsString(NS->getKind(), FlagsStr);
@ -336,16 +336,16 @@ void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) {
SectionKind Kind; SectionKind Kind;
switch (CPE.getRelocationInfo()) { switch (CPE.getRelocationInfo()) {
default: llvm_unreachable("Unknown section kind"); default: llvm_unreachable("Unknown section kind");
case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel, false); break; case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel); break;
case 1: case 1:
Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal,false); Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal);
break; break;
case 0: case 0:
switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) { switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) {
case 4: Kind = SectionKind::get(SectionKind::MergeableConst4,false); break; case 4: Kind = SectionKind::get(SectionKind::MergeableConst4); break;
case 8: Kind = SectionKind::get(SectionKind::MergeableConst8,false); break; case 8: Kind = SectionKind::get(SectionKind::MergeableConst8); break;
case 16: Kind = SectionKind::get(SectionKind::MergeableConst16,false);break; case 16: Kind = SectionKind::get(SectionKind::MergeableConst16);break;
default: Kind = SectionKind::get(SectionKind::MergeableConst,false); break; default: Kind = SectionKind::get(SectionKind::MergeableConst); break;
} }
} }
@ -427,8 +427,7 @@ void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI,
bool JTInDiffSection = false; bool JTInDiffSection = false;
if ((IsPic && !(LoweringInfo && LoweringInfo->usesGlobalOffsetTable())) || if ((IsPic && !(LoweringInfo && LoweringInfo->usesGlobalOffsetTable())) ||
!JumpTableDataSection || !JumpTableDataSection || F->isWeakForLinker()) {
FuncSection->getKind().isWeak()) {
// In PIC mode, we need to emit the jump table to the same section as the // In PIC mode, we need to emit the jump table to the same section as the
// function body itself, otherwise the label differences won't make sense. // function body itself, otherwise the label differences won't make sense.
// We should also do if the section name is NULL or function is declared in // We should also do if the section name is NULL or function is declared in

12
lib/CodeGen/ELFWriter.cpp
View File

@ -188,16 +188,16 @@ ELFSection &ELFWriter::getConstantPoolSection(MachineConstantPoolEntry &CPE) {
SectionKind Kind; SectionKind Kind;
switch (CPE.getRelocationInfo()) { switch (CPE.getRelocationInfo()) {
default: llvm_unreachable("Unknown section kind"); default: llvm_unreachable("Unknown section kind");
case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel,false); break; case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel); break;
case 1: case 1:
Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal,false); Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal);
break; break;
case 0: case 0:
switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) { switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) {
case 4: Kind = SectionKind::get(SectionKind::MergeableConst4,false); break; case 4: Kind = SectionKind::get(SectionKind::MergeableConst4); break;
case 8: Kind = SectionKind::get(SectionKind::MergeableConst8,false); break; case 8: Kind = SectionKind::get(SectionKind::MergeableConst8); break;
case 16: Kind = SectionKind::get(SectionKind::MergeableConst16,false);break; case 16: Kind = SectionKind::get(SectionKind::MergeableConst16); break;
default: Kind = SectionKind::get(SectionKind::MergeableConst,false); break; default: Kind = SectionKind::get(SectionKind::MergeableConst); break;
} }
} }

11
lib/MC/MCSection.cpp
View File

@ -14,15 +14,16 @@ using namespace llvm;
MCSection::~MCSection() { MCSection::~MCSection() {
} }
MCSection::MCSection(const StringRef &N, SectionKind K, MCContext &Ctx) MCSection::MCSection(const StringRef &N, bool isDirective, SectionKind K,
: Name(N), Kind(K) { MCContext &Ctx)
: Name(N), IsDirective(isDirective), Kind(K) {
MCSection *&Entry = Ctx.Sections[Name]; MCSection *&Entry = Ctx.Sections[Name];
assert(Entry == 0 && "Multiple sections with the same name created"); assert(Entry == 0 && "Multiple sections with the same name created");
Entry = this; Entry = this;
} }
MCSection *MCSection::Create(const StringRef &Name, SectionKind K, MCSection *MCSection::Create(const StringRef &Name, bool IsDirective,
MCContext &Ctx) { SectionKind K, MCContext &Ctx) {
return new (Ctx) MCSection(Name, K, Ctx); return new (Ctx) MCSection(Name, IsDirective, K, Ctx);
} }

6
lib/Target/Alpha/AlphaISelLowering.cpp
View File

@ -36,8 +36,10 @@ class TargetLoweringObjectFileAlpha : public TargetLoweringObjectFile {
public: public:
void Initialize(MCContext &Ctx, const TargetMachine &TM) { void Initialize(MCContext &Ctx, const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM); TargetLoweringObjectFile::Initialize(Ctx, TM);
TextSection = getOrCreateSection("_text", true, SectionKind::Text); TextSection = getOrCreateSection("_text", true,
DataSection = getOrCreateSection("_data", true, SectionKind::DataRel); SectionKind::get(SectionKind::Text));
DataSection = getOrCreateSection("_data", true,
SectionKind::get(SectionKind::DataRel));
} }
}; };
} }

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

@ -73,7 +73,7 @@ bool PIC16AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
const MCSection *fCodeSection = const MCSection *fCodeSection =
getObjFileLowering().getOrCreateSection(codeSection, false, getObjFileLowering().getOrCreateSection(codeSection, false,
SectionKind::Text); SectionKind::get(SectionKind::Text));
// Start the Code Section. // Start the Code Section.
O << "\n"; O << "\n";
SwitchToSection(fCodeSection); SwitchToSection(fCodeSection);
@ -350,7 +350,7 @@ void PIC16AsmPrinter::EmitFunctionFrame(MachineFunction &MF) {
const MCSection *fPDataSection = const MCSection *fPDataSection =
getObjFileLowering().getOrCreateSection(SectionName, false, getObjFileLowering().getOrCreateSection(SectionName, false,
SectionKind::DataRel); SectionKind::get(SectionKind::DataRel));
SwitchToSection(fPDataSection); SwitchToSection(fPDataSection);
// Emit function frame label // Emit function frame label

35
lib/Target/PIC16/PIC16TargetObjectFile.cpp
View File

@ -19,24 +19,27 @@ void PIC16TargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &tm){
TargetLoweringObjectFile::Initialize(Ctx, tm); TargetLoweringObjectFile::Initialize(Ctx, tm);
TM = &tm; TM = &tm;
BSSSection_ = getOrCreateSection("udata.# UDATA", false, SectionKind::BSS); BSSSection_ = getOrCreateSection("udata.# UDATA", false,
SectionKind::get(SectionKind::BSS));
ReadOnlySection = getOrCreateSection("romdata.# ROMDATA", false, ReadOnlySection = getOrCreateSection("romdata.# ROMDATA", false,
SectionKind::ReadOnly); SectionKind::get(SectionKind::ReadOnly));
DataSection = getOrCreateSection("idata.# IDATA", false,SectionKind::DataRel); DataSection = getOrCreateSection("idata.# IDATA", false,
SectionKind::get(SectionKind::DataRel));
// Need because otherwise a .text symbol is emitted by DwarfWriter // Need because otherwise a .text symbol is emitted by DwarfWriter
// in BeginModule, and gpasm cribbs for that .text symbol. // 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)); ROSections.push_back(new PIC16Section(ReadOnlySection));
// FIXME: I don't know what the classification of these sections really is. // FIXME: I don't know what the classification of these sections really is.
ExternalVarDecls = new PIC16Section(getOrCreateSection("ExternalVarDecls", ExternalVarDecls = new PIC16Section(getOrCreateSection("ExternalVarDecls",
false, false,
SectionKind::Metadata)); SectionKind::get(SectionKind::Metadata)));
ExternalVarDefs = new PIC16Section(getOrCreateSection("ExternalVarDefs", ExternalVarDefs = new PIC16Section(getOrCreateSection("ExternalVarDefs",
false, false,
SectionKind::Metadata)); SectionKind::get(SectionKind::Metadata)));
} }
@ -66,7 +69,7 @@ PIC16TargetObjectFile::getBSSSectionForGlobal(const GlobalVariable *GV) const {
std::string name = PAN::getUdataSectionName(BSSSections.size()); std::string name = PAN::getUdataSectionName(BSSSections.size());
const MCSection *NewSection = getOrCreateSection(name.c_str(), false, const MCSection *NewSection = getOrCreateSection(name.c_str(), false,
// FIXME. // FIXME.
SectionKind::Metadata); SectionKind::get(SectionKind::Metadata));
FoundBSS = new PIC16Section(NewSection); FoundBSS = new PIC16Section(NewSection);
@ -108,7 +111,7 @@ PIC16TargetObjectFile::getIDATASectionForGlobal(const GlobalVariable *GV) const{
std::string name = PAN::getIdataSectionName(IDATASections.size()); std::string name = PAN::getIdataSectionName(IDATASections.size());
const MCSection *NewSection = getOrCreateSection(name.c_str(), false, const MCSection *NewSection = getOrCreateSection(name.c_str(), false,
// FIXME. // FIXME.
SectionKind::Metadata); SectionKind::get(SectionKind::Metadata));
FoundIDATA = new PIC16Section(NewSection); FoundIDATA = new PIC16Section(NewSection);
@ -144,7 +147,7 @@ PIC16TargetObjectFile::getSectionForAuto(const GlobalVariable *GV) const {
const MCSection *NewSection = getOrCreateSection(name.c_str(), const MCSection *NewSection = getOrCreateSection(name.c_str(),
// FIXME. // FIXME.
false, false,
SectionKind::Metadata); SectionKind::get(SectionKind::Metadata));
FoundAutoSec = new PIC16Section(NewSection); FoundAutoSec = new PIC16Section(NewSection);
@ -163,14 +166,14 @@ PIC16TargetObjectFile::getSectionForAuto(const GlobalVariable *GV) const {
// multiple data sections if required. // multiple data sections if required.
const MCSection * const MCSection *
PIC16TargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV1, PIC16TargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV1,
SectionKind Kind, SectionInfo Info,
Mangler *Mang, Mangler *Mang,
const TargetMachine &TM) const { const TargetMachine &TM) 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);
if (!GV) if (!GV)
return TargetLoweringObjectFile::SelectSectionForGlobal(GV1, Kind, Mang,TM); return TargetLoweringObjectFile::SelectSectionForGlobal(GV1, Info, Mang,TM);
// Record External Var Decls. // Record External Var Decls.
if (GV->isDeclaration()) { if (GV->isDeclaration()) {
@ -204,7 +207,7 @@ PIC16TargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV1,
return getROSectionForGlobal(GV); return getROSectionForGlobal(GV);
// Else let the default implementation take care of it. // 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() { PIC16TargetObjectFile::~PIC16TargetObjectFile() {
@ -226,7 +229,7 @@ PIC16TargetObjectFile::~PIC16TargetObjectFile() {
const MCSection * const MCSection *
PIC16TargetObjectFile::getSpecialCasedSectionGlobals(const GlobalValue *GV, PIC16TargetObjectFile::getSpecialCasedSectionGlobals(const GlobalValue *GV,
Mangler *Mang, Mangler *Mang,
SectionKind Kind) const { SectionInfo Info) 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)) {
@ -297,7 +300,7 @@ PIC16TargetObjectFile::CreateBSSSectionForGlobal(const GlobalVariable *GV,
PIC16Section *NewBSS = FoundBSS; PIC16Section *NewBSS = FoundBSS;
if (NewBSS == NULL) { if (NewBSS == NULL) {
const MCSection *NewSection = getOrCreateSection(Name.c_str(), false, const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
SectionKind::BSS); SectionKind::get(SectionKind::BSS));
NewBSS = new PIC16Section(NewSection); NewBSS = new PIC16Section(NewSection);
BSSSections.push_back(NewBSS); BSSSections.push_back(NewBSS);
} }
@ -350,7 +353,7 @@ PIC16TargetObjectFile::CreateIDATASectionForGlobal(const GlobalVariable *GV,
if (NewIDATASec == NULL) { if (NewIDATASec == NULL) {
const MCSection *NewSection = getOrCreateSection(Name.c_str(), false, const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
// FIXME: // FIXME:
SectionKind::Metadata); SectionKind::get(SectionKind::Metadata));
NewIDATASec = new PIC16Section(NewSection); NewIDATASec = new PIC16Section(NewSection);
IDATASections.push_back(NewIDATASec); IDATASections.push_back(NewIDATASec);
} }
@ -389,7 +392,7 @@ PIC16TargetObjectFile::CreateROSectionForGlobal(const GlobalVariable *GV,
PIC16Section *NewRomSec = FoundROSec; PIC16Section *NewRomSec = FoundROSec;
if (NewRomSec == NULL) { if (NewRomSec == NULL) {
const MCSection *NewSection = getOrCreateSection(Name.c_str(), false, const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
SectionKind::ReadOnly); SectionKind::get(SectionKind::ReadOnly));
NewRomSec = new PIC16Section(NewSection); NewRomSec = new PIC16Section(NewSection);
ROSections.push_back(NewRomSec); ROSections.push_back(NewRomSec);
} }

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

@ -62,9 +62,9 @@ namespace llvm {
/// section assignment of a global. /// section assignment of a global.
virtual const MCSection * virtual const MCSection *
getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang, getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
SectionKind Kind) const; SectionInfo Info) const;
virtual const MCSection *SelectSectionForGlobal(const GlobalValue *GV, virtual const MCSection *SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, SectionInfo Info,
Mangler *Mang, Mangler *Mang,
const TargetMachine&) const; const TargetMachine&) const;
private: private:

246
lib/Target/TargetLoweringObjectFile.cpp
View File

@ -81,26 +81,31 @@ static bool isConstantString(const Constant *C) {
return false; return false;
} }
static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV, /// SectionKindForGlobal - This is a top-level target-independent classifier for
const TargetMachine &TM) { /// 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(); Reloc::Model ReloModel = TM.getRelocationModel();
// 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::get(SectionKind::Text);
// Handle thread-local data first. // Handle thread-local data first.
if (GVar->isThreadLocal()) { if (GVar->isThreadLocal()) {
if (isSuitableForBSS(GVar)) if (isSuitableForBSS(GVar))
return SectionKind::ThreadBSS; return SectionKind::get(SectionKind::ThreadBSS);
return SectionKind::ThreadData; return SectionKind::get(SectionKind::ThreadData);
} }
// Variable can be easily put to BSS section. // Variable can be easily put to BSS section.
if (isSuitableForBSS(GVar)) if (isSuitableForBSS(GVar))
return SectionKind::BSS; return SectionKind::get(SectionKind::BSS);
Constant *C = GVar->getInitializer(); Constant *C = GVar->getInitializer();
@ -116,16 +121,16 @@ 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::MergeableCString; return SectionKind::get(SectionKind::MergeableCString);
// Otherwise, just drop it into a mergable constant section. If we have // Otherwise, just drop it into a mergable constant section. If we have
// a section for this size, use it, otherwise use the arbitrary sized // a section for this size, use it, otherwise use the arbitrary sized
// mergable section. // mergable section.
switch (TM.getTargetData()->getTypeAllocSize(C->getType())) { switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
case 4: return SectionKind::MergeableConst4; case 4: return SectionKind::get(SectionKind::MergeableConst4);
case 8: return SectionKind::MergeableConst8; case 8: return SectionKind::get(SectionKind::MergeableConst8);
case 16: return SectionKind::MergeableConst16; case 16: return SectionKind::get(SectionKind::MergeableConst16);
default: return SectionKind::MergeableConst; default: return SectionKind::get(SectionKind::MergeableConst);
} }
case Constant::LocalRelocation: case Constant::LocalRelocation:
@ -135,11 +140,11 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
// the linker doesn't take relocations into consideration when it tries to // the linker doesn't take relocations into consideration when it tries to
// merge entries in the section. // merge entries in the section.
if (ReloModel == Reloc::Static) 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 // 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::ReadOnlyWithRelLocal; return SectionKind::get(SectionKind::ReadOnlyWithRelLocal);
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
@ -148,11 +153,11 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
// the linker doesn't take relocations into consideration when it tries to // the linker doesn't take relocations into consideration when it tries to
// merge entries in the section. // merge entries in the section.
if (ReloModel == Reloc::Static) 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 // Otherwise, the dynamic linker needs to fix it up, put it in the
// writable data.rel section. // writable data.rel section.
return SectionKind::ReadOnlyWithRel; return SectionKind::get(SectionKind::ReadOnlyWithRel);
} }
} }
@ -162,16 +167,16 @@ 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::DataNoRel; return SectionKind::get(SectionKind::DataNoRel);
switch (C->getRelocationInfo()) { switch (C->getRelocationInfo()) {
default: llvm_unreachable("unknown relocation info kind"); default: llvm_unreachable("unknown relocation info kind");
case Constant::NoRelocation: case Constant::NoRelocation:
return SectionKind::DataNoRel; return SectionKind::get(SectionKind::DataNoRel);
case Constant::LocalRelocation: case Constant::LocalRelocation:
return SectionKind::DataRelLocal; return SectionKind::get(SectionKind::DataRelLocal);
case Constant::GlobalRelocations: case Constant::GlobalRelocations:
return SectionKind::DataRel; return SectionKind::get(SectionKind::DataRel);
} }
} }
@ -184,47 +189,44 @@ SectionForGlobal(const GlobalValue *GV, Mangler *Mang,
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 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. // Select section name.
if (GV->hasSection()) { if (GV->hasSection()) {
// If the target has special section hacks for specifically named globals, // If the target has special section hacks for specifically named globals,
// return them now. // return them now.
if (const MCSection *TS = getSpecialCasedSectionGlobals(GV, Mang, Kind)) if (const MCSection *TS = getSpecialCasedSectionGlobals(GV, Mang, Info))
return TS; return TS;
// If the target has magic semantics for certain section names, make sure to // 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 // pick up the flags. This allows the user to write things with attribute
// section and still get the appropriate section flags printed. // 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 // 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. // Lame default implementation. Calculate the section name for global.
const MCSection * const MCSection *
TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV, TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, SectionInfo Info,
Mangler *Mang, Mangler *Mang,
const TargetMachine &TM) const{ 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(); return getTextSection();
if (Kind.isBSS() && BSSSection_ != 0) if (Info.isBSS() && BSSSection_ != 0)
return BSSSection_; return BSSSection_;
if (Kind.isReadOnly() && ReadOnlySection != 0) if (Info.isReadOnly() && ReadOnlySection != 0)
return ReadOnlySection; return ReadOnlySection;
return getDataSection(); return getDataSection();
@ -244,12 +246,10 @@ getSectionForMergeableConstant(SectionKind Kind) const {
const MCSection *TargetLoweringObjectFile:: const MCSection *TargetLoweringObjectFile::
getOrCreateSection(const char *Name, bool isDirective, getOrCreateSection(const char *Name, bool isDirective, SectionKind Kind) const {
SectionKind::Kind Kind) const {
if (MCSection *S = Ctx->GetSection(Name)) if (MCSection *S = Ctx->GetSection(Name))
return S; return S;
SectionKind K = SectionKind::get(Kind, false /*weak*/, !isDirective); return MCSection::Create(Name, isDirective, Kind, *Ctx);
return MCSection::Create(Name, K, *Ctx);
} }
@ -262,45 +262,55 @@ void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
const TargetMachine &TM) { const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM); TargetLoweringObjectFile::Initialize(Ctx, TM);
if (!HasCrazyBSS) if (!HasCrazyBSS)
BSSSection_ = getOrCreateSection("\t.bss", true, SectionKind::BSS); BSSSection_ = getOrCreateSection("\t.bss", true,
SectionKind::get(SectionKind::BSS));
else else
// PPC/Linux doesn't support the .bss directive, it needs .section .bss. // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
// FIXME: Does .section .bss work everywhere?? // 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); TextSection = getOrCreateSection("\t.text", true,
DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel); SectionKind::get(SectionKind::Text));
DataSection = getOrCreateSection("\t.data", true,
SectionKind::get(SectionKind::DataRel));
ReadOnlySection = ReadOnlySection =
getOrCreateSection("\t.rodata", false, SectionKind::ReadOnly); getOrCreateSection("\t.rodata", false,
SectionKind::get(SectionKind::ReadOnly));
TLSDataSection = TLSDataSection =
getOrCreateSection("\t.tdata", false, SectionKind::ThreadData); getOrCreateSection("\t.tdata", false,
SectionKind::get(SectionKind::ThreadData));
CStringSection_ = getOrCreateSection("\t.rodata.str", true, 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, DataRelSection = getOrCreateSection("\t.data.rel", false,
SectionKind::DataRel); SectionKind::get(SectionKind::DataRel));
DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false, DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
SectionKind::DataRelLocal); SectionKind::get(SectionKind::DataRelLocal));
DataRelROSection = getOrCreateSection("\t.data.rel.ro", false, DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
SectionKind::ReadOnlyWithRel); SectionKind::get(SectionKind::ReadOnlyWithRel));
DataRelROLocalSection = DataRelROLocalSection =
getOrCreateSection("\t.data.rel.ro.local", false, getOrCreateSection("\t.data.rel.ro.local", false,
SectionKind::ReadOnlyWithRelLocal); SectionKind::get(SectionKind::ReadOnlyWithRelLocal));
MergeableConst4Section = getOrCreateSection(".rodata.cst4", false, MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
SectionKind::MergeableConst4); SectionKind::get(SectionKind::MergeableConst4));
MergeableConst8Section = getOrCreateSection(".rodata.cst8", false, MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
SectionKind::MergeableConst8); SectionKind::get(SectionKind::MergeableConst8));
MergeableConst16Section = getOrCreateSection(".rodata.cst16", false, MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
SectionKind::MergeableConst16); SectionKind::get(SectionKind::MergeableConst16));
} }
SectionKind::Kind TargetLoweringObjectFileELF:: SectionKind TargetLoweringObjectFileELF::
getKindForNamedSection(const char *Name, SectionKind::Kind K) const { getKindForNamedSection(const char *Name, SectionKind K) const {
if (Name[0] != '.') return K; if (Name[0] != '.') return K;
// Some lame default implementation based on some magic section names. // Some lame default implementation based on some magic section names.
@ -308,19 +318,19 @@ getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
strncmp(Name, ".llvm.linkonce.b.", 17) == 0 || strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 || strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
strncmp(Name, ".llvm.linkonce.sb.", 18) == 0) strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
return SectionKind::BSS; return SectionKind::get(SectionKind::BSS);
if (strcmp(Name, ".tdata") == 0 || if (strcmp(Name, ".tdata") == 0 ||
strncmp(Name, ".tdata.", 7) == 0 || strncmp(Name, ".tdata.", 7) == 0 ||
strncmp(Name, ".gnu.linkonce.td.", 17) == 0 || strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
strncmp(Name, ".llvm.linkonce.td.", 18) == 0) strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
return SectionKind::ThreadData; return SectionKind::get(SectionKind::ThreadData);
if (strcmp(Name, ".tbss") == 0 || if (strcmp(Name, ".tbss") == 0 ||
strncmp(Name, ".tbss.", 6) == 0 || strncmp(Name, ".tbss.", 6) == 0 ||
strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 || strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
strncmp(Name, ".llvm.linkonce.tb.", 18) == 0) strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
return SectionKind::ThreadBSS; return SectionKind::get(SectionKind::ThreadBSS);
return K; return K;
} }
@ -400,20 +410,20 @@ static const char *getSectionPrefixForUniqueGlobal(SectionKind Kind) {
} }
const MCSection *TargetLoweringObjectFileELF:: const MCSection *TargetLoweringObjectFileELF::
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
Mangler *Mang, const TargetMachine &TM) const { Mangler *Mang, const TargetMachine &TM) const {
// If this global is linkonce/weak and the target handles this by emitting it // 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. // into a 'uniqued' section name, create and return the section now.
if (Kind.isWeak()) { if (Info.isWeak()) {
const char *Prefix = getSectionPrefixForUniqueGlobal(Kind); const char *Prefix = getSectionPrefixForUniqueGlobal(Info);
std::string Name = Mang->makeNameProper(GV->getNameStr()); 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"); assert(CStringSection_ && "Should have string section prefix");
// We also need alignment here. // We also need alignment here.
@ -424,32 +434,32 @@ SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
std::string Name = CStringSection_->getName() + "1." + utostr(Align); std::string Name = CStringSection_->getName() + "1." + utostr(Align);
return getOrCreateSection(Name.c_str(), false, return getOrCreateSection(Name.c_str(), false,
SectionKind::MergeableCString); SectionKind::get(SectionKind::MergeableCString));
} }
if (Kind.isMergeableConst()) { if (Info.isMergeableConst()) {
if (Kind.isMergeableConst4()) if (Info.isMergeableConst4())
return MergeableConst4Section; return MergeableConst4Section;
if (Kind.isMergeableConst8()) if (Info.isMergeableConst8())
return MergeableConst8Section; return MergeableConst8Section;
if (Kind.isMergeableConst16()) if (Info.isMergeableConst16())
return MergeableConst16Section; return MergeableConst16Section;
return ReadOnlySection; // .const return ReadOnlySection; // .const
} }
if (Kind.isReadOnly()) return ReadOnlySection; if (Info.isReadOnly()) return ReadOnlySection;
if (Kind.isThreadData()) return TLSDataSection; if (Info.isThreadData()) return TLSDataSection;
if (Kind.isThreadBSS()) return TLSBSSSection; if (Info.isThreadBSS()) return TLSBSSSection;
if (Kind.isBSS()) return BSSSection_; if (Info.isBSS()) return BSSSection_;
if (Kind.isDataNoRel()) return DataSection; if (Info.isDataNoRel()) return DataSection;
if (Kind.isDataRelLocal()) return DataRelLocalSection; if (Info.isDataRelLocal()) return DataRelLocalSection;
if (Kind.isDataRel()) return DataRelSection; if (Info.isDataRel()) return DataRelSection;
if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection; if (Info.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
assert(Kind.isReadOnlyWithRel() && "Unknown section kind"); assert(Info.isReadOnlyWithRel() && "Unknown section kind");
return DataRelROSection; return DataRelROSection;
} }
@ -479,58 +489,65 @@ getSectionForMergeableConstant(SectionKind Kind) const {
void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx, void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
const TargetMachine &TM) { const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM); TargetLoweringObjectFile::Initialize(Ctx, TM);
TextSection = getOrCreateSection("\t.text", true, SectionKind::Text); TextSection = getOrCreateSection("\t.text", true,
DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel); SectionKind::get(SectionKind::Text));
DataSection = getOrCreateSection("\t.data", true,
SectionKind::get(SectionKind::DataRel));
CStringSection_ = getOrCreateSection("\t.cstring", true, CStringSection_ = getOrCreateSection("\t.cstring", true,
SectionKind::MergeableCString); SectionKind::get(SectionKind::MergeableCString));
FourByteConstantSection = getOrCreateSection("\t.literal4\n", true, FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
SectionKind::MergeableConst4); SectionKind::get(SectionKind::MergeableConst4));
EightByteConstantSection = getOrCreateSection("\t.literal8\n", true, 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 // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
// to using it in -static mode. // to using it in -static mode.
if (TM.getRelocationModel() != Reloc::Static && if (TM.getRelocationModel() != Reloc::Static &&
TM.getTargetData()->getPointerSize() == 32) TM.getTargetData()->getPointerSize() == 32)
SixteenByteConstantSection = SixteenByteConstantSection =
getOrCreateSection("\t.literal16\n", true, SectionKind::MergeableConst16); getOrCreateSection("\t.literal16\n", true,
SectionKind::get(SectionKind::MergeableConst16));
else else
SixteenByteConstantSection = 0; SixteenByteConstantSection = 0;
ReadOnlySection = getOrCreateSection("\t.const", true, SectionKind::ReadOnly); ReadOnlySection = getOrCreateSection("\t.const", true,
SectionKind::get(SectionKind::ReadOnly));
TextCoalSection = TextCoalSection =
getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions", getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
false, SectionKind::Text); false, SectionKind::get(SectionKind::Text));
ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced", ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
false, SectionKind::Text); false,
SectionKind::get(SectionKind::Text));
ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced", ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
false, SectionKind::Text); false,
SectionKind::get(SectionKind::Text));
ConstDataSection = getOrCreateSection("\t.const_data", true, ConstDataSection = getOrCreateSection("\t.const_data", true,
SectionKind::ReadOnlyWithRel); SectionKind::get(SectionKind::ReadOnlyWithRel));
DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced", DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
false, SectionKind::DataRel); false,
SectionKind::get(SectionKind::DataRel));
} }
const MCSection *TargetLoweringObjectFileMachO:: const MCSection *TargetLoweringObjectFileMachO::
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
Mangler *Mang, const TargetMachine &TM) const { 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()) if (Info.isText())
return Kind.isWeak() ? TextCoalSection : TextSection; return Info.isWeak() ? TextCoalSection : TextSection;
// If this is weak/linkonce, put this in a coalescable section, either in text // If this is weak/linkonce, put this in a coalescable section, either in text
// or data depending on if it is writable. // or data depending on if it is writable.
if (Kind.isWeak()) { if (Info.isWeak()) {
if (Kind.isReadOnly()) if (Info.isReadOnly())
return ConstTextCoalSection; return ConstTextCoalSection;
return DataCoalSection; return DataCoalSection;
} }
// FIXME: Alignment check should be handled by section classifier. // FIXME: Alignment check should be handled by section classifier.
if (Kind.isMergeableCString()) { if (Info.isMergeableCString()) {
Constant *C = cast<GlobalVariable>(GV)->getInitializer(); Constant *C = cast<GlobalVariable>(GV)->getInitializer();
const Type *Ty = cast<ArrayType>(C->getType())->getElementType(); const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
const TargetData &TD = *TM.getTargetData(); const TargetData &TD = *TM.getTargetData();
@ -544,24 +561,24 @@ SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
return ReadOnlySection; return ReadOnlySection;
} }
if (Kind.isMergeableConst()) { if (Info.isMergeableConst()) {
if (Kind.isMergeableConst4()) if (Info.isMergeableConst4())
return FourByteConstantSection; return FourByteConstantSection;
if (Kind.isMergeableConst8()) if (Info.isMergeableConst8())
return EightByteConstantSection; return EightByteConstantSection;
if (Kind.isMergeableConst16() && SixteenByteConstantSection) if (Info.isMergeableConst16() && SixteenByteConstantSection)
return SixteenByteConstantSection; return SixteenByteConstantSection;
return ReadOnlySection; // .const return ReadOnlySection; // .const
} }
// FIXME: ROData -> const in -static mode that is relocatable but they happen // FIXME: ROData -> const in -static mode that is relocatable but they happen
// by the static linker. Why not mergeable? // by the static linker. Why not mergeable?
if (Kind.isReadOnly()) if (Info.isReadOnly())
return ReadOnlySection; return ReadOnlySection;
// If this is marked const, put it into a const section. But if the dynamic // 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. // linker needs to write to it, put it in the data segment.
if (Kind.isReadOnlyWithRel()) if (Info.isReadOnlyWithRel())
return ConstDataSection; return ConstDataSection;
// Otherwise, just drop the variable in the normal data section. // Otherwise, just drop the variable in the normal data section.
@ -615,8 +632,10 @@ shouldEmitUsedDirectiveFor(const GlobalValue *GV, Mangler *Mang) const {
void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx, void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
const TargetMachine &TM) { const TargetMachine &TM) {
TargetLoweringObjectFile::Initialize(Ctx, TM); TargetLoweringObjectFile::Initialize(Ctx, TM);
TextSection = getOrCreateSection("\t.text", true, SectionKind::Text); TextSection = getOrCreateSection("\t.text", true,
DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel); SectionKind::get(SectionKind::Text));
DataSection = getOrCreateSection("\t.data", true,
SectionKind::get(SectionKind::DataRel));
} }
void TargetLoweringObjectFileCOFF:: void TargetLoweringObjectFileCOFF::
@ -642,26 +661,25 @@ static const char *getCOFFSectionPrefixForUniqueGlobal(SectionKind Kind) {
const MCSection *TargetLoweringObjectFileCOFF:: const MCSection *TargetLoweringObjectFileCOFF::
SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
Mangler *Mang, const TargetMachine &TM) const { 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 // 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. // into a 'uniqued' section name, create and return the section now.
if (Kind.isWeak()) { if (Info.isWeak()) {
const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind); const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Info);
// FIXME: Use mangler interface (PR4584). std::string Name = Mang->makeNameProper(GV->getNameStr());
std::string Name = Prefix+GV->getNameStr(); return getOrCreateSection((Prefix+Name).c_str(), false, Info);
return getOrCreateSection(Name.c_str(), false, Kind.getKind());
} }
if (Kind.isText()) if (Info.isText())
return getTextSection(); return getTextSection();
if (Kind.isBSS() && BSSSection_ != 0) if (Info.isBSS() && BSSSection_ != 0)
return BSSSection_; return BSSSection_;
if (Kind.isReadOnly() && ReadOnlySection != 0) if (Info.isReadOnly() && ReadOnlySection != 0)
return ReadOnlySection; return ReadOnlySection;
return getDataSection(); return getDataSection();

13
lib/Target/XCore/XCoreTargetObjectFile.cpp
View File

@ -16,9 +16,12 @@ using namespace llvm;
void XCoreTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM){ void XCoreTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM){
TargetLoweringObjectFileELF::Initialize(Ctx, TM); TargetLoweringObjectFileELF::Initialize(Ctx, TM);
TextSection = getOrCreateSection("\t.text", true, SectionKind::Text); TextSection = getOrCreateSection("\t.text", true,
DataSection = getOrCreateSection("\t.dp.data", false, SectionKind::DataRel); SectionKind::get(SectionKind::Text));
BSSSection_ = getOrCreateSection("\t.dp.bss", false, SectionKind::BSS); 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 // 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 // thread id. After lowering they require no special handling by the linker
@ -29,8 +32,8 @@ void XCoreTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM){
if (TM.getSubtarget<XCoreSubtarget>().isXS1A()) if (TM.getSubtarget<XCoreSubtarget>().isXS1A())
// FIXME: Why is this writable ("datarel")??? // FIXME: Why is this writable ("datarel")???
ReadOnlySection = getOrCreateSection("\t.dp.rodata", false, ReadOnlySection = getOrCreateSection("\t.dp.rodata", false,
SectionKind::DataRel); SectionKind::get(SectionKind::DataRel));
else else
ReadOnlySection = getOrCreateSection("\t.cp.rodata", false, ReadOnlySection = getOrCreateSection("\t.cp.rodata", false,
SectionKind::ReadOnly); SectionKind::get(SectionKind::ReadOnly));
} }