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