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