Mercurial > hg > CbC > CbC_gcc
annotate gcc/value-prof.c @ 131:84e7813d76e9
gcc-8.2
| author | mir3636 |
|---|---|
| date | Thu, 25 Oct 2018 07:37:49 +0900 |
| parents | 04ced10e8804 |
| children | 1830386684a0 |
| rev | line source |
|---|---|
| 0 | 1 /* Transformations based on profile information for values. |
| 131 | 2 Copyright (C) 2003-2018 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 | |
| 18 <http://www.gnu.org/licenses/>. */ | |
| 19 | |
| 20 #include "config.h" | |
| 21 #include "system.h" | |
| 22 #include "coretypes.h" | |
| 111 | 23 #include "backend.h" |
| 0 | 24 #include "rtl.h" |
| 111 | 25 #include "tree.h" |
| 26 #include "gimple.h" | |
| 27 #include "cfghooks.h" | |
| 28 #include "ssa.h" | |
| 29 #include "cgraph.h" | |
| 30 #include "coverage.h" | |
| 31 #include "data-streamer.h" | |
| 32 #include "diagnostic.h" | |
| 33 #include "fold-const.h" | |
| 34 #include "tree-nested.h" | |
| 35 #include "calls.h" | |
| 0 | 36 #include "expr.h" |
| 37 #include "value-prof.h" | |
| 111 | 38 #include "tree-eh.h" |
| 39 #include "gimplify.h" | |
| 40 #include "gimple-iterator.h" | |
| 41 #include "tree-cfg.h" | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
42 #include "gimple-pretty-print.h" |
| 111 | 43 #include "dumpfile.h" |
| 44 #include "builtins.h" | |
| 45 #include "params.h" | |
| 0 | 46 |
| 47 /* In this file value profile based optimizations are placed. Currently the | |
| 48 following optimizations are implemented (for more detailed descriptions | |
| 49 see comments at value_profile_transformations): | |
| 50 | |
| 51 1) Division/modulo specialization. Provided that we can determine that the | |
| 52 operands of the division have some special properties, we may use it to | |
| 53 produce more effective code. | |
| 111 | 54 |
| 55 2) Indirect/virtual call specialization. If we can determine most | |
| 56 common function callee in indirect/virtual call. We can use this | |
| 57 information to improve code effectiveness (especially info for | |
| 58 the inliner). | |
| 59 | |
| 60 3) Speculative prefetching. If we are able to determine that the difference | |
| 0 | 61 between addresses accessed by a memory reference is usually constant, we |
| 62 may add the prefetch instructions. | |
| 63 FIXME: This transformation was removed together with RTL based value | |
| 64 profiling. | |
| 65 | |
| 111 | 66 |
| 67 Value profiling internals | |
| 68 ========================== | |
| 0 | 69 |
| 111 | 70 Every value profiling transformation starts with defining what values |
| 71 to profile. There are different histogram types (see HIST_TYPE_* in | |
| 72 value-prof.h) and each transformation can request one or more histogram | |
| 73 types per GIMPLE statement. The function gimple_find_values_to_profile() | |
| 74 collects the values to profile in a vec, and adds the number of counters | |
| 75 required for the different histogram types. | |
| 76 | |
| 77 For a -fprofile-generate run, the statements for which values should be | |
| 78 recorded, are instrumented in instrument_values(). The instrumentation | |
| 79 is done by helper functions that can be found in tree-profile.c, where | |
| 80 new types of histograms can be added if necessary. | |
| 0 | 81 |
| 111 | 82 After a -fprofile-use, the value profiling data is read back in by |
| 83 compute_value_histograms() that translates the collected data to | |
| 84 histograms and attaches them to the profiled statements via | |
| 85 gimple_add_histogram_value(). Histograms are stored in a hash table | |
| 86 that is attached to every intrumented function, see VALUE_HISTOGRAMS | |
| 87 in function.h. | |
| 88 | |
| 89 The value-profile transformations driver is the function | |
| 90 gimple_value_profile_transformations(). It traverses all statements in | |
| 91 the to-be-transformed function, and looks for statements with one or | |
| 92 more histograms attached to it. If a statement has histograms, the | |
| 93 transformation functions are called on the statement. | |
| 0 | 94 |
| 111 | 95 Limitations / FIXME / TODO: |
| 96 * Only one histogram of each type can be associated with a statement. | |
| 97 * Some value profile transformations are done in builtins.c (?!) | |
| 98 * Updating of histograms needs some TLC. | |
| 99 * The value profiling code could be used to record analysis results | |
| 100 from non-profiling (e.g. VRP). | |
| 101 * Adding new profilers should be simplified, starting with a cleanup | |
| 102 of what-happens-where and with making gimple_find_values_to_profile | |
| 103 and gimple_value_profile_transformations table-driven, perhaps... | |
| 104 */ | |
| 0 | 105 |
| 106 static bool gimple_divmod_fixed_value_transform (gimple_stmt_iterator *); | |
| 107 static bool gimple_mod_pow2_value_transform (gimple_stmt_iterator *); | |
| 108 static bool gimple_mod_subtract_transform (gimple_stmt_iterator *); | |
| 109 static bool gimple_stringops_transform (gimple_stmt_iterator *); | |
| 111 | 110 static bool gimple_ic_transform (gimple_stmt_iterator *); |
| 0 | 111 |
| 112 /* Allocate histogram value. */ | |
| 113 | |
| 111 | 114 histogram_value |
| 0 | 115 gimple_alloc_histogram_value (struct function *fun ATTRIBUTE_UNUSED, |
| 111 | 116 enum hist_type type, gimple *stmt, tree value) |
| 0 | 117 { |
| 118 histogram_value hist = (histogram_value) xcalloc (1, sizeof (*hist)); | |
| 119 hist->hvalue.value = value; | |
| 120 hist->hvalue.stmt = stmt; | |
| 121 hist->type = type; | |
| 122 return hist; | |
| 123 } | |
| 124 | |
| 125 /* Hash value for histogram. */ | |
| 126 | |
| 127 static hashval_t | |
| 128 histogram_hash (const void *x) | |
| 129 { | |
| 130 return htab_hash_pointer (((const_histogram_value)x)->hvalue.stmt); | |
| 131 } | |
| 132 | |
| 111 | 133 /* Return nonzero if statement for histogram_value X is Y. */ |
| 0 | 134 |
| 135 static int | |
| 136 histogram_eq (const void *x, const void *y) | |
| 137 { | |
| 111 | 138 return ((const_histogram_value) x)->hvalue.stmt == (const gimple *) y; |
| 0 | 139 } |
| 140 | |
| 141 /* Set histogram for STMT. */ | |
| 142 | |
| 143 static void | |
| 111 | 144 set_histogram_value (struct function *fun, gimple *stmt, histogram_value hist) |
| 0 | 145 { |
| 146 void **loc; | |
| 147 if (!hist && !VALUE_HISTOGRAMS (fun)) | |
| 148 return; | |
| 149 if (!VALUE_HISTOGRAMS (fun)) | |
| 150 VALUE_HISTOGRAMS (fun) = htab_create (1, histogram_hash, | |
| 151 histogram_eq, NULL); | |
| 152 loc = htab_find_slot_with_hash (VALUE_HISTOGRAMS (fun), stmt, | |
| 153 htab_hash_pointer (stmt), | |
| 154 hist ? INSERT : NO_INSERT); | |
| 155 if (!hist) | |
| 156 { | |
| 157 if (loc) | |
| 158 htab_clear_slot (VALUE_HISTOGRAMS (fun), loc); | |
| 159 return; | |
| 160 } | |
| 161 *loc = hist; | |
| 162 } | |
| 163 | |
| 164 /* Get histogram list for STMT. */ | |
| 165 | |
| 166 histogram_value | |
| 111 | 167 gimple_histogram_value (struct function *fun, gimple *stmt) |
| 0 | 168 { |
| 169 if (!VALUE_HISTOGRAMS (fun)) | |
| 170 return NULL; | |
| 171 return (histogram_value) htab_find_with_hash (VALUE_HISTOGRAMS (fun), stmt, | |
| 172 htab_hash_pointer (stmt)); | |
| 173 } | |
| 174 | |
| 175 /* Add histogram for STMT. */ | |
| 176 | |
| 177 void | |
| 111 | 178 gimple_add_histogram_value (struct function *fun, gimple *stmt, |
| 0 | 179 histogram_value hist) |
| 180 { | |
| 181 hist->hvalue.next = gimple_histogram_value (fun, stmt); | |
| 182 set_histogram_value (fun, stmt, hist); | |
| 111 | 183 hist->fun = fun; |
| 0 | 184 } |
| 185 | |
| 186 /* Remove histogram HIST from STMT's histogram list. */ | |
| 187 | |
| 188 void | |
| 111 | 189 gimple_remove_histogram_value (struct function *fun, gimple *stmt, |
| 0 | 190 histogram_value hist) |
| 191 { | |
| 192 histogram_value hist2 = gimple_histogram_value (fun, stmt); | |
| 193 if (hist == hist2) | |
| 194 { | |
| 195 set_histogram_value (fun, stmt, hist->hvalue.next); | |
| 196 } | |
| 197 else | |
| 198 { | |
| 199 while (hist2->hvalue.next != hist) | |
| 200 hist2 = hist2->hvalue.next; | |
| 201 hist2->hvalue.next = hist->hvalue.next; | |
| 202 } | |
| 203 free (hist->hvalue.counters); | |
| 111 | 204 if (flag_checking) |
| 205 memset (hist, 0xab, sizeof (*hist)); | |
| 0 | 206 free (hist); |
| 207 } | |
| 208 | |
| 209 /* Lookup histogram of type TYPE in the STMT. */ | |
| 210 | |
| 211 histogram_value | |
| 111 | 212 gimple_histogram_value_of_type (struct function *fun, gimple *stmt, |
| 0 | 213 enum hist_type type) |
| 214 { | |
| 215 histogram_value hist; | |
| 216 for (hist = gimple_histogram_value (fun, stmt); hist; | |
| 217 hist = hist->hvalue.next) | |
| 218 if (hist->type == type) | |
| 219 return hist; | |
| 220 return NULL; | |
| 221 } | |
| 222 | |
| 223 /* Dump information about HIST to DUMP_FILE. */ | |
| 224 | |
| 225 static void | |
| 226 dump_histogram_value (FILE *dump_file, histogram_value hist) | |
| 227 { | |
| 228 switch (hist->type) | |
| 229 { | |
| 230 case HIST_TYPE_INTERVAL: | |
| 231 fprintf (dump_file, "Interval counter range %d -- %d", | |
| 232 hist->hdata.intvl.int_start, | |
| 233 (hist->hdata.intvl.int_start | |
| 234 + hist->hdata.intvl.steps - 1)); | |
| 235 if (hist->hvalue.counters) | |
| 236 { | |
| 237 unsigned int i; | |
| 111 | 238 fprintf (dump_file, " ["); |
| 0 | 239 for (i = 0; i < hist->hdata.intvl.steps; i++) |
| 111 | 240 fprintf (dump_file, " %d:%" PRId64, |
| 0 | 241 hist->hdata.intvl.int_start + i, |
| 111 | 242 (int64_t) hist->hvalue.counters[i]); |
| 243 fprintf (dump_file, " ] outside range:%" PRId64, | |
| 244 (int64_t) hist->hvalue.counters[i]); | |
| 0 | 245 } |
| 246 fprintf (dump_file, ".\n"); | |
| 247 break; | |
| 248 | |
| 249 case HIST_TYPE_POW2: | |
| 250 fprintf (dump_file, "Pow2 counter "); | |
| 251 if (hist->hvalue.counters) | |
| 252 { | |
| 111 | 253 fprintf (dump_file, "pow2:%" PRId64 |
| 254 " nonpow2:%" PRId64, | |
| 255 (int64_t) hist->hvalue.counters[1], | |
| 256 (int64_t) hist->hvalue.counters[0]); | |
| 0 | 257 } |
| 258 fprintf (dump_file, ".\n"); | |
| 259 break; | |
| 260 | |
| 261 case HIST_TYPE_SINGLE_VALUE: | |
| 262 fprintf (dump_file, "Single value "); | |
| 263 if (hist->hvalue.counters) | |
| 264 { | |
| 111 | 265 fprintf (dump_file, "value:%" PRId64 |
| 266 " match:%" PRId64 | |
| 267 " wrong:%" PRId64, | |
| 268 (int64_t) hist->hvalue.counters[0], | |
| 269 (int64_t) hist->hvalue.counters[1], | |
| 270 (int64_t) hist->hvalue.counters[2]); | |
| 0 | 271 } |
| 272 fprintf (dump_file, ".\n"); | |
| 273 break; | |
| 274 | |
| 275 case HIST_TYPE_AVERAGE: | |
| 276 fprintf (dump_file, "Average value "); | |
| 277 if (hist->hvalue.counters) | |
| 278 { | |
| 111 | 279 fprintf (dump_file, "sum:%" PRId64 |
| 280 " times:%" PRId64, | |
| 281 (int64_t) hist->hvalue.counters[0], | |
| 282 (int64_t) hist->hvalue.counters[1]); | |
| 0 | 283 } |
| 284 fprintf (dump_file, ".\n"); | |
| 285 break; | |
| 286 | |
| 287 case HIST_TYPE_IOR: | |
| 288 fprintf (dump_file, "IOR value "); | |
| 289 if (hist->hvalue.counters) | |
| 290 { | |
| 111 | 291 fprintf (dump_file, "ior:%" PRId64, |
| 292 (int64_t) hist->hvalue.counters[0]); | |
| 0 | 293 } |
| 294 fprintf (dump_file, ".\n"); | |
| 295 break; | |
| 296 | |
| 297 case HIST_TYPE_INDIR_CALL: | |
| 298 fprintf (dump_file, "Indirect call "); | |
| 299 if (hist->hvalue.counters) | |
| 300 { | |
| 111 | 301 fprintf (dump_file, "value:%" PRId64 |
| 302 " match:%" PRId64 | |
| 303 " all:%" PRId64, | |
| 304 (int64_t) hist->hvalue.counters[0], | |
| 305 (int64_t) hist->hvalue.counters[1], | |
| 306 (int64_t) hist->hvalue.counters[2]); | |
| 0 | 307 } |
| 308 fprintf (dump_file, ".\n"); | |
| 309 break; | |
| 111 | 310 case HIST_TYPE_TIME_PROFILE: |
| 311 fprintf (dump_file, "Time profile "); | |
| 312 if (hist->hvalue.counters) | |
| 313 { | |
| 314 fprintf (dump_file, "time:%" PRId64, | |
| 315 (int64_t) hist->hvalue.counters[0]); | |
| 316 } | |
| 317 fprintf (dump_file, ".\n"); | |
| 318 break; | |
| 319 case HIST_TYPE_INDIR_CALL_TOPN: | |
| 320 fprintf (dump_file, "Indirect call topn "); | |
| 321 if (hist->hvalue.counters) | |
| 322 { | |
| 323 int i; | |
| 324 | |
| 325 fprintf (dump_file, "accu:%" PRId64, hist->hvalue.counters[0]); | |
| 326 for (i = 1; i < (GCOV_ICALL_TOPN_VAL << 2); i += 2) | |
| 327 { | |
| 328 fprintf (dump_file, " target:%" PRId64 " value:%" PRId64, | |
| 329 (int64_t) hist->hvalue.counters[i], | |
| 330 (int64_t) hist->hvalue.counters[i+1]); | |
| 331 } | |
| 332 } | |
| 333 fprintf (dump_file, ".\n"); | |
| 334 break; | |
| 335 case HIST_TYPE_MAX: | |
| 336 gcc_unreachable (); | |
| 0 | 337 } |
| 338 } | |
| 339 | |
| 111 | 340 /* Dump information about HIST to DUMP_FILE. */ |
| 341 | |
| 342 void | |
| 343 stream_out_histogram_value (struct output_block *ob, histogram_value hist) | |
| 344 { | |
| 345 struct bitpack_d bp; | |
| 346 unsigned int i; | |
| 347 | |
| 348 bp = bitpack_create (ob->main_stream); | |
| 349 bp_pack_enum (&bp, hist_type, HIST_TYPE_MAX, hist->type); | |
| 350 bp_pack_value (&bp, hist->hvalue.next != NULL, 1); | |
| 351 streamer_write_bitpack (&bp); | |
| 352 switch (hist->type) | |
| 353 { | |
| 354 case HIST_TYPE_INTERVAL: | |
| 355 streamer_write_hwi (ob, hist->hdata.intvl.int_start); | |
| 356 streamer_write_uhwi (ob, hist->hdata.intvl.steps); | |
| 357 break; | |
| 358 default: | |
| 359 break; | |
| 360 } | |
| 361 for (i = 0; i < hist->n_counters; i++) | |
| 362 { | |
| 363 /* When user uses an unsigned type with a big value, constant converted | |
| 364 to gcov_type (a signed type) can be negative. */ | |
| 365 gcov_type value = hist->hvalue.counters[i]; | |
| 366 if (hist->type == HIST_TYPE_SINGLE_VALUE && i == 0) | |
| 367 ; | |
| 368 else | |
| 369 gcc_assert (value >= 0); | |
| 370 | |
| 371 streamer_write_gcov_count (ob, value); | |
| 372 } | |
| 373 if (hist->hvalue.next) | |
| 374 stream_out_histogram_value (ob, hist->hvalue.next); | |
| 375 } | |
| 376 | |
| 377 /* Dump information about HIST to DUMP_FILE. */ | |
| 378 | |
| 379 void | |
| 380 stream_in_histogram_value (struct lto_input_block *ib, gimple *stmt) | |
| 381 { | |
| 382 enum hist_type type; | |
| 383 unsigned int ncounters = 0; | |
| 384 struct bitpack_d bp; | |
| 385 unsigned int i; | |
| 386 histogram_value new_val; | |
| 387 bool next; | |
| 388 histogram_value *next_p = NULL; | |
| 389 | |
| 390 do | |
| 391 { | |
| 392 bp = streamer_read_bitpack (ib); | |
| 393 type = bp_unpack_enum (&bp, hist_type, HIST_TYPE_MAX); | |
| 394 next = bp_unpack_value (&bp, 1); | |
| 395 new_val = gimple_alloc_histogram_value (cfun, type, stmt, NULL); | |
| 396 switch (type) | |
| 397 { | |
| 398 case HIST_TYPE_INTERVAL: | |
| 399 new_val->hdata.intvl.int_start = streamer_read_hwi (ib); | |
| 400 new_val->hdata.intvl.steps = streamer_read_uhwi (ib); | |
| 401 ncounters = new_val->hdata.intvl.steps + 2; | |
| 402 break; | |
| 403 | |
| 404 case HIST_TYPE_POW2: | |
| 405 case HIST_TYPE_AVERAGE: | |
| 406 ncounters = 2; | |
| 407 break; | |
| 408 | |
| 409 case HIST_TYPE_SINGLE_VALUE: | |
| 410 case HIST_TYPE_INDIR_CALL: | |
| 411 ncounters = 3; | |
| 412 break; | |
| 413 | |
| 414 case HIST_TYPE_IOR: | |
| 415 case HIST_TYPE_TIME_PROFILE: | |
| 416 ncounters = 1; | |
| 417 break; | |
| 418 | |
| 419 case HIST_TYPE_INDIR_CALL_TOPN: | |
| 420 ncounters = (GCOV_ICALL_TOPN_VAL << 2) + 1; | |
| 421 break; | |
| 422 | |
| 423 case HIST_TYPE_MAX: | |
| 424 gcc_unreachable (); | |
| 425 } | |
| 426 new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * ncounters); | |
| 427 new_val->n_counters = ncounters; | |
| 428 for (i = 0; i < ncounters; i++) | |
| 429 new_val->hvalue.counters[i] = streamer_read_gcov_count (ib); | |
| 430 if (!next_p) | |
| 431 gimple_add_histogram_value (cfun, stmt, new_val); | |
| 432 else | |
| 433 *next_p = new_val; | |
| 434 next_p = &new_val->hvalue.next; | |
| 435 } | |
| 436 while (next); | |
| 437 } | |
| 438 | |
| 0 | 439 /* Dump all histograms attached to STMT to DUMP_FILE. */ |
| 440 | |
| 441 void | |
| 111 | 442 dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple *stmt) |
| 0 | 443 { |
| 444 histogram_value hist; | |
| 445 for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next) | |
| 111 | 446 dump_histogram_value (dump_file, hist); |
| 0 | 447 } |
| 448 | |
| 449 /* Remove all histograms associated with STMT. */ | |
| 450 | |
| 451 void | |
| 111 | 452 gimple_remove_stmt_histograms (struct function *fun, gimple *stmt) |
| 0 | 453 { |
| 454 histogram_value val; | |
| 455 while ((val = gimple_histogram_value (fun, stmt)) != NULL) | |
| 456 gimple_remove_histogram_value (fun, stmt, val); | |
| 457 } | |
| 458 | |
| 459 /* Duplicate all histograms associates with OSTMT to STMT. */ | |
| 460 | |
| 461 void | |
| 111 | 462 gimple_duplicate_stmt_histograms (struct function *fun, gimple *stmt, |
| 463 struct function *ofun, gimple *ostmt) | |
| 0 | 464 { |
| 465 histogram_value val; | |
| 466 for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next) | |
| 467 { | |
| 468 histogram_value new_val = gimple_alloc_histogram_value (fun, val->type, NULL, NULL); | |
| 469 memcpy (new_val, val, sizeof (*val)); | |
| 470 new_val->hvalue.stmt = stmt; | |
| 471 new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * new_val->n_counters); | |
| 472 memcpy (new_val->hvalue.counters, val->hvalue.counters, sizeof (*new_val->hvalue.counters) * new_val->n_counters); | |
| 473 gimple_add_histogram_value (fun, stmt, new_val); | |
| 474 } | |
| 475 } | |
| 476 | |
| 477 /* Move all histograms associated with OSTMT to STMT. */ | |
| 478 | |
| 479 void | |
| 111 | 480 gimple_move_stmt_histograms (struct function *fun, gimple *stmt, gimple *ostmt) |
| 0 | 481 { |
| 482 histogram_value val = gimple_histogram_value (fun, ostmt); | |
| 483 if (val) | |
| 484 { | |
| 485 /* The following three statements can't be reordered, | |
| 486 because histogram hashtab relies on stmt field value | |
| 487 for finding the exact slot. */ | |
| 488 set_histogram_value (fun, ostmt, NULL); | |
| 489 for (; val != NULL; val = val->hvalue.next) | |
| 490 val->hvalue.stmt = stmt; | |
| 491 set_histogram_value (fun, stmt, val); | |
| 492 } | |
| 493 } | |
| 494 | |
| 495 static bool error_found = false; | |
| 496 | |
| 497 /* Helper function for verify_histograms. For each histogram reachable via htab | |
| 498 walk verify that it was reached via statement walk. */ | |
| 499 | |
| 500 static int | |
| 501 visit_hist (void **slot, void *data) | |
| 502 { | |
| 111 | 503 hash_set<histogram_value> *visited = (hash_set<histogram_value> *) data; |
| 0 | 504 histogram_value hist = *(histogram_value *) slot; |
| 111 | 505 |
| 506 if (!visited->contains (hist) | |
| 507 && hist->type != HIST_TYPE_TIME_PROFILE) | |
| 0 | 508 { |
|
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
|
509 error ("dead histogram"); |
| 0 | 510 dump_histogram_value (stderr, hist); |
| 511 debug_gimple_stmt (hist->hvalue.stmt); | |
| 512 error_found = true; | |
| 513 } | |
| 514 return 1; | |
| 515 } | |
| 516 | |
| 517 /* Verify sanity of the histograms. */ | |
| 518 | |
|
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
|
519 DEBUG_FUNCTION void |
| 0 | 520 verify_histograms (void) |
| 521 { | |
| 522 basic_block bb; | |
| 523 gimple_stmt_iterator gsi; | |
| 524 histogram_value hist; | |
| 525 | |
| 526 error_found = false; | |
| 111 | 527 hash_set<histogram_value> visited_hists; |
| 528 FOR_EACH_BB_FN (bb, cfun) | |
| 0 | 529 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
| 530 { | |
| 111 | 531 gimple *stmt = gsi_stmt (gsi); |
| 0 | 532 |
| 533 for (hist = gimple_histogram_value (cfun, stmt); hist; | |
| 534 hist = hist->hvalue.next) | |
| 535 { | |
| 536 if (hist->hvalue.stmt != stmt) | |
| 537 { | |
| 538 error ("Histogram value statement does not correspond to " | |
| 539 "the statement it is associated with"); | |
| 540 debug_gimple_stmt (stmt); | |
| 541 dump_histogram_value (stderr, hist); | |
| 542 error_found = true; | |
| 543 } | |
| 111 | 544 visited_hists.add (hist); |
| 0 | 545 } |
| 546 } | |
| 547 if (VALUE_HISTOGRAMS (cfun)) | |
| 111 | 548 htab_traverse (VALUE_HISTOGRAMS (cfun), visit_hist, &visited_hists); |
| 0 | 549 if (error_found) |
| 550 internal_error ("verify_histograms failed"); | |
| 551 } | |
| 552 | |
| 553 /* Helper function for verify_histograms. For each histogram reachable via htab | |
| 554 walk verify that it was reached via statement walk. */ | |
| 555 | |
| 556 static int | |
| 557 free_hist (void **slot, void *data ATTRIBUTE_UNUSED) | |
| 558 { | |
| 559 histogram_value hist = *(histogram_value *) slot; | |
| 560 free (hist->hvalue.counters); | |
| 561 free (hist); | |
| 562 return 1; | |
| 563 } | |
| 564 | |
| 565 void | |
| 111 | 566 free_histograms (struct function *fn) |
| 0 | 567 { |
| 111 | 568 if (VALUE_HISTOGRAMS (fn)) |
| 0 | 569 { |
| 111 | 570 htab_traverse (VALUE_HISTOGRAMS (fn), free_hist, NULL); |
| 571 htab_delete (VALUE_HISTOGRAMS (fn)); | |
| 572 VALUE_HISTOGRAMS (fn) = NULL; | |
| 0 | 573 } |
| 574 } | |
| 575 | |
| 576 /* The overall number of invocations of the counter should match | |
| 577 execution count of basic block. Report it as error rather than | |
| 578 internal error as it might mean that user has misused the profile | |
| 579 somehow. */ | |
| 580 | |
| 581 static bool | |
| 111 | 582 check_counter (gimple *stmt, const char * name, |
| 583 gcov_type *count, gcov_type *all, profile_count bb_count_d) | |
| 0 | 584 { |
| 131 | 585 gcov_type bb_count = bb_count_d.ipa ().to_gcov_type (); |
| 0 | 586 if (*all != bb_count || *count > *all) |
| 587 { | |
| 131 | 588 dump_user_location_t locus; |
| 589 locus = ((stmt != NULL) | |
| 590 ? dump_user_location_t (stmt) | |
| 591 : dump_user_location_t::from_function_decl | |
| 592 (current_function_decl)); | |
| 0 | 593 if (flag_profile_correction) |
| 594 { | |
| 111 | 595 if (dump_enabled_p ()) |
| 596 dump_printf_loc (MSG_MISSED_OPTIMIZATION, locus, | |
| 597 "correcting inconsistent value profile: %s " | |
| 598 "profiler overall count (%d) does not match BB " | |
| 599 "count (%d)\n", name, (int)*all, (int)bb_count); | |
| 0 | 600 *all = bb_count; |
| 601 if (*count > *all) | |
| 602 *count = *all; | |
| 603 return false; | |
| 604 } | |
| 605 else | |
| 606 { | |
| 131 | 607 error_at (locus.get_location_t (), "corrupted value profile: %s " |
|
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
|
608 "profile counter (%d out of %d) inconsistent with " |
|
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
|
609 "basic-block count (%d)", |
|
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
|
610 name, |
|
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
|
611 (int) *count, |
|
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
|
612 (int) *all, |
|
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
|
613 (int) bb_count); |
| 0 | 614 return true; |
| 615 } | |
| 616 } | |
| 617 | |
| 618 return false; | |
| 619 } | |
| 620 | |
| 621 /* GIMPLE based transformations. */ | |
| 622 | |
|
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
|
623 bool |
| 0 | 624 gimple_value_profile_transformations (void) |
| 625 { | |
| 626 basic_block bb; | |
| 627 gimple_stmt_iterator gsi; | |
| 628 bool changed = false; | |
| 629 | |
| 111 | 630 /* Autofdo does its own transformations for indirect calls, |
| 631 and otherwise does not support value profiling. */ | |
| 632 if (flag_auto_profile) | |
| 633 return false; | |
| 634 | |
| 635 FOR_EACH_BB_FN (bb, cfun) | |
| 0 | 636 { |
| 637 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
| 638 { | |
| 111 | 639 gimple *stmt = gsi_stmt (gsi); |
| 0 | 640 histogram_value th = gimple_histogram_value (cfun, stmt); |
| 641 if (!th) | |
| 642 continue; | |
| 643 | |
| 644 if (dump_file) | |
| 645 { | |
| 646 fprintf (dump_file, "Trying transformations on stmt "); | |
| 647 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
| 648 dump_histograms_for_stmt (cfun, dump_file, stmt); | |
| 649 } | |
| 650 | |
| 651 /* Transformations: */ | |
| 652 /* The order of things in this conditional controls which | |
| 653 transformation is used when more than one is applicable. */ | |
| 654 /* It is expected that any code added by the transformations | |
| 655 will be added before the current statement, and that the | |
| 656 current statement remain valid (although possibly | |
| 657 modified) upon return. */ | |
| 111 | 658 if (gimple_mod_subtract_transform (&gsi) |
| 659 || gimple_divmod_fixed_value_transform (&gsi) | |
| 660 || gimple_mod_pow2_value_transform (&gsi) | |
| 661 || gimple_stringops_transform (&gsi) | |
| 662 || gimple_ic_transform (&gsi)) | |
| 0 | 663 { |
| 664 stmt = gsi_stmt (gsi); | |
| 665 changed = true; | |
| 666 /* Original statement may no longer be in the same block. */ | |
| 667 if (bb != gimple_bb (stmt)) | |
| 668 { | |
| 669 bb = gimple_bb (stmt); | |
| 670 gsi = gsi_for_stmt (stmt); | |
| 671 } | |
| 672 } | |
| 673 } | |
| 674 } | |
| 675 | |
| 676 return changed; | |
| 677 } | |
| 678 | |
| 679 /* Generate code for transformation 1 (with parent gimple assignment | |
| 680 STMT and probability of taking the optimal path PROB, which is | |
| 681 equivalent to COUNT/ALL within roundoff error). This generates the | |
| 682 result into a temp and returns the temp; it does not replace or | |
| 683 alter the original STMT. */ | |
| 684 | |
| 685 static tree | |
| 111 | 686 gimple_divmod_fixed_value (gassign *stmt, tree value, profile_probability prob, |
| 687 gcov_type count, gcov_type all) | |
| 0 | 688 { |
| 111 | 689 gassign *stmt1, *stmt2; |
| 690 gcond *stmt3; | |
| 691 tree tmp0, tmp1, tmp2; | |
| 692 gimple *bb1end, *bb2end, *bb3end; | |
| 0 | 693 basic_block bb, bb2, bb3, bb4; |
| 694 tree optype, op1, op2; | |
| 695 edge e12, e13, e23, e24, e34; | |
| 696 gimple_stmt_iterator gsi; | |
| 697 | |
| 698 gcc_assert (is_gimple_assign (stmt) | |
| 699 && (gimple_assign_rhs_code (stmt) == TRUNC_DIV_EXPR | |
| 700 || gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR)); | |
| 701 | |
| 702 optype = TREE_TYPE (gimple_assign_lhs (stmt)); | |
| 703 op1 = gimple_assign_rhs1 (stmt); | |
| 704 op2 = gimple_assign_rhs2 (stmt); | |
| 705 | |
| 706 bb = gimple_bb (stmt); | |
| 707 gsi = gsi_for_stmt (stmt); | |
| 708 | |
| 111 | 709 tmp0 = make_temp_ssa_name (optype, NULL, "PROF"); |
| 710 tmp1 = make_temp_ssa_name (optype, NULL, "PROF"); | |
|
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
|
711 stmt1 = gimple_build_assign (tmp0, fold_convert (optype, value)); |
| 0 | 712 stmt2 = gimple_build_assign (tmp1, op2); |
|
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
|
713 stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE); |
| 0 | 714 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); |
| 715 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT); | |
| 716 gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT); | |
| 717 bb1end = stmt3; | |
| 718 | |
| 111 | 719 tmp2 = create_tmp_reg (optype, "PROF"); |
| 720 stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, tmp0); | |
| 0 | 721 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); |
| 722 bb2end = stmt1; | |
| 723 | |
| 111 | 724 stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, op2); |
| 0 | 725 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); |
| 726 bb3end = stmt1; | |
| 727 | |
| 728 /* Fix CFG. */ | |
| 729 /* Edge e23 connects bb2 to bb3, etc. */ | |
| 730 e12 = split_block (bb, bb1end); | |
| 731 bb2 = e12->dest; | |
| 111 | 732 bb2->count = profile_count::from_gcov_type (count); |
| 0 | 733 e23 = split_block (bb2, bb2end); |
| 734 bb3 = e23->dest; | |
| 111 | 735 bb3->count = profile_count::from_gcov_type (all - count); |
| 0 | 736 e34 = split_block (bb3, bb3end); |
| 737 bb4 = e34->dest; | |
| 111 | 738 bb4->count = profile_count::from_gcov_type (all); |
| 0 | 739 |
| 740 e12->flags &= ~EDGE_FALLTHRU; | |
| 741 e12->flags |= EDGE_FALSE_VALUE; | |
| 742 e12->probability = prob; | |
| 743 | |
| 744 e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE); | |
| 111 | 745 e13->probability = prob.invert (); |
| 0 | 746 |
| 747 remove_edge (e23); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
748 |
| 0 | 749 e24 = make_edge (bb2, bb4, EDGE_FALLTHRU); |
| 111 | 750 e24->probability = profile_probability::always (); |
| 0 | 751 |
| 111 | 752 e34->probability = profile_probability::always (); |
| 0 | 753 |
| 754 return tmp2; | |
| 755 } | |
| 756 | |
| 757 /* Do transform 1) on INSN if applicable. */ | |
| 758 | |
| 759 static bool | |
| 760 gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si) | |
| 761 { | |
| 762 histogram_value histogram; | |
| 763 enum tree_code code; | |
| 764 gcov_type val, count, all; | |
| 765 tree result, value, tree_val; | |
| 111 | 766 profile_probability prob; |
| 767 gassign *stmt; | |
| 0 | 768 |
| 111 | 769 stmt = dyn_cast <gassign *> (gsi_stmt (*si)); |
| 770 if (!stmt) | |
| 0 | 771 return false; |
| 772 | |
| 773 if (!INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt)))) | |
| 774 return false; | |
| 775 | |
| 776 code = gimple_assign_rhs_code (stmt); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
777 |
| 0 | 778 if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR) |
| 779 return false; | |
| 780 | |
| 781 histogram = gimple_histogram_value_of_type (cfun, stmt, | |
| 782 HIST_TYPE_SINGLE_VALUE); | |
| 783 if (!histogram) | |
| 784 return false; | |
| 785 | |
| 786 value = histogram->hvalue.value; | |
| 787 val = histogram->hvalue.counters[0]; | |
| 788 count = histogram->hvalue.counters[1]; | |
| 789 all = histogram->hvalue.counters[2]; | |
| 790 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 791 | |
| 792 /* We require that count is at least half of all; this means | |
| 793 that for the transformation to fire the value must be constant | |
| 794 at least 50% of time (and 75% gives the guarantee of usage). */ | |
| 795 if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1 | |
| 796 || 2 * count < all | |
| 797 || optimize_bb_for_size_p (gimple_bb (stmt))) | |
| 798 return false; | |
| 799 | |
| 800 if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count)) | |
| 801 return false; | |
| 802 | |
| 803 /* Compute probability of taking the optimal path. */ | |
| 804 if (all > 0) | |
| 111 | 805 prob = profile_probability::probability_in_gcov_type (count, all); |
| 0 | 806 else |
| 111 | 807 prob = profile_probability::never (); |
| 0 | 808 |
| 111 | 809 if (sizeof (gcov_type) == sizeof (HOST_WIDE_INT)) |
| 810 tree_val = build_int_cst (get_gcov_type (), val); | |
| 811 else | |
| 812 { | |
| 813 HOST_WIDE_INT a[2]; | |
| 814 a[0] = (unsigned HOST_WIDE_INT) val; | |
| 815 a[1] = val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1; | |
| 816 | |
| 817 tree_val = wide_int_to_tree (get_gcov_type (), wide_int::from_array (a, 2, | |
| 818 TYPE_PRECISION (get_gcov_type ()), false)); | |
| 819 } | |
| 0 | 820 result = gimple_divmod_fixed_value (stmt, tree_val, prob, count, all); |
| 821 | |
| 822 if (dump_file) | |
| 823 { | |
| 131 | 824 fprintf (dump_file, "Transformation done: div/mod by constant "); |
| 0 | 825 print_generic_expr (dump_file, tree_val, TDF_SLIM); |
| 131 | 826 fprintf (dump_file, "\n"); |
| 0 | 827 } |
| 828 | |
| 829 gimple_assign_set_rhs_from_tree (si, result); | |
|
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
|
830 update_stmt (gsi_stmt (*si)); |
| 0 | 831 |
| 832 return true; | |
| 833 } | |
| 834 | |
| 835 /* Generate code for transformation 2 (with parent gimple assign STMT and | |
| 836 probability of taking the optimal path PROB, which is equivalent to COUNT/ALL | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
837 within roundoff error). This generates the result into a temp and returns |
| 0 | 838 the temp; it does not replace or alter the original STMT. */ |
| 111 | 839 |
| 0 | 840 static tree |
| 111 | 841 gimple_mod_pow2 (gassign *stmt, profile_probability prob, gcov_type count, gcov_type all) |
| 0 | 842 { |
| 111 | 843 gassign *stmt1, *stmt2, *stmt3; |
| 844 gcond *stmt4; | |
| 845 tree tmp2, tmp3; | |
| 846 gimple *bb1end, *bb2end, *bb3end; | |
| 0 | 847 basic_block bb, bb2, bb3, bb4; |
| 848 tree optype, op1, op2; | |
| 849 edge e12, e13, e23, e24, e34; | |
| 850 gimple_stmt_iterator gsi; | |
| 851 tree result; | |
| 852 | |
| 853 gcc_assert (is_gimple_assign (stmt) | |
| 854 && gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR); | |
| 855 | |
| 856 optype = TREE_TYPE (gimple_assign_lhs (stmt)); | |
| 857 op1 = gimple_assign_rhs1 (stmt); | |
| 858 op2 = gimple_assign_rhs2 (stmt); | |
| 859 | |
| 860 bb = gimple_bb (stmt); | |
| 861 gsi = gsi_for_stmt (stmt); | |
| 862 | |
| 111 | 863 result = create_tmp_reg (optype, "PROF"); |
| 864 tmp2 = make_temp_ssa_name (optype, NULL, "PROF"); | |
| 865 tmp3 = make_temp_ssa_name (optype, NULL, "PROF"); | |
| 866 stmt2 = gimple_build_assign (tmp2, PLUS_EXPR, op2, | |
| 867 build_int_cst (optype, -1)); | |
| 868 stmt3 = gimple_build_assign (tmp3, BIT_AND_EXPR, tmp2, op2); | |
| 0 | 869 stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0), |
| 870 NULL_TREE, NULL_TREE); | |
| 871 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT); | |
| 872 gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT); | |
| 873 gsi_insert_before (&gsi, stmt4, GSI_SAME_STMT); | |
| 874 bb1end = stmt4; | |
| 875 | |
| 876 /* tmp2 == op2-1 inherited from previous block. */ | |
| 111 | 877 stmt1 = gimple_build_assign (result, BIT_AND_EXPR, op1, tmp2); |
| 0 | 878 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); |
| 879 bb2end = stmt1; | |
| 880 | |
| 111 | 881 stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt), |
| 882 op1, op2); | |
| 0 | 883 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); |
| 884 bb3end = stmt1; | |
| 885 | |
| 886 /* Fix CFG. */ | |
| 887 /* Edge e23 connects bb2 to bb3, etc. */ | |
| 888 e12 = split_block (bb, bb1end); | |
| 889 bb2 = e12->dest; | |
| 111 | 890 bb2->count = profile_count::from_gcov_type (count); |
| 0 | 891 e23 = split_block (bb2, bb2end); |
| 892 bb3 = e23->dest; | |
| 111 | 893 bb3->count = profile_count::from_gcov_type (all - count); |
| 0 | 894 e34 = split_block (bb3, bb3end); |
| 895 bb4 = e34->dest; | |
| 111 | 896 bb4->count = profile_count::from_gcov_type (all); |
| 0 | 897 |
| 898 e12->flags &= ~EDGE_FALLTHRU; | |
| 899 e12->flags |= EDGE_FALSE_VALUE; | |
| 900 e12->probability = prob; | |
| 901 | |
| 902 e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE); | |
| 111 | 903 e13->probability = prob.invert (); |
| 0 | 904 |
| 905 remove_edge (e23); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
906 |
| 0 | 907 e24 = make_edge (bb2, bb4, EDGE_FALLTHRU); |
| 111 | 908 e24->probability = profile_probability::always (); |
| 0 | 909 |
| 111 | 910 e34->probability = profile_probability::always (); |
| 0 | 911 |
| 912 return result; | |
| 913 } | |
| 914 | |
| 915 /* Do transform 2) on INSN if applicable. */ | |
| 111 | 916 |
| 0 | 917 static bool |
| 918 gimple_mod_pow2_value_transform (gimple_stmt_iterator *si) | |
| 919 { | |
| 920 histogram_value histogram; | |
| 921 enum tree_code code; | |
| 922 gcov_type count, wrong_values, all; | |
| 923 tree lhs_type, result, value; | |
| 111 | 924 profile_probability prob; |
| 925 gassign *stmt; | |
| 0 | 926 |
| 111 | 927 stmt = dyn_cast <gassign *> (gsi_stmt (*si)); |
| 928 if (!stmt) | |
| 0 | 929 return false; |
| 930 | |
| 931 lhs_type = TREE_TYPE (gimple_assign_lhs (stmt)); | |
| 932 if (!INTEGRAL_TYPE_P (lhs_type)) | |
| 933 return false; | |
| 934 | |
| 935 code = gimple_assign_rhs_code (stmt); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
936 |
| 0 | 937 if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type)) |
| 938 return false; | |
| 939 | |
| 940 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_POW2); | |
| 941 if (!histogram) | |
| 942 return false; | |
| 943 | |
| 944 value = histogram->hvalue.value; | |
| 945 wrong_values = histogram->hvalue.counters[0]; | |
| 946 count = histogram->hvalue.counters[1]; | |
| 947 | |
| 948 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 949 | |
| 950 /* We require that we hit a power of 2 at least half of all evaluations. */ | |
| 951 if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1 | |
| 952 || count < wrong_values | |
| 953 || optimize_bb_for_size_p (gimple_bb (stmt))) | |
| 954 return false; | |
| 955 | |
| 956 /* Compute probability of taking the optimal path. */ | |
| 957 all = count + wrong_values; | |
| 958 | |
| 959 if (check_counter (stmt, "pow2", &count, &all, gimple_bb (stmt)->count)) | |
| 960 return false; | |
| 961 | |
| 131 | 962 if (dump_file) |
| 963 fprintf (dump_file, "Transformation done: mod power of 2\n"); | |
| 964 | |
| 0 | 965 if (all > 0) |
| 111 | 966 prob = profile_probability::probability_in_gcov_type (count, all); |
| 0 | 967 else |
| 111 | 968 prob = profile_probability::never (); |
| 0 | 969 |
| 970 result = gimple_mod_pow2 (stmt, prob, count, all); | |
| 971 | |
| 972 gimple_assign_set_rhs_from_tree (si, result); | |
|
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
|
973 update_stmt (gsi_stmt (*si)); |
| 0 | 974 |
| 975 return true; | |
| 976 } | |
| 977 | |
| 978 /* Generate code for transformations 3 and 4 (with parent gimple assign STMT, and | |
| 979 NCOUNTS the number of cases to support. Currently only NCOUNTS==0 or 1 is | |
| 980 supported and this is built into this interface. The probabilities of taking | |
| 981 the optimal paths are PROB1 and PROB2, which are equivalent to COUNT1/ALL and | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
982 COUNT2/ALL respectively within roundoff error). This generates the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
983 result into a temp and returns the temp; it does not replace or alter |
| 0 | 984 the original STMT. */ |
| 985 /* FIXME: Generalize the interface to handle NCOUNTS > 1. */ | |
| 986 | |
| 987 static tree | |
| 111 | 988 gimple_mod_subtract (gassign *stmt, profile_probability prob1, |
| 989 profile_probability prob2, int ncounts, | |
| 0 | 990 gcov_type count1, gcov_type count2, gcov_type all) |
| 991 { | |
| 111 | 992 gassign *stmt1; |
| 993 gimple *stmt2; | |
| 994 gcond *stmt3; | |
| 0 | 995 tree tmp1; |
| 111 | 996 gimple *bb1end, *bb2end = NULL, *bb3end; |
| 0 | 997 basic_block bb, bb2, bb3, bb4; |
| 998 tree optype, op1, op2; | |
| 999 edge e12, e23 = 0, e24, e34, e14; | |
| 1000 gimple_stmt_iterator gsi; | |
| 1001 tree result; | |
| 1002 | |
| 1003 gcc_assert (is_gimple_assign (stmt) | |
| 1004 && gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR); | |
| 1005 | |
| 1006 optype = TREE_TYPE (gimple_assign_lhs (stmt)); | |
| 1007 op1 = gimple_assign_rhs1 (stmt); | |
| 1008 op2 = gimple_assign_rhs2 (stmt); | |
| 1009 | |
| 1010 bb = gimple_bb (stmt); | |
| 1011 gsi = gsi_for_stmt (stmt); | |
| 1012 | |
| 111 | 1013 result = create_tmp_reg (optype, "PROF"); |
| 1014 tmp1 = make_temp_ssa_name (optype, NULL, "PROF"); | |
| 0 | 1015 stmt1 = gimple_build_assign (result, op1); |
| 1016 stmt2 = gimple_build_assign (tmp1, op2); | |
| 1017 stmt3 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE); | |
| 1018 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); | |
| 1019 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT); | |
| 1020 gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT); | |
| 1021 bb1end = stmt3; | |
| 1022 | |
| 1023 if (ncounts) /* Assumed to be 0 or 1 */ | |
| 1024 { | |
| 111 | 1025 stmt1 = gimple_build_assign (result, MINUS_EXPR, result, tmp1); |
| 0 | 1026 stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE); |
| 1027 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); | |
| 1028 gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT); | |
| 1029 bb2end = stmt2; | |
| 1030 } | |
| 1031 | |
| 1032 /* Fallback case. */ | |
| 111 | 1033 stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt), |
| 1034 result, tmp1); | |
| 0 | 1035 gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT); |
| 1036 bb3end = stmt1; | |
| 1037 | |
| 1038 /* Fix CFG. */ | |
| 1039 /* Edge e23 connects bb2 to bb3, etc. */ | |
| 1040 /* However block 3 is optional; if it is not there, references | |
| 1041 to 3 really refer to block 2. */ | |
| 1042 e12 = split_block (bb, bb1end); | |
| 1043 bb2 = e12->dest; | |
| 111 | 1044 bb2->count = profile_count::from_gcov_type (all - count1); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1045 |
| 0 | 1046 if (ncounts) /* Assumed to be 0 or 1. */ |
| 1047 { | |
| 1048 e23 = split_block (bb2, bb2end); | |
| 1049 bb3 = e23->dest; | |
| 111 | 1050 bb3->count = profile_count::from_gcov_type (all - count1 - count2); |
| 0 | 1051 } |
| 1052 | |
| 1053 e34 = split_block (ncounts ? bb3 : bb2, bb3end); | |
| 1054 bb4 = e34->dest; | |
| 111 | 1055 bb4->count = profile_count::from_gcov_type (all); |
| 0 | 1056 |
| 1057 e12->flags &= ~EDGE_FALLTHRU; | |
| 1058 e12->flags |= EDGE_FALSE_VALUE; | |
| 111 | 1059 e12->probability = prob1.invert (); |
| 0 | 1060 |
| 1061 e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE); | |
| 1062 e14->probability = prob1; | |
| 1063 | |
| 1064 if (ncounts) /* Assumed to be 0 or 1. */ | |
| 1065 { | |
| 1066 e23->flags &= ~EDGE_FALLTHRU; | |
| 1067 e23->flags |= EDGE_FALSE_VALUE; | |
| 111 | 1068 e23->probability = prob2.invert (); |
| 0 | 1069 |
| 1070 e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE); | |
| 1071 e24->probability = prob2; | |
| 1072 } | |
| 1073 | |
| 111 | 1074 e34->probability = profile_probability::always (); |
| 0 | 1075 |
| 1076 return result; | |
| 1077 } | |
| 1078 | |
| 1079 /* Do transforms 3) and 4) on the statement pointed-to by SI if applicable. */ | |
| 1080 | |
| 1081 static bool | |
| 1082 gimple_mod_subtract_transform (gimple_stmt_iterator *si) | |
| 1083 { | |
| 1084 histogram_value histogram; | |
| 1085 enum tree_code code; | |
| 1086 gcov_type count, wrong_values, all; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1087 tree lhs_type, result; |
| 111 | 1088 profile_probability prob1, prob2; |
| 0 | 1089 unsigned int i, steps; |
| 1090 gcov_type count1, count2; | |
| 111 | 1091 gassign *stmt; |
| 1092 stmt = dyn_cast <gassign *> (gsi_stmt (*si)); | |
| 1093 if (!stmt) | |
| 0 | 1094 return false; |
| 1095 | |
| 1096 lhs_type = TREE_TYPE (gimple_assign_lhs (stmt)); | |
| 1097 if (!INTEGRAL_TYPE_P (lhs_type)) | |
| 1098 return false; | |
| 1099 | |
| 1100 code = gimple_assign_rhs_code (stmt); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1101 |
| 0 | 1102 if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type)) |
| 1103 return false; | |
| 1104 | |
| 1105 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INTERVAL); | |
| 1106 if (!histogram) | |
| 1107 return false; | |
| 1108 | |
| 1109 all = 0; | |
| 1110 wrong_values = 0; | |
| 1111 for (i = 0; i < histogram->hdata.intvl.steps; i++) | |
| 1112 all += histogram->hvalue.counters[i]; | |
| 1113 | |
| 1114 wrong_values += histogram->hvalue.counters[i]; | |
| 1115 wrong_values += histogram->hvalue.counters[i+1]; | |
| 1116 steps = histogram->hdata.intvl.steps; | |
| 1117 all += wrong_values; | |
| 1118 count1 = histogram->hvalue.counters[0]; | |
| 1119 count2 = histogram->hvalue.counters[1]; | |
| 1120 | |
| 1121 /* Compute probability of taking the optimal path. */ | |
| 1122 if (check_counter (stmt, "interval", &count1, &all, gimple_bb (stmt)->count)) | |
| 1123 { | |
| 1124 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1125 return false; | |
| 1126 } | |
| 1127 | |
| 1128 if (flag_profile_correction && count1 + count2 > all) | |
| 1129 all = count1 + count2; | |
| 1130 | |
| 1131 gcc_assert (count1 + count2 <= all); | |
| 1132 | |
| 1133 /* We require that we use just subtractions in at least 50% of all | |
| 1134 evaluations. */ | |
| 1135 count = 0; | |
| 1136 for (i = 0; i < histogram->hdata.intvl.steps; i++) | |
| 1137 { | |
| 1138 count += histogram->hvalue.counters[i]; | |
| 1139 if (count * 2 >= all) | |
| 1140 break; | |
| 1141 } | |
| 1142 if (i == steps | |
| 1143 || optimize_bb_for_size_p (gimple_bb (stmt))) | |
| 1144 return false; | |
| 1145 | |
| 1146 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1147 if (dump_file) | |
| 131 | 1148 fprintf (dump_file, "Transformation done: mod subtract\n"); |
| 0 | 1149 |
| 1150 /* Compute probability of taking the optimal path(s). */ | |
| 1151 if (all > 0) | |
| 1152 { | |
| 111 | 1153 prob1 = profile_probability::probability_in_gcov_type (count1, all); |
| 1154 prob2 = profile_probability::probability_in_gcov_type (count2, all); | |
| 0 | 1155 } |
| 1156 else | |
| 1157 { | |
| 111 | 1158 prob1 = prob2 = profile_probability::never (); |
| 0 | 1159 } |
| 1160 | |
| 1161 /* In practice, "steps" is always 2. This interface reflects this, | |
| 1162 and will need to be changed if "steps" can change. */ | |
| 1163 result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all); | |
| 1164 | |
| 1165 gimple_assign_set_rhs_from_tree (si, result); | |
|
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
|
1166 update_stmt (gsi_stmt (*si)); |
| 0 | 1167 |
| 1168 return true; | |
| 1169 } | |
| 1170 | |
| 111 | 1171 typedef int_hash <unsigned int, 0, UINT_MAX> profile_id_hash; |
| 1172 | |
| 1173 static hash_map<profile_id_hash, cgraph_node *> *cgraph_node_map = 0; | |
| 1174 | |
| 1175 /* Returns true if node graph is initialized. This | |
| 1176 is used to test if profile_id has been created | |
| 1177 for cgraph_nodes. */ | |
| 0 | 1178 |
| 111 | 1179 bool |
| 1180 coverage_node_map_initialized_p (void) | |
| 1181 { | |
| 1182 return cgraph_node_map != 0; | |
| 1183 } | |
| 0 | 1184 |
| 111 | 1185 /* Initialize map from PROFILE_ID to CGRAPH_NODE. |
| 1186 When LOCAL is true, the PROFILE_IDs are computed. when it is false we assume | |
| 1187 that the PROFILE_IDs was already assigned. */ | |
| 1188 | |
| 1189 void | |
| 1190 init_node_map (bool local) | |
| 0 | 1191 { |
| 1192 struct cgraph_node *n; | |
| 111 | 1193 cgraph_node_map = new hash_map<profile_id_hash, cgraph_node *>; |
| 0 | 1194 |
| 111 | 1195 FOR_EACH_DEFINED_FUNCTION (n) |
| 1196 if (n->has_gimple_body_p ()) | |
| 1197 { | |
| 1198 cgraph_node **val; | |
| 1199 if (local) | |
| 1200 { | |
| 1201 n->profile_id = coverage_compute_profile_id (n); | |
| 1202 while ((val = cgraph_node_map->get (n->profile_id)) | |
| 1203 || !n->profile_id) | |
| 1204 { | |
| 1205 if (dump_file) | |
| 1206 fprintf (dump_file, "Local profile-id %i conflict" | |
| 1207 " with nodes %s %s\n", | |
| 1208 n->profile_id, | |
| 1209 n->dump_name (), | |
| 1210 (*val)->dump_name ()); | |
| 1211 n->profile_id = (n->profile_id + 1) & 0x7fffffff; | |
| 1212 } | |
| 1213 } | |
| 1214 else if (!n->profile_id) | |
| 1215 { | |
| 1216 if (dump_file) | |
| 1217 fprintf (dump_file, | |
| 1218 "Node %s has no profile-id" | |
| 1219 " (profile feedback missing?)\n", | |
| 1220 n->dump_name ()); | |
| 1221 continue; | |
| 1222 } | |
| 1223 else if ((val = cgraph_node_map->get (n->profile_id))) | |
| 1224 { | |
| 1225 if (dump_file) | |
| 1226 fprintf (dump_file, | |
| 1227 "Node %s has IP profile-id %i conflict. " | |
| 1228 "Giving up.\n", | |
| 1229 n->dump_name (), n->profile_id); | |
| 1230 *val = NULL; | |
| 1231 continue; | |
| 1232 } | |
| 1233 cgraph_node_map->put (n->profile_id, n); | |
| 1234 } | |
| 1235 } | |
| 1236 | |
| 1237 /* Delete the CGRAPH_NODE_MAP. */ | |
| 1238 | |
| 1239 void | |
| 1240 del_node_map (void) | |
| 1241 { | |
| 1242 delete cgraph_node_map; | |
| 0 | 1243 } |
| 1244 | |
| 1245 /* Return cgraph node for function with pid */ | |
| 1246 | |
| 111 | 1247 struct cgraph_node* |
| 1248 find_func_by_profile_id (int profile_id) | |
| 0 | 1249 { |
| 111 | 1250 cgraph_node **val = cgraph_node_map->get (profile_id); |
| 1251 if (val) | |
| 1252 return *val; | |
| 1253 else | |
| 1254 return NULL; | |
| 1255 } | |
| 1256 | |
| 1257 /* Perform sanity check on the indirect call target. Due to race conditions, | |
| 1258 false function target may be attributed to an indirect call site. If the | |
| 1259 call expression type mismatches with the target function's type, expand_call | |
| 1260 may ICE. Here we only do very minimal sanity check just to make compiler happy. | |
| 1261 Returns true if TARGET is considered ok for call CALL_STMT. */ | |
| 0 | 1262 |
| 111 | 1263 bool |
| 1264 check_ic_target (gcall *call_stmt, struct cgraph_node *target) | |
| 1265 { | |
| 1266 if (gimple_check_call_matching_types (call_stmt, target->decl, true)) | |
| 1267 return true; | |
| 1268 | |
| 1269 if (dump_enabled_p ()) | |
| 131 | 1270 dump_printf_loc (MSG_MISSED_OPTIMIZATION, call_stmt, |
| 111 | 1271 "Skipping target %s with mismatching types for icall\n", |
| 1272 target->name ()); | |
| 1273 return false; | |
| 0 | 1274 } |
| 1275 | |
| 1276 /* Do transformation | |
| 1277 | |
| 1278 if (actual_callee_address == address_of_most_common_function/method) | |
| 1279 do direct call | |
| 1280 else | |
| 1281 old call | |
| 1282 */ | |
| 1283 | |
| 111 | 1284 gcall * |
| 1285 gimple_ic (gcall *icall_stmt, struct cgraph_node *direct_call, | |
| 131 | 1286 profile_probability prob) |
| 0 | 1287 { |
| 111 | 1288 gcall *dcall_stmt; |
| 1289 gassign *load_stmt; | |
| 1290 gcond *cond_stmt; | |
| 1291 tree tmp0, tmp1, tmp; | |
| 1292 basic_block cond_bb, dcall_bb, icall_bb, join_bb = NULL; | |
| 1293 edge e_cd, e_ci, e_di, e_dj = NULL, e_ij; | |
| 0 | 1294 gimple_stmt_iterator gsi; |
| 111 | 1295 int lp_nr, dflags; |
| 1296 edge e_eh, e; | |
| 1297 edge_iterator ei; | |
| 0 | 1298 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1299 cond_bb = gimple_bb (icall_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1300 gsi = gsi_for_stmt (icall_stmt); |
| 0 | 1301 |
| 131 | 1302 tmp0 = make_temp_ssa_name (ptr_type_node, NULL, "PROF"); |
| 1303 tmp1 = make_temp_ssa_name (ptr_type_node, NULL, "PROF"); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1304 tmp = unshare_expr (gimple_call_fn (icall_stmt)); |
|
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
|
1305 load_stmt = gimple_build_assign (tmp0, tmp); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1306 gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT); |
| 0 | 1307 |
| 131 | 1308 tmp = fold_convert (ptr_type_node, build_addr (direct_call->decl)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1309 load_stmt = gimple_build_assign (tmp1, tmp); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1310 gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT); |
| 0 | 1311 |
|
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
|
1312 cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1313 gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1314 |
| 111 | 1315 if (TREE_CODE (gimple_vdef (icall_stmt)) == SSA_NAME) |
| 1316 { | |
| 1317 unlink_stmt_vdef (icall_stmt); | |
| 1318 release_ssa_name (gimple_vdef (icall_stmt)); | |
| 1319 } | |
|
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
|
1320 gimple_set_vdef (icall_stmt, NULL_TREE); |
|
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
|
1321 gimple_set_vuse (icall_stmt, NULL_TREE); |
|
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
|
1322 update_stmt (icall_stmt); |
| 111 | 1323 dcall_stmt = as_a <gcall *> (gimple_copy (icall_stmt)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1324 gimple_call_set_fndecl (dcall_stmt, direct_call->decl); |
| 111 | 1325 dflags = flags_from_decl_or_type (direct_call->decl); |
| 1326 if ((dflags & ECF_NORETURN) != 0 | |
| 1327 && should_remove_lhs_p (gimple_call_lhs (dcall_stmt))) | |
| 1328 gimple_call_set_lhs (dcall_stmt, NULL_TREE); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1329 gsi_insert_before (&gsi, dcall_stmt, GSI_SAME_STMT); |
| 0 | 1330 |
| 1331 /* Fix CFG. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1332 /* Edge e_cd connects cond_bb to dcall_bb, etc; note the first letters. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1333 e_cd = split_block (cond_bb, cond_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1334 dcall_bb = e_cd->dest; |
| 131 | 1335 dcall_bb->count = cond_bb->count.apply_probability (prob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1336 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1337 e_di = split_block (dcall_bb, dcall_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1338 icall_bb = e_di->dest; |
| 131 | 1339 icall_bb->count = cond_bb->count - dcall_bb->count; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1340 |
|
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
|
1341 /* Do not disturb existing EH edges from the indirect call. */ |
|
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
|
1342 if (!stmt_ends_bb_p (icall_stmt)) |
|
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
|
1343 e_ij = split_block (icall_bb, icall_stmt); |
|
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
|
1344 else |
|
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
|
1345 { |
|
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
|
1346 e_ij = find_fallthru_edge (icall_bb->succs); |
| 111 | 1347 /* The indirect call might be noreturn. */ |
| 1348 if (e_ij != NULL) | |
| 1349 { | |
| 1350 e_ij->probability = profile_probability::always (); | |
| 1351 e_ij = single_pred_edge (split_edge (e_ij)); | |
| 1352 } | |
|
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
|
1353 } |
| 111 | 1354 if (e_ij != NULL) |
| 1355 { | |
| 1356 join_bb = e_ij->dest; | |
| 131 | 1357 join_bb->count = cond_bb->count; |
| 111 | 1358 } |
| 0 | 1359 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1360 e_cd->flags = (e_cd->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1361 e_cd->probability = prob; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1362 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1363 e_ci = make_edge (cond_bb, icall_bb, EDGE_FALSE_VALUE); |
| 111 | 1364 e_ci->probability = prob.invert (); |
| 0 | 1365 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1366 remove_edge (e_di); |
| 0 | 1367 |
| 111 | 1368 if (e_ij != NULL) |
| 1369 { | |
| 1370 if ((dflags & ECF_NORETURN) == 0) | |
| 1371 { | |
| 1372 e_dj = make_edge (dcall_bb, join_bb, EDGE_FALLTHRU); | |
| 1373 e_dj->probability = profile_probability::always (); | |
| 1374 } | |
| 1375 e_ij->probability = profile_probability::always (); | |
| 1376 } | |
| 0 | 1377 |
|
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
|
1378 /* Insert PHI node for the call result if necessary. */ |
|
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
|
1379 if (gimple_call_lhs (icall_stmt) |
| 111 | 1380 && TREE_CODE (gimple_call_lhs (icall_stmt)) == SSA_NAME |
| 1381 && (dflags & ECF_NORETURN) == 0) | |
|
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
|
1382 { |
|
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
|
1383 tree result = gimple_call_lhs (icall_stmt); |
| 111 | 1384 gphi *phi = create_phi_node (result, join_bb); |
|
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
|
1385 gimple_call_set_lhs (icall_stmt, |
| 111 | 1386 duplicate_ssa_name (result, icall_stmt)); |
|
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
|
1387 add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION); |
|
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
|
1388 gimple_call_set_lhs (dcall_stmt, |
| 111 | 1389 duplicate_ssa_name (result, dcall_stmt)); |
|
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
|
1390 add_phi_arg (phi, gimple_call_lhs (dcall_stmt), e_dj, UNKNOWN_LOCATION); |
|
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
|
1391 } |
|
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
|
1392 |
|
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
|
1393 /* Build an EH edge for the direct call if necessary. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1394 lp_nr = lookup_stmt_eh_lp (icall_stmt); |
| 131 | 1395 if (lp_nr > 0 && stmt_could_throw_p (cfun, dcall_stmt)) |
| 0 | 1396 { |
|
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
|
1397 add_stmt_to_eh_lp (dcall_stmt, lp_nr); |
| 0 | 1398 } |
| 1399 | |
| 111 | 1400 FOR_EACH_EDGE (e_eh, ei, icall_bb->succs) |
| 1401 if (e_eh->flags & (EDGE_EH | EDGE_ABNORMAL)) | |
| 1402 { | |
| 1403 e = make_edge (dcall_bb, e_eh->dest, e_eh->flags); | |
| 1404 e->probability = e_eh->probability; | |
| 1405 for (gphi_iterator psi = gsi_start_phis (e_eh->dest); | |
| 1406 !gsi_end_p (psi); gsi_next (&psi)) | |
| 1407 { | |
| 1408 gphi *phi = psi.phi (); | |
| 1409 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e), | |
| 1410 PHI_ARG_DEF_FROM_EDGE (phi, e_eh)); | |
| 1411 } | |
| 1412 } | |
| 131 | 1413 if (!stmt_could_throw_p (cfun, dcall_stmt)) |
| 111 | 1414 gimple_purge_dead_eh_edges (dcall_bb); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1415 return dcall_stmt; |
| 0 | 1416 } |
| 1417 | |
| 1418 /* | |
| 1419 For every checked indirect/virtual call determine if most common pid of | |
| 1420 function/class method has probability more than 50%. If yes modify code of | |
| 1421 this call to: | |
| 1422 */ | |
| 1423 | |
| 1424 static bool | |
| 111 | 1425 gimple_ic_transform (gimple_stmt_iterator *gsi) |
| 0 | 1426 { |
| 111 | 1427 gcall *stmt; |
| 0 | 1428 histogram_value histogram; |
| 1429 gcov_type val, count, all, bb_all; | |
| 1430 struct cgraph_node *direct_call; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1431 |
| 111 | 1432 stmt = dyn_cast <gcall *> (gsi_stmt (*gsi)); |
| 1433 if (!stmt) | |
| 0 | 1434 return false; |
| 1435 | |
| 111 | 1436 if (gimple_call_fndecl (stmt) != NULL_TREE) |
| 1437 return false; | |
| 0 | 1438 |
| 111 | 1439 if (gimple_call_internal_p (stmt)) |
| 0 | 1440 return false; |
| 1441 | |
| 1442 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INDIR_CALL); | |
| 1443 if (!histogram) | |
| 1444 return false; | |
| 1445 | |
| 1446 val = histogram->hvalue.counters [0]; | |
| 1447 count = histogram->hvalue.counters [1]; | |
| 1448 all = histogram->hvalue.counters [2]; | |
| 111 | 1449 |
| 131 | 1450 bb_all = gimple_bb (stmt)->count.ipa ().to_gcov_type (); |
| 111 | 1451 /* The order of CHECK_COUNTER calls is important - |
| 1452 since check_counter can correct the third parameter | |
| 1453 and we want to make count <= all <= bb_all. */ | |
| 1454 if (check_counter (stmt, "ic", &all, &bb_all, gimple_bb (stmt)->count) | |
| 1455 || check_counter (stmt, "ic", &count, &all, | |
| 1456 profile_count::from_gcov_type (all))) | |
| 1457 { | |
| 1458 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1459 return false; | |
| 1460 } | |
| 0 | 1461 |
| 1462 if (4 * count <= 3 * all) | |
| 1463 return false; | |
| 1464 | |
| 111 | 1465 direct_call = find_func_by_profile_id ((int)val); |
| 0 | 1466 |
| 1467 if (direct_call == NULL) | |
| 111 | 1468 { |
| 1469 if (val) | |
| 1470 { | |
| 1471 if (dump_file) | |
| 1472 { | |
| 1473 fprintf (dump_file, "Indirect call -> direct call from other module"); | |
| 1474 print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM); | |
| 1475 fprintf (dump_file, "=> %i (will resolve only with LTO)\n", (int)val); | |
| 1476 } | |
| 1477 } | |
| 1478 return false; | |
| 1479 } | |
| 0 | 1480 |
| 111 | 1481 if (!check_ic_target (stmt, direct_call)) |
| 1482 { | |
| 1483 if (dump_file) | |
| 1484 { | |
| 1485 fprintf (dump_file, "Indirect call -> direct call "); | |
| 1486 print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM); | |
| 1487 fprintf (dump_file, "=> "); | |
| 1488 print_generic_expr (dump_file, direct_call->decl, TDF_SLIM); | |
| 1489 fprintf (dump_file, " transformation skipped because of type mismatch"); | |
| 1490 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); | |
| 1491 } | |
| 1492 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1493 return false; | |
| 1494 } | |
| 0 | 1495 |
| 1496 if (dump_file) | |
| 1497 { | |
| 1498 fprintf (dump_file, "Indirect call -> direct call "); | |
| 1499 print_generic_expr (dump_file, gimple_call_fn (stmt), TDF_SLIM); | |
| 1500 fprintf (dump_file, "=> "); | |
| 1501 print_generic_expr (dump_file, direct_call->decl, TDF_SLIM); | |
| 111 | 1502 fprintf (dump_file, " transformation on insn postponned to ipa-profile"); |
| 0 | 1503 print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); |
| 111 | 1504 fprintf (dump_file, "hist->count %" PRId64 |
| 1505 " hist->all %" PRId64"\n", count, all); | |
| 0 | 1506 } |
| 1507 | |
| 1508 return true; | |
| 1509 } | |
| 1510 | |
| 111 | 1511 /* Return true if the stringop CALL shall be profiled. SIZE_ARG be |
| 1512 set to the argument index for the size of the string operation. */ | |
| 1513 | |
| 0 | 1514 static bool |
| 111 | 1515 interesting_stringop_to_profile_p (gcall *call, int *size_arg) |
| 0 | 1516 { |
| 111 | 1517 enum built_in_function fcode; |
| 0 | 1518 |
| 111 | 1519 fcode = DECL_FUNCTION_CODE (gimple_call_fndecl (call)); |
| 0 | 1520 switch (fcode) |
| 1521 { | |
| 1522 case BUILT_IN_MEMCPY: | |
| 1523 case BUILT_IN_MEMPCPY: | |
| 131 | 1524 case BUILT_IN_MEMMOVE: |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1525 *size_arg = 2; |
| 0 | 1526 return validate_gimple_arglist (call, POINTER_TYPE, POINTER_TYPE, |
| 1527 INTEGER_TYPE, VOID_TYPE); | |
| 1528 case BUILT_IN_MEMSET: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1529 *size_arg = 2; |
| 0 | 1530 return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE, |
| 1531 INTEGER_TYPE, VOID_TYPE); | |
| 1532 case BUILT_IN_BZERO: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1533 *size_arg = 1; |
| 0 | 1534 return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE, |
| 1535 VOID_TYPE); | |
| 1536 default: | |
| 131 | 1537 return false; |
| 0 | 1538 } |
| 1539 } | |
| 1540 | |
| 111 | 1541 /* Convert stringop (..., vcall_size) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1542 into |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1543 if (vcall_size == icall_size) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1544 stringop (..., icall_size); |
| 0 | 1545 else |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1546 stringop (..., vcall_size); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1547 assuming we'll propagate a true constant into ICALL_SIZE later. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1548 |
| 0 | 1549 static void |
| 111 | 1550 gimple_stringop_fixed_value (gcall *vcall_stmt, tree icall_size, profile_probability prob, |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1551 gcov_type count, gcov_type all) |
| 0 | 1552 { |
| 111 | 1553 gassign *tmp_stmt; |
| 1554 gcond *cond_stmt; | |
| 1555 gcall *icall_stmt; | |
| 1556 tree tmp0, tmp1, vcall_size, optype; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1557 basic_block cond_bb, icall_bb, vcall_bb, join_bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1558 edge e_ci, e_cv, e_iv, e_ij, e_vj; |
| 0 | 1559 gimple_stmt_iterator gsi; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1560 int size_arg; |
| 0 | 1561 |
| 111 | 1562 if (!interesting_stringop_to_profile_p (vcall_stmt, &size_arg)) |
| 1563 gcc_unreachable (); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1564 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1565 cond_bb = gimple_bb (vcall_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1566 gsi = gsi_for_stmt (vcall_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1567 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1568 vcall_size = gimple_call_arg (vcall_stmt, size_arg); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1569 optype = TREE_TYPE (vcall_size); |
| 0 | 1570 |
| 111 | 1571 tmp0 = make_temp_ssa_name (optype, NULL, "PROF"); |
| 1572 tmp1 = make_temp_ssa_name (optype, NULL, "PROF"); | |
|
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
|
1573 tmp_stmt = gimple_build_assign (tmp0, fold_convert (optype, icall_size)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1574 gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1575 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1576 tmp_stmt = gimple_build_assign (tmp1, vcall_size); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1577 gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT); |
| 0 | 1578 |
|
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
|
1579 cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1580 gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1581 |
| 111 | 1582 if (TREE_CODE (gimple_vdef (vcall_stmt)) == SSA_NAME) |
| 1583 { | |
| 1584 unlink_stmt_vdef (vcall_stmt); | |
| 1585 release_ssa_name (gimple_vdef (vcall_stmt)); | |
| 1586 } | |
|
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
|
1587 gimple_set_vdef (vcall_stmt, NULL); |
|
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
|
1588 gimple_set_vuse (vcall_stmt, NULL); |
|
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
|
1589 update_stmt (vcall_stmt); |
| 111 | 1590 icall_stmt = as_a <gcall *> (gimple_copy (vcall_stmt)); |
| 1591 gimple_call_set_arg (icall_stmt, size_arg, | |
| 1592 fold_convert (optype, icall_size)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1593 gsi_insert_before (&gsi, icall_stmt, GSI_SAME_STMT); |
| 0 | 1594 |
| 1595 /* Fix CFG. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1596 /* Edge e_ci connects cond_bb to icall_bb, etc. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1597 e_ci = split_block (cond_bb, cond_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1598 icall_bb = e_ci->dest; |
| 111 | 1599 icall_bb->count = profile_count::from_gcov_type (count); |
| 0 | 1600 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1601 e_iv = split_block (icall_bb, icall_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1602 vcall_bb = e_iv->dest; |
| 111 | 1603 vcall_bb->count = profile_count::from_gcov_type (all - count); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1604 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1605 e_vj = split_block (vcall_bb, vcall_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1606 join_bb = e_vj->dest; |
| 111 | 1607 join_bb->count = profile_count::from_gcov_type (all); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1608 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1609 e_ci->flags = (e_ci->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1610 e_ci->probability = prob; |
| 0 | 1611 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1612 e_cv = make_edge (cond_bb, vcall_bb, EDGE_FALSE_VALUE); |
| 111 | 1613 e_cv->probability = prob.invert (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1614 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1615 remove_edge (e_iv); |
| 0 | 1616 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1617 e_ij = make_edge (icall_bb, join_bb, EDGE_FALLTHRU); |
| 111 | 1618 e_ij->probability = profile_probability::always (); |
| 0 | 1619 |
| 111 | 1620 e_vj->probability = profile_probability::always (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1621 |
|
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
|
1622 /* Insert PHI node for the call result if necessary. */ |
|
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
|
1623 if (gimple_call_lhs (vcall_stmt) |
|
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
|
1624 && TREE_CODE (gimple_call_lhs (vcall_stmt)) == SSA_NAME) |
|
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
|
1625 { |
|
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
|
1626 tree result = gimple_call_lhs (vcall_stmt); |
| 111 | 1627 gphi *phi = create_phi_node (result, join_bb); |
|
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
|
1628 gimple_call_set_lhs (vcall_stmt, |
| 111 | 1629 duplicate_ssa_name (result, vcall_stmt)); |
|
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
|
1630 add_phi_arg (phi, gimple_call_lhs (vcall_stmt), e_vj, UNKNOWN_LOCATION); |
|
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
|
1631 gimple_call_set_lhs (icall_stmt, |
| 111 | 1632 duplicate_ssa_name (result, icall_stmt)); |
|
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
|
1633 add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION); |
|
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
|
1634 } |
|
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
|
1635 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1636 /* Because these are all string op builtins, they're all nothrow. */ |
| 131 | 1637 gcc_assert (!stmt_could_throw_p (cfun, vcall_stmt)); |
| 1638 gcc_assert (!stmt_could_throw_p (cfun, icall_stmt)); | |
| 0 | 1639 } |
| 1640 | |
| 1641 /* Find values inside STMT for that we want to measure histograms for | |
| 1642 division/modulo optimization. */ | |
| 111 | 1643 |
| 0 | 1644 static bool |
| 1645 gimple_stringops_transform (gimple_stmt_iterator *gsi) | |
| 1646 { | |
| 111 | 1647 gcall *stmt; |
| 0 | 1648 tree blck_size; |
| 1649 enum built_in_function fcode; | |
| 1650 histogram_value histogram; | |
| 1651 gcov_type count, all, val; | |
| 1652 tree dest, src; | |
| 1653 unsigned int dest_align, src_align; | |
| 111 | 1654 profile_probability prob; |
| 0 | 1655 tree tree_val; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1656 int size_arg; |
| 0 | 1657 |
| 111 | 1658 stmt = dyn_cast <gcall *> (gsi_stmt (*gsi)); |
| 1659 if (!stmt) | |
| 0 | 1660 return false; |
| 111 | 1661 |
| 1662 if (!gimple_call_builtin_p (gsi_stmt (*gsi), BUILT_IN_NORMAL)) | |
| 0 | 1663 return false; |
| 111 | 1664 |
| 1665 if (!interesting_stringop_to_profile_p (stmt, &size_arg)) | |
| 0 | 1666 return false; |
| 1667 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1668 blck_size = gimple_call_arg (stmt, size_arg); |
| 0 | 1669 if (TREE_CODE (blck_size) == INTEGER_CST) |
| 1670 return false; | |
| 1671 | |
| 1672 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE); | |
| 1673 if (!histogram) | |
| 1674 return false; | |
| 111 | 1675 |
| 0 | 1676 val = histogram->hvalue.counters[0]; |
| 1677 count = histogram->hvalue.counters[1]; | |
| 1678 all = histogram->hvalue.counters[2]; | |
| 1679 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 111 | 1680 |
| 0 | 1681 /* We require that count is at least half of all; this means |
| 1682 that for the transformation to fire the value must be constant | |
| 1683 at least 80% of time. */ | |
| 1684 if ((6 * count / 5) < all || optimize_bb_for_size_p (gimple_bb (stmt))) | |
| 1685 return false; | |
| 1686 if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count)) | |
| 1687 return false; | |
| 1688 if (all > 0) | |
| 111 | 1689 prob = profile_probability::probability_in_gcov_type (count, all); |
| 0 | 1690 else |
| 111 | 1691 prob = profile_probability::never (); |
| 1692 | |
| 0 | 1693 dest = gimple_call_arg (stmt, 0); |
| 111 | 1694 dest_align = get_pointer_alignment (dest); |
| 1695 fcode = DECL_FUNCTION_CODE (gimple_call_fndecl (stmt)); | |
| 0 | 1696 switch (fcode) |
| 1697 { | |
| 1698 case BUILT_IN_MEMCPY: | |
| 1699 case BUILT_IN_MEMPCPY: | |
| 131 | 1700 case BUILT_IN_MEMMOVE: |
| 0 | 1701 src = gimple_call_arg (stmt, 1); |
| 111 | 1702 src_align = get_pointer_alignment (src); |
| 0 | 1703 if (!can_move_by_pieces (val, MIN (dest_align, src_align))) |
| 1704 return false; | |
| 1705 break; | |
| 1706 case BUILT_IN_MEMSET: | |
| 1707 if (!can_store_by_pieces (val, builtin_memset_read_str, | |
| 1708 gimple_call_arg (stmt, 1), | |
| 1709 dest_align, true)) | |
| 1710 return false; | |
| 1711 break; | |
| 1712 case BUILT_IN_BZERO: | |
| 1713 if (!can_store_by_pieces (val, builtin_memset_read_str, | |
| 1714 integer_zero_node, | |
| 1715 dest_align, true)) | |
| 1716 return false; | |
| 1717 break; | |
| 1718 default: | |
| 1719 gcc_unreachable (); | |
| 1720 } | |
| 111 | 1721 |
| 1722 if (sizeof (gcov_type) == sizeof (HOST_WIDE_INT)) | |
| 1723 tree_val = build_int_cst (get_gcov_type (), val); | |
| 1724 else | |
| 1725 { | |
| 1726 HOST_WIDE_INT a[2]; | |
| 1727 a[0] = (unsigned HOST_WIDE_INT) val; | |
| 1728 a[1] = val >> (HOST_BITS_PER_WIDE_INT - 1) >> 1; | |
| 1729 | |
| 1730 tree_val = wide_int_to_tree (get_gcov_type (), wide_int::from_array (a, 2, | |
| 1731 TYPE_PRECISION (get_gcov_type ()), false)); | |
| 1732 } | |
| 1733 | |
| 0 | 1734 if (dump_file) |
| 131 | 1735 fprintf (dump_file, |
| 1736 "Transformation done: single value %i stringop for %s\n", | |
| 1737 (int)val, built_in_names[(int)fcode]); | |
| 111 | 1738 |
| 0 | 1739 gimple_stringop_fixed_value (stmt, tree_val, prob, count, all); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1740 |
| 0 | 1741 return true; |
| 1742 } | |
| 1743 | |
| 1744 void | |
| 111 | 1745 stringop_block_profile (gimple *stmt, unsigned int *expected_align, |
| 0 | 1746 HOST_WIDE_INT *expected_size) |
| 1747 { | |
| 1748 histogram_value histogram; | |
| 1749 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_AVERAGE); | |
| 111 | 1750 |
| 0 | 1751 if (!histogram) |
| 1752 *expected_size = -1; | |
| 1753 else if (!histogram->hvalue.counters[1]) | |
| 1754 { | |
| 1755 *expected_size = -1; | |
| 1756 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1757 } | |
| 1758 else | |
| 1759 { | |
| 1760 gcov_type size; | |
| 1761 size = ((histogram->hvalue.counters[0] | |
| 1762 + histogram->hvalue.counters[1] / 2) | |
| 1763 / histogram->hvalue.counters[1]); | |
| 1764 /* Even if we can hold bigger value in SIZE, INT_MAX | |
| 1765 is safe "infinity" for code generation strategies. */ | |
| 1766 if (size > INT_MAX) | |
| 1767 size = INT_MAX; | |
| 1768 *expected_size = size; | |
| 1769 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1770 } | |
| 111 | 1771 |
| 0 | 1772 histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_IOR); |
| 111 | 1773 |
| 0 | 1774 if (!histogram) |
| 1775 *expected_align = 0; | |
| 1776 else if (!histogram->hvalue.counters[0]) | |
| 1777 { | |
| 1778 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1779 *expected_align = 0; | |
| 1780 } | |
| 1781 else | |
| 1782 { | |
| 1783 gcov_type count; | |
| 111 | 1784 unsigned int alignment; |
| 0 | 1785 |
| 1786 count = histogram->hvalue.counters[0]; | |
| 1787 alignment = 1; | |
| 1788 while (!(count & alignment) | |
| 111 | 1789 && (alignment <= UINT_MAX / 2 / BITS_PER_UNIT)) |
| 0 | 1790 alignment <<= 1; |
| 1791 *expected_align = alignment * BITS_PER_UNIT; | |
| 1792 gimple_remove_histogram_value (cfun, stmt, histogram); | |
| 1793 } | |
| 1794 } | |
| 1795 | |
| 1796 | |
| 1797 /* Find values inside STMT for that we want to measure histograms for | |
| 1798 division/modulo optimization. */ | |
| 111 | 1799 |
| 0 | 1800 static void |
| 111 | 1801 gimple_divmod_values_to_profile (gimple *stmt, histogram_values *values) |
| 0 | 1802 { |
| 1803 tree lhs, divisor, op0, type; | |
| 1804 histogram_value hist; | |
| 1805 | |
| 1806 if (gimple_code (stmt) != GIMPLE_ASSIGN) | |
| 1807 return; | |
| 1808 | |
| 1809 lhs = gimple_assign_lhs (stmt); | |
| 1810 type = TREE_TYPE (lhs); | |
| 1811 if (!INTEGRAL_TYPE_P (type)) | |
| 1812 return; | |
| 1813 | |
| 1814 switch (gimple_assign_rhs_code (stmt)) | |
| 1815 { | |
| 1816 case TRUNC_DIV_EXPR: | |
| 1817 case TRUNC_MOD_EXPR: | |
| 1818 divisor = gimple_assign_rhs2 (stmt); | |
| 1819 op0 = gimple_assign_rhs1 (stmt); | |
| 1820 | |
| 111 | 1821 values->reserve (3); |
| 0 | 1822 |
| 111 | 1823 if (TREE_CODE (divisor) == SSA_NAME) |
| 0 | 1824 /* Check for the case where the divisor is the same value most |
| 1825 of the time. */ | |
| 111 | 1826 values->quick_push (gimple_alloc_histogram_value (cfun, |
| 0 | 1827 HIST_TYPE_SINGLE_VALUE, |
| 1828 stmt, divisor)); | |
| 1829 | |
| 1830 /* For mod, check whether it is not often a noop (or replaceable by | |
| 1831 a few subtractions). */ | |
| 1832 if (gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR | |
| 111 | 1833 && TYPE_UNSIGNED (type) |
| 1834 && TREE_CODE (divisor) == SSA_NAME) | |
| 0 | 1835 { |
| 1836 tree val; | |
| 1837 /* Check for a special case where the divisor is power of 2. */ | |
| 111 | 1838 values->quick_push (gimple_alloc_histogram_value (cfun, |
| 1839 HIST_TYPE_POW2, | |
| 1840 stmt, divisor)); | |
| 0 | 1841 |
| 1842 val = build2 (TRUNC_DIV_EXPR, type, op0, divisor); | |
| 1843 hist = gimple_alloc_histogram_value (cfun, HIST_TYPE_INTERVAL, | |
| 1844 stmt, val); | |
| 1845 hist->hdata.intvl.int_start = 0; | |
| 1846 hist->hdata.intvl.steps = 2; | |
| 111 | 1847 values->quick_push (hist); |
| 0 | 1848 } |
| 1849 return; | |
| 1850 | |
| 1851 default: | |
| 1852 return; | |
| 1853 } | |
| 1854 } | |
| 1855 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1856 /* Find calls inside STMT for that we want to measure histograms for |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1857 indirect/virtual call optimization. */ |
| 0 | 1858 |
| 1859 static void | |
| 111 | 1860 gimple_indirect_call_to_profile (gimple *stmt, histogram_values *values) |
| 0 | 1861 { |
| 1862 tree callee; | |
| 1863 | |
| 1864 if (gimple_code (stmt) != GIMPLE_CALL | |
| 111 | 1865 || gimple_call_internal_p (stmt) |
| 0 | 1866 || gimple_call_fndecl (stmt) != NULL_TREE) |
| 1867 return; | |
| 1868 | |
| 1869 callee = gimple_call_fn (stmt); | |
| 1870 | |
| 111 | 1871 values->reserve (3); |
| 0 | 1872 |
| 111 | 1873 values->quick_push (gimple_alloc_histogram_value ( |
| 1874 cfun, | |
| 1875 PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) ? | |
| 1876 HIST_TYPE_INDIR_CALL_TOPN : | |
| 1877 HIST_TYPE_INDIR_CALL, | |
| 1878 stmt, callee)); | |
| 0 | 1879 |
| 1880 return; | |
| 1881 } | |
| 1882 | |
| 1883 /* Find values inside STMT for that we want to measure histograms for | |
| 1884 string operations. */ | |
| 111 | 1885 |
| 0 | 1886 static void |
| 111 | 1887 gimple_stringops_values_to_profile (gimple *gs, histogram_values *values) |
| 0 | 1888 { |
| 111 | 1889 gcall *stmt; |
| 0 | 1890 tree blck_size; |
| 1891 tree dest; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1892 int size_arg; |
| 0 | 1893 |
| 111 | 1894 stmt = dyn_cast <gcall *> (gs); |
| 1895 if (!stmt) | |
| 0 | 1896 return; |
| 1897 | |
| 111 | 1898 if (!gimple_call_builtin_p (gs, BUILT_IN_NORMAL)) |
| 1899 return; | |
| 1900 | |
| 1901 if (!interesting_stringop_to_profile_p (stmt, &size_arg)) | |
| 0 | 1902 return; |
| 1903 | |
| 1904 dest = gimple_call_arg (stmt, 0); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1905 blck_size = gimple_call_arg (stmt, size_arg); |
| 0 | 1906 |
| 1907 if (TREE_CODE (blck_size) != INTEGER_CST) | |
| 1908 { | |
| 111 | 1909 values->safe_push (gimple_alloc_histogram_value (cfun, |
| 1910 HIST_TYPE_SINGLE_VALUE, | |
| 1911 stmt, blck_size)); | |
| 1912 values->safe_push (gimple_alloc_histogram_value (cfun, HIST_TYPE_AVERAGE, | |
| 1913 stmt, blck_size)); | |
| 0 | 1914 } |
| 111 | 1915 |
| 0 | 1916 if (TREE_CODE (blck_size) != INTEGER_CST) |
| 111 | 1917 values->safe_push (gimple_alloc_histogram_value (cfun, HIST_TYPE_IOR, |
| 1918 stmt, dest)); | |
| 0 | 1919 } |
| 1920 | |
| 1921 /* Find values inside STMT for that we want to measure histograms and adds | |
| 1922 them to list VALUES. */ | |
| 1923 | |
| 1924 static void | |
| 111 | 1925 gimple_values_to_profile (gimple *stmt, histogram_values *values) |
| 0 | 1926 { |
| 111 | 1927 gimple_divmod_values_to_profile (stmt, values); |
| 1928 gimple_stringops_values_to_profile (stmt, values); | |
| 1929 gimple_indirect_call_to_profile (stmt, values); | |
| 0 | 1930 } |
| 1931 | |
|
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
|
1932 void |
| 0 | 1933 gimple_find_values_to_profile (histogram_values *values) |
| 1934 { | |
| 1935 basic_block bb; | |
| 1936 gimple_stmt_iterator gsi; | |
| 1937 unsigned i; | |
| 1938 histogram_value hist = NULL; | |
| 111 | 1939 values->create (0); |
| 0 | 1940 |
| 111 | 1941 FOR_EACH_BB_FN (bb, cfun) |
| 0 | 1942 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) |
| 1943 gimple_values_to_profile (gsi_stmt (gsi), values); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1944 |
| 111 | 1945 values->safe_push (gimple_alloc_histogram_value (cfun, HIST_TYPE_TIME_PROFILE, 0, 0)); |
| 1946 | |
| 1947 FOR_EACH_VEC_ELT (*values, i, hist) | |
| 0 | 1948 { |
| 1949 switch (hist->type) | |
| 1950 { | |
| 1951 case HIST_TYPE_INTERVAL: | |
| 1952 hist->n_counters = hist->hdata.intvl.steps + 2; | |
| 1953 break; | |
| 1954 | |
| 1955 case HIST_TYPE_POW2: | |
| 1956 hist->n_counters = 2; | |
| 1957 break; | |
| 1958 | |
| 1959 case HIST_TYPE_SINGLE_VALUE: | |
| 1960 hist->n_counters = 3; | |
| 1961 break; | |
| 1962 | |
| 1963 case HIST_TYPE_INDIR_CALL: | |
| 1964 hist->n_counters = 3; | |
| 1965 break; | |
| 1966 | |
| 111 | 1967 case HIST_TYPE_TIME_PROFILE: |
| 1968 hist->n_counters = 1; | |
| 1969 break; | |
| 1970 | |
| 0 | 1971 case HIST_TYPE_AVERAGE: |
| 1972 hist->n_counters = 2; | |
| 1973 break; | |
| 1974 | |
| 1975 case HIST_TYPE_IOR: | |
| 1976 hist->n_counters = 1; | |
| 1977 break; | |
| 1978 | |
| 111 | 1979 case HIST_TYPE_INDIR_CALL_TOPN: |
| 1980 hist->n_counters = GCOV_ICALL_TOPN_NCOUNTS; | |
| 1981 break; | |
| 1982 | |
| 0 | 1983 default: |
| 1984 gcc_unreachable (); | |
| 1985 } | |
| 131 | 1986 if (dump_file && hist->hvalue.stmt != NULL) |
| 0 | 1987 { |
| 1988 fprintf (dump_file, "Stmt "); | |
| 1989 print_gimple_stmt (dump_file, hist->hvalue.stmt, 0, TDF_SLIM); | |
| 1990 dump_histogram_value (dump_file, hist); | |
| 1991 } | |
| 1992 } | |
| 1993 } |