Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 1 | //===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file was developed by the LLVM research group and is distributed under |
| 6 | // the University of Illinois Open Source License. See LICENSE.TXT for details. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 9 | // |
| 10 | // Unified name mangler for CWriter and assembly backends. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Brian Gaeke | 6b902dc | 2003-07-25 20:21:20 +0000 | [diff] [blame] | 14 | #include "llvm/Support/Mangler.h" |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 15 | #include "llvm/DerivedTypes.h" |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 16 | #include "llvm/Module.h" |
Owen Anderson | 718cb66 | 2007-09-07 04:06:50 +0000 | [diff] [blame] | 17 | #include "llvm/ADT/STLExtras.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 18 | #include "llvm/ADT/StringExtras.h" |
Chris Lattner | 2cdd21c | 2003-12-14 21:35:53 +0000 | [diff] [blame] | 19 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 20 | |
Chris Lattner | aa8a847 | 2003-08-24 21:08:38 +0000 | [diff] [blame] | 21 | static char HexDigit(int V) { |
| 22 | return V < 10 ? V+'0' : V+'A'-10; |
| 23 | } |
| 24 | |
| 25 | static std::string MangleLetter(unsigned char C) { |
Chris Lattner | 91150e5 | 2005-11-10 21:40:01 +0000 | [diff] [blame] | 26 | char Result[] = { '_', HexDigit(C >> 4), HexDigit(C & 15), '_', 0 }; |
| 27 | return Result; |
Chris Lattner | aa8a847 | 2003-08-24 21:08:38 +0000 | [diff] [blame] | 28 | } |
| 29 | |
| 30 | /// makeNameProper - We don't want identifier names non-C-identifier characters |
| 31 | /// in them, so mangle them as appropriate. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 32 | /// |
Chris Lattner | 5b845c9 | 2005-09-24 08:24:28 +0000 | [diff] [blame] | 33 | std::string Mangler::makeNameProper(const std::string &X, const char *Prefix) { |
Chris Lattner | aa8a847 | 2003-08-24 21:08:38 +0000 | [diff] [blame] | 34 | std::string Result; |
Chris Lattner | 91150e5 | 2005-11-10 21:40:01 +0000 | [diff] [blame] | 35 | if (X.empty()) return X; // Empty names are uniqued by the caller. |
Chris Lattner | 5b845c9 | 2005-09-24 08:24:28 +0000 | [diff] [blame] | 36 | |
Chris Lattner | 833eb68 | 2006-09-07 18:20:41 +0000 | [diff] [blame] | 37 | // If PreserveAsmNames is set, names with asm identifiers are not modified. |
| 38 | if (PreserveAsmNames && X[0] == 1) |
| 39 | return X; |
| 40 | |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 41 | if (!UseQuotes) { |
| 42 | // If X does not start with (char)1, add the prefix. |
| 43 | std::string::const_iterator I = X.begin(); |
| 44 | if (*I != 1) |
| 45 | Result = Prefix; |
Chris Lattner | aa8a847 | 2003-08-24 21:08:38 +0000 | [diff] [blame] | 46 | else |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 47 | ++I; // Skip over the marker. |
| 48 | |
Chris Lattner | 91150e5 | 2005-11-10 21:40:01 +0000 | [diff] [blame] | 49 | // Mangle the first letter specially, don't allow numbers. |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 50 | if (*I >= '0' && *I <= '9') |
| 51 | Result += MangleLetter(*I++); |
| 52 | |
Chris Lattner | 91150e5 | 2005-11-10 21:40:01 +0000 | [diff] [blame] | 53 | for (std::string::const_iterator E = X.end(); I != E; ++I) { |
| 54 | if (!isCharAcceptable(*I)) |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 55 | Result += MangleLetter(*I); |
| 56 | else |
| 57 | Result += *I; |
Chris Lattner | 91150e5 | 2005-11-10 21:40:01 +0000 | [diff] [blame] | 58 | } |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 59 | } else { |
| 60 | bool NeedsQuotes = false; |
| 61 | |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 62 | std::string::const_iterator I = X.begin(); |
Chris Lattner | 92c4bb9 | 2005-11-10 23:24:26 +0000 | [diff] [blame] | 63 | if (*I == 1) |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 64 | ++I; // Skip over the marker. |
Chris Lattner | 92c4bb9 | 2005-11-10 23:24:26 +0000 | [diff] [blame] | 65 | |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 66 | // If the first character is a number, we need quotes. |
| 67 | if (*I >= '0' && *I <= '9') |
| 68 | NeedsQuotes = true; |
| 69 | |
Chris Lattner | bc07666 | 2005-11-10 21:47:01 +0000 | [diff] [blame] | 70 | // Do an initial scan of the string, checking to see if we need quotes or |
| 71 | // to escape a '"' or not. |
| 72 | if (!NeedsQuotes) |
| 73 | for (std::string::const_iterator E = X.end(); I != E; ++I) |
| 74 | if (!isCharAcceptable(*I)) { |
| 75 | NeedsQuotes = true; |
| 76 | break; |
| 77 | } |
| 78 | |
| 79 | // In the common case, we don't need quotes. Handle this quickly. |
Chris Lattner | 92c4bb9 | 2005-11-10 23:24:26 +0000 | [diff] [blame] | 80 | if (!NeedsQuotes) { |
| 81 | if (*X.begin() != 1) |
| 82 | return Prefix+X; |
| 83 | else |
| 84 | return X.substr(1); |
| 85 | } |
Chris Lattner | bc07666 | 2005-11-10 21:47:01 +0000 | [diff] [blame] | 86 | |
| 87 | // Otherwise, construct the string the expensive way. |
| 88 | I = X.begin(); |
Chris Lattner | 92c4bb9 | 2005-11-10 23:24:26 +0000 | [diff] [blame] | 89 | |
| 90 | // If X does not start with (char)1, add the prefix. |
| 91 | if (*I != 1) |
| 92 | Result = Prefix; |
| 93 | else |
| 94 | ++I; // Skip the marker if present. |
| 95 | |
Chris Lattner | bc07666 | 2005-11-10 21:47:01 +0000 | [diff] [blame] | 96 | for (std::string::const_iterator E = X.end(); I != E; ++I) { |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 97 | if (*I == '"') |
| 98 | Result += "_QQ_"; |
Chris Lattner | bc07666 | 2005-11-10 21:47:01 +0000 | [diff] [blame] | 99 | else |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 100 | Result += *I; |
Chris Lattner | bc07666 | 2005-11-10 21:47:01 +0000 | [diff] [blame] | 101 | } |
| 102 | Result = '"' + Result + '"'; |
Chris Lattner | ac8c834 | 2005-11-10 19:30:07 +0000 | [diff] [blame] | 103 | } |
Chris Lattner | aa8a847 | 2003-08-24 21:08:38 +0000 | [diff] [blame] | 104 | return Result; |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 105 | } |
| 106 | |
Chris Lattner | d6391d7 | 2004-07-08 22:09:34 +0000 | [diff] [blame] | 107 | /// getTypeID - Return a unique ID for the specified LLVM type. |
| 108 | /// |
| 109 | unsigned Mangler::getTypeID(const Type *Ty) { |
| 110 | unsigned &E = TypeMap[Ty]; |
| 111 | if (E == 0) E = ++TypeCounter; |
| 112 | return E; |
| 113 | } |
| 114 | |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 115 | std::string Mangler::getValueName(const Value *V) { |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 116 | if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) |
| 117 | return getValueName(GV); |
| 118 | |
| 119 | std::string &Name = Memo[V]; |
| 120 | if (!Name.empty()) |
| 121 | return Name; // Return the already-computed name for V. |
| 122 | |
| 123 | // Always mangle local names. |
| 124 | Name = "ltmp_" + utostr(Count++) + "_" + utostr(getTypeID(V->getType())); |
| 125 | return Name; |
| 126 | } |
| 127 | |
| 128 | |
Bill Wendling | ecd9137 | 2007-09-17 22:39:32 +0000 | [diff] [blame] | 129 | std::string Mangler::getValueName(const GlobalValue *GV, const char * Suffix) { |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 130 | // Check to see whether we've already named V. |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 131 | std::string &Name = Memo[GV]; |
| 132 | if (!Name.empty()) |
| 133 | return Name; // Return the already-computed name for V. |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 134 | |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 135 | // Name mangling occurs as follows: |
| 136 | // - If V is an intrinsic function, do not change name at all |
| 137 | // - Otherwise, mangling occurs if global collides with existing name. |
Duncan Sands | a3355ff | 2007-12-03 20:06:50 +0000 | [diff] [blame^] | 138 | if (isa<Function>(GV) && cast<Function>(GV)->isIntrinsic()) { |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 139 | Name = GV->getName(); // Is an intrinsic function |
Chris Lattner | d358cfc | 2005-11-15 01:32:03 +0000 | [diff] [blame] | 140 | } else if (!GV->hasName()) { |
| 141 | // Must mangle the global into a unique ID. |
| 142 | unsigned TypeUniqueID = getTypeID(GV->getType()); |
| 143 | static unsigned GlobalID = 0; |
| 144 | Name = "__unnamed_" + utostr(TypeUniqueID) + "_" + utostr(GlobalID++); |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 145 | } else if (!MangledGlobals.count(GV)) { |
Bill Wendling | ecd9137 | 2007-09-17 22:39:32 +0000 | [diff] [blame] | 146 | Name = makeNameProper(GV->getName() + Suffix, Prefix); |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 147 | } else { |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 148 | unsigned TypeUniqueID = getTypeID(GV->getType()); |
| 149 | Name = "l" + utostr(TypeUniqueID) + "_" + makeNameProper(GV->getName()); |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 150 | } |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 151 | |
Chris Lattner | 9ddf212 | 2005-11-10 18:48:58 +0000 | [diff] [blame] | 152 | return Name; |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 153 | } |
| 154 | |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 155 | void Mangler::InsertName(GlobalValue *GV, |
| 156 | std::map<std::string, GlobalValue*> &Names) { |
Chris Lattner | d358cfc | 2005-11-15 01:32:03 +0000 | [diff] [blame] | 157 | if (!GV->hasName()) // We must mangle unnamed globals. |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 158 | return; |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 159 | |
| 160 | // Figure out if this is already used. |
| 161 | GlobalValue *&ExistingValue = Names[GV->getName()]; |
| 162 | if (!ExistingValue) { |
| 163 | ExistingValue = GV; |
| 164 | } else { |
| 165 | // If GV is external but the existing one is static, mangle the existing one |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 166 | if ((GV->hasExternalLinkage() || GV->hasDLLImportLinkage()) && |
| 167 | !(ExistingValue->hasExternalLinkage() || ExistingValue->hasDLLImportLinkage())) { |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 168 | MangledGlobals.insert(ExistingValue); |
| 169 | ExistingValue = GV; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 170 | } else if ((GV->hasExternalLinkage() || |
| 171 | GV->hasDLLImportLinkage()) && |
| 172 | (ExistingValue->hasExternalLinkage() || |
| 173 | ExistingValue->hasDLLImportLinkage()) && |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 174 | GV->isDeclaration() && |
| 175 | ExistingValue->isDeclaration()) { |
Chris Lattner | ed1e1e2 | 2006-02-13 21:43:26 +0000 | [diff] [blame] | 176 | // If the two globals both have external inkage, and are both external, |
| 177 | // don't mangle either of them, we just have some silly type mismatch. |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 178 | } else { |
| 179 | // Otherwise, mangle GV |
| 180 | MangledGlobals.insert(GV); |
| 181 | } |
| 182 | } |
| 183 | } |
| 184 | |
| 185 | |
Chris Lattner | 2f9bc4f | 2005-11-10 19:02:18 +0000 | [diff] [blame] | 186 | Mangler::Mangler(Module &M, const char *prefix) |
Chris Lattner | 833eb68 | 2006-09-07 18:20:41 +0000 | [diff] [blame] | 187 | : Prefix(prefix), UseQuotes(false), PreserveAsmNames(false), |
| 188 | Count(0), TypeCounter(0) { |
Owen Anderson | 718cb66 | 2007-09-07 04:06:50 +0000 | [diff] [blame] | 189 | std::fill(AcceptableChars, array_endof(AcceptableChars), 0); |
Chris Lattner | 91150e5 | 2005-11-10 21:40:01 +0000 | [diff] [blame] | 190 | |
| 191 | // Letters and numbers are acceptable. |
| 192 | for (unsigned char X = 'a'; X <= 'z'; ++X) |
| 193 | markCharAcceptable(X); |
| 194 | for (unsigned char X = 'A'; X <= 'Z'; ++X) |
| 195 | markCharAcceptable(X); |
| 196 | for (unsigned char X = '0'; X <= '9'; ++X) |
| 197 | markCharAcceptable(X); |
| 198 | |
| 199 | // These chars are acceptable. |
| 200 | markCharAcceptable('_'); |
| 201 | markCharAcceptable('$'); |
| 202 | markCharAcceptable('.'); |
| 203 | |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 204 | // Calculate which global values have names that will collide when we throw |
| 205 | // away type information. |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 206 | std::map<std::string, GlobalValue*> Names; |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 207 | for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 208 | InsertName(I, Names); |
Chris Lattner | e4d5c44 | 2005-03-15 04:54:21 +0000 | [diff] [blame] | 209 | for (Module::global_iterator I = M.global_begin(), E = M.global_end(); I != E; ++I) |
Chris Lattner | a6acb4f | 2004-02-14 00:30:23 +0000 | [diff] [blame] | 210 | InsertName(I, Names); |
Brian Gaeke | b198ca3 | 2003-07-24 20:20:58 +0000 | [diff] [blame] | 211 | } |
Reid Spencer | af303d5 | 2006-06-07 23:03:13 +0000 | [diff] [blame] | 212 | |
| 213 | // Cause this file to be linked in when Support/Mangler.h is #included |
| 214 | DEFINING_FILE_FOR(Mangler) |