#include "config.h"
#include "system.h"
#include "tree.h"
#include "cp-tree.h"
#include "rtl.h"
#include "insn-config.h"
#include "input.h"
#include "integrate.h"
#include "toplev.h"
#include "varray.h"
#include "params.h"
#include "hashtab.h"
#include "debug.h"
#include "tree-inline.h"
#include "flags.h"
static tree calls_setjmp_r PARAMS ((tree *, int *, void *));
static void update_cloned_parm PARAMS ((tree, tree));
static void dump_function PARAMS ((enum tree_dump_index, tree));
void
optimize_function (fn)
tree fn;
{
dump_function (TDI_original, fn);
++function_depth;
if (flag_inline_trees
&& !DECL_THUNK_P (fn))
{
optimize_inline_calls (fn);
dump_function (TDI_inlined, fn);
}
--function_depth;
dump_function (TDI_optimized, fn);
}
static tree
calls_setjmp_r (tp, walk_subtrees, data)
tree *tp;
int *walk_subtrees ATTRIBUTE_UNUSED;
void *data ATTRIBUTE_UNUSED;
{
if (TREE_CODE (*tp) != FUNCTION_DECL)
return NULL_TREE;
return setjmp_call_p (*tp) ? *tp : NULL_TREE;
}
int
calls_setjmp_p (fn)
tree fn;
{
return walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
calls_setjmp_r,
NULL) != NULL_TREE;
}
static void
update_cloned_parm (parm, cloned_parm)
tree parm;
tree cloned_parm;
{
DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
TREE_USED (cloned_parm) = TREE_USED (parm);
DECL_NAME (cloned_parm) = DECL_NAME (parm);
DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
}
int
maybe_alias_body (fn, clone)
tree fn;
tree clone;
{
extern FILE *asm_out_file;
#ifdef ASM_MAYBE_ALIAS_BODY
ASM_MAYBE_ALIAS_BODY (asm_out_file, fn, clone);
#endif
return 0;
}
int
maybe_thunk_body (fn)
tree fn;
{
tree call, clone, expr_stmt, fn_parm, fn_parm_typelist, last_arg, start;
int parmno, vtt_parmno;
if (flag_apple_kext || flag_clone_structors)
return 0;
if (TREE_ASM_WRITTEN (fn))
return 1;
last_arg = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fn)));
if ( ! VOID_TYPE_P (TREE_VALUE (last_arg)))
return 0;
for (fn_parm = DECL_ARGUMENTS( fn); fn_parm; fn_parm = TREE_CHAIN (fn_parm))
if (TREE_CODE (fn_parm) == VECTOR_TYPE)
return 0;
clone = TREE_CHAIN (fn);
if (!clone || ! DECL_CLONED_FUNCTION_P (clone))
return 0;
if ( ! TREE_CHAIN (clone))
return 0;
if (DECL_NUM_STMTS (fn) < 2)
return 0;
if (flag_debug_only_used_symbols
&& DECL_VIRTUAL_P (fn)
&& DECL_DESTRUCTOR_P (fn)
&& DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
{
}
else
DECL_ABSTRACT (fn) = 0;
for (vtt_parmno = -1, parmno = 0, fn_parm = DECL_ARGUMENTS (fn);
fn_parm;
++parmno, fn_parm = TREE_CHAIN (fn_parm))
{
if (DECL_ARTIFICIAL (fn_parm) && DECL_NAME (fn_parm) == vtt_parm_identifier)
{
vtt_parmno = parmno;
break;
}
}
for (clone = start = TREE_CHAIN (fn);
clone && DECL_CLONED_FUNCTION_P (clone);
clone = TREE_CHAIN (clone))
{
tree clone_parm, parmlist;
if (maybe_alias_body (fn, clone))
continue;
if (DECL_SAVED_TREE (clone) || TREE_ASM_WRITTEN (clone))
continue;
push_to_top_level ();
start_function (NULL_TREE, clone, NULL_TREE, SF_PRE_PARSED);
for (parmno = 0,
parmlist = NULL,
fn_parm = DECL_ARGUMENTS (fn),
fn_parm_typelist = TYPE_ARG_TYPES (TREE_TYPE (fn)),
clone_parm = DECL_ARGUMENTS (clone);
fn_parm;
++parmno,
fn_parm = TREE_CHAIN (fn_parm))
{
if (parmno == vtt_parmno && ! DECL_HAS_VTT_PARM_P (clone))
{
tree typed_null_pointer_node = copy_node (null_pointer_node);
my_friendly_assert (fn_parm_typelist, 0);
TREE_TYPE (typed_null_pointer_node) = TREE_VALUE (fn_parm_typelist);
parmlist = tree_cons (NULL, typed_null_pointer_node, parmlist);
}
else if (parmno == 1 && DECL_HAS_IN_CHARGE_PARM_P (fn))
{
tree in_charge = copy_node (in_charge_arg_for_name (DECL_NAME (clone)));
parmlist = tree_cons (NULL, in_charge, parmlist);
}
else
{
my_friendly_assert (clone_parm, 0);
DECL_ABSTRACT_ORIGIN (clone_parm) = NULL;
parmlist = tree_cons (NULL, clone_parm, parmlist);
clone_parm = TREE_CHAIN (clone_parm);
}
if (fn_parm_typelist)
fn_parm_typelist = TREE_CHAIN (fn_parm_typelist);
}
parmlist = nreverse (parmlist);
mark_used (fn);
call = build_function_call (fn, parmlist);
expr_stmt = build_stmt (EXPR_STMT, call);
add_stmt (expr_stmt);
finish_function (0);
DECL_ABSTRACT_ORIGIN (clone) = NULL;
expand_body (clone);
pop_from_top_level ();
}
return 1;
}
int
maybe_clone_body (fn)
tree fn;
{
tree clone;
int first = 1;
if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
&& !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
return 0;
(*debug_hooks->deferred_inline_function) (fn);
for (clone = TREE_CHAIN (fn);
clone && DECL_CLONED_FUNCTION_P (clone);
clone = TREE_CHAIN (clone), first = 0)
{
tree parm;
tree clone_parm;
DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
DECL_INLINE (clone) = DECL_INLINE (fn);
DID_INLINE_FUNC (clone) = DID_INLINE_FUNC (fn);
DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
DECL_COMDAT (clone) = DECL_COMDAT (fn);
DECL_WEAK (clone) = DECL_WEAK (fn);
DECL_ONE_ONLY (clone) = DECL_ONE_ONLY (fn);
DECL_SECTION_NAME (clone) = DECL_SECTION_NAME (fn);
DECL_USE_TEMPLATE (clone) = DECL_USE_TEMPLATE (fn);
DECL_EXTERNAL (clone) = DECL_EXTERNAL (fn);
DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
DECL_PRIVATE_EXTERN (clone) = DECL_PRIVATE_EXTERN (fn);
DECL_COALESCED (clone) = DECL_COALESCED (fn);
parm = DECL_ARGUMENTS (fn);
clone_parm = DECL_ARGUMENTS (clone);
update_cloned_parm (parm, clone_parm);
parm = TREE_CHAIN (parm);
clone_parm = TREE_CHAIN (clone_parm);
if (DECL_HAS_IN_CHARGE_PARM_P (fn))
parm = TREE_CHAIN (parm);
if (DECL_HAS_VTT_PARM_P (fn))
parm = TREE_CHAIN (parm);
if (DECL_HAS_VTT_PARM_P (clone))
clone_parm = TREE_CHAIN (clone_parm);
for (; parm;
parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
{
update_cloned_parm (parm, clone_parm);
if (!first)
TREE_USED (clone_parm) = 1;
}
}
if (maybe_thunk_body (fn))
return 0;
for (clone = TREE_CHAIN (fn);
clone && DECL_CLONED_FUNCTION_P (clone);
clone = TREE_CHAIN (clone))
{
tree parm;
tree clone_parm;
int parmno;
splay_tree decl_map;
push_to_top_level ();
start_function (NULL_TREE, clone, NULL_TREE, SF_PRE_PARSED);
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))
{
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 (decl_map,
(splay_tree_key) parm,
(splay_tree_value) in_charge);
}
else if (DECL_ARTIFICIAL (parm)
&& DECL_NAME (parm) == vtt_parm_identifier)
{
if (DECL_HAS_VTT_PARM_P (clone))
{
DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
splay_tree_insert (decl_map,
(splay_tree_key) parm,
(splay_tree_value) clone_parm);
clone_parm = TREE_CHAIN (clone_parm);
}
else
{
splay_tree_insert (decl_map,
(splay_tree_key) parm,
(splay_tree_value) null_pointer_node);
}
}
else
{
splay_tree_insert (decl_map,
(splay_tree_key) parm,
(splay_tree_value) clone_parm);
clone_parm = TREE_CHAIN (clone_parm);
}
}
clone_body (clone, fn, decl_map);
DECL_NUM_STMTS (clone) = DECL_NUM_STMTS (fn);
splay_tree_delete (decl_map);
finish_function (0);
BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
expand_body (clone);
pop_from_top_level ();
}
return 1;
}
static void
dump_function (phase, fn)
enum tree_dump_index phase;
tree fn;
{
FILE *stream;
int flags;
stream = dump_begin (phase, &flags);
if (stream)
{
fprintf (stream, "\n;; Function %s",
decl_as_string (fn, TFF_DECL_SPECIFIERS));
fprintf (stream, " (%s)\n",
decl_as_string (DECL_ASSEMBLER_NAME (fn), 0));
fprintf (stream, ";; enabled by -%s\n", dump_flag_name (phase));
fprintf (stream, "\n");
dump_node (fn, TDF_SLIM | flags, stream);
dump_end (phase, stream);
}
}