gdb/inferior.c

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