| /* Pass computing data for optimizing stdarg functions. |
| Copyright (C) 2004-2021 Free Software Foundation, Inc. |
| Contributed by Jakub Jelinek <jakub@redhat.com> |
| |
| This file is part of GCC. |
| |
| GCC 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 3, or (at your option) |
| any later version. |
| |
| GCC 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 GCC; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.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 "langhooks.h" |
| #include "gimple-iterator.h" |
| #include "gimple-walk.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 |
| that need to save register arguments to stack on entry to stdarg functions. |
| If the function doesn't use any va_start macros, no registers need to |
| be saved. If va_start macros are used, the va_list variables don't escape |
| the function, it is only necessary to save registers that will be used |
| in va_arg macros. E.g. if va_arg is only used with integral types |
| in the function, floating point registers don't need to be saved, etc. */ |
| |
| |
| /* Return true if basic block VA_ARG_BB is dominated by VA_START_BB and |
| is executed at most as many times as VA_START_BB. */ |
| |
| static bool |
| reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb) |
| { |
| auto_vec<edge, 10> stack; |
| edge e; |
| edge_iterator ei; |
| bool ret; |
| |
| if (va_arg_bb == va_start_bb) |
| return true; |
| |
| if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb)) |
| return false; |
| |
| auto_sbitmap visited (last_basic_block_for_fn (cfun)); |
| bitmap_clear (visited); |
| ret = true; |
| |
| FOR_EACH_EDGE (e, ei, va_arg_bb->preds) |
| stack.safe_push (e); |
| |
| while (! stack.is_empty ()) |
| { |
| basic_block src; |
| |
| e = stack.pop (); |
| src = e->src; |
| |
| if (e->flags & EDGE_COMPLEX) |
| { |
| ret = false; |
| break; |
| } |
| |
| if (src == va_start_bb) |
| continue; |
| |
| /* va_arg_bb can be executed more times than va_start_bb. */ |
| if (src == va_arg_bb) |
| { |
| ret = false; |
| break; |
| } |
| |
| gcc_assert (src != ENTRY_BLOCK_PTR_FOR_FN (cfun)); |
| |
| if (! bitmap_bit_p (visited, src->index)) |
| { |
| bitmap_set_bit (visited, src->index); |
| FOR_EACH_EDGE (e, ei, src->preds) |
| stack.safe_push (e); |
| } |
| } |
| |
| return ret; |
| } |
| |
| |
| /* For statement COUNTER = RHS, if RHS is COUNTER + constant, |
| return constant, otherwise return HOST_WIDE_INT_M1U. |
| GPR_P is true if this is GPR counter. */ |
| |
| static unsigned HOST_WIDE_INT |
| va_list_counter_bump (struct stdarg_info *si, tree counter, tree rhs, |
| bool gpr_p) |
| { |
| tree lhs, orig_lhs; |
| gimple *stmt; |
| unsigned HOST_WIDE_INT ret = 0, val, counter_val; |
| unsigned int max_size; |
| |
| if (si->offsets == NULL) |
| { |
| unsigned int i; |
| |
| si->offsets = XNEWVEC (int, num_ssa_names); |
| for (i = 0; i < num_ssa_names; ++i) |
| si->offsets[i] = -1; |
| } |
| |
| counter_val = gpr_p ? cfun->va_list_gpr_size : cfun->va_list_fpr_size; |
| max_size = gpr_p ? VA_LIST_MAX_GPR_SIZE : VA_LIST_MAX_FPR_SIZE; |
| orig_lhs = lhs = rhs; |
| while (lhs) |
| { |
| enum tree_code rhs_code; |
| tree rhs1; |
| |
| if (si->offsets[SSA_NAME_VERSION (lhs)] != -1) |
| { |
| if (counter_val >= max_size) |
| { |
| ret = max_size; |
| break; |
| } |
| |
| ret -= counter_val - si->offsets[SSA_NAME_VERSION (lhs)]; |
| break; |
| } |
| |
| stmt = SSA_NAME_DEF_STMT (lhs); |
| |
| if (!is_gimple_assign (stmt) || gimple_assign_lhs (stmt) != lhs) |
| return HOST_WIDE_INT_M1U; |
| |
| rhs_code = gimple_assign_rhs_code (stmt); |
| rhs1 = gimple_assign_rhs1 (stmt); |
| if ((get_gimple_rhs_class (rhs_code) == GIMPLE_SINGLE_RHS |
| || gimple_assign_cast_p (stmt)) |
| && TREE_CODE (rhs1) == SSA_NAME) |
| { |
| lhs = rhs1; |
| continue; |
| } |
| |
| if ((rhs_code == POINTER_PLUS_EXPR |
| || rhs_code == PLUS_EXPR) |
| && TREE_CODE (rhs1) == SSA_NAME |
| && tree_fits_uhwi_p (gimple_assign_rhs2 (stmt))) |
| { |
| ret += tree_to_uhwi (gimple_assign_rhs2 (stmt)); |
| lhs = rhs1; |
| continue; |
| } |
| |
| if (rhs_code == ADDR_EXPR |
| && TREE_CODE (TREE_OPERAND (rhs1, 0)) == MEM_REF |
| && TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0)) == SSA_NAME |
| && tree_fits_uhwi_p (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1))) |
| { |
| ret += tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1)); |
| lhs = TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0); |
| continue; |
| } |
| |
| if (get_gimple_rhs_class (rhs_code) != GIMPLE_SINGLE_RHS) |
| return HOST_WIDE_INT_M1U; |
| |
| rhs = gimple_assign_rhs1 (stmt); |
| if (TREE_CODE (counter) != TREE_CODE (rhs)) |
| return HOST_WIDE_INT_M1U; |
| |
| if (TREE_CODE (counter) == COMPONENT_REF) |
| { |
| if (get_base_address (counter) != get_base_address (rhs) |
| || TREE_CODE (TREE_OPERAND (rhs, 1)) != FIELD_DECL |
| || TREE_OPERAND (counter, 1) != TREE_OPERAND (rhs, 1)) |
| return HOST_WIDE_INT_M1U; |
| } |
| else if (counter != rhs) |
| return HOST_WIDE_INT_M1U; |
| |
| lhs = NULL; |
| } |
| |
| lhs = orig_lhs; |
| val = ret + counter_val; |
| while (lhs) |
| { |
| enum tree_code rhs_code; |
| tree rhs1; |
| |
| if (si->offsets[SSA_NAME_VERSION (lhs)] != -1) |
| break; |
| |
| if (val >= max_size) |
| si->offsets[SSA_NAME_VERSION (lhs)] = max_size; |
| else |
| si->offsets[SSA_NAME_VERSION (lhs)] = val; |
| |
| stmt = SSA_NAME_DEF_STMT (lhs); |
| |
| rhs_code = gimple_assign_rhs_code (stmt); |
| rhs1 = gimple_assign_rhs1 (stmt); |
| if ((get_gimple_rhs_class (rhs_code) == GIMPLE_SINGLE_RHS |
| || gimple_assign_cast_p (stmt)) |
| && TREE_CODE (rhs1) == SSA_NAME) |
| { |
| lhs = rhs1; |
| continue; |
| } |
| |
| if ((rhs_code == POINTER_PLUS_EXPR |
| || rhs_code == PLUS_EXPR) |
| && TREE_CODE (rhs1) == SSA_NAME |
| && tree_fits_uhwi_p (gimple_assign_rhs2 (stmt))) |
| { |
| val -= tree_to_uhwi (gimple_assign_rhs2 (stmt)); |
| lhs = rhs1; |
| continue; |
| } |
| |
| if (rhs_code == ADDR_EXPR |
| && TREE_CODE (TREE_OPERAND (rhs1, 0)) == MEM_REF |
| && TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0)) == SSA_NAME |
| && tree_fits_uhwi_p (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1))) |
| { |
| val -= tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1)); |
| lhs = TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0); |
| continue; |
| } |
| |
| lhs = NULL; |
| } |
| |
| return ret; |
| } |
| |
| |
| /* Called by walk_tree to look for references to va_list variables. */ |
| |
| static tree |
| find_va_list_reference (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, |
| void *data) |
| { |
| bitmap va_list_vars = (bitmap) ((struct walk_stmt_info *) data)->info; |
| tree var = *tp; |
| |
| if (TREE_CODE (var) == SSA_NAME) |
| { |
| if (bitmap_bit_p (va_list_vars, SSA_NAME_VERSION (var))) |
| return var; |
| } |
| else if (VAR_P (var)) |
| { |
| if (bitmap_bit_p (va_list_vars, DECL_UID (var) + num_ssa_names)) |
| return var; |
| } |
| |
| return NULL_TREE; |
| } |
| |
| |
| /* Helper function of va_list_counter_struct_op. Compute |
| cfun->va_list_{g,f}pr_size. AP is a va_list GPR/FPR counter, |
| if WRITE_P is true, seen in AP = VAR, otherwise seen in VAR = AP |
| statement. GPR_P is true if AP is a GPR counter, false if it is |
| a FPR counter. */ |
| |
| static void |
| va_list_counter_op (struct stdarg_info *si, tree ap, tree var, bool gpr_p, |
| bool write_p) |
| { |
| unsigned HOST_WIDE_INT increment; |
| |
| if (si->compute_sizes < 0) |
| { |
| si->compute_sizes = 0; |
| if (si->va_start_count == 1 |
| && reachable_at_most_once (si->bb, si->va_start_bb)) |
| si->compute_sizes = 1; |
| |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| fprintf (dump_file, |
| "bb%d will %sbe executed at most once for each va_start " |
| "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ", |
| si->va_start_bb->index); |
| } |
| |
| if (write_p |
| && si->compute_sizes |
| && (increment = va_list_counter_bump (si, ap, var, gpr_p)) + 1 > 1) |
| { |
| if (gpr_p && cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE) |
| { |
| cfun->va_list_gpr_size += increment; |
| return; |
| } |
| |
| if (!gpr_p && cfun->va_list_fpr_size + increment < VA_LIST_MAX_FPR_SIZE) |
| { |
| cfun->va_list_fpr_size += increment; |
| return; |
| } |
| } |
| |
| if (write_p || !si->compute_sizes) |
| { |
| if (gpr_p) |
| cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; |
| else |
| cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; |
| } |
| } |
| |
| |
| /* If AP is a va_list GPR/FPR counter, compute cfun->va_list_{g,f}pr_size. |
| If WRITE_P is true, AP has been seen in AP = VAR assignment, if WRITE_P |
| is false, AP has been seen in VAR = AP assignment. |
| Return true if the AP = VAR (resp. VAR = AP) statement is a recognized |
| va_arg operation that doesn't cause the va_list variable to escape |
| current function. */ |
| |
| static bool |
| va_list_counter_struct_op (struct stdarg_info *si, tree ap, tree var, |
| bool write_p) |
| { |
| tree base; |
| |
| if (TREE_CODE (ap) != COMPONENT_REF |
| || TREE_CODE (TREE_OPERAND (ap, 1)) != FIELD_DECL) |
| return false; |
| |
| if (TREE_CODE (var) != SSA_NAME |
| || bitmap_bit_p (si->va_list_vars, SSA_NAME_VERSION (var))) |
| return false; |
| |
| base = get_base_address (ap); |
| if (!VAR_P (base) |
| || !bitmap_bit_p (si->va_list_vars, DECL_UID (base) + num_ssa_names)) |
| return false; |
| |
| if (TREE_OPERAND (ap, 1) == va_list_gpr_counter_field) |
| va_list_counter_op (si, ap, var, true, write_p); |
| else if (TREE_OPERAND (ap, 1) == va_list_fpr_counter_field) |
| va_list_counter_op (si, ap, var, false, write_p); |
| |
| return true; |
| } |
| |
| |
| /* Check for TEM = AP. Return true if found and the caller shouldn't |
| search for va_list references in the statement. */ |
| |
| static bool |
| va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem) |
| { |
| if (!VAR_P (ap) |
| || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap) + num_ssa_names)) |
| return false; |
| |
| if (TREE_CODE (tem) != SSA_NAME |
| || bitmap_bit_p (si->va_list_vars, SSA_NAME_VERSION (tem))) |
| return false; |
| |
| if (si->compute_sizes < 0) |
| { |
| si->compute_sizes = 0; |
| if (si->va_start_count == 1 |
| && reachable_at_most_once (si->bb, si->va_start_bb)) |
| si->compute_sizes = 1; |
| |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| fprintf (dump_file, |
| "bb%d will %sbe executed at most once for each va_start " |
| "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ", |
| si->va_start_bb->index); |
| } |
| |
| /* For void * or char * va_list types, there is just one counter. |
| If va_arg is used in a loop, we don't know how many registers need |
| saving. */ |
| if (! si->compute_sizes) |
| return false; |
| |
| if (va_list_counter_bump (si, ap, tem, true) == HOST_WIDE_INT_M1U) |
| return false; |
| |
| /* Note the temporary, as we need to track whether it doesn't escape |
| the current function. */ |
| bitmap_set_bit (si->va_list_escape_vars, SSA_NAME_VERSION (tem)); |
| |
| return true; |
| } |
| |
| |
| /* Check for: |
| tem1 = AP; |
| TEM2 = tem1 + CST; |
| AP = TEM2; |
| sequence and update cfun->va_list_gpr_size. Return true if found. */ |
| |
| static bool |
| va_list_ptr_write (struct stdarg_info *si, tree ap, tree tem2) |
| { |
| unsigned HOST_WIDE_INT increment; |
| |
| if (!VAR_P (ap) |
| || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap) + num_ssa_names)) |
| return false; |
| |
| if (TREE_CODE (tem2) != SSA_NAME |
| || bitmap_bit_p (si->va_list_vars, SSA_NAME_VERSION (tem2))) |
| return false; |
| |
| if (si->compute_sizes <= 0) |
| return false; |
| |
| increment = va_list_counter_bump (si, ap, tem2, true); |
| if (increment + 1 <= 1) |
| return false; |
| |
| if (cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE) |
| cfun->va_list_gpr_size += increment; |
| else |
| cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; |
| |
| return true; |
| } |
| |
| |
| /* If RHS is X, (some type *) X or X + CST for X a temporary variable |
| containing value of some va_list variable plus optionally some constant, |
| either set si->va_list_escapes or add LHS to si->va_list_escape_vars, |
| depending whether LHS is a function local temporary. */ |
| |
| static void |
| check_va_list_escapes (struct stdarg_info *si, tree lhs, tree rhs) |
| { |
| if (! POINTER_TYPE_P (TREE_TYPE (rhs))) |
| return; |
| |
| if (TREE_CODE (rhs) == SSA_NAME) |
| { |
| if (! bitmap_bit_p (si->va_list_escape_vars, SSA_NAME_VERSION (rhs))) |
| return; |
| } |
| else if (TREE_CODE (rhs) == ADDR_EXPR |
| && TREE_CODE (TREE_OPERAND (rhs, 0)) == MEM_REF |
| && TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)) == SSA_NAME) |
| { |
| tree ptr = TREE_OPERAND (TREE_OPERAND (rhs, 0), 0); |
| if (! bitmap_bit_p (si->va_list_escape_vars, SSA_NAME_VERSION (ptr))) |
| return; |
| } |
| else |
| return; |
| |
| if (TREE_CODE (lhs) != SSA_NAME) |
| { |
| si->va_list_escapes = true; |
| return; |
| } |
| |
| if (si->compute_sizes < 0) |
| { |
| si->compute_sizes = 0; |
| if (si->va_start_count == 1 |
| && reachable_at_most_once (si->bb, si->va_start_bb)) |
| si->compute_sizes = 1; |
| |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| fprintf (dump_file, |
| "bb%d will %sbe executed at most once for each va_start " |
| "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ", |
| si->va_start_bb->index); |
| } |
| |
| /* For void * or char * va_list types, there is just one counter. |
| If va_arg is used in a loop, we don't know how many registers need |
| saving. */ |
| if (! si->compute_sizes) |
| { |
| si->va_list_escapes = true; |
| return; |
| } |
| |
| if (va_list_counter_bump (si, si->va_start_ap, lhs, true) |
| == HOST_WIDE_INT_M1U) |
| { |
| si->va_list_escapes = true; |
| return; |
| } |
| |
| bitmap_set_bit (si->va_list_escape_vars, SSA_NAME_VERSION (lhs)); |
| } |
| |
| |
| /* Check all uses of temporaries from si->va_list_escape_vars bitmap. |
| Return true if va_list might be escaping. */ |
| |
| static bool |
| check_all_va_list_escapes (struct stdarg_info *si) |
| { |
| basic_block bb; |
| |
| FOR_EACH_BB_FN (bb, cfun) |
| { |
| for (gphi_iterator i = gsi_start_phis (bb); !gsi_end_p (i); |
| gsi_next (&i)) |
| { |
| tree lhs; |
| use_operand_p uop; |
| ssa_op_iter soi; |
| gphi *phi = i.phi (); |
| |
| lhs = PHI_RESULT (phi); |
| if (virtual_operand_p (lhs) |
| || bitmap_bit_p (si->va_list_escape_vars, |
| SSA_NAME_VERSION (lhs))) |
| continue; |
| |
| FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE) |
| { |
| tree rhs = USE_FROM_PTR (uop); |
| if (TREE_CODE (rhs) == SSA_NAME |
| && bitmap_bit_p (si->va_list_escape_vars, |
| SSA_NAME_VERSION (rhs))) |
| { |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fputs ("va_list escapes in ", dump_file); |
| print_gimple_stmt (dump_file, phi, 0, dump_flags); |
| fputc ('\n', dump_file); |
| } |
| return true; |
| } |
| } |
| } |
| |
| for (gimple_stmt_iterator i = gsi_start_bb (bb); !gsi_end_p (i); |
| gsi_next (&i)) |
| { |
| gimple *stmt = gsi_stmt (i); |
| tree use; |
| ssa_op_iter iter; |
| |
| if (is_gimple_debug (stmt)) |
| continue; |
| |
| FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES) |
| { |
| if (! bitmap_bit_p (si->va_list_escape_vars, |
| SSA_NAME_VERSION (use))) |
| continue; |
| |
| if (is_gimple_assign (stmt)) |
| { |
| tree rhs = gimple_assign_rhs1 (stmt); |
| enum tree_code rhs_code = gimple_assign_rhs_code (stmt); |
| |
| /* x = *ap_temp; */ |
| if (rhs_code == MEM_REF |
| && TREE_OPERAND (rhs, 0) == use |
| && TYPE_SIZE_UNIT (TREE_TYPE (rhs)) |
| && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (rhs))) |
| && si->offsets[SSA_NAME_VERSION (use)] != -1) |
| { |
| unsigned HOST_WIDE_INT gpr_size; |
| tree access_size = TYPE_SIZE_UNIT (TREE_TYPE (rhs)); |
| |
| gpr_size = si->offsets[SSA_NAME_VERSION (use)] |
| + tree_to_shwi (TREE_OPERAND (rhs, 1)) |
| + tree_to_uhwi (access_size); |
| if (gpr_size >= VA_LIST_MAX_GPR_SIZE) |
| cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; |
| else if (gpr_size > cfun->va_list_gpr_size) |
| cfun->va_list_gpr_size = gpr_size; |
| continue; |
| } |
| |
| /* va_arg sequences may contain |
| other_ap_temp = ap_temp; |
| other_ap_temp = ap_temp + constant; |
| other_ap_temp = (some_type *) ap_temp; |
| ap = ap_temp; |
| statements. */ |
| if (rhs == use |
| && ((rhs_code == POINTER_PLUS_EXPR |
| && (TREE_CODE (gimple_assign_rhs2 (stmt)) |
| == INTEGER_CST)) |
| || gimple_assign_cast_p (stmt) |
| || (get_gimple_rhs_class (rhs_code) |
| == GIMPLE_SINGLE_RHS))) |
| { |
| tree lhs = gimple_assign_lhs (stmt); |
| |
| if (TREE_CODE (lhs) == SSA_NAME |
| && bitmap_bit_p (si->va_list_escape_vars, |
| SSA_NAME_VERSION (lhs))) |
| continue; |
| |
| if (VAR_P (lhs) |
| && bitmap_bit_p (si->va_list_vars, |
| DECL_UID (lhs) + num_ssa_names)) |
| continue; |
| } |
| else if (rhs_code == ADDR_EXPR |
| && TREE_CODE (TREE_OPERAND (rhs, 0)) == MEM_REF |
| && TREE_OPERAND (TREE_OPERAND (rhs, 0), 0) == use) |
| { |
| tree lhs = gimple_assign_lhs (stmt); |
| |
| if (bitmap_bit_p (si->va_list_escape_vars, |
| SSA_NAME_VERSION (lhs))) |
| continue; |
| } |
| } |
| |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fputs ("va_list escapes in ", dump_file); |
| print_gimple_stmt (dump_file, stmt, 0, dump_flags); |
| fputc ('\n', dump_file); |
| } |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /* Optimize FUN->va_list_gpr_size and FUN->va_list_fpr_size. */ |
| |
| static void |
| optimize_va_list_gpr_fpr_size (function *fun) |
| { |
| basic_block bb; |
| bool va_list_escapes = false; |
| bool va_list_simple_ptr; |
| struct stdarg_info si; |
| struct walk_stmt_info wi; |
| const char *funcname = NULL; |
| tree cfun_va_list; |
| |
| fun->va_list_gpr_size = 0; |
| fun->va_list_fpr_size = 0; |
| memset (&si, 0, sizeof (si)); |
| si.va_list_vars = BITMAP_ALLOC (NULL); |
| si.va_list_escape_vars = BITMAP_ALLOC (NULL); |
| |
| if (dump_file) |
| funcname = lang_hooks.decl_printable_name (current_function_decl, 2); |
| |
| cfun_va_list = targetm.fn_abi_va_list (fun->decl); |
| va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list) |
| && (TREE_TYPE (cfun_va_list) == void_type_node |
| || TREE_TYPE (cfun_va_list) == char_type_node); |
| gcc_assert (is_gimple_reg_type (cfun_va_list) == va_list_simple_ptr); |
| |
| FOR_EACH_BB_FN (bb, fun) |
| { |
| gimple_stmt_iterator i; |
| |
| for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i)) |
| { |
| gimple *stmt = gsi_stmt (i); |
| tree callee, ap; |
| |
| if (!is_gimple_call (stmt)) |
| continue; |
| |
| callee = gimple_call_fndecl (stmt); |
| if (!callee |
| || !fndecl_built_in_p (callee, BUILT_IN_NORMAL)) |
| continue; |
| |
| switch (DECL_FUNCTION_CODE (callee)) |
| { |
| case BUILT_IN_VA_START: |
| break; |
| /* If old style builtins are used, don't optimize anything. */ |
| case BUILT_IN_SAVEREGS: |
| case BUILT_IN_NEXT_ARG: |
| va_list_escapes = true; |
| continue; |
| default: |
| continue; |
| } |
| |
| si.va_start_count++; |
| ap = gimple_call_arg (stmt, 0); |
| |
| if (TREE_CODE (ap) != ADDR_EXPR) |
| { |
| va_list_escapes = true; |
| break; |
| } |
| ap = TREE_OPERAND (ap, 0); |
| if (TREE_CODE (ap) == ARRAY_REF) |
| { |
| if (! integer_zerop (TREE_OPERAND (ap, 1))) |
| { |
| va_list_escapes = true; |
| break; |
| } |
| ap = TREE_OPERAND (ap, 0); |
| } |
| if (TYPE_MAIN_VARIANT (TREE_TYPE (ap)) |
| != TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (fun->decl)) |
| || !VAR_P (ap)) |
| { |
| va_list_escapes = true; |
| break; |
| } |
| |
| if (is_global_var (ap)) |
| { |
| va_list_escapes = true; |
| break; |
| } |
| |
| bitmap_set_bit (si.va_list_vars, DECL_UID (ap) + num_ssa_names); |
| |
| /* VA_START_BB and VA_START_AP will be only used if there is just |
| one va_start in the function. */ |
| si.va_start_bb = bb; |
| si.va_start_ap = ap; |
| } |
| |
| if (va_list_escapes) |
| break; |
| } |
| |
| /* If there were no va_start uses in the function, there is no need to |
| save anything. */ |
| if (si.va_start_count == 0) |
| goto finish; |
| |
| /* If some va_list arguments weren't local, we can't optimize. */ |
| if (va_list_escapes) |
| goto finish; |
| |
| /* For void * or char * va_list, something useful can be done only |
| if there is just one va_start. */ |
| if (va_list_simple_ptr && si.va_start_count > 1) |
| { |
| va_list_escapes = true; |
| goto finish; |
| } |
| |
| /* For struct * va_list, if the backend didn't tell us what the counter fields |
| are, there is nothing more we can do. */ |
| if (!va_list_simple_ptr |
| && va_list_gpr_counter_field == NULL_TREE |
| && va_list_fpr_counter_field == NULL_TREE) |
| { |
| va_list_escapes = true; |
| goto finish; |
| } |
| |
| /* For void * or char * va_list there is just one counter |
| (va_list itself). Use VA_LIST_GPR_SIZE for it. */ |
| if (va_list_simple_ptr) |
| fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; |
| |
| calculate_dominance_info (CDI_DOMINATORS); |
| memset (&wi, 0, sizeof (wi)); |
| wi.info = si.va_list_vars; |
| |
| FOR_EACH_BB_FN (bb, fun) |
| { |
| si.compute_sizes = -1; |
| si.bb = bb; |
| |
| /* For va_list_simple_ptr, we have to check PHI nodes too. We treat |
| them as assignments for the purpose of escape analysis. This is |
| not needed for non-simple va_list because virtual phis don't perform |
| any real data movement. Also, check PHI nodes for taking address of |
| the va_list vars. */ |
| tree lhs, rhs; |
| use_operand_p uop; |
| ssa_op_iter soi; |
| |
| for (gphi_iterator i = gsi_start_phis (bb); !gsi_end_p (i); |
| gsi_next (&i)) |
| { |
| gphi *phi = i.phi (); |
| lhs = PHI_RESULT (phi); |
| |
| if (virtual_operand_p (lhs)) |
| continue; |
| |
| if (va_list_simple_ptr) |
| { |
| FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE) |
| { |
| rhs = USE_FROM_PTR (uop); |
| if (va_list_ptr_read (&si, rhs, lhs)) |
| continue; |
| else if (va_list_ptr_write (&si, lhs, rhs)) |
| continue; |
| else |
| check_va_list_escapes (&si, lhs, rhs); |
| |
| if (si.va_list_escapes) |
| { |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fputs ("va_list escapes in ", dump_file); |
| print_gimple_stmt (dump_file, phi, 0, dump_flags); |
| fputc ('\n', dump_file); |
| } |
| va_list_escapes = true; |
| } |
| } |
| } |
| |
| for (unsigned j = 0; !va_list_escapes |
| && j < gimple_phi_num_args (phi); ++j) |
| if ((!va_list_simple_ptr |
| || TREE_CODE (gimple_phi_arg_def (phi, j)) != SSA_NAME) |
| && walk_tree (gimple_phi_arg_def_ptr (phi, j), |
| find_va_list_reference, &wi, NULL)) |
| { |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fputs ("va_list escapes in ", dump_file); |
| print_gimple_stmt (dump_file, phi, 0, dump_flags); |
| fputc ('\n', dump_file); |
| } |
| va_list_escapes = true; |
| } |
| } |
| |
| for (gimple_stmt_iterator i = gsi_start_bb (bb); |
| !gsi_end_p (i) && !va_list_escapes; |
| gsi_next (&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 |
| && (fndecl_built_in_p (callee, BUILT_IN_VA_START) |
| || fndecl_built_in_p (callee, BUILT_IN_VA_END))) |
| continue; |
| } |
| |
| if (is_gimple_assign (stmt)) |
| { |
| lhs = gimple_assign_lhs (stmt); |
| rhs = gimple_assign_rhs1 (stmt); |
| |
| if (va_list_simple_ptr) |
| { |
| if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) |
| == GIMPLE_SINGLE_RHS) |
| { |
| /* Check for ap ={v} {}. */ |
| if (TREE_CLOBBER_P (rhs)) |
| continue; |
| |
| /* Check for tem = ap. */ |
| else if (va_list_ptr_read (&si, rhs, lhs)) |
| continue; |
| |
| /* Check for the last insn in: |
| tem1 = ap; |
| tem2 = tem1 + CST; |
| ap = tem2; |
| sequence. */ |
| else if (va_list_ptr_write (&si, lhs, rhs)) |
| continue; |
| } |
| |
| if ((gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR |
| && TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST) |
| || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)) |
| || (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) |
| == GIMPLE_SINGLE_RHS)) |
| check_va_list_escapes (&si, lhs, rhs); |
| } |
| else |
| { |
| if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) |
| == GIMPLE_SINGLE_RHS) |
| { |
| /* Check for ap ={v} {}. */ |
| if (TREE_CLOBBER_P (rhs)) |
| continue; |
| |
| /* Check for ap[0].field = temp. */ |
| else if (va_list_counter_struct_op (&si, lhs, rhs, true)) |
| continue; |
| |
| /* Check for temp = ap[0].field. */ |
| else if (va_list_counter_struct_op (&si, rhs, lhs, |
| false)) |
| continue; |
| } |
| |
| /* Do any architecture specific checking. */ |
| if (targetm.stdarg_optimize_hook |
| && targetm.stdarg_optimize_hook (&si, stmt)) |
| continue; |
| } |
| } |
| else if (is_gimple_debug (stmt)) |
| continue; |
| |
| /* All other uses of va_list are either va_copy (that is not handled |
| in this optimization), taking address of va_list variable or |
| passing va_list to other functions (in that case va_list might |
| escape the function and therefore va_start needs to set it up |
| fully), or some unexpected use of va_list. None of these should |
| happen in a gimplified VA_ARG_EXPR. */ |
| if (si.va_list_escapes |
| || walk_gimple_op (stmt, find_va_list_reference, &wi)) |
| { |
| if (dump_file && (dump_flags & TDF_DETAILS)) |
| { |
| fputs ("va_list escapes in ", dump_file); |
| print_gimple_stmt (dump_file, stmt, 0, dump_flags); |
| fputc ('\n', dump_file); |
| } |
| va_list_escapes = true; |
| } |
| } |
| |
| if (va_list_escapes) |
| break; |
| } |
| |
| if (! va_list_escapes |
| && va_list_simple_ptr |
| && ! bitmap_empty_p (si.va_list_escape_vars) |
| && check_all_va_list_escapes (&si)) |
| va_list_escapes = true; |
| |
| finish: |
| if (va_list_escapes) |
| { |
| fun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE; |
| fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE; |
| } |
| BITMAP_FREE (si.va_list_vars); |
| BITMAP_FREE (si.va_list_escape_vars); |
| free (si.offsets); |
| if (dump_file) |
| { |
| fprintf (dump_file, "%s: va_list escapes %d, needs to save ", |
| funcname, (int) va_list_escapes); |
| if (fun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE) |
| fputs ("all", dump_file); |
| else |
| fprintf (dump_file, "%d", cfun->va_list_gpr_size); |
| fputs (" GPR units and ", dump_file); |
| if (fun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE) |
| fputs ("all", dump_file); |
| else |
| fprintf (dump_file, "%d", cfun->va_list_fpr_size); |
| fputs (" FPR units.\n", dump_file); |
| } |
| } |
| |
| /* 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 = |
| { |
| GIMPLE_PASS, /* type */ |
| "stdarg", /* 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_stdarg : public gimple_opt_pass |
| { |
| public: |
| pass_stdarg (gcc::context *ctxt) |
| : gimple_opt_pass (pass_data_stdarg, ctxt) |
| {} |
| |
| /* opt_pass methods: */ |
| virtual bool gate (function *) |
| { |
| /* 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 *); |
| |
| }; // class pass_stdarg |
| |
| unsigned int |
| pass_stdarg::execute (function *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; |
| } |
| |
| } // anon namespace |
| |
| gimple_opt_pass * |
| make_pass_stdarg (gcc::context *ctxt) |
| { |
| 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); |
| } |