LCOV - code coverage report
Current view: top level - include/llvm/IR - Verifier.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 3 3 100.0 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       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      238050 : 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      238824 :       : 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        1340 :   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

Generated by: LCOV version 1.13