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