import gdb-1999-06-28 snapshot

9 files changed, 943 insertions, 942 deletions

diff --git a/gdb/config/convex/Convex.notes b/gdb/config/convex/Convex.notes
index 28d336b..828778c 100644
--- a/gdb/config/convex/Convex.notes
+++ b/gdb/config/convex/Convex.notes
@@ -1,163 +1,164 @@
+@c OBSOLETE 
+@c OBSOLETE @node Convex,,, Top
+@c OBSOLETE @appendix Convex-specific info
+@c OBSOLETE @cindex Convex notes
+@c OBSOLETE 
+@c OBSOLETE Scalar registers are 64 bits long, which is a pain since
+@c OBSOLETE left half of an S register frequently contains noise.
+@c OBSOLETE Therefore there are two ways to obtain the value of an S register.
+@c OBSOLETE 
+@c OBSOLETE @table @kbd
+@c OBSOLETE @item $s0
+@c OBSOLETE returns the low half of the register as an int
+@c OBSOLETE 
+@c OBSOLETE @item $S0
+@c OBSOLETE returns the whole register as a long long
+@c OBSOLETE @end table
+@c OBSOLETE 
+@c OBSOLETE You can print the value in floating point by using @samp{p/f $s0} or @samp{p/f $S0}
+@c OBSOLETE to print a single or double precision value.
+@c OBSOLETE 
+@c OBSOLETE @cindex vector registers
+@c OBSOLETE Vector registers are handled similarly, with @samp{$V0} denoting the whole
+@c OBSOLETE 64-bit register and @kbd{$v0} denoting the 32-bit low half; @samp{p/f $v0}
+@c OBSOLETE or @samp{p/f $V0} can be used to examine the register in floating point.
+@c OBSOLETE The length of the vector registers is taken from @samp{$vl}.  
+@c OBSOLETE 
+@c OBSOLETE Individual elements of a vector register are denoted in the obvious way;
+@c OBSOLETE @samp{print $v3[9]} prints the tenth element of register @kbd{v3}, and
+@c OBSOLETE @samp{set $v3[9] = 1234} alters it.
+@c OBSOLETE 
+@c OBSOLETE @kbd{$vl} and @kbd{$vs} are int, and @kbd{$vm} is an int vector.
+@c OBSOLETE Elements of @kbd{$vm} can't be assigned to.
+@c OBSOLETE 
+@c OBSOLETE @cindex communication registers
+@c OBSOLETE @kindex info comm-registers
+@c OBSOLETE Communication registers have names @kbd{$C0 .. $C63}, with @kbd{$c0 .. $c63}
+@c OBSOLETE denoting the low-order halves.  @samp{info comm-registers} will print them
+@c OBSOLETE all out, and tell which are locked.  (A communication register is
+@c OBSOLETE locked when a value is sent to it, and unlocked when the value is
+@c OBSOLETE received.)  Communication registers are, of course, global to all
+@c OBSOLETE threads, so it does not matter what the currently selected thread is.
+@c OBSOLETE @samp{info comm-reg @var{name}} prints just that one communication
+@c OBSOLETE register; @samp{name} may also be a communication register number
+@c OBSOLETE @samp{nn} or @samp{0xnn}.
+@c OBSOLETE @samp{info comm-reg @var{address}} prints the contents of the resource
+@c OBSOLETE structure at that address.
+@c OBSOLETE 
+@c OBSOLETE @kindex info psw
+@c OBSOLETE The command @samp{info psw} prints the processor status word @kbd{$ps}
+@c OBSOLETE bit by bit.
+@c OBSOLETE 
+@c OBSOLETE @kindex set base
+@c OBSOLETE GDB normally prints all integers in base 10, but the leading
+@c OBSOLETE @kbd{0x80000000} of pointers is intolerable in decimal, so the default
+@c OBSOLETE output radix has been changed to try to print addresses appropriately.
+@c OBSOLETE The @samp{set base} command can be used to change this.
+@c OBSOLETE 
+@c OBSOLETE @table @code
+@c OBSOLETE @item set base 10
+@c OBSOLETE Integer values always print in decimal.
+@c OBSOLETE 
+@c OBSOLETE @item set base 16
+@c OBSOLETE Integer values always print in hex.
+@c OBSOLETE 
+@c OBSOLETE @item set base
+@c OBSOLETE Go back to the initial state, which prints integer values in hex if they
+@c OBSOLETE look like pointers (specifically, if they start with 0x8 or 0xf in the
+@c OBSOLETE stack), otherwise in decimal.
+@c OBSOLETE @end table
+@c OBSOLETE 
+@c OBSOLETE @kindex set pipeline
+@c OBSOLETE When an exception such as a bus error or overflow happens, usually the PC
+@c OBSOLETE is several instructions ahead by the time the exception is detected.
+@c OBSOLETE The @samp{set pipe} command will disable this.
+@c OBSOLETE 
+@c OBSOLETE @table @code
+@c OBSOLETE @item set pipeline off
+@c OBSOLETE Forces serial execution of instructions; no vector chaining and no 
+@c OBSOLETE scalar instruction overlap.  With this, exceptions are detected with 
+@c OBSOLETE the PC pointing to the instruction after the one in error.
+@c OBSOLETE 
+@c OBSOLETE @item set pipeline on
+@c OBSOLETE Returns to normal, fast, execution.  This is the default.
+@c OBSOLETE @end table
+@c OBSOLETE 
+@c OBSOLETE @cindex parallel
+@c OBSOLETE In a parallel program, multiple threads may be executing, each
+@c OBSOLETE with its own registers, stack, and local memory.  When one of them
+@c OBSOLETE hits a breakpoint, that thread is selected.  Other threads do
+@c OBSOLETE not run while the thread is in the breakpoint.
+@c OBSOLETE 
+@c OBSOLETE @kindex 1cont
+@c OBSOLETE The selected thread can be single-stepped, given signals, and so
+@c OBSOLETE on.  Any other threads remain stopped.  When a @samp{cont} command is given,
+@c OBSOLETE all threads are resumed.  To resume just the selected thread, use
+@c OBSOLETE the command @samp{1cont}.
+@c OBSOLETE 
+@c OBSOLETE @kindex thread
+@c OBSOLETE The @samp{thread} command will show the active threads and the
+@c OBSOLETE instruction they are about to execute.  The selected thread is marked
+@c OBSOLETE with an asterisk.  The command @samp{thread @var{n}} will select thread @var{n},
+@c OBSOLETE shifting the debugger's attention to it for single-stepping,
+@c OBSOLETE registers, local memory, and so on.
+@c OBSOLETE 
+@c OBSOLETE @kindex info threads
+@c OBSOLETE The @samp{info threads} command will show what threads, if any, have
+@c OBSOLETE invisibly hit breakpoints or signals and are waiting to be noticed.
+@c OBSOLETE 
+@c OBSOLETE @kindex set parallel
+@c OBSOLETE The @samp{set parallel} command controls how many threads can be active.
+@c OBSOLETE 
+@c OBSOLETE @table @code
+@c OBSOLETE @item set parallel off
+@c OBSOLETE One thread.  Requests by the program that other threads join in
+@c OBSOLETE (spawn and pfork instructions) do not cause other threads to start up.
+@c OBSOLETE This does the same thing as the @samp{limit concurrency 1} command.
+@c OBSOLETE 
+@c OBSOLETE @item set parallel fixed
+@c OBSOLETE All CPUs are assigned to your program whenever it runs.  When it
+@c OBSOLETE executes a pfork or spawn instruction, it begins parallel execution
+@c OBSOLETE immediately.  This does the same thing as the @samp{mpa -f} command.
+@c OBSOLETE 
+@c OBSOLETE @item set parallel on
+@c OBSOLETE One or more threads.  Spawn and pfork cause CPUs to join in when and if
+@c OBSOLETE they are free.  This is the default.  It is very good for system
+@c OBSOLETE throughput, but not very good for finding bugs in parallel code.  If you
+@c OBSOLETE suspect a bug in parallel code, you probably want @samp{set parallel fixed.}
+@c OBSOLETE @end table
+@c OBSOLETE 
+@c OBSOLETE @subsection Limitations
+@c OBSOLETE 
+@c OBSOLETE WARNING: Convex GDB evaluates expressions in long long, because S
+@c OBSOLETE registers are 64 bits long.  However, GDB expression semantics are not
+@c OBSOLETE exactly C semantics.  This is a bug, strictly speaking, but it's not one I
+@c OBSOLETE know how to fix.  If @samp{x} is a program variable of type int, then it
+@c OBSOLETE is also type int to GDB, but @samp{x + 1} is long long, as is @samp{x + y}
+@c OBSOLETE or any other expression requiring computation.  So is the expression
+@c OBSOLETE @samp{1}, or any other constant.  You only really have to watch out for
+@c OBSOLETE calls.  The innocuous expression @samp{list_node (0x80001234)} has an
+@c OBSOLETE argument of type long long.  You must explicitly cast it to int.
+@c OBSOLETE 
+@c OBSOLETE It is not possible to continue after an uncaught fatal signal by using
+@c OBSOLETE @samp{signal 0}, @samp{return}, @samp{jump}, or anything else.  The difficulty is with
+@c OBSOLETE Unix, not GDB.
+@c OBSOLETE 
+@c OBSOLETE I have made no big effort to make such things as single-stepping a
+@c OBSOLETE @kbd{join} instruction do something reasonable.  If the program seems to
+@c OBSOLETE hang when doing this, type @kbd{ctrl-c} and @samp{cont}, or use
+@c OBSOLETE @samp{thread} to shift to a live thread.  Single-stepping a @kbd{spawn}
+@c OBSOLETE instruction apparently causes new threads to be born with their T bit set;
+@c OBSOLETE this is not handled gracefully.  When a thread has hit a breakpoint, other
+@c OBSOLETE threads may have invisibly hit the breakpoint in the background; if you
+@c OBSOLETE clear the breakpoint gdb will be surprised when threads seem to continue
+@c OBSOLETE to stop at it.  All of these situations produce spurious signal 5 traps;
+@c OBSOLETE if this happens, just type @samp{cont}.  If it becomes a nuisance, use
+@c OBSOLETE @samp{handle 5 nostop}.  (It will ask if you are sure.  You are.)
+@c OBSOLETE 
+@c OBSOLETE There is no way in GDB to store a float in a register, as with
+@c OBSOLETE @kbd{set $s0 = 3.1416}.  The identifier @kbd{$s0} denotes an integer,
+@c OBSOLETE and like any C expression which assigns to an integer variable, the
+@c OBSOLETE right-hand side is casted to type int.  If you should need to do
+@c OBSOLETE something like this, you can assign the value to @kbd{@{float@} ($sp-4)}
+@c OBSOLETE and then do @kbd{set $s0 = $sp[-4]}.  Same deal with @kbd{set $v0[69] = 6.9}.
 
-@node Convex,,, Top
-@appendix Convex-specific info
-@cindex Convex notes
-
-Scalar registers are 64 bits long, which is a pain since
-left half of an S register frequently contains noise.
-Therefore there are two ways to obtain the value of an S register.
-
-@table @kbd
-@item $s0
-returns the low half of the register as an int
-
-@item $S0
-returns the whole register as a long long
-@end table
-
-You can print the value in floating point by using @samp{p/f $s0} or @samp{p/f $S0}
-to print a single or double precision value.
-
-@cindex vector registers
-Vector registers are handled similarly, with @samp{$V0} denoting the whole
-64-bit register and @kbd{$v0} denoting the 32-bit low half; @samp{p/f $v0}
-or @samp{p/f $V0} can be used to examine the register in floating point.
-The length of the vector registers is taken from @samp{$vl}.  
-
-Individual elements of a vector register are denoted in the obvious way;
-@samp{print $v3[9]} prints the tenth element of register @kbd{v3}, and
-@samp{set $v3[9] = 1234} alters it.
-
-@kbd{$vl} and @kbd{$vs} are int, and @kbd{$vm} is an int vector.
-Elements of @kbd{$vm} can't be assigned to.
-
-@cindex communication registers
-@kindex info comm-registers
-Communication registers have names @kbd{$C0 .. $C63}, with @kbd{$c0 .. $c63}
-denoting the low-order halves.  @samp{info comm-registers} will print them
-all out, and tell which are locked.  (A communication register is
-locked when a value is sent to it, and unlocked when the value is
-received.)  Communication registers are, of course, global to all
-threads, so it does not matter what the currently selected thread is.
-@samp{info comm-reg @var{name}} prints just that one communication
-register; @samp{name} may also be a communication register number
-@samp{nn} or @samp{0xnn}.
-@samp{info comm-reg @var{address}} prints the contents of the resource
-structure at that address.
-
-@kindex info psw
-The command @samp{info psw} prints the processor status word @kbd{$ps}
-bit by bit.
-
-@kindex set base
-GDB normally prints all integers in base 10, but the leading
-@kbd{0x80000000} of pointers is intolerable in decimal, so the default
-output radix has been changed to try to print addresses appropriately.
-The @samp{set base} command can be used to change this.
-
-@table @code
-@item set base 10
-Integer values always print in decimal.
-
-@item set base 16
-Integer values always print in hex.
-
-@item set base
-Go back to the initial state, which prints integer values in hex if they
-look like pointers (specifically, if they start with 0x8 or 0xf in the
-stack), otherwise in decimal.
-@end table
-
-@kindex set pipeline
-When an exception such as a bus error or overflow happens, usually the PC
-is several instructions ahead by the time the exception is detected.
-The @samp{set pipe} command will disable this.
-
-@table @code
-@item set pipeline off
-Forces serial execution of instructions; no vector chaining and no 
-scalar instruction overlap.  With this, exceptions are detected with 
-the PC pointing to the instruction after the one in error.
-
-@item set pipeline on
-Returns to normal, fast, execution.  This is the default.
-@end table
-
-@cindex parallel
-In a parallel program, multiple threads may be executing, each
-with its own registers, stack, and local memory.  When one of them
-hits a breakpoint, that thread is selected.  Other threads do
-not run while the thread is in the breakpoint.
-
-@kindex 1cont
-The selected thread can be single-stepped, given signals, and so
-on.  Any other threads remain stopped.  When a @samp{cont} command is given,
-all threads are resumed.  To resume just the selected thread, use
-the command @samp{1cont}.
-
-@kindex thread
-The @samp{thread} command will show the active threads and the
-instruction they are about to execute.  The selected thread is marked
-with an asterisk.  The command @samp{thread @var{n}} will select thread @var{n},
-shifting the debugger's attention to it for single-stepping,
-registers, local memory, and so on.
-
-@kindex info threads
-The @samp{info threads} command will show what threads, if any, have
-invisibly hit breakpoints or signals and are waiting to be noticed.
-
-@kindex set parallel
-The @samp{set parallel} command controls how many threads can be active.
-
-@table @code
-@item set parallel off
-One thread.  Requests by the program that other threads join in
-(spawn and pfork instructions) do not cause other threads to start up.
-This does the same thing as the @samp{limit concurrency 1} command.
-
-@item set parallel fixed
-All CPUs are assigned to your program whenever it runs.  When it
-executes a pfork or spawn instruction, it begins parallel execution
-immediately.  This does the same thing as the @samp{mpa -f} command.
-
-@item set parallel on
-One or more threads.  Spawn and pfork cause CPUs to join in when and if
-they are free.  This is the default.  It is very good for system
-throughput, but not very good for finding bugs in parallel code.  If you
-suspect a bug in parallel code, you probably want @samp{set parallel fixed.}
-@end table
-
-@subsection Limitations
-
-WARNING: Convex GDB evaluates expressions in long long, because S
-registers are 64 bits long.  However, GDB expression semantics are not
-exactly C semantics.  This is a bug, strictly speaking, but it's not one I
-know how to fix.  If @samp{x} is a program variable of type int, then it
-is also type int to GDB, but @samp{x + 1} is long long, as is @samp{x + y}
-or any other expression requiring computation.  So is the expression
-@samp{1}, or any other constant.  You only really have to watch out for
-calls.  The innocuous expression @samp{list_node (0x80001234)} has an
-argument of type long long.  You must explicitly cast it to int.
-
-It is not possible to continue after an uncaught fatal signal by using
-@samp{signal 0}, @samp{return}, @samp{jump}, or anything else.  The difficulty is with
-Unix, not GDB.
-
-I have made no big effort to make such things as single-stepping a
-@kbd{join} instruction do something reasonable.  If the program seems to
-hang when doing this, type @kbd{ctrl-c} and @samp{cont}, or use
-@samp{thread} to shift to a live thread.  Single-stepping a @kbd{spawn}
-instruction apparently causes new threads to be born with their T bit set;
-this is not handled gracefully.  When a thread has hit a breakpoint, other
-threads may have invisibly hit the breakpoint in the background; if you
-clear the breakpoint gdb will be surprised when threads seem to continue
-to stop at it.  All of these situations produce spurious signal 5 traps;
-if this happens, just type @samp{cont}.  If it becomes a nuisance, use
-@samp{handle 5 nostop}.  (It will ask if you are sure.  You are.)
-
-There is no way in GDB to store a float in a register, as with
-@kbd{set $s0 = 3.1416}.  The identifier @kbd{$s0} denotes an integer,
-and like any C expression which assigns to an integer variable, the
-right-hand side is casted to type int.  If you should need to do
-something like this, you can assign the value to @kbd{@{float@} ($sp-4)}
-and then do @kbd{set $s0 = $sp[-4]}.  Same deal with @kbd{set $v0[69] = 6.9}.
diff --git a/gdb/config/convex/convex.mh b/gdb/config/convex/convex.mh
index 35a121f..5ec3bfe 100644
--- a/gdb/config/convex/convex.mh
+++ b/gdb/config/convex/convex.mh
@@ -1,3 +1,3 @@
-# Host: Convex Unix (4bsd)
-XDEPFILES= convex-xdep.o
-XM_FILE= xm-convex.h
+# OBSOLETE # Host: Convex Unix (4bsd)
+# OBSOLETE XDEPFILES= convex-xdep.o
+# OBSOLETE XM_FILE= xm-convex.h
diff --git a/gdb/config/convex/convex.mt b/gdb/config/convex/convex.mt
index eefbeb3..425b171 100644
--- a/gdb/config/convex/convex.mt
+++ b/gdb/config/convex/convex.mt
@@ -1,3 +1,3 @@
-# Target: Convex Unix (4bsd)
-TDEPFILES= convex-tdep.o
-TM_FILE= tm-convex.h
+# OBSOLETE # Target: Convex Unix (4bsd)
+# OBSOLETE TDEPFILES= convex-tdep.o
+# OBSOLETE TM_FILE= tm-convex.h
diff --git a/gdb/config/convex/tm-convex.h b/gdb/config/convex/tm-convex.h
index 212f39d..953f767 100644
--- a/gdb/config/convex/tm-convex.h
+++ b/gdb/config/convex/tm-convex.h
@@ -1,486 +1,486 @@
-/* Definitions to make GDB run on Convex Unix (4bsd)
-   Copyright 1989, 1991, 1993 Free Software Foundation, Inc.
-
-This file is part of GDB.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-#define TARGET_BYTE_ORDER BIG_ENDIAN
-
-/* There is come problem with the debugging symbols generated by the
-   compiler such that the debugging symbol for the first line of a
-   function overlap with the function prologue.  */
-#define PROLOGUE_FIRSTLINE_OVERLAP
-
-/* When convex pcc says CHAR or SHORT, it provides the correct address.  */
-
-#define BELIEVE_PCC_PROMOTION 1
-
-/* Symbol types to ignore.  */
-/* 0xc4 is N_MONPT.  Use the numeric value for the benefit of people
-   with (rather) old OS's.  */
-#define IGNORE_SYMBOL(TYPE) \
-    (((TYPE) & ~N_EXT) == N_TBSS       \
-     || ((TYPE) & ~N_EXT) == N_TDATA   \
-     || ((TYPE) & ~N_EXT) == 0xc4)
-
-/* Offset from address of function to start of its code.
-   Zero on most machines.  */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
-   to reach some "real" code.
-   Convex prolog is:
-       [sub.w #-,sp]		in one of 3 possible sizes
-       [mov psw,-		fc/vc main program prolog
-        and #-,-		  (skip it because the "mov psw" saves the
-	mov -,psw]		   T bit, so continue gets a surprise trap)
-       [and #-,sp]		fc/vc O2 main program prolog
-       [ld.- -(ap),-]		pcc/gcc register arg loads
-*/
-
-extern CORE_ADDR convex_skip_prologue PARAMS ((CORE_ADDR pc));
-#define SKIP_PROLOGUE(pc) (convex_skip_prologue (pc))
-
-/* Immediately after a function call, return the saved pc.
-   (ignore frame and return *$sp so we can handle both calls and callq) */
-
-#define SAVED_PC_AFTER_CALL(frame) \
-    read_memory_integer (read_register (SP_REGNUM), 4)
-
-/* Address of end of stack space.
-   This is ((USRSTACK + 0xfff) & -0x1000)) from <convex/vmparam.h> but
-   that expression depends on the kernel version; instead, fetch a
-   page-zero pointer and get it from that.  This will be invalid if
-   they ever change the way bkpt signals are delivered.  */
-
-#define STACK_END_ADDR (0xfffff000 & *(unsigned *) 0x80000050)
-
-/* User-mode traps push an extended rtn block,
-   then fault with one of the following PCs */
-
-#define is_trace_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000040)) <= 4)
-#define is_arith_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000044)) <= 4)
-#define is_break_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000050)) <= 4)
-
-/* We need to manipulate trap bits in the psw */
-
-#define PSW_TRAP_FLAGS	0x69670000
-#define PSW_T_BIT	0x08000000
-#define PSW_S_BIT	0x01000000
-
-/* Stack grows downward.  */
-
-#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
-
-/* Sequence of bytes for breakpoint instruction. (bkpt)  */
-
-#define BREAKPOINT {0x7d,0x50}
-
-/* Amount PC must be decremented by after a breakpoint.
-   This is often the number of bytes in BREAKPOINT but not always.
-   (The break PC needs to be decremented by 2, but we do it when the
-   break frame is recognized and popped.  That way gdb can tell breaks
-   from trace traps with certainty.) */
-
-#define DECR_PC_AFTER_BREAK 0
-
-/* Say how long (ordinary) registers are.  This is a piece of bogosity
-   used in push_word and a few other places; REGISTER_RAW_SIZE is the
-   real way to know how big a register is.  */
-
-#define REGISTER_SIZE 8
-
-/* Number of machine registers */
-
-#define NUM_REGS 26
-
-/* Initializer for an array of names of registers.
-   There should be NUM_REGS strings in this initializer.  */
-
-#define REGISTER_NAMES {"pc","psw","fp","ap","a5","a4","a3","a2","a1","sp",\
-			"s7","s6","s5","s4","s3","s2","s1","s0",\
-			"S7","S6","S5","S4","S3","S2","S1","S0"}
-
-/* Register numbers of various important registers.
-   Note that some of these values are "real" register numbers,
-   and correspond to the general registers of the machine,
-   and some are "phony" register numbers which are too large
-   to be actual register numbers as far as the user is concerned
-   but do serve to get the desired values when passed to read_register.  */
-
-#define S0_REGNUM 25		/* the real S regs */
-#define S7_REGNUM 18
-#define s0_REGNUM 17		/* low-order halves of S regs */
-#define s7_REGNUM 10
-#define SP_REGNUM 9 		/* A regs */
-#define A1_REGNUM 8
-#define A5_REGNUM 4
-#define AP_REGNUM 3
-#define FP_REGNUM 2		/* Contains address of executing stack frame */
-#define PS_REGNUM 1		/* Contains processor status */
-#define PC_REGNUM 0		/* Contains program counter */
-
-/* convert dbx stab register number (from `r' declaration) to a gdb REGNUM */
-
-#define STAB_REG_TO_REGNUM(value) \
-      ((value) < 8 ? S0_REGNUM - (value) : SP_REGNUM - ((value) - 8))
-
-/* Vector register numbers, not handled as ordinary regs.
-   They are treated as convenience variables whose values are read
-   from the inferior when needed.  */
-
-#define V0_REGNUM 0
-#define V7_REGNUM 7
-#define VM_REGNUM 8
-#define VS_REGNUM 9
-#define VL_REGNUM 10
-
-/* Total amount of space needed to store our copies of the machine's
-   register state, the array `registers'.  */
-#define REGISTER_BYTES (4*10 + 8*8)
-
-/* Index within `registers' of the first byte of the space for
-   register N.
-   NB: must match structure of struct syscall_context for correct operation */
-
-#define REGISTER_BYTE(N) ((N) < s7_REGNUM ? 4*(N) : \
-			  (N) < S7_REGNUM ? 44 + 8 * ((N)-s7_REGNUM) : \
-			                    40 + 8 * ((N)-S7_REGNUM))
-
-/* Number of bytes of storage in the actual machine representation
-   for register N. */
-
-#define REGISTER_RAW_SIZE(N) ((N) < S7_REGNUM ? 4 : 8)
-
-/* Number of bytes of storage in the program's representation
-   for register N.   */
-
-#define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
-
-/* Largest value REGISTER_RAW_SIZE can have.  */
-
-#define MAX_REGISTER_RAW_SIZE 8
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Return the GDB type object for the "standard" data type
-   of data in register N.  */
-
-#define REGISTER_VIRTUAL_TYPE(N) \
-   ((N) < S7_REGNUM ? builtin_type_int : builtin_type_long_long)
-
-/* Store the address of the place in which to copy the structure the
-   subroutine will return.  This is called from call_function. */
-
-#define STORE_STRUCT_RETURN(ADDR, SP) \
-  { write_register (A1_REGNUM, (ADDR)); }
-
-/* Extract from an array REGBUF containing the (raw) register state
-   a function return value of type TYPE, and copy that, in virtual format,
-   into VALBUF.  */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
-  memcpy (VALBUF, &((char *) REGBUF) [REGISTER_BYTE (S0_REGNUM) + \
-			     8 - TYPE_LENGTH (TYPE)],\
-	 TYPE_LENGTH (TYPE))
-
-/* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format.  */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
-    write_register_bytes (REGISTER_BYTE (S0_REGNUM), VALBUF, 8)
-
-/* Extract from an array REGBUF containing the (raw) register state
-   the address in which a function should return its structure value,
-   as a CORE_ADDR (or an expression that can be used as one).  */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
-    (*(int *) & ((char *) REGBUF) [REGISTER_BYTE (s0_REGNUM)])
-
-/* Define trapped internal variable hooks to read and write
-   vector and communication registers.  */
-
-#define IS_TRAPPED_INTERNALVAR is_trapped_internalvar
-#define VALUE_OF_TRAPPED_INTERNALVAR value_of_trapped_internalvar
-#define SET_TRAPPED_INTERNALVAR set_trapped_internalvar
-
-extern struct value *value_of_trapped_internalvar ();
-
-/* Hooks to read data from soff exec and core files,
-   and to describe the files.  */
-
-#define FILES_INFO_HOOK print_maps
-
-/* Hook to call to print a typeless integer value, normally printed in decimal.
-   For convex, use hex instead if the number looks like an address.  */
-
-#define PRINT_TYPELESS_INTEGER decout
-
-/* For the native compiler, variables for a particular lexical context
-   are listed after the beginning LBRAC instead of before in the
-   executables list of symbols.  Using "gcc_compiled." to distinguish
-   between GCC and native compiler doesn't work on Convex because the
-   linker sorts the symbols to put "gcc_compiled." in the wrong place.
-   desc is nonzero for native, zero for gcc.   */
-#define VARIABLES_INSIDE_BLOCK(desc, gcc_p) (desc != 0)
-
-/* Pcc occaisionally puts an SO where there should be an SOL.   */
-#define PCC_SOL_BROKEN
-
-/* Describe the pointer in each stack frame to the previous stack frame
-   (its caller).  */
-
-/* FRAME_CHAIN takes a frame_info with a frame's nominal address in fi->frame,
-   and produces the frame's chain-pointer. */
-
-/* (caller fp is saved at 8(fp)) */
-
-#define FRAME_CHAIN(fi)   (read_memory_integer ((fi)->frame + 8, 4))
-
-/* Define other aspects of the stack frame.  */
-
-/* We need the boundaries of the text in the exec file, as a kludge,
-   for FRAMELESS_FUNCTION_INVOCATION and CALL_DUMMY_LOCATION. */
-
-#define	NEED_TEXT_START_END 1
-
-/* An expression that tells us whether the function invocation represented
-   by FI does not have a frame on the stack associated with it.
-   On convex, check at the return address for `callq' -- if so, frameless,
-   otherwise, not.  */
-
-extern int convex_frameless_function_invocation PARAMS ((struct frame_info *fi));
-#define FRAMELESS_FUNCTION_INVOCATION(FI) (convex_frameless_function_invocatio (FI))
-
-#define FRAME_SAVED_PC(fi) (read_memory_integer ((fi)->frame, 4))
-
-#define FRAME_ARGS_ADDRESS(fi) (read_memory_integer ((fi)->frame + 12, 4))
-
-#define FRAME_LOCALS_ADDRESS(fi) (fi)->frame
-
-/* Return number of args passed to a frame.
-   Can return -1, meaning no way to tell.  */
-
-extern int convex_frame_num_args PARAMS ((struct frame_info *fi));
-#define FRAME_NUM_ARGS(fi) (convex_frame_num_args ((fi)))
-
-/* Return number of bytes at start of arglist that are not really args.  */
-
-#define FRAME_ARGS_SKIP 0
-
-/* Put here the code to store, into a struct frame_saved_regs,
-   the addresses of the saved registers of frame described by FRAME_INFO.
-   This includes special registers such as pc and fp saved in special
-   ways in the stack frame.  sp is even more special:
-   the address we return for it IS the sp for the next frame.  */
-
-/* Normal (short) frames save only PC, FP, (callee's) AP.  To reasonably
-   handle gcc and pcc register variables, scan the code following the
-   call for the instructions the compiler inserts to reload register
-   variables from stack slots and record the stack slots as the saved
-   locations of those registers.  This will occasionally identify some
-   random load as a saved register; this is harmless.  vc does not
-   declare its register allocation actions in the stabs.  */
-
-#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
-{ register int regnum;							\
-  register int frame_length =	/* 3 short, 2 long, 1 extended, 0 context */\
-      (read_memory_integer ((frame_info)->frame + 4, 4) >> 25) & 3;	\
-  register CORE_ADDR frame_fp =						\
-      read_memory_integer ((frame_info)->frame + 8, 4);			\
-  register CORE_ADDR next_addr;						\
-  memset (&frame_saved_regs, '\0', sizeof frame_saved_regs);			\
-  (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 0;		\
-  (frame_saved_regs).regs[PS_REGNUM] = (frame_info)->frame + 4;		\
-  (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame + 8;		\
-  (frame_saved_regs).regs[AP_REGNUM] = frame_fp + 12;			\
-  next_addr = (frame_info)->frame + 12;					\
-  if (frame_length < 3)							\
-    for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum)		\
-      (frame_saved_regs).regs[regnum] = (next_addr += 4);		\
-  if (frame_length < 2)							\
-    (frame_saved_regs).regs[SP_REGNUM] = (next_addr += 4);		\
-  next_addr -= 4;							\
-  if (frame_length < 3)							\
-    for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum)		\
-      (frame_saved_regs).regs[regnum] = (next_addr += 8);		\
-  if (frame_length < 2)							\
-    (frame_saved_regs).regs[S0_REGNUM] = (next_addr += 8);		\
-  else									\
-    (frame_saved_regs).regs[SP_REGNUM] = next_addr + 8;			\
-  if (frame_length == 3) {						\
-    CORE_ADDR pc = read_memory_integer ((frame_info)->frame, 4);	\
-    int op, ix, disp;							\
-    op = read_memory_integer (pc, 2);					\
-    if ((op & 0xffc7) == 0x1480) pc += 4; 	/* add.w #-,sp */	\
-    else if ((op & 0xffc7) == 0x58c0) pc += 2;	/* add.w #-,sp */	\
-    op = read_memory_integer (pc, 2);					\
-    if ((op & 0xffc7) == 0x2a06) pc += 4;	/* ld.w -,ap */		\
-    for (;;) {								\
-      op = read_memory_integer (pc, 2);					\
-      ix = (op >> 3) & 7;						\
-      if ((op & 0xfcc0) == 0x2800) {		/* ld.- -,ak */		\
-        regnum = SP_REGNUM - (op & 7);					\
-	disp = read_memory_integer (pc + 2, 2);				\
-	pc += 4;}							\
-      else if ((op & 0xfcc0) == 0x2840) {	/* ld.- -,ak */		\
-        regnum = SP_REGNUM - (op & 7);					\
-	disp = read_memory_integer (pc + 2, 4);				\
-	pc += 6;}							\
-      if ((op & 0xfcc0) == 0x3000) {		/* ld.- -,sk */		\
-        regnum = S0_REGNUM - (op & 7);					\
-	disp = read_memory_integer (pc + 2, 2);				\
-	pc += 4;}							\
-      else if ((op & 0xfcc0) == 0x3040) {	/* ld.- -,sk */		\
-        regnum = S0_REGNUM - (op & 7);					\
-	disp = read_memory_integer (pc + 2, 4);				\
-	pc += 6;}							\
-      else if ((op & 0xff00) == 0x7100) {	/* br crossjump */	\
-        pc += 2 * (char) op;						\
-        continue;}							\
-      else if (op == 0x0140) {			/* jmp crossjump */	\
-        pc = read_memory_integer (pc + 2, 4);				\
-        continue;}							\
-      else break;							\
-      if ((frame_saved_regs).regs[regnum])				\
-	break;								\
-      if (ix == 7) disp += frame_fp;					\
-      else if (ix == 6) disp += read_memory_integer (frame_fp + 12, 4);	\
-      else if (ix != 0) break;						\
-      (frame_saved_regs).regs[regnum] =					\
-	disp - 8 + (1 << ((op >> 8) & 3));				\
-      if (regnum >= S7_REGNUM)						\
-        (frame_saved_regs).regs[regnum - S0_REGNUM + s0_REGNUM] =	\
-	  disp - 4 + (1 << ((op >> 8) & 3));				\
-    }									\
-  }									\
-}
-
-/* Things needed for making the inferior call functions.  */
-
-#define	CALL_DUMMY_LOCATION	BEFORE_TEXT_END
-
-/* Push an empty stack frame, to record the current PC, etc.  */
-
-#define PUSH_DUMMY_FRAME \
-{ register CORE_ADDR sp = read_register (SP_REGNUM);			\
-  register int regnum;				    			\
-  char buf[8];					    			\
-  long word;								\
-  for (regnum = S0_REGNUM; regnum >= S7_REGNUM; --regnum) { 		\
-    read_register_bytes (REGISTER_BYTE (regnum), buf, 8); 		\
-    sp = push_bytes (sp, buf, 8);}		    			\
-  for (regnum = SP_REGNUM; regnum >= FP_REGNUM; --regnum) { 		\
-    word = read_register (regnum);					\
-    sp = push_bytes (sp, &word, 4);}   					\
-  word = (read_register (PS_REGNUM) &~ (3<<25)) | (1<<25);		\
-  sp = push_bytes (sp, &word, 4); 					\
-  word = read_register (PC_REGNUM);					\
-  sp = push_bytes (sp, &word, 4);   					\
-  write_register (SP_REGNUM, sp);		    			\
-  write_register (FP_REGNUM, sp);		    			\
-  write_register (AP_REGNUM, sp);}
-
-/* Discard from the stack the innermost frame, restoring all registers.  */
-
-#define POP_FRAME  do {\
-  register CORE_ADDR fp = read_register (FP_REGNUM);	    \
-  register int regnum;					    \
-  register int frame_length =	/* 3 short, 2 long, 1 extended, 0 context */ \
-      (read_memory_integer (fp + 4, 4) >> 25) & 3;          \
-  char buf[8];					            \
-  write_register (PC_REGNUM, read_memory_integer (fp, 4));  \
-  write_register (PS_REGNUM, read_memory_integer (fp += 4, 4));  \
-  write_register (FP_REGNUM, read_memory_integer (fp += 4, 4));  \
-  write_register (AP_REGNUM, read_memory_integer (fp += 4, 4));  \
-  if (frame_length < 3) 				     \
-    for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum)   \
-      write_register (regnum, read_memory_integer (fp += 4, 4)); \
-  if (frame_length < 2)					     \
-    write_register (SP_REGNUM, read_memory_integer (fp += 4, 4)); \
-  fp -= 4;							\
-  if (frame_length < 3)  					\
-    for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum) {	\
-      read_memory (fp += 8, buf, 8);				\
-      write_register_bytes (REGISTER_BYTE (regnum), buf, 8);}   \
-  if (frame_length < 2)	{					\
-    read_memory (fp += 8, buf, 8);				\
-    write_register_bytes (REGISTER_BYTE (regnum), buf, 8);}     \
-  else write_register (SP_REGNUM, fp + 8);			\
-  flush_cached_frames ();					\
-} while (0)
-
-/* This sequence of words is the instructions
-     mov sp,ap
-     pshea 69696969
-     calls 32323232
-     bkpt
-   Note this is 16 bytes.  */
-
-#define CALL_DUMMY {0x50860d4069696969LL,0x2140323232327d50LL}
-
-#define CALL_DUMMY_LENGTH 16
-
-#define CALL_DUMMY_START_OFFSET 0
-
-/* Insert the specified number of args and function address
-   into a call sequence of the above form stored at DUMMYNAME.  */
-
-#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)   \
-{ *(int *)((char *) dummyname + 4) = nargs;	\
-  *(int *)((char *) dummyname + 10) = fun; }
-
-/* Defs to read soff symbol tables, see dbxread.c */
-
-#define NUMBER_OF_SYMBOLS    ((long) opthdr.o_nsyms)
-#define STRING_TABLE_OFFSET  ((long) filehdr.h_strptr)
-#define SYMBOL_TABLE_OFFSET  ((long) opthdr.o_symptr)
-#define STRING_TABLE_SIZE    ((long) filehdr.h_strsiz)
-#define SIZE_OF_TEXT_SEGMENT ((long) txthdr.s_size)
-#define ENTRY_POINT          ((long) opthdr.o_entry)
-
-#define READ_STRING_TABLE_SIZE(BUFFER) \
-    (BUFFER = STRING_TABLE_SIZE)
-
-#define DECLARE_FILE_HEADERS \
-  FILEHDR filehdr;							\
-  OPTHDR opthdr;							\
-  SCNHDR txthdr
-
-#define READ_FILE_HEADERS(DESC,NAME) \
-{									\
-  int n;								\
-  val = myread (DESC, &filehdr, sizeof filehdr);			\
-  if (val < 0)								\
-    perror_with_name (NAME);						\
-  if (! IS_SOFF_MAGIC (filehdr.h_magic))				\
-    error ("%s: not an executable file.", NAME);			\
-  lseek (DESC, 0L, 0);							\
-  if (myread (DESC, &filehdr, sizeof filehdr) < 0)			\
-    perror_with_name (NAME);						\
-  if (myread (DESC, &opthdr, filehdr.h_opthdr) <= 0)			\
-    perror_with_name (NAME);						\
-  for (n = 0; n < filehdr.h_nscns; n++)					\
-    {									\
-      if (myread (DESC, &txthdr, sizeof txthdr) < 0)			\
-	perror_with_name (NAME);					\
-      if ((txthdr.s_flags & S_TYPMASK) == S_TEXT)			\
-	break;								\
-    }									\
-}
+/* OBSOLETE /* Definitions to make GDB run on Convex Unix (4bsd) */
+/* OBSOLETE    Copyright 1989, 1991, 1993 Free Software Foundation, Inc. */
+/* OBSOLETE  */
+/* OBSOLETE This file is part of GDB. */
+/* OBSOLETE  */
+/* OBSOLETE This program is free software; you can redistribute it and/or modify */
+/* OBSOLETE it under the terms of the GNU General Public License as published by */
+/* OBSOLETE the Free Software Foundation; either version 2 of the License, or */
+/* OBSOLETE (at your option) any later version. */
+/* OBSOLETE  */
+/* OBSOLETE This program is distributed in the hope that it will be useful, */
+/* OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
+/* OBSOLETE GNU General Public License for more details. */
+/* OBSOLETE  */
+/* OBSOLETE You should have received a copy of the GNU General Public License */
+/* OBSOLETE along with this program; if not, write to the Free Software */
+/* OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define TARGET_BYTE_ORDER BIG_ENDIAN */
+/* OBSOLETE  */
+/* OBSOLETE /* There is come problem with the debugging symbols generated by the */
+/* OBSOLETE    compiler such that the debugging symbol for the first line of a */
+/* OBSOLETE    function overlap with the function prologue.  *x/ */
+/* OBSOLETE #define PROLOGUE_FIRSTLINE_OVERLAP */
+/* OBSOLETE  */
+/* OBSOLETE /* When convex pcc says CHAR or SHORT, it provides the correct address.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define BELIEVE_PCC_PROMOTION 1 */
+/* OBSOLETE  */
+/* OBSOLETE /* Symbol types to ignore.  *x/ */
+/* OBSOLETE /* 0xc4 is N_MONPT.  Use the numeric value for the benefit of people */
+/* OBSOLETE    with (rather) old OS's.  *x/ */
+/* OBSOLETE #define IGNORE_SYMBOL(TYPE) \ */
+/* OBSOLETE     (((TYPE) & ~N_EXT) == N_TBSS       \ */
+/* OBSOLETE      || ((TYPE) & ~N_EXT) == N_TDATA   \ */
+/* OBSOLETE      || ((TYPE) & ~N_EXT) == 0xc4) */
+/* OBSOLETE  */
+/* OBSOLETE /* Offset from address of function to start of its code. */
+/* OBSOLETE    Zero on most machines.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define FUNCTION_START_OFFSET 0 */
+/* OBSOLETE  */
+/* OBSOLETE /* Advance PC across any function entry prologue instructions */
+/* OBSOLETE    to reach some "real" code. */
+/* OBSOLETE    Convex prolog is: */
+/* OBSOLETE        [sub.w #-,sp]		in one of 3 possible sizes */
+/* OBSOLETE        [mov psw,-		fc/vc main program prolog */
+/* OBSOLETE         and #-,-		  (skip it because the "mov psw" saves the */
+/* OBSOLETE 	mov -,psw]		   T bit, so continue gets a surprise trap) */
+/* OBSOLETE        [and #-,sp]		fc/vc O2 main program prolog */
+/* OBSOLETE        [ld.- -(ap),-]		pcc/gcc register arg loads */
+/* OBSOLETE *x/ */
+/* OBSOLETE  */
+/* OBSOLETE extern CORE_ADDR convex_skip_prologue PARAMS ((CORE_ADDR pc)); */
+/* OBSOLETE #define SKIP_PROLOGUE(pc) (convex_skip_prologue (pc)) */
+/* OBSOLETE  */
+/* OBSOLETE /* Immediately after a function call, return the saved pc. */
+/* OBSOLETE    (ignore frame and return *$sp so we can handle both calls and callq) *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define SAVED_PC_AFTER_CALL(frame) \ */
+/* OBSOLETE     read_memory_integer (read_register (SP_REGNUM), 4) */
+/* OBSOLETE  */
+/* OBSOLETE /* Address of end of stack space. */
+/* OBSOLETE    This is ((USRSTACK + 0xfff) & -0x1000)) from <convex/vmparam.h> but */
+/* OBSOLETE    that expression depends on the kernel version; instead, fetch a */
+/* OBSOLETE    page-zero pointer and get it from that.  This will be invalid if */
+/* OBSOLETE    they ever change the way bkpt signals are delivered.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define STACK_END_ADDR (0xfffff000 & *(unsigned *) 0x80000050) */
+/* OBSOLETE  */
+/* OBSOLETE /* User-mode traps push an extended rtn block, */
+/* OBSOLETE    then fault with one of the following PCs *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define is_trace_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000040)) <= 4) */
+/* OBSOLETE #define is_arith_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000044)) <= 4) */
+/* OBSOLETE #define is_break_pc(pc)  ((unsigned) ((pc) - (*(int *) 0x80000050)) <= 4) */
+/* OBSOLETE  */
+/* OBSOLETE /* We need to manipulate trap bits in the psw *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define PSW_TRAP_FLAGS	0x69670000 */
+/* OBSOLETE #define PSW_T_BIT	0x08000000 */
+/* OBSOLETE #define PSW_S_BIT	0x01000000 */
+/* OBSOLETE  */
+/* OBSOLETE /* Stack grows downward.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define INNER_THAN(lhs,rhs) ((lhs) < (rhs)) */
+/* OBSOLETE  */
+/* OBSOLETE /* Sequence of bytes for breakpoint instruction. (bkpt)  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define BREAKPOINT {0x7d,0x50} */
+/* OBSOLETE  */
+/* OBSOLETE /* Amount PC must be decremented by after a breakpoint. */
+/* OBSOLETE    This is often the number of bytes in BREAKPOINT but not always. */
+/* OBSOLETE    (The break PC needs to be decremented by 2, but we do it when the */
+/* OBSOLETE    break frame is recognized and popped.  That way gdb can tell breaks */
+/* OBSOLETE    from trace traps with certainty.) *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define DECR_PC_AFTER_BREAK 0 */
+/* OBSOLETE  */
+/* OBSOLETE /* Say how long (ordinary) registers are.  This is a piece of bogosity */
+/* OBSOLETE    used in push_word and a few other places; REGISTER_RAW_SIZE is the */
+/* OBSOLETE    real way to know how big a register is.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_SIZE 8 */
+/* OBSOLETE  */
+/* OBSOLETE /* Number of machine registers *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define NUM_REGS 26 */
+/* OBSOLETE  */
+/* OBSOLETE /* Initializer for an array of names of registers. */
+/* OBSOLETE    There should be NUM_REGS strings in this initializer.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_NAMES {"pc","psw","fp","ap","a5","a4","a3","a2","a1","sp",\ */
+/* OBSOLETE 			"s7","s6","s5","s4","s3","s2","s1","s0",\ */
+/* OBSOLETE 			"S7","S6","S5","S4","S3","S2","S1","S0"} */
+/* OBSOLETE  */
+/* OBSOLETE /* Register numbers of various important registers. */
+/* OBSOLETE    Note that some of these values are "real" register numbers, */
+/* OBSOLETE    and correspond to the general registers of the machine, */
+/* OBSOLETE    and some are "phony" register numbers which are too large */
+/* OBSOLETE    to be actual register numbers as far as the user is concerned */
+/* OBSOLETE    but do serve to get the desired values when passed to read_register.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define S0_REGNUM 25		/* the real S regs *x/ */
+/* OBSOLETE #define S7_REGNUM 18 */
+/* OBSOLETE #define s0_REGNUM 17		/* low-order halves of S regs *x/ */
+/* OBSOLETE #define s7_REGNUM 10 */
+/* OBSOLETE #define SP_REGNUM 9 		/* A regs *x/ */
+/* OBSOLETE #define A1_REGNUM 8 */
+/* OBSOLETE #define A5_REGNUM 4 */
+/* OBSOLETE #define AP_REGNUM 3 */
+/* OBSOLETE #define FP_REGNUM 2		/* Contains address of executing stack frame *x/ */
+/* OBSOLETE #define PS_REGNUM 1		/* Contains processor status *x/ */
+/* OBSOLETE #define PC_REGNUM 0		/* Contains program counter *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* convert dbx stab register number (from `r' declaration) to a gdb REGNUM *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define STAB_REG_TO_REGNUM(value) \ */
+/* OBSOLETE       ((value) < 8 ? S0_REGNUM - (value) : SP_REGNUM - ((value) - 8)) */
+/* OBSOLETE  */
+/* OBSOLETE /* Vector register numbers, not handled as ordinary regs. */
+/* OBSOLETE    They are treated as convenience variables whose values are read */
+/* OBSOLETE    from the inferior when needed.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define V0_REGNUM 0 */
+/* OBSOLETE #define V7_REGNUM 7 */
+/* OBSOLETE #define VM_REGNUM 8 */
+/* OBSOLETE #define VS_REGNUM 9 */
+/* OBSOLETE #define VL_REGNUM 10 */
+/* OBSOLETE  */
+/* OBSOLETE /* Total amount of space needed to store our copies of the machine's */
+/* OBSOLETE    register state, the array `registers'.  *x/ */
+/* OBSOLETE #define REGISTER_BYTES (4*10 + 8*8) */
+/* OBSOLETE  */
+/* OBSOLETE /* Index within `registers' of the first byte of the space for */
+/* OBSOLETE    register N. */
+/* OBSOLETE    NB: must match structure of struct syscall_context for correct operation *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_BYTE(N) ((N) < s7_REGNUM ? 4*(N) : \ */
+/* OBSOLETE 			  (N) < S7_REGNUM ? 44 + 8 * ((N)-s7_REGNUM) : \ */
+/* OBSOLETE 			                    40 + 8 * ((N)-S7_REGNUM)) */
+/* OBSOLETE  */
+/* OBSOLETE /* Number of bytes of storage in the actual machine representation */
+/* OBSOLETE    for register N. *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_RAW_SIZE(N) ((N) < S7_REGNUM ? 4 : 8) */
+/* OBSOLETE  */
+/* OBSOLETE /* Number of bytes of storage in the program's representation */
+/* OBSOLETE    for register N.   *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N) */
+/* OBSOLETE  */
+/* OBSOLETE /* Largest value REGISTER_RAW_SIZE can have.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define MAX_REGISTER_RAW_SIZE 8 */
+/* OBSOLETE  */
+/* OBSOLETE /* Largest value REGISTER_VIRTUAL_SIZE can have.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define MAX_REGISTER_VIRTUAL_SIZE 8 */
+/* OBSOLETE  */
+/* OBSOLETE /* Return the GDB type object for the "standard" data type */
+/* OBSOLETE    of data in register N.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_VIRTUAL_TYPE(N) \ */
+/* OBSOLETE    ((N) < S7_REGNUM ? builtin_type_int : builtin_type_long_long) */
+/* OBSOLETE  */
+/* OBSOLETE /* Store the address of the place in which to copy the structure the */
+/* OBSOLETE    subroutine will return.  This is called from call_function. *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define STORE_STRUCT_RETURN(ADDR, SP) \ */
+/* OBSOLETE   { write_register (A1_REGNUM, (ADDR)); } */
+/* OBSOLETE  */
+/* OBSOLETE /* Extract from an array REGBUF containing the (raw) register state */
+/* OBSOLETE    a function return value of type TYPE, and copy that, in virtual format, */
+/* OBSOLETE    into VALBUF.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ */
+/* OBSOLETE   memcpy (VALBUF, &((char *) REGBUF) [REGISTER_BYTE (S0_REGNUM) + \ */
+/* OBSOLETE 			     8 - TYPE_LENGTH (TYPE)],\ */
+/* OBSOLETE 	 TYPE_LENGTH (TYPE)) */
+/* OBSOLETE  */
+/* OBSOLETE /* Write into appropriate registers a function return value */
+/* OBSOLETE    of type TYPE, given in virtual format.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define STORE_RETURN_VALUE(TYPE,VALBUF) \ */
+/* OBSOLETE     write_register_bytes (REGISTER_BYTE (S0_REGNUM), VALBUF, 8) */
+/* OBSOLETE  */
+/* OBSOLETE /* Extract from an array REGBUF containing the (raw) register state */
+/* OBSOLETE    the address in which a function should return its structure value, */
+/* OBSOLETE    as a CORE_ADDR (or an expression that can be used as one).  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ */
+/* OBSOLETE     (*(int *) & ((char *) REGBUF) [REGISTER_BYTE (s0_REGNUM)]) */
+/* OBSOLETE  */
+/* OBSOLETE /* Define trapped internal variable hooks to read and write */
+/* OBSOLETE    vector and communication registers.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define IS_TRAPPED_INTERNALVAR is_trapped_internalvar */
+/* OBSOLETE #define VALUE_OF_TRAPPED_INTERNALVAR value_of_trapped_internalvar */
+/* OBSOLETE #define SET_TRAPPED_INTERNALVAR set_trapped_internalvar */
+/* OBSOLETE  */
+/* OBSOLETE extern struct value *value_of_trapped_internalvar (); */
+/* OBSOLETE  */
+/* OBSOLETE /* Hooks to read data from soff exec and core files, */
+/* OBSOLETE    and to describe the files.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define FILES_INFO_HOOK print_maps */
+/* OBSOLETE  */
+/* OBSOLETE /* Hook to call to print a typeless integer value, normally printed in decimal. */
+/* OBSOLETE    For convex, use hex instead if the number looks like an address.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define PRINT_TYPELESS_INTEGER decout */
+/* OBSOLETE  */
+/* OBSOLETE /* For the native compiler, variables for a particular lexical context */
+/* OBSOLETE    are listed after the beginning LBRAC instead of before in the */
+/* OBSOLETE    executables list of symbols.  Using "gcc_compiled." to distinguish */
+/* OBSOLETE    between GCC and native compiler doesn't work on Convex because the */
+/* OBSOLETE    linker sorts the symbols to put "gcc_compiled." in the wrong place. */
+/* OBSOLETE    desc is nonzero for native, zero for gcc.   *x/ */
+/* OBSOLETE #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) (desc != 0) */
+/* OBSOLETE  */
+/* OBSOLETE /* Pcc occaisionally puts an SO where there should be an SOL.   *x/ */
+/* OBSOLETE #define PCC_SOL_BROKEN */
+/* OBSOLETE  */
+/* OBSOLETE /* Describe the pointer in each stack frame to the previous stack frame */
+/* OBSOLETE    (its caller).  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* FRAME_CHAIN takes a frame_info with a frame's nominal address in fi->frame, */
+/* OBSOLETE    and produces the frame's chain-pointer. *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* (caller fp is saved at 8(fp)) *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define FRAME_CHAIN(fi)   (read_memory_integer ((fi)->frame + 8, 4)) */
+/* OBSOLETE  */
+/* OBSOLETE /* Define other aspects of the stack frame.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* We need the boundaries of the text in the exec file, as a kludge, */
+/* OBSOLETE    for FRAMELESS_FUNCTION_INVOCATION and CALL_DUMMY_LOCATION. *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define	NEED_TEXT_START_END 1 */
+/* OBSOLETE  */
+/* OBSOLETE /* An expression that tells us whether the function invocation represented */
+/* OBSOLETE    by FI does not have a frame on the stack associated with it. */
+/* OBSOLETE    On convex, check at the return address for `callq' -- if so, frameless, */
+/* OBSOLETE    otherwise, not.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE extern int convex_frameless_function_invocation PARAMS ((struct frame_info *fi)); */
+/* OBSOLETE #define FRAMELESS_FUNCTION_INVOCATION(FI) (convex_frameless_function_invocatio (FI)) */
+/* OBSOLETE  */
+/* OBSOLETE #define FRAME_SAVED_PC(fi) (read_memory_integer ((fi)->frame, 4)) */
+/* OBSOLETE  */
+/* OBSOLETE #define FRAME_ARGS_ADDRESS(fi) (read_memory_integer ((fi)->frame + 12, 4)) */
+/* OBSOLETE  */
+/* OBSOLETE #define FRAME_LOCALS_ADDRESS(fi) (fi)->frame */
+/* OBSOLETE  */
+/* OBSOLETE /* Return number of args passed to a frame. */
+/* OBSOLETE    Can return -1, meaning no way to tell.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE extern int convex_frame_num_args PARAMS ((struct frame_info *fi)); */
+/* OBSOLETE #define FRAME_NUM_ARGS(fi) (convex_frame_num_args ((fi))) */
+/* OBSOLETE  */
+/* OBSOLETE /* Return number of bytes at start of arglist that are not really args.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define FRAME_ARGS_SKIP 0 */
+/* OBSOLETE  */
+/* OBSOLETE /* Put here the code to store, into a struct frame_saved_regs, */
+/* OBSOLETE    the addresses of the saved registers of frame described by FRAME_INFO. */
+/* OBSOLETE    This includes special registers such as pc and fp saved in special */
+/* OBSOLETE    ways in the stack frame.  sp is even more special: */
+/* OBSOLETE    the address we return for it IS the sp for the next frame.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* Normal (short) frames save only PC, FP, (callee's) AP.  To reasonably */
+/* OBSOLETE    handle gcc and pcc register variables, scan the code following the */
+/* OBSOLETE    call for the instructions the compiler inserts to reload register */
+/* OBSOLETE    variables from stack slots and record the stack slots as the saved */
+/* OBSOLETE    locations of those registers.  This will occasionally identify some */
+/* OBSOLETE    random load as a saved register; this is harmless.  vc does not */
+/* OBSOLETE    declare its register allocation actions in the stabs.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\ */
+/* OBSOLETE { register int regnum;							\ */
+/* OBSOLETE   register int frame_length =	/* 3 short, 2 long, 1 extended, 0 context *x/\ */
+/* OBSOLETE       (read_memory_integer ((frame_info)->frame + 4, 4) >> 25) & 3;	\ */
+/* OBSOLETE   register CORE_ADDR frame_fp =						\ */
+/* OBSOLETE       read_memory_integer ((frame_info)->frame + 8, 4);			\ */
+/* OBSOLETE   register CORE_ADDR next_addr;						\ */
+/* OBSOLETE   memset (&frame_saved_regs, '\0', sizeof frame_saved_regs);			\ */
+/* OBSOLETE   (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 0;		\ */
+/* OBSOLETE   (frame_saved_regs).regs[PS_REGNUM] = (frame_info)->frame + 4;		\ */
+/* OBSOLETE   (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame + 8;		\ */
+/* OBSOLETE   (frame_saved_regs).regs[AP_REGNUM] = frame_fp + 12;			\ */
+/* OBSOLETE   next_addr = (frame_info)->frame + 12;					\ */
+/* OBSOLETE   if (frame_length < 3)							\ */
+/* OBSOLETE     for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum)		\ */
+/* OBSOLETE       (frame_saved_regs).regs[regnum] = (next_addr += 4);		\ */
+/* OBSOLETE   if (frame_length < 2)							\ */
+/* OBSOLETE     (frame_saved_regs).regs[SP_REGNUM] = (next_addr += 4);		\ */
+/* OBSOLETE   next_addr -= 4;							\ */
+/* OBSOLETE   if (frame_length < 3)							\ */
+/* OBSOLETE     for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum)		\ */
+/* OBSOLETE       (frame_saved_regs).regs[regnum] = (next_addr += 8);		\ */
+/* OBSOLETE   if (frame_length < 2)							\ */
+/* OBSOLETE     (frame_saved_regs).regs[S0_REGNUM] = (next_addr += 8);		\ */
+/* OBSOLETE   else									\ */
+/* OBSOLETE     (frame_saved_regs).regs[SP_REGNUM] = next_addr + 8;			\ */
+/* OBSOLETE   if (frame_length == 3) {						\ */
+/* OBSOLETE     CORE_ADDR pc = read_memory_integer ((frame_info)->frame, 4);	\ */
+/* OBSOLETE     int op, ix, disp;							\ */
+/* OBSOLETE     op = read_memory_integer (pc, 2);					\ */
+/* OBSOLETE     if ((op & 0xffc7) == 0x1480) pc += 4; 	/* add.w #-,sp *x/	\ */
+/* OBSOLETE     else if ((op & 0xffc7) == 0x58c0) pc += 2;	/* add.w #-,sp *x/	\ */
+/* OBSOLETE     op = read_memory_integer (pc, 2);					\ */
+/* OBSOLETE     if ((op & 0xffc7) == 0x2a06) pc += 4;	/* ld.w -,ap *x/		\ */
+/* OBSOLETE     for (;;) {								\ */
+/* OBSOLETE       op = read_memory_integer (pc, 2);					\ */
+/* OBSOLETE       ix = (op >> 3) & 7;						\ */
+/* OBSOLETE       if ((op & 0xfcc0) == 0x2800) {		/* ld.- -,ak *x/		\ */
+/* OBSOLETE         regnum = SP_REGNUM - (op & 7);					\ */
+/* OBSOLETE 	disp = read_memory_integer (pc + 2, 2);				\ */
+/* OBSOLETE 	pc += 4;}							\ */
+/* OBSOLETE       else if ((op & 0xfcc0) == 0x2840) {	/* ld.- -,ak *x/		\ */
+/* OBSOLETE         regnum = SP_REGNUM - (op & 7);					\ */
+/* OBSOLETE 	disp = read_memory_integer (pc + 2, 4);				\ */
+/* OBSOLETE 	pc += 6;}							\ */
+/* OBSOLETE       if ((op & 0xfcc0) == 0x3000) {		/* ld.- -,sk *x/		\ */
+/* OBSOLETE         regnum = S0_REGNUM - (op & 7);					\ */
+/* OBSOLETE 	disp = read_memory_integer (pc + 2, 2);				\ */
+/* OBSOLETE 	pc += 4;}							\ */
+/* OBSOLETE       else if ((op & 0xfcc0) == 0x3040) {	/* ld.- -,sk *x/		\ */
+/* OBSOLETE         regnum = S0_REGNUM - (op & 7);					\ */
+/* OBSOLETE 	disp = read_memory_integer (pc + 2, 4);				\ */
+/* OBSOLETE 	pc += 6;}							\ */
+/* OBSOLETE       else if ((op & 0xff00) == 0x7100) {	/* br crossjump *x/	\ */
+/* OBSOLETE         pc += 2 * (char) op;						\ */
+/* OBSOLETE         continue;}							\ */
+/* OBSOLETE       else if (op == 0x0140) {			/* jmp crossjump *x/	\ */
+/* OBSOLETE         pc = read_memory_integer (pc + 2, 4);				\ */
+/* OBSOLETE         continue;}							\ */
+/* OBSOLETE       else break;							\ */
+/* OBSOLETE       if ((frame_saved_regs).regs[regnum])				\ */
+/* OBSOLETE 	break;								\ */
+/* OBSOLETE       if (ix == 7) disp += frame_fp;					\ */
+/* OBSOLETE       else if (ix == 6) disp += read_memory_integer (frame_fp + 12, 4);	\ */
+/* OBSOLETE       else if (ix != 0) break;						\ */
+/* OBSOLETE       (frame_saved_regs).regs[regnum] =					\ */
+/* OBSOLETE 	disp - 8 + (1 << ((op >> 8) & 3));				\ */
+/* OBSOLETE       if (regnum >= S7_REGNUM)						\ */
+/* OBSOLETE         (frame_saved_regs).regs[regnum - S0_REGNUM + s0_REGNUM] =	\ */
+/* OBSOLETE 	  disp - 4 + (1 << ((op >> 8) & 3));				\ */
+/* OBSOLETE     }									\ */
+/* OBSOLETE   }									\ */
+/* OBSOLETE } */
+/* OBSOLETE  */
+/* OBSOLETE /* Things needed for making the inferior call functions.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define	CALL_DUMMY_LOCATION	BEFORE_TEXT_END */
+/* OBSOLETE  */
+/* OBSOLETE /* Push an empty stack frame, to record the current PC, etc.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define PUSH_DUMMY_FRAME \ */
+/* OBSOLETE { register CORE_ADDR sp = read_register (SP_REGNUM);			\ */
+/* OBSOLETE   register int regnum;				    			\ */
+/* OBSOLETE   char buf[8];					    			\ */
+/* OBSOLETE   long word;								\ */
+/* OBSOLETE   for (regnum = S0_REGNUM; regnum >= S7_REGNUM; --regnum) { 		\ */
+/* OBSOLETE     read_register_bytes (REGISTER_BYTE (regnum), buf, 8); 		\ */
+/* OBSOLETE     sp = push_bytes (sp, buf, 8);}		    			\ */
+/* OBSOLETE   for (regnum = SP_REGNUM; regnum >= FP_REGNUM; --regnum) { 		\ */
+/* OBSOLETE     word = read_register (regnum);					\ */
+/* OBSOLETE     sp = push_bytes (sp, &word, 4);}   					\ */
+/* OBSOLETE   word = (read_register (PS_REGNUM) &~ (3<<25)) | (1<<25);		\ */
+/* OBSOLETE   sp = push_bytes (sp, &word, 4); 					\ */
+/* OBSOLETE   word = read_register (PC_REGNUM);					\ */
+/* OBSOLETE   sp = push_bytes (sp, &word, 4);   					\ */
+/* OBSOLETE   write_register (SP_REGNUM, sp);		    			\ */
+/* OBSOLETE   write_register (FP_REGNUM, sp);		    			\ */
+/* OBSOLETE   write_register (AP_REGNUM, sp);} */
+/* OBSOLETE  */
+/* OBSOLETE /* Discard from the stack the innermost frame, restoring all registers.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define POP_FRAME  do {\ */
+/* OBSOLETE   register CORE_ADDR fp = read_register (FP_REGNUM);	    \ */
+/* OBSOLETE   register int regnum;					    \ */
+/* OBSOLETE   register int frame_length =	/* 3 short, 2 long, 1 extended, 0 context *x/ \ */
+/* OBSOLETE       (read_memory_integer (fp + 4, 4) >> 25) & 3;          \ */
+/* OBSOLETE   char buf[8];					            \ */
+/* OBSOLETE   write_register (PC_REGNUM, read_memory_integer (fp, 4));  \ */
+/* OBSOLETE   write_register (PS_REGNUM, read_memory_integer (fp += 4, 4));  \ */
+/* OBSOLETE   write_register (FP_REGNUM, read_memory_integer (fp += 4, 4));  \ */
+/* OBSOLETE   write_register (AP_REGNUM, read_memory_integer (fp += 4, 4));  \ */
+/* OBSOLETE   if (frame_length < 3) 				     \ */
+/* OBSOLETE     for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum)   \ */
+/* OBSOLETE       write_register (regnum, read_memory_integer (fp += 4, 4)); \ */
+/* OBSOLETE   if (frame_length < 2)					     \ */
+/* OBSOLETE     write_register (SP_REGNUM, read_memory_integer (fp += 4, 4)); \ */
+/* OBSOLETE   fp -= 4;							\ */
+/* OBSOLETE   if (frame_length < 3)  					\ */
+/* OBSOLETE     for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum) {	\ */
+/* OBSOLETE       read_memory (fp += 8, buf, 8);				\ */
+/* OBSOLETE       write_register_bytes (REGISTER_BYTE (regnum), buf, 8);}   \ */
+/* OBSOLETE   if (frame_length < 2)	{					\ */
+/* OBSOLETE     read_memory (fp += 8, buf, 8);				\ */
+/* OBSOLETE     write_register_bytes (REGISTER_BYTE (regnum), buf, 8);}     \ */
+/* OBSOLETE   else write_register (SP_REGNUM, fp + 8);			\ */
+/* OBSOLETE   flush_cached_frames ();					\ */
+/* OBSOLETE } while (0) */
+/* OBSOLETE  */
+/* OBSOLETE /* This sequence of words is the instructions */
+/* OBSOLETE      mov sp,ap */
+/* OBSOLETE      pshea 69696969 */
+/* OBSOLETE      calls 32323232 */
+/* OBSOLETE      bkpt */
+/* OBSOLETE    Note this is 16 bytes.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define CALL_DUMMY {0x50860d4069696969LL,0x2140323232327d50LL} */
+/* OBSOLETE  */
+/* OBSOLETE #define CALL_DUMMY_LENGTH 16 */
+/* OBSOLETE  */
+/* OBSOLETE #define CALL_DUMMY_START_OFFSET 0 */
+/* OBSOLETE  */
+/* OBSOLETE /* Insert the specified number of args and function address */
+/* OBSOLETE    into a call sequence of the above form stored at DUMMYNAME.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)   \ */
+/* OBSOLETE { *(int *)((char *) dummyname + 4) = nargs;	\ */
+/* OBSOLETE   *(int *)((char *) dummyname + 10) = fun; } */
+/* OBSOLETE  */
+/* OBSOLETE /* Defs to read soff symbol tables, see dbxread.c *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define NUMBER_OF_SYMBOLS    ((long) opthdr.o_nsyms) */
+/* OBSOLETE #define STRING_TABLE_OFFSET  ((long) filehdr.h_strptr) */
+/* OBSOLETE #define SYMBOL_TABLE_OFFSET  ((long) opthdr.o_symptr) */
+/* OBSOLETE #define STRING_TABLE_SIZE    ((long) filehdr.h_strsiz) */
+/* OBSOLETE #define SIZE_OF_TEXT_SEGMENT ((long) txthdr.s_size) */
+/* OBSOLETE #define ENTRY_POINT          ((long) opthdr.o_entry) */
+/* OBSOLETE  */
+/* OBSOLETE #define READ_STRING_TABLE_SIZE(BUFFER) \ */
+/* OBSOLETE     (BUFFER = STRING_TABLE_SIZE) */
+/* OBSOLETE  */
+/* OBSOLETE #define DECLARE_FILE_HEADERS \ */
+/* OBSOLETE   FILEHDR filehdr;							\ */
+/* OBSOLETE   OPTHDR opthdr;							\ */
+/* OBSOLETE   SCNHDR txthdr */
+/* OBSOLETE  */
+/* OBSOLETE #define READ_FILE_HEADERS(DESC,NAME) \ */
+/* OBSOLETE {									\ */
+/* OBSOLETE   int n;								\ */
+/* OBSOLETE   val = myread (DESC, &filehdr, sizeof filehdr);			\ */
+/* OBSOLETE   if (val < 0)								\ */
+/* OBSOLETE     perror_with_name (NAME);						\ */
+/* OBSOLETE   if (! IS_SOFF_MAGIC (filehdr.h_magic))				\ */
+/* OBSOLETE     error ("%s: not an executable file.", NAME);			\ */
+/* OBSOLETE   lseek (DESC, 0L, 0);							\ */
+/* OBSOLETE   if (myread (DESC, &filehdr, sizeof filehdr) < 0)			\ */
+/* OBSOLETE     perror_with_name (NAME);						\ */
+/* OBSOLETE   if (myread (DESC, &opthdr, filehdr.h_opthdr) <= 0)			\ */
+/* OBSOLETE     perror_with_name (NAME);						\ */
+/* OBSOLETE   for (n = 0; n < filehdr.h_nscns; n++)					\ */
+/* OBSOLETE     {									\ */
+/* OBSOLETE       if (myread (DESC, &txthdr, sizeof txthdr) < 0)			\ */
+/* OBSOLETE 	perror_with_name (NAME);					\ */
+/* OBSOLETE       if ((txthdr.s_flags & S_TYPMASK) == S_TEXT)			\ */
+/* OBSOLETE 	break;								\ */
+/* OBSOLETE     }									\ */
+/* OBSOLETE } */
diff --git a/gdb/config/convex/xm-convex.h b/gdb/config/convex/xm-convex.h
index cfcee4e..8552a3a 100644
--- a/gdb/config/convex/xm-convex.h
+++ b/gdb/config/convex/xm-convex.h
@@ -1,35 +1,35 @@
-/* Definitions to make GDB run on Convex Unix (4bsd)
-   Copyright 1989, 1991, 1992, 1996  Free Software Foundation, Inc.
-
-This file is part of GDB.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-#define HOST_BYTE_ORDER BIG_ENDIAN
-
-#define ATTACH_DETACH
-#define HAVE_WAIT_STRUCT
-#define NO_SIGINTERRUPT
-
-/* Use SIGCONT rather than SIGTSTP because convex Unix occasionally
-   turkeys SIGTSTP.  I think.  */
-
-#define STOP_SIGNAL SIGCONT
-
-/* Hook to call after creating inferior process.  Now init_trace_fun
-   is in the same place.  So re-write this to use the init_trace_fun
-   (making convex a debugging target).  FIXME.  */
-
-#define CREATE_INFERIOR_HOOK create_inferior_hook
+/* OBSOLETE /* Definitions to make GDB run on Convex Unix (4bsd) */
+/* OBSOLETE    Copyright 1989, 1991, 1992, 1996  Free Software Foundation, Inc. */
+/* OBSOLETE  */
+/* OBSOLETE This file is part of GDB. */
+/* OBSOLETE  */
+/* OBSOLETE This program is free software; you can redistribute it and/or modify */
+/* OBSOLETE it under the terms of the GNU General Public License as published by */
+/* OBSOLETE the Free Software Foundation; either version 2 of the License, or */
+/* OBSOLETE (at your option) any later version. */
+/* OBSOLETE  */
+/* OBSOLETE This program is distributed in the hope that it will be useful, */
+/* OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
+/* OBSOLETE GNU General Public License for more details. */
+/* OBSOLETE  */
+/* OBSOLETE You should have received a copy of the GNU General Public License */
+/* OBSOLETE along with this program; if not, write to the Free Software */
+/* OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define HOST_BYTE_ORDER BIG_ENDIAN */
+/* OBSOLETE  */
+/* OBSOLETE #define ATTACH_DETACH */
+/* OBSOLETE #define HAVE_WAIT_STRUCT */
+/* OBSOLETE #define NO_SIGINTERRUPT */
+/* OBSOLETE  */
+/* OBSOLETE /* Use SIGCONT rather than SIGTSTP because convex Unix occasionally */
+/* OBSOLETE    turkeys SIGTSTP.  I think.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define STOP_SIGNAL SIGCONT */
+/* OBSOLETE  */
+/* OBSOLETE /* Hook to call after creating inferior process.  Now init_trace_fun */
+/* OBSOLETE    is in the same place.  So re-write this to use the init_trace_fun */
+/* OBSOLETE    (making convex a debugging target).  FIXME.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define CREATE_INFERIOR_HOOK create_inferior_hook */
diff --git a/gdb/config/m68k/altos.mh b/gdb/config/m68k/altos.mh
index 1073751..51415be 100644
--- a/gdb/config/m68k/altos.mh
+++ b/gdb/config/m68k/altos.mh
@@ -1,5 +1,5 @@
-# Host: Altos 3068 (m68k, System V release 2)
-
-XM_FILE= xm-altos.h
-XDEPFILES= infptrace.o inftarg.o fork-child.o altos-xdep.o
+# OBSOLETE # Host: Altos 3068 (m68k, System V release 2)
+# OBSOLETE 
+# OBSOLETE XM_FILE= xm-altos.h
+# OBSOLETE XDEPFILES= infptrace.o inftarg.o fork-child.o altos-xdep.o
 
diff --git a/gdb/config/m68k/altos.mt b/gdb/config/m68k/altos.mt
index 521e958..7dc654b 100644
--- a/gdb/config/m68k/altos.mt
+++ b/gdb/config/m68k/altos.mt
@@ -1,3 +1,3 @@
-# Target: Altos 3068 (m68k, System V release 2)
-TDEPFILES= m68k-tdep.o
-TM_FILE= tm-altos.h
+# OBSOLETE # Target: Altos 3068 (m68k, System V release 2)
+# OBSOLETE TDEPFILES= m68k-tdep.o
+# OBSOLETE TM_FILE= tm-altos.h
diff --git a/gdb/config/m68k/tm-altos.h b/gdb/config/m68k/tm-altos.h
index 23c5653..4483aa0 100644
--- a/gdb/config/m68k/tm-altos.h
+++ b/gdb/config/m68k/tm-altos.h
@@ -1,44 +1,44 @@
-/* Target definitions for GDB on an Altos 3068 (m68k running SVR2)
-   Copyright 1987, 1989, 1991, 1993 Free Software Foundation, Inc.
-
-This file is part of GDB.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-/* The child target can't deal with floating registers.  */
-#define CANNOT_STORE_REGISTER(regno) ((regno) >= FP0_REGNUM)
-
-/* Define BPT_VECTOR if it is different than the default.
-   This is the vector number used by traps to indicate a breakpoint. */
-
-#define BPT_VECTOR 0xe
-
-/* Address of end of stack space.  */
-
-/*#define STACK_END_ADDR (0xffffff)*/
-#define STACK_END_ADDR (0x1000000)
-
-/* Amount PC must be decremented by after a breakpoint.
-   On the Altos, the kernel resets the pc to the trap instr */
-
-#define DECR_PC_AFTER_BREAK 0
-
-/* The only reason this is here is the tm-altos.h reference below.  It
-   was moved back here from tm-m68k.h.  FIXME? */
-
-extern CORE_ADDR altos_skip_prologue PARAMS ((CORE_ADDR));
-#define SKIP_PROLOGUE(pc) (altos_skip_prologue (pc))
-
-#include "m68k/tm-m68k.h"
+/* OBSOLETE /* Target definitions for GDB on an Altos 3068 (m68k running SVR2) */
+/* OBSOLETE    Copyright 1987, 1989, 1991, 1993 Free Software Foundation, Inc. */
+/* OBSOLETE  */
+/* OBSOLETE This file is part of GDB. */
+/* OBSOLETE  */
+/* OBSOLETE This program is free software; you can redistribute it and/or modify */
+/* OBSOLETE it under the terms of the GNU General Public License as published by */
+/* OBSOLETE the Free Software Foundation; either version 2 of the License, or */
+/* OBSOLETE (at your option) any later version. */
+/* OBSOLETE  */
+/* OBSOLETE This program is distributed in the hope that it will be useful, */
+/* OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
+/* OBSOLETE GNU General Public License for more details. */
+/* OBSOLETE  */
+/* OBSOLETE You should have received a copy of the GNU General Public License */
+/* OBSOLETE along with this program; if not, write to the Free Software */
+/* OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* The child target can't deal with floating registers.  *x/ */
+/* OBSOLETE #define CANNOT_STORE_REGISTER(regno) ((regno) >= FP0_REGNUM) */
+/* OBSOLETE  */
+/* OBSOLETE /* Define BPT_VECTOR if it is different than the default. */
+/* OBSOLETE    This is the vector number used by traps to indicate a breakpoint. *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define BPT_VECTOR 0xe */
+/* OBSOLETE  */
+/* OBSOLETE /* Address of end of stack space.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /*#define STACK_END_ADDR (0xffffff)*x/ */
+/* OBSOLETE #define STACK_END_ADDR (0x1000000) */
+/* OBSOLETE  */
+/* OBSOLETE /* Amount PC must be decremented by after a breakpoint. */
+/* OBSOLETE    On the Altos, the kernel resets the pc to the trap instr *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define DECR_PC_AFTER_BREAK 0 */
+/* OBSOLETE  */
+/* OBSOLETE /* The only reason this is here is the tm-altos.h reference below.  It */
+/* OBSOLETE    was moved back here from tm-m68k.h.  FIXME? *x/ */
+/* OBSOLETE  */
+/* OBSOLETE extern CORE_ADDR altos_skip_prologue PARAMS ((CORE_ADDR)); */
+/* OBSOLETE #define SKIP_PROLOGUE(pc) (altos_skip_prologue (pc)) */
+/* OBSOLETE  */
+/* OBSOLETE #include "m68k/tm-m68k.h" */
diff --git a/gdb/config/m68k/xm-altos.h b/gdb/config/m68k/xm-altos.h
index ca93bd1..008f769 100644
--- a/gdb/config/m68k/xm-altos.h
+++ b/gdb/config/m68k/xm-altos.h
@@ -1,202 +1,202 @@
-/* Definitions to make GDB run on an Altos 3068 (m68k running SVR2)
-   Copyright (C) 1987,1989 Free Software Foundation, Inc.
-
-This file is part of GDB.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
-
-#define HOST_BYTE_ORDER BIG_ENDIAN
-
-/* The altos support would make a good base for a port to other USGR2 systems
-   (like the 3b1 and the Convergent miniframe).  */
-
-/* This is only needed in one file, but it's cleaner to put it here than
-   putting in more #ifdef's.  */
-#include <sys/page.h>
-#include <sys/net.h>
-
-#define USG
-
-#define HAVE_TERMIO
-
-#define CBREAK XTABS	/* It takes all kinds... */
-
-#ifndef R_OK
-#define R_OK 4
-#define W_OK 2
-#define X_OK 1
-#define F_OK 0
-#endif
-
-/* Get sys/wait.h ie. from a Sun and edit it a little (mc68000 to m68k) */
-/* Why bother?  */
-#if 0
-#define HAVE_WAIT_STRUCT
-#endif
-
-/* This is the amount to subtract from u.u_ar0
-   to get the offset in the core file of the register values. */
-
-#define KERNEL_U_ADDR 0x1fbf000
-
-#define REGISTER_U_ADDR(addr, blockend, regno)		\
-{	if (regno <= SP_REGNUM) \
-	  addr = blockend + regno * 4; \
-	else if (regno == PS_REGNUM) \
-	  addr = blockend + regno * 4 + 4; \
-	else if (regno == PC_REGNUM) \
-	  addr = blockend + regno * 4 + 2; \
-}
-
-#define REGISTER_ADDR(u_ar0, regno)					\
-  (((regno) < PS_REGNUM)						\
-   ? (&((struct exception_stack *) (u_ar0))->e_regs[(regno + R0)])	\
-   : (((regno) == PS_REGNUM)						\
-      ? ((int *) (&((struct exception_stack *) (u_ar0))->e_PS))		\
-      : (&((struct exception_stack *) (u_ar0))->e_PC)))
-
-#define FP_REGISTER_ADDR(u, regno)					\
-  (((char *)								\
-    (((regno) < FPC_REGNUM)						\
-     ? (&u.u_pcb.pcb_mc68881[FMC68881_R0 + (((regno) - FP0_REGNUM) * 3)]) \
-     : (&u.u_pcb.pcb_mc68881[FMC68881_C + ((regno) - FPC_REGNUM)])))	\
-   - ((char *) (& u)))
-
-
-#ifndef __GNUC__
-#undef USE_GAS
-#define ALTOS_AS
-#else
-#define USE_GAS
-#endif
-
-/* Motorola assembly format */
-#if !defined(USE_GAS) && !defined(ALTOS)
-#define MOTOROLA
-#endif
-
-/* Interface definitions for kernel debugger KDB.  */
-
-/* Map machine fault codes into signal numbers.
-   First subtract 0, divide by 4, then index in a table.
-   Faults for which the entry in this table is 0
-   are not handled by KDB; the program's own trap handler
-   gets to handle then.  */
-
-#define FAULT_CODE_ORIGIN 0
-#define FAULT_CODE_UNITS 4
-#define FAULT_TABLE    \
-{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
-  0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
-  0, 0, 0, 0, 0, 0, 0, 0, \
-  SIGILL }
-
-/* Start running with a stack stretching from BEG to END.
-   BEG and END should be symbols meaningful to the assembler.
-   This is used only for kdb.  */
-
-#ifdef MOTOROLA
-#define INIT_STACK(beg, end)  \
-{ asm (".globl end");         \
-  asm ("move.l $ end, sp");      \
-  asm ("clr.l fp"); }
-#else
-#ifdef ALTOS_AS
-#define INIT_STACK(beg, end)  \
-{ asm ("global end");         \
-  asm ("mov.l &end,%sp");      \
-  asm ("clr.l %fp"); }
-#else
-#define INIT_STACK(beg, end)  \
-{ asm (".globl end");         \
-  asm ("movel $ end, sp");      \
-  asm ("clrl fp"); }
-#endif
-#endif
-
-/* Push the frame pointer register on the stack.  */
-#ifdef MOTOROLA
-#define PUSH_FRAME_PTR        \
-  asm ("move.l fp, -(sp)");
-#else
-#ifdef ALTOS_AS
-#define PUSH_FRAME_PTR        \
-  asm ("mov.l %fp, -(%sp)");
-#else
-#define PUSH_FRAME_PTR        \
-  asm ("movel fp, -(sp)");
-#endif
-#endif
-
-/* Copy the top-of-stack to the frame pointer register.  */
-#ifdef MOTOROLA
-#define POP_FRAME_PTR  \
-  asm ("move.l (sp), fp");
-#else
-#ifdef ALTOS_AS
-#define POP_FRAME_PTR  \
-  asm ("mov.l (%sp), %fp");
-#else
-#define POP_FRAME_PTR  \
-  asm ("movl (sp), fp");
-#endif
-#endif
-
-/* After KDB is entered by a fault, push all registers
-   that GDB thinks about (all NUM_REGS of them),
-   so that they appear in order of ascending GDB register number.
-   The fault code will be on the stack beyond the last register.  */
-
-#ifdef MOTOROLA
-#define PUSH_REGISTERS        \
-{ asm ("clr.w -(sp)");	      \
-  asm ("pea (10,sp)");	      \
-  asm ("movem $ 0xfffe,-(sp)"); }
-#else
-#ifdef ALTOS_AS
-#define PUSH_REGISTERS        \
-{ asm ("clr.w -(%sp)");	      \
-  asm ("pea (10,%sp)");	      \
-  asm ("movm.l &0xfffe,-(%sp)"); }
-#else
-#define PUSH_REGISTERS        \
-{ asm ("clrw -(sp)");	      \
-  asm ("pea 10(sp)");	      \
-  asm ("movem $ 0xfffe,-(sp)"); }
-#endif
-#endif
-
-/* Assuming the registers (including processor status) have been
-   pushed on the stack in order of ascending GDB register number,
-   restore them and return to the address in the saved PC register.  */
-
-#ifdef MOTOROLA
-#define POP_REGISTERS          \
-{ asm ("subi.l $8,28(sp)");     \
-  asm ("movem (sp),$ 0xffff"); \
-  asm ("rte"); }
-#else
-#ifdef ALTOS_AS
-#define POP_REGISTERS          \
-{ asm ("sub.l &8,28(%sp)");     \
-  asm ("movem (%sp),&0xffff"); \
-  asm ("rte"); }
-#else
-#define POP_REGISTERS          \
-{ asm ("subil $8,28(sp)");     \
-  asm ("movem (sp),$ 0xffff"); \
-  asm ("rte"); }
-#endif
-#endif
+/* OBSOLETE /* Definitions to make GDB run on an Altos 3068 (m68k running SVR2) */
+/* OBSOLETE    Copyright (C) 1987,1989 Free Software Foundation, Inc. */
+/* OBSOLETE  */
+/* OBSOLETE This file is part of GDB. */
+/* OBSOLETE  */
+/* OBSOLETE This program is free software; you can redistribute it and/or modify */
+/* OBSOLETE it under the terms of the GNU General Public License as published by */
+/* OBSOLETE the Free Software Foundation; either version 2 of the License, or */
+/* OBSOLETE (at your option) any later version. */
+/* OBSOLETE  */
+/* OBSOLETE This program is distributed in the hope that it will be useful, */
+/* OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
+/* OBSOLETE GNU General Public License for more details. */
+/* OBSOLETE  */
+/* OBSOLETE You should have received a copy of the GNU General Public License */
+/* OBSOLETE along with this program; if not, write to the Free Software */
+/* OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define HOST_BYTE_ORDER BIG_ENDIAN */
+/* OBSOLETE  */
+/* OBSOLETE /* The altos support would make a good base for a port to other USGR2 systems */
+/* OBSOLETE    (like the 3b1 and the Convergent miniframe).  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* This is only needed in one file, but it's cleaner to put it here than */
+/* OBSOLETE    putting in more #ifdef's.  *x/ */
+/* OBSOLETE #include <sys/page.h> */
+/* OBSOLETE #include <sys/net.h> */
+/* OBSOLETE  */
+/* OBSOLETE #define USG */
+/* OBSOLETE  */
+/* OBSOLETE #define HAVE_TERMIO */
+/* OBSOLETE  */
+/* OBSOLETE #define CBREAK XTABS	/* It takes all kinds... *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #ifndef R_OK */
+/* OBSOLETE #define R_OK 4 */
+/* OBSOLETE #define W_OK 2 */
+/* OBSOLETE #define X_OK 1 */
+/* OBSOLETE #define F_OK 0 */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* Get sys/wait.h ie. from a Sun and edit it a little (mc68000 to m68k) *x/ */
+/* OBSOLETE /* Why bother?  *x/ */
+/* OBSOLETE #if 0 */
+/* OBSOLETE #define HAVE_WAIT_STRUCT */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* This is the amount to subtract from u.u_ar0 */
+/* OBSOLETE    to get the offset in the core file of the register values. *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define KERNEL_U_ADDR 0x1fbf000 */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_U_ADDR(addr, blockend, regno)		\ */
+/* OBSOLETE {	if (regno <= SP_REGNUM) \ */
+/* OBSOLETE 	  addr = blockend + regno * 4; \ */
+/* OBSOLETE 	else if (regno == PS_REGNUM) \ */
+/* OBSOLETE 	  addr = blockend + regno * 4 + 4; \ */
+/* OBSOLETE 	else if (regno == PC_REGNUM) \ */
+/* OBSOLETE 	  addr = blockend + regno * 4 + 2; \ */
+/* OBSOLETE } */
+/* OBSOLETE  */
+/* OBSOLETE #define REGISTER_ADDR(u_ar0, regno)					\ */
+/* OBSOLETE   (((regno) < PS_REGNUM)						\ */
+/* OBSOLETE    ? (&((struct exception_stack *) (u_ar0))->e_regs[(regno + R0)])	\ */
+/* OBSOLETE    : (((regno) == PS_REGNUM)						\ */
+/* OBSOLETE       ? ((int *) (&((struct exception_stack *) (u_ar0))->e_PS))		\ */
+/* OBSOLETE       : (&((struct exception_stack *) (u_ar0))->e_PC))) */
+/* OBSOLETE  */
+/* OBSOLETE #define FP_REGISTER_ADDR(u, regno)					\ */
+/* OBSOLETE   (((char *)								\ */
+/* OBSOLETE     (((regno) < FPC_REGNUM)						\ */
+/* OBSOLETE      ? (&u.u_pcb.pcb_mc68881[FMC68881_R0 + (((regno) - FP0_REGNUM) * 3)]) \ */
+/* OBSOLETE      : (&u.u_pcb.pcb_mc68881[FMC68881_C + ((regno) - FPC_REGNUM)])))	\ */
+/* OBSOLETE    - ((char *) (& u))) */
+/* OBSOLETE  */
+/* OBSOLETE  */
+/* OBSOLETE #ifndef __GNUC__ */
+/* OBSOLETE #undef USE_GAS */
+/* OBSOLETE #define ALTOS_AS */
+/* OBSOLETE #else */
+/* OBSOLETE #define USE_GAS */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* Motorola assembly format *x/ */
+/* OBSOLETE #if !defined(USE_GAS) && !defined(ALTOS) */
+/* OBSOLETE #define MOTOROLA */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* Interface definitions for kernel debugger KDB.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE /* Map machine fault codes into signal numbers. */
+/* OBSOLETE    First subtract 0, divide by 4, then index in a table. */
+/* OBSOLETE    Faults for which the entry in this table is 0 */
+/* OBSOLETE    are not handled by KDB; the program's own trap handler */
+/* OBSOLETE    gets to handle then.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #define FAULT_CODE_ORIGIN 0 */
+/* OBSOLETE #define FAULT_CODE_UNITS 4 */
+/* OBSOLETE #define FAULT_TABLE    \ */
+/* OBSOLETE { 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ */
+/* OBSOLETE   0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ */
+/* OBSOLETE   0, 0, 0, 0, 0, 0, 0, 0, \ */
+/* OBSOLETE   SIGILL } */
+/* OBSOLETE  */
+/* OBSOLETE /* Start running with a stack stretching from BEG to END. */
+/* OBSOLETE    BEG and END should be symbols meaningful to the assembler. */
+/* OBSOLETE    This is used only for kdb.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #ifdef MOTOROLA */
+/* OBSOLETE #define INIT_STACK(beg, end)  \ */
+/* OBSOLETE { asm (".globl end");         \ */
+/* OBSOLETE   asm ("move.l $ end, sp");      \ */
+/* OBSOLETE   asm ("clr.l fp"); } */
+/* OBSOLETE #else */
+/* OBSOLETE #ifdef ALTOS_AS */
+/* OBSOLETE #define INIT_STACK(beg, end)  \ */
+/* OBSOLETE { asm ("global end");         \ */
+/* OBSOLETE   asm ("mov.l &end,%sp");      \ */
+/* OBSOLETE   asm ("clr.l %fp"); } */
+/* OBSOLETE #else */
+/* OBSOLETE #define INIT_STACK(beg, end)  \ */
+/* OBSOLETE { asm (".globl end");         \ */
+/* OBSOLETE   asm ("movel $ end, sp");      \ */
+/* OBSOLETE   asm ("clrl fp"); } */
+/* OBSOLETE #endif */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* Push the frame pointer register on the stack.  *x/ */
+/* OBSOLETE #ifdef MOTOROLA */
+/* OBSOLETE #define PUSH_FRAME_PTR        \ */
+/* OBSOLETE   asm ("move.l fp, -(sp)"); */
+/* OBSOLETE #else */
+/* OBSOLETE #ifdef ALTOS_AS */
+/* OBSOLETE #define PUSH_FRAME_PTR        \ */
+/* OBSOLETE   asm ("mov.l %fp, -(%sp)"); */
+/* OBSOLETE #else */
+/* OBSOLETE #define PUSH_FRAME_PTR        \ */
+/* OBSOLETE   asm ("movel fp, -(sp)"); */
+/* OBSOLETE #endif */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* Copy the top-of-stack to the frame pointer register.  *x/ */
+/* OBSOLETE #ifdef MOTOROLA */
+/* OBSOLETE #define POP_FRAME_PTR  \ */
+/* OBSOLETE   asm ("move.l (sp), fp"); */
+/* OBSOLETE #else */
+/* OBSOLETE #ifdef ALTOS_AS */
+/* OBSOLETE #define POP_FRAME_PTR  \ */
+/* OBSOLETE   asm ("mov.l (%sp), %fp"); */
+/* OBSOLETE #else */
+/* OBSOLETE #define POP_FRAME_PTR  \ */
+/* OBSOLETE   asm ("movl (sp), fp"); */
+/* OBSOLETE #endif */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* After KDB is entered by a fault, push all registers */
+/* OBSOLETE    that GDB thinks about (all NUM_REGS of them), */
+/* OBSOLETE    so that they appear in order of ascending GDB register number. */
+/* OBSOLETE    The fault code will be on the stack beyond the last register.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #ifdef MOTOROLA */
+/* OBSOLETE #define PUSH_REGISTERS        \ */
+/* OBSOLETE { asm ("clr.w -(sp)");	      \ */
+/* OBSOLETE   asm ("pea (10,sp)");	      \ */
+/* OBSOLETE   asm ("movem $ 0xfffe,-(sp)"); } */
+/* OBSOLETE #else */
+/* OBSOLETE #ifdef ALTOS_AS */
+/* OBSOLETE #define PUSH_REGISTERS        \ */
+/* OBSOLETE { asm ("clr.w -(%sp)");	      \ */
+/* OBSOLETE   asm ("pea (10,%sp)");	      \ */
+/* OBSOLETE   asm ("movm.l &0xfffe,-(%sp)"); } */
+/* OBSOLETE #else */
+/* OBSOLETE #define PUSH_REGISTERS        \ */
+/* OBSOLETE { asm ("clrw -(sp)");	      \ */
+/* OBSOLETE   asm ("pea 10(sp)");	      \ */
+/* OBSOLETE   asm ("movem $ 0xfffe,-(sp)"); } */
+/* OBSOLETE #endif */
+/* OBSOLETE #endif */
+/* OBSOLETE  */
+/* OBSOLETE /* Assuming the registers (including processor status) have been */
+/* OBSOLETE    pushed on the stack in order of ascending GDB register number, */
+/* OBSOLETE    restore them and return to the address in the saved PC register.  *x/ */
+/* OBSOLETE  */
+/* OBSOLETE #ifdef MOTOROLA */
+/* OBSOLETE #define POP_REGISTERS          \ */
+/* OBSOLETE { asm ("subi.l $8,28(sp)");     \ */
+/* OBSOLETE   asm ("movem (sp),$ 0xffff"); \ */
+/* OBSOLETE   asm ("rte"); } */
+/* OBSOLETE #else */
+/* OBSOLETE #ifdef ALTOS_AS */
+/* OBSOLETE #define POP_REGISTERS          \ */
+/* OBSOLETE { asm ("sub.l &8,28(%sp)");     \ */
+/* OBSOLETE   asm ("movem (%sp),&0xffff"); \ */
+/* OBSOLETE   asm ("rte"); } */
+/* OBSOLETE #else */
+/* OBSOLETE #define POP_REGISTERS          \ */
+/* OBSOLETE { asm ("subil $8,28(sp)");     \ */
+/* OBSOLETE   asm ("movem (sp),$ 0xffff"); \ */
+/* OBSOLETE   asm ("rte"); } */
+/* OBSOLETE #endif */
+/* OBSOLETE #endif */