clang/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
  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