GDB (xrefs)

mi-main.c
Go to the documentation of this file.
1 /* MI Command Set.
2
3 Copyright (C) 2000-2018 Free Software Foundation, Inc.
4
5 Contributed by Cygnus Solutions (a Red Hat company).
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include "target.h"
25 #include "inferior.h"
26 #include "infrun.h"
27 #include "top.h"
28 #include "gdbthread.h"
29 #include "mi-cmds.h"
30 #include "mi-parse.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
33 #include "ui-out.h"
34 #include "mi-out.h"
35 #include "interps.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
39 #include "value.h"
40 #include "regcache.h"
41 #include "frame.h"
42 #include "mi-main.h"
43 #include "mi-common.h"
44 #include "language.h"
45 #include "valprint.h"
46 #include "inferior.h"
47 #include "osdata.h"
48 #include "common/gdb_splay_tree.h"
49 #include "tracepoint.h"
50 #include "ctf.h"
51 #include "ada-lang.h"
52 #include "linespec.h"
53 #include "extension.h"
54 #include "gdbcmd.h"
55 #include "observer.h"
56 #include "common/gdb_optional.h"
57 #include "common/byte-vector.h"
58
59 #include <ctype.h>
60 #include "run-time-clock.h"
61 #include <chrono>
62 #include "progspace-and-thread.h"
63 #include "common/rsp-low.h"
64 #include <algorithm>
65 #include <set>
66 #include <map>
67
68 enum
69 {
70 FROM_TTY = 0
71 };
72
73 int mi_debug_p;
74
75 /* This is used to pass the current command timestamp down to
76 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 were
83 explicitly specified. This variable keeps the current parsed
84 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 static void mi_cmd_execute (struct mi_parse *parse);
94
95 static void mi_execute_cli_command (const char *cmd, int args_p,
96 const char *args);
97 static void mi_execute_async_cli_command (const char *cli_command,
98 char **argv, int argc);
99 static bool register_changed_p (int regnum, regcache *,
100 regcache *);
101 static void output_register (struct frame_info *, int regnum, int format,
102 int skip_unavailable);
103
104 /* Controls whether the frontend wants MI in async mode. */
105 static int mi_async = 0;
106
107 /* The set command writes to this variable. If the inferior is
108 executing, mi_async is *not* updated. */
109 static int mi_async_1 = 0;
110
111 static void
112 set_mi_async_command (const char *args, int from_tty,
113 struct cmd_list_element *c)
114 {
115 if (have_live_inferiors ())
116 {
117 mi_async_1 = mi_async;
118 error (_("Cannot change this setting while the inferior is running."));
119 }
120
121 mi_async = mi_async_1;
122 }
123
124 static void
125 show_mi_async_command (struct ui_file *file, int from_tty,
126 struct cmd_list_element *c,
127 const char *value)
128 {
129 fprintf_filtered (file,
130 _("Whether MI is in asynchronous mode is %s.\n"),
131 value);
132 }
133
134 /* A wrapper for target_can_async_p that takes the MI setting into
135 account. */
136
137 int
138 mi_async_p (void)
139 {
140 return mi_async && target_can_async_p ();
141 }
142
143 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
144 layer that calls libgdb. Any operation used in the below should be
145 formalized. */
146
147 static void timestamp (struct mi_timestamp *tv);
148
149 static void print_diff (struct ui_file *file, struct mi_timestamp *start,
150 struct mi_timestamp *end);
151
152 void
153 mi_cmd_gdb_exit (const char *command, char **argv, int argc)
154 {
155 struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
156
157 /* We have to print everything right here because we never return. */
158 if (current_token)
159 fputs_unfiltered (current_token, mi->raw_stdout);
160 fputs_unfiltered ("^exit\n", mi->raw_stdout);
161 mi_out_put (current_uiout, mi->raw_stdout);
162 gdb_flush (mi->raw_stdout);
163 /* FIXME: The function called is not yet a formal libgdb function. */
164 quit_force (NULL, FROM_TTY);
165 }
166
167 void
168 mi_cmd_exec_next (const char *command, char **argv, int argc)
169 {
170 /* FIXME: Should call a libgdb function, not a cli wrapper. */
171 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
172 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
173 else
174 mi_execute_async_cli_command ("next", argv, argc);
175 }
176
177 void
178 mi_cmd_exec_next_instruction (const char *command, char **argv, int argc)
179 {
180 /* FIXME: Should call a libgdb function, not a cli wrapper. */
181 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
182 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
183 else
184 mi_execute_async_cli_command ("nexti", argv, argc);
185 }
186
187 void
188 mi_cmd_exec_step (const char *command, char **argv, int argc)
189 {
190 /* FIXME: Should call a libgdb function, not a cli wrapper. */
191 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
192 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
193 else
194 mi_execute_async_cli_command ("step", argv, argc);
195 }
196
197 void
198 mi_cmd_exec_step_instruction (const char *command, char **argv, int argc)
199 {
200 /* FIXME: Should call a libgdb function, not a cli wrapper. */
201 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
202 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
203 else
204 mi_execute_async_cli_command ("stepi", argv, argc);
205 }
206
207 void
208 mi_cmd_exec_finish (const char *command, char **argv, int argc)
209 {
210 /* FIXME: Should call a libgdb function, not a cli wrapper. */
211 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
212 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
213 else
214 mi_execute_async_cli_command ("finish", argv, argc);
215 }
216
217 void
218 mi_cmd_exec_return (const char *command, char **argv, int argc)
219 {
220 /* This command doesn't really execute the target, it just pops the
221 specified number of frames. */
222 if (argc)
223 /* Call return_command with from_tty argument equal to 0 so as to
224 avoid being queried. */
225 return_command (*argv, 0);
226 else
227 /* Call return_command with from_tty argument equal to 0 so as to
228 avoid being queried. */
229 return_command (NULL, 0);
230
231 /* Because we have called return_command with from_tty = 0, we need
232 to print the frame here. */
233 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
234 }
235
236 void
237 mi_cmd_exec_jump (const char *args, char **argv, int argc)
238 {
239 /* FIXME: Should call a libgdb function, not a cli wrapper. */
240 mi_execute_async_cli_command ("jump", argv, argc);
241 }
242
243 static void
244 proceed_thread (struct thread_info *thread, int pid)
245 {
246 if (!is_stopped (thread->ptid))
247 return;
248
249 if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
250 return;
251
252 switch_to_thread (thread->ptid);
253 clear_proceed_status (0);
254 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
255 }
256
257 static int
258 proceed_thread_callback (struct thread_info *thread, void *arg)
259 {
260 int pid = *(int *)arg;
261
262 proceed_thread (thread, pid);
263 return 0;
264 }
265
266 static void
267 exec_continue (char **argv, int argc)
268 {
269 prepare_execution_command (&current_target, mi_async_p ());
270
271 if (non_stop)
272 {
273 /* In non-stop mode, 'resume' always resumes a single thread.
274 Therefore, to resume all threads of the current inferior, or
275 all threads in all inferiors, we need to iterate over
276 threads.
277
278 See comment on infcmd.c:proceed_thread_callback for rationale. */
279 if (current_context->all || current_context->thread_group != -1)
280 {
281 scoped_restore_current_thread restore_thread;
282 int pid = 0;
283
284 if (!current_context->all)
285 {
286 struct inferior *inf
287 = find_inferior_id (current_context->thread_group);
288
289 pid = inf->pid;
290 }
291 iterate_over_threads (proceed_thread_callback, &pid);
292 }
293 else
294 {
295 continue_1 (0);
296 }
297 }
298 else
299 {
300 scoped_restore save_multi = make_scoped_restore (&sched_multi);
301
302 if (current_context->all)
303 {
304 sched_multi = 1;
305 continue_1 (0);
306 }
307 else
308 {
309 /* In all-stop mode, -exec-continue traditionally resumed
310 either all threads, or one thread, depending on the
311 'scheduler-locking' variable. Let's continue to do the
312 same. */
313 continue_1 (1);
314 }
315 }
316 }
317
318 static void
319 exec_reverse_continue (char **argv, int argc)
320 {
321 enum exec_direction_kind dir = execution_direction;
322
323 if (dir == EXEC_REVERSE)
324 error (_("Already in reverse mode."));
325
326 if (!target_can_execute_reverse)
327 error (_("Target %s does not support this command."), target_shortname);
328
329 scoped_restore save_exec_dir = make_scoped_restore (&execution_direction,
330 EXEC_REVERSE);
331 exec_continue (argv, argc);
332 }
333
334 void
335 mi_cmd_exec_continue (const char *command, char **argv, int argc)
336 {
337 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
338 exec_reverse_continue (argv + 1, argc - 1);
339 else
340 exec_continue (argv, argc);
341 }
342
343 static int
344 interrupt_thread_callback (struct thread_info *thread, void *arg)
345 {
346 int pid = *(int *)arg;
347
348 if (!is_running (thread->ptid))
349 return 0;
350
351 if (ptid_get_pid (thread->ptid) != pid)
352 return 0;
353
354 target_stop (thread->ptid);
355 return 0;
356 }
357
358 /* Interrupt the execution of the target. Note how we must play
359 around with the token variables, in order to display the current
360 token in the result of the interrupt command, and the previous
361 execution token when the target finally stops. See comments in
362 mi_cmd_execute. */
363
364 void
365 mi_cmd_exec_interrupt (const char *command, char **argv, int argc)
366 {
367 /* In all-stop mode, everything stops, so we don't need to try
368 anything specific. */
369 if (!non_stop)
370 {
371 interrupt_target_1 (0);
372 return;
373 }
374
375 if (current_context->all)
376 {
377 /* This will interrupt all threads in all inferiors. */
378 interrupt_target_1 (1);
379 }
380 else if (current_context->thread_group != -1)
381 {
382 struct inferior *inf = find_inferior_id (current_context->thread_group);
383
384 iterate_over_threads (interrupt_thread_callback, &inf->pid);
385 }
386 else
387 {
388 /* Interrupt just the current thread -- either explicitly
389 specified via --thread or whatever was current before
390 MI command was sent. */
391 interrupt_target_1 (0);
392 }
393 }
394
395 /* Callback for iterate_over_inferiors which starts the execution
396 of the given inferior.
397
398 ARG is a pointer to an integer whose value, if non-zero, indicates
399 that the program should be stopped when reaching the main subprogram
400 (similar to what the CLI "start" command does). */
401
402 static int
403 run_one_inferior (struct inferior *inf, void *arg)
404 {
405 int start_p = *(int *) arg;
406 const char *run_cmd = start_p ? "start" : "run";
407 struct target_ops *run_target = find_run_target ();
408 int async_p = mi_async && run_target->to_can_async_p (run_target);
409
410 if (inf->pid != 0)
411 {
412 if (inf->pid != ptid_get_pid (inferior_ptid))
413 {
414 struct thread_info *tp;
415
416 tp = any_thread_of_process (inf->pid);
417 if (!tp)
418 error (_("Inferior has no threads."));
419
420 switch_to_thread (tp->ptid);
421 }
422 }
423 else
424 {
425 set_current_inferior (inf);
426 switch_to_thread (null_ptid);
427 set_current_program_space (inf->pspace);
428 }
429 mi_execute_cli_command (run_cmd, async_p,
430 async_p ? "&" : NULL);
431 return 0;
432 }
433
434 void
435 mi_cmd_exec_run (const char *command, char **argv, int argc)
436 {
437 int start_p = 0;
438
439 /* Parse the command options. */
440 enum opt
441 {
442 START_OPT,
443 };
444 static const struct mi_opt opts[] =
445 {
446 {"-start", START_OPT, 0},
447 {NULL, 0, 0},
448 };
449
450 int oind = 0;
451 char *oarg;
452
453 while (1)
454 {
455 int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg);
456
457 if (opt < 0)
458 break;
459 switch ((enum opt) opt)
460 {
461 case START_OPT:
462 start_p = 1;
463 break;
464 }
465 }
466
467 /* This command does not accept any argument. Make sure the user
468 did not provide any. */
469 if (oind != argc)
470 error (_("Invalid argument: %s"), argv[oind]);
471
472 if (current_context->all)
473 {
474 scoped_restore_current_pspace_and_thread restore_pspace_thread;
475
476 iterate_over_inferiors (run_one_inferior, &start_p);
477 }
478 else
479 {
480 const char *run_cmd = start_p ? "start" : "run";
481 struct target_ops *run_target = find_run_target ();
482 int async_p = mi_async && run_target->to_can_async_p (run_target);
483
484 mi_execute_cli_command (run_cmd, async_p,
485 async_p ? "&" : NULL);
486 }
487 }
488
489
490 static int
491 find_thread_of_process (struct thread_info *ti, void *p)
492 {
493 int pid = *(int *)p;
494
495 if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
496 return 1;
497
498 return 0;
499 }
500
501 void
502 mi_cmd_target_detach (const char *command, char **argv, int argc)
503 {
504 if (argc != 0 && argc != 1)
505 error (_("Usage: -target-detach [pid | thread-group]"));
506
507 if (argc == 1)
508 {
509 struct thread_info *tp;
510 char *end = argv[0];
511 int pid;
512
513 /* First see if we are dealing with a thread-group id. */
514 if (*argv[0] == 'i')
515 {
516 struct inferior *inf;
517 int id = strtoul (argv[0] + 1, &end, 0);
518
519 if (*end != '\0')
520 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
521
522 inf = find_inferior_id (id);
523 if (!inf)
524 error (_("Non-existent thread-group id '%d'"), id);
525
526 pid = inf->pid;
527 }
528 else
529 {
530 /* We must be dealing with a pid. */
531 pid = strtol (argv[0], &end, 10);
532
533 if (*end != '\0')
534 error (_("Invalid identifier '%s'"), argv[0]);
535 }
536
537 /* Pick any thread in the desired process. Current
538 target_detach detaches from the parent of inferior_ptid. */
539 tp = iterate_over_threads (find_thread_of_process, &pid);
540 if (!tp)
541 error (_("Thread group is empty"));
542
543 switch_to_thread (tp->ptid);
544 }
545
546 detach_command (NULL, 0);
547 }
548
549 void
550 mi_cmd_target_flash_erase (const char *command, char **argv, int argc)
551 {
552 flash_erase_command (NULL, 0);
553 }
554
555 void
556 mi_cmd_thread_select (const char *command, char **argv, int argc)
557 {
558 if (argc != 1)
559 error (_("-thread-select: USAGE: threadnum."));
560
561 int num = value_as_long (parse_and_eval (argv[0]));
562 thread_info *thr = find_thread_global_id (num);
563 if (thr == NULL)
564 error (_("Thread ID %d not known."), num);
565
566 ptid_t previous_ptid = inferior_ptid;
567
568 thread_select (argv[0], thr);
569
570 print_selected_thread_frame (current_uiout,
571 USER_SELECTED_THREAD | USER_SELECTED_FRAME);
572
573 /* Notify if the thread has effectively changed. */
574 if (!ptid_equal (inferior_ptid, previous_ptid))
575 {
576 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
577 | USER_SELECTED_FRAME);
578 }
579 }
580
581 void
582 mi_cmd_thread_list_ids (const char *command, char **argv, int argc)
583 {
584 if (argc != 0)
585 error (_("-thread-list-ids: No arguments required."));
586
587 int num = 0;
588 int current_thread = -1;
589
590 update_thread_list ();
591
592 {
593 ui_out_emit_tuple tuple_emitter (current_uiout, "thread-ids");
594
595 struct thread_info *tp;
596 ALL_NON_EXITED_THREADS (tp)
597 {
598 if (tp->ptid == inferior_ptid)
599 current_thread = tp->global_num;
600
601 num++;
602 current_uiout->field_int ("thread-id", tp->global_num);
603 }
604 }
605
606 if (current_thread != -1)
607 current_uiout->field_int ("current-thread-id", current_thread);
608 current_uiout->field_int ("number-of-threads", num);
609 }
610
611 void
612 mi_cmd_thread_info (const char *command, char **argv, int argc)
613 {
614 if (argc != 0 && argc != 1)
615 error (_("Invalid MI command"));
616
617 print_thread_info (current_uiout, argv[0], -1);
618 }
619
620 struct collect_cores_data
621 {
622 int pid;
623 std::set<int> cores;
624 };
625
626 static int
627 collect_cores (struct thread_info *ti, void *xdata)
628 {
629 struct collect_cores_data *data = (struct collect_cores_data *) xdata;
630
631 if (ptid_get_pid (ti->ptid) == data->pid)
632 {
633 int core = target_core_of_thread (ti->ptid);
634
635 if (core != -1)
636 data->cores.insert (core);
637 }
638
639 return 0;
640 }
641
642 struct print_one_inferior_data
643 {
644 int recurse;
645 const std::set<int> *inferiors;
646 };
647
648 static int
649 print_one_inferior (struct inferior *inferior, void *xdata)
650 {
651 struct print_one_inferior_data *top_data
652 = (struct print_one_inferior_data *) xdata;
653 struct ui_out *uiout = current_uiout;
654
655 if (top_data->inferiors->empty ()
656 || (top_data->inferiors->find (inferior->pid)
657 != top_data->inferiors->end ()))
658 {
659 struct collect_cores_data data;
660 ui_out_emit_tuple tuple_emitter (uiout, NULL);
661
662 uiout->field_fmt ("id", "i%d", inferior->num);
663 uiout->field_string ("type", "process");
664 if (inferior->has_exit_code)
665 uiout->field_string ("exit-code",
666 int_string (inferior->exit_code, 8, 0, 0, 1));
667 if (inferior->pid != 0)
668 uiout->field_int ("pid", inferior->pid);
669
670 if (inferior->pspace->pspace_exec_filename != NULL)
671 {
672 uiout->field_string ("executable",
673 inferior->pspace->pspace_exec_filename);
674 }
675
676 if (inferior->pid != 0)
677 {
678 data.pid = inferior->pid;
679 iterate_over_threads (collect_cores, &data);
680 }
681
682 if (!data.cores.empty ())
683 {
684 ui_out_emit_list list_emitter (uiout, "cores");
685
686 for (int b : data.cores)
687 uiout->field_int (NULL, b);
688 }
689
690 if (top_data->recurse)
691 print_thread_info (uiout, NULL, inferior->pid);
692 }
693
694 return 0;
695 }
696
697 /* Output a field named 'cores' with a list as the value. The
698 elements of the list are obtained by splitting 'cores' on
699 comma. */
700
701 static void
702 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
703 {
704 ui_out_emit_list list_emitter (uiout, field_name);
705 gdb::unique_xmalloc_ptr<char> cores (xstrdup (xcores));
706 char *p = cores.get ();
707
708 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
709 uiout->field_string (NULL, p);
710 }
711
712 static void
713 list_available_thread_groups (const std::set<int> &ids, int recurse)
714 {
715 struct ui_out *uiout = current_uiout;
716
717 /* This keeps a map from integer (pid) to vector of struct osdata_item.
718 The vector contains information about all threads for the given pid. */
719 std::map<int, std::vector<osdata_item>> tree;
720
721 /* get_osdata will throw if it cannot return data. */
722 std::unique_ptr<osdata> data = get_osdata ("processes");
723
724 if (recurse)
725 {
726 std::unique_ptr<osdata> threads = get_osdata ("threads");
727
728 for (const osdata_item &item : threads->items)
729 {
730 const std::string *pid = get_osdata_column (item, "pid");
731 int pid_i = strtoul (pid->c_str (), NULL, 0);
732
733 tree[pid_i].push_back (item);
734 }
735 }
736
737 ui_out_emit_list list_emitter (uiout, "groups");
738
739 for (const osdata_item &item : data->items)
740 {
741 const std::string *pid = get_osdata_column (item, "pid");
742 const std::string *cmd = get_osdata_column (item, "command");
743 const std::string *user = get_osdata_column (item, "user");
744 const std::string *cores = get_osdata_column (item, "cores");
745
746 int pid_i = strtoul (pid->c_str (), NULL, 0);
747
748 /* At present, the target will return all available processes
749 and if information about specific ones was required, we filter
750 undesired processes here. */
751 if (!ids.empty () && ids.find (pid_i) == ids.end ())
752 continue;
753
754 ui_out_emit_tuple tuple_emitter (uiout, NULL);
755
756 uiout->field_fmt ("id", "%s", pid->c_str ());
757 uiout->field_string ("type", "process");
758 if (cmd)
759 uiout->field_string ("description", cmd->c_str ());
760 if (user)
761 uiout->field_string ("user", user->c_str ());
762 if (cores)
763 output_cores (uiout, "cores", cores->c_str ());
764
765 if (recurse)
766 {
767 auto n = tree.find (pid_i);
768 if (n != tree.end ())
769 {
770 std::vector<osdata_item> &children = n->second;
771
772 ui_out_emit_list thread_list_emitter (uiout, "threads");
773
774 for (const osdata_item &child : children)
775 {
776 ui_out_emit_tuple tuple_emitter (uiout, NULL);
777 const std::string *tid = get_osdata_column (child, "tid");
778 const std::string *tcore = get_osdata_column (child, "core");
779
780 uiout->field_string ("id", tid->c_str ());
781 if (tcore)
782 uiout->field_string ("core", tcore->c_str ());
783 }
784 }
785 }
786 }
787 }
788
789 void
790 mi_cmd_list_thread_groups (const char *command, char **argv, int argc)
791 {
792 struct ui_out *uiout = current_uiout;
793 int available = 0;
794 int recurse = 0;
795 std::set<int> ids;
796
797 enum opt
798 {
799 AVAILABLE_OPT, RECURSE_OPT
800 };
801 static const struct mi_opt opts[] =
802 {
803 {"-available", AVAILABLE_OPT, 0},
804 {"-recurse", RECURSE_OPT, 1},
805 { 0, 0, 0 }
806 };
807
808 int oind = 0;
809 char *oarg;
810
811 while (1)
812 {
813 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
814 &oind, &oarg);
815
816 if (opt < 0)
817 break;
818 switch ((enum opt) opt)
819 {
820 case AVAILABLE_OPT:
821 available = 1;
822 break;
823 case RECURSE_OPT:
824 if (strcmp (oarg, "0") == 0)
825 ;
826 else if (strcmp (oarg, "1") == 0)
827 recurse = 1;
828 else
829 error (_("only '0' and '1' are valid values "
830 "for the '--recurse' option"));
831 break;
832 }
833 }
834
835 for (; oind < argc; ++oind)
836 {
837 char *end;
838 int inf;
839
840 if (*(argv[oind]) != 'i')
841 error (_("invalid syntax of group id '%s'"), argv[oind]);
842
843 inf = strtoul (argv[oind] + 1, &end, 0);
844
845 if (*end != '\0')
846 error (_("invalid syntax of group id '%s'"), argv[oind]);
847 ids.insert (inf);
848 }
849
850 if (available)
851 {
852 list_available_thread_groups (ids, recurse);
853 }
854 else if (ids.size () == 1)
855 {
856 /* Local thread groups, single id. */
857 int id = *(ids.begin ());
858 struct inferior *inf = find_inferior_id (id);
859
860 if (!inf)
861 error (_("Non-existent thread group id '%d'"), id);
862
863 print_thread_info (uiout, NULL, inf->pid);
864 }
865 else
866 {
867 struct print_one_inferior_data data;
868
869 data.recurse = recurse;
870 data.inferiors = &ids;
871
872 /* Local thread groups. Either no explicit ids -- and we
873 print everything, or several explicit ids. In both cases,
874 we print more than one group, and have to use 'groups'
875 as the top-level element. */
876 ui_out_emit_list list_emitter (uiout, "groups");
877 update_thread_list ();
878 iterate_over_inferiors (print_one_inferior, &data);
879 }
880 }
881
882 void
883 mi_cmd_data_list_register_names (const char *command, char **argv, int argc)
884 {
885 struct gdbarch *gdbarch;
886 struct ui_out *uiout = current_uiout;
887 int regnum, numregs;
888 int i;
889
890 /* Note that the test for a valid register must include checking the
891 gdbarch_register_name because gdbarch_num_regs may be allocated
892 for the union of the register sets within a family of related
893 processors. In this case, some entries of gdbarch_register_name
894 will change depending upon the particular processor being
895 debugged. */
896
897 gdbarch = get_current_arch ();
898 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
899
900 ui_out_emit_list list_emitter (uiout, "register-names");
901
902 if (argc == 0) /* No args, just do all the regs. */
903 {
904 for (regnum = 0;
905 regnum < numregs;
906 regnum++)
907 {
908 if (gdbarch_register_name (gdbarch, regnum) == NULL
909 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
910 uiout->field_string (NULL, "");
911 else
912 uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum));
913 }
914 }
915
916 /* Else, list of register #s, just do listed regs. */
917 for (i = 0; i < argc; i++)
918 {
919 regnum = atoi (argv[i]);
920 if (regnum < 0 || regnum >= numregs)
921 error (_("bad register number"));
922
923 if (gdbarch_register_name (gdbarch, regnum) == NULL
924 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
925 uiout->field_string (NULL, "");
926 else
927 uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum));
928 }
929 }
930
931 void
932 mi_cmd_data_list_changed_registers (const char *command, char **argv, int argc)
933 {
934 static std::unique_ptr<struct regcache> this_regs;
935 struct ui_out *uiout = current_uiout;
936 std::unique_ptr<struct regcache> prev_regs;
937 struct gdbarch *gdbarch;
938 int regnum, numregs;
939 int i;
940
941 /* The last time we visited this function, the current frame's
942 register contents were saved in THIS_REGS. Move THIS_REGS over
943 to PREV_REGS, and refresh THIS_REGS with the now-current register
944 contents. */
945
946 prev_regs = std::move (this_regs);
947 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
948
949 /* Note that the test for a valid register must include checking the
950 gdbarch_register_name because gdbarch_num_regs may be allocated
951 for the union of the register sets within a family of related
952 processors. In this case, some entries of gdbarch_register_name
953 will change depending upon the particular processor being
954 debugged. */
955
956 gdbarch = this_regs->arch ();
957 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
958
959 ui_out_emit_list list_emitter (uiout, "changed-registers");
960
961 if (argc == 0)
962 {
963 /* No args, just do all the regs. */
964 for (regnum = 0;
965 regnum < numregs;
966 regnum++)
967 {
968 if (gdbarch_register_name (gdbarch, regnum) == NULL
969 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
970 continue;
971
972 if (register_changed_p (regnum, prev_regs.get (),
973 this_regs.get ()))
974 uiout->field_int (NULL, regnum);
975 }
976 }
977
978 /* Else, list of register #s, just do listed regs. */
979 for (i = 0; i < argc; i++)
980 {
981 regnum = atoi (argv[i]);
982
983 if (regnum >= 0
984 && regnum < numregs
985 && gdbarch_register_name (gdbarch, regnum) != NULL
986 && *gdbarch_register_name (gdbarch, regnum) != '\000')
987 {
988 if (register_changed_p (regnum, prev_regs.get (),
989 this_regs.get ()))
990 uiout->field_int (NULL, regnum);
991 }
992 else
993 error (_("bad register number"));
994 }
995 }
996
997 static bool
998 register_changed_p (int regnum, struct regcache *prev_regs,
999 struct regcache *this_regs)
1000 {
1001 struct gdbarch *gdbarch = this_regs->arch ();
1002 struct value *prev_value, *this_value;
1003
1004 /* First time through or after gdbarch change consider all registers
1005 as changed. */
1006 if (!prev_regs || prev_regs->arch () != gdbarch)
1007 return true;
1008
1009 /* Get register contents and compare. */
1010 prev_value = prev_regs->cooked_read_value (regnum);
1011 this_value = this_regs->cooked_read_value (regnum);
1012 gdb_assert (prev_value != NULL);
1013 gdb_assert (this_value != NULL);
1014
1015 auto ret = !value_contents_eq (prev_value, 0, this_value, 0,
1016 register_size (gdbarch, regnum));
1017
1018 release_value (prev_value);
1019 release_value (this_value);
1020 value_free (prev_value);
1021 value_free (this_value);
1022 return ret;
1023 }
1024
1025 /* Return a list of register number and value pairs. The valid
1026 arguments expected are: a letter indicating the format in which to
1027 display the registers contents. This can be one of: x
1028 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1029 (raw). After the format argument there can be a sequence of
1030 numbers, indicating which registers to fetch the content of. If
1031 the format is the only argument, a list of all the registers with
1032 their values is returned. */
1033
1034 void
1035 mi_cmd_data_list_register_values (const char *command, char **argv, int argc)
1036 {
1037 struct ui_out *uiout = current_uiout;
1038 struct frame_info *frame;
1039 struct gdbarch *gdbarch;
1040 int regnum, numregs, format;
1041 int i;
1042 int skip_unavailable = 0;
1043 int oind = 0;
1044 enum opt
1045 {
1046 SKIP_UNAVAILABLE,
1047 };
1048 static const struct mi_opt opts[] =
1049 {
1050 {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
1051 { 0, 0, 0 }
1052 };
1053
1054 /* Note that the test for a valid register must include checking the
1055 gdbarch_register_name because gdbarch_num_regs may be allocated
1056 for the union of the register sets within a family of related
1057 processors. In this case, some entries of gdbarch_register_name
1058 will change depending upon the particular processor being
1059 debugged. */
1060
1061 while (1)
1062 {
1063 char *oarg;
1064 int opt = mi_getopt ("-data-list-register-values", argc, argv,
1065 opts, &oind, &oarg);
1066
1067 if (opt < 0)
1068 break;
1069 switch ((enum opt) opt)
1070 {
1071 case SKIP_UNAVAILABLE:
1072 skip_unavailable = 1;
1073 break;
1074 }
1075 }
1076
1077 if (argc - oind < 1)
1078 error (_("-data-list-register-values: Usage: "
1079 "-data-list-register-values [--skip-unavailable] <format>"
1080 " [<regnum1>...<regnumN>]"));
1081
1082 format = (int) argv[oind][0];
1083
1084 frame = get_selected_frame (NULL);
1085 gdbarch = get_frame_arch (frame);
1086 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1087
1088 ui_out_emit_list list_emitter (uiout, "register-values");
1089
1090 if (argc - oind == 1)
1091 {
1092 /* No args, beside the format: do all the regs. */
1093 for (regnum = 0;
1094 regnum < numregs;
1095 regnum++)
1096 {
1097 if (gdbarch_register_name (gdbarch, regnum) == NULL
1098 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1099 continue;
1100
1101 output_register (frame, regnum, format, skip_unavailable);
1102 }
1103 }
1104
1105 /* Else, list of register #s, just do listed regs. */
1106 for (i = 1 + oind; i < argc; i++)
1107 {
1108 regnum = atoi (argv[i]);
1109
1110 if (regnum >= 0
1111 && regnum < numregs
1112 && gdbarch_register_name (gdbarch, regnum) != NULL
1113 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1114 output_register (frame, regnum, format, skip_unavailable);
1115 else
1116 error (_("bad register number"));
1117 }
1118 }
1119
1120 /* Output one register REGNUM's contents in the desired FORMAT. If
1121 SKIP_UNAVAILABLE is true, skip the register if it is
1122 unavailable. */
1123
1124 static void
1125 output_register (struct frame_info *frame, int regnum, int format,
1126 int skip_unavailable)
1127 {
1128 struct ui_out *uiout = current_uiout;
1129 struct value *val = value_of_register (regnum, frame);
1130 struct value_print_options opts;
1131
1132 if (skip_unavailable && !value_entirely_available (val))
1133 return;
1134
1135 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1136 uiout->field_int ("number", regnum);
1137
1138 if (format == 'N')
1139 format = 0;
1140
1141 if (format == 'r')
1142 format = 'z';
1143
1144 string_file stb;
1145
1146 get_formatted_print_options (&opts, format);
1147 opts.deref_ref = 1;
1148 val_print (value_type (val),
1149 value_embedded_offset (val), 0,
1150 &stb, 0, val, &opts, current_language);
1151 uiout->field_stream ("value", stb);
1152 }
1153
1154 /* Write given values into registers. The registers and values are
1155 given as pairs. The corresponding MI command is
1156 -data-write-register-values <format>
1157 [<regnum1> <value1>...<regnumN> <valueN>] */
1158 void
1159 mi_cmd_data_write_register_values (const char *command, char **argv, int argc)
1160 {
1161 struct regcache *regcache;
1162 struct gdbarch *gdbarch;
1163 int numregs, i;
1164
1165 /* Note that the test for a valid register must include checking the
1166 gdbarch_register_name because gdbarch_num_regs may be allocated
1167 for the union of the register sets within a family of related
1168 processors. In this case, some entries of gdbarch_register_name
1169 will change depending upon the particular processor being
1170 debugged. */
1171
1172 regcache = get_current_regcache ();
1173 gdbarch = regcache->arch ();
1174 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1175
1176 if (argc == 0)
1177 error (_("-data-write-register-values: Usage: -data-write-register-"
1178 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1179
1180 if (!target_has_registers)
1181 error (_("-data-write-register-values: No registers."));
1182
1183 if (!(argc - 1))
1184 error (_("-data-write-register-values: No regs and values specified."));
1185
1186 if ((argc - 1) % 2)
1187 error (_("-data-write-register-values: "
1188 "Regs and vals are not in pairs."));
1189
1190 for (i = 1; i < argc; i = i + 2)
1191 {
1192 int regnum = atoi (argv[i]);
1193
1194 if (regnum >= 0 && regnum < numregs
1195 && gdbarch_register_name (gdbarch, regnum)
1196 && *gdbarch_register_name (gdbarch, regnum))
1197 {
1198 LONGEST value;
1199
1200 /* Get the value as a number. */
1201 value = parse_and_eval_address (argv[i + 1]);
1202
1203 /* Write it down. */
1204 regcache_cooked_write_signed (regcache, regnum, value);
1205 }
1206 else
1207 error (_("bad register number"));
1208 }
1209 }
1210
1211 /* Evaluate the value of the argument. The argument is an
1212 expression. If the expression contains spaces it needs to be
1213 included in double quotes. */
1214
1215 void
1216 mi_cmd_data_evaluate_expression (const char *command, char **argv, int argc)
1217 {
1218 struct value *val;
1219 struct value_print_options opts;
1220 struct ui_out *uiout = current_uiout;
1221
1222 if (argc != 1)
1223 error (_("-data-evaluate-expression: "
1224 "Usage: -data-evaluate-expression expression"));
1225
1226 expression_up expr = parse_expression (argv[0]);
1227
1228 val = evaluate_expression (expr.get ());
1229
1230 string_file stb;
1231
1232 /* Print the result of the expression evaluation. */
1233 get_user_print_options (&opts);
1234 opts.deref_ref = 0;
1235 common_val_print (val, &stb, 0, &opts, current_language);
1236
1237 uiout->field_stream ("value", stb);
1238 }
1239
1240 /* This is the -data-read-memory command.
1241
1242 ADDR: start address of data to be dumped.
1243 WORD-FORMAT: a char indicating format for the ``word''. See
1244 the ``x'' command.
1245 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1246 NR_ROW: Number of rows.
1247 NR_COL: The number of colums (words per row).
1248 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1249 ASCHAR for unprintable characters.
1250
1251 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1252 displayes them. Returns:
1253
1254 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1255
1256 Returns:
1257 The number of bytes read is SIZE*ROW*COL. */
1258
1259 void
1260 mi_cmd_data_read_memory (const char *command, char **argv, int argc)
1261 {
1262 struct gdbarch *gdbarch = get_current_arch ();
1263 struct ui_out *uiout = current_uiout;
1264 CORE_ADDR addr;
1265 long total_bytes, nr_cols, nr_rows;
1266 char word_format;
1267 struct type *word_type;
1268 long word_size;
1269 char word_asize;
1270 char aschar;
1271 int nr_bytes;
1272 long offset = 0;
1273 int oind = 0;
1274 char *oarg;
1275 enum opt
1276 {
1277 OFFSET_OPT
1278 };
1279 static const struct mi_opt opts[] =
1280 {
1281 {"o", OFFSET_OPT, 1},
1282 { 0, 0, 0 }
1283 };
1284
1285 while (1)
1286 {
1287 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1288 &oind, &oarg);
1289
1290 if (opt < 0)
1291 break;
1292 switch ((enum opt) opt)
1293 {
1294 case OFFSET_OPT:
1295 offset = atol (oarg);
1296 break;
1297 }
1298 }
1299 argv += oind;
1300 argc -= oind;
1301
1302 if (argc < 5 || argc > 6)
1303 error (_("-data-read-memory: Usage: "
1304 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1305
1306 /* Extract all the arguments. */
1307
1308 /* Start address of the memory dump. */
1309 addr = parse_and_eval_address (argv[0]) + offset;
1310 /* The format character to use when displaying a memory word. See
1311 the ``x'' command. */
1312 word_format = argv[1][0];
1313 /* The size of the memory word. */
1314 word_size = atol (argv[2]);
1315 switch (word_size)
1316 {
1317 case 1:
1318 word_type = builtin_type (gdbarch)->builtin_int8;
1319 word_asize = 'b';
1320 break;
1321 case 2:
1322 word_type = builtin_type (gdbarch)->builtin_int16;
1323 word_asize = 'h';
1324 break;
1325 case 4:
1326 word_type = builtin_type (gdbarch)->builtin_int32;
1327 word_asize = 'w';
1328 break;
1329 case 8:
1330 word_type = builtin_type (gdbarch)->builtin_int64;
1331 word_asize = 'g';
1332 break;
1333 default:
1334 word_type = builtin_type (gdbarch)->builtin_int8;
1335 word_asize = 'b';
1336 }
1337 /* The number of rows. */
1338 nr_rows = atol (argv[3]);
1339 if (nr_rows <= 0)
1340 error (_("-data-read-memory: invalid number of rows."));
1341
1342 /* Number of bytes per row. */
1343 nr_cols = atol (argv[4]);
1344 if (nr_cols <= 0)
1345 error (_("-data-read-memory: invalid number of columns."));
1346
1347 /* The un-printable character when printing ascii. */
1348 if (argc == 6)
1349 aschar = *argv[5];
1350 else
1351 aschar = 0;
1352
1353 /* Create a buffer and read it in. */
1354 total_bytes = word_size * nr_rows * nr_cols;
1355
1356 gdb::byte_vector mbuf (total_bytes);
1357
1358 /* Dispatch memory reads to the topmost target, not the flattened
1359 current_target. */
1360 nr_bytes = target_read (current_target.beneath,
1361 TARGET_OBJECT_MEMORY, NULL, mbuf.data (),
1362 addr, total_bytes);
1363 if (nr_bytes <= 0)
1364 error (_("Unable to read memory."));
1365
1366 /* Output the header information. */
1367 uiout->field_core_addr ("addr", gdbarch, addr);
1368 uiout->field_int ("nr-bytes", nr_bytes);
1369 uiout->field_int ("total-bytes", total_bytes);
1370 uiout->field_core_addr ("next-row", gdbarch, addr + word_size * nr_cols);
1371 uiout->field_core_addr ("prev-row", gdbarch, addr - word_size * nr_cols);
1372 uiout->field_core_addr ("next-page", gdbarch, addr + total_bytes);
1373 uiout->field_core_addr ("prev-page", gdbarch, addr - total_bytes);
1374
1375 /* Build the result as a two dimentional table. */
1376 {
1377 int row;
1378 int row_byte;
1379
1380 string_file stream;
1381
1382 ui_out_emit_list list_emitter (uiout, "memory");
1383 for (row = 0, row_byte = 0;
1384 row < nr_rows;
1385 row++, row_byte += nr_cols * word_size)
1386 {
1387 int col;
1388 int col_byte;
1389 struct value_print_options opts;
1390
1391 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1392 uiout->field_core_addr ("addr", gdbarch, addr + row_byte);
1393 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1394 row_byte); */
1395 {
1396 ui_out_emit_list list_data_emitter (uiout, "data");
1397 get_formatted_print_options (&opts, word_format);
1398 for (col = 0, col_byte = row_byte;
1399 col < nr_cols;
1400 col++, col_byte += word_size)
1401 {
1402 if (col_byte + word_size > nr_bytes)
1403 {
1404 uiout->field_string (NULL, "N/A");
1405 }
1406 else
1407 {
1408 stream.clear ();
1409 print_scalar_formatted (&mbuf[col_byte], word_type, &opts,
1410 word_asize, &stream);
1411 uiout->field_stream (NULL, stream);
1412 }
1413 }
1414 }
1415
1416 if (aschar)
1417 {
1418 int byte;
1419
1420 stream.clear ();
1421 for (byte = row_byte;
1422 byte < row_byte + word_size * nr_cols; byte++)
1423 {
1424 if (byte >= nr_bytes)
1425 stream.putc ('X');
1426 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1427 stream.putc (aschar);
1428 else
1429 stream.putc (mbuf[byte]);
1430 }
1431 uiout->field_stream ("ascii", stream);
1432 }
1433 }
1434 }
1435 }
1436
1437 void
1438 mi_cmd_data_read_memory_bytes (const char *command, char **argv, int argc)
1439 {
1440 struct gdbarch *gdbarch = get_current_arch ();
1441 struct ui_out *uiout = current_uiout;
1442 CORE_ADDR addr;
1443 LONGEST length;
1444 long offset = 0;
1445 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
1446 int oind = 0;
1447 char *oarg;
1448 enum opt
1449 {
1450 OFFSET_OPT
1451 };
1452 static const struct mi_opt opts[] =
1453 {
1454 {"o", OFFSET_OPT, 1},
1455 { 0, 0, 0 }
1456 };
1457
1458 while (1)
1459 {
1460 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1461 &oind, &oarg);
1462 if (opt < 0)
1463 break;
1464 switch ((enum opt) opt)
1465 {
1466 case OFFSET_OPT:
1467 offset = atol (oarg);
1468 break;
1469 }
1470 }
1471 argv += oind;
1472 argc -= oind;
1473
1474 if (argc != 2)
1475 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1476
1477 addr = parse_and_eval_address (argv[0]) + offset;
1478 length = atol (argv[1]);
1479
1480 std::vector<memory_read_result> result
1481 = read_memory_robust (current_target.beneath, addr, length);
1482
1483 if (result.size () == 0)
1484 error (_("Unable to read memory."));
1485
1486 ui_out_emit_list list_emitter (uiout, "memory");
1487 for (const memory_read_result &read_result : result)
1488 {
1489 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1490
1491 uiout->field_core_addr ("begin", gdbarch, read_result.begin);
1492 uiout->field_core_addr ("offset", gdbarch, read_result.begin - addr);
1493 uiout->field_core_addr ("end", gdbarch, read_result.end);
1494
1495 std::string data = bin2hex (read_result.data.get (),
1496 (read_result.end - read_result.begin)
1497 * unit_size);
1498 uiout->field_string ("contents", data.c_str ());
1499 }
1500 }
1501
1502 /* Implementation of the -data-write_memory command.
1503
1504 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1505 offset from the beginning of the memory grid row where the cell to
1506 be written is.
1507 ADDR: start address of the row in the memory grid where the memory
1508 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1509 the location to write to.
1510 FORMAT: a char indicating format for the ``word''. See
1511 the ``x'' command.
1512 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1513 VALUE: value to be written into the memory address.
1514
1515 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1516
1517 Prints nothing. */
1518
1519 void
1520 mi_cmd_data_write_memory (const char *command, char **argv, int argc)
1521 {
1522 struct gdbarch *gdbarch = get_current_arch ();
1523 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1524 CORE_ADDR addr;
1525 long word_size;
1526 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1527 enough when using a compiler other than GCC. */
1528 LONGEST value;
1529 long offset = 0;
1530 int oind = 0;
1531 char *oarg;
1532 enum opt
1533 {
1534 OFFSET_OPT
1535 };
1536 static const struct mi_opt opts[] =
1537 {
1538 {"o", OFFSET_OPT, 1},
1539 { 0, 0, 0 }
1540 };
1541
1542 while (1)
1543 {
1544 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1545 &oind, &oarg);
1546
1547 if (opt < 0)
1548 break;
1549 switch ((enum opt) opt)
1550 {
1551 case OFFSET_OPT:
1552 offset = atol (oarg);
1553 break;
1554 }
1555 }
1556 argv += oind;
1557 argc -= oind;
1558
1559 if (argc != 4)
1560 error (_("-data-write-memory: Usage: "
1561 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1562
1563 /* Extract all the arguments. */
1564 /* Start address of the memory dump. */
1565 addr = parse_and_eval_address (argv[0]);
1566 /* The size of the memory word. */
1567 word_size = atol (argv[2]);
1568
1569 /* Calculate the real address of the write destination. */
1570 addr += (offset * word_size);
1571
1572 /* Get the value as a number. */
1573 value = parse_and_eval_address (argv[3]);
1574 /* Get the value into an array. */
1575 gdb::byte_vector buffer (word_size);
1576 store_signed_integer (buffer.data (), word_size, byte_order, value);
1577 /* Write it down to memory. */
1578 write_memory_with_notification (addr, buffer.data (), word_size);
1579 }
1580
1581 /* Implementation of the -data-write-memory-bytes command.
1582
1583 ADDR: start address
1584 DATA: string of bytes to write at that address
1585 COUNT: number of bytes to be filled (decimal integer). */
1586
1587 void
1588 mi_cmd_data_write_memory_bytes (const char *command, char **argv, int argc)
1589 {
1590 CORE_ADDR addr;
1591 char *cdata;
1592 size_t len_hex, len_bytes, len_units, i, steps, remaining_units;
1593 long int count_units;
1594 int unit_size;
1595
1596 if (argc != 2 && argc != 3)
1597 error (_("Usage: ADDR DATA [COUNT]."));
1598
1599 addr = parse_and_eval_address (argv[0]);
1600 cdata = argv[1];
1601 len_hex = strlen (cdata);
1602 unit_size = gdbarch_addressable_memory_unit_size (get_current_arch ());
1603
1604 if (len_hex % (unit_size * 2) != 0)
1605 error (_("Hex-encoded '%s' must represent an integral number of "
1606 "addressable memory units."),
1607 cdata);
1608
1609 len_bytes = len_hex / 2;
1610 len_units = len_bytes / unit_size;
1611
1612 if (argc == 3)
1613 count_units = strtoul (argv[2], NULL, 10);
1614 else
1615 count_units = len_units;
1616
1617 gdb::byte_vector databuf (len_bytes);
1618
1619 for (i = 0; i < len_bytes; ++i)
1620 {
1621 int x;
1622 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1623 error (_("Invalid argument"));
1624 databuf[i] = (gdb_byte) x;
1625 }
1626
1627 gdb::byte_vector data;
1628 if (len_units < count_units)
1629 {
1630 /* Pattern is made of less units than count:
1631 repeat pattern to fill memory. */
1632 data = gdb::byte_vector (count_units * unit_size);
1633
1634 /* Number of times the pattern is entirely repeated. */
1635 steps = count_units / len_units;
1636 /* Number of remaining addressable memory units. */
1637 remaining_units = count_units % len_units;
1638 for (i = 0; i < steps; i++)
1639 memcpy (&data[i * len_bytes], &databuf[0], len_bytes);
1640
1641 if (remaining_units > 0)
1642 memcpy (&data[steps * len_bytes], &databuf[0],
1643 remaining_units * unit_size);
1644 }
1645 else
1646 {
1647 /* Pattern is longer than or equal to count:
1648 just copy count addressable memory units. */
1649 data = std::move (databuf);
1650 }
1651
1652 write_memory_with_notification (addr, data.data (), count_units);
1653 }
1654
1655 void
1656 mi_cmd_enable_timings (const char *command, char **argv, int argc)
1657 {
1658 if (argc == 0)
1659 do_timings = 1;
1660 else if (argc == 1)
1661 {
1662 if (strcmp (argv[0], "yes") == 0)
1663 do_timings = 1;
1664 else if (strcmp (argv[0], "no") == 0)
1665 do_timings = 0;
1666 else
1667 goto usage_error;
1668 }
1669 else
1670 goto usage_error;
1671
1672 return;
1673
1674 usage_error:
1675 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1676 }
1677
1678 void
1679 mi_cmd_list_features (const char *command, char **argv, int argc)
1680 {
1681 if (argc == 0)
1682 {
1683 struct ui_out *uiout = current_uiout;
1684
1685 ui_out_emit_list list_emitter (uiout, "features");
1686 uiout->field_string (NULL, "frozen-varobjs");
1687 uiout->field_string (NULL, "pending-breakpoints");
1688 uiout->field_string (NULL, "thread-info");
1689 uiout->field_string (NULL, "data-read-memory-bytes");
1690 uiout->field_string (NULL, "breakpoint-notifications");
1691 uiout->field_string (NULL, "ada-task-info");
1692 uiout->field_string (NULL, "language-option");
1693 uiout->field_string (NULL, "info-gdb-mi-command");
1694 uiout->field_string (NULL, "undefined-command-error-code");
1695 uiout->field_string (NULL, "exec-run-start-option");
1696
1697 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
1698 uiout->field_string (NULL, "python");
1699
1700 return;
1701 }
1702
1703 error (_("-list-features should be passed no arguments"));
1704 }
1705
1706 void
1707 mi_cmd_list_target_features (const char *command, char **argv, int argc)
1708 {
1709 if (argc == 0)
1710 {
1711 struct ui_out *uiout = current_uiout;
1712
1713 ui_out_emit_list list_emitter (uiout, "features");
1714 if (mi_async_p ())
1715 uiout->field_string (NULL, "async");
1716 if (target_can_execute_reverse)
1717 uiout->field_string (NULL, "reverse");
1718 return;
1719 }
1720
1721 error (_("-list-target-features should be passed no arguments"));
1722 }
1723
1724 void
1725 mi_cmd_add_inferior (const char *command, char **argv, int argc)
1726 {
1727 struct inferior *inf;
1728
1729 if (argc != 0)
1730 error (_("-add-inferior should be passed no arguments"));
1731
1732 inf = add_inferior_with_spaces ();
1733
1734 current_uiout->field_fmt ("inferior", "i%d", inf->num);
1735 }
1736
1737 /* Callback used to find the first inferior other than the current
1738 one. */
1739
1740 static int
1741 get_other_inferior (struct inferior *inf, void *arg)
1742 {
1743 if (inf == current_inferior ())
1744 return 0;
1745
1746 return 1;
1747 }
1748
1749 void
1750 mi_cmd_remove_inferior (const char *command, char **argv, int argc)
1751 {
1752 int id;
1753 struct inferior *inf;
1754
1755 if (argc != 1)
1756 error (_("-remove-inferior should be passed a single argument"));
1757
1758 if (sscanf (argv[0], "i%d", &id) != 1)
1759 error (_("the thread group id is syntactically invalid"));
1760
1761 inf = find_inferior_id (id);
1762 if (!inf)
1763 error (_("the specified thread group does not exist"));
1764
1765 if (inf->pid != 0)
1766 error (_("cannot remove an active inferior"));
1767
1768 if (inf == current_inferior ())
1769 {
1770 struct thread_info *tp = 0;
1771 struct inferior *new_inferior
1772 = iterate_over_inferiors (get_other_inferior, NULL);
1773
1774 if (new_inferior == NULL)
1775 error (_("Cannot remove last inferior"));
1776
1777 set_current_inferior (new_inferior);
1778 if (new_inferior->pid != 0)
1779 tp = any_thread_of_process (new_inferior->pid);
1780 switch_to_thread (tp ? tp->ptid : null_ptid);
1781 set_current_program_space (new_inferior->pspace);
1782 }
1783
1784 delete_inferior (inf);
1785 }
1786
1787
1788
1789 /* Execute a command within a safe environment.
1790 Return <0 for error; >=0 for ok.
1791
1792 args->action will tell mi_execute_command what action
1793 to perform after the given command has executed (display/suppress
1794 prompt, display error). */
1795
1796 static void
1797 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1798 {
1799 struct mi_interp *mi = (struct mi_interp *) command_interp ();
1800
1801 if (do_timings)
1802 current_command_ts = context->cmd_start;
1803
1804 scoped_restore save_token = make_scoped_restore (&current_token,
1805 context->token);
1806
1807 running_result_record_printed = 0;
1808 mi_proceeded = 0;
1809 switch (context->op)
1810 {
1811 case MI_COMMAND:
1812 /* A MI command was read from the input stream. */
1813 if (mi_debug_p)
1814 /* FIXME: gdb_???? */
1815 fprintf_unfiltered (mi->raw_stdout,
1816 " token=`%s' command=`%s' args=`%s'\n",
1817 context->token, context->command, context->args);
1818
1819 mi_cmd_execute (context);
1820
1821 /* Print the result if there were no errors.
1822
1823 Remember that on the way out of executing a command, you have
1824 to directly use the mi_interp's uiout, since the command
1825 could have reset the interpreter, in which case the current
1826 uiout will most likely crash in the mi_out_* routines. */
1827 if (!running_result_record_printed)
1828 {
1829 fputs_unfiltered (context->token, mi->raw_stdout);
1830 /* There's no particularly good reason why target-connect results
1831 in not ^done. Should kill ^connected for MI3. */
1832 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1833 ? "^connected" : "^done", mi->raw_stdout);
1834 mi_out_put (uiout, mi->raw_stdout);
1835 mi_out_rewind (uiout);
1836 mi_print_timing_maybe (mi->raw_stdout);
1837 fputs_unfiltered ("\n", mi->raw_stdout);
1838 }
1839 else
1840 /* The command does not want anything to be printed. In that
1841 case, the command probably should not have written anything
1842 to uiout, but in case it has written something, discard it. */
1843 mi_out_rewind (uiout);
1844 break;
1845
1846 case CLI_COMMAND:
1847 {
1848 char *argv[2];
1849
1850 /* A CLI command was read from the input stream. */
1851 /* This "feature" will be removed as soon as we have a
1852 complete set of mi commands. */
1853 /* Echo the command on the console. */
1854 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1855 /* Call the "console" interpreter. */
1856 argv[0] = (char *) INTERP_CONSOLE;
1857 argv[1] = context->command;
1858 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1859
1860 /* If we changed interpreters, DON'T print out anything. */
1861 if (current_interp_named_p (INTERP_MI)
1862 || current_interp_named_p (INTERP_MI1)
1863 || current_interp_named_p (INTERP_MI2)
1864 || current_interp_named_p (INTERP_MI3))
1865 {
1866 if (!running_result_record_printed)
1867 {
1868 fputs_unfiltered (context->token, mi->raw_stdout);
1869 fputs_unfiltered ("^done", mi->raw_stdout);
1870 mi_out_put (uiout, mi->raw_stdout);
1871 mi_out_rewind (uiout);
1872 mi_print_timing_maybe (mi->raw_stdout);
1873 fputs_unfiltered ("\n", mi->raw_stdout);
1874 }
1875 else
1876 mi_out_rewind (uiout);
1877 }
1878 break;
1879 }
1880 }
1881 }
1882
1883 /* Print a gdb exception to the MI output stream. */
1884
1885 static void
1886 mi_print_exception (const char *token, struct gdb_exception exception)
1887 {
1888 struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
1889
1890 fputs_unfiltered (token, mi->raw_stdout);
1891 fputs_unfiltered ("^error,msg=\"", mi->raw_stdout);
1892 if (exception.message == NULL)
1893 fputs_unfiltered ("unknown error", mi->raw_stdout);
1894 else
1895 fputstr_unfiltered (exception.message, '"', mi->raw_stdout);
1896 fputs_unfiltered ("\"", mi->raw_stdout);
1897
1898 switch (exception.error)
1899 {
1900 case UNDEFINED_COMMAND_ERROR:
1901 fputs_unfiltered (",code=\"undefined-command\"", mi->raw_stdout);
1902 break;
1903 }
1904
1905 fputs_unfiltered ("\n", mi->raw_stdout);
1906 }
1907
1908 /* Determine whether the parsed command already notifies the
1909 user_selected_context_changed observer. */
1910
1911 static int
1912 command_notifies_uscc_observer (struct mi_parse *command)
1913 {
1914 if (command->op == CLI_COMMAND)
1915 {
1916 /* CLI commands "thread" and "inferior" already send it. */
1917 return (strncmp (command->command, "thread ", 7) == 0
1918 || strncmp (command->command, "inferior ", 9) == 0);
1919 }
1920 else /* MI_COMMAND */
1921 {
1922 if (strcmp (command->command, "interpreter-exec") == 0
1923 && command->argc > 1)
1924 {
1925 /* "thread" and "inferior" again, but through -interpreter-exec. */
1926 return (strncmp (command->argv[1], "thread ", 7) == 0
1927 || strncmp (command->argv[1], "inferior ", 9) == 0);
1928 }
1929
1930 else
1931 /* -thread-select already sends it. */
1932 return strcmp (command->command, "thread-select") == 0;
1933 }
1934 }
1935
1936 void
1937 mi_execute_command (const char *cmd, int from_tty)
1938 {
1939 char *token;
1940 std::unique_ptr<struct mi_parse> command;
1941
1942 /* This is to handle EOF (^D). We just quit gdb. */
1943 /* FIXME: we should call some API function here. */
1944 if (cmd == 0)
1945 quit_force (NULL, from_tty);
1946
1947 target_log_command (cmd);
1948
1949 TRY
1950 {
1951 command = mi_parse (cmd, &token);
1952 }
1953 CATCH (exception, RETURN_MASK_ALL)
1954 {
1955 mi_print_exception (token, exception);
1956 xfree (token);
1957 }
1958 END_CATCH
1959
1960 if (command != NULL)
1961 {
1962 ptid_t previous_ptid = inferior_ptid;
1963
1964 gdb::optional<scoped_restore_tmpl<int>> restore_suppress;
1965
1966 if (command->cmd != NULL && command->cmd->suppress_notification != NULL)
1967 restore_suppress.emplace (command->cmd->suppress_notification, 1);
1968
1969 command->token = token;
1970
1971 if (do_timings)
1972 {
1973 command->cmd_start = new mi_timestamp ();
1974 timestamp (command->cmd_start);
1975 }
1976
1977 TRY
1978 {
1979 captured_mi_execute_command (current_uiout, command.get ());
1980 }
1981 CATCH (result, RETURN_MASK_ALL)
1982 {
1983 /* Like in start_event_loop, enable input and force display
1984 of the prompt. Otherwise, any command that calls
1985 async_disable_stdin, and then throws, will leave input
1986 disabled. */
1987 async_enable_stdin ();
1988 current_ui->prompt_state = PROMPT_NEEDED;
1989
1990 /* The command execution failed and error() was called
1991 somewhere. */
1992 mi_print_exception (command->token, result);
1993 mi_out_rewind (current_uiout);
1994 }
1995 END_CATCH
1996
1997 bpstat_do_actions ();
1998
1999 if (/* The notifications are only output when the top-level
2000 interpreter (specified on the command line) is MI. */
2001 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2002 /* Don't try report anything if there are no threads --
2003 the program is dead. */
2004 && thread_count () != 0
2005 /* If the command already reports the thread change, no need to do it
2006 again. */
2007 && !command_notifies_uscc_observer (command.get ()))
2008 {
2009 struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
2010 int report_change = 0;
2011
2012 if (command->thread == -1)
2013 {
2014 report_change = (!ptid_equal (previous_ptid, null_ptid)
2015 && !ptid_equal (inferior_ptid, previous_ptid)
2016 && !ptid_equal (inferior_ptid, null_ptid));
2017 }
2018 else if (!ptid_equal (inferior_ptid, null_ptid))
2019 {
2020 struct thread_info *ti = inferior_thread ();
2021
2022 report_change = (ti->global_num != command->thread);
2023 }
2024
2025 if (report_change)
2026 {
2027 observer_notify_user_selected_context_changed
2028 (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
2029 }
2030 }
2031 }
2032 }
2033
2034 static void
2035 mi_cmd_execute (struct mi_parse *parse)
2036 {
2037 scoped_value_mark cleanup = prepare_execute_command ();
2038
2039 if (parse->all && parse->thread_group != -1)
2040 error (_("Cannot specify --thread-group together with --all"));
2041
2042 if (parse->all && parse->thread != -1)
2043 error (_("Cannot specify --thread together with --all"));
2044
2045 if (parse->thread_group != -1 && parse->thread != -1)
2046 error (_("Cannot specify --thread together with --thread-group"));
2047
2048 if (parse->frame != -1 && parse->thread == -1)
2049 error (_("Cannot specify --frame without --thread"));
2050
2051 if (parse->thread_group != -1)
2052 {
2053 struct inferior *inf = find_inferior_id (parse->thread_group);
2054 struct thread_info *tp = 0;
2055
2056 if (!inf)
2057 error (_("Invalid thread group for the --thread-group option"));
2058
2059 set_current_inferior (inf);
2060 /* This behaviour means that if --thread-group option identifies
2061 an inferior with multiple threads, then a random one will be
2062 picked. This is not a problem -- frontend should always
2063 provide --thread if it wishes to operate on a specific
2064 thread. */
2065 if (inf->pid != 0)
2066 tp = any_live_thread_of_process (inf->pid);
2067 switch_to_thread (tp ? tp->ptid : null_ptid);
2068 set_current_program_space (inf->pspace);
2069 }
2070
2071 if (parse->thread != -1)
2072 {
2073 struct thread_info *tp = find_thread_global_id (parse->thread);
2074
2075 if (!tp)
2076 error (_("Invalid thread id: %d"), parse->thread);
2077
2078 if (is_exited (tp->ptid))
2079 error (_("Thread id: %d has terminated"), parse->thread);
2080
2081 switch_to_thread (tp->ptid);
2082 }
2083
2084 if (parse->frame != -1)
2085 {
2086 struct frame_info *fid;
2087 int frame = parse->frame;
2088
2089 fid = find_relative_frame (get_current_frame (), &frame);
2090 if (frame == 0)
2091 /* find_relative_frame was successful */
2092 select_frame (fid);
2093 else
2094 error (_("Invalid frame id: %d"), frame);
2095 }
2096
2097 gdb::optional<scoped_restore_current_language> lang_saver;
2098 if (parse->language != language_unknown)
2099 {
2100 lang_saver.emplace ();
2101 set_language (parse->language);
2102 }
2103
2104 current_context = parse;
2105
2106 if (parse->cmd->argv_func != NULL)
2107 {
2108 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2109 }
2110 else if (parse->cmd->cli.cmd != 0)
2111 {
2112 /* FIXME: DELETE THIS. */
2113 /* The operation is still implemented by a cli command. */
2114 /* Must be a synchronous one. */
2115 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2116 parse->args);
2117 }
2118 else
2119 {
2120 /* FIXME: DELETE THIS. */
2121 string_file stb;
2122
2123 stb.puts ("Undefined mi command: ");
2124 stb.putstr (parse->command, '"');
2125 stb.puts (" (missing implementation)");
2126
2127 error_stream (stb);
2128 }
2129 }
2130
2131 /* FIXME: This is just a hack so we can get some extra commands going.
2132 We don't want to channel things through the CLI, but call libgdb directly.
2133 Use only for synchronous commands. */
2134
2135 void
2136 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2137 {
2138 if (cmd != 0)
2139 {
2140 std::string run = cmd;
2141
2142 if (args_p)
2143 run = run + " " + args;
2144 if (mi_debug_p)
2145 /* FIXME: gdb_???? */
2146 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2147 cmd, run.c_str ());
2148 execute_command (run.c_str (), 0 /* from_tty */ );
2149 }
2150 }
2151
2152 void
2153 mi_execute_async_cli_command (const char *cli_command, char **argv, int argc)
2154 {
2155 std::string run = cli_command;
2156
2157 if (argc)
2158 run = run + " " + *argv;
2159 if (mi_async_p ())
2160 run += "&";
2161
2162 execute_command (run.c_str (), 0 /* from_tty */ );
2163 }
2164
2165 void
2166 mi_load_progress (const char *section_name,
2167 unsigned long sent_so_far,
2168 unsigned long total_section,
2169 unsigned long total_sent,
2170 unsigned long grand_total)
2171 {
2172 using namespace std::chrono;
2173 static steady_clock::time_point last_update;
2174 static char *previous_sect_name = NULL;
2175 int new_section;
2176 struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
2177
2178 /* This function is called through deprecated_show_load_progress
2179 which means uiout may not be correct. Fix it for the duration
2180 of this function. */
2181
2182 std::unique_ptr<ui_out> uiout;
2183
2184 if (current_interp_named_p (INTERP_MI)
2185 || current_interp_named_p (INTERP_MI2))
2186 uiout.reset (mi_out_new (2));
2187 else if (current_interp_named_p (INTERP_MI1))
2188 uiout.reset (mi_out_new (1));
2189 else if (current_interp_named_p (INTERP_MI3))
2190 uiout.reset (mi_out_new (3));
2191 else
2192 return;
2193
2194 scoped_restore save_uiout
2195 = make_scoped_restore (&current_uiout, uiout.get ());
2196
2197 new_section = (previous_sect_name ?
2198 strcmp (previous_sect_name, section_name) : 1);
2199 if (new_section)
2200 {
2201 xfree (previous_sect_name);
2202 previous_sect_name = xstrdup (section_name);
2203
2204 if (current_token)
2205 fputs_unfiltered (current_token, mi->raw_stdout);
2206 fputs_unfiltered ("+download", mi->raw_stdout);
2207 {
2208 ui_out_emit_tuple tuple_emitter (uiout.get (), NULL);
2209 uiout->field_string ("section", section_name);
2210 uiout->field_int ("section-size", total_section);
2211 uiout->field_int ("total-size", grand_total);
2212 }
2213 mi_out_put (uiout.get (), mi->raw_stdout);
2214 fputs_unfiltered ("\n", mi->raw_stdout);
2215 gdb_flush (mi->raw_stdout);
2216 }
2217
2218 steady_clock::time_point time_now = steady_clock::now ();
2219 if (time_now - last_update > milliseconds (500))
2220 {
2221 last_update = time_now;
2222 if (current_token)
2223 fputs_unfiltered (current_token, mi->raw_stdout);
2224 fputs_unfiltered ("+download", mi->raw_stdout);
2225 {
2226 ui_out_emit_tuple tuple_emitter (uiout.get (), NULL);
2227 uiout->field_string ("section", section_name);
2228 uiout->field_int ("section-sent", sent_so_far);
2229 uiout->field_int ("section-size", total_section);
2230 uiout->field_int ("total-sent", total_sent);
2231 uiout->field_int ("total-size", grand_total);
2232 }
2233 mi_out_put (uiout.get (), mi->raw_stdout);
2234 fputs_unfiltered ("\n", mi->raw_stdout);
2235 gdb_flush (mi->raw_stdout);
2236 }
2237 }
2238
2239 static void
2240 timestamp (struct mi_timestamp *tv)
2241 {
2242 using namespace std::chrono;
2243
2244 tv->wallclock = steady_clock::now ();
2245 run_time_clock::now (tv->utime, tv->stime);
2246 }
2247
2248 static void
2249 print_diff_now (struct ui_file *file, struct mi_timestamp *start)
2250 {
2251 struct mi_timestamp now;
2252
2253 timestamp (&now);
2254 print_diff (file, start, &now);
2255 }
2256
2257 void
2258 mi_print_timing_maybe (struct ui_file *file)
2259 {
2260 /* If the command is -enable-timing then do_timings may be true
2261 whilst current_command_ts is not initialized. */
2262 if (do_timings && current_command_ts)
2263 print_diff_now (file, current_command_ts);
2264 }
2265
2266 static void
2267 print_diff (struct ui_file *file, struct mi_timestamp *start,
2268 struct mi_timestamp *end)
2269 {
2270 using namespace std::chrono;
2271
2272 duration<double> wallclock = end->wallclock - start->wallclock;
2273 duration<double> utime = end->utime - start->utime;
2274 duration<double> stime = end->stime - start->stime;
2275
2276 fprintf_unfiltered
2277 (file,
2278 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2279 wallclock.count (), utime.count (), stime.count ());
2280 }
2281
2282 void
2283 mi_cmd_trace_define_variable (const char *command, char **argv, int argc)
2284 {
2285 LONGEST initval = 0;
2286 struct trace_state_variable *tsv;
2287 char *name = 0;
2288
2289 if (argc != 1 && argc != 2)
2290 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2291
2292 name = argv[0];
2293 if (*name++ != '$')
2294 error (_("Name of trace variable should start with '$'"));
2295
2296 validate_trace_state_variable_name (name);
2297
2298 tsv = find_trace_state_variable (name);
2299 if (!tsv)
2300 tsv = create_trace_state_variable (name);
2301
2302 if (argc == 2)
2303 initval = value_as_long (parse_and_eval (argv[1]));
2304
2305 tsv->initial_value = initval;
2306 }
2307
2308 void
2309 mi_cmd_trace_list_variables (const char *command, char **argv, int argc)
2310 {
2311 if (argc != 0)
2312 error (_("-trace-list-variables: no arguments allowed"));
2313
2314 tvariables_info_1 ();
2315 }
2316
2317 void
2318 mi_cmd_trace_find (const char *command, char **argv, int argc)
2319 {
2320 char *mode;
2321
2322 if (argc == 0)
2323 error (_("trace selection mode is required"));
2324
2325 mode = argv[0];
2326
2327 if (strcmp (mode, "none") == 0)
2328 {
2329 tfind_1 (tfind_number, -1, 0, 0, 0);
2330 return;
2331 }
2332
2333 check_trace_running (current_trace_status ());
2334
2335 if (strcmp (mode, "frame-number") == 0)
2336 {
2337 if (argc != 2)
2338 error (_("frame number is required"));
2339 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2340 }
2341 else if (strcmp (mode, "tracepoint-number") == 0)
2342 {
2343 if (argc != 2)
2344 error (_("tracepoint number is required"));
2345 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2346 }
2347 else if (strcmp (mode, "pc") == 0)
2348 {
2349 if (argc != 2)
2350 error (_("PC is required"));
2351 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2352 }
2353 else if (strcmp (mode, "pc-inside-range") == 0)
2354 {
2355 if (argc != 3)
2356 error (_("Start and end PC are required"));
2357 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2358 parse_and_eval_address (argv[2]), 0);
2359 }
2360 else if (strcmp (mode, "pc-outside-range") == 0)
2361 {
2362 if (argc != 3)
2363 error (_("Start and end PC are required"));
2364 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2365 parse_and_eval_address (argv[2]), 0);
2366 }
2367 else if (strcmp (mode, "line") == 0)
2368 {
2369 if (argc != 2)
2370 error (_("Line is required"));
2371
2372 std::vector<symtab_and_line> sals
2373 = decode_line_with_current_source (argv[1],
2374 DECODE_LINE_FUNFIRSTLINE);
2375 const symtab_and_line &sal = sals[0];
2376
2377 if (sal.symtab == 0)
2378 error (_("Could not find the specified line"));
2379
2380 CORE_ADDR start_pc, end_pc;
2381 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2382 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2383 else
2384 error (_("Could not find the specified line"));
2385 }
2386 else
2387 error (_("Invalid mode '%s'"), mode);
2388
2389 if (has_stack_frames () || get_traceframe_number () >= 0)
2390 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
2391 }
2392
2393 void
2394 mi_cmd_trace_save (const char *command, char **argv, int argc)
2395 {
2396 int target_saves = 0;
2397 int generate_ctf = 0;
2398 char *filename;
2399 int oind = 0;
2400 char *oarg;
2401
2402 enum opt
2403 {
2404 TARGET_SAVE_OPT, CTF_OPT
2405 };
2406 static const struct mi_opt opts[] =
2407 {
2408 {"r", TARGET_SAVE_OPT, 0},
2409 {"ctf", CTF_OPT, 0},
2410 { 0, 0, 0 }
2411 };
2412
2413 while (1)
2414 {
2415 int opt = mi_getopt ("-trace-save", argc, argv, opts,
2416 &oind, &oarg);
2417
2418 if (opt < 0)
2419 break;
2420 switch ((enum opt) opt)
2421 {
2422 case TARGET_SAVE_OPT:
2423 target_saves = 1;
2424 break;
2425 case CTF_OPT:
2426 generate_ctf = 1;
2427 break;
2428 }
2429 }
2430
2431 if (argc - oind != 1)
2432 error (_("Exactly one argument required "
2433 "(file in which to save trace data)"));
2434
2435 filename = argv[oind];
2436
2437 if (generate_ctf)
2438 trace_save_ctf (filename, target_saves);
2439 else
2440 trace_save_tfile (filename, target_saves);
2441 }
2442
2443 void
2444 mi_cmd_trace_start (const char *command, char **argv, int argc)
2445 {
2446 start_tracing (NULL);
2447 }
2448
2449 void
2450 mi_cmd_trace_status (const char *command, char **argv, int argc)
2451 {
2452 trace_status_mi (0);
2453 }
2454
2455 void
2456 mi_cmd_trace_stop (const char *command, char **argv, int argc)
2457 {
2458 stop_tracing (NULL);
2459 trace_status_mi (1);
2460 }
2461
2462 /* Implement the "-ada-task-info" command. */
2463
2464 void
2465 mi_cmd_ada_task_info (const char *command, char **argv, int argc)
2466 {
2467 if (argc != 0 && argc != 1)
2468 error (_("Invalid MI command"));
2469
2470 print_ada_task_info (current_uiout, argv[0], current_inferior ());
2471 }
2472
2473 /* Print EXPRESSION according to VALUES. */
2474
2475 static void
2476 print_variable_or_computed (const char *expression, enum print_values values)
2477 {
2478 struct value *val;
2479 struct type *type;
2480 struct ui_out *uiout = current_uiout;
2481
2482 string_file stb;
2483
2484 expression_up expr = parse_expression (expression);
2485
2486 if (values == PRINT_SIMPLE_VALUES)
2487 val = evaluate_type (expr.get ());
2488 else
2489 val = evaluate_expression (expr.get ());
2490
2491 gdb::optional<ui_out_emit_tuple> tuple_emitter;
2492 if (values != PRINT_NO_VALUES)
2493 tuple_emitter.emplace (uiout, nullptr);
2494 uiout->field_string ("name", expression);
2495
2496 switch (values)
2497 {
2498 case PRINT_SIMPLE_VALUES:
2499 type = check_typedef (value_type (val));
2500 type_print (value_type (val), "", &stb, -1);
2501 uiout->field_stream ("type", stb);
2502 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2503 && TYPE_CODE (type) != TYPE_CODE_STRUCT
2504 && TYPE_CODE (type) != TYPE_CODE_UNION)
2505 {
2506 struct value_print_options opts;
2507
2508 get_no_prettyformat_print_options (&opts);
2509 opts.deref_ref = 1;
2510 common_val_print (val, &stb, 0, &opts, current_language);
2511 uiout->field_stream ("value", stb);
2512 }
2513 break;
2514 case PRINT_ALL_VALUES:
2515 {
2516 struct value_print_options opts;
2517
2518 get_no_prettyformat_print_options (&opts);
2519 opts.deref_ref = 1;
2520 common_val_print (val, &stb, 0, &opts, current_language);
2521 uiout->field_stream ("value", stb);
2522 }
2523 break;
2524 }
2525 }
2526
2527 /* Implement the "-trace-frame-collected" command. */
2528
2529 void
2530 mi_cmd_trace_frame_collected (const char *command, char **argv, int argc)
2531 {
2532 struct bp_location *tloc;
2533 int stepping_frame;
2534 struct collection_list *clist;
2535 struct collection_list tracepoint_list, stepping_list;
2536 struct traceframe_info *tinfo;
2537 int oind = 0;
2538 enum print_values var_print_values = PRINT_ALL_VALUES;
2539 enum print_values comp_print_values = PRINT_ALL_VALUES;
2540 int registers_format = 'x';
2541 int memory_contents = 0;
2542 struct ui_out *uiout = current_uiout;
2543 enum opt
2544 {
2545 VAR_PRINT_VALUES,
2546 COMP_PRINT_VALUES,
2547 REGISTERS_FORMAT,
2548 MEMORY_CONTENTS,
2549 };
2550 static const struct mi_opt opts[] =
2551 {
2552 {"-var-print-values", VAR_PRINT_VALUES, 1},
2553 {"-comp-print-values", COMP_PRINT_VALUES, 1},
2554 {"-registers-format", REGISTERS_FORMAT, 1},
2555 {"-memory-contents", MEMORY_CONTENTS, 0},
2556 { 0, 0, 0 }
2557 };
2558
2559 while (1)
2560 {
2561 char *oarg;
2562 int opt = mi_getopt ("-trace-frame-collected", argc, argv, opts,
2563 &oind, &oarg);
2564 if (opt < 0)
2565 break;
2566 switch ((enum opt) opt)
2567 {
2568 case VAR_PRINT_VALUES:
2569 var_print_values = mi_parse_print_values (oarg);
2570 break;
2571 case COMP_PRINT_VALUES:
2572 comp_print_values = mi_parse_print_values (oarg);
2573 break;
2574 case REGISTERS_FORMAT:
2575 registers_format = oarg[0];
2576 case MEMORY_CONTENTS:
2577 memory_contents = 1;
2578 break;
2579 }
2580 }
2581
2582 if (oind != argc)
2583 error (_("Usage: -trace-frame-collected "
2584 "[--var-print-values PRINT_VALUES] "
2585 "[--comp-print-values PRINT_VALUES] "
2586 "[--registers-format FORMAT]"
2587 "[--memory-contents]"));
2588
2589 /* This throws an error is not inspecting a trace frame. */
2590 tloc = get_traceframe_location (&stepping_frame);
2591
2592 /* This command only makes sense for the current frame, not the
2593 selected frame. */
2594 scoped_restore_current_thread restore_thread;
2595 select_frame (get_current_frame ());
2596
2597 encode_actions (tloc, &tracepoint_list, &stepping_list);
2598
2599 if (stepping_frame)
2600 clist = &stepping_list;
2601 else
2602 clist = &tracepoint_list;
2603
2604 tinfo = get_traceframe_info ();
2605
2606 /* Explicitly wholly collected variables. */
2607 {
2608 ui_out_emit_list list_emitter (uiout, "explicit-variables");
2609 const std::vector<std::string> &wholly_collected
2610 = clist->wholly_collected ();
2611 for (size_t i = 0; i < wholly_collected.size (); i++)
2612 {
2613 const std::string &str = wholly_collected[i];
2614 print_variable_or_computed (str.c_str (), var_print_values);
2615 }
2616 }
2617
2618 /* Computed expressions. */
2619 {
2620 ui_out_emit_list list_emitter (uiout, "computed-expressions");
2621
2622 const std::vector<std::string> &computed = clist->computed ();
2623 for (size_t i = 0; i < computed.size (); i++)
2624 {
2625 const std::string &str = computed[i];
2626 print_variable_or_computed (str.c_str (), comp_print_values);
2627 }
2628 }
2629
2630 /* Registers. Given pseudo-registers, and that some architectures
2631 (like MIPS) actually hide the raw registers, we don't go through
2632 the trace frame info, but instead consult the register cache for
2633 register availability. */
2634 {
2635 struct frame_info *frame;
2636 struct gdbarch *gdbarch;
2637 int regnum;
2638 int numregs;
2639
2640 ui_out_emit_list list_emitter (uiout, "registers");
2641
2642 frame = get_selected_frame (NULL);
2643 gdbarch = get_frame_arch (frame);
2644 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
2645
2646 for (regnum = 0; regnum < numregs; regnum++)
2647 {
2648 if (gdbarch_register_name (gdbarch, regnum) == NULL
2649 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
2650 continue;
2651
2652 output_register (frame, regnum, registers_format, 1);
2653 }
2654 }
2655
2656 /* Trace state variables. */
2657 {
2658 ui_out_emit_list list_emitter (uiout, "tvars");
2659
2660 for (int tvar : tinfo->tvars)
2661 {
2662 struct trace_state_variable *tsv;
2663
2664 tsv = find_trace_state_variable_by_number (tvar);
2665
2666 ui_out_emit_tuple tuple_emitter (uiout, NULL);
2667
2668 if (tsv != NULL)
2669 {
2670 uiout->field_fmt ("name", "$%s", tsv->name);
2671
2672 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
2673 &tsv->value);
2674 uiout->field_int ("current", tsv->value);
2675 }
2676 else
2677 {
2678 uiout->field_skip ("name");
2679 uiout->field_skip ("current");
2680 }
2681 }
2682 }
2683
2684 /* Memory. */
2685 {
2686 std::vector<mem_range> available_memory;
2687
2688 traceframe_available_memory (&available_memory, 0, ULONGEST_MAX);
2689
2690 ui_out_emit_list list_emitter (uiout, "memory");
2691
2692 for (const mem_range &r : available_memory)
2693 {
2694 struct gdbarch *gdbarch = target_gdbarch ();
2695
2696 ui_out_emit_tuple tuple_emitter (uiout, NULL);
2697
2698 uiout->field_core_addr ("address", gdbarch, r.start);
2699 uiout->field_int ("length", r.length);
2700
2701 gdb::byte_vector data (r.length);
2702
2703 if (memory_contents)
2704 {
2705 if (target_read_memory (r.start, data.data (), r.length) == 0)
2706 {
2707 std::string data_str = bin2hex (data.data (), r.length);
2708 uiout->field_string ("contents", data_str.c_str ());
2709 }
2710 else
2711 uiout->field_skip ("contents");
2712 }
2713 }
2714 }
2715 }
2716
2717 void
2718 _initialize_mi_main (void)
2719 {
2720 struct cmd_list_element *c;
2721
2722 add_setshow_boolean_cmd ("mi-async", class_run,
2723 &mi_async_1, _("\
2724 Set whether MI asynchronous mode is enabled."), _("\
2725 Show whether MI asynchronous mode is enabled."), _("\
2726 Tells GDB whether MI should be in asynchronous mode."),
2727 set_mi_async_command,
2728 show_mi_async_command,
2729 &setlist,
2730 &showlist);
2731
2732 /* Alias old "target-async" to "mi-async". */
2733 c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &setlist);
2734 deprecate_cmd (c, "set mi-async");
2735 c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &showlist);
2736 deprecate_cmd (c, "show mi-async");
2737 }
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
gdbarch
Definition: gdbarch.c:127
top.h
target_can_async_p
#define target_can_async_p()
Definition: target.h:1778
string
const char * string
Definition: signals.c:50
mi-common.h
print_diff
static void print_diff(struct ui_file *file, struct mi_timestamp *start, struct mi_timestamp *end)
Definition: mi-main.c:2267
have_live_inferiors
int have_live_inferiors(void)
Definition: inferior.c:451
flash_erase_command
void flash_erase_command(const char *cmd, int from_tty)
Definition: target.c:3808
target_has_registers
#define target_has_registers
Definition: target.h:1740
get_traceframe_info
struct traceframe_info * get_traceframe_info(void)
Definition: tracepoint.c:4042
mi_parse::cmd_start
struct mi_timestamp * cmd_start
Definition: mi-parse.h:53
do_timings
static int do_timings
Definition: mi-main.c:79
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
selftests::ptid::tid
static constexpr ptid_t tid
Definition: ptid-selftests.c:43
return_command
void return_command(const char *, int)
Definition: stack.c:2366
target_can_execute_reverse
#define target_can_execute_reverse
Definition: target.h:2013
mi_cmd_list_thread_groups
void mi_cmd_list_thread_groups(const char *command, char **argv, int argc)
Definition: mi-main.c:790
mi_cmd_list_target_features
void mi_cmd_list_target_features(const char *command, char **argv, int argc)
Definition: mi-main.c:1707
current_ui
struct ui * current_ui
Definition: event-top.c:453
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
target_stop
void target_stop(ptid_t ptid)
Definition: target.c:3316
detach_command
void detach_command(const char *args, int from_tty)
Definition: infcmd.c:2968
ui_out::field_core_addr
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:513
value_print_options::deref_ref
int deref_ref
Definition: valprint.h:75
MI_COMMAND
Definition: mi-parse.h:39
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
mi_cmd_trace_start
void mi_cmd_trace_start(const char *command, char **argv, int argc)
Definition: mi-main.c:2444
ui_out::field_string
void field_string(const char *fldname, const char *string)
Definition: ui-out.c:544
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
ui_out_emit_type
Definition: ui-out.h:192
proceed_thread
static void proceed_thread(struct thread_info *thread, int pid)
Definition: mi-main.c:244
EXT_LANG_PYTHON
Definition: extension.h:63
target_shortname
#define target_shortname
Definition: target.h:1279
RETURN_MASK_ALL
Definition: common-exceptions.h:44
mi_load_progress
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)
Definition: mi-main.c:2166
ptid_get_pid
int ptid_get_pid(const ptid_t &ptid)
Definition: ptid.c:47
fputs_unfiltered
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:127
expression_up
gdb::unique_xmalloc_ptr< expression > expression_up
Definition: expression.h:87
mi_parse
Definition: mi-parse.h:42
INTERP_MI2
#define INTERP_MI2
Definition: interps.h:172
error_stream
void error_stream(const string_file &stream)
Definition: utils.c:255
print_one_inferior_data::recurse
int recurse
Definition: mi-main.c:644
mi_cmd_thread_list_ids
void mi_cmd_thread_list_ids(const char *command, char **argv, int argc)
Definition: mi-main.c:582
xfree
void xfree(void *)
pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1824
interrupt_target_1
void interrupt_target_1(int all_threads)
Definition: infcmd.c:3024
int_string
char * int_string(LONGEST val, int radix, int is_signed, int width, int use_c_format)
Definition: print-utils.c:253
regcache::cooked_read_value
struct value * cooked_read_value(int regnum)
Definition: regcache.c:720
parse
static int parse(struct parser_state *ps)
Definition: ada-lang.c:14317
mi-cmds.h
value_as_long
LONGEST value_as_long(struct value *val)
Definition: value.c:2749
cmd_list_element
Definition: cli-decode.h:46
mi_proceeded
int mi_proceeded
Definition: mi-main.c:91
current_command_ts
static struct mi_timestamp * current_command_ts
Definition: mi-main.c:77
mi-main.h
stop_tracing
void stop_tracing(const char *note)
Definition: tracepoint.c:1730
deprecate_cmd
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition: cli-decode.c:292
regcache::regcache
regcache(gdbarch *gdbarch)
Definition: regcache.h:235
value_embedded_offset
LONGEST value_embedded_offset(const struct value *value)
Definition: value.c:1477
mi_parse::cmd
const struct mi_cmd * cmd
Definition: mi-parse.h:52
available
unsigned available
Definition: go32-nat.c:1072
async_enable_stdin
void async_enable_stdin(void)
Definition: event-top.c:538
current_token
char * current_token
Definition: mi-main.c:81
ada-lang.h
set_language
enum language set_language(enum language lang)
Definition: language.c:379
mi_cmd_trace_status
void mi_cmd_trace_status(const char *command, char **argv, int argc)
Definition: mi-main.c:2450
USER_SELECTED_FRAME
Definition: defs.h:702
bin2hex
int bin2hex(const gdb_byte *bin, char *hex, int count)
Definition: rsp-low.c:173
traceframe_info::tvars
std::vector< int > tvars
Definition: tracepoint.h:37
tfind_outside
Definition: tracepoint.h:390
regcache_cooked_write_signed
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition: regcache.c:785
ui_out::field_skip
void field_skip(const char *fldname)
Definition: ui-out.c:532
mi_parse::argv
char ** argv
Definition: mi-parse.h:55
get_formatted_print_options
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition: valprint.c:137
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
common_val_print
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1136
mi_cmd_add_inferior
void mi_cmd_add_inferior(const char *command, char **argv, int argc)
Definition: mi-main.c:1725
select_frame
void select_frame(struct frame_info *fi)
Definition: frame.c:1677
gdb_exception::error
enum errors error
Definition: common-exceptions.h:114
collection_list::computed
const std::vector< std::string > & computed()
Definition: tracepoint.h:277
inferior::pid
int pid
Definition: inferior.h:328
inferior_thread
struct thread_info * inferior_thread(void)
Definition: thread.c:90
interp_ui_out
struct ui_out * interp_ui_out(struct interp *interp)
Definition: interps.c:257
inferior
Definition: inferior.h:310
observer_notify_user_selected_context_changed
void observer_notify_user_selected_context_changed(user_selected_what selection)
target_log_command
#define target_log_command(p)
Definition: target.h:2226
proceed_thread_callback
static int proceed_thread_callback(struct thread_info *thread, void *arg)
Definition: mi-main.c:258
value_free
void value_free(struct value *val)
Definition: value.c:1608
trace_status_mi
void trace_status_mi(int on_stop)
Definition: tracepoint.c:1939
interrupt_thread_callback
static int interrupt_thread_callback(struct thread_info *thread, void *arg)
Definition: mi-main.c:344
type_print
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:358
find_thread_of_process
static int find_thread_of_process(struct thread_info *ti, void *p)
Definition: mi-main.c:491
frame_info
Definition: frame.c:85
INTERP_MI1
#define INTERP_MI1
Definition: interps.h:171
get_osdata
std::unique_ptr< osdata > get_osdata(const char *type)
Definition: osdata.c:160
INTERP_CONSOLE
#define INTERP_CONSOLE
Definition: interps.h:170
inferior::argc
int argc
Definition: inferior.h:355
get_traceframe_location
struct bp_location * get_traceframe_location(int *stepping_frame_p)
Definition: tracepoint.c:2771
mi_cmd_exec_next
void mi_cmd_exec_next(const char *command, char **argv, int argc)
Definition: mi-main.c:168
token
Definition: c-exp.c:4864
print_one_inferior_data::inferiors
const std::set< int > * inferiors
Definition: mi-main.c:645
tfind_number
Definition: tracepoint.h:386
get_no_prettyformat_print_options
void get_no_prettyformat_print_options(struct value_print_options *opts)
Definition: valprint.c:128
mi_cmd_execute
static void mi_cmd_execute(struct mi_parse *parse)
Definition: mi-main.c:2035
collection_list::wholly_collected
const std::vector< std::string > & wholly_collected()
Definition: tracepoint.h:274
sched_multi
int sched_multi
Definition: infrun.c:2229
iterate_over_inferiors
struct inferior * iterate_over_inferiors(int(*callback)(struct inferior *, void *), void *data)
Definition: inferior.c:346
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
get_other_inferior
static int get_other_inferior(struct inferior *inf, void *arg)
Definition: mi-main.c:1741
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
mi_cmd_trace_stop
void mi_cmd_trace_stop(const char *command, char **argv, int argc)
Definition: mi-main.c:2456
mi_cmd_trace_define_variable
void mi_cmd_trace_define_variable(const char *command, char **argv, int argc)
Definition: mi-main.c:2283
mi_out_new
mi_ui_out * mi_out_new(int mi_version)
Definition: mi-out.c:292
defs.h
collect_cores_data
Definition: mi-main.c:620
mi_cmd_target_detach
void mi_cmd_target_detach(const char *command, char **argv, int argc)
Definition: mi-main.c:502
INTERP_MI
#define INTERP_MI
Definition: interps.h:174
trace_state_variable::initial_value
LONGEST initial_value
Definition: tracepoint.h:59
mi_execute_async_cli_command
static void mi_execute_async_cli_command(const char *cli_command, char **argv, int argc)
Definition: mi-main.c:2153
DECODE_LINE_FUNFIRSTLINE
Definition: linespec.h:31
ULONGEST_MAX
#define ULONGEST_MAX
Definition: defs.h:493
scoped_value_mark
Definition: value.h:716
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
trace_state_variable::number
int number
Definition: tracepoint.h:56
mi_cmd_gdb_exit
void mi_cmd_gdb_exit(const char *command, char **argv, int argc)
Definition: mi-main.c:153
arm-linux.inf
inf
Definition: arm-linux.py:13
get_current_regcache
struct regcache * get_current_regcache(void)
Definition: regcache.c:446
builtin_type::builtin_int32
struct type * builtin_int32
Definition: gdbtypes.h:1538
mi_timestamp::wallclock
std::chrono::steady_clock::time_point wallclock
Definition: mi-parse.h:32
memory_read_result
Definition: target.h:269
progspace-and-thread.h
mi_cmd_data_list_register_names
void mi_cmd_data_list_register_names(const char *command, char **argv, int argc)
Definition: mi-main.c:883
arch-utils.h
mi_cmd_data_list_changed_registers
void mi_cmd_data_list_changed_registers(const char *command, char **argv, int argc)
Definition: mi-main.c:932
set_current_program_space
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:190
mi_interp::raw_stdout
struct ui_file * raw_stdout
Definition: mi-common.h:80
execute_command
void execute_command(const char *, int)
Definition: top.c:540
observer.h
current_context
static struct mi_parse * current_context
Definition: mi-main.c:85
inferior::pspace
struct program_space * pspace
Definition: inferior.h:349
current_trace_status
struct trace_status * current_trace_status(void)
Definition: tracepoint.c:189
event-loop.h
mi_parse::op
enum mi_command_type op
Definition: mi-parse.h:49
gdbarch_addressable_memory_unit_size
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:5030
make_scoped_restore
scoped_restore_tmpl< T > make_scoped_restore(T *var)
Definition: scoped_restore.h:105
gdbarch_num_pseudo_regs
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2057
target_get_trace_state_variable_value
#define target_get_trace_state_variable_value(tsv, val)
Definition: target.h:2165
rsp-low.h
evaluate_expression
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:144
mi_cmd_target_flash_erase
void mi_cmd_target_flash_erase(const char *command, char **argv, int argc)
Definition: mi-main.c:550
TRY
#define TRY
Definition: common-exceptions.h:246
thread_count
int thread_count(void)
Definition: thread.c:567
iterate_over_threads
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:551
mi-console.h
switch_to_thread
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1445
tfind_pc
Definition: tracepoint.h:387
collect_cores
static int collect_cores(struct thread_info *ti, void *xdata)
Definition: mi-main.c:627
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
name
const char *const name
Definition: aarch64-tdep.c:76
value_contents_eq
bool value_contents_eq(const struct value *val1, LONGEST offset1, const struct value *val2, LONGEST offset2, LONGEST length)
Definition: value.c:874
trace_save_ctf
void trace_save_ctf(const char *dirname, int target_does_save)
Definition: tracefile.c:372
fputstr_unfiltered
void fputstr_unfiltered(const char *str, int quoter, struct ui_file *stream)
Definition: utils.c:1261
thread_select
void thread_select(const char *tidstr, class thread_info *thr)
Definition: thread.c:1925
current_interpreter
struct interp * current_interpreter(void)
Definition: interps.c:459
gdb_optional.h
is_stopped
int is_stopped(ptid_t ptid)
Definition: thread.c:963
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
mi_getopt
int mi_getopt(const char *prefix, int argc, char **argv, const struct mi_opt *opts, int *oind, char **oarg)
Definition: mi-getopt.c:83
execution_direction
enum exec_direction_kind execution_direction
Definition: infrun.c:9088
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
value_print_options
Definition: valprint.h:25
mi_cmd_trace_save
void mi_cmd_trace_save(const char *command, char **argv, int argc)
Definition: mi-main.c:2394
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
mi_parse::command
char * command
Definition: mi-parse.h:50
current_target
struct target_ops current_target
mi_cmd_data_write_memory
void mi_cmd_data_write_memory(const char *command, char **argv, int argc)
Definition: mi-main.c:1520
print_ada_task_info
void print_ada_task_info(struct ui_out *uiout, char *taskno_str, struct inferior *inf)
Definition: ada-tasks.c:1031
collect_cores_data::cores
std::set< int > cores
Definition: mi-main.c:623
mi_parse
std::unique_ptr< struct mi_parse > mi_parse(const char *cmd, char **token)
Definition: mi-parse.c:237
find_thread_global_id
struct thread_info * find_thread_global_id(int global_id)
Definition: thread.c:488
delete_inferior
void delete_inferior(struct inferior *todel)
Definition: inferior.c:155
mem_range
Definition: memrange.h:27
target_ops
Definition: target.h:412
print_selected_thread_frame
void print_selected_thread_frame(struct ui_out *uiout, user_selected_what selection)
Definition: thread.c:1942
mi_print_timing_maybe
void mi_print_timing_maybe(struct ui_file *file)
Definition: mi-main.c:2258
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
find_relative_frame
struct frame_info * find_relative_frame(struct frame_info *, int *)
Definition: stack.c:2234
exec_reverse_continue
static void exec_reverse_continue(char **argv, int argc)
Definition: mi-main.c:319
ui_file::putstr
void void putstr(const char *str, int quoter)
Definition: ui-file.c:47
TARGET_OBJECT_MEMORY
Definition: target.h:139
mi_cmd_trace_list_variables
void mi_cmd_trace_list_variables(const char *command, char **argv, int argc)
Definition: mi-main.c:2309
regcache.h
output_register
static void output_register(struct frame_info *, int regnum, int format, int skip_unavailable)
Definition: mi-main.c:1125
mi_cmd_interpreter_exec
mi_cmd_argv_ftype mi_cmd_interpreter_exec
command_notifies_uscc_observer
static int command_notifies_uscc_observer(struct mi_parse *command)
Definition: mi-main.c:1912
scoped_restore_current_pspace_and_thread
Definition: progspace-and-thread.h:29
ui::prompt_state
enum prompt_state prompt_state
Definition: top.h:131
mi_parse::argc
int argc
Definition: mi-parse.h:56
any_live_thread_of_process
struct thread_info * any_live_thread_of_process(int pid)
Definition: thread.c:674
ptid_t
Definition: ptid.h:35
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
UNDEFINED_COMMAND_ERROR
Definition: common-exceptions.h:96
traceframe_available_memory
int traceframe_available_memory(std::vector< mem_range > *result, CORE_ADDR memaddr, ULONGEST len)
Definition: tracepoint.c:4057
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
expression
Definition: expression.h:78
frame.h
thread_info::global_num
int global_num
Definition: gdbthread.h:253
builtin_type::builtin_int16
struct type * builtin_int16
Definition: gdbtypes.h:1536
quit_force
void quit_force(int *exit_arg, int from_tty)
Definition: top.c:1566
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
gdbthread.h
current_uiout
#define current_uiout
Definition: ui-out.h:39
get_traceframe_number
int get_traceframe_number(void)
Definition: tracepoint.c:2976
inferior.h
list_available_thread_groups
static void list_available_thread_groups(const std::set< int > &ids, int recurse)
Definition: mi-main.c:713
TYPE_CODE_UNION
Definition: gdbtypes.h:107
get_osdata_column
const std::string * get_osdata_column(const osdata_item &item, const char *name)
Definition: osdata.c:185
scoped_restore_base
Definition: scoped_restore.h:24
infrun.h
inferior::exit_code
LONGEST exit_code
Definition: inferior.h:416
language.h
tracepoint.h
mi_cmd_data_evaluate_expression
void mi_cmd_data_evaluate_expression(const char *command, char **argv, int argc)
Definition: mi-main.c:1216
byte-vector.h
chrono
mi_cmd_exec_continue
void mi_cmd_exec_continue(const char *command, char **argv, int argc)
Definition: mi-main.c:335
collect_cores_data::pid
int pid
Definition: mi-main.c:622
mi_cmd_thread_select
void mi_cmd_thread_select(const char *command, char **argv, int argc)
Definition: mi-main.c:556
mi_cmd_data_write_memory_bytes
void mi_cmd_data_write_memory_bytes(const char *command, char **argv, int argc)
Definition: mi-main.c:1588
inf
Definition: gnu-nat.c:174
exec_direction_kind
exec_direction_kind
Definition: infrun.h:67
get_current_arch
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:798
string_file::clear
void clear()
Definition: ui-file.h:140
type
static const char * type
Definition: language.c:113
ui_out::field_stream
void field_stream(const char *fldname, string_file &stream)
Definition: ui-out.c:520
gdbarch_register_name
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2282
osdata.h
mi-parse.h
linespec.h
start_tracing
void start_tracing(const char *notes)
Definition: tracepoint.c:1572
ctf.h
mi_interp
Definition: mi-common.h:57
token
int token
Definition: m2-exp.c:2527
mi_debug_p
int mi_debug_p
Definition: mi-main.c:73
running_result_record_printed
int running_result_record_printed
Definition: mi-main.c:87
thread_info::ptid
ptid_t ptid
Definition: gdbthread.h:219
timestamp
static void timestamp(struct mi_timestamp *tv)
Definition: mi-main.c:2240
gdb_splay_tree.h
value_print_options::format
int format
Definition: valprint.h:64
validate_trace_state_variable_name
void validate_trace_state_variable_name(const char *name)
Definition: tracepoint.c:333
regnum
int regnum
Definition: aarch64-tdep.c:77
EXEC_REVERSE
Definition: infrun.h:70
run-time-clock.h
check_trace_running
void check_trace_running(struct trace_status *status)
Definition: tracepoint.c:2241
run
static procfs_run run
Definition: nto-procfs.c:55
ui_file::puts
virtual void puts(const char *str)
Definition: ui-file.h:63
traceframe_info
Definition: tracepoint.h:31
inferior::num
int num
Definition: inferior.h:324
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
set_mi_async_command
static void set_mi_async_command(const char *args, int from_tty, struct cmd_list_element *c)
Definition: mi-main.c:112
interps.h
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
mi_cmd_list_features
void mi_cmd_list_features(const char *command, char **argv, int argc)
Definition: mi-main.c:1679
inferior::has_exit_code
bool has_exit_code
Definition: inferior.h:415
extension.h
print_one_inferior_data
Definition: mi-main.c:642
add_alias_cmd
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *old, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:306
get_ext_lang_defn
const struct extension_language_defn * get_ext_lang_defn(enum extension_language lang)
Definition: extension.c:116
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
continue_1
void continue_1(int all_threads)
Definition: infcmd.c:775
value
Definition: value.c:169
ui_out
Definition: ui-out.h:77
exec_continue
static void exec_continue(char **argv, int argc)
Definition: mi-main.c:267
frame_save_as_regcache
std::unique_ptr< struct regcache > frame_save_as_regcache(struct frame_info *this_frame)
Definition: frame.c:1021
mi_cmd_trace_frame_collected
void mi_cmd_trace_frame_collected(const char *command, char **argv, int argc)
Definition: mi-main.c:2530
mi_parse::token
char * token
Definition: mi-parse.h:51
print_stack_frame
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:165
mi_parse::thread_group
int thread_group
Definition: mi-parse.h:58
symtab_and_line
Definition: symtab.h:1746
event-top.h
read_memory_robust
std::vector< memory_read_result > read_memory_robust(struct target_ops *ops, const ULONGEST offset, const LONGEST len)
Definition: target.c:1731
register_changed_p
static bool register_changed_p(int regnum, regcache *, regcache *)
Definition: mi-main.c:998
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
find_line_pc_range
int find_line_pc_range(struct symtab_and_line sal, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3483
mi_cmd_data_read_memory
void mi_cmd_data_read_memory(const char *command, char **argv, int argc)
Definition: mi-main.c:1260
mi_timestamp::utime
user_cpu_time_clock::time_point utime
Definition: mi-parse.h:33
value_entirely_available
int value_entirely_available(struct value *value)
Definition: value.c:374
mi_cmd_exec_interrupt
void mi_cmd_exec_interrupt(const char *command, char **argv, int argc)
Definition: mi-main.c:365
gdb::optional::emplace
T & emplace(Args &&... args)
Definition: gdb_optional.h:152
non_stop
int non_stop
Definition: infrun.c:204
current_language
const struct language_defn * current_language
Definition: language.c:81
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
tfind_1
void tfind_1(enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int from_tty)
Definition: tracepoint.c:2105
ALL_NON_EXITED_THREADS
#define ALL_NON_EXITED_THREADS(T)
Definition: gdbthread.h:490
mi_cmd_exec_next_instruction
void mi_cmd_exec_next_instruction(const char *command, char **argv, int argc)
Definition: mi-main.c:178
gdb::optional
Definition: gdb_optional.h:51
proceed
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
Definition: infrun.c:2977
osdata_item
Definition: osdata.h:35
gdbcore.h
inf::pid
pid_t pid
Definition: gnu-nat.c:187
update_thread_list
void update_thread_list(void)
Definition: thread.c:2000
mi_cmd_ada_task_info
void mi_cmd_ada_task_info(const char *command, char **argv, int argc)
Definition: mi-main.c:2465
PRINT_NO_VALUES
Definition: mi-cmds.h:26
parse_and_eval_address
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:101
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
value_of_register
struct value * value_of_register(int regnum, struct frame_info *frame)
Definition: findvar.c:263
clear_proceed_status
void clear_proceed_status(int step)
Definition: infrun.c:2860
mi_cmd_exec_jump
void mi_cmd_exec_jump(const char *args, char **argv, int argc)
Definition: mi-main.c:237
INTERP_MI3
#define INTERP_MI3
Definition: interps.h:173
ui_out::field_int
void field_int(const char *fldname, int value)
Definition: ui-out.c:486
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
prepare_execute_command
scoped_value_mark prepare_execute_command()
Definition: top.c:440
mi_cmd_exec_step_instruction
void mi_cmd_exec_step_instruction(const char *command, char **argv, int argc)
Definition: mi-main.c:198
trace_state_variable::value
LONGEST value
Definition: tracepoint.h:67
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
trace_state_variable
Definition: tracepoint.h:49
print_variable_or_computed
static void print_variable_or_computed(const char *expression, enum print_values values)
Definition: mi-main.c:2476
program_space::pspace_exec_filename
char * pspace_exec_filename
Definition: progspace.h:155
command_interp
struct interp * command_interp(void)
Definition: interps.c:321
decode_line_with_current_source
std::vector< symtab_and_line > decode_line_with_current_source(const char *string, int flags)
Definition: linespec.c:3371
offset
int offset
Definition: agent.c:65
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
add_setshow_boolean_cmd
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:569
tvariables_info_1
void tvariables_info_1(void)
Definition: tracepoint.c:438
print_thread_info
void print_thread_info(struct ui_out *uiout, char *requested_threads, int pid)
Definition: thread.c:1367
buffer
Definition: buffer.h:23
target_ops::to_can_async_p
int(* to_can_async_p)(struct target_ops *) TARGET_DEFAULT_RETURN(0)
Definition: target.h:666
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
_initialize_mi_main
void _initialize_mi_main(void)
Definition: mi-main.c:2718
captured_mi_execute_command
static void captured_mi_execute_command(struct ui_out *uiout, struct mi_parse *context)
Definition: mi-main.c:1797
create_trace_state_variable
struct trace_state_variable * create_trace_state_variable(const char *name)
Definition: tracepoint.c:268
show_mi_async_command
static void show_mi_async_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: mi-main.c:125
target.h
find_run_target
struct target_ops * find_run_target(void)
Definition: target.c:2567
value.h
add_inferior_with_spaces
struct inferior * add_inferior_with_spaces(void)
Definition: inferior.c:763
tfind_tp
Definition: tracepoint.h:388
find_inferior_id
struct inferior * find_inferior_id(int num)
Definition: inferior.c:290
gdbarch::data
void ** data
Definition: gdbarch.c:148
target_core_of_thread
int target_core_of_thread(ptid_t ptid)
Definition: target.c:3458
mi_cmd_exec_step
void mi_cmd_exec_step(const char *command, char **argv, int argc)
Definition: mi-main.c:188
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
gdb::byte_vector
gdb::def_vector< gdb_byte > byte_vector
Definition: byte-vector.h:58
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
val_print
void val_print(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1015
is_exited
int is_exited(ptid_t ptid)
Definition: thread.c:969
mi_cmd_enable_timings
void mi_cmd_enable_timings(const char *command, char **argv, int argc)
Definition: mi-main.c:1656
print_scalar_formatted
void print_scalar_formatted(const gdb_byte *, struct type *, const struct value_print_options *, int, struct ui_file *)
Definition: printcmd.c:351
parse_and_eval
struct value * parse_and_eval(const char *exp)
Definition: eval.c:119
trace_save_tfile
void trace_save_tfile(const char *filename, int target_does_save)
Definition: tracefile.c:358
mi_cmd_thread_info
void mi_cmd_thread_info(const char *command, char **argv, int argc)
Definition: mi-main.c:612
gdb_exception
Definition: common-exceptions.h:111
mi_cmd_trace_find
void mi_cmd_trace_find(const char *command, char **argv, int argc)
Definition: mi-main.c:2318
field_name
static PyObject * field_name(struct type *type, int field)
Definition: py-type.c:267
parse_expression
expression_up parse_expression(const char *)
Definition: parse.c:1237
release_value
void release_value(struct value *val)
Definition: value.c:1693
encode_actions
void encode_actions(struct bp_location *tloc, struct collection_list *tracepoint_list, struct collection_list *stepping_list)
Definition: tracepoint.c:1477
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
regcache
Definition: regcache.h:232
class_run
Definition: command.h:41
gdb_exception::message
const char * message
Definition: common-exceptions.h:115
top_level_interpreter
struct interp * top_level_interpreter(void)
Definition: interps.c:449
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
run_one_inferior
static int run_one_inferior(struct inferior *inf, void *arg)
Definition: mi-main.c:403
find_trace_state_variable
struct trace_state_variable * find_trace_state_variable(const char *name)
Definition: tracepoint.c:281
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
collection_list
Definition: tracepoint.h:243
builtin_type::builtin_int64
struct type * builtin_int64
Definition: gdbtypes.h:1540
PRINT_ALL_VALUES
Definition: mi-cmds.h:27
mi_async_1
static int mi_async_1
Definition: mi-main.c:109
CLI_COMMAND
Definition: mi-parse.h:39
PRINT_SIMPLE_VALUES
Definition: mi-cmds.h:28
bpstat_do_actions
void bpstat_do_actions(void)
Definition: breakpoint.c:4494
target_read
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1562
mi_cmd_exec_finish
void mi_cmd_exec_finish(const char *command, char **argv, int argc)
Definition: mi-main.c:208
evaluate_type
struct value * evaluate_type(struct expression *exp)
Definition: eval.c:155
find_trace_state_variable_by_number
struct trace_state_variable * find_trace_state_variable_by_number(int number)
Definition: tracepoint.c:297
mi_execute_cli_command
static void mi_execute_cli_command(const char *cmd, int args_p, const char *args)
Definition: mi-main.c:2136
USER_SELECTED_THREAD
Definition: defs.h:699
symtab_and_line::line
int line
Definition: symtab.h:1757
ui_file::putc
int putc(int c)
Definition: ui-file.c:59
LOC_AND_ADDRESS
Definition: frame.h:670
gdb.argv
argv
Definition: __init__.py:63
mi_cmd_exec_return
void mi_cmd_exec_return(const char *command, char **argv, int argc)
Definition: mi-main.c:218
gdb_flush
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:93
current_thread
static windows_thread_info * current_thread
Definition: windows-nat.c:240
language_unknown
Definition: defs.h:205
write_memory_with_notification
void write_memory_with_notification(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:407
is_running
int is_running(ptid_t ptid)
Definition: thread.c:975
mi_async_p
int mi_async_p(void)
Definition: mi-main.c:138
mi_print_exception
static void mi_print_exception(const char *token, struct gdb_exception exception)
Definition: mi-main.c:1886
mi_out_rewind
void mi_out_rewind(ui_out *uiout)
Definition: mi-out.c:323
builtin_type::builtin_int8
struct type * builtin_int8
Definition: gdbtypes.h:1534
valprint.h
mi_out_put
void mi_out_put(ui_out *uiout, struct ui_file *stream)
Definition: mi-out.c:317
run_time_clock::now
static time_point now() noexcept
Definition: run-time-clock.c:28
mi_parse::all
int all
Definition: mi-parse.h:57
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
mi_cmd_data_list_register_values
void mi_cmd_data_list_register_values(const char *command, char **argv, int argc)
Definition: mi-main.c:1035
current_interp_named_p
int current_interp_named_p(const char *interp_name)
Definition: interps.c:299
gdbcmd.h
mi_cmd_remove_inferior
void mi_cmd_remove_inferior(const char *command, char **argv, int argc)
Definition: mi-main.c:1750
has_stack_frames
int has_stack_frames(void)
Definition: frame.c:1609
mi_parse_print_values
enum print_values mi_parse_print_values(const char *name)
Definition: mi-parse.c:387
mi-getopt.h
mi_execute_command
void mi_execute_command(const char *cmd, int from_tty)
Definition: mi-main.c:1937
any_thread_of_process
struct thread_info * any_thread_of_process(int pid)
Definition: thread.c:656
store_signed_integer
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
Definition: defs.h:597
mi_cmd_data_read_memory_bytes
void mi_cmd_data_read_memory_bytes(const char *command, char **argv, int argc)
Definition: mi-main.c:1438
thread_info
Definition: gdbthread.h:205
error
void error(const char *fmt,...)
Definition: errors.c:38
mi_async
static int mi_async
Definition: mi-main.c:105
trace_state_variable::value_known
int value_known
Definition: tracepoint.h:64
mi_cmd_exec_run
void mi_cmd_exec_run(const char *command, char **argv, int argc)
Definition: mi-main.c:435
print_one_inferior
static int print_one_inferior(struct inferior *inferior, void *xdata)
Definition: mi-main.c:649
mi_timestamp
Definition: mi-parse.h:30
mi_opt
Definition: mi-getopt.h:26
print_values
print_values
Definition: mi-cmds.h:25
mi_parse::args
char * args
Definition: mi-parse.h:54
prepare_execution_command
void prepare_execution_command(struct target_ops *target, int background)
Definition: infcmd.c:529
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
ext_lang_initialized_p
int ext_lang_initialized_p(const struct extension_language_defn *extlang)
Definition: extension.c:179
mi_cmd_data_write_register_values
void mi_cmd_data_write_register_values(const char *command, char **argv, int argc)
Definition: mi-main.c:1159
set_current_inferior
void set_current_inferior(struct inferior *inf)
Definition: inferior.c:64
LONGEST
long long LONGEST
Definition: common-types.h:52
target_ops::beneath
struct target_ops * beneath
Definition: target.h:414
mi-out.h
scoped_restore_current_thread
Definition: gdbthread.h:600
output_cores
static void output_cores(struct ui_out *uiout, const char *field_name, const char *xcores)
Definition: mi-main.c:702
bp_location
Definition: breakpoint.h:315
ui_out::field_fmt
void field_fmt(const char *fldname, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: ui-out.c:557
ui-out.h
tfind_range
Definition: tracepoint.h:389
print_diff_now
static void print_diff_now(struct ui_file *file, struct mi_timestamp *start)
Definition: mi-main.c:2249
gdb_stdout
#define gdb_stdout
Definition: utils.h:340
FROM_TTY
Definition: mi-main.c:70
PROMPT_NEEDED
Definition: top.h:41
trace_state_variable::name
const char * name
Definition: tracepoint.h:53
string_file
Definition: ui-file.h:106
mi_timestamp::stime
system_cpu_time_clock::time_point stime
Definition: mi-parse.h:34