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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [annotate.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Annotation routines for GDB.
2
   Copyright (C) 1986, 1989, 1990, 1991, 1992, 1994, 1995, 1996, 1998, 1999,
3
   2000, 2007, 2008 Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
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 "defs.h"
21
#include "annotate.h"
22
#include "value.h"
23
#include "target.h"
24
#include "gdbtypes.h"
25
#include "breakpoint.h"
26
 
27
 
28
/* Prototypes for local functions. */
29
 
30
extern void _initialize_annotate (void);
31
 
32
static void print_value_flags (struct type *);
33
 
34
static void breakpoint_changed (struct breakpoint *);
35
 
36
void (*deprecated_annotate_starting_hook) (void);
37
void (*deprecated_annotate_stopped_hook) (void);
38
void (*deprecated_annotate_signalled_hook) (void);
39
void (*deprecated_annotate_signal_hook) (void);
40
void (*deprecated_annotate_exited_hook) (void);
41
 
42
static int ignore_count_changed = 0;
43
 
44
static void
45
print_value_flags (struct type *t)
46
{
47
  if (can_dereference (t))
48
    printf_filtered (("*"));
49
  else
50
    printf_filtered (("-"));
51
}
52
 
53
void
54
breakpoints_changed (void)
55
{
56
  if (annotation_level == 2)
57
    {
58
      target_terminal_ours ();
59
      printf_unfiltered (("\n\032\032breakpoints-invalid\n"));
60
      if (ignore_count_changed)
61
        ignore_count_changed = 0;        /* Avoid multiple break annotations. */
62
    }
63
}
64
 
65
/* The GUI needs to be informed of ignore_count changes, but we don't
66
   want to provide successive multiple breakpoints-invalid messages
67
   that are all caused by the fact that the ignore count is changing
68
   (which could keep the GUI very busy).  One is enough, after the
69
   target actually "stops". */
70
 
71
void
72
annotate_ignore_count_change (void)
73
{
74
  if (annotation_level > 1)
75
    ignore_count_changed = 1;
76
}
77
 
78
void
79
annotate_breakpoint (int num)
80
{
81
  if (annotation_level > 1)
82
    printf_filtered (("\n\032\032breakpoint %d\n"), num);
83
}
84
 
85
void
86
annotate_catchpoint (int num)
87
{
88
  if (annotation_level > 1)
89
    printf_filtered (("\n\032\032catchpoint %d\n"), num);
90
}
91
 
92
void
93
annotate_watchpoint (int num)
94
{
95
  if (annotation_level > 1)
96
    printf_filtered (("\n\032\032watchpoint %d\n"), num);
97
}
98
 
99
void
100
annotate_starting (void)
101
{
102
 
103
  if (deprecated_annotate_starting_hook)
104
    deprecated_annotate_starting_hook ();
105
  else
106
    {
107
      if (annotation_level > 1)
108
        {
109
          printf_filtered (("\n\032\032starting\n"));
110
        }
111
    }
112
}
113
 
114
void
115
annotate_stopped (void)
116
{
117
  if (deprecated_annotate_stopped_hook)
118
    deprecated_annotate_stopped_hook ();
119
  else
120
    {
121
      if (annotation_level > 1)
122
        printf_filtered (("\n\032\032stopped\n"));
123
    }
124
  if (annotation_level > 1 && ignore_count_changed)
125
    {
126
      ignore_count_changed = 0;
127
      breakpoints_changed ();
128
    }
129
}
130
 
131
void
132
annotate_exited (int exitstatus)
133
{
134
  if (deprecated_annotate_exited_hook)
135
    deprecated_annotate_exited_hook ();
136
  else
137
    {
138
      if (annotation_level > 1)
139
        printf_filtered (("\n\032\032exited %d\n"), exitstatus);
140
    }
141
}
142
 
143
void
144
annotate_signalled (void)
145
{
146
  if (deprecated_annotate_signalled_hook)
147
    deprecated_annotate_signalled_hook ();
148
 
149
  if (annotation_level > 1)
150
    printf_filtered (("\n\032\032signalled\n"));
151
}
152
 
153
void
154
annotate_signal_name (void)
155
{
156
  if (annotation_level == 2)
157
    printf_filtered (("\n\032\032signal-name\n"));
158
}
159
 
160
void
161
annotate_signal_name_end (void)
162
{
163
  if (annotation_level == 2)
164
    printf_filtered (("\n\032\032signal-name-end\n"));
165
}
166
 
167
void
168
annotate_signal_string (void)
169
{
170
  if (annotation_level == 2)
171
    printf_filtered (("\n\032\032signal-string\n"));
172
}
173
 
174
void
175
annotate_signal_string_end (void)
176
{
177
  if (annotation_level == 2)
178
    printf_filtered (("\n\032\032signal-string-end\n"));
179
}
180
 
181
void
182
annotate_signal (void)
183
{
184
  if (deprecated_annotate_signal_hook)
185
    deprecated_annotate_signal_hook ();
186
 
187
  if (annotation_level > 1)
188
    printf_filtered (("\n\032\032signal\n"));
189
}
190
 
191
void
192
annotate_breakpoints_headers (void)
193
{
194
  if (annotation_level == 2)
195
    printf_filtered (("\n\032\032breakpoints-headers\n"));
196
}
197
 
198
void
199
annotate_field (int num)
200
{
201
  if (annotation_level == 2)
202
    printf_filtered (("\n\032\032field %d\n"), num);
203
}
204
 
205
void
206
annotate_breakpoints_table (void)
207
{
208
  if (annotation_level == 2)
209
    printf_filtered (("\n\032\032breakpoints-table\n"));
210
}
211
 
212
void
213
annotate_record (void)
214
{
215
  if (annotation_level == 2)
216
    printf_filtered (("\n\032\032record\n"));
217
}
218
 
219
void
220
annotate_breakpoints_table_end (void)
221
{
222
  if (annotation_level == 2)
223
    printf_filtered (("\n\032\032breakpoints-table-end\n"));
224
}
225
 
226
void
227
annotate_frames_invalid (void)
228
{
229
  if (annotation_level == 2)
230
    {
231
      target_terminal_ours ();
232
      printf_unfiltered (("\n\032\032frames-invalid\n"));
233
    }
234
}
235
 
236
void
237
annotate_field_begin (struct type *type)
238
{
239
  if (annotation_level == 2)
240
    {
241
      printf_filtered (("\n\032\032field-begin "));
242
      print_value_flags (type);
243
      printf_filtered (("\n"));
244
    }
245
}
246
 
247
void
248
annotate_field_name_end (void)
249
{
250
  if (annotation_level == 2)
251
    printf_filtered (("\n\032\032field-name-end\n"));
252
}
253
 
254
void
255
annotate_field_value (void)
256
{
257
  if (annotation_level == 2)
258
    printf_filtered (("\n\032\032field-value\n"));
259
}
260
 
261
void
262
annotate_field_end (void)
263
{
264
  if (annotation_level == 2)
265
    printf_filtered (("\n\032\032field-end\n"));
266
}
267
 
268
void
269
annotate_quit (void)
270
{
271
  if (annotation_level > 1)
272
    printf_filtered (("\n\032\032quit\n"));
273
}
274
 
275
void
276
annotate_error (void)
277
{
278
  if (annotation_level > 1)
279
    printf_filtered (("\n\032\032error\n"));
280
}
281
 
282
void
283
annotate_error_begin (void)
284
{
285
  if (annotation_level > 1)
286
    fprintf_filtered (gdb_stderr, "\n\032\032error-begin\n");
287
}
288
 
289
void
290
annotate_value_history_begin (int histindex, struct type *type)
291
{
292
  if (annotation_level == 2)
293
    {
294
      printf_filtered (("\n\032\032value-history-begin %d "), histindex);
295
      print_value_flags (type);
296
      printf_filtered (("\n"));
297
    }
298
}
299
 
300
void
301
annotate_value_begin (struct type *type)
302
{
303
  if (annotation_level == 2)
304
    {
305
      printf_filtered (("\n\032\032value-begin "));
306
      print_value_flags (type);
307
      printf_filtered (("\n"));
308
    }
309
}
310
 
311
void
312
annotate_value_history_value (void)
313
{
314
  if (annotation_level == 2)
315
    printf_filtered (("\n\032\032value-history-value\n"));
316
}
317
 
318
void
319
annotate_value_history_end (void)
320
{
321
  if (annotation_level == 2)
322
    printf_filtered (("\n\032\032value-history-end\n"));
323
}
324
 
325
void
326
annotate_value_end (void)
327
{
328
  if (annotation_level == 2)
329
    printf_filtered (("\n\032\032value-end\n"));
330
}
331
 
332
void
333
annotate_display_begin (void)
334
{
335
  if (annotation_level == 2)
336
    printf_filtered (("\n\032\032display-begin\n"));
337
}
338
 
339
void
340
annotate_display_number_end (void)
341
{
342
  if (annotation_level == 2)
343
    printf_filtered (("\n\032\032display-number-end\n"));
344
}
345
 
346
void
347
annotate_display_format (void)
348
{
349
  if (annotation_level == 2)
350
    printf_filtered (("\n\032\032display-format\n"));
351
}
352
 
353
void
354
annotate_display_expression (void)
355
{
356
  if (annotation_level == 2)
357
    printf_filtered (("\n\032\032display-expression\n"));
358
}
359
 
360
void
361
annotate_display_expression_end (void)
362
{
363
  if (annotation_level == 2)
364
    printf_filtered (("\n\032\032display-expression-end\n"));
365
}
366
 
367
void
368
annotate_display_value (void)
369
{
370
  if (annotation_level == 2)
371
    printf_filtered (("\n\032\032display-value\n"));
372
}
373
 
374
void
375
annotate_display_end (void)
376
{
377
  if (annotation_level == 2)
378
    printf_filtered (("\n\032\032display-end\n"));
379
}
380
 
381
void
382
annotate_arg_begin (void)
383
{
384
  if (annotation_level == 2)
385
    printf_filtered (("\n\032\032arg-begin\n"));
386
}
387
 
388
void
389
annotate_arg_name_end (void)
390
{
391
  if (annotation_level == 2)
392
    printf_filtered (("\n\032\032arg-name-end\n"));
393
}
394
 
395
void
396
annotate_arg_value (struct type *type)
397
{
398
  if (annotation_level == 2)
399
    {
400
      printf_filtered (("\n\032\032arg-value "));
401
      print_value_flags (type);
402
      printf_filtered (("\n"));
403
    }
404
}
405
 
406
void
407
annotate_arg_end (void)
408
{
409
  if (annotation_level == 2)
410
    printf_filtered (("\n\032\032arg-end\n"));
411
}
412
 
413
void
414
annotate_source (char *filename, int line, int character, int mid, CORE_ADDR pc)
415
{
416
  if (annotation_level > 1)
417
    printf_filtered (("\n\032\032source "));
418
  else
419
    printf_filtered (("\032\032"));
420
 
421
  printf_filtered (("%s:%d:%d:%s:0x"), filename,
422
                   line, character,
423
                   mid ? "middle" : "beg");
424
  deprecated_print_address_numeric (pc, 0, gdb_stdout);
425
  printf_filtered (("\n"));
426
}
427
 
428
void
429
annotate_frame_begin (int level, CORE_ADDR pc)
430
{
431
  if (annotation_level > 1)
432
    {
433
      printf_filtered (("\n\032\032frame-begin %d 0x"), level);
434
      deprecated_print_address_numeric (pc, 0, gdb_stdout);
435
      printf_filtered (("\n"));
436
    }
437
}
438
 
439
void
440
annotate_function_call (void)
441
{
442
  if (annotation_level == 2)
443
    printf_filtered (("\n\032\032function-call\n"));
444
}
445
 
446
void
447
annotate_signal_handler_caller (void)
448
{
449
  if (annotation_level == 2)
450
    printf_filtered (("\n\032\032signal-handler-caller\n"));
451
}
452
 
453
void
454
annotate_frame_address (void)
455
{
456
  if (annotation_level == 2)
457
    printf_filtered (("\n\032\032frame-address\n"));
458
}
459
 
460
void
461
annotate_frame_address_end (void)
462
{
463
  if (annotation_level == 2)
464
    printf_filtered (("\n\032\032frame-address-end\n"));
465
}
466
 
467
void
468
annotate_frame_function_name (void)
469
{
470
  if (annotation_level == 2)
471
    printf_filtered (("\n\032\032frame-function-name\n"));
472
}
473
 
474
void
475
annotate_frame_args (void)
476
{
477
  if (annotation_level == 2)
478
    printf_filtered (("\n\032\032frame-args\n"));
479
}
480
 
481
void
482
annotate_frame_source_begin (void)
483
{
484
  if (annotation_level == 2)
485
    printf_filtered (("\n\032\032frame-source-begin\n"));
486
}
487
 
488
void
489
annotate_frame_source_file (void)
490
{
491
  if (annotation_level == 2)
492
    printf_filtered (("\n\032\032frame-source-file\n"));
493
}
494
 
495
void
496
annotate_frame_source_file_end (void)
497
{
498
  if (annotation_level == 2)
499
    printf_filtered (("\n\032\032frame-source-file-end\n"));
500
}
501
 
502
void
503
annotate_frame_source_line (void)
504
{
505
  if (annotation_level == 2)
506
    printf_filtered (("\n\032\032frame-source-line\n"));
507
}
508
 
509
void
510
annotate_frame_source_end (void)
511
{
512
  if (annotation_level == 2)
513
    printf_filtered (("\n\032\032frame-source-end\n"));
514
}
515
 
516
void
517
annotate_frame_where (void)
518
{
519
  if (annotation_level == 2)
520
    printf_filtered (("\n\032\032frame-where\n"));
521
}
522
 
523
void
524
annotate_frame_end (void)
525
{
526
  if (annotation_level == 2)
527
    printf_filtered (("\n\032\032frame-end\n"));
528
}
529
 
530
void
531
annotate_array_section_begin (int index, struct type *elttype)
532
{
533
  if (annotation_level == 2)
534
    {
535
      printf_filtered (("\n\032\032array-section-begin %d "), index);
536
      print_value_flags (elttype);
537
      printf_filtered (("\n"));
538
    }
539
}
540
 
541
void
542
annotate_elt_rep (unsigned int repcount)
543
{
544
  if (annotation_level == 2)
545
    printf_filtered (("\n\032\032elt-rep %u\n"), repcount);
546
}
547
 
548
void
549
annotate_elt_rep_end (void)
550
{
551
  if (annotation_level == 2)
552
    printf_filtered (("\n\032\032elt-rep-end\n"));
553
}
554
 
555
void
556
annotate_elt (void)
557
{
558
  if (annotation_level == 2)
559
    printf_filtered (("\n\032\032elt\n"));
560
}
561
 
562
void
563
annotate_array_section_end (void)
564
{
565
  if (annotation_level == 2)
566
    printf_filtered (("\n\032\032array-section-end\n"));
567
}
568
 
569
static void
570
breakpoint_changed (struct breakpoint *b)
571
{
572
  breakpoints_changed ();
573
}
574
 
575
void
576
_initialize_annotate (void)
577
{
578
  if (annotation_level == 2)
579
    {
580
      deprecated_delete_breakpoint_hook = breakpoint_changed;
581
      deprecated_modify_breakpoint_hook = breakpoint_changed;
582
    }
583
}

powered by: WebSVN 2.1.0

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