src/target/breakpoints.c

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <stdlib.h>
  25
  26 #include "binarybuffer.h"
  27 #include "target.h"
  28 #include "log.h"
  29 #include "types.h"
  30
  31 #include "breakpoints.h"
  32
  33 char *breakpoint_type_strings[] =
  34 {
  35         "hardware",
  36         "software"
  37 };
  38
  39 char *watchpoint_rw_strings[] =
  40 {
  41         "read",
  42         "write",
  43         "access"
  44 };
  45
  46 int breakpoint_add(target_t *target, u32 address, u32 length, enum breakpoint_type type)
  47 {
  48         breakpoint_t *breakpoint = target->breakpoints;
  49         breakpoint_t **breakpoint_p = &target->breakpoints;
  50         int retval;
  51
  52         while (breakpoint)
  53         {
  54                 if (breakpoint->address == address)
  55                         return ERROR_OK;
  56                 breakpoint_p = &breakpoint->next;
  57                 breakpoint = breakpoint->next;
  58         }
  59
  60         (*breakpoint_p) = malloc(sizeof(breakpoint_t));
  61         (*breakpoint_p)->address = address;
  62         (*breakpoint_p)->length = length;
  63         (*breakpoint_p)->type = type;
  64         (*breakpoint_p)->set = 0;
  65         (*breakpoint_p)->orig_instr = malloc(length);
  66         (*breakpoint_p)->next = NULL;
  67
  68         if ((retval = target->type->add_breakpoint(target, *breakpoint_p)) != ERROR_OK)
  69         {
  70                 switch (retval)
  71                 {
  72                         case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
  73                                 LOG_INFO("can't add %s breakpoint, resource not available", breakpoint_type_strings[(*breakpoint_p)->type]);
  74                                 free((*breakpoint_p)->orig_instr);
  75                                 free(*breakpoint_p);
  76                                 *breakpoint_p = NULL;
  77                                 return retval;
  78                                 break;
  79                         case ERROR_TARGET_NOT_HALTED:
  80                                 LOG_INFO("can't add breakpoint while target is running");
  81                                 free((*breakpoint_p)->orig_instr);
  82                                 free(*breakpoint_p);
  83                                 *breakpoint_p = NULL;
  84                                 return retval;
  85                                 break;
  86                         default:
  87                                 break;
  88                 }
  89         }
  90
  91         LOG_DEBUG("added %s breakpoint at 0x%8.8x of length 0x%8.8x",
  92                 breakpoint_type_strings[(*breakpoint_p)->type],
  93                 (*breakpoint_p)->address, (*breakpoint_p)->length);
  94
  95         return ERROR_OK;
  96 }
  97
  98 /* free up a breakpoint */
  99 static void breakpoint_free(target_t *target, breakpoint_t *breakpoint_remove)
 100 {
 101         breakpoint_t *breakpoint = target->breakpoints;
 102         breakpoint_t **breakpoint_p = &target->breakpoints;
 103
 104         while (breakpoint)
 105         {
 106                 if (breakpoint==breakpoint_remove)
 107                         break;
 108                 breakpoint_p = &breakpoint->next;
 109                 breakpoint = breakpoint->next;
 110         }
 111
 112         if (breakpoint==NULL)
 113                 return;
 114
 115         target->type->remove_breakpoint(target, breakpoint);
 116
 117         (*breakpoint_p) = breakpoint->next;
 118         free(breakpoint->orig_instr);
 119         free(breakpoint);
 120 }
 121
 122 int breakpoint_remove(target_t *target, u32 address)
 123 {
 124         breakpoint_t *breakpoint = target->breakpoints;
 125         breakpoint_t **breakpoint_p = &target->breakpoints;
 126
 127         while (breakpoint)
 128         {
 129                 if (breakpoint->address == address)
 130                         break;
 131                 breakpoint_p = &breakpoint->next;
 132                 breakpoint = breakpoint->next;
 133         }
 134
 135         if (breakpoint)
 136         {
 137                 breakpoint_free(target, breakpoint);
 138         }
 139         else
 140         {
 141                 LOG_ERROR("no breakpoint at address 0x%8.8x found", address);
 142         }
 143
 144         return ERROR_OK;
 145 }
 146
 147 void breakpoint_clear_target(target_t *target)
 148 {
 149         breakpoint_t *breakpoint;
 150         while ((breakpoint = target->breakpoints)!=NULL)
 151         {
 152                 breakpoint_free(target, breakpoint);
 153         }
 154 }
 155
 156 breakpoint_t* breakpoint_find(target_t *target, u32 address)
 157 {
 158         breakpoint_t *breakpoint = target->breakpoints;
 159
 160         while (breakpoint)
 161         {
 162                 if (breakpoint->address == address)
 163                         return breakpoint;
 164                 breakpoint = breakpoint->next;
 165         }
 166
 167         return NULL;
 168 }
 169
 170 int watchpoint_add(target_t *target, u32 address, u32 length, enum watchpoint_rw rw, u32 value, u32 mask)
 171 {
 172         watchpoint_t *watchpoint = target->watchpoints;
 173         watchpoint_t **watchpoint_p = &target->watchpoints;
 174         int retval;
 175
 176         while (watchpoint)
 177         {
 178                 if (watchpoint->address == address)
 179                         return ERROR_OK;
 180                 watchpoint_p = &watchpoint->next;
 181                 watchpoint = watchpoint->next;
 182         }
 183
 184         (*watchpoint_p) = malloc(sizeof(watchpoint_t));
 185         (*watchpoint_p)->address = address;
 186         (*watchpoint_p)->length = length;
 187         (*watchpoint_p)->value = value;
 188         (*watchpoint_p)->mask = mask;
 189         (*watchpoint_p)->rw = rw;
 190         (*watchpoint_p)->set = 0;
 191         (*watchpoint_p)->next = NULL;
 192
 193         if ((retval = target->type->add_watchpoint(target, *watchpoint_p)) != ERROR_OK)
 194         {
 195                 switch (retval)
 196                 {
 197                         case ERROR_TARGET_RESOURCE_NOT_AVAILABLE:
 198                                 LOG_INFO("can't add %s watchpoint, resource not available", watchpoint_rw_strings[(*watchpoint_p)->rw]);
 199                                 free (*watchpoint_p);
 200                                 *watchpoint_p = NULL;
 201                                 return retval;
 202                                 break;
 203                         case ERROR_TARGET_NOT_HALTED:
 204                                 LOG_INFO("can't add watchpoint while target is running");
 205                                 free (*watchpoint_p);
 206                                 *watchpoint_p = NULL;
 207                                 return retval;
 208                                 break;
 209                         default:
 210                                 LOG_ERROR("unknown error");
 211                                 exit(-1);
 212                                 break;
 213                 }
 214         }
 215
 216         LOG_DEBUG("added %s watchpoint at 0x%8.8x of length 0x%8.8x",
 217                 watchpoint_rw_strings[(*watchpoint_p)->rw],
 218                 (*watchpoint_p)->address, (*watchpoint_p)->length);
 219
 220         return ERROR_OK;
 221 }
 222
 223 static void watchpoint_free(target_t *target, watchpoint_t *watchpoint_remove)
 224 {
 225         watchpoint_t *watchpoint = target->watchpoints;
 226         watchpoint_t **watchpoint_p = &target->watchpoints;
 227
 228         while (watchpoint)
 229         {
 230                 if (watchpoint == watchpoint_remove)
 231                         break;
 232                 watchpoint_p = &watchpoint->next;
 233                 watchpoint = watchpoint->next;
 234         }
 235
 236         if (watchpoint==NULL)
 237                 return;
 238         target->type->remove_watchpoint(target, watchpoint);
 239         (*watchpoint_p) = watchpoint->next;
 240         free(watchpoint);
 241 }
 242
 243
 244
 245 int watchpoint_remove(target_t *target, u32 address)
 246 {
 247         watchpoint_t *watchpoint = target->watchpoints;
 248         watchpoint_t **watchpoint_p = &target->watchpoints;
 249
 250         while (watchpoint)
 251         {
 252                 if (watchpoint->address == address)
 253                         break;
 254                 watchpoint_p = &watchpoint->next;
 255                 watchpoint = watchpoint->next;
 256         }
 257
 258         if (watchpoint)
 259         {
 260                 watchpoint_free(target, watchpoint);
 261         }
 262         else
 263         {
 264                 LOG_ERROR("no watchpoint at address 0x%8.8x found", address);
 265         }
 266
 267         return ERROR_OK;
 268 }
 269
 270
 271 void watchpoint_clear_target(target_t *target)
 272 {
 273         watchpoint_t *watchpoint;
 274         while ((watchpoint = target->watchpoints)!=NULL)
 275         {
 276                 watchpoint_free(target, watchpoint);
 277         }
 278 }