Index: gcc/defaults.h
===================================================================
--- gcc/defaults.h	2014-06-02 19:57:03.814627133 +0100
+++ gcc/defaults.h	2014-06-02 19:57:07.688661350 +0100
@@ -976,74 +976,11 @@ #define HAS_LONG_UNCOND_BRANCH 0
 #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
-#define EXTRA_MEMORY_CONSTRAINT(C,STR) 0
-#endif
-
-/* Determine whether extra constraint letter should be handled
-   as an address (like 'p').  */
-#ifndef EXTRA_ADDRESS_CONSTRAINT
-#define EXTRA_ADDRESS_CONSTRAINT(C,STR) 0
-#endif
-
-/* When a port defines CONSTRAINT_LEN, it should use DEFAULT_CONSTRAINT_LEN
-   for all the characters that it does not want to change, so things like the
-  'length' of a digit in a matching constraint is an implementation detail,
-   and not part of the interface.  */
-#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
-
-#ifndef CONSTRAINT_LEN
-#define CONSTRAINT_LEN(C,STR) DEFAULT_CONSTRAINT_LEN (C, STR)
 #endif
 
-#if defined (CONST_OK_FOR_LETTER_P) && ! defined (CONST_OK_FOR_CONSTRAINT_P)
-#define CONST_OK_FOR_CONSTRAINT_P(VAL,C,STR) CONST_OK_FOR_LETTER_P (VAL, C)
-#endif
-
-#if defined (CONST_DOUBLE_OK_FOR_LETTER_P) && ! defined (CONST_DOUBLE_OK_FOR_CONSTRAINT_P)
-#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(OP,C,STR) \
-  CONST_DOUBLE_OK_FOR_LETTER_P (OP, C)
-#endif
-
-#ifndef REG_CLASS_FROM_CONSTRAINT
-#define REG_CLASS_FROM_CONSTRAINT(C,STR) REG_CLASS_FROM_LETTER (C)
-#endif
-
-#if defined (EXTRA_CONSTRAINT) && ! defined (EXTRA_CONSTRAINT_STR)
-#define EXTRA_CONSTRAINT_STR(OP, C,STR) EXTRA_CONSTRAINT (OP, C)
-#endif
-
-#endif /* old constraint mechanism in use */
-
 /* Determin whether the target runtime library is Bionic */
 #ifndef TARGET_HAS_BIONIC
 #define TARGET_HAS_BIONIC 0
Index: gcc/system.h
===================================================================
--- gcc/system.h	2014-06-02 19:57:03.814627133 +0100
+++ gcc/system.h	2014-06-02 19:57:07.689661359 +0100
@@ -928,7 +928,9 @@ #define realloc xrealloc
 	USE_COMMON_FOR_ONE_ONLY IFCVT_EXTRA_FIELDS IFCVT_INIT_EXTRA_FIELDS \
 	CASE_USE_BIT_TESTS FIXUNS_TRUNC_LIKE_FIX_TRUNC                     \
         GO_IF_MODE_DEPENDENT_ADDRESS DELAY_SLOTS_FOR_EPILOGUE              \
-        ELIGIBLE_FOR_EPILOGUE_DELAY TARGET_C99_FUNCTIONS TARGET_HAS_SINCOS
+        ELIGIBLE_FOR_EPILOGUE_DELAY TARGET_C99_FUNCTIONS TARGET_HAS_SINCOS \
+	REG_CLASS_FROM_LETTER CONST_OK_FOR_LETTER_P			   \
+	CONST_DOUBLE_OK_FOR_LETTER_P EXTRA_CONSTRAINT
 
 /* Hooks that are no longer used.  */
  #pragma GCC poison LANG_HOOKS_FUNCTION_MARK LANG_HOOKS_FUNCTION_FREE	\
Index: gcc/target.def
===================================================================
--- gcc/target.def	2014-06-02 19:57:03.814627133 +0100
+++ gcc/target.def	2014-06-02 19:57:07.691661376 +0100
@@ -4739,10 +4739,9 @@ command options have been applied.\n\
 If the usage of an entire class of registers depends on the target\n\
 flags, you may indicate this to GCC by using this macro to modify\n\
 @code{fixed_regs} and @code{call_used_regs} to 1 for each of the\n\
-registers in the classes which should not be used by GCC@.  Also define\n\
-the macro @code{REG_CLASS_FROM_LETTER} / @code{REG_CLASS_FROM_CONSTRAINT}\n\
-to return @code{NO_REGS} if it\n\
-is called with a letter for a class that shouldn't be used.\n\
+registers in the classes which should not be used by GCC@.  Also make\n\
+@code{define_register_constraint}s return @code{NO_REGS} for constraints\n\
+that shouldn't be used.\n\
 \n\
 (However, if this class is not included in @code{GENERAL_REGS} and all\n\
 of the insn patterns whose constraints permit this class are\n\
Index: gcc/doc/tm.texi.in
===================================================================
--- gcc/doc/tm.texi.in	2014-06-02 19:57:03.814627133 +0100
+++ gcc/doc/tm.texi.in	2014-06-02 19:57:07.704661491 +0100
@@ -32,7 +32,6 @@ through the macros defined in the @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.
@@ -2551,153 +2550,6 @@ as below:
 
 @hook TARGET_CSTORE_MODE
 
-@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
-letters (@samp{I}, @samp{J}, @samp{K}, @dots{} @samp{P}) that specify
-particular ranges of integer values.  If @var{c} is one of those
-letters, the expression should check that @var{value}, an integer, is in
-the appropriate range and return 1 if so, 0 otherwise.  If @var{c} is
-not one of those letters, the value should be 0 regardless of
-@var{value}.
-@end defmac
-
-@defmac CONST_OK_FOR_CONSTRAINT_P (@var{value}, @var{c}, @var{str})
-Like @code{CONST_OK_FOR_LETTER_P}, 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_DOUBLE_OK_FOR_LETTER_P (@var{value}, @var{c})
-A C expression that defines the machine-dependent operand constraint
-letters that specify particular ranges of @code{const_double} values
-(@samp{G} or @samp{H}).
-
-If @var{c} is one of those letters, the expression should check that
-@var{value}, an RTX of code @code{const_double}, is in the appropriate
-range and return 1 if so, 0 otherwise.  If @var{c} is not one of those
-letters, the value should be 0 regardless of @var{value}.
-
-@code{const_double} is used for all floating-point constants and for
-@code{DImode} fixed-point constants.  A given letter can accept either
-or both kinds of values.  It can use @code{GET_MODE} to distinguish
-between these kinds.
-@end defmac
-
-@defmac CONST_DOUBLE_OK_FOR_CONSTRAINT_P (@var{value}, @var{c}, @var{str})
-Like @code{CONST_DOUBLE_OK_FOR_LETTER_P}, 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 EXTRA_CONSTRAINT (@var{value}, @var{c})
-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 @code{REG_CLASS_FROM_LETTER} /
-@code{REG_CLASS_FROM_CONSTRAINT}
-may be used.  Normally this macro will not be defined.
-
-If it is required for a particular target machine, it should return 1
-if @var{value} corresponds to the operand type represented by the
-constraint letter @var{c}.  If @var{c} is not defined as an extra
-constraint, the value returned should be 0 regardless of @var{value}.
-
-For example, on the ROMP, load instructions cannot have their output
-in r0 if the memory reference contains a symbolic address.  Constraint
-letter @samp{Q} is defined as representing a memory address that does
-@emph{not} contain a symbolic address.  An alternative is specified with
-a @samp{Q} constraint on the input and @samp{r} on the output.  The next
-alternative specifies @samp{m} on the input and a register class that
-does not include r0 on the output.
-@end defmac
-
-@defmac EXTRA_CONSTRAINT_STR (@var{value}, @var{c}, @var{str})
-Like @code{EXTRA_CONSTRAINT}, 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 EXTRA_MEMORY_CONSTRAINT (@var{c}, @var{str})
-A C expression that defines the optional machine-dependent constraint
-letters, amongst those accepted by @code{EXTRA_CONSTRAINT}, that should
-be treated like memory constraints by the reload pass.
-
-It should return 1 if the operand type represented by the constraint
-at the start of @var{str}, the first letter of which is the letter @var{c},
-comprises a subset of all memory references including
-all those whose address is simply a base register.  This allows the reload
-pass to reload an operand, if it does not directly correspond to the operand
-type of @var{c}, by copying its address into a base register.
-
-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 via
-@code{EXTRA_CONSTRAINT} as representing a memory address of this type.
-If the letter @samp{Q} is marked as @code{EXTRA_MEMORY_CONSTRAINT},
-a @samp{Q} constraint can handle any memory operand, because the
-reload pass knows it can be reloaded by copying the memory address
-into a base register if required.  This is analogous to the way
-an @samp{o} constraint can handle any memory operand.
-@end defmac
-
-@defmac EXTRA_ADDRESS_CONSTRAINT (@var{c}, @var{str})
-A C expression that defines the optional machine-dependent constraint
-letters, amongst those accepted by @code{EXTRA_CONSTRAINT} /
-@code{EXTRA_CONSTRAINT_STR}, that should
-be treated like address constraints by the reload pass.
-
-It should return 1 if the operand type represented by the constraint
-at the start of @var{str}, which starts with the letter @var{c}, comprises
-a subset of all memory addresses including
-all those that consist of just a base register.  This allows the reload
-pass to reload an operand, if it does not directly correspond to the operand
-type of @var{str}, by copying it into a base register.
-
-Any constraint marked as @code{EXTRA_ADDRESS_CONSTRAINT} can only
-be used with the @code{address_operand} predicate.  It is treated
-analogously to the @samp{p} constraint.
-@end defmac
-
 @node Stack and Calling
 @section Stack Layout and Calling Conventions
 @cindex calling conventions
Index: gcc/doc/tm.texi
===================================================================
--- gcc/doc/tm.texi	2014-06-02 19:57:03.814627133 +0100
+++ gcc/doc/tm.texi	2014-06-02 19:57:07.702661473 +0100
@@ -32,7 +32,6 @@ through the macros defined in the @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.
@@ -1962,10 +1961,9 @@ command options have been applied.
 If the usage of an entire class of registers depends on the target
 flags, you may indicate this to GCC by using this macro to modify
 @code{fixed_regs} and @code{call_used_regs} to 1 for each of the
-registers in the classes which should not be used by GCC@.  Also define
-the macro @code{REG_CLASS_FROM_LETTER} / @code{REG_CLASS_FROM_CONSTRAINT}
-to return @code{NO_REGS} if it
-is called with a letter for a class that shouldn't be used.
+registers in the classes which should not be used by GCC@.  Also make
+@code{define_register_constraint}s return @code{NO_REGS} for constraints
+that shouldn't be used.
 
 (However, if this class is not included in @code{GENERAL_REGS} and all
 of the insn patterns whose constraints permit this class are
@@ -2922,153 +2920,6 @@ This hook defines a class of registers w
 This hook defines the machine mode to use for the boolean result of  conditional store patterns.  The ICODE argument is the instruction code  for the cstore being performed.  Not definiting this hook is the same  as accepting the mode encoded into operand 0 of the cstore expander  patterns.
 @end deftypefn
 
-@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
-letters (@samp{I}, @samp{J}, @samp{K}, @dots{} @samp{P}) that specify
-particular ranges of integer values.  If @var{c} is one of those
-letters, the expression should check that @var{value}, an integer, is in
-the appropriate range and return 1 if so, 0 otherwise.  If @var{c} is
-not one of those letters, the value should be 0 regardless of
-@var{value}.
-@end defmac
-
-@defmac CONST_OK_FOR_CONSTRAINT_P (@var{value}, @var{c}, @var{str})
-Like @code{CONST_OK_FOR_LETTER_P}, 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_DOUBLE_OK_FOR_LETTER_P (@var{value}, @var{c})
-A C expression that defines the machine-dependent operand constraint
-letters that specify particular ranges of @code{const_double} values
-(@samp{G} or @samp{H}).
-
-If @var{c} is one of those letters, the expression should check that
-@var{value}, an RTX of code @code{const_double}, is in the appropriate
-range and return 1 if so, 0 otherwise.  If @var{c} is not one of those
-letters, the value should be 0 regardless of @var{value}.
-
-@code{const_double} is used for all floating-point constants and for
-@code{DImode} fixed-point constants.  A given letter can accept either
-or both kinds of values.  It can use @code{GET_MODE} to distinguish
-between these kinds.
-@end defmac
-
-@defmac CONST_DOUBLE_OK_FOR_CONSTRAINT_P (@var{value}, @var{c}, @var{str})
-Like @code{CONST_DOUBLE_OK_FOR_LETTER_P}, 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 EXTRA_CONSTRAINT (@var{value}, @var{c})
-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 @code{REG_CLASS_FROM_LETTER} /
-@code{REG_CLASS_FROM_CONSTRAINT}
-may be used.  Normally this macro will not be defined.
-
-If it is required for a particular target machine, it should return 1
-if @var{value} corresponds to the operand type represented by the
-constraint letter @var{c}.  If @var{c} is not defined as an extra
-constraint, the value returned should be 0 regardless of @var{value}.
-
-For example, on the ROMP, load instructions cannot have their output
-in r0 if the memory reference contains a symbolic address.  Constraint
-letter @samp{Q} is defined as representing a memory address that does
-@emph{not} contain a symbolic address.  An alternative is specified with
-a @samp{Q} constraint on the input and @samp{r} on the output.  The next
-alternative specifies @samp{m} on the input and a register class that
-does not include r0 on the output.
-@end defmac
-
-@defmac EXTRA_CONSTRAINT_STR (@var{value}, @var{c}, @var{str})
-Like @code{EXTRA_CONSTRAINT}, 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 EXTRA_MEMORY_CONSTRAINT (@var{c}, @var{str})
-A C expression that defines the optional machine-dependent constraint
-letters, amongst those accepted by @code{EXTRA_CONSTRAINT}, that should
-be treated like memory constraints by the reload pass.
-
-It should return 1 if the operand type represented by the constraint
-at the start of @var{str}, the first letter of which is the letter @var{c},
-comprises a subset of all memory references including
-all those whose address is simply a base register.  This allows the reload
-pass to reload an operand, if it does not directly correspond to the operand
-type of @var{c}, by copying its address into a base register.
-
-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 via
-@code{EXTRA_CONSTRAINT} as representing a memory address of this type.
-If the letter @samp{Q} is marked as @code{EXTRA_MEMORY_CONSTRAINT},
-a @samp{Q} constraint can handle any memory operand, because the
-reload pass knows it can be reloaded by copying the memory address
-into a base register if required.  This is analogous to the way
-an @samp{o} constraint can handle any memory operand.
-@end defmac
-
-@defmac EXTRA_ADDRESS_CONSTRAINT (@var{c}, @var{str})
-A C expression that defines the optional machine-dependent constraint
-letters, amongst those accepted by @code{EXTRA_CONSTRAINT} /
-@code{EXTRA_CONSTRAINT_STR}, that should
-be treated like address constraints by the reload pass.
-
-It should return 1 if the operand type represented by the constraint
-at the start of @var{str}, which starts with the letter @var{c}, comprises
-a subset of all memory addresses including
-all those that consist of just a base register.  This allows the reload
-pass to reload an operand, if it does not directly correspond to the operand
-type of @var{str}, by copying it into a base register.
-
-Any constraint marked as @code{EXTRA_ADDRESS_CONSTRAINT} can only
-be used with the @code{address_operand} predicate.  It is treated
-analogously to the @samp{p} constraint.
-@end defmac
-
 @node Stack and Calling
 @section Stack Layout and Calling Conventions
 @cindex calling conventions
Index: gcc/genoutput.c
===================================================================
--- gcc/genoutput.c	2014-06-02 19:57:03.814627133 +0100
+++ gcc/genoutput.c	2014-06-02 19:57:07.698661438 +0100
@@ -197,8 +197,6 @@ 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;
@@ -217,14 +215,6 @@ static const char indep_constraints[] =
 
 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)
@@ -786,7 +776,6 @@ validate_insn_alternatives (struct data
 	      error_with_line (d->lineno,
 			       "character '%c' can only be used at the"
 			       " beginning of a constraint string", c);
-#ifdef USE_MD_CONSTRAINTS
 	    if (ISSPACE (c) || strchr (indep_constraints, c))
 	      len = 1;
 	    else if (ISDIGIT (c))
@@ -799,18 +788,6 @@ validate_insn_alternatives (struct data
 	      }
 	    else
 	      len = mdep_constraint_len (p, d->lineno, start);
-#else
-	    len = CONSTRAINT_LEN (c, p);
-
-	    if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c)))
-	      {
-		error_with_line (d->lineno,
-				 "invalid length %d for char '%c' in"
-				 " alternative %d of operand %d",
-				 len, c, which_alternative, start);
-		len = 1;
-	      }
-#endif
 
 	    if (c == ',')
 	      {
@@ -914,9 +891,6 @@ gen_insn (rtx insn, int lineno)
   d->n_operands = stats.num_insn_operands;
   d->n_dups = stats.num_dups;
 
-#ifndef USE_MD_CONSTRAINTS
-  check_constraint_len ();
-#endif
   validate_insn_operands (d);
   validate_insn_alternatives (d);
   validate_optab_operands (d);
@@ -1106,14 +1080,12 @@ main (int argc, char **argv)
 	  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;
@@ -1169,8 +1141,6 @@ 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
@@ -1261,39 +1231,3 @@ mdep_constraint_len (const char *s, int
   message_with_line (lineno, "note:  in operand %d", opno);
   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.  */
-static void
-check_constraint_len (void)
-{
-  const char *p;
-  int d;
-
-  for (p = ",#*+=&%!1234567890"; *p; p++)
-    for (d = -9; d < 9; d++)
-      gcc_assert (constraint_len (p, d) == d);
-}
-
-static int
-constraint_len (const char *p, int genoutput_default_constraint_len)
-{
-  /* Check that we still match defaults.h .  First we do a generation-time
-     check that fails if the value is not the expected one...  */
-  gcc_assert (DEFAULT_CONSTRAINT_LEN (*p, p) == 1);
-  /* And now a compile-time check that should give a diagnostic if the
-     definition doesn't exactly match.  */
-#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
-  /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is
-     being used.  */
-#undef DEFAULT_CONSTRAINT_LEN
-#define DEFAULT_CONSTRAINT_LEN(C,STR) \
-  ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len)
-  return CONSTRAINT_LEN (*p, p);
-  /* And set it back.  */
-#undef DEFAULT_CONSTRAINT_LEN
-#define DEFAULT_CONSTRAINT_LEN(C,STR) 1
-}
-#endif
Index: gcc/config/frv/frv.md
===================================================================
--- gcc/config/frv/frv.md	2014-06-02 19:57:03.814627133 +0100
+++ gcc/config/frv/frv.md	2014-06-02 19:57:07.697661429 +0100
@@ -89,252 +89,6 @@ (define_mode_iterator IMODE [QI HI SI DI
 (define_mode_attr IMODEsuffix [(QI "b") (HI "h") (SI "") (DI "d")])
 (define_mode_attr BREADsuffix [(QI "ub") (HI "uh") (SI "") (DI "d")])
 
-;; ::::::::::::::::::::
-;; ::
-;; :: Constraints
-;; ::
-;; ::::::::::::::::::::
-
-;; Standard Constraints
-;;
-;; `m' A memory operand is allowed, with any kind of address that the
-;;     machine supports in general.
-;;
-;; `o' A memory operand is allowed, but only if the address is
-;;     "offsettable".  This means that adding a small integer (actually, the
-;;     width in bytes of the operand, as determined by its machine mode) may be
-;;     added to the address and the result is also a valid memory address.
-;;
-;; `V' A memory operand that is not offsettable.  In other words,
-;;     anything that would fit the `m' constraint but not the `o' constraint.
-;;
-;; `<' A memory operand with autodecrement addressing (either
-;;     predecrement or postdecrement) is allowed.
-;;
-;; `>' A memory operand with autoincrement addressing (either
-;;     preincrement or postincrement) is allowed.
-;;
-;; `r' A register operand is allowed provided that it is in a general
-;;     register.
-;;
-;; `d', `a', `f', ...
-;;     Other letters can be defined in machine-dependent fashion to stand for
-;;     particular classes of registers.  `d', `a' and `f' are defined on the
-;;     68000/68020 to stand for data, address and floating point registers.
-;;
-;; `i' An immediate integer operand (one with constant value) is allowed.
-;;     This includes symbolic constants whose values will be known only at
-;;     assembly time.
-;;
-;; `n' An immediate integer operand with a known numeric value is allowed.
-;;     Many systems cannot support assembly-time constants for operands less
-;;     than a word wide.  Constraints for these operands should use `n' rather
-;;     than `i'.
-;;
-;; 'I' First machine-dependent integer constant (6-bit signed ints).
-;; 'J' Second machine-dependent integer constant (10-bit signed ints).
-;; 'K' Third machine-dependent integer constant (-2048).
-;; 'L' Fourth machine-dependent integer constant (16-bit signed ints).
-;; 'M' Fifth machine-dependent integer constant (16-bit unsigned ints).
-;; 'N' Sixth machine-dependent integer constant (-2047..-1).
-;; 'O' Seventh machine-dependent integer constant (zero).
-;; 'P' Eighth machine-dependent integer constant (1..2047).
-;;
-;;     Other letters in the range `I' through `P' may be defined in a
-;;     machine-dependent fashion to permit immediate integer operands with
-;;     explicit integer values in specified ranges.  For example, on the 68000,
-;;     `I' is defined to stand for the range of values 1 to 8.  This is the
-;;     range permitted as a shift count in the shift instructions.
-;;
-;; `E' An immediate floating operand (expression code `const_double') is
-;;     allowed, but only if the target floating point format is the same as
-;;     that of the host machine (on which the compiler is running).
-;;
-;; `F' An immediate floating operand (expression code `const_double') is
-;;     allowed.
-;;
-;; 'G' First machine-dependent const_double.
-;; 'H' Second machine-dependent const_double.
-;;
-;; `s' An immediate integer operand whose value is not an explicit
-;;     integer is allowed.
-;;
-;;     This might appear strange; if an insn allows a constant operand with a
-;;     value not known at compile time, it certainly must allow any known
-;;     value.  So why use `s' instead of `i'?  Sometimes it allows better code
-;;     to be generated.
-;;
-;;     For example, on the 68000 in a fullword instruction it is possible to
-;;     use an immediate operand; but if the immediate value is between -128 and
-;;     127, better code results from loading the value into a register and
-;;     using the register.  This is because the load into the register can be
-;;     done with a `moveq' instruction.  We arrange for this to happen by
-;;     defining the letter `K' to mean "any integer outside the range -128 to
-;;     127", and then specifying `Ks' in the operand constraints.
-;;
-;; `g' Any register, memory or immediate integer operand is allowed,
-;;     except for registers that are not general registers.
-;;
-;; `X' Any operand whatsoever is allowed, even if it does not satisfy
-;;     `general_operand'.  This is normally used in the constraint of a
-;;     `match_scratch' when certain alternatives will not actually require a
-;;     scratch register.
-;;
-;; `0' Match operand 0.
-;; `1' Match operand 1.
-;; `2' Match operand 2.
-;; `3' Match operand 3.
-;; `4' Match operand 4.
-;; `5' Match operand 5.
-;; `6' Match operand 6.
-;; `7' Match operand 7.
-;; `8' Match operand 8.
-;; `9' Match operand 9.
-;;
-;;     An operand that matches the specified operand number is allowed.  If a
-;;     digit is used together with letters within the same alternative, the
-;;     digit should come last.
-;;
-;;     This is called a "matching constraint" and what it really means is that
-;;     the assembler has only a single operand that fills two roles considered
-;;     separate in the RTL insn.  For example, an add insn has two input
-;;     operands and one output operand in the RTL, but on most CISC machines an
-;;     add instruction really has only two operands, one of them an
-;;     input-output operand:
-;;
-;;          addl #35,r12
-;;
-;;     Matching constraints are used in these circumstances.  More precisely,
-;;     the two operands that match must include one input-only operand and one
-;;     output-only operand.  Moreover, the digit must be a smaller number than
-;;     the number of the operand that uses it in the constraint.
-;;
-;;     For operands to match in a particular case usually means that they are
-;;     identical-looking RTL expressions.  But in a few special cases specific
-;;     kinds of dissimilarity are allowed.  For example, `*x' as an input
-;;     operand will match `*x++' as an output operand.  For proper results in
-;;     such cases, the output template should always use the output-operand's
-;;     number when printing the operand.
-;;
-;; `p' An operand that is a valid memory address is allowed.  This is for
-;;     "load address" and "push address" instructions.
-;;
-;;     `p' in the constraint must be accompanied by `address_operand' as the
-;;     predicate in the `match_operand'.  This predicate interprets the mode
-;;     specified in the `match_operand' as the mode of the memory reference for
-;;     which the address would be valid.
-;;
-;; `Q` First non constant, non register machine-dependent insns
-;; `R` Second non constant, non register machine-dependent insns
-;; `S` Third non constant, non register machine-dependent insns
-;; `T` Fourth non constant, non register machine-dependent insns
-;; `U` Fifth non constant, non register machine-dependent insns
-;;
-;;     Letters in the range `Q' through `U' may be defined in a
-;;     machine-dependent fashion to stand for arbitrary operand types.  The
-;;     machine description macro `EXTRA_CONSTRAINT' is passed the operand as
-;;     its first argument and the constraint letter as its second operand.
-;;
-;;     A typical use for this would be to distinguish certain types of memory
-;;     references that affect other insn operands.
-;;
-;;     Do not define these constraint letters to accept register references
-;;     (`reg'); the reload pass does not expect this and would not handle it
-;;     properly.
-
-;; Multiple Alternative Constraints
-;; `?' Disparage slightly the alternative that the `?' appears in, as a
-;;     choice when no alternative applies exactly.  The compiler regards this
-;;     alternative as one unit more costly for each `?' that appears in it.
-;;
-;; `!' Disparage severely the alternative that the `!' appears in.  This
-;;     alternative can still be used if it fits without reloading, but if
-;;     reloading is needed, some other alternative will be used.
-
-;; Constraint modifiers
-;; `=' Means that this operand is write-only for this instruction: the
-;;     previous value is discarded and replaced by output data.
-;;
-;; `+' Means that this operand is both read and written by the
-;;     instruction.
-;;
-;;     When the compiler fixes up the operands to satisfy the constraints, it
-;;     needs to know which operands are inputs to the instruction and which are
-;;     outputs from it.  `=' identifies an output; `+' identifies an operand
-;;     that is both input and output; all other operands are assumed to be
-;;     input only.
-;;
-;; `&' Means (in a particular alternative) that this operand is written
-;;     before the instruction is finished using the input operands.  Therefore,
-;;     this operand may not lie in a register that is used as an input operand
-;;     or as part of any memory address.
-;;
-;;     `&' applies only to the alternative in which it is written.  In
-;;     constraints with multiple alternatives, sometimes one alternative
-;;     requires `&' while others do not.
-;;
-;;     `&' does not obviate the need to write `='.
-;;
-;; `%' Declares the instruction to be commutative for this operand and the
-;;     following operand.  This means that the compiler may interchange the two
-;;     operands if that is the cheapest way to make all operands fit the
-;;     constraints.  This is often used in patterns for addition instructions
-;;     that really have only two operands: the result must go in one of the
-;;     arguments.
-;;
-;; `#' Says that all following characters, up to the next comma, are to be
-;;     ignored as a constraint.  They are significant only for choosing
-;;     register preferences.
-;;
-;; `*' Says that the following character should be ignored when choosing
-;;     register preferences.  `*' has no effect on the meaning of the
-;;     constraint as a constraint, and no effect on reloading.
-
-
-;; ::::::::::::::::::::
-;; ::
-;; :: Attributes
-;; ::
-;; ::::::::::::::::::::
-
-;; The `define_attr' expression is used to define each attribute required by
-;; the target machine.  It looks like:
-;;
-;; (define_attr NAME LIST-OF-VALUES DEFAULT)
-
-;; NAME is a string specifying the name of the attribute being defined.
-
-;; LIST-OF-VALUES is either a string that specifies a comma-separated list of
-;; values that can be assigned to the attribute, or a null string to indicate
-;; that the attribute takes numeric values.
-
-;; DEFAULT is an attribute expression that gives the value of this attribute
-;; for insns that match patterns whose definition does not include an explicit
-;; value for this attribute.
-
-;; For each defined attribute, a number of definitions are written to the
-;; `insn-attr.h' file.  For cases where an explicit set of values is specified
-;; for an attribute, the following are defined:
-
-;; * A `#define' is written for the symbol `HAVE_ATTR_NAME'.
-;;
-;; * An enumeral class is defined for `attr_NAME' with elements of the
-;;   form `UPPER-NAME_UPPER-VALUE' where the attribute name and value are first
-;;   converted to upper case.
-;;
-;; * A function `get_attr_NAME' is defined that is passed an insn and
-;;   returns the attribute value for that insn.
-
-;; For example, if the following is present in the `md' file:
-;;
-;; (define_attr "type" "branch,fp,load,store,arith" ...)
-;;
-;; the following lines will be written to the file `insn-attr.h'.
-;;
-;; #define HAVE_ATTR_type
-;; enum attr_type {TYPE_BRANCH, TYPE_FP, TYPE_LOAD, TYPE_STORE, TYPE_ARITH};
-;; extern enum attr_type get_attr_type ();
-
 ;; If the attribute takes numeric values, no `enum' type will be defined and
 ;; the function to obtain the attribute's value will return `int'.
 
Index: gcc/config/frv/frv.c
===================================================================
--- gcc/config/frv/frv.c	2014-06-02 19:57:03.814627133 +0100
+++ gcc/config/frv/frv.c	2014-06-02 19:57:07.693661394 +0100
@@ -781,25 +781,7 @@ frv_string_begins_with (const_tree name,
 	  && strncmp (TREE_STRING_POINTER (name), prefix, prefix_len) == 0);
 }
 
-/* Zero or more C statements that may conditionally modify two variables
-   `fixed_regs' and `call_used_regs' (both of type `char []') after they have
-   been initialized from the two preceding macros.
-
-   This is necessary in case the fixed or call-clobbered registers depend on
-   target flags.
-
-   You need not define this macro if it has no work to do.
-
-   If the usage of an entire class of registers depends on the target flags,
-   you may indicate this to GCC by using this macro to modify `fixed_regs' and
-   `call_used_regs' to 1 for each of the registers in the classes which should
-   not be used by GCC.  Also define the macro `REG_CLASS_FROM_LETTER' to return
-   `NO_REGS' if it is called with a letter for a class that shouldn't be used.
-
-   (However, if this class is not included in `GENERAL_REGS' and all of the
-   insn patterns whose constraints permit this class are controlled by target
-   switches, then GCC will automatically avoid using these registers when the
-   target switches are opposed to them.)  */
+/* Implement TARGET_CONDITIONAL_REGISTER_USAGE.  */
 
 static void
 frv_conditional_register_usage (void)
Index: gcc/config/m32r/m32r.c
===================================================================
--- gcc/config/m32r/m32r.c	2014-06-02 19:57:03.814627133 +0100
+++ gcc/config/m32r/m32r.c	2014-06-02 19:57:07.695661412 +0100
@@ -604,7 +604,7 @@ call26_operand (rtx op, enum machine_mod
 
 /* Return 1 if OP is a DImode const we want to handle inline.
    This must match the code in the movdi pattern.
-   It is used by the 'G' CONST_DOUBLE_OK_FOR_LETTER.  */
+   It is used by the 'G' constraint.  */
 
 int
 easy_di_const (rtx op)
@@ -624,7 +624,7 @@ easy_di_const (rtx op)
 
 /* Return 1 if OP is a DFmode const we want to handle inline.
    This must match the code in the movdf pattern.
-   It is used by the 'H' CONST_DOUBLE_OK_FOR_LETTER.  */
+   It is used by the 'H' constraint.  */
 
 int
 easy_df_const (rtx op)
Index: gcc/config/sh/constraints.md
===================================================================
--- gcc/config/sh/constraints.md	2014-06-02 19:57:03.814627133 +0100
+++ gcc/config/sh/constraints.md	2014-06-02 19:57:07.698661438 +0100
@@ -55,7 +55,7 @@
 ;; Z: zero in any mode
 ;;
 ;; unused CONST_INT constraint letters: LO
-;; unused EXTRA_CONSTRAINT letters: D T U Y
+;; unused "extra" constraint letters: D T U Y
 
 ;; Register constraints
 (define_register_constraint "a" "ALL_REGS"
