X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FMangler.cpp;h=44cf77826629546e4c35d25d9c92824ed575ad56;hb=61466c50df9d00c4a07b1fd72536399cfb418ebd;hp=665cb7388c117b4b78bc936870bef4ffde468740;hpb=6b902dcd5dd32d333899db17de6b8113bd7b34bb;p=oota-llvm.git diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp index 665cb7388c1..44cf7782662 100644 --- a/lib/VMCore/Mangler.cpp +++ b/lib/VMCore/Mangler.cpp @@ -1,80 +1,179 @@ //===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===// // +// The LLVM Compiler Infrastructure +// +// 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. // //===----------------------------------------------------------------------===// #include "llvm/Support/Mangler.h" +#include "llvm/DerivedTypes.h" #include "llvm/Module.h" -#include "llvm/Type.h" -#include "Support/StringExtras.h" - -/// makeNameProper - We don't want identifier names with ., space, or -/// - in them, so we mangle these characters into the strings "d_", -/// "s_", and "D_", respectively. -/// -std::string Mangler::makeNameProper(const std::string &x) { - std::string tmp; - for (std::string::const_iterator sI = x.begin(), sEnd = x.end(); - sI != sEnd; sI++) - switch (*sI) { - case '.': tmp += "d_"; break; - case ' ': tmp += "s_"; break; - case '-': tmp += "D_"; break; - default: tmp += *sI; - } - return tmp; +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringMap.h" +using namespace llvm; + +static char HexDigit(int V) { + return V < 10 ? V+'0' : V+'A'-10; } -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. - } +static std::string MangleLetter(unsigned char C) { + char Result[] = { '_', HexDigit(C >> 4), HexDigit(C & 15), '_', 0 }; + return Result; +} - std::string name; - if (V->hasName()) { // Print out the label if it exists... - // Name mangling occurs as follows: - // - 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 && !gv->hasInternalLinkage() && !MangledGlobals.count(gv)) { - name = makeNameProper(gv->getName()); - } else { - // Non-global, or global with internal linkage / colliding name - // -> mangle. - name = "l" + utostr(V->getType()->getUniqueID()) + "_" + - makeNameProper(V->getName()); +/// 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, + ManglerPrefixTy PrefixTy) { + assert(!X.empty() && "Cannot mangle empty strings"); + + 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; } - } else { - name = "ltmp_" + utostr(Count++) + "_" - + utostr(V->getType()->getUniqueID()); + + if (NeedPrefix) { + Result = Prefix + Result; + + if (PrefixTy == Mangler::Private) + Result = PrivatePrefix + Result; + else if (PrefixTy == Mangler::LinkerPrivate) + Result = LinkerPrivatePrefix + Result; + } + + return Result; } - Memo[V] = name; - return name; + + 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) + return X.substr(1); // Strip off the \001. + + Result = Prefix + X; + + if (PrefixTy == Mangler::Private) + Result = PrivatePrefix + Result; + else if (PrefixTy == Mangler::LinkerPrivate) + Result = LinkerPrivatePrefix + Result; + + return Result; + } + + Result = X.substr(0, I-X.begin()); + + // 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) { + Result = Prefix + Result; + + if (PrefixTy == Mangler::Private) + Result = PrivatePrefix + Result; + else if (PrefixTy == Mangler::LinkerPrivate) + Result = LinkerPrivatePrefix + Result; + } + + Result = '"' + Result + '"'; + return Result; } -Mangler::Mangler(Module &M_) : M(M_) -{ - // Calculate which global values have names that will collide when we throw - // away type information. - std::set FoundNames; - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - if (I->hasName()) // If the global has a name... - if (FoundNames.count(I->getName())) // And the name is already used - MangledGlobals.insert(I); // Mangle the name - else - FoundNames.insert(I->getName()); // Otherwise, keep track of name +/// getMangledName - Returns the mangled name of V, an LLVM Value, +/// in the current module. If 'Suffix' is specified, the name ends with the +/// specified suffix. If 'ForcePrivate' is specified, the label is specified +/// to have a private label prefix. +/// +std::string Mangler::getMangledName(const GlobalValue *GV, const char *Suffix, + bool ForcePrivate) { + assert((!isa(GV) || !cast(GV)->isIntrinsic()) && + "Intrinsic functions cannot be mangled by Mangler"); - for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I) - if (I->hasName()) // If the global has a name... - if (FoundNames.count(I->getName())) // And the name is already used - MangledGlobals.insert(I); // Mangle the name - else - FoundNames.insert(I->getName()); // Otherwise, keep track of name + ManglerPrefixTy PrefixTy = + (GV->hasPrivateLinkage() || ForcePrivate) ? Mangler::Private : + GV->hasLinkerPrivateLinkage() ? Mangler::LinkerPrivate : Mangler::Default; + + if (GV->hasName()) + return makeNameProper(GV->getNameStr() + Suffix, PrefixTy); + + // Get the ID for the global, assigning a new one if we haven't got one + // already. + unsigned &ID = AnonGlobalIDs[GV]; + if (ID == 0) ID = NextAnonGlobalID++; + + // Must mangle the global into a unique ID. + return makeNameProper("__unnamed_" + utostr(ID) + Suffix, PrefixTy); } +Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix, + const char *linkerPrivatePrefix) + : Prefix(prefix), PrivatePrefix(privatePrefix), + LinkerPrivatePrefix(linkerPrivatePrefix), UseQuotes(false), + NextAnonGlobalID(1) { + std::fill(AcceptableChars, array_endof(AcceptableChars), 0); + + // 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('.'); +}