]> git.sur5r.net Git - openocd/blob - src/target/breakpoints.c
cleanup trailing whitespaces
[openocd] / src / target / breakpoints.c
1 /***************************************************************************
2  *   Copyright (C) 2005 by Dominic Rath                                    *
3  *   Dominic.Rath@gmx.de                                                   *
4  *                                                                         *
5  *   Copyright (C) ST-Ericsson SA 2011                                     *
6  *   michel.jaouen@stericsson.com : smp minimum support                    *
7  *                                                                         *
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 2 of the License, or     *
11  *   (at your option) any later version.                                   *
12  *                                                                         *
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.                          *
17  *                                                                         *
18  *   You should have received a copy of the GNU General Public License     *
19  *   along with this program; if not, write to the                         *
20  *   Free Software Foundation, Inc.,                                       *
21  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
22  ***************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include "target.h"
28 #include <helper/log.h>
29 #include "breakpoints.h"
30
31
32 static char *breakpoint_type_strings[] =
33 {
34         "hardware",
35         "software"
36 };
37
38 static char *watchpoint_rw_strings[] =
39 {
40         "read",
41         "write",
42         "access"
43 };
44
45 // monotonic counter/id-number for breakpoints and watch points
46 static int bpwp_unique_id;
47
48 int breakpoint_add_internal(struct target *target, uint32_t address, uint32_t length, enum breakpoint_type type)
49 {
50         struct breakpoint *breakpoint = target->breakpoints;
51         struct breakpoint **breakpoint_p = &target->breakpoints;
52         char *reason;
53         int retval;
54         int n;
55
56         n = 0;
57         while (breakpoint)
58         {
59                 n++;
60                 if (breakpoint->address == address) {
61                         /* FIXME don't assume "same address" means "same
62                          * breakpoint" ... check all the parameters before
63                          * succeeding.
64                          */
65                         LOG_DEBUG("Duplicate Breakpoint address: 0x%08" PRIx32 " (BP %d)",
66                                   address, breakpoint->unique_id );
67                         return ERROR_OK;
68                 }
69                 breakpoint_p = &breakpoint->next;
70                 breakpoint = breakpoint->next;
71         }
72
73         (*breakpoint_p) = malloc(sizeof(struct breakpoint));
74         (*breakpoint_p)->address = address;
75         (*breakpoint_p)->length = length;
76         (*breakpoint_p)->type = type;
77         (*breakpoint_p)->set = 0;
78         (*breakpoint_p)->orig_instr = malloc(length);
79         (*breakpoint_p)->next = NULL;
80         (*breakpoint_p)->unique_id = bpwp_unique_id++;
81
82         retval = target_add_breakpoint(target, *breakpoint_p);
83         switch (retval) {
84         case ERROR_OK:
85                 break;
86         case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
87                 reason = "resource not available";
88                 goto fail;
89         case ERROR_TARGET_NOT_HALTED:
90                 reason = "target running";
91                 goto fail;
92         default:
93                 reason = "unknown reason";
94 fail:
95                 LOG_ERROR("can't add breakpoint: %s", reason);
96                 free((*breakpoint_p)->orig_instr);
97                 free(*breakpoint_p);
98                 *breakpoint_p = NULL;
99                 return retval;
100         }
101
102         LOG_DEBUG("added %s breakpoint at 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %d)",
103                           breakpoint_type_strings[(*breakpoint_p)->type],
104                           (*breakpoint_p)->address, (*breakpoint_p)->length,
105                           (*breakpoint_p)->unique_id  );
106
107         return ERROR_OK;
108 }
109
110 int breakpoint_add(struct target *target, uint32_t address, uint32_t length, enum breakpoint_type type)
111 {
112
113 int retval = ERROR_OK;
114     if (target->smp)
115         {
116                 struct target_list *head;
117                 struct target *curr;
118                 head = target->head;
119                 while(head != (struct target_list*)NULL)
120                 {
121                         curr = head->target;
122                         retval = breakpoint_add_internal(curr, address,length, type);
123                         if (retval != ERROR_OK) return retval;
124                         head = head->next;      
125                 }
126                 return retval;
127         }
128         else
129         return(breakpoint_add_internal(target, address, length, type));
130
131 }
132
133 /* free up a breakpoint */
134 static void breakpoint_free(struct target *target, struct breakpoint *breakpoint_to_remove)
135 {
136         struct breakpoint *breakpoint = target->breakpoints;
137         struct breakpoint **breakpoint_p = &target->breakpoints;
138         int retval;
139
140         while (breakpoint)
141         {
142                 if (breakpoint == breakpoint_to_remove)
143                         break;
144                 breakpoint_p = &breakpoint->next;
145                 breakpoint = breakpoint->next;
146         }
147
148         if (breakpoint == NULL)
149                 return;
150
151         retval = target_remove_breakpoint(target, breakpoint);
152
153         LOG_DEBUG("free BPID: %d --> %d", breakpoint->unique_id, retval);
154         (*breakpoint_p) = breakpoint->next;
155         free(breakpoint->orig_instr);
156         free(breakpoint);
157 }
158
159 void breakpoint_remove_internal(struct target *target, uint32_t address)
160 {
161         struct breakpoint *breakpoint = target->breakpoints;
162
163         while (breakpoint)
164         {
165                 if (breakpoint->address == address)
166                         break;
167                 breakpoint = breakpoint->next;
168         }
169
170         if (breakpoint)
171         {
172                 breakpoint_free(target, breakpoint);
173         }
174         else
175         {
176                 LOG_ERROR("no breakpoint at address 0x%8.8" PRIx32 " found", address);
177         }
178 }
179 void breakpoint_remove(struct target *target, uint32_t address)
180 {
181     if ((target->smp))
182         {
183                 struct target_list *head;
184                 struct target *curr;
185                 head = target->head;
186                 while(head != (struct target_list*)NULL)
187                 {
188                         curr = head->target;
189                         breakpoint_remove_internal(curr, address);
190                         head = head->next;      
191                 }
192         }
193         else  breakpoint_remove_internal(target, address);
194 }
195
196 void breakpoint_clear_target_internal(struct target *target)
197 {
198         struct breakpoint *breakpoint;
199
200         LOG_DEBUG("Delete all breakpoints for target: %s",
201                         target_name(target));
202         while ((breakpoint = target->breakpoints) != NULL)
203         {
204                 breakpoint_free(target, breakpoint);
205         }
206 }
207
208 void breakpoint_clear_target(struct target *target)
209 {
210     if (target->smp)
211         {
212                 struct target_list *head;
213                 struct target *curr;
214                 head = target->head;
215                 while(head != (struct target_list*)NULL)
216                 {
217                         curr = head->target;
218                     breakpoint_clear_target_internal(curr);
219                         head = head->next;      
220                 }
221      }
222          else breakpoint_clear_target_internal(target);
223         
224 }
225
226
227 struct breakpoint* breakpoint_find(struct target *target, uint32_t address)
228 {
229         struct breakpoint *breakpoint = target->breakpoints;
230
231         while (breakpoint)
232         {
233                 if (breakpoint->address == address)
234                         return breakpoint;
235                 breakpoint = breakpoint->next;
236         }
237
238         return NULL;
239 }
240
241 int watchpoint_add(struct target *target, uint32_t address, uint32_t length,
242                 enum watchpoint_rw rw, uint32_t value, uint32_t mask)
243 {
244         struct watchpoint *watchpoint = target->watchpoints;
245         struct watchpoint **watchpoint_p = &target->watchpoints;
246         int retval;
247         char *reason;
248
249         while (watchpoint)
250         {
251                 if (watchpoint->address == address) {
252                         if (watchpoint->length != length
253                                         || watchpoint->value != value
254                                         || watchpoint->mask != mask
255                                         || watchpoint->rw != rw) {
256                                 LOG_ERROR("address 0x%8.8" PRIx32
257                                                 "already has watchpoint %d",
258                                                 address, watchpoint->unique_id);
259                                 return ERROR_FAIL;
260                         }
261
262                         /* ignore duplicate watchpoint */
263                         return ERROR_OK;
264                 }
265                 watchpoint_p = &watchpoint->next;
266                 watchpoint = watchpoint->next;
267         }
268
269         (*watchpoint_p) = calloc(1, sizeof(struct watchpoint));
270         (*watchpoint_p)->address = address;
271         (*watchpoint_p)->length = length;
272         (*watchpoint_p)->value = value;
273         (*watchpoint_p)->mask = mask;
274         (*watchpoint_p)->rw = rw;
275         (*watchpoint_p)->unique_id = bpwp_unique_id++;
276
277         retval = target_add_watchpoint(target, *watchpoint_p);
278         switch (retval) {
279         case ERROR_OK:
280                 break;
281         case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
282                 reason = "resource not available";
283                 goto bye;
284         case ERROR_TARGET_NOT_HALTED:
285                 reason = "target running";
286                 goto bye;
287         default:
288                 reason = "unrecognized error";
289 bye:
290                 LOG_ERROR("can't add %s watchpoint at 0x%8.8" PRIx32 ", %s",
291                          watchpoint_rw_strings[(*watchpoint_p)->rw],
292                          address, reason);
293                 free (*watchpoint_p);
294                 *watchpoint_p = NULL;
295                 return retval;
296         }
297
298         LOG_DEBUG("added %s watchpoint at 0x%8.8" PRIx32
299                         " of length 0x%8.8" PRIx32 " (WPID: %d)",
300                         watchpoint_rw_strings[(*watchpoint_p)->rw],
301                         (*watchpoint_p)->address,
302                         (*watchpoint_p)->length,
303                         (*watchpoint_p)->unique_id );
304
305         return ERROR_OK;
306 }
307
308 static void watchpoint_free(struct target *target, struct watchpoint *watchpoint_to_remove)
309 {
310         struct watchpoint *watchpoint = target->watchpoints;
311         struct watchpoint **watchpoint_p = &target->watchpoints;
312         int retval;
313
314         while (watchpoint)
315         {
316                 if (watchpoint == watchpoint_to_remove)
317                         break;
318                 watchpoint_p = &watchpoint->next;
319                 watchpoint = watchpoint->next;
320         }
321
322         if (watchpoint == NULL)
323                 return;
324         retval = target_remove_watchpoint(target, watchpoint);
325         LOG_DEBUG("free WPID: %d --> %d", watchpoint->unique_id, retval);
326         (*watchpoint_p) = watchpoint->next;
327         free(watchpoint);
328 }
329
330 void watchpoint_remove(struct target *target, uint32_t address)
331 {
332         struct watchpoint *watchpoint = target->watchpoints;
333
334         while (watchpoint)
335         {
336                 if (watchpoint->address == address)
337                         break;
338                 watchpoint = watchpoint->next;
339         }
340
341         if (watchpoint)
342         {
343                 watchpoint_free(target, watchpoint);
344         }
345         else
346         {
347                 LOG_ERROR("no watchpoint at address 0x%8.8" PRIx32 " found", address);
348         }
349 }
350
351 void watchpoint_clear_target(struct target *target)
352 {
353         struct watchpoint *watchpoint;
354
355         LOG_DEBUG("Delete all watchpoints for target: %s",
356                         target_name(target));
357         while ((watchpoint = target->watchpoints) != NULL)
358         {
359                 watchpoint_free(target, watchpoint);
360         }
361 }