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