1 //===--- CodeGenTBAA.h - TBAA information for LLVM CodeGen ------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This is the code that manages TBAA information and defines the TBAA policy
11 // for the optimizer to use.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENTBAA_H
16 #define LLVM_CLANG_LIB_CODEGEN_CODEGENTBAA_H
18 #include "clang/AST/Type.h"
19 #include "clang/Basic/LLVM.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/IR/MDBuilder.h"
22 #include "llvm/IR/Metadata.h"
36 TBAAPathTag(const Type *B, const llvm::MDNode *A, uint64_t O)
37 : BaseT(B), AccessN(A), Offset(O) {}
39 const llvm::MDNode *AccessN;
43 /// CodeGenTBAA - This class organizes the cross-module state that is used
44 /// while lowering AST types to LLVM types.
47 const CodeGenOptions &CodeGenOpts;
48 const LangOptions &Features;
49 MangleContext &MContext;
51 // MDHelper - Helper for creating metadata.
52 llvm::MDBuilder MDHelper;
54 /// MetadataCache - This maps clang::Types to scalar llvm::MDNodes describing
56 llvm::DenseMap<const Type *, llvm::MDNode *> MetadataCache;
57 /// This maps clang::Types to a struct node in the type DAG.
58 llvm::DenseMap<const Type *, llvm::MDNode *> StructTypeMetadataCache;
59 /// This maps TBAAPathTags to a tag node.
60 llvm::DenseMap<TBAAPathTag, llvm::MDNode *> StructTagMetadataCache;
61 /// This maps a scalar type to a scalar tag node.
62 llvm::DenseMap<const llvm::MDNode *, llvm::MDNode *> ScalarTagMetadataCache;
64 /// StructMetadataCache - This maps clang::Types to llvm::MDNodes describing
65 /// them for struct assignments.
66 llvm::DenseMap<const Type *, llvm::MDNode *> StructMetadataCache;
71 /// getRoot - This is the mdnode for the root of the metadata type graph
72 /// for this translation unit.
73 llvm::MDNode *getRoot();
75 /// getChar - This is the mdnode for "char", which is special, and any types
76 /// considered to be equivalent to it.
77 llvm::MDNode *getChar();
79 /// CollectFields - Collect information about the fields of a type for
80 /// !tbaa.struct metadata formation. Return false for an unsupported type.
81 bool CollectFields(uint64_t BaseOffset,
83 SmallVectorImpl<llvm::MDBuilder::TBAAStructField> &Fields,
86 /// A wrapper function to create a scalar type. For struct-path aware TBAA,
87 /// the scalar type has the same format as the struct type: name, offset,
88 /// pointer to another node in the type DAG.
89 llvm::MDNode *createTBAAScalarType(StringRef Name, llvm::MDNode *Parent);
92 CodeGenTBAA(ASTContext &Ctx, llvm::LLVMContext &VMContext,
93 const CodeGenOptions &CGO,
94 const LangOptions &Features,
95 MangleContext &MContext);
98 /// getTBAAInfo - Get the TBAA MDNode to be used for a dereference
99 /// of the given type.
100 llvm::MDNode *getTBAAInfo(QualType QTy);
102 /// getTBAAInfoForVTablePtr - Get the TBAA MDNode to be used for a
103 /// dereference of a vtable pointer.
104 llvm::MDNode *getTBAAInfoForVTablePtr();
106 /// getTBAAStructInfo - Get the TBAAStruct MDNode to be used for a memcpy of
108 llvm::MDNode *getTBAAStructInfo(QualType QTy);
110 /// Get the MDNode in the type DAG for given struct type QType.
111 llvm::MDNode *getTBAAStructTypeInfo(QualType QType);
112 /// Get the tag MDNode for a given base type, the actual scalar access MDNode
113 /// and offset into the base type.
114 llvm::MDNode *getTBAAStructTagInfo(QualType BaseQType,
115 llvm::MDNode *AccessNode, uint64_t Offset);
117 /// Get the scalar tag MDNode for a given scalar type.
118 llvm::MDNode *getTBAAScalarTagInfo(llvm::MDNode *AccessNode);
121 } // end namespace CodeGen
122 } // end namespace clang
126 template<> struct DenseMapInfo<clang::CodeGen::TBAAPathTag> {
127 static clang::CodeGen::TBAAPathTag getEmptyKey() {
128 return clang::CodeGen::TBAAPathTag(
129 DenseMapInfo<const clang::Type *>::getEmptyKey(),
130 DenseMapInfo<const MDNode *>::getEmptyKey(),
131 DenseMapInfo<uint64_t>::getEmptyKey());
134 static clang::CodeGen::TBAAPathTag getTombstoneKey() {
135 return clang::CodeGen::TBAAPathTag(
136 DenseMapInfo<const clang::Type *>::getTombstoneKey(),
137 DenseMapInfo<const MDNode *>::getTombstoneKey(),
138 DenseMapInfo<uint64_t>::getTombstoneKey());
141 static unsigned getHashValue(const clang::CodeGen::TBAAPathTag &Val) {
142 return DenseMapInfo<const clang::Type *>::getHashValue(Val.BaseT) ^
143 DenseMapInfo<const MDNode *>::getHashValue(Val.AccessN) ^
144 DenseMapInfo<uint64_t>::getHashValue(Val.Offset);
147 static bool isEqual(const clang::CodeGen::TBAAPathTag &LHS,
148 const clang::CodeGen::TBAAPathTag &RHS) {
149 return LHS.BaseT == RHS.BaseT &&
150 LHS.AccessN == RHS.AccessN &&
151 LHS.Offset == RHS.Offset;
155 } // end namespace llvm