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 "arch-utils.h"
  35 #include "target-descriptions.h"
  36 #include "readline/tilde.h"
  37 #include "progspace-and-thread.h"
  38
  39 /* Keep a registry of per-inferior data-pointers required by other GDB
  40    modules.  */
  41
  42 DEFINE_REGISTRY (inferior, REGISTRY_ACCESS_FIELD)
  43
  44 intrusive_list<inferior> inferior_list;
  45 static int highest_inferior_num;
  46
  47 /* See inferior.h.  */
  48 bool print_inferior_events = true;
  49
  50 /* The Current Inferior.  This is a strong reference.  I.e., whenever
  51    an inferior is the current inferior, its refcount is
  52    incremented.  */
  53 static inferior_ref current_inferior_;
  54
  55 struct inferior*
  56 current_inferior (void)
  57 {
  58   return current_inferior_.get ();
  59 }
  60
  61 void
  62 set_current_inferior (struct inferior *inf)
  63 {
  64   /* There's always an inferior.  */
  65   gdb_assert (inf != NULL);
  66
  67   current_inferior_ = inferior_ref::new_reference (inf);
  68 }
  69
  70 private_inferior::~private_inferior () = default;
  71
  72 inferior::~inferior ()
  73 {
  74   inferior *inf = this;
  75
  76   m_continuations.clear ();
  77   inferior_free_data (inf);
  78   target_desc_info_free (inf->tdesc_info);
  79 }
  80
  81 inferior::inferior (int pid_)
  82   : num (++highest_inferior_num),
  83     pid (pid_),
  84     environment (gdb_environ::from_host_environ ()),
  85     registry_data ()
  86 {
  87   inferior_alloc_data (this);
  88
  89   m_target_stack.push (get_dummy_target ());
  90 }
  91
  92 /* See inferior.h.  */
  93
  94 int
  95 inferior::unpush_target (struct target_ops *t)
  96 {
  97   /* If unpushing the process stratum target from the inferior while threads
  98      exist in the inferior, ensure that we don't leave any threads of the
  99      inferior in the target's "resumed with pending wait status" list.
 100
 101      See also the comment in set_thread_exited.  */
 102   if (t->stratum () == process_stratum)
 103     {
 104       process_stratum_target *proc_target = as_process_stratum_target (t);
 105
 106       for (thread_info *thread : this->non_exited_threads ())
 107         proc_target->maybe_remove_resumed_with_pending_wait_status (thread);
 108     }
 109
 110   return m_target_stack.unpush (t);
 111 }
 112
 113 void
 114 inferior::set_tty (std::string terminal_name)
 115 {
 116   m_terminal = std::move (terminal_name);
 117 }
 118
 119 const std::string &
 120 inferior::tty ()
 121 {
 122   return m_terminal;
 123 }
 124
 125 void
 126 inferior::add_continuation (std::function<void ()> &&cont)
 127 {
 128   m_continuations.emplace_front (std::move (cont));
 129 }
 130
 131 void
 132 inferior::do_all_continuations ()
 133 {
 134   while (!m_continuations.empty ())
 135     {
 136       auto iter = m_continuations.begin ();
 137       (*iter) ();
 138       m_continuations.erase (iter);
 139     }
 140 }
 141
 142 struct inferior *
 143 add_inferior_silent (int pid)
 144 {
 145   inferior *inf = new inferior (pid);
 146
 147   inferior_list.push_back (*inf);
 148
 149   gdb::observers::inferior_added.notify (inf);
 150
 151   if (pid != 0)
 152     inferior_appeared (inf, pid);
 153
 154   return inf;
 155 }
 156
 157 struct inferior *
 158 add_inferior (int pid)
 159 {
 160   struct inferior *inf = add_inferior_silent (pid);
 161
 162   if (print_inferior_events)
 163     {
 164       if (pid != 0)
 165         printf_unfiltered (_("[New inferior %d (%s)]\n"),
 166                            inf->num,
 167                            target_pid_to_str (ptid_t (pid)).c_str ());
 168       else
 169         printf_unfiltered (_("[New inferior %d]\n"), inf->num);
 170     }
 171
 172   return inf;
 173 }
 174
 175 /* See inferior.h.  */
 176
 177 void
 178 inferior::clear_thread_list (bool silent)
 179 {
 180   thread_list.clear_and_dispose ([=] (thread_info *thr)
 181     {
 182       set_thread_exited (thr, silent);
 183       if (thr->deletable ())
 184         delete thr;
 185     });
 186   ptid_thread_map.clear ();
 187 }
 188
 189 void
 190 delete_inferior (struct inferior *inf)
 191 {
 192   inf->clear_thread_list (true);
 193
 194   auto it = inferior_list.iterator_to (*inf);
 195   inferior_list.erase (it);
 196
 197   gdb::observers::inferior_removed.notify (inf);
 198
 199   /* If this program space is rendered useless, remove it. */
 200   if (inf->pspace->empty ())
 201     delete inf->pspace;
 202
 203   delete inf;
 204 }
 205
 206 /* If SILENT then be quiet -- don't announce a inferior exit, or the
 207    exit of its threads.  */
 208
 209 static void
 210 exit_inferior_1 (struct inferior *inf, int silent)
 211 {
 212   inf->clear_thread_list (silent);
 213
 214   gdb::observers::inferior_exit.notify (inf);
 215
 216   inf->pid = 0;
 217   inf->fake_pid_p = false;
 218   inf->priv = NULL;
 219
 220   if (inf->vfork_parent != NULL)
 221     {
 222       inf->vfork_parent->vfork_child = NULL;
 223       inf->vfork_parent = NULL;
 224     }
 225   if (inf->vfork_child != NULL)
 226     {
 227       inf->vfork_child->vfork_parent = NULL;
 228       inf->vfork_child = NULL;
 229     }
 230
 231   inf->pending_detach = 0;
 232   /* Reset it.  */
 233   inf->control = inferior_control_state (NO_STOP_QUIETLY);
 234
 235   /* Clear the register cache and the frame cache.  */
 236   registers_changed ();
 237   reinit_frame_cache ();
 238 }
 239
 240 void
 241 exit_inferior (inferior *inf)
 242 {
 243   exit_inferior_1 (inf, 0);
 244 }
 245
 246 void
 247 exit_inferior_silent (inferior *inf)
 248 {
 249   exit_inferior_1 (inf, 1);
 250 }
 251
 252 /* See inferior.h.  */
 253
 254 void
 255 detach_inferior (inferior *inf)
 256 {
 257   /* Save the pid, since exit_inferior_1 will reset it.  */
 258   int pid = inf->pid;
 259
 260   exit_inferior_1 (inf, 0);
 261
 262   if (print_inferior_events)
 263     printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
 264                        inf->num,
 265                        target_pid_to_str (ptid_t (pid)).c_str ());
 266 }
 267
 268 void
 269 inferior_appeared (struct inferior *inf, int pid)
 270 {
 271   /* If this is the first inferior with threads, reset the global
 272      thread id.  */
 273   delete_exited_threads ();
 274   if (!any_thread_p ())
 275     init_thread_list ();
 276
 277   inf->pid = pid;
 278   inf->has_exit_code = 0;
 279   inf->exit_code = 0;
 280
 281   gdb::observers::inferior_appeared.notify (inf);
 282 }
 283
 284 struct inferior *
 285 find_inferior_id (int num)
 286 {
 287   for (inferior *inf : all_inferiors ())
 288     if (inf->num == num)
 289       return inf;
 290
 291   return NULL;
 292 }
 293
 294 struct inferior *
 295 find_inferior_pid (process_stratum_target *targ, int pid)
 296 {
 297   /* Looking for inferior pid == 0 is always wrong, and indicative of
 298      a bug somewhere else.  There may be more than one with pid == 0,
 299      for instance.  */
 300   gdb_assert (pid != 0);
 301
 302   for (inferior *inf : all_inferiors (targ))
 303     if (inf->pid == pid)
 304       return inf;
 305
 306   return NULL;
 307 }
 308
 309 /* See inferior.h */
 310
 311 struct inferior *
 312 find_inferior_ptid (process_stratum_target *targ, ptid_t ptid)
 313 {
 314   return find_inferior_pid (targ, ptid.pid ());
 315 }
 316
 317 /* See inferior.h.  */
 318
 319 struct inferior *
 320 find_inferior_for_program_space (struct program_space *pspace)
 321 {
 322   struct inferior *cur_inf = current_inferior ();
 323
 324   if (cur_inf->pspace == pspace)
 325     return cur_inf;
 326
 327   for (inferior *inf : all_inferiors ())
 328     if (inf->pspace == pspace)
 329       return inf;
 330
 331   return NULL;
 332 }
 333
 334 int
 335 have_inferiors (void)
 336 {
 337   for (inferior *inf ATTRIBUTE_UNUSED : all_non_exited_inferiors ())
 338     return 1;
 339
 340   return 0;
 341 }
 342
 343 /* Return the number of live inferiors.  We account for the case
 344    where an inferior might have a non-zero pid but no threads, as
 345    in the middle of a 'mourn' operation.  */
 346
 347 int
 348 number_of_live_inferiors (process_stratum_target *proc_target)
 349 {
 350   int num_inf = 0;
 351
 352   for (inferior *inf : all_non_exited_inferiors (proc_target))
 353     if (inf->has_execution ())
 354       for (thread_info *tp ATTRIBUTE_UNUSED : inf->non_exited_threads ())
 355         {
 356           /* Found a live thread in this inferior, go to the next
 357              inferior.  */
 358           ++num_inf;
 359           break;
 360         }
 361
 362   return num_inf;
 363 }
 364
 365 /* Return true if there is at least one live inferior.  */
 366
 367 int
 368 have_live_inferiors (void)
 369 {
 370   return number_of_live_inferiors (NULL) > 0;
 371 }
 372
 373 /* Prune away any unused inferiors, and then prune away no longer used
 374    program spaces.  */
 375
 376 void
 377 prune_inferiors (void)
 378 {
 379   for (inferior *inf : all_inferiors_safe ())
 380     {
 381       if (!inf->deletable ()
 382           || !inf->removable
 383           || inf->pid != 0)
 384         continue;
 385
 386       delete_inferior (inf);
 387     }
 388 }
 389
 390 /* Simply returns the count of inferiors.  */
 391
 392 int
 393 number_of_inferiors (void)
 394 {
 395   auto rng = all_inferiors ();
 396   return std::distance (rng.begin (), rng.end ());
 397 }
 398
 399 /* Converts an inferior process id to a string.  Like
 400    target_pid_to_str, but special cases the null process.  */
 401
 402 static std::string
 403 inferior_pid_to_str (int pid)
 404 {
 405   if (pid != 0)
 406     return target_pid_to_str (ptid_t (pid));
 407   else
 408     return _("<null>");
 409 }
 410
 411 /* See inferior.h.  */
 412
 413 void
 414 print_selected_inferior (struct ui_out *uiout)
 415 {
 416   struct inferior *inf = current_inferior ();
 417   const char *filename = inf->pspace->exec_filename.get ();
 418
 419   if (filename == NULL)
 420     filename = _("<noexec>");
 421
 422   uiout->message (_("[Switching to inferior %d [%s] (%s)]\n"),
 423                   inf->num, inferior_pid_to_str (inf->pid).c_str (), filename);
 424 }
 425
 426 /* Helper for print_inferior.  Returns the 'connection-id' string for
 427    PROC_TARGET.  */
 428
 429 static std::string
 430 uiout_field_connection (process_stratum_target *proc_target)
 431 {
 432   if (proc_target == NULL)
 433     {
 434       return {};
 435     }
 436   else if (proc_target->connection_string () != NULL)
 437     {
 438       return string_printf ("%d (%s %s)",
 439                             proc_target->connection_number,
 440                             proc_target->shortname (),
 441                             proc_target->connection_string ());
 442     }
 443   else
 444     {
 445       return string_printf ("%d (%s)",
 446                             proc_target->connection_number,
 447                             proc_target->shortname ());
 448     }
 449 }
 450
 451 /* Prints the list of inferiors and their details on UIOUT.  This is a
 452    version of 'info_inferior_command' suitable for use from MI.
 453
 454    If REQUESTED_INFERIORS is not NULL, it's a list of GDB ids of the
 455    inferiors that should be printed.  Otherwise, all inferiors are
 456    printed.  */
 457
 458 static void
 459 print_inferior (struct ui_out *uiout, const char *requested_inferiors)
 460 {
 461   int inf_count = 0;
 462   size_t connection_id_len = 20;
 463
 464   /* Compute number of inferiors we will print.  */
 465   for (inferior *inf : all_inferiors ())
 466     {
 467       if (!number_is_in_list (requested_inferiors, inf->num))
 468         continue;
 469
 470       std::string conn = uiout_field_connection (inf->process_target ());
 471       if (connection_id_len < conn.size ())
 472         connection_id_len = conn.size ();
 473
 474       ++inf_count;
 475     }
 476
 477   if (inf_count == 0)
 478     {
 479       uiout->message ("No inferiors.\n");
 480       return;
 481     }
 482
 483   ui_out_emit_table table_emitter (uiout, 5, inf_count, "inferiors");
 484   uiout->table_header (1, ui_left, "current", "");
 485   uiout->table_header (4, ui_left, "number", "Num");
 486   uiout->table_header (17, ui_left, "target-id", "Description");
 487   uiout->table_header (connection_id_len, ui_left,
 488                        "connection-id", "Connection");
 489   uiout->table_header (17, ui_left, "exec", "Executable");
 490
 491   uiout->table_body ();
 492
 493   /* Restore the current thread after the loop because we switch the
 494      inferior in the loop.  */
 495   scoped_restore_current_pspace_and_thread restore_pspace_thread;
 496   inferior *current_inf = current_inferior ();
 497   for (inferior *inf : all_inferiors ())
 498     {
 499       if (!number_is_in_list (requested_inferiors, inf->num))
 500         continue;
 501
 502       ui_out_emit_tuple tuple_emitter (uiout, NULL);
 503
 504       if (inf == current_inf)
 505         uiout->field_string ("current", "*");
 506       else
 507         uiout->field_skip ("current");
 508
 509       uiout->field_signed ("number", inf->num);
 510
 511       /* Because target_pid_to_str uses the current inferior,
 512          switch the inferior.  */
 513       switch_to_inferior_no_thread (inf);
 514
 515       uiout->field_string ("target-id", inferior_pid_to_str (inf->pid));
 516
 517       std::string conn = uiout_field_connection (inf->process_target ());
 518       uiout->field_string ("connection-id", conn);
 519
 520       if (inf->pspace->exec_filename != nullptr)
 521         uiout->field_string ("exec", inf->pspace->exec_filename.get ());
 522       else
 523         uiout->field_skip ("exec");
 524
 525       /* Print extra info that isn't really fit to always present in
 526          tabular form.  Currently we print the vfork parent/child
 527          relationships, if any.  */
 528       if (inf->vfork_parent)
 529         {
 530           uiout->text (_("\n\tis vfork child of inferior "));
 531           uiout->field_signed ("vfork-parent", inf->vfork_parent->num);
 532         }
 533       if (inf->vfork_child)
 534         {
 535           uiout->text (_("\n\tis vfork parent of inferior "));
 536           uiout->field_signed ("vfork-child", inf->vfork_child->num);
 537         }
 538
 539       uiout->text ("\n");
 540     }
 541 }
 542
 543 static void
 544 detach_inferior_command (const char *args, int from_tty)
 545 {
 546   if (!args || !*args)
 547     error (_("Requires argument (inferior id(s) to detach)"));
 548
 549   scoped_restore_current_thread restore_thread;
 550
 551   number_or_range_parser parser (args);
 552   while (!parser.finished ())
 553     {
 554       int num = parser.get_number ();
 555
 556       inferior *inf = find_inferior_id (num);
 557       if (inf == NULL)
 558         {
 559           warning (_("Inferior ID %d not known."), num);
 560           continue;
 561         }
 562
 563       if (inf->pid == 0)
 564         {
 565           warning (_("Inferior ID %d is not running."), num);
 566           continue;
 567         }
 568
 569       thread_info *tp = any_thread_of_inferior (inf);
 570       if (tp == NULL)
 571         {
 572           warning (_("Inferior ID %d has no threads."), num);
 573           continue;
 574         }
 575
 576       switch_to_thread (tp);
 577
 578       detach_command (NULL, from_tty);
 579     }
 580 }
 581
 582 static void
 583 kill_inferior_command (const char *args, int from_tty)
 584 {
 585   if (!args || !*args)
 586     error (_("Requires argument (inferior id(s) to kill)"));
 587
 588   scoped_restore_current_thread restore_thread;
 589
 590   number_or_range_parser parser (args);
 591   while (!parser.finished ())
 592     {
 593       int num = parser.get_number ();
 594
 595       inferior *inf = find_inferior_id (num);
 596       if (inf == NULL)
 597         {
 598           warning (_("Inferior ID %d not known."), num);
 599           continue;
 600         }
 601
 602       if (inf->pid == 0)
 603         {
 604           warning (_("Inferior ID %d is not running."), num);
 605           continue;
 606         }
 607
 608       thread_info *tp = any_thread_of_inferior (inf);
 609       if (tp == NULL)
 610         {
 611           warning (_("Inferior ID %d has no threads."), num);
 612           continue;
 613         }
 614
 615       switch_to_thread (tp);
 616
 617       target_kill ();
 618     }
 619
 620   bfd_cache_close_all ();
 621 }
 622
 623 /* See inferior.h.  */
 624
 625 void
 626 switch_to_inferior_no_thread (inferior *inf)
 627 {
 628   set_current_inferior (inf);
 629   switch_to_no_thread ();
 630   set_current_program_space (inf->pspace);
 631 }
 632
 633 static void
 634 inferior_command (const char *args, int from_tty)
 635 {
 636   struct inferior *inf;
 637   int num;
 638
 639   if (args == nullptr)
 640     {
 641       inf = current_inferior ();
 642       gdb_assert (inf != nullptr);
 643       const char *filename = inf->pspace->exec_filename.get ();
 644
 645       if (filename == nullptr)
 646         filename = _("<noexec>");
 647
 648       printf_filtered (_("[Current inferior is %d [%s] (%s)]\n"),
 649                        inf->num, inferior_pid_to_str (inf->pid).c_str (),
 650                        filename);
 651     }
 652   else
 653     {
 654       num = parse_and_eval_long (args);
 655
 656       inf = find_inferior_id (num);
 657       if (inf == NULL)
 658         error (_("Inferior ID %d not known."), num);
 659
 660       if (inf->pid != 0)
 661         {
 662           if (inf != current_inferior ())
 663             {
 664               thread_info *tp = any_thread_of_inferior (inf);
 665               if (tp == NULL)
 666                 error (_("Inferior has no threads."));
 667
 668               switch_to_thread (tp);
 669             }
 670
 671           gdb::observers::user_selected_context_changed.notify
 672             (USER_SELECTED_INFERIOR
 673              | USER_SELECTED_THREAD
 674              | USER_SELECTED_FRAME);
 675         }
 676       else
 677         {
 678           switch_to_inferior_no_thread (inf);
 679
 680           gdb::observers::user_selected_context_changed.notify
 681             (USER_SELECTED_INFERIOR);
 682         }
 683     }
 684 }
 685
 686 /* Print information about currently known inferiors.  */
 687
 688 static void
 689 info_inferiors_command (const char *args, int from_tty)
 690 {
 691   print_inferior (current_uiout, args);
 692 }
 693
 694 /* remove-inferior ID */
 695
 696 static void
 697 remove_inferior_command (const char *args, int from_tty)
 698 {
 699   if (args == NULL || *args == '\0')
 700     error (_("Requires an argument (inferior id(s) to remove)"));
 701
 702   number_or_range_parser parser (args);
 703   while (!parser.finished ())
 704     {
 705       int num = parser.get_number ();
 706       struct inferior *inf = find_inferior_id (num);
 707
 708       if (inf == NULL)
 709         {
 710           warning (_("Inferior ID %d not known."), num);
 711           continue;
 712         }
 713
 714       if (!inf->deletable ())
 715         {
 716           warning (_("Can not remove current inferior %d."), num);
 717           continue;
 718         }
 719
 720       if (inf->pid != 0)
 721         {
 722           warning (_("Can not remove active inferior %d."), num);
 723           continue;
 724         }
 725
 726       delete_inferior (inf);
 727     }
 728 }
 729
 730 struct inferior *
 731 add_inferior_with_spaces (void)
 732 {
 733   struct address_space *aspace;
 734   struct program_space *pspace;
 735   struct inferior *inf;
 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 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 }