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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
//===--------------------------- Mangler.cpp -----------------------------===//
//
// SPIR Tools
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===---------------------------------------------------------------------===//
/*
* Contributed by: Intel Corporation.
*/
#include "FunctionDescriptor.h"
#include "ManglingUtils.h"
#include "NameMangleAPI.h"
#include "ParameterType.h"
#include "SPIRVInternal.h"
#include <algorithm>
#include <map>
#include <sstream>
#include <string>
// According to IA64 name mangling spec,
// builtin vector types should not be substituted
// This is a workaround till this gets fixed in CLang
#define ENABLE_MANGLER_VECTOR_SUBSTITUTION 1
namespace SPIR {
class MangleVisitor : public TypeVisitor {
public:
MangleVisitor(SPIRversion ver, std::stringstream &s)
: TypeVisitor(ver), m_stream(s), seqId(0) {}
//
// mangle substitution methods
//
void mangleSequenceID(unsigned SeqID) {
if (SeqID == 1)
m_stream << '0';
else if (SeqID > 1) {
std::string bstr;
std::string charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
SeqID--;
bstr.reserve(7);
for (; SeqID != 0; SeqID /= 36)
bstr += charset.substr(SeqID % 36, 1);
std::reverse(bstr.begin(), bstr.end());
m_stream << bstr;
}
m_stream << '_';
}
bool mangleSubstitution(const ParamType *type, std::string typeStr) {
size_t fpos;
std::stringstream thistypeStr;
thistypeStr << typeStr;
if ((fpos = m_stream.str().find(typeStr)) != std::string::npos) {
const char *nType;
if (const PointerType *p = SPIR::dyn_cast<PointerType>(type)) {
if ((nType =
mangledPrimitiveStringfromName(p->getPointee()->toString())))
thistypeStr << nType;
}
#if defined(ENABLE_MANGLER_VECTOR_SUBSTITUTION)
else if (const VectorType *pVec = SPIR::dyn_cast<VectorType>(type)) {
if ((nType = mangledPrimitiveStringfromName(
pVec->getScalarType()->toString())))
thistypeStr << nType;
}
#endif
std::map<std::string, unsigned>::iterator I =
substitutions.find(thistypeStr.str());
if (I == substitutions.end())
return false;
unsigned SeqID = I->second;
m_stream << 'S';
mangleSequenceID(SeqID);
return true;
}
return false;
}
//
// Visit methods
//
MangleError visit(const PrimitiveType *t) override {
MangleError me = MANGLE_SUCCESS;
#if defined(SPIRV_SPIR20_MANGLING_REQUIREMENTS)
m_stream << mangledPrimitiveString(t->getPrimitive());
#else
std::string mangledPrimitive =
std::string(mangledPrimitiveString(t->getPrimitive()));
// out of all enums it makes sense to substitute only
// memory_scope/memory_order since only they appear several times in the
// builtin declaration.
if (mangledPrimitive == "12memory_scope" ||
mangledPrimitive == "12memory_order") {
if (!mangleSubstitution(t, mangledPrimitiveString(t->getPrimitive()))) {
size_t index = m_stream.str().size();
m_stream << mangledPrimitiveString(t->getPrimitive());
substitutions[m_stream.str().substr(index)] = seqId++;
}
} else {
m_stream << mangledPrimitive;
}
#endif
return me;
}
MangleError visit(const PointerType *p) override {
size_t fpos = m_stream.str().size();
std::string qualStr;
MangleError me = MANGLE_SUCCESS;
for (unsigned int i = ATTR_QUALIFIER_FIRST; i <= ATTR_QUALIFIER_LAST; i++) {
TypeAttributeEnum qualifier = (TypeAttributeEnum)i;
if (p->hasQualifier(qualifier)) {
qualStr += getMangledAttribute(qualifier);
}
}
qualStr += getMangledAttribute((p->getAddressSpace()));
if (!mangleSubstitution(p, "P" + qualStr)) {
// A pointee type is substituted when it is a user type, a vector type
// (but see a comment in the beginning of this file), a pointer type,
// or a primitive type with qualifiers (addr. space and/or CV qualifiers).
// So, stream "P", type qualifiers
m_stream << "P" << qualStr;
// and the pointee type itself.
me = p->getPointee()->accept(this);
// The type qualifiers plus a pointee type is a substitutable entity
if (qualStr.length() > 0)
substitutions[m_stream.str().substr(fpos + 1)] = seqId++;
// The complete pointer type is substitutable as well
substitutions[m_stream.str().substr(fpos)] = seqId++;
}
return me;
}
MangleError visit(const VectorType *v) override {
size_t index = m_stream.str().size();
std::stringstream typeStr;
typeStr << "Dv" << v->getLength() << "_";
MangleError me = MANGLE_SUCCESS;
#if defined(ENABLE_MANGLER_VECTOR_SUBSTITUTION)
if (!mangleSubstitution(v, typeStr.str()))
#endif
{
m_stream << typeStr.str();
me = v->getScalarType()->accept(this);
substitutions[m_stream.str().substr(index)] = seqId++;
}
return me;
}
MangleError visit(const AtomicType *p) override {
MangleError me = MANGLE_SUCCESS;
size_t index = m_stream.str().size();
const char *typeStr = "U7_Atomic";
if (!mangleSubstitution(p, typeStr)) {
m_stream << typeStr;
me = p->getBaseType()->accept(this);
substitutions[m_stream.str().substr(index)] = seqId++;
}
return me;
}
MangleError visit(const BlockType *p) override {
m_stream << "U"
<< "13block_pointerFv";
if (p->getNumOfParams() == 0)
m_stream << "v";
else
for (unsigned int i = 0; i < p->getNumOfParams(); ++i) {
MangleError err = p->getParam(i)->accept(this);
if (err != MANGLE_SUCCESS) {
return err;
}
}
m_stream << "E";
return MANGLE_SUCCESS;
}
MangleError visit(const UserDefinedType *pTy) override {
std::string name = pTy->toString();
m_stream << name.size() << name;
return MANGLE_SUCCESS;
}
private:
// Holds the mangled string representing the prototype of the function.
std::stringstream &m_stream;
unsigned seqId;
std::map<std::string, unsigned> substitutions;
};
//
// NameMangler
//
NameMangler::NameMangler(SPIRversion version) : m_spir_version(version) {}
MangleError NameMangler::mangle(const FunctionDescriptor &fd,
std::string &mangledName) {
if (fd.isNull()) {
mangledName.assign(FunctionDescriptor::nullString());
return MANGLE_NULL_FUNC_DESCRIPTOR;
}
std::stringstream ret;
ret << "_Z" << fd.name.length() << fd.name;
MangleVisitor visitor(m_spir_version, ret);
for (unsigned int i = 0; i < fd.parameters.size(); ++i) {
MangleError err = fd.parameters[i]->accept(&visitor);
if (err == MANGLE_TYPE_NOT_SUPPORTED) {
mangledName.assign("Type ");
mangledName.append(fd.parameters[i]->toString());
mangledName.append(" is not supported in ");
std::string ver = getSPIRVersionAsString(m_spir_version);
mangledName.append(ver);
return err;
}
}
mangledName.assign(ret.str());
return MANGLE_SUCCESS;
}
} // namespace SPIR
|
