* rtl.def (define_constraint, define_register_constraint)

	(define_memory_constraint, define_address_constraint): New MD forms.
	* gensupport.c (process_rtx): Put define_constraint etc on the
	predicate queue.
	* genpreds.c (process_define_predicate): Adjust comment.  Validate
	the name, and call validate_exp to validate the expression.
	(mark_mode_tests, write_extract_subexp): Can assume correct input.
	(write_predicate_expr): Likewise.  NAME argument no longer necessary;
	all callers changed.
	(validate_exp, needs_variable, struct constraint_data)
	(constraints_by_letter_table, first_constraint, last_constraint_ptr)
	(FOR_ALL_CONSTRAINTS, generic_constraint_letters, const_int_constraints)
	(const_dbl_constraints, constraint_max_namelen)
	(have_register_constraints, have_memory_constraints)
	(have_address_constraints, have_address_constraints)
	(have_extra_constraints, have_const_int_constraints)
	(have_const_dbl_constraints, mangle, add_constraint)
	(process_define_constraint, process_define_register_constraint)
	(write_enum_constraint_num, write_lookup_constraint)
	(write_insn_constraint_len, write_regclass_for_constraint)
	(write_constraint_satisfied_p, write_insn_const_int_ok_for_constraint)
	(write_insn_extra_memory_constraint)
	(write_insn_extra_address_constraint)
	(write_satisfies_constraint_fns): New.
	(write_tm_preds_h): If we have new-style constraint definitions,
	prototype the functions generated from them, and define the
	old constraint interface (still used by generic code) in terms of
	those functions.
	(write_insn_preds_c): If we have new-style constraint definitions,
	generate all relevant functions from those definitions.
	(main): Handle define_constraint etc.
	* genoutput.c (struct constraint_data, indep_constraints)
	(mdep_constraint_letters, constraints_by_letter_table, note_constraint)
	(mdep_constraint_len): New data structures and functions, defined
	#ifdef USE_MD_CONSTRAINTS.
	(check_constraint_len): Don't define #ifdef USE_MD_CONSTRAINTS.
	(validate_insn_alternatives): If USE_MD_CONSTRAINTS is defined,
	use new logic to validate operand constraints against constraint
	definitions.
	(main): Process define_constraint etc. if USE_MD_CONSTRAINTS is
	defined.
	* defaults.h: If none of the old-style constraint macros are
	defined, define USE_MD_CONSTRAINTS; do not provide defaults for any
	old-style macros; and poison REG_CLASS_FROM_LETTER,
	CONST_OK_FOR_LETTER_P, CONST_DOUBLE_OK_FOR_LETTER_P, and
	EXTRA_CONSTRAINT.
	* recog.c (reg_fits_class_p): If cl is NO_REGS, return 0 immediately.
	* doc/md.texi: Document new constraint-definition mechanism and the
	C interface it provides.  Remove references to old mechanism
 	elsewhere in the document.
	(Machine Constraints): Use pathnames relative to gcc directory,
	i.e. config/ARCH/FILE.  Change i386 section to refer to
	config/i386/predicates.md; update that section to match docstrings.
	* doc/tm.texi: Move all documentation of the old constraint-
	definition macros to their own section, clearly mark as obsolete.

	* config/i386/predicates.md (R, q, Q, l, a, b, c, d, S, D, A, f, t)
	(u, y, x, Y, I, J, K, L, M, N, O, G, C, e, Z): New constraint
	definitions.
	* config/i386/i386.h (REG_CLASS_FROM_LETTER, CONST_OK_FOR_LETTER_P)
	(CONST_DOUBLE_OK_FOR_LETTER_P, EXTRA_CONSTRAINT): Delete.
	* config/i386/i386.md (*movdf_nointeger): Remove stray 'H' from
	constraint strings.
	(splits and peepholes): Use satisfies_constraint_*.
	* config/i386/i386.c (memory_address_length)
	(ix86_attr_length_immediate_default): Use satisfies_constraint_*.

From-SVN: r111508

13 files changed, 1678 insertions, 299 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index eadb2fe..7538a9f 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,72 @@
+2006-02-27  Zack Weinberg  <zackw@panix.com>
+
+	* rtl.def (define_constraint, define_register_constraint)
+	(define_memory_constraint, define_address_constraint): New MD forms.
+	* gensupport.c (process_rtx): Put define_constraint etc on the
+	predicate queue.
+	* genpreds.c (process_define_predicate): Adjust comment.  Validate
+	the name, and call validate_exp to validate the expression.
+	(mark_mode_tests, write_extract_subexp): Can assume correct input.
+	(write_predicate_expr): Likewise.  NAME argument no longer necessary;
+	all callers changed.
+	(validate_exp, needs_variable, struct constraint_data)
+	(constraints_by_letter_table, first_constraint, last_constraint_ptr)
+	(FOR_ALL_CONSTRAINTS, generic_constraint_letters, const_int_constraints)
+	(const_dbl_constraints, constraint_max_namelen)
+	(have_register_constraints, have_memory_constraints)
+	(have_address_constraints, have_address_constraints)
+	(have_extra_constraints, have_const_int_constraints)
+	(have_const_dbl_constraints, mangle, add_constraint)
+	(process_define_constraint, process_define_register_constraint)
+	(write_enum_constraint_num, write_lookup_constraint)
+	(write_insn_constraint_len, write_regclass_for_constraint)
+	(write_constraint_satisfied_p, write_insn_const_int_ok_for_constraint)
+	(write_insn_extra_memory_constraint)
+	(write_insn_extra_address_constraint)
+	(write_satisfies_constraint_fns): New.
+	(write_tm_preds_h): If we have new-style constraint definitions,
+	prototype the functions generated from them, and define the
+	old constraint interface (still used by generic code) in terms of
+	those functions.
+	(write_insn_preds_c): If we have new-style constraint definitions,
+	generate all relevant functions from those definitions.
+	(main): Handle define_constraint etc.
+	* genoutput.c (struct constraint_data, indep_constraints)
+	(mdep_constraint_letters, constraints_by_letter_table, note_constraint)
+	(mdep_constraint_len): New data structures and functions, defined
+	#ifdef USE_MD_CONSTRAINTS.
+	(check_constraint_len): Don't define #ifdef USE_MD_CONSTRAINTS.
+	(validate_insn_alternatives): If USE_MD_CONSTRAINTS is defined,
+	use new logic to validate operand constraints against constraint
+	definitions.
+	(main): Process define_constraint etc. if USE_MD_CONSTRAINTS is
+	defined.
+	* defaults.h: If none of the old-style constraint macros are
+	defined, define USE_MD_CONSTRAINTS; do not provide defaults for any
+	old-style macros; and poison REG_CLASS_FROM_LETTER,
+	CONST_OK_FOR_LETTER_P, CONST_DOUBLE_OK_FOR_LETTER_P, and
+	EXTRA_CONSTRAINT.
+	* recog.c (reg_fits_class_p): If cl is NO_REGS, return 0 immediately.
+	* doc/md.texi: Document new constraint-definition mechanism and the
+	C interface it provides.  Remove references to old mechanism
+ 	elsewhere in the document.
+	(Machine Constraints): Use pathnames relative to gcc directory,
+	i.e. config/ARCH/FILE.  Change i386 section to refer to
+	config/i386/predicates.md; update that section to match docstrings.
+	* doc/tm.texi: Move all documentation of the old constraint-
+	definition macros to their own section, clearly mark as obsolete.
+
+	* config/i386/predicates.md (R, q, Q, l, a, b, c, d, S, D, A, f, t)
+	(u, y, x, Y, I, J, K, L, M, N, O, G, C, e, Z): New constraint
+	definitions.
+	* config/i386/i386.h (REG_CLASS_FROM_LETTER, CONST_OK_FOR_LETTER_P)
+	(CONST_DOUBLE_OK_FOR_LETTER_P, EXTRA_CONSTRAINT): Delete.
+	* config/i386/i386.md (*movdf_nointeger): Remove stray 'H' from
+	constraint strings.
+	(splits and peepholes): Use satisfies_constraint_*.
+	* config/i386/i386.c (memory_address_length)
+	(ix86_attr_length_immediate_default): Use satisfies_constraint_*.
+
 2006-02-27  Daniel Berlin  <dberlin@dberlin.org>
 
 	* lambda-code.c (can_convert_to_perfect_nest): Allow any type of
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index edfe04f..fae111e 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -13291,9 +13291,7 @@ memory_address_length (rtx addr)
       /* Find the length of the displacement constant.  */
       if (disp)
 	{
-	  if (GET_CODE (disp) == CONST_INT
-	      && CONST_OK_FOR_LETTER_P (INTVAL (disp), 'K')
-	      && base)
+	  if (base && satisfies_constraint_K (disp))
 	    len = 1;
 	  else
 	    len = 4;
@@ -13326,9 +13324,7 @@ ix86_attr_length_immediate_default (rtx insn, int shortform)
     if (CONSTANT_P (recog_data.operand[i]))
       {
 	gcc_assert (!len);
-	if (shortform
-	    && GET_CODE (recog_data.operand[i]) == CONST_INT
-	    && CONST_OK_FOR_LETTER_P (INTVAL (recog_data.operand[i]), 'K'))
+	if (shortform && satisfies_constraint_K (recog_data.operand[i]))
 	  len = 1;
 	else
 	  {
diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h
index 307cc97..fc8f626 100644
--- a/gcc/config/i386/i386.h
+++ b/gcc/config/i386/i386.h
@@ -1196,92 +1196,6 @@ enum reg_class
 #define INDEX_REG_CLASS INDEX_REGS
 #define BASE_REG_CLASS GENERAL_REGS
 
-/* Unused letters:
-    B                 TU W   
-          h jk          vw  z
-*/
-
-/* Get reg_class from a letter such as appears in the machine description.  */
-
-#define REG_CLASS_FROM_LETTER(C)	\
-  ((C) == 'r' ? GENERAL_REGS :					\
-   (C) == 'R' ? LEGACY_REGS :					\
-   (C) == 'q' ? TARGET_64BIT ? GENERAL_REGS : Q_REGS :		\
-   (C) == 'Q' ? Q_REGS :					\
-   (C) == 'f' ? (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387	\
-		 ? FLOAT_REGS					\
-		 : NO_REGS) :					\
-   (C) == 't' ? (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387	\
-		 ? FP_TOP_REG					\
-		 : NO_REGS) :					\
-   (C) == 'u' ? (TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387	\
-		 ? FP_SECOND_REG				\
-		 : NO_REGS) :					\
-   (C) == 'a' ? AREG :						\
-   (C) == 'b' ? BREG :						\
-   (C) == 'c' ? CREG :						\
-   (C) == 'd' ? DREG :						\
-   (C) == 'x' ? TARGET_SSE ? SSE_REGS : NO_REGS :		\
-   (C) == 'Y' ? TARGET_SSE2? SSE_REGS : NO_REGS :		\
-   (C) == 'y' ? TARGET_MMX ? MMX_REGS : NO_REGS :		\
-   (C) == 'A' ? AD_REGS :					\
-   (C) == 'D' ? DIREG :						\
-   (C) == 'S' ? SIREG :						\
-   (C) == 'l' ? INDEX_REGS :					\
-   NO_REGS)
-
-/* The letters I, J, K, L, M, N, and O in a register constraint string
-   can be used to stand for particular ranges of immediate operands.
-   This macro defines what the ranges are.
-   C is the letter, and VALUE is a constant value.
-   Return 1 if VALUE is in the range specified by C.
-
-   I is for non-DImode shifts.
-   J is for DImode shifts.
-   K is for signed imm8 operands.
-   L is for andsi as zero-extending move.
-   M is for shifts that can be executed by the "lea" opcode.
-   N is for immediate operands for out/in instructions (0-255)
-   O is for TImode shifts.
-   */
-
-#define CONST_OK_FOR_LETTER_P(VALUE, C)				\
-  ((C) == 'I' ? (VALUE) >= 0 && (VALUE) <= 31			\
-   : (C) == 'J' ? (VALUE) >= 0 && (VALUE) <= 63			\
-   : (C) == 'K' ? (VALUE) >= -128 && (VALUE) <= 127		\
-   : (C) == 'L' ? (VALUE) == 0xff || (VALUE) == 0xffff		\
-   : (C) == 'M' ? (VALUE) >= 0 && (VALUE) <= 3			\
-   : (C) == 'N' ? (VALUE) >= 0 && (VALUE) <= 255		\
-   : (C) == 'O' ? (VALUE) >= 0 && (VALUE) <= 127		\
-   : 0)
-
-/* Similar, but for floating constants, and defining letters G and H.
-   Here VALUE is the CONST_DOUBLE rtx itself.  We allow constants even if
-   TARGET_387 isn't set, because the stack register converter may need to
-   load 0.0 into the function value register.  */
-
-#define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)  \
-  ((C) == 'G' ? standard_80387_constant_p (VALUE) \
-   : 0)
-
-/* A C expression that defines the optional machine-dependent
-   constraint letters that can be used to segregate specific types of
-   operands, usually memory references, for the target machine.  Any
-   letter that is not elsewhere defined and not matched by
-   `REG_CLASS_FROM_LETTER' may be used.  Normally this macro will not
-   be defined.
-
-   If it is required for a particular target machine, it should
-   return 1 if VALUE corresponds to the operand type represented by
-   the constraint letter C.  If C is not defined as an extra
-   constraint, the value returned should be 0 regardless of VALUE.  */
-
-#define EXTRA_CONSTRAINT(VALUE, D)					\
-  ((D) == 'e' ? x86_64_immediate_operand (VALUE, VOIDmode)		\
-   : (D) == 'Z' ? x86_64_zext_immediate_operand (VALUE, VOIDmode)	\
-   : (D) == 'C' ? standard_sse_constant_p (VALUE)			\
-   : 0)
-
 /* Place additional restrictions on the register class to use when it
    is necessary to be able to hold a value of mode MODE in a reload
    register for which class CLASS would ordinarily be used.  */
diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
index 868d336..4e64da3 100644
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -2440,9 +2440,9 @@
 
 (define_insn "*movdf_nointeger"
   [(set (match_operand:DF 0 "nonimmediate_operand"
-			"=f#Y,m  ,f#Y,*r  ,o  ,Y*x#f,Y*x#f,Y*x#f  ,m    ")
+			"=f#Y,m  ,f#Y,*r  ,o  ,Y*x#f,Y*x#f,Y*x#f ,m    ")
 	(match_operand:DF 1 "general_operand"
-			"fm#Y,f#Y,G  ,*roF,F*r,C    ,Y*x#f,HmY*x#f,Y*x#f"))]
+			"fm#Y,f#Y,G  ,*roF,F*r,C    ,Y*x#f,mY*x#f,Y*x#f"))]
   "(GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)
    && ((optimize_size || !TARGET_INTEGER_DFMODE_MOVES) && !TARGET_64BIT)
    && (reload_in_progress || reload_completed
@@ -19038,8 +19038,9 @@
   "! TARGET_PARTIAL_REG_STALL && reload_completed
    && ((GET_MODE (operands[0]) == HImode 
 	&& ((!optimize_size && !TARGET_FAST_PREFIX)
+            /* ??? next two lines just !satisfies_constraint_K (...) */
 	    || GET_CODE (operands[2]) != CONST_INT
-	    || CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K')))
+	    || satisfies_constraint_K (operands[2])))
        || (GET_MODE (operands[0]) == QImode 
 	   && (TARGET_PROMOTE_QImode || optimize_size)))"
   [(parallel [(set (match_dup 0)
@@ -19361,8 +19362,7 @@
 	   (const_int 0)]))]
   "ix86_match_ccmode (insn, CCNOmode)
    && (true_regnum (operands[2]) != 0
-       || (GET_CODE (operands[3]) == CONST_INT
-	   && CONST_OK_FOR_LETTER_P (INTVAL (operands[3]), 'K')))
+       || satisfies_constraint_K (operands[3]))
    && peep2_reg_dead_p (1, operands[2])"
   [(parallel
      [(set (match_dup 0)
@@ -19928,8 +19928,7 @@
 			    (match_operand:DI 2 "immediate_operand" "")))
 	      (clobber (reg:CC FLAGS_REG))])]
   "(TARGET_K8 || TARGET_GENERIC64) && !optimize_size
-   && (GET_CODE (operands[2]) != CONST_INT
-       || !CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))"
+   && !satisfies_constraint_K (operands[2])"
   [(set (match_dup 3) (match_dup 1))
    (parallel [(set (match_dup 0) (mult:DI (match_dup 3) (match_dup 2)))
 	      (clobber (reg:CC FLAGS_REG))])]
@@ -19942,8 +19941,7 @@
 			    (match_operand:SI 2 "immediate_operand" "")))
 	      (clobber (reg:CC FLAGS_REG))])]
   "(TARGET_K8 || TARGET_GENERIC64) && !optimize_size
-   && (GET_CODE (operands[2]) != CONST_INT
-       || !CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))"
+   && !satisfies_constraint_K (operands[2])"
   [(set (match_dup 3) (match_dup 1))
    (parallel [(set (match_dup 0) (mult:SI (match_dup 3) (match_dup 2)))
 	      (clobber (reg:CC FLAGS_REG))])]
@@ -19957,8 +19955,7 @@
 			      (match_operand:SI 2 "immediate_operand" ""))))
 	      (clobber (reg:CC FLAGS_REG))])]
   "(TARGET_K8 || TARGET_GENERIC64) && !optimize_size
-   && (GET_CODE (operands[2]) != CONST_INT
-       || !CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))"
+   && !satisfies_constraint_K (operands[2])"
   [(set (match_dup 3) (match_dup 1))
    (parallel [(set (match_dup 0) (zero_extend:DI (mult:SI (match_dup 3) (match_dup 2))))
 	      (clobber (reg:CC FLAGS_REG))])]
@@ -19975,7 +19972,7 @@
 	      (clobber (reg:CC FLAGS_REG))])
    (match_scratch:DI 3 "r")]
   "(TARGET_K8 || TARGET_GENERIC64) && !optimize_size
-   && CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K')"
+   && satisfies_constraint_K (operands[2])"
   [(set (match_dup 3) (match_dup 2))
    (parallel [(set (match_dup 0) (mult:DI (match_dup 0) (match_dup 3)))
 	      (clobber (reg:CC FLAGS_REG))])]
@@ -19991,7 +19988,7 @@
 	      (clobber (reg:CC FLAGS_REG))])
    (match_scratch:SI 3 "r")]
   "(TARGET_K8 || TARGET_GENERIC64) && !optimize_size
-   && CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K')"
+   && satisfies_constraint_K (operands[2])"
   [(set (match_dup 3) (match_dup 2))
    (parallel [(set (match_dup 0) (mult:SI (match_dup 0) (match_dup 3)))
 	      (clobber (reg:CC FLAGS_REG))])]
diff --git a/gcc/config/i386/predicates.md b/gcc/config/i386/predicates.md
index acc01ee..d97f6fc 100644
--- a/gcc/config/i386/predicates.md
+++ b/gcc/config/i386/predicates.md
@@ -947,3 +947,137 @@
 
 (define_predicate "absneg_operator"
   (match_code "abs,neg"))
+
+;;; Constraint definitions.
+;;; Unused letters:
+;;;     B     H           TU W   
+;;;           h jk          vw  z
+
+;; Integer register constraints.
+;; It is not necessary to define 'r' here.
+(define_register_constraint "R" "LEGACY_REGS"
+ "Legacy register---the eight integer registers available on all
+  i386 processors (@code{a}, @code{b}, @code{c}, @code{d},
+  @code{si}, @code{di}, @code{bp}, @code{sp}).")
+
+(define_register_constraint "q" "TARGET_64BIT ? GENERAL_REGS : Q_REGS"
+ "Any register accessible as @code{@var{r}l}.  In 32-bit mode, @code{a},
+  @code{b}, @code{c}, and @code{d}; in 64-bit mode, any integer register.")
+
+(define_register_constraint "Q" "Q_REGS"
+ "Any register accessible as @code{@var{r}h}: @code{a}, @code{b},
+  @code{c}, and @code{d}.")
+
+(define_register_constraint "l" "INDEX_REGS"
+ "@internal Any register that can be used as the index in a base+index
+  memory access: that is, any general register except the stack pointer.")
+
+(define_register_constraint "a" "AREG"
+ "The @code{a} register.")
+
+(define_register_constraint "b" "BREG"
+ "The @code{b} register.")
+
+(define_register_constraint "c" "CREG"
+ "The @code{c} register.")
+
+(define_register_constraint "d" "DREG"
+ "The @code{d} register.")
+
+(define_register_constraint "S" "SIREG"
+ "The @code{si} register.")
+
+(define_register_constraint "D" "DIREG"
+ "The @code{di} register.")
+
+(define_register_constraint "A" "AD_REGS"
+ "The @code{a} and @code{d} registers, as a pair (for instructions
+  that return half the result in one and half in the other).")
+
+;; Floating-point register constraints.
+(define_register_constraint "f"
+ "TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ? FLOAT_REGS : NO_REGS"
+ "Any 80387 floating-point (stack) register.")
+
+(define_register_constraint "t"
+ "TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ? FP_TOP_REG : NO_REGS"
+ "Top of 80387 floating-point stack (@code{%st(0)}).")
+
+(define_register_constraint "u"
+ "TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ? FP_SECOND_REG : NO_REGS"
+ "Second from top of 80387 floating-point stack (@code{%st(1)}).")
+
+;; Vector registers (also used for plain floating point nowadays).
+(define_register_constraint "y" "TARGET_MMX ? MMX_REGS : NO_REGS"
+ "Any MMX register.")
+
+(define_register_constraint "x" "TARGET_SSE ? SSE_REGS : NO_REGS"
+ "Any SSE register.")
+
+(define_register_constraint "Y" "TARGET_SSE2? SSE_REGS : NO_REGS"
+ "@internal Any SSE2 register.")
+
+;; Integer constant constraints.
+(define_constraint "I"
+  "Integer constant in the range 0 @dots{} 31, for 32-bit shifts."
+  (and (match_code "const_int")
+       (match_test "ival >= 0 && ival <= 31")))
+
+(define_constraint "J"
+  "Integer constant in the range 0 @dots{} 63, for 64-bit shifts."
+  (and (match_code "const_int")
+       (match_test "ival >= 0 && ival <= 63")))
+
+(define_constraint "K"
+  "Signed 8-bit integer constant."
+  (and (match_code "const_int")
+       (match_test "ival >= -128 && ival <= 127")))
+
+(define_constraint "L"
+  "@code{0xFF} or @code{0xFFFF}, for andsi as a zero-extending move."
+  (and (match_code "const_int")
+       (match_test "ival == 0xFF || ival == 0xFFFF")))
+
+(define_constraint "M"
+  "0, 1, 2, or 3 (shifts for the @code{lea} instruction)."
+  (and (match_code "const_int")
+       (match_test "ival >= 0 && ival <= 3")))
+
+(define_constraint "N"
+  "Unsigned 8-bit integer constant (for @code{in} and @code{out} 
+   instructions)."
+  (and (match_code "const_int")
+       (match_test "ival >= 0 && ival <= 255")))
+
+(define_constraint "O"
+  "@internal Integer constant in the range 0 @dots{} 127, for 128-bit shifts."
+  (and (match_code "const_int")
+       (match_test "ival >= 0 && ival <= 127")))
+
+;; Floating-point constant constraints.
+;; We allow constants even if TARGET_80387 isn't set, because the
+;; stack register converter may need to load 0.0 into the function
+;; value register (top of stack).
+(define_constraint "G"
+  "Standard 80387 floating point constant."
+  (and (match_code "const_double")
+       (match_test "standard_80387_constant_p (op)")))
+
+;; This can theoretically be any mode's CONST0_RTX.
+(define_constraint "C"
+  "Standard SSE floating point constant."
+  (match_test "standard_sse_constant_p (op)"))
+
+;; Constant-or-symbol-reference constraints.
+
+(define_constraint "e"
+  "32-bit signed integer constant, or a symbolic reference known
+   to fit that range (for immediate operands in sign-extending x86-64
+   instructions)."
+  (match_operand 0 "x86_64_immediate_operand"))
+
+(define_constraint "Z"
+  "32-bit unsigned integer constant, or a symbolic reference known
+   to fit that range (for immediate operands in zero-extending x86-64
+   instructions)."
+  (match_operand 0 "x86_64_zext_immediate_operand"))
diff --git a/gcc/defaults.h b/gcc/defaults.h
index a82a723..624f039 100644
--- a/gcc/defaults.h
+++ b/gcc/defaults.h
@@ -752,6 +752,33 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #define DEFAULT_USE_CXA_ATEXIT 0
 #endif
 
+/* If none of these macros are defined, the port must use the new
+   technique of defining constraints in the machine description.
+   tm_p.h will define those macros that machine-independent code
+   still uses.  */
+#if  !defined CONSTRAINT_LEN			\
+  && !defined REG_CLASS_FROM_LETTER		\
+  && !defined REG_CLASS_FROM_CONSTRAINT		\
+  && !defined CONST_OK_FOR_LETTER_P		\
+  && !defined CONST_OK_FOR_CONSTRAINT_P		\
+  && !defined CONST_DOUBLE_OK_FOR_LETTER_P	\
+  && !defined CONST_DOUBLE_OK_FOR_CONSTRAINT_P  \
+  && !defined EXTRA_CONSTRAINT			\
+  && !defined EXTRA_CONSTRAINT_STR		\
+  && !defined EXTRA_MEMORY_CONSTRAINT		\
+  && !defined EXTRA_ADDRESS_CONSTRAINT
+
+#define USE_MD_CONSTRAINTS
+
+#if GCC_VERSION >= 3000 && defined IN_GCC
+/* These old constraint macros shouldn't appear anywhere in a
+   configuration using MD constraint definitions.  */
+#pragma GCC poison REG_CLASS_FROM_LETTER CONST_OK_FOR_LETTER_P \
+                   CONST_DOUBLE_OK_FOR_LETTER_P EXTRA_CONSTRAINT
+#endif
+
+#else /* old constraint mechanism in use */
+
 /* Determine whether extra constraint letter should be handled
    via address reload (like 'o').  */
 #ifndef EXTRA_MEMORY_CONSTRAINT
@@ -791,6 +818,8 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #define EXTRA_CONSTRAINT_STR(OP, C,STR) EXTRA_CONSTRAINT (OP, C)
 #endif
 
+#endif /* old constraint mechanism in use */
+
 #ifndef REGISTER_MOVE_COST
 #define REGISTER_MOVE_COST(m, x, y) 2
 #endif
diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi
index 462509d..6a3300b 100644
--- a/gcc/doc/md.texi
+++ b/gcc/doc/md.texi
@@ -1051,6 +1051,8 @@ have.  Constraints can also require two operands to match.
 * Class Preferences::   Constraints guide which hard register to put things in.
 * Modifiers::           More precise control over effects of constraints.
 * Machine Constraints:: Existing constraints for some particular machines.
+* Define Constraints::  How to define machine-specific constraints.
+* C Constraint Interface:: How to test constraints from C code.
 @end menu
 @end ifset
 
@@ -1273,15 +1275,6 @@ Other letters can be defined in machine-dependent fashion to stand for
 particular classes of registers or other arbitrary operand types.
 @samp{d}, @samp{a} and @samp{f} are defined on the 68000/68020 to stand
 for data, address and floating point registers.
-
-@ifset INTERNALS
-The machine description macro @code{REG_CLASS_FROM_LETTER} has first
-cut at the otherwise unused letters.  If it evaluates to @code{NO_REGS},
-then @code{EXTRA_CONSTRAINT} is evaluated.
-
-A typical use for @code{EXTRA_CONSTRAINT} would be to distinguish certain
-types of memory references that affect other insn operands.
-@end ifset
 @end table
 
 @ifset INTERNALS
@@ -1624,35 +1617,16 @@ general-purpose registers respectively; @pxref{Simple Constraints}), and
 @samp{I}, usually the letter indicating the most common
 immediate-constant format.
 
-For each machine architecture, the
-@file{config/@var{machine}/@var{machine}.h} file defines additional
-constraints.  These constraints are used by the compiler itself for
-instruction generation, as well as for @code{asm} statements; therefore,
-some of the constraints are not particularly interesting for @code{asm}.
-The constraints are defined through these macros:
-
-@table @code
-@item REG_CLASS_FROM_LETTER
-Register class constraints (usually lowercase).
-
-@item CONST_OK_FOR_LETTER_P
-Immediate constant constraints, for non-floating point constants of
-word size or smaller precision (usually uppercase).
-
-@item CONST_DOUBLE_OK_FOR_LETTER_P
-Immediate constant constraints, for all floating point constants and for
-constants of greater than word size precision (usually uppercase).
-
-@item EXTRA_CONSTRAINT
-Special cases of registers or memory.  This macro is not required, and
-is only defined for some machines.
-@end table
-
-Inspecting these macro definitions in the compiler source for your
-machine is the best way to be certain you have the right constraints.
-However, here is a summary of the machine-dependent constraints
-available on some particular machines.
-
+Each architecture defines additional constraints.  These constraints
+are used by the compiler itself for instruction generation, as well as
+for @code{asm} statements; therefore, some of the constraints are not
+particularly useful for @code{asm}.  Here is a summary of some of the
+machine-dependent constraints available on some particular machines;
+it includes both constraints that are useful for @code{asm} and
+constraints that aren't.  The compiler source file mentioned in the
+table heading for each architecture is the definitive reference for
+the meanings of that architecture's constraints.
+ 
 @table @emph
 @item ARM family---@file{config/arm/arm.h}
 @table @code
@@ -1908,93 +1882,109 @@ A 15-bit signed integer constant.
 A positive 16-bit constant.
 @end table
 
-@item Intel 386---@file{config/i386/i386.h}
+@item Intel 386---@file{config/i386/predicates.md}
 @table @code
-@item q
-@samp{a}, @code{b}, @code{c}, or @code{d} register for the i386.
-For x86-64 it is equivalent to @samp{r} class (for 8-bit instructions that
-do not use upper halves).
-
-@item Q
-@samp{a}, @code{b}, @code{c}, or @code{d} register (for 8-bit instructions,
-that do use upper halves).
-
 @item R
-Legacy register---equivalent to @code{r} class in i386 mode.
-(for non-8-bit registers used together with 8-bit upper halves in a single
-instruction)
-
-@item A
-Specifies the @samp{a} or @samp{d} registers.  This is primarily useful
-for 64-bit integer values (when in 32-bit mode) intended to be returned
-with the @samp{d} register holding the most significant bits and the
-@samp{a} register holding the least significant bits.
+Legacy register---the eight integer registers available on all
+i386 processors (@code{a}, @code{b}, @code{c}, @code{d},
+@code{si}, @code{di}, @code{bp}, @code{sp}).
 
-@item f
-Floating point register
+@item q
+Any register accessible as @code{@var{r}l}.  In 32-bit mode, @code{a},
+@code{b}, @code{c}, and @code{d}; in 64-bit mode, any integer register.
 
-@item t
-First (top of stack) floating point register
+@item Q
+Any register accessible as @code{@var{r}h}: @code{a}, @code{b},
+@code{c}, and @code{d}.
 
-@item u
-Second floating point register
+@ifset INTERNALS
+@item l
+Any register that can be used as the index in a base+index memory
+access: that is, any general register except the stack pointer.
+@end ifset
 
 @item a
-@samp{a} register
+The @code{a} register.
 
 @item b
-@samp{b} register
+The @code{b} register.
 
 @item c
-@samp{c} register
-
-@item C
-Specifies constant that can be easily constructed in SSE register without
-loading it from memory.
+The @code{c} register.
 
 @item d
-@samp{d} register
+The @code{d} register.
+
+@item S
+The @code{si} register.
 
 @item D
-@samp{di} register
+The @code{di} register.
 
-@item S
-@samp{si} register
+@item A
+The @code{a} and @code{d} registers, as a pair (for instructions that
+return half the result in one and half in the other).
 
-@item x
-@samp{xmm} SSE register
+@item f
+Any 80387 floating-point (stack) register.
+
+@item t
+Top of 80387 floating-point stack (@code{%st(0)}).
+
+@item u
+Second from top of 80387 floating-point stack (@code{%st(1)}).
 
 @item y
-MMX register
+Any MMX register.
+
+@item x
+Any SSE register.
+
+@ifset INTERNALS
+@item Y
+Any SSE2 register.
+@end ifset
 
 @item I
-Constant in range 0 to 31 (for 32-bit shifts)
+Integer constant in the range 0 @dots{} 31, for 32-bit shifts.
 
 @item J
-Constant in range 0 to 63 (for 64-bit shifts)
+Integer constant in the range 0 @dots{} 63, for 64-bit shifts.
 
 @item K
-@samp{0xff}
+Signed 8-bit integer constant.
 
 @item L
-@samp{0xffff}
+@code{0xFF} or @code{0xFFFF}, for andsi as a zero-extending move.
 
 @item M
-0, 1, 2, or 3 (shifts for @code{lea} instruction)
+0, 1, 2, or 3 (shifts for the @code{lea} instruction).
 
 @item N
-Constant in range 0 to 255 (for @code{out} instruction)
+Unsigned 8-bit integer constant (for @code{in} and @code{out} 
+instructions).
 
-@item Z
-Constant in range 0 to @code{0xffffffff} or symbolic reference known to fit specified range.
-(for using immediates in zero extending 32-bit to 64-bit x86-64 instructions)
+@ifset INTERNALS
+@item O
+Integer constant in the range 0 @dots{} 127, for 128-bit shifts.
+@end ifset
+
+@item G
+Standard 80387 floating point constant.
+
+@item C
+Standard SSE floating point constant.
 
 @item e
-Constant in range @minus{}2147483648 to 2147483647 or symbolic reference known to fit specified range.
-(for using immediates in 64-bit x86-64 instructions)
+32-bit signed integer constant, or a symbolic reference known
+to fit that range (for immediate operands in sign-extending x86-64
+instructions).
+
+@item Z
+32-bit unsigned integer constant, or a symbolic reference known
+to fit that range (for immediate operands in zero-extending x86-64
+instructions).
 
-@item G
-Standard 80387 floating point constant
 @end table
 
 @item Intel IA-64---@file{config/ia64/ia64.h}
@@ -2868,6 +2858,257 @@ Unsigned constant valid for BccUI instructions
 @end table
 
 @ifset INTERNALS
+@node Define Constraints
+@subsection Defining Machine-Specific Constraints
+@cindex defining constraints
+@cindex constraints, defining
+
+Machine-specific constraints fall into two categories: register and
+non-register constraints.  Within the latter category, constraints
+which allow subsets of all possible memory or address operands should
+be specially marked, to give @code{reload} more information.
+
+Machine-specific constraints can be given names of arbitrary length,
+but they must be entirely composed of letters, digits, underscores
+(@samp{_}), and angle brackets (@samp{< >}).  Like C identifiers, they
+must begin with a letter or underscore. 
+
+In order to avoid ambiguity in operand constraint strings, no
+constraint can have a name that begins with any other constraint's
+name.  For example, if @code{x} is defined as a constraint name,
+@code{xy} may not be, and vice versa.  As a consequence of this rule,
+no constraint may begin with one of the generic constraint letters:
+@samp{E F V X g i m n o p r s}.
+
+Register constraints correspond directly to register classes.
+@xref{Register Classes}.  There is thus not much flexibility in their
+definitions.
+
+@deffn {MD Expression} define_register_constraint name regclass docstring
+All three arguments are string constants.
+@var{name} is the name of the constraint, as it will appear in
+@code{match_operand} expressions.  @var{regclass} can be either the
+name of the corresponding register class (@pxref{Register Classes}),
+or a C expression which evaluates to the appropriate register class.
+If it is an expression, it must have no side effects, and it cannot
+look at the operand.  The usual use of expressions is to map some
+register constraints to @code{NO_REGS} when the register class
+is not available on a given subarchitecture.
+
+@var{docstring} is a sentence documenting the meaning of the
+constraint.  Docstrings are explained further below.
+@end deffn
+
+Non-register constraints are more like predicates: the constraint
+definition gives a Boolean expression which indicates whether the
+constraint matches.
+
+@deffn {MD Expression} define_constraint name docstring exp
+The @var{name} and @var{docstring} arguments are the same as for
+@code{define_register_constraint}, but note that the docstring comes
+immediately after the name for these expressions.  @var{exp} is an RTL
+expression, obeying the same rules as the RTL expressions in predicate
+definitions.  @xref{Defining Predicates}, for details.  If it
+evaluates true, the constraint matches; if it evaluates false, it
+doesn't. Constraint expressions should indicate which RTL codes they
+might match, just like predicate expressions.
+
+@code{match_test} C expressions have access to the
+following variables:
+
+@table @var
+@item op
+The RTL object defining the operand.
+@item mode
+The machine mode of @var{op}.
+@item ival
+@samp{INTVAL (@var{op})}, if @var{op} is a @code{const_int}.
+@item hval
+@samp{CONST_DOUBLE_HIGH (@var{op})}, if @var{op} is an integer
+@code{const_double}.
+@item lval
+@samp{CONST_DOUBLE_LOW (@var{op})}, if @var{op} is an integer
+@code{const_double}.
+@item rval
+@samp{CONST_DOUBLE_REAL_VALUE (@var{op})}, if @var{op} is a floating-point
+@code{const_@/double}.
+@end table
+
+The @var{*val} variables should only be used once another piece of the
+expression has verified that @var{op} is the appropriate kind of RTL
+object.
+@end deffn
+
+Most non-register constraints should be defined with
+@code{define_constraint}.  The remaining two definition expressions
+are only appropriate for constraints that should be handled specially
+by @code{reload} if they fail to match.
+
+@deffn {MD Expression} define_memory_constraint name docstring exp
+Use this expression for constraints that match a subset of all memory
+operands: that is, @code{reload} can make them match by converting the
+operand to the form @samp{@w{(mem (reg @var{X}))}}, where @var{X} is a
+base register (from the register class specified by
+@code{BASE_REG_CLASS}, @pxref{Register Classes}).
+
+For example, on the S/390, some instructions do not accept arbitrary
+memory references, but only those that do not make use of an index
+register.  The constraint letter @samp{Q} is defined to represent a
+memory address of this type.  If @samp{Q} is defined with
+@code{define_memory_constraint}, a @samp{Q} constraint can handle any
+memory operand, because @code{reload} knows it can simply copy the
+memory address into a base register if required.  This is analogous to
+the way a @samp{o} constraint can handle any memory operand.
+
+The syntax and semantics are otherwise identical to
+@code{define_constraint}.
+@end deffn
+
+@deffn {MD Expression} define_address_constraint name docstring exp
+Use this expression for constraints that match a subset of all address
+operands: that is, @code{reload} can make the constraint match by
+converting the operand to the form @samp{@w{(reg @var{X})}}, again
+with @var{X} a base register.
+
+Constraints defined with @code{define_address_constraint} can only be
+used with the @code{address_operand} predicate, or machine-specific
+predicates that work the same way.  They are treated analogously to
+the generic @samp{p} constraint.
+
+The syntax and semantics are otherwise identical to
+@code{define_constraint}.
+@end deffn
+
+For historical reasons, names beginning with the letters @samp{G H}
+are reserved for constraints that match only @code{const_double}s, and
+names beginning with the letters @samp{I J K L M N O P} are reserved
+for constraints that match only @code{const_int}s.  This may change in
+the future.  For the time being, constraints with these names must be
+written in a stylized form, so that @code{genpreds} can tell you did
+it correctly:
+
+@smallexample
+@group
+(define_constraint "[@var{GHIJKLMNOP}]@dots{}"
+  "@var{doc}@dots{}"
+  (and (match_code "const_int")  ; @r{@code{const_double} for G/H}
+       @var{condition}@dots{}))            ; @r{usually a @code{match_test}}
+@end group
+@end smallexample
+@c the semicolons line up in the formatted manual
+
+It is fine to use names beginning with other letters for constraints
+that match @code{const_double}s or @code{const_int}s.
+
+Each docstring in a constraint definition should be one or more complete
+sentences, marked up in Texinfo format.  @emph{They are currently unused.}
+In the future they will be copied into the GCC manual, in @ref{Machine
+Constraints}, replacing the hand-maintained tables currently found in
+that section.  Also, in the future the compiler may use this to give
+more helpful diagnostics when poor choice of @code{asm} constraints
+causes a reload failure.
+
+If you put the pseudo-Texinfo directive @samp{@@internal} at the
+beginning of a docstring, then (in the future) it will appear only in
+the internals manual's version of the machine-specific constraint tables.
+Use this for constraints that should not appear in @code{asm} statements.
+
+@node C Constraint Interface
+@subsection Testing constraints from C
+@cindex testing constraints
+@cindex constraints, testing
+
+It is occasionally useful to test a constraint from C code rather than
+implicitly via the constraint string in a @code{match_operand}.  The
+generated file @file{tm_p.h} declares a few interfaces for working
+with machine-specific constraints.  None of these interfaces work with
+the generic constraints described in @ref{Simple Constraints}.  This
+may change in the future.
+
+@strong{Warning:} @file{tm_p.h} may declare other functions that
+operate on constraints, besides the ones documented here.  Do not use
+those functions from machine-dependent code.  They exist to implement
+the old constraint interface that machine-independent components of
+the compiler still expect.  They will change or disappear in the
+future.
+
+Some valid constraint names are not valid C identifiers, so there is a
+mangling scheme for referring to them from C@.  Constraint names that
+do not contain angle brackets or underscores are left unchanged.
+Underscores are doubled, each @samp{<} is replaced with @samp{_l}, and
+each @samp{>} with @samp{_g}.  Here are some examples:
+
+@c the @c's prevent double blank lines in the printed manual.
+@example
+@multitable {Original} {Mangled}
+@headitem Original @tab Mangled        @c
+@item @code{x}     @tab @code{x}       @c
+@item @code{P42x}  @tab @code{P42x}    @c
+@item @code{P4_x}  @tab @code{P4__x}   @c
+@item @code{P4>x}  @tab @code{P4_gx}   @c
+@item @code{P4>>}  @tab @code{P4_g_g}  @c
+@item @code{P4_g>} @tab @code{P4__g_g} @c
+@end multitable
+@end example
+
+Throughout this section, the variable @var{c} is either a constraint
+in the abstract sense, or a constant from @code{enum constraint_num};
+the variable @var{m} is a mangled constraint name (usually as part of
+a larger identifier).
+
+@deftp Enum constraint_num
+For each machine-specific constraint, there is a corresponding
+enumeration constant: @samp{CONSTRAINT_} plus the mangled name of the
+constraint.  Functions that take an @code{enum constraint_num} as an
+argument expect one of these constants.
+
+Machine-independent constraints do not have associated constants.
+This may change in the future.
+@end deftp
+
+@deftypefun {inline bool} satisfies_constraint_@var{m} (rtx @var{exp})
+For each machine-specific, non-register constraint @var{m}, there is
+one of these functions; it returns @code{true} if @var{exp} satisfies the
+constraint.  These functions are only visible if @file{rtl.h} was included
+before @file{tm_p.h}.
+@end deftypefun
+
+@deftypefun bool constraint_satisfied_p (rtx @var{exp}, enum constraint_num @var{c})
+Like the @code{satisfies_constraint_@var{m}} functions, but the
+constraint to test is given as an argument, @var{c}.  If @var{c}
+specifies a register constraint, this function will always return
+@code{false}.
+@end deftypefun
+
+@deftypefun {enum reg_class} regclass_for_constraint (enum constraint_num @var{c})
+Returns the register class associated with @var{c}.  If @var{c} is not
+a register constraint, or those registers are not available for the
+currently selected subtarget, returns @code{NO_REGS}.
+@end deftypefun
+
+Here is an example use of @code{satisfies_constraint_@var{m}}.  In
+peephole optimizations (@pxref{Peephole Definitions}), operand
+constraint strings are ignored, so if there are relevant constraints,
+they must be tested in the C condition.  In the example, the
+optimization is applied if operand 2 does @emph{not} satisfy the
+@samp{K} constraint.  (This is a simplified version of a peephole
+definition from the i386 machine description.)
+
+@smallexample
+(define_peephole2
+  [(match_scratch:SI 3 "r")
+   (set (match_operand:SI 0 "register_operand" "")
+	(mult:SI (match_operand:SI 1 "memory_operand" "")
+		 (match_operand:SI 2 "immediate_operand" "")))]
+
+  "!satisfies_constraint_K (operands[2])"
+
+  [(set (match_dup 3) (match_dup 1))
+   (set (match_dup 0) (mult:SI (match_dup 3) (match_dup 2)))]
+
+  "")
+@end smallexample
+
 @node Standard Names
 @section Standard Pattern Names For Generation
 @cindex standard pattern names
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index cebb71c..778ecc9 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -33,6 +33,7 @@ through the macros defined in the @file{.h} file.
 * Type Layout::         Defining sizes and properties of basic user data types.
 * Registers::           Naming and describing the hardware registers.
 * Register Classes::    Defining the classes of hardware registers.
+* Old Constraints::     The old way to define machine-specific constraints.
 * Stack and Calling::   Defining which way the stack grows and by how much.
 * Varargs::		Defining the varargs macros.
 * Trampolines::         Code set up at run time to enter a nested function.
@@ -2300,36 +2301,6 @@ address where its value is either multiplied by a scale factor or
 added to another register (as well as added to a displacement).
 @end defmac
 
-@defmac CONSTRAINT_LEN (@var{char}, @var{str})
-For the constraint at the start of @var{str}, which starts with the letter
-@var{c}, return the length.  This allows you to have register class /
-constant / extra constraints that are longer than a single letter;
-you don't need to define this macro if you can do with single-letter
-constraints only.  The definition of this macro should use
-DEFAULT_CONSTRAINT_LEN for all the characters that you don't want
-to handle specially.
-There are some sanity checks in genoutput.c that check the constraint lengths
-for the md file, so you can also use this macro to help you while you are
-transitioning from a byzantine single-letter-constraint scheme: when you
-return a negative length for a constraint you want to re-use, genoutput
-will complain about every instance where it is used in the md file.
-@end defmac
-
-@defmac REG_CLASS_FROM_LETTER (@var{char})
-A C expression which defines the machine-dependent operand constraint
-letters for register classes.  If @var{char} is such a letter, the
-value should be the register class corresponding to it.  Otherwise,
-the value should be @code{NO_REGS}.  The register letter @samp{r},
-corresponding to class @code{GENERAL_REGS}, will not be passed
-to this macro; you do not need to handle it.
-@end defmac
-
-@defmac REG_CLASS_FROM_CONSTRAINT (@var{char}, @var{str})
-Like @code{REG_CLASS_FROM_LETTER}, but you also get the constraint string
-passed in @var{str}, so that you can use suffixes to distinguish between
-different variants.
-@end defmac
-
 @defmac REGNO_OK_FOR_BASE_P (@var{num})
 A C expression which is nonzero if register number @var{num} is
 suitable for use as a base register in operand addresses.  It may be
@@ -2682,8 +2653,45 @@ as below:
 @end smallexample
 @end defmac
 
-Three other special macros describe which operands fit which constraint
-letters.
+@node Old Constraints
+@section Obsolete Macros for Defining Constraints
+@cindex defining constraints, obsolete method
+@cindex constraints, defining, obsolete method
+
+Machine-specific constraints can be defined with these macros instead
+of the machine description constructs described in @ref{Define
+Constraints}.  This mechanism is obsolete.  New ports should not use
+it; old ports should convert to the new mechanism.
+
+@defmac CONSTRAINT_LEN (@var{char}, @var{str})
+For the constraint at the start of @var{str}, which starts with the letter
+@var{c}, return the length.  This allows you to have register class /
+constant / extra constraints that are longer than a single letter;
+you don't need to define this macro if you can do with single-letter
+constraints only.  The definition of this macro should use
+DEFAULT_CONSTRAINT_LEN for all the characters that you don't want
+to handle specially.
+There are some sanity checks in genoutput.c that check the constraint lengths
+for the md file, so you can also use this macro to help you while you are
+transitioning from a byzantine single-letter-constraint scheme: when you
+return a negative length for a constraint you want to re-use, genoutput
+will complain about every instance where it is used in the md file.
+@end defmac
+
+@defmac REG_CLASS_FROM_LETTER (@var{char})
+A C expression which defines the machine-dependent operand constraint
+letters for register classes.  If @var{char} is such a letter, the
+value should be the register class corresponding to it.  Otherwise,
+the value should be @code{NO_REGS}.  The register letter @samp{r},
+corresponding to class @code{GENERAL_REGS}, will not be passed
+to this macro; you do not need to handle it.
+@end defmac
+
+@defmac REG_CLASS_FROM_CONSTRAINT (@var{char}, @var{str})
+Like @code{REG_CLASS_FROM_LETTER}, but you also get the constraint string
+passed in @var{str}, so that you can use suffixes to distinguish between
+different variants.
+@end defmac
 
 @defmac CONST_OK_FOR_LETTER_P (@var{value}, @var{c})
 A C expression that defines the machine-dependent operand constraint
diff --git a/gcc/genoutput.c b/gcc/genoutput.c
index 7d1feb6..4eac581 100644
--- a/gcc/genoutput.c
+++ b/gcc/genoutput.c
@@ -54,12 +54,10 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
      a. `predicate', an int-valued function, is the match_operand predicate
      for this operand.
 
-     b. `constraint' is the constraint for this operand.  This exists
-     only if register constraints appear in match_operand rtx's.
+     b. `constraint' is the constraint for this operand.
 
      c. `address_p' indicates that the operand appears within ADDRESS
-     rtx's.  This exists only if there are *no* register constraints
-     in the match_operand rtx's.
+     rtx's.
 
      d. `mode' is the machine mode that that operand is supposed to have.
 
@@ -189,8 +187,35 @@ static void gen_insn (rtx, int);
 static void gen_peephole (rtx, int);
 static void gen_expand (rtx, int);
 static void gen_split (rtx, int);
+
+#ifdef USE_MD_CONSTRAINTS
+
+struct constraint_data
+{
+  struct constraint_data *next_this_letter;
+  int lineno;
+  unsigned int namelen;
+  const char name[1];
+};
+
+/* This is a complete list (unlike the one in genpreds.c) of constraint
+   letters and modifiers with machine-independent meaning.  The only
+   omission is digits, as these are handled specially.  */
+static const char indep_constraints[] = ",=+%*?!#&<>EFVXgimnoprs";
+
+static struct constraint_data *
+constraints_by_letter_table[1 << CHAR_BIT];
+
+static int mdep_constraint_len (const char *, int, int);
+static void note_constraint (rtx, int);
+
+#else  /* !USE_MD_CONSTRAINTS */
+
 static void check_constraint_len (void);
 static int constraint_len (const char *, int);
+
+#endif /* !USE_MD_CONSTRAINTS */
+
 
 static void
 output_prologue (void)
@@ -725,6 +750,20 @@ validate_insn_alternatives (struct data *d)
 
 	for (p = d->operand[start].constraint; (c = *p); p += len)
 	  {
+#ifdef USE_MD_CONSTRAINTS
+	    if (ISSPACE (c) || strchr (indep_constraints, c))
+	      len = 1;
+	    else if (ISDIGIT (c))
+	      {
+		const char *q = p;
+		do
+		  q++;
+		while (ISDIGIT (*q));
+		len = q - p;
+	      }
+	    else
+	      len = mdep_constraint_len (p, d->lineno, start);
+#else
 	    len = CONSTRAINT_LEN (c, p);
 
 	    if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
@@ -735,6 +774,7 @@ validate_insn_alternatives (struct data *d)
 		len = 1;
 		have_error = 1;
 	      }
+#endif
 
 	    if (c == ',')
 	      {
@@ -826,7 +866,9 @@ gen_insn (rtx insn, int lineno)
   d->n_operands = max_opno + 1;
   d->n_dups = num_dups;
 
+#ifndef USE_MD_CONSTRAINTS
   check_constraint_len ();
+#endif
   validate_insn_operands (d);
   validate_insn_alternatives (d);
   place_operands (d);
@@ -983,15 +1025,37 @@ main (int argc, char **argv)
       if (desc == NULL)
 	break;
 
-      if (GET_CODE (desc) == DEFINE_INSN)
-	gen_insn (desc, line_no);
-      if (GET_CODE (desc) == DEFINE_PEEPHOLE)
-	gen_peephole (desc, line_no);
-      if (GET_CODE (desc) == DEFINE_EXPAND)
-	gen_expand (desc, line_no);
-      if (GET_CODE (desc) == DEFINE_SPLIT
-	  || GET_CODE (desc) == DEFINE_PEEPHOLE2)
-	gen_split (desc, line_no);
+      switch (GET_CODE (desc))
+	{
+	case DEFINE_INSN:
+	  gen_insn (desc, line_no);
+	  break;
+
+	case DEFINE_PEEPHOLE:
+	  gen_peephole (desc, line_no);
+	  break;
+
+	case DEFINE_EXPAND:
+	  gen_expand (desc, line_no);
+	  break;
+
+	case DEFINE_SPLIT:
+	case DEFINE_PEEPHOLE2:
+	  gen_split (desc, line_no);
+	  break;
+
+#ifdef USE_MD_CONSTRAINTS
+	case DEFINE_CONSTRAINT:
+	case DEFINE_REGISTER_CONSTRAINT:
+	case DEFINE_ADDRESS_CONSTRAINT:
+	case DEFINE_MEMORY_CONSTRAINT:
+	  note_constraint (desc, line_no);
+	  break;
+#endif
+
+	default:
+	  break;
+	}
       next_index_number++;
     }
 
@@ -1043,6 +1107,102 @@ strip_whitespace (const char *s)
   return q;
 }
 
+#ifdef USE_MD_CONSTRAINTS
+
+/* Record just enough information about a constraint to allow checking
+   of operand constraint strings above, in validate_insn_alternatives.
+   Does not validate most properties of the constraint itself; does
+   enforce no duplicate names, no overlap with MI constraints, and no
+   prefixes.  EXP is the define_*constraint form, LINENO the line number
+   reported by the reader.  */
+static void
+note_constraint (rtx exp, int lineno)
+{
+  const char *name = XSTR (exp, 0);
+  unsigned int namelen = strlen (name);
+  struct constraint_data **iter, **slot, *new;
+
+  if (strchr (indep_constraints, name[0]))
+    {
+      if (name[1] == '\0')
+	message_with_line (lineno, "constraint letter '%s' cannot be "
+			   "redefined by the machine description", name);
+      else
+	message_with_line (lineno, "constraint name '%s' cannot be defined by "
+			   "the machine description, as it begins with '%c'",
+			   name, name[0]);
+      have_error = 1;
+      return;
+    }
+
+  slot = &constraints_by_letter_table[(unsigned int)name[0]];
+  for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
+    {
+      /* This causes slot to end up pointing to the
+	 next_this_letter field of the last constraint with a name
+	 of equal or greater length than the new constraint; hence
+	 the new constraint will be inserted after all previous
+	 constraints with names of the same length.  */
+      if ((*iter)->namelen >= namelen)
+	slot = iter;
+
+      if (!strcmp ((*iter)->name, name))
+	{
+	  message_with_line (lineno, "redefinition of constraint '%s'", name);
+	  message_with_line ((*iter)->lineno, "previous definition is here");
+	  have_error = 1;
+	  return;
+	}
+      else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
+	{
+	  message_with_line (lineno, "defining constraint '%s' here", name);
+	  message_with_line ((*iter)->lineno, "renders constraint '%s' "
+			     "(defined here) a prefix", (*iter)->name);
+	  have_error = 1;
+	  return;
+	}
+      else if (!strncmp ((*iter)->name, name, namelen))
+	{
+	  message_with_line (lineno, "constraint '%s' is a prefix", name);
+	  message_with_line ((*iter)->lineno, "of constraint '%s' "
+			     "(defined here)", (*iter)->name);
+	  have_error = 1;
+	  return;
+	}
+    }
+  new = xmalloc (sizeof (struct constraint_data) + namelen);
+  strcpy ((char *)new + offsetof(struct constraint_data, name), name);
+  new->namelen = namelen;
+  new->lineno = lineno;
+  new->next_this_letter = *slot;
+  *slot = new;
+}
+
+/* Return the length of the constraint name beginning at position S
+   of an operand constraint string, or issue an error message if there
+   is no such constraint.  Does not expect to be called for generic
+   constraints.  */
+static int
+mdep_constraint_len (const char *s, int lineno, int opno)
+{
+  struct constraint_data *p;
+
+  p = constraints_by_letter_table[(unsigned int)s[0]];
+
+  if (p)
+    for (; p; p = p->next_this_letter)
+      if (!strncmp (s, p->name, p->namelen))
+	return p->namelen;
+
+  message_with_line (lineno,
+		     "error: undefined machine-specific constraint "
+		     "at this point: \"%s\"", s);
+  message_with_line (lineno, "note:  in operand %d", opno);
+  have_error = 1;
+  return 1; /* safe */
+}
+
+#else
 /* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not
    tampered with.  This isn't bullet-proof, but it should catch
    most genuine mistakes.  */
@@ -1076,3 +1236,4 @@ constraint_len (const char *p, int genoutput_default_constraint_len)
 #undef DEFAULT_CONSTRAINT_LEN
 #define DEFAULT_CONSTRAINT_LEN(C,STR) 1
 }
+#endif
diff --git a/gcc/genpreds.c b/gcc/genpreds.c
index bfd681c..9c0bb35 100644
--- a/gcc/genpreds.c
+++ b/gcc/genpreds.c
@@ -27,57 +27,102 @@ Boston, MA 02110-1301, USA.  */
 #include "tm.h"
 #include "rtl.h"
 #include "errors.h"
-#include "gensupport.h"
 #include "obstack.h"
+#include "gensupport.h"
 
-/* The new way to declare predicates is with (define_predicate) or
-   (define_special_predicate) expressions in the machine description.
-   This provides a function body as well as a name.  */
-static void
-process_define_predicate (rtx defn)
+/* Given a predicate expression EXP, from form NAME at line LINENO,
+   verify that it does not contain any RTL constructs which are not
+   valid in predicate definitions.  Returns true if EXP is
+   INvalid; issues error messages, caller need not.  */
+static bool
+validate_exp (rtx exp, const char *name, int lineno)
 {
-  struct pred_data *pred;
-  if (XEXP (defn, 1) == 0)
+  if (exp == 0)
     {
-      error ("%s: must give a predicate expression", XSTR (defn, 0));
-      return;
+      message_with_line (lineno, "%s: must give a predicate expression", name);
+      return true;
     }
 
-  pred = XCNEW (struct pred_data);
-  pred->name    = XSTR (defn, 0);
-  pred->exp     = XEXP (defn, 1);
-  pred->c_block = XSTR (defn, 2);
+  switch (GET_CODE (exp))
+    {
+      /* Ternary, binary, unary expressions: recurse into subexpressions.  */
+    case IF_THEN_ELSE:
+      if (validate_exp (XEXP (exp, 2), name, lineno))
+	return true;
+      /* else fall through */
+    case AND:
+    case IOR:
+      if (validate_exp (XEXP (exp, 1), name, lineno))
+	return true;
+      /* else fall through */
+    case NOT:
+      return validate_exp (XEXP (exp, 0), name, lineno);
 
-  if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
-    pred->special = true;
+      /* MATCH_CODE might have a syntax error in its path expression.  */
+    case MATCH_CODE:
+      {
+	const char *p;
+	for (p = XSTR (exp, 1); *p; p++)
+	  {
+	    if (!ISDIGIT (*p) && !ISLOWER (*p))
+	      {
+		message_with_line (lineno, "%s: invalid character in path "
+				   "string '%s'", name, XSTR (exp, 1));
+		have_error = 1;
+		return true;
+	      }
+	  }
+      }
+      /* fall through */
 
-  add_predicate (pred);
+      /* These need no special checking.  */
+    case MATCH_OPERAND:
+    case MATCH_TEST:
+      return false;
+
+    default:
+      message_with_line (lineno,
+			 "%s: cannot use '%s' in a predicate expression",
+			 name, GET_RTX_NAME (GET_CODE (exp)));
+      have_error = 1;
+      return true;
+    }
 }
 
-/* Write tm-preds.h.  Unfortunately, it is impossible to forward-declare
-   an enumeration in portable C, so we have to condition all these
-   prototypes on HAVE_MACHINE_MODES.  */
+/* Predicates are defined with (define_predicate) or
+   (define_special_predicate) expressions in the machine description.  */
 static void
-write_tm_preds_h (void)
+process_define_predicate (rtx defn, int lineno)
 {
-  struct pred_data *p;
+  struct pred_data *pred;
+  const char *p;
 
-  printf ("\
-/* Generated automatically by the program '%s'\n\
-   from the machine description file '%s'.  */\n\n", progname, in_fname);
+  if (!ISALPHA (XSTR (defn, 0)[0]) && XSTR (defn, 0)[0] != '_')
+    goto bad_name;
+  for (p = XSTR (defn, 0) + 1; *p; p++)
+    if (!ISALNUM (*p) && *p != '_')
+      goto bad_name;
+  
+  if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno))
+    return;
 
-  puts ("\
-#ifndef GCC_TM_PREDS_H\n\
-#define GCC_TM_PREDS_H\n\
-\n\
-#ifdef HAVE_MACHINE_MODES");
+  pred = XCNEW (struct pred_data);
+  pred->name = XSTR (defn, 0);
+  pred->exp = XEXP (defn, 1);
+  pred->c_block = XSTR (defn, 2);
 
-  FOR_ALL_PREDICATES (p)
-    printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
+  if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
+    pred->special = true;
 
-  puts ("\
-#endif /* HAVE_MACHINE_MODES */\n\
-#endif /* tm-preds.h */");
+  add_predicate (pred);
+  return;
+
+ bad_name:
+  message_with_line (lineno,
+		     "%s: predicate name must be a valid C function name",
+		     XSTR (defn, 0));
+  have_error = 1;
+  return;
 }
 
 /* Given a predicate, if it has an embedded C block, write the block
@@ -146,6 +191,59 @@ write_predicate_subfunction (struct pred_data *p)
   fputs ("\n\n", stdout);
 }
 
+/* Given a predicate expression EXP, from form NAME, determine whether
+   it refers to the variable given as VAR.  */
+static bool
+needs_variable (rtx exp, const char *var)
+{
+  switch (GET_CODE (exp))
+    {
+      /* Ternary, binary, unary expressions need a variable if
+	 any of their subexpressions do.  */
+    case IF_THEN_ELSE:
+      if (needs_variable (XEXP (exp, 2), var))
+	return true;
+      /* else fall through */
+    case AND:
+    case IOR:
+      if (needs_variable (XEXP (exp, 1), var))
+	return true;
+      /* else fall through */
+    case NOT:
+      return needs_variable (XEXP (exp, 0), var);
+
+      /* MATCH_CODE uses "op", but nothing else.  */
+    case MATCH_CODE:
+      return !strcmp (var, "op");
+
+      /* MATCH_OPERAND uses "op" and may use "mode".  */
+    case MATCH_OPERAND:
+      if (!strcmp (var, "op"))
+	return true;
+      if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode)
+	return true;
+      return false;
+
+      /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */
+    case MATCH_TEST:
+      {
+	const char *p = XSTR (exp, 0);
+	const char *q = strstr (p, var);
+	if (!q)
+	  return false;
+	if (q != p && (ISALNUM (q[-1]) || q[-1] == '_'))
+	  return false;
+	q += strlen (var);
+	if (ISALNUM (q[0] || q[0] == '_'))
+	  return false;
+      }
+      return true;
+
+    default:
+      gcc_unreachable ();
+    }
+}
+
 /* Given an RTL expression EXP, find all subexpressions which we may
    assume to perform mode tests.  Normal MATCH_OPERAND does;
    MATCH_CODE does if it applies to the whole expression and accepts
@@ -214,8 +312,7 @@ mark_mode_tests (rtx exp)
       break;
 
     default:
-      error ("'%s' cannot be used in a define_predicate expression",
-	     GET_RTX_NAME (GET_CODE (exp)));
+      gcc_unreachable ();
     }
 }
 
@@ -325,10 +422,7 @@ write_extract_subexp (const char *path)
       else if (ISDIGIT (path[i]))
 	fputs ("XEXP (", stdout);
       else
-	{
-	  error ("bad character in path string '%s'", path);
-	  return;
-	}
+	gcc_unreachable ();
     }
 
   fputs ("op", stdout);
@@ -370,39 +464,39 @@ write_match_code (const char *path, const char *codes)
 /* EXP is an RTL (sub)expression for a predicate.  Recursively
    descend the expression and write out an equivalent C expression.  */
 static void
-write_predicate_expr (const char *name, rtx exp)
+write_predicate_expr (rtx exp)
 {
   switch (GET_CODE (exp))
     {
     case AND:
       putchar ('(');
-      write_predicate_expr (name, XEXP (exp, 0));
+      write_predicate_expr (XEXP (exp, 0));
       fputs (") && (", stdout);
-      write_predicate_expr (name, XEXP (exp, 1));
+      write_predicate_expr (XEXP (exp, 1));
       putchar (')');
       break;
   
     case IOR:
       putchar ('(');
-      write_predicate_expr (name, XEXP (exp, 0));
+      write_predicate_expr (XEXP (exp, 0));
       fputs (") || (", stdout);
-      write_predicate_expr (name, XEXP (exp, 1));
+      write_predicate_expr (XEXP (exp, 1));
       putchar (')');
       break;
 
     case NOT:
       fputs ("!(", stdout);
-      write_predicate_expr (name, XEXP (exp, 0));
+      write_predicate_expr (XEXP (exp, 0));
       putchar (')');
       break;
 
     case IF_THEN_ELSE:
       putchar ('(');
-      write_predicate_expr (name, XEXP (exp, 0));
+      write_predicate_expr (XEXP (exp, 0));
       fputs (") ? (", stdout);
-      write_predicate_expr (name, XEXP (exp, 1));
+      write_predicate_expr (XEXP (exp, 1));
       fputs (") : (", stdout);
-      write_predicate_expr (name, XEXP (exp, 2));
+      write_predicate_expr (XEXP (exp, 2));
       putchar (')');
       break;
 
@@ -422,9 +516,7 @@ write_predicate_expr (const char *name, rtx exp)
       break;
 
     default:
-      error ("%s: cannot use '%s' in a predicate expression",
-	     name, GET_RTX_NAME (GET_CODE (exp)));
-      putchar ('0');
+      gcc_unreachable ();
     }
 }
 
@@ -443,9 +535,651 @@ write_one_predicate_function (struct pred_data *p)
   printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n"
 	  "{\n  return ",
 	  p->name);
-  write_predicate_expr (p->name, p->exp);
+  write_predicate_expr (p->exp);
   fputs (";\n}\n\n", stdout);
 }
+
+/* Constraints fall into two categories: register constraints
+   (define_register_constraint), and others (define_constraint,
+   define_memory_constraint, define_address_constraint).  We
+   work out automatically which of the various old-style macros
+   they correspond to, and produce appropriate code.  They all
+   go in the same hash table so we can verify that there are no
+   duplicate names.  */
+
+/* All data from one constraint definition.  */
+struct constraint_data
+{
+  struct constraint_data *next_this_letter;
+  struct constraint_data *next_textual;
+  const char *name;
+  const char *c_name;    /* same as .name unless mangling is necessary */
+  size_t namelen;
+  const char *regclass;  /* for register constraints */
+  rtx exp;               /* for other constraints */
+  unsigned int lineno;   /* line of definition */
+  unsigned int is_register  : 1;
+  unsigned int is_const_int : 1;
+  unsigned int is_const_dbl : 1;
+  unsigned int is_extra     : 1;
+  unsigned int is_memory    : 1;
+  unsigned int is_address   : 1;
+};
+
+/* Overview of all constraints beginning with a given letter.  */
+
+static struct constraint_data *
+constraints_by_letter_table[1<<CHAR_BIT];
+
+/* For looking up all the constraints in the order that they appeared
+   in the machine description.  */
+static struct constraint_data *first_constraint;
+static struct constraint_data **last_constraint_ptr = &first_constraint;
+
+#define FOR_ALL_CONSTRAINTS(iter_) \
+  for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual)
+
+/* These letters, and all names beginning with them, are reserved for
+   generic constraints.  */
+static const char generic_constraint_letters[] = "EFVXgimnoprs";
+
+/* Machine-independent code expects that constraints with these
+   (initial) letters will allow only (a subset of all) CONST_INTs.  */
+
+static const char const_int_constraints[] = "IJKLMNOP";
+
+/* Machine-independent code expects that constraints with these
+   (initial) letters will allow only (a subset of all) CONST_DOUBLEs.  */
+
+static const char const_dbl_constraints[] = "GH";
+
+/* Summary data used to decide whether to output various functions and
+   macro definitions.  */
+static unsigned int constraint_max_namelen;
+static bool have_register_constraints;
+static bool have_memory_constraints;
+static bool have_address_constraints;
+static bool have_extra_constraints;
+static bool have_const_int_constraints;
+static bool have_const_dbl_constraints;
+
+/* Convert NAME, which contains angle brackets and/or underscores, to
+   a string that can be used as part of a C identifier.  The string
+   comes from the rtl_obstack.  */
+static const char *
+mangle (const char *name)
+{
+  for (; *name; name++)
+    switch (*name)
+      {
+      case '_': obstack_grow (rtl_obstack, "__", 2); break;
+      case '<':	obstack_grow (rtl_obstack, "_l", 2); break;
+      case '>':	obstack_grow (rtl_obstack, "_g", 2); break;
+      default: obstack_1grow (rtl_obstack, *name); break;
+      }
+
+  obstack_1grow (rtl_obstack, '\0');
+  return obstack_finish (rtl_obstack);
+}
+
+/* Add one constraint, of any sort, to the tables.  NAME is its name;
+   REGCLASS is the register class, if any; EXP is the expression to
+   test, if any;  IS_MEMORY and IS_ADDRESS indicate memory and address
+   constraints, respectively; LINENO is the line number from the MD reader.
+   Not all combinations of arguments are valid; most importantly, REGCLASS
+   is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only
+   meaningful for constraints with EXP.
+
+   This function enforces all syntactic and semantic rules about what
+   constraints can be defined.  */
+
+static void
+add_constraint (const char *name, const char *regclass,
+		rtx exp, bool is_memory, bool is_address,
+		int lineno)
+{
+  struct constraint_data *c, **iter, **slot;
+  const char *p;
+  bool need_mangled_name = false;
+  bool is_const_int;
+  bool is_const_dbl;
+  size_t namelen;
+
+  if (exp && validate_exp (exp, name, lineno))
+    return;
+
+  if (!ISALPHA (name[0]) && name[0] != '_')
+    {
+      if (name[1] == '\0')
+	message_with_line (lineno, "constraint name '%s' is not "
+			   "a letter or underscore", name);
+      else
+	message_with_line (lineno, "constraint name '%s' does not begin "
+			   "with a letter or underscore", name);
+      have_error = 1;
+      return;
+    }
+  for (p = name; *p; p++)
+    if (!ISALNUM (*p))
+      {
+	if (*p == '<' || *p == '>' || *p == '_')
+	  need_mangled_name = true;
+	else
+	  {
+	    message_with_line (lineno,
+			       "constraint name '%s' must be composed of "
+			       "letters, digits, underscores, and "
+			       "angle brackets", name);
+	    have_error = 1;
+	    return;
+	  }
+      }
+
+  if (strchr (generic_constraint_letters, name[0]))
+    {
+      if (name[1] == '\0')
+	message_with_line (lineno, "constraint letter '%s' cannot be "
+			   "redefined by the machine description", name);
+      else
+	message_with_line (lineno, "constraint name '%s' cannot be defined by "
+			   "the machine description, as it begins with '%c'",
+			   name, name[0]);
+      have_error = 1;
+      return;
+    }
+
+  
+  namelen = strlen (name);
+  slot = &constraints_by_letter_table[(unsigned int)name[0]];
+  for (iter = slot; *iter; iter = &(*iter)->next_this_letter)
+    {
+      /* This causes slot to end up pointing to the
+	 next_this_letter field of the last constraint with a name
+	 of equal or greater length than the new constraint; hence
+	 the new constraint will be inserted after all previous
+	 constraints with names of the same length.  */
+      if ((*iter)->namelen >= namelen)
+	slot = iter;
+
+      if (!strcmp ((*iter)->name, name))
+	{
+	  message_with_line (lineno, "redefinition of constraint '%s'", name);
+	  message_with_line ((*iter)->lineno, "previous definition is here");
+	  have_error = 1;
+	  return;
+	}
+      else if (!strncmp ((*iter)->name, name, (*iter)->namelen))
+	{
+	  message_with_line (lineno, "defining constraint '%s' here", name);
+	  message_with_line ((*iter)->lineno, "renders constraint '%s' "
+			     "(defined here) a prefix", (*iter)->name);
+	  have_error = 1;
+	  return;
+	}
+      else if (!strncmp ((*iter)->name, name, namelen))
+	{
+	  message_with_line (lineno, "constraint '%s' is a prefix", name);
+	  message_with_line ((*iter)->lineno, "of constraint '%s' "
+			     "(defined here)", (*iter)->name);
+	  have_error = 1;
+	  return;
+	}
+    }
+
+  is_const_int = strchr (const_int_constraints, name[0]) != 0;
+  is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0;
+
+  if (is_const_int || is_const_dbl)
+    {
+      enum rtx_code appropriate_code
+	= is_const_int ? CONST_INT : CONST_DOUBLE;
+
+      /* Consider relaxing this requirement in the future.  */
+      if (regclass
+	  || GET_CODE (exp) != AND
+	  || GET_CODE (XEXP (exp, 0)) != MATCH_CODE
+	  || strcmp (XSTR (XEXP (exp, 0), 0),
+		     GET_RTX_NAME (appropriate_code)))
+	{
+	  if (name[1] == '\0')
+	    message_with_line (lineno, "constraint letter '%c' is reserved "
+			       "for %s constraints",
+			       name[0], GET_RTX_NAME (appropriate_code));
+	  else
+	    message_with_line (lineno, "constraint names beginning with '%c' "
+			       "(%s) are reserved for %s constraints",
+			       name[0], name, 
+			       GET_RTX_NAME (appropriate_code));
+
+	  have_error = 1;
+	  return;
+	}
+
+      if (is_memory)
+	{
+	  if (name[1] == '\0')
+	    message_with_line (lineno, "constraint letter '%c' cannot be a "
+			       "memory constraint", name[0]);
+	  else
+	    message_with_line (lineno, "constraint name '%s' begins with '%c', "
+			       "and therefore cannot be a memory constraint",
+			       name, name[0]);
+
+	  have_error = 1;
+	  return;
+	}
+      else if (is_address)
+	{
+	  if (name[1] == '\0')
+	    message_with_line (lineno, "constraint letter '%c' cannot be a "
+			       "memory constraint", name[0]);
+	  else
+	    message_with_line (lineno, "constraint name '%s' begins with '%c', "
+			       "and therefore cannot be a memory constraint",
+			       name, name[0]);
+
+	  have_error = 1;
+	  return;
+	}
+
+      /* Remove the redundant (and (match_code "const_(int|double)")
+	 from the expression.  */
+      exp = XEXP (exp, 1);
+    }
+
+  
+  c = obstack_alloc (rtl_obstack, sizeof (struct constraint_data));
+  c->name = name;
+  c->c_name = need_mangled_name ? mangle (name) : name;
+  c->lineno = lineno;
+  c->namelen = namelen;
+  c->regclass = regclass;
+  c->exp = exp;
+  c->is_register = regclass != 0;
+  c->is_const_int = is_const_int;
+  c->is_const_dbl = is_const_dbl;
+  c->is_extra = !(regclass || is_const_int || is_const_dbl);
+  c->is_memory = is_memory;
+  c->is_address = is_address;
+
+  c->next_this_letter = *slot;
+  *slot = c;
+
+  /* Insert this constraint in the list of all constraints in textual
+     order.  */
+  c->next_textual = 0;
+  *last_constraint_ptr = c;
+  last_constraint_ptr = &c->next_textual;
+
+  constraint_max_namelen = MAX (constraint_max_namelen, strlen (name));
+  have_register_constraints |= c->is_register;
+  have_const_int_constraints |= c->is_const_int;
+  have_const_dbl_constraints |= c->is_const_dbl;
+  have_extra_constraints |= c->is_extra;
+  have_memory_constraints |= c->is_memory;
+  have_address_constraints |= c->is_address;
+}
+
+/* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or
+   DEFINE_ADDRESS_CONSTRAINT expression, C.  */
+static void
+process_define_constraint (rtx c, int lineno)
+{
+  add_constraint (XSTR (c, 0), 0, XEXP (c, 2),
+		  GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT,
+		  GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT,
+		  lineno);
+}
+
+/* Process a DEFINE_REGISTER_CONSTRAINT expression, C.  */
+static void
+process_define_register_constraint (rtx c, int lineno)
+{
+  add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno);
+}
+
+/* Write out an enumeration with one entry per machine-specific
+   constraint.  */
+static void
+write_enum_constraint_num (void)
+{
+  struct constraint_data *c;
+
+  fputs ("enum constraint_num\n"
+	 "{\n"
+	 "  CONSTRAINT__UNKNOWN = 0", stdout);
+  FOR_ALL_CONSTRAINTS (c)
+    printf (",\n  CONSTRAINT_%s", c->c_name);
+  puts ("\n};\n");
+}
+
+/* Write out a function which looks at a string and determines what
+   constraint name, if any, it begins with.  */
+static void
+write_lookup_constraint (void)
+{
+  unsigned int i;
+  puts ("enum constraint_num\n"
+	"lookup_constraint (const char *str)\n"
+	"{\n"
+	"  switch (str[0])\n"
+	"    {");
+
+  for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
+    {
+      struct constraint_data *c = constraints_by_letter_table[i];
+      if (!c)
+	continue;
+
+      printf ("    case '%c':\n", i);
+      if (c->namelen == 1)
+	printf ("      return CONSTRAINT_%s;\n", c->c_name);
+      else
+	{
+	  do
+	    {
+	      printf ("      if (!strncmp (str, \"%s\", %lu))\n"
+		      "        return CONSTRAINT_%s;\n",
+		      c->name, (unsigned long int) c->namelen, c->c_name);
+	      c = c->next_this_letter;
+	    }
+	  while (c);
+	  puts ("      break;");
+	}
+    }
+
+  puts ("    default: break;\n"
+	"    }\n"
+	"  return CONSTRAINT__UNKNOWN;\n"
+	"}\n");
+}
+
+/* Write out the function which computes constraint name lengths from
+   their enumerators. */
+static void
+write_insn_constraint_len (void)
+{
+  struct constraint_data *c;
+
+  if (constraint_max_namelen == 1)
+    return;
+
+  puts ("unsigned int\n"
+	"insn_constraint_len (enum constraint_num c)\n"
+	"{\n"
+	"  switch (c)\n"
+	"    {");
+
+  FOR_ALL_CONSTRAINTS (c)
+    if (c->namelen > 1)
+      printf ("    case CONSTRAINT_%s: return %lu;\n", c->c_name,
+	      (unsigned long int) c->namelen);
+
+  puts ("    default: break;\n"
+	"    }\n"
+	"  return 1;\n"
+	"}\n");
+}
+  
+/* Write out the function which computes the register class corresponding
+   to a register constraint.  */
+static void
+write_regclass_for_constraint (void)
+{
+  struct constraint_data *c;
+
+  puts ("enum reg_class\n"
+	"regclass_for_constraint (enum constraint_num c)\n"
+	"{\n"
+	"  switch (c)\n"
+	"    {");
+
+  FOR_ALL_CONSTRAINTS (c)
+    if (c->is_register)
+      printf ("    case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass);
+
+  puts ("    default: break;\n"
+	"    }\n"
+	"  return NO_REGS;\n"
+	"}\n");
+}
+
+/* Write out the functions which compute whether a given value matches
+   a given non-register constraint.  */
+static void
+write_satisfies_constraint_fns (void)
+{
+  struct constraint_data *c;
+
+  /* A fair number of places include tm_p.h without including rtl.h.  */
+  puts ("#ifdef GCC_RTL_H\n");
+  
+  FOR_ALL_CONSTRAINTS (c)
+    if (!c->is_register)
+      {
+	bool needs_ival = needs_variable (c->exp, "ival");
+	bool needs_hval = needs_variable (c->exp, "hval");
+	bool needs_lval = needs_variable (c->exp, "lval");
+	bool needs_rval = needs_variable (c->exp, "rval");
+	bool needs_mode = (needs_variable (c->exp, "mode")
+			   || needs_hval || needs_lval || needs_rval);
+
+	printf ("static inline bool\n"
+		"satisfies_constraint_%s (rtx op)\n"
+		"{\n", c->c_name);
+	if (needs_mode)
+	  puts ("enum machine_mode mode = GET_MODE (op);");
+	if (needs_ival)
+	  puts ("  HOST_WIDE_INT ival = 0;");
+	if (needs_hval)
+	  puts ("  HOST_WIDE_INT hval = 0;");
+	if (needs_lval)
+	  puts ("  unsigned HOST_WIDE_INT lval = 0;");
+	if (needs_rval)
+	  puts ("  const REAL_VALUE_TYPE *rval = 0;");
+
+	if (needs_ival)
+	  puts ("  if (GET_CODE (op) == CONST_INT)\n"
+		"    ival = INTVAL (op);");
+	if (needs_hval)
+	  puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
+		"    hval = CONST_DOUBLE_HIGH (op);");
+	if (needs_lval)
+	  puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)"
+		"    lval = CONST_DOUBLE_LOW (op);");
+	if (needs_rval)
+	  puts ("  if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)"
+		"    rval = CONST_DOUBLE_REAL_VALUE (op);");
+	  
+	fputs ("  return ", stdout);
+	write_predicate_expr (c->exp);
+	fputs (";\n}\n", stdout);
+      }
+
+  puts ("\n#endif /* rtl.h visible */\n");
+}
+
+/* Write out the wrapper function, constraint_satisfied_p, that maps
+   a CONSTRAINT_xxx constant to one of the predicate functions generated
+   above.  */
+static void
+write_constraint_satisfied_p (void)
+{
+  struct constraint_data *c;
+
+  puts ("bool\n"
+	"constraint_satisfied_p (rtx op, enum constraint_num c)\n"
+	"{\n"
+	"  switch (c)\n"
+	"    {");
+
+  FOR_ALL_CONSTRAINTS (c)
+    if (!c->is_register)
+      printf ("    case CONSTRAINT_%s: "
+	      "return satisfies_constraint_%s (op);\n",
+	      c->c_name, c->c_name);
+
+  puts ("    default: break;\n"
+	"    }\n"
+	"  return false;\n"
+	"}\n");
+}
+
+/* Write out the function which computes whether a given value matches
+   a given CONST_INT constraint.  This doesn't just forward to
+   constraint_satisfied_p because caller passes the INTVAL, not the RTX.  */
+static void
+write_insn_const_int_ok_for_constraint (void)
+{
+  struct constraint_data *c;
+
+  puts ("bool\n"
+	"insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, "
+	                                  "enum constraint_num c)\n"
+	"{\n"
+	"  switch (c)\n"
+	"    {");
+
+  FOR_ALL_CONSTRAINTS (c)
+    if (c->is_const_int)
+      {
+	printf ("    case CONSTRAINT_%s:\n      return ", c->c_name);
+	write_predicate_expr (c->exp);
+	fputs (";\n\n", stdout);
+      }
+
+  puts ("    default: break;\n"
+	"    }\n"
+	"  return false;\n"
+	"}\n");
+}
+
+
+/* Write out the function which computes whether a given constraint is
+   a memory constraint.  */
+static void
+write_insn_extra_memory_constraint (void)
+{
+  struct constraint_data *c;
+
+  puts ("bool\n"
+	"insn_extra_memory_constraint (enum constraint_num c)\n"
+	"{\n"
+	"  switch (c)\n"
+	"    {");
+
+  FOR_ALL_CONSTRAINTS (c)
+    if (c->is_memory)
+      printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
+
+  puts ("    default: break;\n"
+	"    }\n"
+	"  return false;\n"
+	"}\n");
+}
+
+/* Write out the function which computes whether a given constraint is
+   an address constraint.  */
+static void
+write_insn_extra_address_constraint (void)
+{
+  struct constraint_data *c;
+
+  puts ("bool\n"
+	"insn_extra_address_constraint (enum constraint_num c)\n"
+	"{\n"
+	"  switch (str[0])\n"
+	"    {");
+
+  FOR_ALL_CONSTRAINTS (c)
+    if (c->is_address)
+      printf ("    case CONSTRAINT_%s:\n      return true;\n\n", c->c_name);
+
+  puts ("    default: break;\n"
+	"    }\n"
+	"  return false;\n"
+	"}\n");
+}
+
+
+/* Write tm-preds.h.  Unfortunately, it is impossible to forward-declare
+   an enumeration in portable C, so we have to condition all these
+   prototypes on HAVE_MACHINE_MODES.  */
+static void
+write_tm_preds_h (void)
+{
+  struct pred_data *p;
+
+  printf ("\
+/* Generated automatically by the program '%s'\n\
+   from the machine description file '%s'.  */\n\n", progname, in_fname);
+
+  puts ("\
+#ifndef GCC_TM_PREDS_H\n\
+#define GCC_TM_PREDS_H\n\
+\n\
+#ifdef HAVE_MACHINE_MODES");
+
+  FOR_ALL_PREDICATES (p)
+    printf ("extern int %s (rtx, enum machine_mode);\n", p->name);
+
+  puts ("#endif /* HAVE_MACHINE_MODES */\n");
+
+  if (constraint_max_namelen > 0)
+    {
+      write_enum_constraint_num ();
+      puts ("extern enum constraint_num lookup_constraint (const char *);\n"
+	    "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n");
+
+      if (constraint_max_namelen > 1)
+	puts ("extern size_t insn_constraint_len (enum constraint_num);\n"
+	      "#define CONSTRAINT_LEN(c_,s_) "
+	      "insn_constraint_len (lookup_constraint (s_))\n");
+      else
+	puts ("#define CONSTRAINT_LEN(c_,s_) 1\n");
+      if (have_register_constraints)
+	puts ("extern enum reg_class regclass_for_constraint "
+	      "(enum constraint_num);\n"
+	      "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n"
+	      "    regclass_for_constraint (lookup_constraint (s_))\n");
+      else
+	puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS");
+      if (have_const_int_constraints)
+	puts ("extern bool insn_const_int_ok_for_constraint "
+	      "(HOST_WIDE_INT, enum constraint_num);\n"
+	      "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
+	      "    insn_const_int_ok_for_constraint (v_, "
+	      "lookup_constraint (s_))\n");
+      if (have_const_dbl_constraints)
+	puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n"
+	      "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
+      else
+	puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n");
+      if (have_extra_constraints)
+	puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n"
+	      "    constraint_satisfied_p (v_, lookup_constraint (s_))\n");
+      if (have_memory_constraints)
+	puts ("extern bool "
+	      "insn_extra_memory_constraint (enum constraint_num);\n"
+	      "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) "
+	      "insn_extra_memory_constraint (lookup_constraint (s_))\n");
+      else
+	puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n");
+      if (have_address_constraints)
+	puts ("extern bool "
+	      "insn_extra_address_constraint (enum constraint_num)"
+	      "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) "
+	      "insn_extra_address_constraint (lookup_constraint (s_))\n");
+      else
+	puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n");
+
+      if (have_const_int_constraints || have_const_dbl_constraints
+	  || have_extra_constraints)
+	write_satisfies_constraint_fns ();
+    }
+
+  puts ("#endif /* tm-preds.h */");
+}
 
 /* Write insn-preds.c.  
    N.B. the list of headers to include was copied from genrecog; it
@@ -486,6 +1220,24 @@ write_insn_preds_c (void)
 
   FOR_ALL_PREDICATES (p)
     write_one_predicate_function (p);
+
+  if (constraint_max_namelen > 0)
+    {
+      write_lookup_constraint ();
+      write_regclass_for_constraint ();
+      write_constraint_satisfied_p ();
+      
+      if (constraint_max_namelen > 1)
+	write_insn_constraint_len ();
+
+      if (have_const_int_constraints)
+	write_insn_const_int_ok_for_constraint ();
+
+      if (have_memory_constraints)
+	write_insn_extra_memory_constraint ();
+      if (have_address_constraints)
+	write_insn_extra_address_constraint ();
+    }
 }
 
 /* Argument parsing.  */
@@ -516,11 +1268,26 @@ main (int argc, char **argv)
     return FATAL_EXIT_CODE;
 
   while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0)
-    {
-      if (GET_CODE (defn) == DEFINE_PREDICATE
-	  || GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE)
-	process_define_predicate (defn);
-    }
+    switch (GET_CODE (defn))
+      {
+      case DEFINE_PREDICATE:
+      case DEFINE_SPECIAL_PREDICATE:
+	process_define_predicate (defn, pattern_lineno);
+	break;
+
+      case DEFINE_CONSTRAINT:
+      case DEFINE_MEMORY_CONSTRAINT:
+      case DEFINE_ADDRESS_CONSTRAINT:
+	process_define_constraint (defn, pattern_lineno);
+	break;
+
+      case DEFINE_REGISTER_CONSTRAINT:
+	process_define_register_constraint (defn, pattern_lineno);
+	break;
+
+      default:
+	break;
+      }
 
   if (gen_header)
     write_tm_preds_h ();
diff --git a/gcc/gensupport.c b/gcc/gensupport.c
index bbac33a..a880b11 100644
--- a/gcc/gensupport.c
+++ b/gcc/gensupport.c
@@ -287,6 +287,10 @@ process_rtx (rtx desc, int lineno)
 
     case DEFINE_PREDICATE:
     case DEFINE_SPECIAL_PREDICATE:
+    case DEFINE_CONSTRAINT:
+    case DEFINE_REGISTER_CONSTRAINT:
+    case DEFINE_MEMORY_CONSTRAINT:
+    case DEFINE_ADDRESS_CONSTRAINT:
       queue_pattern (desc, &define_pred_tail, read_rtx_filename, lineno);
       break;
 
diff --git a/gcc/recog.c b/gcc/recog.c
index 9d937ed..e3cdfd7 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -2664,6 +2664,10 @@ reg_fits_class_p (rtx operand, enum reg_class cl, int offset,
 		  enum machine_mode mode)
 {
   int regno = REGNO (operand);
+
+  if (cl == NO_REGS)
+    return 0;
+
   if (regno < FIRST_PSEUDO_REGISTER
       && TEST_HARD_REG_BIT (reg_class_contents[(int) cl],
 			    regno + offset))
diff --git a/gcc/rtl.def b/gcc/rtl.def
index 8710f54..84b24bc 100644
--- a/gcc/rtl.def
+++ b/gcc/rtl.def
@@ -874,6 +874,61 @@ DEF_RTL_EXPR(DEFINE_COND_EXEC, "define_cond_exec", "Ess", RTX_EXTRA)
 DEF_RTL_EXPR(DEFINE_PREDICATE, "define_predicate", "ses", RTX_EXTRA)
 DEF_RTL_EXPR(DEFINE_SPECIAL_PREDICATE, "define_special_predicate", "ses", RTX_EXTRA)
 
+/* Definition of a register operand constraint.  This simply maps the
+   constraint string to a register class.
+
+   Operand:
+   0: The name of the constraint (often, but not always, a single letter).
+   1: A C expression which evaluates to the appropriate register class for
+      this constraint.  If this is not just a constant, it should look only
+      at -m switches and the like.
+   2: A docstring for this constraint, in Texinfo syntax; not currently
+      used, in future will be incorporated into the manual's list of
+      machine-specific operand constraints.  */
+DEF_RTL_EXPR(DEFINE_REGISTER_CONSTRAINT, "define_register_constraint", "sss", RTX_EXTRA)
+
+/* Definition of a non-register operand constraint.  These look at the
+   operand and decide whether it fits the constraint.
+
+   DEFINE_CONSTRAINT gets no special treatment if it fails to match.
+   It is appropriate for constant-only constraints, and most others.
+
+   DEFINE_MEMORY_CONSTRAINT tells reload that this constraint can be made
+   to match, if it doesn't already, by converting the operand to the form
+   (mem (reg X)) where X is a base register.  It is suitable for constraints
+   that describe a subset of all memory references.
+
+   DEFINE_ADDRESS_CONSTRAINT tells reload that this constraint can be made
+   to match, if it doesn't already, by converting the operand to the form
+   (reg X) where X is a base register.  It is suitable for constraints that
+   describe a subset of all address references.
+
+   When in doubt, use plain DEFINE_CONSTRAINT.  
+
+   Operand:
+   0: The name of the constraint (often, but not always, a single letter).
+   1: A docstring for this constraint, in Texinfo syntax; not currently
+      used, in future will be incorporated into the manual's list of
+      machine-specific operand constraints.
+   2: A boolean expression which computes whether or not the constraint
+      matches.  It should follow the same rules as a define_predicate
+      expression, including the bit about specifying the set of RTX codes
+      that could possibly match.  MATCH_TEST subexpressions may make use of
+      these variables:
+        `op'    - the RTL object defining the operand.
+        `mode'  - the mode of `op'.
+	`ival'  - INTVAL(op), if op is a CONST_INT.
+        `hval'  - CONST_DOUBLE_HIGH(op), if op is an integer CONST_DOUBLE.
+        `lval'  - CONST_DOUBLE_LOW(op), if op is an integer CONST_DOUBLE.
+        `rval'  - CONST_DOUBLE_REAL_VALUE(op), if op is a floating-point
+                  CONST_DOUBLE.
+      Do not use ival/hval/lval/rval if op is not the appropriate kind of
+      RTL object.  */
+DEF_RTL_EXPR(DEFINE_CONSTRAINT, "define_constraint", "sse", RTX_EXTRA)
+DEF_RTL_EXPR(DEFINE_MEMORY_CONSTRAINT, "define_memory_constraint", "sse", RTX_EXTRA)
+DEF_RTL_EXPR(DEFINE_ADDRESS_CONSTRAINT, "define_address_constraint", "sse", RTX_EXTRA)
+   
+
 /* Constructions for CPU pipeline description described by NDFAs.  */
 
 /* (define_cpu_unit string [string]) describes cpu functional