gdb/inferior.c

   1 /* Multi-process control for GDB, the GNU debugger.
   2
   3    Copyright (C) 2008-2021 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 the current inferior,
 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   if (args == nullptr)
 639     {
 640       inf = current_inferior ();
 641       gdb_assert (inf != nullptr);
 642       const char *filename = inf->pspace->exec_filename.get ();
 643
 644       if (filename == nullptr)
 645         filename = _("<noexec>");
 646
 647       printf_filtered (_("[Current inferior is %d [%s] (%s)]\n"),
 648                        inf->num, inferior_pid_to_str (inf->pid).c_str (),
 649                        filename);
 650     }
 651   else
 652     {
 653       num = parse_and_eval_long (args);
 654
 655       inf = find_inferior_id (num);
 656       if (inf == NULL)
 657         error (_("Inferior ID %d not known."), num);
 658
 659       if (inf->pid != 0)
 660         {
 661           if (inf != current_inferior ())
 662             {
 663               thread_info *tp = any_thread_of_inferior (inf);
 664               if (tp == NULL)
 665                 error (_("Inferior has no threads."));
 666
 667               switch_to_thread (tp);
 668             }
 669
 670           gdb::observers::user_selected_context_changed.notify
 671             (USER_SELECTED_INFERIOR
 672              | USER_SELECTED_THREAD
 673              | USER_SELECTED_FRAME);
 674         }
 675       else
 676         {
 677           switch_to_inferior_no_thread (inf);
 678
 679           gdb::observers::user_selected_context_changed.notify
 680             (USER_SELECTED_INFERIOR);
 681         }
 682     }
 683 }
 684
 685 /* Print information about currently known inferiors.  */
 686
 687 static void
 688 info_inferiors_command (const char *args, int from_tty)
 689 {
 690   print_inferior (current_uiout, args);
 691 }
 692
 693 /* remove-inferior ID */
 694
 695 static void
 696 remove_inferior_command (const char *args, int from_tty)
 697 {
 698   if (args == NULL || *args == '\0')
 699     error (_("Requires an argument (inferior id(s) to remove)"));
 700
 701   number_or_range_parser parser (args);
 702   while (!parser.finished ())
 703     {
 704       int num = parser.get_number ();
 705       struct inferior *inf = find_inferior_id (num);
 706
 707       if (inf == NULL)
 708         {
 709           warning (_("Inferior ID %d not known."), num);
 710           continue;
 711         }
 712
 713       if (!inf->deletable ())
 714         {
 715           warning (_("Can not remove current inferior %d."), num);
 716           continue;
 717         }
 718
 719       if (inf->pid != 0)
 720         {
 721           warning (_("Can not remove active inferior %d."), num);
 722           continue;
 723         }
 724
 725       delete_inferior (inf);
 726     }
 727 }
 728
 729 struct inferior *
 730 add_inferior_with_spaces (void)
 731 {
 732   struct address_space *aspace;
 733   struct program_space *pspace;
 734   struct inferior *inf;
 735   struct gdbarch_info info;
 736
 737   /* If all inferiors share an address space on this system, this
 738      doesn't really return a new address space; otherwise, it
 739      really does.  */
 740   aspace = maybe_new_address_space ();
 741   pspace = new program_space (aspace);
 742   inf = add_inferior (0);
 743   inf->pspace = pspace;
 744   inf->aspace = pspace->aspace;
 745
 746   /* Setup the inferior's initial arch, based on information obtained
 747      from the global "set ..." options.  */
 748   gdbarch_info_init (&info);
 749   inf->gdbarch = gdbarch_find_by_info (info);
 750   /* The "set ..." options reject invalid settings, so we should
 751      always have a valid arch by now.  */
 752   gdb_assert (inf->gdbarch != NULL);
 753
 754   return inf;
 755 }
 756
 757 /* Switch to inferior NEW_INF, a new inferior, and unless
 758    NO_CONNECTION is true, push the process_stratum_target of ORG_INF
 759    to NEW_INF.  */
 760
 761 static void
 762 switch_to_inferior_and_push_target (inferior *new_inf,
 763                                     bool no_connection, inferior *org_inf)
 764 {
 765   process_stratum_target *proc_target = org_inf->process_target ();
 766
 767   /* Switch over temporarily, while reading executable and
 768      symbols.  */
 769   switch_to_inferior_no_thread (new_inf);
 770
 771   /* Reuse the target for new inferior.  */
 772   if (!no_connection && proc_target != NULL)
 773     {
 774       new_inf->push_target (proc_target);
 775       if (proc_target->connection_string () != NULL)
 776         printf_filtered (_("Added inferior %d on connection %d (%s %s)\n"),
 777                          new_inf->num,
 778                          proc_target->connection_number,
 779                          proc_target->shortname (),
 780                          proc_target->connection_string ());
 781       else
 782         printf_filtered (_("Added inferior %d on connection %d (%s)\n"),
 783                          new_inf->num,
 784                          proc_target->connection_number,
 785                          proc_target->shortname ());
 786     }
 787   else
 788     printf_filtered (_("Added inferior %d\n"), new_inf->num);
 789 }
 790
 791 /* add-inferior [-copies N] [-exec FILENAME] [-no-connection] */
 792
 793 static void
 794 add_inferior_command (const char *args, int from_tty)
 795 {
 796   int i, copies = 1;
 797   gdb::unique_xmalloc_ptr<char> exec;
 798   symfile_add_flags add_flags = 0;
 799   bool no_connection = false;
 800
 801   if (from_tty)
 802     add_flags |= SYMFILE_VERBOSE;
 803
 804   if (args)
 805     {
 806       gdb_argv built_argv (args);
 807
 808       for (char **argv = built_argv.get (); *argv != NULL; argv++)
 809         {
 810           if (**argv == '-')
 811             {
 812               if (strcmp (*argv, "-copies") == 0)
 813                 {
 814                   ++argv;
 815                   if (!*argv)
 816                     error (_("No argument to -copies"));
 817                   copies = parse_and_eval_long (*argv);
 818                 }
 819               else if (strcmp (*argv, "-no-connection") == 0)
 820                 no_connection = true;
 821               else if (strcmp (*argv, "-exec") == 0)
 822                 {
 823                   ++argv;
 824                   if (!*argv)
 825                     error (_("No argument to -exec"));
 826                   exec.reset (tilde_expand (*argv));
 827                 }
 828             }
 829           else
 830             error (_("Invalid argument"));
 831         }
 832     }
 833
 834   inferior *orginf = current_inferior ();
 835
 836   scoped_restore_current_pspace_and_thread restore_pspace_thread;
 837
 838   for (i = 0; i < copies; ++i)
 839     {
 840       inferior *inf = add_inferior_with_spaces ();
 841
 842       switch_to_inferior_and_push_target (inf, no_connection, orginf);
 843
 844       if (exec != NULL)
 845         {
 846           exec_file_attach (exec.get (), from_tty);
 847           symbol_file_add_main (exec.get (), add_flags);
 848         }
 849     }
 850 }
 851
 852 /* clone-inferior [-copies N] [ID] [-no-connection] */
 853
 854 static void
 855 clone_inferior_command (const char *args, int from_tty)
 856 {
 857   int i, copies = 1;
 858   struct inferior *orginf = NULL;
 859   bool no_connection = false;
 860
 861   if (args)
 862     {
 863       gdb_argv built_argv (args);
 864
 865       char **argv = built_argv.get ();
 866       for (; *argv != NULL; argv++)
 867         {
 868           if (**argv == '-')
 869             {
 870               if (strcmp (*argv, "-copies") == 0)
 871                 {
 872                   ++argv;
 873                   if (!*argv)
 874                     error (_("No argument to -copies"));
 875                   copies = parse_and_eval_long (*argv);
 876
 877                   if (copies < 0)
 878                     error (_("Invalid copies number"));
 879                 }
 880               else if (strcmp (*argv, "-no-connection") == 0)
 881                 no_connection = true;
 882             }
 883           else
 884             {
 885               if (orginf == NULL)
 886                 {
 887                   int num;
 888
 889                   /* The first non-option (-) argument specified the
 890                      program space ID.  */
 891                   num = parse_and_eval_long (*argv);
 892                   orginf = find_inferior_id (num);
 893
 894                   if (orginf == NULL)
 895                     error (_("Inferior ID %d not known."), num);
 896                   continue;
 897                 }
 898               else
 899                 error (_("Invalid argument"));
 900             }
 901         }
 902     }
 903
 904   /* If no inferior id was specified, then the user wants to clone the
 905      current inferior.  */
 906   if (orginf == NULL)
 907     orginf = current_inferior ();
 908
 909   scoped_restore_current_pspace_and_thread restore_pspace_thread;
 910
 911   for (i = 0; i < copies; ++i)
 912     {
 913       struct address_space *aspace;
 914       struct program_space *pspace;
 915       struct inferior *inf;
 916
 917       /* If all inferiors share an address space on this system, this
 918          doesn't really return a new address space; otherwise, it
 919          really does.  */
 920       aspace = maybe_new_address_space ();
 921       pspace = new program_space (aspace);
 922       inf = add_inferior (0);
 923       inf->pspace = pspace;
 924       inf->aspace = pspace->aspace;
 925       inf->gdbarch = orginf->gdbarch;
 926
 927       switch_to_inferior_and_push_target (inf, no_connection, orginf);
 928
 929       /* If the original inferior had a user specified target
 930          description, make the clone use it too.  */
 931       if (target_desc_info_from_user_p (inf->tdesc_info))
 932         copy_inferior_target_desc_info (inf, orginf);
 933
 934       clone_program_space (pspace, orginf->pspace);
 935     }
 936 }
 937
 938 /* Print notices when new inferiors are created and die.  */
 939 static void
 940 show_print_inferior_events (struct ui_file *file, int from_tty,
 941                            struct cmd_list_element *c, const char *value)
 942 {
 943   fprintf_filtered (file, _("Printing of inferior events is %s.\n"), value);
 944 }
 945
 946 /* Return a new value for the selected inferior's id.  */
 947
 948 static struct value *
 949 inferior_id_make_value (struct gdbarch *gdbarch, struct internalvar *var,
 950                         void *ignore)
 951 {
 952   struct inferior *inf = current_inferior ();
 953
 954   return value_from_longest (builtin_type (gdbarch)->builtin_int, inf->num);
 955 }
 956
 957 /* Implementation of `$_inferior' variable.  */
 958
 959 static const struct internalvar_funcs inferior_funcs =
 960 {
 961   inferior_id_make_value,
 962   NULL,
 963   NULL
 964 };
 965
 966 \f
 967
 968 void
 969 initialize_inferiors (void)
 970 {
 971   struct cmd_list_element *c = NULL;
 972
 973   /* There's always one inferior.  Note that this function isn't an
 974      automatic _initialize_foo function, since other _initialize_foo
 975      routines may need to install their per-inferior data keys.  We
 976      can only allocate an inferior when all those modules have done
 977      that.  Do this after initialize_progspace, due to the
 978      current_program_space reference.  */
 979   set_current_inferior (add_inferior_silent (0));
 980   current_inferior_->pspace = current_program_space;
 981   current_inferior_->aspace = current_program_space->aspace;
 982   /* The architecture will be initialized shortly, by
 983      initialize_current_architecture.  */
 984
 985   add_info ("inferiors", info_inferiors_command,
 986             _("Print a list of inferiors being managed.\n\
 987 Usage: info inferiors [ID]...\n\
 988 If IDs are specified, the list is limited to just those inferiors.\n\
 989 By default all inferiors are displayed."));
 990
 991   c = add_com ("add-inferior", no_class, add_inferior_command, _("\
 992 Add a new inferior.\n\
 993 Usage: add-inferior [-copies N] [-exec FILENAME] [-no-connection]\n\
 994 N is the optional number of inferiors to add, default is 1.\n\
 995 FILENAME is the file name of the executable to use\n\
 996 as main program.\n\
 997 By default, the new inferior inherits the current inferior's connection.\n\
 998 If -no-connection is specified, the new inferior begins with\n\
 999 no target connection yet."));
1000   set_cmd_completer (c, filename_completer);
1001
1002   add_com ("remove-inferiors", no_class, remove_inferior_command, _("\
1003 Remove inferior ID (or list of IDs).\n\
1004 Usage: remove-inferiors ID..."));
1005
1006   add_com ("clone-inferior", no_class, clone_inferior_command, _("\
1007 Clone inferior ID.\n\
1008 Usage: clone-inferior [-copies N] [-no-connection] [ID]\n\
1009 Add N copies of inferior ID.  The new inferiors have the same\n\
1010 executable loaded as the copied inferior.  If -copies is not specified,\n\
1011 adds 1 copy.  If ID is not specified, it is the current inferior\n\
1012 that is cloned.\n\
1013 By default, the new inferiors inherit the copied inferior's connection.\n\
1014 If -no-connection is specified, the new inferiors begin with\n\
1015 no target connection yet."));
1016
1017   add_cmd ("inferiors", class_run, detach_inferior_command, _("\
1018 Detach from inferior ID (or list of IDS).\n\
1019 Usage; detach inferiors ID..."),
1020            &detachlist);
1021
1022   add_cmd ("inferiors", class_run, kill_inferior_command, _("\
1023 Kill inferior ID (or list of IDs).\n\
1024 Usage: kill inferiors ID..."),
1025            &killlist);
1026
1027   add_cmd ("inferior", class_run, inferior_command, _("\
1028 Use this command to switch between inferiors.\n\
1029 Usage: inferior ID\n\
1030 The new inferior ID must be currently known."),
1031            &cmdlist);
1032
1033   add_setshow_boolean_cmd ("inferior-events", no_class,
1034          &print_inferior_events, _("\
1035 Set printing of inferior events (such as inferior start and exit)."), _("\
1036 Show printing of inferior events (such as inferior start and exit)."), NULL,
1037          NULL,
1038          show_print_inferior_events,
1039          &setprintlist, &showprintlist);
1040
1041   create_internalvar_type_lazy ("_inferior", &inferior_funcs, NULL);
1042 }