Line data    Source code

       1              : /* Unit tests for GIMPLE range related routines.
       2              :    Copyright (C) 2021-2026 Free Software Foundation, Inc.
       3              : 
       4              : This file is part of GCC.
       5              : 
       6              : GCC is free software; you can redistribute it and/or modify
       7              : it under the terms of the GNU General Public License as published by
       8              : the Free Software Foundation; either version 3, or (at your option)
       9              : any later version.
      10              : 
      11              : GCC is distributed in the hope that it will be useful,
      12              : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13              : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14              : GNU General Public License for more details.
      15              : 
      16              : You should have received a copy of the GNU General Public License
      17              : along with GCC; see the file COPYING3.  If not see
      18              : <http://www.gnu.org/licenses/>.  */
      19              : 
      20              : #if CHECKING_P
      21              : 
      22              : #include "selftest.h"
      23              : 
      24              : namespace selftest {
      25              : 
      26              : // Test ranges of tree expressions.
      27            8 : class test_expr_eval : public gimple_ranger
      28              : {
      29              : public:
      30            4 :   test_expr_eval ()
      31            4 :   {
      32            4 :     type = integer_type_node;
      33            4 :     op0 = make_ssa_name (type);
      34            4 :     op1 = make_ssa_name (type);
      35              : 
      36              :     // [5,10] + [15,20] => [20, 30]
      37            4 :     tree expr = fold_build2 (PLUS_EXPR, type, op0, op1);
      38            4 :     int_range<1> expect (type,
      39            8 :                          wi::shwi (20, TYPE_PRECISION (type)),
      40            8 :                          wi::shwi (30, TYPE_PRECISION (type)));
      41            4 :     int_range_max r;
      42              : 
      43            4 :     ASSERT_TRUE (range_of_expr (r, expr));
      44            4 :     ASSERT_TRUE (r == expect);
      45            4 :   }
      46              : 
      47           12 :   virtual bool range_of_expr (vrange &v, tree expr, gimple * = NULL) override
      48              :   {
      49           12 :     irange &r = as_a <irange> (v);
      50           12 :     unsigned prec = TYPE_PRECISION (type);
      51           12 :     if (expr == op0)
      52              :       {
      53            4 :         r.set (type, wi::shwi (5, prec), wi::shwi (10, prec));
      54            4 :         return true;
      55              :       }
      56            8 :     if (expr == op1)
      57              :       {
      58            4 :         r.set (type, wi::shwi (15, prec), wi::shwi (20, prec));
      59            4 :         return true;
      60              :       }
      61            4 :     return gimple_ranger::range_of_expr (r, expr);
      62              :   }
      63              : 
      64              : private:
      65              :   tree op0, op1, type;
      66              : };
      67              : 
      68              : void
      69            4 : gimple_range_tests ()
      70              : {
      71            4 :   test_expr_eval e;
      72            4 : }
      73              : 
      74              : } // namespace selftest
      75              : 
      76              : #endif // CHECKING_P