gcc/config/mips/predicates.md

   1 ;; Predicate definitions for MIPS.
   2 ;; Copyright (C) 2004, 2007 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 (define_predicate "const_uns_arith_operand"
  21   (and (match_code "const_int")
  22        (match_test "SMALL_OPERAND_UNSIGNED (INTVAL (op))")))
  23
  24 (define_predicate "uns_arith_operand"
  25   (ior (match_operand 0 "const_uns_arith_operand")
  26        (match_operand 0 "register_operand")))
  27
  28 (define_predicate "const_arith_operand"
  29   (and (match_code "const_int")
  30        (match_test "SMALL_OPERAND (INTVAL (op))")))
  31
  32 (define_predicate "arith_operand"
  33   (ior (match_operand 0 "const_arith_operand")
  34        (match_operand 0 "register_operand")))
  35
  36 (define_predicate "const_uimm6_operand"
  37   (and (match_code "const_int")
  38        (match_test "UIMM6_OPERAND (INTVAL (op))")))
  39
  40 (define_predicate "const_imm10_operand"
  41   (and (match_code "const_int")
  42        (match_test "IMM10_OPERAND (INTVAL (op))")))
  43
  44 (define_predicate "reg_imm10_operand"
  45   (ior (match_operand 0 "const_imm10_operand")
  46        (match_operand 0 "register_operand")))
  47
  48 (define_predicate "sle_operand"
  49   (and (match_code "const_int")
  50        (match_test "SMALL_OPERAND (INTVAL (op) + 1)")))
  51
  52 (define_predicate "sleu_operand"
  53   (and (match_operand 0 "sle_operand")
  54        (match_test "INTVAL (op) + 1 != 0")))
  55
  56 (define_predicate "const_0_operand"
  57   (and (match_code "const_int,const_double,const_vector")
  58        (match_test "op == CONST0_RTX (GET_MODE (op))")))
  59
  60 (define_predicate "reg_or_0_operand"
  61   (ior (and (match_operand 0 "const_0_operand")
  62             (match_test "!TARGET_MIPS16"))
  63        (match_operand 0 "register_operand")))
  64
  65 (define_predicate "const_1_operand"
  66   (and (match_code "const_int,const_double,const_vector")
  67        (match_test "op == CONST1_RTX (GET_MODE (op))")))
  68
  69 (define_predicate "reg_or_1_operand"
  70   (ior (match_operand 0 "const_1_operand")
  71        (match_operand 0 "register_operand")))
  72
  73 ;; This is used for indexing into vectors, and hence only accepts const_int.
  74 (define_predicate "const_0_or_1_operand"
  75   (and (match_code "const_int")
  76        (ior (match_test "op == CONST0_RTX (GET_MODE (op))")
  77             (match_test "op == CONST1_RTX (GET_MODE (op))"))))
  78
  79 (define_predicate "fpr_operand"
  80   (and (match_code "reg")
  81        (match_test "FP_REG_P (REGNO (op))")))
  82
  83 (define_predicate "lo_operand"
  84   (and (match_code "reg")
  85        (match_test "REGNO (op) == LO_REGNUM")))
  86
  87 (define_predicate "fcc_reload_operand"
  88   (and (match_code "reg,subreg")
  89        (match_test "ST_REG_P (true_regnum (op))")))
  90
  91 (define_special_predicate "pc_or_label_operand"
  92   (match_code "pc,label_ref"))
  93
  94 (define_predicate "const_call_insn_operand"
  95   (match_code "const,symbol_ref,label_ref")
  96 {
  97   enum mips_symbol_type symbol_type;
  98
  99   if (!mips_symbolic_constant_p (op, &symbol_type))
 100     return false;
 101
 102   switch (symbol_type)
 103     {
 104     case SYMBOL_GENERAL:
 105       /* We can only use direct calls for TARGET_ABSOLUTE_ABICALLS if we
 106          are sure that the target function does not need $25 to be live
 107          on entry.  This is true for any locally-defined function because
 108          any such function will use %hi/%lo accesses to set up $gp.  */
 109       if (TARGET_ABSOLUTE_ABICALLS
 110           && !(GET_CODE (op) == SYMBOL_REF
 111                && SYMBOL_REF_DECL (op)
 112                && !DECL_EXTERNAL (SYMBOL_REF_DECL (op))))
 113         return false;
 114
 115       /* If -mlong-calls or if this function has an explicit long_call
 116          attribute, we must use register addressing.  The
 117          SYMBOL_FLAG_LONG_CALL bit is set by mips_encode_section_info.  */
 118       return !SYMBOL_REF_LONG_CALL_P (op);
 119
 120     case SYMBOL_GOT_DISP:
 121       /* Without explicit relocs, there is no special syntax for
 122          loading the address of a call destination into a register.
 123          Using "la $25,foo; jal $25" would prevent the lazy binding
 124          of "foo", so keep the address of global symbols with the
 125          jal macro.  */
 126       return !TARGET_EXPLICIT_RELOCS;
 127
 128     default:
 129       return false;
 130     }
 131 })
 132
 133 (define_predicate "call_insn_operand"
 134   (ior (match_operand 0 "const_call_insn_operand")
 135        (match_operand 0 "register_operand")))
 136
 137 ;; A legitimate CONST_INT operand that takes more than one instruction
 138 ;; to load.
 139 (define_predicate "splittable_const_int_operand"
 140   (match_code "const_int")
 141 {
 142   /* When generating mips16 code, LEGITIMATE_CONSTANT_P rejects
 143      CONST_INTs that can't be loaded using simple insns.  */
 144   if (TARGET_MIPS16)
 145     return false;
 146
 147   /* Don't handle multi-word moves this way; we don't want to introduce
 148      the individual word-mode moves until after reload.  */
 149   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 150     return false;
 151
 152   /* Otherwise check whether the constant can be loaded in a single
 153      instruction.  */
 154   return !LUI_INT (op) && !SMALL_INT (op) && !SMALL_INT_UNSIGNED (op);
 155 })
 156
 157 ;; A legitimate symbolic operand that takes more than one instruction
 158 ;; to load.
 159 (define_predicate "splittable_symbolic_operand"
 160   (match_code "const,symbol_ref,label_ref")
 161 {
 162   enum mips_symbol_type symbol_type;
 163   return (mips_symbolic_constant_p (op, &symbol_type)
 164           && mips_split_p[symbol_type]);
 165 })
 166
 167 (define_predicate "move_operand"
 168   (match_operand 0 "general_operand")
 169 {
 170   enum mips_symbol_type symbol_type;
 171
 172   /* The thinking here is as follows:
 173
 174      (1) The move expanders should split complex load sequences into
 175          individual instructions.  Those individual instructions can
 176          then be optimized by all rtl passes.
 177
 178      (2) The target of pre-reload load sequences should not be used
 179          to store temporary results.  If the target register is only
 180          assigned one value, reload can rematerialize that value
 181          on demand, rather than spill it to the stack.
 182
 183      (3) If we allowed pre-reload passes like combine and cse to recreate
 184          complex load sequences, we would want to be able to split the
 185          sequences before reload as well, so that the pre-reload scheduler
 186          can see the individual instructions.  This falls foul of (2);
 187          the splitter would be forced to reuse the target register for
 188          intermediate results.
 189
 190      (4) We want to define complex load splitters for combine.  These
 191          splitters can request a temporary scratch register, which avoids
 192          the problem in (2).  They allow things like:
 193
 194               (set (reg T1) (high SYM))
 195               (set (reg T2) (low (reg T1) SYM))
 196               (set (reg X) (plus (reg T2) (const_int OFFSET)))
 197
 198          to be combined into:
 199
 200               (set (reg T3) (high SYM+OFFSET))
 201               (set (reg X) (lo_sum (reg T3) SYM+OFFSET))
 202
 203          if T2 is only used this once.  */
 204   switch (GET_CODE (op))
 205     {
 206     case CONST_INT:
 207       return !splittable_const_int_operand (op, mode);
 208
 209     case CONST:
 210     case SYMBOL_REF:
 211     case LABEL_REF:
 212       if (CONST_GP_P (op))
 213         return true;
 214       return (mips_symbolic_constant_p (op, &symbol_type)
 215               && !mips_split_p[symbol_type]);
 216
 217     default:
 218       return true;
 219     }
 220 })
 221
 222 (define_predicate "consttable_operand"
 223   (match_test "CONSTANT_P (op)"))
 224
 225 (define_predicate "symbolic_operand"
 226   (match_code "const,symbol_ref,label_ref")
 227 {
 228   enum mips_symbol_type type;
 229   return mips_symbolic_constant_p (op, &type);
 230 })
 231
 232 (define_predicate "general_symbolic_operand"
 233   (match_code "const,symbol_ref,label_ref")
 234 {
 235   enum mips_symbol_type type;
 236   return mips_symbolic_constant_p (op, &type) && type == SYMBOL_GENERAL;
 237 })
 238
 239 (define_predicate "got_disp_operand"
 240   (match_code "const,symbol_ref,label_ref")
 241 {
 242   enum mips_symbol_type type;
 243   return mips_symbolic_constant_p (op, &type) && type == SYMBOL_GOT_DISP;
 244 })
 245
 246 (define_predicate "got_page_ofst_operand"
 247   (match_code "const,symbol_ref,label_ref")
 248 {
 249   enum mips_symbol_type type;
 250   return mips_symbolic_constant_p (op, &type) && type == SYMBOL_GOT_PAGE_OFST;
 251 })
 252
 253 (define_predicate "symbol_ref_operand"
 254   (match_code "symbol_ref"))
 255
 256 (define_predicate "stack_operand"
 257   (and (match_code "mem")
 258        (match_test "mips_stack_address_p (XEXP (op, 0), GET_MODE (op))")))
 259
 260 (define_predicate "macc_msac_operand"
 261   (ior (and (match_code "plus") (match_test "ISA_HAS_MACC"))
 262        (and (match_code "minus") (match_test "ISA_HAS_MSAC")))
 263 {
 264   rtx mult = XEXP (op, GET_CODE (op) == PLUS ? 0 : 1);
 265   rtx accum = XEXP (op, GET_CODE (op) == PLUS ? 1 : 0);
 266   return (GET_CODE (mult) == MULT
 267           && REG_P (XEXP (mult, 0))
 268           && REG_P (XEXP (mult, 1))
 269           && REG_P (accum));
 270 })
 271
 272
 273 (define_predicate "equality_operator"
 274   (match_code "eq,ne"))
 275
 276 (define_predicate "extend_operator"
 277   (match_code "zero_extend,sign_extend"))
 278
 279 (define_predicate "trap_comparison_operator"
 280   (match_code "eq,ne,lt,ltu,ge,geu"))
 281
 282 (define_predicate "order_operator"
 283   (match_code "lt,ltu,le,leu,ge,geu,gt,gtu"))
 284
 285
 286 (define_predicate "small_data_pattern"
 287   (and (match_code "set,parallel,unspec,unspec_volatile,prefetch")
 288        (match_test "mips_small_data_pattern_p (op)")))