/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CodeGenTBAA.h
Line | Count | Source |
1 | | //===--- CodeGenTBAA.h - TBAA information for LLVM CodeGen ------*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This is the code that manages TBAA information and defines the TBAA policy |
10 | | // for the optimizer to use. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENTBAA_H |
15 | | #define LLVM_CLANG_LIB_CODEGEN_CODEGENTBAA_H |
16 | | |
17 | | #include "clang/AST/Type.h" |
18 | | #include "clang/Basic/LLVM.h" |
19 | | #include "llvm/ADT/DenseMap.h" |
20 | | #include "llvm/IR/MDBuilder.h" |
21 | | #include "llvm/IR/Metadata.h" |
22 | | |
23 | | namespace clang { |
24 | | class ASTContext; |
25 | | class CodeGenOptions; |
26 | | class LangOptions; |
27 | | class MangleContext; |
28 | | class QualType; |
29 | | class Type; |
30 | | |
31 | | namespace CodeGen { |
32 | | class CGRecordLayout; |
33 | | |
34 | | // TBAAAccessKind - A kind of TBAA memory access descriptor. |
35 | | enum class TBAAAccessKind : unsigned { |
36 | | Ordinary, |
37 | | MayAlias, |
38 | | Incomplete, |
39 | | }; |
40 | | |
41 | | // TBAAAccessInfo - Describes a memory access in terms of TBAA. |
42 | | struct TBAAAccessInfo { |
43 | | TBAAAccessInfo(TBAAAccessKind Kind, llvm::MDNode *BaseType, |
44 | | llvm::MDNode *AccessType, uint64_t Offset, uint64_t Size) |
45 | | : Kind(Kind), BaseType(BaseType), AccessType(AccessType), |
46 | | Offset(Offset), Size(Size) |
47 | 9.19M | {} |
48 | | |
49 | | TBAAAccessInfo(llvm::MDNode *BaseType, llvm::MDNode *AccessType, |
50 | | uint64_t Offset, uint64_t Size) |
51 | | : TBAAAccessInfo(TBAAAccessKind::Ordinary, BaseType, AccessType, |
52 | | Offset, Size) |
53 | 8.85M | {} clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, llvm::MDNode*, unsigned long long, unsigned long long) Line | Count | Source | 53 | 8.85M | {} |
Unexecuted instantiation: clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, llvm::MDNode*, unsigned long long, unsigned long long) |
54 | | |
55 | | explicit TBAAAccessInfo(llvm::MDNode *AccessType, uint64_t Size) |
56 | | : TBAAAccessInfo(/* BaseType= */ nullptr, AccessType, /* Offset= */ 0, Size) |
57 | 8.85M | {} clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, unsigned long long) Line | Count | Source | 57 | 8.85M | {} |
Unexecuted instantiation: clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, unsigned long long) |
58 | | |
59 | | TBAAAccessInfo() |
60 | | : TBAAAccessInfo(/* AccessType= */ nullptr, /* Size= */ 0) |
61 | 8.68M | {} clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo() Line | Count | Source | 61 | 8.68M | {} |
Unexecuted instantiation: clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo() |
62 | | |
63 | 6.59k | static TBAAAccessInfo getMayAliasInfo() { |
64 | 6.59k | return TBAAAccessInfo(TBAAAccessKind::MayAlias, |
65 | 6.59k | /* BaseType= */ nullptr, /* AccessType= */ nullptr, |
66 | 6.59k | /* Offset= */ 0, /* Size= */ 0); |
67 | 6.59k | } |
68 | | |
69 | 362k | bool isMayAlias() const { return Kind == TBAAAccessKind::MayAlias; } |
70 | | |
71 | 18 | static TBAAAccessInfo getIncompleteInfo() { |
72 | 18 | return TBAAAccessInfo(TBAAAccessKind::Incomplete, |
73 | 18 | /* BaseType= */ nullptr, /* AccessType= */ nullptr, |
74 | 18 | /* Offset= */ 0, /* Size= */ 0); |
75 | 18 | } |
76 | | |
77 | 159k | bool isIncomplete() const { return Kind == TBAAAccessKind::Incomplete; } |
78 | | |
79 | 659k | bool operator==(const TBAAAccessInfo &Other) const { |
80 | 659k | return Kind == Other.Kind && |
81 | 296k | BaseType == Other.BaseType && |
82 | 295k | AccessType == Other.AccessType && |
83 | 289k | Offset == Other.Offset && |
84 | 289k | Size == Other.Size; |
85 | 659k | } |
86 | | |
87 | 4 | bool operator!=(const TBAAAccessInfo &Other) const { |
88 | 4 | return !(*this == Other); |
89 | 4 | } |
90 | | |
91 | 4 | explicit operator bool() const { |
92 | 4 | return *this != TBAAAccessInfo(); |
93 | 4 | } |
94 | | |
95 | | /// Kind - The kind of the access descriptor. |
96 | | TBAAAccessKind Kind; |
97 | | |
98 | | /// BaseType - The base/leading access type. May be null if this access |
99 | | /// descriptor represents an access that is not considered to be an access |
100 | | /// to an aggregate or union member. |
101 | | llvm::MDNode *BaseType; |
102 | | |
103 | | /// AccessType - The final access type. May be null if there is no TBAA |
104 | | /// information available about this access. |
105 | | llvm::MDNode *AccessType; |
106 | | |
107 | | /// Offset - The byte offset of the final access within the base one. Must be |
108 | | /// zero if the base access type is not specified. |
109 | | uint64_t Offset; |
110 | | |
111 | | /// Size - The size of access, in bytes. |
112 | | uint64_t Size; |
113 | | }; |
114 | | |
115 | | /// CodeGenTBAA - This class organizes the cross-module state that is used |
116 | | /// while lowering AST types to LLVM types. |
117 | | class CodeGenTBAA { |
118 | | ASTContext &Context; |
119 | | llvm::Module &Module; |
120 | | const CodeGenOptions &CodeGenOpts; |
121 | | const LangOptions &Features; |
122 | | MangleContext &MContext; |
123 | | |
124 | | // MDHelper - Helper for creating metadata. |
125 | | llvm::MDBuilder MDHelper; |
126 | | |
127 | | /// MetadataCache - This maps clang::Types to scalar llvm::MDNodes describing |
128 | | /// them. |
129 | | llvm::DenseMap<const Type *, llvm::MDNode *> MetadataCache; |
130 | | /// This maps clang::Types to a base access type in the type DAG. |
131 | | llvm::DenseMap<const Type *, llvm::MDNode *> BaseTypeMetadataCache; |
132 | | /// This maps TBAA access descriptors to tag nodes. |
133 | | llvm::DenseMap<TBAAAccessInfo, llvm::MDNode *> AccessTagMetadataCache; |
134 | | |
135 | | /// StructMetadataCache - This maps clang::Types to llvm::MDNodes describing |
136 | | /// them for struct assignments. |
137 | | llvm::DenseMap<const Type *, llvm::MDNode *> StructMetadataCache; |
138 | | |
139 | | llvm::MDNode *Root; |
140 | | llvm::MDNode *Char; |
141 | | |
142 | | /// getRoot - This is the mdnode for the root of the metadata type graph |
143 | | /// for this translation unit. |
144 | | llvm::MDNode *getRoot(); |
145 | | |
146 | | /// getChar - This is the mdnode for "char", which is special, and any types |
147 | | /// considered to be equivalent to it. |
148 | | llvm::MDNode *getChar(); |
149 | | |
150 | | /// CollectFields - Collect information about the fields of a type for |
151 | | /// !tbaa.struct metadata formation. Return false for an unsupported type. |
152 | | bool CollectFields(uint64_t BaseOffset, |
153 | | QualType Ty, |
154 | | SmallVectorImpl<llvm::MDBuilder::TBAAStructField> &Fields, |
155 | | bool MayAlias); |
156 | | |
157 | | /// createScalarTypeNode - A wrapper function to create a metadata node |
158 | | /// describing a scalar type. |
159 | | llvm::MDNode *createScalarTypeNode(StringRef Name, llvm::MDNode *Parent, |
160 | | uint64_t Size); |
161 | | |
162 | | /// getTypeInfoHelper - An internal helper function to generate metadata used |
163 | | /// to describe accesses to objects of the given type. |
164 | | llvm::MDNode *getTypeInfoHelper(const Type *Ty); |
165 | | |
166 | | /// getBaseTypeInfoHelper - An internal helper function to generate metadata |
167 | | /// used to describe accesses to objects of the given base type. |
168 | | llvm::MDNode *getBaseTypeInfoHelper(const Type *Ty); |
169 | | |
170 | | public: |
171 | | CodeGenTBAA(ASTContext &Ctx, llvm::Module &M, const CodeGenOptions &CGO, |
172 | | const LangOptions &Features, MangleContext &MContext); |
173 | | ~CodeGenTBAA(); |
174 | | |
175 | | /// getTypeInfo - Get metadata used to describe accesses to objects of the |
176 | | /// given type. |
177 | | llvm::MDNode *getTypeInfo(QualType QTy); |
178 | | |
179 | | /// getAccessInfo - Get TBAA information that describes an access to |
180 | | /// an object of the given type. |
181 | | TBAAAccessInfo getAccessInfo(QualType AccessType); |
182 | | |
183 | | /// getVTablePtrAccessInfo - Get the TBAA information that describes an |
184 | | /// access to a virtual table pointer. |
185 | | TBAAAccessInfo getVTablePtrAccessInfo(llvm::Type *VTablePtrType); |
186 | | |
187 | | /// getTBAAStructInfo - Get the TBAAStruct MDNode to be used for a memcpy of |
188 | | /// the given type. |
189 | | llvm::MDNode *getTBAAStructInfo(QualType QTy); |
190 | | |
191 | | /// getBaseTypeInfo - Get metadata that describes the given base access type. |
192 | | /// Return null if the type is not suitable for use in TBAA access tags. |
193 | | llvm::MDNode *getBaseTypeInfo(QualType QTy); |
194 | | |
195 | | /// getAccessTagInfo - Get TBAA tag for a given memory access. |
196 | | llvm::MDNode *getAccessTagInfo(TBAAAccessInfo Info); |
197 | | |
198 | | /// mergeTBAAInfoForCast - Get merged TBAA information for the purpose of |
199 | | /// type casts. |
200 | | TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, |
201 | | TBAAAccessInfo TargetInfo); |
202 | | |
203 | | /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the |
204 | | /// purpose of conditional operator. |
205 | | TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, |
206 | | TBAAAccessInfo InfoB); |
207 | | |
208 | | /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the |
209 | | /// purpose of memory transfer calls. |
210 | | TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, |
211 | | TBAAAccessInfo SrcInfo); |
212 | | }; |
213 | | |
214 | | } // end namespace CodeGen |
215 | | } // end namespace clang |
216 | | |
217 | | namespace llvm { |
218 | | |
219 | | template<> struct DenseMapInfo<clang::CodeGen::TBAAAccessInfo> { |
220 | 173k | static clang::CodeGen::TBAAAccessInfo getEmptyKey() { |
221 | 173k | unsigned UnsignedKey = DenseMapInfo<unsigned>::getEmptyKey(); |
222 | 173k | return clang::CodeGen::TBAAAccessInfo( |
223 | 173k | static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), |
224 | 173k | DenseMapInfo<MDNode *>::getEmptyKey(), |
225 | 173k | DenseMapInfo<MDNode *>::getEmptyKey(), |
226 | 173k | DenseMapInfo<uint64_t>::getEmptyKey(), |
227 | 173k | DenseMapInfo<uint64_t>::getEmptyKey()); |
228 | 173k | } |
229 | | |
230 | 161k | static clang::CodeGen::TBAAAccessInfo getTombstoneKey() { |
231 | 161k | unsigned UnsignedKey = DenseMapInfo<unsigned>::getTombstoneKey(); |
232 | 161k | return clang::CodeGen::TBAAAccessInfo( |
233 | 161k | static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), |
234 | 161k | DenseMapInfo<MDNode *>::getTombstoneKey(), |
235 | 161k | DenseMapInfo<MDNode *>::getTombstoneKey(), |
236 | 161k | DenseMapInfo<uint64_t>::getTombstoneKey(), |
237 | 161k | DenseMapInfo<uint64_t>::getTombstoneKey()); |
238 | 161k | } |
239 | | |
240 | 159k | static unsigned getHashValue(const clang::CodeGen::TBAAAccessInfo &Val) { |
241 | 159k | auto KindValue = static_cast<unsigned>(Val.Kind); |
242 | 159k | return DenseMapInfo<unsigned>::getHashValue(KindValue) ^ |
243 | 159k | DenseMapInfo<MDNode *>::getHashValue(Val.BaseType) ^ |
244 | 159k | DenseMapInfo<MDNode *>::getHashValue(Val.AccessType) ^ |
245 | 159k | DenseMapInfo<uint64_t>::getHashValue(Val.Offset) ^ |
246 | 159k | DenseMapInfo<uint64_t>::getHashValue(Val.Size); |
247 | 159k | } |
248 | | |
249 | | static bool isEqual(const clang::CodeGen::TBAAAccessInfo &LHS, |
250 | 659k | const clang::CodeGen::TBAAAccessInfo &RHS) { |
251 | 659k | return LHS == RHS; |
252 | 659k | } |
253 | | }; |
254 | | |
255 | | } // end namespace llvm |
256 | | |
257 | | #endif |