Line data    Source code

       1              : /* A class for building vector integer constants.
       2              :    Copyright (C) 2017-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 it under
       7              : the terms of the GNU General Public License as published by the Free
       8              : Software Foundation; either version 3, or (at your option) any later
       9              : version.
      10              : 
      11              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14              : 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              : #ifndef GCC_INT_VECTOR_BUILDER_H
      21              : #define GCC_INT_VECTOR_BUILDER_H 1
      22              : 
      23              : #include "vector-builder.h"
      24              : 
      25              : /* This class is used to build vectors of integer type T using the same
      26              :    encoding as tree and rtx constants.  See vector_builder for more
      27              :    details.  */
      28              : template<typename T>
      29      4309546 : class int_vector_builder : public vector_builder<T, poly_uint64,
      30              :                                                  int_vector_builder<T> >
      31              : {
      32              :   typedef vector_builder<T, poly_uint64, int_vector_builder> parent;
      33              :   friend class vector_builder<T, poly_uint64, int_vector_builder>;
      34              : 
      35              : public:
      36      6758749 :   int_vector_builder () {}
      37              :   int_vector_builder (poly_uint64, unsigned int, unsigned int);
      38              : 
      39              :   using parent::new_vector;
      40              : 
      41              : private:
      42              :   bool equal_p (T, T) const;
      43              :   bool allow_steps_p () const { return true; }
      44              :   bool integral_p (T) const { return true; }
      45              :   T step (T, T) const;
      46              :   T apply_step (T, unsigned int, T) const;
      47              :   bool can_elide_p (T) const { return true; }
      48              :   void note_representative (T *, T) {}
      49              : 
      50              :   static poly_uint64 shape_nelts (poly_uint64 x) { return x; }
      51              : };
      52              : 
      53              : /* Create a new builder for a vector with FULL_NELTS elements.
      54              :    Initially encode the value as NPATTERNS interleaved patterns with
      55              :    NELTS_PER_PATTERN elements each.  */
      56              : 
      57              : template<typename T>
      58              : inline
      59      1279319 : int_vector_builder<T>::int_vector_builder (poly_uint64 full_nelts,
      60              :                                            unsigned int npatterns,
      61      1279319 :                                            unsigned int nelts_per_pattern)
      62              : {
      63      1279319 :   new_vector (full_nelts, npatterns, nelts_per_pattern);
      64      1279319 : }
      65              : 
      66              : /* Return true if elements ELT1 and ELT2 are equal.  */
      67              : 
      68              : template<typename T>
      69              : inline bool
      70              : int_vector_builder<T>::equal_p (T elt1, T elt2) const
      71              : {
      72     15889769 :   return known_eq (elt1, elt2);
      73              : }
      74              : 
      75              : /* Return the value of element ELT2 minus the value of element ELT1.  */
      76              : 
      77              : template<typename T>
      78              : inline T
      79     14352984 : int_vector_builder<T>::step (T elt1, T elt2) const
      80              : {
      81     14352984 :   return elt2 - elt1;
      82              : }
      83              : 
      84              : /* Return a vector element with the value BASE + FACTOR * STEP.  */
      85              : 
      86              : template<typename T>
      87              : inline T
      88      2656729 : int_vector_builder<T>::apply_step (T base, unsigned int factor, T step) const
      89              : {
      90      2656729 :   return base + factor * step;
      91              : }
      92              : 
      93              : #endif