CodeGenTBAA.h source code [clang_source_code/lib/CodeGen/CodeGenTBAA.h]

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