Mangle.cpp revision d6be277ba4bf271c6de8ffcc8c46f060c8cbd4d5
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/Mangle.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Decl.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/AST/ExprCXX.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 34using 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 39static 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 50void MangleContext::anchor() { } 51 52enum StdOrFastCC { 53 SOF_OTHER, 54 SOF_FAST, 55 SOF_STD 56}; 57 58static 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 64static StdOrFastCC getStdOrFastCallMangling(const ASTContext &Context, 65 const NamedDecl *ND) { 66 const TargetInfo &TI = Context.getTargetInfo(); 67 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 93bool 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 112void 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 (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(), 167 ArgEnd = Proto->arg_type_end(); 168 Arg != ArgEnd; ++Arg) { 169 QualType AT = *Arg; 170 // Size should be aligned to DWORD boundary 171 ArgWords += llvm::RoundUpToAlignment(ASTContext.getTypeSize(AT), 32) / 32; 172 } 173 Out << 4 * ArgWords; 174} 175 176void MangleContext::mangleGlobalBlock(const BlockDecl *BD, 177 const NamedDecl *ID, 178 raw_ostream &Out) { 179 unsigned discriminator = getBlockId(BD, false); 180 if (ID) { 181 if (shouldMangleDeclName(ID)) 182 mangleName(ID, Out); 183 else { 184 Out << ID->getIdentifier()->getName(); 185 } 186 } 187 if (discriminator == 0) 188 Out << "_block_invoke"; 189 else 190 Out << "_block_invoke_" << discriminator+1; 191} 192 193void MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD, 194 CXXCtorType CT, const BlockDecl *BD, 195 raw_ostream &ResStream) { 196 SmallString<64> Buffer; 197 llvm::raw_svector_ostream Out(Buffer); 198 mangleCXXCtor(CD, CT, Out); 199 Out.flush(); 200 mangleFunctionBlock(*this, Buffer, BD, ResStream); 201} 202 203void MangleContext::mangleDtorBlock(const CXXDestructorDecl *DD, 204 CXXDtorType DT, const BlockDecl *BD, 205 raw_ostream &ResStream) { 206 SmallString<64> Buffer; 207 llvm::raw_svector_ostream Out(Buffer); 208 mangleCXXDtor(DD, DT, Out); 209 Out.flush(); 210 mangleFunctionBlock(*this, Buffer, BD, ResStream); 211} 212 213void MangleContext::mangleBlock(const DeclContext *DC, const BlockDecl *BD, 214 raw_ostream &Out) { 215 assert(!isa<CXXConstructorDecl>(DC) && !isa<CXXDestructorDecl>(DC)); 216 217 SmallString<64> Buffer; 218 llvm::raw_svector_ostream Stream(Buffer); 219 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) { 220 mangleObjCMethodName(Method, Stream); 221 } else { 222 const NamedDecl *ND = cast<NamedDecl>(DC); 223 if (!shouldMangleDeclName(ND) && ND->getIdentifier()) 224 Stream << ND->getIdentifier()->getName(); 225 else { 226 // FIXME: We were doing a mangleUnqualifiedName() before, but that's 227 // a private member of a class that will soon itself be private to the 228 // Itanium C++ ABI object. What should we do now? Right now, I'm just 229 // calling the mangleName() method on the MangleContext; is there a 230 // better way? 231 mangleName(ND, Stream); 232 } 233 } 234 Stream.flush(); 235 mangleFunctionBlock(*this, Buffer, BD, Out); 236} 237 238void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD, 239 raw_ostream &Out) { 240 SmallString<64> Name; 241 llvm::raw_svector_ostream OS(Name); 242 243 const ObjCContainerDecl *CD = 244 dyn_cast<ObjCContainerDecl>(MD->getDeclContext()); 245 assert (CD && "Missing container decl in GetNameForMethod"); 246 OS << (MD->isInstanceMethod() ? '-' : '+') << '[' << CD->getName(); 247 if (const ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(CD)) 248 OS << '(' << *CID << ')'; 249 OS << ' ' << MD->getSelector().getAsString() << ']'; 250 251 Out << OS.str().size() << OS.str(); 252} 253