From patchwork Mon Nov 27 14:31:22 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Biener X-Patchwork-Id: 170188 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:ce62:0:b0:403:3b70:6f57 with SMTP id o2csp3164084vqx; Mon, 27 Nov 2023 06:31:55 -0800 (PST) X-Google-Smtp-Source: AGHT+IF5u4QrGWJgyCxe3aGlZcVPXH8b5WftIwmvDeU+nhi5VUEP14ZzcqcafOqsdyqxT/ekbVAE X-Received: by 2002:ad4:5042:0:b0:67a:234c:2c8a with SMTP id m2-20020ad45042000000b0067a234c2c8amr9459999qvq.51.1701095514868; Mon, 27 Nov 2023 06:31:54 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1701095514; cv=pass; d=google.com; s=arc-20160816; b=d9A5FQFZBXndOfCocNZc468mJWHwUPHGjn3ZK6tjsM0DrIaEzs4tM4GY67coZIzCtn v8NlC0OnYGN15dOvy2gNOPWU7KQUKcttR8uTSBCLObTrEB7/yu0tB0oB8USMGqYcNJjT 7sgwb9Yfn7rHyi7BmMv3EjTdxPDH0Kn+diBXvWjvW2ikHfPL+28hjxkkAC7myEaZOF1d bh6WLbPASrADKMo29pfCi7iK4hR1zv0vioxJEIyCPNxo6KX7K9UwHvR7gZEDPj3wNYJ0 DXPAD+908soR+1j3b28x04jYJ9VSRqrm0d3F/nFu8xtkYLGKTyRHeBrwnGsaKB4Ev3xN +HWg== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=message-id:errors-to:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence:mime-version :user-agent:subject:cc:to:from:date:dkim-signature:dkim-signature :arc-filter:dmarc-filter:delivered-to; bh=caRlqoyW1NVCFXsMJ+Cq73/yK39+rQzYsVUUqgOzUnc=; fh=+H+PfslJQ8SfgojuI5pxEuPHAhp/Ml9gJNsp0+tS7IU=; b=j8986mgNfWwHwmxN/ligEpqbxMPM4+9p/Y1OhOF+MTemlig1o15j3Z0qcCjNhuzaUe XxC5OLAoRkdl7xBXt5flaa/lAov97EbPSTK/Rvg0z7XTn65gTOXjFIMr0mbvoG67BKKX XVX6o4ZOLxdJeTQgeimjnmEVcdXGxS0kw80dzu1xUcB22Gjvyy8u/kucw0/USIpxZ/f8 5bnAFb9jFqNdPeFaZ+UiNXEp4L8PXvBC9omJ2vemOEr6tBgFe9ScwsoSmPPg/WvVaNlL aaiDQbO22eIaUATVw3w55T7jcTUGCrsRzZP5gy2M7Z10j6SZ8NShqi+Chne9TTe/rtg0 AYYA== ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@suse.de header.s=susede2_rsa header.b=mnUZR1n9; dkim=neutral (no key) header.i=@suse.de header.s=susede2_ed25519 header.b=TYrkj8Ml; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=suse.de Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id fv15-20020a05622a4a0f00b0042395c25b85si4651220qtb.228.2023.11.27.06.31.54 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 27 Nov 2023 06:31:54 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@suse.de header.s=susede2_rsa header.b=mnUZR1n9; dkim=neutral (no key) header.i=@suse.de header.s=susede2_ed25519 header.b=TYrkj8Ml; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=suse.de Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 6FA693857735 for ; Mon, 27 Nov 2023 14:31:54 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.223.131]) by sourceware.org (Postfix) with ESMTPS id 59E33385841E for ; Mon, 27 Nov 2023 14:31:28 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 59E33385841E Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=suse.de Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=suse.de ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 59E33385841E Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=195.135.223.131 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1701095490; cv=none; b=EvXIymDaEwSQtDBf2hJecCKDxn03Vbty5zqWK1BC7La/VAVBpM7M1Ufl9CG8s3k7eOtWDqYOsrVid1DMV4hKFpbdlWc7k1LmcuJ0JzoT5LX7THJ4JX01ByYRkk204UI1DsCettZM+UopmhL8OB0TB5UmLPFx0Ynrh4KeXAaoPVE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1701095490; c=relaxed/simple; bh=1uRhQm+oQcX+jIp94ISS5Kb9g1C3QXr1JGcVpIxWXfc=; h=DKIM-Signature:DKIM-Signature:Date:From:To:Subject:MIME-Version; b=NrfGIDFaaBV+IJFpz3id2K2R5/8CFX8tK2IXV+ry5Teux9Cms6cCKGBPsaRtZWOBuoCLbOnWPlnZETPN1JmX/pXzm+7xQaA3WVZOkltXT0UTKiHOpCdRSifuhRYhX/2usT+mVhyU5OohTCvFnAkIGK6OiPOfptg/OESPuI8Bosg= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from relay2.suse.de (unknown [149.44.160.134]) by smtp-out2.suse.de (Postfix) with ESMTP id 1046F1FCF9; Mon, 27 Nov 2023 14:31:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_rsa; t=1701095485; h=from:from:reply-to:date:date:to:to:cc:cc:mime-version:mime-version: content-type:content-type; bh=caRlqoyW1NVCFXsMJ+Cq73/yK39+rQzYsVUUqgOzUnc=; b=mnUZR1n9j6Hp2EqG0RNBLHMpG+C1zjGkFcAqBD11eQ+zVGKBTHq78WJlS2bnNOBeSYow+E wjOdIQHhscHGiVOyrEqO2Ygk149MN1ikGq1GtulFg/fuhn1jWdxurHdNFFZzg+D1YFf8oo P27rYQPd2t5dxMc4C9VwXsbapVbauc8= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.de; s=susede2_ed25519; t=1701095485; h=from:from:reply-to:date:date:to:to:cc:cc:mime-version:mime-version: content-type:content-type; bh=caRlqoyW1NVCFXsMJ+Cq73/yK39+rQzYsVUUqgOzUnc=; b=TYrkj8MlyEzGLIy/kOBNW4icaDyQnB9sQk53JJxCzSJWwjSCGwdylU0DNldUo6FuST3Frg czR1dGE7Bt8nsOAg== Received: from wotan.suse.de (wotan.suse.de [10.160.0.1]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by relay2.suse.de (Postfix) with ESMTPS id 1CC142C16D; Mon, 27 Nov 2023 14:31:23 +0000 (UTC) Date: Mon, 27 Nov 2023 14:31:22 +0000 (UTC) From: Richard Biener To: gcc-patches@gcc.gnu.org cc: Jan Hubicka Subject: [PATCH] tree-optimization/112653 - PTA and return User-Agent: Alpine 2.22 (LSU 394 2020-01-19) MIME-Version: 1.0 X-Spamd-Bar: +++++++++++++++++++++ X-Spam-Score: 21.19 X-Rspamd-Server: rspamd1 Authentication-Results: smtp-out2.suse.de; dkim=none; spf=softfail (smtp-out2.suse.de: 149.44.160.134 is neither permitted nor denied by domain of rguenther@suse.de) smtp.mailfrom=rguenther@suse.de; dmarc=fail reason="No valid SPF, No valid DKIM" header.from=suse.de (policy=none) X-Rspamd-Queue-Id: 1046F1FCF9 X-Spamd-Result: default: False [21.19 / 50.00]; RDNS_NONE(1.00)[]; SPAMHAUS_XBL(0.00)[149.44.160.134:from]; TO_DN_SOME(0.00)[]; RWL_MAILSPIKE_GOOD(0.00)[149.44.160.134:from]; HFILTER_HELO_IP_A(1.00)[relay2.suse.de]; HFILTER_HELO_NORES_A_OR_MX(0.30)[relay2.suse.de]; R_SPF_SOFTFAIL(4.60)[~all:c]; R_RATELIMIT(0.00)[ip(RLkk1mdgxgu4i4849a6y),rip(RLa6h5sh378tcam5q78u)]; MX_GOOD(-0.01)[]; RCPT_COUNT_TWO(0.00)[2]; RCVD_NO_TLS_LAST(0.10)[]; FROM_EQ_ENVFROM(0.00)[]; R_DKIM_NA(2.20)[]; MIME_TRACE(0.00)[0:+]; BAYES_HAM(-3.00)[100.00%]; RDNS_DNSFAIL(0.00)[]; ARC_NA(0.00)[]; FROM_HAS_DN(0.00)[]; TO_MATCH_ENVRCPT_ALL(0.00)[]; NEURAL_SPAM_SHORT(3.00)[1.000]; MIME_GOOD(-0.10)[text/plain]; MISSING_MID(2.50)[]; DKIM_SIGNED(0.00)[suse.de:s=susede2_rsa,suse.de:s=susede2_ed25519]; VIOLATED_DIRECT_SPF(3.50)[]; NEURAL_SPAM_LONG(3.50)[1.000]; FUZZY_BLOCKED(0.00)[rspamd.com]; RCVD_COUNT_TWO(0.00)[2]; HFILTER_HOSTNAME_UNKNOWN(2.50)[]; DMARC_POLICY_SOFTFAIL(0.10)[suse.de : No valid SPF, No valid DKIM,none] X-Spam-Status: No, score=-10.7 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, MISSING_MID, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Message-Id: <20231127143154.6FA693857735@sourceware.org> X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1783727930640073155 X-GMAIL-MSGID: 1783727930640073155 The following separates the escape solution for return stmts not only during points-to solving but also for later querying. This requires adjusting the points-to-global tests to include escapes through returns. Technically the patch replaces the existing post-processing which computes the transitive closure of the returned value solution by a proper artificial variable with transitive closure constraints. Instead of adding the solution to escaped we track it separately. Bootstrapped and tested on x86_64-unknown-linux-gnu, will push. Richard. PR tree-optimization/112653 * gimple-ssa.h (gimple_df): Add escaped_return solution. * tree-ssa.cc (init_tree_ssa): Reset it. (delete_tree_ssa): Likewise. * tree-ssa-structalias.cc (escaped_return_id): New. (find_func_aliases): Handle non-IPA return stmts by adding to ESCAPED_RETURN. (set_uids_in_ptset): Adjust HEAP escaping to also cover escapes through return. (init_base_vars): Initialize ESCAPED_RETURN. (compute_points_to_sets): Replace ESCAPED post-processing with recording the ESCAPED_RETURN solution. * tree-ssa-alias.cc (ref_may_alias_global_p_1): Check the ESCAPED_RETUNR solution. (dump_alias_info): Dump it. * cfgexpand.cc (update_alias_info_with_stack_vars): Update it. * ipa-icf.cc (sem_item_optimizer::fixup_points_to_sets): Likewise. * tree-parloops.cc (expand_call_inline): Reset it. * tree-sra.cc (maybe_add_sra_candidate): Check it. * gcc.dg/tree-ssa/pta-return-1.c: New testcase. --- gcc/cfgexpand.cc | 3 +- gcc/gimple-ssa.h | 4 +- gcc/ipa-icf.cc | 1 + gcc/testsuite/gcc.dg/tree-ssa/pta-return-1.c | 16 +++ gcc/tree-inline.cc | 5 +- gcc/tree-parloops.cc | 5 +- gcc/tree-sra.cc | 2 +- gcc/tree-ssa-alias.cc | 6 +- gcc/tree-ssa-structalias.cc | 124 +++++++------------ gcc/tree-ssa.cc | 2 + 10 files changed, 85 insertions(+), 83 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pta-return-1.c diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc index e58327b239b..feed001f3c9 100644 --- a/gcc/cfgexpand.cc +++ b/gcc/cfgexpand.cc @@ -863,7 +863,8 @@ update_alias_info_with_stack_vars (void) add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped, decls_to_partitions, &visited, temp); - + add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped_return, + decls_to_partitions, &visited, temp); delete decls_to_partitions; BITMAP_FREE (temp); } diff --git a/gcc/gimple-ssa.h b/gcc/gimple-ssa.h index f2cffa2b159..79637058f70 100644 --- a/gcc/gimple-ssa.h +++ b/gcc/gimple-ssa.h @@ -76,8 +76,10 @@ struct GTY(()) gimple_df { /* Artificial variable used for the virtual operand FUD chain. */ tree vop; - /* The PTA solution for the ESCAPED artificial variable. */ + /* The PTA solution for the ESCAPED and ESCAPED_RETURN artificial + variables. */ struct pt_solution escaped; + struct pt_solution escaped_return; /* A map of decls to artificial ssa-names that point to the partition of the decl. */ diff --git a/gcc/ipa-icf.cc b/gcc/ipa-icf.cc index bbdfd445397..c72c9d57a80 100644 --- a/gcc/ipa-icf.cc +++ b/gcc/ipa-icf.cc @@ -3506,6 +3506,7 @@ sem_item_optimizer::fixup_points_to_sets (void) && SSA_NAME_PTR_INFO (name)) fixup_pt_set (&SSA_NAME_PTR_INFO (name)->pt); fixup_pt_set (&fn->gimple_df->escaped); + fixup_pt_set (&fn->gimple_df->escaped_return); /* The above gets us to 99% I guess, at least catching the address compares. Below also gets us aliasing correct diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pta-return-1.c b/gcc/testsuite/gcc.dg/tree-ssa/pta-return-1.c new file mode 100644 index 00000000000..9c2416e7810 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pta-return-1.c @@ -0,0 +1,16 @@ +/* PR112653 */ +/* { dg-do compile } */ +/* { dg-options "-O -fdump-tree-optimized" } */ + +char *test; +char * +copy_test () +{ + char *test2 = __builtin_malloc (1000); + __builtin_memmove (test2, test, 1000); + return test2; +} + +/* We should be able to turn the memmove into memcpy by means of alias + analysis. */ +/* { dg-final { scan-tree-dump "memcpy" "optimized" } } */ diff --git a/gcc/tree-inline.cc b/gcc/tree-inline.cc index 0b14118b94b..59847166842 100644 --- a/gcc/tree-inline.cc +++ b/gcc/tree-inline.cc @@ -5147,7 +5147,10 @@ expand_call_inline (basic_block bb, gimple *stmt, copy_body_data *id, /* Reset the escaped solution. */ if (cfun->gimple_df) - pt_solution_reset (&cfun->gimple_df->escaped); + { + pt_solution_reset (&cfun->gimple_df->escaped); + pt_solution_reset (&cfun->gimple_df->escaped_return); + } /* Add new automatic variables to IFN_GOMP_SIMT_ENTER arguments. */ if (id->dst_simt_vars && id->dst_simt_vars->length () > 0) diff --git a/gcc/tree-parloops.cc b/gcc/tree-parloops.cc index 80f3dd6dce2..50e61f00413 100644 --- a/gcc/tree-parloops.cc +++ b/gcc/tree-parloops.cc @@ -4147,7 +4147,10 @@ parallelize_loops (bool oacc_kernels_p) which local variables will escape. Reset the points-to solution for ESCAPED. */ if (changed) - pt_solution_reset (&cfun->gimple_df->escaped); + { + pt_solution_reset (&cfun->gimple_df->escaped); + pt_solution_reset (&cfun->gimple_df->escaped_return); + } return changed; } diff --git a/gcc/tree-sra.cc b/gcc/tree-sra.cc index 3a0d52675fe..0349410972e 100644 --- a/gcc/tree-sra.cc +++ b/gcc/tree-sra.cc @@ -2026,7 +2026,7 @@ maybe_add_sra_candidate (tree var) /* There are cases where non-addressable variables fail the pt_solutions_check test, e.g in gcc.dg/uninit-40.c. */ || (TREE_ADDRESSABLE (var) - && pt_solution_includes (&cfun->gimple_df->escaped, var)) + && pt_solution_includes (&cfun->gimple_df->escaped_return, var)) || (TREE_CODE (var) == RESULT_DECL && !DECL_BY_REFERENCE (var) && aggregate_value_p (var, current_function_decl))) diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc index 373940b5f6c..a708f7e8d28 100644 --- a/gcc/tree-ssa-alias.cc +++ b/gcc/tree-ssa-alias.cc @@ -496,7 +496,8 @@ ref_may_alias_global_p_1 (tree base, bool escaped_local_p) if (DECL_P (base)) return (is_global_var (base) || (escaped_local_p - && pt_solution_includes (&cfun->gimple_df->escaped, base))); + && pt_solution_includes (&cfun->gimple_df->escaped_return, + base))); else if (TREE_CODE (base) == MEM_REF || TREE_CODE (base) == TARGET_MEM_REF) return ptr_deref_may_alias_global_p (TREE_OPERAND (base, 0), @@ -579,6 +580,9 @@ dump_alias_info (FILE *file) fprintf (file, "\nESCAPED"); dump_points_to_solution (file, &cfun->gimple_df->escaped); + fprintf (file, "\nESCAPED_RETURN"); + dump_points_to_solution (file, &cfun->gimple_df->escaped_return); + fprintf (file, "\n\nFlow-insensitive points-to information\n\n"); FOR_EACH_SSA_NAME (i, ptr, cfun) diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc index ee9313c59ca..6db10d5fe11 100644 --- a/gcc/tree-ssa-structalias.cc +++ b/gcc/tree-ssa-structalias.cc @@ -365,8 +365,8 @@ vi_next (varinfo_t vi) /* Static IDs for the special variables. Variable ID zero is unused and used as terminator for the sub-variable chain. */ enum { nothing_id = 1, anything_id = 2, string_id = 3, - escaped_id = 4, nonlocal_id = 5, - storedanything_id = 6, integer_id = 7 }; + escaped_id = 4, nonlocal_id = 5, escaped_return_id = 6, + storedanything_id = 7, integer_id = 8 }; /* Return a new variable info structure consisting for a variable named NAME, and using constraint graph node NODE. Append it @@ -5221,23 +5221,18 @@ find_func_aliases (struct function *fn, gimple *origt) && gimple_return_retval (as_a (t)) != NULL_TREE) { greturn *return_stmt = as_a (t); - fi = NULL; - if (!in_ipa_mode - && SSA_VAR_P (gimple_return_retval (return_stmt))) - { - /* We handle simple returns by post-processing the solutions. */ - ; - } - if (!(fi = get_vi_for_tree (fn->decl))) - make_escape_constraint (gimple_return_retval (return_stmt)); - else if (in_ipa_mode) + tree retval = gimple_return_retval (return_stmt); + if (!in_ipa_mode) + make_constraint_to (escaped_return_id, retval); + else { struct constraint_expr lhs ; struct constraint_expr *rhsp; unsigned i; + fi = lookup_vi_for_tree (fn->decl); lhs = get_function_part_constraint (fi, fi_result); - get_constraint_for_rhs (gimple_return_retval (return_stmt), &rhsc); + get_constraint_for_rhs (retval, &rhsc); FOR_EACH_VEC_ELT (rhsc, i, rhsp) process_constraint (new_constraint (lhs, *rhsp)); } @@ -6665,6 +6660,7 @@ set_uids_in_ptset (bitmap into, bitmap from, struct pt_solution *pt, unsigned int i; bitmap_iterator bi; varinfo_t escaped_vi = get_varinfo (find (escaped_id)); + varinfo_t escaped_return_vi = get_varinfo (find (escaped_return_id)); bool everything_escaped = escaped_vi->solution && bitmap_bit_p (escaped_vi->solution, anything_id); @@ -6682,6 +6678,9 @@ set_uids_in_ptset (bitmap into, bitmap from, struct pt_solution *pt, pt->vars_contains_escaped = true; pt->vars_contains_escaped_heap |= vi->is_heap_var; } + if (escaped_return_vi->solution + && bitmap_bit_p (escaped_return_vi->solution, i)) + pt->vars_contains_escaped_heap |= vi->is_heap_var; if (vi->is_restrict_var) pt->vars_contains_restrict = true; @@ -7196,6 +7195,7 @@ init_base_vars (void) varinfo_t var_string; varinfo_t var_escaped; varinfo_t var_nonlocal; + varinfo_t var_escaped_return; varinfo_t var_storedanything; varinfo_t var_integer; @@ -7271,6 +7271,16 @@ init_base_vars (void) var_nonlocal->fullsize = ~0; var_nonlocal->is_special_var = 1; + /* Create the ESCAPED_RETURN variable, used to represent the set of escaped + memory via a regular return stmt. */ + var_escaped_return = new_var_info (NULL_TREE, "ESCAPED_RETURN", false); + gcc_assert (var_escaped_return->id == escaped_return_id); + var_escaped_return->is_artificial_var = 1; + var_escaped_return->offset = 0; + var_escaped_return->size = ~0; + var_escaped_return->fullsize = ~0; + var_escaped_return->is_special_var = 0; + /* ESCAPED = *ESCAPED, because escaped is may-deref'd at calls, etc. */ lhs.type = SCALAR; lhs.var = escaped_id; @@ -7315,6 +7325,24 @@ init_base_vars (void) rhs.offset = 0; process_constraint (new_constraint (lhs, rhs)); + /* Transitively close ESCAPED_RETURN. + ESCAPED_RETURN = ESCAPED_RETURN + UNKNOWN_OFFSET + ESCAPED_RETURN = *ESCAPED_RETURN. */ + lhs.type = SCALAR; + lhs.var = escaped_return_id; + lhs.offset = 0; + rhs.type = SCALAR; + rhs.var = escaped_return_id; + rhs.offset = UNKNOWN_OFFSET; + process_constraint (new_constraint (lhs, rhs)); + lhs.type = SCALAR; + lhs.var = escaped_return_id; + lhs.offset = 0; + rhs.type = DEREF; + rhs.var = escaped_return_id; + rhs.offset = 0; + process_constraint (new_constraint (lhs, rhs)); + /* Create the STOREDANYTHING variable, used to represent the set of variables stored to *ANYTHING. */ var_storedanything = new_var_info (NULL_TREE, "STOREDANYTHING", false); @@ -7555,70 +7583,6 @@ compute_points_to_sets (void) /* From the constraints compute the points-to sets. */ solve_constraints (); - /* Post-process solutions for escapes through returns. */ - edge_iterator ei; - edge e; - FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) - if (greturn *ret = safe_dyn_cast (*gsi_last_bb (e->src))) - { - tree val = gimple_return_retval (ret); - /* ??? Easy to handle simple indirections with some work. - Arbitrary references like foo.bar.baz are more difficult - (but conservatively easy enough with just looking at the base). - Mind to fixup find_func_aliases as well. */ - if (!val || !SSA_VAR_P (val)) - continue; - /* returns happen last in non-IPA so they only influence - the ESCAPED solution and we can filter local variables. */ - varinfo_t escaped_vi = get_varinfo (find (escaped_id)); - varinfo_t vi = lookup_vi_for_tree (val); - bitmap delta = BITMAP_ALLOC (&pta_obstack); - bitmap_iterator bi; - unsigned i; - for (; vi; vi = vi_next (vi)) - { - varinfo_t part_vi = get_varinfo (find (vi->id)); - EXECUTE_IF_AND_COMPL_IN_BITMAP (part_vi->solution, - escaped_vi->solution, 0, i, bi) - { - varinfo_t pointed_to_vi = get_varinfo (i); - if (pointed_to_vi->is_global_var - /* We delay marking of heap memory as global. */ - || pointed_to_vi->is_heap_var) - bitmap_set_bit (delta, i); - } - } - - /* Now compute the transitive closure. */ - bitmap_ior_into (escaped_vi->solution, delta); - bitmap new_delta = BITMAP_ALLOC (&pta_obstack); - while (!bitmap_empty_p (delta)) - { - EXECUTE_IF_SET_IN_BITMAP (delta, 0, i, bi) - { - varinfo_t pointed_to_vi = get_varinfo (i); - pointed_to_vi = get_varinfo (find (pointed_to_vi->id)); - unsigned j; - bitmap_iterator bi2; - EXECUTE_IF_AND_COMPL_IN_BITMAP (pointed_to_vi->solution, - escaped_vi->solution, - 0, j, bi2) - { - varinfo_t pointed_to_vi2 = get_varinfo (j); - if (pointed_to_vi2->is_global_var - /* We delay marking of heap memory as global. */ - || pointed_to_vi2->is_heap_var) - bitmap_set_bit (new_delta, j); - } - } - bitmap_ior_into (escaped_vi->solution, new_delta); - bitmap_clear (delta); - std::swap (delta, new_delta); - } - BITMAP_FREE (delta); - BITMAP_FREE (new_delta); - } - if (dump_file && (dump_flags & TDF_STATS)) dump_sa_stats (dump_file); @@ -7634,6 +7598,12 @@ compute_points_to_sets (void) points-to solution queries. */ cfun->gimple_df->escaped.escaped = 0; + /* The ESCAPED_RETURN solution is what contains all memory that needs + to be considered global. */ + cfun->gimple_df->escaped_return + = find_what_var_points_to (cfun->decl, get_varinfo (escaped_return_id)); + cfun->gimple_df->escaped_return.escaped = 1; + /* Compute the points-to sets for pointer SSA_NAMEs. */ unsigned i; tree ptr; diff --git a/gcc/tree-ssa.cc b/gcc/tree-ssa.cc index 3858a63de20..9e6233fea2c 100644 --- a/gcc/tree-ssa.cc +++ b/gcc/tree-ssa.cc @@ -1216,6 +1216,7 @@ init_tree_ssa (struct function *fn, int size) fn->gimple_df = ggc_cleared_alloc (); fn->gimple_df->default_defs = hash_table::create_ggc (20); pt_solution_reset (&fn->gimple_df->escaped); + pt_solution_reset (&fn->gimple_df->escaped_return); init_ssanames (fn, size); } @@ -1233,6 +1234,7 @@ delete_tree_ssa (struct function *fn) fn->gimple_df->default_defs->empty (); fn->gimple_df->default_defs = NULL; pt_solution_reset (&fn->gimple_df->escaped); + pt_solution_reset (&fn->gimple_df->escaped_return); if (fn->gimple_df->decls_to_pointers != NULL) delete fn->gimple_df->decls_to_pointers; fn->gimple_df->decls_to_pointers = NULL;