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//===----------------------------------------------------------------------===// 13263509Sdim#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" 23263509Sdim#include "clang/Basic/TargetInfo.h" 24218887Sdim#include "llvm/ADT/StringExtras.h" 25252723Sdim#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, 40226890Sdim StringRef Outer, 41218887Sdim const BlockDecl *BD, 42226890Sdim raw_ostream &Out) { 43245431Sdim unsigned discriminator = Context.getBlockId(BD, true); 44245431Sdim if (discriminator == 0) 45245431Sdim Out << "__" << Outer << "_block_invoke"; 46245431Sdim else 47245431Sdim Out << "__" << Outer << "_block_invoke_" << discriminator+1; 48218887Sdim} 49218887Sdim 50263509Sdimvoid MangleContext::anchor() { } 51263509Sdim 52263509Sdimenum StdOrFastCC { 53263509Sdim SOF_OTHER, 54263509Sdim SOF_FAST, 55263509Sdim SOF_STD 56263509Sdim}; 57263509Sdim 58263509Sdimstatic bool isExternC(const NamedDecl *ND) { 59263509Sdim if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 60263509Sdim return FD->isExternC(); 61263509Sdim return cast<VarDecl>(ND)->isExternC(); 62218887Sdim} 63218887Sdim 64263509Sdimstatic StdOrFastCC getStdOrFastCallMangling(const ASTContext &Context, 65263509Sdim const NamedDecl *ND) { 66263509Sdim const TargetInfo &TI = Context.getTargetInfo(); 67263509Sdim llvm::Triple Triple = TI.getTriple(); 68263509Sdim if (!Triple.isOSWindows() || Triple.getArch() != llvm::Triple::x86) 69263509Sdim return SOF_OTHER; 70263509Sdim 71263509Sdim if (Context.getLangOpts().CPlusPlus && !isExternC(ND) && 72263509Sdim TI.getCXXABI() == TargetCXXABI::Microsoft) 73263509Sdim return SOF_OTHER; 74263509Sdim 75263509Sdim const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND); 76263509Sdim if (!FD) 77263509Sdim return SOF_OTHER; 78263509Sdim QualType T = FD->getType(); 79263509Sdim 80263509Sdim const FunctionType *FT = T->castAs<FunctionType>(); 81263509Sdim 82263509Sdim CallingConv CC = FT->getCallConv(); 83263509Sdim switch (CC) { 84263509Sdim default: 85263509Sdim return SOF_OTHER; 86263509Sdim case CC_X86FastCall: 87263509Sdim return SOF_FAST; 88263509Sdim case CC_X86StdCall: 89263509Sdim return SOF_STD; 90263509Sdim } 91218887Sdim} 92218887Sdim 93263509Sdimbool MangleContext::shouldMangleDeclName(const NamedDecl *D) { 94263509Sdim const ASTContext &ASTContext = getASTContext(); 95235633Sdim 96263509Sdim StdOrFastCC CC = getStdOrFastCallMangling(ASTContext, D); 97263509Sdim if (CC != SOF_OTHER) 98263509Sdim return true; 99263509Sdim 100263509Sdim // In C, functions with no attributes never need to be mangled. Fastpath them. 101263509Sdim if (!getASTContext().getLangOpts().CPlusPlus && !D->hasAttrs()) 102263509Sdim return false; 103263509Sdim 104263509Sdim // Any decl can be declared with __asm("foo") on it, and this takes precedence 105263509Sdim // over all other naming in the .o file. 106263509Sdim if (D->hasAttr<AsmLabelAttr>()) 107263509Sdim return true; 108263509Sdim 109263509Sdim return shouldMangleCXXName(D); 110263509Sdim} 111263509Sdim 112263509Sdimvoid MangleContext::mangleName(const NamedDecl *D, raw_ostream &Out) { 113263509Sdim // Any decl can be declared with __asm("foo") on it, and this takes precedence 114263509Sdim // over all other naming in the .o file. 115263509Sdim if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) { 116263509Sdim // If we have an asm name, then we use it as the mangling. 117263509Sdim 118263509Sdim // Adding the prefix can cause problems when one file has a "foo" and 119263509Sdim // another has a "\01foo". That is known to happen on ELF with the 120263509Sdim // tricks normally used for producing aliases (PR9177). Fortunately the 121263509Sdim // llvm mangler on ELF is a nop, so we can just avoid adding the \01 122263509Sdim // marker. We also avoid adding the marker if this is an alias for an 123263509Sdim // LLVM intrinsic. 124263509Sdim StringRef UserLabelPrefix = 125263509Sdim getASTContext().getTargetInfo().getUserLabelPrefix(); 126263509Sdim if (!UserLabelPrefix.empty() && !ALA->getLabel().startswith("llvm.")) 127263509Sdim Out << '\01'; // LLVM IR Marker for __asm("foo") 128263509Sdim 129263509Sdim Out << ALA->getLabel(); 130263509Sdim return; 131263509Sdim } 132263509Sdim 133263509Sdim const ASTContext &ASTContext = getASTContext(); 134263509Sdim StdOrFastCC CC = getStdOrFastCallMangling(ASTContext, D); 135263509Sdim bool MCXX = shouldMangleCXXName(D); 136263509Sdim const TargetInfo &TI = Context.getTargetInfo(); 137263509Sdim if (CC == SOF_OTHER || (MCXX && TI.getCXXABI() == TargetCXXABI::Microsoft)) { 138263509Sdim mangleCXXName(D, Out); 139263509Sdim return; 140263509Sdim } 141263509Sdim 142263509Sdim Out << '\01'; 143263509Sdim if (CC == SOF_STD) 144263509Sdim Out << '_'; 145263509Sdim else 146263509Sdim Out << '@'; 147263509Sdim 148263509Sdim if (!MCXX) 149263509Sdim Out << D->getIdentifier()->getName(); 150263509Sdim else 151263509Sdim mangleCXXName(D, Out); 152263509Sdim 153263509Sdim const FunctionDecl *FD = cast<FunctionDecl>(D); 154263509Sdim const FunctionType *FT = FD->getType()->castAs<FunctionType>(); 155263509Sdim const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT); 156263509Sdim Out << '@'; 157263509Sdim if (!Proto) { 158263509Sdim Out << '0'; 159263509Sdim return; 160263509Sdim } 161263509Sdim assert(!Proto->isVariadic()); 162263509Sdim unsigned ArgWords = 0; 163263509Sdim if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 164263509Sdim if (!MD->isStatic()) 165263509Sdim ++ArgWords; 166263509Sdim for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(), 167263509Sdim ArgEnd = Proto->arg_type_end(); 168263509Sdim Arg != ArgEnd; ++Arg) { 169263509Sdim QualType AT = *Arg; 170263509Sdim // Size should be aligned to DWORD boundary 171263509Sdim ArgWords += llvm::RoundUpToAlignment(ASTContext.getTypeSize(AT), 32) / 32; 172263509Sdim } 173263509Sdim Out << 4 * ArgWords; 174263509Sdim} 175263509Sdim 176218887Sdimvoid MangleContext::mangleGlobalBlock(const BlockDecl *BD, 177245431Sdim const NamedDecl *ID, 178226890Sdim raw_ostream &Out) { 179245431Sdim unsigned discriminator = getBlockId(BD, false); 180245431Sdim if (ID) { 181245431Sdim if (shouldMangleDeclName(ID)) 182245431Sdim mangleName(ID, Out); 183245431Sdim else { 184245431Sdim Out << ID->getIdentifier()->getName(); 185245431Sdim } 186245431Sdim } 187245431Sdim if (discriminator == 0) 188245431Sdim Out << "_block_invoke"; 189245431Sdim else 190245431Sdim Out << "_block_invoke_" << discriminator+1; 191218887Sdim} 192218887Sdim 193218887Sdimvoid MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD, 194218887Sdim CXXCtorType CT, const BlockDecl *BD, 195226890Sdim raw_ostream &ResStream) { 196235633Sdim 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, 205226890Sdim raw_ostream &ResStream) { 206235633Sdim 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, 214226890Sdim raw_ostream &Out) { 215218887Sdim assert(!isa<CXXConstructorDecl>(DC) && !isa<CXXDestructorDecl>(DC)); 216218887Sdim 217235633Sdim 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); 223245431Sdim if (!shouldMangleDeclName(ND) && ND->getIdentifier()) 224245431Sdim 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, 239226890Sdim raw_ostream &Out) { 240235633Sdim 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)) 248235633Sdim OS << '(' << *CID << ')'; 249218887Sdim OS << ' ' << MD->getSelector().getAsString() << ']'; 250218887Sdim 251218887Sdim Out << OS.str().size() << OS.str(); 252218887Sdim} 253