tree
maybe_fold_tmr (tree ref)
{
struct mem_address addr;
bool changed = false;
tree ret, off;
get_address_description (ref, &addr);
if (addr.base && TREE_CODE (addr.base) == INTEGER_CST)
{
if (addr.offset)
addr.offset = fold_binary_to_constant (PLUS_EXPR, sizetype,
addr.offset,
fold_convert (sizetype, addr.base));
else
addr.offset = addr.base;
addr.base = NULL_TREE;
changed = true;
}
if (addr.index && TREE_CODE (addr.index) == INTEGER_CST)
{
off = addr.index;
if (addr.step)
{
off = fold_binary_to_constant (MULT_EXPR, sizetype,
off, addr.step);
addr.step = NULL_TREE;
}
if (addr.offset)
{
addr.offset = fold_binary_to_constant (PLUS_EXPR, sizetype,
addr.offset, off);
}
else
addr.offset = off;
addr.index = NULL_TREE;
changed = true;
}
if (!changed)
return NULL_TREE;
ret = create_mem_ref_raw (TREE_TYPE (ref), NULL_TREE, &addr);
if (!ret)
return NULL_TREE;
copy_mem_ref_info (ret, ref);
return ret;
}
tree
maybe_fold_tmr (tree ref)
{
struct mem_address addr;
bool changed = false;
tree ret, off;
get_address_description (ref, &addr);
if (addr.base
&& TREE_CODE (addr.base) == INTEGER_CST
&& !integer_zerop (addr.base))
{
addr.offset = fold_binary_to_constant (PLUS_EXPR,
TREE_TYPE (addr.offset),
addr.offset, addr.base);
addr.base = NULL_TREE;
changed = true;
}
if (addr.symbol
&& TREE_CODE (TREE_OPERAND (addr.symbol, 0)) == MEM_REF)
{
addr.offset = fold_binary_to_constant
(PLUS_EXPR, TREE_TYPE (addr.offset),
addr.offset,
TREE_OPERAND (TREE_OPERAND (addr.symbol, 0), 1));
addr.symbol = TREE_OPERAND (TREE_OPERAND (addr.symbol, 0), 0);
changed = true;
}
else if (addr.symbol
&& handled_component_p (TREE_OPERAND (addr.symbol, 0)))
{
HOST_WIDE_INT offset;
addr.symbol = build_fold_addr_expr
(get_addr_base_and_unit_offset
(TREE_OPERAND (addr.symbol, 0), &offset));
addr.offset = int_const_binop (PLUS_EXPR,
addr.offset, size_int (offset));
changed = true;
}
if (addr.index && TREE_CODE (addr.index) == INTEGER_CST)
{
off = addr.index;
if (addr.step)
{
off = fold_binary_to_constant (MULT_EXPR, sizetype,
off, addr.step);
addr.step = NULL_TREE;
}
addr.offset = fold_binary_to_constant (PLUS_EXPR,
TREE_TYPE (addr.offset),
addr.offset, off);
addr.index = NULL_TREE;
changed = true;
}
if (!changed)
return NULL_TREE;
/* If we have propagated something into this TARGET_MEM_REF and thus
ended up folding it, always create a new TARGET_MEM_REF regardless
if it is valid in this for on the target - the propagation result
wouldn't be anyway. */
ret = create_mem_ref_raw (TREE_TYPE (ref),
TREE_TYPE (addr.offset), &addr, false);
copy_mem_ref_info (ret, ref);
return ret;
}
tree
create_mem_ref (gimple_stmt_iterator *gsi, tree type, aff_tree *addr,
tree alias_ptr_type, tree iv_cand, tree base_hint, bool speed)
{
tree mem_ref, tmp;
struct mem_address parts;
addr_to_parts (type, addr, iv_cand, base_hint, &parts, speed);
gimplify_mem_ref_parts (gsi, &parts);
mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true);
if (mem_ref)
return mem_ref;
/* The expression is too complicated. Try making it simpler. */
if (parts.step && !integer_onep (parts.step))
{
/* Move the multiplication to index. */
gcc_assert (parts.index);
parts.index = force_gimple_operand_gsi (gsi,
fold_build2 (MULT_EXPR, sizetype,
parts.index, parts.step),
true, NULL_TREE, true, GSI_SAME_STMT);
parts.step = NULL_TREE;
mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true);
if (mem_ref)
return mem_ref;
}
if (parts.symbol)
{
tmp = parts.symbol;
gcc_assert (is_gimple_val (tmp));
/* Add the symbol to base, eventually forcing it to register. */
if (parts.base)
{
gcc_assert (useless_type_conversion_p
(sizetype, TREE_TYPE (parts.base)));
if (parts.index)
{
parts.base = force_gimple_operand_gsi_1 (gsi,
fold_build_pointer_plus (tmp, parts.base),
is_gimple_mem_ref_addr, NULL_TREE, true, GSI_SAME_STMT);
}
else
{
parts.index = parts.base;
parts.base = tmp;
}
}
else
parts.base = tmp;
parts.symbol = NULL_TREE;
mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true);
if (mem_ref)
return mem_ref;
}
if (parts.index)
{
/* Add index to base. */
if (parts.base)
{
parts.base = force_gimple_operand_gsi_1 (gsi,
fold_build_pointer_plus (parts.base, parts.index),
is_gimple_mem_ref_addr, NULL_TREE, true, GSI_SAME_STMT);
}
else
parts.base = parts.index;
parts.index = NULL_TREE;
mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true);
if (mem_ref)
return mem_ref;
}
if (parts.offset && !integer_zerop (parts.offset))
{
/* Try adding offset to base. */
if (parts.base)
{
parts.base = force_gimple_operand_gsi_1 (gsi,
fold_build_pointer_plus (parts.base, parts.offset),
is_gimple_mem_ref_addr, NULL_TREE, true, GSI_SAME_STMT);
}
else
parts.base = parts.offset;
parts.offset = NULL_TREE;
mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true);
if (mem_ref)
return mem_ref;
}
/* Verify that the address is in the simplest possible shape
(only a register). If we cannot create such a memory reference,
something is really wrong. */
gcc_assert (parts.symbol == NULL_TREE);
gcc_assert (parts.index == NULL_TREE);
gcc_assert (!parts.step || integer_onep (parts.step));
gcc_assert (!parts.offset || integer_zerop (parts.offset));
gcc_unreachable ();
}
