1 /* Default profiling support. 2 Copyright (C) 1996-2024 Free Software Foundation, Inc. 3 Contributed by Cygnus Support. 4 5 This file is part of GDB, the GNU debugger. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* This must come before any other includes. */ 21 #include "defs.h" 22 23 #include <ctype.h> 24 #include <stdarg.h> 25 #include <stdlib.h> 26 #include <string.h> 27 28 #include "ansidecl.h" 29 30 #include "sim-main.h" 31 #include "sim-io.h" 32 #include "sim-options.h" 33 #include "sim-assert.h" 34 35 #if !WITH_PROFILE_PC_P 36 static unsigned int _profile_stub; 37 # define PROFILE_PC_FREQ(p) _profile_stub 38 # define PROFILE_PC_NR_BUCKETS(p) _profile_stub 39 # define PROFILE_PC_SHIFT(p) _profile_stub 40 # define PROFILE_PC_START(p) _profile_stub 41 # define PROFILE_PC_END(p) _profile_stub 42 # define PROFILE_INSN_COUNT(p) &_profile_stub 43 #endif 44 45 #define COMMAS(n) sim_add_commas (comma_buf, sizeof (comma_buf), (n)) 46 47 static MODULE_INIT_FN profile_init; 48 static MODULE_UNINSTALL_FN profile_uninstall; 49 50 static DECLARE_OPTION_HANDLER (profile_option_handler); 51 52 enum { 53 OPTION_PROFILE_INSN = OPTION_START, 54 OPTION_PROFILE_MEMORY, 55 OPTION_PROFILE_MODEL, 56 OPTION_PROFILE_FILE, 57 OPTION_PROFILE_CORE, 58 OPTION_PROFILE_CPU_FREQUENCY, 59 OPTION_PROFILE_PC, 60 OPTION_PROFILE_PC_RANGE, 61 OPTION_PROFILE_PC_GRANULARITY, 62 OPTION_PROFILE_RANGE, 63 OPTION_PROFILE_FUNCTION 64 }; 65 66 static const OPTION profile_options[] = { 67 { {"profile", optional_argument, NULL, 'p'}, 68 'p', "on|off", "Perform profiling", 69 profile_option_handler, NULL }, 70 { {"profile-insn", optional_argument, NULL, OPTION_PROFILE_INSN}, 71 '\0', "on|off", "Perform instruction profiling", 72 profile_option_handler, NULL }, 73 { {"profile-memory", optional_argument, NULL, OPTION_PROFILE_MEMORY}, 74 '\0', "on|off", "Perform memory profiling", 75 profile_option_handler, NULL }, 76 { {"profile-core", optional_argument, NULL, OPTION_PROFILE_CORE}, 77 '\0', "on|off", "Perform CORE profiling", 78 profile_option_handler, NULL }, 79 { {"profile-model", optional_argument, NULL, OPTION_PROFILE_MODEL}, 80 '\0', "on|off", "Perform model profiling", 81 profile_option_handler, NULL }, 82 { {"profile-cpu-frequency", required_argument, NULL, 83 OPTION_PROFILE_CPU_FREQUENCY}, 84 '\0', "CPU FREQUENCY", "Specify the speed of the simulated cpu clock", 85 profile_option_handler, NULL }, 86 87 { {"profile-file", required_argument, NULL, OPTION_PROFILE_FILE}, 88 '\0', "FILE NAME", "Specify profile output file", 89 profile_option_handler, NULL }, 90 91 { {"profile-pc", optional_argument, NULL, OPTION_PROFILE_PC}, 92 '\0', "on|off", "Perform PC profiling", 93 profile_option_handler, NULL }, 94 { {"profile-pc-frequency", required_argument, NULL, 'F'}, 95 'F', "PC PROFILE FREQUENCY", "Specified PC profiling frequency", 96 profile_option_handler, NULL }, 97 { {"profile-pc-size", required_argument, NULL, 'S'}, 98 'S', "PC PROFILE SIZE", "Specify PC profiling size", 99 profile_option_handler, NULL }, 100 { {"profile-pc-granularity", required_argument, NULL, OPTION_PROFILE_PC_GRANULARITY}, 101 '\0', "PC PROFILE GRANULARITY", "Specify PC profiling sample coverage", 102 profile_option_handler, NULL }, 103 { {"profile-pc-range", required_argument, NULL, OPTION_PROFILE_PC_RANGE}, 104 '\0', "BASE,BOUND", "Specify PC profiling address range", 105 profile_option_handler, NULL }, 106 107 #ifdef SIM_HAVE_ADDR_RANGE 108 { {"profile-range", required_argument, NULL, OPTION_PROFILE_RANGE}, 109 '\0', "START,END", "Specify range of addresses for instruction and model profiling", 110 profile_option_handler, NULL }, 111 #if 0 /*wip*/ 112 { {"profile-function", required_argument, NULL, OPTION_PROFILE_FUNCTION}, 113 '\0', "FUNCTION", "Specify function to profile", 114 profile_option_handler, NULL }, 115 #endif 116 #endif 117 118 { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL } 119 }; 120 121 /* Set/reset the profile options indicated in MASK. */ 122 123 SIM_RC 124 set_profile_option_mask (SIM_DESC sd, const char *name, int mask, const char *arg) 125 { 126 int profile_nr; 127 int cpu_nr; 128 int profile_val = 1; 129 130 if (arg != NULL) 131 { 132 if (strcmp (arg, "yes") == 0 133 || strcmp (arg, "on") == 0 134 || strcmp (arg, "1") == 0) 135 profile_val = 1; 136 else if (strcmp (arg, "no") == 0 137 || strcmp (arg, "off") == 0 138 || strcmp (arg, "0") == 0) 139 profile_val = 0; 140 else 141 { 142 sim_io_eprintf (sd, "Argument `%s' for `--profile%s' invalid, one of `on', `off', `yes', `no' expected\n", arg, name); 143 return SIM_RC_FAIL; 144 } 145 } 146 147 /* update applicable profile bits */ 148 for (profile_nr = 0; profile_nr < MAX_PROFILE_VALUES; ++profile_nr) 149 { 150 if ((mask & (1 << profile_nr)) == 0) 151 continue; 152 153 #if 0 /* see sim-trace.c, set flags in STATE here if/when there are any */ 154 /* Set non-cpu specific values. */ 155 switch (profile_nr) 156 { 157 case ??? : 158 break; 159 } 160 #endif 161 162 /* Set cpu values. */ 163 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) 164 { 165 CPU_PROFILE_FLAGS (STATE_CPU (sd, cpu_nr))[profile_nr] = profile_val; 166 } 167 } 168 169 /* Re-compute the cpu profile summary. */ 170 if (profile_val) 171 { 172 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) 173 CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))->profile_any_p = 1; 174 } 175 else 176 { 177 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) 178 { 179 CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))->profile_any_p = 0; 180 for (profile_nr = 0; profile_nr < MAX_PROFILE_VALUES; ++profile_nr) 181 { 182 if (CPU_PROFILE_FLAGS (STATE_CPU (sd, cpu_nr))[profile_nr]) 183 { 184 CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))->profile_any_p = 1; 185 break; 186 } 187 } 188 } 189 } 190 191 return SIM_RC_OK; 192 } 193 194 /* Set one profile option based on its IDX value. 195 Not static as cgen-scache.c uses it. */ 196 197 SIM_RC 198 sim_profile_set_option (SIM_DESC sd, const char *name, int idx, const char *arg) 199 { 200 return set_profile_option_mask (sd, name, 1 << idx, arg); 201 } 202 203 static SIM_RC 204 parse_frequency (SIM_DESC sd, const char *arg, unsigned long *freq) 205 { 206 const char *ch; 207 /* First, parse a decimal number. */ 208 *freq = 0; 209 ch = arg; 210 if (isdigit (*arg)) 211 { 212 for (/**/; *ch != '\0'; ++ch) 213 { 214 if (! isdigit (*ch)) 215 break; 216 *freq = *freq * 10 + (*ch - '0'); 217 } 218 219 /* Accept KHz, MHz or Hz as a suffix. */ 220 if (tolower (*ch) == 'm') 221 { 222 *freq *= 1000000; 223 ++ch; 224 } 225 else if (tolower (*ch) == 'k') 226 { 227 *freq *= 1000; 228 ++ch; 229 } 230 231 if (tolower (*ch) == 'h') 232 { 233 ++ch; 234 if (tolower (*ch) == 'z') 235 ++ch; 236 } 237 } 238 239 if (*ch != '\0') 240 { 241 sim_io_eprintf (sd, "Invalid argument for --profile-cpu-frequency: %s\n", 242 arg); 243 *freq = 0; 244 return SIM_RC_FAIL; 245 } 246 247 return SIM_RC_OK; 248 } 249 250 static SIM_RC 251 profile_option_handler (SIM_DESC sd, 252 sim_cpu *cpu, 253 int opt, 254 char *arg, 255 int is_command) 256 { 257 int cpu_nr; 258 259 /* FIXME: Need to handle `cpu' arg. */ 260 261 switch (opt) 262 { 263 case 'p' : 264 if (! WITH_PROFILE) 265 sim_io_eprintf (sd, "Profiling not compiled in, `-p' ignored\n"); 266 else 267 return set_profile_option_mask (sd, "profile", PROFILE_USEFUL_MASK, 268 arg); 269 break; 270 271 case OPTION_PROFILE_INSN : 272 if (WITH_PROFILE_INSN_P) 273 return sim_profile_set_option (sd, "-insn", PROFILE_INSN_IDX, arg); 274 else 275 sim_io_eprintf (sd, "Instruction profiling not compiled in, `--profile-insn' ignored\n"); 276 break; 277 278 case OPTION_PROFILE_MEMORY : 279 if (WITH_PROFILE_MEMORY_P) 280 return sim_profile_set_option (sd, "-memory", PROFILE_MEMORY_IDX, arg); 281 else 282 sim_io_eprintf (sd, "Memory profiling not compiled in, `--profile-memory' ignored\n"); 283 break; 284 285 case OPTION_PROFILE_CORE : 286 if (WITH_PROFILE_CORE_P) 287 return sim_profile_set_option (sd, "-core", PROFILE_CORE_IDX, arg); 288 else 289 sim_io_eprintf (sd, "CORE profiling not compiled in, `--profile-core' ignored\n"); 290 break; 291 292 case OPTION_PROFILE_MODEL : 293 if (WITH_PROFILE_MODEL_P) 294 return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, arg); 295 else 296 sim_io_eprintf (sd, "Model profiling not compiled in, `--profile-model' ignored\n"); 297 break; 298 299 case OPTION_PROFILE_CPU_FREQUENCY : 300 { 301 unsigned long val; 302 SIM_RC rc = parse_frequency (sd, arg, &val); 303 if (rc == SIM_RC_OK) 304 { 305 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 306 PROFILE_CPU_FREQ (CPU_PROFILE_DATA (STATE_CPU (sd,cpu_nr))) = val; 307 } 308 return rc; 309 } 310 311 case OPTION_PROFILE_FILE : 312 /* FIXME: Might want this to apply to pc profiling only, 313 or have two profile file options. */ 314 if (! WITH_PROFILE) 315 sim_io_eprintf (sd, "Profiling not compiled in, `--profile-file' ignored\n"); 316 else 317 { 318 FILE *f = fopen (arg, "w"); 319 320 if (f == NULL) 321 { 322 sim_io_eprintf (sd, "Unable to open profile output file `%s'\n", arg); 323 return SIM_RC_FAIL; 324 } 325 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 326 PROFILE_FILE (CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))) = f; 327 } 328 break; 329 330 case OPTION_PROFILE_PC: 331 if (WITH_PROFILE_PC_P) 332 return sim_profile_set_option (sd, "-pc", PROFILE_PC_IDX, arg); 333 else 334 sim_io_eprintf (sd, "PC profiling not compiled in, `--profile-pc' ignored\n"); 335 break; 336 337 case 'F' : 338 if (WITH_PROFILE_PC_P) 339 { 340 /* FIXME: Validate arg. */ 341 int val = atoi (arg); 342 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 343 PROFILE_PC_FREQ (CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))) = val; 344 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 345 CPU_PROFILE_FLAGS (STATE_CPU (sd, cpu_nr))[PROFILE_PC_IDX] = 1; 346 } 347 else 348 sim_io_eprintf (sd, "PC profiling not compiled in, `--profile-pc-frequency' ignored\n"); 349 break; 350 351 case 'S' : 352 if (WITH_PROFILE_PC_P) 353 { 354 /* FIXME: Validate arg. */ 355 int val = atoi (arg); 356 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 357 PROFILE_PC_NR_BUCKETS (CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))) = val; 358 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 359 CPU_PROFILE_FLAGS (STATE_CPU (sd, cpu_nr))[PROFILE_PC_IDX] = 1; 360 } 361 else 362 sim_io_eprintf (sd, "PC profiling not compiled in, `--profile-pc-size' ignored\n"); 363 break; 364 365 case OPTION_PROFILE_PC_GRANULARITY: 366 if (WITH_PROFILE_PC_P) 367 { 368 int shift; 369 int val = atoi (arg); 370 /* check that the granularity is a power of two */ 371 shift = 0; 372 while (val > (1 << shift)) 373 { 374 shift += 1; 375 } 376 if (val != (1 << shift)) 377 { 378 sim_io_eprintf (sd, "PC profiling granularity not a power of two\n"); 379 return SIM_RC_FAIL; 380 } 381 if (shift == 0) 382 { 383 sim_io_eprintf (sd, "PC profiling granularity too small"); 384 return SIM_RC_FAIL; 385 } 386 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 387 PROFILE_PC_SHIFT (CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))) = shift; 388 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 389 CPU_PROFILE_FLAGS (STATE_CPU (sd, cpu_nr))[PROFILE_PC_IDX] = 1; 390 } 391 else 392 sim_io_eprintf (sd, "PC profiling not compiled in, `--profile-pc-granularity' ignored\n"); 393 break; 394 395 case OPTION_PROFILE_PC_RANGE: 396 if (WITH_PROFILE_PC_P) 397 { 398 /* FIXME: Validate args */ 399 char *chp = arg; 400 unsigned long base; 401 unsigned long bound; 402 base = strtoul (chp, &chp, 0); 403 if (*chp != ',') 404 { 405 sim_io_eprintf (sd, "--profile-pc-range missing BOUND argument\n"); 406 return SIM_RC_FAIL; 407 } 408 bound = strtoul (chp + 1, NULL, 0); 409 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 410 { 411 PROFILE_PC_START (CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))) = base; 412 PROFILE_PC_END (CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))) = bound; 413 } 414 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 415 CPU_PROFILE_FLAGS (STATE_CPU (sd, cpu_nr))[PROFILE_PC_IDX] = 1; 416 } 417 else 418 sim_io_eprintf (sd, "PC profiling not compiled in, `--profile-pc-range' ignored\n"); 419 break; 420 421 #ifdef SIM_HAVE_ADDR_RANGE 422 case OPTION_PROFILE_RANGE : 423 if (WITH_PROFILE) 424 { 425 char *chp = arg; 426 unsigned long start,end; 427 start = strtoul (chp, &chp, 0); 428 if (*chp != ',') 429 { 430 sim_io_eprintf (sd, "--profile-range missing END argument\n"); 431 return SIM_RC_FAIL; 432 } 433 end = strtoul (chp + 1, NULL, 0); 434 /* FIXME: Argument validation. */ 435 if (cpu != NULL) 436 sim_addr_range_add (PROFILE_RANGE (CPU_PROFILE_DATA (cpu)), 437 start, end); 438 else 439 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 440 sim_addr_range_add (PROFILE_RANGE (CPU_PROFILE_DATA (STATE_CPU (sd, cpu_nr))), 441 start, end); 442 } 443 else 444 sim_io_eprintf (sd, "Profiling not compiled in, `--profile-range' ignored\n"); 445 break; 446 447 case OPTION_PROFILE_FUNCTION : 448 if (WITH_PROFILE) 449 { 450 /*wip: need to compute function range given name*/ 451 } 452 else 453 sim_io_eprintf (sd, "Profiling not compiled in, `--profile-function' ignored\n"); 454 break; 455 #endif /* SIM_HAVE_ADDR_RANGE */ 456 } 457 458 return SIM_RC_OK; 459 } 460 461 /* Profiling output hooks. */ 462 463 static void ATTRIBUTE_PRINTF (3, 0) 464 profile_vprintf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, va_list ap) 465 { 466 FILE *fp = PROFILE_FILE (CPU_PROFILE_DATA (cpu)); 467 468 /* If an output file was given, redirect output to that. */ 469 if (fp != NULL) 470 vfprintf (fp, fmt, ap); 471 else 472 sim_io_evprintf (sd, fmt, ap); 473 } 474 475 ATTRIBUTE_PRINTF (3, 4) 476 static void 477 profile_printf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, ...) 478 { 479 va_list ap; 480 481 va_start (ap, fmt); 482 profile_vprintf (sd, cpu, fmt, ap); 483 va_end (ap); 484 } 485 486 /* PC profiling support */ 487 488 #if WITH_PROFILE_PC_P 489 490 static void 491 profile_pc_cleanup (SIM_DESC sd) 492 { 493 int n; 494 for (n = 0; n < MAX_NR_PROCESSORS; n++) 495 { 496 sim_cpu *cpu = STATE_CPU (sd, n); 497 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 498 if (PROFILE_PC_COUNT (data) != NULL) 499 free (PROFILE_PC_COUNT (data)); 500 PROFILE_PC_COUNT (data) = NULL; 501 if (PROFILE_PC_EVENT (data) != NULL) 502 sim_events_deschedule (sd, PROFILE_PC_EVENT (data)); 503 PROFILE_PC_EVENT (data) = NULL; 504 } 505 } 506 507 508 static void 509 profile_pc_uninstall (SIM_DESC sd) 510 { 511 profile_pc_cleanup (sd); 512 } 513 514 static void 515 profile_pc_event (SIM_DESC sd, 516 void *data) 517 { 518 sim_cpu *cpu = (sim_cpu*) data; 519 PROFILE_DATA *profile = CPU_PROFILE_DATA (cpu); 520 address_word pc = sim_pc_get (cpu); 521 unsigned i; 522 i = (pc - PROFILE_PC_START (profile)) >> PROFILE_PC_SHIFT (profile); 523 if (i < PROFILE_PC_NR_BUCKETS (profile)) 524 PROFILE_PC_COUNT (profile) [i] += 1; /* Overflow? */ 525 else 526 PROFILE_PC_COUNT (profile) [PROFILE_PC_NR_BUCKETS (profile)] += 1; 527 PROFILE_PC_EVENT (profile) = 528 sim_events_schedule (sd, PROFILE_PC_FREQ (profile), profile_pc_event, cpu); 529 } 530 531 static SIM_RC 532 profile_pc_init (SIM_DESC sd) 533 { 534 int n; 535 profile_pc_cleanup (sd); 536 for (n = 0; n < MAX_NR_PROCESSORS; n++) 537 { 538 sim_cpu *cpu = STATE_CPU (sd, n); 539 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 540 if (CPU_PROFILE_FLAGS (STATE_CPU (sd, n))[PROFILE_PC_IDX]) 541 { 542 int bucket_size; 543 /* fill in the frequency if not specified */ 544 if (PROFILE_PC_FREQ (data) == 0) 545 PROFILE_PC_FREQ (data) = 257; 546 /* fill in the start/end if not specified */ 547 if (PROFILE_PC_END (data) == 0) 548 { 549 PROFILE_PC_START (data) = STATE_TEXT_START (sd); 550 PROFILE_PC_END (data) = STATE_TEXT_END (sd); 551 } 552 /* Compute the number of buckets if not specified. */ 553 if (PROFILE_PC_NR_BUCKETS (data) == 0) 554 { 555 if (PROFILE_PC_BUCKET_SIZE (data) == 0) 556 PROFILE_PC_NR_BUCKETS (data) = 16; 557 else 558 { 559 if (PROFILE_PC_END (data) == 0) 560 { 561 /* nr_buckets = (full-address-range / 2) / (bucket_size / 2) */ 562 PROFILE_PC_NR_BUCKETS (data) = 563 ((1ULL << sizeof (sim_cia) * (8 - 1)) 564 / (PROFILE_PC_BUCKET_SIZE (data) / 2)); 565 } 566 else 567 { 568 PROFILE_PC_NR_BUCKETS (data) = 569 ((PROFILE_PC_END (data) 570 - PROFILE_PC_START (data) 571 + PROFILE_PC_BUCKET_SIZE (data) - 1) 572 / PROFILE_PC_BUCKET_SIZE (data)); 573 } 574 } 575 } 576 /* Compute the bucket size if not specified. Ensure that it 577 is rounded up to the next power of two */ 578 if (PROFILE_PC_BUCKET_SIZE (data) == 0) 579 { 580 if (PROFILE_PC_END (data) == 0) 581 /* bucket_size = (full-address-range / 2) / (nr_buckets / 2) */ 582 bucket_size = ((1ULL << ((sizeof (sim_cia) * 8) - 1)) 583 / (PROFILE_PC_NR_BUCKETS (data) / 2)); 584 else 585 bucket_size = ((PROFILE_PC_END (data) 586 - PROFILE_PC_START (data) 587 + PROFILE_PC_NR_BUCKETS (data) - 1) 588 / PROFILE_PC_NR_BUCKETS (data)); 589 PROFILE_PC_SHIFT (data) = 0; 590 while (bucket_size > PROFILE_PC_BUCKET_SIZE (data)) 591 { 592 PROFILE_PC_SHIFT (data) += 1; 593 } 594 } 595 /* Align the end address with bucket size */ 596 if (PROFILE_PC_END (data) != 0) 597 PROFILE_PC_END (data) = (PROFILE_PC_START (data) 598 + (PROFILE_PC_BUCKET_SIZE (data) 599 * PROFILE_PC_NR_BUCKETS (data))); 600 /* create the relevant buffers */ 601 PROFILE_PC_COUNT (data) = 602 NZALLOC (unsigned, PROFILE_PC_NR_BUCKETS (data) + 1); 603 PROFILE_PC_EVENT (data) = 604 sim_events_schedule (sd, 605 PROFILE_PC_FREQ (data), 606 profile_pc_event, 607 cpu); 608 } 609 } 610 return SIM_RC_OK; 611 } 612 613 static void 614 profile_print_pc (sim_cpu *cpu, bool verbose) 615 { 616 SIM_DESC sd = CPU_STATE (cpu); 617 PROFILE_DATA *profile = CPU_PROFILE_DATA (cpu); 618 char comma_buf[20]; 619 unsigned max_val; 620 unsigned total; 621 unsigned i; 622 623 if (PROFILE_PC_COUNT (profile) == 0) 624 return; 625 626 profile_printf (sd, cpu, "Program Counter Statistics:\n\n"); 627 628 /* First pass over data computes various things. */ 629 max_val = 0; 630 total = 0; 631 for (i = 0; i <= PROFILE_PC_NR_BUCKETS (profile); ++i) 632 { 633 total += PROFILE_PC_COUNT (profile) [i]; 634 if (PROFILE_PC_COUNT (profile) [i] > max_val) 635 max_val = PROFILE_PC_COUNT (profile) [i]; 636 } 637 638 profile_printf (sd, cpu, " Total samples: %s\n", 639 COMMAS (total)); 640 profile_printf (sd, cpu, " Granularity: %s bytes per bucket\n", 641 COMMAS (PROFILE_PC_BUCKET_SIZE (profile))); 642 profile_printf (sd, cpu, " Size: %s buckets\n", 643 COMMAS (PROFILE_PC_NR_BUCKETS (profile))); 644 profile_printf (sd, cpu, " Frequency: %s cycles per sample\n", 645 COMMAS (PROFILE_PC_FREQ (profile))); 646 647 if (PROFILE_PC_END (profile) != 0) 648 profile_printf (sd, cpu, " Range: 0x%lx 0x%lx\n", 649 (long) PROFILE_PC_START (profile), 650 (long) PROFILE_PC_END (profile)); 651 652 if (verbose && max_val != 0) 653 { 654 /* Now we can print the histogram. */ 655 profile_printf (sd, cpu, "\n"); 656 for (i = 0; i <= PROFILE_PC_NR_BUCKETS (profile); ++i) 657 { 658 if (PROFILE_PC_COUNT (profile) [i] != 0) 659 { 660 profile_printf (sd, cpu, " "); 661 if (i == PROFILE_PC_NR_BUCKETS (profile)) 662 profile_printf (sd, cpu, "%10s:", "overflow"); 663 else 664 profile_printf (sd, cpu, "0x%08lx:", 665 (long) (PROFILE_PC_START (profile) 666 + (i * PROFILE_PC_BUCKET_SIZE (profile)))); 667 profile_printf (sd, cpu, " %*s", 668 max_val < 10000 ? 5 : 10, 669 COMMAS (PROFILE_PC_COUNT (profile) [i])); 670 profile_printf (sd, cpu, " %4.1f", 671 (PROFILE_PC_COUNT (profile) [i] * 100.0) / total); 672 profile_printf (sd, cpu, ": "); 673 sim_profile_print_bar (sd, cpu, PROFILE_HISTOGRAM_WIDTH, 674 PROFILE_PC_COUNT (profile) [i], 675 max_val); 676 profile_printf (sd, cpu, "\n"); 677 } 678 } 679 } 680 681 /* dump the histogram to the file "gmon.out" using BSD's gprof file 682 format */ 683 /* Since a profile data file is in the native format of the host on 684 which the profile is being, endian issues are not considered in 685 the code below. */ 686 /* FIXME: Is this the best place for this code? */ 687 { 688 FILE *pf = fopen ("gmon.out", "wb"); 689 690 if (pf == NULL) 691 sim_io_eprintf (sd, "Failed to open \"gmon.out\" profile file\n"); 692 else 693 { 694 int ok; 695 /* FIXME: what if the target has a 64 bit PC? */ 696 uint32_t header[3]; 697 unsigned loop; 698 if (PROFILE_PC_END (profile) != 0) 699 { 700 header[0] = PROFILE_PC_START (profile); 701 header[1] = PROFILE_PC_END (profile); 702 } 703 else 704 { 705 header[0] = 0; 706 header[1] = 0; 707 } 708 /* size of sample buffer (+ header) */ 709 header[2] = PROFILE_PC_NR_BUCKETS (profile) * 2 + sizeof (header); 710 711 /* Header must be written out in target byte order. */ 712 H2T (header[0]); 713 H2T (header[1]); 714 H2T (header[2]); 715 716 ok = fwrite (&header, sizeof (header), 1, pf); 717 for (loop = 0; 718 ok && (loop < PROFILE_PC_NR_BUCKETS (profile)); 719 loop++) 720 { 721 int16_t sample; 722 if (PROFILE_PC_COUNT (profile) [loop] >= 0xffff) 723 sample = 0xffff; 724 else 725 sample = PROFILE_PC_COUNT (profile) [loop]; 726 H2T (sample); 727 ok = fwrite (&sample, sizeof (sample), 1, pf); 728 } 729 if (ok == 0) 730 sim_io_eprintf (sd, "Failed to write to \"gmon.out\" profile file\n"); 731 fclose (pf); 732 } 733 } 734 735 profile_printf (sd, cpu, "\n"); 736 } 737 738 #endif 739 740 /* Summary printing support. */ 741 742 #if WITH_PROFILE_INSN_P 743 744 static SIM_RC 745 profile_insn_init (SIM_DESC sd) 746 { 747 int c; 748 749 for (c = 0; c < MAX_NR_PROCESSORS; ++c) 750 { 751 sim_cpu *cpu = STATE_CPU (sd, c); 752 753 if (CPU_MAX_INSNS (cpu) > 0) 754 PROFILE_INSN_COUNT (CPU_PROFILE_DATA (cpu)) = NZALLOC (unsigned int, CPU_MAX_INSNS (cpu)); 755 } 756 757 return SIM_RC_OK; 758 } 759 760 static void 761 profile_print_insn (sim_cpu *cpu, bool verbose) 762 { 763 unsigned int i, n, total, max_val, max_name_len; 764 SIM_DESC sd = CPU_STATE (cpu); 765 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 766 char comma_buf[20]; 767 768 /* If MAX_INSNS not set, insn profiling isn't supported. */ 769 if (CPU_MAX_INSNS (cpu) == 0) 770 return; 771 772 profile_printf (sd, cpu, "Instruction Statistics"); 773 #ifdef SIM_HAVE_ADDR_RANGE 774 if (PROFILE_RANGE (data)->ranges) 775 profile_printf (sd, cpu, " (for selected address range(s))"); 776 #endif 777 profile_printf (sd, cpu, "\n\n"); 778 779 /* First pass over data computes various things. */ 780 max_val = 0; 781 total = 0; 782 max_name_len = 0; 783 for (i = 0; i < CPU_MAX_INSNS (cpu); ++i) 784 { 785 const char *name = (*CPU_INSN_NAME (cpu)) (cpu, i); 786 787 if (name == NULL) 788 continue; 789 total += PROFILE_INSN_COUNT (data) [i]; 790 if (PROFILE_INSN_COUNT (data) [i] > max_val) 791 max_val = PROFILE_INSN_COUNT (data) [i]; 792 n = strlen (name); 793 if (n > max_name_len) 794 max_name_len = n; 795 } 796 /* set the total insn count, in case client is being lazy */ 797 if (! PROFILE_TOTAL_INSN_COUNT (data)) 798 PROFILE_TOTAL_INSN_COUNT (data) = total; 799 800 profile_printf (sd, cpu, " Total: %s insns\n", COMMAS (total)); 801 802 if (verbose && max_val != 0) 803 { 804 /* Now we can print the histogram. */ 805 profile_printf (sd, cpu, "\n"); 806 for (i = 0; i < CPU_MAX_INSNS (cpu); ++i) 807 { 808 const char *name = (*CPU_INSN_NAME (cpu)) (cpu, i); 809 810 if (name == NULL) 811 continue; 812 if (PROFILE_INSN_COUNT (data) [i] != 0) 813 { 814 profile_printf (sd, cpu, " %*s: %*s: ", 815 max_name_len, name, 816 max_val < 10000 ? 5 : 10, 817 COMMAS (PROFILE_INSN_COUNT (data) [i])); 818 sim_profile_print_bar (sd, cpu, PROFILE_HISTOGRAM_WIDTH, 819 PROFILE_INSN_COUNT (data) [i], 820 max_val); 821 profile_printf (sd, cpu, "\n"); 822 } 823 } 824 } 825 826 profile_printf (sd, cpu, "\n"); 827 } 828 829 #endif 830 831 #if WITH_PROFILE_MEMORY_P 832 833 static void 834 profile_print_memory (sim_cpu *cpu, bool verbose) 835 { 836 unsigned int i, n; 837 unsigned int total_read, total_write; 838 unsigned int max_val, max_name_len; 839 /* FIXME: Need to add smp support. */ 840 SIM_DESC sd = CPU_STATE (cpu); 841 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 842 char comma_buf[20]; 843 844 profile_printf (sd, cpu, "Memory Access Statistics\n\n"); 845 846 /* First pass over data computes various things. */ 847 max_val = total_read = total_write = max_name_len = 0; 848 for (i = 0; i < MODE_TARGET_MAX; ++i) 849 { 850 total_read += PROFILE_READ_COUNT (data) [i]; 851 total_write += PROFILE_WRITE_COUNT (data) [i]; 852 if (PROFILE_READ_COUNT (data) [i] > max_val) 853 max_val = PROFILE_READ_COUNT (data) [i]; 854 if (PROFILE_WRITE_COUNT (data) [i] > max_val) 855 max_val = PROFILE_WRITE_COUNT (data) [i]; 856 n = strlen (MODE_NAME (i)); 857 if (n > max_name_len) 858 max_name_len = n; 859 } 860 861 /* One could use PROFILE_LABEL_WIDTH here. I chose not to. */ 862 profile_printf (sd, cpu, " Total read: %s accesses\n", 863 COMMAS (total_read)); 864 profile_printf (sd, cpu, " Total write: %s accesses\n", 865 COMMAS (total_write)); 866 867 if (verbose && max_val != 0) 868 { 869 /* FIXME: Need to separate instruction fetches from data fetches 870 as the former swamps the latter. */ 871 /* Now we can print the histogram. */ 872 profile_printf (sd, cpu, "\n"); 873 for (i = 0; i < MODE_TARGET_MAX; ++i) 874 { 875 if (PROFILE_READ_COUNT (data) [i] != 0) 876 { 877 profile_printf (sd, cpu, " %*s read: %*s: ", 878 max_name_len, MODE_NAME (i), 879 max_val < 10000 ? 5 : 10, 880 COMMAS (PROFILE_READ_COUNT (data) [i])); 881 sim_profile_print_bar (sd, cpu, PROFILE_HISTOGRAM_WIDTH, 882 PROFILE_READ_COUNT (data) [i], 883 max_val); 884 profile_printf (sd, cpu, "\n"); 885 } 886 if (PROFILE_WRITE_COUNT (data) [i] != 0) 887 { 888 profile_printf (sd, cpu, " %*s write: %*s: ", 889 max_name_len, MODE_NAME (i), 890 max_val < 10000 ? 5 : 10, 891 COMMAS (PROFILE_WRITE_COUNT (data) [i])); 892 sim_profile_print_bar (sd, cpu, PROFILE_HISTOGRAM_WIDTH, 893 PROFILE_WRITE_COUNT (data) [i], 894 max_val); 895 profile_printf (sd, cpu, "\n"); 896 } 897 } 898 } 899 900 profile_printf (sd, cpu, "\n"); 901 } 902 903 #endif 904 905 #if WITH_PROFILE_CORE_P 906 907 static void 908 profile_print_core (sim_cpu *cpu, bool verbose) 909 { 910 unsigned int total; 911 unsigned int max_val; 912 /* FIXME: Need to add smp support. */ 913 SIM_DESC sd = CPU_STATE (cpu); 914 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 915 char comma_buf[20]; 916 917 profile_printf (sd, cpu, "CORE Statistics\n\n"); 918 919 /* First pass over data computes various things. */ 920 { 921 unsigned map; 922 total = 0; 923 max_val = 0; 924 for (map = 0; map < nr_maps; map++) 925 { 926 total += PROFILE_CORE_COUNT (data) [map]; 927 if (PROFILE_CORE_COUNT (data) [map] > max_val) 928 max_val = PROFILE_CORE_COUNT (data) [map]; 929 } 930 } 931 932 /* One could use PROFILE_LABEL_WIDTH here. I chose not to. */ 933 profile_printf (sd, cpu, " Total: %s accesses\n", 934 COMMAS (total)); 935 936 if (verbose && max_val != 0) 937 { 938 unsigned map; 939 /* Now we can print the histogram. */ 940 profile_printf (sd, cpu, "\n"); 941 for (map = 0; map < nr_maps; map++) 942 { 943 if (PROFILE_CORE_COUNT (data) [map] != 0) 944 { 945 profile_printf (sd, cpu, "%10s:", map_to_str (map)); 946 profile_printf (sd, cpu, "%*s: ", 947 max_val < 10000 ? 5 : 10, 948 COMMAS (PROFILE_CORE_COUNT (data) [map])); 949 sim_profile_print_bar (sd, cpu, PROFILE_HISTOGRAM_WIDTH, 950 PROFILE_CORE_COUNT (data) [map], 951 max_val); 952 profile_printf (sd, cpu, "\n"); 953 } 954 } 955 } 956 957 profile_printf (sd, cpu, "\n"); 958 } 959 960 #endif 961 962 #if WITH_PROFILE_MODEL_P 963 964 static void 965 profile_print_model (sim_cpu *cpu, bool verbose) 966 { 967 SIM_DESC sd = CPU_STATE (cpu); 968 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 969 unsigned long cti_stall_cycles = PROFILE_MODEL_CTI_STALL_CYCLES (data); 970 unsigned long load_stall_cycles = PROFILE_MODEL_LOAD_STALL_CYCLES (data); 971 unsigned long total_cycles = PROFILE_MODEL_TOTAL_CYCLES (data); 972 char comma_buf[20]; 973 974 profile_printf (sd, cpu, "Model %s Timing Information", 975 MODEL_NAME (CPU_MODEL (cpu))); 976 #ifdef SIM_HAVE_ADDR_RANGE 977 if (PROFILE_RANGE (data)->ranges) 978 profile_printf (sd, cpu, " (for selected address range(s))"); 979 #endif 980 profile_printf (sd, cpu, "\n\n"); 981 profile_printf (sd, cpu, " %-*s %s\n", 982 PROFILE_LABEL_WIDTH, "Taken branches:", 983 COMMAS (PROFILE_MODEL_TAKEN_COUNT (data))); 984 profile_printf (sd, cpu, " %-*s %s\n", 985 PROFILE_LABEL_WIDTH, "Untaken branches:", 986 COMMAS (PROFILE_MODEL_UNTAKEN_COUNT (data))); 987 profile_printf (sd, cpu, " %-*s %s\n", 988 PROFILE_LABEL_WIDTH, "Cycles stalled due to branches:", 989 COMMAS (cti_stall_cycles)); 990 profile_printf (sd, cpu, " %-*s %s\n", 991 PROFILE_LABEL_WIDTH, "Cycles stalled due to loads:", 992 COMMAS (load_stall_cycles)); 993 profile_printf (sd, cpu, " %-*s %s\n", 994 PROFILE_LABEL_WIDTH, "Total cycles (*approximate*):", 995 COMMAS (total_cycles)); 996 profile_printf (sd, cpu, "\n"); 997 } 998 999 #endif 1000 1001 void 1002 sim_profile_print_bar (SIM_DESC sd, sim_cpu *cpu, unsigned int width, 1003 unsigned int val, unsigned int max_val) 1004 { 1005 unsigned int i, count; 1006 1007 count = ((double) val / (double) max_val) * (double) width; 1008 1009 for (i = 0; i < count; ++i) 1010 profile_printf (sd, cpu, "*"); 1011 } 1012 1013 /* Print the simulator's execution speed for CPU. */ 1014 1015 static void 1016 profile_print_speed (sim_cpu *cpu) 1017 { 1018 SIM_DESC sd = CPU_STATE (cpu); 1019 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 1020 unsigned long milliseconds = sim_events_elapsed_time (sd); 1021 unsigned long total = PROFILE_TOTAL_INSN_COUNT (data); 1022 double clock; 1023 double secs; 1024 char comma_buf[20]; 1025 1026 profile_printf (sd, cpu, "Simulator Execution Speed\n\n"); 1027 1028 if (total != 0) 1029 profile_printf (sd, cpu, " Total instructions: %s\n", COMMAS (total)); 1030 1031 if (milliseconds < 1000) 1032 profile_printf (sd, cpu, " Total execution time: < 1 second\n\n"); 1033 else 1034 { 1035 /* The printing of the time rounded to 2 decimal places makes the speed 1036 calculation seem incorrect [even though it is correct]. So round 1037 MILLISECONDS first. This can marginally affect the result, but it's 1038 better that the user not perceive there's a math error. */ 1039 secs = (double) milliseconds / 1000; 1040 secs = ((double) (unsigned long) (secs * 100 + .5)) / 100; 1041 profile_printf (sd, cpu, " Total execution time : %.2f seconds\n", secs); 1042 /* Don't confuse things with data that isn't useful. 1043 If we ran for less than 2 seconds, only use the data if we 1044 executed more than 100,000 insns. */ 1045 if (secs >= 2 || total >= 100000) 1046 profile_printf (sd, cpu, " Simulator speed: %s insns/second\n", 1047 COMMAS ((unsigned long) ((double) total / secs))); 1048 } 1049 1050 /* Print simulated execution time if the cpu frequency has been specified. */ 1051 clock = PROFILE_CPU_FREQ (data); 1052 if (clock != 0) 1053 { 1054 if (clock >= 1000000) 1055 profile_printf (sd, cpu, " Simulated cpu frequency: %.2f MHz\n", 1056 clock / 1000000); 1057 else 1058 profile_printf (sd, cpu, " Simulated cpu frequency: %.2f Hz\n", clock); 1059 1060 #if WITH_PROFILE_MODEL_P 1061 if (PROFILE_FLAGS (data) [PROFILE_MODEL_IDX]) 1062 { 1063 /* The printing of the time rounded to 2 decimal places makes the 1064 speed calculation seem incorrect [even though it is correct]. 1065 So round SECS first. This can marginally affect the result, 1066 but it's better that the user not perceive there's a math 1067 error. */ 1068 secs = PROFILE_MODEL_TOTAL_CYCLES (data) / clock; 1069 secs = ((double) (unsigned long) (secs * 100 + .5)) / 100; 1070 profile_printf (sd, cpu, " Simulated execution time: %.2f seconds\n", 1071 secs); 1072 } 1073 #endif /* WITH_PROFILE_MODEL_P */ 1074 } 1075 } 1076 1077 #ifdef SIM_HAVE_ADDR_RANGE 1078 /* Print selected address ranges. */ 1079 1080 static void 1081 profile_print_addr_ranges (sim_cpu *cpu) 1082 { 1083 ADDR_SUBRANGE *asr = PROFILE_RANGE (CPU_PROFILE_DATA (cpu))->ranges; 1084 SIM_DESC sd = CPU_STATE (cpu); 1085 1086 if (asr) 1087 { 1088 profile_printf (sd, cpu, "Selected address ranges\n\n"); 1089 while (asr != NULL) 1090 { 1091 profile_printf (sd, cpu, " 0x%lx - 0x%lx\n", 1092 (long) asr->start, (long) asr->end); 1093 asr = asr->next; 1094 } 1095 profile_printf (sd, cpu, "\n"); 1096 } 1097 } 1098 #endif 1099 1100 /* Top level function to print all summary profile information. 1101 It is [currently] intended that all such data is printed by this function. 1102 I'd rather keep it all in one place for now. To that end, MISC_CPU and 1103 MISC are callbacks used to print any miscellaneous data. 1104 1105 One might want to add a user option that allows printing by type or by cpu 1106 (i.e. print all insn data for each cpu first, or print data cpu by cpu). 1107 This may be a case of featuritis so it's currently left out. 1108 1109 Note that results are indented two spaces to distinguish them from 1110 section titles. */ 1111 1112 static void 1113 profile_info (SIM_DESC sd, bool verbose) 1114 { 1115 int i,c; 1116 int print_title_p = 0; 1117 1118 /* Only print the title if some data has been collected. */ 1119 /* ??? Why don't we just exit if no data collected? */ 1120 /* FIXME: If the number of processors can be selected on the command line, 1121 then MAX_NR_PROCESSORS will need to take an argument of `sd'. */ 1122 1123 for (c = 0; c < MAX_NR_PROCESSORS && !print_title_p; ++c) 1124 { 1125 sim_cpu *cpu = STATE_CPU (sd, c); 1126 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 1127 1128 for (i = 0; i < MAX_PROFILE_VALUES; ++i) 1129 if (PROFILE_FLAGS (data) [i]) 1130 { 1131 profile_printf (sd, cpu, "Summary profiling results:\n\n"); 1132 print_title_p = 1; 1133 break; 1134 } 1135 } 1136 1137 /* Loop, cpu by cpu, printing results. */ 1138 1139 for (c = 0; c < MAX_NR_PROCESSORS; ++c) 1140 { 1141 sim_cpu *cpu = STATE_CPU (sd, c); 1142 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 1143 1144 if (MAX_NR_PROCESSORS > 1 1145 && (0 1146 #if WITH_PROFILE_INSN_P 1147 || PROFILE_FLAGS (data) [PROFILE_INSN_IDX] 1148 #endif 1149 #if WITH_PROFILE_MEMORY_P 1150 || PROFILE_FLAGS (data) [PROFILE_MEMORY_IDX] 1151 #endif 1152 #if WITH_PROFILE_CORE_P 1153 || PROFILE_FLAGS (data) [PROFILE_CORE_IDX] 1154 #endif 1155 #if WITH_PROFILE_MODEL_P 1156 || PROFILE_FLAGS (data) [PROFILE_MODEL_IDX] 1157 #endif 1158 #if WITH_PROFILE_SCACHE_P && WITH_SCACHE && defined(CGEN_ARCH) 1159 || PROFILE_FLAGS (data) [PROFILE_SCACHE_IDX] 1160 #endif 1161 #if WITH_PROFILE_PC_P 1162 || PROFILE_FLAGS (data) [PROFILE_PC_IDX] 1163 #endif 1164 )) 1165 { 1166 profile_printf (sd, cpu, "CPU %d\n\n", c); 1167 } 1168 1169 #ifdef SIM_HAVE_ADDR_RANGE 1170 if (print_title_p 1171 && (PROFILE_INSN_P (cpu) 1172 || PROFILE_MODEL_P (cpu))) 1173 profile_print_addr_ranges (cpu); 1174 #endif 1175 1176 #if WITH_PROFILE_INSN_P 1177 if (PROFILE_FLAGS (data) [PROFILE_INSN_IDX]) 1178 profile_print_insn (cpu, verbose); 1179 #endif 1180 1181 #if WITH_PROFILE_MEMORY_P 1182 if (PROFILE_FLAGS (data) [PROFILE_MEMORY_IDX]) 1183 profile_print_memory (cpu, verbose); 1184 #endif 1185 1186 #if WITH_PROFILE_CORE_P 1187 if (PROFILE_FLAGS (data) [PROFILE_CORE_IDX]) 1188 profile_print_core (cpu, verbose); 1189 #endif 1190 1191 #if WITH_PROFILE_MODEL_P 1192 if (PROFILE_FLAGS (data) [PROFILE_MODEL_IDX]) 1193 profile_print_model (cpu, verbose); 1194 #endif 1195 1196 #if WITH_PROFILE_SCACHE_P && WITH_SCACHE && defined(CGEN_ARCH) 1197 if (PROFILE_FLAGS (data) [PROFILE_SCACHE_IDX]) 1198 scache_print_profile (cpu, verbose); 1199 #endif 1200 1201 #if WITH_PROFILE_PC_P 1202 if (PROFILE_FLAGS (data) [PROFILE_PC_IDX]) 1203 profile_print_pc (cpu, verbose); 1204 #endif 1205 1206 /* Print cpu-specific data before the execution speed. */ 1207 if (PROFILE_INFO_CPU_CALLBACK (data) != NULL) 1208 PROFILE_INFO_CPU_CALLBACK (data) (cpu, verbose); 1209 1210 /* Always try to print execution time and speed. */ 1211 if (verbose 1212 || PROFILE_FLAGS (data) [PROFILE_INSN_IDX]) 1213 profile_print_speed (cpu); 1214 } 1215 1216 /* Finally print non-cpu specific miscellaneous data. */ 1217 if (STATE_PROFILE_INFO_CALLBACK (sd)) 1218 STATE_PROFILE_INFO_CALLBACK (sd) (sd, verbose); 1219 1220 } 1221 1222 /* Provide a prototype to silence -Wmissing-prototypes. */ 1223 SIM_RC sim_install_profile (SIM_DESC sd); 1224 1225 /* Install profiling support in the simulator. */ 1226 SIM_RC 1227 sim_install_profile (SIM_DESC sd) 1228 { 1229 int i; 1230 1231 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 1232 sim_add_option_table (sd, NULL, profile_options); 1233 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 1234 memset (CPU_PROFILE_DATA (STATE_CPU (sd, i)), 0, 1235 sizeof (* CPU_PROFILE_DATA (STATE_CPU (sd, i)))); 1236 #if WITH_PROFILE_INSN_P 1237 sim_module_add_init_fn (sd, profile_insn_init); 1238 #endif 1239 #if WITH_PROFILE_PC_P 1240 sim_module_add_uninstall_fn (sd, profile_pc_uninstall); 1241 sim_module_add_init_fn (sd, profile_pc_init); 1242 #endif 1243 sim_module_add_init_fn (sd, profile_init); 1244 sim_module_add_uninstall_fn (sd, profile_uninstall); 1245 sim_module_add_info_fn (sd, profile_info); 1246 return SIM_RC_OK; 1247 } 1248 1249 static SIM_RC 1250 profile_init (SIM_DESC sd) 1251 { 1252 #ifdef SIM_HAVE_ADDR_RANGE 1253 /* Check if a range has been specified without specifying what to 1254 collect. */ 1255 { 1256 int i; 1257 1258 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 1259 { 1260 sim_cpu *cpu = STATE_CPU (sd, i); 1261 1262 if (ADDR_RANGE_RANGES (PROFILE_RANGE (CPU_PROFILE_DATA (cpu))) 1263 && ! (PROFILE_INSN_P (cpu) 1264 || PROFILE_MODEL_P (cpu))) 1265 { 1266 sim_io_eprintf_cpu (cpu, "Profiling address range specified without --profile-insn or --profile-model.\n"); 1267 sim_io_eprintf_cpu (cpu, "Address range ignored.\n"); 1268 sim_addr_range_delete (PROFILE_RANGE (CPU_PROFILE_DATA (cpu)), 1269 0, ~ (address_word) 0); 1270 } 1271 } 1272 } 1273 #endif 1274 1275 return SIM_RC_OK; 1276 } 1277 1278 static void 1279 profile_uninstall (SIM_DESC sd) 1280 { 1281 int i,j; 1282 1283 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 1284 { 1285 sim_cpu *cpu = STATE_CPU (sd, i); 1286 PROFILE_DATA *data = CPU_PROFILE_DATA (cpu); 1287 1288 if (PROFILE_FILE (data) != NULL) 1289 { 1290 /* If output from different cpus is going to the same file, 1291 avoid closing the file twice. */ 1292 for (j = 0; j < i; ++j) 1293 if (PROFILE_FILE (CPU_PROFILE_DATA (STATE_CPU (sd, j))) 1294 == PROFILE_FILE (data)) 1295 break; 1296 if (i == j) 1297 fclose (PROFILE_FILE (data)); 1298 } 1299 1300 if (PROFILE_INSN_COUNT (data) != NULL) 1301 free (PROFILE_INSN_COUNT (data)); 1302 } 1303 } 1304