static int small_max_prec, mid_min_prec, large_min_prec, huge_min_prec;
static int limb_prec;
+static bool bitint_big_endian;
/* Categorize _BitInt(PREC) as small, middle, large or huge. */
small_max_prec = prec;
return bitint_prec_small;
}
+ bitint_big_endian = info.big_endian;
if (!large_min_prec
&& GET_MODE_PRECISION (limb_mode) < MAX_FIXED_MODE_SIZE)
large_min_prec = MAX_FIXED_MODE_SIZE + 1;
tree arith_overflow_extract_bits (unsigned int, unsigned int, tree,
unsigned int, bool);
void finish_arith_overflow (tree, tree, tree, tree, tree, tree, gimple *,
- tree_code);
+ unsigned, tree_code);
void lower_addsub_overflow (tree, gimple *);
void lower_mul_overflow (tree, gimple *);
void lower_cplxpart_stmt (tree, gimple *);
unsigned HOST_WIDE_INT i = tree_to_uhwi (idx);
unsigned int prec = TYPE_PRECISION (type);
gcc_assert (i * limb_prec < prec);
- if ((i + 1) * limb_prec <= prec)
+ if (bitint_big_endian
+ ? (i != 0 || (prec % limb_prec) == 0)
+ : (i + 1) * limb_prec <= prec)
return m_limb_type;
else
return build_nonstandard_integer_type (prec % limb_prec,
m_data.safe_push (NULL_TREE);
m_data.safe_push (NULL_TREE);
}
+ if (bitint_big_endian)
+ i = CEIL (TYPE_PRECISION (TREE_TYPE (op)), limb_prec) - 1 - i;
if (limb_prec != HOST_BITS_PER_WIDE_INT)
{
wide_int w = wi::rshift (wi::to_wide (op), i * limb_prec,
min_prec = CEIL (min_prec, 2 * limb_prec) * (2 * limb_prec);
tree type = build_bitint_type (min_prec, 1);
tree c = tree_output_constant_def (fold_convert (type, op));
- tree idx2 = make_ssa_name (sizetype);
- g = gimple_build_assign (idx2, PLUS_EXPR, idx, size_one_node);
+ tree ridx = idx;
+ if (bitint_big_endian)
+ {
+ ridx = make_ssa_name (sizetype);
+ g = gimple_build_assign (ridx, PLUS_EXPR, idx,
+ size_int (min_prec / limb_prec
+ - ((HOST_WIDE_INT)
+ CEIL (prec,
+ limb_prec))));
+ insert_before (g);
+ }
+ tree ridx2 = make_ssa_name (sizetype);
+ g = gimple_build_assign (ridx2, PLUS_EXPR, ridx,
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
- g = gimple_build_cond (LT_EXPR, idx,
- size_int (min_prec / limb_prec),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (GE_EXPR, idx,
+ size_int (CEIL (prec, limb_prec)
+ - min_prec / limb_prec),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (LT_EXPR, idx,
+ size_int (min_prec / limb_prec),
+ NULL_TREE, NULL_TREE);
edge edge_true, edge_false;
if_then (g, (min_prec >= (prec - rem) / 2
? profile_probability::likely ()
: profile_probability::unlikely ()),
edge_true, edge_false);
- tree c1 = limb_access (TREE_TYPE (op), c, idx, false);
+ tree c1 = limb_access (TREE_TYPE (op), c, ridx, false);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (c1)), c1);
insert_before (g);
c1 = gimple_assign_lhs (g);
- tree c2 = limb_access (TREE_TYPE (op), c, idx2, false);
+ tree c2 = limb_access (TREE_TYPE (op), c, ridx2, false);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (c2)), c2);
insert_before (g);
c2 = gimple_assign_lhs (g);
m_data[m_data_cnt + 1] = integer_type_node;
}
t = m_data[m_data_cnt];
- if (m_data[m_data_cnt + 1] == NULL_TREE)
+ }
+ else
+ t = m_data[m_data_cnt + 1];
+ if (m_data[m_data_cnt + 1] == NULL_TREE)
+ {
+ tree ridx = idx;
+ unsigned int prec = TYPE_PRECISION (TREE_TYPE (op));
+ tree c = m_data[m_data_cnt];
+ unsigned int min_prec = TYPE_PRECISION (TREE_TYPE (c));
+ if (bitint_big_endian
+ && CEIL (min_prec, limb_prec) != CEIL (prec, limb_prec))
{
- t = limb_access (TREE_TYPE (op), t, idx, false);
- g = gimple_build_assign (make_ssa_name (TREE_TYPE (t)), t);
+ ridx = make_ssa_name (sizetype);
+ g = gimple_build_assign (ridx, PLUS_EXPR, idx,
+ size_int (CEIL (min_prec, limb_prec)
+ - ((HOST_WIDE_INT)
+ CEIL (prec, limb_prec))));
insert_before (g);
- t = gimple_assign_lhs (g);
}
- }
- else if (m_data[m_data_cnt + 1] == NULL_TREE)
- {
- t = limb_access (TREE_TYPE (op), m_data[m_data_cnt], idx, false);
+ t = limb_access (TREE_TYPE (op), c, ridx, false);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (t)), t);
insert_before (g);
t = gimple_assign_lhs (g);
}
- else
- t = m_data[m_data_cnt + 1];
- if (m_data[m_data_cnt + 1] == integer_type_node)
+ else if (m_data[m_data_cnt + 1] == integer_type_node)
{
unsigned int prec = TYPE_PRECISION (TREE_TYPE (op));
unsigned rem = prec % ((m_upwards_2limb ? 2 : 1) * limb_prec);
int ext = wi::neg_p (wi::to_wide (op)) ? -1 : 0;
tree c = m_data[m_data_cnt];
unsigned min_prec = TYPE_PRECISION (TREE_TYPE (c));
- g = gimple_build_cond (LT_EXPR, idx,
- size_int (min_prec / limb_prec),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (GE_EXPR, idx,
+ size_int (CEIL (prec, limb_prec)
+ - min_prec / limb_prec),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (LT_EXPR, idx,
+ size_int (min_prec / limb_prec),
+ NULL_TREE, NULL_TREE);
edge edge_true, edge_false;
if_then (g, (min_prec >= (prec - rem) / 2
? profile_probability::likely ()
edge_true, edge_false);
if (min_prec > (unsigned) limb_prec)
{
- c = limb_access (TREE_TYPE (op), c, idx, false);
+ tree ridx = idx;
+ if (bitint_big_endian)
+ {
+ ridx = make_ssa_name (sizetype);
+ g = gimple_build_assign (ridx, PLUS_EXPR, idx,
+ size_int (min_prec / limb_prec
+ - ((HOST_WIDE_INT)
+ CEIL (prec,
+ limb_prec))));
+ insert_before (g);
+ }
+ c = limb_access (TREE_TYPE (op), c, ridx, false);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (c)), c);
insert_before (g);
c = gimple_assign_lhs (g);
&& (m_upwards_2limb * limb_prec
< TYPE_PRECISION (lhs_type))))))
{
- rhs1 = handle_operand (rhs1, idx);
+ tree ridx = idx;
+ if (bitint_big_endian
+ && (CEIL (TYPE_PRECISION (lhs_type), limb_prec)
+ != CEIL (TYPE_PRECISION (rhs_type), limb_prec)))
+ {
+ HOST_WIDE_INT diff = CEIL (TYPE_PRECISION (rhs_type), limb_prec);
+ diff -= CEIL (TYPE_PRECISION (lhs_type), limb_prec);
+ if (tree_fits_uhwi_p (idx))
+ ridx = size_int (tree_to_uhwi (idx) + diff);
+ else
+ {
+ tree t = make_ssa_name (sizetype);
+ g = gimple_build_assign (t, PLUS_EXPR, idx, size_int (diff));
+ insert_before (g);
+ ridx = t;
+ }
+ }
+ rhs1 = handle_operand (rhs1, ridx);
if (tree_fits_uhwi_p (idx))
{
tree type = limb_access_type (lhs_type, idx);
- !TYPE_UNSIGNED (rhs_type)) / limb_prec;
/* Indexes >= than this always contain an extension. */
unsigned high = CEIL ((unsigned) TYPE_PRECISION (rhs_type), limb_prec);
+ unsigned lcnt = CEIL ((unsigned) TYPE_PRECISION (lhs_type), limb_prec);
+ unsigned lowe = bitint_big_endian ? lcnt - 1 - low : low;
bool save_first = m_first;
if (m_first)
{
else
gsi_next (&m_gsi);
m_data_cnt = save_data_cnt + 3;
- t = handle_operand (rhs1, size_int (low));
+ t = handle_operand (rhs1, size_int (bitint_big_endian
+ ? high - 1 - low : low));
m_first = false;
m_data[save_data_cnt + 2]
= build_int_cst (NULL_TREE, m_data_cnt);
if (m_upwards_2limb
&& low >= m_upwards_2limb - m_first)
{
+ if (bitint_big_endian
+ && (CEIL (TYPE_PRECISION (lhs_type), limb_prec)
+ != CEIL (TYPE_PRECISION (rhs_type), limb_prec)))
+ {
+ HOST_WIDE_INT diff
+ = CEIL (TYPE_PRECISION (rhs_type), limb_prec);
+ diff -= CEIL (TYPE_PRECISION (lhs_type), limb_prec);
+ tree t = make_ssa_name (sizetype);
+ g = gimple_build_assign (t, PLUS_EXPR, idx, size_int (diff));
+ insert_before (g);
+ idx = t;
+ }
rhs1 = handle_operand (rhs1, idx);
if (m_first)
m_data[save_data_cnt + 2]
emits. So, instead of special-casing that, emit a
low <= low comparison which cfg cleanup will clean up
at the end of the pass. */
- idxc = size_int (low);
- g = gimple_build_cond (single_comparison ? LT_EXPR : LE_EXPR,
- idxc, size_int (low), NULL_TREE, NULL_TREE);
+ idxc = size_int (lowe);
+ if (bitint_big_endian)
+ g = gimple_build_cond (single_comparison ? GT_EXPR : GE_EXPR,
+ idxc, size_int (lowe),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (single_comparison ? LT_EXPR : LE_EXPR,
+ idxc, size_int (low), NULL_TREE, NULL_TREE);
edge edge_true_true, edge_true_false, edge_false;
if_then_if_then_else (g, (single_comparison ? NULL
: gimple_build_cond (EQ_EXPR, idx,
- size_int (low),
+ size_int (lowe),
NULL_TREE,
NULL_TREE)),
profile_probability::likely (),
bool save_cast_conditional = m_cast_conditional;
m_cast_conditional = true;
m_bitfld_load = 0;
- tree t1 = handle_operand (rhs1, idx), t2 = NULL_TREE;
+ tree t1 = idx, t2 = NULL_TREE;
+ if (bitint_big_endian
+ && (CEIL (TYPE_PRECISION (lhs_type), limb_prec)
+ != CEIL (TYPE_PRECISION (rhs_type), limb_prec)))
+ {
+ HOST_WIDE_INT diff = CEIL (TYPE_PRECISION (rhs_type), limb_prec);
+ diff -= CEIL (TYPE_PRECISION (lhs_type), limb_prec);
+ t1 = make_ssa_name (sizetype);
+ g = gimple_build_assign (t1, PLUS_EXPR, idx, size_int (diff));
+ insert_before (g);
+ }
+ t1 = handle_operand (rhs1, t1);
if (m_first)
m_data[save_data_cnt + 2]
= build_int_cst (NULL_TREE, m_data_cnt);
m_data[m_bitfld_load] = m_data[m_bitfld_load + 2];
m_bitfld_load = 0;
}
- t2 = handle_operand (rhs1, size_int (low));
+ t2 = handle_operand (rhs1, size_int (bitint_big_endian
+ ? high - 1 - low : low));
if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (t2)))
t2 = add_cast (m_limb_type, t2);
if (!TYPE_UNSIGNED (rhs_type) && m_upwards_2limb)
else
{
unsigned tidx = tree_to_uhwi (idx);
+ if (bitint_big_endian)
+ tidx = lcnt - 1 - tidx;
if (tidx < low)
{
- t = handle_operand (rhs1, idx);
+ t = handle_operand (rhs1, (bitint_big_endian
+ ? size_int (high - 1 - tidx) : idx));
if (m_first)
m_data[save_data_cnt + 2]
= build_int_cst (NULL_TREE, m_data_cnt);
}
else if (tidx < high)
{
- t = handle_operand (rhs1, size_int (low));
+ t = handle_operand (rhs1, size_int (bitint_big_endian
+ ? high - 1 - low : low));
if (m_first)
m_data[save_data_cnt + 2]
= build_int_cst (NULL_TREE, m_data_cnt);
{
if (TYPE_UNSIGNED (rhs_type) && m_first)
{
- handle_operand (rhs1, size_zero_node);
+ handle_operand (rhs1, (bitint_big_endian
+ ? size_int (high - 1)
+ : size_zero_node));
m_data[save_data_cnt + 2]
= build_int_cst (NULL_TREE, m_data_cnt);
}
m_data.safe_push (r2);
m_data.safe_push (rext);
}
+ unsigned lcnt = CEIL ((unsigned) TYPE_PRECISION (lhs_type), limb_prec);
if (tree_fits_uhwi_p (idx))
{
tree type = limb_access_type (lhs_type, idx);
- if (integer_zerop (idx))
+ if (bitint_big_endian
+ ? tree_to_uhwi (idx) == lcnt - 1 : integer_zerop (idx))
t = m_data[m_data_cnt];
else if (TYPE_PRECISION (rhs_type) > limb_prec
- && integer_onep (idx))
+ && (bitint_big_endian
+ ? tree_to_uhwi (idx) == lcnt - 2
+ : integer_onep (idx)))
t = m_data[m_data_cnt + 1];
else
t = m_data[m_data_cnt + 2];
m_data_cnt += 3;
return t;
}
- g = gimple_build_cond (NE_EXPR, idx, size_zero_node,
+ g = gimple_build_cond (NE_EXPR, idx,
+ bitint_big_endian
+ ? size_int (lcnt - 1) : size_zero_node,
NULL_TREE, NULL_TREE);
edge e2, e3, e4 = NULL;
if_then (g, profile_probability::likely (), e2, e3);
if (m_data[m_data_cnt + 1])
{
- g = gimple_build_cond (EQ_EXPR, idx, size_one_node,
+ g = gimple_build_cond (EQ_EXPR, idx,
+ bitint_big_endian
+ ? size_int (lcnt - 2) : size_one_node,
NULL_TREE, NULL_TREE);
insert_before (g);
edge e5 = split_block (gsi_bb (m_gsi), g);
m_data.safe_push (NULL);
++m_data_cnt;
unsigned HOST_WIDE_INT sz = tree_to_uhwi (TYPE_SIZE (m_limb_type));
+ unsigned i = tree_to_uhwi (idx);
+ if (bitint_big_endian)
+ i = CEIL (TYPE_PRECISION (TREE_TYPE (op)), limb_prec) - 1 - i;
tree bfr = build3 (BIT_FIELD_REF, m_limb_type,
TREE_OPERAND (op, 0),
TYPE_SIZE (m_limb_type),
size_binop (PLUS_EXPR, TREE_OPERAND (op, 2),
- bitsize_int (tree_to_uhwi (idx) * sz)));
+ bitsize_int (i * sz)));
tree r = make_ssa_name (m_limb_type);
gimple *g = gimple_build_assign (r, bfr);
insert_before (g);
/* For little-endian, we can allow as inputs bit-fields
which start at a limb boundary. */
gcc_assert (tree_fits_uhwi_p (DECL_FIELD_BIT_OFFSET (fld)));
- if (DECL_OFFSET_ALIGN (fld) >= TYPE_ALIGN (TREE_TYPE (rhs1))
+ if (!bitint_big_endian
+ && DECL_OFFSET_ALIGN (fld) >= TYPE_ALIGN (TREE_TYPE (rhs1))
&& (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld)) % limb_prec) == 0)
goto normal_load;
- /* Even if DECL_FIELD_BIT_OFFSET (fld) is a multiple of UNITS_PER_BIT,
+ /* Even if DECL_FIELD_BIT_OFFSET (fld) is a multiple of BITS_PER_UNIT,
handle it normally for now. */
- if ((tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld)) % BITS_PER_UNIT) == 0)
+ if (!bitint_big_endian
+ && (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld)) % BITS_PER_UNIT) == 0)
goto normal_load;
tree repr = DECL_BIT_FIELD_REPRESENTATIVE (fld);
poly_int64 bitoffset;
HOST_WIDE_INT bo = bitoffset.to_constant ();
unsigned bo_idx = (unsigned HOST_WIDE_INT) bo / limb_prec;
unsigned bo_bit = (unsigned HOST_WIDE_INT) bo % limb_prec;
+ unsigned bo_last = 0;
+ unsigned bo_shift = bo_bit;
+ unsigned nelts = CEIL (TYPE_PRECISION (rhs_type), limb_prec);
+ if (bitint_big_endian)
+ {
+ bo_last = CEIL (TYPE_PRECISION (rhs_type) + bo_bit, limb_prec) - 1;
+ bo_shift = (TYPE_PRECISION (rhs_type) + bo_bit) % limb_prec;
+ if (bo_shift)
+ bo_shift = limb_prec - bo_shift;
+ }
if (m_first)
{
- if (m_upwards)
+ if (m_upwards && bo_shift)
{
gimple_stmt_iterator save_gsi = m_gsi;
m_gsi = m_init_gsi;
m_gsi = gsi_after_labels (gsi_bb (m_gsi));
else
gsi_next (&m_gsi);
- tree t = limb_access (NULL_TREE, nrhs1, size_int (bo_idx), true);
+ tree t = limb_access (NULL_TREE, nrhs1,
+ size_int (bo_idx + bo_last), true);
tree iv = make_ssa_name (m_limb_type);
g = gimple_build_assign (iv, t);
insert_before (g);
}
}
- tree nidx0 = NULL_TREE, nidx1;
+ tree nidx0 = NULL_TREE, nidx1 = NULL_TREE;
tree iv = m_data[m_data_cnt];
if (m_cast_conditional && iv)
{
{
unsigned prec = TYPE_PRECISION (rhs_type);
unsigned HOST_WIDE_INT i = tree_to_uhwi (idx);
+ if (bitint_big_endian)
+ i = nelts - 1 - i;
gcc_assert (i * limb_prec < prec);
- nidx1 = size_int (i + bo_idx + 1);
+ if (bo_shift)
+ nidx1 = size_int (bo_idx + (bitint_big_endian
+ ? bo_last - i - 1 : i + 1));
if ((i + 1) * limb_prec > prec)
{
prec %= limb_prec;
nidx1 = NULL_TREE;
}
if (!iv)
- nidx0 = size_int (i + bo_idx);
+ nidx0 = size_int (bo_idx + (bitint_big_endian ? bo_last - i : i));
}
else
{
+ HOST_WIDE_INT adj = bo_idx;
+ if (bitint_big_endian)
+ adj += (HOST_WIDE_INT) bo_last + 1 - nelts;
if (!iv)
{
- if (bo_idx == 0)
+ if (adj == 0)
nidx0 = idx;
else
{
nidx0 = make_ssa_name (sizetype);
g = gimple_build_assign (nidx0, PLUS_EXPR, idx,
- size_int (bo_idx));
+ size_int (adj));
+ insert_before (g);
+ }
+ }
+ if (bo_shift)
+ {
+ if (bitint_big_endian && adj == 1)
+ nidx1 = idx;
+ else
+ {
+ nidx1 = make_ssa_name (sizetype);
+ g = gimple_build_assign (nidx1, PLUS_EXPR, idx,
+ size_int (adj + (bitint_big_endian
+ ? -1 : 1)));
insert_before (g);
}
}
- nidx1 = make_ssa_name (sizetype);
- g = gimple_build_assign (nidx1, PLUS_EXPR, idx,
- size_int (bo_idx + 1));
- insert_before (g);
}
tree iv2 = NULL_TREE;
iv = make_ssa_name (m_limb_type);
g = gimple_build_assign (iv, t);
insert_before (g);
- gcc_assert (!eh);
+ if (eh)
+ {
+ maybe_duplicate_eh_stmt (g, stmt);
+ if (eh_edge)
+ {
+ edge e = split_block (gsi_bb (m_gsi), g);
+ m_gsi = gsi_after_labels (e->dest);
+ add_eh_edge (e->src, eh_edge);
+ }
+ }
}
if (nidx1)
{
if (conditional)
{
g = gimple_build_cond (NE_EXPR, idx,
- size_int (prec / limb_prec),
+ bitint_big_endian
+ ? size_zero_node
+ : size_int (prec / limb_prec),
NULL_TREE, NULL_TREE);
if_then (g, profile_probability::likely (),
edge_true, edge_false);
iv2 = iv3;
}
}
- g = gimple_build_assign (make_ssa_name (m_limb_type), RSHIFT_EXPR,
- iv, build_int_cst (unsigned_type_node, bo_bit));
- insert_before (g);
- iv = gimple_assign_lhs (g);
+ if (bo_shift)
+ {
+ g = gimple_build_assign (make_ssa_name (m_limb_type), RSHIFT_EXPR,
+ iv, build_int_cst (unsigned_type_node,
+ bo_shift));
+ insert_before (g);
+ iv = gimple_assign_lhs (g);
+ }
if (iv2)
{
g = gimple_build_assign (make_ssa_name (m_limb_type), LSHIFT_EXPR,
iv2, build_int_cst (unsigned_type_node,
- limb_prec - bo_bit));
+ limb_prec - bo_shift));
insert_before (g);
g = gimple_build_assign (make_ssa_name (m_limb_type), BIT_IOR_EXPR,
gimple_assign_lhs (g), iv);
{
wide_int w;
location_t loc_save = m_loc;
+ tree ret = NULL_TREE;
+ int precs = 0;
if ((TREE_CODE (TREE_TYPE (op)) != BITINT_TYPE
|| bitint_precision_kind (TREE_TYPE (op)) < bitint_prec_large)
&& TREE_CODE (op) != INTEGER_CST)
limb mode smaller than half of largest supported normal
integral type, this will not be needed. */
gcc_assert (nelts <= 2);
- if (prec_stored)
- *prec_stored = (TYPE_UNSIGNED (op_type)
- ? TYPE_PRECISION (op_type)
- : -TYPE_PRECISION (op_type));
+ precs = (TYPE_UNSIGNED (op_type)
+ ? TYPE_PRECISION (op_type) : -TYPE_PRECISION (op_type));
if (*prec <= limb_prec && *prec >= -limb_prec)
{
nelts = 1;
- if (prec_stored)
+ if (TYPE_UNSIGNED (op_type))
{
- if (TYPE_UNSIGNED (op_type))
- {
- if (*prec_stored > limb_prec)
- *prec_stored = limb_prec;
- }
- else if (*prec_stored < -limb_prec)
- *prec_stored = -limb_prec;
+ if (precs > limb_prec)
+ precs = limb_prec;
}
+ else if (precs < -limb_prec)
+ precs = -limb_prec;
}
+ if (prec_stored)
+ *prec_stored = precs;
tree atype = build_array_type_nelts (m_limb_type, nelts);
tree var = create_tmp_var (atype);
tree t1 = op;
if (!useless_type_conversion_p (m_limb_type, op_type))
t1 = add_cast (m_limb_type, t1);
- tree v = build4 (ARRAY_REF, m_limb_type, var, size_zero_node,
+ tree v = build4 (ARRAY_REF, m_limb_type, var,
+ bitint_big_endian && nelts > 1
+ ? size_one_node : size_zero_node,
NULL_TREE, NULL_TREE);
gimple *g = gimple_build_assign (v, t1);
insert_before (g);
insert_before (g);
tree t2 = gimple_assign_lhs (g);
t2 = add_cast (m_limb_type, t2);
- v = build4 (ARRAY_REF, m_limb_type, var, size_one_node,
+ v = build4 (ARRAY_REF, m_limb_type, var,
+ bitint_big_endian ? size_zero_node : size_one_node,
NULL_TREE, NULL_TREE);
g = gimple_build_assign (v, t2);
insert_before (g);
}
- tree ret = build_fold_addr_expr (var);
+ ret = build_fold_addr_expr (var);
if (!stmt_ends_bb_p (gsi_stmt (m_gsi)))
{
tree clobber = build_clobber (atype, CLOBBER_STORAGE_END);
gsi_insert_after (&m_gsi, g, GSI_SAME_STMT);
}
m_loc = loc_save;
- return ret;
+ goto do_ret;
}
switch (TREE_CODE (op))
{
|| !bitmap_bit_p (m_names, SSA_NAME_VERSION (op)))
{
gimple *g = SSA_NAME_DEF_STMT (op);
- tree ret;
m_loc = gimple_location (g);
if (gimple_assign_load_p (g))
{
*prec = range_to_prec (op, NULL);
+ precs = (TYPE_UNSIGNED (TREE_TYPE (op))
+ ? TYPE_PRECISION (TREE_TYPE (op))
+ : -TYPE_PRECISION (TREE_TYPE (op)));
if (prec_stored)
- *prec_stored = (TYPE_UNSIGNED (TREE_TYPE (op))
- ? TYPE_PRECISION (TREE_TYPE (op))
- : -TYPE_PRECISION (TREE_TYPE (op)));
+ *prec_stored = precs;
ret = build_fold_addr_expr (gimple_assign_rhs1 (g));
ret = force_gimple_operand_gsi (&m_gsi, ret, true,
NULL_TREE, true, GSI_SAME_STMT);
else if (gimple_code (g) == GIMPLE_NOP)
{
*prec = TYPE_UNSIGNED (TREE_TYPE (op)) ? limb_prec : -limb_prec;
+ precs = *prec;
if (prec_stored)
- *prec_stored = *prec;
+ *prec_stored = precs;
tree var = create_tmp_var (m_limb_type);
TREE_ADDRESSABLE (var) = 1;
ret = build_fold_addr_expr (var);
tree rhs_type = TREE_TYPE (rhs1);
int prec_stored_val = 0;
ret = handle_operand_addr (rhs1, g, &prec_stored_val, prec);
+ precs = prec_stored_val;
if (TYPE_PRECISION (lhs_type) > TYPE_PRECISION (rhs_type))
{
if (TYPE_UNSIGNED (lhs_type)
}
}
m_loc = loc_save;
- return ret;
+ goto do_ret;
}
else
{
int p = var_to_partition (m_map, op);
gcc_assert (m_vars[p] != NULL_TREE);
*prec = range_to_prec (op, stmt);
+ precs = (TYPE_UNSIGNED (TREE_TYPE (op))
+ ? TYPE_PRECISION (TREE_TYPE (op))
+ : -TYPE_PRECISION (TREE_TYPE (op)));
if (prec_stored)
- *prec_stored = (TYPE_UNSIGNED (TREE_TYPE (op))
- ? TYPE_PRECISION (TREE_TYPE (op))
- : -TYPE_PRECISION (TREE_TYPE (op)));
- return build_fold_addr_expr (m_vars[p]);
+ *prec_stored = precs;
+ ret = build_fold_addr_expr (m_vars[p]);
+ goto do_ret;
}
case INTEGER_CST:
unsigned int min_prec, mp;
type = build_bitint_type (mp, 1);
}
}
+ if (tree_int_cst_sgn (op) >= 0)
+ precs = MAX (TYPE_PRECISION (type), 1);
+ else
+ precs = MIN ((int) -TYPE_PRECISION (type), -2);
if (prec_stored)
- {
- if (tree_int_cst_sgn (op) >= 0)
- *prec_stored = MAX (TYPE_PRECISION (type), 1);
- else
- *prec_stored = MIN ((int) -TYPE_PRECISION (type), -2);
- }
+ *prec_stored = precs;
op = tree_output_constant_def (fold_convert (type, op));
- return build_fold_addr_expr (op);
+ ret = build_fold_addr_expr (op);
+ goto do_ret;
default:
gcc_unreachable ();
}
+do_ret:
+ if (bitint_big_endian && prec_stored == NULL)
+ {
+ int p1 = *prec < 0 ? -*prec : *prec;
+ int p2 = precs < 0 ? -precs : precs;
+ int c1 = CEIL (p1, limb_prec);
+ int c2 = CEIL (p2, limb_prec);
+ gcc_assert (c1 <= c2);
+ if (c1 != c2)
+ {
+ gimple *g
+ = gimple_build_assign (make_ssa_name (TREE_TYPE (ret)),
+ POINTER_PLUS_EXPR, ret,
+ size_int ((c2 - c1) * m_limb_size));
+ insert_before (g);
+ ret = gimple_assign_lhs (g);
+ }
+ }
+ return ret;
}
/* Helper function, create a loop before the current location,
tree nlhs = NULL_TREE;
unsigned HOST_WIDE_INT bo_idx = 0;
unsigned HOST_WIDE_INT bo_bit = 0;
+ unsigned bo_shift = 0;
+ unsigned bo_last = 0;
+ bool bo_be_p = false;
tree bf_cur = NULL_TREE, bf_next = NULL_TREE;
if (gimple_store_p (stmt))
{
tree repr = DECL_BIT_FIELD_REPRESENTATIVE (fld);
poly_int64 bitoffset;
poly_uint64 field_offset, repr_offset;
- if ((tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld)) % BITS_PER_UNIT) == 0)
+ if (!bitint_big_endian
+ && (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld))
+ % BITS_PER_UNIT) == 0)
nlhs = lhs;
else
{
HOST_WIDE_INT bo = bitoffset.to_constant ();
bo_idx = (unsigned HOST_WIDE_INT) bo / limb_prec;
bo_bit = (unsigned HOST_WIDE_INT) bo % limb_prec;
+ bo_shift = bo_bit;
+ if (bitint_big_endian)
+ {
+ bo_last = CEIL (prec + bo_bit, limb_prec) - 1;
+ bo_shift = (prec + bo_bit) % limb_prec;
+ bo_be_p = true;
+ if (bo_shift)
+ bo_shift = limb_prec - bo_shift;
+ }
}
}
}
rem = (prec % (2 * limb_prec));
end = (prec - rem) / limb_prec;
cnt = 2 + CEIL (rem, limb_prec);
- idx = idx_first = create_loop (size_zero_node, &idx_next);
+ idx = idx_first = create_loop (bitint_big_endian
+ ? size_int (cnt - 2 + end - 1)
+ : size_zero_node, &idx_next);
}
basic_block edge_bb = NULL;
= (prec != (unsigned) TYPE_PRECISION (type)
&& (CEIL ((unsigned) TYPE_PRECISION (type), limb_prec)
> CEIL (prec, limb_prec)));
+ unsigned dst_idx_off = 0;
+ if (separate_ext && bitint_big_endian)
+ dst_idx_off = (CEIL ((unsigned) TYPE_PRECISION (type), limb_prec)
+ - CEIL (prec, limb_prec));
for (unsigned i = 0; i < cnt; i++)
{
m_data_cnt = 0;
if (kind == bitint_prec_large)
- idx = size_int (i);
+ idx = size_int (bitint_big_endian ? cnt - 1 - i : i);
else if (i >= 2)
- idx = size_int (end + (i > 2));
+ idx = size_int (bitint_big_endian ? cnt - 1 - i : end + (i > 2));
if (eq_p)
{
rhs1 = handle_operand (cmp_op1, idx);
if (sext && i == cnt - 1)
ext = rhs1;
tree nidx = idx;
- if (bo_idx)
+ HOST_WIDE_INT adj = bo_idx;
+ if (bo_be_p)
+ adj += bo_last - (CEIL (prec, limb_prec) - 1);
+ else
+ adj += dst_idx_off;
+ if (adj)
{
if (tree_fits_uhwi_p (idx))
- nidx = size_int (tree_to_uhwi (idx) + bo_idx);
+ nidx = size_int (tree_to_uhwi (idx) + adj);
else
{
nidx = make_ssa_name (sizetype);
g = gimple_build_assign (nidx, PLUS_EXPR, idx,
- size_int (bo_idx));
+ size_int (adj));
insert_before (g);
}
}
bool done = false;
basic_block new_bb = NULL;
/* Handle stores into bit-fields. */
- if (bo_bit)
+ if (bo_shift)
{
if (i == 0)
{
idx, &bf_next);
bf_next = m_data.pop ();
bf_cur = m_data.pop ();
- g = gimple_build_cond (EQ_EXPR, idx, size_zero_node,
+ g = gimple_build_cond (EQ_EXPR, idx,
+ bitint_big_endian
+ ? size_int (CEIL (prec,
+ limb_prec) - 1)
+ : size_zero_node,
NULL_TREE, NULL_TREE);
edge edge_true;
if_then_else (g, profile_probability::unlikely (),
new_bb = e2->dest;
}
tree ftype
- = build_nonstandard_integer_type (limb_prec - bo_bit, 1);
+ = build_nonstandard_integer_type (limb_prec - bo_shift, 1);
tree bfr = build_bit_field_ref (ftype, unshare_expr (nlhs),
- limb_prec - bo_bit,
- bo_idx * limb_prec + bo_bit);
+ limb_prec - bo_shift,
+ bitint_big_endian
+ ? (bo_idx + bo_last)
+ * limb_prec
+ : bo_idx * limb_prec
+ + bo_bit);
tree t = add_cast (ftype, rhs1);
g = gimple_build_assign (bfr, t);
insert_before (g);
tree t3 = make_ssa_name (m_limb_type);
g = gimple_build_assign (t1, RSHIFT_EXPR, bf_cur,
build_int_cst (unsigned_type_node,
- limb_prec - bo_bit));
+ limb_prec
+ - bo_shift));
insert_before (g);
g = gimple_build_assign (t2, LSHIFT_EXPR, rhs1,
build_int_cst (unsigned_type_node,
- bo_bit));
+ bo_shift));
insert_before (g);
bf_cur = rhs1;
g = gimple_build_assign (t3, BIT_IOR_EXPR, t1, t2);
{
unsigned int tprec = TYPE_PRECISION (type);
unsigned int rprec = (tprec - 1) % limb_prec + 1;
- if (rprec + bo_bit < (unsigned) limb_prec)
+ if (rprec + bo_shift < (unsigned) limb_prec)
{
tree ftype
- = build_nonstandard_integer_type (rprec + bo_bit, 1);
+ = build_nonstandard_integer_type (rprec + bo_shift, 1);
tree bfr
= build_bit_field_ref (ftype, unshare_expr (nlhs),
- rprec + bo_bit,
- (bo_idx + tprec / limb_prec)
- * limb_prec);
+ rprec + bo_shift,
+ bitint_big_endian
+ ? bo_idx * limb_prec + bo_bit
+ : (bo_idx + tprec / limb_prec)
+ * limb_prec);
tree t = add_cast (ftype, rhs1);
g = gimple_build_assign (bfr, t);
done = true;
bf_cur = NULL_TREE;
}
- else if (rprec + bo_bit == (unsigned) limb_prec)
+ else if (rprec + bo_shift == (unsigned) limb_prec)
bf_cur = NULL_TREE;
}
/* Otherwise, stores to any other lhs. */
{
idx = make_ssa_name (sizetype);
g = gimple_build_assign (idx, PLUS_EXPR, idx_first,
- size_one_node);
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
}
else
{
g = gimple_build_assign (idx_next, PLUS_EXPR, idx_first,
- size_int (2));
+ size_int (bitint_big_endian ? -2 : 2));
insert_before (g);
- g = gimple_build_cond (NE_EXPR, idx_next, size_int (end),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (NE_EXPR, idx_first, size_int (cnt - 1),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (NE_EXPR, idx_next, size_int (end),
+ NULL_TREE, NULL_TREE);
insert_before (g);
if (eq_p)
m_gsi = gsi_after_labels (edge_bb);
kind = bitint_precision_kind (type);
unsigned start = CEIL (prec, limb_prec);
prec = TYPE_PRECISION (type);
+ unsigned total = CEIL (prec, limb_prec);
idx = idx_first = idx_next = NULL_TREE;
- if (prec <= (start + 2 + (bo_bit != 0)) * limb_prec)
+ if (prec <= (start + 2 + (bo_shift != 0)) * limb_prec)
kind = bitint_prec_large;
if (kind == bitint_prec_large)
- cnt = CEIL (prec, limb_prec) - start;
+ cnt = total - start;
else
{
rem = prec % limb_prec;
end = (prec - rem) / limb_prec;
- cnt = (bo_bit != 0) + 1 + (rem != 0);
+ cnt = (bo_shift != 0) + 1 + (rem != 0);
}
+ if (bitint_big_endian && bo_shift != 0 && (prec % limb_prec) == 0)
+ ++total;
for (unsigned i = 0; i < cnt; i++)
{
- if (kind == bitint_prec_large || (i == 0 && bo_bit != 0))
- idx = size_int (start + i);
- else if (i == cnt - 1 && (rem != 0))
- idx = size_int (end);
- else if (i == (bo_bit != 0))
- idx = create_loop (size_int (start + i), &idx_next);
+ if (kind == bitint_prec_large || (i == 0 && bo_shift != 0))
+ idx = size_int (bo_idx
+ + (bitint_big_endian
+ ? total - 1 - start - i : start + i));
+ else if (i == cnt - 1 && rem != 0)
+ idx = size_int (bo_idx + (bitint_big_endian ? 0 : end));
+ else if (i == (bo_shift != 0))
+ idx = create_loop (size_int (bo_idx
+ + (bitint_big_endian
+ ? total - 1 - start - i
+ : start + i)), &idx_next);
rhs1 = ext;
if (bf_cur != NULL_TREE && bf_cur != ext)
{
tree t1 = make_ssa_name (m_limb_type);
g = gimple_build_assign (t1, RSHIFT_EXPR, bf_cur,
build_int_cst (unsigned_type_node,
- limb_prec - bo_bit));
+ limb_prec - bo_shift));
insert_before (g);
if (integer_zerop (ext))
rhs1 = t1;
rhs1 = make_ssa_name (m_limb_type);
g = gimple_build_assign (t2, LSHIFT_EXPR, ext,
build_int_cst (unsigned_type_node,
- bo_bit));
+ bo_shift));
insert_before (g);
g = gimple_build_assign (rhs1, BIT_IOR_EXPR, t1, t2);
insert_before (g);
}
bf_cur = ext;
}
- tree nidx = idx;
- if (bo_idx)
- {
- if (tree_fits_uhwi_p (idx))
- nidx = size_int (tree_to_uhwi (idx) + bo_idx);
- else
- {
- nidx = make_ssa_name (sizetype);
- g = gimple_build_assign (nidx, PLUS_EXPR, idx,
- size_int (bo_idx));
- insert_before (g);
- }
- }
bool done = false;
/* Handle bit-field access to partial last limb if needed. */
if (nlhs && i == cnt - 1)
{
unsigned int tprec = TYPE_PRECISION (type);
unsigned int rprec = (tprec - 1) % limb_prec + 1;
- if (rprec + bo_bit < (unsigned) limb_prec)
+ if (rprec + bo_shift < (unsigned) limb_prec)
{
tree ftype
- = build_nonstandard_integer_type (rprec + bo_bit, 1);
+ = build_nonstandard_integer_type (rprec + bo_shift, 1);
tree bfr
= build_bit_field_ref (ftype, unshare_expr (nlhs),
- rprec + bo_bit,
- (bo_idx + tprec / limb_prec)
- * limb_prec);
+ rprec + bo_shift,
+ bitint_big_endian
+ ? bo_idx * limb_prec + bo_bit
+ : (bo_idx + tprec / limb_prec)
+ * limb_prec);
tree t = add_cast (ftype, rhs1);
g = gimple_build_assign (bfr, t);
done = true;
bf_cur = NULL_TREE;
}
- else if (rprec + bo_bit == (unsigned) limb_prec)
+ else if (rprec + bo_shift == (unsigned) limb_prec)
bf_cur = NULL_TREE;
}
/* Otherwise, stores to any other lhs. */
if (!done)
{
tree l = limb_access (nlhs ? NULL_TREE : lhs_type,
- nlhs ? nlhs : lhs, nidx, true);
+ nlhs ? nlhs : lhs, idx, true);
g = gimple_build_assign (l, rhs1);
}
insert_before (g);
add_eh_edge (e->src, find_edge (gimple_bb (stmt), eh_pad));
}
}
- if (kind == bitint_prec_huge && i == (bo_bit != 0))
+ if (kind == bitint_prec_huge && i == (bo_shift != 0))
{
g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
- size_one_node);
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
- g = gimple_build_cond (NE_EXPR, idx_next, size_int (end),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian && rem != 0)
+ g = gimple_build_cond (NE_EXPR, idx,
+ size_int (bo_idx + 1),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (NE_EXPR, idx_next,
+ size_int (bo_idx
+ + (bitint_big_endian
+ ? 0 : end)),
+ NULL_TREE, NULL_TREE);
insert_before (g);
m_gsi = gsi_for_stmt (stmt);
m_bb = NULL;
if (bf_cur != NULL_TREE)
{
unsigned int tprec = TYPE_PRECISION (type);
- unsigned int rprec = (tprec + bo_bit) % limb_prec;
+ unsigned int rprec = (tprec + bo_shift) % limb_prec;
tree ftype = build_nonstandard_integer_type (rprec, 1);
tree bfr = build_bit_field_ref (ftype, unshare_expr (nlhs),
rprec,
- (bo_idx + (tprec + bo_bit) / limb_prec)
- * limb_prec);
+ bitint_big_endian
+ ? bo_idx * limb_prec + bo_bit
+ : (bo_idx + (tprec + bo_bit) / limb_prec)
+ * limb_prec);
rhs1 = bf_cur;
if (bf_cur != ext)
{
rhs1 = make_ssa_name (TREE_TYPE (rhs1));
g = gimple_build_assign (rhs1, RSHIFT_EXPR, bf_cur,
build_int_cst (unsigned_type_node,
- limb_prec - bo_bit));
+ limb_prec - bo_shift));
insert_before (g);
}
rhs1 = add_cast (ftype, rhs1);
&& (cmp_code == GE_EXPR || cmp_code == LT_EXPR))
{
unsigned end = CEIL ((unsigned) TYPE_PRECISION (type), limb_prec) - 1;
- tree idx = size_int (end);
+ tree idx = size_int (bitint_big_endian ? 0 : end);
m_data_cnt = 0;
tree rhs1 = handle_operand (cmp_op1, idx);
if (TYPE_UNSIGNED (TREE_TYPE (rhs1)))
{
m_data_cnt = 0;
if (kind == bitint_prec_large)
- idx = size_int (cnt - i - 1);
+ idx = size_int (bitint_big_endian ? i : cnt - i - 1);
else if (i == cnt - 1)
- idx = create_loop (size_int (end - 1), &idx_next);
+ idx = create_loop (size_int (bitint_big_endian ? cnt - 1 : end - 1),
+ &idx_next);
else
- idx = size_int (end);
+ idx = size_int (bitint_big_endian ? 0 : end);
tree rhs1 = handle_operand (cmp_op1, idx);
tree rhs2 = handle_operand (cmp_op2, idx);
if (i == 0
m_first = false;
if (kind == bitint_prec_huge && i == cnt - 1)
{
- g = gimple_build_assign (idx_next, PLUS_EXPR, idx, size_int (-1));
+ g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+ bitint_big_endian ? size_one_node
+ : size_int (-1));
insert_before (g);
- g = gimple_build_cond (NE_EXPR, idx, size_zero_node,
+ g = gimple_build_cond (NE_EXPR, idx,
+ bitint_big_endian
+ ? size_int (end - 1 + (cnt != 1))
+ : size_zero_node,
NULL_TREE, NULL_TREE);
insert_before (g);
edge true_edge, false_edge;
size_t n2 = n / limb_prec;
size_t n3 = n1 != 0;
unsigned n4 = (limb_prec - n1) % limb_prec;
- (for power of 2 limb_prec n4 can be -n1 & (limb_prec)). */
+ (for power of 2 limb_prec n4 can be -n1 & limb_prec). */
if (TREE_CODE (n) == INTEGER_CST)
{
tree lp = build_int_cst (TREE_TYPE (n), limb_prec);
dst[idx] = ext; */
tree pmn3;
if (TYPE_UNSIGNED (type) && prec % limb_prec == 0)
- pmn3 = p;
+ pmn3 = bitint_big_endian ? size_zero_node : p;
+ else if (bitint_big_endian)
+ pmn3 = n3;
else if (TREE_CODE (n3) == INTEGER_CST)
pmn3 = int_const_binop (MINUS_EXPR, p, n3);
else
g = gimple_build_assign (pmn3, MINUS_EXPR, p, n3);
insert_before (g);
}
- g = gimple_build_cond (LT_EXPR, n2, pmn3, NULL_TREE, NULL_TREE);
+ tree pmn2 = NULL_TREE;
+ if (bitint_big_endian)
+ {
+ if (TREE_CODE (n2) == INTEGER_CST)
+ pmn2 = int_const_binop (MINUS_EXPR, p, n2);
+ else
+ {
+ pmn2 = make_ssa_name (sizetype);
+ g = gimple_build_assign (pmn2, MINUS_EXPR, p, n2);
+ insert_before (g);
+ }
+ g = gimple_build_cond (GT_EXPR, pmn2, pmn3, NULL_TREE, NULL_TREE);
+ }
+ else
+ g = gimple_build_cond (LT_EXPR, n2, pmn3, NULL_TREE, NULL_TREE);
edge edge_true, edge_false;
if_then (g, profile_probability::likely (), edge_true, edge_false);
tree idx_next;
- tree idx = create_loop (n2, &idx_next);
+ tree idx = create_loop (bitint_big_endian ? pmn2 : n2, &idx_next);
tree idxmn2 = make_ssa_name (sizetype);
tree idxpn3 = make_ssa_name (sizetype);
- g = gimple_build_assign (idxmn2, MINUS_EXPR, idx, n2);
+ g = gimple_build_assign (idxmn2,
+ bitint_big_endian ? PLUS_EXPR : MINUS_EXPR,
+ idx, n2);
insert_before (g);
- g = gimple_build_assign (idxpn3, PLUS_EXPR, idx, n3);
+ g = gimple_build_assign (idxpn3,
+ bitint_big_endian ? MINUS_EXPR : PLUS_EXPR,
+ idx, n3);
insert_before (g);
m_data_cnt = 0;
tree t1 = handle_operand (rhs1, idx);
tree l = limb_access (TREE_TYPE (lhs), obj, idxmn2, true);
g = gimple_build_assign (l, t1);
insert_before (g);
- g = gimple_build_assign (idx_next, PLUS_EXPR, idx, size_one_node);
+ g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+ bitint_big_endian ? size_int (-1)
+ : size_one_node);
insert_before (g);
- g = gimple_build_cond (LT_EXPR, idx_next, pmn3, NULL_TREE, NULL_TREE);
+ g = gimple_build_cond (bitint_big_endian ? GT_EXPR : LT_EXPR,
+ idx_next, pmn3, NULL_TREE, NULL_TREE);
insert_before (g);
idx = make_ssa_name (sizetype);
m_gsi = gsi_for_stmt (final_stmt);
edge_false = find_edge (edge_false->src, gsi_bb (m_gsi));
edge_true = EDGE_PRED (gsi_bb (m_gsi),
EDGE_PRED (gsi_bb (m_gsi), 0) == edge_false);
- add_phi_arg (phi, n2, edge_false, UNKNOWN_LOCATION);
+ add_phi_arg (phi, bitint_big_endian ? pmn2 : n2, edge_false,
+ UNKNOWN_LOCATION);
add_phi_arg (phi, idx_next, edge_true, UNKNOWN_LOCATION);
m_data_cnt = 0;
- tree ms = handle_operand (rhs1, p);
+ tree ms = handle_operand (rhs1, bitint_big_endian ? size_zero_node : p);
tree ext = ms;
if (!types_compatible_p (TREE_TYPE (ms), m_limb_type))
ext = add_cast (m_limb_type, ms);
if (!(TYPE_UNSIGNED (type) && prec % limb_prec == 0)
&& !integer_zerop (n3))
{
- g = gimple_build_cond (LT_EXPR, idx, p, NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (GT_EXPR, idx, size_zero_node,
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (LT_EXPR, idx, p, NULL_TREE, NULL_TREE);
if_then (g, profile_probability::likely (), edge_true, edge_false);
m_data_cnt = 0;
t1 = handle_operand (rhs1, idx);
insert_before (g);
t1 = gimple_assign_lhs (g);
idxmn2 = make_ssa_name (sizetype);
- g = gimple_build_assign (idxmn2, MINUS_EXPR, idx, n2);
+ g = gimple_build_assign (idxmn2, bitint_big_endian
+ ? PLUS_EXPR : MINUS_EXPR, idx, n2);
insert_before (g);
l = limb_access (TREE_TYPE (lhs), obj, idxmn2, true);
g = gimple_build_assign (l, t1);
insert_before (g);
idx_next = make_ssa_name (sizetype);
- g = gimple_build_assign (idx_next, PLUS_EXPR, idx, size_one_node);
+ g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
m_gsi = gsi_for_stmt (final_stmt);
tree nidx = make_ssa_name (sizetype);
add_phi_arg (phi, idx_next, edge_true, UNKNOWN_LOCATION);
idx = nidx;
}
- g = gimple_build_assign (make_ssa_name (sizetype), MINUS_EXPR, idx, n2);
+ g = gimple_build_assign (make_ssa_name (sizetype),
+ bitint_big_endian ? PLUS_EXPR : MINUS_EXPR,
+ idx, n2);
insert_before (g);
idx = gimple_assign_lhs (g);
tree sext = ext;
g = gimple_build_assign (l, t1);
insert_before (g);
g = gimple_build_assign (make_ssa_name (sizetype), PLUS_EXPR, idx,
- size_one_node);
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
- idx = gimple_assign_lhs (g);
- g = gimple_build_cond (LE_EXPR, idx, p, NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ {
+ tree new_idx = gimple_assign_lhs (g);
+ g = gimple_build_cond (NE_EXPR, idx, size_zero_node,
+ NULL_TREE, NULL_TREE);
+ idx = new_idx;
+ }
+ else
+ {
+ idx = gimple_assign_lhs (g);
+ g = gimple_build_cond (LE_EXPR, idx, p, NULL_TREE, NULL_TREE);
+ }
if_then (g, profile_probability::likely (), edge_true, edge_false);
idx = create_loop (idx, &idx_next);
l = limb_access (TREE_TYPE (lhs), obj, idx, true);
g = gimple_build_assign (l, ext);
insert_before (g);
- g = gimple_build_assign (idx_next, PLUS_EXPR, idx, size_one_node);
+ g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
- g = gimple_build_cond (LE_EXPR, idx_next, p, NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (NE_EXPR, idx, size_zero_node,
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (LE_EXPR, idx_next, p, NULL_TREE, NULL_TREE);
insert_before (g);
}
else
g = gimple_build_assign (n2pn3, PLUS_EXPR, n2, n3);
insert_before (g);
}
+ if (bitint_big_endian)
+ {
+ if (TREE_CODE (n2pn3) == INTEGER_CST)
+ n2pn3 = int_const_binop (MINUS_EXPR, p, n2pn3);
+ else
+ {
+ g = gimple_build_assign (make_ssa_name (sizetype),
+ MINUS_EXPR, p, n2pn3);
+ insert_before (g);
+ n2pn3 = gimple_assign_lhs (g);
+ }
+ }
/* For LSHIFT_EXPR, we can use handle_operand with non-INTEGER_CST
idx even to access the most significant partial limb. */
m_var_msb = true;
counts. Emit if (true) condition that can be optimized later. */
g = gimple_build_cond (NE_EXPR, boolean_true_node, boolean_false_node,
NULL_TREE, NULL_TREE);
+ else if (bitint_big_endian)
+ g = gimple_build_cond (NE_EXPR, n2pn3, size_int (-1), NULL_TREE,
+ NULL_TREE);
else
g = gimple_build_cond (LE_EXPR, n2pn3, p, NULL_TREE, NULL_TREE);
edge edge_true, edge_false;
if_then (g, profile_probability::likely (), edge_true, edge_false);
tree idx_next;
- tree idx = create_loop (p, &idx_next);
+ tree idx = create_loop (bitint_big_endian ? size_zero_node : p,
+ &idx_next);
tree idxmn2 = make_ssa_name (sizetype);
tree idxmn2mn3 = make_ssa_name (sizetype);
- g = gimple_build_assign (idxmn2, MINUS_EXPR, idx, n2);
+ g = gimple_build_assign (idxmn2,
+ bitint_big_endian ? PLUS_EXPR : MINUS_EXPR,
+ idx, n2);
insert_before (g);
- g = gimple_build_assign (idxmn2mn3, MINUS_EXPR, idxmn2, n3);
+ g = gimple_build_assign (idxmn2mn3,
+ bitint_big_endian ? PLUS_EXPR : MINUS_EXPR,
+ idxmn2, n3);
insert_before (g);
m_data_cnt = 0;
tree t1 = handle_operand (rhs1, idxmn2);
tree l = limb_access (TREE_TYPE (lhs), obj, idx, true);
g = gimple_build_assign (l, t1);
insert_before (g);
- g = gimple_build_assign (idx_next, PLUS_EXPR, idx, size_int (-1));
+ g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+ bitint_big_endian
+ ? size_one_node : size_int (-1));
insert_before (g);
tree sn2pn3 = add_cast (ssizetype, n2pn3);
- g = gimple_build_cond (GE_EXPR, add_cast (ssizetype, idx_next), sn2pn3,
+ g = gimple_build_cond (bitint_big_endian ? LE_EXPR : GE_EXPR,
+ add_cast (ssizetype, idx_next), sn2pn3,
NULL_TREE, NULL_TREE);
insert_before (g);
idx = make_ssa_name (sizetype);
edge_false = find_edge (edge_false->src, gsi_bb (m_gsi));
edge_true = EDGE_PRED (gsi_bb (m_gsi),
EDGE_PRED (gsi_bb (m_gsi), 0) == edge_false);
- add_phi_arg (phi, p, edge_false, UNKNOWN_LOCATION);
+ add_phi_arg (phi, bitint_big_endian ? size_zero_node : p,
+ edge_false, UNKNOWN_LOCATION);
add_phi_arg (phi, idx_next, edge_true, UNKNOWN_LOCATION);
m_data_cnt = 0;
if (!integer_zerop (n3))
NULL_TREE, NULL_TREE);
if_then (g, profile_probability::likely (), edge_true, edge_false);
idxmn2 = make_ssa_name (sizetype);
- g = gimple_build_assign (idxmn2, MINUS_EXPR, idx, n2);
+ g = gimple_build_assign (idxmn2,
+ bitint_big_endian ? PLUS_EXPR : MINUS_EXPR,
+ idx, n2);
insert_before (g);
m_data_cnt = 0;
t1 = handle_operand (rhs1, idxmn2);
g = gimple_build_assign (l, t1);
insert_before (g);
idx_next = make_ssa_name (sizetype);
- g = gimple_build_assign (idx_next, PLUS_EXPR, idx, size_int (-1));
+ g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+ bitint_big_endian
+ ? size_one_node : size_int (-1));
insert_before (g);
m_gsi = gsi_for_stmt (final_stmt);
tree nidx = make_ssa_name (sizetype);
add_phi_arg (phi, idx_next, edge_true, UNKNOWN_LOCATION);
idx = nidx;
}
- g = gimple_build_cond (GE_EXPR, add_cast (ssizetype, idx),
- ssize_int (0), NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (LE_EXPR, idx, p, NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (GE_EXPR, add_cast (ssizetype, idx),
+ ssize_int (0), NULL_TREE, NULL_TREE);
if_then (g, profile_probability::likely (), edge_true, edge_false);
idx = create_loop (idx, &idx_next);
l = limb_access (TREE_TYPE (lhs), obj, idx, true);
g = gimple_build_assign (l, build_zero_cst (m_limb_type));
insert_before (g);
- g = gimple_build_assign (idx_next, PLUS_EXPR, idx, size_int (-1));
+ g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
+ bitint_big_endian
+ ? size_one_node : size_int (-1));
insert_before (g);
- g = gimple_build_cond (GE_EXPR, add_cast (ssizetype, idx_next),
- ssize_int (0), NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (LE_EXPR, idx_next, p, NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (GE_EXPR, add_cast (ssizetype, idx_next),
+ ssize_int (0), NULL_TREE, NULL_TREE);
insert_before (g);
}
}
void
bitint_large_huge::finish_arith_overflow (tree var, tree obj, tree type,
tree ovf, tree lhs, tree orig_obj,
- gimple *stmt, tree_code code)
+ gimple *stmt, unsigned nelts,
+ tree_code code)
{
gimple *g;
&& bitint_precision_kind (type) == bitint_prec_middle)
lhs_type = build_nonstandard_integer_type (TYPE_PRECISION (type),
TYPE_UNSIGNED (type));
- tree r1 = limb_access (NULL_TREE, var, size_int (0), true);
+ tree r1 = limb_access (NULL_TREE, var,
+ bitint_big_endian
+ ? size_int (nelts - 1) : size_zero_node, true);
g = gimple_build_assign (make_ssa_name (m_limb_type), r1);
insert_before (g);
r1 = gimple_assign_lhs (g);
r1 = add_cast (lhs_type, r1);
if (TYPE_PRECISION (lhs_type) > limb_prec)
{
- tree r2 = limb_access (NULL_TREE, var, size_int (1), true);
+ tree r2 = limb_access (NULL_TREE, var,
+ bitint_big_endian
+ ? size_int (nelts - 2) : size_one_node, true);
g = gimple_build_assign (make_ssa_name (m_limb_type), r2);
insert_before (g);
r2 = gimple_assign_lhs (g);
}
else
{
- unsigned HOST_WIDE_INT nelts = 0;
+ unsigned HOST_WIDE_INT obj_nelts = 0;
tree atype = NULL_TREE;
if (obj)
{
- nelts = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (obj))) / limb_prec;
+ obj_nelts = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (obj))) / limb_prec;
if (orig_obj == NULL_TREE)
- nelts >>= 1;
- atype = build_array_type_nelts (m_limb_type, nelts);
+ obj_nelts >>= 1;
+ atype = build_array_type_nelts (m_limb_type, obj_nelts);
}
if (var && obj)
{
tree v1, v2;
- tree zero;
+ tree off;
if (orig_obj == NULL_TREE)
{
- zero = build_zero_cst (build_pointer_type (TREE_TYPE (obj)));
+ off = build_zero_cst (build_pointer_type (TREE_TYPE (obj)));
v1 = build2 (MEM_REF, atype,
- build_fold_addr_expr (unshare_expr (obj)), zero);
+ build_fold_addr_expr (unshare_expr (obj)), off);
}
else if (!useless_type_conversion_p (atype, TREE_TYPE (obj)))
v1 = build1 (VIEW_CONVERT_EXPR, atype, unshare_expr (obj));
else
v1 = unshare_expr (obj);
- zero = build_zero_cst (build_pointer_type (TREE_TYPE (var)));
- v2 = build2 (MEM_REF, atype, build_fold_addr_expr (var), zero);
+ off = build_int_cst (build_pointer_type (TREE_TYPE (var)),
+ bitint_big_endian
+ ? (nelts - obj_nelts) * m_limb_size : 0);
+ v2 = build2 (MEM_REF, atype, build_fold_addr_expr (var), off);
g = gimple_build_assign (v1, v2);
insert_before (g);
}
+ else if (obj && bitint_big_endian && nelts != obj_nelts)
+ {
+ gcc_assert (nelts > obj_nelts);
+ tree fn = builtin_decl_implicit (BUILT_IN_MEMMOVE);
+ tree off = build_int_cst (build_pointer_type (TREE_TYPE (obj)),
+ (nelts - obj_nelts) * m_limb_size);
+ tree src = build2 (MEM_REF, atype,
+ build_fold_addr_expr (unshare_expr (obj)), off);
+ g = gimple_build_call (fn, 3,
+ build_fold_addr_expr (unshare_expr (obj)),
+ src, build_int_cst (size_type_node,
+ obj_nelts * m_limb_size));
+ insert_before (g);
+ }
if (orig_obj == NULL_TREE && obj)
{
ovf = add_cast (m_limb_type, ovf);
- tree l = limb_access (NULL_TREE, obj, size_int (nelts), true);
+ tree l = limb_access (NULL_TREE, obj,
+ size_int (bitint_big_endian
+ ? obj_nelts * 2 - 1 : obj_nelts),
+ true);
g = gimple_build_assign (l, ovf);
insert_before (g);
- if (nelts > 1)
+ if (obj_nelts > 1)
{
- atype = build_array_type_nelts (m_limb_type, nelts - 1);
+ atype = build_array_type_nelts (m_limb_type, obj_nelts - 1);
tree off = build_int_cst (build_pointer_type (TREE_TYPE (obj)),
- (nelts + 1) * m_limb_size);
+ (obj_nelts + !bitint_big_endian)
+ * m_limb_size);
tree v1 = build2 (MEM_REF, atype,
build_fold_addr_expr (unshare_expr (obj)),
off);
int prec4 = ovf != NULL_TREE ? prec : prec3;
bitint_prec_kind kind = bitint_precision_kind (prec4);
- unsigned cnt, rem = 0, fin = 0;
+ unsigned cnt, rem = 0, fin = 0, nelts;
tree idx = NULL_TREE, idx_first = NULL_TREE, idx_next = NULL_TREE;
bool last_ovf = (ovf == NULL_TREE
&& CEIL (prec2, limb_prec) > CEIL (prec3, limb_prec));
if (kind != bitint_prec_huge)
- cnt = CEIL (prec4, limb_prec) + last_ovf;
+ nelts = cnt = CEIL (prec4, limb_prec) + last_ovf;
else
{
- rem = (prec4 % (2 * limb_prec));
+ rem = prec4 % (2 * limb_prec);
fin = (prec4 - rem) / limb_prec;
cnt = 2 + CEIL (rem, limb_prec) + last_ovf;
- idx = idx_first = create_loop (size_zero_node, &idx_next);
+ nelts = fin + cnt - 2;
+ idx = idx_first = create_loop (bitint_big_endian
+ ? size_int (nelts - 1) : size_zero_node,
+ &idx_next);
}
if (kind == bitint_prec_huge)
m_data_cnt = 0;
tree rhs1, rhs2;
if (kind != bitint_prec_huge)
- idx = size_int (i);
+ idx = size_int (bitint_big_endian ? nelts - 1 - i : i);
else if (i >= 2)
- idx = size_int (fin + i - 2);
+ idx = size_int (bitint_big_endian ? nelts + 1 - fin - i : fin + i - 2);
if (!last_ovf || i < cnt - 1)
{
+ tree idx0 = idx, idx1 = idx;
+ if (bitint_big_endian
+ && CEIL ((unsigned) TYPE_PRECISION (type0), limb_prec) != nelts)
+ {
+ HOST_WIDE_INT diff
+ = ((HOST_WIDE_INT) CEIL (TYPE_PRECISION (type0), limb_prec)
+ - (HOST_WIDE_INT) nelts);
+ if (tree_fits_uhwi_p (idx))
+ idx0 = size_int (tree_to_uhwi (idx) + diff);
+ else
+ {
+ idx0 = make_ssa_name (sizetype);
+ g = gimple_build_assign (idx0, PLUS_EXPR, idx,
+ size_int (diff));
+ insert_before (g);
+ }
+ }
if (type0 != TREE_TYPE (arg0))
- rhs1 = handle_cast (type0, arg0, idx);
+ rhs1 = handle_cast (type0, arg0, idx0);
else
- rhs1 = handle_operand (arg0, idx);
+ rhs1 = handle_operand (arg0, idx0);
+ if (bitint_big_endian
+ && CEIL ((unsigned) TYPE_PRECISION (type1), limb_prec) != nelts)
+ {
+ HOST_WIDE_INT diff
+ = ((HOST_WIDE_INT) CEIL (TYPE_PRECISION (type1), limb_prec)
+ - (HOST_WIDE_INT) nelts);
+ if (tree_fits_uhwi_p (idx))
+ idx1 = size_int (tree_to_uhwi (idx) + diff);
+ else
+ {
+ idx1 = make_ssa_name (sizetype);
+ g = gimple_build_assign (idx1, PLUS_EXPR, idx,
+ size_int (diff));
+ insert_before (g);
+ }
+ }
if (type1 != TREE_TYPE (arg1))
- rhs2 = handle_cast (type1, arg1, idx);
+ rhs2 = handle_cast (type1, arg1, idx1);
else
- rhs2 = handle_operand (arg1, idx);
+ rhs2 = handle_operand (arg1, idx1);
if (i == 0)
data_cnt = m_data_cnt;
if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (rhs1)))
if (tree_fits_uhwi_p (idx))
{
unsigned limb = tree_to_uhwi (idx);
+ if (bitint_big_endian)
+ limb = nelts - 1 - limb;
if (limb >= startlimb && limb <= endlimb)
{
tree l = arith_overflow_extract_bits (start, end, rhs,
cmp_code = EQ_EXPR;
else
cmp_code = GT_EXPR;
- g = gimple_build_cond (cmp_code, idx, size_int (startlimb),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (swap_tree_comparison (cmp_code),
+ idx, size_int (nelts - 1
+ - startlimb),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (cmp_code, idx, size_int (startlimb),
+ NULL_TREE, NULL_TREE);
edge edge_true_true, edge_true_false, edge_false;
gimple *g2 = NULL;
if (!single_comparison)
g2 = gimple_build_cond (NE_EXPR, idx,
- size_int (startlimb), NULL_TREE,
- NULL_TREE);
+ size_int (bitint_big_endian
+ ? nelts - 1 - startlimb
+ : startlimb),
+ NULL_TREE, NULL_TREE);
if_then_if_then_else (g, g2, profile_probability::likely (),
profile_probability::likely (),
edge_true_true, edge_true_false,
if (var || obj)
{
- if (tree_fits_uhwi_p (idx) && tree_to_uhwi (idx) >= prec_limbs)
+ if (tree_fits_uhwi_p (idx)
+ && (bitint_big_endian
+ ? nelts - 1 - tree_to_uhwi (idx)
+ : tree_to_uhwi (idx)) >= prec_limbs)
;
else if (!tree_fits_uhwi_p (idx)
&& (unsigned) prec < (fin - (i == 0)) * limb_prec)
= (((unsigned) prec % limb_prec) == 0
|| prec_limbs + 1 >= fin
|| (prec_limbs & 1) == (i & 1));
- g = gimple_build_cond (LE_EXPR, idx, size_int (prec_limbs - 1),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (GE_EXPR, idx,
+ size_int (nelts - prec_limbs),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (LE_EXPR, idx, size_int (prec_limbs - 1),
+ NULL_TREE, NULL_TREE);
gimple *g2 = NULL;
if (!single_comparison)
g2 = gimple_build_cond (EQ_EXPR, idx,
- size_int (prec_limbs - 1),
+ size_int (bitint_big_endian
+ ? nelts - prec_limbs
+ : prec_limbs - 1),
NULL_TREE, NULL_TREE);
edge edge_true_true, edge_true_false, edge_false;
if_then_if_then_else (g, g2, profile_probability::likely (),
profile_probability::unlikely (),
edge_true_true, edge_true_false,
edge_false);
- tree l = limb_access (type, var ? var : obj, idx, true);
+ tree idxl = idx;
+ if (bitint_big_endian && prec_limbs != nelts)
+ {
+ HOST_WIDE_INT diff = ((HOST_WIDE_INT) prec_limbs
+ - (HOST_WIDE_INT) nelts);
+ if (tree_fits_uhwi_p (idx))
+ idxl = size_int (tree_to_uhwi (idx) + diff);
+ else
+ {
+ idxl = make_ssa_name (sizetype);
+ g = gimple_build_assign (idxl, PLUS_EXPR, idx,
+ size_int (diff));
+ insert_before (g);
+ }
+ }
+ tree l = limb_access (type, var ? var : obj, idxl, true);
g = gimple_build_assign (l, rhs);
insert_before (g);
if (!single_comparison)
{
m_gsi = gsi_after_labels (edge_true_true->src);
- tree plm1idx = size_int (prec_limbs - 1);
+ tree plm1idx = size_int (bitint_big_endian
+ ? 0 : prec_limbs - 1);
tree plm1type = limb_access_type (type, plm1idx);
l = limb_access (type, var ? var : obj, plm1idx, true);
if (!useless_type_conversion_p (plm1type, TREE_TYPE (rhs)))
}
else
{
- tree l = limb_access (type, var ? var : obj, idx, true);
+ tree idxl = idx;
+ if (bitint_big_endian && prec_limbs != nelts)
+ {
+ HOST_WIDE_INT diff = ((HOST_WIDE_INT) prec_limbs
+ - (HOST_WIDE_INT) nelts);
+ if (tree_fits_uhwi_p (idx))
+ idxl = size_int (tree_to_uhwi (idx) + diff);
+ else
+ {
+ idxl = make_ssa_name (sizetype);
+ g = gimple_build_assign (idxl, PLUS_EXPR, idx,
+ size_int (diff));
+ insert_before (g);
+ }
+ }
+ tree l = limb_access (type, var ? var : obj, idxl, true);
if (!useless_type_conversion_p (TREE_TYPE (l), TREE_TYPE (rhs)))
rhs = add_cast (TREE_TYPE (l), rhs);
g = gimple_build_assign (l, rhs);
{
idx = make_ssa_name (sizetype);
g = gimple_build_assign (idx, PLUS_EXPR, idx_first,
- size_one_node);
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
}
else
{
g = gimple_build_assign (idx_next, PLUS_EXPR, idx_first,
- size_int (2));
+ size_int (bitint_big_endian ? -2 : 2));
insert_before (g);
- g = gimple_build_cond (NE_EXPR, idx_next, size_int (fin),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (NE_EXPR, idx_first,
+ size_int (nelts + 1 - fin),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (NE_EXPR, idx_next, size_int (fin),
+ NULL_TREE, NULL_TREE);
insert_before (g);
m_gsi = gsi_for_stmt (final_stmt);
m_bb = NULL;
}
}
- finish_arith_overflow (var, obj, type, ovf, lhs, orig_obj, stmt, code);
+ finish_arith_overflow (var, obj, type, ovf, lhs, orig_obj, stmt,
+ prec_limbs, code);
}
/* Lower a .MUL_OVERFLOW call with at least one large/huge _BitInt
{
unsigned startlimb = start / limb_prec;
unsigned endlimb = (end - 1) / limb_prec;
+ unsigned nelts = CEIL (MAX (prec, prec2), limb_prec);
unsigned cnt;
bool use_loop = false;
if (startlimb == endlimb)
if (cnt == 1)
{
tree l = limb_access (NULL_TREE, var ? var : obj,
- size_int (startlimb), true);
+ size_int (bitint_big_endian
+ ? nelts - 1 - startlimb
+ : startlimb), true);
g = gimple_build_assign (make_ssa_name (m_limb_type), l);
insert_before (g);
l = arith_overflow_extract_bits (start, end, gimple_assign_lhs (g),
{
tree idx, idx_next = NULL_TREE;
if (i == 0)
- idx = size_int (startlimb);
+ idx = size_int (bitint_big_endian
+ ? nelts - 1 - startlimb : startlimb);
else if (i == 2)
- idx = size_int (endlimb);
+ idx = size_int (bitint_big_endian
+ ? nelts - 1 - endlimb : endlimb);
else if (use_loop)
- idx = create_loop (size_int (startlimb + 1), &idx_next);
+ idx = create_loop (size_int (bitint_big_endian
+ ? nelts - startlimb - 2
+ : startlimb + 1), &idx_next);
else
- idx = size_int (startlimb + 1);
+ idx = size_int (bitint_big_endian
+ ? nelts - startlimb - 2 : startlimb + 1);
tree l = limb_access (NULL_TREE, var ? var : obj, idx, true);
g = gimple_build_assign (make_ssa_name (m_limb_type), l);
insert_before (g);
l = gimple_assign_lhs (g);
if (i == 0 || i == 2)
l = arith_overflow_extract_bits (start, end, l,
- tree_to_uhwi (idx),
+ i == 0 ? startlimb : endlimb,
check_zero);
if (i == 0 && !check_zero)
{
if (i == 1 && use_loop)
{
g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
- size_one_node);
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
- g = gimple_build_cond (NE_EXPR, idx_next,
- size_int (endlimb + (cnt == 2)),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (NE_EXPR, idx,
+ size_int (nelts - endlimb
+ - (cnt == 2)),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (NE_EXPR, idx_next,
+ size_int (endlimb + (cnt == 2)),
+ NULL_TREE, NULL_TREE);
insert_before (g);
edge true_edge, false_edge;
extract_true_false_edges_from_block (gsi_bb (m_gsi),
}
}
- finish_arith_overflow (var, obj, type, ovf, lhs, orig_obj, stmt, MULT_EXPR);
+ finish_arith_overflow (var, obj, type, ovf, lhs, orig_obj, stmt,
+ CEIL (MAX (prec, prec2), limb_prec), MULT_EXPR);
}
/* Lower REALPART_EXPR or IMAGPART_EXPR stmt extracting part of result from
}
tree fndecl = builtin_decl_explicit (fcode), res = NULL_TREE;
unsigned cnt = 0, rem = 0, end = 0, prec = TYPE_PRECISION (type);
+ unsigned nelts = CEIL (prec, limb_prec);
struct bq_details { edge e; tree val, addend; } *bqp = NULL;
basic_block edge_bb = NULL;
if (m_upwards)
{
tree idx = NULL_TREE, idx_first = NULL_TREE, idx_next = NULL_TREE;
if (kind == bitint_prec_large)
- cnt = CEIL (prec, limb_prec);
+ cnt = nelts;
else
{
rem = (prec % (2 * limb_prec));
end = (prec - rem) / limb_prec;
cnt = 2 + CEIL (rem, limb_prec);
- idx = idx_first = create_loop (size_zero_node, &idx_next);
+ idx = idx_first = create_loop (bitint_big_endian
+ ? size_int (nelts - 1)
+ : size_zero_node, &idx_next);
}
if (ifn == IFN_CTZ || ifn == IFN_FFS)
{
m_data_cnt = 0;
if (kind == bitint_prec_large)
- idx = size_int (i);
+ idx = size_int (bitint_big_endian ? nelts - 1 - i : i);
else if (i >= 2)
- idx = size_int (end + (i > 2));
+ idx = size_int (bitint_big_endian
+ ? nelts - 1 - end - (i > 2) : end + (i > 2));
tree rhs1 = handle_operand (arg0, idx);
if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (rhs1)))
if (tree_fits_uhwi_p (idx))
bqp[i].addend
= build_int_cst (integer_type_node,
- tree_to_uhwi (idx) * limb_prec
+ (bitint_big_endian
+ ? nelts - 1 - tree_to_uhwi (idx)
+ : tree_to_uhwi (idx)) * limb_prec
+ (ifn == IFN_FFS));
else
{
{
idx = make_ssa_name (sizetype);
g = gimple_build_assign (idx, PLUS_EXPR, idx_first,
- size_one_node);
+ bitint_big_endian
+ ? size_int (-1) : size_one_node);
insert_before (g);
}
else
{
g = gimple_build_assign (idx_next, PLUS_EXPR, idx_first,
- size_int (2));
+ size_int (bitint_big_endian
+ ? -2 : 2));
insert_before (g);
- g = gimple_build_cond (NE_EXPR, idx_next, size_int (end),
- NULL_TREE, NULL_TREE);
+ if (bitint_big_endian)
+ g = gimple_build_cond (NE_EXPR, idx_first,
+ size_int (cnt - 1),
+ NULL_TREE, NULL_TREE);
+ else
+ g = gimple_build_cond (NE_EXPR, idx_next, size_int (end),
+ NULL_TREE, NULL_TREE);
insert_before (g);
if (ifn == IFN_CTZ || ifn == IFN_FFS)
m_gsi = gsi_after_labels (edge_bb);
tree idx = NULL_TREE, idx_next = NULL_TREE, first = NULL_TREE;
int sub_one = 0;
if (kind == bitint_prec_large)
- cnt = CEIL (prec, limb_prec);
+ cnt = nelts;
else
{
rem = prec % limb_prec;
{
m_data_cnt = 0;
if (kind == bitint_prec_large)
- idx = size_int (cnt - i - 1);
+ idx = size_int (bitint_big_endian ? i : cnt - i - 1);
else if (i == cnt - 1)
- idx = create_loop (size_int (end - 1), &idx_next);
+ idx = create_loop (size_int (bitint_big_endian ? i : end - 1),
+ &idx_next);
else
- idx = size_int (end);
+ idx = bitint_big_endian ? size_zero_node : size_int (end);
tree rhs1 = handle_operand (arg0, idx);
if (!useless_type_conversion_p (m_limb_type, TREE_TYPE (rhs1)))
bqp[i].addend
= build_int_cst (integer_type_node,
(int) prec
- - (((int) tree_to_uhwi (idx) + 1)
+ - (((int) (bitint_big_endian
+ ? nelts - 1 - tree_to_uhwi (idx)
+ : tree_to_uhwi (idx)) + 1)
* limb_prec) - sub_one);
else
{
if (kind == bitint_prec_huge && i == cnt - 1)
{
g = gimple_build_assign (idx_next, PLUS_EXPR, idx,
- size_int (-1));
+ bitint_big_endian
+ ? size_one_node : size_int (-1));
insert_before (g);
- g = gimple_build_cond (NE_EXPR, idx, size_zero_node,
+ g = gimple_build_cond (NE_EXPR, idx,
+ bitint_big_endian
+ ? size_int (nelts - 1) : size_zero_node,
NULL_TREE, NULL_TREE);
insert_before (g);
edge true_edge, false_edge;
TYPE_UNSIGNED (lhs_type));
m_data_cnt = 0;
tree rhs1 = gimple_assign_rhs1 (stmt);
- tree r1 = handle_operand (rhs1, size_int (0));
+ unsigned int prec = TYPE_PRECISION (TREE_TYPE (rhs1));
+ unsigned int cnt = CEIL (prec, limb_prec);
+ tree r1 = handle_operand (rhs1, size_int (bitint_big_endian
+ ? cnt - 1 : 0));
if (!useless_type_conversion_p (lhs_type, TREE_TYPE (r1)))
r1 = add_cast (lhs_type, r1);
if (TYPE_PRECISION (lhs_type) > limb_prec)
{
m_data_cnt = 0;
m_first = false;
- tree r2 = handle_operand (rhs1, size_int (1));
+ tree r2 = handle_operand (rhs1, size_int (bitint_big_endian
+ ? cnt - 2 : 1));
r2 = add_cast (lhs_type, r2);
g = gimple_build_assign (make_ssa_name (lhs_type), LSHIFT_EXPR, r2,
build_int_cst (unsigned_type_node,
tree fld = TREE_OPERAND (rhs1, 1);
/* For little-endian, we can allow as inputs bit-fields
which start at a limb boundary. */
- if (DECL_OFFSET_ALIGN (fld) >= TYPE_ALIGN (TREE_TYPE (rhs1))
+ if (!bitint_big_endian
+ && DECL_OFFSET_ALIGN (fld) >= TYPE_ALIGN (TREE_TYPE (rhs1))
&& tree_fits_uhwi_p (DECL_FIELD_BIT_OFFSET (fld))
&& (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (fld))
% limb_prec) == 0)
}
}
}
+ else if (bitint_big_endian
+ && is_gimple_call (stmt)
+ && gimple_call_internal_p (stmt))
+ switch (gimple_call_internal_fn (stmt))
+ {
+ case IFN_ADD_OVERFLOW:
+ case IFN_SUB_OVERFLOW:
+ case IFN_UBSAN_CHECK_ADD:
+ case IFN_UBSAN_CHECK_SUB:
+ case IFN_MUL_OVERFLOW:
+ case IFN_UBSAN_CHECK_MUL:
+ lhs = gimple_call_lhs (stmt);
+ if (lhs)
+ muldiv_p = true;
+ break;
+ default:
+ break;
+ }
+ auto_vec<tree, 16> worklist;
ssa_op_iter iter;
tree var;
+ /* On little-endian, mergeable ops process limbs from 0 up so except
+ for multiplication/division/modulo there is no risk in using the
+ same underlying variable for lhs and some operand, even when casts
+ are involved, the lhs limb is stored only after processing the source
+ limbs with the same index.
+ For multiplication/division/modulo, the libgcc library function requires
+ no aliasing between result and sources.
+ On big-endian, even mergeable ops limb processing can be problematic
+ though, because it can apply various index corrections e.g. when there
+ is a cast from operand with different number of limbs. So, make the
+ lhs conflict with all the operands which are (for now virtually) used on
+ the current stmt if there is any mismatch in the number of limbs between
+ operands and the lhs. */
+ if (bitint_big_endian && lhs && !muldiv_p)
+ {
+ tree ltype = TREE_TYPE (lhs);
+ if (TREE_CODE (ltype) == COMPLEX_TYPE)
+ muldiv_p = true;
+ else if (TREE_CODE (lhs) == SSA_NAME
+ && TREE_CODE (ltype) == BITINT_TYPE
+ && bitint_precision_kind (ltype) >= bitint_prec_large)
+ {
+ unsigned lnelts = CEIL (TYPE_PRECISION (ltype), limb_prec);
+ FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
+ {
+ tree type = TREE_TYPE (var);
+ if (TREE_CODE (type) == COMPLEX_TYPE)
+ type = TREE_TYPE (type);
+ if (TREE_CODE (type) == BITINT_TYPE
+ && bitint_precision_kind (type) >= bitint_prec_large)
+ {
+ if (bitmap_bit_p (names, SSA_NAME_VERSION (var)))
+ {
+ unsigned nelts = CEIL (TYPE_PRECISION (type), limb_prec);
+ if (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
+ || lnelts != nelts)
+ {
+ muldiv_p = true;
+ break;
+ }
+ }
+ else
+ worklist.safe_push (var);
+ }
+ }
+
+ while (!muldiv_p && worklist.length () > 0)
+ {
+ tree s = worklist.pop ();
+ FOR_EACH_SSA_TREE_OPERAND (var, SSA_NAME_DEF_STMT (s), iter,
+ SSA_OP_USE)
+ {
+ tree type = TREE_TYPE (var);
+ if (TREE_CODE (type) == COMPLEX_TYPE)
+ type = TREE_TYPE (type);
+ if (TREE_CODE (type) == BITINT_TYPE
+ && bitint_precision_kind (type) >= bitint_prec_large)
+ {
+ if (bitmap_bit_p (names, SSA_NAME_VERSION (var)))
+ {
+ unsigned nelts = CEIL (TYPE_PRECISION (type),
+ limb_prec);
+ if (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
+ || lnelts != nelts)
+ {
+ muldiv_p = true;
+ break;
+ }
+ }
+ else
+ worklist.safe_push (var);
+ }
+ }
+ }
+ worklist.truncate (0);
+ }
+ }
+
if (!muldiv_p)
{
/* For stmts with more than one SSA_NAME definition pretend all the
def (live, var, graph);
}
- auto_vec<tree, 16> worklist;
FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
{
tree type = TREE_TYPE (var);
{
small_max_prec = mid_min_prec = large_min_prec = huge_min_prec = 0;
limb_prec = 0;
+ bitint_big_endian = false;
unsigned int i;
for (i = 0; i < num_ssa_names; ++i)
break;
}
if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE)
- g = gimple_build_assign (build1 (VIEW_CONVERT_EXPR,
- TREE_TYPE (c), v1),
- c);
+ {
+ if (bitint_big_endian)
+ {
+ tree ptype = build_pointer_type (TREE_TYPE (v1));
+ tree sz1 = TYPE_SIZE_UNIT (TREE_TYPE (v1));
+ tree sz2 = TYPE_SIZE_UNIT (TREE_TYPE (c));
+ tree off = build_int_cst (ptype,
+ tree_to_uhwi (sz1)
+ - tree_to_uhwi (sz2));
+ tree vd = build2 (MEM_REF, TREE_TYPE (c),
+ build_fold_addr_expr (v1),
+ off);
+ g = gimple_build_assign (vd, c);
+ }
+ else
+ g = gimple_build_assign (build1 (VIEW_CONVERT_EXPR,
+ TREE_TYPE (c),
+ v1), c);
+ }
else
{
unsigned HOST_WIDE_INT nelts
tree vtype
= build_array_type_nelts (large_huge.m_limb_type,
nelts);
- g = gimple_build_assign (build1 (VIEW_CONVERT_EXPR,
- vtype, v1),
+ tree vd;
+ if (bitint_big_endian)
+ {
+ tree ptype = build_pointer_type (TREE_TYPE (v1));
+ tree sz1 = TYPE_SIZE_UNIT (TREE_TYPE (v1));
+ tree sz2 = TYPE_SIZE_UNIT (vtype);
+ tree off = build_int_cst (ptype,
+ tree_to_uhwi (sz1)
+ - tree_to_uhwi (sz2));
+ vd = build2 (MEM_REF, vtype,
+ build_fold_addr_expr (v1), off);
+ }
+ else
+ vd = build1 (VIEW_CONVERT_EXPR, vtype, v1);
+ g = gimple_build_assign (vd,
build1 (VIEW_CONVERT_EXPR,
vtype, c));
}
nelts);
tree ptype = build_pointer_type (TREE_TYPE (v1));
tree off;
- if (c)
+ if (c && !bitint_big_endian)
off = fold_convert (ptype,
TYPE_SIZE_UNIT (TREE_TYPE (c)));
else
else
{
tree vd = v1;
- if (c)
+ if (c && !bitint_big_endian)
{
tree ptype = build_pointer_type (TREE_TYPE (v1));
tree off
projects / thirdparty / gcc.git / commitdiff
