Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/IR/Verifier.h
Line
Count
Source
1
//===- Verifier.h - LLVM IR Verifier ----------------------------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file defines the function verifier interface, that can be used for some
11
// sanity checking of input to the system, and for checking that transformations
12
// haven't done something bad.
13
//
14
// Note that this does not provide full 'java style' security and verifications,
15
// instead it just tries to ensure that code is well formed.
16
//
17
// To see what specifically is checked, look at the top of Verifier.cpp
18
//
19
//===----------------------------------------------------------------------===//
20
21
#ifndef LLVM_IR_VERIFIER_H
22
#define LLVM_IR_VERIFIER_H
23
24
#include "llvm/ADT/DenseMap.h"
25
#include "llvm/IR/PassManager.h"
26
#include <utility>
27
28
namespace llvm {
29
30
class APInt;
31
class Function;
32
class FunctionPass;
33
class Instruction;
34
class MDNode;
35
class Module;
36
class raw_ostream;
37
struct VerifierSupport;
38
39
/// Verify that the TBAA Metadatas are valid.
40
class TBAAVerifier {
41
  VerifierSupport *Diagnostic = nullptr;
42
43
  /// Helper to diagnose a failure
44
  template <typename... Tys> void CheckFailed(Tys &&... Args);
45
46
  /// Cache of TBAA base nodes that have already been visited.  This cachce maps
47
  /// a node that has been visited to a pair (IsInvalid, BitWidth) where
48
  ///
49
  ///  \c IsInvalid is true iff the node is invalid.
50
  ///  \c BitWidth, if non-zero, is the bitwidth of the integer used to denoting
51
  ///    the offset of the access.  If zero, only a zero offset is allowed.
52
  ///
53
  /// \c BitWidth has no meaning if \c IsInvalid is true.
54
  using TBAABaseNodeSummary = std::pair<bool, unsigned>;
55
  DenseMap<const MDNode *, TBAABaseNodeSummary> TBAABaseNodes;
56
57
  /// Maps an alleged scalar TBAA node to a boolean that is true if the said
58
  /// TBAA node is a valid scalar TBAA node or false otherwise.
59
  DenseMap<const MDNode *, bool> TBAAScalarNodes;
60
61
  /// \name Helper functions used by \c visitTBAAMetadata.
62
  /// @{
63
  MDNode *getFieldNodeFromTBAABaseNode(Instruction &I, const MDNode *BaseNode,
64
                                       APInt &Offset);
65
  TBAAVerifier::TBAABaseNodeSummary verifyTBAABaseNode(Instruction &I,
66
                                                       const MDNode *BaseNode);
67
  TBAABaseNodeSummary verifyTBAABaseNodeImpl(Instruction &I,
68
                                             const MDNode *BaseNode);
69
70
  bool isValidScalarTBAANode(const MDNode *MD);
71
  /// @}
72
73
public:
74
  TBAAVerifier(VerifierSupport *Diagnostic = nullptr)
75
85.8k
      : Diagnostic(Diagnostic) {}
76
  /// Visit an instruction and return true if it is valid, return false if an
77
  /// invalid TBAA is attached.
78
  bool visitTBAAMetadata(Instruction &I, const MDNode *MD);
79
};
80
81
/// \brief Check a function for errors, useful for use when debugging a
82
/// pass.
83
///
84
/// If there are no errors, the function returns false. If an error is found,
85
/// a message describing the error is written to OS (if non-null) and true is
86
/// returned.
87
bool verifyFunction(const Function &F, raw_ostream *OS = nullptr);
88
89
/// \brief Check a module for errors.
90
///
91
/// If there are no errors, the function returns false. If an error is
92
/// found, a message describing the error is written to OS (if
93
/// non-null) and true is returned.
94
///
95
/// \return true if the module is broken. If BrokenDebugInfo is
96
/// supplied, DebugInfo verification failures won't be considered as
97
/// error and instead *BrokenDebugInfo will be set to true. Debug
98
/// info errors can be "recovered" from by stripping the debug info.
99
bool verifyModule(const Module &M, raw_ostream *OS = nullptr,
100
                  bool *BrokenDebugInfo = nullptr);
101
102
FunctionPass *createVerifierPass(bool FatalErrors = true);
103
104
/// Check a module for errors, and report separate error states for IR
105
/// and debug info errors.
106
class VerifierAnalysis : public AnalysisInfoMixin<VerifierAnalysis> {
107
  friend AnalysisInfoMixin<VerifierAnalysis>;
108
109
  static AnalysisKey Key;
110
111
public:
112
  struct Result {
113
    bool IRBroken, DebugInfoBroken;
114
  };
115
116
  Result run(Module &M, ModuleAnalysisManager &);
117
  Result run(Function &F, FunctionAnalysisManager &);
118
};
119
120
/// Check a module for errors, but report debug info errors separately.
121
/// Otherwise behaves as the normal verifyModule. Debug info errors can be
122
/// "recovered" from by stripping the debug info.
123
bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS);
124
125
/// \brief Create a verifier pass.
126
///
127
/// Check a module or function for validity. This is essentially a pass wrapped
128
/// around the above verifyFunction and verifyModule routines and
129
/// functionality. When the pass detects a verification error it is always
130
/// printed to stderr, and by default they are fatal. You can override that by
131
/// passing \c false to \p FatalErrors.
132
///
133
/// Note that this creates a pass suitable for the legacy pass manager. It has
134
/// nothing to do with \c VerifierPass.
135
class VerifierPass : public PassInfoMixin<VerifierPass> {
136
  bool FatalErrors;
137
138
public:
139
1.34k
  explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
140
141
  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
142
  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
143
};
144
145
} // end namespace llvm
146
147
#endif // LLVM_IR_VERIFIER_H