OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [mi/] [mi-cmd-break.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* 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
enum mi_cmd_result
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
 
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
          return MI_CMD_DONE;
160
          break;
161
#endif
162
        default:
163
          internal_error (__FILE__, __LINE__,
164
                          _("mi_cmd_break_insert: Bad switch."));
165
        }
166
    }
167
  deprecated_set_gdb_event_hooks (old_hooks);
168
  if (e.reason < 0)
169
    throw_exception (e);
170
 
171
  return MI_CMD_DONE;
172
}
173
 
174
enum wp_type
175
{
176
  REG_WP,
177
  READ_WP,
178
  ACCESS_WP
179
};
180
 
181
/* Insert a watchpoint. The type of watchpoint is specified by the
182
   first argument:
183
   -break-watch <expr> --> insert a regular wp.
184
   -break-watch -r <expr> --> insert a read watchpoint.
185
   -break-watch -a <expr> --> insert an access wp. */
186
 
187
enum mi_cmd_result
188
mi_cmd_break_watch (char *command, char **argv, int argc)
189
{
190
  char *expr = NULL;
191
  enum wp_type type = REG_WP;
192
  enum opt
193
    {
194
      READ_OPT, ACCESS_OPT
195
    };
196
  static struct mi_opt opts[] =
197
  {
198
    {"r", READ_OPT, 0},
199
    {"a", ACCESS_OPT, 0},
200
    { 0, 0, 0 }
201
  };
202
 
203
  /* Parse arguments. */
204
  int optind = 0;
205
  char *optarg;
206
  while (1)
207
    {
208
      int opt = mi_getopt ("mi_cmd_break_watch", argc, argv, opts, &optind, &optarg);
209
      if (opt < 0)
210
        break;
211
      switch ((enum opt) opt)
212
        {
213
        case READ_OPT:
214
          type = READ_WP;
215
          break;
216
        case ACCESS_OPT:
217
          type = ACCESS_WP;
218
          break;
219
        }
220
    }
221
  if (optind >= argc)
222
    error (_("mi_cmd_break_watch: Missing <expression>"));
223
  if (optind < argc - 1)
224
    error (_("mi_cmd_break_watch: Garbage following <expression>"));
225
  expr = argv[optind];
226
 
227
  /* Now we have what we need, let's insert the watchpoint! */
228
  switch (type)
229
    {
230
    case REG_WP:
231
      watch_command_wrapper (expr, FROM_TTY);
232
      break;
233
    case READ_WP:
234
      rwatch_command_wrapper (expr, FROM_TTY);
235
      break;
236
    case ACCESS_WP:
237
      awatch_command_wrapper (expr, FROM_TTY);
238
      break;
239
    default:
240
      error (_("mi_cmd_break_watch: Unknown watchpoint type."));
241
    }
242
  return MI_CMD_DONE;
243
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.