1 /* Memory breakpoint operations for the remote server for GDB.
2 Copyright (C) 2002-2015 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
6 This file is part of GDB.
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.
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.
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/>. */
25 #define MAX_BREAKPOINT_LEN 8
27 /* Helper macro used in loops that append multiple items to a singly-linked
28 list instead of inserting items at the head of the list, as, say, in the
29 breakpoint lists. LISTPP is a pointer to the pointer that is the head of
30 the new list. ITEMP is a pointer to the item to be added to the list.
31 TAILP must be defined to be the same type as ITEMP, and initialized to
34 #define APPEND_TO_LIST(listpp, itemp, tailp) \
37 if ((tailp) == NULL) \
38 *(listpp) = (itemp); \
40 (tailp)->next = (itemp); \
45 /* GDB will never try to install multiple breakpoints at the same
46 address. However, we can see GDB requesting to insert a breakpoint
47 at an address is had already inserted one previously in a few
50 - The RSP documentation on Z packets says that to avoid potential
51 problems with duplicate packets, the operations should be
52 implemented in an idempotent way.
54 - A breakpoint is set at ADDR, an address in a shared library.
55 Then the shared library is unloaded. And then another, unrelated,
56 breakpoint at ADDR is set. There is not breakpoint removal request
57 between the first and the second breakpoint.
59 - When GDB wants to update the target-side breakpoint conditions or
60 commands, it re-inserts the breakpoint, with updated
61 conditions/commands associated.
63 Also, we need to keep track of internal breakpoints too, so we do
64 need to be able to install multiple breakpoints at the same address
67 We keep track of two different, and closely related structures. A
68 raw breakpoint, which manages the low level, close to the metal
69 aspect of a breakpoint. It holds the breakpoint address, and for
70 software breakpoints, a buffer holding a copy of the instructions
71 that would be in memory had not been a breakpoint there (we call
72 that the shadow memory of the breakpoint). We occasionally need to
73 temporarilly uninsert a breakpoint without the client knowing about
74 it (e.g., to step over an internal breakpoint), so we keep an
75 `inserted' state associated with this low level breakpoint
76 structure. There can only be one such object for a given address.
77 Then, we have (a bit higher level) breakpoints. This structure
78 holds a callback to be called whenever a breakpoint is hit, a
79 high-level type, and a link to a low level raw breakpoint. There
80 can be many high-level breakpoints at the same address, and all of
81 them will point to the same raw breakpoint, which is reference
84 /* The low level, physical, raw breakpoint. */
87 struct raw_breakpoint
*next
;
89 /* The low level type of the breakpoint (software breakpoint,
91 enum raw_bkpt_type raw_type
;
93 /* A reference count. Each high level breakpoint referencing this
94 raw breakpoint accounts for one reference. */
97 /* The breakpoint's insertion address. There can only be one raw
98 breakpoint for a given PC. */
101 /* The breakpoint's kind. This is target specific. Most
102 architectures only use one specific instruction for breakpoints, while
103 others may use more than one. E.g., on ARM, we need to use different
104 breakpoint instructions on Thumb, Thumb-2, and ARM code. Likewise for
105 hardware breakpoints -- some architectures (including ARM) need to
106 setup debug registers differently depending on mode. */
109 /* The breakpoint's shadow memory. */
110 unsigned char old_data
[MAX_BREAKPOINT_LEN
];
112 /* Positive if this breakpoint is currently inserted in the
113 inferior. Negative if it was, but we've detected that it's now
114 gone. Zero if not inserted. */
118 /* The type of a breakpoint. */
121 /* A GDB breakpoint, requested with a Z0 packet. */
124 /* A GDB hardware breakpoint, requested with a Z1 packet. */
127 /* A GDB write watchpoint, requested with a Z2 packet. */
130 /* A GDB read watchpoint, requested with a Z3 packet. */
133 /* A GDB access watchpoint, requested with a Z4 packet. */
136 /* A basic-software-single-step breakpoint. */
139 /* Any other breakpoint type that doesn't require specific
140 treatment goes here. E.g., an event breakpoint. */
144 struct point_cond_list
146 /* Pointer to the agent expression that is the breakpoint's
148 struct agent_expr
*cond
;
150 /* Pointer to the next condition. */
151 struct point_cond_list
*next
;
154 struct point_command_list
156 /* Pointer to the agent expression that is the breakpoint's
158 struct agent_expr
*cmd
;
160 /* Flag that is true if this command should run even while GDB is
164 /* Pointer to the next command. */
165 struct point_command_list
*next
;
168 /* A high level (in gdbserver's perspective) breakpoint. */
171 struct breakpoint
*next
;
173 /* The breakpoint's type. */
176 /* Pointer to the condition list that should be evaluated on
177 the target or NULL if the breakpoint is unconditional or
178 if GDB doesn't want us to evaluate the conditionals on the
180 struct point_cond_list
*cond_list
;
182 /* Point to the list of commands to run when this is hit. */
183 struct point_command_list
*command_list
;
185 /* Link to this breakpoint's raw breakpoint. This is always
187 struct raw_breakpoint
*raw
;
189 /* Function to call when we hit this breakpoint. If it returns 1,
190 the breakpoint shall be deleted; 0 or if this callback is NULL,
191 it will be left inserted. */
192 int (*handler
) (CORE_ADDR
);
195 /* Return the breakpoint size from its kind. */
198 bp_size (struct raw_breakpoint
*bp
)
202 the_target
->sw_breakpoint_from_kind (bp
->kind
, &size
);
206 /* Return the breakpoint opcode from its kind. */
208 static const gdb_byte
*
209 bp_opcode (struct raw_breakpoint
*bp
)
213 return the_target
->sw_breakpoint_from_kind (bp
->kind
, &size
);
216 /* See mem-break.h. */
218 enum target_hw_bp_type
219 raw_bkpt_type_to_target_hw_bp_type (enum raw_bkpt_type raw_type
)
223 case raw_bkpt_type_hw
:
225 case raw_bkpt_type_write_wp
:
227 case raw_bkpt_type_read_wp
:
229 case raw_bkpt_type_access_wp
:
232 internal_error (__FILE__
, __LINE__
,
233 "bad raw breakpoint type %d", (int) raw_type
);
237 /* See mem-break.h. */
239 static enum bkpt_type
240 Z_packet_to_bkpt_type (char z_type
)
242 gdb_assert ('0' <= z_type
&& z_type
<= '4');
244 return gdb_breakpoint_Z0
+ (z_type
- '0');
247 /* See mem-break.h. */
250 Z_packet_to_raw_bkpt_type (char z_type
)
255 return raw_bkpt_type_sw
;
257 return raw_bkpt_type_hw
;
258 case Z_PACKET_WRITE_WP
:
259 return raw_bkpt_type_write_wp
;
260 case Z_PACKET_READ_WP
:
261 return raw_bkpt_type_read_wp
;
262 case Z_PACKET_ACCESS_WP
:
263 return raw_bkpt_type_access_wp
;
265 gdb_assert_not_reached ("unhandled Z packet type.");
270 any_persistent_commands ()
272 struct process_info
*proc
= current_process ();
273 struct breakpoint
*bp
;
274 struct point_command_list
*cl
;
276 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= bp
->next
)
278 for (cl
= bp
->command_list
; cl
!= NULL
; cl
= cl
->next
)
286 /* Find low-level breakpoint of type TYPE at address ADDR that is not
287 insert-disabled. Returns NULL if not found. */
289 static struct raw_breakpoint
*
290 find_enabled_raw_code_breakpoint_at (CORE_ADDR addr
, enum raw_bkpt_type type
)
292 struct process_info
*proc
= current_process ();
293 struct raw_breakpoint
*bp
;
295 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
297 && bp
->raw_type
== type
298 && bp
->inserted
>= 0)
304 /* Find low-level breakpoint of type TYPE at address ADDR. Returns
305 NULL if not found. */
307 static struct raw_breakpoint
*
308 find_raw_breakpoint_at (CORE_ADDR addr
, enum raw_bkpt_type type
, int kind
)
310 struct process_info
*proc
= current_process ();
311 struct raw_breakpoint
*bp
;
313 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
314 if (bp
->pc
== addr
&& bp
->raw_type
== type
&& bp
->kind
== kind
)
320 /* See mem-break.h. */
323 insert_memory_breakpoint (struct raw_breakpoint
*bp
)
325 unsigned char buf
[MAX_BREAKPOINT_LEN
];
328 /* Note that there can be fast tracepoint jumps installed in the
329 same memory range, so to get at the original memory, we need to
330 use read_inferior_memory, which masks those out. */
331 err
= read_inferior_memory (bp
->pc
, buf
, bp_size (bp
));
335 debug_printf ("Failed to read shadow memory of"
336 " breakpoint at 0x%s (%s).\n",
337 paddress (bp
->pc
), strerror (err
));
341 memcpy (bp
->old_data
, buf
, bp_size (bp
));
343 err
= (*the_target
->write_memory
) (bp
->pc
, bp_opcode (bp
),
348 debug_printf ("Failed to insert breakpoint at 0x%s (%s).\n",
349 paddress (bp
->pc
), strerror (err
));
352 return err
!= 0 ? -1 : 0;
355 /* See mem-break.h */
358 remove_memory_breakpoint (struct raw_breakpoint
*bp
)
360 unsigned char buf
[MAX_BREAKPOINT_LEN
];
363 /* Since there can be trap breakpoints inserted in the same address
364 range, we use `write_inferior_memory', which takes care of
365 layering breakpoints on top of fast tracepoints, and on top of
366 the buffer we pass it. This works because the caller has already
367 either unlinked the breakpoint or marked it uninserted. Also
368 note that we need to pass the current shadow contents, because
369 write_inferior_memory updates any shadow memory with what we pass
370 here, and we want that to be a nop. */
371 memcpy (buf
, bp
->old_data
, bp_size (bp
));
372 err
= write_inferior_memory (bp
->pc
, buf
, bp_size (bp
));
376 debug_printf ("Failed to uninsert raw breakpoint "
377 "at 0x%s (%s) while deleting it.\n",
378 paddress (bp
->pc
), strerror (err
));
380 return err
!= 0 ? -1 : 0;
383 /* Set a RAW breakpoint of type TYPE and kind KIND at WHERE. On
384 success, a pointer to the new breakpoint is returned. On failure,
385 returns NULL and writes the error code to *ERR. */
387 static struct raw_breakpoint
*
388 set_raw_breakpoint_at (enum raw_bkpt_type type
, CORE_ADDR where
, int kind
,
391 struct process_info
*proc
= current_process ();
392 struct raw_breakpoint
*bp
;
394 if (type
== raw_bkpt_type_sw
|| type
== raw_bkpt_type_hw
)
396 bp
= find_enabled_raw_code_breakpoint_at (where
, type
);
397 if (bp
!= NULL
&& bp
->kind
!= kind
)
399 /* A different kind than previously seen. The previous
400 breakpoint must be gone then. */
402 debug_printf ("Inconsistent breakpoint kind? Was %d, now %d.\n",
409 bp
= find_raw_breakpoint_at (where
, type
, kind
);
417 bp
= XCNEW (struct raw_breakpoint
);
423 *err
= the_target
->insert_point (bp
->raw_type
, bp
->pc
, bp
->kind
, bp
);
427 debug_printf ("Failed to insert breakpoint at 0x%s (%d).\n",
428 paddress (where
), *err
);
434 /* Link the breakpoint in. */
435 bp
->next
= proc
->raw_breakpoints
;
436 proc
->raw_breakpoints
= bp
;
440 /* Notice that breakpoint traps are always installed on top of fast
441 tracepoint jumps. This is even if the fast tracepoint is installed
442 at a later time compared to when the breakpoint was installed.
443 This means that a stopping breakpoint or tracepoint has higher
444 "priority". In turn, this allows having fast and slow tracepoints
445 (and breakpoints) at the same address behave correctly. */
448 /* A fast tracepoint jump. */
450 struct fast_tracepoint_jump
452 struct fast_tracepoint_jump
*next
;
454 /* A reference count. GDB can install more than one fast tracepoint
455 at the same address (each with its own action list, for
459 /* The fast tracepoint's insertion address. There can only be one
460 of these for a given PC. */
463 /* Non-zero if this fast tracepoint jump is currently inserted in
467 /* The length of the jump instruction. */
470 /* A poor-man's flexible array member, holding both the jump
471 instruction to insert, and a copy of the instruction that would
472 be in memory had not been a jump there (the shadow memory of the
474 unsigned char insn_and_shadow
[0];
477 /* Fast tracepoint FP's jump instruction to insert. */
478 #define fast_tracepoint_jump_insn(fp) \
479 ((fp)->insn_and_shadow + 0)
481 /* The shadow memory of fast tracepoint jump FP. */
482 #define fast_tracepoint_jump_shadow(fp) \
483 ((fp)->insn_and_shadow + (fp)->length)
486 /* Return the fast tracepoint jump set at WHERE. */
488 static struct fast_tracepoint_jump
*
489 find_fast_tracepoint_jump_at (CORE_ADDR where
)
491 struct process_info
*proc
= current_process ();
492 struct fast_tracepoint_jump
*jp
;
494 for (jp
= proc
->fast_tracepoint_jumps
; jp
!= NULL
; jp
= jp
->next
)
502 fast_tracepoint_jump_here (CORE_ADDR where
)
504 struct fast_tracepoint_jump
*jp
= find_fast_tracepoint_jump_at (where
);
510 delete_fast_tracepoint_jump (struct fast_tracepoint_jump
*todel
)
512 struct fast_tracepoint_jump
*bp
, **bp_link
;
514 struct process_info
*proc
= current_process ();
516 bp
= proc
->fast_tracepoint_jumps
;
517 bp_link
= &proc
->fast_tracepoint_jumps
;
523 if (--bp
->refcount
== 0)
525 struct fast_tracepoint_jump
*prev_bp_link
= *bp_link
;
531 /* Since there can be breakpoints inserted in the same
532 address range, we use `write_inferior_memory', which
533 takes care of layering breakpoints on top of fast
534 tracepoints, and on top of the buffer we pass it.
535 This works because we've already unlinked the fast
536 tracepoint jump above. Also note that we need to
537 pass the current shadow contents, because
538 write_inferior_memory updates any shadow memory with
539 what we pass here, and we want that to be a nop. */
540 buf
= (unsigned char *) alloca (bp
->length
);
541 memcpy (buf
, fast_tracepoint_jump_shadow (bp
), bp
->length
);
542 ret
= write_inferior_memory (bp
->pc
, buf
, bp
->length
);
545 /* Something went wrong, relink the jump. */
546 *bp_link
= prev_bp_link
;
549 debug_printf ("Failed to uninsert fast tracepoint jump "
550 "at 0x%s (%s) while deleting it.\n",
551 paddress (bp
->pc
), strerror (ret
));
567 warning ("Could not find fast tracepoint jump in list.");
572 inc_ref_fast_tracepoint_jump (struct fast_tracepoint_jump
*jp
)
577 struct fast_tracepoint_jump
*
578 set_fast_tracepoint_jump (CORE_ADDR where
,
579 unsigned char *insn
, ULONGEST length
)
581 struct process_info
*proc
= current_process ();
582 struct fast_tracepoint_jump
*jp
;
586 /* We refcount fast tracepoint jumps. Check if we already know
587 about a jump at this address. */
588 jp
= find_fast_tracepoint_jump_at (where
);
595 /* We don't, so create a new object. Double the length, because the
596 flexible array member holds both the jump insn, and the
598 jp
= (struct fast_tracepoint_jump
*) xcalloc (1, sizeof (*jp
) + (length
* 2));
601 memcpy (fast_tracepoint_jump_insn (jp
), insn
, length
);
603 buf
= (unsigned char *) alloca (length
);
605 /* Note that there can be trap breakpoints inserted in the same
606 address range. To access the original memory contents, we use
607 `read_inferior_memory', which masks out breakpoints. */
608 err
= read_inferior_memory (where
, buf
, length
);
612 debug_printf ("Failed to read shadow memory of"
613 " fast tracepoint at 0x%s (%s).\n",
614 paddress (where
), strerror (err
));
618 memcpy (fast_tracepoint_jump_shadow (jp
), buf
, length
);
620 /* Link the jump in. */
622 jp
->next
= proc
->fast_tracepoint_jumps
;
623 proc
->fast_tracepoint_jumps
= jp
;
625 /* Since there can be trap breakpoints inserted in the same address
626 range, we use use `write_inferior_memory', which takes care of
627 layering breakpoints on top of fast tracepoints, on top of the
628 buffer we pass it. This works because we've already linked in
629 the fast tracepoint jump above. Also note that we need to pass
630 the current shadow contents, because write_inferior_memory
631 updates any shadow memory with what we pass here, and we want
633 err
= write_inferior_memory (where
, buf
, length
);
637 debug_printf ("Failed to insert fast tracepoint jump at 0x%s (%s).\n",
638 paddress (where
), strerror (err
));
641 proc
->fast_tracepoint_jumps
= jp
->next
;
651 uninsert_fast_tracepoint_jumps_at (CORE_ADDR pc
)
653 struct fast_tracepoint_jump
*jp
;
656 jp
= find_fast_tracepoint_jump_at (pc
);
659 /* This can happen when we remove all breakpoints while handling
662 debug_printf ("Could not find fast tracepoint jump at 0x%s "
663 "in list (uninserting).\n",
674 /* Since there can be trap breakpoints inserted in the same
675 address range, we use use `write_inferior_memory', which
676 takes care of layering breakpoints on top of fast
677 tracepoints, and on top of the buffer we pass it. This works
678 because we've already marked the fast tracepoint fast
679 tracepoint jump uninserted above. Also note that we need to
680 pass the current shadow contents, because
681 write_inferior_memory updates any shadow memory with what we
682 pass here, and we want that to be a nop. */
683 buf
= (unsigned char *) alloca (jp
->length
);
684 memcpy (buf
, fast_tracepoint_jump_shadow (jp
), jp
->length
);
685 err
= write_inferior_memory (jp
->pc
, buf
, jp
->length
);
691 debug_printf ("Failed to uninsert fast tracepoint jump at"
693 paddress (pc
), strerror (err
));
699 reinsert_fast_tracepoint_jumps_at (CORE_ADDR where
)
701 struct fast_tracepoint_jump
*jp
;
705 jp
= find_fast_tracepoint_jump_at (where
);
708 /* This can happen when we remove breakpoints when a tracepoint
709 hit causes a tracing stop, while handling a step-over. */
711 debug_printf ("Could not find fast tracepoint jump at 0x%s "
712 "in list (reinserting).\n",
718 error ("Jump already inserted at reinsert time.");
722 /* Since there can be trap breakpoints inserted in the same address
723 range, we use `write_inferior_memory', which takes care of
724 layering breakpoints on top of fast tracepoints, and on top of
725 the buffer we pass it. This works because we've already marked
726 the fast tracepoint jump inserted above. Also note that we need
727 to pass the current shadow contents, because
728 write_inferior_memory updates any shadow memory with what we pass
729 here, and we want that to be a nop. */
730 buf
= (unsigned char *) alloca (jp
->length
);
731 memcpy (buf
, fast_tracepoint_jump_shadow (jp
), jp
->length
);
732 err
= write_inferior_memory (where
, buf
, jp
->length
);
738 debug_printf ("Failed to reinsert fast tracepoint jump at"
740 paddress (where
), strerror (err
));
744 /* Set a high-level breakpoint of type TYPE, with low level type
745 RAW_TYPE and kind KIND, at WHERE. On success, a pointer to the new
746 breakpoint is returned. On failure, returns NULL and writes the
747 error code to *ERR. HANDLER is called when the breakpoint is hit.
748 HANDLER should return 1 if the breakpoint should be deleted, 0
751 static struct breakpoint
*
752 set_breakpoint (enum bkpt_type type
, enum raw_bkpt_type raw_type
,
753 CORE_ADDR where
, int kind
,
754 int (*handler
) (CORE_ADDR
), int *err
)
756 struct process_info
*proc
= current_process ();
757 struct breakpoint
*bp
;
758 struct raw_breakpoint
*raw
;
760 raw
= set_raw_breakpoint_at (raw_type
, where
, kind
, err
);
768 bp
= XCNEW (struct breakpoint
);
772 bp
->handler
= handler
;
774 bp
->next
= proc
->breakpoints
;
775 proc
->breakpoints
= bp
;
780 /* See mem-break.h */
783 set_breakpoint_at (CORE_ADDR where
, int (*handler
) (CORE_ADDR
))
786 CORE_ADDR placed_address
= where
;
787 int breakpoint_kind
= target_breakpoint_kind_from_pc (&placed_address
);
789 return set_breakpoint (other_breakpoint
, raw_bkpt_type_sw
,
790 placed_address
, breakpoint_kind
, handler
,
796 delete_raw_breakpoint (struct process_info
*proc
, struct raw_breakpoint
*todel
)
798 struct raw_breakpoint
*bp
, **bp_link
;
801 bp
= proc
->raw_breakpoints
;
802 bp_link
= &proc
->raw_breakpoints
;
808 if (bp
->inserted
> 0)
810 struct raw_breakpoint
*prev_bp_link
= *bp_link
;
814 ret
= the_target
->remove_point (bp
->raw_type
, bp
->pc
, bp
->kind
,
818 /* Something went wrong, relink the breakpoint. */
819 *bp_link
= prev_bp_link
;
822 debug_printf ("Failed to uninsert raw breakpoint "
823 "at 0x%s while deleting it.\n",
841 warning ("Could not find raw breakpoint in list.");
846 release_breakpoint (struct process_info
*proc
, struct breakpoint
*bp
)
851 newrefcount
= bp
->raw
->refcount
- 1;
852 if (newrefcount
== 0)
854 ret
= delete_raw_breakpoint (proc
, bp
->raw
);
859 bp
->raw
->refcount
= newrefcount
;
867 delete_breakpoint_1 (struct process_info
*proc
, struct breakpoint
*todel
)
869 struct breakpoint
*bp
, **bp_link
;
872 bp
= proc
->breakpoints
;
873 bp_link
= &proc
->breakpoints
;
881 err
= release_breakpoint (proc
, bp
);
895 warning ("Could not find breakpoint in list.");
900 delete_breakpoint (struct breakpoint
*todel
)
902 struct process_info
*proc
= current_process ();
903 return delete_breakpoint_1 (proc
, todel
);
906 /* Locate a GDB breakpoint of type Z_TYPE and kind KIND placed at
907 address ADDR and return a pointer to its structure. If KIND is -1,
908 the breakpoint's kind is ignored. */
910 static struct breakpoint
*
911 find_gdb_breakpoint (char z_type
, CORE_ADDR addr
, int kind
)
913 struct process_info
*proc
= current_process ();
914 struct breakpoint
*bp
;
915 enum bkpt_type type
= Z_packet_to_bkpt_type (z_type
);
917 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= bp
->next
)
918 if (bp
->type
== type
&& bp
->raw
->pc
== addr
919 && (kind
== -1 || bp
->raw
->kind
== kind
))
926 z_type_supported (char z_type
)
928 return (z_type
>= '0' && z_type
<= '4'
929 && the_target
->supports_z_point_type
!= NULL
930 && the_target
->supports_z_point_type (z_type
));
933 /* Create a new GDB breakpoint of type Z_TYPE at ADDR with kind KIND.
934 Returns a pointer to the newly created breakpoint on success. On
935 failure returns NULL and sets *ERR to either -1 for error, or 1 if
936 Z_TYPE breakpoints are not supported on this target. */
938 static struct breakpoint
*
939 set_gdb_breakpoint_1 (char z_type
, CORE_ADDR addr
, int kind
, int *err
)
941 struct breakpoint
*bp
;
943 enum raw_bkpt_type raw_type
;
945 /* If we see GDB inserting a second code breakpoint at the same
946 address, then either: GDB is updating the breakpoint's conditions
947 or commands; or, the first breakpoint must have disappeared due
948 to a shared library unload. On targets where the shared
949 libraries are handled by userspace, like SVR4, for example,
950 GDBserver can't tell if a library was loaded or unloaded. Since
951 we refcount raw breakpoints, we must be careful to make sure GDB
952 breakpoints never contribute more than one reference. if we
953 didn't do this, in case the previous breakpoint is gone due to a
954 shared library unload, we'd just increase the refcount of the
955 previous breakpoint at this address, but the trap was not planted
956 in the inferior anymore, thus the breakpoint would never be hit.
957 Note this must be careful to not create a window where
958 breakpoints are removed from the target, for non-stop, in case
959 the target can poke at memory while the program is running. */
960 if (z_type
== Z_PACKET_SW_BP
961 || z_type
== Z_PACKET_HW_BP
)
963 bp
= find_gdb_breakpoint (z_type
, addr
, -1);
967 if (bp
->raw
->kind
!= kind
)
969 /* A different kind than previously seen. The previous
970 breakpoint must be gone then. */
971 bp
->raw
->inserted
= -1;
972 delete_breakpoint (bp
);
975 else if (z_type
== Z_PACKET_SW_BP
)
977 /* Check if the breakpoint is actually gone from the
978 target, due to an solib unload, for example. Might
979 as well validate _all_ breakpoints. */
980 validate_breakpoints ();
982 /* Breakpoints that don't pass validation are
984 bp
= find_gdb_breakpoint (z_type
, addr
, -1);
990 /* Data breakpoints for the same address but different kind are
991 expected. GDB doesn't merge these. The backend gets to do
992 that if it wants/can. */
993 bp
= find_gdb_breakpoint (z_type
, addr
, kind
);
998 /* We already know about this breakpoint, there's nothing else
999 to do - GDB's reference is already accounted for. Note that
1000 whether the breakpoint inserted is left as is - we may be
1001 stepping over it, for example, in which case we don't want to
1002 force-reinsert it. */
1006 raw_type
= Z_packet_to_raw_bkpt_type (z_type
);
1007 type
= Z_packet_to_bkpt_type (z_type
);
1008 return set_breakpoint (type
, raw_type
, addr
, kind
, NULL
, err
);
1012 check_gdb_bp_preconditions (char z_type
, int *err
)
1014 /* As software/memory breakpoints work by poking at memory, we need
1015 to prepare to access memory. If that operation fails, we need to
1016 return error. Seeing an error, if this is the first breakpoint
1017 of that type that GDB tries to insert, GDB would then assume the
1018 breakpoint type is supported, but it may actually not be. So we
1019 need to check whether the type is supported at all before
1020 preparing to access memory. */
1021 if (!z_type_supported (z_type
))
1026 else if (current_thread
== NULL
)
1035 /* See mem-break.h. This is a wrapper for set_gdb_breakpoint_1 that
1036 knows to prepare to access memory for Z0 breakpoints. */
1039 set_gdb_breakpoint (char z_type
, CORE_ADDR addr
, int kind
, int *err
)
1041 struct breakpoint
*bp
;
1043 if (!check_gdb_bp_preconditions (z_type
, err
))
1046 /* If inserting a software/memory breakpoint, need to prepare to
1048 if (z_type
== Z_PACKET_SW_BP
)
1050 *err
= prepare_to_access_memory ();
1055 bp
= set_gdb_breakpoint_1 (z_type
, addr
, kind
, err
);
1057 if (z_type
== Z_PACKET_SW_BP
)
1058 done_accessing_memory ();
1063 /* Delete a GDB breakpoint of type Z_TYPE and kind KIND previously
1064 inserted at ADDR with set_gdb_breakpoint_at. Returns 0 on success,
1065 -1 on error, and 1 if Z_TYPE breakpoints are not supported on this
1069 delete_gdb_breakpoint_1 (char z_type
, CORE_ADDR addr
, int kind
)
1071 struct breakpoint
*bp
;
1074 bp
= find_gdb_breakpoint (z_type
, addr
, kind
);
1078 /* Before deleting the breakpoint, make sure to free its condition
1079 and command lists. */
1080 clear_breakpoint_conditions_and_commands (bp
);
1081 err
= delete_breakpoint (bp
);
1088 /* See mem-break.h. This is a wrapper for delete_gdb_breakpoint that
1089 knows to prepare to access memory for Z0 breakpoints. */
1092 delete_gdb_breakpoint (char z_type
, CORE_ADDR addr
, int kind
)
1096 if (!check_gdb_bp_preconditions (z_type
, &ret
))
1099 /* If inserting a software/memory breakpoint, need to prepare to
1101 if (z_type
== Z_PACKET_SW_BP
)
1105 err
= prepare_to_access_memory ();
1110 ret
= delete_gdb_breakpoint_1 (z_type
, addr
, kind
);
1112 if (z_type
== Z_PACKET_SW_BP
)
1113 done_accessing_memory ();
1118 /* Clear all conditions associated with a breakpoint. */
1121 clear_breakpoint_conditions (struct breakpoint
*bp
)
1123 struct point_cond_list
*cond
;
1125 if (bp
->cond_list
== NULL
)
1128 cond
= bp
->cond_list
;
1130 while (cond
!= NULL
)
1132 struct point_cond_list
*cond_next
;
1134 cond_next
= cond
->next
;
1135 gdb_free_agent_expr (cond
->cond
);
1140 bp
->cond_list
= NULL
;
1143 /* Clear all commands associated with a breakpoint. */
1146 clear_breakpoint_commands (struct breakpoint
*bp
)
1148 struct point_command_list
*cmd
;
1150 if (bp
->command_list
== NULL
)
1153 cmd
= bp
->command_list
;
1157 struct point_command_list
*cmd_next
;
1159 cmd_next
= cmd
->next
;
1160 gdb_free_agent_expr (cmd
->cmd
);
1165 bp
->command_list
= NULL
;
1169 clear_breakpoint_conditions_and_commands (struct breakpoint
*bp
)
1171 clear_breakpoint_conditions (bp
);
1172 clear_breakpoint_commands (bp
);
1175 /* Add condition CONDITION to GDBserver's breakpoint BP. */
1178 add_condition_to_breakpoint (struct breakpoint
*bp
,
1179 struct agent_expr
*condition
)
1181 struct point_cond_list
*new_cond
;
1183 /* Create new condition. */
1184 new_cond
= XCNEW (struct point_cond_list
);
1185 new_cond
->cond
= condition
;
1187 /* Add condition to the list. */
1188 new_cond
->next
= bp
->cond_list
;
1189 bp
->cond_list
= new_cond
;
1192 /* Add a target-side condition CONDITION to a breakpoint. */
1195 add_breakpoint_condition (struct breakpoint
*bp
, char **condition
)
1197 char *actparm
= *condition
;
1198 struct agent_expr
*cond
;
1200 if (condition
== NULL
)
1206 cond
= gdb_parse_agent_expr (&actparm
);
1210 fprintf (stderr
, "Condition evaluation failed. "
1211 "Assuming unconditional.\n");
1215 add_condition_to_breakpoint (bp
, cond
);
1217 *condition
= actparm
;
1222 /* Evaluate condition (if any) at breakpoint BP. Return 1 if
1223 true and 0 otherwise. */
1226 gdb_condition_true_at_breakpoint_z_type (char z_type
, CORE_ADDR addr
)
1228 /* Fetch registers for the current inferior. */
1229 struct breakpoint
*bp
= find_gdb_breakpoint (z_type
, addr
, -1);
1231 struct point_cond_list
*cl
;
1233 struct eval_agent_expr_context ctx
;
1238 /* Check if the breakpoint is unconditional. If it is,
1239 the condition always evaluates to TRUE. */
1240 if (bp
->cond_list
== NULL
)
1243 ctx
.regcache
= get_thread_regcache (current_thread
, 1);
1247 /* Evaluate each condition in the breakpoint's list of conditions.
1248 Return true if any of the conditions evaluates to TRUE.
1250 If we failed to evaluate the expression, TRUE is returned. This
1251 forces GDB to reevaluate the conditions. */
1252 for (cl
= bp
->cond_list
;
1253 cl
&& !value
&& !err
; cl
= cl
->next
)
1255 /* Evaluate the condition. */
1256 err
= gdb_eval_agent_expr (&ctx
, cl
->cond
, &value
);
1262 return (value
!= 0);
1266 gdb_condition_true_at_breakpoint (CORE_ADDR where
)
1268 /* Only check code (software or hardware) breakpoints. */
1269 return (gdb_condition_true_at_breakpoint_z_type (Z_PACKET_SW_BP
, where
)
1270 || gdb_condition_true_at_breakpoint_z_type (Z_PACKET_HW_BP
, where
));
1273 /* Add commands COMMANDS to GDBserver's breakpoint BP. */
1276 add_commands_to_breakpoint (struct breakpoint
*bp
,
1277 struct agent_expr
*commands
, int persist
)
1279 struct point_command_list
*new_cmd
;
1281 /* Create new command. */
1282 new_cmd
= XCNEW (struct point_command_list
);
1283 new_cmd
->cmd
= commands
;
1284 new_cmd
->persistence
= persist
;
1286 /* Add commands to the list. */
1287 new_cmd
->next
= bp
->command_list
;
1288 bp
->command_list
= new_cmd
;
1291 /* Add a target-side command COMMAND to the breakpoint at ADDR. */
1294 add_breakpoint_commands (struct breakpoint
*bp
, char **command
,
1297 char *actparm
= *command
;
1298 struct agent_expr
*cmd
;
1300 if (command
== NULL
)
1306 cmd
= gdb_parse_agent_expr (&actparm
);
1310 fprintf (stderr
, "Command evaluation failed. "
1315 add_commands_to_breakpoint (bp
, cmd
, persist
);
1322 /* Return true if there are no commands to run at this location,
1323 which likely means we want to report back to GDB. */
1326 gdb_no_commands_at_breakpoint_z_type (char z_type
, CORE_ADDR addr
)
1328 struct breakpoint
*bp
= find_gdb_breakpoint (z_type
, addr
, -1);
1334 debug_printf ("at 0x%s, type Z%c, bp command_list is 0x%s\n",
1335 paddress (addr
), z_type
,
1336 phex_nz ((uintptr_t) bp
->command_list
, 0));
1337 return (bp
->command_list
== NULL
);
1340 /* Return true if there are no commands to run at this location,
1341 which likely means we want to report back to GDB. */
1344 gdb_no_commands_at_breakpoint (CORE_ADDR where
)
1346 /* Only check code (software or hardware) breakpoints. */
1347 return (gdb_no_commands_at_breakpoint_z_type (Z_PACKET_SW_BP
, where
)
1348 && gdb_no_commands_at_breakpoint_z_type (Z_PACKET_HW_BP
, where
));
1351 /* Run a breakpoint's commands. Returns 0 if there was a problem
1352 running any command, 1 otherwise. */
1355 run_breakpoint_commands_z_type (char z_type
, CORE_ADDR addr
)
1357 /* Fetch registers for the current inferior. */
1358 struct breakpoint
*bp
= find_gdb_breakpoint (z_type
, addr
, -1);
1360 struct point_command_list
*cl
;
1362 struct eval_agent_expr_context ctx
;
1367 ctx
.regcache
= get_thread_regcache (current_thread
, 1);
1371 for (cl
= bp
->command_list
;
1372 cl
&& !value
&& !err
; cl
= cl
->next
)
1374 /* Run the command. */
1375 err
= gdb_eval_agent_expr (&ctx
, cl
->cmd
, &value
);
1377 /* If one command has a problem, stop digging the hole deeper. */
1386 run_breakpoint_commands (CORE_ADDR where
)
1388 /* Only check code (software or hardware) breakpoints. If one
1389 command has a problem, stop digging the hole deeper. */
1390 if (run_breakpoint_commands_z_type (Z_PACKET_SW_BP
, where
))
1391 run_breakpoint_commands_z_type (Z_PACKET_HW_BP
, where
);
1394 /* See mem-break.h. */
1397 gdb_breakpoint_here (CORE_ADDR where
)
1399 /* Only check code (software or hardware) breakpoints. */
1400 return (find_gdb_breakpoint (Z_PACKET_SW_BP
, where
, -1) != NULL
1401 || find_gdb_breakpoint (Z_PACKET_HW_BP
, where
, -1) != NULL
);
1405 set_reinsert_breakpoint (CORE_ADDR stop_at
)
1407 struct breakpoint
*bp
;
1409 bp
= set_breakpoint_at (stop_at
, NULL
);
1410 bp
->type
= reinsert_breakpoint
;
1414 delete_reinsert_breakpoints (void)
1416 struct process_info
*proc
= current_process ();
1417 struct breakpoint
*bp
, **bp_link
;
1419 bp
= proc
->breakpoints
;
1420 bp_link
= &proc
->breakpoints
;
1424 if (bp
->type
== reinsert_breakpoint
)
1426 *bp_link
= bp
->next
;
1427 release_breakpoint (proc
, bp
);
1432 bp_link
= &bp
->next
;
1439 uninsert_raw_breakpoint (struct raw_breakpoint
*bp
)
1441 if (bp
->inserted
< 0)
1444 debug_printf ("Breakpoint at %s is marked insert-disabled.\n",
1447 else if (bp
->inserted
> 0)
1453 err
= the_target
->remove_point (bp
->raw_type
, bp
->pc
, bp
->kind
, bp
);
1459 debug_printf ("Failed to uninsert raw breakpoint at 0x%s.\n",
1466 uninsert_breakpoints_at (CORE_ADDR pc
)
1468 struct process_info
*proc
= current_process ();
1469 struct raw_breakpoint
*bp
;
1472 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1473 if ((bp
->raw_type
== raw_bkpt_type_sw
1474 || bp
->raw_type
== raw_bkpt_type_hw
)
1480 uninsert_raw_breakpoint (bp
);
1485 /* This can happen when we remove all breakpoints while handling
1488 debug_printf ("Could not find breakpoint at 0x%s "
1489 "in list (uninserting).\n",
1495 uninsert_all_breakpoints (void)
1497 struct process_info
*proc
= current_process ();
1498 struct raw_breakpoint
*bp
;
1500 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1501 if ((bp
->raw_type
== raw_bkpt_type_sw
1502 || bp
->raw_type
== raw_bkpt_type_hw
)
1504 uninsert_raw_breakpoint (bp
);
1508 reinsert_raw_breakpoint (struct raw_breakpoint
*bp
)
1513 error ("Breakpoint already inserted at reinsert time.");
1515 err
= the_target
->insert_point (bp
->raw_type
, bp
->pc
, bp
->kind
, bp
);
1518 else if (debug_threads
)
1519 debug_printf ("Failed to reinsert breakpoint at 0x%s (%d).\n",
1520 paddress (bp
->pc
), err
);
1524 reinsert_breakpoints_at (CORE_ADDR pc
)
1526 struct process_info
*proc
= current_process ();
1527 struct raw_breakpoint
*bp
;
1530 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1531 if ((bp
->raw_type
== raw_bkpt_type_sw
1532 || bp
->raw_type
== raw_bkpt_type_hw
)
1537 reinsert_raw_breakpoint (bp
);
1542 /* This can happen when we remove all breakpoints while handling
1545 debug_printf ("Could not find raw breakpoint at 0x%s "
1546 "in list (reinserting).\n",
1552 reinsert_all_breakpoints (void)
1554 struct process_info
*proc
= current_process ();
1555 struct raw_breakpoint
*bp
;
1557 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1558 if ((bp
->raw_type
== raw_bkpt_type_sw
1559 || bp
->raw_type
== raw_bkpt_type_hw
)
1561 reinsert_raw_breakpoint (bp
);
1565 check_breakpoints (CORE_ADDR stop_pc
)
1567 struct process_info
*proc
= current_process ();
1568 struct breakpoint
*bp
, **bp_link
;
1570 bp
= proc
->breakpoints
;
1571 bp_link
= &proc
->breakpoints
;
1575 struct raw_breakpoint
*raw
= bp
->raw
;
1577 if ((raw
->raw_type
== raw_bkpt_type_sw
1578 || raw
->raw_type
== raw_bkpt_type_hw
)
1579 && raw
->pc
== stop_pc
)
1583 warning ("Hit a removed breakpoint?");
1587 if (bp
->handler
!= NULL
&& (*bp
->handler
) (stop_pc
))
1589 *bp_link
= bp
->next
;
1591 release_breakpoint (proc
, bp
);
1598 bp_link
= &bp
->next
;
1604 breakpoint_here (CORE_ADDR addr
)
1606 struct process_info
*proc
= current_process ();
1607 struct raw_breakpoint
*bp
;
1609 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1610 if ((bp
->raw_type
== raw_bkpt_type_sw
1611 || bp
->raw_type
== raw_bkpt_type_hw
)
1619 breakpoint_inserted_here (CORE_ADDR addr
)
1621 struct process_info
*proc
= current_process ();
1622 struct raw_breakpoint
*bp
;
1624 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1625 if ((bp
->raw_type
== raw_bkpt_type_sw
1626 || bp
->raw_type
== raw_bkpt_type_hw
)
1634 /* See mem-break.h. */
1637 software_breakpoint_inserted_here (CORE_ADDR addr
)
1639 struct process_info
*proc
= current_process ();
1640 struct raw_breakpoint
*bp
;
1642 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1643 if (bp
->raw_type
== raw_bkpt_type_sw
1651 /* See mem-break.h. */
1654 hardware_breakpoint_inserted_here (CORE_ADDR addr
)
1656 struct process_info
*proc
= current_process ();
1657 struct raw_breakpoint
*bp
;
1659 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1660 if (bp
->raw_type
== raw_bkpt_type_hw
1669 validate_inserted_breakpoint (struct raw_breakpoint
*bp
)
1674 gdb_assert (bp
->inserted
);
1675 gdb_assert (bp
->raw_type
== raw_bkpt_type_sw
);
1677 buf
= (unsigned char *) alloca (bp_size (bp
));
1678 err
= (*the_target
->read_memory
) (bp
->pc
, buf
, bp_size (bp
));
1679 if (err
|| memcmp (buf
, bp_opcode (bp
), bp_size (bp
)) != 0)
1681 /* Tag it as gone. */
1690 delete_disabled_breakpoints (void)
1692 struct process_info
*proc
= current_process ();
1693 struct breakpoint
*bp
, *next
;
1695 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= next
)
1698 if (bp
->raw
->inserted
< 0)
1699 delete_breakpoint_1 (proc
, bp
);
1703 /* Check if breakpoints we inserted still appear to be inserted. They
1704 may disappear due to a shared library unload, and worse, a new
1705 shared library may be reloaded at the same address as the
1706 previously unloaded one. If that happens, we should make sure that
1707 the shadow memory of the old breakpoints isn't used when reading or
1711 validate_breakpoints (void)
1713 struct process_info
*proc
= current_process ();
1714 struct breakpoint
*bp
;
1716 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= bp
->next
)
1718 struct raw_breakpoint
*raw
= bp
->raw
;
1720 if (raw
->raw_type
== raw_bkpt_type_sw
&& raw
->inserted
> 0)
1721 validate_inserted_breakpoint (raw
);
1724 delete_disabled_breakpoints ();
1728 check_mem_read (CORE_ADDR mem_addr
, unsigned char *buf
, int mem_len
)
1730 struct process_info
*proc
= current_process ();
1731 struct raw_breakpoint
*bp
= proc
->raw_breakpoints
;
1732 struct fast_tracepoint_jump
*jp
= proc
->fast_tracepoint_jumps
;
1733 CORE_ADDR mem_end
= mem_addr
+ mem_len
;
1734 int disabled_one
= 0;
1736 for (; jp
!= NULL
; jp
= jp
->next
)
1738 CORE_ADDR bp_end
= jp
->pc
+ jp
->length
;
1739 CORE_ADDR start
, end
;
1740 int copy_offset
, copy_len
, buf_offset
;
1742 gdb_assert (fast_tracepoint_jump_shadow (jp
) >= buf
+ mem_len
1743 || buf
>= fast_tracepoint_jump_shadow (jp
) + (jp
)->length
);
1745 if (mem_addr
>= bp_end
)
1747 if (jp
->pc
>= mem_end
)
1751 if (mem_addr
> start
)
1758 copy_len
= end
- start
;
1759 copy_offset
= start
- jp
->pc
;
1760 buf_offset
= start
- mem_addr
;
1763 memcpy (buf
+ buf_offset
,
1764 fast_tracepoint_jump_shadow (jp
) + copy_offset
,
1768 for (; bp
!= NULL
; bp
= bp
->next
)
1770 CORE_ADDR bp_end
= bp
->pc
+ bp_size (bp
);
1771 CORE_ADDR start
, end
;
1772 int copy_offset
, copy_len
, buf_offset
;
1774 if (bp
->raw_type
!= raw_bkpt_type_sw
)
1777 gdb_assert (bp
->old_data
>= buf
+ mem_len
1778 || buf
>= &bp
->old_data
[sizeof (bp
->old_data
)]);
1780 if (mem_addr
>= bp_end
)
1782 if (bp
->pc
>= mem_end
)
1786 if (mem_addr
> start
)
1793 copy_len
= end
- start
;
1794 copy_offset
= start
- bp
->pc
;
1795 buf_offset
= start
- mem_addr
;
1797 if (bp
->inserted
> 0)
1799 if (validate_inserted_breakpoint (bp
))
1800 memcpy (buf
+ buf_offset
, bp
->old_data
+ copy_offset
, copy_len
);
1807 delete_disabled_breakpoints ();
1811 check_mem_write (CORE_ADDR mem_addr
, unsigned char *buf
,
1812 const unsigned char *myaddr
, int mem_len
)
1814 struct process_info
*proc
= current_process ();
1815 struct raw_breakpoint
*bp
= proc
->raw_breakpoints
;
1816 struct fast_tracepoint_jump
*jp
= proc
->fast_tracepoint_jumps
;
1817 CORE_ADDR mem_end
= mem_addr
+ mem_len
;
1818 int disabled_one
= 0;
1820 /* First fast tracepoint jumps, then breakpoint traps on top. */
1822 for (; jp
!= NULL
; jp
= jp
->next
)
1824 CORE_ADDR jp_end
= jp
->pc
+ jp
->length
;
1825 CORE_ADDR start
, end
;
1826 int copy_offset
, copy_len
, buf_offset
;
1828 gdb_assert (fast_tracepoint_jump_shadow (jp
) >= myaddr
+ mem_len
1829 || myaddr
>= fast_tracepoint_jump_shadow (jp
) + (jp
)->length
);
1830 gdb_assert (fast_tracepoint_jump_insn (jp
) >= buf
+ mem_len
1831 || buf
>= fast_tracepoint_jump_insn (jp
) + (jp
)->length
);
1833 if (mem_addr
>= jp_end
)
1835 if (jp
->pc
>= mem_end
)
1839 if (mem_addr
> start
)
1846 copy_len
= end
- start
;
1847 copy_offset
= start
- jp
->pc
;
1848 buf_offset
= start
- mem_addr
;
1850 memcpy (fast_tracepoint_jump_shadow (jp
) + copy_offset
,
1851 myaddr
+ buf_offset
, copy_len
);
1853 memcpy (buf
+ buf_offset
,
1854 fast_tracepoint_jump_insn (jp
) + copy_offset
, copy_len
);
1857 for (; bp
!= NULL
; bp
= bp
->next
)
1859 CORE_ADDR bp_end
= bp
->pc
+ bp_size (bp
);
1860 CORE_ADDR start
, end
;
1861 int copy_offset
, copy_len
, buf_offset
;
1863 if (bp
->raw_type
!= raw_bkpt_type_sw
)
1866 gdb_assert (bp
->old_data
>= myaddr
+ mem_len
1867 || myaddr
>= &bp
->old_data
[sizeof (bp
->old_data
)]);
1869 if (mem_addr
>= bp_end
)
1871 if (bp
->pc
>= mem_end
)
1875 if (mem_addr
> start
)
1882 copy_len
= end
- start
;
1883 copy_offset
= start
- bp
->pc
;
1884 buf_offset
= start
- mem_addr
;
1886 memcpy (bp
->old_data
+ copy_offset
, myaddr
+ buf_offset
, copy_len
);
1887 if (bp
->inserted
> 0)
1889 if (validate_inserted_breakpoint (bp
))
1890 memcpy (buf
+ buf_offset
, bp_opcode (bp
) + copy_offset
, copy_len
);
1897 delete_disabled_breakpoints ();
1900 /* Delete all breakpoints, and un-insert them from the inferior. */
1903 delete_all_breakpoints (void)
1905 struct process_info
*proc
= current_process ();
1907 while (proc
->breakpoints
)
1908 delete_breakpoint_1 (proc
, proc
->breakpoints
);
1911 /* Clear the "inserted" flag in all breakpoints. */
1914 mark_breakpoints_out (struct process_info
*proc
)
1916 struct raw_breakpoint
*raw_bp
;
1918 for (raw_bp
= proc
->raw_breakpoints
; raw_bp
!= NULL
; raw_bp
= raw_bp
->next
)
1919 raw_bp
->inserted
= 0;
1922 /* Release all breakpoints, but do not try to un-insert them from the
1926 free_all_breakpoints (struct process_info
*proc
)
1928 mark_breakpoints_out (proc
);
1930 /* Note: use PROC explicitly instead of deferring to
1931 delete_all_breakpoints --- CURRENT_INFERIOR may already have been
1932 released when we get here. There should be no call to
1933 current_process from here on. */
1934 while (proc
->breakpoints
)
1935 delete_breakpoint_1 (proc
, proc
->breakpoints
);
1938 /* Clone an agent expression. */
1940 static struct agent_expr
*
1941 clone_agent_expr (const struct agent_expr
*src_ax
)
1943 struct agent_expr
*ax
;
1945 ax
= XCNEW (struct agent_expr
);
1946 ax
->length
= src_ax
->length
;
1947 ax
->bytes
= (unsigned char *) xcalloc (ax
->length
, 1);
1948 memcpy (ax
->bytes
, src_ax
->bytes
, ax
->length
);
1952 /* Deep-copy the contents of one breakpoint to another. */
1954 static struct breakpoint
*
1955 clone_one_breakpoint (const struct breakpoint
*src
)
1957 struct breakpoint
*dest
;
1958 struct raw_breakpoint
*dest_raw
;
1959 struct point_cond_list
*current_cond
;
1960 struct point_cond_list
*new_cond
;
1961 struct point_cond_list
*cond_tail
= NULL
;
1962 struct point_command_list
*current_cmd
;
1963 struct point_command_list
*new_cmd
;
1964 struct point_command_list
*cmd_tail
= NULL
;
1966 /* Clone the raw breakpoint. */
1967 dest_raw
= XCNEW (struct raw_breakpoint
);
1968 dest_raw
->raw_type
= src
->raw
->raw_type
;
1969 dest_raw
->refcount
= src
->raw
->refcount
;
1970 dest_raw
->pc
= src
->raw
->pc
;
1971 dest_raw
->kind
= src
->raw
->kind
;
1972 memcpy (dest_raw
->old_data
, src
->raw
->old_data
, MAX_BREAKPOINT_LEN
);
1973 dest_raw
->inserted
= src
->raw
->inserted
;
1975 /* Clone the high-level breakpoint. */
1976 dest
= XCNEW (struct breakpoint
);
1977 dest
->type
= src
->type
;
1978 dest
->raw
= dest_raw
;
1979 dest
->handler
= src
->handler
;
1981 /* Clone the condition list. */
1982 for (current_cond
= src
->cond_list
; current_cond
!= NULL
;
1983 current_cond
= current_cond
->next
)
1985 new_cond
= XCNEW (struct point_cond_list
);
1986 new_cond
->cond
= clone_agent_expr (current_cond
->cond
);
1987 APPEND_TO_LIST (&dest
->cond_list
, new_cond
, cond_tail
);
1990 /* Clone the command list. */
1991 for (current_cmd
= src
->command_list
; current_cmd
!= NULL
;
1992 current_cmd
= current_cmd
->next
)
1994 new_cmd
= XCNEW (struct point_command_list
);
1995 new_cmd
->cmd
= clone_agent_expr (current_cmd
->cmd
);
1996 new_cmd
->persistence
= current_cmd
->persistence
;
1997 APPEND_TO_LIST (&dest
->command_list
, new_cmd
, cmd_tail
);
2003 /* Create a new breakpoint list NEW_LIST that is a copy of the
2004 list starting at SRC_LIST. Create the corresponding new
2005 raw_breakpoint list NEW_RAW_LIST as well. */
2008 clone_all_breakpoints (struct breakpoint
**new_list
,
2009 struct raw_breakpoint
**new_raw_list
,
2010 const struct breakpoint
*src_list
)
2012 const struct breakpoint
*bp
;
2013 struct breakpoint
*new_bkpt
;
2014 struct breakpoint
*bkpt_tail
= NULL
;
2015 struct raw_breakpoint
*raw_bkpt_tail
= NULL
;
2017 for (bp
= src_list
; bp
!= NULL
; bp
= bp
->next
)
2019 new_bkpt
= clone_one_breakpoint (bp
);
2020 APPEND_TO_LIST (new_list
, new_bkpt
, bkpt_tail
);
2021 APPEND_TO_LIST (new_raw_list
, new_bkpt
->raw
, raw_bkpt_tail
);