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