1 /* MI Command Set.
2
3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, 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 3 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, see <http://www.gnu.org/licenses/>. */
22
23 /* Work in progress. */
24
25 #include "defs.h"
26 #include "arch-utils.h"
27 #include "target.h"
28 #include "inferior.h"
29 #include "gdb_string.h"
30 #include "exceptions.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"
44 #include "regcache.h"
45 #include "gdb.h"
46 #include "frame.h"
47 #include "mi-main.h"
48 #include "mi-common.h"
49 #include "language.h"
50 #include "valprint.h"
51 #include "inferior.h"
52 #include "osdata.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
55
56 #include <ctype.h>
57 #include <sys/time.h>
58
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
61 #endif
62
63 #ifdef HAVE_GETRUSAGE
64 struct rusage rusage;
65 #endif
66
67 enum
68 {
69 FROM_TTY = 0
70 };
71
72 int mi_debug_p;
73 struct ui_file *raw_stdout;
74
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp *current_command_ts;
78
79 static int do_timings = 0;
80
81 char *current_token;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse *current_context;
86
87 int running_result_record_printed = 1;
88
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
91 int mi_proceeded;
92
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse *parse);
95
96 static void mi_execute_cli_command (const char *cmd, int args_p,
97 const char *args);
98 static void mi_execute_async_cli_command (char *cli_command,
99 char **argv, int argc);
100 static int register_changed_p (int regnum, struct regcache *,
101 struct regcache *);
102 static void get_register (struct frame_info *, int regnum, int format);
103
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
106 formalized. */
107
108 static void timestamp (struct mi_timestamp *tv);
109
110 static void print_diff_now (struct mi_timestamp *start);
111 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
112
113 void
mi_cmd_gdb_exit(char * command,char ** argv,int argc)114 mi_cmd_gdb_exit (char *command, char **argv, int argc)
115 {
116 /* We have to print everything right here because we never return. */
117 if (current_token)
118 fputs_unfiltered (current_token, raw_stdout);
119 fputs_unfiltered ("^exit\n", raw_stdout);
120 mi_out_put (uiout, raw_stdout);
121 gdb_flush (raw_stdout);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL, FROM_TTY);
124 }
125
126 void
mi_cmd_exec_next(char * command,char ** argv,int argc)127 mi_cmd_exec_next (char *command, char **argv, int argc)
128 {
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
132 else
133 mi_execute_async_cli_command ("next", argv, argc);
134 }
135
136 void
mi_cmd_exec_next_instruction(char * command,char ** argv,int argc)137 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
138 {
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
142 else
143 mi_execute_async_cli_command ("nexti", argv, argc);
144 }
145
146 void
mi_cmd_exec_step(char * command,char ** argv,int argc)147 mi_cmd_exec_step (char *command, char **argv, int argc)
148 {
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
152 else
153 mi_execute_async_cli_command ("step", argv, argc);
154 }
155
156 void
mi_cmd_exec_step_instruction(char * command,char ** argv,int argc)157 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
158 {
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
162 else
163 mi_execute_async_cli_command ("stepi", argv, argc);
164 }
165
166 void
mi_cmd_exec_finish(char * command,char ** argv,int argc)167 mi_cmd_exec_finish (char *command, char **argv, int argc)
168 {
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
172 else
173 mi_execute_async_cli_command ("finish", argv, argc);
174 }
175
176 void
mi_cmd_exec_return(char * command,char ** argv,int argc)177 mi_cmd_exec_return (char *command, char **argv, int argc)
178 {
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
181 if (argc)
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv, 0);
185 else
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL, 0);
189
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
193 }
194
195 void
mi_cmd_exec_jump(char * args,char ** argv,int argc)196 mi_cmd_exec_jump (char *args, char **argv, int argc)
197 {
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv, argc);
200 }
201
202 static void
proceed_thread(struct thread_info * thread,int pid)203 proceed_thread (struct thread_info *thread, int pid)
204 {
205 if (!is_stopped (thread->ptid))
206 return;
207
208 if (pid != 0 && PIDGET (thread->ptid) != pid)
209 return;
210
211 switch_to_thread (thread->ptid);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
214 }
215
216
217 static int
proceed_thread_callback(struct thread_info * thread,void * arg)218 proceed_thread_callback (struct thread_info *thread, void *arg)
219 {
220 int pid = *(int *)arg;
221
222 proceed_thread (thread, pid);
223 return 0;
224 }
225
226 static void
exec_continue(char ** argv,int argc)227 exec_continue (char **argv, int argc)
228 {
229 if (non_stop)
230 {
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
234
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context->all || current_context->thread_group != -1)
237 {
238 int pid = 0;
239 struct cleanup *back_to = make_cleanup_restore_current_thread ();
240
241 if (!current_context->all)
242 {
243 struct inferior *inf
244 = find_inferior_id (current_context->thread_group);
245
246 pid = inf->pid;
247 }
248 iterate_over_threads (proceed_thread_callback, &pid);
249 do_cleanups (back_to);
250 }
251 else
252 {
253 continue_1 (0);
254 }
255 }
256 else
257 {
258 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
259
260 if (current_context->all)
261 {
262 sched_multi = 1;
263 continue_1 (0);
264 }
265 else
266 {
267 /* In all-stop mode, -exec-continue traditionally resumed either
268 all threads, or one thread, depending on the 'scheduler-locking'
269 variable. Let's continue to do the same. */
270 continue_1 (1);
271 }
272 do_cleanups (back_to);
273 }
274 }
275
276 static void
exec_direction_forward(void * notused)277 exec_direction_forward (void *notused)
278 {
279 execution_direction = EXEC_FORWARD;
280 }
281
282 static void
exec_reverse_continue(char ** argv,int argc)283 exec_reverse_continue (char **argv, int argc)
284 {
285 enum exec_direction_kind dir = execution_direction;
286 struct cleanup *old_chain;
287
288 if (dir == EXEC_ERROR)
289 error (_("Target %s does not support this command."), target_shortname);
290
291 if (dir == EXEC_REVERSE)
292 error (_("Already in reverse mode."));
293
294 if (!target_can_execute_reverse)
295 error (_("Target %s does not support this command."), target_shortname);
296
297 old_chain = make_cleanup (exec_direction_forward, NULL);
298 execution_direction = EXEC_REVERSE;
299 exec_continue (argv, argc);
300 do_cleanups (old_chain);
301 }
302
303 void
mi_cmd_exec_continue(char * command,char ** argv,int argc)304 mi_cmd_exec_continue (char *command, char **argv, int argc)
305 {
306 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
307 exec_reverse_continue (argv + 1, argc - 1);
308 else
309 exec_continue (argv, argc);
310 }
311
312 static int
interrupt_thread_callback(struct thread_info * thread,void * arg)313 interrupt_thread_callback (struct thread_info *thread, void *arg)
314 {
315 int pid = *(int *)arg;
316
317 if (!is_running (thread->ptid))
318 return 0;
319
320 if (PIDGET (thread->ptid) != pid)
321 return 0;
322
323 target_stop (thread->ptid);
324 return 0;
325 }
326
327 /* Interrupt the execution of the target. Note how we must play around
328 with the token variables, in order to display the current token in
329 the result of the interrupt command, and the previous execution
330 token when the target finally stops. See comments in
331 mi_cmd_execute. */
332 void
mi_cmd_exec_interrupt(char * command,char ** argv,int argc)333 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
334 {
335 /* In all-stop mode, everything stops, so we don't need to try
336 anything specific. */
337 if (!non_stop)
338 {
339 interrupt_target_1 (0);
340 return;
341 }
342
343 if (current_context->all)
344 {
345 /* This will interrupt all threads in all inferiors. */
346 interrupt_target_1 (1);
347 }
348 else if (current_context->thread_group != -1)
349 {
350 struct inferior *inf = find_inferior_id (current_context->thread_group);
351
352 iterate_over_threads (interrupt_thread_callback, &inf->pid);
353 }
354 else
355 {
356 /* Interrupt just the current thread -- either explicitly
357 specified via --thread or whatever was current before
358 MI command was sent. */
359 interrupt_target_1 (0);
360 }
361 }
362
363 static int
run_one_inferior(struct inferior * inf,void * arg)364 run_one_inferior (struct inferior *inf, void *arg)
365 {
366 if (inf->pid != 0)
367 {
368 if (inf->pid != ptid_get_pid (inferior_ptid))
369 {
370 struct thread_info *tp;
371
372 tp = any_thread_of_process (inf->pid);
373 if (!tp)
374 error (_("Inferior has no threads."));
375
376 switch_to_thread (tp->ptid);
377 }
378 }
379 else
380 {
381 set_current_inferior (inf);
382 switch_to_thread (null_ptid);
383 set_current_program_space (inf->pspace);
384 }
385 mi_execute_cli_command ("run", target_can_async_p (),
386 target_can_async_p () ? "&" : NULL);
387 return 0;
388 }
389
390 void
mi_cmd_exec_run(char * command,char ** argv,int argc)391 mi_cmd_exec_run (char *command, char **argv, int argc)
392 {
393 if (current_context->all)
394 {
395 struct cleanup *back_to = save_current_space_and_thread ();
396
397 iterate_over_inferiors (run_one_inferior, NULL);
398 do_cleanups (back_to);
399 }
400 else
401 {
402 mi_execute_cli_command ("run", target_can_async_p (),
403 target_can_async_p () ? "&" : NULL);
404 }
405 }
406
407
408 static int
find_thread_of_process(struct thread_info * ti,void * p)409 find_thread_of_process (struct thread_info *ti, void *p)
410 {
411 int pid = *(int *)p;
412
413 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
414 return 1;
415
416 return 0;
417 }
418
419 void
mi_cmd_target_detach(char * command,char ** argv,int argc)420 mi_cmd_target_detach (char *command, char **argv, int argc)
421 {
422 if (argc != 0 && argc != 1)
423 error (_("Usage: -target-detach [pid | thread-group]"));
424
425 if (argc == 1)
426 {
427 struct thread_info *tp;
428 char *end = argv[0];
429 int pid;
430
431 /* First see if we are dealing with a thread-group id. */
432 if (*argv[0] == 'i')
433 {
434 struct inferior *inf;
435 int id = strtoul (argv[0] + 1, &end, 0);
436
437 if (*end != '\0')
438 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
439
440 inf = find_inferior_id (id);
441 if (!inf)
442 error (_("Non-existent thread-group id '%d'"), id);
443
444 pid = inf->pid;
445 }
446 else
447 {
448 /* We must be dealing with a pid. */
449 pid = strtol (argv[0], &end, 10);
450
451 if (*end != '\0')
452 error (_("Invalid identifier '%s'"), argv[0]);
453 }
454
455 /* Pick any thread in the desired process. Current
456 target_detach detaches from the parent of inferior_ptid. */
457 tp = iterate_over_threads (find_thread_of_process, &pid);
458 if (!tp)
459 error (_("Thread group is empty"));
460
461 switch_to_thread (tp->ptid);
462 }
463
464 detach_command (NULL, 0);
465 }
466
467 void
mi_cmd_thread_select(char * command,char ** argv,int argc)468 mi_cmd_thread_select (char *command, char **argv, int argc)
469 {
470 enum gdb_rc rc;
471 char *mi_error_message;
472
473 if (argc != 1)
474 error (_("-thread-select: USAGE: threadnum."));
475
476 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
477
478 if (rc == GDB_RC_FAIL)
479 {
480 make_cleanup (xfree, mi_error_message);
481 error ("%s", mi_error_message);
482 }
483 }
484
485 void
mi_cmd_thread_list_ids(char * command,char ** argv,int argc)486 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
487 {
488 enum gdb_rc rc;
489 char *mi_error_message;
490
491 if (argc != 0)
492 error (_("-thread-list-ids: No arguments required."));
493
494 rc = gdb_list_thread_ids (uiout, &mi_error_message);
495
496 if (rc == GDB_RC_FAIL)
497 {
498 make_cleanup (xfree, mi_error_message);
499 error ("%s", mi_error_message);
500 }
501 }
502
503 void
mi_cmd_thread_info(char * command,char ** argv,int argc)504 mi_cmd_thread_info (char *command, char **argv, int argc)
505 {
506 if (argc != 0 && argc != 1)
507 error (_("Invalid MI command"));
508
509 print_thread_info (uiout, argv[0], -1);
510 }
511
512 struct collect_cores_data
513 {
514 int pid;
515
516 VEC (int) *cores;
517 };
518
519 static int
collect_cores(struct thread_info * ti,void * xdata)520 collect_cores (struct thread_info *ti, void *xdata)
521 {
522 struct collect_cores_data *data = xdata;
523
524 if (ptid_get_pid (ti->ptid) == data->pid)
525 {
526 int core = target_core_of_thread (ti->ptid);
527
528 if (core != -1)
529 VEC_safe_push (int, data->cores, core);
530 }
531
532 return 0;
533 }
534
535 static int *
unique(int * b,int * e)536 unique (int *b, int *e)
537 {
538 int *d = b;
539
540 while (++b != e)
541 if (*d != *b)
542 *++d = *b;
543 return ++d;
544 }
545
546 struct print_one_inferior_data
547 {
548 int recurse;
549 VEC (int) *inferiors;
550 };
551
552 static int
print_one_inferior(struct inferior * inferior,void * xdata)553 print_one_inferior (struct inferior *inferior, void *xdata)
554 {
555 struct print_one_inferior_data *top_data = xdata;
556
557 if (VEC_empty (int, top_data->inferiors)
558 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
559 VEC_length (int, top_data->inferiors), sizeof (int),
560 compare_positive_ints))
561 {
562 struct collect_cores_data data;
563 struct cleanup *back_to
564 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
565
566 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
567 ui_out_field_string (uiout, "type", "process");
568 if (inferior->pid != 0)
569 ui_out_field_int (uiout, "pid", inferior->pid);
570
571 if (inferior->pspace->ebfd)
572 {
573 ui_out_field_string (uiout, "executable",
574 bfd_get_filename (inferior->pspace->ebfd));
575 }
576
577 data.cores = 0;
578 if (inferior->pid != 0)
579 {
580 data.pid = inferior->pid;
581 iterate_over_threads (collect_cores, &data);
582 }
583
584 if (!VEC_empty (int, data.cores))
585 {
586 int *b, *e;
587 struct cleanup *back_to_2 =
588 make_cleanup_ui_out_list_begin_end (uiout, "cores");
589
590 qsort (VEC_address (int, data.cores),
591 VEC_length (int, data.cores), sizeof (int),
592 compare_positive_ints);
593
594 b = VEC_address (int, data.cores);
595 e = b + VEC_length (int, data.cores);
596 e = unique (b, e);
597
598 for (; b != e; ++b)
599 ui_out_field_int (uiout, NULL, *b);
600
601 do_cleanups (back_to_2);
602 }
603
604 if (top_data->recurse)
605 print_thread_info (uiout, NULL, inferior->pid);
606
607 do_cleanups (back_to);
608 }
609
610 return 0;
611 }
612
613 /* Output a field named 'cores' with a list as the value. The elements of
614 the list are obtained by splitting 'cores' on comma. */
615
616 static void
output_cores(struct ui_out * uiout,const char * field_name,const char * xcores)617 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
618 {
619 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
620 field_name);
621 char *cores = xstrdup (xcores);
622 char *p = cores;
623
624 make_cleanup (xfree, cores);
625
626 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
627 ui_out_field_string (uiout, NULL, p);
628
629 do_cleanups (back_to);
630 }
631
632 static void
free_vector_of_ints(void * xvector)633 free_vector_of_ints (void *xvector)
634 {
635 VEC (int) **vector = xvector;
636
637 VEC_free (int, *vector);
638 }
639
640 static void
do_nothing(splay_tree_key k)641 do_nothing (splay_tree_key k)
642 {
643 }
644
645 static void
free_vector_of_osdata_items(splay_tree_value xvalue)646 free_vector_of_osdata_items (splay_tree_value xvalue)
647 {
648 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
649
650 /* We don't free the items itself, it will be done separately. */
651 VEC_free (osdata_item_s, value);
652 }
653
654 static int
splay_tree_int_comparator(splay_tree_key xa,splay_tree_key xb)655 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
656 {
657 int a = xa;
658 int b = xb;
659
660 return a - b;
661 }
662
663 static void
free_splay_tree(void * xt)664 free_splay_tree (void *xt)
665 {
666 splay_tree t = xt;
667 splay_tree_delete (t);
668 }
669
670 static void
list_available_thread_groups(VEC (int)* ids,int recurse)671 list_available_thread_groups (VEC (int) *ids, int recurse)
672 {
673 struct osdata *data;
674 struct osdata_item *item;
675 int ix_items;
676
677 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
678 The vector contains information about all threads for the given pid.
679 This is assigned an initial value to avoid "may be used uninitialized"
680 warning from gcc. */
681 splay_tree tree = NULL;
682
683 /* get_osdata will throw if it cannot return data. */
684 data = get_osdata ("processes");
685 make_cleanup_osdata_free (data);
686
687 if (recurse)
688 {
689 struct osdata *threads = get_osdata ("threads");
690
691 make_cleanup_osdata_free (threads);
692 tree = splay_tree_new (splay_tree_int_comparator,
693 do_nothing,
694 free_vector_of_osdata_items);
695 make_cleanup (free_splay_tree, tree);
696
697 for (ix_items = 0;
698 VEC_iterate (osdata_item_s, threads->items,
699 ix_items, item);
700 ix_items++)
701 {
702 const char *pid = get_osdata_column (item, "pid");
703 int pid_i = strtoul (pid, NULL, 0);
704 VEC (osdata_item_s) *vec = 0;
705
706 splay_tree_node n = splay_tree_lookup (tree, pid_i);
707 if (!n)
708 {
709 VEC_safe_push (osdata_item_s, vec, item);
710 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
711 }
712 else
713 {
714 vec = (VEC (osdata_item_s) *) n->value;
715 VEC_safe_push (osdata_item_s, vec, item);
716 n->value = (splay_tree_value) vec;
717 }
718 }
719 }
720
721 make_cleanup_ui_out_list_begin_end (uiout, "groups");
722
723 for (ix_items = 0;
724 VEC_iterate (osdata_item_s, data->items,
725 ix_items, item);
726 ix_items++)
727 {
728 struct cleanup *back_to;
729
730 const char *pid = get_osdata_column (item, "pid");
731 const char *cmd = get_osdata_column (item, "command");
732 const char *user = get_osdata_column (item, "user");
733 const char *cores = get_osdata_column (item, "cores");
734
735 int pid_i = strtoul (pid, NULL, 0);
736
737 /* At present, the target will return all available processes
738 and if information about specific ones was required, we filter
739 undesired processes here. */
740 if (ids && bsearch (&pid_i, VEC_address (int, ids),
741 VEC_length (int, ids),
742 sizeof (int), compare_positive_ints) == NULL)
743 continue;
744
745
746 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
747
748 ui_out_field_fmt (uiout, "id", "%s", pid);
749 ui_out_field_string (uiout, "type", "process");
750 if (cmd)
751 ui_out_field_string (uiout, "description", cmd);
752 if (user)
753 ui_out_field_string (uiout, "user", user);
754 if (cores)
755 output_cores (uiout, "cores", cores);
756
757 if (recurse)
758 {
759 splay_tree_node n = splay_tree_lookup (tree, pid_i);
760 if (n)
761 {
762 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
763 struct osdata_item *child;
764 int ix_child;
765
766 make_cleanup_ui_out_list_begin_end (uiout, "threads");
767
768 for (ix_child = 0;
769 VEC_iterate (osdata_item_s, children, ix_child, child);
770 ++ix_child)
771 {
772 struct cleanup *back_to_2 =
773 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
774 const char *tid = get_osdata_column (child, "tid");
775 const char *tcore = get_osdata_column (child, "core");
776
777 ui_out_field_string (uiout, "id", tid);
778 if (tcore)
779 ui_out_field_string (uiout, "core", tcore);
780
781 do_cleanups (back_to_2);
782 }
783 }
784 }
785
786 do_cleanups (back_to);
787 }
788 }
789
790 void
mi_cmd_list_thread_groups(char * command,char ** argv,int argc)791 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
792 {
793 struct cleanup *back_to;
794 int available = 0;
795 int recurse = 0;
796 VEC (int) *ids = 0;
797
798 enum opt
799 {
800 AVAILABLE_OPT, RECURSE_OPT
801 };
802 static struct mi_opt opts[] =
803 {
804 {"-available", AVAILABLE_OPT, 0},
805 {"-recurse", RECURSE_OPT, 1},
806 { 0, 0, 0 }
807 };
808
809 int optind = 0;
810 char *optarg;
811
812 while (1)
813 {
814 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
815 &optind, &optarg);
816
817 if (opt < 0)
818 break;
819 switch ((enum opt) opt)
820 {
821 case AVAILABLE_OPT:
822 available = 1;
823 break;
824 case RECURSE_OPT:
825 if (strcmp (optarg, "0") == 0)
826 ;
827 else if (strcmp (optarg, "1") == 0)
828 recurse = 1;
829 else
830 error (_("only '0' and '1' are valid values "
831 "for the '--recurse' option"));
832 break;
833 }
834 }
835
836 for (; optind < argc; ++optind)
837 {
838 char *end;
839 int inf;
840
841 if (*(argv[optind]) != 'i')
842 error (_("invalid syntax of group id '%s'"), argv[optind]);
843
844 inf = strtoul (argv[optind] + 1, &end, 0);
845
846 if (*end != '\0')
847 error (_("invalid syntax of group id '%s'"), argv[optind]);
848 VEC_safe_push (int, ids, inf);
849 }
850 if (VEC_length (int, ids) > 1)
851 qsort (VEC_address (int, ids),
852 VEC_length (int, ids),
853 sizeof (int), compare_positive_ints);
854
855 back_to = make_cleanup (free_vector_of_ints, &ids);
856
857 if (available)
858 {
859 list_available_thread_groups (ids, recurse);
860 }
861 else if (VEC_length (int, ids) == 1)
862 {
863 /* Local thread groups, single id. */
864 int id = *VEC_address (int, ids);
865 struct inferior *inf = find_inferior_id (id);
866
867 if (!inf)
868 error (_("Non-existent thread group id '%d'"), id);
869
870 print_thread_info (uiout, NULL, inf->pid);
871 }
872 else
873 {
874 struct print_one_inferior_data data;
875
876 data.recurse = recurse;
877 data.inferiors = ids;
878
879 /* Local thread groups. Either no explicit ids -- and we
880 print everything, or several explicit ids. In both cases,
881 we print more than one group, and have to use 'groups'
882 as the top-level element. */
883 make_cleanup_ui_out_list_begin_end (uiout, "groups");
884 update_thread_list ();
885 iterate_over_inferiors (print_one_inferior, &data);
886 }
887
888 do_cleanups (back_to);
889 }
890
891 void
mi_cmd_data_list_register_names(char * command,char ** argv,int argc)892 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
893 {
894 struct gdbarch *gdbarch;
895 int regnum, numregs;
896 int i;
897 struct cleanup *cleanup;
898
899 /* Note that the test for a valid register must include checking the
900 gdbarch_register_name because gdbarch_num_regs may be allocated for
901 the union of the register sets within a family of related processors.
902 In this case, some entries of gdbarch_register_name will change depending
903 upon the particular processor being debugged. */
904
905 gdbarch = get_current_arch ();
906 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
907
908 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
909
910 if (argc == 0) /* No args, just do all the regs. */
911 {
912 for (regnum = 0;
913 regnum < numregs;
914 regnum++)
915 {
916 if (gdbarch_register_name (gdbarch, regnum) == NULL
917 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
918 ui_out_field_string (uiout, NULL, "");
919 else
920 ui_out_field_string (uiout, NULL,
921 gdbarch_register_name (gdbarch, regnum));
922 }
923 }
924
925 /* Else, list of register #s, just do listed regs. */
926 for (i = 0; i < argc; i++)
927 {
928 regnum = atoi (argv[i]);
929 if (regnum < 0 || regnum >= numregs)
930 error (_("bad register number"));
931
932 if (gdbarch_register_name (gdbarch, regnum) == NULL
933 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
934 ui_out_field_string (uiout, NULL, "");
935 else
936 ui_out_field_string (uiout, NULL,
937 gdbarch_register_name (gdbarch, regnum));
938 }
939 do_cleanups (cleanup);
940 }
941
942 void
mi_cmd_data_list_changed_registers(char * command,char ** argv,int argc)943 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
944 {
945 static struct regcache *this_regs = NULL;
946 struct regcache *prev_regs;
947 struct gdbarch *gdbarch;
948 int regnum, numregs, changed;
949 int i;
950 struct cleanup *cleanup;
951
952 /* The last time we visited this function, the current frame's register
953 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
954 and refresh THIS_REGS with the now-current register contents. */
955
956 prev_regs = this_regs;
957 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
958 cleanup = make_cleanup_regcache_xfree (prev_regs);
959
960 /* Note that the test for a valid register must include checking the
961 gdbarch_register_name because gdbarch_num_regs may be allocated for
962 the union of the register sets within a family of related processors.
963 In this case, some entries of gdbarch_register_name will change depending
964 upon the particular processor being debugged. */
965
966 gdbarch = get_regcache_arch (this_regs);
967 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
968
969 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
970
971 if (argc == 0) /* No args, just do all the regs. */
972 {
973 for (regnum = 0;
974 regnum < numregs;
975 regnum++)
976 {
977 if (gdbarch_register_name (gdbarch, regnum) == NULL
978 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
979 continue;
980 changed = register_changed_p (regnum, prev_regs, this_regs);
981 if (changed < 0)
982 error (_("-data-list-changed-registers: "
983 "Unable to read register contents."));
984 else if (changed)
985 ui_out_field_int (uiout, NULL, regnum);
986 }
987 }
988
989 /* Else, list of register #s, just do listed regs. */
990 for (i = 0; i < argc; i++)
991 {
992 regnum = atoi (argv[i]);
993
994 if (regnum >= 0
995 && regnum < numregs
996 && gdbarch_register_name (gdbarch, regnum) != NULL
997 && *gdbarch_register_name (gdbarch, regnum) != '\000')
998 {
999 changed = register_changed_p (regnum, prev_regs, this_regs);
1000 if (changed < 0)
1001 error (_("-data-list-changed-registers: "
1002 "Unable to read register contents."));
1003 else if (changed)
1004 ui_out_field_int (uiout, NULL, regnum);
1005 }
1006 else
1007 error (_("bad register number"));
1008 }
1009 do_cleanups (cleanup);
1010 }
1011
1012 static int
register_changed_p(int regnum,struct regcache * prev_regs,struct regcache * this_regs)1013 register_changed_p (int regnum, struct regcache *prev_regs,
1014 struct regcache *this_regs)
1015 {
1016 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1017 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1018 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1019 enum register_status prev_status;
1020 enum register_status this_status;
1021
1022 /* First time through or after gdbarch change consider all registers
1023 as changed. */
1024 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1025 return 1;
1026
1027 /* Get register contents and compare. */
1028 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1029 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1030
1031 if (this_status != prev_status)
1032 return 1;
1033 else if (this_status == REG_VALID)
1034 return memcmp (prev_buffer, this_buffer,
1035 register_size (gdbarch, regnum)) != 0;
1036 else
1037 return 0;
1038 }
1039
1040 /* Return a list of register number and value pairs. The valid
1041 arguments expected are: a letter indicating the format in which to
1042 display the registers contents. This can be one of: x (hexadecimal), d
1043 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1044 format argumetn there can be a sequence of numbers, indicating which
1045 registers to fetch the content of. If the format is the only argument,
1046 a list of all the registers with their values is returned. */
1047 void
mi_cmd_data_list_register_values(char * command,char ** argv,int argc)1048 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1049 {
1050 struct frame_info *frame;
1051 struct gdbarch *gdbarch;
1052 int regnum, numregs, format;
1053 int i;
1054 struct cleanup *list_cleanup, *tuple_cleanup;
1055
1056 /* Note that the test for a valid register must include checking the
1057 gdbarch_register_name because gdbarch_num_regs may be allocated for
1058 the union of the register sets within a family of related processors.
1059 In this case, some entries of gdbarch_register_name will change depending
1060 upon the particular processor being debugged. */
1061
1062 if (argc == 0)
1063 error (_("-data-list-register-values: Usage: "
1064 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1065
1066 format = (int) argv[0][0];
1067
1068 frame = get_selected_frame (NULL);
1069 gdbarch = get_frame_arch (frame);
1070 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1071
1072 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1073
1074 if (argc == 1) /* No args, beside the format: do all the regs. */
1075 {
1076 for (regnum = 0;
1077 regnum < numregs;
1078 regnum++)
1079 {
1080 if (gdbarch_register_name (gdbarch, regnum) == NULL
1081 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1082 continue;
1083 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1084 ui_out_field_int (uiout, "number", regnum);
1085 get_register (frame, regnum, format);
1086 do_cleanups (tuple_cleanup);
1087 }
1088 }
1089
1090 /* Else, list of register #s, just do listed regs. */
1091 for (i = 1; i < argc; i++)
1092 {
1093 regnum = atoi (argv[i]);
1094
1095 if (regnum >= 0
1096 && regnum < numregs
1097 && gdbarch_register_name (gdbarch, regnum) != NULL
1098 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1099 {
1100 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1101 ui_out_field_int (uiout, "number", regnum);
1102 get_register (frame, regnum, format);
1103 do_cleanups (tuple_cleanup);
1104 }
1105 else
1106 error (_("bad register number"));
1107 }
1108 do_cleanups (list_cleanup);
1109 }
1110
1111 /* Output one register's contents in the desired format. */
1112 static void
get_register(struct frame_info * frame,int regnum,int format)1113 get_register (struct frame_info *frame, int regnum, int format)
1114 {
1115 struct gdbarch *gdbarch = get_frame_arch (frame);
1116 CORE_ADDR addr;
1117 enum lval_type lval;
1118 static struct ui_stream *stb = NULL;
1119 struct value *val;
1120
1121 stb = ui_out_stream_new (uiout);
1122
1123 if (format == 'N')
1124 format = 0;
1125
1126 val = get_frame_register_value (frame, regnum);
1127
1128 if (value_optimized_out (val))
1129 error (_("Optimized out"));
1130
1131 if (format == 'r')
1132 {
1133 int j;
1134 char *ptr, buf[1024];
1135 const gdb_byte *valaddr = value_contents_for_printing (val);
1136
1137 strcpy (buf, "0x");
1138 ptr = buf + 2;
1139 for (j = 0; j < register_size (gdbarch, regnum); j++)
1140 {
1141 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1142 j : register_size (gdbarch, regnum) - 1 - j;
1143
1144 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1145 ptr += 2;
1146 }
1147 ui_out_field_string (uiout, "value", buf);
1148 /*fputs_filtered (buf, gdb_stdout); */
1149 }
1150 else
1151 {
1152 struct value_print_options opts;
1153
1154 get_formatted_print_options (&opts, format);
1155 opts.deref_ref = 1;
1156 val_print (value_type (val),
1157 value_contents_for_printing (val),
1158 value_embedded_offset (val), 0,
1159 stb->stream, 0, val, &opts, current_language);
1160 ui_out_field_stream (uiout, "value", stb);
1161 ui_out_stream_delete (stb);
1162 }
1163 }
1164
1165 /* Write given values into registers. The registers and values are
1166 given as pairs. The corresponding MI command is
1167 -data-write-register-values <format>
1168 [<regnum1> <value1>...<regnumN> <valueN>] */
1169 void
mi_cmd_data_write_register_values(char * command,char ** argv,int argc)1170 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1171 {
1172 struct regcache *regcache;
1173 struct gdbarch *gdbarch;
1174 int numregs, i;
1175 char format;
1176
1177 /* Note that the test for a valid register must include checking the
1178 gdbarch_register_name because gdbarch_num_regs may be allocated for
1179 the union of the register sets within a family of related processors.
1180 In this case, some entries of gdbarch_register_name will change depending
1181 upon the particular processor being debugged. */
1182
1183 regcache = get_current_regcache ();
1184 gdbarch = get_regcache_arch (regcache);
1185 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1186
1187 if (argc == 0)
1188 error (_("-data-write-register-values: Usage: -data-write-register-"
1189 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1190
1191 format = (int) argv[0][0];
1192
1193 if (!target_has_registers)
1194 error (_("-data-write-register-values: No registers."));
1195
1196 if (!(argc - 1))
1197 error (_("-data-write-register-values: No regs and values specified."));
1198
1199 if ((argc - 1) % 2)
1200 error (_("-data-write-register-values: "
1201 "Regs and vals are not in pairs."));
1202
1203 for (i = 1; i < argc; i = i + 2)
1204 {
1205 int regnum = atoi (argv[i]);
1206
1207 if (regnum >= 0 && regnum < numregs
1208 && gdbarch_register_name (gdbarch, regnum)
1209 && *gdbarch_register_name (gdbarch, regnum))
1210 {
1211 LONGEST value;
1212
1213 /* Get the value as a number. */
1214 value = parse_and_eval_address (argv[i + 1]);
1215
1216 /* Write it down. */
1217 regcache_cooked_write_signed (regcache, regnum, value);
1218 }
1219 else
1220 error (_("bad register number"));
1221 }
1222 }
1223
1224 /* Evaluate the value of the argument. The argument is an
1225 expression. If the expression contains spaces it needs to be
1226 included in double quotes. */
1227 void
mi_cmd_data_evaluate_expression(char * command,char ** argv,int argc)1228 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1229 {
1230 struct expression *expr;
1231 struct cleanup *old_chain = NULL;
1232 struct value *val;
1233 struct ui_stream *stb = NULL;
1234 struct value_print_options opts;
1235
1236 stb = ui_out_stream_new (uiout);
1237
1238 if (argc != 1)
1239 {
1240 ui_out_stream_delete (stb);
1241 error (_("-data-evaluate-expression: "
1242 "Usage: -data-evaluate-expression expression"));
1243 }
1244
1245 expr = parse_expression (argv[0]);
1246
1247 old_chain = make_cleanup (free_current_contents, &expr);
1248
1249 val = evaluate_expression (expr);
1250
1251 /* Print the result of the expression evaluation. */
1252 get_user_print_options (&opts);
1253 opts.deref_ref = 0;
1254 common_val_print (val, stb->stream, 0, &opts, current_language);
1255
1256 ui_out_field_stream (uiout, "value", stb);
1257 ui_out_stream_delete (stb);
1258
1259 do_cleanups (old_chain);
1260 }
1261
1262 /* DATA-MEMORY-READ:
1263
1264 ADDR: start address of data to be dumped.
1265 WORD-FORMAT: a char indicating format for the ``word''. See
1266 the ``x'' command.
1267 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1268 NR_ROW: Number of rows.
1269 NR_COL: The number of colums (words per row).
1270 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1271 ASCHAR for unprintable characters.
1272
1273 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1274 displayes them. Returns:
1275
1276 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1277
1278 Returns:
1279 The number of bytes read is SIZE*ROW*COL. */
1280
1281 void
mi_cmd_data_read_memory(char * command,char ** argv,int argc)1282 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1283 {
1284 struct gdbarch *gdbarch = get_current_arch ();
1285 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1286 CORE_ADDR addr;
1287 long total_bytes;
1288 long nr_cols;
1289 long nr_rows;
1290 char word_format;
1291 struct type *word_type;
1292 long word_size;
1293 char word_asize;
1294 char aschar;
1295 gdb_byte *mbuf;
1296 int nr_bytes;
1297 long offset = 0;
1298 int optind = 0;
1299 char *optarg;
1300 enum opt
1301 {
1302 OFFSET_OPT
1303 };
1304 static struct mi_opt opts[] =
1305 {
1306 {"o", OFFSET_OPT, 1},
1307 { 0, 0, 0 }
1308 };
1309
1310 while (1)
1311 {
1312 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1313 &optind, &optarg);
1314
1315 if (opt < 0)
1316 break;
1317 switch ((enum opt) opt)
1318 {
1319 case OFFSET_OPT:
1320 offset = atol (optarg);
1321 break;
1322 }
1323 }
1324 argv += optind;
1325 argc -= optind;
1326
1327 if (argc < 5 || argc > 6)
1328 error (_("-data-read-memory: Usage: "
1329 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1330
1331 /* Extract all the arguments. */
1332
1333 /* Start address of the memory dump. */
1334 addr = parse_and_eval_address (argv[0]) + offset;
1335 /* The format character to use when displaying a memory word. See
1336 the ``x'' command. */
1337 word_format = argv[1][0];
1338 /* The size of the memory word. */
1339 word_size = atol (argv[2]);
1340 switch (word_size)
1341 {
1342 case 1:
1343 word_type = builtin_type (gdbarch)->builtin_int8;
1344 word_asize = 'b';
1345 break;
1346 case 2:
1347 word_type = builtin_type (gdbarch)->builtin_int16;
1348 word_asize = 'h';
1349 break;
1350 case 4:
1351 word_type = builtin_type (gdbarch)->builtin_int32;
1352 word_asize = 'w';
1353 break;
1354 case 8:
1355 word_type = builtin_type (gdbarch)->builtin_int64;
1356 word_asize = 'g';
1357 break;
1358 default:
1359 word_type = builtin_type (gdbarch)->builtin_int8;
1360 word_asize = 'b';
1361 }
1362 /* The number of rows. */
1363 nr_rows = atol (argv[3]);
1364 if (nr_rows <= 0)
1365 error (_("-data-read-memory: invalid number of rows."));
1366
1367 /* Number of bytes per row. */
1368 nr_cols = atol (argv[4]);
1369 if (nr_cols <= 0)
1370 error (_("-data-read-memory: invalid number of columns."));
1371
1372 /* The un-printable character when printing ascii. */
1373 if (argc == 6)
1374 aschar = *argv[5];
1375 else
1376 aschar = 0;
1377
1378 /* Create a buffer and read it in. */
1379 total_bytes = word_size * nr_rows * nr_cols;
1380 mbuf = xcalloc (total_bytes, 1);
1381 make_cleanup (xfree, mbuf);
1382
1383 /* Dispatch memory reads to the topmost target, not the flattened
1384 current_target. */
1385 nr_bytes = target_read (current_target.beneath,
1386 TARGET_OBJECT_MEMORY, NULL, mbuf,
1387 addr, total_bytes);
1388 if (nr_bytes <= 0)
1389 error (_("Unable to read memory."));
1390
1391 /* Output the header information. */
1392 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1393 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1394 ui_out_field_int (uiout, "total-bytes", total_bytes);
1395 ui_out_field_core_addr (uiout, "next-row",
1396 gdbarch, addr + word_size * nr_cols);
1397 ui_out_field_core_addr (uiout, "prev-row",
1398 gdbarch, addr - word_size * nr_cols);
1399 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1400 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1401
1402 /* Build the result as a two dimentional table. */
1403 {
1404 struct ui_stream *stream = ui_out_stream_new (uiout);
1405 struct cleanup *cleanup_list_memory;
1406 int row;
1407 int row_byte;
1408
1409 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1410 for (row = 0, row_byte = 0;
1411 row < nr_rows;
1412 row++, row_byte += nr_cols * word_size)
1413 {
1414 int col;
1415 int col_byte;
1416 struct cleanup *cleanup_tuple;
1417 struct cleanup *cleanup_list_data;
1418 struct value_print_options opts;
1419
1420 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1421 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1422 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1423 row_byte); */
1424 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1425 get_formatted_print_options (&opts, word_format);
1426 for (col = 0, col_byte = row_byte;
1427 col < nr_cols;
1428 col++, col_byte += word_size)
1429 {
1430 if (col_byte + word_size > nr_bytes)
1431 {
1432 ui_out_field_string (uiout, NULL, "N/A");
1433 }
1434 else
1435 {
1436 ui_file_rewind (stream->stream);
1437 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1438 word_asize, stream->stream);
1439 ui_out_field_stream (uiout, NULL, stream);
1440 }
1441 }
1442 do_cleanups (cleanup_list_data);
1443 if (aschar)
1444 {
1445 int byte;
1446
1447 ui_file_rewind (stream->stream);
1448 for (byte = row_byte;
1449 byte < row_byte + word_size * nr_cols; byte++)
1450 {
1451 if (byte >= nr_bytes)
1452 {
1453 fputc_unfiltered ('X', stream->stream);
1454 }
1455 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1456 {
1457 fputc_unfiltered (aschar, stream->stream);
1458 }
1459 else
1460 fputc_unfiltered (mbuf[byte], stream->stream);
1461 }
1462 ui_out_field_stream (uiout, "ascii", stream);
1463 }
1464 do_cleanups (cleanup_tuple);
1465 }
1466 ui_out_stream_delete (stream);
1467 do_cleanups (cleanup_list_memory);
1468 }
1469 do_cleanups (cleanups);
1470 }
1471
1472 void
mi_cmd_data_read_memory_bytes(char * command,char ** argv,int argc)1473 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1474 {
1475 struct gdbarch *gdbarch = get_current_arch ();
1476 struct cleanup *cleanups;
1477 CORE_ADDR addr;
1478 LONGEST length;
1479 memory_read_result_s *read_result;
1480 int ix;
1481 VEC(memory_read_result_s) *result;
1482 long offset = 0;
1483 int optind = 0;
1484 char *optarg;
1485 enum opt
1486 {
1487 OFFSET_OPT
1488 };
1489 static struct mi_opt opts[] =
1490 {
1491 {"o", OFFSET_OPT, 1},
1492 { 0, 0, 0 }
1493 };
1494
1495 while (1)
1496 {
1497 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1498 &optind, &optarg);
1499 if (opt < 0)
1500 break;
1501 switch ((enum opt) opt)
1502 {
1503 case OFFSET_OPT:
1504 offset = atol (optarg);
1505 break;
1506 }
1507 }
1508 argv += optind;
1509 argc -= optind;
1510
1511 if (argc != 2)
1512 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1513
1514 addr = parse_and_eval_address (argv[0]) + offset;
1515 length = atol (argv[1]);
1516
1517 result = read_memory_robust (current_target.beneath, addr, length);
1518
1519 cleanups = make_cleanup (free_memory_read_result_vector, result);
1520
1521 if (VEC_length (memory_read_result_s, result) == 0)
1522 error (_("Unable to read memory."));
1523
1524 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1525 for (ix = 0;
1526 VEC_iterate (memory_read_result_s, result, ix, read_result);
1527 ++ix)
1528 {
1529 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1530 char *data, *p;
1531 int i;
1532
1533 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1534 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1535 - addr);
1536 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1537
1538 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1539
1540 for (i = 0, p = data;
1541 i < (read_result->end - read_result->begin);
1542 ++i, p += 2)
1543 {
1544 sprintf (p, "%02x", read_result->data[i]);
1545 }
1546 ui_out_field_string (uiout, "contents", data);
1547 xfree (data);
1548 do_cleanups (t);
1549 }
1550 do_cleanups (cleanups);
1551 }
1552
1553
1554 /* DATA-MEMORY-WRITE:
1555
1556 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1557 offset from the beginning of the memory grid row where the cell to
1558 be written is.
1559 ADDR: start address of the row in the memory grid where the memory
1560 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1561 the location to write to.
1562 FORMAT: a char indicating format for the ``word''. See
1563 the ``x'' command.
1564 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1565 VALUE: value to be written into the memory address.
1566
1567 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1568
1569 Prints nothing. */
1570 void
mi_cmd_data_write_memory(char * command,char ** argv,int argc)1571 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1572 {
1573 struct gdbarch *gdbarch = get_current_arch ();
1574 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1575 CORE_ADDR addr;
1576 char word_format;
1577 long word_size;
1578 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1579 enough when using a compiler other than GCC. */
1580 LONGEST value;
1581 void *buffer;
1582 struct cleanup *old_chain;
1583 long offset = 0;
1584 int optind = 0;
1585 char *optarg;
1586 enum opt
1587 {
1588 OFFSET_OPT
1589 };
1590 static struct mi_opt opts[] =
1591 {
1592 {"o", OFFSET_OPT, 1},
1593 { 0, 0, 0 }
1594 };
1595
1596 while (1)
1597 {
1598 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1599 &optind, &optarg);
1600
1601 if (opt < 0)
1602 break;
1603 switch ((enum opt) opt)
1604 {
1605 case OFFSET_OPT:
1606 offset = atol (optarg);
1607 break;
1608 }
1609 }
1610 argv += optind;
1611 argc -= optind;
1612
1613 if (argc != 4)
1614 error (_("-data-write-memory: Usage: "
1615 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1616
1617 /* Extract all the arguments. */
1618 /* Start address of the memory dump. */
1619 addr = parse_and_eval_address (argv[0]);
1620 /* The format character to use when displaying a memory word. See
1621 the ``x'' command. */
1622 word_format = argv[1][0];
1623 /* The size of the memory word. */
1624 word_size = atol (argv[2]);
1625
1626 /* Calculate the real address of the write destination. */
1627 addr += (offset * word_size);
1628
1629 /* Get the value as a number. */
1630 value = parse_and_eval_address (argv[3]);
1631 /* Get the value into an array. */
1632 buffer = xmalloc (word_size);
1633 old_chain = make_cleanup (xfree, buffer);
1634 store_signed_integer (buffer, word_size, byte_order, value);
1635 /* Write it down to memory. */
1636 write_memory (addr, buffer, word_size);
1637 /* Free the buffer. */
1638 do_cleanups (old_chain);
1639 }
1640
1641 /* DATA-MEMORY-WRITE-RAW:
1642
1643 ADDR: start address
1644 DATA: string of bytes to write at that address. */
1645 void
mi_cmd_data_write_memory_bytes(char * command,char ** argv,int argc)1646 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1647 {
1648 CORE_ADDR addr;
1649 char *cdata;
1650 gdb_byte *data;
1651 int len, r, i;
1652 struct cleanup *back_to;
1653
1654 if (argc != 2)
1655 error (_("Usage: ADDR DATA."));
1656
1657 addr = parse_and_eval_address (argv[0]);
1658 cdata = argv[1];
1659 len = strlen (cdata)/2;
1660
1661 data = xmalloc (len);
1662 back_to = make_cleanup (xfree, data);
1663
1664 for (i = 0; i < len; ++i)
1665 {
1666 int x;
1667 sscanf (cdata + i * 2, "%02x", &x);
1668 data[i] = (gdb_byte)x;
1669 }
1670
1671 r = target_write_memory (addr, data, len);
1672 if (r != 0)
1673 error (_("Could not write memory"));
1674
1675 do_cleanups (back_to);
1676 }
1677
1678
1679 void
mi_cmd_enable_timings(char * command,char ** argv,int argc)1680 mi_cmd_enable_timings (char *command, char **argv, int argc)
1681 {
1682 if (argc == 0)
1683 do_timings = 1;
1684 else if (argc == 1)
1685 {
1686 if (strcmp (argv[0], "yes") == 0)
1687 do_timings = 1;
1688 else if (strcmp (argv[0], "no") == 0)
1689 do_timings = 0;
1690 else
1691 goto usage_error;
1692 }
1693 else
1694 goto usage_error;
1695
1696 return;
1697
1698 usage_error:
1699 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1700 }
1701
1702 void
mi_cmd_list_features(char * command,char ** argv,int argc)1703 mi_cmd_list_features (char *command, char **argv, int argc)
1704 {
1705 if (argc == 0)
1706 {
1707 struct cleanup *cleanup = NULL;
1708
1709 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1710 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1711 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1712 ui_out_field_string (uiout, NULL, "thread-info");
1713 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1714
1715 #if HAVE_PYTHON
1716 ui_out_field_string (uiout, NULL, "python");
1717 #endif
1718
1719 do_cleanups (cleanup);
1720 return;
1721 }
1722
1723 error (_("-list-features should be passed no arguments"));
1724 }
1725
1726 void
mi_cmd_list_target_features(char * command,char ** argv,int argc)1727 mi_cmd_list_target_features (char *command, char **argv, int argc)
1728 {
1729 if (argc == 0)
1730 {
1731 struct cleanup *cleanup = NULL;
1732
1733 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1734 if (target_can_async_p ())
1735 ui_out_field_string (uiout, NULL, "async");
1736 if (target_can_execute_reverse)
1737 ui_out_field_string (uiout, NULL, "reverse");
1738
1739 do_cleanups (cleanup);
1740 return;
1741 }
1742
1743 error (_("-list-target-features should be passed no arguments"));
1744 }
1745
1746 void
mi_cmd_add_inferior(char * command,char ** argv,int argc)1747 mi_cmd_add_inferior (char *command, char **argv, int argc)
1748 {
1749 struct inferior *inf;
1750
1751 if (argc != 0)
1752 error (_("-add-inferior should be passed no arguments"));
1753
1754 inf = add_inferior_with_spaces ();
1755
1756 ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
1757 }
1758
1759 /* Callback used to find the first inferior other than the
1760 current one. */
1761
1762 static int
get_other_inferior(struct inferior * inf,void * arg)1763 get_other_inferior (struct inferior *inf, void *arg)
1764 {
1765 if (inf == current_inferior ())
1766 return 0;
1767
1768 return 1;
1769 }
1770
1771 void
mi_cmd_remove_inferior(char * command,char ** argv,int argc)1772 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1773 {
1774 int id;
1775 struct inferior *inf;
1776
1777 if (argc != 1)
1778 error (_("-remove-inferior should be passed a single argument"));
1779
1780 if (sscanf (argv[0], "i%d", &id) != 1)
1781 error (_("the thread group id is syntactically invalid"));
1782
1783 inf = find_inferior_id (id);
1784 if (!inf)
1785 error (_("the specified thread group does not exist"));
1786
1787 if (inf->pid != 0)
1788 error (_("cannot remove an active inferior"));
1789
1790 if (inf == current_inferior ())
1791 {
1792 struct thread_info *tp = 0;
1793 struct inferior *new_inferior
1794 = iterate_over_inferiors (get_other_inferior, NULL);
1795
1796 if (new_inferior == NULL)
1797 error (_("Cannot remove last inferior"));
1798
1799 set_current_inferior (new_inferior);
1800 if (new_inferior->pid != 0)
1801 tp = any_thread_of_process (new_inferior->pid);
1802 switch_to_thread (tp ? tp->ptid : null_ptid);
1803 set_current_program_space (new_inferior->pspace);
1804 }
1805
1806 delete_inferior_1 (inf, 1 /* silent */);
1807 }
1808
1809
1810
1811 /* Execute a command within a safe environment.
1812 Return <0 for error; >=0 for ok.
1813
1814 args->action will tell mi_execute_command what action
1815 to perfrom after the given command has executed (display/suppress
1816 prompt, display error). */
1817
1818 static void
captured_mi_execute_command(struct ui_out * uiout,void * data)1819 captured_mi_execute_command (struct ui_out *uiout, void *data)
1820 {
1821 struct cleanup *cleanup;
1822 struct mi_parse *context = (struct mi_parse *) data;
1823
1824 if (do_timings)
1825 current_command_ts = context->cmd_start;
1826
1827 current_token = xstrdup (context->token);
1828 cleanup = make_cleanup (free_current_contents, ¤t_token);
1829
1830 running_result_record_printed = 0;
1831 mi_proceeded = 0;
1832 switch (context->op)
1833 {
1834 case MI_COMMAND:
1835 /* A MI command was read from the input stream. */
1836 if (mi_debug_p)
1837 /* FIXME: gdb_???? */
1838 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1839 context->token, context->command, context->args);
1840
1841
1842 mi_cmd_execute (context);
1843
1844 /* Print the result if there were no errors.
1845
1846 Remember that on the way out of executing a command, you have
1847 to directly use the mi_interp's uiout, since the command could
1848 have reset the interpreter, in which case the current uiout
1849 will most likely crash in the mi_out_* routines. */
1850 if (!running_result_record_printed)
1851 {
1852 fputs_unfiltered (context->token, raw_stdout);
1853 /* There's no particularly good reason why target-connect results
1854 in not ^done. Should kill ^connected for MI3. */
1855 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1856 ? "^connected" : "^done", raw_stdout);
1857 mi_out_put (uiout, raw_stdout);
1858 mi_out_rewind (uiout);
1859 mi_print_timing_maybe ();
1860 fputs_unfiltered ("\n", raw_stdout);
1861 }
1862 else
1863 /* The command does not want anything to be printed. In that
1864 case, the command probably should not have written anything
1865 to uiout, but in case it has written something, discard it. */
1866 mi_out_rewind (uiout);
1867 break;
1868
1869 case CLI_COMMAND:
1870 {
1871 char *argv[2];
1872
1873 /* A CLI command was read from the input stream. */
1874 /* This "feature" will be removed as soon as we have a
1875 complete set of mi commands. */
1876 /* Echo the command on the console. */
1877 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1878 /* Call the "console" interpreter. */
1879 argv[0] = "console";
1880 argv[1] = context->command;
1881 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1882
1883 /* If we changed interpreters, DON'T print out anything. */
1884 if (current_interp_named_p (INTERP_MI)
1885 || current_interp_named_p (INTERP_MI1)
1886 || current_interp_named_p (INTERP_MI2)
1887 || current_interp_named_p (INTERP_MI3))
1888 {
1889 if (!running_result_record_printed)
1890 {
1891 fputs_unfiltered (context->token, raw_stdout);
1892 fputs_unfiltered ("^done", raw_stdout);
1893 mi_out_put (uiout, raw_stdout);
1894 mi_out_rewind (uiout);
1895 mi_print_timing_maybe ();
1896 fputs_unfiltered ("\n", raw_stdout);
1897 }
1898 else
1899 mi_out_rewind (uiout);
1900 }
1901 break;
1902 }
1903
1904 }
1905
1906 do_cleanups (cleanup);
1907
1908 return;
1909 }
1910
1911 /* Print a gdb exception to the MI output stream. */
1912
1913 static void
mi_print_exception(const char * token,struct gdb_exception exception)1914 mi_print_exception (const char *token, struct gdb_exception exception)
1915 {
1916 fputs_unfiltered (token, raw_stdout);
1917 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1918 if (exception.message == NULL)
1919 fputs_unfiltered ("unknown error", raw_stdout);
1920 else
1921 fputstr_unfiltered (exception.message, '"', raw_stdout);
1922 fputs_unfiltered ("\"\n", raw_stdout);
1923 }
1924
1925 void
mi_execute_command(char * cmd,int from_tty)1926 mi_execute_command (char *cmd, int from_tty)
1927 {
1928 char *token;
1929 struct mi_parse *command = NULL;
1930 volatile struct gdb_exception exception;
1931
1932 /* This is to handle EOF (^D). We just quit gdb. */
1933 /* FIXME: we should call some API function here. */
1934 if (cmd == 0)
1935 quit_force (NULL, from_tty);
1936
1937 target_log_command (cmd);
1938
1939 TRY_CATCH (exception, RETURN_MASK_ALL)
1940 {
1941 command = mi_parse (cmd, &token);
1942 }
1943 if (exception.reason < 0)
1944 {
1945 mi_print_exception (token, exception);
1946 xfree (token);
1947 }
1948 else
1949 {
1950 struct gdb_exception result;
1951 ptid_t previous_ptid = inferior_ptid;
1952
1953 command->token = token;
1954
1955 if (do_timings)
1956 {
1957 command->cmd_start = (struct mi_timestamp *)
1958 xmalloc (sizeof (struct mi_timestamp));
1959 timestamp (command->cmd_start);
1960 }
1961
1962 result = catch_exception (uiout, captured_mi_execute_command, command,
1963 RETURN_MASK_ALL);
1964 if (result.reason < 0)
1965 {
1966 /* The command execution failed and error() was called
1967 somewhere. */
1968 mi_print_exception (command->token, result);
1969 mi_out_rewind (uiout);
1970 }
1971
1972 bpstat_do_actions ();
1973
1974 if (/* The notifications are only output when the top-level
1975 interpreter (specified on the command line) is MI. */
1976 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1977 /* Don't try report anything if there are no threads --
1978 the program is dead. */
1979 && thread_count () != 0
1980 /* -thread-select explicitly changes thread. If frontend uses that
1981 internally, we don't want to emit =thread-selected, since
1982 =thread-selected is supposed to indicate user's intentions. */
1983 && strcmp (command->command, "thread-select") != 0)
1984 {
1985 struct mi_interp *mi = top_level_interpreter_data ();
1986 int report_change = 0;
1987
1988 if (command->thread == -1)
1989 {
1990 report_change = (!ptid_equal (previous_ptid, null_ptid)
1991 && !ptid_equal (inferior_ptid, previous_ptid)
1992 && !ptid_equal (inferior_ptid, null_ptid));
1993 }
1994 else if (!ptid_equal (inferior_ptid, null_ptid))
1995 {
1996 struct thread_info *ti = inferior_thread ();
1997
1998 report_change = (ti->num != command->thread);
1999 }
2000
2001 if (report_change)
2002 {
2003 struct thread_info *ti = inferior_thread ();
2004
2005 target_terminal_ours ();
2006 fprintf_unfiltered (mi->event_channel,
2007 "thread-selected,id=\"%d\"",
2008 ti->num);
2009 gdb_flush (mi->event_channel);
2010 }
2011 }
2012
2013 mi_parse_free (command);
2014 }
2015
2016 fputs_unfiltered ("(gdb) \n", raw_stdout);
2017 gdb_flush (raw_stdout);
2018 /* Print any buffered hook code. */
2019 /* ..... */
2020 }
2021
2022 static void
mi_cmd_execute(struct mi_parse * parse)2023 mi_cmd_execute (struct mi_parse *parse)
2024 {
2025 struct cleanup *cleanup;
2026
2027 prepare_execute_command ();
2028
2029 cleanup = make_cleanup (null_cleanup, NULL);
2030
2031 if (parse->all && parse->thread_group != -1)
2032 error (_("Cannot specify --thread-group together with --all"));
2033
2034 if (parse->all && parse->thread != -1)
2035 error (_("Cannot specify --thread together with --all"));
2036
2037 if (parse->thread_group != -1 && parse->thread != -1)
2038 error (_("Cannot specify --thread together with --thread-group"));
2039
2040 if (parse->frame != -1 && parse->thread == -1)
2041 error (_("Cannot specify --frame without --thread"));
2042
2043 if (parse->thread_group != -1)
2044 {
2045 struct inferior *inf = find_inferior_id (parse->thread_group);
2046 struct thread_info *tp = 0;
2047
2048 if (!inf)
2049 error (_("Invalid thread group for the --thread-group option"));
2050
2051 set_current_inferior (inf);
2052 /* This behaviour means that if --thread-group option identifies
2053 an inferior with multiple threads, then a random one will be picked.
2054 This is not a problem -- frontend should always provide --thread if
2055 it wishes to operate on a specific thread. */
2056 if (inf->pid != 0)
2057 tp = any_thread_of_process (inf->pid);
2058 switch_to_thread (tp ? tp->ptid : null_ptid);
2059 set_current_program_space (inf->pspace);
2060 }
2061
2062 if (parse->thread != -1)
2063 {
2064 struct thread_info *tp = find_thread_id (parse->thread);
2065
2066 if (!tp)
2067 error (_("Invalid thread id: %d"), parse->thread);
2068
2069 if (is_exited (tp->ptid))
2070 error (_("Thread id: %d has terminated"), parse->thread);
2071
2072 switch_to_thread (tp->ptid);
2073 }
2074
2075 if (parse->frame != -1)
2076 {
2077 struct frame_info *fid;
2078 int frame = parse->frame;
2079
2080 fid = find_relative_frame (get_current_frame (), &frame);
2081 if (frame == 0)
2082 /* find_relative_frame was successful */
2083 select_frame (fid);
2084 else
2085 error (_("Invalid frame id: %d"), frame);
2086 }
2087
2088 current_context = parse;
2089
2090 if (parse->cmd->argv_func != NULL)
2091 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2092 else if (parse->cmd->cli.cmd != 0)
2093 {
2094 /* FIXME: DELETE THIS. */
2095 /* The operation is still implemented by a cli command. */
2096 /* Must be a synchronous one. */
2097 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2098 parse->args);
2099 }
2100 else
2101 {
2102 /* FIXME: DELETE THIS. */
2103 struct ui_file *stb;
2104
2105 stb = mem_fileopen ();
2106
2107 fputs_unfiltered ("Undefined mi command: ", stb);
2108 fputstr_unfiltered (parse->command, '"', stb);
2109 fputs_unfiltered (" (missing implementation)", stb);
2110
2111 make_cleanup_ui_file_delete (stb);
2112 error_stream (stb);
2113 }
2114 do_cleanups (cleanup);
2115 }
2116
2117 /* FIXME: This is just a hack so we can get some extra commands going.
2118 We don't want to channel things through the CLI, but call libgdb directly.
2119 Use only for synchronous commands. */
2120
2121 void
mi_execute_cli_command(const char * cmd,int args_p,const char * args)2122 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2123 {
2124 if (cmd != 0)
2125 {
2126 struct cleanup *old_cleanups;
2127 char *run;
2128
2129 if (args_p)
2130 run = xstrprintf ("%s %s", cmd, args);
2131 else
2132 run = xstrdup (cmd);
2133 if (mi_debug_p)
2134 /* FIXME: gdb_???? */
2135 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2136 cmd, run);
2137 old_cleanups = make_cleanup (xfree, run);
2138 execute_command ( /*ui */ run, 0 /*from_tty */ );
2139 do_cleanups (old_cleanups);
2140 return;
2141 }
2142 }
2143
2144 void
mi_execute_async_cli_command(char * cli_command,char ** argv,int argc)2145 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2146 {
2147 struct cleanup *old_cleanups;
2148 char *run;
2149
2150 if (target_can_async_p ())
2151 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2152 else
2153 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2154 old_cleanups = make_cleanup (xfree, run);
2155
2156 execute_command ( /*ui */ run, 0 /*from_tty */ );
2157
2158 if (target_can_async_p ())
2159 {
2160 /* If we're not executing, an exception should have been throw. */
2161 gdb_assert (is_running (inferior_ptid));
2162 do_cleanups (old_cleanups);
2163 }
2164 else
2165 {
2166 /* Do this before doing any printing. It would appear that some
2167 print code leaves garbage around in the buffer. */
2168 do_cleanups (old_cleanups);
2169 }
2170 }
2171
2172 void
mi_load_progress(const char * section_name,unsigned long sent_so_far,unsigned long total_section,unsigned long total_sent,unsigned long grand_total)2173 mi_load_progress (const char *section_name,
2174 unsigned long sent_so_far,
2175 unsigned long total_section,
2176 unsigned long total_sent,
2177 unsigned long grand_total)
2178 {
2179 struct timeval time_now, delta, update_threshold;
2180 static struct timeval last_update;
2181 static char *previous_sect_name = NULL;
2182 int new_section;
2183 struct ui_out *saved_uiout;
2184
2185 /* This function is called through deprecated_show_load_progress
2186 which means uiout may not be correct. Fix it for the duration
2187 of this function. */
2188 saved_uiout = uiout;
2189
2190 if (current_interp_named_p (INTERP_MI)
2191 || current_interp_named_p (INTERP_MI2))
2192 uiout = mi_out_new (2);
2193 else if (current_interp_named_p (INTERP_MI1))
2194 uiout = mi_out_new (1);
2195 else if (current_interp_named_p (INTERP_MI3))
2196 uiout = mi_out_new (3);
2197 else
2198 return;
2199
2200 update_threshold.tv_sec = 0;
2201 update_threshold.tv_usec = 500000;
2202 gettimeofday (&time_now, NULL);
2203
2204 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2205 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2206
2207 if (delta.tv_usec < 0)
2208 {
2209 delta.tv_sec -= 1;
2210 delta.tv_usec += 1000000L;
2211 }
2212
2213 new_section = (previous_sect_name ?
2214 strcmp (previous_sect_name, section_name) : 1);
2215 if (new_section)
2216 {
2217 struct cleanup *cleanup_tuple;
2218
2219 xfree (previous_sect_name);
2220 previous_sect_name = xstrdup (section_name);
2221
2222 if (current_token)
2223 fputs_unfiltered (current_token, raw_stdout);
2224 fputs_unfiltered ("+download", raw_stdout);
2225 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2226 ui_out_field_string (uiout, "section", section_name);
2227 ui_out_field_int (uiout, "section-size", total_section);
2228 ui_out_field_int (uiout, "total-size", grand_total);
2229 do_cleanups (cleanup_tuple);
2230 mi_out_put (uiout, raw_stdout);
2231 fputs_unfiltered ("\n", raw_stdout);
2232 gdb_flush (raw_stdout);
2233 }
2234
2235 if (delta.tv_sec >= update_threshold.tv_sec &&
2236 delta.tv_usec >= update_threshold.tv_usec)
2237 {
2238 struct cleanup *cleanup_tuple;
2239
2240 last_update.tv_sec = time_now.tv_sec;
2241 last_update.tv_usec = time_now.tv_usec;
2242 if (current_token)
2243 fputs_unfiltered (current_token, raw_stdout);
2244 fputs_unfiltered ("+download", raw_stdout);
2245 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2246 ui_out_field_string (uiout, "section", section_name);
2247 ui_out_field_int (uiout, "section-sent", sent_so_far);
2248 ui_out_field_int (uiout, "section-size", total_section);
2249 ui_out_field_int (uiout, "total-sent", total_sent);
2250 ui_out_field_int (uiout, "total-size", grand_total);
2251 do_cleanups (cleanup_tuple);
2252 mi_out_put (uiout, raw_stdout);
2253 fputs_unfiltered ("\n", raw_stdout);
2254 gdb_flush (raw_stdout);
2255 }
2256
2257 xfree (uiout);
2258 uiout = saved_uiout;
2259 }
2260
2261 static void
timestamp(struct mi_timestamp * tv)2262 timestamp (struct mi_timestamp *tv)
2263 {
2264 gettimeofday (&tv->wallclock, NULL);
2265 #ifdef HAVE_GETRUSAGE
2266 getrusage (RUSAGE_SELF, &rusage);
2267 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2268 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2269 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2270 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2271 #else
2272 {
2273 long usec = get_run_time ();
2274
2275 tv->utime.tv_sec = usec/1000000L;
2276 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2277 tv->stime.tv_sec = 0;
2278 tv->stime.tv_usec = 0;
2279 }
2280 #endif
2281 }
2282
2283 static void
print_diff_now(struct mi_timestamp * start)2284 print_diff_now (struct mi_timestamp *start)
2285 {
2286 struct mi_timestamp now;
2287
2288 timestamp (&now);
2289 print_diff (start, &now);
2290 }
2291
2292 void
mi_print_timing_maybe(void)2293 mi_print_timing_maybe (void)
2294 {
2295 /* If the command is -enable-timing then do_timings may be
2296 true whilst current_command_ts is not initialized. */
2297 if (do_timings && current_command_ts)
2298 print_diff_now (current_command_ts);
2299 }
2300
2301 static long
timeval_diff(struct timeval start,struct timeval end)2302 timeval_diff (struct timeval start, struct timeval end)
2303 {
2304 return ((end.tv_sec - start.tv_sec) * 1000000L)
2305 + (end.tv_usec - start.tv_usec);
2306 }
2307
2308 static void
print_diff(struct mi_timestamp * start,struct mi_timestamp * end)2309 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2310 {
2311 fprintf_unfiltered
2312 (raw_stdout,
2313 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2314 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2315 timeval_diff (start->utime, end->utime) / 1000000.0,
2316 timeval_diff (start->stime, end->stime) / 1000000.0);
2317 }
2318
2319 void
mi_cmd_trace_define_variable(char * command,char ** argv,int argc)2320 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2321 {
2322 struct expression *expr;
2323 struct cleanup *back_to;
2324 LONGEST initval = 0;
2325 struct trace_state_variable *tsv;
2326 char *name = 0;
2327
2328 if (argc != 1 && argc != 2)
2329 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2330
2331 expr = parse_expression (argv[0]);
2332 back_to = make_cleanup (xfree, expr);
2333
2334 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2335 {
2336 struct internalvar *intvar = expr->elts[1].internalvar;
2337
2338 if (intvar)
2339 name = internalvar_name (intvar);
2340 }
2341
2342 if (!name || *name == '\0')
2343 error (_("Invalid name of trace variable"));
2344
2345 tsv = find_trace_state_variable (name);
2346 if (!tsv)
2347 tsv = create_trace_state_variable (name);
2348
2349 if (argc == 2)
2350 initval = value_as_long (parse_and_eval (argv[1]));
2351
2352 tsv->initial_value = initval;
2353
2354 do_cleanups (back_to);
2355 }
2356
2357 void
mi_cmd_trace_list_variables(char * command,char ** argv,int argc)2358 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2359 {
2360 if (argc != 0)
2361 error (_("-trace-list-variables: no arguments are allowed"));
2362
2363 tvariables_info_1 ();
2364 }
2365
2366 void
mi_cmd_trace_find(char * command,char ** argv,int argc)2367 mi_cmd_trace_find (char *command, char **argv, int argc)
2368 {
2369 char *mode;
2370
2371 if (argc == 0)
2372 error (_("trace selection mode is required"));
2373
2374 mode = argv[0];
2375
2376 if (strcmp (mode, "none") == 0)
2377 {
2378 tfind_1 (tfind_number, -1, 0, 0, 0);
2379 return;
2380 }
2381
2382 if (current_trace_status ()->running)
2383 error (_("May not look at trace frames while trace is running."));
2384
2385 if (strcmp (mode, "frame-number") == 0)
2386 {
2387 if (argc != 2)
2388 error (_("frame number is required"));
2389 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2390 }
2391 else if (strcmp (mode, "tracepoint-number") == 0)
2392 {
2393 if (argc != 2)
2394 error (_("tracepoint number is required"));
2395 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2396 }
2397 else if (strcmp (mode, "pc") == 0)
2398 {
2399 if (argc != 2)
2400 error (_("PC is required"));
2401 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2402 }
2403 else if (strcmp (mode, "pc-inside-range") == 0)
2404 {
2405 if (argc != 3)
2406 error (_("Start and end PC are required"));
2407 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2408 parse_and_eval_address (argv[2]), 0);
2409 }
2410 else if (strcmp (mode, "pc-outside-range") == 0)
2411 {
2412 if (argc != 3)
2413 error (_("Start and end PC are required"));
2414 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2415 parse_and_eval_address (argv[2]), 0);
2416 }
2417 else if (strcmp (mode, "line") == 0)
2418 {
2419 struct symtabs_and_lines sals;
2420 struct symtab_and_line sal;
2421 static CORE_ADDR start_pc, end_pc;
2422 struct cleanup *back_to;
2423
2424 if (argc != 2)
2425 error (_("Line is required"));
2426
2427 sals = decode_line_spec (argv[1], 1);
2428 back_to = make_cleanup (xfree, sals.sals);
2429
2430 sal = sals.sals[0];
2431
2432 if (sal.symtab == 0)
2433 error (_("Could not find the specified line"));
2434
2435 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2436 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2437 else
2438 error (_("Could not find the specified line"));
2439
2440 do_cleanups (back_to);
2441 }
2442 else
2443 error (_("Invalid mode '%s'"), mode);
2444
2445 if (has_stack_frames () || get_traceframe_number () >= 0)
2446 {
2447 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2448 }
2449 }
2450
2451 void
mi_cmd_trace_save(char * command,char ** argv,int argc)2452 mi_cmd_trace_save (char *command, char **argv, int argc)
2453 {
2454 int target_saves = 0;
2455 char *filename;
2456
2457 if (argc != 1 && argc != 2)
2458 error (_("Usage: -trace-save [-r] filename"));
2459
2460 if (argc == 2)
2461 {
2462 filename = argv[1];
2463 if (strcmp (argv[0], "-r") == 0)
2464 target_saves = 1;
2465 else
2466 error (_("Invalid option: %s"), argv[0]);
2467 }
2468 else
2469 {
2470 filename = argv[0];
2471 }
2472
2473 trace_save (filename, target_saves);
2474 }
2475
2476
2477 void
mi_cmd_trace_start(char * command,char ** argv,int argc)2478 mi_cmd_trace_start (char *command, char **argv, int argc)
2479 {
2480 start_tracing ();
2481 }
2482
2483 void
mi_cmd_trace_status(char * command,char ** argv,int argc)2484 mi_cmd_trace_status (char *command, char **argv, int argc)
2485 {
2486 trace_status_mi (0);
2487 }
2488
2489 void
mi_cmd_trace_stop(char * command,char ** argv,int argc)2490 mi_cmd_trace_stop (char *command, char **argv, int argc)
2491 {
2492 stop_tracing ();
2493 trace_status_mi (1);
2494 }
2495