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 inferior_ref current_inferior_;
  55
  56 struct inferior*
  57 current_inferior (void)
  58 {
  59   return current_inferior_.get ();
  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   current_inferior_ = inferior_ref::new_reference (inf);
  69 }
  70
  71 private_inferior::~private_inferior () = default;
  72
  73 inferior::~inferior ()
  74 {
  75   inferior *inf = this;
  76
  77   discard_all_inferior_continuations (inf);
  78   inferior_free_data (inf);
  79   xfree (inf->args);
  80   target_desc_info_free (inf->tdesc_info);
  81 }
  82
  83 inferior::inferior (int pid_)
  84   : num (++highest_inferior_num),
  85     pid (pid_),
  86     environment (gdb_environ::from_host_environ ()),
  87     registry_data ()
  88 {
  89   inferior_alloc_data (this);
  90
  91   m_target_stack.push (get_dummy_target ());
  92 }
  93
  94 void
  95 inferior::set_tty (const char *terminal_name)
  96 {
  97   if (terminal_name != nullptr && *terminal_name != '\0')
  98     m_terminal = make_unique_xstrdup (terminal_name);
  99   else
 100     m_terminal = NULL;
 101 }
 102
 103 const char *
 104 inferior::tty ()
 105 {
 106   return m_terminal.get ();
 107 }
 108
 109 struct inferior *
 110 add_inferior_silent (int pid)
 111 {
 112   inferior *inf = new inferior (pid);
 113
 114   if (inferior_list == NULL)
 115     inferior_list = inf;
 116   else
 117     {
 118       inferior *last;
 119
 120       for (last = inferior_list; last->next != NULL; last = last->next)
 121         ;
 122       last->next = inf;
 123     }
 124
 125   gdb::observers::inferior_added.notify (inf);
 126
 127   if (pid != 0)
 128     inferior_appeared (inf, pid);
 129
 130   return inf;
 131 }
 132
 133 struct inferior *
 134 add_inferior (int pid)
 135 {
 136   struct inferior *inf = add_inferior_silent (pid);
 137
 138   if (print_inferior_events)
 139     {
 140       if (pid != 0)
 141         printf_unfiltered (_("[New inferior %d (%s)]\n"),
 142                            inf->num,
 143                            target_pid_to_str (ptid_t (pid)).c_str ());
 144       else
 145         printf_unfiltered (_("[New inferior %d]\n"), inf->num);
 146     }
 147
 148   return inf;
 149 }
 150
 151 void
 152 delete_inferior (struct inferior *todel)
 153 {
 154   struct inferior *inf, *infprev;
 155
 156   infprev = NULL;
 157
 158   for (inf = inferior_list; inf; infprev = inf, inf = inf->next)
 159     if (inf == todel)
 160       break;
 161
 162   if (!inf)
 163     return;
 164
 165   for (thread_info *tp : inf->threads_safe ())
 166     delete_thread_silent (tp);
 167
 168   if (infprev)
 169     infprev->next = inf->next;
 170   else
 171     inferior_list = inf->next;
 172
 173   gdb::observers::inferior_removed.notify (inf);
 174
 175   /* If this program space is rendered useless, remove it. */
 176   if (inf->pspace->empty ())
 177     delete inf->pspace;
 178
 179   delete inf;
 180 }
 181
 182 /* If SILENT then be quiet -- don't announce a inferior exit, or the
 183    exit of its threads.  */
 184
 185 static void
 186 exit_inferior_1 (struct inferior *inftoex, int silent)
 187 {
 188   struct inferior *inf;
 189
 190   for (inf = inferior_list; inf; inf = inf->next)
 191     if (inf == inftoex)
 192       break;
 193
 194   if (!inf)
 195     return;
 196
 197   for (thread_info *tp : inf->threads_safe ())
 198     {
 199       if (silent)
 200         delete_thread_silent (tp);
 201       else
 202         delete_thread (tp);
 203     }
 204
 205   gdb::observers::inferior_exit.notify (inf);
 206
 207   inf->pid = 0;
 208   inf->fake_pid_p = false;
 209   inf->priv = NULL;
 210
 211   if (inf->vfork_parent != NULL)
 212     {
 213       inf->vfork_parent->vfork_child = NULL;
 214       inf->vfork_parent = NULL;
 215     }
 216   if (inf->vfork_child != NULL)
 217     {
 218       inf->vfork_child->vfork_parent = NULL;
 219       inf->vfork_child = NULL;
 220     }
 221
 222   inf->pending_detach = 0;
 223   /* Reset it.  */
 224   inf->control = inferior_control_state (NO_STOP_QUIETLY);
 225
 226   /* Clear the register cache and the frame cache.  */
 227   registers_changed ();
 228   reinit_frame_cache ();
 229 }
 230
 231 void
 232 exit_inferior (inferior *inf)
 233 {
 234   exit_inferior_1 (inf, 0);
 235 }
 236
 237 void
 238 exit_inferior_silent (inferior *inf)
 239 {
 240   exit_inferior_1 (inf, 1);
 241 }
 242
 243 /* See inferior.h.  */
 244
 245 void
 246 detach_inferior (inferior *inf)
 247 {
 248   /* Save the pid, since exit_inferior_1 will reset it.  */
 249   int pid = inf->pid;
 250
 251   exit_inferior_1 (inf, 0);
 252
 253   if (print_inferior_events)
 254     printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
 255                        inf->num,
 256                        target_pid_to_str (ptid_t (pid)).c_str ());
 257 }
 258
 259 void
 260 inferior_appeared (struct inferior *inf, int pid)
 261 {
 262   /* If this is the first inferior with threads, reset the global
 263      thread id.  */
 264   delete_exited_threads ();
 265   if (!any_thread_p ())
 266     init_thread_list ();
 267
 268   inf->pid = pid;
 269   inf->has_exit_code = 0;
 270   inf->exit_code = 0;
 271
 272   gdb::observers::inferior_appeared.notify (inf);
 273 }
 274
 275 struct inferior *
 276 find_inferior_id (int num)
 277 {
 278   for (inferior *inf : all_inferiors ())
 279     if (inf->num == num)
 280       return inf;
 281
 282   return NULL;
 283 }
 284
 285 struct inferior *
 286 find_inferior_pid (process_stratum_target *targ, int pid)
 287 {
 288   /* Looking for inferior pid == 0 is always wrong, and indicative of
 289      a bug somewhere else.  There may be more than one with pid == 0,
 290      for instance.  */
 291   gdb_assert (pid != 0);
 292
 293   for (inferior *inf : all_inferiors (targ))
 294     if (inf->pid == pid)
 295       return inf;
 296
 297   return NULL;
 298 }
 299
 300 /* See inferior.h */
 301
 302 struct inferior *
 303 find_inferior_ptid (process_stratum_target *targ, ptid_t ptid)
 304 {
 305   return find_inferior_pid (targ, ptid.pid ());
 306 }
 307
 308 /* See inferior.h.  */
 309
 310 struct inferior *
 311 find_inferior_for_program_space (struct program_space *pspace)
 312 {
 313   struct inferior *cur_inf = current_inferior ();
 314
 315   if (cur_inf->pspace == pspace)
 316     return cur_inf;
 317
 318   for (inferior *inf : all_inferiors ())
 319     if (inf->pspace == pspace)
 320       return inf;
 321
 322   return NULL;
 323 }
 324
 325 int
 326 have_inferiors (void)
 327 {
 328   for (inferior *inf ATTRIBUTE_UNUSED : all_non_exited_inferiors ())
 329     return 1;
 330
 331   return 0;
 332 }
 333
 334 /* Return the number of live inferiors.  We account for the case
 335    where an inferior might have a non-zero pid but no threads, as
 336    in the middle of a 'mourn' operation.  */
 337
 338 int
 339 number_of_live_inferiors (process_stratum_target *proc_target)
 340 {
 341   int num_inf = 0;
 342
 343   for (inferior *inf : all_non_exited_inferiors (proc_target))
 344     if (inf->has_execution ())
 345       for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
 346         {
 347           /* Found a live thread in this inferior, go to the next
 348              inferior.  */
 349           ++num_inf;
 350           break;
 351         }
 352
 353   return num_inf;
 354 }
 355
 356 /* Return true if there is at least one live inferior.  */
 357
 358 int
 359 have_live_inferiors (void)
 360 {
 361   return number_of_live_inferiors (NULL) > 0;
 362 }
 363
 364 /* Prune away any unused inferiors, and then prune away no longer used
 365    program spaces.  */
 366
 367 void
 368 prune_inferiors (void)
 369 {
 370   inferior *ss;
 371
 372   ss = inferior_list;
 373   while (ss)
 374     {
 375       if (!ss->deletable ()
 376           || !ss->removable
 377           || ss->pid != 0)
 378         {
 379           ss = ss->next;
 380           continue;
 381         }
 382
 383       inferior *ss_next = ss->next;
 384       delete_inferior (ss);
 385       ss = ss_next;
 386     }
 387 }
 388
 389 /* Simply returns the count of inferiors.  */
 390
 391 int
 392 number_of_inferiors (void)
 393 {
 394   auto rng = all_inferiors ();
 395   return std::distance (rng.begin (), rng.end ());
 396 }
 397
 398 /* Converts an inferior process id to a string.  Like
 399    target_pid_to_str, but special cases the null process.  */
 400
 401 static std::string
 402 inferior_pid_to_str (int pid)
 403 {
 404   if (pid != 0)
 405     return target_pid_to_str (ptid_t (pid));
 406   else
 407     return _("<null>");
 408 }
 409
 410 /* See inferior.h.  */
 411
 412 void
 413 print_selected_inferior (struct ui_out *uiout)
 414 {
 415   struct inferior *inf = current_inferior ();
 416   const char *filename = inf->pspace->exec_filename.get ();
 417
 418   if (filename == NULL)
 419     filename = _("<noexec>");
 420
 421   uiout->message (_("[Switching to inferior %d [%s] (%s)]\n"),
 422                   inf->num, inferior_pid_to_str (inf->pid).c_str (), filename);
 423 }
 424
 425 /* Helper for print_inferior.  Returns the 'connection-id' string for
 426    PROC_TARGET.  */
 427
 428 static std::string
 429 uiout_field_connection (process_stratum_target *proc_target)
 430 {
 431   if (proc_target == NULL)
 432     {
 433       return {};
 434     }
 435   else if (proc_target->connection_string () != NULL)
 436     {
 437       return string_printf ("%d (%s %s)",
 438                             proc_target->connection_number,
 439                             proc_target->shortname (),
 440                             proc_target->connection_string ());
 441     }
 442   else
 443     {
 444       return string_printf ("%d (%s)",
 445                             proc_target->connection_number,
 446                             proc_target->shortname ());
 447     }
 448 }
 449
 450 /* Prints the list of inferiors and their details on UIOUT.  This is a
 451    version of 'info_inferior_command' suitable for use from MI.
 452
 453    If REQUESTED_INFERIORS is not NULL, it's a list of GDB ids of the
 454    inferiors that should be printed.  Otherwise, all inferiors are
 455    printed.  */
 456
 457 static void
 458 print_inferior (struct ui_out *uiout, const char *requested_inferiors)
 459 {
 460   int inf_count = 0;
 461   size_t connection_id_len = 20;
 462
 463   /* Compute number of inferiors we will print.  */
 464   for (inferior *inf : all_inferiors ())
 465     {
 466       if (!number_is_in_list (requested_inferiors, inf->num))
 467         continue;
 468
 469       std::string conn = uiout_field_connection (inf->process_target ());
 470       if (connection_id_len < conn.size ())
 471         connection_id_len = conn.size ();
 472
 473       ++inf_count;
 474     }
 475
 476   if (inf_count == 0)
 477     {
 478       uiout->message ("No inferiors.\n");
 479       return;
 480     }
 481
 482   ui_out_emit_table table_emitter (uiout, 5, inf_count, "inferiors");
 483   uiout->table_header (1, ui_left, "current", "");
 484   uiout->table_header (4, ui_left, "number", "Num");
 485   uiout->table_header (17, ui_left, "target-id", "Description");
 486   uiout->table_header (connection_id_len, ui_left,
 487                        "connection-id", "Connection");
 488   uiout->table_header (17, ui_left, "exec", "Executable");
 489
 490   uiout->table_body ();
 491
 492   /* Restore the current thread after the loop because we switch the
 493      inferior in the loop.  */
 494   scoped_restore_current_pspace_and_thread restore_pspace_thread;
 495   inferior *current_inf = current_inferior ();
 496   for (inferior *inf : all_inferiors ())
 497     {
 498       if (!number_is_in_list (requested_inferiors, inf->num))
 499         continue;
 500
 501       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 502
 503       if (inf == current_inf)
 504         uiout->field_string ("current", "*");
 505       else
 506         uiout->field_skip ("current");
 507
 508       uiout->field_signed ("number", inf->num);
 509
 510       /* Because target_pid_to_str uses current_top_target,
 511          switch the inferior.  */
 512       switch_to_inferior_no_thread (inf);
 513
 514       uiout->field_string ("target-id", inferior_pid_to_str (inf->pid));
 515
 516       std::string conn = uiout_field_connection (inf->process_target ());
 517       uiout->field_string ("connection-id", conn.c_str ());
 518
 519       if (inf->pspace->exec_filename != nullptr)
 520         uiout->field_string ("exec", inf->pspace->exec_filename.get ());
 521       else
 522         uiout->field_skip ("exec");
 523
 524       /* Print extra info that isn't really fit to always present in
 525          tabular form.  Currently we print the vfork parent/child
 526          relationships, if any.  */
 527       if (inf->vfork_parent)
 528         {
 529           uiout->text (_("\n\tis vfork child of inferior "));
 530           uiout->field_signed ("vfork-parent", inf->vfork_parent->num);
 531         }
 532       if (inf->vfork_child)
 533         {
 534           uiout->text (_("\n\tis vfork parent of inferior "));
 535           uiout->field_signed ("vfork-child", inf->vfork_child->num);
 536         }
 537
 538       uiout->text ("\n");
 539     }
 540 }
 541
 542 static void
 543 detach_inferior_command (const char *args, int from_tty)
 544 {
 545   if (!args || !*args)
 546     error (_("Requires argument (inferior id(s) to detach)"));
 547
 548   scoped_restore_current_thread restore_thread;
 549
 550   number_or_range_parser parser (args);
 551   while (!parser.finished ())
 552     {
 553       int num = parser.get_number ();
 554
 555       inferior *inf = find_inferior_id (num);
 556       if (inf == NULL)
 557         {
 558           warning (_("Inferior ID %d not known."), num);
 559           continue;
 560         }
 561
 562       if (inf->pid == 0)
 563         {
 564           warning (_("Inferior ID %d is not running."), num);
 565           continue;
 566         }
 567
 568       thread_info *tp = any_thread_of_inferior (inf);
 569       if (tp == NULL)
 570         {
 571           warning (_("Inferior ID %d has no threads."), num);
 572           continue;
 573         }
 574
 575       switch_to_thread (tp);
 576
 577       detach_command (NULL, from_tty);
 578     }
 579 }
 580
 581 static void
 582 kill_inferior_command (const char *args, int from_tty)
 583 {
 584   if (!args || !*args)
 585     error (_("Requires argument (inferior id(s) to kill)"));
 586
 587   scoped_restore_current_thread restore_thread;
 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   set_current_inferior (add_inferior_silent (0));
 964   current_inferior_->pspace = current_program_space;
 965   current_inferior_->aspace = current_program_space->aspace;
 966   /* The architecture will be initialized shortly, by
 967      initialize_current_architecture.  */
 968
 969   add_info ("inferiors", info_inferiors_command,
 970             _("Print a list of inferiors being managed.\n\
 971 Usage: info inferiors [ID]...\n\
 972 If IDs are specified, the list is limited to just those inferiors.\n\
 973 By default all inferiors are displayed."));
 974
 975   c = add_com ("add-inferior", no_class, add_inferior_command, _("\
 976 Add a new inferior.\n\
 977 Usage: add-inferior [-copies N] [-exec FILENAME] [-no-connection]\n\
 978 N is the optional number of inferiors to add, default is 1.\n\
 979 FILENAME is the file name of the executable to use\n\
 980 as main program.\n\
 981 By default, the new inferior inherits the current inferior's connection.\n\
 982 If -no-connection is specified, the new inferior begins with\n\
 983 no target connection yet."));
 984   set_cmd_completer (c, filename_completer);
 985
 986   add_com ("remove-inferiors", no_class, remove_inferior_command, _("\
 987 Remove inferior ID (or list of IDs).\n\
 988 Usage: remove-inferiors ID..."));
 989
 990   add_com ("clone-inferior", no_class, clone_inferior_command, _("\
 991 Clone inferior ID.\n\
 992 Usage: clone-inferior [-copies N] [-no-connection] [ID]\n\
 993 Add N copies of inferior ID.  The new inferiors have the same\n\
 994 executable loaded as the copied inferior.  If -copies is not specified,\n\
 995 adds 1 copy.  If ID is not specified, it is the current inferior\n\
 996 that is cloned.\n\
 997 By default, the new inferiors inherit the copied inferior's connection.\n\
 998 If -no-connection is specified, the new inferiors begin with\n\
 999 no target connection yet."));
1000
1001   add_cmd ("inferiors", class_run, detach_inferior_command, _("\
1002 Detach from inferior ID (or list of IDS).\n\
1003 Usage; detach inferiors ID..."),
1004            &detachlist);
1005
1006   add_cmd ("inferiors", class_run, kill_inferior_command, _("\
1007 Kill inferior ID (or list of IDs).\n\
1008 Usage: kill inferiors ID..."),
1009            &killlist);
1010
1011   add_cmd ("inferior", class_run, inferior_command, _("\
1012 Use this command to switch between inferiors.\n\
1013 Usage: inferior ID\n\
1014 The new inferior ID must be currently known."),
1015            &cmdlist);
1016
1017   add_setshow_boolean_cmd ("inferior-events", no_class,
1018          &print_inferior_events, _("\
1019 Set printing of inferior events (such as inferior start and exit)."), _("\
1020 Show printing of inferior events (such as inferior start and exit)."), NULL,
1021          NULL,
1022          show_print_inferior_events,
1023          &setprintlist, &showprintlist);
1024
1025   create_internalvar_type_lazy ("_inferior", &inferior_funcs, NULL);
1026 }