/**
* Adjust the size of a node representing a stack alloc to a certain
* stack_alignment.
*
* @param size the node containing the non-aligned size
* @param block the block where new nodes are allocated on
* @return a node representing the aligned size
*/
static ir_node *adjust_alloc_size(dbg_info *dbgi, ir_node *size, ir_node *block)
{
/* Example: po2_alignment 4 (align to 16 bytes):
* size = (size+15) & 0xfff...f8 */
ir_mode *mode = get_irn_mode(size);
ir_graph *irg = get_irn_irg(block);
ir_tarval *allone = get_mode_all_one(mode);
ir_tarval *shr = tarval_shr_unsigned(allone, po2_stack_alignment);
ir_tarval *mask = tarval_shl_unsigned(shr, po2_stack_alignment);
ir_tarval *invmask = tarval_not(mask);
ir_node *addv = new_r_Const(irg, invmask);
ir_node *add = new_rd_Add(dbgi, block, size, addv);
ir_node *maskc = new_r_Const(irg, mask);
ir_node *and = new_rd_And(dbgi, block, add, maskc);
return and;
}
static void check_mode(ir_mode *mode)
{
ir_tarval *zero = get_mode_null(mode);
ir_tarval *minus_zero = tarval_neg(zero);
ir_tarval *min = get_mode_min(mode);
ir_tarval *max = get_mode_max(mode);
ir_tarval *inf = get_mode_infinite(mode);
ir_tarval *minus_inf = tarval_neg(inf);
ir_tarval *one = get_mode_one(mode);
ir_tarval *minus_one = tarval_neg(one);
/* some random arithmetics */
ir_tarval *int_zero = get_mode_null(mode_Is);
ir_tarval *int_one = get_mode_one(mode_Is);
ir_tarval *int_minus_one = get_mode_all_one(mode_Is);
ir_tarval *int_min = get_mode_min(mode_Is);
ir_tarval *int_max = get_mode_max(mode_Is);
assert(tarval_convert_to(zero, mode_Is) == int_zero);
assert(tarval_convert_to(minus_zero, mode_Is) == int_zero);
assert(tarval_convert_to(one, mode_Is) == int_one);
assert(tarval_convert_to(minus_one, mode_Is) == int_minus_one);
assert(tarval_convert_to(min, mode_Is) == int_min);
assert(tarval_convert_to(max, mode_Is) == int_max);
assert(tarval_convert_to(inf, mode_Is) == int_max);
assert(tarval_convert_to(minus_inf, mode_Is) == int_min);
static const char *const ints[] = {
"0", "1", "-1", "12345", "2", "4", "8", "16", "32", "64", "128", "256",
"512", "1024", "2048", "127", "2047"
};
for (unsigned i = 0; i < ARRAY_SIZE(ints); ++i) {
const char *str = ints[i];
ir_tarval *flt = new_tarval_from_str(str, strlen(str), mode);
ir_tarval *intt = new_tarval_from_str(str, strlen(str), mode_Is);
assert(tarval_convert_to(flt, mode_Is) == intt);
assert(tarval_convert_to(intt, mode) == flt);
}
}
bool enum_bitfield_big_enough(enum_t *enume, type_t *base_type,
unsigned bitfield_size)
{
ir_mode *mode = get_ir_mode_storage(base_type);
ir_tarval *max = get_mode_max(mode);
ir_tarval *min = get_mode_min(mode);
bool is_signed = is_type_signed(base_type);
unsigned mode_size = get_mode_size_bits(mode);
unsigned shift_amount = mode_size - bitfield_size + is_signed;
ir_tarval *adjusted_max;
ir_tarval *adjusted_min;
/* corner case: signed mode with just sign bit results in shift_amount
* being as big as mode_size triggering "modulo shift" which is not what
* we want here. */
if (shift_amount >= mode_size) {
assert(bitfield_size == 1 && mode_is_signed(mode));
adjusted_max = get_mode_null(mode);
adjusted_min = get_mode_all_one(mode);
} else {
adjusted_max = tarval_shr_unsigned(max, shift_amount);
adjusted_min = tarval_shrs_unsigned(min, shift_amount);
}
for (entity_t *entry = enume->first_value;
entry != NULL && entry->kind == ENTITY_ENUM_VALUE;
entry = entry->base.next) {
ir_tarval *tv = get_enum_value(&entry->enum_value);
if (tv == NULL)
continue;
ir_tarval *tvc = tarval_convert_to(tv, mode);
if (tarval_cmp(tvc, adjusted_min) == ir_relation_less
|| tarval_cmp(tvc, adjusted_max) == ir_relation_greater) {
return false;
}
}
return true;
}
void x86_create_address_mode(x86_address_t *addr, ir_node *node,
x86_create_am_flags_t flags)
{
addr->imm.kind = X86_IMM_VALUE;
if (eat_immediate(addr, node, true)) {
addr->variant = addr->ip_base ? X86_ADDR_RIP : X86_ADDR_JUST_IMM;
return;
}
assert(!addr->ip_base);
if (!(flags & x86_create_am_force) && x86_is_non_address_mode_node(node)
&& (!(flags & x86_create_am_double_use) || get_irn_n_edges(node) > 2)) {
addr->variant = X86_ADDR_BASE;
addr->base = node;
return;
}
ir_node *eat_imms = eat_immediates(addr, node, flags, false);
if (eat_imms != node) {
if (flags & x86_create_am_force)
eat_imms = be_skip_downconv(eat_imms, true);
node = eat_imms;
if (x86_is_non_address_mode_node(node)) {
addr->variant = X86_ADDR_BASE;
addr->base = node;
return;
}
}
/* starting point Add, Sub or Shl, FrameAddr */
if (is_Shl(node)) {
/* We don't want to eat add x, x as shl here, so only test for real Shl
* instructions, because we want the former as Lea x, x, not Shl x, 1 */
if (eat_shl(addr, node)) {
addr->variant = X86_ADDR_INDEX;
return;
}
} else if (eat_immediate(addr, node, true)) {
/* we can hit this case in x86_create_am_force mode */
addr->variant = addr->ip_base ? X86_ADDR_RIP : X86_ADDR_JUST_IMM;
return;
} else if (is_Add(node)) {
ir_node *left = get_Add_left(node);
ir_node *right = get_Add_right(node);
if (flags & x86_create_am_force) {
left = be_skip_downconv(left, true);
right = be_skip_downconv(right, true);
}
left = eat_immediates(addr, left, flags, false);
right = eat_immediates(addr, right, flags, false);
if (eat_shl(addr, left)) {
left = NULL;
} else if (eat_shl(addr, right)) {
right = NULL;
}
/* (x & 0xFFFFFFFC) + (x >> 2) -> lea(x >> 2, x >> 2, 4) */
if (left != NULL && right != NULL) {
ir_node *and;
ir_node *shr;
if (is_And(left) && (is_Shr(right) || is_Shrs(right))) {
and = left;
shr = right;
goto tryit;
}
if (is_And(right) && (is_Shr(left) || is_Shrs(left))) {
and = right;
shr = left;
tryit:
if (get_And_left(and) == get_binop_left(shr)) {
ir_node *and_right = get_And_right(and);
ir_node *shr_right = get_binop_right(shr);
if (is_Const(and_right) && is_Const(shr_right)) {
ir_tarval *and_mask = get_Const_tarval(and_right);
ir_tarval *shift_amount = get_Const_tarval(shr_right);
ir_mode *mode = get_irn_mode(and);
ir_tarval *all_one = get_mode_all_one(mode);
ir_tarval *shift_mask = tarval_shl(tarval_shr(all_one, shift_amount), shift_amount);
long val = get_tarval_long(shift_amount);
if (and_mask == shift_mask && val >= 0 && val <= 3) {
addr->variant = X86_ADDR_BASE_INDEX;
addr->base = shr;
addr->index = shr;
addr->scale = val;
return;
}
}
}
}
}
if (left != NULL) {
ir_node *base = addr->base;
if (base == NULL) {
addr->variant = addr->index != NULL ? X86_ADDR_BASE_INDEX
: X86_ADDR_BASE;
addr->base = left;
} else {
addr->variant = X86_ADDR_BASE_INDEX;
assert(addr->index == NULL && addr->scale == 0);
assert(right == NULL);
/* esp must be used as base */
if (is_Proj(left) && is_Start(get_Proj_pred(left))) {
addr->index = base;
addr->base = left;
} else {
addr->index = left;
}
}
}
if (right != NULL) {
ir_node *base = addr->base;
if (base == NULL) {
addr->variant = addr->index != NULL ? X86_ADDR_BASE_INDEX
: X86_ADDR_BASE;
addr->base = right;
} else {
addr->variant = X86_ADDR_BASE_INDEX;
assert(addr->index == NULL && addr->scale == 0);
/* esp must be used as base */
if (is_Proj(right) && is_Start(get_Proj_pred(right))) {
addr->index = base;
addr->base = right;
} else {
addr->index = right;
}
}
}
return;
}
addr->variant = X86_ADDR_BASE;
addr->base = node;
}