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   bool op2_range (frange &r, tree type,
 168                   const irange &lhs, const frange &op1,
 169                   relation_trio = TRIO_VARYING) const final override;
 170
 171   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 172                                   const irange &) const final override;
 173   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 174                                   const frange &) const final override;
 175   void update_bitmask (irange &r, const irange &lh,
 176                        const irange &rh) const final override;
 177 };
 178
 179 class operator_lt :  public range_operator
 180 {
 181 public:
 182   using range_operator::fold_range;
 183   using range_operator::op1_range;
 184   using range_operator::op2_range;
 185   using range_operator::op1_op2_relation;
 186   bool fold_range (irange &r, tree type,
 187                    const irange &op1, const irange &op2,
 188                    relation_trio = TRIO_VARYING) const final override;
 189   bool fold_range (irange &r, tree type,
 190                    const frange &op1, const frange &op2,
 191                    relation_trio = TRIO_VARYING) const final override;
 192   bool op1_range (irange &r, tree type,
 193                   const irange &lhs, const irange &op2,
 194                   relation_trio = TRIO_VARYING) const final override;
 195   bool op1_range (frange &r, tree type,
 196                   const irange &lhs, const frange &op2,
 197                   relation_trio = TRIO_VARYING) const final override;
 198   bool op2_range (irange &r, tree type,
 199                   const irange &lhs, const irange &op1,
 200                   relation_trio = TRIO_VARYING) const final override;
 201   bool op2_range (frange &r, tree type,
 202                   const irange &lhs, const frange &op1,
 203                   relation_trio = TRIO_VARYING) const final override;
 204   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 205                                   const irange &) const final override;
 206   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 207                                   const frange &) const final override;
 208   void update_bitmask (irange &r, const irange &lh,
 209                        const irange &rh) const final override;
 210 };
 211
 212 class operator_le :  public range_operator
 213 {
 214 public:
 215   using range_operator::fold_range;
 216   using range_operator::op1_range;
 217   using range_operator::op2_range;
 218   using range_operator::op1_op2_relation;
 219   bool fold_range (irange &r, tree type,
 220                    const irange &op1, const irange &op2,
 221                    relation_trio = TRIO_VARYING) const final override;
 222   bool fold_range (irange &r, tree type,
 223                    const frange &op1, const frange &op2,
 224                    relation_trio rel = TRIO_VARYING) const final override;
 225
 226   bool op1_range (irange &r, tree type,
 227                   const irange &lhs, const irange &op2,
 228                   relation_trio = TRIO_VARYING) const final override;
 229   bool op1_range (frange &r, tree type,
 230                   const irange &lhs, const frange &op2,
 231                   relation_trio rel = TRIO_VARYING) const final override;
 232
 233   bool op2_range (irange &r, tree type,
 234                   const irange &lhs, const irange &op1,
 235                   relation_trio = TRIO_VARYING) const final override;
 236   bool op2_range (frange &r, tree type,
 237                   const irange &lhs, const frange &op1,
 238                   relation_trio rel = TRIO_VARYING) const final override;
 239
 240   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 241                                   const irange &) const final override;
 242   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 243                                   const frange &) const final override;
 244   void update_bitmask (irange &r, const irange &lh,
 245                        const irange &rh) const final override;
 246 };
 247
 248 class operator_gt :  public range_operator
 249 {
 250 public:
 251   using range_operator::fold_range;
 252   using range_operator::op1_range;
 253   using range_operator::op2_range;
 254   using range_operator::op1_op2_relation;
 255   bool fold_range (irange &r, tree type,
 256                    const irange &op1, const irange &op2,
 257                    relation_trio = TRIO_VARYING) const final override;
 258   bool fold_range (irange &r, tree type,
 259                    const frange &op1, const frange &op2,
 260                    relation_trio = TRIO_VARYING) const final override;
 261
 262   bool op1_range (irange &r, tree type,
 263                   const irange &lhs, const irange &op2,
 264                   relation_trio = TRIO_VARYING) const final override;
 265   bool op1_range (frange &r, tree type,
 266                   const irange &lhs, const frange &op2,
 267                   relation_trio = TRIO_VARYING) const final override;
 268
 269   bool op2_range (irange &r, tree type,
 270                   const irange &lhs, const irange &op1,
 271                   relation_trio = TRIO_VARYING) const final override;
 272   bool op2_range (frange &r, tree type,
 273                   const irange &lhs, const frange &op1,
 274                   relation_trio = TRIO_VARYING) const final override;
 275   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 276                                   const irange &) const final override;
 277   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 278                                   const frange &) const final override;
 279   void update_bitmask (irange &r, const irange &lh,
 280                        const irange &rh) const final override;
 281 };
 282
 283 class operator_ge :  public range_operator
 284 {
 285 public:
 286   using range_operator::fold_range;
 287   using range_operator::op1_range;
 288   using range_operator::op2_range;
 289   using range_operator::op1_op2_relation;
 290   bool fold_range (irange &r, tree type,
 291                    const irange &op1, const irange &op2,
 292                    relation_trio = TRIO_VARYING) const final override;
 293   bool fold_range (irange &r, tree type,
 294                    const frange &op1, const frange &op2,
 295                    relation_trio = TRIO_VARYING) const final override;
 296
 297   bool op1_range (irange &r, tree type,
 298                   const irange &lhs, const irange &op2,
 299                   relation_trio = TRIO_VARYING) const final override;
 300   bool op1_range (frange &r, tree type,
 301                   const irange &lhs, const frange &op2,
 302                   relation_trio = TRIO_VARYING) const final override;
 303
 304   bool op2_range (irange &r, tree type,
 305                   const irange &lhs, const irange &op1,
 306                   relation_trio = TRIO_VARYING) const final override;
 307   bool op2_range (frange &r, tree type,
 308                   const irange &lhs, const frange &op1,
 309                   relation_trio = TRIO_VARYING) const final override;
 310
 311   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 312                                   const irange &) const final override;
 313   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 314                                   const frange &) const final override;
 315   void update_bitmask (irange &r, const irange &lh,
 316                        const irange &rh) const final override;
 317 };
 318
 319 class operator_identity : public range_operator
 320 {
 321 public:
 322   using range_operator::fold_range;
 323   using range_operator::op1_range;
 324   using range_operator::lhs_op1_relation;
 325   bool fold_range (irange &r, tree type,
 326                    const irange &op1, const irange &op2,
 327                    relation_trio rel = TRIO_VARYING) const final override;
 328   bool fold_range (frange &r, tree type ATTRIBUTE_UNUSED,
 329                    const frange &op1, const frange &op2 ATTRIBUTE_UNUSED,
 330                    relation_trio = TRIO_VARYING) const final override;
 331   bool op1_range (irange &r, tree type,
 332                   const irange &lhs, const irange &op2,
 333                   relation_trio rel = TRIO_VARYING) const final override;
 334   bool op1_range (frange &r, tree type ATTRIBUTE_UNUSED,
 335                   const frange &lhs, const frange &op2 ATTRIBUTE_UNUSED,
 336                   relation_trio = TRIO_VARYING) const final override;
 337   relation_kind lhs_op1_relation (const irange &lhs,
 338                                   const irange &op1, const irange &op2,
 339                                   relation_kind rel) const final override;
 340 };
 341
 342 class operator_cst : public range_operator
 343 {
 344 public:
 345   using range_operator::fold_range;
 346   bool fold_range (irange &r, tree type,
 347                    const irange &op1, const irange &op2,
 348                    relation_trio rel = TRIO_VARYING) const final override;
 349   bool fold_range (frange &r, tree type,
 350                    const frange &op1, const frange &op2,
 351                    relation_trio = TRIO_VARYING) const final override;
 352 };
 353
 354
 355 class operator_cast: public range_operator
 356 {
 357 public:
 358   using range_operator::fold_range;
 359   using range_operator::op1_range;
 360   using range_operator::lhs_op1_relation;
 361   bool fold_range (irange &r, tree type,
 362                    const irange &op1, const irange &op2,
 363                    relation_trio rel = TRIO_VARYING) const final override;
 364   bool op1_range (irange &r, tree type,
 365                   const irange &lhs, const irange &op2,
 366                   relation_trio rel = TRIO_VARYING) const final override;
 367   relation_kind lhs_op1_relation (const irange &lhs,
 368                                   const irange &op1, const irange &op2,
 369                                   relation_kind) const final override;
 370   void update_bitmask (irange &r, const irange &lh,
 371                        const irange &rh) const final override;
 372 private:
 373   bool truncating_cast_p (const irange &inner, const irange &outer) const;
 374   bool inside_domain_p (const wide_int &min, const wide_int &max,
 375                         const irange &outer) const;
 376   void fold_pair (irange &r, unsigned index, const irange &inner,
 377                            const irange &outer) const;
 378 };
 379
 380 class operator_plus : public range_operator
 381 {
 382 public:
 383   using range_operator::op1_range;
 384   using range_operator::op2_range;
 385   using range_operator::lhs_op1_relation;
 386   using range_operator::lhs_op2_relation;
 387   bool op1_range (irange &r, tree type,
 388                   const irange &lhs, const irange &op2,
 389                   relation_trio) const final override;
 390   bool op1_range (frange &r, tree type,
 391                   const frange &lhs, const frange &op2,
 392                   relation_trio = TRIO_VARYING) const final override;
 393
 394   bool op2_range (irange &r, tree type,
 395                   const irange &lhs, const irange &op1,
 396                   relation_trio) const final override;
 397   bool op2_range (frange &r, tree type,
 398                   const frange &lhs, const frange &op1,
 399                   relation_trio = TRIO_VARYING) const final override;
 400
 401   relation_kind lhs_op1_relation (const irange &lhs, const irange &op1,
 402                                   const irange &op2,
 403                                   relation_kind rel) const final override;
 404   relation_kind lhs_op2_relation (const irange &lhs, const irange &op1,
 405                                   const irange &op2,
 406                                   relation_kind rel) const final override;
 407   void update_bitmask (irange &r, const irange &lh,
 408                        const irange &rh) const final override;
 409
 410   virtual bool overflow_free_p (const irange &lh, const irange &rh,
 411                                 relation_trio = TRIO_VARYING) const;
 412
 413 private:
 414   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 415                 const wide_int &lh_ub, const wide_int &rh_lb,
 416                 const wide_int &rh_ub) const final override;
 417   void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
 418                 bool &maybe_nan, tree type,
 419                 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
 420                 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
 421                 relation_kind) const final override;
 422 };
 423
 424 class operator_abs : public range_operator
 425 {
 426  public:
 427   using range_operator::fold_range;
 428   using range_operator::op1_range;
 429   bool fold_range (frange &r, tree type,
 430                    const frange &op1, const frange &,
 431                    relation_trio = TRIO_VARYING) const final override;
 432
 433   bool op1_range (irange &r, tree type, const irange &lhs,
 434                   const irange &op2, relation_trio) const final override;
 435   bool op1_range (frange &r, tree type,
 436                   const frange &lhs, const frange &op2,
 437                   relation_trio rel = TRIO_VARYING) const final override;
 438   void update_bitmask (irange &r, const irange &lh,
 439                        const irange &rh) const final override;
 440 private:
 441   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 442                 const wide_int &lh_ub, const wide_int &rh_lb,
 443                 const wide_int &rh_ub) const final override;
 444
 445 };
 446
 447 class operator_minus : public range_operator
 448 {
 449 public:
 450   using range_operator::fold_range;
 451   using range_operator::op1_range;
 452   using range_operator::op2_range;
 453   using range_operator::lhs_op1_relation;
 454   bool op1_range (irange &r, tree type,
 455                   const irange &lhs, const irange &op2,
 456                   relation_trio) const final override;
 457   bool op1_range (frange &r, tree type,
 458                   const frange &lhs, const frange &op2,
 459                   relation_trio = TRIO_VARYING) const final override;
 460
 461   bool op2_range (irange &r, tree type,
 462                   const irange &lhs, const irange &op1,
 463                   relation_trio) const final override;
 464   bool op2_range (frange &r, tree type,
 465                   const frange &lhs,
 466                   const frange &op1,
 467                   relation_trio = TRIO_VARYING) const final override;
 468
 469   relation_kind lhs_op1_relation (const irange &lhs,
 470                                   const irange &op1, const irange &op2,
 471                                   relation_kind rel) const final override;
 472   bool op1_op2_relation_effect (irange &lhs_range, tree type,
 473                                 const irange &op1_range,
 474                                 const irange &op2_range,
 475                                 relation_kind rel) const final override;
 476   void update_bitmask (irange &r, const irange &lh,
 477                        const irange &rh) const final override;
 478
 479   virtual bool overflow_free_p (const irange &lh, const irange &rh,
 480                                 relation_trio = TRIO_VARYING) const;
 481
 482 private:
 483   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 484                 const wide_int &lh_ub, const wide_int &rh_lb,
 485                 const wide_int &rh_ub) const final override;
 486   void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
 487                 bool &maybe_nan, tree type,
 488                 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
 489                 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
 490                 relation_kind) const final override;
 491 };
 492
 493 class operator_negate : public range_operator
 494 {
 495  public:
 496   using range_operator::fold_range;
 497   using range_operator::op1_range;
 498   bool fold_range (irange &r, tree type,
 499                    const irange &op1, const irange &op2,
 500                    relation_trio rel = TRIO_VARYING) const final override;
 501   bool fold_range (frange &r, tree type,
 502                    const frange &op1, const frange &op2,
 503                    relation_trio = TRIO_VARYING) const final override;
 504
 505   bool op1_range (irange &r, tree type,
 506                   const irange &lhs, const irange &op2,
 507                   relation_trio rel = TRIO_VARYING) const final override;
 508   bool op1_range (frange &r, tree type,
 509                   const frange &lhs, const frange &op2,
 510                   relation_trio rel = TRIO_VARYING) const final override;
 511 };
 512
 513
 514 class cross_product_operator : public range_operator
 515 {
 516 public:
 517   virtual bool wi_op_overflows (wide_int &r,
 518                                 tree type,
 519                                 const wide_int &,
 520                                 const wide_int &) const = 0;
 521   void wi_cross_product (irange &r, tree type,
 522                          const wide_int &lh_lb,
 523                          const wide_int &lh_ub,
 524                          const wide_int &rh_lb,
 525                          const wide_int &rh_ub) const;
 526 };
 527
 528 class operator_mult : public cross_product_operator
 529 {
 530 public:
 531   using range_operator::op1_range;
 532   using range_operator::op2_range;
 533   bool op1_range (irange &r, tree type,
 534                   const irange &lhs, const irange &op2,
 535                   relation_trio) const final override;
 536   bool op1_range (frange &r, tree type,
 537                   const frange &lhs, const frange &op2,
 538                   relation_trio = TRIO_VARYING) const final override;
 539
 540   bool op2_range (irange &r, tree type,
 541                   const irange &lhs, const irange &op1,
 542                   relation_trio) const final override;
 543   bool op2_range (frange &r, tree type,
 544                   const frange &lhs, const frange &op1,
 545                   relation_trio = TRIO_VARYING) const final override;
 546
 547   void update_bitmask (irange &r, const irange &lh,
 548                        const irange &rh) const final override;
 549
 550   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 551                 const wide_int &lh_ub, const wide_int &rh_lb,
 552                 const wide_int &rh_ub) const final override;
 553   bool wi_op_overflows (wide_int &res, tree type, const wide_int &w0,
 554                         const wide_int &w1) const final override;
 555
 556   void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
 557                 bool &maybe_nan, tree type,
 558                 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
 559                 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
 560                 relation_kind kind) const final override;
 561   virtual bool overflow_free_p (const irange &lh, const irange &rh,
 562                                 relation_trio = TRIO_VARYING) const;
 563
 564 };
 565
 566 class operator_addr_expr : public range_operator
 567 {
 568 public:
 569   using range_operator::fold_range;
 570   using range_operator::op1_range;
 571   bool fold_range (irange &r, tree type,
 572                    const irange &op1, const irange &op2,
 573                    relation_trio rel = TRIO_VARYING) const final override;
 574   bool op1_range (irange &r, tree type,
 575                   const irange &lhs, const irange &op2,
 576                   relation_trio rel = TRIO_VARYING) const final override;
 577 };
 578
 579 class operator_bitwise_not : public range_operator
 580 {
 581 public:
 582   using range_operator::fold_range;
 583   using range_operator::op1_range;
 584   bool fold_range (irange &r, tree type,
 585                    const irange &lh, const irange &rh,
 586                    relation_trio rel = TRIO_VARYING) const final override;
 587   bool op1_range (irange &r, tree type,
 588                   const irange &lhs, const irange &op2,
 589                   relation_trio rel = TRIO_VARYING) const final override;
 590   void update_bitmask (irange &r, const irange &lh,
 591                        const irange &rh) const final override;
 592 };
 593
 594 class operator_bitwise_xor : public range_operator
 595 {
 596 public:
 597   using range_operator::op1_range;
 598   using range_operator::op2_range;
 599   bool op1_range (irange &r, tree type,
 600                   const irange &lhs, const irange &op2,
 601                   relation_trio rel = TRIO_VARYING) const final override;
 602   bool op2_range (irange &r, tree type,
 603                   const irange &lhs, const irange &op1,
 604                   relation_trio rel = TRIO_VARYING) const final override;
 605   bool op1_op2_relation_effect (irange &lhs_range,
 606                                         tree type,
 607                                         const irange &op1_range,
 608                                         const irange &op2_range,
 609                                         relation_kind rel) const final override;
 610   void update_bitmask (irange &r, const irange &lh,
 611                        const irange &rh) const final override;
 612 private:
 613   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 614                 const wide_int &lh_ub, const wide_int &rh_lb,
 615                 const wide_int &rh_ub) const final override;
 616 };
 617
 618 class operator_bitwise_and : public range_operator
 619 {
 620 public:
 621   using range_operator::op1_range;
 622   using range_operator::op2_range;
 623   using range_operator::lhs_op1_relation;
 624   bool op1_range (irange &r, tree type,
 625                   const irange &lhs, const irange &op2,
 626                   relation_trio rel = TRIO_VARYING) const override;
 627   bool op2_range (irange &r, tree type,
 628                   const irange &lhs, const irange &op1,
 629                   relation_trio rel = TRIO_VARYING) const override;
 630   relation_kind lhs_op1_relation (const irange &lhs,
 631                                   const irange &op1, const irange &op2,
 632                                   relation_kind) const override;
 633   void update_bitmask (irange &r, const irange &lh,
 634                        const irange &rh) const override;
 635 protected:
 636   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 637                 const wide_int &lh_ub, const wide_int &rh_lb,
 638                 const wide_int &rh_ub) const override;
 639   void simple_op1_range_solver (irange &r, tree type,
 640                                 const irange &lhs,
 641                                 const irange &op2) const;
 642 };
 643
 644 class operator_bitwise_or : public range_operator
 645 {
 646 public:
 647   using range_operator::op1_range;
 648   using range_operator::op2_range;
 649   bool op1_range (irange &r, tree type,
 650                   const irange &lhs, const irange &op2,
 651                   relation_trio rel = TRIO_VARYING) const override;
 652   bool op2_range (irange &r, tree type,
 653                   const irange &lhs, const irange &op1,
 654                   relation_trio rel = TRIO_VARYING) const override;
 655   void update_bitmask (irange &r, const irange &lh,
 656                        const irange &rh) const override;
 657 protected:
 658   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 659                 const wide_int &lh_ub, const wide_int &rh_lb,
 660                 const wide_int &rh_ub) const override;
 661 };
 662
 663 class operator_min : public range_operator
 664 {
 665 public:
 666   void update_bitmask (irange &r, const irange &lh,
 667                        const irange &rh) const override;
 668 protected:
 669   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 670                 const wide_int &lh_ub, const wide_int &rh_lb,
 671                 const wide_int &rh_ub) const override;
 672 };
 673
 674 class operator_max : public range_operator
 675 {
 676 public:
 677   void update_bitmask (irange &r, const irange &lh,
 678       const irange &rh) const override;
 679 protected:
 680   void wi_fold (irange &r, tree type, const wide_int &lh_lb,
 681                 const wide_int &lh_ub, const wide_int &rh_lb,
 682                 const wide_int &rh_ub) const override;
 683 };
 684 #endif // GCC_RANGE_OP_MIXED_H