1 //===--- Mangle.cpp - Mangle C++ Names --------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Implements generic name mangling support for blocks and Objective-C.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "clang/AST/Attr.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/Mangle.h"
21 #include "clang/Basic/ABI.h"
22 #include "clang/Basic/SourceManager.h"
23 #include "clang/Basic/TargetInfo.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/Support/raw_ostream.h"
27
28 #define MANGLE_CHECKER 0
29
30 #if MANGLE_CHECKER
31 #include <cxxabi.h>
32 #endif
33
34 using namespace clang;
35
36 // FIXME: For blocks we currently mimic GCC's mangling scheme, which leaves
37 // much to be desired. Come up with a better mangling scheme.
38
mangleFunctionBlock(MangleContext & Context,StringRef Outer,const BlockDecl * BD,raw_ostream & Out)39 static void mangleFunctionBlock(MangleContext &Context,
40 StringRef Outer,
41 const BlockDecl *BD,
42 raw_ostream &Out) {
43 unsigned discriminator = Context.getBlockId(BD, true);
44 if (discriminator == 0)
45 Out << "__" << Outer << "_block_invoke";
46 else
47 Out << "__" << Outer << "_block_invoke_" << discriminator+1;
48 }
49
anchor()50 void MangleContext::anchor() { }
51
52 enum StdOrFastCC {
53 SOF_OTHER,
54 SOF_FAST,
55 SOF_STD
56 };
57
isExternC(const NamedDecl * ND)58 static bool isExternC(const NamedDecl *ND) {
59 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
60 return FD->isExternC();
61 return cast<VarDecl>(ND)->isExternC();
62 }
63
getStdOrFastCallMangling(const ASTContext & Context,const NamedDecl * ND)64 static StdOrFastCC getStdOrFastCallMangling(const ASTContext &Context,
65 const NamedDecl *ND) {
66 const TargetInfo &TI = Context.getTargetInfo();
67 const llvm::Triple &Triple = TI.getTriple();
68 if (!Triple.isOSWindows() || Triple.getArch() != llvm::Triple::x86)
69 return SOF_OTHER;
70
71 if (Context.getLangOpts().CPlusPlus && !isExternC(ND) &&
72 TI.getCXXABI() == TargetCXXABI::Microsoft)
73 return SOF_OTHER;
74
75 const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
76 if (!FD)
77 return SOF_OTHER;
78 QualType T = FD->getType();
79
80 const FunctionType *FT = T->castAs<FunctionType>();
81
82 CallingConv CC = FT->getCallConv();
83 switch (CC) {
84 default:
85 return SOF_OTHER;
86 case CC_X86FastCall:
87 return SOF_FAST;
88 case CC_X86StdCall:
89 return SOF_STD;
90 }
91 }
92
shouldMangleDeclName(const NamedDecl * D)93 bool MangleContext::shouldMangleDeclName(const NamedDecl *D) {
94 const ASTContext &ASTContext = getASTContext();
95
96 StdOrFastCC CC = getStdOrFastCallMangling(ASTContext, D);
97 if (CC != SOF_OTHER)
98 return true;
99
100 // In C, functions with no attributes never need to be mangled. Fastpath them.
101 if (!getASTContext().getLangOpts().CPlusPlus && !D->hasAttrs())
102 return false;
103
104 // Any decl can be declared with __asm("foo") on it, and this takes precedence
105 // over all other naming in the .o file.
106 if (D->hasAttr<AsmLabelAttr>())
107 return true;
108
109 return shouldMangleCXXName(D);
110 }
111
mangleName(const NamedDecl * D,raw_ostream & Out)112 void MangleContext::mangleName(const NamedDecl *D, raw_ostream &Out) {
113 // Any decl can be declared with __asm("foo") on it, and this takes precedence
114 // over all other naming in the .o file.
115 if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) {
116 // If we have an asm name, then we use it as the mangling.
117
118 // Adding the prefix can cause problems when one file has a "foo" and
119 // another has a "\01foo". That is known to happen on ELF with the
120 // tricks normally used for producing aliases (PR9177). Fortunately the
121 // llvm mangler on ELF is a nop, so we can just avoid adding the \01
122 // marker. We also avoid adding the marker if this is an alias for an
123 // LLVM intrinsic.
124 StringRef UserLabelPrefix =
125 getASTContext().getTargetInfo().getUserLabelPrefix();
126 if (!UserLabelPrefix.empty() && !ALA->getLabel().startswith("llvm."))
127 Out << '\01'; // LLVM IR Marker for __asm("foo")
128
129 Out << ALA->getLabel();
130 return;
131 }
132
133 const ASTContext &ASTContext = getASTContext();
134 StdOrFastCC CC = getStdOrFastCallMangling(ASTContext, D);
135 bool MCXX = shouldMangleCXXName(D);
136 const TargetInfo &TI = Context.getTargetInfo();
137 if (CC == SOF_OTHER || (MCXX && TI.getCXXABI() == TargetCXXABI::Microsoft)) {
138 mangleCXXName(D, Out);
139 return;
140 }
141
142 Out << '\01';
143 if (CC == SOF_STD)
144 Out << '_';
145 else
146 Out << '@';
147
148 if (!MCXX)
149 Out << D->getIdentifier()->getName();
150 else
151 mangleCXXName(D, Out);
152
153 const FunctionDecl *FD = cast<FunctionDecl>(D);
154 const FunctionType *FT = FD->getType()->castAs<FunctionType>();
155 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT);
156 Out << '@';
157 if (!Proto) {
158 Out << '0';
159 return;
160 }
161 assert(!Proto->isVariadic());
162 unsigned ArgWords = 0;
163 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
164 if (!MD->isStatic())
165 ++ArgWords;
166 for (const auto &AT : Proto->param_types())
167 // Size should be aligned to DWORD boundary
168 ArgWords += llvm::RoundUpToAlignment(ASTContext.getTypeSize(AT), 32) / 32;
169 Out << 4 * ArgWords;
170 }
171
mangleGlobalBlock(const BlockDecl * BD,const NamedDecl * ID,raw_ostream & Out)172 void MangleContext::mangleGlobalBlock(const BlockDecl *BD,
173 const NamedDecl *ID,
174 raw_ostream &Out) {
175 unsigned discriminator = getBlockId(BD, false);
176 if (ID) {
177 if (shouldMangleDeclName(ID))
178 mangleName(ID, Out);
179 else {
180 Out << ID->getIdentifier()->getName();
181 }
182 }
183 if (discriminator == 0)
184 Out << "_block_invoke";
185 else
186 Out << "_block_invoke_" << discriminator+1;
187 }
188
mangleCtorBlock(const CXXConstructorDecl * CD,CXXCtorType CT,const BlockDecl * BD,raw_ostream & ResStream)189 void MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD,
190 CXXCtorType CT, const BlockDecl *BD,
191 raw_ostream &ResStream) {
192 SmallString<64> Buffer;
193 llvm::raw_svector_ostream Out(Buffer);
194 mangleCXXCtor(CD, CT, Out);
195 Out.flush();
196 mangleFunctionBlock(*this, Buffer, BD, ResStream);
197 }
198
mangleDtorBlock(const CXXDestructorDecl * DD,CXXDtorType DT,const BlockDecl * BD,raw_ostream & ResStream)199 void MangleContext::mangleDtorBlock(const CXXDestructorDecl *DD,
200 CXXDtorType DT, const BlockDecl *BD,
201 raw_ostream &ResStream) {
202 SmallString<64> Buffer;
203 llvm::raw_svector_ostream Out(Buffer);
204 mangleCXXDtor(DD, DT, Out);
205 Out.flush();
206 mangleFunctionBlock(*this, Buffer, BD, ResStream);
207 }
208
mangleBlock(const DeclContext * DC,const BlockDecl * BD,raw_ostream & Out)209 void MangleContext::mangleBlock(const DeclContext *DC, const BlockDecl *BD,
210 raw_ostream &Out) {
211 assert(!isa<CXXConstructorDecl>(DC) && !isa<CXXDestructorDecl>(DC));
212
213 SmallString<64> Buffer;
214 llvm::raw_svector_ostream Stream(Buffer);
215 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) {
216 mangleObjCMethodName(Method, Stream);
217 } else {
218 const NamedDecl *ND = cast<NamedDecl>(DC);
219 if (!shouldMangleDeclName(ND) && ND->getIdentifier())
220 Stream << ND->getIdentifier()->getName();
221 else {
222 // FIXME: We were doing a mangleUnqualifiedName() before, but that's
223 // a private member of a class that will soon itself be private to the
224 // Itanium C++ ABI object. What should we do now? Right now, I'm just
225 // calling the mangleName() method on the MangleContext; is there a
226 // better way?
227 mangleName(ND, Stream);
228 }
229 }
230 Stream.flush();
231 mangleFunctionBlock(*this, Buffer, BD, Out);
232 }
233
mangleObjCMethodName(const ObjCMethodDecl * MD,raw_ostream & Out)234 void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD,
235 raw_ostream &Out) {
236 SmallString<64> Name;
237 llvm::raw_svector_ostream OS(Name);
238
239 const ObjCContainerDecl *CD =
240 dyn_cast<ObjCContainerDecl>(MD->getDeclContext());
241 assert (CD && "Missing container decl in GetNameForMethod");
242 OS << (MD->isInstanceMethod() ? '-' : '+') << '[' << CD->getName();
243 if (const ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(CD))
244 OS << '(' << *CID << ')';
245 OS << ' ';
246 MD->getSelector().print(OS);
247 OS << ']';
248
249 Out << OS.str().size() << OS.str();
250 }
251