Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c	2013-11-16 22:21:20.716272495 +0000
+++ gcc/c-family/c-common.c	2013-11-16 22:36:56.575137937 +0000
@@ -6056,8 +6056,10 @@ match_case_to_enum_1 (tree key, tree typ
 {
   char buf[WIDE_INT_PRINT_BUFFER_SIZE];
 
-  if (tree_fits_hwi_p (key, TYPE_SIGN (type)))
-    print_dec (key, buf, TYPE_SIGN (type));
+  if (tree_fits_uhwi_p (key))
+    print_dec (key, buf, UNSIGNED);
+  else if (tree_fits_shwi_p (key))
+    print_dec (key, buf, SIGNED);
   else
     print_hex (key, buf);
 
Index: gcc/doc/generic.texi
===================================================================
--- gcc/doc/generic.texi	2013-11-16 22:21:23.034289829 +0000
+++ gcc/doc/generic.texi	2013-11-16 22:40:47.479832766 +0000
@@ -1024,10 +1024,8 @@ As this example indicates, the operands
 @tindex INTEGER_CST
 @tindex tree_fits_uhwi_p
 @tindex tree_fits_shwi_p
-@tindex tree_fits_hwi_p
 @tindex tree_to_uhwi
 @tindex tree_to_shwi
-@tindex tree_to_hwi
 @tindex REAL_CST
 @tindex FIXED_CST
 @tindex COMPLEX_CST
@@ -1050,16 +1048,11 @@ represented in an array of HOST_WIDE_INT
 in the array to represent the value without taking extra elements for
 redundant 0s or -1.
 
-The functions @code{tree_fits_uhwi_p}, @code{tree_fits_shwi_p}, and
-@code{tree_fits_hwi_p} can be used to tell if the value is small
-enough to fit in a HOST_WIDE_INT, as either a signed value, an unsiged
-value or a value whose sign is given as a parameter.  The value can
-then be extracted using the @code{tree_to_uhwi}, @code{tree_to_shwi},
-or @code{tree_to_hwi}.  The @code{tree_to_hwi} comes in both checked
-and unchecked flavors.  However, when the value is used in a context
-where it may represent a value that is larger than can be represented
-in HOST_BITS_PER_WIDE_INT bits, the wide_int class should be used to
-manipulate the constant.
+The functions @code{tree_fits_shwi_p} and @code{tree_fits_uhwi_p}
+can be used to tell if the value is small enough to fit in a
+signed HOST_WIDE_INT or an unsigned HOST_WIDE_INT respectively.
+The value can then be extracted using @code{tree_to_shwi} and
+@code{tree_to_uhwi}.
 
 @item REAL_CST
 
Index: gcc/sdbout.c
===================================================================
--- gcc/sdbout.c	2013-10-22 10:15:14.050507121 +0100
+++ gcc/sdbout.c	2013-11-16 22:37:51.168539468 +0000
@@ -1152,7 +1152,7 @@ sdbout_one_type (tree type)
 	        if (TREE_CODE (value) == CONST_DECL)
 	          value = DECL_INITIAL (value);
 
-	        if (tree_fits_hwi_p (value))
+	        if (tree_fits_shwi_p (value))
 		  {
 		    PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
 		    PUT_SDB_INT_VAL (tree_to_shwi (value));
Index: gcc/tree.h
===================================================================
--- gcc/tree.h	2013-11-16 22:21:25.473308066 +0000
+++ gcc/tree.h	2013-11-16 22:42:05.148400937 +0000
@@ -3235,37 +3235,6 @@ tree_fits_shwi_p (const_tree cst)
   return false;
 }
 
-/* Return true if T is an INTEGER_CST that can be manipulated
-   efficiently on the host.  If SIGN is SIGNED, the value can be
-   represented in a single HOST_WIDE_INT.  If SIGN is UNSIGNED, the
-   value must be non-negative and can be represented in a single
-   unsigned HOST_WIDE_INT.  */
-
-static inline bool
-tree_fits_hwi_p (const_tree cst, signop sign)
-{
-  return sign ? tree_fits_uhwi_p (cst) : tree_fits_shwi_p (cst);
-}
-
-/* Return true if T is an INTEGER_CST that can be manipulated
-   efficiently on the host.  If the sign of CST is SIGNED, the value
-   can be represented in a single HOST_WIDE_INT.  If the sign of CST
-   is UNSIGNED, the value must be non-negative and can be represented
-   in a single unsigned HOST_WIDE_INT.  */
-
-static inline bool
-tree_fits_hwi_p (const_tree cst)
-{
-  if (cst == NULL_TREE)
-    return false;
-
-  if (TREE_CODE (cst) != INTEGER_CST)
-    return false;
-
-  return TYPE_UNSIGNED (TREE_TYPE (cst)) 
-    ? tree_fits_uhwi_p (cst) : tree_fits_shwi_p (cst);
-}
-
 /* Return the unsigned HOST_WIDE_INT least significant bits of CST.
    If checking is enabled, this ices if the value does not fit.  */
 
@@ -3298,19 +3267,6 @@ tree_to_hwi (const_tree cst)
   return TREE_INT_CST_ELT (cst, 0);
 }
 
-/* Return the HOST_WIDE_INT least significant bits of CST.  The sign
-   of the checking is based on SIGNOP. */
-
-static inline HOST_WIDE_INT
-tree_to_hwi (const_tree cst, signop sgn)
-{
-  if (sgn == SIGNED)
-    return tree_to_shwi (cst);
-  else
-    return tree_to_uhwi (cst);
-}
-
-
 /* Compute the number of operands in an expression node NODE.  For
    tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
    otherwise it is looked up from the node's code.  */
