This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[patch] mmix: Move predicates to predicates.md.
- From: Kazu Hirata <kazu at cs dot umass dot edu>
- To: gcc-patches at gcc dot gnu dot org
- Cc: hp at bitrange dot com
- Date: Sun, 03 Apr 2005 20:56:35 -0400 (EDT)
- Subject: [patch] mmix: Move predicates to predicates.md.
Hi,
Attached is a patch to move predicates to predicates.md.
Built mmix-knuth-mmixware. OK to apply?
Kazu Hirata
2005-04-04 Kazu Hirata <kazu@cs.umass.edu>
* config/mmix/mmix.c (mmix_symbolic_or_address_operand,
mmix_reg_or_constant_operand, mmix_reg_cc_operand,
mmix_foldable_comparison_operator, mmix_comparison_operator,
mmix_reg_or_0_operand, mmix_reg_or_8bit_operand): Move to
predicates.md.
* config/mmix/mmix.h (PREDICATE_CODES,
SPECIAL_MODE_PREDICATES): Remove.
* config/mmix/mmix.md: Include predicates.md.
* config/mmix/predicates.md: New.
Index: mmix.c
===================================================================
RCS file: /home/kazu/nobackup/gcc-cvs/gcc/gcc/config/mmix/mmix.c,v
retrieving revision 1.74
diff -u -d -p -r1.74 mmix.c
--- mmix.c 30 Dec 2004 01:16:08 -0000 1.74
+++ mmix.c 4 Apr 2005 00:37:44 -0000
@@ -2346,139 +2346,6 @@ mmix_shiftable_wyde_value (unsigned HOST
return 1;
}
-/* True if this is an address_operand or a symbolic operand. */
-
-int
-mmix_symbolic_or_address_operand (rtx op, enum machine_mode mode)
-{
- switch (GET_CODE (op))
- {
- case SYMBOL_REF:
- case LABEL_REF:
- return 1;
- case CONST:
- op = XEXP (op, 0);
- if ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
- || GET_CODE (XEXP (op, 0)) == LABEL_REF)
- && (GET_CODE (XEXP (op, 1)) == CONST_INT
- || (GET_CODE (XEXP (op, 1)) == CONST_DOUBLE
- && GET_MODE (XEXP (op, 1)) == VOIDmode)))
- return 1;
- /* Fall through. */
- default:
- return address_operand (op, mode);
- }
-}
-
-/* True if this is a register or CONST_INT (or CONST_DOUBLE for DImode).
- We could narrow the value down with a couple of predicated, but that
- doesn't seem to be worth it at the moment. */
-
-int
-mmix_reg_or_constant_operand (rtx op, enum machine_mode mode)
-{
- return register_operand (op, mode)
- || (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == VOIDmode)
- || GET_CODE (op) == CONST_INT;
-}
-
-/* True if this is a register with a condition-code mode. */
-
-int
-mmix_reg_cc_operand (rtx op, enum machine_mode mode)
-{
- if (mode == VOIDmode)
- mode = GET_MODE (op);
-
- return register_operand (op, mode)
- && (mode == CCmode || mode == CC_UNSmode || mode == CC_FPmode
- || mode == CC_FPEQmode || mode == CC_FUNmode);
-}
-
-/* True if this is a foldable comparison operator
- - one where a the result of (compare:CC (reg) (const_int 0)) can be
- replaced by (reg). */
-
-int
-mmix_foldable_comparison_operator (rtx op, enum machine_mode mode)
-{
- RTX_CODE code = GET_CODE (op);
-
- if (mode == VOIDmode)
- mode = GET_MODE (op);
-
- if (mode == VOIDmode && COMPARISON_P (op))
- mode = GET_MODE (XEXP (op, 0));
-
- return ((mode == CCmode || mode == DImode)
- && (code == NE || code == EQ || code == GE || code == GT
- || code == LE))
- /* FIXME: This may be a stupid trick. What happens when GCC wants to
- reverse the condition? Can it do that by itself? Maybe it can
- even reverse the condition to fit a foldable one in the first
- place? */
- || (mode == CC_UNSmode && (code == GTU || code == LEU));
-}
-
-/* Like comparison_operator, but only true if this comparison operator is
- applied to a valid mode. Needed to avoid jump.c generating invalid
- code with -ffast-math (gcc.dg/20001228-1.c). */
-
-int
-mmix_comparison_operator (rtx op, enum machine_mode mode)
-{
- RTX_CODE code = GET_CODE (op);
-
- /* Comparison operators usually don't have a mode, but let's try and get
- one anyway for the day that changes. */
- if (mode == VOIDmode)
- mode = GET_MODE (op);
-
- /* Get the mode from the first operand if we don't have one. */
- if (mode == VOIDmode && COMPARISON_P (op))
- mode = GET_MODE (XEXP (op, 0));
-
- /* FIXME: This needs to be kept in sync with the tables in
- mmix_output_condition. */
- return
- (mode == VOIDmode && COMPARISON_P (op))
- || (mode == CC_FUNmode
- && (code == ORDERED || code == UNORDERED))
- || (mode == CC_FPmode
- && (code == GT || code == LT))
- || (mode == CC_FPEQmode
- && (code == NE || code == EQ))
- || (mode == CC_UNSmode
- && (code == GEU || code == GTU || code == LEU || code == LTU))
- || (mode == CCmode
- && (code == NE || code == EQ || code == GE || code == GT
- || code == LE || code == LT))
- || (mode == DImode
- && (code == NE || code == EQ || code == GE || code == GT
- || code == LE || code == LT || code == LEU || code == GTU));
-}
-
-/* True if this is a register or 0 (int or float). */
-
-int
-mmix_reg_or_0_operand (rtx op, enum machine_mode mode)
-{
- /* FIXME: Is mode calculation necessary and correct? */
- return
- op == CONST0_RTX (mode == VOIDmode ? GET_MODE (op) : mode)
- || register_operand (op, mode);
-}
-
-/* True if this is a register or an int 0..255. */
-
-int
-mmix_reg_or_8bit_operand (rtx op, enum machine_mode mode)
-{
- return register_operand (op, mode)
- || (GET_CODE (op) == CONST_INT
- && CONST_OK_FOR_LETTER_P (INTVAL (op), 'I'));
-}
-
/* Returns zero if code and mode is not a valid condition from a
compare-type insn. Nonzero if it is. The parameter op, if non-NULL,
is the comparison of mode is CC-somethingmode. */
Index: mmix.h
===================================================================
RCS file: /home/kazu/nobackup/gcc-cvs/gcc/gcc/config/mmix/mmix.h,v
retrieving revision 1.71
diff -u -d -p -r1.71 mmix.h
--- mmix.h 30 Dec 2004 01:16:09 -0000 1.71
+++ mmix.h 4 Apr 2005 00:18:27 -0000
@@ -1045,27 +1045,6 @@ typedef struct { int regs; int lib; } CU
/* Node: Misc */
-#define PREDICATE_CODES \
- {"mmix_reg_cc_operand", {SUBREG, REG}}, \
- {"mmix_foldable_comparison_operator", \
- {NE, EQ, GE, GT, LE, LT}}, \
- /* All '<', actually. */ \
- {"mmix_comparison_operator", \
- {NE, EQ, GE, GT, LE, LT, GEU, GTU, LEU, \
- LTU, UNORDERED, ORDERED, UNEQ, UNGE, UNLE, \
- UNLT, LTGT}}, \
- {"mmix_symbolic_or_address_operand", \
- {SYMBOL_REF, LABEL_REF, CONST, \
- SUBREG, REG, PLUS}}, \
- {"mmix_reg_or_constant_operand", \
- {CONST_INT, CONST_DOUBLE, SUBREG, REG}}, \
- {"mmix_reg_or_8bit_operand", \
- {CONST_INT, CONST_DOUBLE, SUBREG, REG}}, \
- {"mmix_reg_or_0_operand", \
- {CONST_INT, CONST_DOUBLE, SUBREG, REG}},
-
-#define SPECIAL_MODE_PREDICATES "mmix_symbolic_or_address_operand",
-
/* There's no way to get a PC-relative offset into tables for SImode, so
for the moment we have absolute entries in DImode.
When we're going ELF, these should be SImode and 1. */
Index: mmix.md
===================================================================
RCS file: /home/kazu/nobackup/gcc-cvs/gcc/gcc/config/mmix/mmix.md,v
retrieving revision 1.25
diff -u -d -p -r1.25 mmix.md
--- mmix.md 28 Nov 2004 09:48:27 -0000 1.25
+++ mmix.md 4 Apr 2005 00:49:04 -0000
@@ -1,5 +1,5 @@
;; GCC machine description for MMIX
-;; Copyright (C) 2000, 2001, 2002, 2003, 2004
+;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
;; Free Software Foundation, Inc.
;; Contributed by Hans-Peter Nilsson (hp@bitrange.com)
@@ -41,6 +41,8 @@
(MMIX_fp_rO_OFFSET -24)]
)
+(include "predicates.md")
+
;; FIXME: Can we remove the reg-to-reg for smaller modes? Shouldn't they
;; be synthesized ok?
(define_insn "movqi"
--- /dev/null 2005-03-29 05:55:50.256877624 -0500
+++ predicates.md 2005-04-03 20:48:57.277914832 -0400
@@ -0,0 +1,152 @@
+;; Predicate definitions for MMIX.
+;; Copyright (C) 2005 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 2, 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 COPYING. If not, write to
+;; the Free Software Foundation, 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;; True if this is a register with a condition-code mode.
+
+(define_predicate "mmix_reg_cc_operand"
+ (match_code "subreg,reg")
+{
+ if (mode == VOIDmode)
+ mode = GET_MODE (op);
+
+ return register_operand (op, mode)
+ && (mode == CCmode || mode == CC_UNSmode || mode == CC_FPmode
+ || mode == CC_FPEQmode || mode == CC_FUNmode);
+})
+
+;; True if this is a foldable comparison operator
+;; - one where a the result of (compare:CC (reg) (const_int 0)) can be
+;; replaced by (reg).
+
+(define_predicate "mmix_foldable_comparison_operator"
+ (match_code "ne,eq,ge,gt,le,lt")
+{
+ RTX_CODE code = GET_CODE (op);
+
+ if (mode == VOIDmode)
+ mode = GET_MODE (op);
+
+ if (mode == VOIDmode && COMPARISON_P (op))
+ mode = GET_MODE (XEXP (op, 0));
+
+ return ((mode == CCmode || mode == DImode)
+ && (code == NE || code == EQ || code == GE || code == GT
+ || code == LE))
+ /* FIXME: This may be a stupid trick. What happens when GCC wants to
+ reverse the condition? Can it do that by itself? Maybe it can
+ even reverse the condition to fit a foldable one in the first
+ place? */
+ || (mode == CC_UNSmode && (code == GTU || code == LEU));
+})
+
+;; Like comparison_operator, but only true if this comparison operator
+;; is applied to a valid mode. Needed to avoid jump.c generating
+;; invalid code with -ffast-math (gcc.dg/20001228-1.c).
+
+(define_predicate "mmix_comparison_operator"
+ (match_code "ne,eq,ge,gt,le,lt,geu,gtu,leu,ltu,unordered,ordered,uneq,unge,unle,unlt,ltgt")
+{
+ RTX_CODE code = GET_CODE (op);
+
+ /* Comparison operators usually don't have a mode, but let's try and get
+ one anyway for the day that changes. */
+ if (mode == VOIDmode)
+ mode = GET_MODE (op);
+
+ /* Get the mode from the first operand if we don't have one. */
+ if (mode == VOIDmode && COMPARISON_P (op))
+ mode = GET_MODE (XEXP (op, 0));
+
+ /* FIXME: This needs to be kept in sync with the tables in
+ mmix_output_condition. */
+ return
+ (mode == VOIDmode && COMPARISON_P (op))
+ || (mode == CC_FUNmode
+ && (code == ORDERED || code == UNORDERED))
+ || (mode == CC_FPmode
+ && (code == GT || code == LT))
+ || (mode == CC_FPEQmode
+ && (code == NE || code == EQ))
+ || (mode == CC_UNSmode
+ && (code == GEU || code == GTU || code == LEU || code == LTU))
+ || (mode == CCmode
+ && (code == NE || code == EQ || code == GE || code == GT
+ || code == LE || code == LT))
+ || (mode == DImode
+ && (code == NE || code == EQ || code == GE || code == GT
+ || code == LE || code == LT || code == LEU || code == GTU));
+})
+
+;; True if this is an address_operand or a symbolic operand.
+
+(define_special_predicate "mmix_symbolic_or_address_operand"
+ (match_code "symbol_ref,label_ref,const,subreg,reg,plus")
+{
+ switch (GET_CODE (op))
+ {
+ case SYMBOL_REF:
+ case LABEL_REF:
+ return 1;
+ case CONST:
+ op = XEXP (op, 0);
+ if ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
+ || GET_CODE (XEXP (op, 0)) == LABEL_REF)
+ && (GET_CODE (XEXP (op, 1)) == CONST_INT
+ || (GET_CODE (XEXP (op, 1)) == CONST_DOUBLE
+ && GET_MODE (XEXP (op, 1)) == VOIDmode)))
+ return 1;
+ /* Fall through. */
+ default:
+ return address_operand (op, mode);
+ }
+})
+
+;; True if this is a register or CONST_INT (or CONST_DOUBLE for
+;; DImode). We could narrow the value down with a couple of
+;; predicated, but that doesn't seem to be worth it at the moment.
+
+(define_predicate "mmix_reg_or_constant_operand"
+ (match_code "const_int,const_double,subreg,reg")
+{
+ return register_operand (op, mode)
+ || (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == VOIDmode)
+ || GET_CODE (op) == CONST_INT;
+})
+
+;; True if this is a register or an int 0..255.
+
+(define_predicate "mmix_reg_or_8bit_operand"
+ (match_code "const_int,const_double,subreg,reg")
+{
+ return register_operand (op, mode)
+ || (GET_CODE (op) == CONST_INT
+ && CONST_OK_FOR_LETTER_P (INTVAL (op), 'I'));
+})
+
+;; True if this is a register or 0 (int or float).
+
+(define_predicate "mmix_reg_or_0_operand"
+ (match_code "const_int,const_double,subreg,reg")
+{
+ /* FIXME: Is mode calculation necessary and correct? */
+ return
+ op == CONST0_RTX (mode == VOIDmode ? GET_MODE (op) : mode)
+ || register_operand (op, mode);
+})