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.");
306 inc_ref_fast_tracepoint_jump (struct fast_tracepoint_jump
*jp
)
311 struct fast_tracepoint_jump
*
312 set_fast_tracepoint_jump (CORE_ADDR where
,
313 unsigned char *insn
, ULONGEST length
)
315 struct process_info
*proc
= current_process ();
316 struct fast_tracepoint_jump
*jp
;
319 /* We refcount fast tracepoint jumps. Check if we already know
320 about a jump at this address. */
321 jp
= find_fast_tracepoint_jump_at (where
);
328 /* We don't, so create a new object. Double the length, because the
329 flexible array member holds both the jump insn, and the
331 jp
= xcalloc (1, sizeof (*jp
) + (length
* 2));
334 memcpy (fast_tracepoint_jump_insn (jp
), insn
, length
);
337 /* Note that there can be trap breakpoints inserted in the same
338 address range. To access the original memory contents, we use
339 `read_inferior_memory', which masks out breakpoints. */
340 err
= read_inferior_memory (where
,
341 fast_tracepoint_jump_shadow (jp
), jp
->length
);
346 "Failed to read shadow memory of"
347 " fast tracepoint at 0x%s (%s).\n",
348 paddress (where
), strerror (err
));
353 /* Link the jump in. */
355 jp
->next
= proc
->fast_tracepoint_jumps
;
356 proc
->fast_tracepoint_jumps
= jp
;
358 /* Since there can be trap breakpoints inserted in the same address
359 range, we use use `write_inferior_memory', which takes care of
360 layering breakpoints on top of fast tracepoints, on top of the
361 buffer we pass it. This works because we've already linked in
362 the fast tracepoint jump above. Also note that we need to pass
363 the current shadow contents, because write_inferior_memory
364 updates any shadow memory with what we pass here, and we want
366 err
= write_inferior_memory (where
, fast_tracepoint_jump_shadow (jp
),
372 "Failed to insert fast tracepoint jump at 0x%s (%s).\n",
373 paddress (where
), strerror (err
));
376 proc
->fast_tracepoint_jumps
= jp
->next
;
386 uninsert_fast_tracepoint_jumps_at (CORE_ADDR pc
)
388 struct fast_tracepoint_jump
*jp
;
391 jp
= find_fast_tracepoint_jump_at (pc
);
394 /* This can happen when we remove all breakpoints while handling
398 "Could not find fast tracepoint jump at 0x%s "
399 "in list (uninserting).\n",
408 /* Since there can be trap breakpoints inserted in the same
409 address range, we use use `write_inferior_memory', which
410 takes care of layering breakpoints on top of fast
411 tracepoints, and on top of the buffer we pass it. This works
412 because we've already marked the fast tracepoint fast
413 tracepoint jump uninserted above. Also note that we need to
414 pass the current shadow contents, because
415 write_inferior_memory updates any shadow memory with what we
416 pass here, and we want that to be a nop. */
417 err
= write_inferior_memory (jp
->pc
,
418 fast_tracepoint_jump_shadow (jp
),
426 "Failed to uninsert fast tracepoint jump at 0x%s (%s).\n",
427 paddress (pc
), strerror (err
));
433 reinsert_fast_tracepoint_jumps_at (CORE_ADDR where
)
435 struct fast_tracepoint_jump
*jp
;
438 jp
= find_fast_tracepoint_jump_at (where
);
441 /* This can happen when we remove breakpoints when a tracepoint
442 hit causes a tracing stop, while handling a step-over. */
445 "Could not find fast tracepoint jump at 0x%s "
446 "in list (reinserting).\n",
452 error ("Jump already inserted at reinsert time.");
456 /* Since there can be trap breakpoints inserted in the same address
457 range, we use `write_inferior_memory', which takes care of
458 layering breakpoints on top of fast tracepoints, and on top of
459 the buffer we pass it. This works because we've already marked
460 the fast tracepoint jump inserted above. Also note that we need
461 to pass the current shadow contents, because
462 write_inferior_memory updates any shadow memory with what we pass
463 here, and we want that to be a nop. */
464 err
= write_inferior_memory (where
,
465 fast_tracepoint_jump_shadow (jp
), jp
->length
);
472 "Failed to reinsert fast tracepoint jump at 0x%s (%s).\n",
473 paddress (where
), strerror (err
));
478 set_breakpoint_at (CORE_ADDR where
, int (*handler
) (CORE_ADDR
))
480 struct process_info
*proc
= current_process ();
481 struct breakpoint
*bp
;
482 struct raw_breakpoint
*raw
;
484 raw
= set_raw_breakpoint_at (where
);
492 bp
= xcalloc (1, sizeof (struct breakpoint
));
493 bp
->type
= other_breakpoint
;
496 bp
->handler
= handler
;
498 bp
->next
= proc
->breakpoints
;
499 proc
->breakpoints
= bp
;
505 delete_raw_breakpoint (struct process_info
*proc
, struct raw_breakpoint
*todel
)
507 struct raw_breakpoint
*bp
, **bp_link
;
510 bp
= proc
->raw_breakpoints
;
511 bp_link
= &proc
->raw_breakpoints
;
519 struct raw_breakpoint
*prev_bp_link
= *bp_link
;
523 /* Since there can be trap breakpoints inserted in the
524 same address range, we use `write_inferior_memory',
525 which takes care of layering breakpoints on top of
526 fast tracepoints, and on top of the buffer we pass
527 it. This works because we've already unlinked the
528 fast tracepoint jump above. Also note that we need
529 to pass the current shadow contents, because
530 write_inferior_memory updates any shadow memory with
531 what we pass here, and we want that to be a nop. */
532 ret
= write_inferior_memory (bp
->pc
, bp
->old_data
,
536 /* Something went wrong, relink the breakpoint. */
537 *bp_link
= prev_bp_link
;
541 "Failed to uninsert raw breakpoint "
542 "at 0x%s (%s) while deleting it.\n",
543 paddress (bp
->pc
), strerror (ret
));
561 warning ("Could not find raw breakpoint in list.");
566 release_breakpoint (struct process_info
*proc
, struct breakpoint
*bp
)
571 newrefcount
= bp
->raw
->refcount
- 1;
572 if (newrefcount
== 0)
574 ret
= delete_raw_breakpoint (proc
, bp
->raw
);
579 bp
->raw
->refcount
= newrefcount
;
587 delete_breakpoint_1 (struct process_info
*proc
, struct breakpoint
*todel
)
589 struct breakpoint
*bp
, **bp_link
;
592 bp
= proc
->breakpoints
;
593 bp_link
= &proc
->breakpoints
;
601 err
= release_breakpoint (proc
, bp
);
615 warning ("Could not find breakpoint in list.");
620 delete_breakpoint (struct breakpoint
*todel
)
622 struct process_info
*proc
= current_process ();
623 return delete_breakpoint_1 (proc
, todel
);
626 static struct breakpoint
*
627 find_gdb_breakpoint_at (CORE_ADDR where
)
629 struct process_info
*proc
= current_process ();
630 struct breakpoint
*bp
;
632 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= bp
->next
)
633 if (bp
->type
== gdb_breakpoint
&& bp
->raw
->pc
== where
)
640 set_gdb_breakpoint_at (CORE_ADDR where
)
642 struct breakpoint
*bp
;
644 if (breakpoint_data
== NULL
)
647 /* If we see GDB inserting a second breakpoint at the same address,
648 then the first breakpoint must have disappeared due to a shared
649 library unload. On targets where the shared libraries are
650 handled by userspace, like SVR4, for example, GDBserver can't
651 tell if a library was loaded or unloaded. Since we refcount
652 breakpoints, if we didn't do this, we'd just increase the
653 refcount of the previous breakpoint at this address, but the trap
654 was not planted in the inferior anymore, thus the breakpoint
655 would never be hit. */
656 bp
= find_gdb_breakpoint_at (where
);
659 delete_gdb_breakpoint_at (where
);
661 /* Might as well validate all other breakpoints. */
662 validate_breakpoints ();
665 bp
= set_breakpoint_at (where
, NULL
);
669 bp
->type
= gdb_breakpoint
;
674 delete_gdb_breakpoint_at (CORE_ADDR addr
)
676 struct breakpoint
*bp
;
679 if (breakpoint_data
== NULL
)
682 bp
= find_gdb_breakpoint_at (addr
);
686 err
= delete_breakpoint (bp
);
694 gdb_breakpoint_here (CORE_ADDR where
)
696 struct breakpoint
*bp
= find_gdb_breakpoint_at (where
);
702 set_reinsert_breakpoint (CORE_ADDR stop_at
)
704 struct breakpoint
*bp
;
706 bp
= set_breakpoint_at (stop_at
, NULL
);
707 bp
->type
= reinsert_breakpoint
;
711 delete_reinsert_breakpoints (void)
713 struct process_info
*proc
= current_process ();
714 struct breakpoint
*bp
, **bp_link
;
716 bp
= proc
->breakpoints
;
717 bp_link
= &proc
->breakpoints
;
721 if (bp
->type
== reinsert_breakpoint
)
724 release_breakpoint (proc
, bp
);
736 uninsert_raw_breakpoint (struct raw_breakpoint
*bp
)
743 /* Since there can be fast tracepoint jumps inserted in the same
744 address range, we use `write_inferior_memory', which takes
745 care of layering breakpoints on top of fast tracepoints, and
746 on top of the buffer we pass it. This works because we've
747 already unlinked the fast tracepoint jump above. Also note
748 that we need to pass the current shadow contents, because
749 write_inferior_memory updates any shadow memory with what we
750 pass here, and we want that to be a nop. */
751 err
= write_inferior_memory (bp
->pc
, bp
->old_data
,
759 "Failed to uninsert raw breakpoint at 0x%s (%s).\n",
760 paddress (bp
->pc
), strerror (err
));
766 uninsert_breakpoints_at (CORE_ADDR pc
)
768 struct raw_breakpoint
*bp
;
770 bp
= find_raw_breakpoint_at (pc
);
773 /* This can happen when we remove all breakpoints while handling
777 "Could not find breakpoint at 0x%s "
778 "in list (uninserting).\n",
784 uninsert_raw_breakpoint (bp
);
788 uninsert_all_breakpoints (void)
790 struct process_info
*proc
= current_process ();
791 struct raw_breakpoint
*bp
;
793 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
795 uninsert_raw_breakpoint (bp
);
799 reinsert_raw_breakpoint (struct raw_breakpoint
*bp
)
804 error ("Breakpoint already inserted at reinsert time.");
806 err
= (*the_target
->write_memory
) (bp
->pc
, breakpoint_data
,
810 else if (debug_threads
)
812 "Failed to reinsert breakpoint at 0x%s (%s).\n",
813 paddress (bp
->pc
), strerror (err
));
817 reinsert_breakpoints_at (CORE_ADDR pc
)
819 struct raw_breakpoint
*bp
;
821 bp
= find_raw_breakpoint_at (pc
);
824 /* This can happen when we remove all breakpoints while handling
828 "Could not find raw breakpoint at 0x%s "
829 "in list (reinserting).\n",
834 reinsert_raw_breakpoint (bp
);
838 reinsert_all_breakpoints (void)
840 struct process_info
*proc
= current_process ();
841 struct raw_breakpoint
*bp
;
843 for (bp
= proc
->raw_breakpoints
; bp
!= NULL
; bp
= bp
->next
)
845 reinsert_raw_breakpoint (bp
);
849 check_breakpoints (CORE_ADDR stop_pc
)
851 struct process_info
*proc
= current_process ();
852 struct breakpoint
*bp
, **bp_link
;
854 bp
= proc
->breakpoints
;
855 bp_link
= &proc
->breakpoints
;
859 if (bp
->raw
->pc
== stop_pc
)
861 if (!bp
->raw
->inserted
)
863 warning ("Hit a removed breakpoint?");
867 if (bp
->handler
!= NULL
&& (*bp
->handler
) (stop_pc
))
871 release_breakpoint (proc
, bp
);
884 set_breakpoint_data (const unsigned char *bp_data
, int bp_len
)
886 breakpoint_data
= bp_data
;
887 breakpoint_len
= bp_len
;
891 breakpoint_here (CORE_ADDR addr
)
893 return (find_raw_breakpoint_at (addr
) != NULL
);
897 breakpoint_inserted_here (CORE_ADDR addr
)
899 struct raw_breakpoint
*bp
;
901 bp
= find_raw_breakpoint_at (addr
);
903 return (bp
!= NULL
&& bp
->inserted
);
907 validate_inserted_breakpoint (struct raw_breakpoint
*bp
)
912 gdb_assert (bp
->inserted
);
914 buf
= alloca (breakpoint_len
);
915 err
= (*the_target
->read_memory
) (bp
->pc
, buf
, breakpoint_len
);
916 if (err
|| memcmp (buf
, breakpoint_data
, breakpoint_len
) != 0)
918 /* Tag it as gone. */
920 bp
->shlib_disabled
= 1;
928 delete_disabled_breakpoints (void)
930 struct process_info
*proc
= current_process ();
931 struct breakpoint
*bp
, *next
;
933 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= next
)
936 if (bp
->raw
->shlib_disabled
)
937 delete_breakpoint_1 (proc
, bp
);
941 /* Check if breakpoints we inserted still appear to be inserted. They
942 may disappear due to a shared library unload, and worse, a new
943 shared library may be reloaded at the same address as the
944 previously unloaded one. If that happens, we should make sure that
945 the shadow memory of the old breakpoints isn't used when reading or
949 validate_breakpoints (void)
951 struct process_info
*proc
= current_process ();
952 struct breakpoint
*bp
;
954 for (bp
= proc
->breakpoints
; bp
!= NULL
; bp
= bp
->next
)
956 if (bp
->raw
->inserted
)
957 validate_inserted_breakpoint (bp
->raw
);
960 delete_disabled_breakpoints ();
964 check_mem_read (CORE_ADDR mem_addr
, unsigned char *buf
, int mem_len
)
966 struct process_info
*proc
= current_process ();
967 struct raw_breakpoint
*bp
= proc
->raw_breakpoints
;
968 struct fast_tracepoint_jump
*jp
= proc
->fast_tracepoint_jumps
;
969 CORE_ADDR mem_end
= mem_addr
+ mem_len
;
970 int disabled_one
= 0;
972 for (; jp
!= NULL
; jp
= jp
->next
)
974 CORE_ADDR bp_end
= jp
->pc
+ jp
->length
;
975 CORE_ADDR start
, end
;
976 int copy_offset
, copy_len
, buf_offset
;
978 if (mem_addr
>= bp_end
)
980 if (jp
->pc
>= mem_end
)
984 if (mem_addr
> start
)
991 copy_len
= end
- start
;
992 copy_offset
= start
- jp
->pc
;
993 buf_offset
= start
- mem_addr
;
996 memcpy (buf
+ buf_offset
,
997 fast_tracepoint_jump_shadow (jp
) + copy_offset
,
1001 for (; bp
!= NULL
; bp
= bp
->next
)
1003 CORE_ADDR bp_end
= bp
->pc
+ breakpoint_len
;
1004 CORE_ADDR start
, end
;
1005 int copy_offset
, copy_len
, buf_offset
;
1007 if (mem_addr
>= bp_end
)
1009 if (bp
->pc
>= mem_end
)
1013 if (mem_addr
> start
)
1020 copy_len
= end
- start
;
1021 copy_offset
= start
- bp
->pc
;
1022 buf_offset
= start
- mem_addr
;
1026 if (validate_inserted_breakpoint (bp
))
1027 memcpy (buf
+ buf_offset
, bp
->old_data
+ copy_offset
, copy_len
);
1034 delete_disabled_breakpoints ();
1038 check_mem_write (CORE_ADDR mem_addr
, unsigned char *buf
,
1039 const unsigned char *myaddr
, int mem_len
)
1041 struct process_info
*proc
= current_process ();
1042 struct raw_breakpoint
*bp
= proc
->raw_breakpoints
;
1043 struct fast_tracepoint_jump
*jp
= proc
->fast_tracepoint_jumps
;
1044 CORE_ADDR mem_end
= mem_addr
+ mem_len
;
1045 int disabled_one
= 0;
1047 /* First fast tracepoint jumps, then breakpoint traps on top. */
1049 for (; jp
!= NULL
; jp
= jp
->next
)
1051 CORE_ADDR jp_end
= jp
->pc
+ jp
->length
;
1052 CORE_ADDR start
, end
;
1053 int copy_offset
, copy_len
, buf_offset
;
1055 if (mem_addr
>= jp_end
)
1057 if (jp
->pc
>= mem_end
)
1061 if (mem_addr
> start
)
1068 copy_len
= end
- start
;
1069 copy_offset
= start
- jp
->pc
;
1070 buf_offset
= start
- mem_addr
;
1072 memcpy (fast_tracepoint_jump_shadow (jp
) + copy_offset
,
1073 myaddr
+ buf_offset
, copy_len
);
1075 memcpy (buf
+ buf_offset
,
1076 fast_tracepoint_jump_insn (jp
) + copy_offset
, copy_len
);
1079 for (; bp
!= NULL
; bp
= bp
->next
)
1081 CORE_ADDR bp_end
= bp
->pc
+ breakpoint_len
;
1082 CORE_ADDR start
, end
;
1083 int copy_offset
, copy_len
, buf_offset
;
1085 if (mem_addr
>= bp_end
)
1087 if (bp
->pc
>= mem_end
)
1091 if (mem_addr
> start
)
1098 copy_len
= end
- start
;
1099 copy_offset
= start
- bp
->pc
;
1100 buf_offset
= start
- mem_addr
;
1102 memcpy (bp
->old_data
+ copy_offset
, myaddr
+ buf_offset
, copy_len
);
1105 if (validate_inserted_breakpoint (bp
))
1106 memcpy (buf
+ buf_offset
, breakpoint_data
+ copy_offset
, copy_len
);
1113 delete_disabled_breakpoints ();
1116 /* Delete all breakpoints, and un-insert them from the inferior. */
1119 delete_all_breakpoints (void)
1121 struct process_info
*proc
= current_process ();
1123 while (proc
->breakpoints
)
1124 delete_breakpoint_1 (proc
, proc
->breakpoints
);
1127 /* Clear the "inserted" flag in all breakpoints. */
1130 mark_breakpoints_out (struct process_info
*proc
)
1132 struct raw_breakpoint
*raw_bp
;
1134 for (raw_bp
= proc
->raw_breakpoints
; raw_bp
!= NULL
; raw_bp
= raw_bp
->next
)
1135 raw_bp
->inserted
= 0;
1138 /* Release all breakpoints, but do not try to un-insert them from the
1142 free_all_breakpoints (struct process_info
*proc
)
1144 mark_breakpoints_out (proc
);
1146 /* Note: use PROC explicitly instead of deferring to
1147 delete_all_breakpoints --- CURRENT_INFERIOR may already have been
1148 released when we get here. There should be no call to
1149 current_process from here on. */
1150 while (proc
->breakpoints
)
1151 delete_breakpoint_1 (proc
, proc
->breakpoints
);
This page took 0.053844 seconds and 5 git commands to generate.