From 250c1d8734ae29b8e408e16dc575b21a31fcb0d7 Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Thu, 10 Jul 2008 00:04:23 +0000 Subject: [PATCH] - Replace use of std::map with StringMap. Replace use of std::map with DenseMap, std::set with SmallPtrSet. This results in minor speed up. - Some code clean up. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53379 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/Mangler.h | 17 +++++------ lib/VMCore/Mangler.cpp | 55 +++++++++++++++++----------------- 2 files changed, 35 insertions(+), 37 deletions(-) diff --git a/include/llvm/Support/Mangler.h b/include/llvm/Support/Mangler.h index 0a7b33a2327..94f0adb267d 100644 --- a/include/llvm/Support/Mangler.h +++ b/include/llvm/Support/Mangler.h @@ -15,8 +15,7 @@ #define LLVM_SUPPORT_MANGLER_H #include "llvm/ADT/DenseMap.h" -#include -#include +#include "llvm/ADT/SmallPtrSet.h" #include namespace llvm { @@ -49,13 +48,13 @@ class Mangler { /// TypeMap - If the client wants us to unique types, this keeps track of the /// current assignments and TypeCounter keeps track of the next id to assign. - std::map TypeMap; + DenseMap TypeMap; unsigned TypeCounter; /// This keeps track of which global values have had their names /// mangled in the current module. /// - std::set MangledGlobals; + SmallPtrSet MangledGlobals; /// AcceptableChars - This bitfield contains a one for each character that is /// allowed to be part of an unmangled name. @@ -87,10 +86,6 @@ public: return (AcceptableChars[X/32] & (1 << (X&31))) != 0; } - /// getTypeID - Return a unique ID for the specified LLVM type. - /// - unsigned getTypeID(const Type *Ty); - /// getValueName - Returns the mangled name of V, an LLVM Value, /// in the current module. /// @@ -105,9 +100,11 @@ public: /// from getValueName. /// std::string makeNameProper(const std::string &x, const char *Prefix = ""); - + private: - void InsertName(GlobalValue *GV, std::map &Names); + /// getTypeID - Return a unique ID for the specified LLVM type. + /// + unsigned getTypeID(const Type *Ty); }; } // End llvm namespace diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp index 50fa3c1885b..d86d9c0da6c 100644 --- a/lib/VMCore/Mangler.cpp +++ b/lib/VMCore/Mangler.cpp @@ -16,6 +16,7 @@ #include "llvm/Module.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringMap.h" using namespace llvm; static char HexDigit(int V) { @@ -138,7 +139,7 @@ std::string Mangler::getValueName(const GlobalValue *GV, const char * Suffix) { // - If V is an intrinsic function, do not change name at all // - Otherwise, mangling occurs if global collides with existing name. if (isa(GV) && cast(GV)->isIntrinsic()) { - Name = GV->getName(); // Is an intrinsic function + Name = GV->getNameStart(); // Is an intrinsic function } else if (!GV->hasName()) { // Must mangle the global into a unique ID. unsigned TypeUniqueID = getTypeID(GV->getType()); @@ -154,34 +155,35 @@ std::string Mangler::getValueName(const GlobalValue *GV, const char * Suffix) { return Name; } -void Mangler::InsertName(GlobalValue *GV, - std::map &Names) { +static void InsertName(GlobalValue *GV, StringMap &Names, + SmallPtrSet &MangledGlobals) { if (!GV->hasName()) // We must mangle unnamed globals. return; // Figure out if this is already used. - GlobalValue *&ExistingValue = Names[GV->getName()]; + GlobalValue *&ExistingValue = Names[GV->getNameStart()]; if (!ExistingValue) { ExistingValue = GV; + return; + } + + // If GV is external but the existing one is static, mangle the existing one + if ((GV->hasExternalLinkage() || GV->hasDLLImportLinkage()) && + !(ExistingValue->hasExternalLinkage() + || ExistingValue->hasDLLImportLinkage())) { + MangledGlobals.insert(ExistingValue); + ExistingValue = GV; + } else if ((GV->hasExternalLinkage() || + GV->hasDLLImportLinkage()) && + (ExistingValue->hasExternalLinkage() || + ExistingValue->hasDLLImportLinkage()) && + GV->isDeclaration() && + ExistingValue->isDeclaration()) { + // If the two globals both have external inkage, and are both external, + // don't mangle either of them, we just have some silly type mismatch. } else { - // If GV is external but the existing one is static, mangle the existing one - if ((GV->hasExternalLinkage() || GV->hasDLLImportLinkage()) && - !(ExistingValue->hasExternalLinkage() - || ExistingValue->hasDLLImportLinkage())) { - MangledGlobals.insert(ExistingValue); - ExistingValue = GV; - } else if ((GV->hasExternalLinkage() || - GV->hasDLLImportLinkage()) && - (ExistingValue->hasExternalLinkage() || - ExistingValue->hasDLLImportLinkage()) && - GV->isDeclaration() && - ExistingValue->isDeclaration()) { - // If the two globals both have external inkage, and are both external, - // don't mangle either of them, we just have some silly type mismatch. - } else { - // Otherwise, mangle GV - MangledGlobals.insert(GV); - } + // Otherwise, mangle GV + MangledGlobals.insert(GV); } } @@ -206,11 +208,10 @@ Mangler::Mangler(Module &M, const char *prefix) // Calculate which global values have names that will collide when we throw // away type information. - std::map Names; + StringMap Names; for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - InsertName(I, Names); + InsertName(I, Names, MangledGlobals); for (Module::global_iterator I = M.global_begin(), E = M.global_end(); - I != E; - ++I) - InsertName(I, Names); + I != E; ++I) + InsertName(I, Names, MangledGlobals); } -- 2.34.1