From patchwork Sat Jan 25 09:54:52 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Feng Xue OS X-Patchwork-Id: 1229184 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-518251-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=os.amperecomputing.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha1 header.s=default header.b=oP1OMrK4; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=os.amperecomputing.com header.i=@os.amperecomputing.com header.a=rsa-sha256 header.s=selector2 header.b=MLT3qYwN; 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 484Wb35fx7z9sRf for ; Sat, 25 Jan 2020 20:55:09 +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:from :to:subject:date:message-id:content-type:mime-version; q=dns; s= default; b=pbX3GxI2g91FvDnysYrghLgb3ewbId5eKmzHhMfKWThiuivJ84h00 Nx8sCO0WWPpJRvNqy8rAqzGqVQftF/ksoXZ5Vq/ASnfxdRYnCVa09DZMl5U/qzO6 ZAvlyBbXqdBF/X3IxfsJsmbdjdt/lY6kTVXs6zIarEG/0dZHJmfPHM= 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:from :to:subject:date:message-id:content-type:mime-version; s= default; bh=lgJhJaXXbZQ3xpPR2QW+SS6U6VA=; b=oP1OMrK4uiwMbvWheY+r tPUFH50D4RtQqzNUdikdw1djckibzmrVEW32RU9xIeddj5wdwFcl1DGaFU1HYDOS dw6bUXzsPCmoOiAOYMvX1OqoeKU3KPV13oG2z5uGsmY9pDwcRWDc3tlaZBhYLCVm dAfXdtAQslgJSL8sdGqIKdg= Received: (qmail 74729 invoked by alias); 25 Jan 2020 09:55:01 -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 74721 invoked by uid 89); 25 Jan 2020 09:55:01 -0000 Authentication-Results: sourceware.org; auth=none 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, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.1 spammy=UD:bd, sk:useless, aman, passed-in X-HELO: NAM10-DM6-obe.outbound.protection.outlook.com Received: from mail-dm6nam10on2136.outbound.protection.outlook.com (HELO NAM10-DM6-obe.outbound.protection.outlook.com) (40.107.93.136) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 25 Jan 2020 09:54:58 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=apO91WXg8vgWbdPXwmRvTOWKSDpxeBsaXDECqekr4oYzhcBmU6v8EC4NLY3UmD/krT9acqw47zEH40tLoIHbEPvryM1aw2BYTSj5SjxrGF8f4EcZpAVqQgenuNQAXxLP+xNWKEl+AT3xg86K6kiQQjlUtSIcCSngRAh7roOri5rhFp4LZcil4y27zP+TAkX7EoAkyUj6nwawDAxNtc6XfBh/elDwWOsCb2RTx/P6qkqndyQjCcpIYOIR8vr9PRxUnPlkUFfq5QErMRlPIlF4NBeGRP5+EuVc6pV7MMJl5H5XEEKPk0jdapO27urbyEOS9lcQBnyK04uWEwWW8X0ovA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=zUnJmaKZ6YDmjDfxZ6TAdfMixPxRnh1h/LiRbGLBjLs=; b=KTwyZXw5Siy3V3MpP9Lu68fdqxl32FTbYuHi5HXDOdxfbxtpBsKBdrHxDXvB3qLvPzDbFxDa7l5Zt4tWEF11gklO/TCDw9gR/mIZUewB09Drfz9qUZpfkxK/+R8es7wXEGrNw7lUFlusJaBN0CIStN+dF4ZGEBeMvh4/4DST1FBxTmvGiy8S/hmnN11+Leki2PqH2dpm3nyaLxR/TcgRM7FISAUdZtSl7y/av46K/FwNFKHlsxCS+liIgdfbQTbkGVyPlf4Yfp4Ygn8uaXdlyjm/8QNU0NoPN84Oe0wbWmf/H8nxwuZkjnd26osgcUP19xTh2ONllJNm1691YsxeTg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=os.amperecomputing.com; dmarc=pass action=none header.from=os.amperecomputing.com; dkim=pass header.d=os.amperecomputing.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=os.amperecomputing.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=zUnJmaKZ6YDmjDfxZ6TAdfMixPxRnh1h/LiRbGLBjLs=; b=MLT3qYwNhT1xnASWNUo7Wb83OlIoPAhnk6jCRD0IeRNw+7rxUFJ0MujuFEPDbrNZ+SOBV72V25Vp1Za73uP/Xh2jn2DGneUBKEtjMiE1RT6kuKH+qPzrTShwdKnjbexF1d1As1wLInL1tgW6Sk3NPiZa1XgyTxLsuZ/6+2YGn3g= Received: from BYAPR01MB4869.prod.exchangelabs.com (20.177.226.139) by BYAPR01MB4872.prod.exchangelabs.com (20.177.226.19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2665.20; Sat, 25 Jan 2020 09:54:54 +0000 Received: from BYAPR01MB4869.prod.exchangelabs.com ([fe80::b092:f9fd:5516:bba]) by BYAPR01MB4869.prod.exchangelabs.com ([fe80::b092:f9fd:5516:bba%7]) with mapi id 15.20.2665.017; Sat, 25 Jan 2020 09:54:52 +0000 From: Feng Xue OS To: "mjambor@suse.cz" , Jan Hubicka , "gcc-patches@gcc.gnu.org" Subject: [PATCH] Generalized value pass-through for self-recursive function (ipa/pr93203) Date: Sat, 25 Jan 2020 09:54:52 +0000 Message-ID: authentication-results: spf=none (sender IP is ) smtp.mailfrom=fxue@os.amperecomputing.com; x-ms-oob-tlc-oobclassifiers: OLM:5797; received-spf: None (protection.outlook.com: os.amperecomputing.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-messagedata: 4GkU5vIHRArshNk34525NVOKGAzfdJjZvO3Uzch09l+7vk6Uni/14cS6MUK4qqz1QzWqftEjkXS9LOUNza0JD21zhpugvXtxPR+vx9+GTTVWZhsXw//XNrNVLH4lqb7llZzSYdxCQH7syUhKgwEDmA== x-ms-exchange-transport-forked: True MIME-Version: 1.0 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: b8lhik8i3s+qVUFX8mKlty+1MRn6/yMOzi9QzPkKuNwtq5GD2hHLBpvV3kIOYTVcMSPmSmUlbUru7q/tO8iX60RHWFhCWxOhtNOMA84w7Gs= X-IsSubscribed: yes Besides simple pass-through (aggregate) jump function, arithmetic (aggregate) jump function could also bring same (aggregate) value as parameter passed-in for self-feeding recursive call. For example, f1 (int i) /* normal jump function */ { f1 (i & 1); } Suppose i is 0, recursive propagation via (i & 1) also gets 0, which can be seen as a simple pass-through of i. f2 (int *p) /* aggregate jump function */ { int t = *p & 1; f2 (&t); } Likewise, if *p is 0, (*p & 1) is also 0, and &t is an aggregate simple pass-through of p. This patch is to support these two kinds of value pass-through. Bootstrapped/regtested on x86_64-linux and aarch64-linux. Feng --- 2020-01-25 Feng Xue PR ipa/93203 * ipa-cp.c (ipcp_lattice::add_value): Add source with same call edge but different source value. (adjust_callers_for_value_intersection): New function. (gather_edges_for_value): Adjust order of callers to let a non-self-recursive caller be the first element. (self_recursive_pass_through_p): Add a new parameter simple, and check generalized self-recursive pass-through jump function. (self_recursive_agg_pass_through_p): Likewise. (find_more_scalar_values_for_callers_subset): Compute value from pass-through jump function for self-recursive. (intersect_with_plats): Remove code of itersection with unknown place holder value. (intersect_with_agg_replacements): Likewise. (intersect_aggregates_with_edge): Deduce with from pass-through jump function for self-recursive. (decide_whether_version_node): Remove dead callers and adjust order to let a non-self-recursive caller be the first element. From 406c23711077c0df18d5e77270d0a82be098224b Mon Sep 17 00:00:00 2001 From: Feng Xue Date: Tue, 21 Jan 2020 20:53:38 +0800 Subject: [PATCH] Generalized value pass-through for self-recusive function --- gcc/ipa-cp.c | 196 ++++++++++++++++++----------- gcc/testsuite/g++.dg/ipa/pr93203.C | 95 ++++++++++++++ gcc/testsuite/gcc.dg/ipa/ipcp-1.c | 2 +- 3 files changed, 217 insertions(+), 76 deletions(-) create mode 100644 gcc/testsuite/g++.dg/ipa/pr93203.C diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index 17da1d8e8a7..533a429ba3b 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -1850,7 +1850,7 @@ ipcp_lattice::add_value (valtype newval, cgraph_edge *cs, { ipcp_value_source *s; for (s = val->sources; s; s = s->next) - if (s->cs == cs) + if (s->cs == cs && s->val == src_val) break; if (s) return false; @@ -4207,6 +4207,33 @@ get_info_about_necessary_edges (ipcp_value *val, cgraph_node *dest, return hot; } +/* Given a NODE, and a set of its CALLERS, try to adjust order of the callers + to let a non-self-recursive caller be the first element. Thus, we can + simplify intersecting operations on values that arrive from all of these + callers, especially when there exists self-recursive call. Return true if + this kind of adjustment is possible. */ + +static bool +adjust_callers_for_value_intersection (vec callers, + cgraph_node *node) +{ + for (unsigned i = 0; i < callers.length (); i++) + { + cgraph_edge *cs = callers[i]; + + if (cs->caller != node) + { + if (i > 0) + { + callers[i] = callers[0]; + callers[0] = cs; + } + return true; + } + } + return false; +} + /* Return a vector of incoming edges that do bring value VAL to node DEST. It is assumed their number is known and equal to CALLER_COUNT. */ @@ -4230,6 +4257,9 @@ gather_edges_for_value (ipcp_value *val, cgraph_node *dest, } } + if (caller_count > 1) + adjust_callers_for_value_intersection (ret, dest); + return ret; } @@ -4241,7 +4271,6 @@ get_replacement_map (class ipa_node_params *info, tree value, int parm_num) { struct ipa_replace_map *replace_map; - replace_map = ggc_alloc (); if (dump_file) { @@ -4592,36 +4621,40 @@ create_specialized_node (struct cgraph_node *node, } /* Return true, if JFUNC, which describes a i-th parameter of call CS, is a - simple no-operation pass-through function to itself. */ + pass-through function to itself. When SIMPLE is true, further check if + JFUNC is a simple no-operation pass-through. */ static bool -self_recursive_pass_through_p (cgraph_edge *cs, ipa_jump_func *jfunc, int i) +self_recursive_pass_through_p (cgraph_edge *cs, ipa_jump_func *jfunc, int i, + bool simple = true) { enum availability availability; if (cs->caller == cs->callee->function_symbol (&availability) && availability > AVAIL_INTERPOSABLE && jfunc->type == IPA_JF_PASS_THROUGH - && ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR + && (!simple || ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR) && ipa_get_jf_pass_through_formal_id (jfunc) == i) return true; return false; } /* Return true, if JFUNC, which describes a part of an aggregate represented - or pointed to by the i-th parameter of call CS, is a simple no-operation - pass-through function to itself. */ + or pointed to by the i-th parameter of call CS, is a pass-through function + to itself. When SIMPLE is true, further check if JFUNC is a simple + no-operation pass-through. */ static bool self_recursive_agg_pass_through_p (cgraph_edge *cs, ipa_agg_jf_item *jfunc, - int i) + int i, bool simple = true) { enum availability availability; if (cs->caller == cs->callee->function_symbol (&availability) && availability > AVAIL_INTERPOSABLE && jfunc->jftype == IPA_JF_LOAD_AGG && jfunc->offset == jfunc->value.load_agg.offset - && jfunc->value.pass_through.operation == NOP_EXPR - && jfunc->value.pass_through.formal_id == i) + && (!simple || jfunc->value.pass_through.operation == NOP_EXPR) + && jfunc->value.pass_through.formal_id == i + && useless_type_conversion_p (jfunc->value.load_agg.type, jfunc->type)) return true; return false; } @@ -4653,9 +4686,6 @@ find_more_scalar_values_for_callers_subset (struct cgraph_node *node, struct ipa_jump_func *jump_func; tree t; - if (IPA_NODE_REF (cs->caller) && IPA_NODE_REF (cs->caller)->node_dead) - continue; - if (!IPA_EDGE_REF (cs) || i >= ipa_get_cs_argument_count (IPA_EDGE_REF (cs)) || (i == 0 @@ -4665,10 +4695,30 @@ find_more_scalar_values_for_callers_subset (struct cgraph_node *node, break; } jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i); - if (self_recursive_pass_through_p (cs, jump_func, i)) - continue; - t = ipa_value_from_jfunc (IPA_NODE_REF (cs->caller), jump_func, type); + /* Besides simple pass-through jump function, arithmetic jump + function could also introduce argument-direct-pass-through for + self-feeding recursive call. For example, + + fn (int i) + { + fn (i & 1); + } + + Given that i is 0, recursive propagation via (i & 1) also gets + 0. */ + if (self_recursive_pass_through_p (cs, jump_func, i, false)) + { + gcc_assert (newval); + t = ipa_get_jf_arith_result ( + ipa_get_jf_pass_through_operation (jump_func), + newval, + ipa_get_jf_pass_through_operand (jump_func), + type); + } + else + t = ipa_value_from_jfunc (IPA_NODE_REF (cs->caller), jump_func, + type); if (!t || (newval && !values_equal_for_ipcp_p (t, newval)) @@ -4817,19 +4867,12 @@ intersect_with_plats (class ipcp_param_lattices *plats, break; if (aglat->offset - offset == item->offset) { - gcc_checking_assert (item->value); if (aglat->is_single_const ()) { tree value = aglat->values->value; if (values_equal_for_ipcp_p (item->value, value)) found = true; - else if (item->value == error_mark_node) - { - /* Replace unknown place holder value with real one. */ - item->value = value; - found = true; - } } break; } @@ -4898,12 +4941,6 @@ intersect_with_agg_replacements (struct cgraph_node *node, int index, { if (values_equal_for_ipcp_p (item->value, av->value)) found = true; - else if (item->value == error_mark_node) - { - /* Replace place holder value with real one. */ - item->value = av->value; - found = true; - } break; } } @@ -5008,31 +5045,16 @@ intersect_aggregates_with_edge (struct cgraph_edge *cs, int index, for (unsigned i = 0; i < jfunc->agg.items->length (); i++) { struct ipa_agg_jf_item *agg_item = &(*jfunc->agg.items)[i]; - struct ipa_agg_value agg_value; - - if (self_recursive_agg_pass_through_p (cs, agg_item, index)) + tree value = ipa_agg_value_from_node (caller_info, cs->caller, + agg_item); + if (value) { - /* For a self-recursive call, if aggregate jump function is a - simple pass-through, the exact value that it stands for is - not known at this point, which must comes from other call - sites. But we still need to add a place holder in value - sets to indicate it, here we use error_mark_node to - represent the special unknown value, which will be replaced - with real one during later intersecting operations. */ - agg_value.value = error_mark_node; - } - else - { - tree value = ipa_agg_value_from_node (caller_info, cs->caller, - agg_item); - if (!value) - continue; + struct ipa_agg_value agg_value; agg_value.value = value; + agg_value.offset = agg_item->offset; + inter.safe_push (agg_value); } - - agg_value.offset = agg_item->offset; - inter.safe_push (agg_value); } else FOR_EACH_VEC_ELT (inter, k, item) @@ -5053,25 +5075,32 @@ intersect_aggregates_with_edge (struct cgraph_edge *cs, int index, { tree value; - if (self_recursive_agg_pass_through_p (cs, ti, index)) - { - /* A simple aggregate pass-through in self-recursive - call should lead to same value. */ - found = true; - } - else if ((value = ipa_agg_value_from_node (caller_info, - cs->caller, ti))) - { - if (values_equal_for_ipcp_p (item->value, value)) - found = true; - else if (item->value == error_mark_node) - { - /* Replace unknown place holder value with real - one. */ - item->value = value; - found = true; - } - } + /* Besides simple pass-through aggregate jump function, + arithmetic aggregate jump function could also bring + same aggregate value as parameter passed-in for + self-feeding recursive call. For example, + + fn (int *i) + { + int j = *i & 1; + fn (&j); + } + + Given that *i is 0, recursive propagation via (*i & 1) + also gets 0. */ + if (self_recursive_agg_pass_through_p (cs, ti, index, + false)) + value = ipa_get_jf_arith_result ( + ti->value.pass_through.operation, + item->value, + ti->value.pass_through.operand, + ti->type); + else + value = ipa_agg_value_from_node (caller_info, + cs->caller, ti); + + if (value && values_equal_for_ipcp_p (item->value, value)) + found = true; break; } l++; @@ -5147,9 +5176,6 @@ find_aggregate_values_for_callers_subset (struct cgraph_node *node, if (!item->value) continue; - /* All values must be real values, not unknown place holders. */ - gcc_assert (item->value != error_mark_node); - v = ggc_alloc (); v->index = i; v->offset = item->offset; @@ -5488,6 +5514,7 @@ decide_whether_version_node (struct cgraph_node *node) int i, count = ipa_get_param_count (info); vec known_csts; vec known_contexts; + vec callers; bool ret = false; if (count == 0) @@ -5542,16 +5569,36 @@ decide_whether_version_node (struct cgraph_node *node) info = IPA_NODE_REF (node); } + if (info->do_clone_for_all_contexts) + { + callers = node->collect_callers (); + + for (unsigned i = 0; i < callers.length (); i++) + { + cgraph_edge *cs = callers[i]; + class ipa_node_params *caller_info = IPA_NODE_REF (cs->caller); + + if (caller_info && caller_info->node_dead) + callers.unordered_remove (i); + } + + if (!adjust_callers_for_value_intersection (callers, node)) + { + /* If all caller edges of node are self-recursive, the node + is not really be in use, no need to do cloning. */ + callers.release (); + info->do_clone_for_all_contexts = false; + } + } + if (info->do_clone_for_all_contexts) { struct cgraph_node *clone; - vec callers; if (dump_file) fprintf (dump_file, " - Creating a specialized node of %s " "for all known contexts.\n", node->dump_name ()); - callers = node->collect_callers (); find_more_scalar_values_for_callers_subset (node, known_csts, callers); find_more_contexts_for_caller_subset (node, &known_contexts, callers); ipa_agg_replacement_value *aggvals @@ -5564,7 +5611,6 @@ decide_whether_version_node (struct cgraph_node *node) } clone = create_specialized_node (node, known_csts, known_contexts, aggvals, callers); - info = IPA_NODE_REF (node); info->do_clone_for_all_contexts = false; IPA_NODE_REF (clone)->is_all_contexts_clone = true; ret = true; diff --git a/gcc/testsuite/g++.dg/ipa/pr93203.C b/gcc/testsuite/g++.dg/ipa/pr93203.C new file mode 100644 index 00000000000..b4cd69001b5 --- /dev/null +++ b/gcc/testsuite/g++.dg/ipa/pr93203.C @@ -0,0 +1,95 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -w -std=gnu++11" } */ + +class a { +public: + a(char *); +}; +class ad { +public: + ad(a *); +}; +class b {}; +using ah = class ak { + using al = char; + +public: + ak(b) : ak(0) {} + ak an() { return ap & 1; } + al ap; + ak(al af) : ap(af) {} +}; +struct at { + ah au; + int av; + char aw; + char ax; +}; +class az { +public: + struct ba { + void bb(ak am) { + ak bc = am.an(); + bb(bc); + } + }; + void bd(ak am) { be.bb(am); } + ba be; +}; +class bg { +public: + int bh; + at bi; +}; +int bj; +int *bk; +int c; +class bl { + bool bm(); + bg bn; + az bo; + int e; + int bq; +}; +class bs { +public: + bs(int *, ah *, char *, char *, int); +}; +template < typename bt > class bu : bs { + using bv = typename bt::bv; + +public: + template < typename... bx > + bu(a *by, int *bz, at body, bx...) + : bs(bz, &body.au, &body.aw, &body.ax, body.av), ca(bx()...), cb(by), + cc(by), cd(by), ce(by) {} + void cf() { + auto cg = ch(); + auto ci = *cj(); + ca.ck(this, cg, &ci); + } + bt ca; + ad cb; + ad cc; + ad cd; + ad ce; + bv *cj(); + bv ch(); +}; +class cl { +public: + using bv = struct {}; + cl(az *, int, int, int, int, a *, int, int **); + void ck(bs *, bv, bv *) { + b d; + ak ci(d); + bo.bd(ci); + } + az bo; +}; +bool bl::bm() { + a by(""); + bu< cl > cn(&by, &bj, bn.bi, &bo, c, bn.bh, e, 0, &by, bq, &bk); + cn.cf(); +} + diff --git a/gcc/testsuite/gcc.dg/ipa/ipcp-1.c b/gcc/testsuite/gcc.dg/ipa/ipcp-1.c index 952694d302b..baa9c97ffb0 100644 --- a/gcc/testsuite/gcc.dg/ipa/ipcp-1.c +++ b/gcc/testsuite/gcc.dg/ipa/ipcp-1.c @@ -45,7 +45,7 @@ main (int argc, char *argv[]) } -/* { dg-final { scan-ipa-dump "Creating a specialized node of f.*for all known contexts" "cp" } } */ +/* { dg-final { scan-ipa-dump "Creating a specialized node of f" "cp" } } */ /* { dg-final { scan-ipa-dump "replacing param .0 a with const 7" "cp" } } */ -- 2.17.1