Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/lib/CodeGen/CodeGenTBAA.h
Line
Count
Source (jump to first uncovered line)
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 CGRecordLayout;
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
27.1M
  {}
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
20.4M
  {}
clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, llvm::MDNode*, unsigned long long, unsigned long long)
Line
Count
Source
53
20.4M
  {}
Unexecuted instantiation: clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, llvm::MDNode*, unsigned long long, unsigned long long)
54
55
  explicit TBAAAccessInfo(llvm::MDNode *AccessType, uint64_t Size)
56
    : TBAAAccessInfo(/* BaseType= */ nullptr, AccessType, /* Offset= */ 0, Size)
57
20.4M
  {}
clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, unsigned long long)
Line
Count
Source
57
20.4M
  {}
Unexecuted instantiation: clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo(llvm::MDNode*, unsigned long long)
58
59
  TBAAAccessInfo()
60
    : TBAAAccessInfo(/* AccessType= */ nullptr, /* Size= */ 0)
61
16.2M
  {}
clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo()
Line
Count
Source
61
16.2M
  {}
Unexecuted instantiation: clang::CodeGen::TBAAAccessInfo::TBAAAccessInfo()
62
63
130k
  static TBAAAccessInfo getMayAliasInfo() {
64
130k
    return TBAAAccessInfo(TBAAAccessKind::MayAlias,
65
130k
                          /* BaseType= */ nullptr, /* AccessType= */ nullptr,
66
130k
                          /* Offset= */ 0, /* Size= */ 0);
67
130k
  }
68
69
4.01M
  bool isMayAlias() const { return Kind == TBAAAccessKind::MayAlias; }
70
71
3.88k
  static TBAAAccessInfo getIncompleteInfo() {
72
3.88k
    return TBAAAccessInfo(TBAAAccessKind::Incomplete,
73
3.88k
                          /* BaseType= */ nullptr, /* AccessType= */ nullptr,
74
3.88k
                          /* Offset= */ 0, /* Size= */ 0);
75
3.88k
  }
76
77
0
  bool isIncomplete() const { return Kind == TBAAAccessKind::Incomplete; }
78
79
5.43M
  bool operator==(const TBAAAccessInfo &Other) const {
80
5.43M
    return Kind == Other.Kind &&
81
5.43M
           
BaseType == Other.BaseType4.19M
&&
82
5.43M
           
AccessType == Other.AccessType3.91M
&&
83
5.43M
           
Offset == Other.Offset3.79M
&&
84
5.43M
           
Size == Other.Size3.78M
;
85
5.43M
  }
86
87
24
  bool operator!=(const TBAAAccessInfo &Other) const {
88
24
    return !(*this == Other);
89
24
  }
90
91
24
  explicit operator bool() const {
92
24
    return *this != TBAAAccessInfo();
93
24
  }
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
  llvm::Module &Module;
120
  const CodeGenOptions &CodeGenOpts;
121
  const LangOptions &Features;
122
  MangleContext &MContext;
123
124
  // MDHelper - Helper for creating metadata.
125
  llvm::MDBuilder MDHelper;
126
127
  /// MetadataCache - This maps clang::Types to scalar llvm::MDNodes describing
128
  /// them.
129
  llvm::DenseMap<const Type *, llvm::MDNode *> MetadataCache;
130
  /// This maps clang::Types to a base access type in the type DAG.
131
  llvm::DenseMap<const Type *, llvm::MDNode *> BaseTypeMetadataCache;
132
  /// This maps TBAA access descriptors to tag nodes.
133
  llvm::DenseMap<TBAAAccessInfo, llvm::MDNode *> AccessTagMetadataCache;
134
135
  /// StructMetadataCache - This maps clang::Types to llvm::MDNodes describing
136
  /// them for struct assignments.
137
  llvm::DenseMap<const Type *, llvm::MDNode *> StructMetadataCache;
138
139
  llvm::MDNode *Root;
140
  llvm::MDNode *Char;
141
142
  /// getRoot - This is the mdnode for the root of the metadata type graph
143
  /// for this translation unit.
144
  llvm::MDNode *getRoot();
145
146
  /// getChar - This is the mdnode for "char", which is special, and any types
147
  /// considered to be equivalent to it.
148
  llvm::MDNode *getChar();
149
150
  /// CollectFields - Collect information about the fields of a type for
151
  /// !tbaa.struct metadata formation. Return false for an unsupported type.
152
  bool CollectFields(uint64_t BaseOffset,
153
                     QualType Ty,
154
                     SmallVectorImpl<llvm::MDBuilder::TBAAStructField> &Fields,
155
                     bool MayAlias);
156
157
  /// createScalarTypeNode - A wrapper function to create a metadata node
158
  /// describing a scalar type.
159
  llvm::MDNode *createScalarTypeNode(StringRef Name, llvm::MDNode *Parent,
160
                                     uint64_t Size);
161
162
  /// getTypeInfoHelper - An internal helper function to generate metadata used
163
  /// to describe accesses to objects of the given type.
164
  llvm::MDNode *getTypeInfoHelper(const Type *Ty);
165
166
  /// getBaseTypeInfoHelper - An internal helper function to generate metadata
167
  /// used to describe accesses to objects of the given base type.
168
  llvm::MDNode *getBaseTypeInfoHelper(const Type *Ty);
169
170
public:
171
  CodeGenTBAA(ASTContext &Ctx, llvm::Module &M, const CodeGenOptions &CGO,
172
              const LangOptions &Features, MangleContext &MContext);
173
  ~CodeGenTBAA();
174
175
  /// getTypeInfo - Get metadata used to describe accesses to objects of the
176
  /// given type.
177
  llvm::MDNode *getTypeInfo(QualType QTy);
178
179
  /// getAccessInfo - Get TBAA information that describes an access to
180
  /// an object of the given type.
181
  TBAAAccessInfo getAccessInfo(QualType AccessType);
182
183
  /// getVTablePtrAccessInfo - Get the TBAA information that describes an
184
  /// access to a virtual table pointer.
185
  TBAAAccessInfo getVTablePtrAccessInfo(llvm::Type *VTablePtrType);
186
187
  /// getTBAAStructInfo - Get the TBAAStruct MDNode to be used for a memcpy of
188
  /// the given type.
189
  llvm::MDNode *getTBAAStructInfo(QualType QTy);
190
191
  /// getBaseTypeInfo - Get metadata that describes the given base access type.
192
  /// Return null if the type is not suitable for use in TBAA access tags.
193
  llvm::MDNode *getBaseTypeInfo(QualType QTy);
194
195
  /// getAccessTagInfo - Get TBAA tag for a given memory access.
196
  llvm::MDNode *getAccessTagInfo(TBAAAccessInfo Info);
197
198
  /// mergeTBAAInfoForCast - Get merged TBAA information for the purpose of
199
  /// type casts.
200
  TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo,
201
                                      TBAAAccessInfo TargetInfo);
202
203
  /// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the
204
  /// purpose of conditional operator.
205
  TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA,
206
                                                     TBAAAccessInfo InfoB);
207
208
  /// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the
209
  /// purpose of memory transfer calls.
210
  TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo,
211
                                                TBAAAccessInfo SrcInfo);
212
};
213
214
}  // end namespace CodeGen
215
}  // end namespace clang
216
217
namespace llvm {
218
219
template<> struct DenseMapInfo<clang::CodeGen::TBAAAccessInfo> {
220
3.36M
  static clang::CodeGen::TBAAAccessInfo getEmptyKey() {
221
3.36M
    unsigned UnsignedKey = DenseMapInfo<unsigned>::getEmptyKey();
222
3.36M
    return clang::CodeGen::TBAAAccessInfo(
223
3.36M
      static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey),
224
3.36M
      DenseMapInfo<MDNode *>::getEmptyKey(),
225
3.36M
      DenseMapInfo<MDNode *>::getEmptyKey(),
226
3.36M
      DenseMapInfo<uint64_t>::getEmptyKey(),
227
3.36M
      DenseMapInfo<uint64_t>::getEmptyKey());
228
3.36M
  }
229
230
3.26M
  static clang::CodeGen::TBAAAccessInfo getTombstoneKey() {
231
3.26M
    unsigned UnsignedKey = DenseMapInfo<unsigned>::getTombstoneKey();
232
3.26M
    return clang::CodeGen::TBAAAccessInfo(
233
3.26M
      static_cast<clang::CodeGen::TBAAAccessKind>(UnsignedKey),
234
3.26M
      DenseMapInfo<MDNode *>::getTombstoneKey(),
235
3.26M
      DenseMapInfo<MDNode *>::getTombstoneKey(),
236
3.26M
      DenseMapInfo<uint64_t>::getTombstoneKey(),
237
3.26M
      DenseMapInfo<uint64_t>::getTombstoneKey());
238
3.26M
  }
239
240
3.25M
  static unsigned getHashValue(const clang::CodeGen::TBAAAccessInfo &Val) {
241
3.25M
    auto KindValue = static_cast<unsigned>(Val.Kind);
242
3.25M
    return DenseMapInfo<unsigned>::getHashValue(KindValue) ^
243
3.25M
           DenseMapInfo<MDNode *>::getHashValue(Val.BaseType) ^
244
3.25M
           DenseMapInfo<MDNode *>::getHashValue(Val.AccessType) ^
245
3.25M
           DenseMapInfo<uint64_t>::getHashValue(Val.Offset) ^
246
3.25M
           DenseMapInfo<uint64_t>::getHashValue(Val.Size);
247
3.25M
  }
248
249
  static bool isEqual(const clang::CodeGen::TBAAAccessInfo &LHS,
250
5.43M
                      const clang::CodeGen::TBAAAccessInfo &RHS) {
251
5.43M
    return LHS == RHS;
252
5.43M
  }
253
};
254
255
}  // end namespace llvm
256
257
#endif