Implement an isBytecodeArchive method to determine if an archive contains

[oota-llvm.git] / lib / VMCore / Mangler.cpp

diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp
index 699ecd1a651821c8bbab5206fa89b702d71c9cc2..69bbe261fa50f22d32cbdb5db0e8b087379c789d 100644 (file)
--- a/lib/VMCore/Mangler.cpp
+++ b/lib/VMCore/Mangler.cpp
@@ -14,7 +14,7 @@
 #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) {
@@ -46,6 +46,15 @@ std::string Mangler::makeNameProper(const std::string &X) {
   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);
@@ -56,46 +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<GlobalValue>(V);
-    if (gv && !gv->hasInternalLinkage() && !MangledGlobals.count(gv)) {
-      name = makeNameProper(gv->getName());
-      if (AddUnderscorePrefix) name = "_" + name;
+    if (gv && isa<Function>(gv) && cast<Function>(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, bool addUnderscorePrefix)
-  : M(m), AddUnderscorePrefix(addUnderscorePrefix) {
+void Mangler::InsertName(GlobalValue *GV,
+                         std::map<std::string, GlobalValue*> &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<std::string> FoundNames;
+  std::map<std::string, GlobalValue*> 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
-
+    InsertName(I, Names);
   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);
 }