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