gdb/mi/mi-cmd-break.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* MI Command Set - breakpoint and watchpoint commands.
  2.    Copyright (C) 2000-2015 Free Software Foundation, Inc.
  3.    Contributed by Cygnus Solutions (a Red Hat company).

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "arch-utils.h"
  22. #include "mi-cmds.h"
  23. #include "ui-out.h"
  24. #include "mi-out.h"
  25. #include "breakpoint.h"
  26. #include "mi-getopt.h"
  27. #include "gdb.h"
  28. #include "observer.h"
  29. #include "mi-main.h"
  30. #include "mi-cmd-break.h"
  31. #include "gdb_obstack.h"
  32. #include <ctype.h>

  34. enum
  35.   {
  36.     FROM_TTY = 0
  37.   };

  39. /* True if MI breakpoint observers have been registered.  */

  41. ‌static int mi_breakpoint_observers_installed;

  43. /* Control whether breakpoint_notify may act.  */

  45. ‌static int mi_can_breakpoint_notify;

  47. /* Output a single breakpoint, when allowed.  */

  49. static void
  50. ‌breakpoint_notify (struct breakpoint *b)
  51. {
  52.   if (mi_can_breakpoint_notify)
  53.     gdb_breakpoint_query (current_uiout, b->number, NULL);
  54. }

  56. ‌enum bp_type
  57.   {
  58.     REG_BP,
  59.     HW_BP,
  60.     REGEXP_BP
  61.   };

  63. /* Arrange for all new breakpoints and catchpoints to be reported to
  64.    CURRENT_UIOUT until the cleanup returned by this function is run.

  66.    Note that MI output will be probably invalid if more than one
  67.    breakpoint is created inside one MI command.  */

  69. struct cleanup *
  70. ‌setup_breakpoint_reporting (void)
  71. {
  72.   struct cleanup *rev_flag;

  74.   if (! mi_breakpoint_observers_installed)
  75.     {
  76.       observer_attach_breakpoint_created (breakpoint_notify);
  77.       mi_breakpoint_observers_installed = 1;
  78.     }

  80.   rev_flag = make_cleanup_restore_integer (&mi_can_breakpoint_notify);
  81.   mi_can_breakpoint_notify = 1;

  83.   return rev_flag;
  84. }


  87. /* Convert arguments in ARGV to the string in "format",argv,argv...
  88.    and return it.  */

  90. static char *
  91. ‌mi_argv_to_format (char **argv, int argc)
  92. {
  93.   int i;
  94.   struct obstack obstack;
  95.   char *ret;

  97.   obstack_init (&obstack);

  99.   /* Convert ARGV[OIND + 1] to format string and save to FORMAT.  */
  100.   obstack_1grow (&obstack, '\"');
  101.   for (i = 0; i < strlen (argv[0]); i++)
  102.     {
  103.       switch (argv[0][i])
  104.         {
  105.         case '\\':
  106.           obstack_grow (&obstack, "\\\\", 2);
  107.           break;
  108.         case '\a':
  109.           obstack_grow (&obstack, "\\a", 2);
  110.           break;
  111.         case '\b':
  112.           obstack_grow (&obstack, "\\b", 2);
  113.           break;
  114.         case '\f':
  115.           obstack_grow (&obstack, "\\f", 2);
  116.           break;
  117.         case '\n':
  118.           obstack_grow (&obstack, "\\n", 2);
  119.           break;
  120.         case '\r':
  121.           obstack_grow (&obstack, "\\r", 2);
  122.           break;
  123.         case '\t':
  124.           obstack_grow (&obstack, "\\t", 2);
  125.           break;
  126.         case '\v':
  127.           obstack_grow (&obstack, "\\v", 2);
  128.           break;
  129.         case '"':
  130.           obstack_grow (&obstack, "\\\"", 2);
  131.           break;
  132.         default:
  133.           if (isprint (argv[0][i]))
  134.             obstack_grow (&obstack, argv[0] + i, 1);
  135.           else
  136.             {
  137.               char tmp[5];

  139.               xsnprintf (tmp, sizeof (tmp), "\\%o",
  140.                          (unsigned char) argv[0][i]);
  141.               obstack_grow (&obstack, tmp, strlen (tmp));
  142.             }
  143.           break;
  144.         }
  145.     }
  146.   obstack_1grow (&obstack, '\"');

  148.   /* Apply other argv to FORMAT.  */
  149.   for (i = 1; i < argc; i++)
  150.     {
  151.       obstack_1grow (&obstack, ',');
  152.       obstack_grow (&obstack, argv[i], strlen (argv[i]));
  153.     }
  154.   obstack_1grow (&obstack, '\0');

  156.   ret = xstrdup (obstack_finish (&obstack));
  157.   obstack_free (&obstack, NULL);

  159.   return ret;
  160. }

  162. /* Insert breakpoint.
  163.    If dprintf is true, it will insert dprintf.
  164.    If not, it will insert other type breakpoint.  */

  166. static void
  167. ‌mi_cmd_break_insert_1 (int dprintf, char *command, char **argv, int argc)
  168. {
  169.   char *address = NULL;
  170.   int hardware = 0;
  171.   int temp_p = 0;
  172.   int thread = -1;
  173.   int ignore_count = 0;
  174.   char *condition = NULL;
  175.   int pending = 0;
  176.   int enabled = 1;
  177.   int tracepoint = 0;
  178.   struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
  179.   enum bptype type_wanted;
  180.   struct breakpoint_ops *ops;
  181.   char *extra_string = NULL;

  183.   enum opt
  184.     {
  185.       HARDWARE_OPT, TEMP_OPT, CONDITION_OPT,
  186.       IGNORE_COUNT_OPT, THREAD_OPT, PENDING_OPT, DISABLE_OPT,
  187.       TRACEPOINT_OPT,
  188.     };
  189.   static const struct mi_opt opts[] =
  190.   {
  191.     {"h", HARDWARE_OPT, 0},
  192.     {"t", TEMP_OPT, 0},
  193.     {"c", CONDITION_OPT, 1},
  194.     {"i", IGNORE_COUNT_OPT, 1},
  195.     {"p", THREAD_OPT, 1},
  196.     {"f", PENDING_OPT, 0},
  197.     {"d", DISABLE_OPT, 0},
  198.     {"a", TRACEPOINT_OPT, 0},
  199.     { 0, 0, 0 }
  200.   };

  202.   /* Parse arguments. It could be -r or -h or -t, <location> or ``--''
  203.      to denote the end of the option list. */
  204.   int oind = 0;
  205.   char *oarg;

  207.   while (1)
  208.     {
  209.       int opt = mi_getopt ("-break-insert", argc, argv,
  210.                            opts, &oind, &oarg);
  211.       if (opt < 0)
  212.         break;
  213.       switch ((enum opt) opt)
  214.         {
  215.         case TEMP_OPT:
  216.           temp_p = 1;
  217.           break;
  218.         case HARDWARE_OPT:
  219.           hardware = 1;
  220.           break;
  221.         case CONDITION_OPT:
  222.           condition = oarg;
  223.           break;
  224.         case IGNORE_COUNT_OPT:
  225.           ignore_count = atol (oarg);
  226.           break;
  227.         case THREAD_OPT:
  228.           thread = atol (oarg);
  229.           break;
  230.         case PENDING_OPT:
  231.           pending = 1;
  232.           break;
  233.         case DISABLE_OPT:
  234.           enabled = 0;
  235.           break;
  236.         case TRACEPOINT_OPT:
  237.           tracepoint = 1;
  238.           break;
  239.         }
  240.     }

  242.   if (oind >= argc)
  243.     error (_("-%s-insert: Missing <location>"),
  244.            dprintf ? "dprintf" : "break");
  245.   address = argv[oind];
  246.   if (dprintf)
  247.     {
  248.       int format_num = oind + 1;

  250.       if (hardware || tracepoint)
  251.         error (_("-dprintf-insert: does not support -h or -a"));
  252.       if (format_num >= argc)
  253.         error (_("-dprintf-insert: Missing <format>"));

  255.       extra_string = mi_argv_to_format (argv + format_num, argc - format_num);
  256.       make_cleanup (xfree, extra_string);
  257.     }
  258.   else
  259.     {
  260.       if (oind < argc - 1)
  261.         error (_("-break-insert: Garbage following <location>"));
  262.     }

  264.   /* Now we have what we need, let's insert the breakpoint!  */
  265.   setup_breakpoint_reporting ();

  267.   if (tracepoint)
  268.     {
  269.       /* Note that to request a fast tracepoint, the client uses the
  270.          "hardware" flag, although there's nothing of hardware related to
  271.          fast tracepoints -- one can implement slow tracepoints with
  272.          hardware breakpoints, but fast tracepoints are always software.
  273.          "fast" is a misnomer, actually, "jump" would be more appropriate.
  274.          A simulator or an emulator could conceivably implement fast
  275.          regular non-jump based tracepoints.  */
  276.       type_wanted = hardware ? bp_fast_tracepoint : bp_tracepoint;
  277.       ops = &tracepoint_breakpoint_ops;
  278.     }
  279.   else if (dprintf)
  280.     {
  281.       type_wanted = bp_dprintf;
  282.       ops = &dprintf_breakpoint_ops;
  283.     }
  284.   else
  285.     {
  286.       type_wanted = hardware ? bp_hardware_breakpoint : bp_breakpoint;
  287.       ops = &bkpt_breakpoint_ops;
  288.     }

  290.   create_breakpoint (get_current_arch (), address, condition, thread,
  291.                      extra_string,
  292.                      0 /* condition and thread are valid.  */,
  293.                      temp_p, type_wanted,
  294.                      ignore_count,
  295.                      pending ? AUTO_BOOLEAN_TRUE : AUTO_BOOLEAN_FALSE,
  296.                      ops, 0, enabled, 0, 0);
  297.   do_cleanups (back_to);
  298. }

  300. /* Implements the -break-insert command.
  301.    See the MI manual for the list of possible options.  */

  303. void
  304. ‌mi_cmd_break_insert (char *command, char **argv, int argc)
  305. {
  306.   mi_cmd_break_insert_1 (0, command, argv, argc);
  307. }

  309. /* Implements the -dprintf-insert command.
  310.    See the MI manual for the list of possible options.  */

  312. void
  313. ‌mi_cmd_dprintf_insert (char *command, char **argv, int argc)
  314. {
  315.   mi_cmd_break_insert_1 (1, command, argv, argc);
  316. }

  318. ‌enum wp_type
  319. {
  320.   REG_WP,
  321.   READ_WP,
  322.   ACCESS_WP
  323. };

  325. void
  326. ‌mi_cmd_break_passcount (char *command, char **argv, int argc)
  327. {
  328.   int n;
  329.   int p;
  330.   struct tracepoint *t;

  332.   if (argc != 2)
  333.     error (_("Usage: tracepoint-number passcount"));

  335.   n = atoi (argv[0]);
  336.   p = atoi (argv[1]);
  337.   t = get_tracepoint (n);

  339.   if (t)
  340.     {
  341.       t->pass_count = p;
  342.       observer_notify_breakpoint_modified (&t->base);
  343.     }
  344.   else
  345.     {
  346.       error (_("Could not find tracepoint %d"), n);
  347.     }
  348. }

  350. /* Insert a watchpoint. The type of watchpoint is specified by the
  351.    first argument:
  352.    -break-watch <expr> --> insert a regular wp.
  353.    -break-watch -r <expr> --> insert a read watchpoint.
  354.    -break-watch -a <expr> --> insert an access wp.  */

  356. void
  357. ‌mi_cmd_break_watch (char *command, char **argv, int argc)
  358. {
  359.   char *expr = NULL;
  360.   enum wp_type type = REG_WP;
  361.   enum opt
  362.     {
  363.       READ_OPT, ACCESS_OPT
  364.     };
  365.   static const struct mi_opt opts[] =
  366.   {
  367.     {"r", READ_OPT, 0},
  368.     {"a", ACCESS_OPT, 0},
  369.     { 0, 0, 0 }
  370.   };

  372.   /* Parse arguments. */
  373.   int oind = 0;
  374.   char *oarg;

  376.   while (1)
  377.     {
  378.       int opt = mi_getopt ("-break-watch", argc, argv,
  379.                            opts, &oind, &oarg);

  381.       if (opt < 0)
  382.         break;
  383.       switch ((enum opt) opt)
  384.         {
  385.         case READ_OPT:
  386.           type = READ_WP;
  387.           break;
  388.         case ACCESS_OPT:
  389.           type = ACCESS_WP;
  390.           break;
  391.         }
  392.     }
  393.   if (oind >= argc)
  394.     error (_("-break-watch: Missing <expression>"));
  395.   if (oind < argc - 1)
  396.     error (_("-break-watch: Garbage following <expression>"));
  397.   expr = argv[oind];

  399.   /* Now we have what we need, let's insert the watchpoint!  */
  400.   switch (type)
  401.     {
  402.     case REG_WP:
  403.       watch_command_wrapper (expr, FROM_TTY, 0);
  404.       break;
  405.     case READ_WP:
  406.       rwatch_command_wrapper (expr, FROM_TTY, 0);
  407.       break;
  408.     case ACCESS_WP:
  409.       awatch_command_wrapper (expr, FROM_TTY, 0);
  410.       break;
  411.     default:
  412.       error (_("-break-watch: Unknown watchpoint type."));
  413.     }
  414. }

  416. /* The mi_read_next_line consults these variable to return successive
  417.    command lines.  While it would be clearer to use a closure pointer,
  418.    it is not expected that any future code will use read_command_lines_1,
  419.    therefore no point of overengineering.  */

  421. ‌static char **mi_command_line_array;
  422. ‌static int mi_command_line_array_cnt;
  423. ‌static int mi_command_line_array_ptr;

  425. static char *
  426. ‌mi_read_next_line (void)
  427. {
  428.   if (mi_command_line_array_ptr == mi_command_line_array_cnt)
  429.     return NULL;
  430.   else
  431.     return mi_command_line_array[mi_command_line_array_ptr++];
  432. }

  434. void
  435. ‌mi_cmd_break_commands (char *command, char **argv, int argc)
  436. {
  437.   struct command_line *break_command;
  438.   char *endptr;
  439.   int bnum;
  440.   struct breakpoint *b;

  442.   if (argc < 1)
  443.     error (_("USAGE: %s <BKPT> [<COMMAND> [<COMMAND>...]]"), command);

  445.   bnum = strtol (argv[0], &endptr, 0);
  446.   if (endptr == argv[0])
  447.     error (_("breakpoint number argument \"%s\" is not a number."),
  448.            argv[0]);
  449.   else if (*endptr != '\0')
  450.     error (_("junk at the end of breakpoint number argument \"%s\"."),
  451.            argv[0]);

  453.   b = get_breakpoint (bnum);
  454.   if (b == NULL)
  455.     error (_("breakpoint %d not found."), bnum);

  457.   mi_command_line_array = argv;
  458.   mi_command_line_array_ptr = 1;
  459.   mi_command_line_array_cnt = argc;

  461.   if (is_tracepoint (b))
  462.     break_command = read_command_lines_1 (mi_read_next_line, 1,
  463.                                           check_tracepoint_command, b);
  464.   else
  465.     break_command = read_command_lines_1 (mi_read_next_line, 1, 0, 0);

  467.   breakpoint_set_commands (b, break_command);
  468. }