X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FMangler.cpp;h=44cf77826629546e4c35d25d9c92824ed575ad56;hb=61466c50df9d00c4a07b1fd72536399cfb418ebd;hp=53719aff2cc1405a5461269adc461cfbf1a4f7b5;hpb=af303d53e6013417d189621c75179df6c7cbdcde;p=oota-llvm.git diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp index 53719aff2cc..44cf7782662 100644 --- a/lib/VMCore/Mangler.cpp +++ b/lib/VMCore/Mangler.cpp @@ -2,8 +2,8 @@ // // 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. // //===----------------------------------------------------------------------===// // @@ -14,7 +14,9 @@ #include "llvm/Support/Mangler.h" #include "llvm/DerivedTypes.h" #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) { @@ -29,17 +31,20 @@ static std::string MangleLetter(unsigned char C) { /// 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, const char *Prefix) { - std::string Result; - if (X.empty()) return X; // Empty names are uniqued by the caller. +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) - Result = Prefix; - else + if (*I == 1) { + NeedPrefix = false; ++I; // Skip over the marker. + } // Mangle the first letter specially, don't allow numbers. if (*I >= '0' && *I <= '9') @@ -51,133 +56,113 @@ std::string Mangler::makeNameProper(const std::string &X, const char *Prefix) { else Result += *I; } - } else { - bool NeedsQuotes = false; - - std::string::const_iterator I = X.begin(); - if (*I == 1) - ++I; // Skip over the marker. - // If the first character is a number, we need quotes. - if (*I >= '0' && *I <= '9') - NeedsQuotes = true; + if (NeedPrefix) { + Result = Prefix + Result; + + if (PrefixTy == Mangler::Private) + Result = PrivatePrefix + Result; + else if (PrefixTy == Mangler::LinkerPrivate) + Result = LinkerPrivatePrefix + 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 (!NeedsQuotes) - for (std::string::const_iterator E = X.end(); I != E; ++I) - if (!isCharAcceptable(*I)) { - NeedsQuotes = true; - break; - } + // 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 (!NeedsQuotes) { - if (*X.begin() != 1) - return Prefix+X; - else - return X.substr(1); - } + // In the common case, we don't need quotes. Handle this quickly. + if (!NeedQuotes) { + if (!NeedPrefix) + return X.substr(1); // Strip off the \001. - // Otherwise, construct the string the expensive way. - I = X.begin(); + 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()); - // If X does not start with (char)1, add the prefix. - if (*I != 1) - Result = Prefix; + // 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 - ++I; // Skip the marker if present. - - for (std::string::const_iterator E = X.end(); I != E; ++I) { - if (*I == '"') - Result += "_QQ_"; - else - Result += *I; - } - Result = '"' + Result + '"'; + 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; } -/// getTypeID - Return a unique ID for the specified LLVM type. +/// 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. /// -unsigned Mangler::getTypeID(const Type *Ty) { - unsigned &E = TypeMap[Ty]; - if (E == 0) E = ++TypeCounter; - return E; -} +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"); + + ManglerPrefixTy PrefixTy = + (GV->hasPrivateLinkage() || ForcePrivate) ? Mangler::Private : + GV->hasLinkerPrivateLinkage() ? Mangler::LinkerPrivate : Mangler::Default; -std::string Mangler::getValueName(const Value *V) { - if (const GlobalValue *GV = dyn_cast(V)) - return getValueName(GV); + if (GV->hasName()) + return makeNameProper(GV->getNameStr() + Suffix, PrefixTy); - std::string &Name = Memo[V]; - if (!Name.empty()) - return Name; // Return the already-computed name for V. + // 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++; - // Always mangle local names. - Name = "ltmp_" + utostr(Count++) + "_" + utostr(getTypeID(V->getType())); - return Name; + // Must mangle the global into a unique ID. + return makeNameProper("__unnamed_" + utostr(ID) + Suffix, PrefixTy); } - -std::string Mangler::getValueName(const GlobalValue *GV) { - // 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)->getIntrinsicID()) { - Name = GV->getName(); // Is an intrinsic function - } else if (!GV->hasName()) { - // Must mangle the global into a unique ID. - unsigned TypeUniqueID = getTypeID(GV->getType()); - static unsigned GlobalID = 0; - Name = "__unnamed_" + utostr(TypeUniqueID) + "_" + utostr(GlobalID++); - } else if (!MangledGlobals.count(GV)) { - Name = makeNameProper(GV->getName(), Prefix); - } else { - unsigned TypeUniqueID = getTypeID(GV->getType()); - Name = "l" + utostr(TypeUniqueID) + "_" + makeNameProper(GV->getName()); - } - - return Name; -} - -void Mangler::InsertName(GlobalValue *GV, - std::map &Names) { - if (!GV->hasName()) // We must mangle unnamed globals. - return; - - // Figure out if this is already used. - GlobalValue *&ExistingValue = Names[GV->getName()]; - if (!ExistingValue) { - ExistingValue = GV; - } 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 if (GV->hasExternalLinkage() && ExistingValue->hasExternalLinkage()&& - GV->isExternal() && ExistingValue->isExternal()) { - // 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); - } - } -} - - -Mangler::Mangler(Module &M, const char *prefix) - : Prefix(prefix), UseQuotes(false), Count(0), TypeCounter(0) { - std::fill(AcceptableChars, - AcceptableChars+sizeof(AcceptableChars)/sizeof(AcceptableChars[0]), - 0); +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) @@ -191,15 +176,4 @@ Mangler::Mangler(Module &M, const char *prefix) markCharAcceptable('_'); markCharAcceptable('$'); markCharAcceptable('.'); - - // 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::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) - InsertName(I, Names); } - -// Cause this file to be linked in when Support/Mangler.h is #included -DEFINING_FILE_FOR(Mangler)