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