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