contrib/gdb-7/gdb/inferior.c

   1 /* Multi-process control for GDB, the GNU debugger.
   2
   3    Copyright (C) 2008, 2009, 2010 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 "gdbcmd.h"
  26 #include "gdbthread.h"
  27 #include "ui-out.h"
  28 #include "observer.h"
  29 #include "gdbthread.h"
  30 #include "gdbcore.h"
  31 #include "symfile.h"
  32 #include "environ.h"
  33
  34 void _initialize_inferiors (void);
  35
  36 static void inferior_alloc_data (struct inferior *inf);
  37 static void inferior_free_data (struct inferior *inf);
  38
  39 struct inferior *inferior_list = NULL;
  40 static int highest_inferior_num;
  41
  42 /* Print notices on inferior events (attach, detach, etc.), set with
  43    `set print inferior-events'.  */
  44 static int print_inferior_events = 0;
  45
  46 /* The Current Inferior.  */
  47 static struct inferior *current_inferior_ = NULL;
  48
  49 struct inferior*
  50 current_inferior (void)
  51 {
  52   return current_inferior_;
  53 }
  54
  55 void
  56 set_current_inferior (struct inferior *inf)
  57 {
  58   /* There's always an inferior.  */
  59   gdb_assert (inf != NULL);
  60
  61   current_inferior_ = inf;
  62 }
  63
  64 /* A cleanups callback, helper for save_current_program_space
  65    below.  */
  66
  67 static void
  68 restore_inferior (void *arg)
  69 {
  70   struct inferior *saved_inferior = arg;
  71
  72   set_current_inferior (saved_inferior);
  73 }
  74
  75 /* Save the current program space so that it may be restored by a later
  76    call to do_cleanups.  Returns the struct cleanup pointer needed for
  77    later doing the cleanup.  */
  78
  79 struct cleanup *
  80 save_current_inferior (void)
  81 {
  82   struct cleanup *old_chain = make_cleanup (restore_inferior,
  83                                             current_inferior_);
  84
  85   return old_chain;
  86 }
  87
  88 static void
  89 free_inferior (struct inferior *inf)
  90 {
  91   discard_all_inferior_continuations (inf);
  92   inferior_free_data (inf);
  93   xfree (inf->args);
  94   xfree (inf->terminal);
  95   free_environ (inf->environment);
  96   xfree (inf->private);
  97   xfree (inf);
  98 }
  99
 100 void
 101 init_inferior_list (void)
 102 {
 103   struct inferior *inf, *infnext;
 104
 105   highest_inferior_num = 0;
 106   if (!inferior_list)
 107     return;
 108
 109   for (inf = inferior_list; inf; inf = infnext)
 110     {
 111       infnext = inf->next;
 112       free_inferior (inf);
 113     }
 114
 115   inferior_list = NULL;
 116 }
 117
 118 struct inferior *
 119 add_inferior_silent (int pid)
 120 {
 121   struct inferior *inf;
 122
 123   inf = xmalloc (sizeof (*inf));
 124   memset (inf, 0, sizeof (*inf));
 125   inf->pid = pid;
 126
 127   inf->stop_soon = NO_STOP_QUIETLY;
 128
 129   inf->num = ++highest_inferior_num;
 130   inf->next = inferior_list;
 131   inferior_list = inf;
 132
 133   inf->environment = make_environ ();
 134   init_environ (inf->environment);
 135
 136   inferior_alloc_data (inf);
 137
 138   observer_notify_inferior_added (inf);
 139
 140   if (kernel_debugger || (pid != 0))
 141     inferior_appeared (inf, pid);
 142
 143   return inf;
 144 }
 145
 146 struct inferior *
 147 add_inferior (int pid)
 148 {
 149   struct inferior *inf = add_inferior_silent (pid);
 150
 151   if (print_inferior_events)
 152     printf_unfiltered (_("[New inferior %d]\n"), pid);
 153
 154   return inf;
 155 }
 156
 157 struct delete_thread_of_inferior_arg
 158 {
 159   int pid;
 160   int silent;
 161 };
 162
 163 static int
 164 delete_thread_of_inferior (struct thread_info *tp, void *data)
 165 {
 166   struct delete_thread_of_inferior_arg *arg = data;
 167
 168   if (ptid_get_pid (tp->ptid) == arg->pid)
 169     {
 170       if (arg->silent)
 171         delete_thread_silent (tp->ptid);
 172       else
 173         delete_thread (tp->ptid);
 174     }
 175
 176   return 0;
 177 }
 178
 179 void
 180 delete_threads_of_inferior (int pid)
 181 {
 182   struct inferior *inf;
 183   struct delete_thread_of_inferior_arg arg;
 184
 185   for (inf = inferior_list; inf; inf = inf->next)
 186     if (inf->pid == pid)
 187       break;
 188
 189   if (!inf)
 190     return;
 191
 192   arg.pid = pid;
 193   arg.silent = 1;
 194
 195   iterate_over_threads (delete_thread_of_inferior, &arg);
 196 }
 197
 198 /* If SILENT then be quiet -- don't announce a inferior death, or the
 199    exit of its threads.  */
 200
 201 void
 202 delete_inferior_1 (struct inferior *todel, int silent)
 203 {
 204   struct inferior *inf, *infprev;
 205   struct delete_thread_of_inferior_arg arg;
 206
 207   infprev = NULL;
 208
 209   for (inf = inferior_list; inf; infprev = inf, inf = inf->next)
 210     if (inf == todel)
 211       break;
 212
 213   if (!inf)
 214     return;
 215
 216   arg.pid = inf->pid;
 217   arg.silent = silent;
 218
 219   iterate_over_threads (delete_thread_of_inferior, &arg);
 220
 221   if (infprev)
 222     infprev->next = inf->next;
 223   else
 224     inferior_list = inf->next;
 225
 226   observer_notify_inferior_removed (inf);
 227
 228   free_inferior (inf);
 229 }
 230
 231 void
 232 delete_inferior (int pid)
 233 {
 234   struct inferior *inf = find_inferior_pid (pid);
 235
 236   delete_inferior_1 (inf, 0);
 237
 238   if (print_inferior_events)
 239     printf_unfiltered (_("[Inferior %d exited]\n"), pid);
 240 }
 241
 242 void
 243 delete_inferior_silent (int pid)
 244 {
 245   struct inferior *inf = find_inferior_pid (pid);
 246
 247   delete_inferior_1 (inf, 1);
 248 }
 249
 250
 251 /* If SILENT then be quiet -- don't announce a inferior exit, or the
 252    exit of its threads.  */
 253
 254 static void
 255 exit_inferior_1 (struct inferior *inftoex, int silent)
 256 {
 257   struct inferior *inf;
 258   struct delete_thread_of_inferior_arg arg;
 259
 260   for (inf = inferior_list; inf; inf = inf->next)
 261     if (inf == inftoex)
 262       break;
 263
 264   if (!inf)
 265     return;
 266
 267   arg.pid = inf->pid;
 268   arg.silent = silent;
 269
 270   iterate_over_threads (delete_thread_of_inferior, &arg);
 271
 272   /* Notify the observers before removing the inferior from the list,
 273      so that the observers have a chance to look it up.  */
 274   observer_notify_inferior_exit (inf);
 275
 276   inf->pid = 0;
 277   if (inf->vfork_parent != NULL)
 278     {
 279       inf->vfork_parent->vfork_child = NULL;
 280       inf->vfork_parent = NULL;
 281     }
 282 }
 283
 284 void
 285 exit_inferior (int pid)
 286 {
 287   struct inferior *inf = find_inferior_pid (pid);
 288
 289   exit_inferior_1 (inf, 0);
 290
 291   if (print_inferior_events)
 292     printf_unfiltered (_("[Inferior %d exited]\n"), pid);
 293 }
 294
 295 void
 296 exit_inferior_silent (int pid)
 297 {
 298   struct inferior *inf = find_inferior_pid (pid);
 299
 300   exit_inferior_1 (inf, 1);
 301 }
 302
 303 void
 304 exit_inferior_num_silent (int num)
 305 {
 306   struct inferior *inf = find_inferior_id (num);
 307
 308   exit_inferior_1 (inf, 1);
 309 }
 310
 311 void
 312 detach_inferior (int pid)
 313 {
 314   struct inferior *inf = find_inferior_pid (pid);
 315
 316   exit_inferior_1 (inf, 1);
 317
 318   if (print_inferior_events)
 319     printf_unfiltered (_("[Inferior %d detached]\n"), pid);
 320 }
 321
 322 void
 323 inferior_appeared (struct inferior *inf, int pid)
 324 {
 325   inf->pid = pid;
 326
 327   observer_notify_inferior_appeared (inf);
 328 }
 329
 330 void
 331 discard_all_inferiors (void)
 332 {
 333   struct inferior *inf;
 334
 335   for (inf = inferior_list; inf; inf = inf->next)
 336     {
 337       if (kernel_debugger || (inf->pid != 0))
 338         exit_inferior_silent (inf->pid);
 339     }
 340 }
 341
 342 struct inferior *
 343 find_inferior_id (int num)
 344 {
 345   struct inferior *inf;
 346
 347   for (inf = inferior_list; inf; inf = inf->next)
 348     if (inf->num == num)
 349       return inf;
 350
 351   return NULL;
 352 }
 353
 354 struct inferior *
 355 find_inferior_pid (int pid)
 356 {
 357   struct inferior *inf;
 358
 359   /* Looking for inferior pid == 0 is always wrong, and indicative of
 360      a bug somewhere else.  There may be more than one with pid == 0,
 361      for instance.  */
 362   gdb_assert (kernel_debugger || (pid != 0));
 363
 364   for (inf = inferior_list; inf; inf = inf->next)
 365     if (inf->pid == pid)
 366       return inf;
 367
 368   return NULL;
 369 }
 370
 371 /* Find an inferior bound to PSPACE.  */
 372
 373 struct inferior *
 374 find_inferior_for_program_space (struct program_space *pspace)
 375 {
 376   struct inferior *inf;
 377
 378   for (inf = inferior_list; inf != NULL; inf = inf->next)
 379     {
 380       if (inf->pspace == pspace)
 381         return inf;
 382     }
 383
 384   return NULL;
 385 }
 386
 387 struct inferior *
 388 iterate_over_inferiors (int (*callback) (struct inferior *, void *),
 389                         void *data)
 390 {
 391   struct inferior *inf, *infnext;
 392
 393   for (inf = inferior_list; inf; inf = infnext)
 394     {
 395       infnext = inf->next;
 396       if ((*callback) (inf, data))
 397         return inf;
 398     }
 399
 400   return NULL;
 401 }
 402
 403 int
 404 valid_gdb_inferior_id (int num)
 405 {
 406   struct inferior *inf;
 407
 408   for (inf = inferior_list; inf; inf = inf->next)
 409     if (inf->num == num)
 410       return 1;
 411
 412   return 0;
 413 }
 414
 415 int
 416 pid_to_gdb_inferior_id (int pid)
 417 {
 418   struct inferior *inf;
 419
 420   for (inf = inferior_list; inf; inf = inf->next)
 421     if (inf->pid == pid)
 422       return inf->num;
 423
 424   return 0;
 425 }
 426
 427 int
 428 gdb_inferior_id_to_pid (int num)
 429 {
 430   struct inferior *inferior = find_inferior_id (num);
 431   if (inferior)
 432     return inferior->pid;
 433   else
 434     return -1;
 435 }
 436
 437 int
 438 in_inferior_list (int pid)
 439 {
 440   struct inferior *inf;
 441
 442   for (inf = inferior_list; inf; inf = inf->next)
 443     if (inf->pid == pid)
 444       return 1;
 445
 446   return 0;
 447 }
 448
 449 int
 450 have_inferiors (void)
 451 {
 452   struct inferior *inf;
 453
 454   for (inf = inferior_list; inf; inf = inf->next)
 455     if (kernel_debugger || (inf->pid != 0))
 456       return 1;
 457
 458   return 0;
 459 }
 460
 461 int
 462 have_live_inferiors (void)
 463 {
 464   struct target_ops *t;
 465
 466   /* The check on stratum suffices, as GDB doesn't currently support
 467      multiple target interfaces.  */
 468   if (have_inferiors ())
 469     for (t = current_target.beneath; t != NULL; t = t->beneath)
 470       if (t->to_stratum == process_stratum)
 471         return 1;
 472
 473   return 0;
 474 }
 475
 476 /* Prune away automatically added program spaces that aren't required
 477    anymore.  */
 478
 479 void
 480 prune_inferiors (void)
 481 {
 482   struct inferior *ss, **ss_link;
 483   struct inferior *current = current_inferior ();
 484
 485   ss = inferior_list;
 486   ss_link = &inferior_list;
 487   while (ss)
 488     {
 489       if (ss == current
 490           || !ss->removable
 491           || (kernel_debugger || (ss->pid != 0)))
 492         {
 493           ss_link = &ss->next;
 494           ss = *ss_link;
 495           continue;
 496         }
 497
 498       *ss_link = ss->next;
 499       delete_inferior_1 (ss, 1);
 500       ss = *ss_link;
 501     }
 502
 503   prune_program_spaces ();
 504 }
 505
 506 /* Simply returns the count of inferiors.  */
 507
 508 int
 509 number_of_inferiors (void)
 510 {
 511   struct inferior *inf;
 512   int count = 0;
 513
 514   for (inf = inferior_list; inf != NULL; inf = inf->next)
 515     count++;
 516
 517   return count;
 518 }
 519
 520 /* Prints the list of inferiors and their details on UIOUT.  This is a
 521    version of 'info_inferior_command' suitable for use from MI.
 522
 523    If REQUESTED_INFERIOR is not -1, it's the GDB id of the inferior that
 524    should be printed.  Otherwise, all inferiors are printed.  */
 525 void
 526 print_inferior (struct ui_out *uiout, int requested_inferior)
 527 {
 528   struct inferior *inf;
 529   struct cleanup *old_chain;
 530   int inf_count = 0;
 531
 532   /* Compute number of inferiors we will print.  */
 533   for (inf = inferior_list; inf; inf = inf->next)
 534     {
 535       if (requested_inferior != -1 && inf->num != requested_inferior)
 536         continue;
 537
 538       ++inf_count;
 539     }
 540
 541   if (inf_count == 0)
 542     {
 543       ui_out_message (uiout, 0, "No inferiors.\n");
 544       return;
 545     }
 546
 547   old_chain = make_cleanup_ui_out_table_begin_end (uiout, 4, inf_count,
 548                                                    "inferiors");
 549   ui_out_table_header (uiout, 1, ui_left, "current", "");
 550   ui_out_table_header (uiout, 4, ui_left, "number", "Num");
 551   ui_out_table_header (uiout, 17, ui_left, "target-id", "Description");
 552   ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
 553
 554   ui_out_table_body (uiout);
 555   for (inf = inferior_list; inf; inf = inf->next)
 556     {
 557       struct cleanup *chain2;
 558
 559       if (requested_inferior != -1 && inf->num != requested_inferior)
 560         continue;
 561
 562       chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 563
 564       if (inf == current_inferior ())
 565         ui_out_field_string (uiout, "current", "*");
 566       else
 567         ui_out_field_skip (uiout, "current");
 568
 569       ui_out_field_int (uiout, "number", inf->num);
 570
 571       if (kernel_debugger || (inf->pid != 0))
 572         ui_out_field_string (uiout, "target-id",
 573                              target_pid_to_str (pid_to_ptid (inf->pid)));
 574       else
 575         ui_out_field_string (uiout, "target-id", "<null>");
 576
 577       if (inf->pspace->ebfd)
 578         ui_out_field_string (uiout, "exec",
 579                              bfd_get_filename (inf->pspace->ebfd));
 580       else
 581         ui_out_field_skip (uiout, "exec");
 582
 583       /* Print extra info that isn't really fit to always present in
 584          tabular form.  Currently we print the vfork parent/child
 585          relationships, if any.  */
 586       if (inf->vfork_parent)
 587         {
 588           ui_out_text (uiout, _("\n\tis vfork child of inferior "));
 589           ui_out_field_int (uiout, "vfork-parent", inf->vfork_parent->num);
 590         }
 591       if (inf->vfork_child)
 592         {
 593           ui_out_text (uiout, _("\n\tis vfork parent of inferior "));
 594           ui_out_field_int (uiout, "vfork-child", inf->vfork_child->num);
 595         }
 596
 597       ui_out_text (uiout, "\n");
 598       do_cleanups (chain2);
 599     }
 600
 601   do_cleanups (old_chain);
 602 }
 603
 604 static void
 605 detach_inferior_command (char *args, int from_tty)
 606 {
 607   int num, pid;
 608   struct thread_info *tp;
 609
 610   if (!args || !*args)
 611     error (_("Requires argument (inferior id to detach)"));
 612
 613   num = parse_and_eval_long (args);
 614
 615   if (!valid_gdb_inferior_id (num))
 616     error (_("Inferior ID %d not known."), num);
 617
 618   pid = gdb_inferior_id_to_pid (num);
 619
 620   tp = any_thread_of_process (pid);
 621   if (!tp)
 622     error (_("Inferior has no threads."));
 623
 624   switch_to_thread (tp->ptid);
 625
 626   detach_command (NULL, from_tty);
 627 }
 628
 629 static void
 630 kill_inferior_command (char *args, int from_tty)
 631 {
 632   int num, pid;
 633   struct thread_info *tp;
 634
 635   if (!args || !*args)
 636     error (_("Requires argument (inferior id to kill)"));
 637
 638   num = parse_and_eval_long (args);
 639
 640   if (!valid_gdb_inferior_id (num))
 641     error (_("Inferior ID %d not known."), num);
 642
 643   pid = gdb_inferior_id_to_pid (num);
 644
 645   tp = any_thread_of_process (pid);
 646   if (!tp)
 647     error (_("Inferior has no threads."));
 648
 649   switch_to_thread (tp->ptid);
 650
 651   target_kill ();
 652
 653   bfd_cache_close_all ();
 654 }
 655
 656 static void
 657 inferior_command (char *args, int from_tty)
 658 {
 659   struct inferior *inf;
 660   int num;
 661
 662   num = parse_and_eval_long (args);
 663
 664   inf = find_inferior_id (num);
 665   if (inf == NULL)
 666     error (_("Inferior ID %d not known."), num);
 667
 668   printf_filtered (_("[Switching to inferior %d [%s] (%s)]\n"),
 669                    inf->num,
 670                    target_pid_to_str (pid_to_ptid (inf->pid)),
 671                    (inf->pspace->ebfd
 672                     ? bfd_get_filename (inf->pspace->ebfd)
 673                     : _("<noexec>")));
 674
 675   if (inf->pid != 0)
 676     {
 677       if (inf->pid != ptid_get_pid (inferior_ptid))
 678         {
 679           struct thread_info *tp;
 680
 681           tp = any_thread_of_process (inf->pid);
 682           if (!tp)
 683             error (_("Inferior has no threads."));
 684
 685           switch_to_thread (tp->ptid);
 686         }
 687
 688       printf_filtered (_("[Switching to thread %d (%s)] "),
 689                        pid_to_thread_id (inferior_ptid),
 690                        target_pid_to_str (inferior_ptid));
 691     }
 692   else
 693     {
 694       struct inferior *inf;
 695
 696       inf = find_inferior_id (num);
 697       set_current_inferior (inf);
 698       switch_to_thread (null_ptid);
 699       set_current_program_space (inf->pspace);
 700     }
 701
 702   if (inf->pid != 0 && is_running (inferior_ptid))
 703     ui_out_text (uiout, "(running)\n");
 704   else if (inf->pid != 0)
 705     {
 706       ui_out_text (uiout, "\n");
 707       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 708     }
 709 }
 710
 711 /* Print information about currently known inferiors.  */
 712
 713 static void
 714 info_inferiors_command (char *args, int from_tty)
 715 {
 716   int requested = -1;
 717
 718   if (args && *args)
 719     {
 720       requested = parse_and_eval_long (args);
 721       if (!valid_gdb_inferior_id (requested))
 722         error (_("Inferior ID %d not known."), requested);
 723     }
 724
 725   print_inferior (uiout, requested);
 726 }
 727
 728 /* remove-inferior ID */
 729
 730 void
 731 remove_inferior_command (char *args, int from_tty)
 732 {
 733   int num;
 734   struct inferior *inf;
 735
 736   num = parse_and_eval_long (args);
 737   inf = find_inferior_id (num);
 738
 739   if (inf == NULL)
 740     error (_("Inferior ID %d not known."), num);
 741
 742   if (inf == current_inferior ())
 743     error (_("Can not remove current symbol inferior."));
 744
 745   delete_inferior_1 (inf, 1);
 746 }
 747
 748 struct inferior *
 749 add_inferior_with_spaces (void)
 750 {
 751   struct address_space *aspace;
 752   struct program_space *pspace;
 753   struct inferior *inf;
 754
 755   /* If all inferiors share an address space on this system, this
 756      doesn't really return a new address space; otherwise, it
 757      really does.  */
 758   aspace = maybe_new_address_space ();
 759   pspace = add_program_space (aspace);
 760   inf = add_inferior (0);
 761   inf->pspace = pspace;
 762   inf->aspace = pspace->aspace;
 763
 764   return inf;
 765 }
 766
 767 /* add-inferior [-copies N] [-exec FILENAME]  */
 768
 769 void
 770 add_inferior_command (char *args, int from_tty)
 771 {
 772   int i, copies = 1;
 773   char *exec = NULL;
 774   char **argv;
 775   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
 776
 777   if (args)
 778     {
 779       argv = gdb_buildargv (args);
 780       make_cleanup_freeargv (argv);
 781
 782       for (; *argv != NULL; argv++)
 783         {
 784           if (**argv == '-')
 785             {
 786               if (strcmp (*argv, "-copies") == 0)
 787                 {
 788                   ++argv;
 789                   if (!*argv)
 790                     error (_("No argument to -copies"));
 791                   copies = parse_and_eval_long (*argv);
 792                 }
 793               else if (strcmp (*argv, "-exec") == 0)
 794                 {
 795                   ++argv;
 796                   if (!*argv)
 797                     error (_("No argument to -exec"));
 798                   exec = *argv;
 799                 }
 800             }
 801           else
 802             error (_("Invalid argument"));
 803         }
 804     }
 805
 806   save_current_space_and_thread ();
 807
 808   for (i = 0; i < copies; ++i)
 809     {
 810       struct inferior *inf = add_inferior_with_spaces ();
 811
 812       printf_filtered (_("Added inferior %d\n"), inf->num);
 813
 814       if (exec != NULL)
 815         {
 816           /* Switch over temporarily, while reading executable and
 817              symbols.q  */
 818           set_current_program_space (inf->pspace);
 819           set_current_inferior (inf);
 820           switch_to_thread (null_ptid);
 821
 822           exec_file_attach (exec, from_tty);
 823           symbol_file_add_main (exec, from_tty);
 824         }
 825     }
 826
 827   do_cleanups (old_chain);
 828 }
 829
 830 /* clone-inferior [-copies N] [ID] */
 831
 832 void
 833 clone_inferior_command (char *args, int from_tty)
 834 {
 835   int i, copies = 1;
 836   char **argv;
 837   struct inferior *orginf = NULL;
 838   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
 839
 840   if (args)
 841     {
 842       argv = gdb_buildargv (args);
 843       make_cleanup_freeargv (argv);
 844
 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             }
 860           else
 861             {
 862               if (orginf == NULL)
 863                 {
 864                   int num;
 865
 866                   /* The first non-option (-) argument specified the
 867                      program space ID.  */
 868                   num = parse_and_eval_long (*argv);
 869                   orginf = find_inferior_id (num);
 870
 871                   if (orginf == NULL)
 872                     error (_("Inferior ID %d not known."), num);
 873                   continue;
 874                 }
 875               else
 876                 error (_("Invalid argument"));
 877             }
 878         }
 879     }
 880
 881   /* If no inferior id was specified, then the user wants to clone the
 882      current inferior.  */
 883   if (orginf == NULL)
 884     orginf = current_inferior ();
 885
 886   save_current_space_and_thread ();
 887
 888   for (i = 0; i < copies; ++i)
 889     {
 890       struct address_space *aspace;
 891       struct program_space *pspace;
 892       struct inferior *inf;
 893
 894       /* If all inferiors share an address space on this system, this
 895          doesn't really return a new address space; otherwise, it
 896          really does.  */
 897       aspace = maybe_new_address_space ();
 898       pspace = add_program_space (aspace);
 899       inf = add_inferior (0);
 900       inf->pspace = pspace;
 901       inf->aspace = pspace->aspace;
 902
 903       printf_filtered (_("Added inferior %d.\n"), inf->num);
 904
 905       set_current_inferior (inf);
 906       switch_to_thread (null_ptid);
 907       clone_program_space (pspace, orginf->pspace);
 908     }
 909
 910   do_cleanups (old_chain);
 911 }
 912
 913 /* Print notices when new inferiors are created and die.  */
 914 static void
 915 show_print_inferior_events (struct ui_file *file, int from_tty,
 916                            struct cmd_list_element *c, const char *value)
 917 {
 918   fprintf_filtered (file, _("Printing of inferior events is %s.\n"), value);
 919 }
 920
 921 \f
 922
 923 /* Keep a registry of per-inferior data-pointers required by other GDB
 924    modules.  */
 925
 926 struct inferior_data
 927 {
 928   unsigned index;
 929   void (*cleanup) (struct inferior *, void *);
 930 };
 931
 932 struct inferior_data_registration
 933 {
 934   struct inferior_data *data;
 935   struct inferior_data_registration *next;
 936 };
 937
 938 struct inferior_data_registry
 939 {
 940   struct inferior_data_registration *registrations;
 941   unsigned num_registrations;
 942 };
 943
 944 static struct inferior_data_registry inferior_data_registry
 945   = { NULL, 0 };
 946
 947 const struct inferior_data *
 948 register_inferior_data_with_cleanup
 949   (void (*cleanup) (struct inferior *, void *))
 950 {
 951   struct inferior_data_registration **curr;
 952
 953   /* Append new registration.  */
 954   for (curr = &inferior_data_registry.registrations;
 955        *curr != NULL; curr = &(*curr)->next);
 956
 957   *curr = XMALLOC (struct inferior_data_registration);
 958   (*curr)->next = NULL;
 959   (*curr)->data = XMALLOC (struct inferior_data);
 960   (*curr)->data->index = inferior_data_registry.num_registrations++;
 961   (*curr)->data->cleanup = cleanup;
 962
 963   return (*curr)->data;
 964 }
 965
 966 const struct inferior_data *
 967 register_inferior_data (void)
 968 {
 969   return register_inferior_data_with_cleanup (NULL);
 970 }
 971
 972 static void
 973 inferior_alloc_data (struct inferior *inf)
 974 {
 975   gdb_assert (inf->data == NULL);
 976   inf->num_data = inferior_data_registry.num_registrations;
 977   inf->data = XCALLOC (inf->num_data, void *);
 978 }
 979
 980 static void
 981 inferior_free_data (struct inferior *inf)
 982 {
 983   gdb_assert (inf->data != NULL);
 984   clear_inferior_data (inf);
 985   xfree (inf->data);
 986   inf->data = NULL;
 987 }
 988
 989 void
 990 clear_inferior_data (struct inferior *inf)
 991 {
 992   struct inferior_data_registration *registration;
 993   int i;
 994
 995   gdb_assert (inf->data != NULL);
 996
 997   for (registration = inferior_data_registry.registrations, i = 0;
 998        i < inf->num_data;
 999        registration = registration->next, i++)
1000     if (inf->data[i] != NULL && registration->data->cleanup)
1001       registration->data->cleanup (inf, inf->data[i]);
1002
1003   memset (inf->data, 0, inf->num_data * sizeof (void *));
1004 }
1005
1006 void
1007 set_inferior_data (struct inferior *inf,
1008                        const struct inferior_data *data,
1009                        void *value)
1010 {
1011   gdb_assert (data->index < inf->num_data);
1012   inf->data[data->index] = value;
1013 }
1014
1015 void *
1016 inferior_data (struct inferior *inf, const struct inferior_data *data)
1017 {
1018   gdb_assert (data->index < inf->num_data);
1019   return inf->data[data->index];
1020 }
1021
1022 void
1023 initialize_inferiors (void)
1024 {
1025   /* There's always one inferior.  Note that this function isn't an
1026      automatic _initialize_foo function, since other _initialize_foo
1027      routines may need to install their per-inferior data keys.  We
1028      can only allocate an inferior when all those modules have done
1029      that.  Do this after initialize_progspace, due to the
1030      current_program_space reference.  */
1031
1032   /* However, when invoked by DragonFly kgdb which always has many inferiors,
1033      the default inferior will not be defined.  The swapper process always has
1034      pid 0, which conflicts with the default. */
1035
1036   if (!kernel_debugger) {
1037     current_inferior_ = add_inferior (0);
1038     current_inferior_->pspace = current_program_space;
1039     current_inferior_->aspace = current_program_space->aspace;
1040   }
1041
1042   add_info ("inferiors", info_inferiors_command,
1043             _("IDs of currently known inferiors."));
1044
1045   add_com ("add-inferior", no_class, add_inferior_command, _("\
1046 Add a new inferior.\n\
1047 Usage: add-inferior [-copies <N>] [-exec <FILENAME>]\n\
1048 N is the optional number of inferior to add, default is 1.\n\
1049 FILENAME is the file name of the executable to use\n\
1050 as main program."));
1051
1052   add_com ("remove-inferior", no_class, remove_inferior_command, _("\
1053 Remove inferior ID.\n\
1054 Usage: remove-inferior ID"));
1055
1056   add_com ("clone-inferior", no_class, clone_inferior_command, _("\
1057 Clone inferior ID.\n\
1058 Usage: clone-inferior [-copies <N>] [ID]\n\
1059 Add N copies of inferior ID.  The new inferior has the same\n\
1060 executable loaded as the copied inferior.  If -copies is not specified,\n\
1061 adds 1 copy.  If ID is not specified, it is the current inferior\n\
1062 that is cloned."));
1063
1064   add_cmd ("inferior", class_run, detach_inferior_command, _("\
1065 Detach from inferior ID."),
1066            &detachlist);
1067
1068   add_cmd ("inferior", class_run, kill_inferior_command, _("\
1069 Kill inferior ID."),
1070            &killlist);
1071
1072   add_cmd ("inferior", class_run, inferior_command, _("\
1073 Use this command to switch between inferiors.\n\
1074 The new inferior ID must be currently known."),
1075            &cmdlist);
1076
1077   add_setshow_boolean_cmd ("inferior-events", no_class,
1078          &print_inferior_events, _("\
1079 Set printing of inferior events (e.g., inferior start and exit)."), _("\
1080 Show printing of inferior events (e.g., inferior start and exit)."), NULL,
1081          NULL,
1082          show_print_inferior_events,
1083          &setprintlist, &showprintlist);
1084
1085 }