void test_should_print_binop_expression(void)
{
assert_printed_binop_expr(str_aprintf(
"BINOP:\n"
" vm_type: [int]\n"
" binary_operator: [add]\n"
" binary_left: [value int 0x0]\n"
" binary_right: [value int 0x1]\n"),
J_INT, OP_ADD, value_expr(J_INT, 0), value_expr(J_INT, 1));
assert_printed_binop_expr(str_aprintf(
"BINOP:\n"
" vm_type: [long]\n"
" binary_operator: [add]\n"
" binary_left: [value long 0x1]\n"
" binary_right:\n"
" BINOP:\n"
" vm_type: [long]\n"
" binary_operator: [sub]\n"
" binary_left: [value long 0x2]\n"
" binary_right: [value long 0x3]\n"),
J_LONG, OP_ADD,
value_expr(J_LONG, 1), binop_expr(J_LONG, OP_SUB,
value_expr(J_LONG, 2), value_expr(J_LONG, 3)));
}
static struct statement *__convert_if(struct parse_context *ctx,
enum vm_type vm_type,
enum binary_operator binop,
struct expression *binary_left,
struct expression *binary_right)
{
struct basic_block *true_bb;
struct expression *if_conditional;
struct statement *if_stmt;
int32_t if_target;
if_target = bytecode_read_branch_target(ctx->opc, ctx->buffer);
true_bb = find_bb(ctx->cu, ctx->offset + if_target);
if_conditional = binop_expr(vm_type, binop, binary_left, binary_right);
if (!if_conditional)
goto failed;
if_stmt = alloc_statement(STMT_IF);
if (!if_stmt)
goto failed_put_expr;
if_stmt->if_true = true_bb;
if_stmt->if_conditional = &if_conditional->node;
return if_stmt;
failed_put_expr:
expr_put(if_conditional);
failed:
return NULL;
}
void assert_printed_binop_expr(struct string *expected, enum vm_type type,
enum binary_operator op,
struct expression *binary_left,
struct expression *binary_right)
{
struct expression *expr;
expr = binop_expr(type, op, binary_left, binary_right);
assert_print_expr(expected, expr);
}
int convert_iinc(struct parse_context *ctx)
{
struct statement *store_stmt;
struct expression *local_expression, *binop_expression,
*const_expression;
unsigned int index;
int const_value;
store_stmt = alloc_statement(STMT_STORE);
if (!store_stmt)
goto failed;
if (ctx->is_wide) {
index = bytecode_read_u16(ctx->buffer);
const_value = bytecode_read_s16(ctx->buffer);
} else {
index = bytecode_read_u8(ctx->buffer);
const_value = bytecode_read_s8(ctx->buffer);
}
local_expression = local_expr(J_INT, index);
if (!local_expression)
goto failed;
store_stmt->store_dest = &local_expression->node;
const_expression = value_expr(J_INT, const_value);
if (!const_expression)
goto failed;
expr_get(local_expression);
binop_expression = binop_expr(J_INT, OP_ADD, local_expression,
const_expression);
if (!binop_expression) {
expr_put(local_expression);
expr_put(const_expression);
goto failed;
}
store_stmt->store_src = &binop_expression->node;
convert_statement(ctx, store_stmt);
return 0;
failed:
free_statement(store_stmt);
return warn("out of memory"), -ENOMEM;
}
static int convert_binop(struct parse_context *ctx, enum vm_type vm_type,
enum binary_operator binary_operator)
{
struct expression *left, *right, *expr;
right = stack_pop(ctx->bb->mimic_stack);
left = stack_pop(ctx->bb->mimic_stack);
expr = binop_expr(vm_type, binary_operator, left, right);
if (!expr)
return warn("out of memory"), -ENOMEM;
convert_expression(ctx, expr);
return 0;
}
