RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-01-20 10:42:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

now that Type::getDescription() is dead, the TypePrinting class can move from Assembly/Writer.h to being

Browse Source 
a private class in AsmWriter.cpp.

llvm-svn: 133361
This commit is contained in:
Chris Lattner 2011-06-18 21:23:04 +00:00
parent 50b274b1cb
commit 6632283a47
3 changed files with 42 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -17,46 +17,12 @@
#ifndef LLVM_ASSEMBLY_WRITER_H
#define LLVM_ASSEMBLY_WRITER_H
#include <string>
namespace llvm {
class Type;
class Module;
class Value;
class raw_ostream;
template <typename T> class SmallVectorImpl;
/// TypePrinting - Type printing machinery.
class TypePrinting {
void *TypeNames; // A map to remember type names.
TypePrinting(const TypePrinting &); // DO NOT IMPLEMENT
void operator=(const TypePrinting&); // DO NOT IMPLEMENT
public:
TypePrinting();
~TypePrinting();
void clear();
void print(const Type *Ty, raw_ostream &OS, bool IgnoreTopLevelName = false);
void printAtLeastOneLevel(const Type *Ty, raw_ostream &OS) {
print(Ty, OS, true);
}
/// hasTypeName - Return true if the type has a name in TypeNames, false
/// otherwise.
bool hasTypeName(const Type *Ty) const;
/// addTypeName - Add a name for the specified type if it doesn't already have
/// one. This name will be printed instead of the structural version of the
/// type in order to make the output more concise.
void addTypeName(const Type *Ty, const std::string &N);
private:
void CalcTypeName(const Type *Ty, SmallVectorImpl<const Type *> &TypeStack,
raw_ostream &OS, bool IgnoreTopLevelName = false);
};
// 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

1
include/llvm/Type.h
View File

@ -17,7 +17,6 @@
#include "llvm/AbstractTypeUser.h"
#include "llvm/Support/Casting.h"
#include <string>
#include <vector>
namespace llvm {

70
lib/VMCore/AsmWriter.cpp
View File

@ -140,30 +140,45 @@ static void PrintLLVMName(raw_ostream &OS, const Value *V) {
// TypePrinting Class: Type printing machinery
//===----------------------------------------------------------------------===//
static DenseMap<const Type *, std::string> &getTypeNamesMap(void *M) {
return *static_cast<DenseMap<const Type *, std::string>*>(M);
}
/// TypePrinting - Type printing machinery.
namespace {
class TypePrinting {
DenseMap<const Type *, std::string> TypeNames;
TypePrinting(const TypePrinting &); // DO NOT IMPLEMENT
void operator=(const TypePrinting&); // DO NOT IMPLEMENT
public:
TypePrinting() {}
~TypePrinting() {}
void clear() {
TypeNames.clear();
}
void print(const Type *Ty, raw_ostream &OS, bool IgnoreTopLevelName = false);
void printAtLeastOneLevel(const Type *Ty, raw_ostream &OS) {
print(Ty, OS, true);
}
/// hasTypeName - Return true if the type has a name in TypeNames, false
/// otherwise.
bool hasTypeName(const Type *Ty) const {
return TypeNames.count(Ty);
}
void TypePrinting::clear() {
getTypeNamesMap(TypeNames).clear();
}
bool TypePrinting::hasTypeName(const Type *Ty) const {
return getTypeNamesMap(TypeNames).count(Ty);
}
void TypePrinting::addTypeName(const Type *Ty, const std::string &N) {
getTypeNamesMap(TypeNames).insert(std::make_pair(Ty, N));
}
TypePrinting::TypePrinting() {
TypeNames = new DenseMap<const Type *, std::string>();
}
TypePrinting::~TypePrinting() {
delete &getTypeNamesMap(TypeNames);
}
/// addTypeName - Add a name for the specified type if it doesn't already have
/// one. This name will be printed instead of the structural version of the
/// type in order to make the output more concise.
void addTypeName(const Type *Ty, const std::string &N) {
TypeNames.insert(std::make_pair(Ty, N));
}
private:
void CalcTypeName(const Type *Ty, SmallVectorImpl<const Type *> &TypeStack,
raw_ostream &OS, bool IgnoreTopLevelName = false);
};
} // end anonymous namespace.
/// 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.
@ -172,7 +187,7 @@ void TypePrinting::CalcTypeName(const Type *Ty,
raw_ostream &OS, bool IgnoreTopLevelName) {
// Check to see if the type is named.
if (!IgnoreTopLevelName) {
DenseMap<const Type *, std::string> &TM = getTypeNamesMap(TypeNames);
DenseMap<const Type *, std::string> &TM = TypeNames;
DenseMap<const Type *, std::string>::iterator I = TM.find(Ty);
if (I != TM.end()) {
OS << I->second;
@ -283,10 +298,9 @@ void TypePrinting::CalcTypeName(const Type *Ty,
void TypePrinting::print(const Type *Ty, raw_ostream &OS,
bool IgnoreTopLevelName) {
// Check to see if the type is named.
DenseMap<const Type*, std::string> &TM = getTypeNamesMap(TypeNames);
if (!IgnoreTopLevelName) {
DenseMap<const Type*, std::string>::iterator I = TM.find(Ty);
if (I != TM.end()) {
DenseMap<const Type*, std::string>::iterator I = TypeNames.find(Ty);
if (I != TypeNames.end()) {
OS << I->second;
return;
}
@ -304,7 +318,7 @@ void TypePrinting::print(const Type *Ty, raw_ostream &OS,
// Cache type name for later use.
if (!IgnoreTopLevelName)
TM.insert(std::make_pair(Ty, TypeOS.str()));
TypeNames.insert(std::make_pair(Ty, TypeOS.str()));
}
namespace {