OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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