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