clang 17.0.0git
CodeGenTBAA.h
Go to the documentation of this file.
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
23namespace clang {
24 class ASTContext;
25 class CodeGenOptions;
26 class LangOptions;
27 class MangleContext;
28 class QualType;
29 class Type;
30
31namespace CodeGen {
32
33// TBAAAccessKind - A kind of TBAA memory access descriptor.
34enum class TBAAAccessKind : unsigned {
38};
39
40// TBAAAccessInfo - Describes a memory access in terms of TBAA.
43 llvm::MDNode *AccessType, uint64_t Offset, uint64_t Size)
46 {}
47
48 TBAAAccessInfo(llvm::MDNode *BaseType, llvm::MDNode *AccessType,
49 uint64_t Offset, uint64_t Size)
51 Offset, Size)
52 {}
53
54 explicit TBAAAccessInfo(llvm::MDNode *AccessType, uint64_t Size)
55 : TBAAAccessInfo(/* BaseType= */ nullptr, AccessType, /* Offset= */ 0, Size)
56 {}
57
59 : TBAAAccessInfo(/* AccessType= */ nullptr, /* Size= */ 0)
60 {}
61
64 /* BaseType= */ nullptr, /* AccessType= */ nullptr,
65 /* Offset= */ 0, /* Size= */ 0);
66 }
67
68 bool isMayAlias() const { return Kind == TBAAAccessKind::MayAlias; }
69
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.
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.
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,
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
169public:
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.
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.
201
202 /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the
203 /// purpose of conditional operator.
205 TBAAAccessInfo InfoB);
206
207 /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the
208 /// purpose of memory transfer calls.
210 TBAAAccessInfo SrcInfo);
211};
212
213} // end namespace CodeGen
214} // end namespace clang
215
216namespace llvm {
217
218template<> struct DenseMapInfo<clang::CodeGen::TBAAAccessInfo> {
220 unsigned UnsignedKey = DenseMapInfo<unsigned>::getEmptyKey();
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
230 unsigned UnsignedKey = DenseMapInfo<unsigned>::getTombstoneKey();
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(KindValue) ^
242 DenseMapInfo<MDNode *>::getHashValue(Val.BaseType) ^
243 DenseMapInfo<MDNode *>::getHashValue(Val.AccessType) ^
244 DenseMapInfo<uint64_t>::getHashValue(Val.Offset) ^
245 DenseMapInfo<uint64_t>::getHashValue(Val.Size);
246 }
247
250 return LHS == RHS;
251 }
252};
253
254} // end namespace llvm
255
256#endif
NodeId Parent
Definition: ASTDiff.cpp:191
MatchType Type
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LL...
Definition: CodeGenTBAA.h:116
llvm::MDNode * getBaseTypeInfo(QualType QTy)
getBaseTypeInfo - Get metadata that describes the given base access type.
llvm::MDNode * getTypeInfo(QualType QTy)
getTypeInfo - Get metadata used to describe accesses to objects of the given type.
TBAAAccessInfo getVTablePtrAccessInfo(llvm::Type *VTablePtrType)
getVTablePtrAccessInfo - Get the TBAA information that describes an access to a virtual table pointer...
TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, TBAAAccessInfo SrcInfo)
mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the purpose of memory transfer calls...
TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)
mergeTBAAInfoForCast - Get merged TBAA information for the purpose of type casts.
TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB)
mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the purpose of conditional oper...
llvm::MDNode * getAccessTagInfo(TBAAAccessInfo Info)
getAccessTagInfo - Get TBAA tag for a given memory access.
llvm::MDNode * getTBAAStructInfo(QualType QTy)
getTBAAStructInfo - Get the TBAAStruct MDNode to be used for a memcpy of the given type.
TBAAAccessInfo getAccessInfo(QualType AccessType)
getAccessInfo - Get TBAA information that describes an access to an object of the given type.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:82
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Definition: Mangle.h:45
Describes a module or submodule.
Definition: Module.h:98
A (possibly-)qualified type.
Definition: Type.h:736
Exposes information about the current target.
Definition: TargetInfo.h:206
The base class of the type hierarchy.
Definition: Type.h:1568
YAML serialization mapping.
Definition: Dominators.h:30
#define bool
Definition: stdbool.h:20
TBAAAccessKind Kind
Kind - The kind of the access descriptor.
Definition: CodeGenTBAA.h:95
llvm::MDNode * AccessType
AccessType - The final access type.
Definition: CodeGenTBAA.h:104
uint64_t Offset
Offset - The byte offset of the final access within the base one.
Definition: CodeGenTBAA.h:108
TBAAAccessInfo(TBAAAccessKind Kind, llvm::MDNode *BaseType, llvm::MDNode *AccessType, uint64_t Offset, uint64_t Size)
Definition: CodeGenTBAA.h:42
static TBAAAccessInfo getMayAliasInfo()
Definition: CodeGenTBAA.h:62
TBAAAccessInfo(llvm::MDNode *AccessType, uint64_t Size)
Definition: CodeGenTBAA.h:54
uint64_t Size
Size - The size of access, in bytes.
Definition: CodeGenTBAA.h:111
bool operator==(const TBAAAccessInfo &Other) const
Definition: CodeGenTBAA.h:78
static TBAAAccessInfo getIncompleteInfo()
Definition: CodeGenTBAA.h:70
bool operator!=(const TBAAAccessInfo &Other) const
Definition: CodeGenTBAA.h:86
llvm::MDNode * BaseType
BaseType - The base/leading access type.
Definition: CodeGenTBAA.h:100
TBAAAccessInfo(llvm::MDNode *BaseType, llvm::MDNode *AccessType, uint64_t Offset, uint64_t Size)
Definition: CodeGenTBAA.h:48
static clang::CodeGen::TBAAAccessInfo getTombstoneKey()
Definition: CodeGenTBAA.h:229
static clang::CodeGen::TBAAAccessInfo getEmptyKey()
Definition: CodeGenTBAA.h:219
static unsigned getHashValue(const clang::CodeGen::TBAAAccessInfo &Val)
Definition: CodeGenTBAA.h:239
static bool isEqual(const clang::CodeGen::TBAAAccessInfo &LHS, const clang::CodeGen::TBAAAccessInfo &RHS)
Definition: CodeGenTBAA.h:248