1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
//===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Unified name mangler for CWriter and assembly backends.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/Mangler.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Module.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringMap.h"
using namespace llvm;
static char HexDigit(int V) {
return V < 10 ? V+'0' : V+'A'-10;
}
static std::string MangleLetter(unsigned char C) {
char Result[] = { '_', HexDigit(C >> 4), HexDigit(C & 15), '_', 0 };
return Result;
}
/// 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,
bool hasPrivateLinkage) {
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;
// If X does not start with (char)1, add the prefix.
bool NeedPrefix = true;
std::string::const_iterator I = X.begin();
if (*I == 1) {
NeedPrefix = false;
++I; // Skip over the marker.
}
// Mangle the first letter specially, don't allow numbers.
if (*I >= '0' && *I <= '9')
Result += MangleLetter(*I++);
for (std::string::const_iterator E = X.end(); I != E; ++I) {
if (!isCharAcceptable(*I))
Result += MangleLetter(*I);
else
Result += *I;
}
if (NeedPrefix)
Result = ThePrefix + Result;
return Result;
}
bool NeedPrefix = true;
bool NeedQuotes = false;
std::string Result;
std::string::const_iterator I = X.begin();
if (*I == 1) {
NeedPrefix = false;
++I; // Skip over the marker.
}
// If the first character is a number, we need quotes.
if (*I >= '0' && *I <= '9')
NeedQuotes = true;
// Do an initial scan of the string, checking to see if we need quotes or
// to escape a '"' or not.
if (!NeedQuotes)
for (std::string::const_iterator E = X.end(); I != E; ++I)
if (!isCharAcceptable(*I)) {
NeedQuotes = true;
break;
}
// In the common case, we don't need quotes. Handle this quickly.
if (!NeedQuotes) {
if (!NeedPrefix)
return X.substr(1); // Strip off the \001.
return ThePrefix + X;
}
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) {
if (*I == '"')
Result += "_QQ_";
else if (*I == '\n')
Result += "_NL_";
else
Result += *I;
}
if (NeedPrefix)
Result = ThePrefix + Result;
Result = '"' + Result + '"';
return Result;
}
std::string Mangler::getValueName(const GlobalValue *GV, const char *Suffix) {
assert((!isa<Function>(GV) || !cast<Function>(GV)->isIntrinsic()) &&
"Intrinsic functions cannot be mangled by Mangler");
if (GV->hasName())
return makeNameProper(GV->getName() + Suffix, GV->hasPrivateLinkage());
// 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 "__unnamed_" + utostr(ID) + Suffix;
}
Mangler::Mangler(Module &M, const char *prefix, const char *privatePrefix)
: Prefix(prefix), PrivatePrefix (privatePrefix), UseQuotes(false),
PreserveAsmNames(false), NextAnonGlobalID(1) {
std::fill(AcceptableChars, array_endof(AcceptableChars), 0);
// Letters and numbers are acceptable.
for (unsigned char X = 'a'; X <= 'z'; ++X)
markCharAcceptable(X);
for (unsigned char X = 'A'; X <= 'Z'; ++X)
markCharAcceptable(X);
for (unsigned char X = '0'; X <= '9'; ++X)
markCharAcceptable(X);
// These chars are acceptable.
markCharAcceptable('_');
markCharAcceptable('$');
markCharAcceptable('.');
}
|
