gcc/rtl-ssa/change-utils.h

   1 // RTL SSA utility functions for changing instructions              -*- C++ -*-
   2 // Copyright (C) 2020-2021 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 namespace rtl_ssa {
  21
  22 // Return true if INSN is one of the instructions being changed by CHANGES.
  23 inline bool
  24 insn_is_changing (array_slice<insn_change *const> changes,
  25                   const insn_info *insn)
  26 {
  27   for (const insn_change *change : changes)
  28     if (change->insn () == insn)
  29       return true;
  30   return false;
  31 }
  32
  33 // Return a closure of insn_is_changing, for use as a predicate.
  34 // This could be done using local lambdas instead, but the predicate is
  35 // used often enough that having a class should be more convenient and allow
  36 // reuse of template instantiations.
  37 //
  38 // We don't use std::bind because it would involve an indirect function call,
  39 // whereas this function is used in relatively performance-critical code.
  40 inline insn_is_changing_closure
  41 insn_is_changing (array_slice<insn_change *const> changes)
  42 {
  43   return insn_is_changing_closure (changes);
  44 }
  45
  46 // Restrict CHANGE.move_range so that the changed instruction can perform
  47 // all its definitions and uses.  Assume that if:
  48 //
  49 // - CHANGE contains an access A1 of resource R;
  50 // - an instruction I2 contains another access A2 to R; and
  51 // - IGNORE (I2) is true
  52 //
  53 // then either:
  54 //
  55 // - A2 will be removed; or
  56 // - something will ensure that A1 and A2 maintain their current order,
  57 //   without this having to be enforced by CHANGE's move range.
  58 //
  59 // IGNORE should return true for CHANGE.insn ().
  60 //
  61 // Return true on success, otherwise leave CHANGE.move_range in an invalid
  62 // state.
  63 //
  64 // This function only works correctly for instructions that remain within
  65 // the same extended basic block.
  66 template<typename IgnorePredicate>
  67 bool
  68 restrict_movement_ignoring (insn_change &change, IgnorePredicate ignore)
  69 {
  70   // Uses generally lead to failure quicker, so test those first.
  71   return (restrict_movement_for_uses_ignoring (change.move_range,
  72                                                change.new_uses, ignore)
  73           && restrict_movement_for_defs_ignoring (change.move_range,
  74                                                   change.new_defs, ignore)
  75           && canonicalize_move_range (change.move_range, change.insn ()));
  76 }
  77
  78 // Like restrict_movement_ignoring, but ignore only the instruction
  79 // that is being changed.
  80 inline bool
  81 restrict_movement (insn_change &change)
  82 {
  83   return restrict_movement_ignoring (change, insn_is (change.insn ()));
  84 }
  85
  86 using add_regno_clobber_fn = std::function<bool (insn_change &,
  87                                                  unsigned int)>;
  88 bool recog_internal (insn_change &, add_regno_clobber_fn);
  89
  90 // Try to recognize the new instruction pattern for CHANGE, potentially
  91 // tweaking the pattern or adding extra clobbers in order to make it match.
  92 //
  93 // When adding an extra clobber for register R, restrict CHANGE.move_range
  94 // to a range of instructions for which R is not live.  When determining
  95 // whether R is live, ignore accesses made by an instruction I if
  96 // IGNORE (I) is true.  The caller then assumes the responsibility
  97 // of ensuring that CHANGE and I are placed in a valid order.
  98 //
  99 // IGNORE should return true for CHANGE.insn ().
 100 //
 101 // Return true on success.  Leave CHANGE unmodified on failure.
 102 template<typename IgnorePredicate>
 103 inline bool
 104 recog_ignoring (obstack_watermark &watermark, insn_change &change,
 105                 IgnorePredicate ignore)
 106 {
 107   auto add_regno_clobber = [&](insn_change &change, unsigned int regno)
 108     {
 109       return crtl->ssa->add_regno_clobber (watermark, change, regno, ignore);
 110     };
 111   return recog_internal (change, add_regno_clobber);
 112 }
 113
 114 // As for recog_ignoring, but ignore only the instruction that is being
 115 // changed.
 116 inline bool
 117 recog (obstack_watermark &watermark, insn_change &change)
 118 {
 119   return recog_ignoring (watermark, change, insn_is (change.insn ()));
 120 }
 121
 122 // Check whether insn costs indicate that the net effect of the changes
 123 // in CHANGES is worthwhile.  Require a strict improvement if STRICT_P,
 124 // otherwise allow the new instructions to be the same cost as the old
 125 // instructions.
 126 bool changes_are_worthwhile (array_slice<insn_change *const> changes,
 127                              bool strict_p = false);
 128
 129 // Like changes_are_worthwhile, but for a single change.
 130 inline bool
 131 change_is_worthwhile (insn_change &change, bool strict_p = false)
 132 {
 133   insn_change *changes[] = { &change };
 134   return changes_are_worthwhile (changes, strict_p);
 135 }
 136
 137 }