Mangle.cpp revision 344779
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 28using namespace clang; 29 30// FIXME: For blocks we currently mimic GCC's mangling scheme, which leaves 31// much to be desired. Come up with a better mangling scheme. 32 33static void mangleFunctionBlock(MangleContext &Context, 34 StringRef Outer, 35 const BlockDecl *BD, 36 raw_ostream &Out) { 37 unsigned discriminator = Context.getBlockId(BD, true); 38 if (discriminator == 0) 39 Out << "__" << Outer << "_block_invoke"; 40 else 41 Out << "__" << Outer << "_block_invoke_" << discriminator+1; 42} 43 44void MangleContext::anchor() { } 45 46enum CCMangling { 47 CCM_Other, 48 CCM_Fast, 49 CCM_RegCall, 50 CCM_Vector, 51 CCM_Std 52}; 53 54static bool isExternC(const NamedDecl *ND) { 55 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 56 return FD->isExternC(); 57 return cast<VarDecl>(ND)->isExternC(); 58} 59 60static CCMangling getCallingConvMangling(const ASTContext &Context, 61 const NamedDecl *ND) { 62 const TargetInfo &TI = Context.getTargetInfo(); 63 const llvm::Triple &Triple = TI.getTriple(); 64 if (!Triple.isOSWindows() || 65 !(Triple.getArch() == llvm::Triple::x86 || 66 Triple.getArch() == llvm::Triple::x86_64)) 67 return CCM_Other; 68 69 if (Context.getLangOpts().CPlusPlus && !isExternC(ND) && 70 TI.getCXXABI() == TargetCXXABI::Microsoft) 71 return CCM_Other; 72 73 const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND); 74 if (!FD) 75 return CCM_Other; 76 QualType T = FD->getType(); 77 78 const FunctionType *FT = T->castAs<FunctionType>(); 79 80 CallingConv CC = FT->getCallConv(); 81 switch (CC) { 82 default: 83 return CCM_Other; 84 case CC_X86FastCall: 85 return CCM_Fast; 86 case CC_X86StdCall: 87 return CCM_Std; 88 case CC_X86VectorCall: 89 return CCM_Vector; 90 } 91} 92 93bool MangleContext::shouldMangleDeclName(const NamedDecl *D) { 94 const ASTContext &ASTContext = getASTContext(); 95 96 CCMangling CC = getCallingConvMangling(ASTContext, D); 97 if (CC != CCM_Other) 98 return true; 99 100 // If the declaration has an owning module for linkage purposes that needs to 101 // be mangled, we must mangle its name. 102 if (!D->hasExternalFormalLinkage() && D->getOwningModuleForLinkage()) 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 117void 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 else if (CC == CCM_RegCall) 156 Out << "__regcall3__"; 157 158 if (!MCXX) 159 Out << D->getIdentifier()->getName(); 160 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) 161 mangleObjCMethodName(OMD, Out); 162 else 163 mangleCXXName(D, Out); 164 165 const FunctionDecl *FD = cast<FunctionDecl>(D); 166 const FunctionType *FT = FD->getType()->castAs<FunctionType>(); 167 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT); 168 if (CC == CCM_Vector) 169 Out << '@'; 170 Out << '@'; 171 if (!Proto) { 172 Out << '0'; 173 return; 174 } 175 assert(!Proto->isVariadic()); 176 unsigned ArgWords = 0; 177 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 178 if (!MD->isStatic()) 179 ++ArgWords; 180 for (const auto &AT : Proto->param_types()) 181 // Size should be aligned to pointer size. 182 ArgWords += 183 llvm::alignTo(ASTContext.getTypeSize(AT), TI.getPointerWidth(0)) / 184 TI.getPointerWidth(0); 185 Out << ((TI.getPointerWidth(0) / 8) * ArgWords); 186} 187 188void MangleContext::mangleGlobalBlock(const BlockDecl *BD, 189 const NamedDecl *ID, 190 raw_ostream &Out) { 191 unsigned discriminator = getBlockId(BD, false); 192 if (ID) { 193 if (shouldMangleDeclName(ID)) 194 mangleName(ID, Out); 195 else { 196 Out << ID->getIdentifier()->getName(); 197 } 198 } 199 if (discriminator == 0) 200 Out << "_block_invoke"; 201 else 202 Out << "_block_invoke_" << discriminator+1; 203} 204 205void MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD, 206 CXXCtorType CT, const BlockDecl *BD, 207 raw_ostream &ResStream) { 208 SmallString<64> Buffer; 209 llvm::raw_svector_ostream Out(Buffer); 210 mangleCXXCtor(CD, CT, Out); 211 mangleFunctionBlock(*this, Buffer, BD, ResStream); 212} 213 214void MangleContext::mangleDtorBlock(const CXXDestructorDecl *DD, 215 CXXDtorType DT, const BlockDecl *BD, 216 raw_ostream &ResStream) { 217 SmallString<64> Buffer; 218 llvm::raw_svector_ostream Out(Buffer); 219 mangleCXXDtor(DD, DT, Out); 220 mangleFunctionBlock(*this, Buffer, BD, ResStream); 221} 222 223void MangleContext::mangleBlock(const DeclContext *DC, const BlockDecl *BD, 224 raw_ostream &Out) { 225 assert(!isa<CXXConstructorDecl>(DC) && !isa<CXXDestructorDecl>(DC)); 226 227 SmallString<64> Buffer; 228 llvm::raw_svector_ostream Stream(Buffer); 229 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) { 230 mangleObjCMethodName(Method, Stream); 231 } else { 232 assert((isa<NamedDecl>(DC) || isa<BlockDecl>(DC)) && 233 "expected a NamedDecl or BlockDecl"); 234 if (isa<BlockDecl>(DC)) 235 for (; DC && isa<BlockDecl>(DC); DC = DC->getParent()) 236 (void) getBlockId(cast<BlockDecl>(DC), true); 237 assert((isa<TranslationUnitDecl>(DC) || isa<NamedDecl>(DC)) && 238 "expected a TranslationUnitDecl or a NamedDecl"); 239 if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC)) 240 mangleCtorBlock(CD, /*CT*/ Ctor_Complete, BD, Out); 241 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC)) 242 mangleDtorBlock(DD, /*DT*/ Dtor_Complete, BD, Out); 243 else if (auto ND = dyn_cast<NamedDecl>(DC)) { 244 if (!shouldMangleDeclName(ND) && ND->getIdentifier()) 245 Stream << ND->getIdentifier()->getName(); 246 else { 247 // FIXME: We were doing a mangleUnqualifiedName() before, but that's 248 // a private member of a class that will soon itself be private to the 249 // Itanium C++ ABI object. What should we do now? Right now, I'm just 250 // calling the mangleName() method on the MangleContext; is there a 251 // better way? 252 mangleName(ND, Stream); 253 } 254 } 255 } 256 mangleFunctionBlock(*this, Buffer, BD, Out); 257} 258 259void MangleContext::mangleObjCMethodNameWithoutSize(const ObjCMethodDecl *MD, 260 raw_ostream &OS) { 261 const ObjCContainerDecl *CD = 262 dyn_cast<ObjCContainerDecl>(MD->getDeclContext()); 263 assert (CD && "Missing container decl in GetNameForMethod"); 264 OS << (MD->isInstanceMethod() ? '-' : '+') << '['; 265 if (const ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(CD)) { 266 OS << CID->getClassInterface()->getName(); 267 OS << '(' << *CID << ')'; 268 } else { 269 OS << CD->getName(); 270 } 271 OS << ' '; 272 MD->getSelector().print(OS); 273 OS << ']'; 274} 275 276void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD, 277 raw_ostream &Out) { 278 SmallString<64> Name; 279 llvm::raw_svector_ostream OS(Name); 280 281 mangleObjCMethodNameWithoutSize(MD, OS); 282 Out << OS.str().size() << OS.str(); 283} 284