static MonoInst*
emit_widen (MonoCompile *cfg, const MagicTypeInfo *info, int sreg)
{
MonoInst *ins;
if (cfg->r4fp && info->conv_4_to_8 == OP_FCONV_TO_R8)
MONO_INST_NEW (cfg, ins, OP_RCONV_TO_R8);
else
MONO_INST_NEW (cfg, ins, info->conv_4_to_8);
ins->sreg1 = sreg;
ins->type = info->big_stack_type;
ins->dreg = alloc_dreg (cfg, info->big_stack_type);
MONO_ADD_INS (cfg->cbb, ins);
return mono_decompose_opcode (cfg, ins);
}
static void
move_basic_block_to_end (MonoCompile *cfg, MonoBasicBlock *bb)
{
MonoBasicBlock *bbn, *next;
next = bb->next_bb;
/* Find the previous */
for (bbn = cfg->bb_entry; bbn->next_bb && bbn->next_bb != bb; bbn = bbn->next_bb)
;
if (bbn->next_bb) {
bbn->next_bb = bb->next_bb;
}
/* Find the last */
for (bbn = cfg->bb_entry; bbn->next_bb; bbn = bbn->next_bb)
;
bbn->next_bb = bb;
bb->next_bb = NULL;
/* Add a branch */
if (next && (!bb->last_ins || ((bb->last_ins->opcode != OP_NOT_REACHED) && (bb->last_ins->opcode != OP_BR) && (bb->last_ins->opcode != OP_BR_REG) && (!MONO_IS_COND_BRANCH_OP (bb->last_ins))))) {
MonoInst *ins;
MONO_INST_NEW (cfg, ins, OP_BR);
MONO_ADD_INS (bb, ins);
mono_link_bblock (cfg, bb, next);
ins->inst_target_bb = next;
}
}
static MonoInst*
emit_narrow (MonoCompile *cfg, const MagicTypeInfo *info, int sreg)
{
MonoInst *ins;
MONO_INST_NEW (cfg, ins, info->conv_8_to_4);
ins->sreg1 = sreg;
if (info->conv_8_to_4 == OP_FCONV_TO_R4)
ins->type = cfg->r4_stack_type;
else
ins->type = info->small_stack_type;
ins->dreg = alloc_dreg (cfg, ins->type);
MONO_ADD_INS (cfg->cbb, ins);
return mono_decompose_opcode (cfg, ins);
}
static MonoInst*
emit_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args, const MagicTypeInfo *info)
{
int i = 0;
const char *name = cmethod->name;
MonoInst *ins;
int type_index, stack_type;
if (info->op_index == 2 && cfg->r4fp && SIZEOF_VOID_P == 4) {
type_index = 3;
stack_type = STACK_R4;
} else {
type_index = info->op_index;
stack_type = info->stack_type;
}
if (!strcmp ("op_Implicit", name) || !strcmp ("op_Explicit", name)) {
int source_size = type_size (cfg, fsig->params [0]);
int dest_size = type_size (cfg, fsig->ret);
switch (info->big_stack_type) {
case STACK_I8:
if (!is_int_type (fsig->params [0]) || !is_int_type (fsig->ret))
return NULL;
break;
case STACK_R8:
if (!is_float_type (fsig->params [0]) || !is_float_type (fsig->ret))
return NULL;
break;
default:
g_assert_not_reached ();
}
//4 -> 4 or 8 -> 8
if (source_size == dest_size)
return args [0];
//4 -> 8
if (source_size < dest_size)
return emit_widen (cfg, info, args [0]->dreg);
//8 -> 4
return emit_narrow (cfg, info, args [0]->dreg);
}
if (!strcmp (".ctor", name)) {
gboolean is_ldaddr = args [0]->opcode == OP_LDADDR;
int arg0 = args [1]->dreg;
int arg_size = type_size (cfg, fsig->params [0]);
if (arg_size > SIZEOF_VOID_P) //8 -> 4
arg0 = emit_narrow (cfg, info, arg0)->dreg;
else if (arg_size < SIZEOF_VOID_P) //4 -> 8
arg0 = emit_widen (cfg, info, arg0)->dreg;
if (is_ldaddr) { /*Eliminate LDADDR if it's initing a local var*/
int dreg = ((MonoInst*)args [0]->inst_p0)->dreg;
NULLIFY_INS (args [0]);
EMIT_NEW_UNALU (cfg, ins, info->move, dreg, arg0);
cfg->has_indirection = TRUE;
} else {
EMIT_NEW_STORE_MEMBASE (cfg, ins, info->store_op, args [0]->dreg, 0, arg0);
}
return ins;
}
if (!strcmp ("op_Increment", name) || !strcmp ("op_Decrement", name)) {
gboolean inc = !strcmp ("op_Increment", name);
/* FIXME float inc is too complex to bother with*/
//this is broken with ints too
// if (!info->inc_op)
return NULL;
/* We have IR for inc/dec */
MONO_INST_NEW (cfg, ins, inc ? info->inc_op : info->dec_op);
ins->dreg = alloc_dreg (cfg, info->stack_type);
ins->sreg1 = args [0]->dreg;
ins->inst_imm = 1;
ins->type = info->stack_type;
MONO_ADD_INS (cfg->cbb, ins);
return ins;
}
for (i = 0; i < sizeof (int_binop) / sizeof (IntIntrisic); ++i) {
if (!strcmp (int_binop [i].op_name, name)) {
if (!int_binop [i].op_table [info->op_index])
return NULL;
g_assert (int_binop [i].op_table [type_index]);
MONO_INST_NEW (cfg, ins, int_binop [i].op_table [type_index]);
ins->dreg = alloc_dreg (cfg, stack_type);
ins->sreg1 = args [0]->dreg;
ins->sreg2 = args [1]->dreg;
ins->type = stack_type;
MONO_ADD_INS (cfg->cbb, ins);
return mono_decompose_opcode (cfg, ins);
}
}
for (i = 0; i < sizeof (int_unnop) / sizeof (IntIntrisic); ++i) {
if (!strcmp (int_unnop [i].op_name, name)) {
g_assert (int_unnop [i].op_table [type_index]);
MONO_INST_NEW (cfg, ins, int_unnop [i].op_table [type_index]);
ins->dreg = alloc_dreg (cfg, stack_type);
ins->sreg1 = args [0]->dreg;
ins->type = stack_type;
MONO_ADD_INS (cfg->cbb, ins);
return ins;
}
}
for (i = 0; i < sizeof (int_cmpop) / sizeof (IntIntrisic); ++i) {
if (!strcmp (int_cmpop [i].op_name, name)) {
short op_cmp = int_cmpop [i].op_table [type_index];
g_assert (op_cmp);
if (info->compare_op) {
MONO_INST_NEW (cfg, ins, info->compare_op);
ins->dreg = -1;
ins->sreg1 = args [0]->dreg;
ins->sreg2 = args [1]->dreg;
MONO_ADD_INS (cfg->cbb, ins);
MONO_INST_NEW (cfg, ins, op_cmp);
ins->dreg = alloc_preg (cfg);
ins->type = STACK_I4;
MONO_ADD_INS (cfg->cbb, ins);
} else {
MONO_INST_NEW (cfg, ins, op_cmp);
guint32 fcmp_dreg = ins->dreg = alloc_ireg (cfg);
ins->sreg1 = args [0]->dreg;
ins->sreg2 = args [1]->dreg;
MONO_ADD_INS (cfg->cbb, ins);
if (op_cmp == OP_FCLT_UN || op_cmp == OP_FCGT_UN || op_cmp == OP_RCLT_UN || op_cmp == OP_RCGT_UN) {
/* we have to negate the result of this comparison:
* - op_GreaterThanOrEqual maps to NOT x OP_FCLT_UN / OP_RCLT_UN
* - op_LessThanOrEqual maps to NOT x OP_FCGT_UN / OP_RCGT_UN
*
* this matches generated bytecode by C# when doing the
* same operations on float/double. the `_UN` suffix says
* that if an operand is NaN, the result is true. If
* OP_FCGE/OP_FCLE is used, it is mapped to instructions
* on some architectures that don't detect NaN. For
* example, on arm64 the condition `eq` doesn't respect
* NaN results of a `fcmp` instruction.
*/
MONO_INST_NEW (cfg, ins, OP_ICOMPARE_IMM);
ins->dreg = -1;
ins->sreg1 = fcmp_dreg;
ins->inst_imm = 0;
MONO_ADD_INS (cfg->cbb, ins);
MONO_INST_NEW (cfg, ins, OP_CEQ);
ins->dreg = alloc_preg (cfg);
ins->type = STACK_I4;
MONO_ADD_INS (cfg->cbb, ins);
}
}
return ins;
}
}
return NULL;
}
static MonoInst*
emit_intrinsics (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args, const MagicTypeInfo *info)
{
int i = 0;
const char *name = cmethod->name;
MonoInst *ins;
int type_index, stack_type;
if (info->op_index == 2 && cfg->r4fp && SIZEOF_VOID_P == 4) {
type_index = 3;
stack_type = STACK_R4;
} else {
type_index = info->op_index;
stack_type = info->stack_type;
}
if (!strcmp ("op_Implicit", name) || !strcmp ("op_Explicit", name)) {
int source_size = type_size (cfg, fsig->params [0]);
int dest_size = type_size (cfg, fsig->ret);
switch (info->big_stack_type) {
case STACK_I8:
if (!is_int_type (fsig->params [0]) || !is_int_type (fsig->ret))
return NULL;
break;
case STACK_R8:
if (!is_float_type (fsig->params [0]) || !is_float_type (fsig->ret))
return NULL;
break;
default:
g_assert_not_reached ();
}
//4 -> 4 or 8 -> 8
if (source_size == dest_size)
return args [0];
//4 -> 8
if (source_size < dest_size)
return emit_widen (cfg, info, args [0]->dreg);
//8 -> 4
return emit_narrow (cfg, info, args [0]->dreg);
}
if (!strcmp (".ctor", name)) {
gboolean is_ldaddr = args [0]->opcode == OP_LDADDR;
int arg0 = args [1]->dreg;
int arg_size = type_size (cfg, fsig->params [0]);
if (arg_size > SIZEOF_VOID_P) //8 -> 4
arg0 = emit_narrow (cfg, info, arg0)->dreg;
else if (arg_size < SIZEOF_VOID_P) //4 -> 8
arg0 = emit_widen (cfg, info, arg0)->dreg;
if (is_ldaddr) { /*Eliminate LDADDR if it's initing a local var*/
int dreg = ((MonoInst*)args [0]->inst_p0)->dreg;
NULLIFY_INS (args [0]);
EMIT_NEW_UNALU (cfg, ins, info->move, dreg, arg0);
cfg->has_indirection = TRUE;
} else {
EMIT_NEW_STORE_MEMBASE (cfg, ins, info->store_op, args [0]->dreg, 0, arg0);
}
return ins;
}
if (!strcmp ("op_Increment", name) || !strcmp ("op_Decrement", name)) {
gboolean inc = !strcmp ("op_Increment", name);
/* FIXME float inc is too complex to bother with*/
//this is broken with ints too
// if (!info->inc_op)
return NULL;
/* We have IR for inc/dec */
MONO_INST_NEW (cfg, ins, inc ? info->inc_op : info->dec_op);
ins->dreg = alloc_dreg (cfg, info->stack_type);
ins->sreg1 = args [0]->dreg;
ins->inst_imm = 1;
ins->type = info->stack_type;
MONO_ADD_INS (cfg->cbb, ins);
return ins;
}
for (i = 0; i < sizeof (int_binop) / sizeof (IntIntrisic); ++i) {
if (!strcmp (int_binop [i].op_name, name)) {
if (!int_binop [i].op_table [info->op_index])
return NULL;
g_assert (int_binop [i].op_table [type_index]);
MONO_INST_NEW (cfg, ins, int_binop [i].op_table [type_index]);
ins->dreg = alloc_dreg (cfg, stack_type);
ins->sreg1 = args [0]->dreg;
ins->sreg2 = args [1]->dreg;
ins->type = stack_type;
MONO_ADD_INS (cfg->cbb, ins);
return mono_decompose_opcode (cfg, ins);
}
}
for (i = 0; i < sizeof (int_unnop) / sizeof (IntIntrisic); ++i) {
if (!strcmp (int_unnop [i].op_name, name)) {
g_assert (int_unnop [i].op_table [type_index]);
MONO_INST_NEW (cfg, ins, int_unnop [i].op_table [type_index]);
ins->dreg = alloc_dreg (cfg, stack_type);
ins->sreg1 = args [0]->dreg;
ins->type = stack_type;
MONO_ADD_INS (cfg->cbb, ins);
return ins;
}
}
for (i = 0; i < sizeof (int_cmpop) / sizeof (IntIntrisic); ++i) {
if (!strcmp (int_cmpop [i].op_name, name)) {
g_assert (int_cmpop [i].op_table [type_index]);
if (info->compare_op) {
MONO_INST_NEW (cfg, ins, info->compare_op);
ins->dreg = -1;
ins->sreg1 = args [0]->dreg;
ins->sreg2 = args [1]->dreg;
MONO_ADD_INS (cfg->cbb, ins);
MONO_INST_NEW (cfg, ins, int_cmpop [i].op_table [type_index]);
ins->dreg = alloc_preg (cfg);
ins->type = STACK_I4;
MONO_ADD_INS (cfg->cbb, ins);
} else {
MONO_INST_NEW (cfg, ins, int_cmpop [i].op_table [type_index]);
ins->dreg = alloc_ireg (cfg);
ins->sreg1 = args [0]->dreg;
ins->sreg2 = args [1]->dreg;
MONO_ADD_INS (cfg->cbb, ins);
}
return ins;
}
}
return NULL;
}
void
mono_merge_basic_blocks (MonoCompile *cfg, MonoBasicBlock *bb, MonoBasicBlock *bbn)
{
MonoInst *inst;
MonoBasicBlock *prev_bb;
int i;
bb->has_array_access |= bbn->has_array_access;
bb->extended |= bbn->extended;
mono_unlink_bblock (cfg, bb, bbn);
for (i = 0; i < bbn->out_count; ++i)
mono_link_bblock (cfg, bb, bbn->out_bb [i]);
while (bbn->out_count)
mono_unlink_bblock (cfg, bbn, bbn->out_bb [0]);
/* Handle the branch at the end of the bb */
if (bb->has_call_handler) {
for (inst = bb->code; inst != NULL; inst = inst->next) {
if (inst->opcode == OP_CALL_HANDLER) {
g_assert (inst->inst_target_bb == bbn);
NULLIFY_INS (inst);
}
}
}
if (bb->has_jump_table) {
for (inst = bb->code; inst != NULL; inst = inst->next) {
if (MONO_IS_JUMP_TABLE (inst)) {
int i;
MonoJumpInfoBBTable *table = MONO_JUMP_TABLE_FROM_INS (inst);
for (i = 0; i < table->table_size; i++ ) {
/* Might be already NULL from a previous merge */
if (table->table [i])
g_assert (table->table [i] == bbn);
table->table [i] = NULL;
}
/* Can't nullify this as later instructions depend on it */
}
}
}
if (bb->last_ins && MONO_IS_COND_BRANCH_OP (bb->last_ins)) {
g_assert (bb->last_ins->inst_false_bb == bbn);
bb->last_ins->inst_false_bb = NULL;
bb->extended = TRUE;
} else if (bb->last_ins && MONO_IS_BRANCH_OP (bb->last_ins)) {
NULLIFY_INS (bb->last_ins);
}
bb->has_call_handler |= bbn->has_call_handler;
bb->has_jump_table |= bbn->has_jump_table;
if (bb->last_ins) {
if (bbn->code) {
bb->last_ins->next = bbn->code;
bbn->code->prev = bb->last_ins;
bb->last_ins = bbn->last_ins;
}
} else {
bb->code = bbn->code;
bb->last_ins = bbn->last_ins;
}
for (prev_bb = cfg->bb_entry; prev_bb && prev_bb->next_bb != bbn; prev_bb = prev_bb->next_bb)
;
if (prev_bb) {
prev_bb->next_bb = bbn->next_bb;
} else {
/* bbn might not be in the bb list yet */
if (bb->next_bb == bbn)
bb->next_bb = bbn->next_bb;
}
mono_nullify_basic_block (bbn);
/*
* If bbn fell through to its next bblock, have to add a branch, since bb
* will not fall though to the same bblock (#513931).
*/
if (bb->last_ins && bb->out_count == 1 && bb->out_bb [0] != bb->next_bb && !MONO_IS_BRANCH_OP (bb->last_ins)) {
MONO_INST_NEW (cfg, inst, OP_BR);
inst->inst_target_bb = bb->out_bb [0];
MONO_ADD_INS (bb, inst);
}
}
/**
* Check if a bb is useless (is just made of NOPs and ends with an
* unconditional branch, or nothing).
* If it is so, unlink it from the CFG and nullify it, and return TRUE.
* Otherwise, return FALSE;
*/
static gboolean
remove_block_if_useless (MonoCompile *cfg, MonoBasicBlock *bb, MonoBasicBlock *previous_bb) {
MonoBasicBlock *target_bb = NULL;
MonoInst *inst;
/* Do not touch handlers */
if (bb->region != -1) {
bb->not_useless = TRUE;
return FALSE;
}
MONO_BB_FOR_EACH_INS (bb, inst) {
switch (inst->opcode) {
case OP_NOP:
break;
case OP_BR:
target_bb = inst->inst_target_bb;
break;
default:
bb->not_useless = TRUE;
return FALSE;
}
}
if (target_bb == NULL) {
if ((bb->out_count == 1) && (bb->out_bb [0] == bb->next_bb)) {
target_bb = bb->next_bb;
} else {
/* Do not touch empty BBs that do not "fall through" to their next BB (like the exit BB) */
return FALSE;
}
}
/* Do not touch BBs following a switch (they are the "default" branch) */
if ((previous_bb->last_ins != NULL) && (previous_bb->last_ins->opcode == OP_SWITCH)) {
return FALSE;
}
/* Do not touch BBs following the entry BB and jumping to something that is not */
/* thiry "next" bb (the entry BB cannot contain the branch) */
if ((previous_bb == cfg->bb_entry) && (bb->next_bb != target_bb)) {
return FALSE;
}
/*
* Do not touch BBs following a try block as the code in
* mini_method_compile needs them to compute the length of the try block.
*/
if (MONO_BBLOCK_IS_IN_REGION (previous_bb, MONO_REGION_TRY))
return FALSE;
/* Check that there is a target BB, and that bb is not an empty loop (Bug 75061) */
if ((target_bb != NULL) && (target_bb != bb)) {
int i;
if (cfg->verbose_level > 1) {
printf ("remove_block_if_useless, removed BB%d\n", bb->block_num);
}
/* unlink_bblock () modifies the bb->in_bb array so can't use a for loop here */
while (bb->in_count) {
MonoBasicBlock *in_bb = bb->in_bb [0];
mono_unlink_bblock (cfg, in_bb, bb);
mono_link_bblock (cfg, in_bb, target_bb);
replace_out_block_in_code (in_bb, bb, target_bb);
}
mono_unlink_bblock (cfg, bb, target_bb);
if (previous_bb != cfg->bb_entry && mono_bb_is_fall_through (cfg, previous_bb)) {
for (i = 0; i < previous_bb->out_count; i++) {
if (previous_bb->out_bb [i] == target_bb) {
MonoInst *jump;
MONO_INST_NEW (cfg, jump, OP_BR);
MONO_ADD_INS (previous_bb, jump);
jump->cil_code = previous_bb->cil_code;
jump->inst_target_bb = target_bb;
break;
}
}
}
previous_bb->next_bb = bb->next_bb;
mono_nullify_basic_block (bb);
return TRUE;
} else {
return FALSE;
}
}
/*
* Used by the arch code to replace the exception handling
* with a direct branch. This is safe to do if the
* exception object isn't used, no rethrow statement and
* no filter statement (verify).
*
*/
MonoInst *
mono_branch_optimize_exception_target (MonoCompile *cfg, MonoBasicBlock *bb, const char * exname)
{
MonoMethodHeader *header = cfg->header;
MonoExceptionClause *clause;
MonoClass *exclass;
int i;
if (!(cfg->opt & MONO_OPT_EXCEPTION))
return NULL;
if (bb->region == -1 || !MONO_BBLOCK_IS_IN_REGION (bb, MONO_REGION_TRY))
return NULL;
exclass = mono_class_from_name (mono_get_corlib (), "System", exname);
/* search for the handler */
for (i = 0; i < header->num_clauses; ++i) {
clause = &header->clauses [i];
if (MONO_OFFSET_IN_CLAUSE (clause, bb->real_offset)) {
if (clause->flags == MONO_EXCEPTION_CLAUSE_NONE && clause->data.catch_class && mono_class_is_assignable_from (clause->data.catch_class, exclass)) {
MonoBasicBlock *tbb;
/* get the basic block for the handler and
* check if the exception object is used.
* Flag is set during method_to_ir due to
* pop-op is optmized away in codegen (burg).
*/
tbb = cfg->cil_offset_to_bb [clause->handler_offset];
if (tbb && tbb->flags & BB_EXCEPTION_DEAD_OBJ && !(tbb->flags & BB_EXCEPTION_UNSAFE)) {
MonoBasicBlock *targetbb = tbb;
gboolean unsafe = FALSE;
/* Check if this catch clause is ok to optimize by
* looking for the BB_EXCEPTION_UNSAFE in every BB that
* belongs to the same region.
*
* UNSAFE flag is set during method_to_ir (OP_RETHROW)
*/
while (!unsafe && tbb->next_bb && tbb->region == tbb->next_bb->region) {
if (tbb->next_bb->flags & BB_EXCEPTION_UNSAFE) {
unsafe = TRUE;
break;
}
tbb = tbb->next_bb;
}
if (!unsafe) {
MonoInst *jump;
/* Create dummy inst to allow easier integration in
* arch dependent code (opcode ignored)
*/
MONO_INST_NEW (cfg, jump, OP_BR);
/* Allocate memory for our branch target */
jump->inst_i1 = mono_mempool_alloc0 (cfg->mempool, sizeof (MonoInst));
jump->inst_true_bb = targetbb;
if (cfg->verbose_level > 2)
g_print ("found exception to optimize - returning branch to BB%d (%s) (instead of throw) for method %s:%s\n", targetbb->block_num, clause->data.catch_class->name, cfg->method->klass->name, cfg->method->name);
return jump;
}
return NULL;
} else {
/* Branching to an outer clause could skip inner clauses */
return NULL;
}
} else {
/* Branching to an outer clause could skip inner clauses */
return NULL;
}
}
}
return NULL;
}
void
mono_if_conversion (MonoCompile *cfg)
{
#ifdef MONO_ARCH_HAVE_CMOV_OPS
MonoBasicBlock *bb;
gboolean changed = FALSE;
if (!(cfg->opt & MONO_OPT_CMOV))
return;
// FIXME: Make this work with extended bblocks
/*
* This pass requires somewhat optimized IR code so it should be run after
* local cprop/deadce. Also, it should be run before dominator computation, since
* it changes control flow.
*/
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
MonoBasicBlock *bb1, *bb2;
restart:
/* Look for the IR code generated from cond ? a : b
* which is:
* BB:
* b<cond> [BB1BB2]
* BB1:
* <var> <- <a>
* br BB3
* BB2:
* <var> <- <b>
* br BB3
*/
if (!(bb->out_count == 2 && !bb->extended))
continue;
bb1 = bb->out_bb [0];
bb2 = bb->out_bb [1];
if (bb1->in_count == 1 && bb2->in_count == 1 && bb1->out_count == 1 && bb2->out_count == 1 && bb1->out_bb [0] == bb2->out_bb [0]) {
MonoInst *compare, *branch, *ins1, *ins2, *cmov, *move, *tmp;
MonoBasicBlock *true_bb, *false_bb;
gboolean simple, ret;
int dreg, tmp_reg;
CompType comp_type;
if (bb->last_ins && (bb->last_ins->opcode == OP_BR_REG || bb->last_ins->opcode == OP_BR))
continue;
/* Find the compare instruction */
if (!bb->last_ins || !bb->last_ins->prev)
continue;
branch = bb->last_ins;
compare = branch->prev;
if (!MONO_IS_COND_BRANCH_OP (branch))
/* This can happen if a cond branch is optimized away */
continue;
true_bb = branch->inst_true_bb;
false_bb = branch->inst_false_bb;
/*
* Check that bb1 and bb2 are 'simple' and both assign to the same
* variable.
*/
/* FIXME: Get rid of the nops earlier */
ins1 = true_bb->code;
while (ins1 && ins1->opcode == OP_NOP)
ins1 = ins1->next;
ins2 = false_bb->code;
while (ins2 && ins2->opcode == OP_NOP)
ins2 = ins2->next;
if (!(ins1 && ins2 && ins1->dreg == ins2->dreg && ins1->dreg != -1))
continue;
simple = TRUE;
for (tmp = ins1->next; tmp; tmp = tmp->next)
if (!((tmp->opcode == OP_NOP) || (tmp->opcode == OP_BR)))
simple = FALSE;
for (tmp = ins2->next; tmp; tmp = tmp->next)
if (!((tmp->opcode == OP_NOP) || (tmp->opcode == OP_BR)))
simple = FALSE;
if (!simple)
continue;
/* We move ins1/ins2 before the compare so they should have no side effect */
if (!(MONO_INS_HAS_NO_SIDE_EFFECT (ins1) && MONO_INS_HAS_NO_SIDE_EFFECT (ins2)))
continue;
/* Moving ins1/ins2 could change the comparison */
/* FIXME: */
if (!((compare->sreg1 != ins1->dreg) && (compare->sreg2 != ins1->dreg)))
continue;
/* FIXME: */
comp_type = mono_opcode_to_type (branch->opcode, compare->opcode);
if (!((comp_type == CMP_TYPE_I) || (comp_type == CMP_TYPE_L)))
continue;
/* FIXME: */
/* ins->type might not be set */
if (INS_INFO (ins1->opcode) [MONO_INST_DEST] != 'i')
continue;
if (cfg->verbose_level > 2) {
printf ("\tBranch -> CMove optimization in BB%d on\n", bb->block_num);
printf ("\t\t"); mono_print_ins (compare);
printf ("\t\t"); mono_print_ins (compare->next);
printf ("\t\t"); mono_print_ins (ins1);
printf ("\t\t"); mono_print_ins (ins2);
}
changed = TRUE;
//printf ("HIT!\n");
/* Assignments to the return register must remain at the end of bbs */
if (cfg->ret)
ret = ins1->dreg == cfg->ret->dreg;
else
ret = FALSE;
tmp_reg = mono_alloc_dreg (cfg, STACK_I4);
dreg = ins1->dreg;
/* Rewrite ins1 to emit to tmp_reg */
ins1->dreg = tmp_reg;
if (ret) {
dreg = mono_alloc_dreg (cfg, STACK_I4);
ins2->dreg = dreg;
}
/* Remove ins1/ins2 from bb1/bb2 */
MONO_REMOVE_INS (true_bb, ins1);
MONO_REMOVE_INS (false_bb, ins2);
/* Move ins1 and ins2 before the comparison */
/* ins1 comes first to avoid ins1 overwriting an argument of ins2 */
mono_bblock_insert_before_ins (bb, compare, ins2);
mono_bblock_insert_before_ins (bb, ins2, ins1);
/* Add cmov instruction */
MONO_INST_NEW (cfg, cmov, OP_NOP);
cmov->dreg = dreg;
cmov->sreg1 = dreg;
cmov->sreg2 = tmp_reg;
switch (mono_opcode_to_type (branch->opcode, compare->opcode)) {
case CMP_TYPE_I:
cmov->opcode = int_cmov_opcodes [mono_opcode_to_cond (branch->opcode)];
break;
case CMP_TYPE_L:
cmov->opcode = long_cmov_opcodes [mono_opcode_to_cond (branch->opcode)];
break;
default:
g_assert_not_reached ();
}
mono_bblock_insert_after_ins (bb, compare, cmov);
if (ret) {
/* Add an extra move */
MONO_INST_NEW (cfg, move, OP_MOVE);
move->dreg = cfg->ret->dreg;
move->sreg1 = dreg;
mono_bblock_insert_after_ins (bb, cmov, move);
}
/* Rewrite the branch */
branch->opcode = OP_BR;
branch->inst_target_bb = true_bb->out_bb [0];
mono_link_bblock (cfg, bb, branch->inst_target_bb);
/* Reorder bblocks */
mono_unlink_bblock (cfg, bb, true_bb);
mono_unlink_bblock (cfg, bb, false_bb);
mono_unlink_bblock (cfg, true_bb, true_bb->out_bb [0]);
mono_unlink_bblock (cfg, false_bb, false_bb->out_bb [0]);
mono_remove_bblock (cfg, true_bb);
mono_remove_bblock (cfg, false_bb);
/* Merge bb and its successor if possible */
if ((bb->out_bb [0]->in_count == 1) && (bb->out_bb [0] != cfg->bb_exit) &&
(bb->region == bb->out_bb [0]->region)) {
mono_merge_basic_blocks (cfg, bb, bb->out_bb [0]);
goto restart;
}
}
/* Look for the IR code generated from if (cond) <var> <- <a>
* which is:
* BB:
* b<cond> [BB1BB2]
* BB1:
* <var> <- <a>
* br BB2
*/
if ((bb2->in_count == 1 && bb2->out_count == 1 && bb2->out_bb [0] == bb1) ||
(bb1->in_count == 1 && bb1->out_count == 1 && bb1->out_bb [0] == bb2)) {
MonoInst *compare, *branch, *ins1, *cmov, *tmp;
gboolean simple;
int dreg, tmp_reg;
CompType comp_type;
CompRelation cond;
MonoBasicBlock *next_bb, *code_bb;
/* code_bb is the bblock containing code, next_bb is the successor bblock */
if (bb2->in_count == 1 && bb2->out_count == 1 && bb2->out_bb [0] == bb1) {
code_bb = bb2;
next_bb = bb1;
} else {
code_bb = bb1;
next_bb = bb2;
}
ins1 = code_bb->code;
if (!ins1)
continue;
/* Check that code_bb is simple */
simple = TRUE;
for (tmp = ins1->next; tmp; tmp = tmp->next)
if (!((tmp->opcode == OP_NOP) || (tmp->opcode == OP_BR)))
simple = FALSE;
if (!simple)
continue;
/* We move ins1 before the compare so it should have no side effect */
if (!MONO_INS_HAS_NO_SIDE_EFFECT (ins1))
continue;
if (bb->last_ins && bb->last_ins->opcode == OP_BR_REG)
continue;
/* Find the compare instruction */
if (!bb->last_ins || !bb->last_ins->prev)
continue;
branch = bb->last_ins;
compare = branch->prev;
if (!MONO_IS_COND_BRANCH_OP (branch))
/* This can happen if a cond branch is optimized away */
continue;
/* FIXME: */
comp_type = mono_opcode_to_type (branch->opcode, compare->opcode);
if (!((comp_type == CMP_TYPE_I) || (comp_type == CMP_TYPE_L)))
continue;
/* FIXME: */
/* ins->type might not be set */
if (INS_INFO (ins1->opcode) [MONO_INST_DEST] != 'i')
continue;
/* FIXME: */
if (cfg->ret && ins1->dreg == cfg->ret->dreg)
continue;
if (!(cfg->opt & MONO_OPT_DEADCE))
/*
* It is possible that dreg is never set before, so we can't use
* it as an sreg of the cmov instruction (#582322).
*/
continue;
if (cfg->verbose_level > 2) {
printf ("\tBranch -> CMove optimization (2) in BB%d on\n", bb->block_num);
printf ("\t\t"); mono_print_ins (compare);
printf ("\t\t"); mono_print_ins (compare->next);
printf ("\t\t"); mono_print_ins (ins1);
}
changed = TRUE;
//printf ("HIT!\n");
tmp_reg = mono_alloc_dreg (cfg, STACK_I4);
dreg = ins1->dreg;
/* Rewrite ins1 to emit to tmp_reg */
ins1->dreg = tmp_reg;
/* Remove ins1 from code_bb */
MONO_REMOVE_INS (code_bb, ins1);
/* Move ins1 before the comparison */
mono_bblock_insert_before_ins (bb, compare, ins1);
/* Add cmov instruction */
MONO_INST_NEW (cfg, cmov, OP_NOP);
cmov->dreg = dreg;
cmov->sreg1 = dreg;
cmov->sreg2 = tmp_reg;
cond = mono_opcode_to_cond (branch->opcode);
if (branch->inst_false_bb == code_bb)
cond = mono_negate_cond (cond);
switch (mono_opcode_to_type (branch->opcode, compare->opcode)) {
case CMP_TYPE_I:
cmov->opcode = int_cmov_opcodes [cond];
break;
case CMP_TYPE_L:
cmov->opcode = long_cmov_opcodes [cond];
break;
default:
g_assert_not_reached ();
}
mono_bblock_insert_after_ins (bb, compare, cmov);
/* Rewrite the branch */
branch->opcode = OP_BR;
branch->inst_target_bb = next_bb;
mono_link_bblock (cfg, bb, branch->inst_target_bb);
/* Nullify the branch at the end of code_bb */
if (code_bb->code) {
branch = code_bb->code;
MONO_DELETE_INS (code_bb, branch);
}
/* Reorder bblocks */
mono_unlink_bblock (cfg, bb, code_bb);
mono_unlink_bblock (cfg, code_bb, next_bb);
/* Merge bb and its successor if possible */
if ((bb->out_bb [0]->in_count == 1) && (bb->out_bb [0] != cfg->bb_exit) &&
(bb->region == bb->out_bb [0]->region)) {
mono_merge_basic_blocks (cfg, bb, bb->out_bb [0]);
/*
* bbn might have fallen through to the next bb without a branch,
* have to add one now (#474718).
* FIXME: Maybe need to do this more generally in
* merge_basic_blocks () ?
*/
if (!(bb->last_ins && MONO_IS_BRANCH_OP (bb->last_ins)) && bb->out_count) {
MONO_INST_NEW (cfg, ins1, OP_BR);
ins1->inst_target_bb = bb->out_bb [0];
MONO_ADD_INS (bb, ins1);
}
goto restart;
}
}
}
/*
* Optimize checks like: if (v < 0 || v > limit) by changing then to unsigned
* compares. This isn't really if conversion, but it easier to do here than in
* optimize_branches () since the IR is already optimized.
*/
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
MonoBasicBlock *bb1, *bb2, *true_bb, *false_bb, *next_bb;
MonoInst *branch1, *branch2, *compare1, *ins;
/* Look for the IR code generated from if (<var> < 0 || v > <limit>)
* after branch opts which is:
* BB:
* icompare_imm R [0]
* int_blt [BB1BB2]
* BB2:
* icompare_imm R [<limit>]
* int_ble [BB3BB1]
*/
if (!(bb->out_count == 2 && !bb->extended))
continue;
bb1 = bb->out_bb [0];
bb2 = bb->out_bb [1];
// FIXME: Add more cases
/* Check structure */
if (!(bb1->in_count == 2 && bb1->in_bb [0] == bb && bb1->in_bb [1] == bb2 && bb2->in_count == 1 && bb2->out_count == 2))
continue;
next_bb = bb2;
/* Check first branch */
branch1 = bb->last_ins;
if (!(branch1 && ((branch1->opcode == OP_IBLT) || (branch1->opcode == OP_LBLT)) && (branch1->inst_false_bb == next_bb)))
continue;
true_bb = branch1->inst_true_bb;
/* Check second branch */
branch2 = next_bb->last_ins;
if (!branch2)
continue;
/* mcs sometimes generates inverted branches */
if (((branch2->opcode == OP_IBGT) || (branch2->opcode == OP_LBGT)) && branch2->inst_true_bb == branch1->inst_true_bb)
false_bb = branch2->inst_false_bb;
else if (((branch2->opcode == OP_IBLE) || (branch2->opcode == OP_LBLE)) && branch2->inst_false_bb == branch1->inst_true_bb)
false_bb = branch2->inst_true_bb;
else
continue;
/* Check first compare */
compare1 = bb->last_ins->prev;
if (!(compare1 && ((compare1->opcode == OP_ICOMPARE_IMM) || (compare1->opcode == OP_LCOMPARE_IMM)) && compare1->inst_imm == 0))
continue;
/* Check second bblock */
ins = next_bb->code;
if (!ins)
continue;
if (((ins->opcode == OP_ICOMPARE_IMM) || (ins->opcode == OP_LCOMPARE_IMM)) && ins->sreg1 == compare1->sreg1 && ins->next == branch2) {
/* The second arg must be positive */
if (ins->inst_imm < 0)
continue;
} else if (((ins->opcode == OP_LDLEN) || (ins->opcode == OP_STRLEN)) && ins->dreg != compare1->sreg1 && ins->next && ins->next->opcode == OP_ICOMPARE && ins->next->sreg1 == compare1->sreg1 && ins->next->sreg2 == ins->dreg && ins->next->next == branch2) {
/* Another common case: if (index < 0 || index > arr.Length) */
} else {
continue;
}
if (cfg->verbose_level > 2) {
printf ("\tSigned->unsigned compare optimization in BB%d on\n", bb->block_num);
printf ("\t\t"); mono_print_ins (compare1);
printf ("\t\t"); mono_print_ins (compare1->next);
printf ("\t\t"); mono_print_ins (ins);
}
/* Rewrite the first compare+branch */
MONO_DELETE_INS (bb, compare1);
branch1->opcode = OP_BR;
mono_unlink_bblock (cfg, bb, branch1->inst_true_bb);
mono_unlink_bblock (cfg, bb, branch1->inst_false_bb);
branch1->inst_target_bb = next_bb;
mono_link_bblock (cfg, bb, next_bb);
/* Rewrite the second branch */
branch2->opcode = br_to_br_un (branch2->opcode);
mono_merge_basic_blocks (cfg, bb, next_bb);
}
#if 0
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
MonoBasicBlock *bb1, *bb2;
MonoInst *prev, *compare, *branch, *ins1, *ins2, *cmov, *move, *tmp;
gboolean simple, ret;
int dreg, tmp_reg;
CompType comp_type;
/* Look for the IR code generated from if (cond) <var> <- <a>
* after branch opts which is:
* BB:
* compare
* b<cond> [BB1]
* <var> <- <a>
* BB1:
*/
if (!(bb->out_count == 1 && bb->extended && bb->code && bb->code->next && bb->code->next->next))
continue;
mono_print_bb (bb, "");
/* Find the compare instruction */
prev = NULL;
compare = bb->code;
g_assert (compare);
while (compare->next->next && compare->next->next != bb->last_ins) {
prev = compare;
compare = compare->next;
}
branch = compare->next;
if (!MONO_IS_COND_BRANCH_OP (branch))
continue;
}
#endif
if (changed) {
if (cfg->opt & MONO_OPT_BRANCH)
mono_optimize_branches (cfg);
/* Merging bblocks could make some variables local */
mono_handle_global_vregs (cfg);
if (cfg->opt & (MONO_OPT_CONSPROP | MONO_OPT_COPYPROP))
mono_local_cprop (cfg);
if (cfg->opt & MONO_OPT_DEADCE)
mono_local_deadce (cfg);
}
#endif
}
void
mono_remove_critical_edges (MonoCompile *cfg)
{
MonoBasicBlock *bb;
MonoBasicBlock *previous_bb;
if (cfg->verbose_level > 3) {
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
int i;
printf ("remove_critical_edges, BEFORE BB%d (in:", bb->block_num);
for (i = 0; i < bb->in_count; i++) {
printf (" %d", bb->in_bb [i]->block_num);
}
printf (") (out:");
for (i = 0; i < bb->out_count; i++) {
printf (" %d", bb->out_bb [i]->block_num);
}
printf (")");
if (bb->last_ins != NULL) {
printf (" ");
mono_print_ins (bb->last_ins);
}
printf ("\n");
}
}
for (previous_bb = cfg->bb_entry, bb = previous_bb->next_bb; bb != NULL; previous_bb = previous_bb->next_bb, bb = bb->next_bb) {
if (bb->in_count > 1) {
int in_bb_index;
for (in_bb_index = 0; in_bb_index < bb->in_count; in_bb_index++) {
MonoBasicBlock *in_bb = bb->in_bb [in_bb_index];
/*
* Have to remove non-critical edges whose source ends with a BR_REG
* ins too, since inserting a computation before the BR_REG could
* overwrite the sreg1 of the ins.
*/
if ((in_bb->out_count > 1) || (in_bb->out_count == 1 && in_bb->last_ins && in_bb->last_ins->opcode == OP_BR_REG)) {
MonoBasicBlock *new_bb = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
new_bb->block_num = cfg->num_bblocks++;
// new_bb->real_offset = bb->real_offset;
new_bb->region = bb->region;
/* Do not alter the CFG while altering the BB list */
if (mono_bb_is_fall_through (cfg, previous_bb)) {
if (previous_bb != cfg->bb_entry) {
int i;
/* Make sure previous_bb really falls through bb */
for (i = 0; i < previous_bb->out_count; i++) {
if (previous_bb->out_bb [i] == bb) {
MonoInst *jump;
MONO_INST_NEW (cfg, jump, OP_BR);
MONO_ADD_INS (previous_bb, jump);
jump->cil_code = previous_bb->cil_code;
jump->inst_target_bb = bb;
break;
}
}
} else {
/* We cannot add any inst to the entry BB, so we must */
/* put a new BB in the middle to hold the OP_BR */
MonoInst *jump;
MonoBasicBlock *new_bb_after_entry = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoBasicBlock));
new_bb_after_entry->block_num = cfg->num_bblocks++;
// new_bb_after_entry->real_offset = bb->real_offset;
new_bb_after_entry->region = bb->region;
MONO_INST_NEW (cfg, jump, OP_BR);
MONO_ADD_INS (new_bb_after_entry, jump);
jump->cil_code = bb->cil_code;
jump->inst_target_bb = bb;
mono_unlink_bblock (cfg, previous_bb, bb);
mono_link_bblock (cfg, new_bb_after_entry, bb);
mono_link_bblock (cfg, previous_bb, new_bb_after_entry);
previous_bb->next_bb = new_bb_after_entry;
previous_bb = new_bb_after_entry;
if (cfg->verbose_level > 2) {
printf ("remove_critical_edges, added helper BB%d jumping to BB%d\n", new_bb_after_entry->block_num, bb->block_num);
}
}
}
/* Insert new_bb in the BB list */
previous_bb->next_bb = new_bb;
new_bb->next_bb = bb;
previous_bb = new_bb;
/* Setup in_bb and out_bb */
new_bb->in_bb = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoBasicBlock*));
new_bb->in_bb [0] = in_bb;
new_bb->in_count = 1;
new_bb->out_bb = mono_mempool_alloc ((cfg)->mempool, sizeof (MonoBasicBlock*));
new_bb->out_bb [0] = bb;
new_bb->out_count = 1;
/* Relink in_bb and bb to (from) new_bb */
replace_out_block (in_bb, bb, new_bb);
replace_out_block_in_code (in_bb, bb, new_bb);
replace_in_block (bb, in_bb, new_bb);
if (cfg->verbose_level > 2) {
printf ("remove_critical_edges, removed critical edge from BB%d to BB%d (added BB%d)\n", in_bb->block_num, bb->block_num, new_bb->block_num);
}
}
}
}
}
if (cfg->verbose_level > 3) {
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
int i;
printf ("remove_critical_edges, AFTER BB%d (in:", bb->block_num);
for (i = 0; i < bb->in_count; i++) {
printf (" %d", bb->in_bb [i]->block_num);
}
printf (") (out:");
for (i = 0; i < bb->out_count; i++) {
printf (" %d", bb->out_bb [i]->block_num);
}
printf (")");
if (bb->last_ins != NULL) {
printf (" ");
mono_print_ins (bb->last_ins);
}
printf ("\n");
}
}
}