Mercurial > hg > CbC > CbC_gcc
annotate gcc/dbgcnt.c @ 158:494b0b89df80 default tip
...
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 25 May 2020 18:13:55 +0900 |
| parents | 1830386684a0 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Debug counter for debugging support |
| 145 | 2 Copyright (C) 2006-2020 Free Software Foundation, Inc. |
| 0 | 3 |
| 4 This file is part of GCC. | |
| 5 | |
| 6 GCC is free software; you can redistribute it and/or modify it under | |
| 7 the terms of the GNU General Public License as published by the Free | |
| 8 Software Foundation; either version 3, or (at your option) any later | |
| 9 version. | |
| 10 | |
| 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 14 for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU General Public License | |
| 17 along with GCC; see the file COPYING3. If not see | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
18 <http://www.gnu.org/licenses/>. |
| 0 | 19 |
| 20 See dbgcnt.def for usage information. */ | |
| 21 | |
| 22 #include "config.h" | |
| 23 #include "system.h" | |
| 24 #include "coretypes.h" | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
25 #include "diagnostic-core.h" |
| 111 | 26 #include "dumpfile.h" |
| 145 | 27 #include "selftest.h" |
| 28 #include "intl.h" | |
| 0 | 29 |
| 30 #include "dbgcnt.h" | |
| 31 | |
| 32 struct string2counter_map { | |
| 33 const char *name; | |
| 34 enum debug_counter counter; | |
| 35 }; | |
| 36 | |
| 37 #define DEBUG_COUNTER(a) { #a , a }, | |
| 38 | |
| 39 static struct string2counter_map map[debug_counter_number_of_counters] = | |
| 40 { | |
| 41 #include "dbgcnt.def" | |
| 42 }; | |
| 43 #undef DEBUG_COUNTER | |
| 44 | |
| 145 | 45 typedef std::pair<unsigned int, unsigned int> limit_tuple; |
| 0 | 46 |
| 145 | 47 static vec<limit_tuple> limits[debug_counter_number_of_counters]; |
| 131 | 48 |
| 0 | 49 static unsigned int count[debug_counter_number_of_counters]; |
| 50 | |
| 145 | 51 static void |
| 52 print_limit_reach (const char *counter, int limit, bool upper_p) | |
| 0 | 53 { |
| 145 | 54 char buffer[128]; |
| 55 sprintf (buffer, "***dbgcnt: %s limit %d reached for %s.***\n", | |
| 56 upper_p ? "upper" : "lower", limit, counter); | |
| 57 fputs (buffer, stderr); | |
| 58 if (dump_file) | |
| 59 fputs (buffer, dump_file); | |
| 0 | 60 } |
| 61 | |
| 62 bool | |
| 63 dbg_cnt (enum debug_counter index) | |
| 64 { | |
| 145 | 65 unsigned v = ++count[index]; |
| 66 | |
| 67 if (!limits[index].exists ()) | |
| 68 return true; | |
| 69 else if (limits[index].is_empty ()) | |
| 70 return false; | |
| 131 | 71 |
| 145 | 72 unsigned last = limits[index].length () - 1; |
| 73 unsigned int min = limits[index][last].first; | |
| 74 unsigned int max = limits[index][last].second; | |
| 75 | |
| 76 if (v < min) | |
| 77 return false; | |
| 78 else if (v == min) | |
| 131 | 79 { |
| 145 | 80 print_limit_reach (map[index].name, v, false); |
| 81 if (min == max) | |
| 82 limits[index].pop (); | |
| 83 return true; | |
| 131 | 84 } |
| 145 | 85 else if (v < max) |
| 86 return true; | |
| 87 else if (v == max) | |
| 88 { | |
| 89 print_limit_reach (map[index].name, v, true); | |
| 90 limits[index].pop (); | |
| 91 return true; | |
| 92 } | |
| 93 else | |
| 94 return false; | |
| 0 | 95 } |
| 96 | |
| 145 | 97 /* Compare limit_tuple intervals by first item in descending order. */ |
| 98 | |
| 99 static int | |
| 100 cmp_tuples (const void *ptr1, const void *ptr2) | |
| 0 | 101 { |
| 145 | 102 const limit_tuple *p1 = (const limit_tuple *)ptr1; |
| 103 const limit_tuple *p2 = (const limit_tuple *)ptr2; | |
| 0 | 104 |
| 145 | 105 if (p1->first < p2->first) |
| 106 return 1; | |
| 107 else if (p1->first > p2->first) | |
| 108 return -1; | |
| 109 return 0; | |
| 0 | 110 } |
| 111 | |
| 112 static bool | |
| 145 | 113 dbg_cnt_set_limit_by_index (enum debug_counter index, const char *name, |
| 114 unsigned int low, unsigned int high) | |
| 115 { | |
| 116 if (!limits[index].exists ()) | |
| 117 limits[index].create (1); | |
| 118 | |
| 119 limits[index].safe_push (limit_tuple (low, high)); | |
| 120 limits[index].qsort (cmp_tuples); | |
| 121 | |
| 122 for (unsigned i = 0; i < limits[index].length () - 1; i++) | |
| 123 { | |
| 124 limit_tuple t1 = limits[index][i]; | |
| 125 limit_tuple t2 = limits[index][i + 1]; | |
| 126 if (t1.first <= t2.second) | |
| 127 { | |
| 128 error ("Interval overlap of %<-fdbg-cnt=%s%>: [%u, %u] and " | |
| 129 "[%u, %u]\n", name, t2.first, t2.second, t1.first, t1.second); | |
| 130 return false; | |
| 131 } | |
| 132 } | |
| 133 | |
| 134 return true; | |
| 135 } | |
| 136 | |
| 137 static bool | |
| 138 dbg_cnt_set_limit_by_name (const char *name, unsigned int low, | |
| 139 unsigned int high) | |
| 0 | 140 { |
| 131 | 141 if (high < low) |
| 142 { | |
| 145 | 143 error ("%<-fdbg-cnt=%s:%d-%d%> has smaller upper limit than the lower", |
| 131 | 144 name, low, high); |
| 145 return false; | |
| 146 } | |
| 147 | |
| 0 | 148 int i; |
| 149 for (i = debug_counter_number_of_counters - 1; i >= 0; i--) | |
| 131 | 150 if (strcmp (map[i].name, name) == 0) |
| 0 | 151 break; |
| 152 | |
| 153 if (i < 0) | |
| 145 | 154 { |
| 155 error ("cannot find a valid counter name %qs of %<-fdbg-cnt=%> option", | |
| 156 name); | |
| 157 return false; | |
| 158 } | |
| 0 | 159 |
| 145 | 160 return dbg_cnt_set_limit_by_index ((enum debug_counter) i, name, low, high); |
| 0 | 161 } |
| 162 | |
| 145 | 163 /* Process a single "low:high" pair. |
| 0 | 164 Returns NULL if there's no valid pair is found. |
| 165 Otherwise returns a pointer to the end of the pair. */ | |
| 166 | |
| 131 | 167 static bool |
| 145 | 168 dbg_cnt_process_single_pair (char *name, char *str) |
| 0 | 169 { |
| 145 | 170 char *value1 = strtok (str, "-"); |
| 171 char *value2 = strtok (NULL, "-"); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
172 |
| 145 | 173 unsigned int high, low; |
| 131 | 174 |
| 175 if (value1 == NULL) | |
| 176 return false; | |
| 0 | 177 |
| 131 | 178 if (value2 == NULL) |
| 179 { | |
| 180 high = strtol (value1, NULL, 10); | |
| 145 | 181 /* Let's allow 0:0. */ |
| 182 low = high == 0 ? 0 : 1; | |
| 131 | 183 } |
| 184 else | |
| 185 { | |
| 186 low = strtol (value1, NULL, 10); | |
| 187 high = strtol (value2, NULL, 10); | |
| 188 } | |
| 0 | 189 |
| 145 | 190 return dbg_cnt_set_limit_by_name (name, low, high); |
| 0 | 191 } |
| 192 | |
| 193 void | |
| 194 dbg_cnt_process_opt (const char *arg) | |
| 195 { | |
| 131 | 196 char *str = xstrdup (arg); |
| 197 unsigned int start = 0; | |
| 198 | |
| 145 | 199 auto_vec<char *> tokens; |
| 200 for (char *next = strtok (str, ","); next != NULL; next = strtok (NULL, ",")) | |
| 201 tokens.safe_push (next); | |
| 0 | 202 |
| 145 | 203 unsigned i; |
| 204 for (i = 0; i < tokens.length (); i++) | |
| 205 { | |
| 206 auto_vec<char *> ranges; | |
| 207 char *name = strtok (tokens[i], ":"); | |
| 208 for (char *part = strtok (NULL, ":"); part; part = strtok (NULL, ":")) | |
| 209 ranges.safe_push (part); | |
| 210 | |
| 211 for (unsigned j = 0; j < ranges.length (); j++) | |
| 212 { | |
| 213 if (!dbg_cnt_process_single_pair (name, ranges[j])) | |
| 214 break; | |
| 215 } | |
| 216 start += strlen (tokens[i]) + 1; | |
| 217 } | |
| 0 | 218 } |
| 219 | |
| 220 /* Print name, limit and count of all counters. */ | |
| 221 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
222 void |
| 0 | 223 dbg_cnt_list_all_counters (void) |
| 224 { | |
| 225 int i; | |
| 145 | 226 printf (" %-30s %s\n", G_("counter name"), G_("closed intervals")); |
| 131 | 227 printf ("-----------------------------------------------------------------\n"); |
| 0 | 228 for (i = 0; i < debug_counter_number_of_counters; i++) |
| 145 | 229 { |
| 230 printf (" %-30s ", map[i].name); | |
| 231 if (limits[i].exists ()) | |
| 232 { | |
| 233 for (int j = limits[i].length () - 1; j >= 0; j--) | |
| 234 { | |
| 235 printf ("[%u, %u]", limits[i][j].first, limits[i][j].second); | |
| 236 if (j > 0) | |
| 237 printf (", "); | |
| 238 } | |
| 239 putchar ('\n'); | |
| 240 } | |
| 241 else | |
| 242 printf ("unset\n"); | |
| 243 } | |
| 0 | 244 printf ("\n"); |
| 245 } | |
| 145 | 246 |
| 247 #if CHECKING_P | |
| 248 | |
| 249 namespace selftest { | |
| 250 | |
| 251 /* Selftests. */ | |
| 252 | |
| 253 static void | |
| 254 test_sorted_dbg_counters () | |
| 255 { | |
| 256 for (unsigned i = 0; i < debug_counter_number_of_counters - 1; i++) | |
| 257 ASSERT_LT (strcmp (map[i].name, map[i + 1].name), 0); | |
| 258 } | |
| 259 | |
| 260 void | |
| 261 dbgcnt_c_tests () | |
| 262 { | |
| 263 test_sorted_dbg_counters (); | |
| 264 } | |
| 265 | |
| 266 } // namespace selftest | |
| 267 | |
| 268 #endif /* #if CHECKING_P */ |