teach reassociate to factor x+x+x -> x*3. While I'm at it,

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

diff --git a/lib/VMCore/Mangler.cpp b/lib/VMCore/Mangler.cpp
index c4c2502f0c215cdada314a0e235dfa87d0f2d4ec..33eb0449e824067bff0a616f48b945c94597060c 100644 (file)
--- 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) {
@@ -46,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) {
@@ -60,9 +62,9 @@ std::string Mangler::makeNameProper(const std::string &X,
     if (NeedPrefix) {
       Result = Prefix + Result;
 
-      if (PrefixTy == PrivatePrefixTy)
+      if (PrefixTy == Mangler::Private)
         Result = PrivatePrefix + Result;
-      else if (PrefixTy == LinkerPrivatePrefixTy)
+      else if (PrefixTy == Mangler::LinkerPrivate)
         Result = LinkerPrivatePrefix + Result;
     }
 
@@ -98,15 +100,16 @@ std::string Mangler::makeNameProper(const std::string &X,
     
     Result = Prefix + X;
 
-    if (PrefixTy == PrivatePrefixTy)
+    if (PrefixTy == Mangler::Private)
       Result = PrivatePrefix + Result;
-    else if (PrefixTy == LinkerPrivatePrefixTy)
+    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) {
@@ -121,9 +124,9 @@ std::string Mangler::makeNameProper(const std::string &X,
   if (NeedPrefix) {
     Result = Prefix + Result;
 
-    if (PrefixTy == PrivatePrefixTy)
+    if (PrefixTy == Mangler::Private)
       Result = PrivatePrefix + Result;
-    else if (PrefixTy == LinkerPrivatePrefixTy)
+    else if (PrefixTy == Mangler::LinkerPrivate)
       Result = LinkerPrivatePrefix + Result;
   }
 
@@ -142,11 +145,11 @@ std::string Mangler::getMangledName(const GlobalValue *GV, const char *Suffix,
          "Intrinsic functions cannot be mangled by Mangler");
 
   ManglerPrefixTy PrefixTy =
-    (GV->hasPrivateLinkage() || ForcePrivate) ? PrivatePrefixTy :
-     GV->hasLinkerPrivateLinkage() ? LinkerPrivatePrefixTy : DefaultPrefixTy;
+    (GV->hasPrivateLinkage() || ForcePrivate) ? Mangler::Private :
+      GV->hasLinkerPrivateLinkage() ? Mangler::LinkerPrivate : Mangler::Default;
 
   if (GV->hasName())
-    return makeNameProper(GV->getName() + Suffix, PrefixTy);
+    return makeNameProper(GV->getNameStr() + Suffix, PrefixTy);
   
   // Get the ID for the global, assigning a new one if we haven't got one
   // already.
@@ -157,11 +160,55 @@ std::string Mangler::getMangledName(const GlobalValue *GV, const char *Suffix,
   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<char> &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.
+  unsigned &ID = AnonGlobalIDs[GV];
+  if (ID == 0) ID = NextAnonGlobalID++;
+  
+  // Must mangle the global into a unique ID.
+  raw_svector_ostream(OutName) << "__unnamed_" << ID;
+}
+
+
 Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix,
                  const char *linkerPrivatePrefix)
   : Prefix(prefix), PrivatePrefix(privatePrefix),
     LinkerPrivatePrefix(linkerPrivatePrefix), UseQuotes(false),
-    NextAnonGlobalID(1) {
+    SymbolsCanStartWithDigit(false), NextAnonGlobalID(1) {
   std::fill(AcceptableChars, array_endof(AcceptableChars), 0);
 
   // Letters and numbers are acceptable.
@@ -176,4 +223,5 @@ Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix,
   markCharAcceptable('_');
   markCharAcceptable('$');
   markCharAcceptable('.');
+  markCharAcceptable('@');
 }