Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / inferior.c
CommitLineData
5796c8dc
SS
1/* Multi-process control for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 2008-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
cf7f2e2d 21#include "exec.h"
5796c8dc
SS
22#include "inferior.h"
23#include "target.h"
24#include "command.h"
ef5ccd6c 25#include "completer.h"
5796c8dc
SS
26#include "gdbcmd.h"
27#include "gdbthread.h"
28#include "ui-out.h"
29#include "observer.h"
30#include "gdbthread.h"
cf7f2e2d
JM
31#include "gdbcore.h"
32#include "symfile.h"
33#include "environ.h"
c50c785c 34#include "cli/cli-utils.h"
a45ae5f8 35#include "continuations.h"
ef5ccd6c
JM
36#include "arch-utils.h"
37#include "target-descriptions.h"
5796c8dc
SS
38
39void _initialize_inferiors (void);
40
ef5ccd6c
JM
41/* Keep a registry of per-inferior data-pointers required by other GDB
42 modules. */
43
44DEFINE_REGISTRY (inferior, REGISTRY_ACCESS_FIELD)
cf7f2e2d
JM
45
46struct inferior *inferior_list = NULL;
5796c8dc
SS
47static int highest_inferior_num;
48
49/* Print notices on inferior events (attach, detach, etc.), set with
50 `set print inferior-events'. */
51static int print_inferior_events = 0;
52
cf7f2e2d
JM
53/* The Current Inferior. */
54static struct inferior *current_inferior_ = NULL;
55
5796c8dc
SS
56struct inferior*
57current_inferior (void)
58{
cf7f2e2d
JM
59 return current_inferior_;
60}
61
62void
63set_current_inferior (struct inferior *inf)
64{
65 /* There's always an inferior. */
66 gdb_assert (inf != NULL);
67
68 current_inferior_ = inf;
69}
70
71/* A cleanups callback, helper for save_current_program_space
72 below. */
73
74static void
75restore_inferior (void *arg)
76{
77 struct inferior *saved_inferior = arg;
78
79 set_current_inferior (saved_inferior);
80}
81
82/* Save the current program space so that it may be restored by a later
83 call to do_cleanups. Returns the struct cleanup pointer needed for
84 later doing the cleanup. */
85
86struct cleanup *
87save_current_inferior (void)
88{
89 struct cleanup *old_chain = make_cleanup (restore_inferior,
90 current_inferior_);
91
92 return old_chain;
5796c8dc
SS
93}
94
95static void
96free_inferior (struct inferior *inf)
97{
98 discard_all_inferior_continuations (inf);
cf7f2e2d
JM
99 inferior_free_data (inf);
100 xfree (inf->args);
101 xfree (inf->terminal);
102 free_environ (inf->environment);
ef5ccd6c 103 target_desc_info_free (inf->tdesc_info);
5796c8dc
SS
104 xfree (inf->private);
105 xfree (inf);
106}
107
108void
109init_inferior_list (void)
110{
111 struct inferior *inf, *infnext;
112
113 highest_inferior_num = 0;
114 if (!inferior_list)
115 return;
116
117 for (inf = inferior_list; inf; inf = infnext)
118 {
119 infnext = inf->next;
120 free_inferior (inf);
121 }
122
123 inferior_list = NULL;
124}
125
126struct inferior *
127add_inferior_silent (int pid)
128{
129 struct inferior *inf;
130
131 inf = xmalloc (sizeof (*inf));
132 memset (inf, 0, sizeof (*inf));
133 inf->pid = pid;
134
c50c785c 135 inf->control.stop_soon = NO_STOP_QUIETLY;
5796c8dc
SS
136
137 inf->num = ++highest_inferior_num;
138 inf->next = inferior_list;
139 inferior_list = inf;
140
cf7f2e2d
JM
141 inf->environment = make_environ ();
142 init_environ (inf->environment);
143
144 inferior_alloc_data (inf);
145
146 observer_notify_inferior_added (inf);
147
148 if (pid != 0)
149 inferior_appeared (inf, pid);
5796c8dc
SS
150
151 return inf;
152}
153
154struct inferior *
155add_inferior (int pid)
156{
157 struct inferior *inf = add_inferior_silent (pid);
158
159 if (print_inferior_events)
160 printf_unfiltered (_("[New inferior %d]\n"), pid);
161
162 return inf;
163}
164
165struct delete_thread_of_inferior_arg
166{
167 int pid;
168 int silent;
169};
170
171static int
172delete_thread_of_inferior (struct thread_info *tp, void *data)
173{
174 struct delete_thread_of_inferior_arg *arg = data;
175
176 if (ptid_get_pid (tp->ptid) == arg->pid)
177 {
178 if (arg->silent)
179 delete_thread_silent (tp->ptid);
180 else
181 delete_thread (tp->ptid);
182 }
183
184 return 0;
185}
186
187/* If SILENT then be quiet -- don't announce a inferior death, or the
188 exit of its threads. */
cf7f2e2d
JM
189
190void
191delete_inferior_1 (struct inferior *todel, int silent)
5796c8dc
SS
192{
193 struct inferior *inf, *infprev;
cf7f2e2d 194 struct delete_thread_of_inferior_arg arg;
5796c8dc
SS
195
196 infprev = NULL;
197
198 for (inf = inferior_list; inf; infprev = inf, inf = inf->next)
cf7f2e2d 199 if (inf == todel)
5796c8dc
SS
200 break;
201
202 if (!inf)
203 return;
204
cf7f2e2d 205 arg.pid = inf->pid;
5796c8dc
SS
206 arg.silent = silent;
207
208 iterate_over_threads (delete_thread_of_inferior, &arg);
209
5796c8dc
SS
210 if (infprev)
211 infprev->next = inf->next;
212 else
213 inferior_list = inf->next;
214
cf7f2e2d
JM
215 observer_notify_inferior_removed (inf);
216
5796c8dc
SS
217 free_inferior (inf);
218}
219
220void
221delete_inferior (int pid)
222{
cf7f2e2d
JM
223 struct inferior *inf = find_inferior_pid (pid);
224
225 delete_inferior_1 (inf, 0);
5796c8dc
SS
226
227 if (print_inferior_events)
228 printf_unfiltered (_("[Inferior %d exited]\n"), pid);
229}
230
231void
232delete_inferior_silent (int pid)
233{
cf7f2e2d
JM
234 struct inferior *inf = find_inferior_pid (pid);
235
236 delete_inferior_1 (inf, 1);
237}
238
239
240/* If SILENT then be quiet -- don't announce a inferior exit, or the
241 exit of its threads. */
242
243static void
244exit_inferior_1 (struct inferior *inftoex, int silent)
245{
246 struct inferior *inf;
247 struct delete_thread_of_inferior_arg arg;
248
249 for (inf = inferior_list; inf; inf = inf->next)
250 if (inf == inftoex)
251 break;
252
253 if (!inf)
254 return;
255
256 arg.pid = inf->pid;
257 arg.silent = silent;
258
259 iterate_over_threads (delete_thread_of_inferior, &arg);
260
261 /* Notify the observers before removing the inferior from the list,
262 so that the observers have a chance to look it up. */
263 observer_notify_inferior_exit (inf);
264
265 inf->pid = 0;
ef5ccd6c 266 inf->fake_pid_p = 0;
cf7f2e2d
JM
267 if (inf->vfork_parent != NULL)
268 {
269 inf->vfork_parent->vfork_child = NULL;
270 inf->vfork_parent = NULL;
271 }
ef5ccd6c
JM
272 if (inf->vfork_child != NULL)
273 {
274 inf->vfork_child->vfork_parent = NULL;
275 inf->vfork_child = NULL;
276 }
c50c785c
JM
277
278 inf->has_exit_code = 0;
279 inf->exit_code = 0;
ef5ccd6c 280 inf->pending_detach = 0;
cf7f2e2d
JM
281}
282
283void
284exit_inferior (int pid)
285{
286 struct inferior *inf = find_inferior_pid (pid);
287
288 exit_inferior_1 (inf, 0);
289
290 if (print_inferior_events)
291 printf_unfiltered (_("[Inferior %d exited]\n"), pid);
292}
293
294void
295exit_inferior_silent (int pid)
296{
297 struct inferior *inf = find_inferior_pid (pid);
298
299 exit_inferior_1 (inf, 1);
300}
301
302void
303exit_inferior_num_silent (int num)
304{
305 struct inferior *inf = find_inferior_id (num);
306
307 exit_inferior_1 (inf, 1);
5796c8dc
SS
308}
309
310void
311detach_inferior (int pid)
312{
cf7f2e2d
JM
313 struct inferior *inf = find_inferior_pid (pid);
314
315 exit_inferior_1 (inf, 1);
5796c8dc
SS
316
317 if (print_inferior_events)
318 printf_unfiltered (_("[Inferior %d detached]\n"), pid);
319}
320
cf7f2e2d
JM
321void
322inferior_appeared (struct inferior *inf, int pid)
323{
324 inf->pid = pid;
325
326 observer_notify_inferior_appeared (inf);
327}
328
5796c8dc
SS
329void
330discard_all_inferiors (void)
331{
cf7f2e2d 332 struct inferior *inf;
5796c8dc 333
cf7f2e2d 334 for (inf = inferior_list; inf; inf = inf->next)
5796c8dc 335 {
cf7f2e2d
JM
336 if (inf->pid != 0)
337 exit_inferior_silent (inf->pid);
5796c8dc
SS
338 }
339}
340
cf7f2e2d 341struct inferior *
5796c8dc
SS
342find_inferior_id (int num)
343{
344 struct inferior *inf;
345
346 for (inf = inferior_list; inf; inf = inf->next)
347 if (inf->num == num)
348 return inf;
349
350 return NULL;
351}
352
353struct inferior *
354find_inferior_pid (int pid)
355{
356 struct inferior *inf;
357
cf7f2e2d
JM
358 /* Looking for inferior pid == 0 is always wrong, and indicative of
359 a bug somewhere else. There may be more than one with pid == 0,
360 for instance. */
361 gdb_assert (pid != 0);
362
5796c8dc
SS
363 for (inf = inferior_list; inf; inf = inf->next)
364 if (inf->pid == pid)
365 return inf;
366
367 return NULL;
368}
369
cf7f2e2d
JM
370/* Find an inferior bound to PSPACE. */
371
372struct inferior *
373find_inferior_for_program_space (struct program_space *pspace)
374{
375 struct inferior *inf;
376
377 for (inf = inferior_list; inf != NULL; inf = inf->next)
378 {
379 if (inf->pspace == pspace)
380 return inf;
381 }
382
383 return NULL;
384}
385
5796c8dc
SS
386struct inferior *
387iterate_over_inferiors (int (*callback) (struct inferior *, void *),
388 void *data)
389{
390 struct inferior *inf, *infnext;
391
392 for (inf = inferior_list; inf; inf = infnext)
393 {
394 infnext = inf->next;
395 if ((*callback) (inf, data))
396 return inf;
397 }
398
399 return NULL;
400}
401
402int
403valid_gdb_inferior_id (int num)
404{
405 struct inferior *inf;
406
407 for (inf = inferior_list; inf; inf = inf->next)
408 if (inf->num == num)
409 return 1;
410
411 return 0;
412}
413
414int
415pid_to_gdb_inferior_id (int pid)
416{
417 struct inferior *inf;
418
419 for (inf = inferior_list; inf; inf = inf->next)
420 if (inf->pid == pid)
421 return inf->num;
422
423 return 0;
424}
425
426int
427gdb_inferior_id_to_pid (int num)
428{
429 struct inferior *inferior = find_inferior_id (num);
430 if (inferior)
431 return inferior->pid;
432 else
433 return -1;
434}
435
436int
437in_inferior_list (int pid)
438{
439 struct inferior *inf;
440
441 for (inf = inferior_list; inf; inf = inf->next)
442 if (inf->pid == pid)
443 return 1;
444
445 return 0;
446}
447
448int
449have_inferiors (void)
450{
cf7f2e2d
JM
451 struct inferior *inf;
452
453 for (inf = inferior_list; inf; inf = inf->next)
454 if (inf->pid != 0)
455 return 1;
456
457 return 0;
5796c8dc
SS
458}
459
460int
461have_live_inferiors (void)
462{
c50c785c 463 struct inferior *inf;
cf7f2e2d 464
c50c785c
JM
465 for (inf = inferior_list; inf; inf = inf->next)
466 if (inf->pid != 0)
467 {
468 struct thread_info *tp;
469
470 tp = any_thread_of_process (inf->pid);
471 if (tp && target_has_execution_1 (tp->ptid))
472 break;
473 }
474
475 return inf != NULL;
cf7f2e2d
JM
476}
477
478/* Prune away automatically added program spaces that aren't required
479 anymore. */
480
481void
482prune_inferiors (void)
483{
484 struct inferior *ss, **ss_link;
485 struct inferior *current = current_inferior ();
486
487 ss = inferior_list;
488 ss_link = &inferior_list;
489 while (ss)
490 {
491 if (ss == current
492 || !ss->removable
493 || ss->pid != 0)
494 {
495 ss_link = &ss->next;
496 ss = *ss_link;
497 continue;
498 }
499
500 *ss_link = ss->next;
501 delete_inferior_1 (ss, 1);
502 ss = *ss_link;
503 }
504
505 prune_program_spaces ();
506}
507
508/* Simply returns the count of inferiors. */
509
510int
511number_of_inferiors (void)
512{
513 struct inferior *inf;
514 int count = 0;
515
516 for (inf = inferior_list; inf != NULL; inf = inf->next)
517 count++;
518
519 return count;
5796c8dc
SS
520}
521
ef5ccd6c
JM
522/* Converts an inferior process id to a string. Like
523 target_pid_to_str, but special cases the null process. */
524
525static char *
526inferior_pid_to_str (int pid)
527{
528 if (pid != 0)
529 return target_pid_to_str (pid_to_ptid (pid));
530 else
531 return _("<null>");
532}
533
5796c8dc
SS
534/* Prints the list of inferiors and their details on UIOUT. This is a
535 version of 'info_inferior_command' suitable for use from MI.
536
c50c785c
JM
537 If REQUESTED_INFERIORS is not NULL, it's a list of GDB ids of the
538 inferiors that should be printed. Otherwise, all inferiors are
539 printed. */
540
541static void
542print_inferior (struct ui_out *uiout, char *requested_inferiors)
5796c8dc
SS
543{
544 struct inferior *inf;
545 struct cleanup *old_chain;
546 int inf_count = 0;
547
548 /* Compute number of inferiors we will print. */
549 for (inf = inferior_list; inf; inf = inf->next)
550 {
c50c785c 551 if (!number_is_in_list (requested_inferiors, inf->num))
5796c8dc
SS
552 continue;
553
554 ++inf_count;
555 }
556
557 if (inf_count == 0)
558 {
559 ui_out_message (uiout, 0, "No inferiors.\n");
560 return;
561 }
562
cf7f2e2d 563 old_chain = make_cleanup_ui_out_table_begin_end (uiout, 4, inf_count,
5796c8dc
SS
564 "inferiors");
565 ui_out_table_header (uiout, 1, ui_left, "current", "");
566 ui_out_table_header (uiout, 4, ui_left, "number", "Num");
567 ui_out_table_header (uiout, 17, ui_left, "target-id", "Description");
cf7f2e2d 568 ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
5796c8dc 569
cf7f2e2d 570 ui_out_table_body (uiout);
5796c8dc
SS
571 for (inf = inferior_list; inf; inf = inf->next)
572 {
573 struct cleanup *chain2;
574
c50c785c 575 if (!number_is_in_list (requested_inferiors, inf->num))
5796c8dc
SS
576 continue;
577
578 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
579
cf7f2e2d 580 if (inf == current_inferior ())
5796c8dc
SS
581 ui_out_field_string (uiout, "current", "*");
582 else
583 ui_out_field_skip (uiout, "current");
584
585 ui_out_field_int (uiout, "number", inf->num);
cf7f2e2d 586
ef5ccd6c
JM
587 ui_out_field_string (uiout, "target-id",
588 inferior_pid_to_str (inf->pid));
cf7f2e2d 589
ef5ccd6c
JM
590 if (inf->pspace->pspace_exec_filename != NULL)
591 ui_out_field_string (uiout, "exec", inf->pspace->pspace_exec_filename);
cf7f2e2d
JM
592 else
593 ui_out_field_skip (uiout, "exec");
594
595 /* Print extra info that isn't really fit to always present in
596 tabular form. Currently we print the vfork parent/child
597 relationships, if any. */
598 if (inf->vfork_parent)
599 {
600 ui_out_text (uiout, _("\n\tis vfork child of inferior "));
601 ui_out_field_int (uiout, "vfork-parent", inf->vfork_parent->num);
602 }
603 if (inf->vfork_child)
604 {
605 ui_out_text (uiout, _("\n\tis vfork parent of inferior "));
606 ui_out_field_int (uiout, "vfork-child", inf->vfork_child->num);
607 }
5796c8dc
SS
608
609 ui_out_text (uiout, "\n");
610 do_cleanups (chain2);
611 }
612
5796c8dc
SS
613 do_cleanups (old_chain);
614}
615
616static void
617detach_inferior_command (char *args, int from_tty)
618{
619 int num, pid;
620 struct thread_info *tp;
c50c785c 621 struct get_number_or_range_state state;
5796c8dc
SS
622
623 if (!args || !*args)
c50c785c 624 error (_("Requires argument (inferior id(s) to detach)"));
5796c8dc 625
c50c785c
JM
626 init_number_or_range (&state, args);
627 while (!state.finished)
628 {
629 num = get_number_or_range (&state);
5796c8dc 630
c50c785c
JM
631 if (!valid_gdb_inferior_id (num))
632 {
633 warning (_("Inferior ID %d not known."), num);
634 continue;
635 }
5796c8dc 636
c50c785c 637 pid = gdb_inferior_id_to_pid (num);
5796c8dc 638
c50c785c
JM
639 tp = any_thread_of_process (pid);
640 if (!tp)
641 {
642 warning (_("Inferior ID %d has no threads."), num);
643 continue;
644 }
5796c8dc 645
c50c785c 646 switch_to_thread (tp->ptid);
5796c8dc 647
c50c785c
JM
648 detach_command (NULL, from_tty);
649 }
5796c8dc
SS
650}
651
652static void
653kill_inferior_command (char *args, int from_tty)
654{
655 int num, pid;
656 struct thread_info *tp;
c50c785c 657 struct get_number_or_range_state state;
5796c8dc
SS
658
659 if (!args || !*args)
c50c785c 660 error (_("Requires argument (inferior id(s) to kill)"));
5796c8dc 661
c50c785c
JM
662 init_number_or_range (&state, args);
663 while (!state.finished)
664 {
665 num = get_number_or_range (&state);
5796c8dc 666
c50c785c
JM
667 if (!valid_gdb_inferior_id (num))
668 {
669 warning (_("Inferior ID %d not known."), num);
670 continue;
671 }
5796c8dc 672
c50c785c 673 pid = gdb_inferior_id_to_pid (num);
5796c8dc 674
c50c785c
JM
675 tp = any_thread_of_process (pid);
676 if (!tp)
677 {
678 warning (_("Inferior ID %d has no threads."), num);
679 continue;
680 }
5796c8dc 681
c50c785c 682 switch_to_thread (tp->ptid);
5796c8dc 683
c50c785c
JM
684 target_kill ();
685 }
5796c8dc
SS
686
687 bfd_cache_close_all ();
688}
689
690static void
691inferior_command (char *args, int from_tty)
692{
cf7f2e2d
JM
693 struct inferior *inf;
694 int num;
5796c8dc
SS
695
696 num = parse_and_eval_long (args);
697
cf7f2e2d
JM
698 inf = find_inferior_id (num);
699 if (inf == NULL)
5796c8dc
SS
700 error (_("Inferior ID %d not known."), num);
701
cf7f2e2d
JM
702 printf_filtered (_("[Switching to inferior %d [%s] (%s)]\n"),
703 inf->num,
ef5ccd6c
JM
704 inferior_pid_to_str (inf->pid),
705 (inf->pspace->pspace_exec_filename != NULL
706 ? inf->pspace->pspace_exec_filename
cf7f2e2d 707 : _("<noexec>")));
5796c8dc 708
cf7f2e2d 709 if (inf->pid != 0)
5796c8dc 710 {
cf7f2e2d
JM
711 if (inf->pid != ptid_get_pid (inferior_ptid))
712 {
713 struct thread_info *tp;
714
715 tp = any_thread_of_process (inf->pid);
716 if (!tp)
717 error (_("Inferior has no threads."));
5796c8dc 718
cf7f2e2d
JM
719 switch_to_thread (tp->ptid);
720 }
5796c8dc 721
cf7f2e2d
JM
722 printf_filtered (_("[Switching to thread %d (%s)] "),
723 pid_to_thread_id (inferior_ptid),
724 target_pid_to_str (inferior_ptid));
5796c8dc 725 }
cf7f2e2d
JM
726 else
727 {
728 struct inferior *inf;
5796c8dc 729
cf7f2e2d
JM
730 inf = find_inferior_id (num);
731 set_current_inferior (inf);
732 switch_to_thread (null_ptid);
733 set_current_program_space (inf->pspace);
734 }
5796c8dc 735
cf7f2e2d 736 if (inf->pid != 0 && is_running (inferior_ptid))
a45ae5f8 737 ui_out_text (current_uiout, "(running)\n");
cf7f2e2d 738 else if (inf->pid != 0)
5796c8dc 739 {
a45ae5f8 740 ui_out_text (current_uiout, "\n");
5796c8dc
SS
741 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
742 }
743}
744
745/* Print information about currently known inferiors. */
746
747static void
748info_inferiors_command (char *args, int from_tty)
749{
a45ae5f8 750 print_inferior (current_uiout, args);
5796c8dc
SS
751}
752
cf7f2e2d
JM
753/* remove-inferior ID */
754
ef5ccd6c 755static void
cf7f2e2d
JM
756remove_inferior_command (char *args, int from_tty)
757{
758 int num;
759 struct inferior *inf;
c50c785c 760 struct get_number_or_range_state state;
cf7f2e2d 761
c50c785c
JM
762 if (args == NULL || *args == '\0')
763 error (_("Requires an argument (inferior id(s) to remove)"));
cf7f2e2d 764
c50c785c
JM
765 init_number_or_range (&state, args);
766 while (!state.finished)
767 {
768 num = get_number_or_range (&state);
769 inf = find_inferior_id (num);
770
771 if (inf == NULL)
772 {
773 warning (_("Inferior ID %d not known."), num);
774 continue;
775 }
cf7f2e2d 776
c50c785c
JM
777 if (inf == current_inferior ())
778 {
779 warning (_("Can not remove current symbol inferior %d."), num);
780 continue;
781 }
782
783 if (inf->pid != 0)
784 {
785 warning (_("Can not remove active inferior %d."), num);
786 continue;
787 }
cf7f2e2d 788
c50c785c
JM
789 delete_inferior_1 (inf, 1);
790 }
cf7f2e2d
JM
791}
792
793struct inferior *
794add_inferior_with_spaces (void)
795{
796 struct address_space *aspace;
797 struct program_space *pspace;
798 struct inferior *inf;
ef5ccd6c 799 struct gdbarch_info info;
cf7f2e2d
JM
800
801 /* If all inferiors share an address space on this system, this
802 doesn't really return a new address space; otherwise, it
803 really does. */
804 aspace = maybe_new_address_space ();
805 pspace = add_program_space (aspace);
806 inf = add_inferior (0);
807 inf->pspace = pspace;
808 inf->aspace = pspace->aspace;
809
ef5ccd6c
JM
810 /* Setup the inferior's initial arch, based on information obtained
811 from the global "set ..." options. */
812 gdbarch_info_init (&info);
813 inf->gdbarch = gdbarch_find_by_info (info);
814 /* The "set ..." options reject invalid settings, so we should
815 always have a valid arch by now. */
816 gdb_assert (inf->gdbarch != NULL);
817
cf7f2e2d
JM
818 return inf;
819}
820
821/* add-inferior [-copies N] [-exec FILENAME] */
822
ef5ccd6c 823static void
cf7f2e2d
JM
824add_inferior_command (char *args, int from_tty)
825{
826 int i, copies = 1;
827 char *exec = NULL;
828 char **argv;
829 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
830
831 if (args)
832 {
833 argv = gdb_buildargv (args);
834 make_cleanup_freeargv (argv);
835
836 for (; *argv != NULL; argv++)
837 {
838 if (**argv == '-')
839 {
840 if (strcmp (*argv, "-copies") == 0)
841 {
842 ++argv;
843 if (!*argv)
844 error (_("No argument to -copies"));
845 copies = parse_and_eval_long (*argv);
846 }
847 else if (strcmp (*argv, "-exec") == 0)
848 {
849 ++argv;
850 if (!*argv)
851 error (_("No argument to -exec"));
852 exec = *argv;
853 }
854 }
855 else
856 error (_("Invalid argument"));
857 }
858 }
859
860 save_current_space_and_thread ();
861
862 for (i = 0; i < copies; ++i)
863 {
864 struct inferior *inf = add_inferior_with_spaces ();
865
866 printf_filtered (_("Added inferior %d\n"), inf->num);
867
868 if (exec != NULL)
869 {
870 /* Switch over temporarily, while reading executable and
c50c785c 871 symbols.q. */
cf7f2e2d
JM
872 set_current_program_space (inf->pspace);
873 set_current_inferior (inf);
874 switch_to_thread (null_ptid);
875
876 exec_file_attach (exec, from_tty);
877 symbol_file_add_main (exec, from_tty);
878 }
879 }
880
881 do_cleanups (old_chain);
882}
883
884/* clone-inferior [-copies N] [ID] */
885
ef5ccd6c 886static void
cf7f2e2d
JM
887clone_inferior_command (char *args, int from_tty)
888{
889 int i, copies = 1;
890 char **argv;
891 struct inferior *orginf = NULL;
892 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
893
894 if (args)
895 {
896 argv = gdb_buildargv (args);
897 make_cleanup_freeargv (argv);
898
899 for (; *argv != NULL; argv++)
900 {
901 if (**argv == '-')
902 {
903 if (strcmp (*argv, "-copies") == 0)
904 {
905 ++argv;
906 if (!*argv)
907 error (_("No argument to -copies"));
908 copies = parse_and_eval_long (*argv);
909
910 if (copies < 0)
911 error (_("Invalid copies number"));
912 }
913 }
914 else
915 {
916 if (orginf == NULL)
917 {
918 int num;
919
920 /* The first non-option (-) argument specified the
921 program space ID. */
922 num = parse_and_eval_long (*argv);
923 orginf = find_inferior_id (num);
924
925 if (orginf == NULL)
926 error (_("Inferior ID %d not known."), num);
927 continue;
928 }
929 else
930 error (_("Invalid argument"));
931 }
932 }
933 }
934
935 /* If no inferior id was specified, then the user wants to clone the
936 current inferior. */
937 if (orginf == NULL)
938 orginf = current_inferior ();
939
940 save_current_space_and_thread ();
941
942 for (i = 0; i < copies; ++i)
943 {
944 struct address_space *aspace;
945 struct program_space *pspace;
946 struct inferior *inf;
947
948 /* If all inferiors share an address space on this system, this
949 doesn't really return a new address space; otherwise, it
950 really does. */
951 aspace = maybe_new_address_space ();
952 pspace = add_program_space (aspace);
953 inf = add_inferior (0);
954 inf->pspace = pspace;
955 inf->aspace = pspace->aspace;
ef5ccd6c
JM
956 inf->gdbarch = orginf->gdbarch;
957
958 /* If the original inferior had a user specified target
959 description, make the clone use it too. */
960 if (target_desc_info_from_user_p (inf->tdesc_info))
961 copy_inferior_target_desc_info (inf, orginf);
cf7f2e2d
JM
962
963 printf_filtered (_("Added inferior %d.\n"), inf->num);
964
965 set_current_inferior (inf);
966 switch_to_thread (null_ptid);
967 clone_program_space (pspace, orginf->pspace);
968 }
969
970 do_cleanups (old_chain);
971}
972
5796c8dc
SS
973/* Print notices when new inferiors are created and die. */
974static void
975show_print_inferior_events (struct ui_file *file, int from_tty,
976 struct cmd_list_element *c, const char *value)
977{
978 fprintf_filtered (file, _("Printing of inferior events is %s.\n"), value);
979}
980
cf7f2e2d
JM
981\f
982
5796c8dc 983void
cf7f2e2d 984initialize_inferiors (void)
5796c8dc 985{
ef5ccd6c
JM
986 struct cmd_list_element *c = NULL;
987
cf7f2e2d
JM
988 /* There's always one inferior. Note that this function isn't an
989 automatic _initialize_foo function, since other _initialize_foo
990 routines may need to install their per-inferior data keys. We
991 can only allocate an inferior when all those modules have done
992 that. Do this after initialize_progspace, due to the
993 current_program_space reference. */
994 current_inferior_ = add_inferior (0);
995 current_inferior_->pspace = current_program_space;
996 current_inferior_->aspace = current_program_space->aspace;
ef5ccd6c
JM
997 /* The architecture will be initialized shortly, by
998 initialize_current_architecture. */
cf7f2e2d 999
c50c785c
JM
1000 add_info ("inferiors", info_inferiors_command,
1001 _("IDs of specified inferiors (all inferiors if no argument)."));
5796c8dc 1002
ef5ccd6c 1003 c = add_com ("add-inferior", no_class, add_inferior_command, _("\
cf7f2e2d
JM
1004Add a new inferior.\n\
1005Usage: add-inferior [-copies <N>] [-exec <FILENAME>]\n\
c50c785c 1006N is the optional number of inferiors to add, default is 1.\n\
cf7f2e2d
JM
1007FILENAME is the file name of the executable to use\n\
1008as main program."));
ef5ccd6c 1009 set_cmd_completer (c, filename_completer);
cf7f2e2d 1010
c50c785c
JM
1011 add_com ("remove-inferiors", no_class, remove_inferior_command, _("\
1012Remove inferior ID (or list of IDs).\n\
1013Usage: remove-inferiors ID..."));
cf7f2e2d
JM
1014
1015 add_com ("clone-inferior", no_class, clone_inferior_command, _("\
1016Clone inferior ID.\n\
1017Usage: clone-inferior [-copies <N>] [ID]\n\
1018Add N copies of inferior ID. The new inferior has the same\n\
1019executable loaded as the copied inferior. If -copies is not specified,\n\
1020adds 1 copy. If ID is not specified, it is the current inferior\n\
1021that is cloned."));
5796c8dc 1022
c50c785c
JM
1023 add_cmd ("inferiors", class_run, detach_inferior_command, _("\
1024Detach from inferior ID (or list of IDS)."),
5796c8dc
SS
1025 &detachlist);
1026
c50c785c
JM
1027 add_cmd ("inferiors", class_run, kill_inferior_command, _("\
1028Kill inferior ID (or list of IDs)."),
5796c8dc
SS
1029 &killlist);
1030
1031 add_cmd ("inferior", class_run, inferior_command, _("\
1032Use this command to switch between inferiors.\n\
1033The new inferior ID must be currently known."),
1034 &cmdlist);
cf7f2e2d
JM
1035
1036 add_setshow_boolean_cmd ("inferior-events", no_class,
1037 &print_inferior_events, _("\
1038Set printing of inferior events (e.g., inferior start and exit)."), _("\
1039Show printing of inferior events (e.g., inferior start and exit)."), NULL,
1040 NULL,
1041 show_print_inferior_events,
1042 &setprintlist, &showprintlist);
1043
5796c8dc 1044}