OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [sim/] [common/] [sim-profile.c] - Blame information for rev 816

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.