| ;; Predicate definitions for DEC VAX. |
| ;; Copyright (C) 2007-2021 Free Software Foundation, Inc. |
| ;; |
| ;; This file is part of GCC. |
| ;; |
| ;; GCC is free software; you can redistribute it and/or modify it under |
| ;; the terms of the GNU General Public License as published by the Free |
| ;; Software Foundation; either version 3, or (at your option) any later |
| ;; version. |
| ;; |
| ;; GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| ;; WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| ;; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| ;; for more details. |
| ;; |
| ;; You should have received a copy of the GNU General Public License |
| ;; along with GCC; see the file COPYING3. If not see |
| ;; <http://www.gnu.org/licenses/>. |
| |
| ;; Return true if OP is a constant zero operand. |
| (define_predicate "const_zero_operand" |
| (match_test "op == CONST0_RTX (mode)")) |
| |
| ;; Special case of a symbolic operand that's used as a |
| ;; operand. |
| |
| (define_predicate "symbolic_operand" |
| (match_code "const,symbol_ref,label_ref")) |
| |
| (define_predicate "pic_symbolic_operand" |
| (and (match_code "const,symbol_ref,label_ref") |
| (match_test "!flag_pic |
| || vax_acceptable_pic_operand_p (op, false, true)"))) |
| |
| (define_predicate "nonsymbolic_operand" |
| (and (ior (match_test "!flag_pic") |
| (not (match_operand 0 "symbolic_operand"))) |
| (match_operand 0 "general_operand" ""))) |
| |
| (define_predicate "non_pic_external_memory_operand" |
| (match_code "mem") |
| { |
| rtx addr = XEXP (op, 0); |
| if (MEM_P (addr)) |
| addr = XEXP (addr, 0); |
| if (GET_CODE (addr) == PLUS) |
| addr = XEXP (addr, 1); |
| if (MEM_P (addr)) |
| addr = XEXP (addr, 0); |
| if (GET_CODE (addr) == PLUS) |
| addr = XEXP (addr, 1); |
| return (symbolic_operand (addr, SImode) |
| && !vax_acceptable_pic_operand_p (addr, true, true)); |
| }) |
| |
| (define_predicate "indirect_memory_operand" |
| (match_code "mem") |
| { |
| op = XEXP (op, 0); |
| if (MEM_P (op)) |
| return 1; |
| if (GET_CODE (op) == PLUS) |
| op = XEXP (op, 1); |
| return MEM_P (op); |
| }) |
| |
| (define_predicate "indexed_memory_operand" |
| (match_code "mem") |
| { |
| rtx addr = XEXP (op, 0); |
| return GET_CODE (addr) != PRE_DEC && GET_CODE (addr) != POST_INC |
| && mode_dependent_address_p (addr, MEM_ADDR_SPACE (op)); |
| }) |
| |
| (define_predicate "illegal_blk_memory_operand" |
| (and (match_code "mem") |
| (ior (and (match_test "flag_pic") |
| (match_operand 0 "non_pic_external_memory_operand" "")) |
| (ior (match_operand 0 "indexed_memory_operand" "") |
| (ior (match_operand 0 "indirect_memory_operand" "") |
| (match_test "GET_CODE (XEXP (op, 0)) == PRE_DEC")))))) |
| |
| (define_predicate "illegal_addsub_di_memory_operand" |
| (and (match_code "mem") |
| (ior (and (match_test "flag_pic") |
| (match_operand 0 "non_pic_external_memory_operand" "")) |
| (ior (match_operand 0 "indexed_memory_operand" "") |
| (ior (match_operand 0 "indirect_memory_operand" "") |
| (match_test "GET_CODE (XEXP (op, 0)) == PRE_DEC")))))) |
| |
| (define_predicate "nonimmediate_addsub_di_operand" |
| (and (match_code "subreg,reg,mem") |
| (and (match_operand:DI 0 "nonimmediate_operand" "") |
| (not (match_operand:DI 0 "illegal_addsub_di_memory_operand"))))) |
| |
| (define_predicate "general_addsub_di_operand" |
| (and (match_code "const_int,const_double,subreg,reg,mem") |
| (and (match_operand:DI 0 "general_operand" "") |
| (not (match_operand:DI 0 "illegal_addsub_di_memory_operand"))))) |
| |
| ;; Return 1 if the operand is in volatile memory. Note that during the |
| ;; RTL generation phase, `memory_operand' does not return TRUE for |
| ;; volatile memory references. So this function allows us to recognize |
| ;; volatile references where it's safe. |
| (define_predicate "volatile_mem_operand" |
| (and (match_code "mem") |
| (match_test "MEM_VOLATILE_P (op)") |
| (if_then_else (match_test "reload_completed") |
| (match_operand 0 "memory_operand") |
| (match_test "memory_address_p (mode, XEXP (op, 0))")))) |
| |
| ;; Return 1 if the operand is a volatile or non-volatile memory operand. |
| (define_predicate "any_memory_operand" |
| (ior (match_operand 0 "memory_operand") |
| (match_operand 0 "volatile_mem_operand"))) |
| |
| ;; Return true if OP is a comparison operator that requires at least CCmode. |
| (define_predicate "vax_cc_comparison_operator" |
| (match_code "geu,gtu,leu,ltu")) |
| |
| ;; Return true if OP is a comparison operator that requires at least CCNmode. |
| (define_predicate "vax_ccn_comparison_operator" |
| (match_code "ge,lt")) |
| |
| ;; Return true if OP is a comparison operator that requires at least CCNZmode. |
| (define_predicate "vax_ccnz_comparison_operator" |
| (match_code "gt,le")) |
| |
| ;; Return true if OP is a comparison operator that requires at least CCZmode. |
| (define_predicate "vax_ccz_comparison_operator" |
| (match_code "ne,eq")) |