2014-01-13 10:26:24 +01:00
|
|
|
//===- Verifier.h - LLVM IR Verifier ----------------------------*- C++ -*-===//
|
2005-04-21 22:19:05 +02:00
|
|
|
//
|
2003-10-20 22:19:47 +02:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:59:42 +01:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 22:19:05 +02:00
|
|
|
//
|
2003-10-20 22:19:47 +02:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 22:29:01 +02:00
|
|
|
//
|
2002-04-14 08:14:15 +02:00
|
|
|
// This file defines the function verifier interface, that can be used for some
|
2002-08-31 00:51:08 +02:00
|
|
|
// sanity checking of input to the system, and for checking that transformations
|
|
|
|
// haven't done something bad.
|
2001-06-06 22:29:01 +02:00
|
|
|
//
|
|
|
|
// Note that this does not provide full 'java style' security and verifications,
|
|
|
|
// instead it just tries to ensure that code is well formed.
|
|
|
|
//
|
|
|
|
// To see what specifically is checked, look at the top of Verifier.cpp
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-01-13 10:26:24 +01:00
|
|
|
#ifndef LLVM_IR_VERIFIER_H
|
|
|
|
#define LLVM_IR_VERIFIER_H
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2016-02-26 12:44:45 +01:00
|
|
|
#include "llvm/IR/PassManager.h"
|
2006-07-06 20:00:01 +02:00
|
|
|
|
2003-11-11 23:41:34 +01:00
|
|
|
namespace llvm {
|
|
|
|
|
2014-01-20 12:34:08 +01:00
|
|
|
class Function;
|
2003-09-10 21:37:04 +02:00
|
|
|
class FunctionPass;
|
2014-04-15 18:27:38 +02:00
|
|
|
class ModulePass;
|
2001-06-06 22:29:01 +02:00
|
|
|
class Module;
|
2014-01-19 03:22:18 +01:00
|
|
|
class raw_ostream;
|
2004-04-02 17:44:33 +02:00
|
|
|
|
2014-01-13 11:52:56 +01:00
|
|
|
/// \brief Check a function for errors, useful for use when debugging a
|
|
|
|
/// pass.
|
2014-01-17 12:09:34 +01:00
|
|
|
///
|
|
|
|
/// If there are no errors, the function returns false. If an error is found,
|
2014-01-20 03:32:02 +01:00
|
|
|
/// a message describing the error is written to OS (if non-null) and true is
|
2014-01-19 03:22:18 +01:00
|
|
|
/// returned.
|
2014-04-09 08:08:46 +02:00
|
|
|
bool verifyFunction(const Function &F, raw_ostream *OS = nullptr);
|
2014-01-13 11:52:56 +01:00
|
|
|
|
2014-01-13 10:31:09 +01:00
|
|
|
/// \brief Check a module for errors.
|
2004-04-02 17:44:33 +02:00
|
|
|
///
|
2016-05-09 21:57:15 +02:00
|
|
|
/// 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.
|
|
|
|
///
|
|
|
|
/// \return true if the module is broken. If BrokenDebugInfo is
|
|
|
|
/// supplied, DebugInfo verification failures won't be considered as
|
|
|
|
/// error and instead *BrokenDebugInfo will be set to true. Debug
|
|
|
|
/// info errors can be "recovered" from by stripping the debug info.
|
|
|
|
bool verifyModule(const Module &M, raw_ostream *OS = nullptr,
|
|
|
|
bool *BrokenDebugInfo = nullptr);
|
2014-01-19 03:22:18 +01:00
|
|
|
|
2016-05-09 21:57:29 +02:00
|
|
|
FunctionPass *createVerifierPass(bool FatalErrors = true);
|
|
|
|
|
|
|
|
/// Check a module for errors, and report separate error states for IR
|
|
|
|
/// and debug info errors.
|
|
|
|
class VerifierAnalysis : public AnalysisInfoMixin<VerifierAnalysis> {
|
|
|
|
friend AnalysisInfoMixin<VerifierAnalysis>;
|
2016-11-23 18:53:26 +01:00
|
|
|
static AnalysisKey Key;
|
2016-05-09 21:57:29 +02:00
|
|
|
|
|
|
|
public:
|
|
|
|
struct Result {
|
|
|
|
bool IRBroken, DebugInfoBroken;
|
|
|
|
};
|
2016-06-17 02:11:01 +02:00
|
|
|
Result run(Module &M, ModuleAnalysisManager &);
|
|
|
|
Result run(Function &F, FunctionAnalysisManager &);
|
2016-05-09 21:57:29 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/// Check a module for errors, but report debug info errors separately.
|
|
|
|
/// Otherwise behaves as the normal verifyModule. Debug info errors can be
|
|
|
|
/// "recovered" from by stripping the debug info.
|
|
|
|
bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS);
|
|
|
|
|
2014-01-19 03:22:18 +01:00
|
|
|
/// \brief Create a verifier pass.
|
|
|
|
///
|
|
|
|
/// 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.
|
2014-01-20 12:34:08 +01:00
|
|
|
///
|
2014-04-15 18:27:38 +02:00
|
|
|
/// Note that this creates a pass suitable for the legacy pass manager. It has
|
|
|
|
/// nothing to do with \c VerifierPass.
|
2016-03-11 11:33:22 +01:00
|
|
|
class VerifierPass : public PassInfoMixin<VerifierPass> {
|
2014-01-20 12:34:08 +01:00
|
|
|
bool FatalErrors;
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
|
|
|
|
|
2016-05-09 21:57:29 +02:00
|
|
|
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
|
|
|
|
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
|
2014-01-20 12:34:08 +01:00
|
|
|
};
|
|
|
|
|
2016-05-09 21:57:29 +02:00
|
|
|
|
2015-06-23 11:49:53 +02:00
|
|
|
} // End llvm namespace
|
2003-11-11 23:41:34 +01:00
|
|
|
|
2001-06-06 22:29:01 +02:00
|
|
|
#endif
|