1 /* Simulator tracing/debugging support. 2 Copyright (C) 1997-2017 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 #include "sim-main.h" 21 #include "sim-io.h" 22 #include "sim-options.h" 23 #include "sim-fpu.h" 24 25 #include "bfd.h" 26 #include "libiberty.h" 27 28 #include "dis-asm.h" 29 30 #include "sim-assert.h" 31 32 #ifdef HAVE_STRING_H 33 #include <string.h> 34 #else 35 #ifdef HAVE_STRINGS_H 36 #include <strings.h> 37 #endif 38 #endif 39 #ifdef HAVE_STDLIB_H 40 #include <stdlib.h> 41 #endif 42 43 #ifndef SIZE_PHASE 44 #define SIZE_PHASE 8 45 #endif 46 47 #ifndef SIZE_LOCATION 48 #define SIZE_LOCATION 20 49 #endif 50 51 #ifndef SIZE_PC 52 #define SIZE_PC 6 53 #endif 54 55 #ifndef SIZE_LINE_NUMBER 56 #define SIZE_LINE_NUMBER 4 57 #endif 58 59 static MODULE_INIT_FN trace_init; 60 static MODULE_UNINSTALL_FN trace_uninstall; 61 62 static DECLARE_OPTION_HANDLER (trace_option_handler); 63 64 enum { 65 OPTION_TRACE_INSN = OPTION_START, 66 OPTION_TRACE_DISASM, 67 OPTION_TRACE_DECODE, 68 OPTION_TRACE_EXTRACT, 69 OPTION_TRACE_LINENUM, 70 OPTION_TRACE_MEMORY, 71 OPTION_TRACE_MODEL, 72 OPTION_TRACE_ALU, 73 OPTION_TRACE_CORE, 74 OPTION_TRACE_EVENTS, 75 OPTION_TRACE_FPU, 76 OPTION_TRACE_BRANCH, 77 OPTION_TRACE_SEMANTICS, 78 OPTION_TRACE_RANGE, 79 OPTION_TRACE_FUNCTION, 80 OPTION_TRACE_DEBUG, 81 OPTION_TRACE_FILE, 82 OPTION_TRACE_VPU, 83 OPTION_TRACE_SYSCALL, 84 OPTION_TRACE_REGISTER 85 }; 86 87 static const OPTION trace_options[] = 88 { 89 /* This table is organized to group related instructions together. */ 90 { {"trace", optional_argument, NULL, 't'}, 91 't', "on|off", "Trace useful things", 92 trace_option_handler, NULL }, 93 { {"trace-insn", optional_argument, NULL, OPTION_TRACE_INSN}, 94 '\0', "on|off", "Perform instruction tracing", 95 trace_option_handler, NULL }, 96 { {"trace-disasm", optional_argument, NULL, OPTION_TRACE_DISASM}, 97 '\0', "on|off", "Disassemble instructions (slower, but more accurate)", 98 trace_option_handler, NULL }, 99 { {"trace-decode", optional_argument, NULL, OPTION_TRACE_DECODE}, 100 '\0', "on|off", "Trace instruction decoding", 101 trace_option_handler, NULL }, 102 { {"trace-extract", optional_argument, NULL, OPTION_TRACE_EXTRACT}, 103 '\0', "on|off", "Trace instruction extraction", 104 trace_option_handler, NULL }, 105 { {"trace-linenum", optional_argument, NULL, OPTION_TRACE_LINENUM}, 106 '\0', "on|off", "Perform line number tracing (implies --trace-insn)", 107 trace_option_handler, NULL }, 108 { {"trace-memory", optional_argument, NULL, OPTION_TRACE_MEMORY}, 109 '\0', "on|off", "Trace memory operations", 110 trace_option_handler, NULL }, 111 { {"trace-alu", optional_argument, NULL, OPTION_TRACE_ALU}, 112 '\0', "on|off", "Trace ALU (Arithmetic Logic Unit) operations", 113 trace_option_handler, NULL }, 114 { {"trace-fpu", optional_argument, NULL, OPTION_TRACE_FPU}, 115 '\0', "on|off", "Trace FPU (Floating Point Unit) operations", 116 trace_option_handler, NULL }, 117 { {"trace-vpu", optional_argument, NULL, OPTION_TRACE_VPU}, 118 '\0', "on|off", "Trace VPU (Vector Processing Unit) operations", 119 trace_option_handler, NULL }, 120 { {"trace-branch", optional_argument, NULL, OPTION_TRACE_BRANCH}, 121 '\0', "on|off", "Trace branching", 122 trace_option_handler, NULL }, 123 { {"trace-semantics", optional_argument, NULL, OPTION_TRACE_SEMANTICS}, 124 '\0', "on|off", "Perform ALU, FPU, VPU, MEMORY, and BRANCH tracing", 125 trace_option_handler, NULL }, 126 { {"trace-model", optional_argument, NULL, OPTION_TRACE_MODEL}, 127 '\0', "on|off", "Include model performance data", 128 trace_option_handler, NULL }, 129 { {"trace-core", optional_argument, NULL, OPTION_TRACE_CORE}, 130 '\0', "on|off", "Trace core operations", 131 trace_option_handler, NULL }, 132 { {"trace-events", optional_argument, NULL, OPTION_TRACE_EVENTS}, 133 '\0', "on|off", "Trace events", 134 trace_option_handler, NULL }, 135 { {"trace-syscall", optional_argument, NULL, OPTION_TRACE_SYSCALL}, 136 '\0', "on|off", "Trace system calls", 137 trace_option_handler, NULL }, 138 { {"trace-register", optional_argument, NULL, OPTION_TRACE_REGISTER}, 139 '\0', "on|off", "Trace cpu register accesses", 140 trace_option_handler, NULL }, 141 #ifdef SIM_HAVE_ADDR_RANGE 142 { {"trace-range", required_argument, NULL, OPTION_TRACE_RANGE}, 143 '\0', "START,END", "Specify range of addresses for instruction tracing", 144 trace_option_handler, NULL }, 145 #if 0 /*wip*/ 146 { {"trace-function", required_argument, NULL, OPTION_TRACE_FUNCTION}, 147 '\0', "FUNCTION", "Specify function to trace", 148 trace_option_handler, NULL }, 149 #endif 150 #endif 151 { {"trace-debug", optional_argument, NULL, OPTION_TRACE_DEBUG}, 152 '\0', "on|off", "Add information useful for debugging the simulator to the tracing output", 153 trace_option_handler, NULL }, 154 { {"trace-file", required_argument, NULL, OPTION_TRACE_FILE}, 155 '\0', "FILE NAME", "Specify tracing output file", 156 trace_option_handler, NULL }, 157 { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL } 158 }; 159 160 /* Set/reset the trace options indicated in MASK. */ 161 162 static SIM_RC 163 set_trace_option_mask (SIM_DESC sd, const char *name, int mask, const char *arg) 164 { 165 int trace_nr; 166 int cpu_nr; 167 int trace_val = 1; 168 169 if (arg != NULL) 170 { 171 if (strcmp (arg, "yes") == 0 172 || strcmp (arg, "on") == 0 173 || strcmp (arg, "1") == 0) 174 trace_val = 1; 175 else if (strcmp (arg, "no") == 0 176 || strcmp (arg, "off") == 0 177 || strcmp (arg, "0") == 0) 178 trace_val = 0; 179 else 180 { 181 sim_io_eprintf (sd, "Argument `%s' for `--trace%s' invalid, one of `on', `off', `yes', `no' expected\n", arg, name); 182 return SIM_RC_FAIL; 183 } 184 } 185 186 /* Update applicable trace bits. */ 187 for (trace_nr = 0; trace_nr < MAX_TRACE_VALUES; ++trace_nr) 188 { 189 if ((mask & (1 << trace_nr)) == 0) 190 continue; 191 192 /* Set non-cpu specific values. */ 193 STATE_TRACE_FLAGS (sd)[trace_nr] = trace_val; 194 195 /* Set cpu values. */ 196 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) 197 { 198 CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr] = trace_val; 199 } 200 } 201 202 /* Re-compute the cpu trace summary. */ 203 if (trace_val) 204 { 205 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) 206 CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 1; 207 } 208 else 209 { 210 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) 211 { 212 CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 0; 213 for (trace_nr = 0; trace_nr < MAX_TRACE_VALUES; ++trace_nr) 214 { 215 if (CPU_TRACE_FLAGS (STATE_CPU (sd, cpu_nr))[trace_nr]) 216 { 217 CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))->trace_any_p = 1; 218 break; 219 } 220 } 221 } 222 } 223 224 return SIM_RC_OK; 225 } 226 227 /* Set one trace option based on its IDX value. */ 228 229 static SIM_RC 230 set_trace_option (SIM_DESC sd, const char *name, int idx, const char *arg) 231 { 232 return set_trace_option_mask (sd, name, 1 << idx, arg); 233 } 234 235 236 static SIM_RC 237 trace_option_handler (SIM_DESC sd, sim_cpu *cpu, int opt, 238 char *arg, int is_command) 239 { 240 int n; 241 242 switch (opt) 243 { 244 case 't' : 245 if (!WITH_TRACE_ANY_P) 246 sim_io_eprintf (sd, "Tracing not compiled in, `-t' ignored\n"); 247 else 248 return set_trace_option_mask (sd, "trace", TRACE_USEFUL_MASK, arg); 249 break; 250 251 case OPTION_TRACE_INSN : 252 if (WITH_TRACE_INSN_P) 253 return set_trace_option (sd, "-insn", TRACE_INSN_IDX, arg); 254 else 255 sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-insn' ignored\n"); 256 break; 257 258 case OPTION_TRACE_DISASM : 259 if (WITH_TRACE_DISASM_P) 260 return set_trace_option (sd, "-disasm", TRACE_DISASM_IDX, arg); 261 else 262 sim_io_eprintf (sd, "Instruction tracing not compiled in, `--trace-disasm' ignored\n"); 263 break; 264 265 case OPTION_TRACE_DECODE : 266 if (WITH_TRACE_DECODE_P) 267 return set_trace_option (sd, "-decode", TRACE_DECODE_IDX, arg); 268 else 269 sim_io_eprintf (sd, "Decode tracing not compiled in, `--trace-decode' ignored\n"); 270 break; 271 272 case OPTION_TRACE_EXTRACT : 273 if (WITH_TRACE_EXTRACT_P) 274 return set_trace_option (sd, "-extract", TRACE_EXTRACT_IDX, arg); 275 else 276 sim_io_eprintf (sd, "Extract tracing not compiled in, `--trace-extract' ignored\n"); 277 break; 278 279 case OPTION_TRACE_LINENUM : 280 if (WITH_TRACE_LINENUM_P && WITH_TRACE_INSN_P) 281 { 282 if (set_trace_option (sd, "-linenum", TRACE_LINENUM_IDX, arg) != SIM_RC_OK 283 || set_trace_option (sd, "-linenum", TRACE_INSN_IDX, arg) != SIM_RC_OK) 284 return SIM_RC_FAIL; 285 } 286 else 287 sim_io_eprintf (sd, "Line number or instruction tracing not compiled in, `--trace-linenum' ignored\n"); 288 break; 289 290 case OPTION_TRACE_MEMORY : 291 if (WITH_TRACE_MEMORY_P) 292 return set_trace_option (sd, "-memory", TRACE_MEMORY_IDX, arg); 293 else 294 sim_io_eprintf (sd, "Memory tracing not compiled in, `--trace-memory' ignored\n"); 295 break; 296 297 case OPTION_TRACE_MODEL : 298 if (WITH_TRACE_MODEL_P) 299 return set_trace_option (sd, "-model", TRACE_MODEL_IDX, arg); 300 else 301 sim_io_eprintf (sd, "Model tracing not compiled in, `--trace-model' ignored\n"); 302 break; 303 304 case OPTION_TRACE_ALU : 305 if (WITH_TRACE_ALU_P) 306 return set_trace_option (sd, "-alu", TRACE_ALU_IDX, arg); 307 else 308 sim_io_eprintf (sd, "ALU tracing not compiled in, `--trace-alu' ignored\n"); 309 break; 310 311 case OPTION_TRACE_CORE : 312 if (WITH_TRACE_CORE_P) 313 return set_trace_option (sd, "-core", TRACE_CORE_IDX, arg); 314 else 315 sim_io_eprintf (sd, "CORE tracing not compiled in, `--trace-core' ignored\n"); 316 break; 317 318 case OPTION_TRACE_EVENTS : 319 if (WITH_TRACE_EVENTS_P) 320 return set_trace_option (sd, "-events", TRACE_EVENTS_IDX, arg); 321 else 322 sim_io_eprintf (sd, "EVENTS tracing not compiled in, `--trace-events' ignored\n"); 323 break; 324 325 case OPTION_TRACE_FPU : 326 if (WITH_TRACE_FPU_P) 327 return set_trace_option (sd, "-fpu", TRACE_FPU_IDX, arg); 328 else 329 sim_io_eprintf (sd, "FPU tracing not compiled in, `--trace-fpu' ignored\n"); 330 break; 331 332 case OPTION_TRACE_VPU : 333 if (WITH_TRACE_VPU_P) 334 return set_trace_option (sd, "-vpu", TRACE_VPU_IDX, arg); 335 else 336 sim_io_eprintf (sd, "VPU tracing not compiled in, `--trace-vpu' ignored\n"); 337 break; 338 339 case OPTION_TRACE_BRANCH : 340 if (WITH_TRACE_BRANCH_P) 341 return set_trace_option (sd, "-branch", TRACE_BRANCH_IDX, arg); 342 else 343 sim_io_eprintf (sd, "Branch tracing not compiled in, `--trace-branch' ignored\n"); 344 break; 345 346 case OPTION_TRACE_SYSCALL : 347 if (WITH_TRACE_SYSCALL_P) 348 return set_trace_option (sd, "-syscall", TRACE_SYSCALL_IDX, arg); 349 else 350 sim_io_eprintf (sd, "System call tracing not compiled in, `--trace-syscall' ignored\n"); 351 break; 352 353 case OPTION_TRACE_REGISTER : 354 if (WITH_TRACE_REGISTER_P) 355 return set_trace_option (sd, "-register", TRACE_REGISTER_IDX, arg); 356 else 357 sim_io_eprintf (sd, "Register tracing not compiled in, `--trace-register' ignored\n"); 358 break; 359 360 case OPTION_TRACE_SEMANTICS : 361 if (WITH_TRACE_ALU_P 362 && WITH_TRACE_FPU_P 363 && WITH_TRACE_MEMORY_P 364 && WITH_TRACE_BRANCH_P) 365 { 366 if (set_trace_option (sd, "-semantics", TRACE_ALU_IDX, arg) != SIM_RC_OK 367 || set_trace_option (sd, "-semantics", TRACE_FPU_IDX, arg) != SIM_RC_OK 368 || set_trace_option (sd, "-semantics", TRACE_VPU_IDX, arg) != SIM_RC_OK 369 || set_trace_option (sd, "-semantics", TRACE_MEMORY_IDX, arg) != SIM_RC_OK 370 || set_trace_option (sd, "-semantics", TRACE_BRANCH_IDX, arg) != SIM_RC_OK) 371 return SIM_RC_FAIL; 372 } 373 else 374 sim_io_eprintf (sd, "Alu, fpu, memory, and/or branch tracing not compiled in, `--trace-semantics' ignored\n"); 375 break; 376 377 #ifdef SIM_HAVE_ADDR_RANGE 378 case OPTION_TRACE_RANGE : 379 if (WITH_TRACE_ANY_P) 380 { 381 int cpu_nr; 382 char *chp = arg; 383 unsigned long start,end; 384 start = strtoul (chp, &chp, 0); 385 if (*chp != ',') 386 { 387 sim_io_eprintf (sd, "--trace-range missing END argument\n"); 388 return SIM_RC_FAIL; 389 } 390 end = strtoul (chp + 1, NULL, 0); 391 /* FIXME: Argument validation. */ 392 if (cpu != NULL) 393 sim_addr_range_add (TRACE_RANGE (CPU_PROFILE_DATA (cpu)), 394 start, end); 395 else 396 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; ++cpu_nr) 397 sim_addr_range_add (TRACE_RANGE (CPU_TRACE_DATA (STATE_CPU (sd, cpu_nr))), 398 start, end); 399 } 400 else 401 sim_io_eprintf (sd, "Tracing not compiled in, `--trace-range' ignored\n"); 402 break; 403 404 case OPTION_TRACE_FUNCTION : 405 if (WITH_TRACE_ANY_P) 406 { 407 /*wip: need to compute function range given name*/ 408 } 409 else 410 sim_io_eprintf (sd, "Tracing not compiled in, `--trace-function' ignored\n"); 411 break; 412 #endif /* SIM_HAVE_ADDR_RANGE */ 413 414 case OPTION_TRACE_DEBUG : 415 if (WITH_TRACE_DEBUG_P) 416 return set_trace_option (sd, "-debug", TRACE_DEBUG_IDX, arg); 417 else 418 sim_io_eprintf (sd, "Tracing debug support not compiled in, `--trace-debug' ignored\n"); 419 break; 420 421 case OPTION_TRACE_FILE : 422 if (!WITH_TRACE_ANY_P) 423 sim_io_eprintf (sd, "Tracing not compiled in, `--trace-file' ignored\n"); 424 else 425 { 426 FILE *f = fopen (arg, "w"); 427 428 if (f == NULL) 429 { 430 sim_io_eprintf (sd, "Unable to open trace output file `%s'\n", arg); 431 return SIM_RC_FAIL; 432 } 433 for (n = 0; n < MAX_NR_PROCESSORS; ++n) 434 TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, n))) = f; 435 TRACE_FILE (STATE_TRACE_DATA (sd)) = f; 436 } 437 break; 438 } 439 440 return SIM_RC_OK; 441 } 442 443 /* Install tracing support. */ 444 445 SIM_RC 446 trace_install (SIM_DESC sd) 447 { 448 int i; 449 450 SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); 451 452 sim_add_option_table (sd, NULL, trace_options); 453 memset (STATE_TRACE_DATA (sd), 0, sizeof (* STATE_TRACE_DATA (sd))); 454 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 455 memset (CPU_TRACE_DATA (STATE_CPU (sd, i)), 0, 456 sizeof (* CPU_TRACE_DATA (STATE_CPU (sd, i)))); 457 sim_module_add_init_fn (sd, trace_init); 458 sim_module_add_uninstall_fn (sd, trace_uninstall); 459 return SIM_RC_OK; 460 } 461 462 static SIM_RC 463 trace_init (SIM_DESC sd) 464 { 465 #ifdef SIM_HAVE_ADDR_RANGE 466 /* Check if a range has been specified without specifying what to 467 collect. */ 468 { 469 int i; 470 471 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 472 { 473 sim_cpu *cpu = STATE_CPU (sd, i); 474 475 if (ADDR_RANGE_RANGES (TRACE_RANGE (CPU_TRACE_DATA (cpu))) 476 && ! TRACE_INSN_P (cpu)) 477 { 478 sim_io_eprintf_cpu (cpu, "Tracing address range specified without --trace-insn.\n"); 479 sim_io_eprintf_cpu (cpu, "Address range ignored.\n"); 480 sim_addr_range_delete (TRACE_RANGE (CPU_TRACE_DATA (cpu)), 481 0, ~ (address_word) 0); 482 } 483 } 484 } 485 #endif 486 487 return SIM_RC_OK; 488 } 489 490 static void 491 trace_uninstall (SIM_DESC sd) 492 { 493 int i,j; 494 FILE *sfile = TRACE_FILE (STATE_TRACE_DATA (sd)); 495 496 if (sfile != NULL) 497 fclose (sfile); 498 499 for (i = 0; i < MAX_NR_PROCESSORS; ++i) 500 { 501 FILE *cfile = TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, i))); 502 if (cfile != NULL && cfile != sfile) 503 { 504 /* If output from different cpus is going to the same file, 505 avoid closing the file twice. */ 506 for (j = 0; j < i; ++j) 507 if (TRACE_FILE (CPU_TRACE_DATA (STATE_CPU (sd, j))) == cfile) 508 break; 509 if (i == j) 510 fclose (cfile); 511 } 512 } 513 514 if (STATE_PROG_SYMS (sd)) 515 free (STATE_PROG_SYMS (sd)); 516 } 517 518 /* compute the nr of trace data units consumed by data */ 519 static int 520 save_data_size (TRACE_DATA *data, 521 long size) 522 { 523 return ((size + sizeof (TRACE_INPUT_DATA (data) [0]) - 1) 524 / sizeof (TRACE_INPUT_DATA (data) [0])); 525 } 526 527 528 /* Archive DATA into the trace buffer */ 529 void 530 save_data (SIM_DESC sd, 531 TRACE_DATA *data, 532 data_fmt fmt, 533 long size, 534 const void *buf) 535 { 536 int i = TRACE_INPUT_IDX (data); 537 if (i == sizeof (TRACE_INPUT_FMT (data))) 538 sim_io_error (sd, "trace buffer overflow"); 539 TRACE_INPUT_FMT (data) [i] = fmt; 540 TRACE_INPUT_SIZE (data) [i] = size; 541 memcpy (&TRACE_INPUT_DATA (data) [i], buf, size); 542 i += save_data_size (data, size); 543 TRACE_INPUT_IDX (data) = i; 544 } 545 546 static void 547 print_data (SIM_DESC sd, 548 sim_cpu *cpu, 549 data_fmt fmt, 550 long size, 551 void *data) 552 { 553 switch (fmt) 554 { 555 case trace_fmt_instruction_incomplete: 556 trace_printf (sd, cpu, " (instruction incomplete)"); 557 break; 558 case trace_fmt_word: 559 case trace_fmt_addr: 560 { 561 switch (size) 562 { 563 case sizeof (unsigned32): 564 trace_printf (sd, cpu, " 0x%08lx", (long) * (unsigned32*) data); 565 break; 566 case sizeof (unsigned64): 567 trace_printf (sd, cpu, " 0x%08lx%08lx", 568 (long) ((* (unsigned64*) data) >> 32), 569 (long) * (unsigned64*) data); 570 break; 571 default: 572 abort (); 573 } 574 break; 575 } 576 case trace_fmt_bool: 577 { 578 SIM_ASSERT (size == sizeof (int)); 579 trace_printf (sd, cpu, " %-8s", 580 (* (int*) data) ? "true" : "false"); 581 break; 582 } 583 case trace_fmt_fp: 584 { 585 sim_fpu fp; 586 switch (size) 587 { 588 /* FIXME: Assumes sizeof float == 4; sizeof double == 8 */ 589 case 4: 590 sim_fpu_32to (&fp, *(unsigned32*)data); 591 break; 592 case 8: 593 sim_fpu_64to (&fp, *(unsigned64*)data); 594 break; 595 default: 596 abort (); 597 } 598 trace_printf (sd, cpu, " %8g", sim_fpu_2d (&fp)); 599 switch (size) 600 { 601 case 4: 602 trace_printf (sd, cpu, " (0x%08lx)", 603 (long) *(unsigned32*)data); 604 break; 605 case 8: 606 trace_printf (sd, cpu, " (0x%08lx%08lx)", 607 (long) (*(unsigned64*)data >> 32), 608 (long) (*(unsigned64*)data)); 609 break; 610 default: 611 abort (); 612 } 613 break; 614 } 615 case trace_fmt_fpu: 616 /* FIXME: At present sim_fpu data is stored as a double */ 617 trace_printf (sd, cpu, " %8g", * (double*) data); 618 break; 619 case trace_fmt_string: 620 trace_printf (sd, cpu, " %-8s", (char*) data); 621 break; 622 default: 623 abort (); 624 } 625 } 626 627 static const char * 628 trace_idx_to_str (int trace_idx) 629 { 630 static char num[8]; 631 switch (trace_idx) 632 { 633 case TRACE_ALU_IDX: return "alu: "; 634 case TRACE_INSN_IDX: return "insn: "; 635 case TRACE_DISASM_IDX: return "disasm: "; 636 case TRACE_DECODE_IDX: return "decode: "; 637 case TRACE_EXTRACT_IDX: return "extract: "; 638 case TRACE_MEMORY_IDX: return "memory: "; 639 case TRACE_CORE_IDX: return "core: "; 640 case TRACE_EVENTS_IDX: return "events: "; 641 case TRACE_FPU_IDX: return "fpu: "; 642 case TRACE_BRANCH_IDX: return "branch: "; 643 case TRACE_SYSCALL_IDX: return "syscall: "; 644 case TRACE_REGISTER_IDX: return "reg: "; 645 case TRACE_VPU_IDX: return "vpu: "; 646 default: 647 sprintf (num, "?%d?", trace_idx); 648 return num; 649 } 650 } 651 652 static void 653 trace_results (SIM_DESC sd, 654 sim_cpu *cpu, 655 int trace_idx, 656 int last_input) 657 { 658 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 659 int nr_out; 660 int i; 661 662 /* cross check trace_idx against TRACE_IDX (data)? */ 663 664 /* prefix */ 665 trace_printf (sd, cpu, "%s %s", 666 trace_idx_to_str (TRACE_IDX (data)), 667 TRACE_PREFIX (data)); 668 TRACE_IDX (data) = 0; 669 670 for (i = 0, nr_out = 0; 671 i < TRACE_INPUT_IDX (data); 672 i += save_data_size (data, TRACE_INPUT_SIZE (data) [i]), nr_out++) 673 { 674 if (i == last_input) 675 { 676 int pad = (strlen (" 0x") + sizeof (unsigned_word) * 2); 677 int padding = pad * (3 - nr_out); 678 if (padding < 0) 679 padding = 0; 680 padding += strlen (" ::"); 681 trace_printf (sd, cpu, "%*s", padding, " ::"); 682 } 683 print_data (sd, cpu, 684 TRACE_INPUT_FMT (data) [i], 685 TRACE_INPUT_SIZE (data) [i], 686 &TRACE_INPUT_DATA (data) [i]); 687 } 688 trace_printf (sd, cpu, "\n"); 689 } 690 691 int 692 trace_load_symbols (SIM_DESC sd) 693 { 694 bfd *abfd; 695 asymbol **asymbols; 696 long symsize; 697 long symbol_count; 698 699 /* Already loaded, so nothing to do. */ 700 if (STATE_PROG_SYMS (sd)) 701 return 1; 702 703 abfd = STATE_PROG_BFD (sd); 704 if (abfd == NULL) 705 return 0; 706 707 symsize = bfd_get_symtab_upper_bound (abfd); 708 if (symsize < 0) 709 return 0; 710 711 asymbols = xmalloc (symsize); 712 symbol_count = bfd_canonicalize_symtab (abfd, asymbols); 713 if (symbol_count < 0) 714 { 715 free (asymbols); 716 return 0; 717 } 718 719 STATE_PROG_SYMS (sd) = asymbols; 720 STATE_PROG_SYMS_COUNT (sd) = symbol_count; 721 return 1; 722 } 723 724 bfd_vma 725 trace_sym_value (SIM_DESC sd, const char *name) 726 { 727 asymbol **asymbols; 728 long i; 729 730 if (!trace_load_symbols (sd)) 731 return -1; 732 733 asymbols = STATE_PROG_SYMS (sd); 734 735 for (i = 0; i < STATE_PROG_SYMS_COUNT (sd); ++i) 736 if (strcmp (asymbols[i]->name, name) == 0) 737 return bfd_asymbol_value (asymbols[i]); 738 739 return -1; 740 } 741 742 void 743 trace_prefix (SIM_DESC sd, 744 sim_cpu *cpu, 745 sim_cia cia, 746 address_word pc, 747 int line_p, 748 const char *filename, 749 int linenum, 750 const char *fmt, 751 ...) 752 { 753 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 754 va_list ap; 755 char *prefix = TRACE_PREFIX (data); 756 char *chp; 757 /* FIXME: The TRACE_PREFIX_WIDTH should be determined at build time using 758 known information about the disassembled instructions. */ 759 #ifndef TRACE_PREFIX_WIDTH 760 #define TRACE_PREFIX_WIDTH 48 761 #endif 762 int width = TRACE_PREFIX_WIDTH; 763 764 /* if the previous trace data wasn't flushed, flush it now with a 765 note indicating that the trace was incomplete. */ 766 if (TRACE_IDX (data) != 0) 767 { 768 int last_input = TRACE_INPUT_IDX (data); 769 save_data (sd, data, trace_fmt_instruction_incomplete, 1, ""); 770 trace_results (sd, cpu, TRACE_IDX (data), last_input); 771 } 772 TRACE_IDX (data) = 0; 773 TRACE_INPUT_IDX (data) = 0; 774 775 /* Create the text prefix for this new instruction: */ 776 if (!line_p) 777 { 778 if (filename) 779 { 780 sprintf (prefix, "%s:%-*d 0x%.*lx ", 781 filename, 782 SIZE_LINE_NUMBER, linenum, 783 SIZE_PC, (long) pc); 784 } 785 else 786 { 787 sprintf (prefix, "0x%.*lx ", 788 SIZE_PC, (long) pc); 789 /* Shrink the width by the amount that we didn't print. */ 790 width -= SIZE_LINE_NUMBER + SIZE_PC + 8; 791 } 792 chp = strchr (prefix, '\0'); 793 va_start (ap, fmt); 794 vsprintf (chp, fmt, ap); 795 va_end (ap); 796 } 797 else 798 { 799 char buf[256]; 800 buf[0] = 0; 801 if (STATE_TEXT_SECTION (sd) 802 && pc >= STATE_TEXT_START (sd) 803 && pc < STATE_TEXT_END (sd)) 804 { 805 const char *pc_filename = (const char *)0; 806 const char *pc_function = (const char *)0; 807 unsigned int pc_linenum = 0; 808 bfd *abfd; 809 asymbol **asymbols; 810 811 if (!trace_load_symbols (sd)) 812 sim_engine_abort (sd, cpu, cia, "could not load symbols"); 813 814 abfd = STATE_PROG_BFD (sd); 815 asymbols = STATE_PROG_SYMS (sd); 816 817 if (bfd_find_nearest_line (abfd, STATE_TEXT_SECTION (sd), asymbols, 818 pc - STATE_TEXT_START (sd), 819 &pc_filename, &pc_function, &pc_linenum)) 820 { 821 char *p = buf; 822 if (pc_linenum) 823 { 824 sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, pc_linenum); 825 p += strlen (p); 826 } 827 else 828 { 829 sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---"); 830 p += SIZE_LINE_NUMBER+2; 831 } 832 833 if (pc_function) 834 { 835 sprintf (p, "%s ", pc_function); 836 p += strlen (p); 837 } 838 else if (pc_filename) 839 { 840 char *q = (char *) strrchr (pc_filename, '/'); 841 sprintf (p, "%s ", (q) ? q+1 : pc_filename); 842 p += strlen (p); 843 } 844 845 if (*p == ' ') 846 *p = '\0'; 847 } 848 } 849 850 sprintf (prefix, "0x%.*x %-*.*s ", 851 SIZE_PC, (unsigned) pc, 852 SIZE_LOCATION, SIZE_LOCATION, buf); 853 chp = strchr (prefix, '\0'); 854 va_start (ap, fmt); 855 vsprintf (chp, fmt, ap); 856 va_end (ap); 857 } 858 859 /* Pad it out to TRACE_PREFIX_WIDTH. */ 860 chp = strchr (prefix, '\0'); 861 if (chp - prefix < width) 862 { 863 memset (chp, ' ', width - (chp - prefix)); 864 chp = &prefix [width]; 865 *chp = '\0'; 866 } 867 strcpy (chp, " -"); 868 869 /* check that we've not over flowed the prefix buffer */ 870 if (strlen (prefix) >= sizeof (TRACE_PREFIX (data))) 871 abort (); 872 } 873 874 void 875 trace_generic (SIM_DESC sd, 876 sim_cpu *cpu, 877 int trace_idx, 878 const char *fmt, 879 ...) 880 { 881 va_list ap; 882 trace_printf (sd, cpu, "%s %s", 883 trace_idx_to_str (trace_idx), 884 TRACE_PREFIX (CPU_TRACE_DATA (cpu))); 885 va_start (ap, fmt); 886 trace_vprintf (sd, cpu, fmt, ap); 887 va_end (ap); 888 trace_printf (sd, cpu, "\n"); 889 } 890 891 static int 892 dis_read (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length, 893 struct disassemble_info *dinfo) 894 { 895 SIM_CPU *cpu = dinfo->application_data; 896 sim_core_read_buffer (CPU_STATE (cpu), cpu, NULL_CIA, myaddr, memaddr, length); 897 return 0; 898 } 899 900 static int 901 dis_printf (SIM_CPU *cpu, const char *fmt, ...) 902 { 903 SIM_DESC sd = CPU_STATE (cpu); 904 va_list ap; 905 va_start (ap, fmt); 906 trace_vprintf (sd, cpu, fmt, ap); 907 va_end (ap); 908 return 0; 909 } 910 911 void 912 trace_disasm (SIM_DESC sd, sim_cpu *cpu, address_word addr) 913 { 914 struct bfd *bfd = STATE_PROG_BFD (sd); 915 TRACE_DATA *trace_data = CPU_TRACE_DATA (cpu); 916 disassemble_info *info = &trace_data->dis_info; 917 918 /* See if we need to set up the disassembly func. */ 919 if (trace_data->dis_bfd != bfd) 920 { 921 trace_data->dis_bfd = bfd; 922 trace_data->disassembler = disassembler (trace_data->dis_bfd); 923 INIT_DISASSEMBLE_INFO (*info, cpu, dis_printf); 924 info->read_memory_func = dis_read; 925 info->arch = bfd_get_arch (bfd); 926 info->mach = bfd_get_mach (bfd); 927 disassemble_init_for_target (info); 928 } 929 930 info->application_data = cpu; 931 932 trace_printf (sd, cpu, "%s %s", 933 trace_idx_to_str (TRACE_DISASM_IDX), 934 TRACE_PREFIX (trace_data)); 935 trace_data->disassembler (addr, info); 936 trace_printf (sd, cpu, "\n"); 937 } 938 939 void 940 trace_input0 (SIM_DESC sd, 941 sim_cpu *cpu, 942 int trace_idx) 943 { 944 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 945 TRACE_IDX (data) = trace_idx; 946 } 947 948 void 949 trace_input_word1 (SIM_DESC sd, 950 sim_cpu *cpu, 951 int trace_idx, 952 unsigned_word d0) 953 { 954 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 955 TRACE_IDX (data) = trace_idx; 956 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0); 957 } 958 959 void 960 trace_input_word2 (SIM_DESC sd, 961 sim_cpu *cpu, 962 int trace_idx, 963 unsigned_word d0, 964 unsigned_word d1) 965 { 966 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 967 TRACE_IDX (data) = trace_idx; 968 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0); 969 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1); 970 } 971 972 void 973 trace_input_word3 (SIM_DESC sd, 974 sim_cpu *cpu, 975 int trace_idx, 976 unsigned_word d0, 977 unsigned_word d1, 978 unsigned_word d2) 979 { 980 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 981 TRACE_IDX (data) = trace_idx; 982 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d0); 983 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d1); 984 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &d2); 985 } 986 987 void 988 trace_input_word4 (SIM_DESC sd, 989 sim_cpu *cpu, 990 int trace_idx, 991 unsigned_word d0, 992 unsigned_word d1, 993 unsigned_word d2, 994 unsigned_word d3) 995 { 996 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 997 TRACE_IDX (data) = trace_idx; 998 save_data (sd, data, trace_fmt_word, sizeof (d0), &d0); 999 save_data (sd, data, trace_fmt_word, sizeof (d1), &d1); 1000 save_data (sd, data, trace_fmt_word, sizeof (d2), &d2); 1001 save_data (sd, data, trace_fmt_word, sizeof (d3), &d3); 1002 } 1003 1004 void 1005 trace_input_bool1 (SIM_DESC sd, 1006 sim_cpu *cpu, 1007 int trace_idx, 1008 int d0) 1009 { 1010 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1011 TRACE_IDX (data) = trace_idx; 1012 save_data (sd, data, trace_fmt_bool, sizeof (d0), &d0); 1013 } 1014 1015 void 1016 trace_input_addr1 (SIM_DESC sd, 1017 sim_cpu *cpu, 1018 int trace_idx, 1019 address_word d0) 1020 { 1021 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1022 TRACE_IDX (data) = trace_idx; 1023 save_data (sd, data, trace_fmt_addr, sizeof (d0), &d0); 1024 } 1025 1026 void 1027 trace_input_fp1 (SIM_DESC sd, 1028 sim_cpu *cpu, 1029 int trace_idx, 1030 fp_word f0) 1031 { 1032 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1033 TRACE_IDX (data) = trace_idx; 1034 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); 1035 } 1036 1037 void 1038 trace_input_fp2 (SIM_DESC sd, 1039 sim_cpu *cpu, 1040 int trace_idx, 1041 fp_word f0, 1042 fp_word f1) 1043 { 1044 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1045 TRACE_IDX (data) = trace_idx; 1046 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); 1047 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1); 1048 } 1049 1050 void 1051 trace_input_fp3 (SIM_DESC sd, 1052 sim_cpu *cpu, 1053 int trace_idx, 1054 fp_word f0, 1055 fp_word f1, 1056 fp_word f2) 1057 { 1058 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1059 TRACE_IDX (data) = trace_idx; 1060 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); 1061 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f1); 1062 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f2); 1063 } 1064 1065 void 1066 trace_input_fpu1 (SIM_DESC sd, 1067 sim_cpu *cpu, 1068 int trace_idx, 1069 sim_fpu *f0) 1070 { 1071 double d; 1072 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1073 TRACE_IDX (data) = trace_idx; 1074 d = sim_fpu_2d (f0); 1075 save_data (sd, data, trace_fmt_fp, sizeof (double), &d); 1076 } 1077 1078 void 1079 trace_input_fpu2 (SIM_DESC sd, 1080 sim_cpu *cpu, 1081 int trace_idx, 1082 sim_fpu *f0, 1083 sim_fpu *f1) 1084 { 1085 double d; 1086 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1087 TRACE_IDX (data) = trace_idx; 1088 d = sim_fpu_2d (f0); 1089 save_data (sd, data, trace_fmt_fp, sizeof (double), &d); 1090 d = sim_fpu_2d (f1); 1091 save_data (sd, data, trace_fmt_fp, sizeof (double), &d); 1092 } 1093 1094 void 1095 trace_input_fpu3 (SIM_DESC sd, 1096 sim_cpu *cpu, 1097 int trace_idx, 1098 sim_fpu *f0, 1099 sim_fpu *f1, 1100 sim_fpu *f2) 1101 { 1102 double d; 1103 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1104 TRACE_IDX (data) = trace_idx; 1105 d = sim_fpu_2d (f0); 1106 save_data (sd, data, trace_fmt_fp, sizeof (double), &d); 1107 d = sim_fpu_2d (f1); 1108 save_data (sd, data, trace_fmt_fp, sizeof (double), &d); 1109 d = sim_fpu_2d (f2); 1110 save_data (sd, data, trace_fmt_fp, sizeof (double), &d); 1111 } 1112 1113 void 1114 trace_result_word1 (SIM_DESC sd, 1115 sim_cpu *cpu, 1116 int trace_idx, 1117 unsigned_word r0) 1118 { 1119 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1120 int last_input; 1121 1122 /* Append any results to the end of the inputs */ 1123 last_input = TRACE_INPUT_IDX (data); 1124 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0); 1125 1126 trace_results (sd, cpu, trace_idx, last_input); 1127 } 1128 1129 void 1130 trace_result0 (SIM_DESC sd, 1131 sim_cpu *cpu, 1132 int trace_idx) 1133 { 1134 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1135 int last_input; 1136 1137 /* Append any results to the end of the inputs */ 1138 last_input = TRACE_INPUT_IDX (data); 1139 1140 trace_results (sd, cpu, trace_idx, last_input); 1141 } 1142 1143 void 1144 trace_result_word2 (SIM_DESC sd, 1145 sim_cpu *cpu, 1146 int trace_idx, 1147 unsigned_word r0, 1148 unsigned_word r1) 1149 { 1150 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1151 int last_input; 1152 1153 /* Append any results to the end of the inputs */ 1154 last_input = TRACE_INPUT_IDX (data); 1155 save_data (sd, data, trace_fmt_word, sizeof (r0), &r0); 1156 save_data (sd, data, trace_fmt_word, sizeof (r1), &r1); 1157 1158 trace_results (sd, cpu, trace_idx, last_input); 1159 } 1160 1161 void 1162 trace_result_word4 (SIM_DESC sd, 1163 sim_cpu *cpu, 1164 int trace_idx, 1165 unsigned_word r0, 1166 unsigned_word r1, 1167 unsigned_word r2, 1168 unsigned_word r3) 1169 { 1170 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1171 int last_input; 1172 1173 /* Append any results to the end of the inputs */ 1174 last_input = TRACE_INPUT_IDX (data); 1175 save_data (sd, data, trace_fmt_word, sizeof (r0), &r0); 1176 save_data (sd, data, trace_fmt_word, sizeof (r1), &r1); 1177 save_data (sd, data, trace_fmt_word, sizeof (r2), &r2); 1178 save_data (sd, data, trace_fmt_word, sizeof (r3), &r3); 1179 1180 trace_results (sd, cpu, trace_idx, last_input); 1181 } 1182 1183 void 1184 trace_result_bool1 (SIM_DESC sd, 1185 sim_cpu *cpu, 1186 int trace_idx, 1187 int r0) 1188 { 1189 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1190 int last_input; 1191 1192 /* Append any results to the end of the inputs */ 1193 last_input = TRACE_INPUT_IDX (data); 1194 save_data (sd, data, trace_fmt_bool, sizeof (r0), &r0); 1195 1196 trace_results (sd, cpu, trace_idx, last_input); 1197 } 1198 1199 void 1200 trace_result_addr1 (SIM_DESC sd, 1201 sim_cpu *cpu, 1202 int trace_idx, 1203 address_word r0) 1204 { 1205 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1206 int last_input; 1207 1208 /* Append any results to the end of the inputs */ 1209 last_input = TRACE_INPUT_IDX (data); 1210 save_data (sd, data, trace_fmt_addr, sizeof (r0), &r0); 1211 1212 trace_results (sd, cpu, trace_idx, last_input); 1213 } 1214 1215 void 1216 trace_result_fp1 (SIM_DESC sd, 1217 sim_cpu *cpu, 1218 int trace_idx, 1219 fp_word f0) 1220 { 1221 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1222 int last_input; 1223 1224 /* Append any results to the end of the inputs */ 1225 last_input = TRACE_INPUT_IDX (data); 1226 save_data (sd, data, trace_fmt_fp, sizeof (fp_word), &f0); 1227 1228 trace_results (sd, cpu, trace_idx, last_input); 1229 } 1230 1231 void 1232 trace_result_fp2 (SIM_DESC sd, 1233 sim_cpu *cpu, 1234 int trace_idx, 1235 fp_word f0, 1236 fp_word f1) 1237 { 1238 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1239 int last_input; 1240 1241 /* Append any results to the end of the inputs */ 1242 last_input = TRACE_INPUT_IDX (data); 1243 save_data (sd, data, trace_fmt_fp, sizeof (f0), &f0); 1244 save_data (sd, data, trace_fmt_fp, sizeof (f1), &f1); 1245 1246 trace_results (sd, cpu, trace_idx, last_input); 1247 } 1248 1249 void 1250 trace_result_fpu1 (SIM_DESC sd, 1251 sim_cpu *cpu, 1252 int trace_idx, 1253 sim_fpu *f0) 1254 { 1255 double d; 1256 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1257 int last_input; 1258 1259 /* Append any results to the end of the inputs */ 1260 last_input = TRACE_INPUT_IDX (data); 1261 d = sim_fpu_2d (f0); 1262 save_data (sd, data, trace_fmt_fp, sizeof (double), &d); 1263 1264 trace_results (sd, cpu, trace_idx, last_input); 1265 } 1266 1267 void 1268 trace_result_string1 (SIM_DESC sd, 1269 sim_cpu *cpu, 1270 int trace_idx, 1271 char *s0) 1272 { 1273 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1274 int last_input; 1275 1276 /* Append any results to the end of the inputs */ 1277 last_input = TRACE_INPUT_IDX (data); 1278 save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0); 1279 1280 trace_results (sd, cpu, trace_idx, last_input); 1281 } 1282 1283 void 1284 trace_result_word1_string1 (SIM_DESC sd, 1285 sim_cpu *cpu, 1286 int trace_idx, 1287 unsigned_word r0, 1288 char *s0) 1289 { 1290 TRACE_DATA *data = CPU_TRACE_DATA (cpu); 1291 int last_input; 1292 1293 /* Append any results to the end of the inputs */ 1294 last_input = TRACE_INPUT_IDX (data); 1295 save_data (sd, data, trace_fmt_word, sizeof (unsigned_word), &r0); 1296 save_data (sd, data, trace_fmt_string, strlen (s0) + 1, s0); 1297 1298 trace_results (sd, cpu, trace_idx, last_input); 1299 } 1300 1301 void 1302 trace_vprintf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, va_list ap) 1303 { 1304 if (cpu != NULL) 1305 { 1306 if (TRACE_FILE (CPU_TRACE_DATA (cpu)) != NULL) 1307 vfprintf (TRACE_FILE (CPU_TRACE_DATA (cpu)), fmt, ap); 1308 else 1309 sim_io_evprintf (sd, fmt, ap); 1310 } 1311 else 1312 { 1313 if (TRACE_FILE (STATE_TRACE_DATA (sd)) != NULL) 1314 vfprintf (TRACE_FILE (STATE_TRACE_DATA (sd)), fmt, ap); 1315 else 1316 sim_io_evprintf (sd, fmt, ap); 1317 } 1318 } 1319 1320 void 1321 trace_printf (SIM_DESC sd, sim_cpu *cpu, const char *fmt, ...) 1322 { 1323 va_list ap; 1324 1325 va_start (ap, fmt); 1326 1327 trace_vprintf (sd, cpu, fmt, ap); 1328 1329 va_end (ap); 1330 } 1331 1332 void 1333 sim_debug_printf (sim_cpu *cpu, const char *fmt, ...) 1334 { 1335 va_list ap; 1336 1337 va_start (ap, fmt); 1338 1339 if (CPU_DEBUG_FILE (cpu) == NULL) 1340 (* STATE_CALLBACK (CPU_STATE (cpu))->evprintf_filtered) 1341 (STATE_CALLBACK (CPU_STATE (cpu)), fmt, ap); 1342 else 1343 vfprintf (CPU_DEBUG_FILE (cpu), fmt, ap); 1344 1345 va_end (ap); 1346 } 1347