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: 2018-06-17 00:07:59 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       98929 : 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, bool IsNewFormat);
      65             :   TBAAVerifier::TBAABaseNodeSummary verifyTBAABaseNode(Instruction &I,
      66             :                                                        const MDNode *BaseNode,
      67             :                                                        bool IsNewFormat);
      68             :   TBAABaseNodeSummary verifyTBAABaseNodeImpl(Instruction &I,
      69             :                                              const MDNode *BaseNode,
      70             :                                              bool IsNewFormat);
      71             : 
      72             :   bool isValidScalarTBAANode(const MDNode *MD);
      73             :   /// @}
      74             : 
      75             : public:
      76             :   TBAAVerifier(VerifierSupport *Diagnostic = nullptr)
      77      198400 :       : Diagnostic(Diagnostic) {}
      78             :   /// Visit an instruction and return true if it is valid, return false if an
      79             :   /// invalid TBAA is attached.
      80             :   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.
      89             : bool 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.
     101             : bool verifyModule(const Module &M, raw_ostream *OS = nullptr,
     102             :                   bool *BrokenDebugInfo = nullptr);
     103             : 
     104             : FunctionPass *createVerifierPass(bool FatalErrors = true);
     105             : 
     106             : /// Check a module for errors, and report separate error states for IR
     107             : /// and debug info errors.
     108             : class VerifierAnalysis : public AnalysisInfoMixin<VerifierAnalysis> {
     109             :   friend AnalysisInfoMixin<VerifierAnalysis>;
     110             : 
     111             :   static AnalysisKey Key;
     112             : 
     113             : public:
     114             :   struct Result {
     115             :     bool IRBroken, DebugInfoBroken;
     116             :   };
     117             : 
     118             :   Result run(Module &M, ModuleAnalysisManager &);
     119             :   Result run(Function &F, FunctionAnalysisManager &);
     120             : };
     121             : 
     122             : /// Check a module for errors, but report debug info errors separately.
     123             : /// Otherwise behaves as the normal verifyModule. Debug info errors can be
     124             : /// "recovered" from by stripping the debug info.
     125             : bool verifyModule(bool &BrokenDebugInfo, const Module &M, raw_ostream *OS);
     126             : 
     127             : /// Create a verifier pass.
     128             : ///
     129             : /// Check a module or function for validity. This is essentially a pass wrapped
     130             : /// around the above verifyFunction and verifyModule routines and
     131             : /// functionality. When the pass detects a verification error it is always
     132             : /// printed to stderr, and by default they are fatal. You can override that by
     133             : /// passing \c false to \p FatalErrors.
     134             : ///
     135             : /// Note that this creates a pass suitable for the legacy pass manager. It has
     136             : /// nothing to do with \c VerifierPass.
     137             : class VerifierPass : public PassInfoMixin<VerifierPass> {
     138             :   bool FatalErrors;
     139             : 
     140             : public:
     141        1658 :   explicit VerifierPass(bool FatalErrors = true) : FatalErrors(FatalErrors) {}
     142             : 
     143             :   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
     144             :   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
     145             : };
     146             : 
     147             : } // end namespace llvm
     148             : 
     149             : #endif // LLVM_IR_VERIFIER_H

Generated by: LCOV version 1.13