1 //===------- ItaniumCXXABI.cpp - AST support for the Itanium C++ ABI ------===//
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 // This provides C++ AST support targeting the Itanium C++ ABI, which is
11 // documented at:
12 // http://www.codesourcery.com/public/cxx-abi/abi.html
13 // http://www.codesourcery.com/public/cxx-abi/abi-eh.html
14 //
15 // It also supports the closely-related ARM C++ ABI, documented at:
16 // http://infocenter.arm.com/help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf
17 //
18 //===----------------------------------------------------------------------===//
19
20 #include "CXXABI.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/DeclCXX.h"
23 #include "clang/AST/MangleNumberingContext.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/Type.h"
26 #include "clang/Basic/TargetInfo.h"
27
28 using namespace clang;
29
30 namespace {
31
32 /// According to Itanium C++ ABI 5.1.2:
33 /// the name of an anonymous union is considered to be
34 /// the name of the first named data member found by a pre-order,
35 /// depth-first, declaration-order walk of the data members of
36 /// the anonymous union.
37 /// If there is no such data member (i.e., if all of the data members
38 /// in the union are unnamed), then there is no way for a program to
39 /// refer to the anonymous union, and there is therefore no need to mangle its name.
40 ///
41 /// Returns the name of anonymous union VarDecl or nullptr if it is not found.
findAnonymousUnionVarDeclName(const VarDecl & VD)42 static const IdentifierInfo *findAnonymousUnionVarDeclName(const VarDecl& VD) {
43 const RecordType *RT = VD.getType()->getAs<RecordType>();
44 assert(RT && "type of VarDecl is expected to be RecordType.");
45 assert(RT->getDecl()->isUnion() && "RecordType is expected to be a union.");
46 if (const FieldDecl *FD = RT->getDecl()->findFirstNamedDataMember()) {
47 return FD->getIdentifier();
48 }
49
50 return nullptr;
51 }
52
53 /// \brief Keeps track of the mangled names of lambda expressions and block
54 /// literals within a particular context.
55 class ItaniumNumberingContext : public MangleNumberingContext {
56 llvm::DenseMap<const Type *, unsigned> ManglingNumbers;
57 llvm::DenseMap<const IdentifierInfo *, unsigned> VarManglingNumbers;
58 llvm::DenseMap<const IdentifierInfo *, unsigned> TagManglingNumbers;
59
60 public:
getManglingNumber(const CXXMethodDecl * CallOperator)61 unsigned getManglingNumber(const CXXMethodDecl *CallOperator) override {
62 const FunctionProtoType *Proto =
63 CallOperator->getType()->getAs<FunctionProtoType>();
64 ASTContext &Context = CallOperator->getASTContext();
65
66 QualType Key =
67 Context.getFunctionType(Context.VoidTy, Proto->getParamTypes(),
68 FunctionProtoType::ExtProtoInfo());
69 Key = Context.getCanonicalType(Key);
70 return ++ManglingNumbers[Key->castAs<FunctionProtoType>()];
71 }
72
getManglingNumber(const BlockDecl * BD)73 unsigned getManglingNumber(const BlockDecl *BD) override {
74 const Type *Ty = nullptr;
75 return ++ManglingNumbers[Ty];
76 }
77
getStaticLocalNumber(const VarDecl * VD)78 unsigned getStaticLocalNumber(const VarDecl *VD) override {
79 return 0;
80 }
81
82 /// Variable decls are numbered by identifier.
getManglingNumber(const VarDecl * VD,unsigned)83 unsigned getManglingNumber(const VarDecl *VD, unsigned) override {
84 const IdentifierInfo *Identifier = VD->getIdentifier();
85 if (!Identifier) {
86 // VarDecl without an identifier represents an anonymous union declaration.
87 Identifier = findAnonymousUnionVarDeclName(*VD);
88 }
89 return ++VarManglingNumbers[Identifier];
90 }
91
getManglingNumber(const TagDecl * TD,unsigned)92 unsigned getManglingNumber(const TagDecl *TD, unsigned) override {
93 return ++TagManglingNumbers[TD->getIdentifier()];
94 }
95 };
96
97 class ItaniumCXXABI : public CXXABI {
98 protected:
99 ASTContext &Context;
100 public:
ItaniumCXXABI(ASTContext & Ctx)101 ItaniumCXXABI(ASTContext &Ctx) : Context(Ctx) { }
102
103 std::pair<uint64_t, unsigned>
getMemberPointerWidthAndAlign(const MemberPointerType * MPT) const104 getMemberPointerWidthAndAlign(const MemberPointerType *MPT) const override {
105 const TargetInfo &Target = Context.getTargetInfo();
106 TargetInfo::IntType PtrDiff = Target.getPtrDiffType(0);
107 uint64_t Width = Target.getTypeWidth(PtrDiff);
108 unsigned Align = Target.getTypeAlign(PtrDiff);
109 if (MPT->isMemberFunctionPointer())
110 Width = 2 * Width;
111 return std::make_pair(Width, Align);
112 }
113
getDefaultMethodCallConv(bool isVariadic) const114 CallingConv getDefaultMethodCallConv(bool isVariadic) const override {
115 const llvm::Triple &T = Context.getTargetInfo().getTriple();
116 if (!isVariadic && T.isWindowsGNUEnvironment() &&
117 T.getArch() == llvm::Triple::x86)
118 return CC_X86ThisCall;
119 return CC_C;
120 }
121
122 // We cheat and just check that the class has a vtable pointer, and that it's
123 // only big enough to have a vtable pointer and nothing more (or less).
isNearlyEmpty(const CXXRecordDecl * RD) const124 bool isNearlyEmpty(const CXXRecordDecl *RD) const override {
125
126 // Check that the class has a vtable pointer.
127 if (!RD->isDynamicClass())
128 return false;
129
130 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
131 CharUnits PointerSize =
132 Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
133 return Layout.getNonVirtualSize() == PointerSize;
134 }
135
136 const CXXConstructorDecl *
getCopyConstructorForExceptionObject(CXXRecordDecl * RD)137 getCopyConstructorForExceptionObject(CXXRecordDecl *RD) override {
138 return nullptr;
139 }
140
addCopyConstructorForExceptionObject(CXXRecordDecl * RD,CXXConstructorDecl * CD)141 void addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
142 CXXConstructorDecl *CD) override {}
143
addDefaultArgExprForConstructor(const CXXConstructorDecl * CD,unsigned ParmIdx,Expr * DAE)144 void addDefaultArgExprForConstructor(const CXXConstructorDecl *CD,
145 unsigned ParmIdx, Expr *DAE) override {}
146
getDefaultArgExprForConstructor(const CXXConstructorDecl * CD,unsigned ParmIdx)147 Expr *getDefaultArgExprForConstructor(const CXXConstructorDecl *CD,
148 unsigned ParmIdx) override {
149 return nullptr;
150 }
151
addTypedefNameForUnnamedTagDecl(TagDecl * TD,TypedefNameDecl * DD)152 void addTypedefNameForUnnamedTagDecl(TagDecl *TD,
153 TypedefNameDecl *DD) override {}
154
getTypedefNameForUnnamedTagDecl(const TagDecl * TD)155 TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD) override {
156 return nullptr;
157 }
158
addDeclaratorForUnnamedTagDecl(TagDecl * TD,DeclaratorDecl * DD)159 void addDeclaratorForUnnamedTagDecl(TagDecl *TD,
160 DeclaratorDecl *DD) override {}
161
getDeclaratorForUnnamedTagDecl(const TagDecl * TD)162 DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD) override {
163 return nullptr;
164 }
165
createMangleNumberingContext() const166 MangleNumberingContext *createMangleNumberingContext() const override {
167 return new ItaniumNumberingContext();
168 }
169 };
170 }
171
CreateItaniumCXXABI(ASTContext & Ctx)172 CXXABI *clang::CreateItaniumCXXABI(ASTContext &Ctx) {
173 return new ItaniumCXXABI(Ctx);
174 }
175