• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 CCMangling {
53   CCM_Other,
54   CCM_Fast,
55   CCM_Vector,
56   CCM_Std
57 };
58 
isExternC(const NamedDecl * ND)59 static bool isExternC(const NamedDecl *ND) {
60   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
61     return FD->isExternC();
62   return cast<VarDecl>(ND)->isExternC();
63 }
64 
getCallingConvMangling(const ASTContext & Context,const NamedDecl * ND)65 static CCMangling getCallingConvMangling(const ASTContext &Context,
66                                          const NamedDecl *ND) {
67   const TargetInfo &TI = Context.getTargetInfo();
68   const llvm::Triple &Triple = TI.getTriple();
69   if (!Triple.isOSWindows() ||
70       !(Triple.getArch() == llvm::Triple::x86 ||
71         Triple.getArch() == llvm::Triple::x86_64))
72     return CCM_Other;
73 
74   if (Context.getLangOpts().CPlusPlus && !isExternC(ND) &&
75       TI.getCXXABI() == TargetCXXABI::Microsoft)
76     return CCM_Other;
77 
78   const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
79   if (!FD)
80     return CCM_Other;
81   QualType T = FD->getType();
82 
83   const FunctionType *FT = T->castAs<FunctionType>();
84 
85   CallingConv CC = FT->getCallConv();
86   switch (CC) {
87   default:
88     return CCM_Other;
89   case CC_X86FastCall:
90     return CCM_Fast;
91   case CC_X86StdCall:
92     return CCM_Std;
93   case CC_X86VectorCall:
94     return CCM_Vector;
95   }
96 }
97 
shouldMangleDeclName(const NamedDecl * D)98 bool MangleContext::shouldMangleDeclName(const NamedDecl *D) {
99   const ASTContext &ASTContext = getASTContext();
100 
101   CCMangling CC = getCallingConvMangling(ASTContext, D);
102   if (CC != CCM_Other)
103     return true;
104 
105   // In C, functions with no attributes never need to be mangled. Fastpath them.
106   if (!getASTContext().getLangOpts().CPlusPlus && !D->hasAttrs())
107     return false;
108 
109   // Any decl can be declared with __asm("foo") on it, and this takes precedence
110   // over all other naming in the .o file.
111   if (D->hasAttr<AsmLabelAttr>())
112     return true;
113 
114   return shouldMangleCXXName(D);
115 }
116 
mangleName(const NamedDecl * D,raw_ostream & Out)117 void MangleContext::mangleName(const NamedDecl *D, raw_ostream &Out) {
118   // Any decl can be declared with __asm("foo") on it, and this takes precedence
119   // over all other naming in the .o file.
120   if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) {
121     // If we have an asm name, then we use it as the mangling.
122 
123     // Adding the prefix can cause problems when one file has a "foo" and
124     // another has a "\01foo". That is known to happen on ELF with the
125     // tricks normally used for producing aliases (PR9177). Fortunately the
126     // llvm mangler on ELF is a nop, so we can just avoid adding the \01
127     // marker.  We also avoid adding the marker if this is an alias for an
128     // LLVM intrinsic.
129     char GlobalPrefix =
130         getASTContext().getTargetInfo().getDataLayout().getGlobalPrefix();
131     if (GlobalPrefix && !ALA->getLabel().startswith("llvm."))
132       Out << '\01'; // LLVM IR Marker for __asm("foo")
133 
134     Out << ALA->getLabel();
135     return;
136   }
137 
138   const ASTContext &ASTContext = getASTContext();
139   CCMangling CC = getCallingConvMangling(ASTContext, D);
140   bool MCXX = shouldMangleCXXName(D);
141   const TargetInfo &TI = Context.getTargetInfo();
142   if (CC == CCM_Other || (MCXX && TI.getCXXABI() == TargetCXXABI::Microsoft)) {
143     if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))
144       mangleObjCMethodName(OMD, Out);
145     else
146       mangleCXXName(D, Out);
147     return;
148   }
149 
150   Out << '\01';
151   if (CC == CCM_Std)
152     Out << '_';
153   else if (CC == CCM_Fast)
154     Out << '@';
155 
156   if (!MCXX)
157     Out << D->getIdentifier()->getName();
158   else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))
159     mangleObjCMethodName(OMD, Out);
160   else
161     mangleCXXName(D, Out);
162 
163   const FunctionDecl *FD = cast<FunctionDecl>(D);
164   const FunctionType *FT = FD->getType()->castAs<FunctionType>();
165   const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT);
166   if (CC == CCM_Vector)
167     Out << '@';
168   Out << '@';
169   if (!Proto) {
170     Out << '0';
171     return;
172   }
173   assert(!Proto->isVariadic());
174   unsigned ArgWords = 0;
175   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
176     if (!MD->isStatic())
177       ++ArgWords;
178   for (const auto &AT : Proto->param_types())
179     // Size should be aligned to pointer size.
180     ArgWords +=
181         llvm::alignTo(ASTContext.getTypeSize(AT), TI.getPointerWidth(0)) /
182         TI.getPointerWidth(0);
183   Out << ((TI.getPointerWidth(0) / 8) * ArgWords);
184 }
185 
mangleGlobalBlock(const BlockDecl * BD,const NamedDecl * ID,raw_ostream & Out)186 void MangleContext::mangleGlobalBlock(const BlockDecl *BD,
187                                       const NamedDecl *ID,
188                                       raw_ostream &Out) {
189   unsigned discriminator = getBlockId(BD, false);
190   if (ID) {
191     if (shouldMangleDeclName(ID))
192       mangleName(ID, Out);
193     else {
194       Out << ID->getIdentifier()->getName();
195     }
196   }
197   if (discriminator == 0)
198     Out << "_block_invoke";
199   else
200     Out << "_block_invoke_" << discriminator+1;
201 }
202 
mangleCtorBlock(const CXXConstructorDecl * CD,CXXCtorType CT,const BlockDecl * BD,raw_ostream & ResStream)203 void MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD,
204                                     CXXCtorType CT, const BlockDecl *BD,
205                                     raw_ostream &ResStream) {
206   SmallString<64> Buffer;
207   llvm::raw_svector_ostream Out(Buffer);
208   mangleCXXCtor(CD, CT, Out);
209   mangleFunctionBlock(*this, Buffer, BD, ResStream);
210 }
211 
mangleDtorBlock(const CXXDestructorDecl * DD,CXXDtorType DT,const BlockDecl * BD,raw_ostream & ResStream)212 void MangleContext::mangleDtorBlock(const CXXDestructorDecl *DD,
213                                     CXXDtorType DT, const BlockDecl *BD,
214                                     raw_ostream &ResStream) {
215   SmallString<64> Buffer;
216   llvm::raw_svector_ostream Out(Buffer);
217   mangleCXXDtor(DD, DT, Out);
218   mangleFunctionBlock(*this, Buffer, BD, ResStream);
219 }
220 
mangleBlock(const DeclContext * DC,const BlockDecl * BD,raw_ostream & Out)221 void MangleContext::mangleBlock(const DeclContext *DC, const BlockDecl *BD,
222                                 raw_ostream &Out) {
223   assert(!isa<CXXConstructorDecl>(DC) && !isa<CXXDestructorDecl>(DC));
224 
225   SmallString<64> Buffer;
226   llvm::raw_svector_ostream Stream(Buffer);
227   if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) {
228     mangleObjCMethodName(Method, Stream);
229   } else {
230     assert((isa<NamedDecl>(DC) || isa<BlockDecl>(DC)) &&
231            "expected a NamedDecl or BlockDecl");
232     if (isa<BlockDecl>(DC))
233       for (; DC && isa<BlockDecl>(DC); DC = DC->getParent())
234         (void) getBlockId(cast<BlockDecl>(DC), true);
235     assert((isa<TranslationUnitDecl>(DC) || isa<NamedDecl>(DC)) &&
236            "expected a TranslationUnitDecl or a NamedDecl");
237     if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC))
238       mangleCtorBlock(CD, /*CT*/ Ctor_Complete, BD, Out);
239     else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC))
240       mangleDtorBlock(DD, /*DT*/ Dtor_Complete, BD, Out);
241     else if (auto ND = dyn_cast<NamedDecl>(DC)) {
242       if (!shouldMangleDeclName(ND) && ND->getIdentifier())
243         Stream << ND->getIdentifier()->getName();
244       else {
245         // FIXME: We were doing a mangleUnqualifiedName() before, but that's
246         // a private member of a class that will soon itself be private to the
247         // Itanium C++ ABI object. What should we do now? Right now, I'm just
248         // calling the mangleName() method on the MangleContext; is there a
249         // better way?
250         mangleName(ND, Stream);
251       }
252     }
253   }
254   mangleFunctionBlock(*this, Buffer, BD, Out);
255 }
256 
mangleObjCMethodNameWithoutSize(const ObjCMethodDecl * MD,raw_ostream & OS)257 void MangleContext::mangleObjCMethodNameWithoutSize(const ObjCMethodDecl *MD,
258                                                     raw_ostream &OS) {
259   const ObjCContainerDecl *CD =
260   dyn_cast<ObjCContainerDecl>(MD->getDeclContext());
261   assert (CD && "Missing container decl in GetNameForMethod");
262   OS << (MD->isInstanceMethod() ? '-' : '+') << '[' << CD->getName();
263   if (const ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(CD))
264     OS << '(' << *CID << ')';
265   OS << ' ';
266   MD->getSelector().print(OS);
267   OS << ']';
268 }
269 
mangleObjCMethodName(const ObjCMethodDecl * MD,raw_ostream & Out)270 void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD,
271                                          raw_ostream &Out) {
272   SmallString<64> Name;
273   llvm::raw_svector_ostream OS(Name);
274 
275   mangleObjCMethodNameWithoutSize(MD, OS);
276   Out << OS.str().size() << OS.str();
277 }
278