1 /* Memory breakpoint operations for the remote server for GDB.
2 Copyright (C) 2002, 2003, 2005, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 Contributed by MontaVista Software.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 const unsigned char *breakpoint_data
;
27 #define MAX_BREAKPOINT_LEN 8
29 /* GDB will never try to install multiple breakpoints at the same
30 address. But, we need to keep track of internal breakpoints too,
31 and so we do need to be able to install multiple breakpoints at the
32 same address transparently. We keep track of two different, and
33 closely related structures. A raw breakpoint, which manages the
34 low level, close to the metal aspect of a breakpoint. It holds the
35 breakpoint address, and a buffer holding a copy of the instructions
36 that would be in memory had not been a breakpoint there (we call
37 that the shadow memory of the breakpoint). We occasionally need to
38 temporarilly uninsert a breakpoint without the client knowing about
39 it (e.g., to step over an internal breakpoint), so we keep an
40 `inserted' state associated with this low level breakpoint
41 structure. There can only be one such object for a given address.
42 Then, we have (a bit higher level) breakpoints. This structure
43 holds a callback to be called whenever a breakpoint is hit, a
44 high-level type, and a link to a low level raw breakpoint. There
45 can be many high-level breakpoints at the same address, and all of
46 them will point to the same raw breakpoint, which is reference
49 /* The low level, physical, raw breakpoint. */
52 struct raw_breakpoint
*next
;
54 /* A reference count. Each high level breakpoint referencing this
55 raw breakpoint accounts for one reference. */
58 /* The breakpoint's insertion address. There can only be one raw
59 breakpoint for a given PC. */
62 /* The breakpoint's shadow memory. */
63 unsigned char old_data
[MAX_BREAKPOINT_LEN
];
65 /* Non-zero if this breakpoint is currently inserted in the
69 /* Non-zero if this breakpoint is currently disabled because we no
70 longer detect it as inserted. */
74 /* The type of a breakpoint. */
77 /* A GDB breakpoint, requested with a Z0 packet. */
80 /* A basic-software-single-step breakpoint. */
83 /* Any other breakpoint type that doesn't require specific
84 treatment goes here. E.g., an event breakpoint. */
88 /* A high level (in gdbserver's perspective) breakpoint. */
91 struct breakpoint
*next
;
93 /* The breakpoint's type. */
96 /* Link to this breakpoint's raw breakpoint. This is always
98 struct raw_breakpoint
*raw
;
100 /* Function to call when we hit this breakpoint. If it returns 1,
101 the breakpoint shall be deleted; 0 or if this callback is NULL,
102 it will be left inserted. */
103 int (*handler
) (CORE_ADDR
);
106 static struct raw_breakpoint
*
107 find_raw_breakpoint_at (CORE_ADDR where
)
109 struct process_info
*proc
= current_process ();
110 struct raw_breakpoint
*bp
;
112 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
119 static struct raw_breakpoint
*
120 set_raw_breakpoint_at (CORE_ADDR where
)
122 struct process_info
*proc
= current_process ();
123 struct raw_breakpoint
*bp
;
126 if (breakpoint_data
== NULL
)
127 error ("Target does not support breakpoints.");
129 bp
= find_raw_breakpoint_at (where
);
136 bp
= xcalloc (1, sizeof (*bp
));
140 /* Note that there can be fast tracepoint jumps installed in the
141 same memory range, so to get at the original memory, we need to
142 use read_inferior_memory, which masks those out. */
143 err
= read_inferior_memory (where
, bp
->old_data
, breakpoint_len
);
148 "Failed to read shadow memory of"
149 " breakpoint at 0x%s (%s).\n",
150 paddress (where
), strerror (err
));
155 err
= (*the_target
->write_memory
) (where
, breakpoint_data
,
161 "Failed to insert breakpoint at 0x%s (%s).\n",
162 paddress (where
), strerror (err
));
167 /* Link the breakpoint in. */
169 bp
->next
= proc
->raw_breakpoints
;
170 proc
->raw_breakpoints
= bp
;
174 /* Notice that breakpoint traps are always installed on top of fast
175 tracepoint jumps. This is even if the fast tracepoint is installed
176 at a later time compared to when the breakpoint was installed.
177 This means that a stopping breakpoint or tracepoint has higher
178 "priority". In turn, this allows having fast and slow tracepoints
179 (and breakpoints) at the same address behave correctly. */
182 /* A fast tracepoint jump. */
184 struct fast_tracepoint_jump
186 struct fast_tracepoint_jump
*next
;
188 /* A reference count. GDB can install more than one fast tracepoint
189 at the same address (each with its own action list, for
193 /* The fast tracepoint's insertion address. There can only be one
194 of these for a given PC. */
197 /* Non-zero if this fast tracepoint jump is currently inserted in
201 /* The length of the jump instruction. */
204 /* A poor-man's flexible array member, holding both the jump
205 instruction to insert, and a copy of the instruction that would
206 be in memory had not been a jump there (the shadow memory of the
208 unsigned char insn_and_shadow
[0];
211 /* Fast tracepoint FP's jump instruction to insert. */
212 #define fast_tracepoint_jump_insn(fp) \
213 ((fp)->insn_and_shadow + 0)
215 /* The shadow memory of fast tracepoint jump FP. */
216 #define fast_tracepoint_jump_shadow(fp) \
217 ((fp)->insn_and_shadow + (fp)->length)
220 /* Return the fast tracepoint jump set at WHERE. */
222 static struct fast_tracepoint_jump
*
223 find_fast_tracepoint_jump_at (CORE_ADDR where
)
225 struct process_info
*proc
= current_process ();
226 struct fast_tracepoint_jump
*jp
;
228 for (jp
= proc
->fast_tracepoint_jumps
; jp
!= NULL
; jp
= jp
->next
)
236 fast_tracepoint_jump_here (CORE_ADDR where
)
238 struct fast_tracepoint_jump
*jp
= find_fast_tracepoint_jump_at (where
);
244 delete_fast_tracepoint_jump (struct fast_tracepoint_jump
*todel
)
246 struct fast_tracepoint_jump
*bp
, **bp_link
;
248 struct process_info
*proc
= current_process ();
250 bp
= proc
->fast_tracepoint_jumps
;
251 bp_link
= &proc
->fast_tracepoint_jumps
;
257 if (--bp
->refcount
== 0)
259 struct fast_tracepoint_jump
*prev_bp_link
= *bp_link
;
264 /* Since there can be breakpoints inserted in the same
265 address range, we use `write_inferior_memory', which
266 takes care of layering breakpoints on top of fast
267 tracepoints, and on top of the buffer we pass it.
268 This works because we've already unlinked the fast
269 tracepoint jump above. Also note that we need to
270 pass the current shadow contents, because
271 write_inferior_memory updates any shadow memory with
272 what we pass here, and we want that to be a nop. */
273 ret
= write_inferior_memory (bp
->pc
,
274 fast_tracepoint_jump_shadow (bp
),
278 /* Something went wrong, relink the jump. */
279 *bp_link
= prev_bp_link
;
283 "Failed to uninsert fast tracepoint jump "
284 "at 0x%s (%s) while deleting it.\n",
285 paddress (bp
->pc
), strerror (ret
));
301 warning ("Could not find fast tracepoint jump in list.");
305 struct fast_tracepoint_jump
*
306 set_fast_tracepoint_jump (CORE_ADDR where
,
307 unsigned char *insn
, ULONGEST length
)
309 struct process_info
*proc
= current_process ();
310 struct fast_tracepoint_jump
*jp
;
313 /* We refcount fast tracepoint jumps. Check if we already know
314 about a jump at this address. */
315 jp
= find_fast_tracepoint_jump_at (where
);
322 /* We don't, so create a new object. Double the length, because the
323 flexible array member holds both the jump insn, and the
325 jp
= xcalloc (1, sizeof (*jp
) + (length
* 2));
328 memcpy (fast_tracepoint_jump_insn (jp
), insn
, length
);
331 /* Note that there can be trap breakpoints inserted in the same
332 address range. To access the original memory contents, we use
333 `read_inferior_memory', which masks out breakpoints. */
334 err
= read_inferior_memory (where
,
335 fast_tracepoint_jump_shadow (jp
), jp
->length
);
340 "Failed to read shadow memory of"
341 " fast tracepoint at 0x%s (%s).\n",
342 paddress (where
), strerror (err
));
347 /* Link the jump in. */
349 jp
->next
= proc
->fast_tracepoint_jumps
;
350 proc
->fast_tracepoint_jumps
= jp
;
352 /* Since there can be trap breakpoints inserted in the same address
353 range, we use use `write_inferior_memory', which takes care of
354 layering breakpoints on top of fast tracepoints, on top of the
355 buffer we pass it. This works because we've already linked in
356 the fast tracepoint jump above. Also note that we need to pass
357 the current shadow contents, because write_inferior_memory
358 updates any shadow memory with what we pass here, and we want
360 err
= write_inferior_memory (where
, fast_tracepoint_jump_shadow (jp
),
366 "Failed to insert fast tracepoint jump at 0x%s (%s).\n",
367 paddress (where
), strerror (err
));
370 proc
->fast_tracepoint_jumps
= jp
->next
;
380 uninsert_fast_tracepoint_jumps_at (CORE_ADDR pc
)
382 struct fast_tracepoint_jump
*jp
;
385 jp
= find_fast_tracepoint_jump_at (pc
);
388 /* This can happen when we remove all breakpoints while handling
392 "Could not find fast tracepoint jump at 0x%s "
393 "in list (uninserting).\n",
402 /* Since there can be trap breakpoints inserted in the same
403 address range, we use use `write_inferior_memory', which
404 takes care of layering breakpoints on top of fast
405 tracepoints, and on top of the buffer we pass it. This works
406 because we've already marked the fast tracepoint fast
407 tracepoint jump uninserted above. Also note that we need to
408 pass the current shadow contents, because
409 write_inferior_memory updates any shadow memory with what we
410 pass here, and we want that to be a nop. */
411 err
= write_inferior_memory (jp
->pc
,
412 fast_tracepoint_jump_shadow (jp
),
420 "Failed to uninsert fast tracepoint jump at 0x%s (%s).\n",
421 paddress (pc
), strerror (err
));
427 reinsert_fast_tracepoint_jumps_at (CORE_ADDR where
)
429 struct fast_tracepoint_jump
*jp
;
432 jp
= find_fast_tracepoint_jump_at (where
);
435 /* This can happen when we remove breakpoints when a tracepoint
436 hit causes a tracing stop, while handling a step-over. */
439 "Could not find fast tracepoint jump at 0x%s "
440 "in list (reinserting).\n",
446 error ("Jump already inserted at reinsert time.");
450 /* Since there can be trap breakpoints inserted in the same address
451 range, we use `write_inferior_memory', which takes care of
452 layering breakpoints on top of fast tracepoints, and on top of
453 the buffer we pass it. This works because we've already marked
454 the fast tracepoint jump inserted above. Also note that we need
455 to pass the current shadow contents, because
456 write_inferior_memory updates any shadow memory with what we pass
457 here, and we want that to be a nop. */
458 err
= write_inferior_memory (where
,
459 fast_tracepoint_jump_shadow (jp
), jp
->length
);
466 "Failed to reinsert fast tracepoint jump at 0x%s (%s).\n",
467 paddress (where
), strerror (err
));
472 set_breakpoint_at (CORE_ADDR where
, int (*handler
) (CORE_ADDR
))
474 struct process_info
*proc
= current_process ();
475 struct breakpoint
*bp
;
476 struct raw_breakpoint
*raw
;
478 raw
= set_raw_breakpoint_at (where
);
486 bp
= xcalloc (1, sizeof (struct breakpoint
));
487 bp
->type
= other_breakpoint
;
490 bp
->handler
= handler
;
492 bp
->next
= proc
->breakpoints
;
493 proc
->breakpoints
= bp
;
499 delete_raw_breakpoint (struct process_info
*proc
, struct raw_breakpoint
*todel
)
501 struct raw_breakpoint
*bp
, **bp_link
;
504 bp
= proc
->raw_breakpoints
;
505 bp_link
= &proc
->raw_breakpoints
;
513 struct raw_breakpoint
*prev_bp_link
= *bp_link
;
517 /* Since there can be trap breakpoints inserted in the
518 same address range, we use `write_inferior_memory',
519 which takes care of layering breakpoints on top of
520 fast tracepoints, and on top of the buffer we pass
521 it. This works because we've already unlinked the
522 fast tracepoint jump above. Also note that we need
523 to pass the current shadow contents, because
524 write_inferior_memory updates any shadow memory with
525 what we pass here, and we want that to be a nop. */
526 ret
= write_inferior_memory (bp
->pc
, bp
->old_data
,
530 /* Something went wrong, relink the breakpoint. */
531 *bp_link
= prev_bp_link
;
535 "Failed to uninsert raw breakpoint "
536 "at 0x%s (%s) while deleting it.\n",
537 paddress (bp
->pc
), strerror (ret
));
555 warning ("Could not find raw breakpoint in list.");
560 release_breakpoint (struct process_info
*proc
, struct breakpoint
*bp
)
565 newrefcount
= bp
->raw
->refcount
- 1;
566 if (newrefcount
== 0)
568 ret
= delete_raw_breakpoint (proc
, bp
->raw
);
573 bp
->raw
->refcount
= newrefcount
;
581 delete_breakpoint_1 (struct process_info
*proc
, struct breakpoint
*todel
)
583 struct breakpoint
*bp
, **bp_link
;
586 bp
= proc
->breakpoints
;
587 bp_link
= &proc
->breakpoints
;
595 err
= release_breakpoint (proc
, bp
);
609 warning ("Could not find breakpoint in list.");
614 delete_breakpoint (struct breakpoint
*todel
)
616 struct process_info
*proc
= current_process ();
617 return delete_breakpoint_1 (proc
, todel
);
620 static struct breakpoint
*
621 find_gdb_breakpoint_at (CORE_ADDR where
)
623 struct process_info
*proc
= current_process ();
624 struct breakpoint
*bp
;
626 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= bp
->next
)
627 if (bp
->type
== gdb_breakpoint
&& bp
->raw
->pc
== where
)
634 set_gdb_breakpoint_at (CORE_ADDR where
)
636 struct breakpoint
*bp
;
638 if (breakpoint_data
== NULL
)
641 /* If we see GDB inserting a second breakpoint at the same address,
642 then the first breakpoint must have disappeared due to a shared
643 library unload. On targets where the shared libraries are
644 handled by userspace, like SVR4, for example, GDBserver can't
645 tell if a library was loaded or unloaded. Since we refcount
646 breakpoints, if we didn't do this, we'd just increase the
647 refcount of the previous breakpoint at this address, but the trap
648 was not planted in the inferior anymore, thus the breakpoint
649 would never be hit. */
650 bp
= find_gdb_breakpoint_at (where
);
653 delete_gdb_breakpoint_at (where
);
655 /* Might as well validate all other breakpoints. */
656 validate_breakpoints ();
659 bp
= set_breakpoint_at (where
, NULL
);
663 bp
->type
= gdb_breakpoint
;
668 delete_gdb_breakpoint_at (CORE_ADDR addr
)
670 struct breakpoint
*bp
;
673 if (breakpoint_data
== NULL
)
676 bp
= find_gdb_breakpoint_at (addr
);
680 err
= delete_breakpoint (bp
);
688 gdb_breakpoint_here (CORE_ADDR where
)
690 struct breakpoint
*bp
= find_gdb_breakpoint_at (where
);
696 set_reinsert_breakpoint (CORE_ADDR stop_at
)
698 struct breakpoint
*bp
;
700 bp
= set_breakpoint_at (stop_at
, NULL
);
701 bp
->type
= reinsert_breakpoint
;
705 delete_reinsert_breakpoints (void)
707 struct process_info
*proc
= current_process ();
708 struct breakpoint
*bp
, **bp_link
;
710 bp
= proc
->breakpoints
;
711 bp_link
= &proc
->breakpoints
;
715 if (bp
->type
== reinsert_breakpoint
)
718 release_breakpoint (proc
, bp
);
730 uninsert_raw_breakpoint (struct raw_breakpoint
*bp
)
737 /* Since there can be fast tracepoint jumps inserted in the same
738 address range, we use `write_inferior_memory', which takes
739 care of layering breakpoints on top of fast tracepoints, and
740 on top of the buffer we pass it. This works because we've
741 already unlinked the fast tracepoint jump above. Also note
742 that we need to pass the current shadow contents, because
743 write_inferior_memory updates any shadow memory with what we
744 pass here, and we want that to be a nop. */
745 err
= write_inferior_memory (bp
->pc
, bp
->old_data
,
753 "Failed to uninsert raw breakpoint at 0x%s (%s).\n",
754 paddress (bp
->pc
), strerror (err
));
760 uninsert_breakpoints_at (CORE_ADDR pc
)
762 struct raw_breakpoint
*bp
;
764 bp
= find_raw_breakpoint_at (pc
);
767 /* This can happen when we remove all breakpoints while handling
771 "Could not find breakpoint at 0x%s "
772 "in list (uninserting).\n",
778 uninsert_raw_breakpoint (bp
);
782 uninsert_all_breakpoints (void)
784 struct process_info
*proc
= current_process ();
785 struct raw_breakpoint
*bp
;
787 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
789 uninsert_raw_breakpoint (bp
);
793 reinsert_raw_breakpoint (struct raw_breakpoint
*bp
)
798 error ("Breakpoint already inserted at reinsert time.");
800 err
= (*the_target
->write_memory
) (bp
->pc
, breakpoint_data
,
804 else if (debug_threads
)
806 "Failed to reinsert breakpoint at 0x%s (%s).\n",
807 paddress (bp
->pc
), strerror (err
));
811 reinsert_breakpoints_at (CORE_ADDR pc
)
813 struct raw_breakpoint
*bp
;
815 bp
= find_raw_breakpoint_at (pc
);
818 /* This can happen when we remove all breakpoints while handling
822 "Could not find raw breakpoint at 0x%s "
823 "in list (reinserting).\n",
828 reinsert_raw_breakpoint (bp
);
832 reinsert_all_breakpoints (void)
834 struct process_info
*proc
= current_process ();
835 struct raw_breakpoint
*bp
;
837 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
839 reinsert_raw_breakpoint (bp
);
843 check_breakpoints (CORE_ADDR stop_pc
)
845 struct process_info
*proc
= current_process ();
846 struct breakpoint
*bp
, **bp_link
;
848 bp
= proc
->breakpoints
;
849 bp_link
= &proc
->breakpoints
;
853 if (bp
->raw
->pc
== stop_pc
)
855 if (!bp
->raw
->inserted
)
857 warning ("Hit a removed breakpoint?");
861 if (bp
->handler
!= NULL
&& (*bp
->handler
) (stop_pc
))
865 release_breakpoint (proc
, bp
);
878 set_breakpoint_data (const unsigned char *bp_data
, int bp_len
)
880 breakpoint_data
= bp_data
;
881 breakpoint_len
= bp_len
;
885 breakpoint_here (CORE_ADDR addr
)
887 return (find_raw_breakpoint_at (addr
) != NULL
);
891 breakpoint_inserted_here (CORE_ADDR addr
)
893 struct raw_breakpoint
*bp
;
895 bp
= find_raw_breakpoint_at (addr
);
897 return (bp
!= NULL
&& bp
->inserted
);
901 validate_inserted_breakpoint (struct raw_breakpoint
*bp
)
906 gdb_assert (bp
->inserted
);
908 buf
= alloca (breakpoint_len
);
909 err
= (*the_target
->read_memory
) (bp
->pc
, buf
, breakpoint_len
);
910 if (err
|| memcmp (buf
, breakpoint_data
, breakpoint_len
) != 0)
912 /* Tag it as gone. */
914 bp
->shlib_disabled
= 1;
922 delete_disabled_breakpoints (void)
924 struct process_info
*proc
= current_process ();
925 struct breakpoint
*bp
, *next
;
927 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= next
)
930 if (bp
->raw
->shlib_disabled
)
931 delete_breakpoint_1 (proc
, bp
);
935 /* Check if breakpoints we inserted still appear to be inserted. They
936 may disappear due to a shared library unload, and worse, a new
937 shared library may be reloaded at the same address as the
938 previously unloaded one. If that happens, we should make sure that
939 the shadow memory of the old breakpoints isn't used when reading or
943 validate_breakpoints (void)
945 struct process_info
*proc
= current_process ();
946 struct breakpoint
*bp
;
948 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= bp
->next
)
950 if (bp
->raw
->inserted
)
951 validate_inserted_breakpoint (bp
->raw
);
954 delete_disabled_breakpoints ();
958 check_mem_read (CORE_ADDR mem_addr
, unsigned char *buf
, int mem_len
)
960 struct process_info
*proc
= current_process ();
961 struct raw_breakpoint
*bp
= proc
->raw_breakpoints
;
962 struct fast_tracepoint_jump
*jp
= proc
->fast_tracepoint_jumps
;
963 CORE_ADDR mem_end
= mem_addr
+ mem_len
;
964 int disabled_one
= 0;
966 for (; jp
!= NULL
; jp
= jp
->next
)
968 CORE_ADDR bp_end
= jp
->pc
+ jp
->length
;
969 CORE_ADDR start
, end
;
970 int copy_offset
, copy_len
, buf_offset
;
972 if (mem_addr
>= bp_end
)
974 if (jp
->pc
>= mem_end
)
978 if (mem_addr
> start
)
985 copy_len
= end
- start
;
986 copy_offset
= start
- jp
->pc
;
987 buf_offset
= start
- mem_addr
;
990 memcpy (buf
+ buf_offset
,
991 fast_tracepoint_jump_shadow (jp
) + copy_offset
,
995 for (; bp
!= NULL
; bp
= bp
->next
)
997 CORE_ADDR bp_end
= bp
->pc
+ breakpoint_len
;
998 CORE_ADDR start
, end
;
999 int copy_offset
, copy_len
, buf_offset
;
1001 if (mem_addr
>= bp_end
)
1003 if (bp
->pc
>= mem_end
)
1007 if (mem_addr
> start
)
1014 copy_len
= end
- start
;
1015 copy_offset
= start
- bp
->pc
;
1016 buf_offset
= start
- mem_addr
;
1020 if (validate_inserted_breakpoint (bp
))
1021 memcpy (buf
+ buf_offset
, bp
->old_data
+ copy_offset
, copy_len
);
1028 delete_disabled_breakpoints ();
1032 check_mem_write (CORE_ADDR mem_addr
, unsigned char *buf
, int mem_len
)
1034 struct process_info
*proc
= current_process ();
1035 struct raw_breakpoint
*bp
= proc
->raw_breakpoints
;
1036 struct fast_tracepoint_jump
*jp
= proc
->fast_tracepoint_jumps
;
1037 CORE_ADDR mem_end
= mem_addr
+ mem_len
;
1038 int disabled_one
= 0;
1040 /* First fast tracepoint jumps, then breakpoint traps on top. */
1042 for (; jp
!= NULL
; jp
= jp
->next
)
1044 CORE_ADDR jp_end
= jp
->pc
+ jp
->length
;
1045 CORE_ADDR start
, end
;
1046 int copy_offset
, copy_len
, buf_offset
;
1048 if (mem_addr
>= jp_end
)
1050 if (jp
->pc
>= mem_end
)
1054 if (mem_addr
> start
)
1061 copy_len
= end
- start
;
1062 copy_offset
= start
- jp
->pc
;
1063 buf_offset
= start
- mem_addr
;
1065 memcpy (fast_tracepoint_jump_shadow (jp
) + copy_offset
,
1066 buf
+ buf_offset
, copy_len
);
1068 memcpy (buf
+ buf_offset
,
1069 fast_tracepoint_jump_insn (jp
) + copy_offset
, copy_len
);
1072 for (; bp
!= NULL
; bp
= bp
->next
)
1074 CORE_ADDR bp_end
= bp
->pc
+ breakpoint_len
;
1075 CORE_ADDR start
, end
;
1076 int copy_offset
, copy_len
, buf_offset
;
1078 if (mem_addr
>= bp_end
)
1080 if (bp
->pc
>= mem_end
)
1084 if (mem_addr
> start
)
1091 copy_len
= end
- start
;
1092 copy_offset
= start
- bp
->pc
;
1093 buf_offset
= start
- mem_addr
;
1095 memcpy (bp
->old_data
+ copy_offset
, buf
+ buf_offset
, copy_len
);
1098 if (validate_inserted_breakpoint (bp
))
1099 memcpy (buf
+ buf_offset
, breakpoint_data
+ copy_offset
, copy_len
);
1106 delete_disabled_breakpoints ();
1109 /* Delete all breakpoints, and un-insert them from the inferior. */
1112 delete_all_breakpoints (void)
1114 struct process_info
*proc
= current_process ();
1116 while (proc
->breakpoints
)
1117 delete_breakpoint_1 (proc
, proc
->breakpoints
);
1120 /* Clear the "inserted" flag in all breakpoints. */
1123 mark_breakpoints_out (struct process_info
*proc
)
1125 struct raw_breakpoint
*raw_bp
;
1127 for (raw_bp
= proc
->raw_breakpoints
; raw_bp
!= NULL
; raw_bp
= raw_bp
->next
)
1128 raw_bp
->inserted
= 0;
1131 /* Release all breakpoints, but do not try to un-insert them from the
1135 free_all_breakpoints (struct process_info
*proc
)
1137 mark_breakpoints_out (proc
);
1139 /* Note: use PROC explicitly instead of deferring to
1140 delete_all_breakpoints --- CURRENT_INFERIOR may already have been
1141 released when we get here. There should be no call to
1142 current_process from here on. */
1143 while (proc
->breakpoints
)
1144 delete_breakpoint_1 (proc
, proc
->breakpoints
);
This page took 0.053394 seconds and 4 git commands to generate.