LCOV - code coverage report
Current view: top level - gcc/analyzer - sm-pattern-test.cc (source / functions) Hit Total Coverage
Test: gcc.info Lines: 26 26 100.0 %
Date: 2020-03-28 11:57:23 Functions: 9 9 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* A state machine for use in DejaGnu tests, to check that
       2                 :            :    pattern-matching works as expected.
       3                 :            : 
       4                 :            :    Copyright (C) 2019-2020 Free Software Foundation, Inc.
       5                 :            :    Contributed by David Malcolm <dmalcolm@redhat.com>.
       6                 :            : 
       7                 :            : This file is part of GCC.
       8                 :            : 
       9                 :            : GCC is free software; you can redistribute it and/or modify it
      10                 :            : under the terms of the GNU General Public License as published by
      11                 :            : the Free Software Foundation; either version 3, or (at your option)
      12                 :            : any later version.
      13                 :            : 
      14                 :            : GCC is distributed in the hope that it will be useful, but
      15                 :            : WITHOUT ANY WARRANTY; without even the implied warranty of
      16                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      17                 :            : General Public License for more details.
      18                 :            : 
      19                 :            : You should have received a copy of the GNU General Public License
      20                 :            : along with GCC; see the file COPYING3.  If not see
      21                 :            : <http://www.gnu.org/licenses/>.  */
      22                 :            : 
      23                 :            : #include "config.h"
      24                 :            : #include "system.h"
      25                 :            : #include "coretypes.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "function.h"
      28                 :            : #include "basic-block.h"
      29                 :            : #include "gimple.h"
      30                 :            : #include "tree-pretty-print.h"
      31                 :            : #include "diagnostic-path.h"
      32                 :            : #include "diagnostic-metadata.h"
      33                 :            : #include "function.h"
      34                 :            : #include "analyzer/analyzer.h"
      35                 :            : #include "diagnostic-event-id.h"
      36                 :            : #include "analyzer/analyzer-logging.h"
      37                 :            : #include "analyzer/sm.h"
      38                 :            : #include "analyzer/pending-diagnostic.h"
      39                 :            : 
      40                 :            : #if ENABLE_ANALYZER
      41                 :            : 
      42                 :            : namespace ana {
      43                 :            : 
      44                 :            : namespace {
      45                 :            : 
      46                 :            : /* A state machine for use in DejaGnu tests, to check that
      47                 :            :    pattern-matching works as expected.  */
      48                 :            : 
      49                 :            : class pattern_test_state_machine : public state_machine
      50                 :            : {
      51                 :            : public:
      52                 :            :   pattern_test_state_machine (logger *logger);
      53                 :            : 
      54                 :         16 :   bool inherited_state_p () const FINAL OVERRIDE { return false; }
      55                 :            : 
      56                 :            :   bool on_stmt (sm_context *sm_ctxt,
      57                 :            :                 const supernode *node,
      58                 :            :                 const gimple *stmt) const FINAL OVERRIDE;
      59                 :            : 
      60                 :            :   void on_condition (sm_context *sm_ctxt,
      61                 :            :                      const supernode *node,
      62                 :            :                      const gimple *stmt,
      63                 :            :                      tree lhs,
      64                 :            :                      enum tree_code op,
      65                 :            :                      tree rhs) const FINAL OVERRIDE;
      66                 :            : 
      67                 :            :   bool can_purge_p (state_t s) const FINAL OVERRIDE;
      68                 :            : 
      69                 :            : private:
      70                 :            :   state_t m_start;
      71                 :            : };
      72                 :            : 
      73                 :            : class pattern_match : public pending_diagnostic_subclass<pattern_match>
      74                 :            : {
      75                 :            : public:
      76                 :         20 :   pattern_match (tree lhs, enum tree_code op, tree rhs)
      77                 :         20 :   : m_lhs (lhs), m_op (op), m_rhs (rhs) {}
      78                 :            : 
      79                 :         96 :   const char *get_kind () const FINAL OVERRIDE { return "pattern_match"; }
      80                 :            : 
      81                 :         38 :   bool operator== (const pattern_match &other) const
      82                 :            :   {
      83                 :         38 :     return (same_tree_p (m_lhs, other.m_lhs)
      84                 :         38 :             && m_op == other.m_op
      85                 :         58 :             && same_tree_p (m_rhs, other.m_rhs));
      86                 :            :   }
      87                 :            : 
      88                 :         20 :   bool emit (rich_location *rich_loc) FINAL OVERRIDE
      89                 :            :   {
      90                 :         20 :     return warning_at (rich_loc, 0, "pattern match on %<%E %s %E%>",
      91                 :         20 :                        m_lhs, op_symbol_code (m_op), m_rhs);
      92                 :            :   }
      93                 :            : 
      94                 :            : private:
      95                 :            :   tree m_lhs;
      96                 :            :   enum tree_code m_op;
      97                 :            :   tree m_rhs;
      98                 :            : };
      99                 :            : 
     100                 :          6 : pattern_test_state_machine::pattern_test_state_machine (logger *logger)
     101                 :          6 : : state_machine ("pattern-test", logger)
     102                 :            : {
     103                 :          6 :   m_start = add_state ("start");
     104                 :          6 : }
     105                 :            : 
     106                 :            : bool
     107                 :         26 : pattern_test_state_machine::on_stmt (sm_context *sm_ctxt ATTRIBUTE_UNUSED,
     108                 :            :                                      const supernode *node ATTRIBUTE_UNUSED,
     109                 :            :                                      const gimple *stmt ATTRIBUTE_UNUSED) const
     110                 :            : {
     111                 :         26 :   return false;
     112                 :            : }
     113                 :            : 
     114                 :            : /* Implementation of state_machine::on_condition vfunc for
     115                 :            :    pattern_test_state_machine.
     116                 :            : 
     117                 :            :    Queue a pattern_match diagnostic for any comparison against a
     118                 :            :    constant.  */
     119                 :            : 
     120                 :            : void
     121                 :         20 : pattern_test_state_machine::on_condition (sm_context *sm_ctxt,
     122                 :            :                                           const supernode *node,
     123                 :            :                                           const gimple *stmt,
     124                 :            :                                           tree lhs,
     125                 :            :                                           enum tree_code op,
     126                 :            :                                           tree rhs) const
     127                 :            : {
     128                 :         20 :   if (stmt == NULL)
     129                 :            :     return;
     130                 :            : 
     131                 :         20 :   if (!CONSTANT_CLASS_P (rhs))
     132                 :            :     return;
     133                 :            : 
     134                 :         20 :   pending_diagnostic *diag = new pattern_match (lhs, op, rhs);
     135                 :         20 :   sm_ctxt->warn_for_state (node, stmt, lhs, m_start, diag);
     136                 :            : }
     137                 :            : 
     138                 :            : bool
     139                 :         33 : pattern_test_state_machine::can_purge_p (state_t s ATTRIBUTE_UNUSED) const
     140                 :            : {
     141                 :         33 :   return true;
     142                 :            : }
     143                 :            : 
     144                 :            : } // anonymous namespace
     145                 :            : 
     146                 :            : /* Internal interface to this file. */
     147                 :            : 
     148                 :            : state_machine *
     149                 :          6 : make_pattern_test_state_machine (logger *logger)
     150                 :            : {
     151                 :          6 :   return new pattern_test_state_machine (logger);
     152                 :            : }
     153                 :            : 
     154                 :            : } // namespace ana
     155                 :            : 
     156                 :            : #endif /* #if ENABLE_ANALYZER */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.