/* Perform optimizations on tree structure.
-
- Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
Written by Mark Michell (mark@codesourcery.com).
- This file is part of GNU CC.
+This file is part of GNU CC.
- GNU CC is free software; you can redistribute it and/or modify it
- under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- GNU CC is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+GNU CC is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with GNU CC; see the file COPYING. If not, write to the Free
- Software Foundation, 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
#include "config.h"
#include "system.h"
#include "cp-tree.h"
#include "rtl.h"
#include "insn-config.h"
+#include "input.h"
#include "integrate.h"
#include "varray.h"
are not needed.
o Provide heuristics to clamp inlining of recursive template
- calls?
+ calls? */
- o It looks like the return label is not being placed in the optimal
- place. Shouldn't it come before the returned value? */
-
/* Data required for function inlining. */
typedef struct inline_data
inlining the body of `h', the stack will contain, `h', followed
by `g', followed by `f'. */
varray_type fns;
- /* The last SCOPE_STMT we have encountered. */
- tree scope_stmt;
- /* The label to jump to when a return statement is encountered. */
+ /* The label to jump to when a return statement is encountered. If
+ this value is NULL, then return statements will simply be
+ remapped as return statements, rather than as jumps. */
tree ret_label;
/* The map from local declarations in the inlined function to
equivalents in the function into which it is being inlined. */
/* Nonzero if we are currently within the cleanup for a
TARGET_EXPR. */
int in_target_cleanup_p;
+ /* A stack of the TARGET_EXPRs that we are currently processing. */
+ varray_type target_exprs;
} inline_data;
/* Prototypes. */
-static tree initialize_inlined_parameters PROTO((inline_data *, tree));
-static tree declare_return_variable PROTO((inline_data *, tree *));
-static tree copy_body_r PROTO((tree *, int *, void *));
-static tree copy_body PROTO((inline_data *));
-static tree expand_call_inline PROTO((tree *, int *, void *));
-static void expand_calls_inline PROTO((tree *, inline_data *));
-static int inlinable_function_p PROTO((tree, inline_data *));
-static tree remap_decl PROTO((tree, inline_data *));
-static void remap_block PROTO((tree, tree, inline_data *));
-static void copy_scope_stmt PROTO((tree *, int *, inline_data *));
-static tree calls_setjmp_r PROTO((tree *, int *, void *));
+static tree initialize_inlined_parameters PARAMS ((inline_data *, tree, tree));
+static tree declare_return_variable PARAMS ((inline_data *, tree *));
+static tree copy_body_r PARAMS ((tree *, int *, void *));
+static tree copy_body PARAMS ((inline_data *));
+static tree expand_call_inline PARAMS ((tree *, int *, void *));
+static void expand_calls_inline PARAMS ((tree *, inline_data *));
+static int inlinable_function_p PARAMS ((tree, inline_data *));
+static tree remap_decl PARAMS ((tree, inline_data *));
+static void remap_block PARAMS ((tree, tree, inline_data *));
+static void copy_scope_stmt PARAMS ((tree *, int *, inline_data *));
+static tree calls_setjmp_r PARAMS ((tree *, int *, void *));
/* Remap DECL during the copying of the BLOCK tree for the function.
DATA is really an `inline_data *'. */
/* Make a copy of the variable or label. */
t = copy_decl_for_inlining (decl, fn,
VARRAY_TREE (id->fns, 0));
+
+ /* The decl T could be a dynamic array or other variable size type,
+ in which case some fields need to be remapped because they may
+ contain SAVE_EXPRs. */
+ walk_tree (&DECL_SIZE (t), copy_body_r, id);
+ walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id);
+ if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE
+ && TYPE_DOMAIN (TREE_TYPE (t)))
+ {
+ TREE_TYPE (t) = copy_node (TREE_TYPE (t));
+ TYPE_DOMAIN (TREE_TYPE (t))
+ = copy_node (TYPE_DOMAIN (TREE_TYPE (t)));
+ walk_tree (&TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (t))),
+ copy_body_r, id);
+ }
+
/* Remember it, so that if we encounter this local entity
again we can reuse this copy. */
n = splay_tree_insert (id->decl_map,
tree old_block;
tree new_block;
tree old_var;
+ tree *first_block;
+ tree fn;
/* Make the new block. */
old_block = SCOPE_STMT_BLOCK (scope_stmt);
/* Remap the variable. */
new_var = remap_decl (old_var, id);
- if (!new_var)
- /* We didn't remap this variable, so we can't mess with
- its TREE_CHAIN. */
+ /* If we didn't remap this variable, so we can't mess with
+ its TREE_CHAIN. If we remapped this variable to
+ something other than a declaration (say, if we mapped it
+ to a constant), then we must similarly omit any mention
+ of it here. */
+ if (!new_var || !DECL_P (new_var))
;
else
{
}
/* We put the BLOCK_VARS in reverse order; fix that now. */
BLOCK_VARS (new_block) = nreverse (BLOCK_VARS (new_block));
- /* Graft the new block into the tree. */
- insert_block_after_note (new_block,
- (id->scope_stmt
- ? SCOPE_STMT_BLOCK (id->scope_stmt)
- : NULL_TREE),
- (id->scope_stmt
- ? SCOPE_BEGIN_P (id->scope_stmt) : 1),
- VARRAY_TREE (id->fns, 0));
- /* Remember that this is now the last scope statement with
- an associated block. */
- id->scope_stmt = scope_stmt;
+ /* Attach this new block after the DECL_INITIAL block for the
+ function into which this block is being inlined. In
+ rest_of_compilation we will straighten out the BLOCK tree. */
+ fn = VARRAY_TREE (id->fns, 0);
+ if (DECL_INITIAL (fn))
+ first_block = &BLOCK_CHAIN (DECL_INITIAL (fn));
+ else
+ first_block = &DECL_INITIAL (fn);
+ BLOCK_CHAIN (new_block) = *first_block;
+ *first_block = new_block;
/* Remember the remapped block. */
splay_tree_insert (id->decl_map,
(splay_tree_key) old_block,
(splay_tree_key) SCOPE_STMT_BLOCK (scope_stmt));
my_friendly_assert (n != NULL, 19991203);
SCOPE_STMT_BLOCK (scope_stmt) = (tree) n->value;
-
- /* Remember that this is now the last scope statement with an
- associated block. */
- id->scope_stmt = scope_stmt;
}
}
/* If this is a RETURN_STMT, change it into an EXPR_STMT and a
GOTO_STMT with the RET_LABEL as its target. */
- if (TREE_CODE (*tp) == RETURN_STMT)
+ if (TREE_CODE (*tp) == RETURN_STMT && id->ret_label)
{
tree return_stmt = *tp;
tree goto_stmt;
new_decl = remap_decl (*tp, id);
my_friendly_assert (new_decl != NULL_TREE, 19991203);
/* Replace this variable with the copy. */
+ STRIP_TYPE_NOPS (new_decl);
*tp = new_decl;
}
+ else if (nonstatic_local_decl_p (*tp)
+ && DECL_CONTEXT (*tp) != VARRAY_TREE (id->fns, 0))
+ my_friendly_abort (0);
else if (TREE_CODE (*tp) == SAVE_EXPR)
- remap_save_expr (tp, id->decl_map, VARRAY_TREE (id->fns, 0));
+ remap_save_expr (tp, id->decl_map, VARRAY_TREE (id->fns, 0),
+ walk_subtrees);
else if (TREE_CODE (*tp) == UNSAVE_EXPR)
my_friendly_abort (19991113);
/* For a SCOPE_STMT, we must copy the associated block so that we
/* The copied TARGET_EXPR has never been expanded, even if the
original node was expanded already. */
if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3))
- TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
+ {
+ TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3);
+ TREE_OPERAND (*tp, 3) = NULL_TREE;
+ }
/* Similarly, if we're copying a CALL_EXPR, the RTL for the
result is no longer valid. */
else if (TREE_CODE (*tp) == CALL_EXPR)
top of the stack in ID from the ARGS (presented as a TREE_LIST). */
static tree
-initialize_inlined_parameters (id, args)
+initialize_inlined_parameters (id, args, fn)
inline_data *id;
tree args;
+ tree fn;
{
- tree fn;
tree init_stmts;
tree parms;
tree a;
tree p;
/* Figure out what the parameters are. */
- fn = VARRAY_TOP_TREE (id->fns);
parms = DECL_ARGUMENTS (fn);
/* Start with no initializations whatsoever. */
{
tree init_stmt;
tree var;
-
+ tree value;
+
+ /* Find the initializer. */
+ value = TREE_VALUE (a);
+ /* If the parameter is never assigned to, we may not need to
+ create a new variable here at all. Instead, we may be able
+ to just use the argument value. */
+ if (TREE_READONLY (p)
+ && !TREE_ADDRESSABLE (p)
+ && !TREE_SIDE_EFFECTS (value))
+ {
+ /* Simplify the value, if possible. */
+ value = fold (decl_constant_value (value));
+
+ /* We can't risk substituting complex expressions. They
+ might contain variables that will be assigned to later.
+ 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))
+ {
+ /* 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);
+
+ splay_tree_insert (id->decl_map,
+ (splay_tree_key) p,
+ (splay_tree_value) value);
+ continue;
+ }
+ }
+
/* Make an equivalent VAR_DECL. */
var = copy_decl_for_inlining (p, fn, VARRAY_TREE (id->fns, 0));
/* Register the VAR_DECL as the equivalent for the PARM_DECL;
splay_tree_insert (id->decl_map,
(splay_tree_key) p,
(splay_tree_value) var);
+
+ /* Declare this new variable. */
+ init_stmt = build_min_nt (DECL_STMT, var);
+ TREE_CHAIN (init_stmt) = init_stmts;
+ init_stmts = init_stmt;
+
/* Initialize this VAR_DECL from the equivalent argument. If
the argument is an object, created via a constructor or copy,
this will not result in an extra copy: the TARGET_EXPR
representing the argument will be bound to VAR, and the
object will be constructed in VAR. */
- init_stmt = build_min_nt (EXPR_STMT,
- build (INIT_EXPR, TREE_TYPE (p),
- var, TREE_VALUE (a)));
- /* Declare this new variable. Note that we do this *after* the
- initialization because we are going to reverse all the
- initialization statements below. */
- TREE_CHAIN (init_stmt) = build_min_nt (DECL_STMT, var);
- /* Add this initialization to the list. */
- TREE_CHAIN (TREE_CHAIN (init_stmt)) = init_stmts;
- init_stmts = init_stmt;
+ if (! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p)))
+ DECL_INITIAL (var) = value;
+ else
+ {
+ init_stmt = build_min_nt (EXPR_STMT,
+ build (INIT_EXPR, TREE_TYPE (p),
+ var, value));
+ /* Add this initialization to the list. Note that we want the
+ declaration *after* the initialization because we are going
+ to reverse all the initialization statements below. */
+ TREE_CHAIN (init_stmt) = init_stmts;
+ init_stmts = init_stmt;
+ }
}
/* The initialization statements have been built up in reverse
tree fn = VARRAY_TOP_TREE (id->fns);
tree result = DECL_RESULT (fn);
tree var;
+ int aggregate_return_p;
/* We don't need to do anything for functions that don't return
anything. */
return NULL_TREE;
}
- /* Make an appropriate copy. */
- var = copy_decl_for_inlining (result, fn, VARRAY_TREE (id->fns, 0));
+ /* Figure out whether or not FN returns an aggregate. */
+ aggregate_return_p = IS_AGGR_TYPE (TREE_TYPE (result));
+
+ /* If FN returns an aggregate then the caller will always create the
+ temporary (using a TARGET_EXPR) and the call will be the
+ initializing expression for the TARGET_EXPR. If we were just to
+ create a new VAR_DECL here, then the result of this function
+ would be copied (bitwise) into the variable initialized by the
+ TARGET_EXPR. That's incorrect, so we must transform any
+ references to the RESULT into references to the target. */
+ if (aggregate_return_p)
+ {
+ my_friendly_assert (id->target_exprs->elements_used != 0,
+ 20000430);
+ var = TREE_OPERAND (VARRAY_TOP_TREE (id->target_exprs), 0);
+ my_friendly_assert
+ (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (var),
+ TREE_TYPE (result)),
+ 20000430);
+ }
+ /* Otherwise, make an appropriate copy. */
+ else
+ var = copy_decl_for_inlining (result, fn, VARRAY_TREE (id->fns, 0));
+
/* 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. */
/* Build the USE_STMT. */
*use_stmt = build_min_nt (EXPR_STMT, var);
- /* Build the declaration statement. */
- return build_min_nt (DECL_STMT, var);
+ /* Build the declaration statement if FN does not return an
+ aggregate. */
+ if (!aggregate_return_p)
+ return build_min_nt (DECL_STMT, 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;
}
/* Returns non-zero if FN is a function that can be inlined. */
it. */
else if (!DECL_INLINE (fn))
;
- /* If we don't have the function body available, we can't inline
- it. */
- else if (!DECL_SAVED_TREE (fn))
- ;
/* We can't inline varargs functions. */
else if (varargs_function_p (fn))
;
/* All is well. We can inline this function. Traditionally, GCC
- has refused to inline functions using setjmp or alloca, or
- functions whose values are returned in a PARALLEL, and a few
- other such obscure conditions. We are not equally constrained at
- the tree level. */
+ has refused to inline functions using alloca, or functions whose
+ values are returned in a PARALLEL, and a few other such obscure
+ conditions. We are not equally constrained at the tree level. */
else
inlinable = 1;
/* Squirrel away the result so that we don't have to check again. */
DECL_UNINLINABLE (fn) = !inlinable;
+ /* We can inline a template instantiation only if it's fully
+ instantiated. */
+ if (inlinable
+ && DECL_TEMPLATE_INFO (fn)
+ && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
+ {
+ fn = instantiate_decl (fn, /*defer_ok=*/0);
+ inlinable = !TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn));
+ }
+
+ /* If we don't have the function body available, we can't inline
+ it. */
+ if (!DECL_SAVED_TREE (fn))
+ inlinable = 0;
+
/* Don't do recursive inlining, either. We don't record this in
DECL_UNLINABLE; we may be able to inline this function later. */
if (inlinable)
inlinable = 0;
}
- /* We can inline a template instantiation only if its fully
- instantiated. */
- if (inlinable
- && DECL_TEMPLATE_INFO (fn)
- && TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn)))
- {
- fn = instantiate_decl (fn);
- inlinable = !TI_PENDING_TEMPLATE_FLAG (DECL_TEMPLATE_INFO (fn));
- }
-
/* Return the result. */
return inlinable;
}
-/* If *TP is CALL_EXPR, replace it with its inline expansion. */
+/* If *TP is a CALL_EXPR, replace it with its inline expansion. */
static tree
expand_call_inline (tp, walk_subtrees, data)
tree fn;
tree scope_stmt;
tree use_stmt;
+ tree arg_inits;
splay_tree st;
/* See what we've got. */
id = (inline_data *) data;
t = *tp;
- /* Keep track of the last SCOPE_STMT we've seen. */
- if (TREE_CODE (t) == SCOPE_STMT)
- {
- if (SCOPE_STMT_BLOCK (t) && !id->in_target_cleanup_p)
- id->scope_stmt = t;
- return NULL_TREE;
- }
-
/* Recurse, but letting recursive invocations know that we are
inside the body of a TARGET_EXPR. */
if (TREE_CODE (*tp) == TARGET_EXPR)
{
- int i;
+ int i, len = first_rtl_op (TARGET_EXPR);
/* We're walking our own subtrees. */
*walk_subtrees = 0;
+ /* Push *TP on the stack of pending TARGET_EXPRs. */
+ VARRAY_PUSH_TREE (id->target_exprs, *tp);
+
/* Actually walk over them. This loop is the body of
walk_trees, omitting the case where the TARGET_EXPR
itself is handled. */
- for (i = first_rtl_op (TARGET_EXPR) - 1; i >= 0; --i)
+ for (i = 0; i < len; ++i)
{
if (i == 2)
++id->in_target_cleanup_p;
--id->in_target_cleanup_p;
}
+ /* We're done with this TARGET_EXPR now. */
+ VARRAY_POP (id->target_exprs);
+
return NULL_TREE;
}
if (!inlinable_function_p (fn, id))
return NULL_TREE;
- /* Return statements in the function body will be replaced by jumps
- to the RET_LABEL. */
- id->ret_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
- DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
+ /* Set the current filename and line number to the function we are
+ inlining so that when we create new _STMT nodes here they get
+ line numbers corresponding to the function we are calling. We
+ wrap the whole inlined body in an EXPR_WITH_FILE_AND_LINE as well
+ because individual statements don't record the filename. */
+ push_srcloc (fn->decl.filename, fn->decl.linenum);
/* Build a statement-expression containing code to initialize the
arguments, the actual inline expansion of the body, and a label
function call. */
expr = build_min (STMT_EXPR, TREE_TYPE (TREE_TYPE (fn)), NULL_TREE);
- /* Record the function we are about to inline so that we can avoid
- recursing into it. */
- VARRAY_PUSH_TREE (id->fns, fn);
-
/* Local declarations will be replaced by their equivalents in this
map. */
st = id->decl_map;
NULL, NULL);
/* Initialize the parameters. */
- STMT_EXPR_STMT (expr)
- = initialize_inlined_parameters (id, TREE_OPERAND (t, 1));
-
+ arg_inits = initialize_inlined_parameters (id, TREE_OPERAND (t, 1), fn);
+ /* Expand any inlined calls in the initializers. Do this before we
+ push FN on the stack of functions we are inlining; we want to
+ inline calls to FN that appear in the initializers for the
+ parameters. */
+ expand_calls_inline (&arg_inits, id);
+ /* And add them to the tree. */
+ STMT_EXPR_STMT (expr) = chainon (STMT_EXPR_STMT (expr), arg_inits);
+
+ /* Record the function we are about to inline so that we can avoid
+ recursing into it. */
+ VARRAY_PUSH_TREE (id->fns, fn);
+
+ /* Return statements in the function body will be replaced by jumps
+ to the RET_LABEL. */
+ id->ret_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
+ DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
+
/* Create a block to put the parameters in. We have to do this
after the parameters have been remapped because remapping
parameters is different from remapping ordinary variables. */
remap_block (scope_stmt, DECL_ARGUMENTS (fn), id);
TREE_CHAIN (scope_stmt) = STMT_EXPR_STMT (expr);
STMT_EXPR_STMT (expr) = scope_stmt;
- id->scope_stmt = scope_stmt;
+
+ /* Tell the debugging backends that this block represents the
+ outermost scope of the inlined function. */
+ if (SCOPE_STMT_BLOCK (scope_stmt))
+ BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope_stmt)) = DECL_ORIGIN (fn);
/* Declare the return variable for the function. */
STMT_EXPR_STMT (expr)
STMT_EXPR_STMT (expr)
= chainon (STMT_EXPR_STMT (expr), scope_stmt);
+ /* After the body of the function comes the RET_LABEL. This must come
+ before we evaluate the returned value below, because that evalulation
+ may cause RTL to be generated. */
+ STMT_EXPR_STMT (expr)
+ = chainon (STMT_EXPR_STMT (expr),
+ build_min_nt (LABEL_STMT, id->ret_label));
+
/* Finally, mention the returned value so that the value of the
statement-expression is the returned value of the function. */
STMT_EXPR_STMT (expr) = chainon (STMT_EXPR_STMT (expr), use_stmt);
splay_tree_delete (id->decl_map);
id->decl_map = st;
- /* After the body of the function comes the RET_LABEL. */
- STMT_EXPR_STMT (expr)
- = chainon (STMT_EXPR_STMT (expr),
- build_min_nt (LABEL_STMT, id->ret_label));
-
/* The new expression has side-effects if the old one did. */
TREE_SIDE_EFFECTS (expr) = TREE_SIDE_EFFECTS (t);
/*col=*/0);
EXPR_WFL_EMIT_LINE_NOTE (*tp) = 1;
TREE_CHAIN (*tp) = chain;
+ pop_srcloc ();
/* 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
VARRAY_PUSH_TREE (id.fns, s->function_decl);
prev_fn = s->function_decl;
}
+
+ /* Create the stack of TARGET_EXPRs. */
+ VARRAY_TREE_INIT (id.target_exprs, 32, "target_exprs");
+
/* Replace all calls to inline functions with the bodies of those
functions. */
expand_calls_inline (&DECL_SAVED_TREE (fn), &id);
/* Clean up. */
VARRAY_FREE (id.fns);
+ VARRAY_FREE (id.target_exprs);
}
}
int *walk_subtrees ATTRIBUTE_UNUSED;
void *data ATTRIBUTE_UNUSED;
{
- int setjmp_p;
- int longjmp_p;
- int malloc_p;
- int alloca_p;
-
/* We're only interested in FUNCTION_DECLS. */
if (TREE_CODE (*tp) != FUNCTION_DECL)
return NULL_TREE;
- special_function_p (*tp, &setjmp_p, &longjmp_p, &malloc_p, &alloca_p);
-
- return setjmp_p ? *tp : NULL_TREE;
+ return setjmp_call_p (*tp) ? *tp : NULL_TREE;
}
/* Returns non-zero if FN calls `setjmp' or some other function that
!= NULL_TREE);
}
+/* FN is a function that has a complete body. Clone the body as
+ necessary. Returns non-zero if there's no longer any need to
+ process the main body. */
+
+int
+maybe_clone_body (fn)
+ tree fn;
+{
+ inline_data id;
+ tree clone;
+
+ /* We don't clone constructors and destructors under the old ABI. */
+ if (!flag_new_abi)
+ return 0;
+
+ /* We only clone constructors and destructors. */
+ if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
+ && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
+ return 0;
+
+ /* We know that any clones immediately follow FN in the TYPE_METHODS
+ list. */
+ for (clone = TREE_CHAIN (fn);
+ clone && DECL_CLONED_FUNCTION_P (clone);
+ clone = TREE_CHAIN (clone))
+ {
+ tree parm;
+ tree clone_parm;
+ int parmno;
+
+ /* Update CLONE's source position information to match FN's. */
+ DECL_SOURCE_FILE (clone) = DECL_SOURCE_FILE (fn);
+ DECL_SOURCE_LINE (clone) = DECL_SOURCE_LINE (fn);
+ DECL_INLINE (clone) = DECL_INLINE (fn);
+ DECL_THIS_INLINE (clone) = DECL_THIS_INLINE (fn);
+
+ /* Start processing the function. */
+ push_to_top_level ();
+ start_function (NULL_TREE, clone, NULL_TREE, SF_PRE_PARSED);
+ store_parm_decls ();
+
+ /* Just clone the body, as if we were making an inline call.
+ But, remap the parameters in the callee to the parameters of
+ caller. If there's an in-charge parameter, map it to an
+ appropriate constant. */
+ memset (&id, 0, sizeof (id));
+ VARRAY_TREE_INIT (id.fns, 2, "fns");
+ VARRAY_PUSH_TREE (id.fns, clone);
+ VARRAY_PUSH_TREE (id.fns, fn);
+
+ /* Remap the parameters. */
+ id.decl_map = splay_tree_new (splay_tree_compare_pointers,
+ NULL, NULL);
+ for (parmno = 0,
+ parm = DECL_ARGUMENTS (fn),
+ clone_parm = DECL_ARGUMENTS (clone);
+ parm;
+ ++parmno,
+ parm = TREE_CHAIN (parm))
+ {
+ /* Map the in-charge parameter to an appropriate constant. */
+ if (DECL_HAS_IN_CHARGE_PARM_P (fn) && parmno == 1)
+ {
+ tree in_charge;
+ in_charge = in_charge_arg_for_name (DECL_NAME (clone));
+ splay_tree_insert (id.decl_map,
+ (splay_tree_key) parm,
+ (splay_tree_key) in_charge);
+ }
+ /* Map other parameters to their equivalents in the cloned
+ function. */
+ else
+ {
+ splay_tree_insert (id.decl_map,
+ (splay_tree_key) parm,
+ (splay_tree_value) clone_parm);
+ clone_parm = TREE_CHAIN (clone_parm);
+ }
+ }
+
+ /* Actually copy the body. */
+ TREE_CHAIN (DECL_SAVED_TREE (clone)) = copy_body (&id);
+
+ /* Clean up. */
+ splay_tree_delete (id.decl_map);
+ VARRAY_FREE (id.fns);
+
+ /* Now, expand this function into RTL, if appropriate. */
+ current_function_name_declared = 1;
+ expand_body (finish_function (0));
+ pop_from_top_level ();
+ }
+
+ /* We don't need to process the original function any further. */
+ return 1;
+}
OSDN Git Service
