===================================================================
@@ -1875,18 +1875,12 @@ Usually that is the only mode for which
@findex const
@item (const:@var{m} @var{exp})
-Wraps an rtx computation @var{exp} whose inputs and result do not
-change during the execution of a thread. There are two valid uses.
-The first is to represent a global or thread-local address calculation.
-In this case @var{exp} should contain @code{const_int},
-@code{symbol_ref}, @code{label_ref} or @code{unspec} expressions,
-combined with @code{plus} and @code{minus}. Any such @code{unspec}s
-are target-specific and typically represent some form of relocation
-operator. @var{m} should be a valid address mode.
-
-The second use of @code{const} is to wrap a vector operation.
-In this case @var{exp} must be a @code{vec_duplicate} or
-@code{vec_series} expression.
+Represents a constant that is the result of an assembly-time
+arithmetic computation. The operand, @var{exp}, contains only
+@code{const_int}, @code{symbol_ref}, @code{label_ref} or @code{unspec}
+expressions, combined with @code{plus} and @code{minus}. Any such
+@code{unspec}s are target-specific and typically represent some form
+of relocation operator. @var{m} should be a valid address mode.
@findex high
@item (high:@var{m} @var{exp})
===================================================================
@@ -2935,24 +2935,14 @@ extern rtx shallow_copy_rtx (const_rtx C
extern int rtx_equal_p (const_rtx, const_rtx);
extern bool rtvec_all_equal_p (const_rtvec);
-/* Return true if X is some form of vector constant. */
-
-inline bool
-const_vec_p (const_rtx x)
-{
- return VECTOR_MODE_P (GET_MODE (x)) && CONSTANT_P (x);
-}
-
/* Return true if X is a vector constant with a duplicated element value. */
inline bool
const_vec_duplicate_p (const_rtx x)
{
- return ((GET_CODE (x) == CONST_VECTOR
- && CONST_VECTOR_NPATTERNS (x) == 1
- && CONST_VECTOR_DUPLICATE_P (x))
- || (GET_CODE (x) == CONST
- && GET_CODE (XEXP (x, 0)) == VEC_DUPLICATE));
+ return (GET_CODE (x) == CONST_VECTOR
+ && CONST_VECTOR_NPATTERNS (x) == 1
+ && CONST_VECTOR_DUPLICATE_P (x));
}
/* Return true if X is a vector constant with a duplicated element value.
@@ -2962,20 +2952,11 @@ const_vec_duplicate_p (const_rtx x)
inline bool
const_vec_duplicate_p (T x, T *elt)
{
- if (GET_CODE (x) == CONST_VECTOR
- && CONST_VECTOR_NPATTERNS (x) == 1
- && CONST_VECTOR_DUPLICATE_P (x))
+ if (const_vec_duplicate_p (x))
{
*elt = CONST_VECTOR_ENCODED_ELT (x, 0);
return true;
}
- if (GET_CODE (x) == CONST
- && GET_CODE (XEXP (x, 0)) == VEC_DUPLICATE
- && !VECTOR_MODE_P (GET_MODE (XEXP (XEXP (x, 0), 0))))
- {
- *elt = XEXP (XEXP (x, 0), 0);
- return true;
- }
return false;
}
@@ -3002,12 +2983,8 @@ vec_duplicate_p (T x, T *elt)
inline T
unwrap_const_vec_duplicate (T x)
{
- if (GET_CODE (x) == CONST_VECTOR
- && CONST_VECTOR_NPATTERNS (x) == 1
- && CONST_VECTOR_DUPLICATE_P (x))
- return CONST_VECTOR_ENCODED_ELT (x, 0);
- if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == VEC_DUPLICATE)
- return XEXP (XEXP (x, 0), 0);
+ if (const_vec_duplicate_p (x))
+ x = CONST_VECTOR_ELT (x, 0);
return x;
}
@@ -3030,12 +3007,6 @@ const_vec_series_p (const_rtx x, rtx *ba
&& CONST_VECTOR_NPATTERNS (x) == 1
&& !CONST_VECTOR_DUPLICATE_P (x))
return const_vec_series_p_1 (x, base_out, step_out);
- if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == VEC_SERIES)
- {
- *base_out = XEXP (XEXP (x, 0), 0);
- *step_out = XEXP (XEXP (x, 0), 1);
- return true;
- }
return false;
}
===================================================================
@@ -5355,22 +5355,7 @@ make_tree (tree type, rtx x)
return fold_convert (type, make_tree (t, XEXP (x, 0)));
case CONST:
- {
- rtx op = XEXP (x, 0);
- if (GET_CODE (op) == VEC_DUPLICATE)
- {
- tree elt_tree = make_tree (TREE_TYPE (type), XEXP (op, 0));
- return build_vector_from_val (type, elt_tree);
- }
- if (GET_CODE (op) == VEC_SERIES)
- {
- tree itype = TREE_TYPE (type);
- tree base_tree = make_tree (itype, XEXP (op, 0));
- tree step_tree = make_tree (itype, XEXP (op, 1));
- return build_vec_series (type, base_tree, step_tree);
- }
- return make_tree (type, op);
- }
+ return make_tree (type, XEXP (x, 0));
case SYMBOL_REF:
t = SYMBOL_REF_DECL (x);
===================================================================
@@ -80,14 +80,14 @@ (define_constraint "n"
(define_constraint "E"
"Matches a floating-point constant."
(ior (match_test "CONST_DOUBLE_AS_FLOAT_P (op)")
- (match_test "CONSTANT_P (op)
+ (match_test "GET_CODE (op) == CONST_VECTOR
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT")))
;; There is no longer a distinction between "E" and "F".
(define_constraint "F"
"Matches a floating-point constant."
(ior (match_test "CONST_DOUBLE_AS_FLOAT_P (op)")
- (match_test "CONSTANT_P (op)
+ (match_test "GET_CODE (op) == CONST_VECTOR
&& GET_MODE_CLASS (GET_MODE (op)) == MODE_VECTOR_FLOAT")))
(define_constraint "X"
===================================================================
@@ -1593,7 +1593,7 @@ gen_lowpart_common (machine_mode mode, r
return gen_rtx_fmt_e (GET_CODE (x), int_mode, XEXP (x, 0));
}
else if (GET_CODE (x) == SUBREG || REG_P (x)
- || GET_CODE (x) == CONCAT || const_vec_p (x)
+ || GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR
|| CONST_DOUBLE_AS_FLOAT_P (x) || CONST_SCALAR_INT_P (x)
|| CONST_POLY_INT_P (x))
return lowpart_subreg (mode, x, innermode);