[llvm-commits] [llvm] r65729 - in /llvm/trunk: include/llvm/Assembly/Writer.h lib/VMCore/AsmWriter.cpp

[Chris Lattner]

Author: lattner
Date: Sat Feb 28 16:34:45 2009
New Revision: 65729

URL: http://llvm.org/viewvc/llvm-project?rev=65729&view=rev
Log:
expose TypePrinting as a public API.

Modified:
    llvm/trunk/include/llvm/Assembly/Writer.h
    llvm/trunk/lib/VMCore/AsmWriter.cpp

Modified: llvm/trunk/include/llvm/Assembly/Writer.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Assembly/Writer.h?rev=65729&r1=65728&r2=65729&view=diff

==============================================================================
--- llvm/trunk/include/llvm/Assembly/Writer.h (original)
+++ llvm/trunk/include/llvm/Assembly/Writer.h Sat Feb 28 16:34:45 2009
@@ -25,6 +25,24 @@
 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

Modified: llvm/trunk/lib/VMCore/AsmWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/AsmWriter.cpp?rev=65729&r1=65728&r2=65729&view=diff

==============================================================================
--- llvm/trunk/lib/VMCore/AsmWriter.cpp (original)
+++ llvm/trunk/lib/VMCore/AsmWriter.cpp Sat Feb 28 16:34:45 2009
@@ -137,25 +137,19 @@
 // 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 @@
     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::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 @@
   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::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.