6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-23 17:29:19 +00:00
Code Issues Projects Releases Wiki Activity

remove a densemap from TargetAsmInfo that was uniquing the targetflags strings,

Browse Source 
just use a smallstring instead.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77144 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2009-07-26 07:33:58 +00:00
parent 6468b44d3a
commit f40761d522
9 changed files with 82 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -41,7 +41,8 @@ namespace llvm {
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind) const;
virtual std::string printSectionFlags(unsigned flags) const;
virtual void getSectionFlags(unsigned Flags,
SmallVectorImpl<char> &Str) const;
const Section *DataRelSection;
const Section *DataRelLocalSection;

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

@ -16,12 +16,13 @@
#ifndef LLVM_TARGET_ASM_INFO_H
#define LLVM_TARGET_ASM_INFO_H
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/DataTypes.h"
#include <string>
namespace llvm {
template <typename T> class SmallVectorImpl;
// DWARF encoding query type
namespace DwarfEncoding {
enum Target {
@ -235,8 +236,6 @@ namespace llvm {
static bool isEqual(unsigned LHS, unsigned RHS) { return LHS == RHS; }
static bool isPod() { return true; }
};
typedef DenseMap<unsigned, std::string, KeyInfo> FlagsStringsMapType;
}
class TargetMachine;
@ -269,7 +268,6 @@ namespace llvm {
class TargetAsmInfo {
private:
mutable StringMap<Section> Sections;
mutable SectionFlags::FlagsStringsMapType FlagsStrings;
protected:
/// TM - The current TargetMachine.
const TargetMachine &TM;
@ -746,8 +744,11 @@ namespace llvm {
return 0;
}
const std::string &getSectionFlags(unsigned Flags) const;
virtual std::string printSectionFlags(unsigned flags) const { return ""; }
/// Turn the specified flags into a string that can be printed to the
/// assembly file.
virtual void getSectionFlags(unsigned Flags,
SmallVectorImpl<char> &Str) const {
}
// FIXME: Eliminate this.
virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,

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

@ -135,12 +135,16 @@ void AsmPrinter::SwitchToSection(const Section* NS) {
// If section is named we need to switch into it via special '.section'
// directive and also append funky flags. Otherwise - section name is just
// some magic assembler directive.
if (NS->hasFlag(SectionFlags::Named))
if (NS->hasFlag(SectionFlags::Named)) {
O << TAI->getSwitchToSectionDirective()
<< CurrentSection
<< TAI->getSectionFlags(NS->getFlags());
else
<< CurrentSection;
SmallString<32> FlagsStr;
TAI->getSectionFlags(NS->getFlags(), FlagsStr);
O << FlagsStr.c_str();
} else {
O << CurrentSection;
}
O << TAI->getDataSectionStartSuffix() << '\n';
}

58
lib/Target/ELFTargetAsmInfo.cpp
View File

@ -168,38 +168,44 @@ ELFTargetAsmInfo::MergeableStringSection(const GlobalVariable *GV) const {
return getReadOnlySection();
}
std::string ELFTargetAsmInfo::printSectionFlags(unsigned flags) const {
std::string Flags = ",\"";
void ELFTargetAsmInfo::getSectionFlags(unsigned Flags,
SmallVectorImpl<char> &Str) const {
Str.push_back(',');
Str.push_back('"');
if (!(Flags & SectionFlags::Debug))
Str.push_back('a');
if (Flags & SectionFlags::Code)
Str.push_back('x');
if (Flags & SectionFlags::Writable)
Str.push_back('w');
if (Flags & SectionFlags::Mergeable)
Str.push_back('M');
if (Flags & SectionFlags::Strings)
Str.push_back('S');
if (Flags & SectionFlags::TLS)
Str.push_back('T');
if (!(flags & SectionFlags::Debug))
Flags += 'a';
if (flags & SectionFlags::Code)
Flags += 'x';
if (flags & SectionFlags::Writable)
Flags += 'w';
if (flags & SectionFlags::Mergeable)
Flags += 'M';
if (flags & SectionFlags::Strings)
Flags += 'S';
if (flags & SectionFlags::TLS)
Flags += 'T';
Flags += "\",";
Str.push_back('"');
Str.push_back(',');
// If comment string is '@', e.g. as on ARM - use '%' instead
if (strcmp(CommentString, "@") == 0)
Flags += '%';
Str.push_back('%');
else
Flags += '@';
Str.push_back('@');
// FIXME: There can be exceptions here
if (flags & SectionFlags::BSS)
Flags += "nobits";
const char *KindStr;
if (Flags & SectionFlags::BSS)
KindStr = "nobits";
else
Flags += "progbits";
KindStr = "progbits";
Str.append(KindStr, KindStr+strlen(KindStr));
if (unsigned entitySize = SectionFlags::getEntitySize(flags))
Flags += "," + utostr(entitySize);
return Flags;
if (unsigned entitySize = SectionFlags::getEntitySize(Flags)) {
Str.push_back(',');
std::string Size = utostr(entitySize);
Str.append(Size.begin(), Size.end());
}
}

31
lib/Target/Sparc/SparcTargetAsmInfo.cpp
View File

@ -12,7 +12,7 @@
//===----------------------------------------------------------------------===//
#include "SparcTargetAsmInfo.h"
#include "llvm/ADT/SmallVector.h"
using namespace llvm;
SparcELFTargetAsmInfo::SparcELFTargetAsmInfo(const TargetMachine &TM):
@ -32,19 +32,22 @@ SparcELFTargetAsmInfo::SparcELFTargetAsmInfo(const TargetMachine &TM):
/* Override */ true);
}
std::string SparcELFTargetAsmInfo::printSectionFlags(unsigned flags) const {
if (flags & SectionFlags::Mergeable)
return ELFTargetAsmInfo::printSectionFlags(flags);
std::string Flags;
if (!(flags & SectionFlags::Debug))
Flags += ",#alloc";
if (flags & SectionFlags::Code)
Flags += ",#execinstr";
if (flags & SectionFlags::Writable)
Flags += ",#write";
if (flags & SectionFlags::TLS)
Flags += ",#tls";
void SparcELFTargetAsmInfo::getSectionFlags(unsigned Flags,
SmallVectorImpl<char> &Str) const {
if (Flags & SectionFlags::Mergeable)
return ELFTargetAsmInfo::getSectionFlags(Flags, Str);
return Flags;
// FIXME: Inefficient.
std::string Res;
if (!(Flags & SectionFlags::Debug))
Res += ",#alloc";
if (Flags & SectionFlags::Code)
Res += ",#execinstr";
if (Flags & SectionFlags::Writable)
Res += ",#write";
if (Flags & SectionFlags::TLS)
Res += ",#tls";
Str.append(Res.begin(), Res.end());
}

4
lib/Target/Sparc/SparcTargetAsmInfo.h
View File

@ -25,7 +25,9 @@ namespace llvm {
struct SparcELFTargetAsmInfo : public ELFTargetAsmInfo {
explicit SparcELFTargetAsmInfo(const TargetMachine &TM);
std::string printSectionFlags(unsigned flags) const;
virtual void getSectionFlags(unsigned Flags,
SmallVectorImpl<char> &Str) const;
};
} // namespace llvm

13
lib/Target/TargetAsmInfo.cpp
View File

@ -416,19 +416,6 @@ TargetAsmInfo::getUnnamedSection(const char *Directive, unsigned Flags,
return &S;
}
const std::string&
TargetAsmInfo::getSectionFlags(unsigned Flags) const {
SectionFlags::FlagsStringsMapType::iterator I = FlagsStrings.find(Flags);
// We didn't print these flags yet, print and save them to map. This reduces
// amount of heap trashing due to std::string construction / concatenation.
if (I == FlagsStrings.end())
I = FlagsStrings.insert(std::make_pair(Flags,
printSectionFlags(Flags))).first;
return I->second;
}
unsigned TargetAsmInfo::getULEB128Size(unsigned Value) {
unsigned Size = 0;
do {

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

@ -274,17 +274,18 @@ getSectionPrefixForUniqueGlobal(SectionKind Kind) const {
return ".rdata$linkonce";
}
std::string X86COFFTargetAsmInfo::printSectionFlags(unsigned flags) const {
std::string Flags = ",\"";
if (flags & SectionFlags::Code)
Flags += 'x';
if (flags & SectionFlags::Writable)
Flags += 'w';
void X86COFFTargetAsmInfo::getSectionFlags(unsigned Flags,
SmallVectorImpl<char> &Str) const {
// FIXME: Inefficient.
std::string Res = ",\"";
if (Flags & SectionFlags::Code)
Res += 'x';
if (Flags & SectionFlags::Writable)
Res += 'w';
Res += "\"";
Flags += "\"";
return Flags;
Str.append(Res.begin(), Res.end());
}
X86WinTargetAsmInfo::X86WinTargetAsmInfo(const X86TargetMachine &TM):

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

@ -55,7 +55,9 @@ namespace llvm {
bool Global) const;
virtual const char *
getSectionPrefixForUniqueGlobal(SectionKind kind) const;
virtual std::string printSectionFlags(unsigned flags) const;
virtual void getSectionFlags(unsigned Flags,
SmallVectorImpl<char> &Str) const;
};
struct X86WinTargetAsmInfo : public X86GenericTargetAsmInfo {