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