xref: /openbsd/gnu/usr.bin/binutils/gdb/mi/mi-main.c (revision 404b540a)
1 /* MI Command Set.
2 
3    Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
4    Inc.
5 
6    Contributed by Cygnus Solutions (a Red Hat company).
7 
8    This file is part of GDB.
9 
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14 
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19 
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place - Suite 330,
23    Boston, MA 02111-1307, USA.  */
24 
25 /* Work in progress */
26 
27 #include "defs.h"
28 #include "target.h"
29 #include "inferior.h"
30 #include "gdb_string.h"
31 #include "top.h"
32 #include "gdbthread.h"
33 #include "mi-cmds.h"
34 #include "mi-parse.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
37 #include "ui-out.h"
38 #include "mi-out.h"
39 #include "interps.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h"		/* for write_memory() */
43 #include "value.h"		/* for deprecated_write_register_bytes() */
44 #include "regcache.h"
45 #include "gdb.h"
46 #include "frame.h"
47 #include "mi-main.h"
48 
49 #include <ctype.h>
50 #include <sys/time.h>
51 
52 enum
53   {
54     FROM_TTY = 0
55   };
56 
57 /* Enumerations of the actions that may result from calling
58    captured_mi_execute_command */
59 
60 enum captured_mi_execute_command_actions
61   {
62     EXECUTE_COMMAND_DISPLAY_PROMPT,
63     EXECUTE_COMMAND_SUPRESS_PROMPT,
64     EXECUTE_COMMAND_DISPLAY_ERROR
65   };
66 
67 /* This structure is used to pass information from captured_mi_execute_command
68    to mi_execute_command. */
69 struct captured_mi_execute_command_args
70 {
71   /* This return result of the MI command (output) */
72   enum mi_cmd_result rc;
73 
74   /* What action to perform when the call is finished (output) */
75   enum captured_mi_execute_command_actions action;
76 
77   /* The command context to be executed (input) */
78   struct mi_parse *command;
79 };
80 
81 int mi_debug_p;
82 struct ui_file *raw_stdout;
83 
84 /* The token of the last asynchronous command */
85 static char *last_async_command;
86 static char *previous_async_command;
87 char *mi_error_message;
88 static char *old_regs;
89 
90 extern void _initialize_mi_main (void);
91 static enum mi_cmd_result mi_cmd_execute (struct mi_parse *parse);
92 
93 static void mi_execute_cli_command (const char *cmd, int args_p,
94 				    const char *args);
95 static enum mi_cmd_result mi_execute_async_cli_command (char *mi, char *args, int from_tty);
96 
97 static void mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg);
98 
99 static int register_changed_p (int regnum);
100 static int get_register (int regnum, int format);
101 
102 /* Command implementations. FIXME: Is this libgdb? No.  This is the MI
103    layer that calls libgdb.  Any operation used in the below should be
104    formalized. */
105 
106 enum mi_cmd_result
107 mi_cmd_gdb_exit (char *command, char **argv, int argc)
108 {
109   /* We have to print everything right here because we never return */
110   if (last_async_command)
111     fputs_unfiltered (last_async_command, raw_stdout);
112   fputs_unfiltered ("^exit\n", raw_stdout);
113   mi_out_put (uiout, raw_stdout);
114   /* FIXME: The function called is not yet a formal libgdb function */
115   quit_force (NULL, FROM_TTY);
116   return MI_CMD_DONE;
117 }
118 
119 enum mi_cmd_result
120 mi_cmd_exec_run (char *args, int from_tty)
121 {
122   /* FIXME: Should call a libgdb function, not a cli wrapper */
123   return mi_execute_async_cli_command ("run", args, from_tty);
124 }
125 
126 enum mi_cmd_result
127 mi_cmd_exec_next (char *args, int from_tty)
128 {
129   /* FIXME: Should call a libgdb function, not a cli wrapper */
130   return mi_execute_async_cli_command ("next", args, from_tty);
131 }
132 
133 enum mi_cmd_result
134 mi_cmd_exec_next_instruction (char *args, int from_tty)
135 {
136   /* FIXME: Should call a libgdb function, not a cli wrapper */
137   return mi_execute_async_cli_command ("nexti", args, from_tty);
138 }
139 
140 enum mi_cmd_result
141 mi_cmd_exec_step (char *args, int from_tty)
142 {
143   /* FIXME: Should call a libgdb function, not a cli wrapper */
144   return mi_execute_async_cli_command ("step", args, from_tty);
145 }
146 
147 enum mi_cmd_result
148 mi_cmd_exec_step_instruction (char *args, int from_tty)
149 {
150   /* FIXME: Should call a libgdb function, not a cli wrapper */
151   return mi_execute_async_cli_command ("stepi", args, from_tty);
152 }
153 
154 enum mi_cmd_result
155 mi_cmd_exec_finish (char *args, int from_tty)
156 {
157   /* FIXME: Should call a libgdb function, not a cli wrapper */
158   return mi_execute_async_cli_command ("finish", args, from_tty);
159 }
160 
161 enum mi_cmd_result
162 mi_cmd_exec_until (char *args, int from_tty)
163 {
164   /* FIXME: Should call a libgdb function, not a cli wrapper */
165   return mi_execute_async_cli_command ("until", args, from_tty);
166 }
167 
168 enum mi_cmd_result
169 mi_cmd_exec_return (char *args, int from_tty)
170 {
171   /* This command doesn't really execute the target, it just pops the
172      specified number of frames. */
173   if (*args)
174     /* Call return_command with from_tty argument equal to 0 so as to
175        avoid being queried. */
176     return_command (args, 0);
177   else
178     /* Call return_command with from_tty argument equal to 0 so as to
179        avoid being queried. */
180     return_command (NULL, 0);
181 
182   /* Because we have called return_command with from_tty = 0, we need
183      to print the frame here. */
184   print_stack_frame (get_selected_frame (), 1, LOC_AND_ADDRESS);
185 
186   return MI_CMD_DONE;
187 }
188 
189 enum mi_cmd_result
190 mi_cmd_exec_continue (char *args, int from_tty)
191 {
192   /* FIXME: Should call a libgdb function, not a cli wrapper */
193   return mi_execute_async_cli_command ("continue", args, from_tty);
194 }
195 
196 /* Interrupt the execution of the target. Note how we must play around
197    with the token varialbes, in order to display the current token in
198    the result of the interrupt command, and the previous execution
199    token when the target finally stops. See comments in
200    mi_cmd_execute. */
201 enum mi_cmd_result
202 mi_cmd_exec_interrupt (char *args, int from_tty)
203 {
204   if (!target_executing)
205     {
206       mi_error_message = xstrprintf ("mi_cmd_exec_interrupt: Inferior not executing.");
207       return MI_CMD_ERROR;
208     }
209   interrupt_target_command (args, from_tty);
210   if (last_async_command)
211     fputs_unfiltered (last_async_command, raw_stdout);
212   fputs_unfiltered ("^done", raw_stdout);
213   xfree (last_async_command);
214   if (previous_async_command)
215     last_async_command = xstrdup (previous_async_command);
216   xfree (previous_async_command);
217   previous_async_command = NULL;
218   mi_out_put (uiout, raw_stdout);
219   mi_out_rewind (uiout);
220   fputs_unfiltered ("\n", raw_stdout);
221   return MI_CMD_QUIET;
222 }
223 
224 enum mi_cmd_result
225 mi_cmd_thread_select (char *command, char **argv, int argc)
226 {
227   enum gdb_rc rc;
228 
229   if (argc != 1)
230     {
231       mi_error_message = xstrprintf ("mi_cmd_thread_select: USAGE: threadnum.");
232       return MI_CMD_ERROR;
233     }
234   else
235     rc = gdb_thread_select (uiout, argv[0]);
236 
237   /* RC is enum gdb_rc if it is successful (>=0)
238      enum return_reason if not (<0). */
239   if ((int) rc < 0 && (enum return_reason) rc == RETURN_ERROR)
240     return MI_CMD_CAUGHT_ERROR;
241   else if ((int) rc >= 0 && rc == GDB_RC_FAIL)
242     return MI_CMD_ERROR;
243   else
244     return MI_CMD_DONE;
245 }
246 
247 enum mi_cmd_result
248 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
249 {
250   enum gdb_rc rc = MI_CMD_DONE;
251 
252   if (argc != 0)
253     {
254       mi_error_message = xstrprintf ("mi_cmd_thread_list_ids: No arguments required.");
255       return MI_CMD_ERROR;
256     }
257   else
258     rc = gdb_list_thread_ids (uiout);
259 
260   if (rc == GDB_RC_FAIL)
261     return MI_CMD_CAUGHT_ERROR;
262   else
263     return MI_CMD_DONE;
264 }
265 
266 enum mi_cmd_result
267 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
268 {
269   int regnum, numregs;
270   int i;
271   struct cleanup *cleanup;
272 
273   /* Note that the test for a valid register must include checking the
274      REGISTER_NAME because NUM_REGS may be allocated for the union of
275      the register sets within a family of related processors.  In this
276      case, some entries of REGISTER_NAME will change depending upon
277      the particular processor being debugged.  */
278 
279   numregs = NUM_REGS + NUM_PSEUDO_REGS;
280 
281   cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
282 
283   if (argc == 0)		/* No args, just do all the regs */
284     {
285       for (regnum = 0;
286 	   regnum < numregs;
287 	   regnum++)
288 	{
289 	  if (REGISTER_NAME (regnum) == NULL
290 	      || *(REGISTER_NAME (regnum)) == '\0')
291 	    ui_out_field_string (uiout, NULL, "");
292 	  else
293 	    ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
294 	}
295     }
296 
297   /* Else, list of register #s, just do listed regs */
298   for (i = 0; i < argc; i++)
299     {
300       regnum = atoi (argv[i]);
301       if (regnum < 0 || regnum >= numregs)
302 	{
303 	  do_cleanups (cleanup);
304 	  mi_error_message = xstrprintf ("bad register number");
305 	  return MI_CMD_ERROR;
306 	}
307       if (REGISTER_NAME (regnum) == NULL
308 	  || *(REGISTER_NAME (regnum)) == '\0')
309 	ui_out_field_string (uiout, NULL, "");
310       else
311 	ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
312     }
313   do_cleanups (cleanup);
314   return MI_CMD_DONE;
315 }
316 
317 enum mi_cmd_result
318 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
319 {
320   int regnum, numregs, changed;
321   int i;
322   struct cleanup *cleanup;
323 
324   /* Note that the test for a valid register must include checking the
325      REGISTER_NAME because NUM_REGS may be allocated for the union of
326      the register sets within a family of related processors.  In this
327      case, some entries of REGISTER_NAME will change depending upon
328      the particular processor being debugged.  */
329 
330   numregs = NUM_REGS + NUM_PSEUDO_REGS;
331 
332   cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
333 
334   if (argc == 0)		/* No args, just do all the regs */
335     {
336       for (regnum = 0;
337 	   regnum < numregs;
338 	   regnum++)
339 	{
340 	  if (REGISTER_NAME (regnum) == NULL
341 	      || *(REGISTER_NAME (regnum)) == '\0')
342 	    continue;
343 	  changed = register_changed_p (regnum);
344 	  if (changed < 0)
345 	    {
346 	      do_cleanups (cleanup);
347 	      mi_error_message = xstrprintf ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
348 	      return MI_CMD_ERROR;
349 	    }
350 	  else if (changed)
351 	    ui_out_field_int (uiout, NULL, regnum);
352 	}
353     }
354 
355   /* Else, list of register #s, just do listed regs */
356   for (i = 0; i < argc; i++)
357     {
358       regnum = atoi (argv[i]);
359 
360       if (regnum >= 0
361 	  && regnum < numregs
362 	  && REGISTER_NAME (regnum) != NULL
363 	  && *REGISTER_NAME (regnum) != '\000')
364 	{
365 	  changed = register_changed_p (regnum);
366 	  if (changed < 0)
367 	    {
368 	      do_cleanups (cleanup);
369 	      mi_error_message = xstrprintf ("mi_cmd_data_list_register_change: Unable to read register contents.");
370 	      return MI_CMD_ERROR;
371 	    }
372 	  else if (changed)
373 	    ui_out_field_int (uiout, NULL, regnum);
374 	}
375       else
376 	{
377 	  do_cleanups (cleanup);
378 	  mi_error_message = xstrprintf ("bad register number");
379 	  return MI_CMD_ERROR;
380 	}
381     }
382   do_cleanups (cleanup);
383   return MI_CMD_DONE;
384 }
385 
386 static int
387 register_changed_p (int regnum)
388 {
389   char raw_buffer[MAX_REGISTER_SIZE];
390 
391   if (! frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
392     return -1;
393 
394   if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
395 	      register_size (current_gdbarch, regnum)) == 0)
396     return 0;
397 
398   /* Found a changed register. Return 1. */
399 
400   memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
401 	  register_size (current_gdbarch, regnum));
402 
403   return 1;
404 }
405 
406 /* Return a list of register number and value pairs. The valid
407    arguments expected are: a letter indicating the format in which to
408    display the registers contents. This can be one of: x (hexadecimal), d
409    (decimal), N (natural), t (binary), o (octal), r (raw).  After the
410    format argumetn there can be a sequence of numbers, indicating which
411    registers to fetch the content of. If the format is the only argument,
412    a list of all the registers with their values is returned. */
413 enum mi_cmd_result
414 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
415 {
416   int regnum, numregs, format, result;
417   int i;
418   struct cleanup *list_cleanup, *tuple_cleanup;
419 
420   /* Note that the test for a valid register must include checking the
421      REGISTER_NAME because NUM_REGS may be allocated for the union of
422      the register sets within a family of related processors.  In this
423      case, some entries of REGISTER_NAME will change depending upon
424      the particular processor being debugged.  */
425 
426   numregs = NUM_REGS + NUM_PSEUDO_REGS;
427 
428   if (argc == 0)
429     {
430       mi_error_message = xstrprintf ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
431       return MI_CMD_ERROR;
432     }
433 
434   format = (int) argv[0][0];
435 
436   if (!target_has_registers)
437     {
438       mi_error_message = xstrprintf ("mi_cmd_data_list_register_values: No registers.");
439       return MI_CMD_ERROR;
440     }
441 
442   list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
443 
444   if (argc == 1)		/* No args, beside the format: do all the regs */
445     {
446       for (regnum = 0;
447 	   regnum < numregs;
448 	   regnum++)
449 	{
450 	  if (REGISTER_NAME (regnum) == NULL
451 	      || *(REGISTER_NAME (regnum)) == '\0')
452 	    continue;
453 	  tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
454 	  ui_out_field_int (uiout, "number", regnum);
455 	  result = get_register (regnum, format);
456 	  if (result == -1)
457 	    {
458 	      do_cleanups (list_cleanup);
459 	      return MI_CMD_ERROR;
460 	    }
461 	  do_cleanups (tuple_cleanup);
462 	}
463     }
464 
465   /* Else, list of register #s, just do listed regs */
466   for (i = 1; i < argc; i++)
467     {
468       regnum = atoi (argv[i]);
469 
470       if (regnum >= 0
471 	  && regnum < numregs
472 	  && REGISTER_NAME (regnum) != NULL
473 	  && *REGISTER_NAME (regnum) != '\000')
474 	{
475 	  tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
476 	  ui_out_field_int (uiout, "number", regnum);
477 	  result = get_register (regnum, format);
478 	  if (result == -1)
479 	    {
480 	      do_cleanups (list_cleanup);
481 	      return MI_CMD_ERROR;
482 	    }
483 	  do_cleanups (tuple_cleanup);
484 	}
485       else
486 	{
487 	  do_cleanups (list_cleanup);
488 	  mi_error_message = xstrprintf ("bad register number");
489 	  return MI_CMD_ERROR;
490 	}
491     }
492   do_cleanups (list_cleanup);
493   return MI_CMD_DONE;
494 }
495 
496 /* Output one register's contents in the desired format. */
497 static int
498 get_register (int regnum, int format)
499 {
500   char buffer[MAX_REGISTER_SIZE];
501   int optim;
502   int realnum;
503   CORE_ADDR addr;
504   enum lval_type lval;
505   static struct ui_stream *stb = NULL;
506 
507   stb = ui_out_stream_new (uiout);
508 
509   if (format == 'N')
510     format = 0;
511 
512   frame_register (deprecated_selected_frame, regnum, &optim, &lval, &addr,
513 		  &realnum, buffer);
514 
515   if (optim)
516     {
517       mi_error_message = xstrprintf ("Optimized out");
518       return -1;
519     }
520 
521   if (format == 'r')
522     {
523       int j;
524       char *ptr, buf[1024];
525 
526       strcpy (buf, "0x");
527       ptr = buf + 2;
528       for (j = 0; j < register_size (current_gdbarch, regnum); j++)
529 	{
530 	  int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
531 	  : register_size (current_gdbarch, regnum) - 1 - j;
532 	  sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
533 	  ptr += 2;
534 	}
535       ui_out_field_string (uiout, "value", buf);
536       /*fputs_filtered (buf, gdb_stdout); */
537     }
538   else
539     {
540       val_print (register_type (current_gdbarch, regnum), buffer, 0, 0,
541 		 stb->stream, format, 1, 0, Val_pretty_default);
542       ui_out_field_stream (uiout, "value", stb);
543       ui_out_stream_delete (stb);
544     }
545   return 1;
546 }
547 
548 /* Write given values into registers. The registers and values are
549    given as pairs. The corresponding MI command is
550    -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
551 enum mi_cmd_result
552 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
553 {
554   int regnum;
555   int i;
556   int numregs;
557   LONGEST value;
558   char format;
559 
560   /* Note that the test for a valid register must include checking the
561      REGISTER_NAME because NUM_REGS may be allocated for the union of
562      the register sets within a family of related processors.  In this
563      case, some entries of REGISTER_NAME will change depending upon
564      the particular processor being debugged.  */
565 
566   numregs = NUM_REGS + NUM_PSEUDO_REGS;
567 
568   if (argc == 0)
569     {
570       mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
571       return MI_CMD_ERROR;
572     }
573 
574   format = (int) argv[0][0];
575 
576   if (!target_has_registers)
577     {
578       mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No registers.");
579       return MI_CMD_ERROR;
580     }
581 
582   if (!(argc - 1))
583     {
584       mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No regs and values specified.");
585       return MI_CMD_ERROR;
586     }
587 
588   if ((argc - 1) % 2)
589     {
590       mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
591       return MI_CMD_ERROR;
592     }
593 
594   for (i = 1; i < argc; i = i + 2)
595     {
596       regnum = atoi (argv[i]);
597 
598       if (regnum >= 0
599 	  && regnum < numregs
600 	  && REGISTER_NAME (regnum) != NULL
601 	  && *REGISTER_NAME (regnum) != '\000')
602 	{
603 	  void *buffer;
604 	  struct cleanup *old_chain;
605 
606 	  /* Get the value as a number */
607 	  value = parse_and_eval_address (argv[i + 1]);
608 	  /* Get the value into an array */
609 	  buffer = xmalloc (DEPRECATED_REGISTER_SIZE);
610 	  old_chain = make_cleanup (xfree, buffer);
611 	  store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value);
612 	  /* Write it down */
613 	  deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, register_size (current_gdbarch, regnum));
614 	  /* Free the buffer.  */
615 	  do_cleanups (old_chain);
616 	}
617       else
618 	{
619 	  mi_error_message = xstrprintf ("bad register number");
620 	  return MI_CMD_ERROR;
621 	}
622     }
623   return MI_CMD_DONE;
624 }
625 
626 #if 0
627 /*This is commented out because we decided it was not useful. I leave
628    it, just in case. ezannoni:1999-12-08 */
629 
630 /* Assign a value to a variable. The expression argument must be in
631    the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
632    quoted. */
633 enum mi_cmd_result
634 mi_cmd_data_assign (char *command, char **argv, int argc)
635 {
636   struct expression *expr;
637   struct cleanup *old_chain;
638 
639   if (argc != 1)
640     {
641       mi_error_message = xstrprintf ("mi_cmd_data_assign: Usage: -data-assign expression");
642       return MI_CMD_ERROR;
643     }
644 
645   /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
646      01-12-1999: Need to decide what to do with this for libgdb purposes. */
647 
648   expr = parse_expression (argv[0]);
649   old_chain = make_cleanup (free_current_contents, &expr);
650   evaluate_expression (expr);
651   do_cleanups (old_chain);
652   return MI_CMD_DONE;
653 }
654 #endif
655 
656 /* Evaluate the value of the argument. The argument is an
657    expression. If the expression contains spaces it needs to be
658    included in double quotes. */
659 enum mi_cmd_result
660 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
661 {
662   struct expression *expr;
663   struct cleanup *old_chain = NULL;
664   struct value *val;
665   struct ui_stream *stb = NULL;
666 
667   stb = ui_out_stream_new (uiout);
668 
669   if (argc != 1)
670     {
671       mi_error_message = xstrprintf ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
672       return MI_CMD_ERROR;
673     }
674 
675   expr = parse_expression (argv[0]);
676 
677   old_chain = make_cleanup (free_current_contents, &expr);
678 
679   val = evaluate_expression (expr);
680 
681   /* Print the result of the expression evaluation. */
682   val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
683 	     VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
684 	     stb->stream, 0, 0, 0, 0);
685 
686   ui_out_field_stream (uiout, "value", stb);
687   ui_out_stream_delete (stb);
688 
689   do_cleanups (old_chain);
690 
691   return MI_CMD_DONE;
692 }
693 
694 enum mi_cmd_result
695 mi_cmd_target_download (char *args, int from_tty)
696 {
697   char *run;
698   struct cleanup *old_cleanups = NULL;
699 
700   run = xstrprintf ("load %s", args);
701   old_cleanups = make_cleanup (xfree, run);
702   execute_command (run, from_tty);
703 
704   do_cleanups (old_cleanups);
705   return MI_CMD_DONE;
706 }
707 
708 /* Connect to the remote target. */
709 enum mi_cmd_result
710 mi_cmd_target_select (char *args, int from_tty)
711 {
712   char *run;
713   struct cleanup *old_cleanups = NULL;
714 
715   run = xstrprintf ("target %s", args);
716   old_cleanups = make_cleanup (xfree, run);
717 
718   /* target-select is always synchronous.  once the call has returned
719      we know that we are connected. */
720   /* NOTE: At present all targets that are connected are also
721      (implicitly) talking to a halted target.  In the future this may
722      change. */
723   execute_command (run, from_tty);
724 
725   do_cleanups (old_cleanups);
726 
727   /* Issue the completion message here. */
728   if (last_async_command)
729     fputs_unfiltered (last_async_command, raw_stdout);
730   fputs_unfiltered ("^connected", raw_stdout);
731   mi_out_put (uiout, raw_stdout);
732   mi_out_rewind (uiout);
733   fputs_unfiltered ("\n", raw_stdout);
734   do_exec_cleanups (ALL_CLEANUPS);
735   return MI_CMD_QUIET;
736 }
737 
738 /* DATA-MEMORY-READ:
739 
740    ADDR: start address of data to be dumped.
741    WORD-FORMAT: a char indicating format for the ``word''. See
742    the ``x'' command.
743    WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
744    NR_ROW: Number of rows.
745    NR_COL: The number of colums (words per row).
746    ASCHAR: (OPTIONAL) Append an ascii character dump to each row.  Use
747    ASCHAR for unprintable characters.
748 
749    Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
750    displayes them.  Returns:
751 
752    {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
753 
754    Returns:
755    The number of bytes read is SIZE*ROW*COL. */
756 
757 enum mi_cmd_result
758 mi_cmd_data_read_memory (char *command, char **argv, int argc)
759 {
760   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
761   CORE_ADDR addr;
762   long total_bytes;
763   long nr_cols;
764   long nr_rows;
765   char word_format;
766   struct type *word_type;
767   long word_size;
768   char word_asize;
769   char aschar;
770   char *mbuf;
771   int nr_bytes;
772   long offset = 0;
773   int optind = 0;
774   char *optarg;
775   enum opt
776     {
777       OFFSET_OPT
778     };
779   static struct mi_opt opts[] =
780   {
781     {"o", OFFSET_OPT, 1},
782     0
783   };
784 
785   while (1)
786     {
787       int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
788 			   &optind, &optarg);
789       if (opt < 0)
790 	break;
791       switch ((enum opt) opt)
792 	{
793 	case OFFSET_OPT:
794 	  offset = atol (optarg);
795 	  break;
796 	}
797     }
798   argv += optind;
799   argc -= optind;
800 
801   if (argc < 5 || argc > 6)
802     {
803       mi_error_message = xstrprintf ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
804       return MI_CMD_ERROR;
805     }
806 
807   /* Extract all the arguments. */
808 
809   /* Start address of the memory dump. */
810   addr = parse_and_eval_address (argv[0]) + offset;
811   /* The format character to use when displaying a memory word. See
812      the ``x'' command. */
813   word_format = argv[1][0];
814   /* The size of the memory word. */
815   word_size = atol (argv[2]);
816   switch (word_size)
817     {
818     case 1:
819       word_type = builtin_type_int8;
820       word_asize = 'b';
821       break;
822     case 2:
823       word_type = builtin_type_int16;
824       word_asize = 'h';
825       break;
826     case 4:
827       word_type = builtin_type_int32;
828       word_asize = 'w';
829       break;
830     case 8:
831       word_type = builtin_type_int64;
832       word_asize = 'g';
833       break;
834     default:
835       word_type = builtin_type_int8;
836       word_asize = 'b';
837     }
838   /* The number of rows */
839   nr_rows = atol (argv[3]);
840   if (nr_rows <= 0)
841     {
842       mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of rows.");
843       return MI_CMD_ERROR;
844     }
845   /* number of bytes per row. */
846   nr_cols = atol (argv[4]);
847   if (nr_cols <= 0)
848     {
849       mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of columns.");
850       return MI_CMD_ERROR;
851     }
852   /* The un-printable character when printing ascii. */
853   if (argc == 6)
854     aschar = *argv[5];
855   else
856     aschar = 0;
857 
858   /* create a buffer and read it in. */
859   total_bytes = word_size * nr_rows * nr_cols;
860   mbuf = xcalloc (total_bytes, 1);
861   make_cleanup (xfree, mbuf);
862   nr_bytes = 0;
863   while (nr_bytes < total_bytes)
864     {
865       int error;
866       long num = target_read_memory_partial (addr + nr_bytes, mbuf + nr_bytes,
867 					     total_bytes - nr_bytes,
868 					     &error);
869       if (num <= 0)
870 	break;
871       nr_bytes += num;
872     }
873 
874   /* output the header information. */
875   ui_out_field_core_addr (uiout, "addr", addr);
876   ui_out_field_int (uiout, "nr-bytes", nr_bytes);
877   ui_out_field_int (uiout, "total-bytes", total_bytes);
878   ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
879   ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
880   ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
881   ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
882 
883   /* Build the result as a two dimentional table. */
884   {
885     struct ui_stream *stream = ui_out_stream_new (uiout);
886     struct cleanup *cleanup_list_memory;
887     int row;
888     int row_byte;
889     cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
890     for (row = 0, row_byte = 0;
891 	 row < nr_rows;
892 	 row++, row_byte += nr_cols * word_size)
893       {
894 	int col;
895 	int col_byte;
896 	struct cleanup *cleanup_tuple;
897 	struct cleanup *cleanup_list_data;
898 	cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
899 	ui_out_field_core_addr (uiout, "addr", addr + row_byte);
900 	/* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
901 	cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
902 	for (col = 0, col_byte = row_byte;
903 	     col < nr_cols;
904 	     col++, col_byte += word_size)
905 	  {
906 	    if (col_byte + word_size > nr_bytes)
907 	      {
908 		ui_out_field_string (uiout, NULL, "N/A");
909 	      }
910 	    else
911 	      {
912 		ui_file_rewind (stream->stream);
913 		print_scalar_formatted (mbuf + col_byte, word_type, word_format,
914 					word_asize, stream->stream);
915 		ui_out_field_stream (uiout, NULL, stream);
916 	      }
917 	  }
918 	do_cleanups (cleanup_list_data);
919 	if (aschar)
920 	  {
921 	    int byte;
922 	    ui_file_rewind (stream->stream);
923 	    for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
924 	      {
925 		if (byte >= nr_bytes)
926 		  {
927 		    fputc_unfiltered ('X', stream->stream);
928 		  }
929 		else if (mbuf[byte] < 32 || mbuf[byte] > 126)
930 		  {
931 		    fputc_unfiltered (aschar, stream->stream);
932 		  }
933 		else
934 		  fputc_unfiltered (mbuf[byte], stream->stream);
935 	      }
936 	    ui_out_field_stream (uiout, "ascii", stream);
937 	  }
938 	do_cleanups (cleanup_tuple);
939       }
940     ui_out_stream_delete (stream);
941     do_cleanups (cleanup_list_memory);
942   }
943   do_cleanups (cleanups);
944   return MI_CMD_DONE;
945 }
946 
947 /* DATA-MEMORY-WRITE:
948 
949    COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
950    offset from the beginning of the memory grid row where the cell to
951    be written is.
952    ADDR: start address of the row in the memory grid where the memory
953    cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
954    the location to write to.
955    FORMAT: a char indicating format for the ``word''. See
956    the ``x'' command.
957    WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
958    VALUE: value to be written into the memory address.
959 
960    Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
961 
962    Prints nothing. */
963 enum mi_cmd_result
964 mi_cmd_data_write_memory (char *command, char **argv, int argc)
965 {
966   CORE_ADDR addr;
967   char word_format;
968   long word_size;
969   /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
970      enough when using a compiler other than GCC. */
971   LONGEST value;
972   void *buffer;
973   struct cleanup *old_chain;
974   long offset = 0;
975   int optind = 0;
976   char *optarg;
977   enum opt
978     {
979       OFFSET_OPT
980     };
981   static struct mi_opt opts[] =
982   {
983     {"o", OFFSET_OPT, 1},
984     0
985   };
986 
987   while (1)
988     {
989       int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
990 			   &optind, &optarg);
991       if (opt < 0)
992 	break;
993       switch ((enum opt) opt)
994 	{
995 	case OFFSET_OPT:
996 	  offset = atol (optarg);
997 	  break;
998 	}
999     }
1000   argv += optind;
1001   argc -= optind;
1002 
1003   if (argc != 4)
1004     {
1005       mi_error_message = xstrprintf ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1006       return MI_CMD_ERROR;
1007     }
1008 
1009   /* Extract all the arguments. */
1010   /* Start address of the memory dump. */
1011   addr = parse_and_eval_address (argv[0]);
1012   /* The format character to use when displaying a memory word. See
1013      the ``x'' command. */
1014   word_format = argv[1][0];
1015   /* The size of the memory word. */
1016   word_size = atol (argv[2]);
1017 
1018   /* Calculate the real address of the write destination. */
1019   addr += (offset * word_size);
1020 
1021   /* Get the value as a number */
1022   value = parse_and_eval_address (argv[3]);
1023   /* Get the value into an array */
1024   buffer = xmalloc (word_size);
1025   old_chain = make_cleanup (xfree, buffer);
1026   store_signed_integer (buffer, word_size, value);
1027   /* Write it down to memory */
1028   write_memory (addr, buffer, word_size);
1029   /* Free the buffer.  */
1030   do_cleanups (old_chain);
1031 
1032   return MI_CMD_DONE;
1033 }
1034 
1035 /* Execute a command within a safe environment.
1036    Return <0 for error; >=0 for ok.
1037 
1038    args->action will tell mi_execute_command what action
1039    to perfrom after the given command has executed (display/supress
1040    prompt, display error). */
1041 
1042 static int
1043 captured_mi_execute_command (struct ui_out *uiout, void *data)
1044 {
1045   struct captured_mi_execute_command_args *args =
1046     (struct captured_mi_execute_command_args *) data;
1047   struct mi_parse *context = args->command;
1048 
1049   switch (context->op)
1050     {
1051 
1052     case MI_COMMAND:
1053       /* A MI command was read from the input stream */
1054       if (mi_debug_p)
1055 	/* FIXME: gdb_???? */
1056 	fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1057 			    context->token, context->command, context->args);
1058       /* FIXME: cagney/1999-09-25: Rather than this convoluted
1059          condition expression, each function should return an
1060          indication of what action is required and then switch on
1061          that. */
1062       args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
1063       args->rc = mi_cmd_execute (context);
1064 
1065       if (!target_can_async_p () || !target_executing)
1066 	{
1067 	  /* print the result if there were no errors
1068 
1069 	     Remember that on the way out of executing a command, you have
1070 	     to directly use the mi_interp's uiout, since the command could
1071 	     have reset the interpreter, in which case the current uiout
1072 	     will most likely crash in the mi_out_* routines.  */
1073 	  if (args->rc == MI_CMD_DONE)
1074 	    {
1075 	      fputs_unfiltered (context->token, raw_stdout);
1076 	      fputs_unfiltered ("^done", raw_stdout);
1077 	      mi_out_put (uiout, raw_stdout);
1078 	      mi_out_rewind (uiout);
1079 	      fputs_unfiltered ("\n", raw_stdout);
1080 	    }
1081 	  else if (args->rc == MI_CMD_ERROR)
1082 	    {
1083 	      if (mi_error_message)
1084 		{
1085 		  fputs_unfiltered (context->token, raw_stdout);
1086 		  fputs_unfiltered ("^error,msg=\"", raw_stdout);
1087 		  fputstr_unfiltered (mi_error_message, '"', raw_stdout);
1088 		  xfree (mi_error_message);
1089 		  fputs_unfiltered ("\"\n", raw_stdout);
1090 		}
1091 	      mi_out_rewind (uiout);
1092 	    }
1093 	  else if (args->rc == MI_CMD_CAUGHT_ERROR)
1094 	    {
1095 	      mi_out_rewind (uiout);
1096 	      args->action = EXECUTE_COMMAND_DISPLAY_ERROR;
1097 	      return 1;
1098 	    }
1099 	  else
1100 	    mi_out_rewind (uiout);
1101 	}
1102       else if (sync_execution)
1103 	{
1104 	  /* Don't print the prompt. We are executing the target in
1105 	     synchronous mode. */
1106 	  args->action = EXECUTE_COMMAND_SUPRESS_PROMPT;
1107 	  return 1;
1108 	}
1109       break;
1110 
1111     case CLI_COMMAND:
1112       /* A CLI command was read from the input stream */
1113       /* This will be removed as soon as we have a complete set of
1114          mi commands */
1115       /* echo the command on the console. */
1116       fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1117       mi_execute_cli_command (context->command, 0, NULL);
1118 
1119       /* If we changed interpreters, DON'T print out anything. */
1120       if (current_interp_named_p (INTERP_MI)
1121 	  || current_interp_named_p (INTERP_MI1)
1122 	  || current_interp_named_p (INTERP_MI2)
1123 	  || current_interp_named_p (INTERP_MI3))
1124 	{
1125 	  /* print the result */
1126 	  /* FIXME: Check for errors here. */
1127 	  fputs_unfiltered (context->token, raw_stdout);
1128 	  fputs_unfiltered ("^done", raw_stdout);
1129 	  mi_out_put (uiout, raw_stdout);
1130 	  mi_out_rewind (uiout);
1131 	  fputs_unfiltered ("\n", raw_stdout);
1132 	  args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
1133 	  args->rc = MI_CMD_DONE;
1134 	}
1135       break;
1136 
1137     }
1138 
1139   return 1;
1140 }
1141 
1142 
1143 void
1144 mi_execute_command (char *cmd, int from_tty)
1145 {
1146   struct mi_parse *command;
1147   struct captured_mi_execute_command_args args;
1148   struct ui_out *saved_uiout = uiout;
1149   int result;
1150 
1151   /* This is to handle EOF (^D). We just quit gdb. */
1152   /* FIXME: we should call some API function here. */
1153   if (cmd == 0)
1154     quit_force (NULL, from_tty);
1155 
1156   command = mi_parse (cmd);
1157 
1158   if (command != NULL)
1159     {
1160       /* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either
1161          be pushed even further down or even eliminated? */
1162       args.command = command;
1163       result = catch_exceptions (uiout, captured_mi_execute_command, &args, "",
1164 				 RETURN_MASK_ALL);
1165 
1166       if (args.action == EXECUTE_COMMAND_SUPRESS_PROMPT)
1167 	{
1168 	  /* The command is executing synchronously.  Bail out early
1169 	     suppressing the finished prompt. */
1170 	  mi_parse_free (command);
1171 	  return;
1172 	}
1173       if (args.action == EXECUTE_COMMAND_DISPLAY_ERROR || result < 0)
1174 	{
1175 	  char *msg = error_last_message ();
1176 	  struct cleanup *cleanup = make_cleanup (xfree, msg);
1177 	  /* The command execution failed and error() was called
1178 	     somewhere */
1179 	  fputs_unfiltered (command->token, raw_stdout);
1180 	  fputs_unfiltered ("^error,msg=\"", raw_stdout);
1181 	  fputstr_unfiltered (msg, '"', raw_stdout);
1182 	  fputs_unfiltered ("\"\n", raw_stdout);
1183 	}
1184       mi_parse_free (command);
1185     }
1186 
1187   fputs_unfiltered ("(gdb) \n", raw_stdout);
1188   gdb_flush (raw_stdout);
1189   /* print any buffered hook code */
1190   /* ..... */
1191 }
1192 
1193 static enum mi_cmd_result
1194 mi_cmd_execute (struct mi_parse *parse)
1195 {
1196   if (parse->cmd->argv_func != NULL
1197       || parse->cmd->args_func != NULL)
1198     {
1199       /* FIXME: We need to save the token because the command executed
1200          may be asynchronous and need to print the token again.
1201          In the future we can pass the token down to the func
1202          and get rid of the last_async_command */
1203       /* The problem here is to keep the token around when we launch
1204          the target, and we want to interrupt it later on.  The
1205          interrupt command will have its own token, but when the
1206          target stops, we must display the token corresponding to the
1207          last execution command given. So we have another string where
1208          we copy the token (previous_async_command), if this was
1209          indeed the token of an execution command, and when we stop we
1210          print that one. This is possible because the interrupt
1211          command, when over, will copy that token back into the
1212          default token string (last_async_command). */
1213 
1214       if (target_executing)
1215 	{
1216 	  if (!previous_async_command)
1217 	    previous_async_command = xstrdup (last_async_command);
1218 	  if (strcmp (parse->command, "exec-interrupt"))
1219 	    {
1220 	      fputs_unfiltered (parse->token, raw_stdout);
1221 	      fputs_unfiltered ("^error,msg=\"", raw_stdout);
1222 	      fputs_unfiltered ("Cannot execute command ", raw_stdout);
1223 	      fputstr_unfiltered (parse->command, '"', raw_stdout);
1224 	      fputs_unfiltered (" while target running", raw_stdout);
1225 	      fputs_unfiltered ("\"\n", raw_stdout);
1226 	      return MI_CMD_ERROR;
1227 	    }
1228 	}
1229       last_async_command = xstrdup (parse->token);
1230       make_exec_cleanup (free_current_contents, &last_async_command);
1231       /* FIXME: DELETE THIS! */
1232       if (parse->cmd->args_func != NULL)
1233 	return parse->cmd->args_func (parse->args, 0 /*from_tty */ );
1234       return parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1235     }
1236   else if (parse->cmd->cli.cmd != 0)
1237     {
1238       /* FIXME: DELETE THIS. */
1239       /* The operation is still implemented by a cli command */
1240       /* Must be a synchronous one */
1241       mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1242 			      parse->args);
1243       return MI_CMD_DONE;
1244     }
1245   else
1246     {
1247       /* FIXME: DELETE THIS. */
1248       fputs_unfiltered (parse->token, raw_stdout);
1249       fputs_unfiltered ("^error,msg=\"", raw_stdout);
1250       fputs_unfiltered ("Undefined mi command: ", raw_stdout);
1251       fputstr_unfiltered (parse->command, '"', raw_stdout);
1252       fputs_unfiltered (" (missing implementation)", raw_stdout);
1253       fputs_unfiltered ("\"\n", raw_stdout);
1254       return MI_CMD_ERROR;
1255     }
1256 }
1257 
1258 /* FIXME: This is just a hack so we can get some extra commands going.
1259    We don't want to channel things through the CLI, but call libgdb directly */
1260 /* Use only for synchronous commands */
1261 
1262 void
1263 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1264 {
1265   if (cmd != 0)
1266     {
1267       struct cleanup *old_cleanups;
1268       char *run;
1269       if (args_p)
1270 	run = xstrprintf ("%s %s", cmd, args);
1271       else
1272 	run = xstrdup (cmd);
1273       if (mi_debug_p)
1274 	/* FIXME: gdb_???? */
1275 	fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1276 			    cmd, run);
1277       old_cleanups = make_cleanup (xfree, run);
1278       execute_command ( /*ui */ run, 0 /*from_tty */ );
1279       do_cleanups (old_cleanups);
1280       return;
1281     }
1282 }
1283 
1284 enum mi_cmd_result
1285 mi_execute_async_cli_command (char *mi, char *args, int from_tty)
1286 {
1287   struct cleanup *old_cleanups;
1288   char *run;
1289   char *async_args;
1290 
1291   if (target_can_async_p ())
1292     {
1293       async_args = (char *) xmalloc (strlen (args) + 2);
1294       make_exec_cleanup (free, async_args);
1295       strcpy (async_args, args);
1296       strcat (async_args, "&");
1297       run = xstrprintf ("%s %s", mi, async_args);
1298       make_exec_cleanup (free, run);
1299       add_continuation (mi_exec_async_cli_cmd_continuation, NULL);
1300       old_cleanups = NULL;
1301     }
1302   else
1303     {
1304       run = xstrprintf ("%s %s", mi, args);
1305       old_cleanups = make_cleanup (xfree, run);
1306     }
1307 
1308   if (!target_can_async_p ())
1309     {
1310       /* NOTE: For synchronous targets asynchronous behavour is faked by
1311          printing out the GDB prompt before we even try to execute the
1312          command. */
1313       if (last_async_command)
1314 	fputs_unfiltered (last_async_command, raw_stdout);
1315       fputs_unfiltered ("^running\n", raw_stdout);
1316       fputs_unfiltered ("(gdb) \n", raw_stdout);
1317       gdb_flush (raw_stdout);
1318     }
1319   else
1320     {
1321       /* FIXME: cagney/1999-11-29: Printing this message before
1322          calling execute_command is wrong.  It should only be printed
1323          once gdb has confirmed that it really has managed to send a
1324          run command to the target. */
1325       if (last_async_command)
1326 	fputs_unfiltered (last_async_command, raw_stdout);
1327       fputs_unfiltered ("^running\n", raw_stdout);
1328     }
1329 
1330   execute_command ( /*ui */ run, 0 /*from_tty */ );
1331 
1332   if (!target_can_async_p ())
1333     {
1334       /* Do this before doing any printing.  It would appear that some
1335          print code leaves garbage around in the buffer. */
1336       do_cleanups (old_cleanups);
1337       /* If the target was doing the operation synchronously we fake
1338          the stopped message. */
1339       if (last_async_command)
1340 	fputs_unfiltered (last_async_command, raw_stdout);
1341       fputs_unfiltered ("*stopped", raw_stdout);
1342       mi_out_put (uiout, raw_stdout);
1343       mi_out_rewind (uiout);
1344       fputs_unfiltered ("\n", raw_stdout);
1345       return MI_CMD_QUIET;
1346     }
1347   return MI_CMD_DONE;
1348 }
1349 
1350 void
1351 mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg)
1352 {
1353   if (last_async_command)
1354     fputs_unfiltered (last_async_command, raw_stdout);
1355   fputs_unfiltered ("*stopped", raw_stdout);
1356   mi_out_put (uiout, raw_stdout);
1357   fputs_unfiltered ("\n", raw_stdout);
1358   fputs_unfiltered ("(gdb) \n", raw_stdout);
1359   gdb_flush (raw_stdout);
1360   do_exec_cleanups (ALL_CLEANUPS);
1361 }
1362 
1363 void
1364 mi_load_progress (const char *section_name,
1365 		  unsigned long sent_so_far,
1366 		  unsigned long total_section,
1367 		  unsigned long total_sent,
1368 		  unsigned long grand_total)
1369 {
1370   struct timeval time_now, delta, update_threshold;
1371   static struct timeval last_update;
1372   static char *previous_sect_name = NULL;
1373   int new_section;
1374 
1375   if (!current_interp_named_p (INTERP_MI)
1376       && !current_interp_named_p (INTERP_MI1))
1377     return;
1378 
1379   update_threshold.tv_sec = 0;
1380   update_threshold.tv_usec = 500000;
1381   gettimeofday (&time_now, NULL);
1382 
1383   delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1384   delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1385 
1386   if (delta.tv_usec < 0)
1387     {
1388       delta.tv_sec -= 1;
1389       delta.tv_usec += 1000000;
1390     }
1391 
1392   new_section = (previous_sect_name ?
1393 		 strcmp (previous_sect_name, section_name) : 1);
1394   if (new_section)
1395     {
1396       struct cleanup *cleanup_tuple;
1397       xfree (previous_sect_name);
1398       previous_sect_name = xstrdup (section_name);
1399 
1400       if (last_async_command)
1401 	fputs_unfiltered (last_async_command, raw_stdout);
1402       fputs_unfiltered ("+download", raw_stdout);
1403       cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1404       ui_out_field_string (uiout, "section", section_name);
1405       ui_out_field_int (uiout, "section-size", total_section);
1406       ui_out_field_int (uiout, "total-size", grand_total);
1407       do_cleanups (cleanup_tuple);
1408       mi_out_put (uiout, raw_stdout);
1409       fputs_unfiltered ("\n", raw_stdout);
1410       gdb_flush (raw_stdout);
1411     }
1412 
1413   if (delta.tv_sec >= update_threshold.tv_sec &&
1414       delta.tv_usec >= update_threshold.tv_usec)
1415     {
1416       struct cleanup *cleanup_tuple;
1417       last_update.tv_sec = time_now.tv_sec;
1418       last_update.tv_usec = time_now.tv_usec;
1419       if (last_async_command)
1420 	fputs_unfiltered (last_async_command, raw_stdout);
1421       fputs_unfiltered ("+download", raw_stdout);
1422       cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1423       ui_out_field_string (uiout, "section", section_name);
1424       ui_out_field_int (uiout, "section-sent", sent_so_far);
1425       ui_out_field_int (uiout, "section-size", total_section);
1426       ui_out_field_int (uiout, "total-sent", total_sent);
1427       ui_out_field_int (uiout, "total-size", grand_total);
1428       do_cleanups (cleanup_tuple);
1429       mi_out_put (uiout, raw_stdout);
1430       fputs_unfiltered ("\n", raw_stdout);
1431       gdb_flush (raw_stdout);
1432     }
1433 }
1434 
1435 void
1436 mi_setup_architecture_data (void)
1437 {
1438   old_regs = xmalloc ((NUM_REGS + NUM_PSEUDO_REGS) * MAX_REGISTER_SIZE + 1);
1439   memset (old_regs, 0, (NUM_REGS + NUM_PSEUDO_REGS) * MAX_REGISTER_SIZE + 1);
1440 }
1441 
1442 void
1443 _initialize_mi_main (void)
1444 {
1445   DEPRECATED_REGISTER_GDBARCH_SWAP (old_regs);
1446   deprecated_register_gdbarch_swap (NULL, 0, mi_setup_architecture_data);
1447 }
1448