X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FMangler.cpp;h=14830cb8f820bd39c636947250af99eabc45769b;hb=f26226155e2a49fa453f20b850849c5852c3af58;hp=665cb7388c117b4b78bc936870bef4ffde468740;hpb=6b902dcd5dd32d333899db17de6b8113bd7b34bb;p=oota-llvm.git diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp index 665cb7388c1..14830cb8f82 100644 --- a/lib/VMCore/Mangler.cpp +++ b/lib/VMCore/Mangler.cpp @@ -1,4 +1,11 @@ //===-- 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. +// +//===----------------------------------------------------------------------===// // // Unified name mangler for CWriter and assembly backends. // @@ -7,25 +14,47 @@ #include "llvm/Support/Mangler.h" #include "llvm/Module.h" #include "llvm/Type.h" -#include "Support/StringExtras.h" +#include "llvm/ADT/StringExtras.h" +using namespace llvm; + +static char HexDigit(int V) { + return V < 10 ? V+'0' : V+'A'-10; +} + +static std::string MangleLetter(unsigned char C) { + return std::string("_")+HexDigit(C >> 4) + HexDigit(C & 15) + "_"; +} -/// 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. +/// 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 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; +std::string Mangler::makeNameProper(const std::string &X) { + std::string Result; + + // 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); + else + Result += *I; + return Result; } +/// 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 Mangler::getValueName(const Value *V) { // Check to see whether we've already named V. ValueMap::iterator VI = Memo.find(V); @@ -36,45 +65,62 @@ std::string Mangler::getValueName(const Value *V) { 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 && !gv->hasInternalLinkage() && !MangledGlobals.count(gv)) { - name = makeNameProper(gv->getName()); + if (gv && isa(gv) && cast(gv)->getIntrinsicID()) { + name = gv->getName(); // Is an intrinsic function + } else if (gv && !gv->hasInternalLinkage() && !MangledGlobals.count(gv)) { + name = Prefix + makeNameProper(gv->getName()); } else { // Non-global, or global with internal linkage / colliding name // -> mangle. - name = "l" + utostr(V->getType()->getUniqueID()) + "_" + - makeNameProper(V->getName()); + unsigned TypeUniqueID = getTypeID(V->getType()); + name = "l" + utostr(TypeUniqueID) + "_" + makeNameProper(V->getName()); } } else { - name = "ltmp_" + utostr(Count++) + "_" - + utostr(V->getType()->getUniqueID()); + name = "ltmp_" + utostr(Count++) + "_" + utostr(getTypeID(V->getType())); } + Memo[V] = name; return name; } -Mangler::Mangler(Module &M_) : M(M_) -{ +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; + } 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); + } + } +} + + +Mangler::Mangler(Module &m, const char *prefix) + : M(m), Prefix(prefix), TypeCounter(0), Count(0) { // Calculate which global values have names that will collide when we throw // away type information. - std::set FoundNames; + std::map Names; 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 - - 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 + InsertName(I, Names); + for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) + InsertName(I, Names); } -