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 CodeGenTypes; 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 CodeGenTypes &CGTypes; 120 llvm::Module &Module; 121 const CodeGenOptions &CodeGenOpts; 122 const LangOptions &Features; 123 std::unique_ptr<MangleContext> MangleCtx; 124 125 // MDHelper - Helper for creating metadata. 126 llvm::MDBuilder MDHelper; 127 128 /// MetadataCache - This maps clang::Types to scalar llvm::MDNodes describing 129 /// them. 130 llvm::DenseMap<const Type *, llvm::MDNode *> MetadataCache; 131 /// This maps clang::Types to a base access type in the type DAG. 132 llvm::DenseMap<const Type *, llvm::MDNode *> BaseTypeMetadataCache; 133 /// This maps TBAA access descriptors to tag nodes. 134 llvm::DenseMap<TBAAAccessInfo, llvm::MDNode *> AccessTagMetadataCache; 135 136 /// StructMetadataCache - This maps clang::Types to llvm::MDNodes describing 137 /// them for struct assignments. 138 llvm::DenseMap<const Type *, llvm::MDNode *> StructMetadataCache; 139 140 llvm::MDNode *Root; 141 llvm::MDNode *Char; 142 143 /// getRoot - This is the mdnode for the root of the metadata type graph 144 /// for this translation unit. 145 llvm::MDNode *getRoot(); 146 147 /// getChar - This is the mdnode for "char", which is special, and any types 148 /// considered to be equivalent to it. 149 llvm::MDNode *getChar(); 150 151 /// CollectFields - Collect information about the fields of a type for 152 /// !tbaa.struct metadata formation. Return false for an unsupported type. 153 bool CollectFields(uint64_t BaseOffset, 154 QualType Ty, 155 SmallVectorImpl<llvm::MDBuilder::TBAAStructField> &Fields, 156 bool MayAlias); 157 158 /// createScalarTypeNode - A wrapper function to create a metadata node 159 /// describing a scalar type. 160 llvm::MDNode *createScalarTypeNode(StringRef Name, llvm::MDNode *Parent, 161 uint64_t Size); 162 163 /// getTypeInfoHelper - An internal helper function to generate metadata used 164 /// to describe accesses to objects of the given type. 165 llvm::MDNode *getTypeInfoHelper(const Type *Ty); 166 167 /// getBaseTypeInfoHelper - An internal helper function to generate metadata 168 /// used to describe accesses to objects of the given base type. 169 llvm::MDNode *getBaseTypeInfoHelper(const Type *Ty); 170 171 /// getValidBaseTypeInfo - Return metadata that describes the given base 172 /// access type. The type must be suitable. 173 llvm::MDNode *getValidBaseTypeInfo(QualType QTy); 174 175 public: 176 CodeGenTBAA(ASTContext &Ctx, CodeGenTypes &CGTypes, llvm::Module &M, 177 const CodeGenOptions &CGO, const LangOptions &Features); 178 ~CodeGenTBAA(); 179 180 /// getTypeInfo - Get metadata used to describe accesses to objects of the 181 /// given type. 182 llvm::MDNode *getTypeInfo(QualType QTy); 183 184 /// getAccessInfo - Get TBAA information that describes an access to 185 /// an object of the given type. 186 TBAAAccessInfo getAccessInfo(QualType AccessType); 187 188 /// getVTablePtrAccessInfo - Get the TBAA information that describes an 189 /// access to a virtual table pointer. 190 TBAAAccessInfo getVTablePtrAccessInfo(llvm::Type *VTablePtrType); 191 192 /// getTBAAStructInfo - Get the TBAAStruct MDNode to be used for a memcpy of 193 /// the given type. 194 llvm::MDNode *getTBAAStructInfo(QualType QTy); 195 196 /// getBaseTypeInfo - Get metadata that describes the given base access 197 /// type. Return null if the type is not suitable for use in TBAA access 198 /// tags. 199 llvm::MDNode *getBaseTypeInfo(QualType QTy); 200 201 /// getAccessTagInfo - Get TBAA tag for a given memory access. 202 llvm::MDNode *getAccessTagInfo(TBAAAccessInfo Info); 203 204 /// mergeTBAAInfoForCast - Get merged TBAA information for the purpose of 205 /// type casts. 206 TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, 207 TBAAAccessInfo TargetInfo); 208 209 /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the 210 /// purpose of conditional operator. 211 TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, 212 TBAAAccessInfo InfoB); 213 214 /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the 215 /// purpose of memory transfer calls. 216 TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, 217 TBAAAccessInfo SrcInfo); 218 }; 219 220 } // end namespace CodeGen 221 } // end namespace clang 222 223 namespace llvm { 224 225 template<> struct DenseMapInfo<clang::CodeGen::TBAAAccessInfo> { 226 static clang::CodeGen::TBAAAccessInfo getEmptyKey() { 227 unsigned UnsignedKey = DenseMapInfo<unsigned>::getEmptyKey(); 228 return clang::CodeGen::TBAAAccessInfo( 229 static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), 230 DenseMapInfo<MDNode *>::getEmptyKey(), 231 DenseMapInfo<MDNode *>::getEmptyKey(), 232 DenseMapInfo<uint64_t>::getEmptyKey(), 233 DenseMapInfo<uint64_t>::getEmptyKey()); 234 } 235 236 static clang::CodeGen::TBAAAccessInfo getTombstoneKey() { 237 unsigned UnsignedKey = DenseMapInfo<unsigned>::getTombstoneKey(); 238 return clang::CodeGen::TBAAAccessInfo( 239 static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey), 240 DenseMapInfo<MDNode *>::getTombstoneKey(), 241 DenseMapInfo<MDNode *>::getTombstoneKey(), 242 DenseMapInfo<uint64_t>::getTombstoneKey(), 243 DenseMapInfo<uint64_t>::getTombstoneKey()); 244 } 245 246 static unsigned getHashValue(const clang::CodeGen::TBAAAccessInfo &Val) { 247 auto KindValue = static_cast<unsigned>(Val.Kind); 248 return DenseMapInfo<unsigned>::getHashValue(KindValue) ^ 249 DenseMapInfo<MDNode *>::getHashValue(Val.BaseType) ^ 250 DenseMapInfo<MDNode *>::getHashValue(Val.AccessType) ^ 251 DenseMapInfo<uint64_t>::getHashValue(Val.Offset) ^ 252 DenseMapInfo<uint64_t>::getHashValue(Val.Size); 253 } 254 255 static bool isEqual(const clang::CodeGen::TBAAAccessInfo &LHS, 256 const clang::CodeGen::TBAAAccessInfo &RHS) { 257 return LHS == RHS; 258 } 259 }; 260 261 } // end namespace llvm 262 263 #endif 264