1;; Predicate definitions for Motorola 68000. 2;; Copyright (C) 2005-2020 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;; Special case of a general operand that's used as a source 21;; operand. Use this to permit reads from PC-relative memory when 22;; -mpcrel is specified. 23 24(define_predicate "general_src_operand" 25 (match_code "const_int,const_double,const,symbol_ref,label_ref,subreg,reg,mem") 26{ 27 if (TARGET_PCREL 28 && GET_CODE (op) == MEM 29 && (GET_CODE (XEXP (op, 0)) == SYMBOL_REF 30 || GET_CODE (XEXP (op, 0)) == LABEL_REF 31 || GET_CODE (XEXP (op, 0)) == CONST)) 32 return 1; 33 return general_operand (op, mode); 34}) 35 36;; Special case of a nonimmediate operand that's used as a source. Use 37;; this to permit reads from PC-relative memory when -mpcrel is 38;; specified. 39 40(define_predicate "nonimmediate_src_operand" 41 (match_code "subreg,reg,mem") 42{ 43 if (TARGET_PCREL && GET_CODE (op) == MEM 44 && (GET_CODE (XEXP (op, 0)) == SYMBOL_REF 45 || GET_CODE (XEXP (op, 0)) == LABEL_REF 46 || GET_CODE (XEXP (op, 0)) == CONST)) 47 return 1; 48 return nonimmediate_operand (op, mode); 49}) 50 51;; Special case of a memory operand that's used as a source. Use this 52;; to permit reads from PC-relative memory when -mpcrel is specified. 53 54(define_predicate "memory_src_operand" 55 (match_code "subreg,mem") 56{ 57 if (TARGET_PCREL && GET_CODE (op) == MEM 58 && (GET_CODE (XEXP (op, 0)) == SYMBOL_REF 59 || GET_CODE (XEXP (op, 0)) == LABEL_REF 60 || GET_CODE (XEXP (op, 0)) == CONST)) 61 return 1; 62 return memory_operand (op, mode); 63}) 64 65;; Similar to general_operand, but exclude stack_pointer_rtx. 66 67(define_predicate "not_sp_operand" 68 (match_code "subreg,reg,mem") 69{ 70 return op != stack_pointer_rtx && nonimmediate_operand (op, mode); 71}) 72 73;; Predicate that accepts only a pc-relative address. This is needed 74;; because pc-relative addresses don't satisfy the predicate 75;; "general_src_operand". 76 77(define_predicate "pcrel_address" 78 (match_code "symbol_ref,label_ref,const")) 79 80;; Accept integer operands in the range 0..0xffffffff. We have to 81;; check the range carefully since this predicate is used in DImode 82;; contexts. Also, we need some extra crud to make it work when 83;; hosted on 64-bit machines. 84 85(define_predicate "const_uint32_operand" 86 (match_code "const_int,const_double") 87{ 88 /* It doesn't make sense to ask this question with a mode that is 89 not larger than 32 bits. */ 90 gcc_assert (GET_MODE_BITSIZE (mode) > 32); 91 92#if HOST_BITS_PER_WIDE_INT > 32 93 /* All allowed constants will fit a CONST_INT. */ 94 return (GET_CODE (op) == CONST_INT 95 && (INTVAL (op) >= 0 && INTVAL (op) <= 0xffffffffL)); 96#else 97 return (GET_CODE (op) == CONST_INT 98 || (GET_CODE (op) == CONST_DOUBLE && CONST_DOUBLE_HIGH (op) == 0)); 99#endif 100}) 101 102;; Accept integer operands in the range -0x80000000..0x7fffffff. We 103;; have to check the range carefully since this predicate is used in 104;; DImode contexts. 105 106(define_predicate "const_sint32_operand" 107 (match_code "const_int") 108{ 109 /* It doesn't make sense to ask this question with a mode that is 110 not larger than 32 bits. */ 111 gcc_assert (GET_MODE_BITSIZE (mode) > 32); 112 113 /* All allowed constants will fit a CONST_INT. */ 114 return (GET_CODE (op) == CONST_INT 115 && (INTVAL (op) >= (-0x7fffffff - 1) && INTVAL (op) <= 0x7fffffff)); 116}) 117 118(define_predicate "m68k_cstore_comparison_operator" 119 (if_then_else (match_test "TARGET_68881") 120 (match_operand 0 "comparison_operator") 121 (match_operand 0 "ordered_comparison_operator"))) 122 123;; Check for sign_extend or zero_extend. Used for bit-count operands. 124 125(define_predicate "extend_operator" 126 (match_code "sign_extend,zero_extend")) 127 128;; Returns true if OP is either a symbol reference or a sum of a 129;; symbol reference and a constant. This predicate is for "raw" 130;; symbol references not yet processed by legitimize*_address, 131;; hence we do not handle UNSPEC_{XGOT, TLS, XTLS} here. 132 133(define_predicate "symbolic_operand" 134 (match_code "symbol_ref,label_ref,const") 135{ 136 switch (GET_CODE (op)) 137 { 138 case SYMBOL_REF: 139 case LABEL_REF: 140 return true; 141 142 case CONST: 143 op = XEXP (op, 0); 144 return ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF 145 || GET_CODE (XEXP (op, 0)) == LABEL_REF) 146 && GET_CODE (XEXP (op, 1)) == CONST_INT); 147 148#if 0 /* Deleted, with corresponding change in m68k.h, 149 so as to fit the specs. No CONST_DOUBLE is ever symbolic. */ 150 case CONST_DOUBLE: 151 return GET_MODE (op) == mode; 152#endif 153 154 default: 155 return false; 156 } 157}) 158 159;; A constant that can be used the address in a call insn 160(define_predicate "const_call_operand" 161 (ior (match_operand 0 "const_int_operand") 162 (and (match_test "m68k_symbolic_call != NULL") 163 (match_operand 0 "symbolic_operand")))) 164 165;; An operand that can be used as the address in a call insn. 166(define_predicate "call_operand" 167 (ior (match_operand 0 "const_call_operand") 168 (match_operand 0 "register_operand"))) 169 170;; A constant that can be used the address in a sibcall insn 171(define_predicate "const_sibcall_operand" 172 (ior (match_operand 0 "const_int_operand") 173 (and (match_test "m68k_symbolic_jump != NULL") 174 (match_operand 0 "symbolic_operand")))) 175 176;; An operand that can be used as the address in a sibcall insn. 177(define_predicate "sibcall_operand" 178 (ior (match_operand 0 "const_sibcall_operand") 179 (and (match_code "reg") 180 (match_test "REGNO (op) == STATIC_CHAIN_REGNUM")))) 181 182;; TODO: Add a comment here. 183 184(define_predicate "post_inc_operand" 185 (and (match_code "mem") 186 (match_test "GET_CODE (XEXP (op, 0)) == POST_INC"))) 187 188;; TODO: Add a comment here. 189 190(define_predicate "pre_dec_operand" 191 (and (match_code "mem") 192 (match_test "GET_CODE (XEXP (op, 0)) == PRE_DEC"))) 193 194;; A zero constant. 195(define_predicate "const0_operand" 196 (and (match_code "const_int,const_double,const_vector") 197 (match_test "op == CONST0_RTX (mode)"))) 198 199;; A one constant (operand for conditional_trap). 200(define_predicate "const1_operand" 201 (and (match_code "const_int") 202 (match_test "op == const1_rtx"))) 203 204;; A valid operand for a conditional operation. 205;; ColdFire has tst patterns for HImode and QImode, but not cmp patterns. 206(define_predicate "m68k_comparison_operand" 207 (if_then_else (match_test "TARGET_COLDFIRE && mode != SImode") 208 (and (match_code "const_int") 209 (match_test "op == const0_rtx")) 210 (match_operand 0 "general_src_operand"))) 211 212;; An operand for movsi_const0 pattern. 213(define_predicate "movsi_const0_operand" 214 (and (match_operand 0 "nonimmediate_operand") 215 (match_test "(TARGET_68010 || TARGET_COLDFIRE) 216 || !(MEM_P (op) && MEM_VOLATILE_P (op))"))) 217 218;; A non-symbolic call operand. 219;; We need to special case 'const_int' to ignore its mode while matching. 220(define_predicate "non_symbolic_call_operand" 221 (and (match_operand 0 "call_operand") 222 (ior (and (match_code "const_int") 223 (match_test "!symbolic_operand (op, mode)")) 224 (match_test "!symbolic_operand (op,mode)")))) 225 226;; Special case of general_src_operand, which rejects a few fp 227;; constants (which we prefer in registers) before reload. 228;; Used only in comparisons, and we do want to allow zero. 229 230(define_predicate "fp_src_operand" 231 (match_operand 0 "general_src_operand") 232{ 233 return (!CONSTANT_P (op) 234 || op == CONST0_RTX (mode) 235 || (TARGET_68881 236 && (!standard_68881_constant_p (op) 237 || reload_in_progress 238 || reload_completed))); 239}) 240 241;; Used to detect constants that are valid for addq/subq instructions 242(define_predicate "addq_subq_operand" 243 (match_code "const_int") 244{ 245 return ((INTVAL (op) <= 8 && INTVAL (op) > 0) 246 || (INTVAL (op) >= -8 && INTVAL (op) < 0)); 247}) 248 249;; Used to detect equality and non-equality operators 250(define_predicate "equality_comparison_operator" 251 (match_code "eq,ne")) 252 253;; Used to detect when an operand is either a register 254;; or a constant that is all ones in its lower bits. 255;; Used by insv pattern to help detect when we're initializing 256;; a bitfield to all ones. 257 258(define_predicate "reg_or_pow2_m1_operand" 259 (match_code "reg,const_int") 260{ 261 return (REG_P (op) || pow2_m1_operand (op, VOIDmode)); 262}) 263 264;; Used to detect a constant that is all ones in its lower bits. 265(define_predicate "pow2_m1_operand" 266 (match_code "const_int") 267{ 268 return (GET_CODE (op) == CONST_INT && exact_log2 (INTVAL (op) + 1) >= 0); 269}) 270 271;; Used to detect valid targets for conditional branches 272;; Used to detect (pc) or (label_ref) in some jumping patterns to cut down 273(define_predicate "pc_or_label_operand" 274 (match_code "pc,label_ref")) 275 276(define_predicate "swap_peephole_relational_operator" 277 (match_code "gtu,leu,gt,le")) 278 279(define_predicate "address_reg_operand" 280 (match_test ("ADDRESS_REG_P (op)"))) 281