decisions about when a function is too big to inline. */
#define INSNS_PER_STMT (10)
-static tree declare_return_variable (inline_data *, tree, tree *);
static tree copy_body_r (tree *, int *, void *);
static tree copy_body (inline_data *);
static tree expand_call_inline (tree *, int *, void *);
if (assignment)
{
/* Do not create a statement containing a naked RESULT_DECL. */
- if (lang_hooks.gimple_before_inlining)
- if (TREE_CODE (assignment) == RESULT_DECL)
- gimplify_stmt (&assignment);
+ if (TREE_CODE (assignment) == RESULT_DECL)
+ gimplify_stmt (&assignment);
*tp = build (BIND_EXPR, void_type_node, NULL, NULL, NULL);
append_to_statement_list (assignment, &BIND_EXPR_BODY (*tp));
Theoretically, we could check the expression to see if
all of the variables that determine its value are
read-only, but we don't bother. */
- if ((TREE_CONSTANT (value) || TREE_READONLY_DECL_P (value))
- /* We may produce non-gimple trees by adding NOPs or introduce
- invalid sharing when operand is not really constant.
- It is not big deal to prohibit constant propagation here as
- we will constant propagate in DOM1 pass anyway. */
- && (!lang_hooks.gimple_before_inlining
- || (is_gimple_min_invariant (value)
- && TREE_TYPE (value) == TREE_TYPE (p))))
+ /* We may produce non-gimple trees by adding NOPs or introduce
+ invalid sharing when operand is not really constant.
+ It is not big deal to prohibit constant propagation here as
+ we will constant propagate in DOM1 pass anyway. */
+ if (is_gimple_min_invariant (value)
+ && lang_hooks.types_compatible_p (TREE_TYPE (value), TREE_TYPE (p)))
{
- /* If this is a declaration, wrap it a NOP_EXPR so that
- we don't try to put the VALUE on the list of BLOCK_VARS. */
- if (DECL_P (value))
- value = build1 (NOP_EXPR, TREE_TYPE (value), value);
-
- /* If this is a constant, make sure it has the right type. */
- else if (TREE_TYPE (value) != TREE_TYPE (p))
- value = fold (build1 (NOP_EXPR, TREE_TYPE (p), value));
-
insert_decl_map (id, p, value);
return;
}
*vars = var;
/* Make gimplifier happy about this variable. */
- DECL_SEEN_IN_BIND_EXPR_P (var) = lang_hooks.gimple_before_inlining;
+ DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
/* Even if P was TREE_READONLY, the new VAR should not be.
In the original code, we would have constructed a
&gimplify_init_stmts_p);
}
- if (gimplify_init_stmts_p && lang_hooks.gimple_before_inlining)
+ if (gimplify_init_stmts_p)
gimplify_body (&init_stmts, current_function_decl);
declare_inline_vars (bind_expr, vars);
return init_stmts;
}
-/* Declare a return variable to replace the RESULT_DECL for the
- function we are calling. An appropriate decl is returned.
-
- ??? Needs documentation of parameters. */
+/* Declare a return variable to replace the RESULT_DECL for the function we
+ are calling. RETURN_SLOT_ADDR, if non-null, was a fake parameter that
+ took the address of the result. MODIFY_DEST, if non-null, was the LHS of
+ the MODIFY_EXPR to which this call is the RHS.
+
+ The return value is a (possibly null) value that is the result of the
+ function as seen by the callee. *USE_P is a (possibly null) value that
+ holds the result as seen by the caller. */
static tree
-declare_return_variable (inline_data *id, tree return_slot_addr, tree *use_p)
+declare_return_variable (inline_data *id, tree return_slot_addr,
+ tree modify_dest, tree *use_p)
{
- tree fn = VARRAY_TOP_TREE (id->fns);
- tree result = DECL_RESULT (fn);
- int need_return_decl = 1;
- tree var;
+ tree callee = VARRAY_TOP_TREE (id->fns);
+ tree caller = VARRAY_TREE (id->fns, 0);
+ tree result = DECL_RESULT (callee);
+ tree callee_type = TREE_TYPE (result);
+ tree caller_type = TREE_TYPE (TREE_TYPE (callee));
+ tree var, use;
/* We don't need to do anything for functions that don't return
anything. */
- if (!result || VOID_TYPE_P (TREE_TYPE (result)))
+ if (!result || VOID_TYPE_P (callee_type))
{
*use_p = NULL_TREE;
return NULL_TREE;
}
- var = (lang_hooks.tree_inlining.copy_res_decl_for_inlining
- (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map,
- &need_return_decl, return_slot_addr));
-
+ /* If there was a return slot, then the return value the the
+ dereferenced address of that object. */
+ if (return_slot_addr)
+ {
+ /* The front end shouldn't have used both return_slot_addr and
+ a modify expression. */
+ if (modify_dest)
+ abort ();
+ var = build_fold_indirect_ref (return_slot_addr);
+ use = NULL;
+ goto done;
+ }
+
+ /* All types requiring non-trivial constructors should have been handled. */
+ if (TREE_ADDRESSABLE (callee_type))
+ abort ();
+
+ /* Attempt to avoid creating a new temporary variable. */
+ if (modify_dest)
+ {
+ bool use_it = false;
+
+ /* We can't use MODIFY_DEST if there's type promotion involved. */
+ if (!lang_hooks.types_compatible_p (caller_type, callee_type))
+ use_it = false;
+
+ /* ??? If we're assigning to a variable sized type, then we must
+ reuse the destination variable, because we've no good way to
+ create variable sized temporaries at this point. */
+ else if (TREE_CODE (TYPE_SIZE_UNIT (caller_type)) != INTEGER_CST)
+ use_it = true;
+
+ /* If the callee cannot possibly modify MODIFY_DEST, then we can
+ reuse it as the result of the call directly. Don't do this if
+ it would promote MODIFY_DEST to addressable. */
+ else if (!TREE_STATIC (modify_dest)
+ && !TREE_ADDRESSABLE (modify_dest)
+ && !TREE_ADDRESSABLE (result))
+ use_it = true;
+
+ if (use_it)
+ {
+ var = modify_dest;
+ use = NULL;
+ goto done;
+ }
+ }
+
+ if (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) != INTEGER_CST)
+ abort ();
+
+ var = copy_decl_for_inlining (result, callee, caller);
+ DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
+ DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list
+ = tree_cons (NULL_TREE, var,
+ DECL_STRUCT_FUNCTION (caller)->unexpanded_var_list);
+
/* Do not have the rest of GCC warn about this variable as it should
not be visible to the user. */
TREE_NO_WARNING (var) = 1;
+ /* Build the use expr. If the return type of the function was
+ promoted, convert it back to the expected type. */
+ use = var;
+ if (!lang_hooks.types_compatible_p (TREE_TYPE (var), caller_type))
+ use = fold_convert (caller_type, var);
+
+ done:
/* Register the VAR_DECL as the equivalent for the RESULT_DECL; that
way, when the RESULT_DECL is encountered, it will be
automatically replaced by the VAR_DECL. */
/* Remember this so we can ignore it in remap_decls. */
id->retvar = var;
- /* Build the use expr. If the return type of the function was
- promoted, convert it back to the expected type. */
- if (return_slot_addr)
- /* The function returns through an explicit return slot, not a normal
- return value. */
- *use_p = NULL_TREE;
- else if (TREE_TYPE (var) == TREE_TYPE (TREE_TYPE (fn)))
- *use_p = var;
- else if (TREE_CODE (var) == INDIRECT_REF)
- *use_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (fn)),
- TREE_OPERAND (var, 0));
- else if (TREE_ADDRESSABLE (TREE_TYPE (var)))
- abort ();
- else
- *use_p = build1 (NOP_EXPR, TREE_TYPE (TREE_TYPE (fn)), var);
-
- /* Build the declaration statement if FN does not return an
- aggregate. */
- if (need_return_decl)
- return var;
- /* If FN does return an aggregate, there's no need to declare the
- return variable; we're using a variable in our caller's frame. */
- else
- return NULL_TREE;
+ *use_p = use;
+ return var;
}
/* Returns nonzero if a function can be inlined as a tree. */
case COMPONENT_REF:
case BIT_FIELD_REF:
case INDIRECT_REF:
- case BUFFER_REF:
case ARRAY_REF:
case ARRAY_RANGE_REF:
case OBJ_TYPE_REF:
case EXIT_EXPR:
case LOOP_EXPR:
case PHI_NODE:
+ case WITH_SIZE_EXPR:
break;
/* We don't account constants for now. Assume that the cost is amortized
case ASM_EXPR:
case RESX_EXPR:
- *count++;
+ *count += 1;
break;
/* Few special cases of expensive operations. This is useful
tree fn;
tree arg_inits;
tree *inlined_body;
- tree inline_result;
splay_tree st;
tree args;
tree return_slot_addr;
+ tree modify_dest;
location_t saved_location;
struct cgraph_edge *edge;
const char *reason;
statements within the function to jump to. The type of the
statement expression is the return type of the function call. */
stmt = NULL;
- expr = build (BIND_EXPR, TREE_TYPE (TREE_TYPE (fn)), NULL_TREE,
+ expr = build (BIND_EXPR, void_type_node, NULL_TREE,
stmt, make_node (BLOCK));
BLOCK_ABSTRACT_ORIGIN (BIND_EXPR_BLOCK (expr)) = fn;
|| TREE_CODE (DECL_INITIAL (fn)) != BLOCK)
abort ();
+ /* Find the lhs to which the result of this call is assigned. */
+ modify_dest = tsi_stmt (id->tsi);
+ if (TREE_CODE (modify_dest) == MODIFY_EXPR)
+ modify_dest = TREE_OPERAND (modify_dest, 0);
+ else
+ modify_dest = NULL;
+
/* Declare the return variable for the function. */
- decl = declare_return_variable (id, return_slot_addr, &use_retvar);
- if (decl)
- declare_inline_vars (expr, decl);
+ decl = declare_return_variable (id, return_slot_addr,
+ modify_dest, &use_retvar);
/* After we've initialized the parameters, we insert the body of the
function itself. */
append_to_statement_list (label, &BIND_EXPR_BODY (expr));
}
- /* Finally, mention the returned value so that the value of the
- statement-expression is the returned value of the function. */
- if (use_retvar)
- /* Set TREE_TYPE on BIND_EXPR? */
- append_to_statement_list_force (use_retvar, &BIND_EXPR_BODY (expr));
-
/* Clean up. */
splay_tree_delete (id->decl_map);
id->decl_map = st;
/* The new expression has side-effects if the old one did. */
TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (t);
- /* If we are working with gimple form, then we need to keep the tree
- in gimple form. If we are not in gimple form, we can just replace
- *tp with the new BIND_EXPR. */
- if (lang_hooks.gimple_before_inlining)
- {
- tree save_decl;
-
- /* We want to create a new variable to hold the result of the inlined
- body. This new variable needs to be added to the function which we
- are inlining into, thus the saving and restoring of
- current_function_decl. */
- save_decl = current_function_decl;
- current_function_decl = id->node->decl;
- inline_result = voidify_wrapper_expr (expr, NULL);
- current_function_decl = save_decl;
-
- /* If the inlined function returns a result that we care about,
- then we're going to need to splice in a MODIFY_EXPR. Otherwise
- the call was a standalone statement and we can just replace it
- with the BIND_EXPR inline representation of the called function. */
- if (TREE_CODE (tsi_stmt (id->tsi)) != CALL_EXPR)
- {
- tsi_link_before (&id->tsi, expr, TSI_SAME_STMT);
- *tp = inline_result;
- }
- else
- *tp = expr;
+ tsi_link_before (&id->tsi, expr, TSI_SAME_STMT);
- /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS on
- the call if it is to a "const" function. Thus the copy of
- TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above with
- result in TREE_SIDE_EFFECTS not being set for the inlined copy of a
- "const" function.
+ /* If the inlined function returns a result that we care about,
+ then we're going to need to splice in a MODIFY_EXPR. Otherwise
+ the call was a standalone statement and we can just replace it
+ with the BIND_EXPR inline representation of the called function. */
+ if (!use_retvar || !modify_dest)
+ *tsi_stmt_ptr (id->tsi) = build_empty_stmt ();
+ else
+ *tp = use_retvar;
- Unfortunately, that is wrong as inlining the function can
- create/expose interesting side effects (such as setting of a return
- value).
+ /* When we gimplify a function call, we may clear TREE_SIDE_EFFECTS on
+ the call if it is to a "const" function. Thus the copy of
+ TREE_SIDE_EFFECTS from the CALL_EXPR to the BIND_EXPR above with
+ result in TREE_SIDE_EFFECTS not being set for the inlined copy of a
+ "const" function.
- The easiest solution is to simply recalculate TREE_SIDE_EFFECTS for
- the toplevel expression. */
- recalculate_side_effects (expr);
- }
- else
- *tp = expr;
+ Unfortunately, that is wrong as inlining the function can create/expose
+ interesting side effects (such as setting of a return value).
- /* If the value of the new expression is ignored, that's OK. We
- don't warn about this for CALL_EXPRs, so we shouldn't warn about
- the equivalent inlined version either. */
- TREE_USED (*tp) = 1;
+ The easiest solution is to simply recalculate TREE_SIDE_EFFECTS for
+ the toplevel expression. */
+ recalculate_side_effects (expr);
/* Update callgraph if needed. */
cgraph_remove_node (edge->callee);
}
static void
-gimple_expand_calls_inline (tree *stmt_p, inline_data *id)
+expand_calls_inline (tree *stmt_p, inline_data *id)
{
tree stmt = *stmt_p;
enum tree_code code = TREE_CODE (stmt);
for (i = tsi_start (stmt); !tsi_end_p (i); )
{
id->tsi = i;
- gimple_expand_calls_inline (tsi_stmt_ptr (i), id);
+ expand_calls_inline (tsi_stmt_ptr (i), id);
new = tsi_stmt (i);
if (TREE_CODE (new) == STATEMENT_LIST)
break;
case COND_EXPR:
- gimple_expand_calls_inline (&COND_EXPR_THEN (stmt), id);
- gimple_expand_calls_inline (&COND_EXPR_ELSE (stmt), id);
+ expand_calls_inline (&COND_EXPR_THEN (stmt), id);
+ expand_calls_inline (&COND_EXPR_ELSE (stmt), id);
break;
case CATCH_EXPR:
- gimple_expand_calls_inline (&CATCH_BODY (stmt), id);
+ expand_calls_inline (&CATCH_BODY (stmt), id);
break;
case EH_FILTER_EXPR:
- gimple_expand_calls_inline (&EH_FILTER_FAILURE (stmt), id);
+ expand_calls_inline (&EH_FILTER_FAILURE (stmt), id);
break;
case TRY_CATCH_EXPR:
case TRY_FINALLY_EXPR:
- gimple_expand_calls_inline (&TREE_OPERAND (stmt, 0), id);
- gimple_expand_calls_inline (&TREE_OPERAND (stmt, 1), id);
+ expand_calls_inline (&TREE_OPERAND (stmt, 0), id);
+ expand_calls_inline (&TREE_OPERAND (stmt, 1), id);
break;
case BIND_EXPR:
- gimple_expand_calls_inline (&BIND_EXPR_BODY (stmt), id);
+ expand_calls_inline (&BIND_EXPR_BODY (stmt), id);
break;
case COMPOUND_EXPR:
case MODIFY_EXPR:
stmt_p = &TREE_OPERAND (stmt, 1);
stmt = *stmt_p;
+ if (TREE_CODE (stmt) == WITH_SIZE_EXPR)
+ {
+ stmt_p = &TREE_OPERAND (stmt, 0);
+ stmt = *stmt_p;
+ }
if (TREE_CODE (stmt) != CALL_EXPR)
break;
}
}
-/* Walk over the entire tree *TP, replacing CALL_EXPRs with inline
- expansions as appropriate. */
-
-static void
-expand_calls_inline (tree *tp, inline_data *id)
-{
- /* If we are not in gimple form, then we want to walk the tree
- recursively as we do not know anything about the structure
- of the tree. */
-
- if (!lang_hooks.gimple_before_inlining)
- {
- walk_tree (tp, expand_call_inline, id, id->tree_pruner);
- return;
- }
-
- /* We are in gimple form. We want to stay in gimple form. Walk
- the statements, inlining calls in each statement. By walking
- the statements, we have enough information to keep the tree
- in gimple form as we insert inline bodies. */
-
- gimple_expand_calls_inline (tp, id);
-}
-
/* Expand calls to inline functions in the body of FN. */
void
{
inline_data id;
tree prev_fn;
+ tree ifn;
/* There is no point in performing inlining if errors have already
occurred -- and we might crash if we try to inline invalid
/* Clean up. */
htab_delete (id.tree_pruner);
- if (DECL_LANG_SPECIFIC (fn))
- {
- tree ifn = make_tree_vec (VARRAY_ACTIVE_SIZE (id.inlined_fns));
-
- if (VARRAY_ACTIVE_SIZE (id.inlined_fns))
- memcpy (&TREE_VEC_ELT (ifn, 0), &VARRAY_TREE (id.inlined_fns, 0),
- VARRAY_ACTIVE_SIZE (id.inlined_fns) * sizeof (tree));
- DECL_INLINED_FNS (fn) = ifn;
- }
+ ifn = make_tree_vec (VARRAY_ACTIVE_SIZE (id.inlined_fns));
+ if (VARRAY_ACTIVE_SIZE (id.inlined_fns))
+ memcpy (&TREE_VEC_ELT (ifn, 0), &VARRAY_TREE (id.inlined_fns, 0),
+ VARRAY_ACTIVE_SIZE (id.inlined_fns) * sizeof (tree));
+ DECL_INLINED_FNS (fn) = ifn;
#ifdef ENABLE_CHECKING
{
static void
declare_inline_vars (tree bind_expr, tree vars)
{
- if (lang_hooks.gimple_before_inlining)
- {
- tree t;
-
- for (t = vars; t; t = TREE_CHAIN (t))
- DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
- }
+ tree t;
+ for (t = vars; t; t = TREE_CHAIN (t))
+ DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
add_var_to_bind_expr (bind_expr, vars);
}
OSDN Git Service
