gdb/mi/mi-cmd-break.c

   1 /* MI Command Set - breakpoint and watchpoint commands.
   2    Copyright 2000, 2001 Free Software Foundation, Inc.
   3    Contributed by Cygnus Solutions (a Red Hat company).
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "mi-cmds.h"
  24 #include "ui-out.h"
  25 #include "mi-out.h"
  26 #include "breakpoint.h"
  27 #include "gdb_string.h"
  28 #include "mi-getopt.h"
  29 #include "gdb-events.h"
  30
  31 /* Convenience macro for allocting typesafe memory. */
  32
  33 #undef XMALLOC
  34 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
  35
  36 enum
  37   {
  38     FROM_TTY = 0
  39   };
  40
  41 /* Output a single breakpoint. */
  42
  43 static void
  44 breakpoint_notify (int b)
  45 {
  46   gdb_breakpoint_query (b);
  47 }
  48
  49
  50 struct gdb_events breakpoint_hooks =
  51 {
  52   breakpoint_notify,
  53   breakpoint_notify,
  54   breakpoint_notify,
  55 };
  56
  57
  58 enum bp_type
  59   {
  60     REG_BP,
  61     HW_BP,
  62     REGEXP_BP
  63   };
  64
  65 /* Insert a breakpoint. The type of breakpoint is specified by the
  66    first argument: -break-insert <location> --> insert a regular
  67    breakpoint.  -break-insert -t <location> --> insert a temporary
  68    breakpoint.  -break-insert -h <location> --> insert an hardware
  69    breakpoint.  -break-insert -t -h <location> --> insert a temporary
  70    hw bp.
  71    -break-insert -r <regexp> --> insert a bp at functions matching
  72    <regexp> */
  73
  74 enum mi_cmd_result
  75 mi_cmd_break_insert (char *command, char **argv, int argc)
  76 {
  77   char *address = NULL;
  78   enum bp_type type = REG_BP;
  79   int temp_p = 0;
  80   int thread = -1;
  81   int ignore_count = 0;
  82   char *condition = NULL;
  83   enum gdb_rc rc;
  84   struct gdb_events *old_hooks;
  85   enum opt
  86     {
  87       HARDWARE_OPT, TEMP_OPT /*, REGEXP_OPT */ , CONDITION_OPT,
  88       IGNORE_COUNT_OPT, THREAD_OPT
  89     };
  90   static struct mi_opt opts[] =
  91   {
  92     {"h", HARDWARE_OPT, 0},
  93     {"t", TEMP_OPT, 0},
  94     {"c", CONDITION_OPT, 1},
  95     {"i", IGNORE_COUNT_OPT, 1},
  96     {"p", THREAD_OPT, 1},
  97     0
  98   };
  99
 100   /* Parse arguments. It could be -r or -h or -t, <location> or ``--''
 101      to denote the end of the option list. */
 102   int optind = 0;
 103   char *optarg;
 104   while (1)
 105     {
 106       int opt = mi_getopt ("mi_cmd_break_insert", argc, argv, opts, &optind, &optarg);
 107       if (opt < 0)
 108         break;
 109       switch ((enum opt) opt)
 110         {
 111         case TEMP_OPT:
 112           temp_p = 1;
 113           break;
 114         case HARDWARE_OPT:
 115           type = HW_BP;
 116           break;
 117 #if 0
 118         case REGEXP_OPT:
 119           type = REGEXP_BP;
 120           break;
 121 #endif
 122         case CONDITION_OPT:
 123           condition = optarg;
 124           break;
 125         case IGNORE_COUNT_OPT:
 126           ignore_count = atol (optarg);
 127           break;
 128         case THREAD_OPT:
 129           thread = atol (optarg);
 130           break;
 131         }
 132     }
 133
 134   if (optind >= argc)
 135     error ("mi_cmd_break_insert: Missing <location>");
 136   if (optind < argc - 1)
 137     error ("mi_cmd_break_insert: Garbage following <location>");
 138   address = argv[optind];
 139
 140   /* Now we have what we need, let's insert the breakpoint! */
 141   old_hooks = set_gdb_event_hooks (&breakpoint_hooks);
 142   switch (type)
 143     {
 144     case REG_BP:
 145       rc = gdb_breakpoint (address, condition,
 146                            0 /*hardwareflag */ , temp_p,
 147                            thread, ignore_count);
 148       break;
 149     case HW_BP:
 150       rc = gdb_breakpoint (address, condition,
 151                            1 /*hardwareflag */ , temp_p,
 152                            thread, ignore_count);
 153       break;
 154 #if 0
 155     case REGEXP_BP:
 156       if (temp_p)
 157         error ("mi_cmd_break_insert: Unsupported tempoary regexp breakpoint");
 158       else
 159         rbreak_command_wrapper (address, FROM_TTY);
 160       return MI_CMD_DONE;
 161       break;
 162 #endif
 163     default:
 164       internal_error (__FILE__, __LINE__,
 165                       "mi_cmd_break_insert: Bad switch.");
 166     }
 167   set_gdb_event_hooks (old_hooks);
 168
 169   if (rc == GDB_RC_FAIL)
 170     return MI_CMD_CAUGHT_ERROR;
 171   else
 172     return MI_CMD_DONE;
 173 }
 174
 175 enum wp_type
 176 {
 177   REG_WP,
 178   READ_WP,
 179   ACCESS_WP
 180 };
 181
 182 /* Insert a watchpoint. The type of watchpoint is specified by the
 183    first argument:
 184    -break-watch <expr> --> insert a regular wp.
 185    -break-watch -r <expr> --> insert a read watchpoint.
 186    -break-watch -a <expr> --> insert an access wp. */
 187
 188 enum mi_cmd_result
 189 mi_cmd_break_watch (char *command, char **argv, int argc)
 190 {
 191   char *expr = NULL;
 192   enum wp_type type = REG_WP;
 193   enum opt
 194     {
 195       READ_OPT, ACCESS_OPT
 196     };
 197   static struct mi_opt opts[] =
 198   {
 199     {"r", READ_OPT, 0},
 200     {"a", ACCESS_OPT, 0},
 201     0
 202   };
 203
 204   /* Parse arguments. */
 205   int optind = 0;
 206   char *optarg;
 207   while (1)
 208     {
 209       int opt = mi_getopt ("mi_cmd_break_watch", argc, argv, opts, &optind, &optarg);
 210       if (opt < 0)
 211         break;
 212       switch ((enum opt) opt)
 213         {
 214         case READ_OPT:
 215           type = READ_WP;
 216           break;
 217         case ACCESS_OPT:
 218           type = ACCESS_WP;
 219           break;
 220         }
 221     }
 222   if (optind >= argc)
 223     error ("mi_cmd_break_watch: Missing <expression>");
 224   if (optind < argc - 1)
 225     error ("mi_cmd_break_watch: Garbage following <expression>");
 226   expr = argv[optind];
 227
 228   /* Now we have what we need, let's insert the watchpoint! */
 229   switch (type)
 230     {
 231     case REG_WP:
 232 #ifdef UI_OUT
 233       watch_command_wrapper (expr, FROM_TTY);
 234 #endif
 235       break;
 236     case READ_WP:
 237 #ifdef UI_OUT
 238       rwatch_command_wrapper (expr, FROM_TTY);
 239 #endif
 240       break;
 241     case ACCESS_WP:
 242 #ifdef UI_OUT
 243       awatch_command_wrapper (expr, FROM_TTY);
 244 #endif
 245       break;
 246     default:
 247       error ("mi_cmd_break_watch: Unknown watchpoint type.");
 248     }
 249   return MI_CMD_DONE;
 250 }