/* Pass computing data for optimizing stdarg functions.
- Copyright (C) 2004-2015 Free Software Foundation, Inc.
+ Copyright (C) 2004-2020 Free Software Foundation, Inc.
Contributed by Jakub Jelinek <jakub@redhat.com>
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
-#include "hash-set.h"
-#include "machmode.h"
-#include "vec.h"
-#include "double-int.h"
-#include "input.h"
-#include "alias.h"
-#include "symtab.h"
-#include "wide-int.h"
-#include "inchash.h"
+#include "backend.h"
+#include "target.h"
#include "tree.h"
+#include "gimple.h"
+#include "tree-pass.h"
+#include "ssa.h"
+#include "gimple-pretty-print.h"
#include "fold-const.h"
-#include "hard-reg-set.h"
-#include "input.h"
-#include "function.h"
#include "langhooks.h"
-#include "gimple-pretty-print.h"
-#include "target.h"
-#include "bitmap.h"
-#include "predict.h"
-#include "dominance.h"
-#include "cfg.h"
-#include "basic-block.h"
-#include "tree-ssa-alias.h"
-#include "internal-fn.h"
-#include "gimple-expr.h"
-#include "is-a.h"
-#include "gimple.h"
#include "gimple-iterator.h"
#include "gimple-walk.h"
-#include "gimple-ssa.h"
-#include "tree-phinodes.h"
-#include "ssa-iterators.h"
-#include "stringpool.h"
-#include "tree-ssanames.h"
-#include "sbitmap.h"
-#include "tree-pass.h"
+#include "gimplify.h"
+#include "tree-into-ssa.h"
+#include "tree-cfg.h"
#include "tree-stdarg.h"
/* A simple pass that attempts to optimize stdarg functions on architectures
static bool
reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
{
- vec<edge> stack = vNULL;
+ auto_vec<edge, 10> stack;
edge e;
edge_iterator ei;
- sbitmap visited;
bool ret;
if (va_arg_bb == va_start_bb)
if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
return false;
- visited = sbitmap_alloc (last_basic_block_for_fn (cfun));
+ auto_sbitmap visited (last_basic_block_for_fn (cfun));
bitmap_clear (visited);
ret = true;
}
}
- stack.release ();
- sbitmap_free (visited);
return ret;
}
bool gpr_p)
{
tree lhs, orig_lhs;
- gimple stmt;
+ gimple *stmt;
unsigned HOST_WIDE_INT ret = 0, val, counter_val;
unsigned int max_size;
if (bitmap_bit_p (va_list_vars, SSA_NAME_VERSION (var)))
return var;
}
- else if (TREE_CODE (var) == VAR_DECL)
+ else if (VAR_P (var))
{
if (bitmap_bit_p (va_list_vars, DECL_UID (var) + num_ssa_names))
return var;
return false;
base = get_base_address (ap);
- if (TREE_CODE (base) != VAR_DECL
+ if (!VAR_P (base)
|| !bitmap_bit_p (si->va_list_vars, DECL_UID (base) + num_ssa_names))
return false;
static bool
va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem)
{
- if (TREE_CODE (ap) != VAR_DECL
+ if (!VAR_P (ap)
|| !bitmap_bit_p (si->va_list_vars, DECL_UID (ap) + num_ssa_names))
return false;
{
unsigned HOST_WIDE_INT increment;
- if (TREE_CODE (ap) != VAR_DECL
+ if (!VAR_P (ap)
|| !bitmap_bit_p (si->va_list_vars, DECL_UID (ap) + num_ssa_names))
return false;
for (gimple_stmt_iterator i = gsi_start_bb (bb); !gsi_end_p (i);
gsi_next (&i))
{
- gimple stmt = gsi_stmt (i);
+ gimple *stmt = gsi_stmt (i);
tree use;
ssa_op_iter iter;
SSA_NAME_VERSION (lhs)))
continue;
- if (TREE_CODE (lhs) == VAR_DECL
+ if (VAR_P (lhs)
&& bitmap_bit_p (si->va_list_vars,
DECL_UID (lhs) + num_ssa_names))
continue;
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
{
- gimple stmt = gsi_stmt (i);
+ gimple *stmt = gsi_stmt (i);
tree callee, ap;
if (!is_gimple_call (stmt))
callee = gimple_call_fndecl (stmt);
if (!callee
- || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
+ || !fndecl_built_in_p (callee, BUILT_IN_NORMAL))
continue;
switch (DECL_FUNCTION_CODE (callee))
}
if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
!= TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (fun->decl))
- || TREE_CODE (ap) != VAR_DECL)
+ || !VAR_P (ap))
{
va_list_escapes = true;
break;
!gsi_end_p (i) && !va_list_escapes;
gsi_next (&i))
{
- gimple stmt = gsi_stmt (i);
+ gimple *stmt = gsi_stmt (i);
/* Don't look at __builtin_va_{start,end}, they are ok. */
if (is_gimple_call (stmt))
tree callee = gimple_call_fndecl (stmt);
if (callee
- && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
- && (DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_START
- || DECL_FUNCTION_CODE (callee) == BUILT_IN_VA_END))
+ && (fndecl_built_in_p (callee, BUILT_IN_VA_START)
+ || fndecl_built_in_p (callee, BUILT_IN_VA_END)))
continue;
}
}
}
+/* Expand IFN_VA_ARGs in FUN. */
+
+static void
+expand_ifn_va_arg_1 (function *fun)
+{
+ bool modified = false;
+ basic_block bb;
+ gimple_stmt_iterator i;
+ location_t saved_location;
+
+ FOR_EACH_BB_FN (bb, fun)
+ for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
+ {
+ gimple *stmt = gsi_stmt (i);
+ tree ap, aptype, expr, lhs, type;
+ gimple_seq pre = NULL, post = NULL;
+
+ if (!gimple_call_internal_p (stmt, IFN_VA_ARG))
+ continue;
+
+ modified = true;
+
+ type = TREE_TYPE (TREE_TYPE (gimple_call_arg (stmt, 1)));
+ ap = gimple_call_arg (stmt, 0);
+ aptype = TREE_TYPE (gimple_call_arg (stmt, 2));
+ gcc_assert (POINTER_TYPE_P (aptype));
+
+ /* Balanced out the &ap, usually added by build_va_arg. */
+ ap = build2 (MEM_REF, TREE_TYPE (aptype), ap,
+ build_int_cst (aptype, 0));
+
+ push_gimplify_context (false);
+ saved_location = input_location;
+ input_location = gimple_location (stmt);
+
+ /* Make it easier for the backends by protecting the valist argument
+ from multiple evaluations. */
+ gimplify_expr (&ap, &pre, &post, is_gimple_min_lval, fb_lvalue);
+
+ expr = targetm.gimplify_va_arg_expr (ap, type, &pre, &post);
+
+ lhs = gimple_call_lhs (stmt);
+ if (lhs != NULL_TREE)
+ {
+ unsigned int nargs = gimple_call_num_args (stmt);
+ gcc_assert (useless_type_conversion_p (TREE_TYPE (lhs), type));
+
+ if (nargs == 4)
+ {
+ /* We've transported the size of with WITH_SIZE_EXPR here as
+ the last argument of the internal fn call. Now reinstate
+ it. */
+ tree size = gimple_call_arg (stmt, nargs - 1);
+ expr = build2 (WITH_SIZE_EXPR, TREE_TYPE (expr), expr, size);
+ }
+
+ /* We use gimplify_assign here, rather than gimple_build_assign,
+ because gimple_assign knows how to deal with variable-sized
+ types. */
+ gimplify_assign (lhs, expr, &pre);
+ }
+ else
+ gimplify_and_add (expr, &pre);
+
+ input_location = saved_location;
+ pop_gimplify_context (NULL);
+
+ gimple_seq_add_seq (&pre, post);
+ update_modified_stmts (pre);
+
+ /* Add the sequence after IFN_VA_ARG. This splits the bb right
+ after IFN_VA_ARG, and adds the sequence in one or more new bbs
+ inbetween. */
+ gimple_find_sub_bbs (pre, &i);
+
+ /* Remove the IFN_VA_ARG gimple_call. It's the last stmt in the
+ bb. */
+ unlink_stmt_vdef (stmt);
+ release_ssa_name_fn (fun, gimple_vdef (stmt));
+ gsi_remove (&i, true);
+ gcc_assert (gsi_end_p (i));
+
+ /* We're walking here into the bbs which contain the expansion of
+ IFN_VA_ARG, and will not contain another IFN_VA_ARG that needs
+ expanding. We could try to skip walking these bbs, perhaps by
+ walking backwards over gimples and bbs. */
+ break;
+ }
+
+ if (!modified)
+ return;
+
+ free_dominance_info (CDI_DOMINATORS);
+ update_ssa (TODO_update_ssa);
+}
+
+/* Expand IFN_VA_ARGs in FUN, if necessary. */
+
+static void
+expand_ifn_va_arg (function *fun)
+{
+ if ((fun->curr_properties & PROP_gimple_lva) == 0)
+ expand_ifn_va_arg_1 (fun);
+
+ if (flag_checking)
+ {
+ basic_block bb;
+ gimple_stmt_iterator i;
+ FOR_EACH_BB_FN (bb, fun)
+ for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
+ gcc_assert (!gimple_call_internal_p (gsi_stmt (i), IFN_VA_ARG));
+ }
+}
+
namespace {
const pass_data pass_data_stdarg =
OPTGROUP_NONE, /* optinfo_flags */
TV_NONE, /* tv_id */
( PROP_cfg | PROP_ssa ), /* properties_required */
- 0, /* properties_provided */
+ PROP_gimple_lva, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
0, /* todo_flags_finish */
{}
/* opt_pass methods: */
- virtual bool gate (function *fun)
+ virtual bool gate (function *)
{
- return (flag_stdarg_opt
-#ifdef ACCEL_COMPILER
- /* Disable for GCC5 in the offloading compilers, as
- va_list and gpr/fpr counter fields are not merged.
- In GCC6 when stdarg is lowered late this shouldn't be
- an issue. */
- && !in_lto_p
-#endif
- /* This optimization is only for stdarg functions. */
- && fun->stdarg != 0);
+ /* Always run this pass, in order to expand va_arg internal_fns. We
+ also need to do that if fun->stdarg == 0, because a va_arg may also
+ occur in a function without varargs, f.i. if when passing a va_list to
+ another function. */
+ return true;
}
virtual unsigned int execute (function *);
unsigned int
pass_stdarg::execute (function *fun)
{
- optimize_va_list_gpr_fpr_size (fun);
+ /* TODO: Postpone expand_ifn_va_arg till after
+ optimize_va_list_gpr_fpr_size. */
+ expand_ifn_va_arg (fun);
+
+ if (flag_stdarg_opt
+ /* This optimization is only for stdarg functions. */
+ && fun->stdarg != 0)
+ optimize_va_list_gpr_fpr_size (fun);
return 0;
}
{
return new pass_stdarg (ctxt);
}
+
+namespace {
+
+const pass_data pass_data_lower_vaarg =
+{
+ GIMPLE_PASS, /* type */
+ "lower_vaarg", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ TV_NONE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ PROP_gimple_lva, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_lower_vaarg : public gimple_opt_pass
+{
+public:
+ pass_lower_vaarg (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_vaarg, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ virtual bool gate (function *)
+ {
+ return (cfun->curr_properties & PROP_gimple_lva) == 0;
+ }
+
+ virtual unsigned int execute (function *);
+
+}; // class pass_lower_vaarg
+
+unsigned int
+pass_lower_vaarg::execute (function *fun)
+{
+ expand_ifn_va_arg (fun);
+ return 0;
+}
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_lower_vaarg (gcc::context *ctxt)
+{
+ return new pass_lower_vaarg (ctxt);
+}
projects / thirdparty / gcc.git / blobdiff