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 | {} |
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 | {} |
53 | |
54 | explicit TBAAAccessInfo(llvm::MDNode *AccessType, uint64_t Size) |
55 | : TBAAAccessInfo(/* BaseType= */ nullptr, AccessType, /* Offset= */ 0, Size) |
56 | {} |
57 | |
58 | TBAAAccessInfo() |
59 | : TBAAAccessInfo(/* AccessType= */ nullptr, /* Size= */ 0) |
60 | {} |
61 | |
62 | static TBAAAccessInfo getMayAliasInfo() { |
63 | return TBAAAccessInfo(TBAAAccessKind::MayAlias, |
64 | /* BaseType= */ nullptr, /* AccessType= */ nullptr, |
65 | /* Offset= */ 0, /* Size= */ 0); |
66 | } |
67 | |
68 | bool isMayAlias() const { return Kind == TBAAAccessKind::MayAlias; } |
69 | |
70 | static TBAAAccessInfo getIncompleteInfo() { |
71 | return TBAAAccessInfo(TBAAAccessKind::Incomplete, |
72 | /* BaseType= */ nullptr, /* AccessType= */ nullptr, |
73 | /* Offset= */ 0, /* Size= */ 0); |
74 | } |
75 | |
76 | bool isIncomplete() const { return Kind == TBAAAccessKind::Incomplete; } |
77 | |
78 | bool operator==(const TBAAAccessInfo &Other) const { |
79 | return Kind == Other.Kind && |
80 | BaseType == Other.BaseType && |
81 | AccessType == Other.AccessType && |
82 | Offset == Other.Offset && |
83 | Size == Other.Size; |
84 | } |
85 | |
86 | bool operator!=(const TBAAAccessInfo &Other) const { |
87 | return !(*this == Other); |
88 | } |
89 | |
90 | explicit operator bool() const { |
91 | return *this != TBAAAccessInfo(); |
92 | } |
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 | static clang::CodeGen::TBAAAccessInfo getEmptyKey() { |
220 | unsigned UnsignedKey = DenseMapInfo<unsigned>::getEmptyKey(); |
221 | return clang::CodeGen::TBAAAccessInfo( |
222 | static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), |
223 | DenseMapInfo<MDNode *>::getEmptyKey(), |
224 | DenseMapInfo<MDNode *>::getEmptyKey(), |
225 | DenseMapInfo<uint64_t>::getEmptyKey(), |
226 | DenseMapInfo<uint64_t>::getEmptyKey()); |
227 | } |
228 | |
229 | static clang::CodeGen::TBAAAccessInfo getTombstoneKey() { |
230 | unsigned UnsignedKey = DenseMapInfo<unsigned>::getTombstoneKey(); |
231 | return clang::CodeGen::TBAAAccessInfo( |
232 | static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), |
233 | DenseMapInfo<MDNode *>::getTombstoneKey(), |
234 | DenseMapInfo<MDNode *>::getTombstoneKey(), |
235 | DenseMapInfo<uint64_t>::getTombstoneKey(), |
236 | DenseMapInfo<uint64_t>::getTombstoneKey()); |
237 | } |
238 | |
239 | static unsigned getHashValue(const clang::CodeGen::TBAAAccessInfo &Val) { |
240 | auto KindValue = static_cast<unsigned>(Val.Kind); |
241 | return DenseMapInfo<unsigned>::getHashValue(Val: KindValue) ^ |
242 | DenseMapInfo<MDNode *>::getHashValue(PtrVal: Val.BaseType) ^ |
243 | DenseMapInfo<MDNode *>::getHashValue(PtrVal: Val.AccessType) ^ |
244 | DenseMapInfo<uint64_t>::getHashValue(Val: Val.Offset) ^ |
245 | DenseMapInfo<uint64_t>::getHashValue(Val: Val.Size); |
246 | } |
247 | |
248 | static bool isEqual(const clang::CodeGen::TBAAAccessInfo &LHS, |
249 | const clang::CodeGen::TBAAAccessInfo &RHS) { |
250 | return LHS == RHS; |
251 | } |
252 | }; |
253 | |
254 | } // end namespace llvm |
255 | |
256 | #endif |
257 | |