gdb/inferior.h

   1 /* Variables that describe the inferior process running under GDB:
   2    Where it is, why it stopped, and how to step it.
   3
   4    Copyright (C) 1986-2020 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #if !defined (INFERIOR_H)
  22 #define INFERIOR_H 1
  23
  24 struct target_waitstatus;
  25 struct frame_info;
  26 struct ui_file;
  27 struct type;
  28 struct gdbarch;
  29 struct regcache;
  30 struct ui_out;
  31 struct terminal_info;
  32 struct target_desc_info;
  33 struct continuation;
  34 struct inferior;
  35 struct thread_info;
  36
  37 /* For bpstat.  */
  38 #include "breakpoint.h"
  39
  40 /* For enum gdb_signal.  */
  41 #include "target.h"
  42
  43 /* For struct frame_id.  */
  44 #include "frame.h"
  45
  46 /* For gdb_environ.  */
  47 #include "gdbsupport/environ.h"
  48
  49 #include "progspace.h"
  50 #include "registry.h"
  51
  52 #include "symfile-add-flags.h"
  53 #include "gdbsupport/refcounted-object.h"
  54 #include "gdbsupport/forward-scope-exit.h"
  55
  56 #include "gdbsupport/common-inferior.h"
  57 #include "gdbthread.h"
  58
  59 #include "process-stratum-target.h"
  60
  61 struct infcall_suspend_state;
  62 struct infcall_control_state;
  63
  64 extern void restore_infcall_suspend_state (struct infcall_suspend_state *);
  65 extern void restore_infcall_control_state (struct infcall_control_state *);
  66
  67 /* A deleter for infcall_suspend_state that calls
  68    restore_infcall_suspend_state.  */
  69 struct infcall_suspend_state_deleter
  70 {
  71   void operator() (struct infcall_suspend_state *state) const
  72   {
  73     try
  74       {
  75         restore_infcall_suspend_state (state);
  76       }
  77     catch (const gdb_exception_error &e)
  78       {
  79         /* If we are restoring the inferior state due to an exception,
  80            some error message will be printed.  So, only warn the user
  81            when we cannot restore during normal execution.  */
  82         if (!std::uncaught_exception ())
  83           warning (_("Failed to restore inferior state: %s"), e.what ());
  84       }
  85   }
  86 };
  87
  88 /* A unique_ptr specialization for infcall_suspend_state.  */
  89 typedef std::unique_ptr<infcall_suspend_state, infcall_suspend_state_deleter>
  90     infcall_suspend_state_up;
  91
  92 extern infcall_suspend_state_up save_infcall_suspend_state ();
  93
  94 /* A deleter for infcall_control_state that calls
  95    restore_infcall_control_state.  */
  96 struct infcall_control_state_deleter
  97 {
  98   void operator() (struct infcall_control_state *state) const
  99   {
 100     restore_infcall_control_state (state);
 101   }
 102 };
 103
 104 /* A unique_ptr specialization for infcall_control_state.  */
 105 typedef std::unique_ptr<infcall_control_state, infcall_control_state_deleter>
 106     infcall_control_state_up;
 107
 108 extern infcall_control_state_up save_infcall_control_state ();
 109
 110 extern void discard_infcall_suspend_state (struct infcall_suspend_state *);
 111 extern void discard_infcall_control_state (struct infcall_control_state *);
 112
 113 extern readonly_detached_regcache *
 114   get_infcall_suspend_state_regcache (struct infcall_suspend_state *);
 115
 116 extern void set_sigint_trap (void);
 117
 118 extern void clear_sigint_trap (void);
 119
 120 /* Set/get file name for default use for standard in/out in the inferior.  */
 121
 122 extern void set_inferior_io_terminal (const char *terminal_name);
 123 extern const char *get_inferior_io_terminal (void);
 124
 125 /* Collected pid, tid, etc. of the debugged inferior.  When there's
 126    no inferior, inferior_ptid.pid () will be 0.  */
 127
 128 extern ptid_t inferior_ptid;
 129
 130 extern void generic_mourn_inferior (void);
 131
 132 extern CORE_ADDR unsigned_pointer_to_address (struct gdbarch *gdbarch,
 133                                               struct type *type,
 134                                               const gdb_byte *buf);
 135 extern void unsigned_address_to_pointer (struct gdbarch *gdbarch,
 136                                          struct type *type, gdb_byte *buf,
 137                                          CORE_ADDR addr);
 138 extern CORE_ADDR signed_pointer_to_address (struct gdbarch *gdbarch,
 139                                             struct type *type,
 140                                             const gdb_byte *buf);
 141 extern void address_to_signed_pointer (struct gdbarch *gdbarch,
 142                                        struct type *type, gdb_byte *buf,
 143                                        CORE_ADDR addr);
 144
 145 extern void reopen_exec_file (void);
 146
 147 /* From misc files */
 148
 149 extern void default_print_registers_info (struct gdbarch *gdbarch,
 150                                           struct ui_file *file,
 151                                           struct frame_info *frame,
 152                                           int regnum, int all);
 153
 154 /* Default implementation of gdbarch_print_float_info.  Print
 155    the values of all floating point registers.  */
 156
 157 extern void default_print_float_info (struct gdbarch *gdbarch,
 158                                       struct ui_file *file,
 159                                       struct frame_info *frame,
 160                                       const char *args);
 161
 162 extern void child_terminal_info (struct target_ops *self, const char *, int);
 163
 164 extern void child_terminal_ours (struct target_ops *self);
 165
 166 extern void child_terminal_ours_for_output (struct target_ops *self);
 167
 168 extern void child_terminal_inferior (struct target_ops *self);
 169
 170 extern void child_terminal_save_inferior (struct target_ops *self);
 171
 172 extern void child_terminal_init (struct target_ops *self);
 173
 174 extern void child_terminal_init_with_pgrp (int pgrp);
 175
 176 extern void child_pass_ctrlc (struct target_ops *self);
 177
 178 extern void child_interrupt (struct target_ops *self);
 179
 180 /* From fork-child.c */
 181
 182 /* Helper function to call STARTUP_INFERIOR with PID and NUM_TRAPS.
 183    This function already calls set_executing.  Return the ptid_t from
 184    STARTUP_INFERIOR.  */
 185 extern ptid_t gdb_startup_inferior (pid_t pid, int num_traps);
 186
 187 /* From infcmd.c */
 188
 189 /* Initial inferior setup.  Determines the exec file is not yet known,
 190    takes any necessary post-attaching actions, fetches the target
 191    description and syncs the shared library list.  */
 192
 193 extern void setup_inferior (int from_tty);
 194
 195 extern void post_create_inferior (struct target_ops *, int);
 196
 197 extern void attach_command (const char *, int);
 198
 199 extern const char *get_inferior_args (void);
 200
 201 extern void set_inferior_args (const char *);
 202
 203 extern void set_inferior_args_vector (int, char **);
 204
 205 extern void registers_info (const char *, int);
 206
 207 extern void continue_1 (int all_threads);
 208
 209 extern void interrupt_target_1 (bool all_threads);
 210
 211 using delete_longjmp_breakpoint_cleanup
 212   = FORWARD_SCOPE_EXIT (delete_longjmp_breakpoint);
 213
 214 extern void detach_command (const char *, int);
 215
 216 extern void notice_new_inferior (struct thread_info *, int, int);
 217
 218 extern struct value *get_return_value (struct value *function,
 219                                        struct type *value_type);
 220
 221 /* Prepare for execution command.  TARGET is the target that will run
 222    the command.  BACKGROUND determines whether this is a foreground
 223    (synchronous) or background (asynchronous) command.  */
 224
 225 extern void prepare_execution_command (struct target_ops *target,
 226                                        int background);
 227
 228 /* Nonzero if stopped due to completion of a stack dummy routine.  */
 229
 230 extern enum stop_stack_kind stop_stack_dummy;
 231
 232 /* Nonzero if program stopped due to a random (unexpected) signal in
 233    inferior process.  */
 234
 235 extern int stopped_by_random_signal;
 236
 237 /* Print notices on inferior events (attach, detach, etc.), set with
 238    `set print inferior-events'.  */
 239 extern bool print_inferior_events;
 240
 241 /* Anything but NO_STOP_QUIETLY means we expect a trap and the caller
 242    will handle it themselves.  STOP_QUIETLY is used when running in
 243    the shell before the child program has been exec'd and when running
 244    through shared library loading.  STOP_QUIETLY_REMOTE is used when
 245    setting up a remote connection; it is like STOP_QUIETLY_NO_SIGSTOP
 246    except that there is no need to hide a signal.  */
 247
 248 /* STOP_QUIETLY_NO_SIGSTOP is used to handle a tricky situation with attach.
 249    When doing an attach, the kernel stops the debuggee with a SIGSTOP.
 250    On newer GNU/Linux kernels (>= 2.5.61) the handling of SIGSTOP for
 251    a ptraced process has changed.  Earlier versions of the kernel
 252    would ignore these SIGSTOPs, while now SIGSTOP is treated like any
 253    other signal, i.e. it is not muffled.
 254
 255    If the gdb user does a 'continue' after the 'attach', gdb passes
 256    the global variable stop_signal (which stores the signal from the
 257    attach, SIGSTOP) to the ptrace(PTRACE_CONT,...)  call.  This is
 258    problematic, because the kernel doesn't ignore such SIGSTOP
 259    now.  I.e. it is reported back to gdb, which in turn presents it
 260    back to the user.
 261
 262    To avoid the problem, we use STOP_QUIETLY_NO_SIGSTOP, which allows
 263    gdb to clear the value of stop_signal after the attach, so that it
 264    is not passed back down to the kernel.  */
 265
 266 enum stop_kind
 267   {
 268     NO_STOP_QUIETLY = 0,
 269     STOP_QUIETLY,
 270     STOP_QUIETLY_REMOTE,
 271     STOP_QUIETLY_NO_SIGSTOP
 272   };
 273
 274 \f
 275 /* Possible values for gdbarch_call_dummy_location.  */
 276 #define ON_STACK 1
 277 #define AT_ENTRY_POINT 4
 278
 279 /* Base class for target-specific inferior data.  */
 280
 281 struct private_inferior
 282 {
 283   virtual ~private_inferior () = 0;
 284 };
 285
 286 /* Inferior process specific part of `struct infcall_control_state'.
 287
 288    Inferior thread counterpart is `struct thread_control_state'.  */
 289
 290 struct inferior_control_state
 291 {
 292   inferior_control_state ()
 293     : stop_soon (NO_STOP_QUIETLY)
 294   {
 295   }
 296
 297   explicit inferior_control_state (enum stop_kind when)
 298     : stop_soon (when)
 299   {
 300   }
 301
 302   /* See the definition of stop_kind above.  */
 303   enum stop_kind stop_soon;
 304 };
 305
 306 /* Return a pointer to the current inferior.  */
 307 extern inferior *current_inferior ();
 308
 309 extern void set_current_inferior (inferior *);
 310
 311 /* Switch inferior (and program space) to INF, and switch to no thread
 312    selected.  */
 313 extern void switch_to_inferior_no_thread (inferior *inf);
 314
 315 /* GDB represents the state of each program execution with an object
 316    called an inferior.  An inferior typically corresponds to a process
 317    but is more general and applies also to targets that do not have a
 318    notion of processes.  Each run of an executable creates a new
 319    inferior, as does each attachment to an existing process.
 320    Inferiors have unique internal identifiers that are different from
 321    target process ids.  Each inferior may in turn have multiple
 322    threads running in it.
 323
 324    Inferiors are intrusively refcounted objects.  Unlike thread
 325    objects, being the user-selected inferior is considered a strong
 326    reference and is thus accounted for in the inferior object's
 327    refcount (see set_current_inferior).  When GDB needs to remember
 328    the selected inferior to later restore it, GDB temporarily bumps
 329    the inferior object's refcount, to prevent something deleting the
 330    inferior object before reverting back (e.g., due to a
 331    "remove-inferiors" command (see
 332    scoped_restore_current_inferior).  All other inferior
 333    references are considered weak references.  Inferiors are always
 334    listed exactly once in the inferior list, so placing an inferior in
 335    the inferior list is an implicit, not counted strong reference.  */
 336
 337 class inferior : public refcounted_object
 338 {
 339 public:
 340   explicit inferior (int pid);
 341   ~inferior ();
 342
 343   /* Returns true if we can delete this inferior.  */
 344   bool deletable () const { return refcount () == 0; }
 345
 346   /* Push T in this inferior's target stack.  */
 347   void push_target (struct target_ops *t)
 348   { m_target_stack.push (t); }
 349
 350   /* Unpush T from this inferior's target stack.  */
 351   int unpush_target (struct target_ops *t)
 352   { return m_target_stack.unpush (t); }
 353
 354   /* Returns true if T is pushed in this inferior's target stack.  */
 355   bool target_is_pushed (target_ops *t)
 356   { return m_target_stack.is_pushed (t); }
 357
 358   /* Find the target beneath T in this inferior's target stack.  */
 359   target_ops *find_target_beneath (const target_ops *t)
 360   { return m_target_stack.find_beneath (t); }
 361
 362   /* Return the target at the top of this inferior's target stack.  */
 363   target_ops *top_target ()
 364   { return m_target_stack.top (); }
 365
 366   /* Return the target at process_stratum level in this inferior's
 367      target stack.  */
 368   struct process_stratum_target *process_target ()
 369   { return (process_stratum_target *) m_target_stack.at (process_stratum); }
 370
 371   /* Return the target at STRATUM in this inferior's target stack.  */
 372   target_ops *target_at (enum strata stratum)
 373   { return m_target_stack.at (stratum); }
 374
 375   bool has_execution ()
 376   { return target_has_execution_1 (this); }
 377
 378   /* Pointer to next inferior in singly-linked list of inferiors.  */
 379   struct inferior *next = NULL;
 380
 381   /* This inferior's thread list.  */
 382   thread_info *thread_list = nullptr;
 383
 384   /* Returns a range adapter covering the inferior's threads,
 385      including exited threads.  Used like this:
 386
 387        for (thread_info *thr : inf->threads ())
 388          { .... }
 389   */
 390   inf_threads_range threads ()
 391   { return inf_threads_range (this->thread_list); }
 392
 393   /* Returns a range adapter covering the inferior's non-exited
 394      threads.  Used like this:
 395
 396        for (thread_info *thr : inf->non_exited_threads ())
 397          { .... }
 398   */
 399   inf_non_exited_threads_range non_exited_threads ()
 400   { return inf_non_exited_threads_range (this->thread_list); }
 401
 402   /* Like inferior::threads(), but returns a range adapter that can be
 403      used with range-for, safely.  I.e., it is safe to delete the
 404      currently-iterated thread, like this:
 405
 406      for (thread_info *t : inf->threads_safe ())
 407        if (some_condition ())
 408          delete f;
 409   */
 410   inline safe_inf_threads_range threads_safe ()
 411   { return safe_inf_threads_range (this->thread_list); }
 412
 413   /* Convenient handle (GDB inferior id).  Unique across all
 414      inferiors.  */
 415   int num = 0;
 416
 417   /* Actual target inferior id, usually, a process id.  This matches
 418      the ptid_t.pid member of threads of this inferior.  */
 419   int pid = 0;
 420   /* True if the PID was actually faked by GDB.  */
 421   bool fake_pid_p = false;
 422
 423   /* The highest thread number this inferior ever had.  */
 424   int highest_thread_num = 0;
 425
 426   /* State of GDB control of inferior process execution.
 427      See `struct inferior_control_state'.  */
 428   inferior_control_state control;
 429
 430   /* True if this was an auto-created inferior, e.g. created from
 431      following a fork; false, if this inferior was manually added by
 432      the user, and we should not attempt to prune it
 433      automatically.  */
 434   bool removable = false;
 435
 436   /* The address space bound to this inferior.  */
 437   struct address_space *aspace = NULL;
 438
 439   /* The program space bound to this inferior.  */
 440   struct program_space *pspace = NULL;
 441
 442   /* The arguments string to use when running.  */
 443   char *args = NULL;
 444
 445   /* The size of elements in argv.  */
 446   int argc = 0;
 447
 448   /* The vector version of arguments.  If ARGC is nonzero,
 449      then we must compute ARGS from this (via the target).
 450      This is always coming from main's argv and therefore
 451      should never be freed.  */
 452   char **argv = NULL;
 453
 454   /* The current working directory that will be used when starting
 455      this inferior.  */
 456   gdb::unique_xmalloc_ptr<char> cwd;
 457
 458   /* The name of terminal device to use for I/O.  */
 459   char *terminal = NULL;
 460
 461   /* The terminal state as set by the last target_terminal::terminal_*
 462      call.  */
 463   target_terminal_state terminal_state = target_terminal_state::is_ours;
 464
 465   /* Environment to use for running inferior,
 466      in format described in environ.h.  */
 467   gdb_environ environment;
 468
 469   /* True if this child process was attached rather than forked.  */
 470   bool attach_flag = false;
 471
 472   /* If this inferior is a vfork child, then this is the pointer to
 473      its vfork parent, if GDB is still attached to it.  */
 474   inferior *vfork_parent = NULL;
 475
 476   /* If this process is a vfork parent, this is the pointer to the
 477      child.  Since a vfork parent is left frozen by the kernel until
 478      the child execs or exits, a process can only have one vfork child
 479      at a given time.  */
 480   inferior *vfork_child = NULL;
 481
 482   /* True if this inferior should be detached when it's vfork sibling
 483      exits or execs.  */
 484   bool pending_detach = false;
 485
 486   /* True if this inferior is a vfork parent waiting for a vfork child
 487      not under our control to be done with the shared memory region,
 488      either by exiting or execing.  */
 489   bool waiting_for_vfork_done = false;
 490
 491   /* True if we're in the process of detaching from this inferior.  */
 492   bool detaching = false;
 493
 494   /* What is left to do for an execution command after any thread of
 495      this inferior stops.  For continuations associated with a
 496      specific thread, see `struct thread_info'.  */
 497   continuation *continuations = NULL;
 498
 499   /* True if setup_inferior wasn't called for this inferior yet.
 500      Until that is done, we must not access inferior memory or
 501      registers, as we haven't determined the target
 502      architecture/description.  */
 503   bool needs_setup = false;
 504
 505   /* Private data used by the target vector implementation.  */
 506   std::unique_ptr<private_inferior> priv;
 507
 508   /* HAS_EXIT_CODE is true if the inferior exited with an exit code.
 509      In this case, the EXIT_CODE field is also valid.  */
 510   bool has_exit_code = false;
 511   LONGEST exit_code = 0;
 512
 513   /* Default flags to pass to the symbol reading functions.  These are
 514      used whenever a new objfile is created.  */
 515   symfile_add_flags symfile_flags = 0;
 516
 517   /* Info about an inferior's target description (if it's fetched; the
 518      user supplied description's filename, if any; etc.).  */
 519   target_desc_info *tdesc_info = NULL;
 520
 521   /* The architecture associated with the inferior through the
 522      connection to the target.
 523
 524      The architecture vector provides some information that is really
 525      a property of the inferior, accessed through a particular target:
 526      ptrace operations; the layout of certain RSP packets; the
 527      solib_ops vector; etc.  To differentiate architecture accesses to
 528      per-inferior/target properties from
 529      per-thread/per-frame/per-objfile properties, accesses to
 530      per-inferior/target properties should be made through
 531      this gdbarch.  */
 532   struct gdbarch *gdbarch = NULL;
 533
 534   /* Data related to displaced stepping.  */
 535   displaced_step_inferior_state displaced_step_state;
 536
 537   /* Per inferior data-pointers required by other GDB modules.  */
 538   REGISTRY_FIELDS;
 539
 540 private:
 541   /* The inferior's target stack.  */
 542   target_stack m_target_stack;
 543 };
 544
 545 /* Keep a registry of per-inferior data-pointers required by other GDB
 546    modules.  */
 547
 548 DECLARE_REGISTRY (inferior);
 549
 550 /* Add an inferior to the inferior list, print a message that a new
 551    inferior is found, and return the pointer to the new inferior.
 552    Caller may use this pointer to initialize the private inferior
 553    data.  */
 554 extern struct inferior *add_inferior (int pid);
 555
 556 /* Same as add_inferior, but don't print new inferior notifications to
 557    the CLI.  */
 558 extern struct inferior *add_inferior_silent (int pid);
 559
 560 extern void delete_inferior (struct inferior *todel);
 561
 562 /* Delete an existing inferior list entry, due to inferior detaching.  */
 563 extern void detach_inferior (inferior *inf);
 564
 565 extern void exit_inferior (inferior *inf);
 566
 567 extern void exit_inferior_silent (inferior *inf);
 568
 569 extern void exit_inferior_num_silent (int num);
 570
 571 extern void inferior_appeared (struct inferior *inf, int pid);
 572
 573 /* Search function to lookup an inferior of TARG by target 'pid'.  */
 574 extern struct inferior *find_inferior_pid (process_stratum_target *targ,
 575                                            int pid);
 576
 577 /* Search function to lookup an inferior of TARG whose pid is equal to
 578    'ptid.pid'. */
 579 extern struct inferior *find_inferior_ptid (process_stratum_target *targ,
 580                                             ptid_t ptid);
 581
 582 /* Search function to lookup an inferior by GDB 'num'.  */
 583 extern struct inferior *find_inferior_id (int num);
 584
 585 /* Find an inferior bound to PSPACE, giving preference to the current
 586    inferior.  */
 587 extern struct inferior *
 588   find_inferior_for_program_space (struct program_space *pspace);
 589
 590 /* Returns true if the inferior list is not empty.  */
 591 extern int have_inferiors (void);
 592
 593 /* Returns the number of live inferiors running on PROC_TARGET (real
 594    live processes with execution).  */
 595 extern int number_of_live_inferiors (process_stratum_target *proc_target);
 596
 597 /* Returns true if there are any live inferiors in the inferior list
 598    (not cores, not executables, real live processes).  */
 599 extern int have_live_inferiors (void);
 600
 601 /* Save/restore the current inferior.  */
 602
 603 class scoped_restore_current_inferior
 604 {
 605 public:
 606   scoped_restore_current_inferior ()
 607     : m_saved_inf (current_inferior ())
 608   {}
 609
 610   ~scoped_restore_current_inferior ()
 611   { set_current_inferior (m_saved_inf); }
 612
 613   DISABLE_COPY_AND_ASSIGN (scoped_restore_current_inferior);
 614
 615 private:
 616   inferior *m_saved_inf;
 617 };
 618
 619
 620 /* Traverse all inferiors.  */
 621
 622 extern struct inferior *inferior_list;
 623
 624 /* Pull in the internals of the inferiors ranges and iterators.  Must
 625    be done after struct inferior is defined.  */
 626 #include "inferior-iter.h"
 627
 628 /* Return a range that can be used to walk over all inferiors
 629    inferiors, with range-for, safely.  I.e., it is safe to delete the
 630    currently-iterated inferior.  When combined with range-for, this
 631    allow convenient patterns like this:
 632
 633      for (inferior *inf : all_inferiors_safe ())
 634        if (some_condition ())
 635          delete inf;
 636 */
 637
 638 inline all_inferiors_safe_range
 639 all_inferiors_safe ()
 640 {
 641   return {};
 642 }
 643
 644 /* Returns a range representing all inferiors, suitable to use with
 645    range-for, like this:
 646
 647    for (inferior *inf : all_inferiors ())
 648      [...]
 649 */
 650
 651 inline all_inferiors_range
 652 all_inferiors (process_stratum_target *proc_target = nullptr)
 653 {
 654   return all_inferiors_range (proc_target);
 655 }
 656
 657 /* Return a range that can be used to walk over all inferiors with PID
 658    not zero, with range-for.  */
 659
 660 inline all_non_exited_inferiors_range
 661 all_non_exited_inferiors (process_stratum_target *proc_target = nullptr)
 662 {
 663   return all_non_exited_inferiors_range (proc_target);
 664 }
 665
 666 /* Prune away automatically added inferiors that aren't required
 667    anymore.  */
 668 extern void prune_inferiors (void);
 669
 670 extern int number_of_inferiors (void);
 671
 672 extern struct inferior *add_inferior_with_spaces (void);
 673
 674 /* Print the current selected inferior.  */
 675 extern void print_selected_inferior (struct ui_out *uiout);
 676
 677 #endif /* !defined (INFERIOR_H) */