X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FMangler.cpp;h=33eb0449e824067bff0a616f48b945c94597060c;hb=3efabd316f05c8c9f82a62424721532c474fc067;hp=cec41dfd40071d8a4e1572f9c6fd6e690ad579cd;hpb=41ffe6c7afe0ff8ec3d0ae11bd82d165abe5a232;p=oota-llvm.git diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp index cec41dfd400..33eb0449e82 100644 --- a/lib/VMCore/Mangler.cpp +++ b/lib/VMCore/Mangler.cpp @@ -12,11 +12,12 @@ //===----------------------------------------------------------------------===// #include "llvm/Support/Mangler.h" -#include "llvm/DerivedTypes.h" -#include "llvm/Module.h" +#include "llvm/Function.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringMap.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/raw_ostream.h" using namespace llvm; static char HexDigit(int V) { @@ -32,16 +33,9 @@ static std::string MangleLetter(unsigned char C) { /// in them, so mangle them as appropriate. /// std::string Mangler::makeNameProper(const std::string &X, - bool hasPrivateLinkage) { + ManglerPrefixTy PrefixTy) { assert(!X.empty() && "Cannot mangle empty strings"); - // If PreserveAsmNames is set, names with asm identifiers are not modified. - if (PreserveAsmNames && X[0] == 1) - return X; - - // Figure out the prefix to use. - const char *ThePrefix = hasPrivateLinkage ? PrivatePrefix : Prefix; - if (!UseQuotes) { std::string Result; @@ -53,8 +47,9 @@ std::string Mangler::makeNameProper(const std::string &X, ++I; // Skip over the marker. } - // Mangle the first letter specially, don't allow numbers. - if (*I >= '0' && *I <= '9') + // Mangle the first letter specially, don't allow numbers unless the target + // explicitly allows them. + if (!SymbolsCanStartWithDigit && *I >= '0' && *I <= '9') Result += MangleLetter(*I++); for (std::string::const_iterator E = X.end(); I != E; ++I) { @@ -64,8 +59,15 @@ std::string Mangler::makeNameProper(const std::string &X, Result += *I; } - if (NeedPrefix) - Result = ThePrefix + Result; + if (NeedPrefix) { + Result = Prefix + Result; + + if (PrefixTy == Mangler::Private) + Result = PrivatePrefix + Result; + else if (PrefixTy == Mangler::LinkerPrivate) + Result = LinkerPrivatePrefix + Result; + } + return Result; } @@ -95,10 +97,19 @@ std::string Mangler::makeNameProper(const std::string &X, if (!NeedQuotes) { if (!NeedPrefix) return X.substr(1); // Strip off the \001. - return ThePrefix + X; + + 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 (NeedPrefix) + 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) { @@ -110,18 +121,78 @@ std::string Mangler::makeNameProper(const std::string &X, Result += *I; } - if (NeedPrefix) - Result = ThePrefix + Result; + if (NeedPrefix) { + Result = Prefix + Result; + + if (PrefixTy == Mangler::Private) + Result = PrivatePrefix + Result; + else if (PrefixTy == Mangler::LinkerPrivate) + Result = LinkerPrivatePrefix + Result; + } + Result = '"' + Result + '"'; return Result; } -std::string Mangler::getValueName(const GlobalValue *GV, const char *Suffix) { +/// 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"); - + + ManglerPrefixTy PrefixTy = + (GV->hasPrivateLinkage() || ForcePrivate) ? Mangler::Private : + GV->hasLinkerPrivateLinkage() ? Mangler::LinkerPrivate : Mangler::Default; + if (GV->hasName()) - return makeNameProper(GV->getName() + Suffix, GV->hasPrivateLinkage()); + 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); +} + + +/// getNameWithPrefix - Fill OutName with the name of the appropriate prefix +/// and the specified global variable's name. If the global variable doesn't +/// have a name, this fills in a unique name for the global. +void Mangler::getNameWithPrefix(SmallVectorImpl &OutName, + const GlobalValue *GV, + bool isImplicitlyPrivate) { + + // If the global is anonymous or not led with \1, then add the appropriate + // prefix. + if (!GV->hasName() || GV->getName()[0] != '\1') { + if (GV->hasPrivateLinkage() || isImplicitlyPrivate) + OutName.append(PrivatePrefix, PrivatePrefix+strlen(PrivatePrefix)); + else if (GV->hasLinkerPrivateLinkage()) + OutName.append(LinkerPrivatePrefix, + LinkerPrivatePrefix+strlen(LinkerPrivatePrefix));; + OutName.append(Prefix, Prefix+strlen(Prefix)); + } + + // If the global has a name, just append it now. + if (GV->hasName()) { + StringRef Name = GV->getName(); + + // Strip off the prefix marker if present. + if (Name[0] != '\1') + OutName.append(Name.begin(), Name.end()); + else + OutName.append(Name.begin()+1, Name.end()); + return; + } + + // If the global variable doesn't have a name, return a unique name for the + // global based on a numbering. // Get the ID for the global, assigning a new one if we haven't got one // already. @@ -129,12 +200,15 @@ std::string Mangler::getValueName(const GlobalValue *GV, const char *Suffix) { if (ID == 0) ID = NextAnonGlobalID++; // Must mangle the global into a unique ID. - return "__unnamed_" + utostr(ID) + Suffix; + raw_svector_ostream(OutName) << "__unnamed_" << ID; } -Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix) - : Prefix(prefix), PrivatePrefix (privatePrefix), UseQuotes(false), - PreserveAsmNames(false), NextAnonGlobalID(1) { + +Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix, + const char *linkerPrivatePrefix) + : Prefix(prefix), PrivatePrefix(privatePrefix), + LinkerPrivatePrefix(linkerPrivatePrefix), UseQuotes(false), + SymbolsCanStartWithDigit(false), NextAnonGlobalID(1) { std::fill(AcceptableChars, array_endof(AcceptableChars), 0); // Letters and numbers are acceptable. @@ -149,4 +223,5 @@ Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix) markCharAcceptable('_'); markCharAcceptable('$'); markCharAcceptable('.'); + markCharAcceptable('@'); }