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 QualType; 28 class Type; 29 30 namespace CodeGen { 31 class CodeGenTypes; 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 { TBAAAccessInfoTBAAAccessInfo42 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 TBAAAccessInfoTBAAAccessInfo48 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 TBAAAccessInfoTBAAAccessInfo54 explicit TBAAAccessInfo(llvm::MDNode *AccessType, uint64_t Size) 55 : TBAAAccessInfo(/* BaseType= */ nullptr, AccessType, /* Offset= */ 0, Size) 56 {} 57 TBAAAccessInfoTBAAAccessInfo58 TBAAAccessInfo() 59 : TBAAAccessInfo(/* AccessType= */ nullptr, /* Size= */ 0) 60 {} 61 getMayAliasInfoTBAAAccessInfo62 static TBAAAccessInfo getMayAliasInfo() { 63 return TBAAAccessInfo(TBAAAccessKind::MayAlias, 64 /* BaseType= */ nullptr, /* AccessType= */ nullptr, 65 /* Offset= */ 0, /* Size= */ 0); 66 } 67 isMayAliasTBAAAccessInfo68 bool isMayAlias() const { return Kind == TBAAAccessKind::MayAlias; } 69 getIncompleteInfoTBAAAccessInfo70 static TBAAAccessInfo getIncompleteInfo() { 71 return TBAAAccessInfo(TBAAAccessKind::Incomplete, 72 /* BaseType= */ nullptr, /* AccessType= */ nullptr, 73 /* Offset= */ 0, /* Size= */ 0); 74 } 75 isIncompleteTBAAAccessInfo76 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 CodeGenTypes &CGTypes; 119 llvm::Module &Module; 120 const CodeGenOptions &CodeGenOpts; 121 const LangOptions &Features; 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 /// getValidBaseTypeInfo - Return metadata that describes the given base 170 /// access type. The type must be suitable. 171 llvm::MDNode *getValidBaseTypeInfo(QualType QTy); 172 173 public: 174 CodeGenTBAA(ASTContext &Ctx, CodeGenTypes &CGTypes, llvm::Module &M, 175 const CodeGenOptions &CGO, const LangOptions &Features); 176 ~CodeGenTBAA(); 177 178 /// getTypeInfo - Get metadata used to describe accesses to objects of the 179 /// given type. 180 llvm::MDNode *getTypeInfo(QualType QTy); 181 182 /// getAccessInfo - Get TBAA information that describes an access to 183 /// an object of the given type. 184 TBAAAccessInfo getAccessInfo(QualType AccessType); 185 186 /// getVTablePtrAccessInfo - Get the TBAA information that describes an 187 /// access to a virtual table pointer. 188 TBAAAccessInfo getVTablePtrAccessInfo(llvm::Type *VTablePtrType); 189 190 /// getTBAAStructInfo - Get the TBAAStruct MDNode to be used for a memcpy of 191 /// the given type. 192 llvm::MDNode *getTBAAStructInfo(QualType QTy); 193 194 /// getBaseTypeInfo - Get metadata that describes the given base access 195 /// type. Return null if the type is not suitable for use in TBAA access 196 /// tags. 197 llvm::MDNode *getBaseTypeInfo(QualType QTy); 198 199 /// getAccessTagInfo - Get TBAA tag for a given memory access. 200 llvm::MDNode *getAccessTagInfo(TBAAAccessInfo Info); 201 202 /// mergeTBAAInfoForCast - Get merged TBAA information for the purpose of 203 /// type casts. 204 TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, 205 TBAAAccessInfo TargetInfo); 206 207 /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the 208 /// purpose of conditional operator. 209 TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, 210 TBAAAccessInfo InfoB); 211 212 /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the 213 /// purpose of memory transfer calls. 214 TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, 215 TBAAAccessInfo SrcInfo); 216 }; 217 218 } // end namespace CodeGen 219 } // end namespace clang 220 221 namespace llvm { 222 223 template<> struct DenseMapInfo<clang::CodeGen::TBAAAccessInfo> { 224 static clang::CodeGen::TBAAAccessInfo getEmptyKey() { 225 unsigned UnsignedKey = DenseMapInfo<unsigned>::getEmptyKey(); 226 return clang::CodeGen::TBAAAccessInfo( 227 static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), 228 DenseMapInfo<MDNode *>::getEmptyKey(), 229 DenseMapInfo<MDNode *>::getEmptyKey(), 230 DenseMapInfo<uint64_t>::getEmptyKey(), 231 DenseMapInfo<uint64_t>::getEmptyKey()); 232 } 233 234 static clang::CodeGen::TBAAAccessInfo getTombstoneKey() { 235 unsigned UnsignedKey = DenseMapInfo<unsigned>::getTombstoneKey(); 236 return clang::CodeGen::TBAAAccessInfo( 237 static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), 238 DenseMapInfo<MDNode *>::getTombstoneKey(), 239 DenseMapInfo<MDNode *>::getTombstoneKey(), 240 DenseMapInfo<uint64_t>::getTombstoneKey(), 241 DenseMapInfo<uint64_t>::getTombstoneKey()); 242 } 243 244 static unsigned getHashValue(const clang::CodeGen::TBAAAccessInfo &Val) { 245 auto KindValue = static_cast<unsigned>(Val.Kind); 246 return DenseMapInfo<unsigned>::getHashValue(KindValue) ^ 247 DenseMapInfo<MDNode *>::getHashValue(Val.BaseType) ^ 248 DenseMapInfo<MDNode *>::getHashValue(Val.AccessType) ^ 249 DenseMapInfo<uint64_t>::getHashValue(Val.Offset) ^ 250 DenseMapInfo<uint64_t>::getHashValue(Val.Size); 251 } 252 253 static bool isEqual(const clang::CodeGen::TBAAAccessInfo &LHS, 254 const clang::CodeGen::TBAAAccessInfo &RHS) { 255 return LHS == RHS; 256 } 257 }; 258 259 } // end namespace llvm 260 261 #endif 262