#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
// TypePrinting Class: Type printing machinery
//===----------------------------------------------------------------------===//
-static DenseMap<const Type *, std::string> &getTypeNamesMap(void *M) {
- return *static_cast<DenseMap<const Type *, std::string>*>(M);
-}
-
-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 - 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);
+ }
-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.
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;
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;
}
// 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 {