1218887Sdim//===--- Mangle.cpp - Mangle C++ Names --------------------------*- C++ -*-===// 2218887Sdim// 3218887Sdim// The LLVM Compiler Infrastructure 4218887Sdim// 5218887Sdim// This file is distributed under the University of Illinois Open Source 6218887Sdim// License. See LICENSE.TXT for details. 7218887Sdim// 8218887Sdim//===----------------------------------------------------------------------===// 9218887Sdim// 10218887Sdim// Implements generic name mangling support for blocks and Objective-C. 11218887Sdim// 12218887Sdim//===----------------------------------------------------------------------===// 13263508Sdim#include "clang/AST/Attr.h" 14218887Sdim#include "clang/AST/Mangle.h" 15218887Sdim#include "clang/AST/ASTContext.h" 16218887Sdim#include "clang/AST/Decl.h" 17218887Sdim#include "clang/AST/DeclCXX.h" 18218887Sdim#include "clang/AST/DeclObjC.h" 19218887Sdim#include "clang/AST/DeclTemplate.h" 20218887Sdim#include "clang/AST/ExprCXX.h" 21218887Sdim#include "clang/Basic/ABI.h" 22218887Sdim#include "clang/Basic/SourceManager.h" 23263508Sdim#include "clang/Basic/TargetInfo.h" 24218887Sdim#include "llvm/ADT/StringExtras.h" 25249423Sdim#include "llvm/Support/ErrorHandling.h" 26218887Sdim#include "llvm/Support/raw_ostream.h" 27218887Sdim 28218887Sdim#define MANGLE_CHECKER 0 29218887Sdim 30218887Sdim#if MANGLE_CHECKER 31218887Sdim#include <cxxabi.h> 32218887Sdim#endif 33218887Sdim 34218887Sdimusing namespace clang; 35218887Sdim 36218887Sdim// FIXME: For blocks we currently mimic GCC's mangling scheme, which leaves 37218887Sdim// much to be desired. Come up with a better mangling scheme. 38218887Sdim 39218887Sdimstatic void mangleFunctionBlock(MangleContext &Context, 40226633Sdim StringRef Outer, 41218887Sdim const BlockDecl *BD, 42226633Sdim raw_ostream &Out) { 43239462Sdim unsigned discriminator = Context.getBlockId(BD, true); 44239462Sdim if (discriminator == 0) 45239462Sdim Out << "__" << Outer << "_block_invoke"; 46239462Sdim else 47239462Sdim Out << "__" << Outer << "_block_invoke_" << discriminator+1; 48218887Sdim} 49218887Sdim 50263508Sdimvoid MangleContext::anchor() { } 51263508Sdim 52263508Sdimenum StdOrFastCC { 53263508Sdim SOF_OTHER, 54263508Sdim SOF_FAST, 55263508Sdim SOF_STD 56263508Sdim}; 57263508Sdim 58263508Sdimstatic bool isExternC(const NamedDecl *ND) { 59263508Sdim if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 60263508Sdim return FD->isExternC(); 61263508Sdim return cast<VarDecl>(ND)->isExternC(); 62218887Sdim} 63218887Sdim 64263508Sdimstatic StdOrFastCC getStdOrFastCallMangling(const ASTContext &Context, 65263508Sdim const NamedDecl *ND) { 66263508Sdim const TargetInfo &TI = Context.getTargetInfo(); 67263508Sdim llvm::Triple Triple = TI.getTriple(); 68263508Sdim if (!Triple.isOSWindows() || Triple.getArch() != llvm::Triple::x86) 69263508Sdim return SOF_OTHER; 70263508Sdim 71263508Sdim if (Context.getLangOpts().CPlusPlus && !isExternC(ND) && 72263508Sdim TI.getCXXABI() == TargetCXXABI::Microsoft) 73263508Sdim return SOF_OTHER; 74263508Sdim 75263508Sdim const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND); 76263508Sdim if (!FD) 77263508Sdim return SOF_OTHER; 78263508Sdim QualType T = FD->getType(); 79263508Sdim 80263508Sdim const FunctionType *FT = T->castAs<FunctionType>(); 81263508Sdim 82263508Sdim CallingConv CC = FT->getCallConv(); 83263508Sdim switch (CC) { 84263508Sdim default: 85263508Sdim return SOF_OTHER; 86263508Sdim case CC_X86FastCall: 87263508Sdim return SOF_FAST; 88263508Sdim case CC_X86StdCall: 89263508Sdim return SOF_STD; 90263508Sdim } 91218887Sdim} 92218887Sdim 93263508Sdimbool MangleContext::shouldMangleDeclName(const NamedDecl *D) { 94263508Sdim const ASTContext &ASTContext = getASTContext(); 95234353Sdim 96263508Sdim StdOrFastCC CC = getStdOrFastCallMangling(ASTContext, D); 97263508Sdim if (CC != SOF_OTHER) 98263508Sdim return true; 99263508Sdim 100263508Sdim // In C, functions with no attributes never need to be mangled. Fastpath them. 101263508Sdim if (!getASTContext().getLangOpts().CPlusPlus && !D->hasAttrs()) 102263508Sdim return false; 103263508Sdim 104263508Sdim // Any decl can be declared with __asm("foo") on it, and this takes precedence 105263508Sdim // over all other naming in the .o file. 106263508Sdim if (D->hasAttr<AsmLabelAttr>()) 107263508Sdim return true; 108263508Sdim 109263508Sdim return shouldMangleCXXName(D); 110263508Sdim} 111263508Sdim 112263508Sdimvoid MangleContext::mangleName(const NamedDecl *D, raw_ostream &Out) { 113263508Sdim // Any decl can be declared with __asm("foo") on it, and this takes precedence 114263508Sdim // over all other naming in the .o file. 115263508Sdim if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) { 116263508Sdim // If we have an asm name, then we use it as the mangling. 117263508Sdim 118263508Sdim // Adding the prefix can cause problems when one file has a "foo" and 119263508Sdim // another has a "\01foo". That is known to happen on ELF with the 120263508Sdim // tricks normally used for producing aliases (PR9177). Fortunately the 121263508Sdim // llvm mangler on ELF is a nop, so we can just avoid adding the \01 122263508Sdim // marker. We also avoid adding the marker if this is an alias for an 123263508Sdim // LLVM intrinsic. 124263508Sdim StringRef UserLabelPrefix = 125263508Sdim getASTContext().getTargetInfo().getUserLabelPrefix(); 126263508Sdim if (!UserLabelPrefix.empty() && !ALA->getLabel().startswith("llvm.")) 127263508Sdim Out << '\01'; // LLVM IR Marker for __asm("foo") 128263508Sdim 129263508Sdim Out << ALA->getLabel(); 130263508Sdim return; 131263508Sdim } 132263508Sdim 133263508Sdim const ASTContext &ASTContext = getASTContext(); 134263508Sdim StdOrFastCC CC = getStdOrFastCallMangling(ASTContext, D); 135263508Sdim bool MCXX = shouldMangleCXXName(D); 136263508Sdim const TargetInfo &TI = Context.getTargetInfo(); 137263508Sdim if (CC == SOF_OTHER || (MCXX && TI.getCXXABI() == TargetCXXABI::Microsoft)) { 138263508Sdim mangleCXXName(D, Out); 139263508Sdim return; 140263508Sdim } 141263508Sdim 142263508Sdim Out << '\01'; 143263508Sdim if (CC == SOF_STD) 144263508Sdim Out << '_'; 145263508Sdim else 146263508Sdim Out << '@'; 147263508Sdim 148263508Sdim if (!MCXX) 149263508Sdim Out << D->getIdentifier()->getName(); 150263508Sdim else 151263508Sdim mangleCXXName(D, Out); 152263508Sdim 153263508Sdim const FunctionDecl *FD = cast<FunctionDecl>(D); 154263508Sdim const FunctionType *FT = FD->getType()->castAs<FunctionType>(); 155263508Sdim const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT); 156263508Sdim Out << '@'; 157263508Sdim if (!Proto) { 158263508Sdim Out << '0'; 159263508Sdim return; 160263508Sdim } 161263508Sdim assert(!Proto->isVariadic()); 162263508Sdim unsigned ArgWords = 0; 163263508Sdim if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 164263508Sdim if (!MD->isStatic()) 165263508Sdim ++ArgWords; 166263508Sdim for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(), 167263508Sdim ArgEnd = Proto->arg_type_end(); 168263508Sdim Arg != ArgEnd; ++Arg) { 169263508Sdim QualType AT = *Arg; 170263508Sdim // Size should be aligned to DWORD boundary 171263508Sdim ArgWords += llvm::RoundUpToAlignment(ASTContext.getTypeSize(AT), 32) / 32; 172263508Sdim } 173263508Sdim Out << 4 * ArgWords; 174263508Sdim} 175263508Sdim 176218887Sdimvoid MangleContext::mangleGlobalBlock(const BlockDecl *BD, 177239462Sdim const NamedDecl *ID, 178226633Sdim raw_ostream &Out) { 179239462Sdim unsigned discriminator = getBlockId(BD, false); 180239462Sdim if (ID) { 181239462Sdim if (shouldMangleDeclName(ID)) 182239462Sdim mangleName(ID, Out); 183239462Sdim else { 184239462Sdim Out << ID->getIdentifier()->getName(); 185239462Sdim } 186239462Sdim } 187239462Sdim if (discriminator == 0) 188239462Sdim Out << "_block_invoke"; 189239462Sdim else 190239462Sdim Out << "_block_invoke_" << discriminator+1; 191218887Sdim} 192218887Sdim 193218887Sdimvoid MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD, 194218887Sdim CXXCtorType CT, const BlockDecl *BD, 195226633Sdim raw_ostream &ResStream) { 196234353Sdim SmallString<64> Buffer; 197218887Sdim llvm::raw_svector_ostream Out(Buffer); 198218887Sdim mangleCXXCtor(CD, CT, Out); 199218887Sdim Out.flush(); 200218887Sdim mangleFunctionBlock(*this, Buffer, BD, ResStream); 201218887Sdim} 202218887Sdim 203218887Sdimvoid MangleContext::mangleDtorBlock(const CXXDestructorDecl *DD, 204218887Sdim CXXDtorType DT, const BlockDecl *BD, 205226633Sdim raw_ostream &ResStream) { 206234353Sdim SmallString<64> Buffer; 207218887Sdim llvm::raw_svector_ostream Out(Buffer); 208218887Sdim mangleCXXDtor(DD, DT, Out); 209218887Sdim Out.flush(); 210218887Sdim mangleFunctionBlock(*this, Buffer, BD, ResStream); 211218887Sdim} 212218887Sdim 213218887Sdimvoid MangleContext::mangleBlock(const DeclContext *DC, const BlockDecl *BD, 214226633Sdim raw_ostream &Out) { 215218887Sdim assert(!isa<CXXConstructorDecl>(DC) && !isa<CXXDestructorDecl>(DC)); 216218887Sdim 217234353Sdim SmallString<64> Buffer; 218218887Sdim llvm::raw_svector_ostream Stream(Buffer); 219218887Sdim if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) { 220218887Sdim mangleObjCMethodName(Method, Stream); 221218887Sdim } else { 222218887Sdim const NamedDecl *ND = cast<NamedDecl>(DC); 223239462Sdim if (!shouldMangleDeclName(ND) && ND->getIdentifier()) 224239462Sdim Stream << ND->getIdentifier()->getName(); 225218887Sdim else { 226218887Sdim // FIXME: We were doing a mangleUnqualifiedName() before, but that's 227218887Sdim // a private member of a class that will soon itself be private to the 228218887Sdim // Itanium C++ ABI object. What should we do now? Right now, I'm just 229218887Sdim // calling the mangleName() method on the MangleContext; is there a 230218887Sdim // better way? 231218887Sdim mangleName(ND, Stream); 232218887Sdim } 233218887Sdim } 234218887Sdim Stream.flush(); 235218887Sdim mangleFunctionBlock(*this, Buffer, BD, Out); 236218887Sdim} 237218887Sdim 238218887Sdimvoid MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD, 239226633Sdim raw_ostream &Out) { 240234353Sdim SmallString<64> Name; 241218887Sdim llvm::raw_svector_ostream OS(Name); 242218887Sdim 243218887Sdim const ObjCContainerDecl *CD = 244218887Sdim dyn_cast<ObjCContainerDecl>(MD->getDeclContext()); 245218887Sdim assert (CD && "Missing container decl in GetNameForMethod"); 246218887Sdim OS << (MD->isInstanceMethod() ? '-' : '+') << '[' << CD->getName(); 247218887Sdim if (const ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(CD)) 248234353Sdim OS << '(' << *CID << ')'; 249218887Sdim OS << ' ' << MD->getSelector().getAsString() << ']'; 250218887Sdim 251218887Sdim Out << OS.str().size() << OS.str(); 252218887Sdim} 253