/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/clang/include/clang/AST/Mangle.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- Mangle.h - 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 | | // Defines the C++ name mangling interface. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_CLANG_AST_MANGLE_H |
15 | | #define LLVM_CLANG_AST_MANGLE_H |
16 | | |
17 | | #include "clang/AST/Type.h" |
18 | | #include "clang/Basic/ABI.h" |
19 | | #include "llvm/ADT/DenseMap.h" |
20 | | #include "llvm/Support/Casting.h" |
21 | | |
22 | | namespace llvm { |
23 | | class raw_ostream; |
24 | | } |
25 | | |
26 | | namespace clang { |
27 | | class ASTContext; |
28 | | class BlockDecl; |
29 | | class CXXConstructorDecl; |
30 | | class CXXDestructorDecl; |
31 | | class CXXMethodDecl; |
32 | | class FunctionDecl; |
33 | | class NamedDecl; |
34 | | class ObjCMethodDecl; |
35 | | class StringLiteral; |
36 | | struct ThisAdjustment; |
37 | | struct ThunkInfo; |
38 | | class VarDecl; |
39 | | |
40 | | /// MangleContext - Context for tracking state which persists across multiple |
41 | | /// calls to the C++ name mangler. |
42 | | class MangleContext { |
43 | | public: |
44 | | enum ManglerKind { |
45 | | MK_Itanium, |
46 | | MK_Microsoft |
47 | | }; |
48 | | |
49 | | private: |
50 | | virtual void anchor(); |
51 | | |
52 | | ASTContext &Context; |
53 | | DiagnosticsEngine &Diags; |
54 | | const ManglerKind Kind; |
55 | | |
56 | | llvm::DenseMap<const BlockDecl*, unsigned> GlobalBlockIds; |
57 | | llvm::DenseMap<const BlockDecl*, unsigned> LocalBlockIds; |
58 | | llvm::DenseMap<const TagDecl*, uint64_t> AnonStructIds; |
59 | | |
60 | | public: |
61 | 0 | ManglerKind getKind() const { return Kind; } |
62 | | |
63 | | explicit MangleContext(ASTContext &Context, |
64 | | DiagnosticsEngine &Diags, |
65 | | ManglerKind Kind) |
66 | 14.4k | : Context(Context), Diags(Diags), Kind(Kind) {} |
67 | | |
68 | 14.4k | virtual ~MangleContext() { } |
69 | | |
70 | 4.28M | ASTContext &getASTContext() const { return Context; } |
71 | | |
72 | 2 | DiagnosticsEngine &getDiags() const { return Diags; } |
73 | | |
74 | 181k | virtual void startNewFunction() { LocalBlockIds.clear(); } |
75 | | |
76 | 696 | unsigned getBlockId(const BlockDecl *BD, bool Local) { |
77 | 696 | llvm::DenseMap<const BlockDecl *, unsigned> &BlockIds |
78 | 696 | = Local? LocalBlockIds561 : GlobalBlockIds135 ; |
79 | 696 | std::pair<llvm::DenseMap<const BlockDecl *, unsigned>::iterator, bool> |
80 | 696 | Result = BlockIds.insert(std::make_pair(BD, BlockIds.size())); |
81 | 696 | return Result.first->second; |
82 | 696 | } |
83 | | |
84 | 526 | uint64_t getAnonymousStructId(const TagDecl *TD) { |
85 | 526 | std::pair<llvm::DenseMap<const TagDecl *, uint64_t>::iterator, bool> |
86 | 526 | Result = AnonStructIds.insert(std::make_pair(TD, AnonStructIds.size())); |
87 | 526 | return Result.first->second; |
88 | 526 | } |
89 | | |
90 | | /// @name Mangler Entry Points |
91 | | /// @{ |
92 | | |
93 | | bool shouldMangleDeclName(const NamedDecl *D); |
94 | | virtual bool shouldMangleCXXName(const NamedDecl *D) = 0; |
95 | | virtual bool shouldMangleStringLiteral(const StringLiteral *SL) = 0; |
96 | | |
97 | | // FIXME: consider replacing raw_ostream & with something like SmallString &. |
98 | | void mangleName(const NamedDecl *D, raw_ostream &); |
99 | | virtual void mangleCXXName(const NamedDecl *D, raw_ostream &) = 0; |
100 | | virtual void mangleThunk(const CXXMethodDecl *MD, |
101 | | const ThunkInfo &Thunk, |
102 | | raw_ostream &) = 0; |
103 | | virtual void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type, |
104 | | const ThisAdjustment &ThisAdjustment, |
105 | | raw_ostream &) = 0; |
106 | | virtual void mangleReferenceTemporary(const VarDecl *D, |
107 | | unsigned ManglingNumber, |
108 | | raw_ostream &) = 0; |
109 | | virtual void mangleCXXRTTI(QualType T, raw_ostream &) = 0; |
110 | | virtual void mangleCXXRTTIName(QualType T, raw_ostream &) = 0; |
111 | | virtual void mangleCXXCtor(const CXXConstructorDecl *D, CXXCtorType Type, |
112 | | raw_ostream &) = 0; |
113 | | virtual void mangleCXXDtor(const CXXDestructorDecl *D, CXXDtorType Type, |
114 | | raw_ostream &) = 0; |
115 | | virtual void mangleStringLiteral(const StringLiteral *SL, raw_ostream &) = 0; |
116 | | |
117 | | void mangleGlobalBlock(const BlockDecl *BD, |
118 | | const NamedDecl *ID, |
119 | | raw_ostream &Out); |
120 | | void mangleCtorBlock(const CXXConstructorDecl *CD, CXXCtorType CT, |
121 | | const BlockDecl *BD, raw_ostream &Out); |
122 | | void mangleDtorBlock(const CXXDestructorDecl *CD, CXXDtorType DT, |
123 | | const BlockDecl *BD, raw_ostream &Out); |
124 | | void mangleBlock(const DeclContext *DC, const BlockDecl *BD, |
125 | | raw_ostream &Out); |
126 | | |
127 | | void mangleObjCMethodNameWithoutSize(const ObjCMethodDecl *MD, raw_ostream &); |
128 | | void mangleObjCMethodName(const ObjCMethodDecl *MD, raw_ostream &); |
129 | | |
130 | | virtual void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &) = 0; |
131 | | |
132 | | virtual void mangleDynamicInitializer(const VarDecl *D, raw_ostream &) = 0; |
133 | | |
134 | | virtual void mangleDynamicAtExitDestructor(const VarDecl *D, |
135 | | raw_ostream &) = 0; |
136 | | |
137 | | virtual void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl, |
138 | | raw_ostream &Out) = 0; |
139 | | |
140 | | virtual void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl, |
141 | | raw_ostream &Out) = 0; |
142 | | |
143 | | /// Generates a unique string for an externally visible type for use with TBAA |
144 | | /// or type uniquing. |
145 | | /// TODO: Extend this to internal types by generating names that are unique |
146 | | /// across translation units so it can be used with LTO. |
147 | | virtual void mangleTypeName(QualType T, raw_ostream &) = 0; |
148 | | |
149 | | /// @} |
150 | | }; |
151 | | |
152 | | class ItaniumMangleContext : public MangleContext { |
153 | | public: |
154 | | explicit ItaniumMangleContext(ASTContext &C, DiagnosticsEngine &D) |
155 | 14.0k | : MangleContext(C, D, MK_Itanium) {} |
156 | | |
157 | | virtual void mangleCXXVTable(const CXXRecordDecl *RD, raw_ostream &) = 0; |
158 | | virtual void mangleCXXVTT(const CXXRecordDecl *RD, raw_ostream &) = 0; |
159 | | virtual void mangleCXXCtorVTable(const CXXRecordDecl *RD, int64_t Offset, |
160 | | const CXXRecordDecl *Type, |
161 | | raw_ostream &) = 0; |
162 | | virtual void mangleItaniumThreadLocalInit(const VarDecl *D, |
163 | | raw_ostream &) = 0; |
164 | | virtual void mangleItaniumThreadLocalWrapper(const VarDecl *D, |
165 | | raw_ostream &) = 0; |
166 | | |
167 | | virtual void mangleCXXCtorComdat(const CXXConstructorDecl *D, |
168 | | raw_ostream &) = 0; |
169 | | virtual void mangleCXXDtorComdat(const CXXDestructorDecl *D, |
170 | | raw_ostream &) = 0; |
171 | | |
172 | 0 | static bool classof(const MangleContext *C) { |
173 | 0 | return C->getKind() == MK_Itanium; |
174 | 0 | } |
175 | | |
176 | | static ItaniumMangleContext *create(ASTContext &Context, |
177 | | DiagnosticsEngine &Diags); |
178 | | }; |
179 | | |
180 | | class MicrosoftMangleContext : public MangleContext { |
181 | | public: |
182 | | explicit MicrosoftMangleContext(ASTContext &C, DiagnosticsEngine &D) |
183 | 476 | : MangleContext(C, D, MK_Microsoft) {} |
184 | | |
185 | | /// \brief Mangle vftable symbols. Only a subset of the bases along the path |
186 | | /// to the vftable are included in the name. It's up to the caller to pick |
187 | | /// them correctly. |
188 | | virtual void mangleCXXVFTable(const CXXRecordDecl *Derived, |
189 | | ArrayRef<const CXXRecordDecl *> BasePath, |
190 | | raw_ostream &Out) = 0; |
191 | | |
192 | | /// \brief Mangle vbtable symbols. Only a subset of the bases along the path |
193 | | /// to the vbtable are included in the name. It's up to the caller to pick |
194 | | /// them correctly. |
195 | | virtual void mangleCXXVBTable(const CXXRecordDecl *Derived, |
196 | | ArrayRef<const CXXRecordDecl *> BasePath, |
197 | | raw_ostream &Out) = 0; |
198 | | |
199 | | virtual void mangleThreadSafeStaticGuardVariable(const VarDecl *VD, |
200 | | unsigned GuardNum, |
201 | | raw_ostream &Out) = 0; |
202 | | |
203 | | virtual void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD, |
204 | | raw_ostream &) = 0; |
205 | | |
206 | | virtual void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD, |
207 | | const CXXRecordDecl *DstRD, |
208 | | raw_ostream &Out) = 0; |
209 | | |
210 | | virtual void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile, |
211 | | bool IsUnaligned, uint32_t NumEntries, |
212 | | raw_ostream &Out) = 0; |
213 | | |
214 | | virtual void mangleCXXCatchableTypeArray(QualType T, uint32_t NumEntries, |
215 | | raw_ostream &Out) = 0; |
216 | | |
217 | | virtual void mangleCXXCatchableType(QualType T, const CXXConstructorDecl *CD, |
218 | | CXXCtorType CT, uint32_t Size, |
219 | | uint32_t NVOffset, int32_t VBPtrOffset, |
220 | | uint32_t VBIndex, raw_ostream &Out) = 0; |
221 | | |
222 | | virtual void mangleCXXRTTIBaseClassDescriptor( |
223 | | const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset, |
224 | | uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) = 0; |
225 | | |
226 | | virtual void mangleCXXRTTIBaseClassArray(const CXXRecordDecl *Derived, |
227 | | raw_ostream &Out) = 0; |
228 | | virtual void |
229 | | mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl *Derived, |
230 | | raw_ostream &Out) = 0; |
231 | | |
232 | | virtual void |
233 | | mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl *Derived, |
234 | | ArrayRef<const CXXRecordDecl *> BasePath, |
235 | | raw_ostream &Out) = 0; |
236 | | |
237 | 0 | static bool classof(const MangleContext *C) { |
238 | 0 | return C->getKind() == MK_Microsoft; |
239 | 0 | } |
240 | | |
241 | | static MicrosoftMangleContext *create(ASTContext &Context, |
242 | | DiagnosticsEngine &Diags); |
243 | | }; |
244 | | } |
245 | | |
246 | | #endif |