gdb/inferior.c

   1 /* Multi-process control for GDB, the GNU debugger.
   2
   3    Copyright (C) 2008-2020 Free Software Foundation, Inc.
   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"
  21 #include "exec.h"
  22 #include "inferior.h"
  23 #include "target.h"
  24 #include "command.h"
  25 #include "completer.h"
  26 #include "gdbcmd.h"
  27 #include "gdbthread.h"
  28 #include "ui-out.h"
  29 #include "observable.h"
  30 #include "gdbcore.h"
  31 #include "symfile.h"
  32 #include "gdbsupport/environ.h"
  33 #include "cli/cli-utils.h"
  34 #include "continuations.h"
  35 #include "arch-utils.h"
  36 #include "target-descriptions.h"
  37 #include "readline/tilde.h"
  38 #include "progspace-and-thread.h"
  39
  40 /* Keep a registry of per-inferior data-pointers required by other GDB
  41    modules.  */
  42
  43 DEFINE_REGISTRY (inferior, REGISTRY_ACCESS_FIELD)
  44
  45 struct inferior *inferior_list = NULL;
  46 static int highest_inferior_num;
  47
  48 /* See inferior.h.  */
  49 bool print_inferior_events = true;
  50
  51 /* The Current Inferior.  This is a strong reference.  I.e., whenever
  52    an inferior is the current inferior, its refcount is
  53    incremented.  */
  54 static struct inferior *current_inferior_ = NULL;
  55
  56 struct inferior*
  57 current_inferior (void)
  58 {
  59   return current_inferior_;
  60 }
  61
  62 void
  63 set_current_inferior (struct inferior *inf)
  64 {
  65   /* There's always an inferior.  */
  66   gdb_assert (inf != NULL);
  67
  68   inf->incref ();
  69   current_inferior_->decref ();
  70   current_inferior_ = inf;
  71 }
  72
  73 private_inferior::~private_inferior () = default;
  74
  75 inferior::~inferior ()
  76 {
  77   inferior *inf = this;
  78
  79   discard_all_inferior_continuations (inf);
  80   inferior_free_data (inf);
  81   xfree (inf->args);
  82   xfree (inf->terminal);
  83   target_desc_info_free (inf->tdesc_info);
  84 }
  85
  86 inferior::inferior (int pid_)
  87   : num (++highest_inferior_num),
  88     pid (pid_),
  89     environment (gdb_environ::from_host_environ ()),
  90     registry_data ()
  91 {
  92   inferior_alloc_data (this);
  93
  94   m_target_stack.push (get_dummy_target ());
  95 }
  96
  97 struct inferior *
  98 add_inferior_silent (int pid)
  99 {
 100   inferior *inf = new inferior (pid);
 101
 102   if (inferior_list == NULL)
 103     inferior_list = inf;
 104   else
 105     {
 106       inferior *last;
 107
 108       for (last = inferior_list; last->next != NULL; last = last->next)
 109         ;
 110       last->next = inf;
 111     }
 112
 113   gdb::observers::inferior_added.notify (inf);
 114
 115   if (pid != 0)
 116     inferior_appeared (inf, pid);
 117
 118   return inf;
 119 }
 120
 121 struct inferior *
 122 add_inferior (int pid)
 123 {
 124   struct inferior *inf = add_inferior_silent (pid);
 125
 126   if (print_inferior_events)
 127     {
 128       if (pid != 0)
 129         printf_unfiltered (_("[New inferior %d (%s)]\n"),
 130                            inf->num,
 131                            target_pid_to_str (ptid_t (pid)).c_str ());
 132       else
 133         printf_unfiltered (_("[New inferior %d]\n"), inf->num);
 134     }
 135
 136   return inf;
 137 }
 138
 139 void
 140 delete_inferior (struct inferior *todel)
 141 {
 142   struct inferior *inf, *infprev;
 143
 144   infprev = NULL;
 145
 146   for (inf = inferior_list; inf; infprev = inf, inf = inf->next)
 147     if (inf == todel)
 148       break;
 149
 150   if (!inf)
 151     return;
 152
 153   for (thread_info *tp : inf->threads_safe ())
 154     delete_thread_silent (tp);
 155
 156   if (infprev)
 157     infprev->next = inf->next;
 158   else
 159     inferior_list = inf->next;
 160
 161   gdb::observers::inferior_removed.notify (inf);
 162
 163   /* If this program space is rendered useless, remove it. */
 164   if (program_space_empty_p (inf->pspace))
 165     delete_program_space (inf->pspace);
 166
 167   delete inf;
 168 }
 169
 170 /* If SILENT then be quiet -- don't announce a inferior exit, or the
 171    exit of its threads.  */
 172
 173 static void
 174 exit_inferior_1 (struct inferior *inftoex, int silent)
 175 {
 176   struct inferior *inf;
 177
 178   for (inf = inferior_list; inf; inf = inf->next)
 179     if (inf == inftoex)
 180       break;
 181
 182   if (!inf)
 183     return;
 184
 185   for (thread_info *tp : inf->threads_safe ())
 186     {
 187       if (silent)
 188         delete_thread_silent (tp);
 189       else
 190         delete_thread (tp);
 191     }
 192
 193   gdb::observers::inferior_exit.notify (inf);
 194
 195   inf->pid = 0;
 196   inf->fake_pid_p = false;
 197   inf->priv = NULL;
 198
 199   if (inf->vfork_parent != NULL)
 200     {
 201       inf->vfork_parent->vfork_child = NULL;
 202       inf->vfork_parent = NULL;
 203     }
 204   if (inf->vfork_child != NULL)
 205     {
 206       inf->vfork_child->vfork_parent = NULL;
 207       inf->vfork_child = NULL;
 208     }
 209
 210   inf->pending_detach = 0;
 211   /* Reset it.  */
 212   inf->control = inferior_control_state (NO_STOP_QUIETLY);
 213
 214   /* Clear the register cache and the frame cache.  */
 215   registers_changed ();
 216   reinit_frame_cache ();
 217 }
 218
 219 void
 220 exit_inferior (inferior *inf)
 221 {
 222   exit_inferior_1 (inf, 0);
 223 }
 224
 225 void
 226 exit_inferior_silent (inferior *inf)
 227 {
 228   exit_inferior_1 (inf, 1);
 229 }
 230
 231 /* See inferior.h.  */
 232
 233 void
 234 detach_inferior (inferior *inf)
 235 {
 236   /* Save the pid, since exit_inferior_1 will reset it.  */
 237   int pid = inf->pid;
 238
 239   exit_inferior_1 (inf, 0);
 240
 241   if (print_inferior_events)
 242     printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
 243                        inf->num,
 244                        target_pid_to_str (ptid_t (pid)).c_str ());
 245 }
 246
 247 void
 248 inferior_appeared (struct inferior *inf, int pid)
 249 {
 250   /* If this is the first inferior with threads, reset the global
 251      thread id.  */
 252   delete_exited_threads ();
 253   if (!any_thread_p ())
 254     init_thread_list ();
 255
 256   inf->pid = pid;
 257   inf->has_exit_code = 0;
 258   inf->exit_code = 0;
 259
 260   gdb::observers::inferior_appeared.notify (inf);
 261 }
 262
 263 void
 264 discard_all_inferiors (void)
 265 {
 266   for (inferior *inf : all_non_exited_inferiors ())
 267     exit_inferior_silent (inf);
 268 }
 269
 270 struct inferior *
 271 find_inferior_id (int num)
 272 {
 273   for (inferior *inf : all_inferiors ())
 274     if (inf->num == num)
 275       return inf;
 276
 277   return NULL;
 278 }
 279
 280 struct inferior *
 281 find_inferior_pid (process_stratum_target *targ, int pid)
 282 {
 283   /* Looking for inferior pid == 0 is always wrong, and indicative of
 284      a bug somewhere else.  There may be more than one with pid == 0,
 285      for instance.  */
 286   gdb_assert (pid != 0);
 287
 288   for (inferior *inf : all_inferiors (targ))
 289     if (inf->pid == pid)
 290       return inf;
 291
 292   return NULL;
 293 }
 294
 295 /* See inferior.h */
 296
 297 struct inferior *
 298 find_inferior_ptid (process_stratum_target *targ, ptid_t ptid)
 299 {
 300   return find_inferior_pid (targ, ptid.pid ());
 301 }
 302
 303 /* See inferior.h.  */
 304
 305 struct inferior *
 306 find_inferior_for_program_space (struct program_space *pspace)
 307 {
 308   struct inferior *cur_inf = current_inferior ();
 309
 310   if (cur_inf->pspace == pspace)
 311     return cur_inf;
 312
 313   for (inferior *inf : all_inferiors ())
 314     if (inf->pspace == pspace)
 315       return inf;
 316
 317   return NULL;
 318 }
 319
 320 struct inferior *
 321 iterate_over_inferiors (int (*callback) (struct inferior *, void *),
 322                         void *data)
 323 {
 324   for (inferior *inf : all_inferiors_safe ())
 325     if ((*callback) (inf, data))
 326       return inf;
 327
 328   return NULL;
 329 }
 330
 331 int
 332 have_inferiors (void)
 333 {
 334   for (inferior *inf ATTRIBUTE_UNUSED : all_non_exited_inferiors ())
 335     return 1;
 336
 337   return 0;
 338 }
 339
 340 /* Return the number of live inferiors.  We account for the case
 341    where an inferior might have a non-zero pid but no threads, as
 342    in the middle of a 'mourn' operation.  */
 343
 344 int
 345 number_of_live_inferiors (process_stratum_target *proc_target)
 346 {
 347   int num_inf = 0;
 348
 349   for (inferior *inf : all_non_exited_inferiors (proc_target))
 350     if (inf->has_execution ())
 351       for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
 352         {
 353           /* Found a live thread in this inferior, go to the next
 354              inferior.  */
 355           ++num_inf;
 356           break;
 357         }
 358
 359   return num_inf;
 360 }
 361
 362 /* Return true if there is at least one live inferior.  */
 363
 364 int
 365 have_live_inferiors (void)
 366 {
 367   return number_of_live_inferiors (NULL) > 0;
 368 }
 369
 370 /* Prune away any unused inferiors, and then prune away no longer used
 371    program spaces.  */
 372
 373 void
 374 prune_inferiors (void)
 375 {
 376   inferior *ss;
 377
 378   ss = inferior_list;
 379   while (ss)
 380     {
 381       if (!ss->deletable ()
 382           || !ss->removable
 383           || ss->pid != 0)
 384         {
 385           ss = ss->next;
 386           continue;
 387         }
 388
 389       inferior *ss_next = ss->next;
 390       delete_inferior (ss);
 391       ss = ss_next;
 392     }
 393 }
 394
 395 /* Simply returns the count of inferiors.  */
 396
 397 int
 398 number_of_inferiors (void)
 399 {
 400   auto rng = all_inferiors ();
 401   return std::distance (rng.begin (), rng.end ());
 402 }
 403
 404 /* Converts an inferior process id to a string.  Like
 405    target_pid_to_str, but special cases the null process.  */
 406
 407 static std::string
 408 inferior_pid_to_str (int pid)
 409 {
 410   if (pid != 0)
 411     return target_pid_to_str (ptid_t (pid));
 412   else
 413     return _("<null>");
 414 }
 415
 416 /* See inferior.h.  */
 417
 418 void
 419 print_selected_inferior (struct ui_out *uiout)
 420 {
 421   struct inferior *inf = current_inferior ();
 422   const char *filename = inf->pspace->pspace_exec_filename;
 423
 424   if (filename == NULL)
 425     filename = _("<noexec>");
 426
 427   uiout->message (_("[Switching to inferior %d [%s] (%s)]\n"),
 428                   inf->num, inferior_pid_to_str (inf->pid).c_str (), filename);
 429 }
 430
 431 /* Helper for print_inferior.  Returns the 'connection-id' string for
 432    PROC_TARGET.  */
 433
 434 static std::string
 435 uiout_field_connection (process_stratum_target *proc_target)
 436 {
 437   if (proc_target == NULL)
 438     {
 439       return {};
 440     }
 441   else if (proc_target->connection_string () != NULL)
 442     {
 443       return string_printf ("%d (%s %s)",
 444                             proc_target->connection_number,
 445                             proc_target->shortname (),
 446                             proc_target->connection_string ());
 447     }
 448   else
 449     {
 450       return string_printf ("%d (%s)",
 451                             proc_target->connection_number,
 452                             proc_target->shortname ());
 453     }
 454 }
 455
 456 /* Prints the list of inferiors and their details on UIOUT.  This is a
 457    version of 'info_inferior_command' suitable for use from MI.
 458
 459    If REQUESTED_INFERIORS is not NULL, it's a list of GDB ids of the
 460    inferiors that should be printed.  Otherwise, all inferiors are
 461    printed.  */
 462
 463 static void
 464 print_inferior (struct ui_out *uiout, const char *requested_inferiors)
 465 {
 466   int inf_count = 0;
 467   size_t connection_id_len = 20;
 468
 469   /* Compute number of inferiors we will print.  */
 470   for (inferior *inf : all_inferiors ())
 471     {
 472       if (!number_is_in_list (requested_inferiors, inf->num))
 473         continue;
 474
 475       std::string conn = uiout_field_connection (inf->process_target ());
 476       if (connection_id_len < conn.size ())
 477         connection_id_len = conn.size ();
 478
 479       ++inf_count;
 480     }
 481
 482   if (inf_count == 0)
 483     {
 484       uiout->message ("No inferiors.\n");
 485       return;
 486     }
 487
 488   ui_out_emit_table table_emitter (uiout, 5, inf_count, "inferiors");
 489   uiout->table_header (1, ui_left, "current", "");
 490   uiout->table_header (4, ui_left, "number", "Num");
 491   uiout->table_header (17, ui_left, "target-id", "Description");
 492   uiout->table_header (connection_id_len, ui_left,
 493                        "connection-id", "Connection");
 494   uiout->table_header (17, ui_left, "exec", "Executable");
 495
 496   uiout->table_body ();
 497   for (inferior *inf : all_inferiors ())
 498     {
 499       if (!number_is_in_list (requested_inferiors, inf->num))
 500         continue;
 501
 502       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 503
 504       if (inf == current_inferior ())
 505         uiout->field_string ("current", "*");
 506       else
 507         uiout->field_skip ("current");
 508
 509       uiout->field_signed ("number", inf->num);
 510
 511       uiout->field_string ("target-id", inferior_pid_to_str (inf->pid));
 512
 513       std::string conn = uiout_field_connection (inf->process_target ());
 514       uiout->field_string ("connection-id", conn.c_str ());
 515
 516       if (inf->pspace->pspace_exec_filename != NULL)
 517         uiout->field_string ("exec", inf->pspace->pspace_exec_filename);
 518       else
 519         uiout->field_skip ("exec");
 520
 521       /* Print extra info that isn't really fit to always present in
 522          tabular form.  Currently we print the vfork parent/child
 523          relationships, if any.  */
 524       if (inf->vfork_parent)
 525         {
 526           uiout->text (_("\n\tis vfork child of inferior "));
 527           uiout->field_signed ("vfork-parent", inf->vfork_parent->num);
 528         }
 529       if (inf->vfork_child)
 530         {
 531           uiout->text (_("\n\tis vfork parent of inferior "));
 532           uiout->field_signed ("vfork-child", inf->vfork_child->num);
 533         }
 534
 535       uiout->text ("\n");
 536     }
 537 }
 538
 539 static void
 540 detach_inferior_command (const char *args, int from_tty)
 541 {
 542   if (!args || !*args)
 543     error (_("Requires argument (inferior id(s) to detach)"));
 544
 545   number_or_range_parser parser (args);
 546   while (!parser.finished ())
 547     {
 548       int num = parser.get_number ();
 549
 550       inferior *inf = find_inferior_id (num);
 551       if (inf == NULL)
 552         {
 553           warning (_("Inferior ID %d not known."), num);
 554           continue;
 555         }
 556
 557       if (inf->pid == 0)
 558         {
 559           warning (_("Inferior ID %d is not running."), num);
 560           continue;
 561         }
 562
 563       thread_info *tp = any_thread_of_inferior (inf);
 564       if (tp == NULL)
 565         {
 566           warning (_("Inferior ID %d has no threads."), num);
 567           continue;
 568         }
 569
 570       switch_to_thread (tp);
 571
 572       detach_command (NULL, from_tty);
 573     }
 574 }
 575
 576 static void
 577 kill_inferior_command (const char *args, int from_tty)
 578 {
 579   if (!args || !*args)
 580     error (_("Requires argument (inferior id(s) to kill)"));
 581
 582   number_or_range_parser parser (args);
 583   while (!parser.finished ())
 584     {
 585       int num = parser.get_number ();
 586
 587       inferior *inf = find_inferior_id (num);
 588       if (inf == NULL)
 589         {
 590           warning (_("Inferior ID %d not known."), num);
 591           continue;
 592         }
 593
 594       if (inf->pid == 0)
 595         {
 596           warning (_("Inferior ID %d is not running."), num);
 597           continue;
 598         }
 599
 600       thread_info *tp = any_thread_of_inferior (inf);
 601       if (tp == NULL)
 602         {
 603           warning (_("Inferior ID %d has no threads."), num);
 604           continue;
 605         }
 606
 607       switch_to_thread (tp);
 608
 609       target_kill ();
 610     }
 611
 612   bfd_cache_close_all ();
 613 }
 614
 615 /* See inferior.h.  */
 616
 617 void
 618 switch_to_inferior_no_thread (inferior *inf)
 619 {
 620   set_current_inferior (inf);
 621   switch_to_no_thread ();
 622   set_current_program_space (inf->pspace);
 623 }
 624
 625 static void
 626 inferior_command (const char *args, int from_tty)
 627 {
 628   struct inferior *inf;
 629   int num;
 630
 631   num = parse_and_eval_long (args);
 632
 633   inf = find_inferior_id (num);
 634   if (inf == NULL)
 635     error (_("Inferior ID %d not known."), num);
 636
 637   if (inf->pid != 0)
 638     {
 639       if (inf != current_inferior ())
 640         {
 641           thread_info *tp = any_thread_of_inferior (inf);
 642           if (tp == NULL)
 643             error (_("Inferior has no threads."));
 644
 645           switch_to_thread (tp);
 646         }
 647
 648       gdb::observers::user_selected_context_changed.notify
 649         (USER_SELECTED_INFERIOR
 650          | USER_SELECTED_THREAD
 651          | USER_SELECTED_FRAME);
 652     }
 653   else
 654     {
 655       switch_to_inferior_no_thread (inf);
 656
 657       gdb::observers::user_selected_context_changed.notify
 658         (USER_SELECTED_INFERIOR);
 659     }
 660 }
 661
 662 /* Print information about currently known inferiors.  */
 663
 664 static void
 665 info_inferiors_command (const char *args, int from_tty)
 666 {
 667   print_inferior (current_uiout, args);
 668 }
 669
 670 /* remove-inferior ID */
 671
 672 static void
 673 remove_inferior_command (const char *args, int from_tty)
 674 {
 675   if (args == NULL || *args == '\0')
 676     error (_("Requires an argument (inferior id(s) to remove)"));
 677
 678   number_or_range_parser parser (args);
 679   while (!parser.finished ())
 680     {
 681       int num = parser.get_number ();
 682       struct inferior *inf = find_inferior_id (num);
 683
 684       if (inf == NULL)
 685         {
 686           warning (_("Inferior ID %d not known."), num);
 687           continue;
 688         }
 689
 690       if (!inf->deletable ())
 691         {
 692           warning (_("Can not remove current inferior %d."), num);
 693           continue;
 694         }
 695
 696       if (inf->pid != 0)
 697         {
 698           warning (_("Can not remove active inferior %d."), num);
 699           continue;
 700         }
 701
 702       delete_inferior (inf);
 703     }
 704 }
 705
 706 struct inferior *
 707 add_inferior_with_spaces (void)
 708 {
 709   struct address_space *aspace;
 710   struct program_space *pspace;
 711   struct inferior *inf;
 712   struct gdbarch_info info;
 713
 714   /* If all inferiors share an address space on this system, this
 715      doesn't really return a new address space; otherwise, it
 716      really does.  */
 717   aspace = maybe_new_address_space ();
 718   pspace = new program_space (aspace);
 719   inf = add_inferior (0);
 720   inf->pspace = pspace;
 721   inf->aspace = pspace->aspace;
 722
 723   /* Setup the inferior's initial arch, based on information obtained
 724      from the global "set ..." options.  */
 725   gdbarch_info_init (&info);
 726   inf->gdbarch = gdbarch_find_by_info (info);
 727   /* The "set ..." options reject invalid settings, so we should
 728      always have a valid arch by now.  */
 729   gdb_assert (inf->gdbarch != NULL);
 730
 731   return inf;
 732 }
 733
 734 /* Switch to inferior NEW_INF, a new inferior, and unless
 735    NO_CONNECTION is true, push the process_stratum_target of ORG_INF
 736    to NEW_INF.  */
 737
 738 static void
 739 switch_to_inferior_and_push_target (inferior *new_inf,
 740                                     bool no_connection, inferior *org_inf)
 741 {
 742   process_stratum_target *proc_target = org_inf->process_target ();
 743
 744   /* Switch over temporarily, while reading executable and
 745      symbols.  */
 746   switch_to_inferior_no_thread (new_inf);
 747
 748   /* Reuse the target for new inferior.  */
 749   if (!no_connection && proc_target != NULL)
 750     {
 751       push_target (proc_target);
 752       if (proc_target->connection_string () != NULL)
 753         printf_filtered (_("Added inferior %d on connection %d (%s %s)\n"),
 754                          new_inf->num,
 755                          proc_target->connection_number,
 756                          proc_target->shortname (),
 757                          proc_target->connection_string ());
 758       else
 759         printf_filtered (_("Added inferior %d on connection %d (%s)\n"),
 760                          new_inf->num,
 761                          proc_target->connection_number,
 762                          proc_target->shortname ());
 763     }
 764   else
 765     printf_filtered (_("Added inferior %d\n"), new_inf->num);
 766 }
 767
 768 /* add-inferior [-copies N] [-exec FILENAME] [-no-connection] */
 769
 770 static void
 771 add_inferior_command (const char *args, int from_tty)
 772 {
 773   int i, copies = 1;
 774   gdb::unique_xmalloc_ptr<char> exec;
 775   symfile_add_flags add_flags = 0;
 776   bool no_connection = false;
 777
 778   if (from_tty)
 779     add_flags |= SYMFILE_VERBOSE;
 780
 781   if (args)
 782     {
 783       gdb_argv built_argv (args);
 784
 785       for (char **argv = built_argv.get (); *argv != NULL; argv++)
 786         {
 787           if (**argv == '-')
 788             {
 789               if (strcmp (*argv, "-copies") == 0)
 790                 {
 791                   ++argv;
 792                   if (!*argv)
 793                     error (_("No argument to -copies"));
 794                   copies = parse_and_eval_long (*argv);
 795                 }
 796               else if (strcmp (*argv, "-no-connection") == 0)
 797                 no_connection = true;
 798               else if (strcmp (*argv, "-exec") == 0)
 799                 {
 800                   ++argv;
 801                   if (!*argv)
 802                     error (_("No argument to -exec"));
 803                   exec.reset (tilde_expand (*argv));
 804                 }
 805             }
 806           else
 807             error (_("Invalid argument"));
 808         }
 809     }
 810
 811   inferior *orginf = current_inferior ();
 812
 813   scoped_restore_current_pspace_and_thread restore_pspace_thread;
 814
 815   for (i = 0; i < copies; ++i)
 816     {
 817       inferior *inf = add_inferior_with_spaces ();
 818
 819       switch_to_inferior_and_push_target (inf, no_connection, orginf);
 820
 821       if (exec != NULL)
 822         {
 823           exec_file_attach (exec.get (), from_tty);
 824           symbol_file_add_main (exec.get (), add_flags);
 825         }
 826     }
 827 }
 828
 829 /* clone-inferior [-copies N] [ID] [-no-connection] */
 830
 831 static void
 832 clone_inferior_command (const char *args, int from_tty)
 833 {
 834   int i, copies = 1;
 835   struct inferior *orginf = NULL;
 836   bool no_connection = false;
 837
 838   if (args)
 839     {
 840       gdb_argv built_argv (args);
 841
 842       char **argv = built_argv.get ();
 843       for (; *argv != NULL; argv++)
 844         {
 845           if (**argv == '-')
 846             {
 847               if (strcmp (*argv, "-copies") == 0)
 848                 {
 849                   ++argv;
 850                   if (!*argv)
 851                     error (_("No argument to -copies"));
 852                   copies = parse_and_eval_long (*argv);
 853
 854                   if (copies < 0)
 855                     error (_("Invalid copies number"));
 856                 }
 857               else if (strcmp (*argv, "-no-connection") == 0)
 858                 no_connection = true;
 859             }
 860           else
 861             {
 862               if (orginf == NULL)
 863                 {
 864                   int num;
 865
 866                   /* The first non-option (-) argument specified the
 867                      program space ID.  */
 868                   num = parse_and_eval_long (*argv);
 869                   orginf = find_inferior_id (num);
 870
 871                   if (orginf == NULL)
 872                     error (_("Inferior ID %d not known."), num);
 873                   continue;
 874                 }
 875               else
 876                 error (_("Invalid argument"));
 877             }
 878         }
 879     }
 880
 881   /* If no inferior id was specified, then the user wants to clone the
 882      current inferior.  */
 883   if (orginf == NULL)
 884     orginf = current_inferior ();
 885
 886   scoped_restore_current_pspace_and_thread restore_pspace_thread;
 887
 888   for (i = 0; i < copies; ++i)
 889     {
 890       struct address_space *aspace;
 891       struct program_space *pspace;
 892       struct inferior *inf;
 893
 894       /* If all inferiors share an address space on this system, this
 895          doesn't really return a new address space; otherwise, it
 896          really does.  */
 897       aspace = maybe_new_address_space ();
 898       pspace = new program_space (aspace);
 899       inf = add_inferior (0);
 900       inf->pspace = pspace;
 901       inf->aspace = pspace->aspace;
 902       inf->gdbarch = orginf->gdbarch;
 903
 904       switch_to_inferior_and_push_target (inf, no_connection, orginf);
 905
 906       /* If the original inferior had a user specified target
 907          description, make the clone use it too.  */
 908       if (target_desc_info_from_user_p (inf->tdesc_info))
 909         copy_inferior_target_desc_info (inf, orginf);
 910
 911       clone_program_space (pspace, orginf->pspace);
 912     }
 913 }
 914
 915 /* Print notices when new inferiors are created and die.  */
 916 static void
 917 show_print_inferior_events (struct ui_file *file, int from_tty,
 918                            struct cmd_list_element *c, const char *value)
 919 {
 920   fprintf_filtered (file, _("Printing of inferior events is %s.\n"), value);
 921 }
 922
 923 /* Return a new value for the selected inferior's id.  */
 924
 925 static struct value *
 926 inferior_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
 927                         void *ignore)
 928 {
 929   struct inferior *inf = current_inferior ();
 930
 931   return value_from_longest (builtin_type (gdbarch)->builtin_int, inf->num);
 932 }
 933
 934 /* Implementation of `$_inferior' variable.  */
 935
 936 static const struct internalvar_funcs inferior_funcs =
 937 {
 938   inferior_id_make_value,
 939   NULL,
 940   NULL
 941 };
 942
 943 \f
 944
 945 void
 946 initialize_inferiors (void)
 947 {
 948   struct cmd_list_element *c = NULL;
 949
 950   /* There's always one inferior.  Note that this function isn't an
 951      automatic _initialize_foo function, since other _initialize_foo
 952      routines may need to install their per-inferior data keys.  We
 953      can only allocate an inferior when all those modules have done
 954      that.  Do this after initialize_progspace, due to the
 955      current_program_space reference.  */
 956   current_inferior_ = add_inferior_silent (0);
 957   current_inferior_->incref ();
 958   current_inferior_->pspace = current_program_space;
 959   current_inferior_->aspace = current_program_space->aspace;
 960   /* The architecture will be initialized shortly, by
 961      initialize_current_architecture.  */
 962
 963   add_info ("inferiors", info_inferiors_command,
 964             _("Print a list of inferiors being managed.\n\
 965 Usage: info inferiors [ID]...\n\
 966 If IDs are specified, the list is limited to just those inferiors.\n\
 967 By default all inferiors are displayed."));
 968
 969   c = add_com ("add-inferior", no_class, add_inferior_command, _("\
 970 Add a new inferior.\n\
 971 Usage: add-inferior [-copies N] [-exec FILENAME] [-no-connection]\n\
 972 N is the optional number of inferiors to add, default is 1.\n\
 973 FILENAME is the file name of the executable to use\n\
 974 as main program.\n\
 975 By default, the new inferior inherits the current inferior's connection.\n\
 976 If -no-connection is specified, the new inferior begins with\n\
 977 no target connection yet."));
 978   set_cmd_completer (c, filename_completer);
 979
 980   add_com ("remove-inferiors", no_class, remove_inferior_command, _("\
 981 Remove inferior ID (or list of IDs).\n\
 982 Usage: remove-inferiors ID..."));
 983
 984   add_com ("clone-inferior", no_class, clone_inferior_command, _("\
 985 Clone inferior ID.\n\
 986 Usage: clone-inferior [-copies N] [-no-connection] [ID]\n\
 987 Add N copies of inferior ID.  The new inferiors have the same\n\
 988 executable loaded as the copied inferior.  If -copies is not specified,\n\
 989 adds 1 copy.  If ID is not specified, it is the current inferior\n\
 990 that is cloned.\n\
 991 By default, the new inferiors inherit the copied inferior's connection.\n\
 992 If -no-connection is specified, the new inferiors begin with\n\
 993 no target connection yet."));
 994
 995   add_cmd ("inferiors", class_run, detach_inferior_command, _("\
 996 Detach from inferior ID (or list of IDS).\n\
 997 Usage; detach inferiors ID..."),
 998            &detachlist);
 999
1000   add_cmd ("inferiors", class_run, kill_inferior_command, _("\
1001 Kill inferior ID (or list of IDs).\n\
1002 Usage: kill inferiors ID..."),
1003            &killlist);
1004
1005   add_cmd ("inferior", class_run, inferior_command, _("\
1006 Use this command to switch between inferiors.\n\
1007 Usage: inferior ID\n\
1008 The new inferior ID must be currently known."),
1009            &cmdlist);
1010
1011   add_setshow_boolean_cmd ("inferior-events", no_class,
1012          &print_inferior_events, _("\
1013 Set printing of inferior events (such as inferior start and exit)."), _("\
1014 Show printing of inferior events (such as inferior start and exit)."), NULL,
1015          NULL,
1016          show_print_inferior_events,
1017          &setprintlist, &showprintlist);
1018
1019   create_internalvar_type_lazy ("_inferior", &inferior_funcs, NULL);
1020 }