LLVM 19.0.0git
Verifier.h
Go to the documentation of this file.
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
10// validation checking of input to the system, and for checking that
11// transformations 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
27namespace llvm {
28
29class APInt;
30class Function;
31class FunctionPass;
32class Instruction;
33class MDNode;
34class Module;
35class raw_ostream;
36struct VerifierSupport;
37
38/// Verify that the TBAA Metadatas are valid.
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>;
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
74public:
75 TBAAVerifier(VerifierSupport *Diagnostic = nullptr)
76 : 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);
81};
82
83/// Check a function for errors, useful for use when debugging a
84/// pass.
85///
86/// If there are no errors, the function returns false. If an error is found,
87/// a message describing the error is written to OS (if non-null) and true is
88/// returned.
89bool verifyFunction(const Function &F, raw_ostream *OS = nullptr);
90
91/// Check a module for errors.
92///
93/// If there are no errors, the function returns false. If an error is
94/// found, a message describing the error is written to OS (if
95/// non-null) and true is returned.
96///
97/// \return true if the module is broken. If BrokenDebugInfo is
98/// supplied, DebugInfo verification failures won't be considered as
99/// error and instead *BrokenDebugInfo will be set to true. Debug
100/// info errors can be "recovered" from by stripping the debug info.
101bool verifyModule(const Module &M, raw_ostream *OS = nullptr,
102 bool *BrokenDebugInfo = nullptr);
103
104FunctionPass *createVerifierPass(bool FatalErrors = true);
105
106/// Check a module for errors, and report separate error states for IR
107/// and debug info errors.
108class VerifierAnalysis : public AnalysisInfoMixin<VerifierAnalysis> {
110
111 static AnalysisKey Key;
112
113public:
114 struct Result {
116 };
117
120 static bool isRequired() { return true; }
121};
122
123/// Create a verifier pass.
124///
125/// Check a module or function for validity. This is essentially a pass wrapped
126/// around the above verifyFunction and verifyModule routines and
127/// functionality. When the pass detects a verification error it is always
128/// printed to stderr, and by default they are fatal. You can override that by
129/// passing \c false to \p FatalErrors.
130///
131/// Note that this creates a pass suitable for the legacy pass manager. It has
132/// nothing to do with \c VerifierPass.
133class VerifierPass : public PassInfoMixin<VerifierPass> {
134 bool FatalErrors;
135
136public:
137 explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
138
141 static bool isRequired() { return true; }
142};
143
144} // end namespace llvm
145
146#endif // LLVM_IR_VERIFIER_H
This file defines the DenseMap class.
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Machine Check Debug Module
This header defines various interfaces for pass management in LLVM.
raw_pwrite_stream & OS
Class for arbitrary precision integers.
Definition: APInt.h:76
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:321
Metadata node.
Definition: Metadata.h:1067
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
Verify that the TBAA Metadatas are valid.
Definition: Verifier.h:39
bool visitTBAAMetadata(Instruction &I, const MDNode *MD)
Visit an instruction and return true if it is valid, return false if an invalid TBAA is attached.
Definition: Verifier.cpp:7351
TBAAVerifier(VerifierSupport *Diagnostic=nullptr)
Definition: Verifier.h:75
bool visitTBAAStructMetadata(Instruction &I, const MDNode *MD)
Definition: Verifier.cpp:7459
Check a module for errors, and report separate error states for IR and debug info errors.
Definition: Verifier.h:108
static bool isRequired()
Definition: Verifier.h:120
Result run(Module &M, ModuleAnalysisManager &)
Definition: Verifier.cpp:7496
Create a verifier pass.
Definition: Verifier.h:133
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: Verifier.cpp:7508
static bool isRequired()
Definition: Verifier.h:141
VerifierPass(bool FatalErrors=true)
Definition: Verifier.h:137
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
bool verifyFunction(const Function &F, raw_ostream *OS=nullptr)
Check a function for errors, useful for use when debugging a pass.
Definition: Verifier.cpp:7036
FunctionPass * createVerifierPass(bool FatalErrors=true)
Definition: Verifier.cpp:7491
bool verifyModule(const Module &M, raw_ostream *OS=nullptr, bool *BrokenDebugInfo=nullptr)
Check a module for errors.
Definition: Verifier.cpp:7047
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:97
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:26
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:74