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
 498   /* Restore the current thread after the loop because we switch the
 499      inferior in the loop.  */
 500   scoped_restore_current_pspace_and_thread restore_pspace_thread;
 501   inferior *current_inf = current_inferior ();
 502   for (inferior *inf : all_inferiors ())
 503     {
 504       if (!number_is_in_list (requested_inferiors, inf->num))
 505         continue;
 506
 507       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 508
 509       if (inf == current_inf)
 510         uiout->field_string ("current", "*");
 511       else
 512         uiout->field_skip ("current");
 513
 514       uiout->field_signed ("number", inf->num);
 515
 516       /* Because target_pid_to_str uses current_top_target,
 517          switch the inferior.  */
 518       switch_to_inferior_no_thread (inf);
 519
 520       uiout->field_string ("target-id", inferior_pid_to_str (inf->pid));
 521
 522       std::string conn = uiout_field_connection (inf->process_target ());
 523       uiout->field_string ("connection-id", conn.c_str ());
 524
 525       if (inf->pspace->pspace_exec_filename != NULL)
 526         uiout->field_string ("exec", inf->pspace->pspace_exec_filename);
 527       else
 528         uiout->field_skip ("exec");
 529
 530       /* Print extra info that isn't really fit to always present in
 531          tabular form.  Currently we print the vfork parent/child
 532          relationships, if any.  */
 533       if (inf->vfork_parent)
 534         {
 535           uiout->text (_("\n\tis vfork child of inferior "));
 536           uiout->field_signed ("vfork-parent", inf->vfork_parent->num);
 537         }
 538       if (inf->vfork_child)
 539         {
 540           uiout->text (_("\n\tis vfork parent of inferior "));
 541           uiout->field_signed ("vfork-child", inf->vfork_child->num);
 542         }
 543
 544       uiout->text ("\n");
 545     }
 546 }
 547
 548 static void
 549 detach_inferior_command (const char *args, int from_tty)
 550 {
 551   if (!args || !*args)
 552     error (_("Requires argument (inferior id(s) to detach)"));
 553
 554   number_or_range_parser parser (args);
 555   while (!parser.finished ())
 556     {
 557       int num = parser.get_number ();
 558
 559       inferior *inf = find_inferior_id (num);
 560       if (inf == NULL)
 561         {
 562           warning (_("Inferior ID %d not known."), num);
 563           continue;
 564         }
 565
 566       if (inf->pid == 0)
 567         {
 568           warning (_("Inferior ID %d is not running."), num);
 569           continue;
 570         }
 571
 572       thread_info *tp = any_thread_of_inferior (inf);
 573       if (tp == NULL)
 574         {
 575           warning (_("Inferior ID %d has no threads."), num);
 576           continue;
 577         }
 578
 579       switch_to_thread (tp);
 580
 581       detach_command (NULL, from_tty);
 582     }
 583 }
 584
 585 static void
 586 kill_inferior_command (const char *args, int from_tty)
 587 {
 588   if (!args || !*args)
 589     error (_("Requires argument (inferior id(s) to kill)"));
 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 }