maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

expose TypePrinting as a public API. 

llvm-svn: 65729
This commit is contained in:
Chris Lattner 2009-02-28 22:34:45 +00:00
parent e2a87a98b3
commit 3ad4682b23
2 changed files with 42 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
llvm/include/llvm/Assembly/Writer.h
View File

@ -25,6 +25,24 @@ class Type;
class Module;
class Value;
class raw_ostream;
template <typename T> class SmallVectorImpl;
/// TypePrinting - Type printing machinery.
class TypePrinting {
void *TypeNames;
public:
TypePrinting(const Module *M);
~TypePrinting();
void clear();
void print(const Type *Ty, raw_ostream &OS);
void printAtLeastOneLevel(const Type *Ty, raw_ostream &OS);
private:
void CalcTypeName(const Type *Ty, SmallVectorImpl<const Type *> &TypeStack,
raw_ostream &OS);
};
// WriteTypeSymbolic - This attempts to write the specified type as a symbolic
// type, if there is an entry in the Module's symbol table for the specified

47
llvm/lib/VMCore/AsmWriter.cpp
View File

@ -137,25 +137,19 @@ static void PrintLLVMName(raw_ostream &OS, const Value *V) {
// TypePrinting Class: Type printing machinery
//===----------------------------------------------------------------------===//
namespace {
/// TypePrinting - Type printing machinery.
class TypePrinting {
std::map<const Type *, std::string> TypeNames;
public:
TypePrinting(const Module *M);
void print(const Type *Ty, raw_ostream &OS);
void printAtLeastOneLevel(const Type *Ty, raw_ostream &OS);
private:
void CalcTypeName(const Type *Ty, SmallVectorImpl<const Type *> &TypeStack,
raw_ostream &OS);
};
} // end anonymous namespace.
static std::map<const Type *, std::string> &getTypeNamesMap(void *M) {
return *static_cast<std::map<const Type *, std::string>*>(M);
}
void TypePrinting::clear() {
getTypeNamesMap(TypeNames).clear();
}
TypePrinting::TypePrinting(const Module *M) {
if (M == 0) return;
TypeNames = new std::map<const Type *, std::string>();
// If the module has a symbol table, take all global types and stuff their
// names into the TypeNames map.
const TypeSymbolTable &ST = M->getTypeSymbolTable();
@ -180,18 +174,23 @@ TypePrinting::TypePrinting(const Module *M) {
std::string NameStr;
raw_string_ostream NameOS(NameStr);
PrintLLVMName(NameOS, TI->first.c_str(), TI->first.length(), LocalPrefix);
TypeNames.insert(std::make_pair(Ty, NameOS.str()));
getTypeNamesMap(TypeNames).insert(std::make_pair(Ty, NameOS.str()));
}
}
TypePrinting::~TypePrinting() {
delete &getTypeNamesMap(TypeNames);
}
/// CalcTypeName - Write the specified type to the specified raw_ostream, making
/// use of type names or up references to shorten the type name where possible.
void TypePrinting::CalcTypeName(const Type *Ty,
SmallVectorImpl<const Type *> &TypeStack,
raw_ostream &OS) {
// Check to see if the type is named.
std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
if (I != TypeNames.end() &&
std::map<const Type*, std::string> &TM = getTypeNamesMap(TypeNames);
std::map<const Type *, std::string>::iterator I = TM.find(Ty);
if (I != TM.end() &&
// If the name wasn't temporarily removed use it.
!I->second.empty()) {
OS << I->second;
@ -296,8 +295,9 @@ void TypePrinting::CalcTypeName(const Type *Ty,
///
void TypePrinting::print(const Type *Ty, raw_ostream &OS) {
// Check to see if the type is named.
std::map<const Type*, std::string>::iterator I = TypeNames.find(Ty);
if (I != TypeNames.end()) {
std::map<const Type*, std::string> &TM = getTypeNamesMap(TypeNames);
std::map<const Type*, std::string>::iterator I = TM.find(Ty);
if (I != TM.end()) {
OS << I->second;
return;
}
@ -313,7 +313,7 @@ void TypePrinting::print(const Type *Ty, raw_ostream &OS) {
OS << TypeOS.str();
// Cache type name for later use.
TypeNames.insert(std::make_pair(Ty, TypeOS.str()));
TM.insert(std::make_pair(Ty, TypeOS.str()));
}
/// printAtLeastOneLevel - Print out one level of the possibly complex type
@ -321,8 +321,9 @@ void TypePrinting::print(const Type *Ty, raw_ostream &OS) {
void TypePrinting::printAtLeastOneLevel(const Type *Ty, raw_ostream &OS) {
// If the type does not have a name, then it is already guaranteed to print at
// least one level.
std::map<const Type*, std::string>::iterator I = TypeNames.find(Ty);
if (I == TypeNames.end())
std::map<const Type*, std::string> &TM = getTypeNamesMap(TypeNames);
std::map<const Type*, std::string>::iterator I = TM.find(Ty);
if (I == TM.end())
return print(Ty, OS);
// Otherwise, temporarily remove the name and print it.