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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [breakpoint.h] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Data structures associated with breakpoints in GDB.
2
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3
   2002, 2003, 2004, 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
#if !defined (BREAKPOINT_H)
21
#define BREAKPOINT_H 1
22
 
23
#include "frame.h"
24
#include "value.h"
25
#include "vec.h"
26
 
27
struct value;
28
struct block;
29
 
30
/* This is the maximum number of bytes a breakpoint instruction can take.
31
   Feel free to increase it.  It's just used in a few places to size
32
   arrays that should be independent of the target architecture.  */
33
 
34
#define BREAKPOINT_MAX  16
35
 
36
 
37
/* Type of breakpoint.  */
38
/* FIXME In the future, we should fold all other breakpoint-like things into
39
   here.  This includes:
40
 
41
   * single-step (for machines where we have to simulate single stepping)
42
   (probably, though perhaps it is better for it to look as much as
43
   possible like a single-step to wait_for_inferior).  */
44
 
45
enum bptype
46
  {
47
    bp_none = 0,         /* Eventpoint has been deleted. */
48
    bp_breakpoint,              /* Normal breakpoint */
49
    bp_hardware_breakpoint,     /* Hardware assisted breakpoint */
50
    bp_until,                   /* used by until command */
51
    bp_finish,                  /* used by finish command */
52
    bp_watchpoint,              /* Watchpoint */
53
    bp_hardware_watchpoint,     /* Hardware assisted watchpoint */
54
    bp_read_watchpoint,         /* read watchpoint, (hardware assisted) */
55
    bp_access_watchpoint,       /* access watchpoint, (hardware assisted) */
56
    bp_longjmp,                 /* secret breakpoint to find longjmp() */
57
    bp_longjmp_resume,          /* secret breakpoint to escape longjmp() */
58
 
59
    /* Used by wait_for_inferior for stepping over subroutine calls, for
60
       stepping over signal handlers, and for skipping prologues.  */
61
    bp_step_resume,
62
 
63
    /* Used to detect when a watchpoint expression has gone out of
64
       scope.  These breakpoints are usually not visible to the user.
65
 
66
       This breakpoint has some interesting properties:
67
 
68
       1) There's always a 1:1 mapping between watchpoints
69
       on local variables and watchpoint_scope breakpoints.
70
 
71
       2) It automatically deletes itself and the watchpoint it's
72
       associated with when hit.
73
 
74
       3) It can never be disabled.  */
75
    bp_watchpoint_scope,
76
 
77
    /* The breakpoint at the end of a call dummy.  */
78
    /* FIXME: What if the function we are calling longjmp()s out of the
79
       call, or the user gets out with the "return" command?  We currently
80
       have no way of cleaning up the breakpoint in these (obscure) situations.
81
       (Probably can solve this by noticing longjmp, "return", etc., it's
82
       similar to noticing when a watchpoint on a local variable goes out
83
       of scope (with hardware support for watchpoints)).  */
84
    bp_call_dummy,
85
 
86
    /* Some dynamic linkers (HP, maybe Solaris) can arrange for special
87
       code in the inferior to run when significant events occur in the
88
       dynamic linker (for example a library is loaded or unloaded).
89
 
90
       By placing a breakpoint in this magic code GDB will get control
91
       when these significant events occur.  GDB can then re-examine
92
       the dynamic linker's data structures to discover any newly loaded
93
       dynamic libraries.  */
94
    bp_shlib_event,
95
 
96
    /* Some multi-threaded systems can arrange for a location in the
97
       inferior to be executed when certain thread-related events occur
98
       (such as thread creation or thread death).
99
 
100
       By placing a breakpoint at one of these locations, GDB will get
101
       control when these events occur.  GDB can then update its thread
102
       lists etc.  */
103
 
104
    bp_thread_event,
105
 
106
    /* On the same principal, an overlay manager can arrange to call a
107
       magic location in the inferior whenever there is an interesting
108
       change in overlay status.  GDB can update its overlay tables
109
       and fiddle with breakpoints in overlays when this breakpoint
110
       is hit.  */
111
 
112
    bp_overlay_event,
113
 
114
    /* Master copies of longjmp breakpoints.  These are always installed
115
       as soon as an objfile containing longjmp is loaded, but they are
116
       always disabled.  While necessary, temporary clones of bp_longjmp
117
       type will be created and enabled.  */
118
 
119
    bp_longjmp_master,
120
 
121
    bp_catchpoint,
122
 
123
    bp_tracepoint,
124
    bp_fast_tracepoint,
125
 
126
    /* Event for JIT compiled code generation or deletion.  */
127
    bp_jit_event,
128
  };
129
 
130
/* States of enablement of breakpoint. */
131
 
132
enum enable_state
133
  {
134
    bp_disabled,        /* The eventpoint is inactive, and cannot trigger. */
135
    bp_enabled,         /* The eventpoint is active, and can trigger. */
136
    bp_call_disabled,   /* The eventpoint has been disabled while a call
137
                           into the inferior is "in flight", because some
138
                           eventpoints interfere with the implementation of
139
                           a call on some targets.  The eventpoint will be
140
                           automatically enabled and reset when the call
141
                           "lands" (either completes, or stops at another
142
                           eventpoint). */
143
    bp_startup_disabled,/* The eventpoint has been disabled during inferior
144
                           startup.  This is necessary on some targets where
145
                           the main executable will get relocated during
146
                           startup, making breakpoint addresses invalid.
147
                           The eventpoint will be automatically enabled and
148
                           reset once inferior startup is complete.  */
149
    bp_permanent        /* There is a breakpoint instruction hard-wired into
150
                           the target's code.  Don't try to write another
151
                           breakpoint instruction on top of it, or restore
152
                           its value.  Step over it using the architecture's
153
                           SKIP_INSN macro.  */
154
  };
155
 
156
 
157
/* Disposition of breakpoint.  Ie: what to do after hitting it. */
158
 
159
enum bpdisp
160
  {
161
    disp_del,                   /* Delete it */
162
    disp_del_at_next_stop,      /* Delete at next stop, whether hit or not */
163
    disp_disable,               /* Disable it */
164
    disp_donttouch              /* Leave it alone */
165
  };
166
 
167
enum target_hw_bp_type
168
  {
169
    hw_write   = 0,              /* Common  HW watchpoint */
170
    hw_read    = 1,             /* Read    HW watchpoint */
171
    hw_access  = 2,             /* Access  HW watchpoint */
172
    hw_execute = 3              /* Execute HW breakpoint */
173
  };
174
 
175
 
176
/* Information used by targets to insert and remove breakpoints.  */
177
 
178
struct bp_target_info
179
{
180
  /* Address space at which the breakpoint was placed.  */
181
  struct address_space *placed_address_space;
182
 
183
  /* Address at which the breakpoint was placed.  This is normally the
184
     same as ADDRESS from the bp_location, except when adjustment
185
     happens in gdbarch_breakpoint_from_pc.  The most common form of
186
     adjustment is stripping an alternate ISA marker from the PC which
187
     is used to determine the type of breakpoint to insert.  */
188
  CORE_ADDR placed_address;
189
 
190
  /* If the breakpoint lives in memory and reading that memory would
191
     give back the breakpoint, instead of the original contents, then
192
     the original contents are cached here.  Only SHADOW_LEN bytes of
193
     this buffer are valid, and only when the breakpoint is inserted.  */
194
  gdb_byte shadow_contents[BREAKPOINT_MAX];
195
 
196
  /* The length of the data cached in SHADOW_CONTENTS.  */
197
  int shadow_len;
198
 
199
  /* The size of the placed breakpoint, according to
200
     gdbarch_breakpoint_from_pc, when the breakpoint was inserted.  This is
201
     generally the same as SHADOW_LEN, unless we did not need
202
     to read from the target to implement the memory breakpoint
203
     (e.g. if a remote stub handled the details).  We may still
204
     need the size to remove the breakpoint safely.  */
205
  int placed_size;
206
};
207
 
208
/* GDB maintains two types of information about each breakpoint (or
209
   watchpoint, or other related event).  The first type corresponds
210
   to struct breakpoint; this is a relatively high-level structure
211
   which contains the source location(s), stopping conditions, user
212
   commands to execute when the breakpoint is hit, and so forth.
213
 
214
   The second type of information corresponds to struct bp_location.
215
   Each breakpoint has one or (eventually) more locations associated
216
   with it, which represent target-specific and machine-specific
217
   mechanisms for stopping the program.  For instance, a watchpoint
218
   expression may require multiple hardware watchpoints in order to
219
   catch all changes in the value of the expression being watched.  */
220
 
221
enum bp_loc_type
222
{
223
  bp_loc_software_breakpoint,
224
  bp_loc_hardware_breakpoint,
225
  bp_loc_hardware_watchpoint,
226
  bp_loc_other                  /* Miscellaneous...  */
227
};
228
 
229
struct bp_location
230
{
231
  /* Chain pointer to the next breakpoint location for
232
     the same parent breakpoint.  */
233
  struct bp_location *next;
234
 
235
  /* Type of this breakpoint location.  */
236
  enum bp_loc_type loc_type;
237
 
238
  /* Each breakpoint location must belong to exactly one higher-level
239
     breakpoint.  This and the DUPLICATE flag are more straightforward
240
     than reference counting.  */
241
  struct breakpoint *owner;
242
 
243
  /* Conditional.  Break only if this expression's value is nonzero.
244
     Unlike string form of condition, which is associated with breakpoint,
245
     this is associated with location, since if breakpoint has several
246
     locations,  the evaluation of expression can be different for
247
     different locations.  */
248
  struct expression *cond;
249
 
250
  /* This location's address is in an unloaded solib, and so this
251
     location should not be inserted.  It will be automatically
252
     enabled when that solib is loaded.  */
253
  char shlib_disabled;
254
 
255
  /* Is this particular location enabled.  */
256
  char enabled;
257
 
258
  /* Nonzero if this breakpoint is now inserted.  */
259
  char inserted;
260
 
261
  /* Nonzero if this is not the first breakpoint in the list
262
     for the given address.  */
263
  char duplicate;
264
 
265
  /* If we someday support real thread-specific breakpoints, then
266
     the breakpoint location will need a thread identifier.  */
267
 
268
  /* Data for specific breakpoint types.  These could be a union, but
269
     simplicity is more important than memory usage for breakpoints.  */
270
 
271
  /* Architecture associated with this location's address.  May be
272
     different from the breakpoint architecture.  */
273
  struct gdbarch *gdbarch;
274
 
275
  /* The program space associated with this breakpoint location
276
     address.  Note that an address space may be represented in more
277
     than one program space (e.g. each uClinux program will be given
278
     its own program space, but there will only be one address space
279
     for all of them), but we must not insert more than one location
280
     at the same address in the same address space.  */
281
  struct program_space *pspace;
282
 
283
  /* Note that zero is a perfectly valid code address on some platforms
284
     (for example, the mn10200 (OBSOLETE) and mn10300 simulators).  NULL
285
     is not a special value for this field.  Valid for all types except
286
     bp_loc_other.  */
287
  CORE_ADDR address;
288
 
289
  /* For hardware watchpoints, the size of data ad ADDRESS being watches.  */
290
  int length;
291
 
292
  /* Type of hardware watchpoint. */
293
  enum target_hw_bp_type watchpoint_type;
294
 
295
  /* For any breakpoint type with an address, this is the section
296
     associated with the address.  Used primarily for overlay debugging.  */
297
  struct obj_section *section;
298
 
299
  /* Address at which breakpoint was requested, either by the user or
300
     by GDB for internal breakpoints.  This will usually be the same
301
     as ``address'' (above) except for cases in which
302
     ADJUST_BREAKPOINT_ADDRESS has computed a different address at
303
     which to place the breakpoint in order to comply with a
304
     processor's architectual constraints.  */
305
  CORE_ADDR requested_address;
306
 
307
  char *function_name;
308
 
309
  /* Details of the placed breakpoint, when inserted.  */
310
  struct bp_target_info target_info;
311
 
312
  /* Similarly, for the breakpoint at an overlay's LMA, if necessary.  */
313
  struct bp_target_info overlay_target_info;
314
 
315
  /* In a non-stop mode, it's possible that we delete a breakpoint,
316
     but as we do that, some still running thread hits that breakpoint.
317
     For that reason, we need to keep locations belonging to deleted
318
     breakpoints for a bit, so that don't report unexpected SIGTRAP.
319
     We can't keep such locations forever, so we use a heuristic --
320
     after we process certain number of inferior events since
321
     breakpoint was deleted, we retire all locations of that breakpoint.
322
     This variable keeps a number of events still to go, when
323
     it becomes 0 this location is retired.  */
324
  int events_till_retirement;
325
};
326
 
327
/* This structure is a collection of function pointers that, if available,
328
   will be called instead of the performing the default action for this
329
   bptype.  */
330
 
331
struct breakpoint_ops
332
{
333
  /* Insert the breakpoint or activate the catchpoint.  Should raise
334
     an exception if the operation failed.  */
335
  void (*insert) (struct breakpoint *);
336
 
337
  /* Remove the breakpoint/catchpoint that was previously inserted
338
     with the "insert" method above.  Return non-zero if the operation
339
     succeeded.  */
340
  int (*remove) (struct breakpoint *);
341
 
342
  /* Return non-zero if the debugger should tell the user that this
343
     breakpoint was hit.  */
344
  int (*breakpoint_hit) (struct breakpoint *);
345
 
346
  /* The normal print routine for this breakpoint, called when we
347
     hit it.  */
348
  enum print_stop_action (*print_it) (struct breakpoint *);
349
 
350
  /* Display information about this breakpoint, for "info breakpoints".  */
351
  void (*print_one) (struct breakpoint *, struct bp_location **);
352
 
353
  /* Display information about this breakpoint after setting it (roughly
354
     speaking; this is called from "mention").  */
355
  void (*print_mention) (struct breakpoint *);
356
};
357
 
358
enum watchpoint_triggered
359
{
360
  /* This watchpoint definitely did not trigger.  */
361
  watch_triggered_no = 0,
362
 
363
  /* Some hardware watchpoint triggered, and it might have been this
364
     one, but we do not know which it was.  */
365
  watch_triggered_unknown,
366
 
367
  /* This hardware watchpoint definitely did trigger.  */
368
  watch_triggered_yes
369
};
370
 
371
/* This is used to declare the VEC syscalls_to_be_caught.  */
372
DEF_VEC_I(int);
373
 
374
typedef struct bp_location *bp_location_p;
375
DEF_VEC_P(bp_location_p);
376
 
377
/* Note that the ->silent field is not currently used by any commands
378
   (though the code is in there if it was to be, and set_raw_breakpoint
379
   does set it to 0).  I implemented it because I thought it would be
380
   useful for a hack I had to put in; I'm going to leave it in because
381
   I can see how there might be times when it would indeed be useful */
382
 
383
/* This is for a breakpoint or a watchpoint.  */
384
 
385
struct breakpoint
386
  {
387
    struct breakpoint *next;
388
    /* Type of breakpoint. */
389
    enum bptype type;
390
    /* Zero means disabled; remember the info but don't break here.  */
391
    enum enable_state enable_state;
392
    /* What to do with this breakpoint after we hit it. */
393
    enum bpdisp disposition;
394
    /* Number assigned to distinguish breakpoints.  */
395
    int number;
396
 
397
    /* Location(s) associated with this high-level breakpoint.  */
398
    struct bp_location *loc;
399
 
400
    /* Line number of this address.  */
401
 
402
    int line_number;
403
 
404
    /* Source file name of this address.  */
405
 
406
    char *source_file;
407
 
408
    /* Non-zero means a silent breakpoint (don't print frame info
409
       if we stop here). */
410
    unsigned char silent;
411
    /* Number of stops at this breakpoint that should
412
       be continued automatically before really stopping.  */
413
    int ignore_count;
414
    /* Chain of command lines to execute when this breakpoint is hit.  */
415
    struct command_line *commands;
416
    /* Stack depth (address of frame).  If nonzero, break only if fp
417
       equals this.  */
418
    struct frame_id frame_id;
419
 
420
    /* The program space used to set the breakpoint.  */
421
    struct program_space *pspace;
422
 
423
    /* String we used to set the breakpoint (malloc'd).  */
424
    char *addr_string;
425
    /* Architecture we used to set the breakpoint.  */
426
    struct gdbarch *gdbarch;
427
    /* Language we used to set the breakpoint.  */
428
    enum language language;
429
    /* Input radix we used to set the breakpoint.  */
430
    int input_radix;
431
    /* String form of the breakpoint condition (malloc'd), or NULL if there
432
       is no condition.  */
433
    char *cond_string;
434
    /* String form of exp (malloc'd), or NULL if none.  */
435
    char *exp_string;
436
 
437
    /* The expression we are watching, or NULL if not a watchpoint.  */
438
    struct expression *exp;
439
    /* The largest block within which it is valid, or NULL if it is
440
       valid anywhere (e.g. consists just of global symbols).  */
441
    struct block *exp_valid_block;
442
    /* Value of the watchpoint the last time we checked it, or NULL
443
       when we do not know the value yet or the value was not
444
       readable.  VAL is never lazy.  */
445
    struct value *val;
446
    /* Nonzero if VAL is valid.  If VAL_VALID is set but VAL is NULL,
447
       then an error occurred reading the value.  */
448
    int val_valid;
449
 
450
    /* Holds the address of the related watchpoint_scope breakpoint
451
       when using watchpoints on local variables (might the concept
452
       of a related breakpoint be useful elsewhere, if not just call
453
       it the watchpoint_scope breakpoint or something like that. FIXME).  */
454
    struct breakpoint *related_breakpoint;
455
 
456
    /* Holds the frame address which identifies the frame this
457
       watchpoint should be evaluated in, or `null' if the watchpoint
458
       should be evaluated on the outermost frame.  */
459
    struct frame_id watchpoint_frame;
460
 
461
    /* Holds the thread which identifies the frame this watchpoint
462
       should be considered in scope for, or `null_ptid' if the
463
       watchpoint should be evaluated in all threads.  */
464
    ptid_t watchpoint_thread;
465
 
466
    /* For hardware watchpoints, the triggered status according to the
467
       hardware.  */
468
    enum watchpoint_triggered watchpoint_triggered;
469
 
470
    /* Thread number for thread-specific breakpoint, or -1 if don't care.  */
471
    int thread;
472
 
473
    /* Ada task number for task-specific breakpoint, or 0 if don't care.  */
474
    int task;
475
 
476
    /* Count of the number of times this breakpoint was taken, dumped
477
       with the info, but not used for anything else.  Useful for
478
       seeing how many times you hit a break prior to the program
479
       aborting, so you can back up to just before the abort.  */
480
    int hit_count;
481
 
482
    /* Process id of a child process whose forking triggered this
483
       catchpoint.  This field is only valid immediately after this
484
       catchpoint has triggered.  */
485
    ptid_t forked_inferior_pid;
486
 
487
    /* Filename of a program whose exec triggered this catchpoint.
488
       This field is only valid immediately after this catchpoint has
489
       triggered.  */
490
    char *exec_pathname;
491
 
492
    /* Syscall numbers used for the 'catch syscall' feature.
493
       If no syscall has been specified for filtering, its value is NULL.
494
       Otherwise, it holds a list of all syscalls to be caught.
495
       The list elements are allocated with xmalloc.  */
496
    VEC(int) *syscalls_to_be_caught;
497
 
498
    /* Methods associated with this breakpoint.  */
499
    struct breakpoint_ops *ops;
500
 
501
    /* Is breakpoint's condition not yet parsed because we found
502
       no location initially so had no context to parse
503
       the condition in.  */
504
    int condition_not_parsed;
505
 
506
    /* Number of times this tracepoint should single-step
507
       and collect additional data.  */
508
    long step_count;
509
 
510
    /* Number of times this tracepoint should be hit before
511
       disabling/ending.  */
512
    int pass_count;
513
 
514
    /* Chain of action lines to execute when this tracepoint is hit.  */
515
    struct action_line *actions;
516
 
517
    /* The number of the tracepoint on the target.  */
518
    int number_on_target;
519
  };
520
 
521
typedef struct breakpoint *breakpoint_p;
522
DEF_VEC_P(breakpoint_p);
523
 
524
/* The following stuff is an abstract data type "bpstat" ("breakpoint
525
   status").  This provides the ability to determine whether we have
526
   stopped at a breakpoint, and what we should do about it.  */
527
 
528
typedef struct bpstats *bpstat;
529
 
530
/* Frees any storage that is part of a bpstat.
531
   Does not walk the 'next' chain.  */
532
extern void bpstat_free (bpstat);
533
 
534
/* Clears a chain of bpstat, freeing storage
535
   of each.  */
536
extern void bpstat_clear (bpstat *);
537
 
538
/* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
539
   is part of the bpstat is copied as well.  */
540
extern bpstat bpstat_copy (bpstat);
541
 
542
extern bpstat bpstat_stop_status (struct address_space *aspace,
543
                                  CORE_ADDR pc, ptid_t ptid);
544
 
545
/* This bpstat_what stuff tells wait_for_inferior what to do with a
546
   breakpoint (a challenging task).  */
547
 
548
enum bpstat_what_main_action
549
  {
550
    /* Perform various other tests; that is, this bpstat does not
551
       say to perform any action (e.g. failed watchpoint and nothing
552
       else).  */
553
    BPSTAT_WHAT_KEEP_CHECKING,
554
 
555
    /* Rather than distinguish between noisy and silent stops here, it
556
       might be cleaner to have bpstat_print make that decision (also
557
       taking into account stop_print_frame and source_only).  But the
558
       implications are a bit scary (interaction with auto-displays, etc.),
559
       so I won't try it.  */
560
 
561
    /* Stop silently.  */
562
    BPSTAT_WHAT_STOP_SILENT,
563
 
564
    /* Stop and print.  */
565
    BPSTAT_WHAT_STOP_NOISY,
566
 
567
    /* Remove breakpoints, single step once, then put them back in and
568
       go back to what we were doing.  It's possible that this should be
569
       removed from the main_action and put into a separate field, to more
570
       cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE.  */
571
    BPSTAT_WHAT_SINGLE,
572
 
573
    /* Set longjmp_resume breakpoint, remove all other breakpoints,
574
       and continue.  The "remove all other breakpoints" part is required
575
       if we are also stepping over another breakpoint as well as doing
576
       the longjmp handling.  */
577
    BPSTAT_WHAT_SET_LONGJMP_RESUME,
578
 
579
    /* Clear longjmp_resume breakpoint, then handle as
580
       BPSTAT_WHAT_KEEP_CHECKING.  */
581
    BPSTAT_WHAT_CLEAR_LONGJMP_RESUME,
582
 
583
    /* Clear step resume breakpoint, and keep checking.  */
584
    BPSTAT_WHAT_STEP_RESUME,
585
 
586
    /* Check the dynamic linker's data structures for new libraries, then
587
       keep checking.  */
588
    BPSTAT_WHAT_CHECK_SHLIBS,
589
 
590
    /* Check for new JITed code.  */
591
    BPSTAT_WHAT_CHECK_JIT,
592
 
593
    /* This is just used to keep track of how many enums there are.  */
594
    BPSTAT_WHAT_LAST
595
  };
596
 
597
struct bpstat_what
598
  {
599
    enum bpstat_what_main_action main_action;
600
 
601
    /* Did we hit a call dummy breakpoint?  This only goes with a main_action
602
       of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
603
       continuing from a call dummy without popping the frame is not a
604
       useful one).  */
605
    int call_dummy;
606
  };
607
 
608
/* The possible return values for print_bpstat, print_it_normal,
609
   print_it_done, print_it_noop. */
610
enum print_stop_action
611
  {
612
    PRINT_UNKNOWN = -1,
613
    PRINT_SRC_AND_LOC,
614
    PRINT_SRC_ONLY,
615
    PRINT_NOTHING
616
  };
617
 
618
/* Tell what to do about this bpstat.  */
619
struct bpstat_what bpstat_what (bpstat);
620
 
621
/* Find the bpstat associated with a breakpoint.  NULL otherwise. */
622
bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
623
 
624
/* Find a step_resume breakpoint associated with this bpstat.
625
   (If there are multiple step_resume bp's on the list, this function
626
   will arbitrarily pick one.)
627
 
628
   It is an error to use this function if BPSTAT doesn't contain a
629
   step_resume breakpoint.
630
 
631
   See wait_for_inferior's use of this function.
632
 */
633
extern struct breakpoint *bpstat_find_step_resume_breakpoint (bpstat);
634
 
635
/* Nonzero if a signal that we got in wait() was due to circumstances
636
   explained by the BS.  */
637
/* Currently that is true if we have hit a breakpoint, or if there is
638
   a watchpoint enabled.  */
639
#define bpstat_explains_signal(bs) ((bs) != NULL)
640
 
641
/* Nonzero is this bpstat causes a stop.  */
642
extern int bpstat_causes_stop (bpstat);
643
 
644
/* Nonzero if we should step constantly (e.g. watchpoints on machines
645
   without hardware support).  This isn't related to a specific bpstat,
646
   just to things like whether watchpoints are set.  */
647
extern int bpstat_should_step (void);
648
 
649
/* Print a message indicating what happened.  Returns nonzero to
650
   say that only the source line should be printed after this (zero
651
   return means print the frame as well as the source line).  */
652
extern enum print_stop_action bpstat_print (bpstat);
653
 
654
/* Put in *NUM the breakpoint number of the first breakpoint we are stopped
655
   at.  *BSP upon return is a bpstat which points to the remaining
656
   breakpoints stopped at (but which is not guaranteed to be good for
657
   anything but further calls to bpstat_num).
658
   Return 0 if passed a bpstat which does not indicate any breakpoints.
659
   Return -1 if stopped at a breakpoint that has been deleted since
660
   we set it.
661
   Return 1 otherwise.  */
662
extern int bpstat_num (bpstat *, int *);
663
 
664
/* Perform actions associated with the stopped inferior.  Actually, we
665
   just use this for breakpoint commands.  Perhaps other actions will
666
   go here later, but this is executed at a late time (from the
667
   command loop).  */
668
extern void bpstat_do_actions (void);
669
 
670
/* Modify BS so that the actions will not be performed.  */
671
extern void bpstat_clear_actions (bpstat);
672
 
673
/* Implementation:  */
674
 
675
/* Values used to tell the printing routine how to behave for this bpstat. */
676
enum bp_print_how
677
  {
678
    /* This is used when we want to do a normal printing of the reason
679
       for stopping. The output will depend on the type of eventpoint
680
       we are dealing with. This is the default value, most commonly
681
       used. */
682
    print_it_normal,
683
    /* This is used when nothing should be printed for this bpstat entry.  */
684
    print_it_noop,
685
    /* This is used when everything which needs to be printed has
686
       already been printed.  But we still want to print the frame.  */
687
    print_it_done
688
  };
689
 
690
struct bpstats
691
  {
692
    /* Linked list because there can be two breakpoints at the same
693
       place, and a bpstat reflects the fact that both have been hit.  */
694
    bpstat next;
695
    /* Breakpoint that we are at.  */
696
    const struct bp_location *breakpoint_at;
697
    /* Commands left to be done.  */
698
    struct command_line *commands;
699
    /* Old value associated with a watchpoint.  */
700
    struct value *old_val;
701
 
702
    /* Nonzero if this breakpoint tells us to print the frame.  */
703
    char print;
704
 
705
    /* Nonzero if this breakpoint tells us to stop.  */
706
    char stop;
707
 
708
    /* Tell bpstat_print and print_bp_stop_message how to print stuff
709
       associated with this element of the bpstat chain.  */
710
    enum bp_print_how print_it;
711
  };
712
 
713
enum inf_context
714
  {
715
    inf_starting,
716
    inf_running,
717
    inf_exited,
718
    inf_execd
719
  };
720
 
721
/* The possible return values for breakpoint_here_p.
722
   We guarantee that zero always means "no breakpoint here".  */
723
enum breakpoint_here
724
  {
725
    no_breakpoint_here = 0,
726
    ordinary_breakpoint_here,
727
    permanent_breakpoint_here
728
  };
729
 
730
 
731
/* Prototypes for breakpoint-related functions.  */
732
 
733
extern enum breakpoint_here breakpoint_here_p (struct address_space *, CORE_ADDR);
734
 
735
extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
736
 
737
extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
738
 
739
extern int regular_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
740
 
741
extern int software_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
742
 
743
/* Returns true if there's a hardware watchpoint or access watchpoint
744
   inserted in the range defined by ADDR and LEN.  */
745
extern int hardware_watchpoint_inserted_in_range (struct address_space *,
746
                                                  CORE_ADDR addr,
747
                                                  ULONGEST len);
748
 
749
extern int breakpoint_thread_match (struct address_space *, CORE_ADDR, ptid_t);
750
 
751
extern void until_break_command (char *, int, int);
752
 
753
extern void breakpoint_re_set (void);
754
 
755
extern void breakpoint_re_set_thread (struct breakpoint *);
756
 
757
extern struct breakpoint *set_momentary_breakpoint
758
  (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
759
 
760
extern struct breakpoint *set_momentary_breakpoint_at_pc
761
  (struct gdbarch *, CORE_ADDR pc, enum bptype type);
762
 
763
extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
764
 
765
extern void set_ignore_count (int, int, int);
766
 
767
extern void set_default_breakpoint (int, struct program_space *,
768
                                    CORE_ADDR, struct symtab *, int);
769
 
770
extern void breakpoint_init_inferior (enum inf_context);
771
 
772
extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
773
 
774
extern void delete_breakpoint (struct breakpoint *);
775
 
776
extern void breakpoint_auto_delete (bpstat);
777
 
778
extern void break_command (char *, int);
779
 
780
extern void hbreak_command_wrapper (char *, int);
781
extern void thbreak_command_wrapper (char *, int);
782
extern void rbreak_command_wrapper (char *, int);
783
extern void watch_command_wrapper (char *, int);
784
extern void awatch_command_wrapper (char *, int);
785
extern void rwatch_command_wrapper (char *, int);
786
extern void tbreak_command (char *, int);
787
 
788
extern void set_breakpoint (struct gdbarch *gdbarch,
789
                            char *address, char *condition,
790
                            int hardwareflag, int tempflag,
791
                            int thread, int ignore_count,
792
                            int pending,
793
                            int enabled);
794
 
795
extern void insert_breakpoints (void);
796
 
797
extern int remove_breakpoints (void);
798
 
799
extern int remove_breakpoints_pid (int pid);
800
 
801
/* This function can be used to physically insert eventpoints from the
802
   specified traced inferior process, without modifying the breakpoint
803
   package's state.  This can be useful for those targets which support
804
   following the processes of a fork() or vfork() system call, when both
805
   of the resulting two processes are to be followed.  */
806
extern int reattach_breakpoints (int);
807
 
808
/* This function can be used to update the breakpoint package's state
809
   after an exec() system call has been executed.
810
 
811
   This function causes the following:
812
 
813
   - All eventpoints are marked "not inserted".
814
   - All eventpoints with a symbolic address are reset such that
815
   the symbolic address must be reevaluated before the eventpoints
816
   can be reinserted.
817
   - The solib breakpoints are explicitly removed from the breakpoint
818
   list.
819
   - A step-resume breakpoint, if any, is explicitly removed from the
820
   breakpoint list.
821
   - All eventpoints without a symbolic address are removed from the
822
   breakpoint list. */
823
extern void update_breakpoints_after_exec (void);
824
 
825
/* This function can be used to physically remove hardware breakpoints
826
   and watchpoints from the specified traced inferior process, without
827
   modifying the breakpoint package's state.  This can be useful for
828
   those targets which support following the processes of a fork() or
829
   vfork() system call, when one of the resulting two processes is to
830
   be detached and allowed to run free.
831
 
832
   It is an error to use this function on the process whose id is
833
   inferior_ptid.  */
834
extern int detach_breakpoints (int);
835
 
836
/* This function is called when program space PSPACE is about to be
837
   deleted.  It takes care of updating breakpoints to not reference
838
   this PSPACE anymore.  */
839
extern void breakpoint_program_space_exit (struct program_space *pspace);
840
 
841
extern void set_longjmp_breakpoint (int thread);
842
extern void delete_longjmp_breakpoint (int thread);
843
 
844
extern void enable_overlay_breakpoints (void);
845
extern void disable_overlay_breakpoints (void);
846
 
847
/* These functions respectively disable or reenable all currently
848
   enabled watchpoints.  When disabled, the watchpoints are marked
849
   call_disabled.  When reenabled, they are marked enabled.
850
 
851
   The intended client of these functions is call_function_by_hand.
852
 
853
   The inferior must be stopped, and all breakpoints removed, when
854
   these functions are used.
855
 
856
   The need for these functions is that on some targets (e.g., HP-UX),
857
   gdb is unable to unwind through the dummy frame that is pushed as
858
   part of the implementation of a call command.  Watchpoints can
859
   cause the inferior to stop in places where this frame is visible,
860
   and that can cause execution control to become very confused.
861
 
862
   Note that if a user sets breakpoints in an interactively called
863
   function, the call_disabled watchpoints will have been reenabled
864
   when the first such breakpoint is reached.  However, on targets
865
   that are unable to unwind through the call dummy frame, watches
866
   of stack-based storage may then be deleted, because gdb will
867
   believe that their watched storage is out of scope.  (Sigh.) */
868
extern void disable_watchpoints_before_interactive_call_start (void);
869
 
870
extern void enable_watchpoints_after_interactive_call_stop (void);
871
 
872
/* These functions disable and re-enable all breakpoints during
873
   inferior startup.  They are intended to be called from solib
874
   code where necessary.  This is needed on platforms where the
875
   main executable is relocated at some point during startup
876
   processing, making breakpoint addresses invalid.
877
 
878
   If additional breakpoints are created after the routine
879
   disable_breakpoints_before_startup but before the routine
880
   enable_breakpoints_after_startup was called, they will also
881
   be marked as disabled.  */
882
extern void disable_breakpoints_before_startup (void);
883
extern void enable_breakpoints_after_startup (void);
884
 
885
/* For script interpreters that need to define breakpoint commands
886
   after they've already read the commands into a struct command_line.  */
887
extern enum command_control_type commands_from_control_command
888
  (char *arg, struct command_line *cmd);
889
 
890
extern void clear_breakpoint_hit_counts (void);
891
 
892
extern int get_number (char **);
893
 
894
extern int get_number_or_range (char **);
895
 
896
extern struct breakpoint *get_breakpoint (int num);
897
 
898
/* The following are for displays, which aren't really breakpoints, but
899
   here is as good a place as any for them.  */
900
 
901
extern void disable_current_display (void);
902
 
903
extern void do_displays (void);
904
 
905
extern void disable_display (int);
906
 
907
extern void clear_displays (void);
908
 
909
extern void disable_breakpoint (struct breakpoint *);
910
 
911
extern void enable_breakpoint (struct breakpoint *);
912
 
913
extern void breakpoint_set_commands (struct breakpoint *b,
914
                                     struct command_line *commands);
915
 
916
/* Clear the "inserted" flag in all breakpoints.  */
917
extern void mark_breakpoints_out (void);
918
 
919
extern void make_breakpoint_permanent (struct breakpoint *);
920
 
921
extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
922
                                                       CORE_ADDR);
923
 
924
extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
925
                                                         CORE_ADDR);
926
 
927
extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
928
                                                          CORE_ADDR);
929
 
930
extern void remove_solib_event_breakpoints (void);
931
 
932
extern void remove_thread_event_breakpoints (void);
933
 
934
extern void disable_breakpoints_in_shlibs (void);
935
 
936
/* This function returns TRUE if ep is a catchpoint. */
937
extern int ep_is_catchpoint (struct breakpoint *);
938
 
939
/* Enable breakpoints and delete when hit.  Called with ARG == NULL
940
   deletes all breakpoints. */
941
extern void delete_command (char *arg, int from_tty);
942
 
943
/* Pull all H/W watchpoints from the target. Return non-zero if the
944
   remove fails. */
945
extern int remove_hw_watchpoints (void);
946
 
947
/* Manage a software single step breakpoint (or two).  Insert may be called
948
   twice before remove is called.  */
949
extern void insert_single_step_breakpoint (struct gdbarch *,
950
                                           struct address_space *, CORE_ADDR);
951
extern void remove_single_step_breakpoints (void);
952
 
953
/* Manage manual breakpoints, separate from the normal chain of
954
   breakpoints.  These functions are used in murky target-specific
955
   ways.  Please do not add more uses!  */
956
extern void *deprecated_insert_raw_breakpoint (struct gdbarch *,
957
                                               struct address_space *, CORE_ADDR);
958
extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *);
959
 
960
/* Check if any hardware watchpoints have triggered, according to the
961
   target.  */
962
int watchpoints_triggered (struct target_waitstatus *);
963
 
964
/* Update BUF, which is LEN bytes read from the target address MEMADDR,
965
   by replacing any memory breakpoints with their shadowed contents.  */
966
void breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr,
967
                                 LONGEST len);
968
 
969
extern int breakpoints_always_inserted_mode (void);
970
 
971
/* Called each time new event from target is processed.
972
   Retires previously deleted breakpoint locations that
973
   in our opinion won't ever trigger.  */
974
extern void breakpoint_retire_moribund (void);
975
 
976
/* Checks if we are catching syscalls or not.
977
   Returns 0 if not, greater than 0 if we are.  */
978
extern int catch_syscall_enabled (void);
979
 
980
/* Checks if we are catching syscalls with the specific
981
   syscall_number.  Used for "filtering" the catchpoints.
982
   Returns 0 if not, greater than 0 if we are.  */
983
extern int catching_syscall_number (int syscall_number);
984
 
985
/* Tell a breakpoint to be quiet.  */
986
extern void make_breakpoint_silent (struct breakpoint *);
987
 
988
/* Return a tracepoint with the given number if found.  */
989
extern struct breakpoint *get_tracepoint (int num);
990
 
991
extern struct breakpoint *get_tracepoint_by_number_on_target (int num);
992
 
993
/* Find a tracepoint by parsing a number in the supplied string.  */
994
extern struct breakpoint *get_tracepoint_by_number (char **arg, int multi_p,
995
                                                    int optional_p);
996
 
997
/* Return a vector of all tracepoints currently defined.  The vector
998
   is newly allocated; the caller should free when done with it.  */
999
extern VEC(breakpoint_p) *all_tracepoints (void);
1000
 
1001
#endif /* !defined (BREAKPOINT_H) */

powered by: WebSVN 2.1.0

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