static void check_call (ipa_reference_local_vars_info_t local, tree call_expr) { int flags = call_expr_flags (call_expr); tree operand_list = TREE_OPERAND (call_expr, 1); tree operand; tree callee_t = get_callee_fndecl (call_expr); enum availability avail = AVAIL_NOT_AVAILABLE; for (operand = operand_list; operand != NULL_TREE; operand = TREE_CHAIN (operand)) { tree argument = TREE_VALUE (operand); check_rhs_var (local, argument); } if (callee_t) { struct cgraph_node* callee = cgraph_node(callee_t); avail = cgraph_function_body_availability (callee); } if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE) if (local) { if (flags & ECF_PURE) local->calls_read_all = true; else { local->calls_read_all = true; local->calls_write_all = true; } } }
static void check_call (ipa_reference_local_vars_info_t local, tree call_expr) { int flags = call_expr_flags (call_expr); tree operand; tree callee_t = get_callee_fndecl (call_expr); enum availability avail = AVAIL_NOT_AVAILABLE; call_expr_arg_iterator iter; FOR_EACH_CALL_EXPR_ARG (operand, iter, call_expr) check_rhs_var (local, operand); if (callee_t) { struct cgraph_node* callee = cgraph_node(callee_t); avail = cgraph_function_body_availability (callee); } if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE) if (local) { if (flags & ECF_PURE) local->calls_read_all = true; else { local->calls_read_all = true; local->calls_write_all = true; } } }
bool block_may_fallthru (tree block) { tree stmt = expr_last (block); switch (stmt ? TREE_CODE (stmt) : ERROR_MARK) { case GOTO_EXPR: case RETURN_EXPR: case RESX_EXPR: /* Easy cases. If the last statement of the block implies control transfer, then we can't fall through. */ return false; case SWITCH_EXPR: /* If SWITCH_LABELS is set, this is lowered, and represents a branch to a selected label and hence can not fall through. Otherwise SWITCH_BODY is set, and the switch can fall through. */ return SWITCH_LABELS (stmt) == NULL_TREE; case COND_EXPR: if (block_may_fallthru (COND_EXPR_THEN (stmt))) return true; return block_may_fallthru (COND_EXPR_ELSE (stmt)); case BIND_EXPR: return block_may_fallthru (BIND_EXPR_BODY (stmt)); case TRY_CATCH_EXPR: return try_catch_may_fallthru (stmt); case TRY_FINALLY_EXPR: /* The finally clause is always executed after the try clause, so if it does not fall through, then the try-finally will not fall through. Otherwise, if the try clause does not fall through, then when the finally clause falls through it will resume execution wherever the try clause was going. So the whole try-finally will only fall through if both the try clause and the finally clause fall through. */ return (block_may_fallthru (TREE_OPERAND (stmt, 0)) && block_may_fallthru (TREE_OPERAND (stmt, 1))); case MODIFY_EXPR: if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR) stmt = TREE_OPERAND (stmt, 1); else return true; /* FALLTHRU */ case CALL_EXPR: /* Functions that do not return do not fall through. */ return (call_expr_flags (stmt) & ECF_NORETURN) == 0; default: return true; } }
static struct mem_ref_group * gather_memory_references (struct loop *loop, bool *no_other_refs) { basic_block *body = get_loop_body_in_dom_order (loop); basic_block bb; unsigned i; block_stmt_iterator bsi; tree stmt, lhs, rhs, call; struct mem_ref_group *refs = NULL; *no_other_refs = true; /* Scan the loop body in order, so that the former references precede the later ones. */ for (i = 0; i < loop->num_nodes; i++) { bb = body[i]; if (bb->loop_father != loop) continue; for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) { stmt = bsi_stmt (bsi); call = get_call_expr_in (stmt); if (call && !(call_expr_flags (call) & ECF_CONST)) *no_other_refs = false; if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) { if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)) *no_other_refs = false; continue; } lhs = GIMPLE_STMT_OPERAND (stmt, 0); rhs = GIMPLE_STMT_OPERAND (stmt, 1); if (REFERENCE_CLASS_P (rhs)) *no_other_refs &= gather_memory_references_ref (loop, &refs, rhs, false, stmt); if (REFERENCE_CLASS_P (lhs)) *no_other_refs &= gather_memory_references_ref (loop, &refs, lhs, true, stmt); } } free (body); return refs; }
static void check_call (funct_state local, tree call_expr) { int flags = call_expr_flags(call_expr); tree operand_list = TREE_OPERAND (call_expr, 1); tree operand; tree callee_t = get_callee_fndecl (call_expr); struct cgraph_node* callee; enum availability avail = AVAIL_NOT_AVAILABLE; for (operand = operand_list; operand != NULL_TREE; operand = TREE_CHAIN (operand)) { tree argument = TREE_VALUE (operand); check_rhs_var (local, argument); } /* The const and pure flags are set by a variety of places in the compiler (including here). If someone has already set the flags for the callee, (such as for some of the builtins) we will use them, otherwise we will compute our own information. Const and pure functions have less clobber effects than other functions so we process these first. Otherwise if it is a call outside the compilation unit or an indirect call we punt. This leaves local calls which will be processed by following the call graph. */ if (callee_t) { callee = cgraph_node(callee_t); avail = cgraph_function_body_availability (callee); /* When bad things happen to bad functions, they cannot be const or pure. */ if (setjmp_call_p (callee_t)) local->pure_const_state = IPA_NEITHER; if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL) switch (DECL_FUNCTION_CODE (callee_t)) { case BUILT_IN_LONGJMP: case BUILT_IN_NONLOCAL_GOTO: local->pure_const_state = IPA_NEITHER; break; default: break; } } /* The callee is either unknown (indirect call) or there is just no scannable code for it (external call) . We look to see if there are any bits available for the callee (such as by declaration or because it is builtin) and process solely on the basis of those bits. */ if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE) { if (flags & ECF_PURE) { if (local->pure_const_state == IPA_CONST) local->pure_const_state = IPA_PURE; } else local->pure_const_state = IPA_NEITHER; } else { /* We have the code and we will scan it for the effects. */ if (flags & ECF_PURE) { if (local->pure_const_state == IPA_CONST) local->pure_const_state = IPA_PURE; } } }