From patchwork Wed Nov 8 20:54:43 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Martin Jambor X-Patchwork-Id: 835985 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-466330-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="tGBPfI+P"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3yXJTS5FpMz9s7B for ; Thu, 9 Nov 2017 07:55:04 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:mime-version:content-type; q=dns; s=default; b=hnq/ngfPHXjhCtqhr39Mu775CPhCIdvM50mIQdX+9M3pum+Zqx BpIOR83vQiopzQU0T+0p7SC4qzBLR2u0Xm22AfmR85KeGToFwDwBOv4RvKg/zLkA dAbAQ06g8suXS1BPLqeRvl2KcScUAAZD0m8GXYqZdzgyQSjg2kKeowlr8= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:mime-version:content-type; s= default; bh=l+6XLUUmeUfPwFp0VWoOrXFMNCY=; b=tGBPfI+P83gQ6i1zCFBU 8FcaBjO8FTFP3tx61cO8LL+dK3x9Krgq7YIse5011Q04Kc3gT/ZqfC8vguaJKXc4 nnIcDpfOwvcIGPltEAdu1FjCHNjr/yToWdLFHNd+bSCCC962oeAuRawnC6npdVgV /wAEf+98aN7axQJIumBrl0A= Received: (qmail 26725 invoked by alias); 8 Nov 2017 20:54:54 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 26716 invoked by uid 89); 8 Nov 2017 20:54:53 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=ham version=3.3.2 spammy=rop, H*Ad:U*jh, first X-HELO: mx2.suse.de Received: from mx2.suse.de (HELO mx2.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 08 Nov 2017 20:54:46 +0000 Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 14637AD0B for ; Wed, 8 Nov 2017 20:54:44 +0000 (UTC) Date: Wed, 8 Nov 2017 21:54:43 +0100 From: Martin Jambor To: GCC Patches Cc: Jan Hubicka Subject: [PATCH 1/2] Moving parameter manipulation into its own file Message-ID: <20171108205442.jeosnobdino4fde7@virgil.suse.cz> MIME-Version: 1.0 Content-Disposition: inline User-Agent: NeoMutt/20170912 (1.9.0) X-IsSubscribed: yes Hi, the following patch moves all function and call parameter manipulation (as opposed to analysis) data structures and functions from ipa-prop.h and ipa-prop.c to new files ipa-param-manipulation.h and ipa-param-manipulation.c respectively. It does no functional change. Please look at the followup patch if you'd like to see where I am heading with this. While I am willing to hold up the followup patch for GCC 9, I would like to commit this now because it increases modularity in an area where it is needed. Bootstrapped and teste on x86_64-linux. OK for trunk? Martin 2017-08-23 Martin Jambor * ipa-param-manipulation.c: New file. * ipa-param-manipulation.h: Likewise. * Makefile.in (OBJS): Add ipa-param-manipulation.o. (PLUGIN_HEADERS): Addded ipa-param-manipulation.h * ipa-param.h (ipa_parm_op): Moved to ipa-param-manipulation.h. (ipa_parm_adjustment): Likewise. (ipa_parm_adjustment_vec): Likewise. (ipa_get_vector_of_formal_parms): Moved declaration to ipa-param-manipulation.h. (ipa_get_vector_of_formal_parm_types): Likewise. (ipa_modify_formal_parameters): Likewise. (ipa_modify_call_arguments): Likewise. (ipa_combine_adjustments): Likewise. (ipa_dump_param_adjustments): Likewise. (ipa_modify_expr): Likewise. (ipa_get_adjustment_candidate): Likewise. * ipa-prop.c (ipa_get_vector_of_formal_parms): Moved to ipa-param-manipulation.c. (ipa_get_vector_of_formal_parm_types): Likewise. (ipa_modify_formal_parameters): Likewise. (ipa_modify_call_arguments): Likewise. (ipa_modify_expr): Likewise. (get_ssa_base_param): Likewise. (ipa_get_adjustment_candidate): Likewise. (index_in_adjustments_multiple_times_p): Likewise. (ipa_combine_adjustments): Likewise. (ipa_dump_param_adjustments): Likewise. * tree-sra.c: Also include ipa-param-manipulation.h * omp-simd-clone.c: Include ipa-param-manipulation.h instead of ipa-param.h. --- gcc/Makefile.in | 3 +- gcc/ipa-param-manipulation.c | 767 +++++++++++++++++++++++++++++++++++++++++++ gcc/ipa-param-manipulation.h | 120 +++++++ gcc/ipa-prop.c | 725 ---------------------------------------- gcc/ipa-prop.h | 94 ------ gcc/omp-simd-clone.c | 2 +- gcc/tree-sra.c | 1 + 7 files changed, 891 insertions(+), 821 deletions(-) create mode 100644 gcc/ipa-param-manipulation.c create mode 100644 gcc/ipa-param-manipulation.h diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 51968e4a66f..1bb1d6ec0ff 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1354,6 +1354,7 @@ OBJS = \ ipa-predicate.o \ ipa-profile.o \ ipa-prop.o \ + ipa-param-manipulation.o \ ipa-pure-const.o \ ipa-icf.o \ ipa-icf-gimple.o \ @@ -3467,7 +3468,7 @@ PLUGIN_HEADERS = $(TREE_H) $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(C_COMMON_H) c-family/c-objc.h $(C_PRETTY_PRINT_H) \ tree-iterator.h $(PLUGIN_H) $(TREE_SSA_H) langhooks.h incpath.h debug.h \ $(EXCEPT_H) tree-ssa-sccvn.h real.h output.h $(IPA_UTILS_H) \ - $(C_PRAGMA_H) $(CPPLIB_H) $(FUNCTION_H) \ + ipa-param-manipulation.h $(C_PRAGMA_H) $(CPPLIB_H) $(FUNCTION_H) \ cppdefault.h flags.h $(MD5_H) params.def params.h params-enum.h \ prefix.h tree-inline.h $(GIMPLE_PRETTY_PRINT_H) realmpfr.h \ $(IPA_PROP_H) $(TARGET_H) $(RTL_H) $(TM_P_H) $(CFGLOOP_H) $(EMIT_RTL_H) \ diff --git a/gcc/ipa-param-manipulation.c b/gcc/ipa-param-manipulation.c new file mode 100644 index 00000000000..bedd201f6dd --- /dev/null +++ b/gcc/ipa-param-manipulation.c @@ -0,0 +1,767 @@ +/* Manipulation of formal and actual parameters of functions and function + calls. + Copyright (C) 2017 Free Software Foundation, Inc. + +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 +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "backend.h" +#include "rtl.h" +#include "tree.h" +#include "gimple.h" +#include "ssa.h" +#include "cgraph.h" +#include "fold-const.h" +#include "stor-layout.h" +#include "gimplify.h" +#include "gimple-iterator.h" +#include "gimplify-me.h" +#include "tree-dfa.h" +#include "ipa-param-manipulation.h" +#include "print-tree.h" +#include "gimple-pretty-print.h" +#include "builtins.h" + +/* Return a heap allocated vector containing formal parameters of FNDECL. */ + +vec +ipa_get_vector_of_formal_parms (tree fndecl) +{ + vec args; + int count; + tree parm; + + gcc_assert (!flag_wpa); + count = 0; + for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) + count++; + + args.create (count); + for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) + args.quick_push (parm); + + return args; +} + +/* Return a heap allocated vector containing types of formal parameters of + function type FNTYPE. */ + +vec +ipa_get_vector_of_formal_parm_types (tree fntype) +{ + vec types; + int count = 0; + tree t; + + for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) + count++; + + types.create (count); + for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) + types.quick_push (TREE_VALUE (t)); + + return types; +} + +/* Modify the function declaration FNDECL and its type according to the plan in + ADJUSTMENTS. It also sets base fields of individual adjustments structures + to reflect the actual parameters being modified which are determined by the + base_index field. */ + +void +ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments) +{ + vec oparms = ipa_get_vector_of_formal_parms (fndecl); + tree orig_type = TREE_TYPE (fndecl); + tree old_arg_types = TYPE_ARG_TYPES (orig_type); + + /* The following test is an ugly hack, some functions simply don't have any + arguments in their type. This is probably a bug but well... */ + bool care_for_types = (old_arg_types != NULL_TREE); + bool last_parm_void; + vec otypes; + if (care_for_types) + { + last_parm_void = (TREE_VALUE (tree_last (old_arg_types)) + == void_type_node); + otypes = ipa_get_vector_of_formal_parm_types (orig_type); + if (last_parm_void) + gcc_assert (oparms.length () + 1 == otypes.length ()); + else + gcc_assert (oparms.length () == otypes.length ()); + } + else + { + last_parm_void = false; + otypes.create (0); + } + + int len = adjustments.length (); + tree *link = &DECL_ARGUMENTS (fndecl); + tree new_arg_types = NULL; + for (int i = 0; i < len; i++) + { + struct ipa_parm_adjustment *adj; + gcc_assert (link); + + adj = &adjustments[i]; + tree parm; + if (adj->op == IPA_PARM_OP_NEW) + parm = NULL; + else + parm = oparms[adj->base_index]; + adj->base = parm; + + if (adj->op == IPA_PARM_OP_COPY) + { + if (care_for_types) + new_arg_types = tree_cons (NULL_TREE, otypes[adj->base_index], + new_arg_types); + *link = parm; + link = &DECL_CHAIN (parm); + } + else if (adj->op != IPA_PARM_OP_REMOVE) + { + tree new_parm; + tree ptype; + + if (adj->by_ref) + ptype = build_pointer_type (adj->type); + else + { + ptype = adj->type; + if (is_gimple_reg_type (ptype) + && TYPE_MODE (ptype) != BLKmode) + { + unsigned malign = GET_MODE_ALIGNMENT (TYPE_MODE (ptype)); + if (TYPE_ALIGN (ptype) != malign) + ptype = build_aligned_type (ptype, malign); + } + } + + if (care_for_types) + new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types); + + new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE, + ptype); + const char *prefix = adj->arg_prefix ? adj->arg_prefix : "SYNTH"; + DECL_NAME (new_parm) = create_tmp_var_name (prefix); + DECL_ARTIFICIAL (new_parm) = 1; + DECL_ARG_TYPE (new_parm) = ptype; + DECL_CONTEXT (new_parm) = fndecl; + TREE_USED (new_parm) = 1; + DECL_IGNORED_P (new_parm) = 1; + layout_decl (new_parm, 0); + + if (adj->op == IPA_PARM_OP_NEW) + adj->base = NULL; + else + adj->base = parm; + adj->new_decl = new_parm; + + *link = new_parm; + link = &DECL_CHAIN (new_parm); + } + } + + *link = NULL_TREE; + + tree new_reversed = NULL; + if (care_for_types) + { + new_reversed = nreverse (new_arg_types); + if (last_parm_void) + { + if (new_reversed) + TREE_CHAIN (new_arg_types) = void_list_node; + else + new_reversed = void_list_node; + } + } + + /* Use copy_node to preserve as much as possible from original type + (debug info, attribute lists etc.) + Exception is METHOD_TYPEs must have THIS argument. + When we are asked to remove it, we need to build new FUNCTION_TYPE + instead. */ + tree new_type = NULL; + if (TREE_CODE (orig_type) != METHOD_TYPE + || (adjustments[0].op == IPA_PARM_OP_COPY + && adjustments[0].base_index == 0)) + { + new_type = build_distinct_type_copy (orig_type); + TYPE_ARG_TYPES (new_type) = new_reversed; + } + else + { + new_type + = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type), + new_reversed)); + TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type); + DECL_VINDEX (fndecl) = NULL_TREE; + } + + /* When signature changes, we need to clear builtin info. */ + if (DECL_BUILT_IN (fndecl)) + { + DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN; + DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0; + } + + TREE_TYPE (fndecl) = new_type; + DECL_VIRTUAL_P (fndecl) = 0; + DECL_LANG_SPECIFIC (fndecl) = NULL; + otypes.release (); + oparms.release (); +} + +/* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS. + If this is a directly recursive call, CS must be NULL. Otherwise it must + contain the corresponding call graph edge. */ + +void +ipa_modify_call_arguments (struct cgraph_edge *cs, gcall *stmt, + ipa_parm_adjustment_vec adjustments) +{ + struct cgraph_node *current_node = cgraph_node::get (current_function_decl); + vec vargs; + vec **debug_args = NULL; + gcall *new_stmt; + gimple_stmt_iterator gsi, prev_gsi; + tree callee_decl; + int i, len; + + len = adjustments.length (); + vargs.create (len); + callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl; + current_node->remove_stmt_references (stmt); + + gsi = gsi_for_stmt (stmt); + prev_gsi = gsi; + gsi_prev (&prev_gsi); + for (i = 0; i < len; i++) + { + struct ipa_parm_adjustment *adj; + + adj = &adjustments[i]; + + if (adj->op == IPA_PARM_OP_COPY) + { + tree arg = gimple_call_arg (stmt, adj->base_index); + + vargs.quick_push (arg); + } + else if (adj->op != IPA_PARM_OP_REMOVE) + { + tree expr, base, off; + location_t loc; + unsigned int deref_align = 0; + bool deref_base = false; + + /* We create a new parameter out of the value of the old one, we can + do the following kind of transformations: + + - A scalar passed by reference is converted to a scalar passed by + value. (adj->by_ref is false and the type of the original + actual argument is a pointer to a scalar). + + - A part of an aggregate is passed instead of the whole aggregate. + The part can be passed either by value or by reference, this is + determined by value of adj->by_ref. Moreover, the code below + handles both situations when the original aggregate is passed by + value (its type is not a pointer) and when it is passed by + reference (it is a pointer to an aggregate). + + When the new argument is passed by reference (adj->by_ref is true) + it must be a part of an aggregate and therefore we form it by + simply taking the address of a reference inside the original + aggregate. */ + + gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0); + base = gimple_call_arg (stmt, adj->base_index); + loc = DECL_P (base) ? DECL_SOURCE_LOCATION (base) + : EXPR_LOCATION (base); + + if (TREE_CODE (base) != ADDR_EXPR + && POINTER_TYPE_P (TREE_TYPE (base))) + off = build_int_cst (adj->alias_ptr_type, + adj->offset / BITS_PER_UNIT); + else + { + HOST_WIDE_INT base_offset; + tree prev_base; + bool addrof; + + if (TREE_CODE (base) == ADDR_EXPR) + { + base = TREE_OPERAND (base, 0); + addrof = true; + } + else + addrof = false; + prev_base = base; + base = get_addr_base_and_unit_offset (base, &base_offset); + /* Aggregate arguments can have non-invariant addresses. */ + if (!base) + { + base = build_fold_addr_expr (prev_base); + off = build_int_cst (adj->alias_ptr_type, + adj->offset / BITS_PER_UNIT); + } + else if (TREE_CODE (base) == MEM_REF) + { + if (!addrof) + { + deref_base = true; + deref_align = TYPE_ALIGN (TREE_TYPE (base)); + } + off = build_int_cst (adj->alias_ptr_type, + base_offset + + adj->offset / BITS_PER_UNIT); + off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1), + off); + base = TREE_OPERAND (base, 0); + } + else + { + off = build_int_cst (adj->alias_ptr_type, + base_offset + + adj->offset / BITS_PER_UNIT); + base = build_fold_addr_expr (base); + } + } + + if (!adj->by_ref) + { + tree type = adj->type; + unsigned int align; + unsigned HOST_WIDE_INT misalign; + + if (deref_base) + { + align = deref_align; + misalign = 0; + } + else + { + get_pointer_alignment_1 (base, &align, &misalign); + if (TYPE_ALIGN (type) > align) + align = TYPE_ALIGN (type); + } + misalign += (offset_int::from (wi::to_wide (off), + SIGNED).to_short_addr () + * BITS_PER_UNIT); + misalign = misalign & (align - 1); + if (misalign != 0) + align = least_bit_hwi (misalign); + if (align < TYPE_ALIGN (type)) + type = build_aligned_type (type, align); + base = force_gimple_operand_gsi (&gsi, base, + true, NULL, true, GSI_SAME_STMT); + expr = fold_build2_loc (loc, MEM_REF, type, base, off); + REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse; + /* If expr is not a valid gimple call argument emit + a load into a temporary. */ + if (is_gimple_reg_type (TREE_TYPE (expr))) + { + gimple *tem = gimple_build_assign (NULL_TREE, expr); + if (gimple_in_ssa_p (cfun)) + { + gimple_set_vuse (tem, gimple_vuse (stmt)); + expr = make_ssa_name (TREE_TYPE (expr), tem); + } + else + expr = create_tmp_reg (TREE_TYPE (expr)); + gimple_assign_set_lhs (tem, expr); + gsi_insert_before (&gsi, tem, GSI_SAME_STMT); + } + } + else + { + expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off); + REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse; + expr = build_fold_addr_expr (expr); + expr = force_gimple_operand_gsi (&gsi, expr, + true, NULL, true, GSI_SAME_STMT); + } + vargs.quick_push (expr); + } + if (adj->op != IPA_PARM_OP_COPY && MAY_HAVE_DEBUG_STMTS) + { + unsigned int ix; + tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg; + gimple *def_temp; + + arg = gimple_call_arg (stmt, adj->base_index); + if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg))) + { + if (!fold_convertible_p (TREE_TYPE (origin), arg)) + continue; + arg = fold_convert_loc (gimple_location (stmt), + TREE_TYPE (origin), arg); + } + if (debug_args == NULL) + debug_args = decl_debug_args_insert (callee_decl); + for (ix = 0; vec_safe_iterate (*debug_args, ix, &ddecl); ix += 2) + if (ddecl == origin) + { + ddecl = (**debug_args)[ix + 1]; + break; + } + if (ddecl == NULL) + { + ddecl = make_node (DEBUG_EXPR_DECL); + DECL_ARTIFICIAL (ddecl) = 1; + TREE_TYPE (ddecl) = TREE_TYPE (origin); + SET_DECL_MODE (ddecl, DECL_MODE (origin)); + + vec_safe_push (*debug_args, origin); + vec_safe_push (*debug_args, ddecl); + } + def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg), stmt); + gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT); + } + } + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "replacing stmt:"); + print_gimple_stmt (dump_file, gsi_stmt (gsi), 0); + } + + new_stmt = gimple_build_call_vec (callee_decl, vargs); + vargs.release (); + if (gimple_call_lhs (stmt)) + gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt)); + + gimple_set_block (new_stmt, gimple_block (stmt)); + if (gimple_has_location (stmt)) + gimple_set_location (new_stmt, gimple_location (stmt)); + gimple_call_set_chain (new_stmt, gimple_call_chain (stmt)); + gimple_call_copy_flags (new_stmt, stmt); + if (gimple_in_ssa_p (cfun)) + { + gimple_set_vuse (new_stmt, gimple_vuse (stmt)); + if (gimple_vdef (stmt)) + { + gimple_set_vdef (new_stmt, gimple_vdef (stmt)); + SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt; + } + } + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "with stmt:"); + print_gimple_stmt (dump_file, new_stmt, 0); + fprintf (dump_file, "\n"); + } + gsi_replace (&gsi, new_stmt, true); + if (cs) + cs->set_call_stmt (new_stmt); + do + { + current_node->record_stmt_references (gsi_stmt (gsi)); + gsi_prev (&gsi); + } + while (gsi_stmt (gsi) != gsi_stmt (prev_gsi)); +} + +/* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */ + +static bool +index_in_adjustments_multiple_times_p (int base_index, + ipa_parm_adjustment_vec adjustments) +{ + int i, len = adjustments.length (); + bool one = false; + + for (i = 0; i < len; i++) + { + struct ipa_parm_adjustment *adj; + adj = &adjustments[i]; + + if (adj->base_index == base_index) + { + if (one) + return true; + else + one = true; + } + } + return false; +} + +/* Return adjustments that should have the same effect on function parameters + and call arguments as if they were first changed according to adjustments in + INNER and then by adjustments in OUTER. */ + +ipa_parm_adjustment_vec +ipa_combine_adjustments (ipa_parm_adjustment_vec inner, + ipa_parm_adjustment_vec outer) +{ + int i, outlen = outer.length (); + int inlen = inner.length (); + int removals = 0; + ipa_parm_adjustment_vec adjustments, tmp; + + tmp.create (inlen); + for (i = 0; i < inlen; i++) + { + struct ipa_parm_adjustment *n; + n = &inner[i]; + + if (n->op == IPA_PARM_OP_REMOVE) + removals++; + else + { + /* FIXME: Handling of new arguments are not implemented yet. */ + gcc_assert (n->op != IPA_PARM_OP_NEW); + tmp.quick_push (*n); + } + } + + adjustments.create (outlen + removals); + for (i = 0; i < outlen; i++) + { + struct ipa_parm_adjustment r; + struct ipa_parm_adjustment *out = &outer[i]; + struct ipa_parm_adjustment *in = &tmp[out->base_index]; + + memset (&r, 0, sizeof (r)); + gcc_assert (in->op != IPA_PARM_OP_REMOVE); + if (out->op == IPA_PARM_OP_REMOVE) + { + if (!index_in_adjustments_multiple_times_p (in->base_index, tmp)) + { + r.op = IPA_PARM_OP_REMOVE; + adjustments.quick_push (r); + } + continue; + } + else + { + /* FIXME: Handling of new arguments are not implemented yet. */ + gcc_assert (out->op != IPA_PARM_OP_NEW); + } + + r.base_index = in->base_index; + r.type = out->type; + + /* FIXME: Create nonlocal value too. */ + + if (in->op == IPA_PARM_OP_COPY && out->op == IPA_PARM_OP_COPY) + r.op = IPA_PARM_OP_COPY; + else if (in->op == IPA_PARM_OP_COPY) + r.offset = out->offset; + else if (out->op == IPA_PARM_OP_COPY) + r.offset = in->offset; + else + r.offset = in->offset + out->offset; + adjustments.quick_push (r); + } + + for (i = 0; i < inlen; i++) + { + struct ipa_parm_adjustment *n = &inner[i]; + + if (n->op == IPA_PARM_OP_REMOVE) + adjustments.quick_push (*n); + } + + tmp.release (); + return adjustments; +} + +/* If T is an SSA_NAME, return NULL if it is not a default def or + return its base variable if it is. If IGNORE_DEFAULT_DEF is true, + the base variable is always returned, regardless if it is a default + def. Return T if it is not an SSA_NAME. */ + +static tree +get_ssa_base_param (tree t, bool ignore_default_def) +{ + if (TREE_CODE (t) == SSA_NAME) + { + if (ignore_default_def || SSA_NAME_IS_DEFAULT_DEF (t)) + return SSA_NAME_VAR (t); + else + return NULL_TREE; + } + return t; +} + +/* Given an expression, return an adjustment entry specifying the + transformation to be done on EXPR. If no suitable adjustment entry + was found, returns NULL. + + If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a + default def, otherwise bail on them. + + If CONVERT is non-NULL, this function will set *CONVERT if the + expression provided is a component reference. ADJUSTMENTS is the + adjustments vector. */ + +ipa_parm_adjustment * +ipa_get_adjustment_candidate (tree **expr, bool *convert, + ipa_parm_adjustment_vec adjustments, + bool ignore_default_def) +{ + if (TREE_CODE (**expr) == BIT_FIELD_REF + || TREE_CODE (**expr) == IMAGPART_EXPR + || TREE_CODE (**expr) == REALPART_EXPR) + { + *expr = &TREE_OPERAND (**expr, 0); + if (convert) + *convert = true; + } + + HOST_WIDE_INT offset, size, max_size; + bool reverse; + tree base + = get_ref_base_and_extent (**expr, &offset, &size, &max_size, &reverse); + if (!base || size == -1 || max_size == -1) + return NULL; + + if (TREE_CODE (base) == MEM_REF) + { + offset += mem_ref_offset (base).to_short_addr () * BITS_PER_UNIT; + base = TREE_OPERAND (base, 0); + } + + base = get_ssa_base_param (base, ignore_default_def); + if (!base || TREE_CODE (base) != PARM_DECL) + return NULL; + + struct ipa_parm_adjustment *cand = NULL; + unsigned int len = adjustments.length (); + for (unsigned i = 0; i < len; i++) + { + struct ipa_parm_adjustment *adj = &adjustments[i]; + + if (adj->base == base + && (adj->offset == offset || adj->op == IPA_PARM_OP_REMOVE)) + { + cand = adj; + break; + } + } + + if (!cand || cand->op == IPA_PARM_OP_COPY || cand->op == IPA_PARM_OP_REMOVE) + return NULL; + return cand; +} + +/* If the expression *EXPR should be replaced by a reduction of a parameter, do + so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT + specifies whether the function should care about type incompatibility the + current and new expressions. If it is false, the function will leave + incompatibility issues to the caller. Return true iff the expression + was modified. */ + +bool +ipa_modify_expr (tree *expr, bool convert, + ipa_parm_adjustment_vec adjustments) +{ + struct ipa_parm_adjustment *cand + = ipa_get_adjustment_candidate (&expr, &convert, adjustments, false); + if (!cand) + return false; + + tree src; + if (cand->by_ref) + { + src = build_simple_mem_ref (cand->new_decl); + REF_REVERSE_STORAGE_ORDER (src) = cand->reverse; + } + else + src = cand->new_decl; + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "About to replace expr "); + print_generic_expr (dump_file, *expr); + fprintf (dump_file, " with "); + print_generic_expr (dump_file, src); + fprintf (dump_file, "\n"); + } + + if (convert && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type)) + { + tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr), src); + *expr = vce; + } + else + *expr = src; + return true; +} + +/* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human + friendly way, assuming they are meant to be applied to FNDECL. */ + +void +ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments, + tree fndecl) +{ + int i, len = adjustments.length (); + bool first = true; + vec parms = ipa_get_vector_of_formal_parms (fndecl); + + fprintf (file, "IPA param adjustments: "); + for (i = 0; i < len; i++) + { + struct ipa_parm_adjustment *adj; + adj = &adjustments[i]; + + if (!first) + fprintf (file, " "); + else + first = false; + + fprintf (file, "%i. base_index: %i - ", i, adj->base_index); + print_generic_expr (file, parms[adj->base_index]); + if (adj->base) + { + fprintf (file, ", base: "); + print_generic_expr (file, adj->base); + } + if (adj->new_decl) + { + fprintf (file, ", new_decl: "); + print_generic_expr (file, adj->new_decl); + } + if (adj->new_ssa_base) + { + fprintf (file, ", new_ssa_base: "); + print_generic_expr (file, adj->new_ssa_base); + } + + if (adj->op == IPA_PARM_OP_COPY) + fprintf (file, ", copy_param"); + else if (adj->op == IPA_PARM_OP_REMOVE) + fprintf (file, ", remove_param"); + else + fprintf (file, ", offset %li", (long) adj->offset); + if (adj->by_ref) + fprintf (file, ", by_ref"); + print_node_brief (file, ", type: ", adj->type, 0); + fprintf (file, "\n"); + } + parms.release (); +} + diff --git a/gcc/ipa-param-manipulation.h b/gcc/ipa-param-manipulation.h new file mode 100644 index 00000000000..364e4489c29 --- /dev/null +++ b/gcc/ipa-param-manipulation.h @@ -0,0 +1,120 @@ +/* Manipulation of formal and actual parameters of functions and function + calls. + Copyright (C) 2017 Free Software Foundation, Inc. + +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 +. */ + +#ifndef IPA_PARAM_MANIPULATION_H +#define IPA_PARAM_MANIPULATION_H + +/* Operation to be performed for the parameter in ipa_parm_adjustment + below. */ +enum ipa_parm_op { + IPA_PARM_OP_NONE, + + /* This describes a brand new parameter. + + The field `type' should be set to the new type, `arg_prefix' + should be set to the string prefix for the new DECL_NAME, and + `new_decl' will ultimately hold the newly created argument. */ + IPA_PARM_OP_NEW, + + /* This new parameter is an unmodified parameter at index base_index. */ + IPA_PARM_OP_COPY, + + /* This adjustment describes a parameter that is about to be removed + completely. Most users will probably need to book keep those so that they + don't leave behinfd any non default def ssa names belonging to them. */ + IPA_PARM_OP_REMOVE +}; + +/* Structure to describe transformations of formal parameters and actual + arguments. Each instance describes one new parameter and they are meant to + be stored in a vector. Additionally, most users will probably want to store + adjustments about parameters that are being removed altogether so that SSA + names belonging to them can be replaced by SSA names of an artificial + variable. */ +struct ipa_parm_adjustment +{ + /* The original PARM_DECL itself, helpful for processing of the body of the + function itself. Intended for traversing function bodies. + ipa_modify_formal_parameters, ipa_modify_call_arguments and + ipa_combine_adjustments ignore this and use base_index. + ipa_modify_formal_parameters actually sets this. */ + tree base; + + /* Type of the new parameter. However, if by_ref is true, the real type will + be a pointer to this type. */ + tree type; + + /* Alias refrerence type to be used in MEM_REFs when adjusting caller + arguments. */ + tree alias_ptr_type; + + /* The new declaration when creating/replacing a parameter. Created + by ipa_modify_formal_parameters, useful for functions modifying + the body accordingly. For brand new arguments, this is the newly + created argument. */ + tree new_decl; + + /* New declaration of a substitute variable that we may use to replace all + non-default-def ssa names when a parm decl is going away. */ + tree new_ssa_base; + + /* If non-NULL and the original parameter is to be removed (copy_param below + is NULL), this is going to be its nonlocalized vars value. */ + tree nonlocal_value; + + /* This holds the prefix to be used for the new DECL_NAME. */ + const char *arg_prefix; + + /* Offset into the original parameter (for the cases when the new parameter + is a component of an original one). */ + HOST_WIDE_INT offset; + + /* Zero based index of the original parameter this one is based on. */ + int base_index; + + /* Whether this parameter is a new parameter, a copy of an old one, + or one about to be removed. */ + enum ipa_parm_op op; + + /* Storage order of the original parameter (for the cases when the new + parameter is a component of an original one). */ + unsigned reverse : 1; + + /* The parameter is to be passed by reference. */ + unsigned by_ref : 1; +}; + +typedef vec ipa_parm_adjustment_vec; + +vec ipa_get_vector_of_formal_parms (tree fndecl); +vec ipa_get_vector_of_formal_parm_types (tree fntype); +void ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec); +void ipa_modify_call_arguments (struct cgraph_edge *, gcall *, + ipa_parm_adjustment_vec); +ipa_parm_adjustment_vec ipa_combine_adjustments (ipa_parm_adjustment_vec, + ipa_parm_adjustment_vec); +void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree); + +bool ipa_modify_expr (tree *, bool, ipa_parm_adjustment_vec); +ipa_parm_adjustment *ipa_get_adjustment_candidate (tree **, bool *, + ipa_parm_adjustment_vec, + bool); + +#endif /* IPA_PARAM_MANIPULATION_H */ diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c index a687f7cb29e..729251714de 100644 --- a/gcc/ipa-prop.c +++ b/gcc/ipa-prop.c @@ -4050,731 +4050,6 @@ ipa_print_all_params (FILE * f) ipa_print_node_params (f, node); } -/* Return a heap allocated vector containing formal parameters of FNDECL. */ - -vec -ipa_get_vector_of_formal_parms (tree fndecl) -{ - vec args; - int count; - tree parm; - - gcc_assert (!flag_wpa); - count = count_formal_params (fndecl); - args.create (count); - for (parm = DECL_ARGUMENTS (fndecl); parm; parm = DECL_CHAIN (parm)) - args.quick_push (parm); - - return args; -} - -/* Return a heap allocated vector containing types of formal parameters of - function type FNTYPE. */ - -vec -ipa_get_vector_of_formal_parm_types (tree fntype) -{ - vec types; - int count = 0; - tree t; - - for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) - count++; - - types.create (count); - for (t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t)) - types.quick_push (TREE_VALUE (t)); - - return types; -} - -/* Modify the function declaration FNDECL and its type according to the plan in - ADJUSTMENTS. It also sets base fields of individual adjustments structures - to reflect the actual parameters being modified which are determined by the - base_index field. */ - -void -ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments) -{ - vec oparms = ipa_get_vector_of_formal_parms (fndecl); - tree orig_type = TREE_TYPE (fndecl); - tree old_arg_types = TYPE_ARG_TYPES (orig_type); - - /* The following test is an ugly hack, some functions simply don't have any - arguments in their type. This is probably a bug but well... */ - bool care_for_types = (old_arg_types != NULL_TREE); - bool last_parm_void; - vec otypes; - if (care_for_types) - { - last_parm_void = (TREE_VALUE (tree_last (old_arg_types)) - == void_type_node); - otypes = ipa_get_vector_of_formal_parm_types (orig_type); - if (last_parm_void) - gcc_assert (oparms.length () + 1 == otypes.length ()); - else - gcc_assert (oparms.length () == otypes.length ()); - } - else - { - last_parm_void = false; - otypes.create (0); - } - - int len = adjustments.length (); - tree *link = &DECL_ARGUMENTS (fndecl); - tree new_arg_types = NULL; - for (int i = 0; i < len; i++) - { - struct ipa_parm_adjustment *adj; - gcc_assert (link); - - adj = &adjustments[i]; - tree parm; - if (adj->op == IPA_PARM_OP_NEW) - parm = NULL; - else - parm = oparms[adj->base_index]; - adj->base = parm; - - if (adj->op == IPA_PARM_OP_COPY) - { - if (care_for_types) - new_arg_types = tree_cons (NULL_TREE, otypes[adj->base_index], - new_arg_types); - *link = parm; - link = &DECL_CHAIN (parm); - } - else if (adj->op != IPA_PARM_OP_REMOVE) - { - tree new_parm; - tree ptype; - - if (adj->by_ref) - ptype = build_pointer_type (adj->type); - else - { - ptype = adj->type; - if (is_gimple_reg_type (ptype) - && TYPE_MODE (ptype) != BLKmode) - { - unsigned malign = GET_MODE_ALIGNMENT (TYPE_MODE (ptype)); - if (TYPE_ALIGN (ptype) != malign) - ptype = build_aligned_type (ptype, malign); - } - } - - if (care_for_types) - new_arg_types = tree_cons (NULL_TREE, ptype, new_arg_types); - - new_parm = build_decl (UNKNOWN_LOCATION, PARM_DECL, NULL_TREE, - ptype); - const char *prefix = adj->arg_prefix ? adj->arg_prefix : "SYNTH"; - DECL_NAME (new_parm) = create_tmp_var_name (prefix); - DECL_ARTIFICIAL (new_parm) = 1; - DECL_ARG_TYPE (new_parm) = ptype; - DECL_CONTEXT (new_parm) = fndecl; - TREE_USED (new_parm) = 1; - DECL_IGNORED_P (new_parm) = 1; - layout_decl (new_parm, 0); - - if (adj->op == IPA_PARM_OP_NEW) - adj->base = NULL; - else - adj->base = parm; - adj->new_decl = new_parm; - - *link = new_parm; - link = &DECL_CHAIN (new_parm); - } - } - - *link = NULL_TREE; - - tree new_reversed = NULL; - if (care_for_types) - { - new_reversed = nreverse (new_arg_types); - if (last_parm_void) - { - if (new_reversed) - TREE_CHAIN (new_arg_types) = void_list_node; - else - new_reversed = void_list_node; - } - } - - /* Use copy_node to preserve as much as possible from original type - (debug info, attribute lists etc.) - Exception is METHOD_TYPEs must have THIS argument. - When we are asked to remove it, we need to build new FUNCTION_TYPE - instead. */ - tree new_type = NULL; - if (TREE_CODE (orig_type) != METHOD_TYPE - || (adjustments[0].op == IPA_PARM_OP_COPY - && adjustments[0].base_index == 0)) - { - new_type = build_distinct_type_copy (orig_type); - TYPE_ARG_TYPES (new_type) = new_reversed; - } - else - { - new_type - = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type), - new_reversed)); - TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type); - DECL_VINDEX (fndecl) = NULL_TREE; - } - - /* When signature changes, we need to clear builtin info. */ - if (DECL_BUILT_IN (fndecl)) - { - DECL_BUILT_IN_CLASS (fndecl) = NOT_BUILT_IN; - DECL_FUNCTION_CODE (fndecl) = (enum built_in_function) 0; - } - - TREE_TYPE (fndecl) = new_type; - DECL_VIRTUAL_P (fndecl) = 0; - DECL_LANG_SPECIFIC (fndecl) = NULL; - otypes.release (); - oparms.release (); -} - -/* Modify actual arguments of a function call CS as indicated in ADJUSTMENTS. - If this is a directly recursive call, CS must be NULL. Otherwise it must - contain the corresponding call graph edge. */ - -void -ipa_modify_call_arguments (struct cgraph_edge *cs, gcall *stmt, - ipa_parm_adjustment_vec adjustments) -{ - struct cgraph_node *current_node = cgraph_node::get (current_function_decl); - vec vargs; - vec **debug_args = NULL; - gcall *new_stmt; - gimple_stmt_iterator gsi, prev_gsi; - tree callee_decl; - int i, len; - - len = adjustments.length (); - vargs.create (len); - callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl; - current_node->remove_stmt_references (stmt); - - gsi = gsi_for_stmt (stmt); - prev_gsi = gsi; - gsi_prev (&prev_gsi); - for (i = 0; i < len; i++) - { - struct ipa_parm_adjustment *adj; - - adj = &adjustments[i]; - - if (adj->op == IPA_PARM_OP_COPY) - { - tree arg = gimple_call_arg (stmt, adj->base_index); - - vargs.quick_push (arg); - } - else if (adj->op != IPA_PARM_OP_REMOVE) - { - tree expr, base, off; - location_t loc; - unsigned int deref_align = 0; - bool deref_base = false; - - /* We create a new parameter out of the value of the old one, we can - do the following kind of transformations: - - - A scalar passed by reference is converted to a scalar passed by - value. (adj->by_ref is false and the type of the original - actual argument is a pointer to a scalar). - - - A part of an aggregate is passed instead of the whole aggregate. - The part can be passed either by value or by reference, this is - determined by value of adj->by_ref. Moreover, the code below - handles both situations when the original aggregate is passed by - value (its type is not a pointer) and when it is passed by - reference (it is a pointer to an aggregate). - - When the new argument is passed by reference (adj->by_ref is true) - it must be a part of an aggregate and therefore we form it by - simply taking the address of a reference inside the original - aggregate. */ - - gcc_checking_assert (adj->offset % BITS_PER_UNIT == 0); - base = gimple_call_arg (stmt, adj->base_index); - loc = DECL_P (base) ? DECL_SOURCE_LOCATION (base) - : EXPR_LOCATION (base); - - if (TREE_CODE (base) != ADDR_EXPR - && POINTER_TYPE_P (TREE_TYPE (base))) - off = build_int_cst (adj->alias_ptr_type, - adj->offset / BITS_PER_UNIT); - else - { - HOST_WIDE_INT base_offset; - tree prev_base; - bool addrof; - - if (TREE_CODE (base) == ADDR_EXPR) - { - base = TREE_OPERAND (base, 0); - addrof = true; - } - else - addrof = false; - prev_base = base; - base = get_addr_base_and_unit_offset (base, &base_offset); - /* Aggregate arguments can have non-invariant addresses. */ - if (!base) - { - base = build_fold_addr_expr (prev_base); - off = build_int_cst (adj->alias_ptr_type, - adj->offset / BITS_PER_UNIT); - } - else if (TREE_CODE (base) == MEM_REF) - { - if (!addrof) - { - deref_base = true; - deref_align = TYPE_ALIGN (TREE_TYPE (base)); - } - off = build_int_cst (adj->alias_ptr_type, - base_offset - + adj->offset / BITS_PER_UNIT); - off = int_const_binop (PLUS_EXPR, TREE_OPERAND (base, 1), - off); - base = TREE_OPERAND (base, 0); - } - else - { - off = build_int_cst (adj->alias_ptr_type, - base_offset - + adj->offset / BITS_PER_UNIT); - base = build_fold_addr_expr (base); - } - } - - if (!adj->by_ref) - { - tree type = adj->type; - unsigned int align; - unsigned HOST_WIDE_INT misalign; - - if (deref_base) - { - align = deref_align; - misalign = 0; - } - else - { - get_pointer_alignment_1 (base, &align, &misalign); - if (TYPE_ALIGN (type) > align) - align = TYPE_ALIGN (type); - } - misalign += (offset_int::from (wi::to_wide (off), - SIGNED).to_short_addr () - * BITS_PER_UNIT); - misalign = misalign & (align - 1); - if (misalign != 0) - align = least_bit_hwi (misalign); - if (align < TYPE_ALIGN (type)) - type = build_aligned_type (type, align); - base = force_gimple_operand_gsi (&gsi, base, - true, NULL, true, GSI_SAME_STMT); - expr = fold_build2_loc (loc, MEM_REF, type, base, off); - REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse; - /* If expr is not a valid gimple call argument emit - a load into a temporary. */ - if (is_gimple_reg_type (TREE_TYPE (expr))) - { - gimple *tem = gimple_build_assign (NULL_TREE, expr); - if (gimple_in_ssa_p (cfun)) - { - gimple_set_vuse (tem, gimple_vuse (stmt)); - expr = make_ssa_name (TREE_TYPE (expr), tem); - } - else - expr = create_tmp_reg (TREE_TYPE (expr)); - gimple_assign_set_lhs (tem, expr); - gsi_insert_before (&gsi, tem, GSI_SAME_STMT); - } - } - else - { - expr = fold_build2_loc (loc, MEM_REF, adj->type, base, off); - REF_REVERSE_STORAGE_ORDER (expr) = adj->reverse; - expr = build_fold_addr_expr (expr); - expr = force_gimple_operand_gsi (&gsi, expr, - true, NULL, true, GSI_SAME_STMT); - } - vargs.quick_push (expr); - } - if (adj->op != IPA_PARM_OP_COPY && MAY_HAVE_DEBUG_STMTS) - { - unsigned int ix; - tree ddecl = NULL_TREE, origin = DECL_ORIGIN (adj->base), arg; - gimple *def_temp; - - arg = gimple_call_arg (stmt, adj->base_index); - if (!useless_type_conversion_p (TREE_TYPE (origin), TREE_TYPE (arg))) - { - if (!fold_convertible_p (TREE_TYPE (origin), arg)) - continue; - arg = fold_convert_loc (gimple_location (stmt), - TREE_TYPE (origin), arg); - } - if (debug_args == NULL) - debug_args = decl_debug_args_insert (callee_decl); - for (ix = 0; vec_safe_iterate (*debug_args, ix, &ddecl); ix += 2) - if (ddecl == origin) - { - ddecl = (**debug_args)[ix + 1]; - break; - } - if (ddecl == NULL) - { - ddecl = make_node (DEBUG_EXPR_DECL); - DECL_ARTIFICIAL (ddecl) = 1; - TREE_TYPE (ddecl) = TREE_TYPE (origin); - SET_DECL_MODE (ddecl, DECL_MODE (origin)); - - vec_safe_push (*debug_args, origin); - vec_safe_push (*debug_args, ddecl); - } - def_temp = gimple_build_debug_bind (ddecl, unshare_expr (arg), stmt); - gsi_insert_before (&gsi, def_temp, GSI_SAME_STMT); - } - } - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "replacing stmt:"); - print_gimple_stmt (dump_file, gsi_stmt (gsi), 0); - } - - new_stmt = gimple_build_call_vec (callee_decl, vargs); - vargs.release (); - if (gimple_call_lhs (stmt)) - gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt)); - - gimple_set_block (new_stmt, gimple_block (stmt)); - if (gimple_has_location (stmt)) - gimple_set_location (new_stmt, gimple_location (stmt)); - gimple_call_set_chain (new_stmt, gimple_call_chain (stmt)); - gimple_call_copy_flags (new_stmt, stmt); - if (gimple_in_ssa_p (cfun)) - { - gimple_set_vuse (new_stmt, gimple_vuse (stmt)); - if (gimple_vdef (stmt)) - { - gimple_set_vdef (new_stmt, gimple_vdef (stmt)); - SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt; - } - } - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "with stmt:"); - print_gimple_stmt (dump_file, new_stmt, 0); - fprintf (dump_file, "\n"); - } - gsi_replace (&gsi, new_stmt, true); - if (cs) - cs->set_call_stmt (new_stmt); - do - { - current_node->record_stmt_references (gsi_stmt (gsi)); - gsi_prev (&gsi); - } - while (gsi_stmt (gsi) != gsi_stmt (prev_gsi)); -} - -/* If the expression *EXPR should be replaced by a reduction of a parameter, do - so. ADJUSTMENTS is a pointer to a vector of adjustments. CONVERT - specifies whether the function should care about type incompatibility the - current and new expressions. If it is false, the function will leave - incompatibility issues to the caller. Return true iff the expression - was modified. */ - -bool -ipa_modify_expr (tree *expr, bool convert, - ipa_parm_adjustment_vec adjustments) -{ - struct ipa_parm_adjustment *cand - = ipa_get_adjustment_candidate (&expr, &convert, adjustments, false); - if (!cand) - return false; - - tree src; - if (cand->by_ref) - { - src = build_simple_mem_ref (cand->new_decl); - REF_REVERSE_STORAGE_ORDER (src) = cand->reverse; - } - else - src = cand->new_decl; - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "About to replace expr "); - print_generic_expr (dump_file, *expr); - fprintf (dump_file, " with "); - print_generic_expr (dump_file, src); - fprintf (dump_file, "\n"); - } - - if (convert && !useless_type_conversion_p (TREE_TYPE (*expr), cand->type)) - { - tree vce = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr), src); - *expr = vce; - } - else - *expr = src; - return true; -} - -/* If T is an SSA_NAME, return NULL if it is not a default def or - return its base variable if it is. If IGNORE_DEFAULT_DEF is true, - the base variable is always returned, regardless if it is a default - def. Return T if it is not an SSA_NAME. */ - -static tree -get_ssa_base_param (tree t, bool ignore_default_def) -{ - if (TREE_CODE (t) == SSA_NAME) - { - if (ignore_default_def || SSA_NAME_IS_DEFAULT_DEF (t)) - return SSA_NAME_VAR (t); - else - return NULL_TREE; - } - return t; -} - -/* Given an expression, return an adjustment entry specifying the - transformation to be done on EXPR. If no suitable adjustment entry - was found, returns NULL. - - If IGNORE_DEFAULT_DEF is set, consider SSA_NAMEs which are not a - default def, otherwise bail on them. - - If CONVERT is non-NULL, this function will set *CONVERT if the - expression provided is a component reference. ADJUSTMENTS is the - adjustments vector. */ - -ipa_parm_adjustment * -ipa_get_adjustment_candidate (tree **expr, bool *convert, - ipa_parm_adjustment_vec adjustments, - bool ignore_default_def) -{ - if (TREE_CODE (**expr) == BIT_FIELD_REF - || TREE_CODE (**expr) == IMAGPART_EXPR - || TREE_CODE (**expr) == REALPART_EXPR) - { - *expr = &TREE_OPERAND (**expr, 0); - if (convert) - *convert = true; - } - - HOST_WIDE_INT offset, size, max_size; - bool reverse; - tree base - = get_ref_base_and_extent (**expr, &offset, &size, &max_size, &reverse); - if (!base || size == -1 || max_size == -1) - return NULL; - - if (TREE_CODE (base) == MEM_REF) - { - offset += mem_ref_offset (base).to_short_addr () * BITS_PER_UNIT; - base = TREE_OPERAND (base, 0); - } - - base = get_ssa_base_param (base, ignore_default_def); - if (!base || TREE_CODE (base) != PARM_DECL) - return NULL; - - struct ipa_parm_adjustment *cand = NULL; - unsigned int len = adjustments.length (); - for (unsigned i = 0; i < len; i++) - { - struct ipa_parm_adjustment *adj = &adjustments[i]; - - if (adj->base == base - && (adj->offset == offset || adj->op == IPA_PARM_OP_REMOVE)) - { - cand = adj; - break; - } - } - - if (!cand || cand->op == IPA_PARM_OP_COPY || cand->op == IPA_PARM_OP_REMOVE) - return NULL; - return cand; -} - -/* Return true iff BASE_INDEX is in ADJUSTMENTS more than once. */ - -static bool -index_in_adjustments_multiple_times_p (int base_index, - ipa_parm_adjustment_vec adjustments) -{ - int i, len = adjustments.length (); - bool one = false; - - for (i = 0; i < len; i++) - { - struct ipa_parm_adjustment *adj; - adj = &adjustments[i]; - - if (adj->base_index == base_index) - { - if (one) - return true; - else - one = true; - } - } - return false; -} - - -/* Return adjustments that should have the same effect on function parameters - and call arguments as if they were first changed according to adjustments in - INNER and then by adjustments in OUTER. */ - -ipa_parm_adjustment_vec -ipa_combine_adjustments (ipa_parm_adjustment_vec inner, - ipa_parm_adjustment_vec outer) -{ - int i, outlen = outer.length (); - int inlen = inner.length (); - int removals = 0; - ipa_parm_adjustment_vec adjustments, tmp; - - tmp.create (inlen); - for (i = 0; i < inlen; i++) - { - struct ipa_parm_adjustment *n; - n = &inner[i]; - - if (n->op == IPA_PARM_OP_REMOVE) - removals++; - else - { - /* FIXME: Handling of new arguments are not implemented yet. */ - gcc_assert (n->op != IPA_PARM_OP_NEW); - tmp.quick_push (*n); - } - } - - adjustments.create (outlen + removals); - for (i = 0; i < outlen; i++) - { - struct ipa_parm_adjustment r; - struct ipa_parm_adjustment *out = &outer[i]; - struct ipa_parm_adjustment *in = &tmp[out->base_index]; - - memset (&r, 0, sizeof (r)); - gcc_assert (in->op != IPA_PARM_OP_REMOVE); - if (out->op == IPA_PARM_OP_REMOVE) - { - if (!index_in_adjustments_multiple_times_p (in->base_index, tmp)) - { - r.op = IPA_PARM_OP_REMOVE; - adjustments.quick_push (r); - } - continue; - } - else - { - /* FIXME: Handling of new arguments are not implemented yet. */ - gcc_assert (out->op != IPA_PARM_OP_NEW); - } - - r.base_index = in->base_index; - r.type = out->type; - - /* FIXME: Create nonlocal value too. */ - - if (in->op == IPA_PARM_OP_COPY && out->op == IPA_PARM_OP_COPY) - r.op = IPA_PARM_OP_COPY; - else if (in->op == IPA_PARM_OP_COPY) - r.offset = out->offset; - else if (out->op == IPA_PARM_OP_COPY) - r.offset = in->offset; - else - r.offset = in->offset + out->offset; - adjustments.quick_push (r); - } - - for (i = 0; i < inlen; i++) - { - struct ipa_parm_adjustment *n = &inner[i]; - - if (n->op == IPA_PARM_OP_REMOVE) - adjustments.quick_push (*n); - } - - tmp.release (); - return adjustments; -} - -/* Dump the adjustments in the vector ADJUSTMENTS to dump_file in a human - friendly way, assuming they are meant to be applied to FNDECL. */ - -void -ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments, - tree fndecl) -{ - int i, len = adjustments.length (); - bool first = true; - vec parms = ipa_get_vector_of_formal_parms (fndecl); - - fprintf (file, "IPA param adjustments: "); - for (i = 0; i < len; i++) - { - struct ipa_parm_adjustment *adj; - adj = &adjustments[i]; - - if (!first) - fprintf (file, " "); - else - first = false; - - fprintf (file, "%i. base_index: %i - ", i, adj->base_index); - print_generic_expr (file, parms[adj->base_index]); - if (adj->base) - { - fprintf (file, ", base: "); - print_generic_expr (file, adj->base); - } - if (adj->new_decl) - { - fprintf (file, ", new_decl: "); - print_generic_expr (file, adj->new_decl); - } - if (adj->new_ssa_base) - { - fprintf (file, ", new_ssa_base: "); - print_generic_expr (file, adj->new_ssa_base); - } - - if (adj->op == IPA_PARM_OP_COPY) - fprintf (file, ", copy_param"); - else if (adj->op == IPA_PARM_OP_REMOVE) - fprintf (file, ", remove_param"); - else - fprintf (file, ", offset %li", (long) adj->offset); - if (adj->by_ref) - fprintf (file, ", by_ref"); - print_node_brief (file, ", type: ", adj->type, 0); - fprintf (file, "\n"); - } - parms.release (); -} - /* Dump the AV linked list. */ void diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h index fa5bed49ee0..bd8ae3e8dae 100644 --- a/gcc/ipa-prop.h +++ b/gcc/ipa-prop.h @@ -765,96 +765,6 @@ class ipcp_agg_lattice; extern object_allocator ipcp_agg_lattice_pool; -/* Operation to be performed for the parameter in ipa_parm_adjustment - below. */ -enum ipa_parm_op { - IPA_PARM_OP_NONE, - - /* This describes a brand new parameter. - - The field `type' should be set to the new type, `arg_prefix' - should be set to the string prefix for the new DECL_NAME, and - `new_decl' will ultimately hold the newly created argument. */ - IPA_PARM_OP_NEW, - - /* This new parameter is an unmodified parameter at index base_index. */ - IPA_PARM_OP_COPY, - - /* This adjustment describes a parameter that is about to be removed - completely. Most users will probably need to book keep those so that they - don't leave behinfd any non default def ssa names belonging to them. */ - IPA_PARM_OP_REMOVE -}; - -/* Structure to describe transformations of formal parameters and actual - arguments. Each instance describes one new parameter and they are meant to - be stored in a vector. Additionally, most users will probably want to store - adjustments about parameters that are being removed altogether so that SSA - names belonging to them can be replaced by SSA names of an artificial - variable. */ -struct ipa_parm_adjustment -{ - /* The original PARM_DECL itself, helpful for processing of the body of the - function itself. Intended for traversing function bodies. - ipa_modify_formal_parameters, ipa_modify_call_arguments and - ipa_combine_adjustments ignore this and use base_index. - ipa_modify_formal_parameters actually sets this. */ - tree base; - - /* Type of the new parameter. However, if by_ref is true, the real type will - be a pointer to this type. */ - tree type; - - /* Alias refrerence type to be used in MEM_REFs when adjusting caller - arguments. */ - tree alias_ptr_type; - - /* The new declaration when creating/replacing a parameter. Created - by ipa_modify_formal_parameters, useful for functions modifying - the body accordingly. For brand new arguments, this is the newly - created argument. */ - tree new_decl; - - /* New declaration of a substitute variable that we may use to replace all - non-default-def ssa names when a parm decl is going away. */ - tree new_ssa_base; - - /* If non-NULL and the original parameter is to be removed (copy_param below - is NULL), this is going to be its nonlocalized vars value. */ - tree nonlocal_value; - - /* This holds the prefix to be used for the new DECL_NAME. */ - const char *arg_prefix; - - /* Offset into the original parameter (for the cases when the new parameter - is a component of an original one). */ - HOST_WIDE_INT offset; - - /* Zero based index of the original parameter this one is based on. */ - int base_index; - - /* Whether this parameter is a new parameter, a copy of an old one, - or one about to be removed. */ - enum ipa_parm_op op; - - /* Storage order of the original parameter (for the cases when the new - parameter is a component of an original one). */ - unsigned reverse : 1; - - /* The parameter is to be passed by reference. */ - unsigned by_ref : 1; -}; - -typedef vec ipa_parm_adjustment_vec; - -vec ipa_get_vector_of_formal_parms (tree fndecl); -vec ipa_get_vector_of_formal_parm_types (tree fntype); -void ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec); -void ipa_modify_call_arguments (struct cgraph_edge *, gcall *, - ipa_parm_adjustment_vec); -ipa_parm_adjustment_vec ipa_combine_adjustments (ipa_parm_adjustment_vec, - ipa_parm_adjustment_vec); -void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree); void ipa_dump_agg_replacement_values (FILE *f, struct ipa_agg_replacement_value *av); void ipa_prop_write_jump_functions (void); @@ -870,10 +780,6 @@ ipa_polymorphic_call_context ipa_context_from_jfunc (ipa_node_params *, int, ipa_jump_func *); void ipa_dump_param (FILE *, struct ipa_node_params *info, int i); -bool ipa_modify_expr (tree *, bool, ipa_parm_adjustment_vec); -ipa_parm_adjustment *ipa_get_adjustment_candidate (tree **, bool *, - ipa_parm_adjustment_vec, - bool); void ipa_release_body_info (struct ipa_func_body_info *); tree ipa_get_callee_param_type (struct cgraph_edge *e, int i); diff --git a/gcc/omp-simd-clone.c b/gcc/omp-simd-clone.c index 37a5f64a549..b8386037dfd 100644 --- a/gcc/omp-simd-clone.c +++ b/gcc/omp-simd-clone.c @@ -45,7 +45,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-dfa.h" #include "cfgloop.h" #include "symbol-summary.h" -#include "ipa-prop.h" +#include "ipa-param-manipulation.h" #include "tree-eh.h" #include "varasm.h" #include "stringpool.h" diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index bac593951e7..db490b20c3e 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -97,6 +97,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-dfa.h" #include "tree-ssa.h" #include "symbol-summary.h" +#include "ipa-param-manipulation.h" #include "ipa-prop.h" #include "params.h" #include "dbgcnt.h"