[opaque pointer type] Allow gep_type_iterator to work with the pointee type from...

[oota-llvm.git] / include / llvm / IR / Verifier.h

diff --git a/include/llvm/IR/Verifier.h b/include/llvm/IR/Verifier.h
index 77b1269c06da52a6ba9518113858f139659c2721..89039d24195eeacde8e7fb4f7179bff9136aac30 100644 (file)
--- a/include/llvm/IR/Verifier.h
+++ b/include/llvm/IR/Verifier.h
@@ -21,54 +21,56 @@
 #ifndef LLVM_IR_VERIFIER_H
 #define LLVM_IR_VERIFIER_H
 
+#include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace llvm {
 
+class Function;
 class FunctionPass;
+class ModulePass;
 class Module;
-class Function;
+class PreservedAnalyses;
+class raw_ostream;
 
-/// @brief An enumeration to specify the action to be taken if errors found.
+/// \brief Check a function for errors, useful for use when debugging a
+/// pass.
 ///
-/// This enumeration is used in the functions below to indicate what should
-/// happen if the verifier finds errors. Each of the functions that uses
-/// this enumeration as an argument provides a default value for it. The
-/// actions are listed below.
-enum VerifierFailureAction {
-  AbortProcessAction,   ///< verifyModule will print to stderr and abort()
-  PrintMessageAction,   ///< verifyModule will print to stderr and return true
-  ReturnStatusAction    ///< verifyModule will just return true
-};
+/// If there are no errors, the function returns false. If an error is found,
+/// a message describing the error is written to OS (if non-null) and true is
+/// returned.
+bool verifyFunction(const Function &F, raw_ostream *OS = nullptr);
 
-/// @brief Create a verifier pass.
+/// \brief Check a module for errors.
 ///
-/// Check a module or function for validity.  When the pass is used, the
-/// action indicated by the \p action argument will be used if errors are
-/// found.
-FunctionPass *createVerifierPass(
-  VerifierFailureAction action = AbortProcessAction ///< Action to take
-);
+/// If there are no errors, the function returns false. If an error is found,
+/// a message describing the error is written to OS (if non-null) and true is
+/// returned.
+bool verifyModule(const Module &M, raw_ostream *OS = nullptr);
 
-/// @brief Check a module for errors.
+/// \brief Create a verifier pass.
 ///
-/// If there are no errors, the function returns false. If an error is found,
-/// the action taken depends on the \p action parameter.
-/// This should only be used for debugging, because it plays games with
-/// PassManagers and stuff.
+/// Check a module or function for validity. This is essentially a pass wrapped
+/// around the above verifyFunction and verifyModule routines and
+/// functionality. When the pass detects a verification error it is always
+/// printed to stderr, and by default they are fatal. You can override that by
+/// passing \c false to \p FatalErrors.
+///
+/// Note that this creates a pass suitable for the legacy pass manager. It has
+/// nothing to do with \c VerifierPass.
+FunctionPass *createVerifierPass(bool FatalErrors = true);
+
+class VerifierPass {
+  bool FatalErrors;
 
-bool verifyModule(
-  const Module &M,  ///< The module to be verified
-  VerifierFailureAction action = AbortProcessAction, ///< Action to take
-  std::string *ErrorInfo = 0      ///< Information about failures.
-);
+public:
+  explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
 
-// verifyFunction - Check a function for errors, useful for use when debugging a
-// pass.
-bool verifyFunction(
-  const Function &F,  ///< The function to be verified
-  VerifierFailureAction action = AbortProcessAction ///< Action to take
-);
+  PreservedAnalyses run(Module &M);
+  PreservedAnalyses run(Function &F);
+
+  static StringRef name() { return "VerifierPass"; }
+};
 
 } // End llvm namespace