X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FMangler.cpp;h=1a68b890542f6fde732df09e93be7925fcccb922;hb=b983d67465a939c43173e381f9063d9d9245f45b;hp=0705c9b608c6cad457e7570d33c4e67331c65edf;hpb=6e40e1d15c70d21b582dc8273f727aadc751a380;p=oota-llvm.git diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp index 0705c9b608c..1a68b890542 100644 --- a/lib/VMCore/Mangler.cpp +++ b/lib/VMCore/Mangler.cpp @@ -1,10 +1,10 @@ //===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// // // Unified name mangler for CWriter and assembly backends. @@ -12,9 +12,12 @@ //===----------------------------------------------------------------------===// #include "llvm/Support/Mangler.h" +#include "llvm/DerivedTypes.h" #include "llvm/Module.h" -#include "llvm/Type.h" -#include "Support/StringExtras.h" +#include "llvm/System/Atomic.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringMap.h" using namespace llvm; static char HexDigit(int V) { @@ -22,98 +25,177 @@ static char HexDigit(int V) { } static std::string MangleLetter(unsigned char C) { - return std::string("_")+HexDigit(C >> 4) + HexDigit(C & 15) + "_"; + char Result[] = { '_', HexDigit(C >> 4), HexDigit(C & 15), '_', 0 }; + return Result; } /// makeNameProper - We don't want identifier names non-C-identifier characters /// in them, so mangle them as appropriate. -/// -std::string Mangler::makeNameProper(const std::string &X) { - std::string Result; +/// +std::string Mangler::makeNameProper(const std::string &X, const char *Prefix, + const char *PrivatePrefix) { + if (X.empty()) return X; // Empty names are uniqued by the caller. - // Mangle the first letter specially, don't allow numbers... - if ((X[0] < 'a' || X[0] > 'z') && (X[0] < 'A' || X[0] > 'Z') && X[0] != '_') - Result += MangleLetter(X[0]); - else - Result += X[0]; - - for (std::string::const_iterator I = X.begin()+1, E = X.end(); I != E; ++I) - if ((*I < 'a' || *I > 'z') && (*I < 'A' || *I > 'Z') && - (*I < '0' || *I > '9') && *I != '_') - Result += MangleLetter(*I); + // If PreserveAsmNames is set, names with asm identifiers are not modified. + if (PreserveAsmNames && X[0] == 1) + return X; + + if (!UseQuotes) { + std::string Result; + + // If X does not start with (char)1, add the prefix. + bool NeedPrefix = true; + std::string::const_iterator I = X.begin(); + if (*I == 1) { + NeedPrefix = false; + ++I; // Skip over the marker. + } + + // Mangle the first letter specially, don't allow numbers. + if (*I >= '0' && *I <= '9') + Result += MangleLetter(*I++); + + for (std::string::const_iterator E = X.end(); I != E; ++I) { + if (!isCharAcceptable(*I)) + Result += MangleLetter(*I); + else + Result += *I; + } + + if (NeedPrefix) { + if (Prefix) + Result = Prefix + Result; + if (PrivatePrefix) + Result = PrivatePrefix + Result; + } + return Result; + } + + bool NeedPrefix = true; + bool NeedQuotes = false; + std::string Result; + std::string::const_iterator I = X.begin(); + if (*I == 1) { + NeedPrefix = false; + ++I; // Skip over the marker. + } + + // If the first character is a number, we need quotes. + if (*I >= '0' && *I <= '9') + NeedQuotes = true; + + // Do an initial scan of the string, checking to see if we need quotes or + // to escape a '"' or not. + if (!NeedQuotes) + for (std::string::const_iterator E = X.end(); I != E; ++I) + if (!isCharAcceptable(*I)) { + NeedQuotes = true; + break; + } + + // In the common case, we don't need quotes. Handle this quickly. + if (!NeedQuotes) { + if (NeedPrefix) { + if (Prefix) + Result = Prefix + X; + else + Result = X; + if (PrivatePrefix) + Result = PrivatePrefix + Result; + return Result; + } else + return X.substr(1); + } + + // Otherwise, construct the string the expensive way. + for (std::string::const_iterator E = X.end(); I != E; ++I) { + if (*I == '"') + Result += "_QQ_"; + else if (*I == '\n') + Result += "_NL_"; else Result += *I; + } + + if (NeedPrefix) { + if (Prefix) + Result = Prefix + X; + else + Result = X; + if (PrivatePrefix) + Result = PrivatePrefix + Result; + } + Result = '"' + Result + '"'; return Result; } -std::string Mangler::getValueName(const Value *V) { - // Check to see whether we've already named V. - ValueMap::iterator VI = Memo.find(V); - if (VI != Memo.end()) { - return VI->second; // Return the old name for V. - } +/// getTypeID - Return a unique ID for the specified LLVM type. +/// +unsigned Mangler::getTypeID(const Type *Ty) { + unsigned &E = TypeMap[Ty]; + if (E == 0) E = ++TypeCounter; + return E; +} - std::string name; - if (V->hasName()) { // Print out the label if it exists... - // Name mangling occurs as follows: - // - If V is an intrinsic function, do not change name at all - // - If V is not a global, mangling always occurs. - // - Otherwise, mangling occurs when any of the following are true: - // 1) V has internal linkage - // 2) V's name would collide if it is not mangled. - // - const GlobalValue* gv = dyn_cast(V); - if (gv && isa(gv) && cast(gv)->getIntrinsicID()) { - name = gv->getName(); // Is an intrinsic function - } else if (gv && !gv->hasInternalLinkage() && !MangledGlobals.count(gv)) { - name = makeNameProper(gv->getName()); - if (AddUnderscorePrefix) name = "_" + name; - } else { - // Non-global, or global with internal linkage / colliding name - // -> mangle. - name = "l" + utostr(V->getType()->getUniqueID()) + "_" + - makeNameProper(V->getName()); - } - } else { - name = "ltmp_" + utostr(Count++) + "_" - + utostr(V->getType()->getUniqueID()); - } +std::string Mangler::getValueName(const Value *V) { + if (const GlobalValue *GV = dyn_cast(V)) + return getValueName(GV); - Memo[V] = name; - return name; + std::string &Name = Memo[V]; + if (!Name.empty()) + return Name; // Return the already-computed name for V. + + // Always mangle local names. + Name = "ltmp_" + utostr(Count++) + "_" + utostr(getTypeID(V->getType())); + return Name; } -void Mangler::InsertName(GlobalValue *GV, - std::map &Names) { - if (!GV->hasName()) { // We must mangle unnamed globals. - MangledGlobals.insert(GV); - return; - } - // Figure out if this is already used. - GlobalValue *&ExistingValue = Names[GV->getName()]; - if (!ExistingValue) { - ExistingValue = GV; +std::string Mangler::getValueName(const GlobalValue *GV, const char * Suffix) { + // Check to see whether we've already named V. + std::string &Name = Memo[GV]; + if (!Name.empty()) + return Name; // Return the already-computed name for V. + + // Name mangling occurs as follows: + // - 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->getNameStart(); // Is an intrinsic function + } else if (!GV->hasName()) { + // Must mangle the global into a unique ID. + unsigned TypeUniqueID = getTypeID(GV->getType()); + static uint32_t GlobalID = 0; + + unsigned OldID = GlobalID; + sys::AtomicIncrement(&GlobalID); + + Name = "__unnamed_" + utostr(TypeUniqueID) + "_" + utostr(OldID); } else { - // If GV is external but the existing one is static, mangle the existing one - if (GV->hasExternalLinkage() && !ExistingValue->hasExternalLinkage()) { - MangledGlobals.insert(ExistingValue); - ExistingValue = GV; - } else { - // Otherwise, mangle GV - MangledGlobals.insert(GV); - } + if (GV->hasPrivateLinkage()) + Name = makeNameProper(GV->getName() + Suffix, Prefix, PrivatePrefix); + else + Name = makeNameProper(GV->getName() + Suffix, Prefix); } + + return Name; } +Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix) + : Prefix(prefix), PrivatePrefix (privatePrefix), UseQuotes(false), + PreserveAsmNames(false), Count(0), TypeCounter(0) { + std::fill(AcceptableChars, array_endof(AcceptableChars), 0); -Mangler::Mangler(Module &m, bool addUnderscorePrefix) - : M(m), AddUnderscorePrefix(addUnderscorePrefix), Count(0) { - // Calculate which global values have names that will collide when we throw - // away type information. - std::map Names; - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - InsertName(I, Names); - for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I) - InsertName(I, Names); + // Letters and numbers are acceptable. + for (unsigned char X = 'a'; X <= 'z'; ++X) + markCharAcceptable(X); + for (unsigned char X = 'A'; X <= 'Z'; ++X) + markCharAcceptable(X); + for (unsigned char X = '0'; X <= '9'; ++X) + markCharAcceptable(X); + + // These chars are acceptable. + markCharAcceptable('_'); + markCharAcceptable('$'); + markCharAcceptable('.'); }