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