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