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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [annotate.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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