From patchwork Wed May 16 07:15:05 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: =?utf-8?q?Martin_Li=C5=A1ka?= X-Patchwork-Id: 914216 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-477737-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=suse.cz Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="A41PfB7q"; 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 40m5MK3hhNz9s2k for ; Wed, 16 May 2018 17:16:11 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :subject:to:message-id:date:mime-version:content-type; q=dns; s= default; b=rQGFqYFTfI4IJPR9WFxC1DE0DNKfr1jy/GLbXj0VYj6J5pJvTEzv0 N02FLWNEOJRTqdDlPiRzmFABAblzKQD4jMOGumzX2v60I3t3e1pZCDGaFdfP+Qd0 Y2relzzKoKJtk87x7JzeAAc78mmPjGhCfb99/ej3dshHY44wGggJpo= 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 :subject:to:message-id:date:mime-version:content-type; s= default; bh=Mu3gHG/URVVdW4P4Fg6m//vtA8o=; b=A41PfB7qv3TNSixIgdiq QxXylf0ByyEaUiTcNq1IOmCDNkR6DNYpLnVg1qgx7LdoUo9n91j3ig7pnzM1017h yJijhkSgHn02MOMnGPuRTcB/xEO/VvoudktbbjuDfOeyGq1Latb3Hei5VudMRFCq W3nTmrwQLwV7aJuXiRJPWUQ= Received: (qmail 24140 invoked by alias); 16 May 2018 07:16:02 -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 69163 invoked by uid 89); 16 May 2018 07:15:42 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.1 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, SPF_PASS, TIME_LIMIT_EXCEEDED autolearn=unavailable version=3.3.2 spammy=Unified, sk:scan-ip, sk:scanip, Doing 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, 16 May 2018 07:15:26 +0000 Received: from relay2.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id A46E4AD48 for ; Wed, 16 May 2018 07:15:05 +0000 (UTC) From: =?utf-8?q?Martin_Li=C5=A1ka?= Subject: [PATCH] Support lower and upper limit for -fdbg-cnt flag. To: gcc-patches@gcc.gnu.org Message-ID: Date: Wed, 16 May 2018 09:15:05 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.7.0 MIME-Version: 1.0 X-IsSubscribed: yes Hi. I consider it handy sometimes to trigger just a single invocation of an optimization driven by a debug counter. Doing that one needs to be able to limit both lower and upper limit of a counter. It's implemented in the patch. Patch can bootstrap on x86_64-linux-gnu and survives regression tests. Ready to be installed? Martin gcc/ChangeLog: 2018-05-15 Martin Liska * dbgcnt.c (limit_low): Renamed from limit. (limit_high): New variable. (dbg_cnt_is_enabled): Check for upper limit. (dbg_cnt): Adjust dumping. (dbg_cnt_set_limit_by_index): Add new argument for high value. (dbg_cnt_set_limit_by_name): Likewise. (dbg_cnt_process_single_pair): Parse new format. (dbg_cnt_process_opt): Use strtok. (dbg_cnt_list_all_counters): Remove 'value' and add 'limit_high'. * doc/invoke.texi: Document changes. gcc/testsuite/ChangeLog: 2018-05-15 Martin Liska * gcc.dg/ipa/ipa-icf-39.c: New test. * gcc.dg/pr68766.c: Adjust pruned output. --- gcc/common.opt | 2 +- gcc/dbgcnt.c | 113 ++++++++++++++++++++++------------ gcc/doc/invoke.texi | 9 +-- gcc/testsuite/gcc.dg/ipa/ipa-icf-39.c | 33 ++++++++++ gcc/testsuite/gcc.dg/pr68766.c | 2 +- 5 files changed, 112 insertions(+), 47 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/ipa/ipa-icf-39.c diff --git a/gcc/common.opt b/gcc/common.opt index d6ef85928f3..d2f8736a62d 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -1171,7 +1171,7 @@ List all available debugging counters with their limits and counts. fdbg-cnt= Common RejectNegative Joined Var(common_deferred_options) Defer --fdbg-cnt=:[,:,...] Set the debug counter limit. +-fdbg-cnt=[:]:[,::,...] Set the debug counter limit. fdebug-prefix-map= Common Joined RejectNegative Var(common_deferred_options) Defer diff --git a/gcc/dbgcnt.c b/gcc/dbgcnt.c index 96b3df28f5e..13d0ad8190a 100644 --- a/gcc/dbgcnt.c +++ b/gcc/dbgcnt.c @@ -41,53 +41,72 @@ static struct string2counter_map map[debug_counter_number_of_counters] = #undef DEBUG_COUNTER #define DEBUG_COUNTER(a) UINT_MAX, -static unsigned int limit[debug_counter_number_of_counters] = +static unsigned int limit_high[debug_counter_number_of_counters] = { #include "dbgcnt.def" }; #undef DEBUG_COUNTER +#define DEBUG_COUNTER(a) 1, +static unsigned int limit_low[debug_counter_number_of_counters] = +{ +#include "dbgcnt.def" +}; +#undef DEBUG_COUNTER + + static unsigned int count[debug_counter_number_of_counters]; bool dbg_cnt_is_enabled (enum debug_counter index) { - return count[index] <= limit[index]; + return limit_low[index] <= count[index] && count[index] <= limit_high[index]; } bool dbg_cnt (enum debug_counter index) { count[index]++; - if (dump_file && count[index] == limit[index]) - fprintf (dump_file, "***dbgcnt: limit reached for %s.***\n", - map[index].name); + + if (dump_file) + { + /* Do not print the info for default lower limit. */ + if (count[index] == limit_low[index] && limit_low[index] > 1) + fprintf (dump_file, "***dbgcnt: lower limit %d reached for %s.***\n", + limit_low[index], map[index].name); + else if (count[index] == limit_high[index]) + fprintf (dump_file, "***dbgcnt: upper limit %d reached for %s.***\n", + limit_high[index], map[index].name); + } return dbg_cnt_is_enabled (index); } - static void -dbg_cnt_set_limit_by_index (enum debug_counter index, int value) +dbg_cnt_set_limit_by_index (enum debug_counter index, int low, int high) { - limit[index] = value; + limit_low[index] = low; + limit_high[index] = high; - fprintf (stderr, "dbg_cnt '%s' set to %d\n", map[index].name, value); + fprintf (stderr, "dbg_cnt '%s' set to %d-%d\n", map[index].name, low, high); } static bool -dbg_cnt_set_limit_by_name (const char *name, int len, int value) +dbg_cnt_set_limit_by_name (const char *name, int low, int high) { + if (high < low) + error ("-fdbg-cnt=%s:%d:%d has smaller upper limit than the lower", + name, low, high); + int i; for (i = debug_counter_number_of_counters - 1; i >= 0; i--) - if (strncmp (map[i].name, name, len) == 0 - && map[i].name[len] == '\0') + if (strcmp (map[i].name, name) == 0) break; if (i < 0) return false; - dbg_cnt_set_limit_by_index ((enum debug_counter) i, value); + dbg_cnt_set_limit_by_index ((enum debug_counter) i, low, high); return true; } @@ -96,42 +115,53 @@ dbg_cnt_set_limit_by_name (const char *name, int len, int value) Returns NULL if there's no valid pair is found. Otherwise returns a pointer to the end of the pair. */ -static const char * +static bool dbg_cnt_process_single_pair (const char *arg) { - const char *colon = strchr (arg, ':'); - char *endptr = NULL; - int value; - - if (colon == NULL) - return NULL; - - value = strtol (colon + 1, &endptr, 10); - - if (endptr != NULL && endptr != colon + 1 - && dbg_cnt_set_limit_by_name (arg, colon - arg, value)) - return endptr; - - return NULL; + char *str = xstrdup (arg); + char *name = strtok (str, ":"); + char *value1 = strtok (NULL, ":"); + char *value2 = strtok (NULL, ":"); + + int high, low; + + if (value1 == NULL) + return NULL; + + if (value2 == NULL) + { + low = 1; + high = strtol (value1, NULL, 10); + } + else + { + low = strtol (value1, NULL, 10); + high = strtol (value2, NULL, 10); + } + + return dbg_cnt_set_limit_by_name (name, low, high); } void dbg_cnt_process_opt (const char *arg) { - const char *start = arg; - const char *next; + char *str = xstrdup (arg); + const char *next = strtok (str, ","); + unsigned int start = 0; + do { - next = dbg_cnt_process_single_pair (arg); - if (next == NULL) + if (!dbg_cnt_process_single_pair (arg)) break; - } while (*next == ',' && (arg = next + 1)); + start += strlen (arg) + 1; + next = strtok (NULL, ","); + } while (next != NULL); - if (next == NULL || *next != 0) + if (next != NULL) { - char *buffer = XALLOCAVEC (char, arg - start + 2); - sprintf (buffer, "%*c", (int)(1 + (arg - start)), '^'); + char *buffer = XALLOCAVEC (char, start + 2); + sprintf (buffer, "%*c", start + 1, '^'); error ("cannot find a valid counter:value pair:"); - error ("-fdbg-cnt=%s", start); + error ("-fdbg-cnt=%s", next); error (" %s", buffer); } } @@ -142,10 +172,11 @@ void dbg_cnt_list_all_counters (void) { int i; - printf (" %-30s %-5s %-5s\n", "counter name", "limit", "value"); - printf ("----------------------------------------------\n"); + printf (" %-32s %-11s %-12s\n", "counter name", "low limit", + "high limit"); + printf ("-----------------------------------------------------------------\n"); for (i = 0; i < debug_counter_number_of_counters; i++) - printf (" %-30s %5d %5u\n", - map[i].name, limit[map[i].counter], count[map[i].counter]); + printf (" %-30s %11u %12u\n", + map[i].name, limit_low[map[i].counter], limit_high[map[i].counter]); printf ("\n"); } diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index ca3772bbebf..d7c5e1aa716 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -14326,13 +14326,14 @@ Print the name and the counter upper bound for all debug counters. @item -fdbg-cnt=@var{counter-value-list} @opindex fdbg-cnt -Set the internal debug counter upper bound. @var{counter-value-list} -is a comma-separated list of @var{name}:@var{value} pairs -which sets the upper bound of each debug counter @var{name} to @var{value}. +Set the internal debug counter lower and upper bound. @var{counter-value-list} +is a comma-separated list of @var{name}:@var{lower_bound}:@var{upper_bound} +tuples which sets the lower and the upper bound of each debug +counter @var{name}. All debug counters have the initial upper bound of @code{UINT_MAX}; thus @code{dbg_cnt} returns true always unless the upper bound is set by this option. -For example, with @option{-fdbg-cnt=dce:10,tail_call:0}, +For example, with @option{-fdbg-cnt=dce:9:10,tail_call:0}, @code{dbg_cnt(dce)} returns true only for first 10 invocations. @item -print-file-name=@var{library} diff --git a/gcc/testsuite/gcc.dg/ipa/ipa-icf-39.c b/gcc/testsuite/gcc.dg/ipa/ipa-icf-39.c new file mode 100644 index 00000000000..8759108a2d5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/ipa/ipa-icf-39.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-ipa-icf -fmerge-all-constants -fdbg-cnt=merged_ipa_icf:1:2" } */ +/* { dg-prune-output "dbg_cnt 'merged_ipa_icf' set to 1-2" } */ + +static int a; +static int b; +static const int c = 2; +static const int d = 2; +static char * e = "test"; +static char * f = "test"; +static int g[3]={1,2,3}; +static int h[3]={1,2,3}; +static const int *i=&c; +static const int *j=&c; +static const int *k=&d; +int t(int tt) +{ + switch (tt) + { + case 1: return a; + case 2: return b; + case 3: return c; + case 4: return d; + case 5: return e[1]; + case 6: return f[1]; + case 7: return g[1]; + case 8: return h[1]; + case 9: return i[0]; + case 10: return j[0]; + case 11: return k[0]; + } +} +/* { dg-final { scan-ipa-dump-times "Unified;" 2 "icf" } } */ diff --git a/gcc/testsuite/gcc.dg/pr68766.c b/gcc/testsuite/gcc.dg/pr68766.c index a0d549b946e..83f0e14b7d2 100644 --- a/gcc/testsuite/gcc.dg/pr68766.c +++ b/gcc/testsuite/gcc.dg/pr68766.c @@ -1,7 +1,7 @@ /* { dg-do compile } */ /* { dg-options "-O2 -ftree-vectorize -fdbg-cnt=vect_loop:1" } */ /* { dg-additional-options "-mavx2" { target { i?86-*-* x86_64-*-* } } } */ -/* { dg-prune-output "dbg_cnt 'vect_loop' set to 1" } */ +/* { dg-prune-output "dbg_cnt 'vect_loop' set to 1-1" } */ int a, b, g, h; int c[58];