gdb/mi/mi-cmd-break.c

   1 /* MI Command Set - breakpoint and watchpoint commands.
   2    Copyright (C) 2000, 2001, 2002, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "mi-cmds.h"
  22 #include "ui-out.h"
  23 #include "mi-out.h"
  24 #include "breakpoint.h"
  25 #include "gdb_string.h"
  26 #include "mi-getopt.h"
  27 #include "gdb-events.h"
  28 #include "gdb.h"
  29 #include "exceptions.h"
  30
  31 enum
  32   {
  33     FROM_TTY = 0
  34   };
  35
  36 /* Output a single breakpoint. */
  37
  38 static void
  39 breakpoint_notify (int b)
  40 {
  41   gdb_breakpoint_query (uiout, b, NULL);
  42 }
  43
  44
  45 struct gdb_events breakpoint_hooks =
  46 {
  47   breakpoint_notify,
  48   breakpoint_notify,
  49   breakpoint_notify,
  50 };
  51
  52
  53 enum bp_type
  54   {
  55     REG_BP,
  56     HW_BP,
  57     REGEXP_BP
  58   };
  59
  60 /* Implements the -break-insert command.
  61    See the MI manual for the list of possible options.  */
  62
  63 void
  64 mi_cmd_break_insert (char *command, char **argv, int argc)
  65 {
  66   char *address = NULL;
  67   enum bp_type type = REG_BP;
  68   int temp_p = 0;
  69   int thread = -1;
  70   int ignore_count = 0;
  71   char *condition = NULL;
  72   int pending = 0;
  73   struct gdb_exception e;
  74   struct gdb_events *old_hooks;
  75   enum opt
  76     {
  77       HARDWARE_OPT, TEMP_OPT /*, REGEXP_OPT */ , CONDITION_OPT,
  78       IGNORE_COUNT_OPT, THREAD_OPT, PENDING_OPT
  79     };
  80   static struct mi_opt opts[] =
  81   {
  82     {"h", HARDWARE_OPT, 0},
  83     {"t", TEMP_OPT, 0},
  84     {"c", CONDITION_OPT, 1},
  85     {"i", IGNORE_COUNT_OPT, 1},
  86     {"p", THREAD_OPT, 1},
  87     {"f", PENDING_OPT, 0},
  88     { 0, 0, 0 }
  89   };
  90
  91   /* Parse arguments. It could be -r or -h or -t, <location> or ``--''
  92      to denote the end of the option list. */
  93   int optind = 0;
  94   char *optarg;
  95   while (1)
  96     {
  97       int opt = mi_getopt ("mi_cmd_break_insert", argc, argv, opts, &optind, &optarg);
  98       if (opt < 0)
  99         break;
 100       switch ((enum opt) opt)
 101         {
 102         case TEMP_OPT:
 103           temp_p = 1;
 104           break;
 105         case HARDWARE_OPT:
 106           type = HW_BP;
 107           break;
 108 #if 0
 109         case REGEXP_OPT:
 110           type = REGEXP_BP;
 111           break;
 112 #endif
 113         case CONDITION_OPT:
 114           condition = optarg;
 115           break;
 116         case IGNORE_COUNT_OPT:
 117           ignore_count = atol (optarg);
 118           break;
 119         case THREAD_OPT:
 120           thread = atol (optarg);
 121           break;
 122         case PENDING_OPT:
 123           pending = 1;
 124           break;
 125         }
 126     }
 127
 128   if (optind >= argc)
 129     error (_("mi_cmd_break_insert: Missing <location>"));
 130   if (optind < argc - 1)
 131     error (_("mi_cmd_break_insert: Garbage following <location>"));
 132   address = argv[optind];
 133
 134   /* Now we have what we need, let's insert the breakpoint! */
 135   old_hooks = deprecated_set_gdb_event_hooks (&breakpoint_hooks);
 136   /* Make sure we restore hooks even if exception is thrown.  */
 137   TRY_CATCH (e, RETURN_MASK_ALL)
 138     {
 139       switch (type)
 140         {
 141         case REG_BP:
 142           set_breakpoint (address, condition,
 143                           0 /*hardwareflag */ , temp_p,
 144                           thread, ignore_count,
 145                           pending);
 146           break;
 147         case HW_BP:
 148           set_breakpoint (address, condition,
 149                           1 /*hardwareflag */ , temp_p,
 150                           thread, ignore_count,
 151                           pending);
 152           break;
 153 #if 0
 154         case REGEXP_BP:
 155           if (temp_p)
 156             error (_("mi_cmd_break_insert: Unsupported tempoary regexp breakpoint"));
 157           else
 158             rbreak_command_wrapper (address, FROM_TTY);
 159           break;
 160 #endif
 161         default:
 162           internal_error (__FILE__, __LINE__,
 163                           _("mi_cmd_break_insert: Bad switch."));
 164         }
 165     }
 166   deprecated_set_gdb_event_hooks (old_hooks);
 167   if (e.reason < 0)
 168     throw_exception (e);
 169 }
 170
 171 enum wp_type
 172 {
 173   REG_WP,
 174   READ_WP,
 175   ACCESS_WP
 176 };
 177
 178 /* Insert a watchpoint. The type of watchpoint is specified by the
 179    first argument:
 180    -break-watch <expr> --> insert a regular wp.
 181    -break-watch -r <expr> --> insert a read watchpoint.
 182    -break-watch -a <expr> --> insert an access wp. */
 183
 184 void
 185 mi_cmd_break_watch (char *command, char **argv, int argc)
 186 {
 187   char *expr = NULL;
 188   enum wp_type type = REG_WP;
 189   enum opt
 190     {
 191       READ_OPT, ACCESS_OPT
 192     };
 193   static struct mi_opt opts[] =
 194   {
 195     {"r", READ_OPT, 0},
 196     {"a", ACCESS_OPT, 0},
 197     { 0, 0, 0 }
 198   };
 199
 200   /* Parse arguments. */
 201   int optind = 0;
 202   char *optarg;
 203   while (1)
 204     {
 205       int opt = mi_getopt ("mi_cmd_break_watch", argc, argv, opts, &optind, &optarg);
 206       if (opt < 0)
 207         break;
 208       switch ((enum opt) opt)
 209         {
 210         case READ_OPT:
 211           type = READ_WP;
 212           break;
 213         case ACCESS_OPT:
 214           type = ACCESS_WP;
 215           break;
 216         }
 217     }
 218   if (optind >= argc)
 219     error (_("mi_cmd_break_watch: Missing <expression>"));
 220   if (optind < argc - 1)
 221     error (_("mi_cmd_break_watch: Garbage following <expression>"));
 222   expr = argv[optind];
 223
 224   /* Now we have what we need, let's insert the watchpoint! */
 225   switch (type)
 226     {
 227     case REG_WP:
 228       watch_command_wrapper (expr, FROM_TTY);
 229       break;
 230     case READ_WP:
 231       rwatch_command_wrapper (expr, FROM_TTY);
 232       break;
 233     case ACCESS_WP:
 234       awatch_command_wrapper (expr, FROM_TTY);
 235       break;
 236     default:
 237       error (_("mi_cmd_break_watch: Unknown watchpoint type."));
 238     }
 239 }