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(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 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