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