Initial creation of sourceware repositorygdb-4_18-branchpoint

5 files changed, 715 insertions, 0 deletions

diff --git a/gdb/config/convex/Convex.notes b/gdb/config/convex/Convex.notes
new file mode 100644
index 0000000..28d336b
--- /dev/null
+++ b/gdb/config/convex/Convex.notes
@@ -0,0 +1,163 @@
+
+@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
new file mode 100644
index 0000000..35a121f
--- /dev/null
+++ b/gdb/config/convex/convex.mh
@@ -0,0 +1,3 @@
+# Host: Convex Unix (4bsd)
+XDEPFILES= convex-xdep.o
+XM_FILE= xm-convex.h
diff --git a/gdb/config/convex/convex.mt b/gdb/config/convex/convex.mt
new file mode 100644
index 0000000..eefbeb3
--- /dev/null
+++ b/gdb/config/convex/convex.mt
@@ -0,0 +1,3 @@
+# Target: Convex Unix (4bsd)
+TDEPFILES= convex-tdep.o
+TM_FILE= tm-convex.h
diff --git a/gdb/config/convex/tm-convex.h b/gdb/config/convex/tm-convex.h
new file mode 100644
index 0000000..5eb9f6e
--- /dev/null
+++ b/gdb/config/convex/tm-convex.h
@@ -0,0 +1,511 @@
+/* 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
+*/
+
+#define SKIP_PROLOGUE(pc)  \
+{ int op, ix;								\
+  op = read_memory_integer (pc, 2);					\
+  if ((op & 0xffc7) == 0x5ac0) pc += 2;					\
+  else if (op == 0x1580) pc += 4;					\
+  else if (op == 0x15c0) pc += 6;					\
+  if ((read_memory_integer (pc, 2) & 0xfff8) == 0x7c40			\
+      && (read_memory_integer (pc + 2, 2) & 0xfff8) == 0x1240		\
+      && (read_memory_integer (pc + 8, 2) & 0xfff8) == 0x7c48)		\
+    pc += 10;								\
+  if (read_memory_integer (pc, 2) == 0x1240) pc += 6;			\
+  for (;;) {								\
+    op = read_memory_integer (pc, 2);					\
+    ix = (op >> 3) & 7;							\
+    if (ix != 6) break;							\
+    if ((op & 0xfcc0) == 0x3000) pc += 4;				\
+    else if ((op & 0xfcc0) == 0x3040) pc += 6;				\
+    else if ((op & 0xfcc0) == 0x2800) pc += 4;				\
+    else if ((op & 0xfcc0) == 0x2840) pc += 6;				\
+    else break;}}
+
+/* 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
+
+/* A macro that tells us whether the function invocation represented
+   by FI does not have a frame on the stack associated with it.  If it
+   does not, FRAMELESS is set to 1, else 0.
+   On convex, check at the return address for `callq' -- if so, frameless,
+   otherwise, not.  */
+
+#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
+{ 									\
+  extern CORE_ADDR text_start, text_end;				\
+  CORE_ADDR call_addr = SAVED_PC_AFTER_CALL (FI);			\
+  (FRAMELESS) = (call_addr >= text_start && call_addr < text_end	\
+		 && read_memory_integer (call_addr - 6, 1) == 0x22);	\
+}
+
+#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.  */
+
+#define FRAME_NUM_ARGS(numargs, fi)  \
+{ numargs = read_memory_integer (FRAME_ARGS_ADDRESS (fi) - 4, 4); \
+  if (numargs < 0 || numargs >= 256) numargs = -1;}
+
+/* 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;								\
+    }									\
+}
diff --git a/gdb/config/convex/xm-convex.h b/gdb/config/convex/xm-convex.h
new file mode 100644
index 0000000..cfcee4e
--- /dev/null
+++ b/gdb/config/convex/xm-convex.h
@@ -0,0 +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