gcc/range-op-mixed.h

   1 /* Header file for mixed range operator class.
   2    Copyright (C) 2017-2023 Free Software Foundation, Inc.
   3    Contributed by Andrew MacLeod <amacleod@redhat.com>
   4    and Aldy Hernandez <aldyh@redhat.com>.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16  for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #ifndef GCC_RANGE_OP_MIXED_H
  23 #define GCC_RANGE_OP_MIXED_H
  24
  25 void update_known_bitmask (irange &, tree_code, const irange &, const irange &);
  26 bool minus_op1_op2_relation_effect (irange &lhs_range, tree type,
  27                                     const irange &, const irange &,
  28                                     relation_kind rel);
  29
  30
  31 // Return TRUE if 0 is within [WMIN, WMAX].
  32
  33 inline bool
  34 wi_includes_zero_p (tree type, const wide_int &wmin, const wide_int &wmax)
  35 {
  36   signop sign = TYPE_SIGN (type);
  37   return wi::le_p (wmin, 0, sign) && wi::ge_p (wmax, 0, sign);
  38 }
  39
  40 // Return TRUE if [WMIN, WMAX] is the singleton 0.
  41
  42 inline bool
  43 wi_zero_p (tree type, const wide_int &wmin, const wide_int &wmax)
  44 {
  45   unsigned prec = TYPE_PRECISION (type);
  46   return wmin == wmax && wi::eq_p (wmin, wi::zero (prec));
  47 }
  48
  49
  50 enum bool_range_state { BRS_FALSE, BRS_TRUE, BRS_EMPTY, BRS_FULL };
  51 bool_range_state get_bool_state (vrange &r, const vrange &lhs, tree val_type);
  52
  53 // If the range of either op1 or op2 is undefined, set the result to
  54 // varying and return TRUE.  If the caller truly cares about a result,
  55 // they should pass in a varying if it has an undefined that it wants
  56 // treated as a varying.
  57
  58 inline bool
  59 empty_range_varying (vrange &r, tree type,
  60                      const vrange &op1, const vrange & op2)
  61 {
  62   if (op1.undefined_p () || op2.undefined_p ())
  63     {
  64       r.set_varying (type);
  65       return true;
  66     }
  67   else
  68     return false;
  69 }
  70
  71 // For relation opcodes, first try to see if the supplied relation
  72 // forces a true or false result, and return that.
  73 // Then check for undefined operands.  If none of this applies,
  74 // return false.
  75
  76 inline bool
  77 relop_early_resolve (irange &r, tree type, const vrange &op1,
  78                      const vrange &op2, relation_trio trio,
  79                      relation_kind my_rel)
  80 {
  81   relation_kind rel = trio.op1_op2 ();
  82   // If known relation is a complete subset of this relation, always true.
  83   if (relation_union (rel, my_rel) == my_rel)
  84     {
  85       r = range_true (type);
  86       return true;
  87     }
  88
  89   // If known relation has no subset of this relation, always false.
  90   if (relation_intersect (rel, my_rel) == VREL_UNDEFINED)
  91     {
  92       r = range_false (type);
  93       return true;
  94     }
  95
  96   // If either operand is undefined, return VARYING.
  97   if (empty_range_varying (r, type, op1, op2))
  98     return true;
  99
 100   return false;
 101 }
 102
 103 // ----------------------------------------------------------------------
 104 //                          Mixed Mode Operators.
 105 // ----------------------------------------------------------------------
 106
 107 class operator_equal : public range_operator
 108 {
 109 public:
 110   using range_operator::fold_range;
 111   using range_operator::op1_range;
 112   using range_operator::op2_range;
 113   using range_operator::op1_op2_relation;
 114   bool fold_range (irange &r, tree type,
 115                    const irange &op1, const irange &op2,
 116                    relation_trio = TRIO_VARYING) const final override;
 117   bool fold_range (irange &r, tree type,
 118                    const frange &op1, const frange &op2,
 119                    relation_trio = TRIO_VARYING) const final override;
 120
 121   bool op1_range (irange &r, tree type,
 122                   const irange &lhs, const irange &val,
 123                   relation_trio = TRIO_VARYING) const final override;
 124   bool op1_range (frange &r, tree type,
 125                   const irange &lhs, const frange &op2,
 126                   relation_trio = TRIO_VARYING) const final override;
 127
 128   bool op2_range (irange &r, tree type,
 129                   const irange &lhs, const irange &val,
 130                   relation_trio = TRIO_VARYING) const final override;
 131   bool op2_range (frange &r, tree type,
 132                   const irange &lhs, const frange &op1,
 133                   relation_trio rel = TRIO_VARYING) const final override;
 134
 135   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 136                                   const irange &) const final override;
 137   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 138                                   const frange &) const final override;
 139   void update_bitmask (irange &r, const irange &lh,
 140                        const irange &rh) const final override;
 141 };
 142
 143 class operator_not_equal : public range_operator
 144 {
 145 public:
 146   using range_operator::fold_range;
 147   using range_operator::op1_range;
 148   using range_operator::op2_range;
 149   using range_operator::op1_op2_relation;
 150   bool fold_range (irange &r, tree type,
 151                    const irange &op1, const irange &op2,
 152                    relation_trio = TRIO_VARYING) const final override;
 153   bool fold_range (irange &r, tree type,
 154                    const frange &op1, const frange &op2,
 155                    relation_trio rel = TRIO_VARYING) const final override;
 156
 157   bool op1_range (irange &r, tree type,
 158                   const irange &lhs, const irange &op2,
 159                   relation_trio = TRIO_VARYING) const final override;
 160   bool op1_range (frange &r, tree type,
 161                   const irange &lhs, const frange &op2,
 162                   relation_trio = TRIO_VARYING) const final override;
 163
 164   bool op2_range (irange &r, tree type,
 165                   const irange &lhs, const irange &op1,
 166                   relation_trio = TRIO_VARYING) const final override;
 167
 168   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 169                                   const irange &) const final override;
 170   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 171                                   const frange &) const final override;
 172   void update_bitmask (irange &r, const irange &lh,
 173                        const irange &rh) const final override;
 174 };
 175
 176 class operator_lt :  public range_operator
 177 {
 178 public:
 179   using range_operator::fold_range;
 180   using range_operator::op1_range;
 181   using range_operator::op2_range;
 182   using range_operator::op1_op2_relation;
 183   bool fold_range (irange &r, tree type,
 184                    const irange &op1, const irange &op2,
 185                    relation_trio = TRIO_VARYING) const final override;
 186   bool fold_range (irange &r, tree type,
 187                    const frange &op1, const frange &op2,
 188                    relation_trio = TRIO_VARYING) const final override;
 189   bool op1_range (irange &r, tree type,
 190                   const irange &lhs, const irange &op2,
 191                   relation_trio = TRIO_VARYING) const final override;
 192   bool op1_range (frange &r, tree type,
 193                   const irange &lhs, const frange &op2,
 194                   relation_trio = TRIO_VARYING) const final override;
 195   bool op2_range (irange &r, tree type,
 196                   const irange &lhs, const irange &op1,
 197                   relation_trio = TRIO_VARYING) const final override;
 198   bool op2_range (frange &r, tree type,
 199                   const irange &lhs, const frange &op1,
 200                   relation_trio = TRIO_VARYING) const final override;
 201   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 202                                   const irange &) const final override;
 203   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 204                                   const frange &) const final override;
 205   void update_bitmask (irange &r, const irange &lh,
 206                        const irange &rh) const final override;
 207 };
 208
 209 class operator_le :  public range_operator
 210 {
 211 public:
 212   using range_operator::fold_range;
 213   using range_operator::op1_range;
 214   using range_operator::op2_range;
 215   using range_operator::op1_op2_relation;
 216   bool fold_range (irange &r, tree type,
 217                    const irange &op1, const irange &op2,
 218                    relation_trio = TRIO_VARYING) const final override;
 219   bool fold_range (irange &r, tree type,
 220                    const frange &op1, const frange &op2,
 221                    relation_trio rel = TRIO_VARYING) const final override;
 222
 223   bool op1_range (irange &r, tree type,
 224                   const irange &lhs, const irange &op2,
 225                   relation_trio = TRIO_VARYING) const final override;
 226   bool op1_range (frange &r, tree type,
 227                   const irange &lhs, const frange &op2,
 228                   relation_trio rel = TRIO_VARYING) const final override;
 229
 230   bool op2_range (irange &r, tree type,
 231                   const irange &lhs, const irange &op1,
 232                   relation_trio = TRIO_VARYING) const final override;
 233   bool op2_range (frange &r, tree type,
 234                   const irange &lhs, const frange &op1,
 235                   relation_trio rel = TRIO_VARYING) const final override;
 236
 237   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 238                                   const irange &) const final override;
 239   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 240                                   const frange &) const final override;
 241   void update_bitmask (irange &r, const irange &lh,
 242                        const irange &rh) const final override;
 243 };
 244
 245 class operator_gt :  public range_operator
 246 {
 247 public:
 248   using range_operator::fold_range;
 249   using range_operator::op1_range;
 250   using range_operator::op2_range;
 251   using range_operator::op1_op2_relation;
 252   bool fold_range (irange &r, tree type,
 253                    const irange &op1, const irange &op2,
 254                    relation_trio = TRIO_VARYING) const final override;
 255   bool fold_range (irange &r, tree type,
 256                    const frange &op1, const frange &op2,
 257                    relation_trio = TRIO_VARYING) const final override;
 258
 259   bool op1_range (irange &r, tree type,
 260                   const irange &lhs, const irange &op2,
 261                   relation_trio = TRIO_VARYING) const final override;
 262   bool op1_range (frange &r, tree type,
 263                   const irange &lhs, const frange &op2,
 264                   relation_trio = TRIO_VARYING) const final override;
 265
 266   bool op2_range (irange &r, tree type,
 267                   const irange &lhs, const irange &op1,
 268                   relation_trio = TRIO_VARYING) const final override;
 269   bool op2_range (frange &r, tree type,
 270                   const irange &lhs, const frange &op1,
 271                   relation_trio = TRIO_VARYING) const final override;
 272   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 273                                   const irange &) const final override;
 274   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 275                                   const frange &) const final override;
 276   void update_bitmask (irange &r, const irange &lh,
 277                        const irange &rh) const final override;
 278 };
 279
 280 class operator_ge :  public range_operator
 281 {
 282 public:
 283   using range_operator::fold_range;
 284   using range_operator::op1_range;
 285   using range_operator::op2_range;
 286   using range_operator::op1_op2_relation;
 287   bool fold_range (irange &r, tree type,
 288                    const irange &op1, const irange &op2,
 289                    relation_trio = TRIO_VARYING) const final override;
 290   bool fold_range (irange &r, tree type,
 291                    const frange &op1, const frange &op2,
 292                    relation_trio = TRIO_VARYING) const final override;
 293
 294   bool op1_range (irange &r, tree type,
 295                   const irange &lhs, const irange &op2,
 296                   relation_trio = TRIO_VARYING) const final override;
 297   bool op1_range (frange &r, tree type,
 298                   const irange &lhs, const frange &op2,
 299                   relation_trio = TRIO_VARYING) const final override;
 300
 301   bool op2_range (irange &r, tree type,
 302                   const irange &lhs, const irange &op1,
 303                   relation_trio = TRIO_VARYING) const final override;
 304   bool op2_range (frange &r, tree type,
 305                   const irange &lhs, const frange &op1,
 306                   relation_trio = TRIO_VARYING) const final override;
 307
 308   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 309                                   const irange &) const final override;
 310   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 311                                   const frange &) const final override;
 312   void update_bitmask (irange &r, const irange &lh,
 313                        const irange &rh) const final override;
 314 };
 315
 316 class operator_identity : public range_operator
 317 {
 318 public:
 319   using range_operator::fold_range;
 320   using range_operator::op1_range;
 321   using range_operator::lhs_op1_relation;
 322   bool fold_range (irange &r, tree type,
 323                    const irange &op1, const irange &op2,
 324                    relation_trio rel = TRIO_VARYING) const final override;
 325   bool fold_range (frange &r, tree type ATTRIBUTE_UNUSED,
 326                    const frange &op1, const frange &op2 ATTRIBUTE_UNUSED,
 327                    relation_trio = TRIO_VARYING) const final override;
 328   bool op1_range (irange &r, tree type,
 329                   const irange &lhs, const irange &op2,
 330                   relation_trio rel = TRIO_VARYING) const final override;
 331   bool op1_range (frange &r, tree type ATTRIBUTE_UNUSED,
 332                   const frange &lhs, const frange &op2 ATTRIBUTE_UNUSED,
 333                   relation_trio = TRIO_VARYING) const final override;
 334   relation_kind lhs_op1_relation (const irange &lhs,
 335                                   const irange &op1, const irange &op2,
 336                                   relation_kind rel) const final override;
 337 };
 338
 339 class operator_cst : public range_operator
 340 {
 341 public:
 342   using range_operator::fold_range;
 343   bool fold_range (irange &r, tree type,
 344                    const irange &op1, const irange &op2,
 345                    relation_trio rel = TRIO_VARYING) const final override;
 346   bool fold_range (frange &r, tree type,
 347                    const frange &op1, const frange &op2,
 348                    relation_trio = TRIO_VARYING) const final override;
 349 };
 350
 351
 352 class operator_cast: public range_operator
 353 {
 354 public:
 355   using range_operator::fold_range;
 356   using range_operator::op1_range;
 357   using range_operator::lhs_op1_relation;
 358   bool fold_range (irange &r, tree type,
 359                    const irange &op1, const irange &op2,
 360                    relation_trio rel = TRIO_VARYING) const final override;
 361   bool op1_range (irange &r, tree type,
 362                   const irange &lhs, const irange &op2,
 363                   relation_trio rel = TRIO_VARYING) const final override;
 364   relation_kind lhs_op1_relation (const irange &lhs,
 365                                   const irange &op1, const irange &op2,
 366                                   relation_kind) const final override;
 367   void update_bitmask (irange &r, const irange &lh,
 368                        const irange &rh) const final override;
 369 private:
 370   bool truncating_cast_p (const irange &inner, const irange &outer) const;
 371   bool inside_domain_p (const wide_int &min, const wide_int &max,
 372                         const irange &outer) const;
 373   void fold_pair (irange &r, unsigned index, const irange &inner,
 374                            const irange &outer) const;
 375 };
 376
 377 class operator_plus : public range_operator
 378 {
 379 public:
 380   using range_operator::op1_range;
 381   using range_operator::op2_range;
 382   using range_operator::lhs_op1_relation;
 383   using range_operator::lhs_op2_relation;
 384   bool op1_range (irange &r, tree type,
 385                   const irange &lhs, const irange &op2,
 386                   relation_trio) const final override;
 387   bool op1_range (frange &r, tree type,
 388                   const frange &lhs, const frange &op2,
 389                   relation_trio = TRIO_VARYING) const final override;
 390
 391   bool op2_range (irange &r, tree type,
 392                   const irange &lhs, const irange &op1,
 393                   relation_trio) const final override;
 394   bool op2_range (frange &r, tree type,
 395                   const frange &lhs, const frange &op1,
 396                   relation_trio = TRIO_VARYING) const final override;
 397
 398   relation_kind lhs_op1_relation (const irange &lhs, const irange &op1,
 399                                   const irange &op2,
 400                                   relation_kind rel) const final override;
 401   relation_kind lhs_op2_relation (const irange &lhs, const irange &op1,
 402                                   const irange &op2,
 403                                   relation_kind rel) const final override;
 404   void update_bitmask (irange &r, const irange &lh,
 405                        const irange &rh) const final override;
 406
 407   virtual bool overflow_free_p (const irange &lh, const irange &rh,
 408                                 relation_trio = TRIO_VARYING) const;
 409
 410 private:
 411   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 412                 const wide_int &lh_ub, const wide_int &rh_lb,
 413                 const wide_int &rh_ub) const final override;
 414   void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
 415                 bool &maybe_nan, tree type,
 416                 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
 417                 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
 418                 relation_kind) const final override;
 419 };
 420
 421 class operator_abs : public range_operator
 422 {
 423  public:
 424   using range_operator::fold_range;
 425   using range_operator::op1_range;
 426   bool fold_range (frange &r, tree type,
 427                    const frange &op1, const frange &,
 428                    relation_trio = TRIO_VARYING) const final override;
 429
 430   bool op1_range (irange &r, tree type, const irange &lhs,
 431                   const irange &op2, relation_trio) const final override;
 432   bool op1_range (frange &r, tree type,
 433                   const frange &lhs, const frange &op2,
 434                   relation_trio rel = TRIO_VARYING) const final override;
 435   void update_bitmask (irange &r, const irange &lh,
 436                        const irange &rh) const final override;
 437 private:
 438   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 439                 const wide_int &lh_ub, const wide_int &rh_lb,
 440                 const wide_int &rh_ub) const final override;
 441
 442 };
 443
 444 class operator_minus : public range_operator
 445 {
 446 public:
 447   using range_operator::fold_range;
 448   using range_operator::op1_range;
 449   using range_operator::op2_range;
 450   using range_operator::lhs_op1_relation;
 451   bool op1_range (irange &r, tree type,
 452                   const irange &lhs, const irange &op2,
 453                   relation_trio) const final override;
 454   bool op1_range (frange &r, tree type,
 455                   const frange &lhs, const frange &op2,
 456                   relation_trio = TRIO_VARYING) const final override;
 457
 458   bool op2_range (irange &r, tree type,
 459                   const irange &lhs, const irange &op1,
 460                   relation_trio) const final override;
 461   bool op2_range (frange &r, tree type,
 462                   const frange &lhs,
 463                   const frange &op1,
 464                   relation_trio = TRIO_VARYING) const final override;
 465
 466   relation_kind lhs_op1_relation (const irange &lhs,
 467                                   const irange &op1, const irange &op2,
 468                                   relation_kind rel) const final override;
 469   bool op1_op2_relation_effect (irange &lhs_range, tree type,
 470                                 const irange &op1_range,
 471                                 const irange &op2_range,
 472                                 relation_kind rel) const final override;
 473   void update_bitmask (irange &r, const irange &lh,
 474                        const irange &rh) const final override;
 475
 476   virtual bool overflow_free_p (const irange &lh, const irange &rh,
 477                                 relation_trio = TRIO_VARYING) const;
 478
 479 private:
 480   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 481                 const wide_int &lh_ub, const wide_int &rh_lb,
 482                 const wide_int &rh_ub) const final override;
 483   void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
 484                 bool &maybe_nan, tree type,
 485                 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
 486                 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
 487                 relation_kind) const final override;
 488 };
 489
 490 class operator_negate : public range_operator
 491 {
 492  public:
 493   using range_operator::fold_range;
 494   using range_operator::op1_range;
 495   bool fold_range (irange &r, tree type,
 496                    const irange &op1, const irange &op2,
 497                    relation_trio rel = TRIO_VARYING) const final override;
 498   bool fold_range (frange &r, tree type,
 499                    const frange &op1, const frange &op2,
 500                    relation_trio = TRIO_VARYING) const final override;
 501
 502   bool op1_range (irange &r, tree type,
 503                   const irange &lhs, const irange &op2,
 504                   relation_trio rel = TRIO_VARYING) const final override;
 505   bool op1_range (frange &r, tree type,
 506                   const frange &lhs, const frange &op2,
 507                   relation_trio rel = TRIO_VARYING) const final override;
 508 };
 509
 510
 511 class cross_product_operator : public range_operator
 512 {
 513 public:
 514   virtual bool wi_op_overflows (wide_int &r,
 515                                 tree type,
 516                                 const wide_int &,
 517                                 const wide_int &) const = 0;
 518   void wi_cross_product (irange &r, tree type,
 519                          const wide_int &lh_lb,
 520                          const wide_int &lh_ub,
 521                          const wide_int &rh_lb,
 522                          const wide_int &rh_ub) const;
 523 };
 524
 525 class operator_mult : public cross_product_operator
 526 {
 527 public:
 528   using range_operator::op1_range;
 529   using range_operator::op2_range;
 530   bool op1_range (irange &r, tree type,
 531                   const irange &lhs, const irange &op2,
 532                   relation_trio) const final override;
 533   bool op1_range (frange &r, tree type,
 534                   const frange &lhs, const frange &op2,
 535                   relation_trio = TRIO_VARYING) const final override;
 536
 537   bool op2_range (irange &r, tree type,
 538                   const irange &lhs, const irange &op1,
 539                   relation_trio) const final override;
 540   bool op2_range (frange &r, tree type,
 541                   const frange &lhs, const frange &op1,
 542                   relation_trio = TRIO_VARYING) const final override;
 543
 544   void update_bitmask (irange &r, const irange &lh,
 545                        const irange &rh) const final override;
 546
 547   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 548                 const wide_int &lh_ub, const wide_int &rh_lb,
 549                 const wide_int &rh_ub) const final override;
 550   bool wi_op_overflows (wide_int &res, tree type, const wide_int &w0,
 551                         const wide_int &w1) const final override;
 552
 553   void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
 554                 bool &maybe_nan, tree type,
 555                 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
 556                 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
 557                 relation_kind kind) const final override;
 558   virtual bool overflow_free_p (const irange &lh, const irange &rh,
 559                                 relation_trio = TRIO_VARYING) const;
 560
 561 };
 562
 563 class operator_addr_expr : public range_operator
 564 {
 565 public:
 566   using range_operator::fold_range;
 567   using range_operator::op1_range;
 568   bool fold_range (irange &r, tree type,
 569                    const irange &op1, const irange &op2,
 570                    relation_trio rel = TRIO_VARYING) const final override;
 571   bool op1_range (irange &r, tree type,
 572                   const irange &lhs, const irange &op2,
 573                   relation_trio rel = TRIO_VARYING) const final override;
 574 };
 575
 576 class operator_bitwise_not : public range_operator
 577 {
 578 public:
 579   using range_operator::fold_range;
 580   using range_operator::op1_range;
 581   bool fold_range (irange &r, tree type,
 582                    const irange &lh, const irange &rh,
 583                    relation_trio rel = TRIO_VARYING) const final override;
 584   bool op1_range (irange &r, tree type,
 585                   const irange &lhs, const irange &op2,
 586                   relation_trio rel = TRIO_VARYING) const final override;
 587   void update_bitmask (irange &r, const irange &lh,
 588                        const irange &rh) const final override;
 589 };
 590
 591 class operator_bitwise_xor : public range_operator
 592 {
 593 public:
 594   using range_operator::op1_range;
 595   using range_operator::op2_range;
 596   bool op1_range (irange &r, tree type,
 597                   const irange &lhs, const irange &op2,
 598                   relation_trio rel = TRIO_VARYING) const final override;
 599   bool op2_range (irange &r, tree type,
 600                   const irange &lhs, const irange &op1,
 601                   relation_trio rel = TRIO_VARYING) const final override;
 602   bool op1_op2_relation_effect (irange &lhs_range,
 603                                         tree type,
 604                                         const irange &op1_range,
 605                                         const irange &op2_range,
 606                                         relation_kind rel) const final override;
 607   void update_bitmask (irange &r, const irange &lh,
 608                        const irange &rh) const final override;
 609 private:
 610   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 611                 const wide_int &lh_ub, const wide_int &rh_lb,
 612                 const wide_int &rh_ub) const final override;
 613 };
 614
 615 class operator_bitwise_and : public range_operator
 616 {
 617 public:
 618   using range_operator::op1_range;
 619   using range_operator::op2_range;
 620   using range_operator::lhs_op1_relation;
 621   bool op1_range (irange &r, tree type,
 622                   const irange &lhs, const irange &op2,
 623                   relation_trio rel = TRIO_VARYING) const override;
 624   bool op2_range (irange &r, tree type,
 625                   const irange &lhs, const irange &op1,
 626                   relation_trio rel = TRIO_VARYING) const override;
 627   relation_kind lhs_op1_relation (const irange &lhs,
 628                                   const irange &op1, const irange &op2,
 629                                   relation_kind) const override;
 630   void update_bitmask (irange &r, const irange &lh,
 631                        const irange &rh) const override;
 632 protected:
 633   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 634                 const wide_int &lh_ub, const wide_int &rh_lb,
 635                 const wide_int &rh_ub) const override;
 636   void simple_op1_range_solver (irange &r, tree type,
 637                                 const irange &lhs,
 638                                 const irange &op2) const;
 639 };
 640
 641 class operator_bitwise_or : public range_operator
 642 {
 643 public:
 644   using range_operator::op1_range;
 645   using range_operator::op2_range;
 646   bool op1_range (irange &r, tree type,
 647                   const irange &lhs, const irange &op2,
 648                   relation_trio rel = TRIO_VARYING) const override;
 649   bool op2_range (irange &r, tree type,
 650                   const irange &lhs, const irange &op1,
 651                   relation_trio rel = TRIO_VARYING) const override;
 652   void update_bitmask (irange &r, const irange &lh,
 653                        const irange &rh) const override;
 654 protected:
 655   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 656                 const wide_int &lh_ub, const wide_int &rh_lb,
 657                 const wide_int &rh_ub) const override;
 658 };
 659
 660 class operator_min : public range_operator
 661 {
 662 public:
 663   void update_bitmask (irange &r, const irange &lh,
 664                        const irange &rh) const override;
 665 protected:
 666   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 667                 const wide_int &lh_ub, const wide_int &rh_lb,
 668                 const wide_int &rh_ub) const override;
 669 };
 670
 671 class operator_max : public range_operator
 672 {
 673 public:
 674   void update_bitmask (irange &r, const irange &lh,
 675       const irange &rh) const override;
 676 protected:
 677   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 678                 const wide_int &lh_ub, const wide_int &rh_lb,
 679                 const wide_int &rh_ub) const override;
 680 };
 681 #endif // GCC_RANGE_OP_MIXED_H