import gdb-1999-07-19 snapshot

36 files changed, 2322 insertions, 970 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 1694d94..93a273f 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,78 @@
+1999-07-16  Keith Seitz  <keiths@cygnus.com>
+
+	* remote.c (_initialize_remote): "remotebreak" should be a var_boolean.
+
+1999-07-15  Jim Blandy  <jimb@cris.red-bean.com>
+	
+	Make the output from "info registers" fit withinin 80 columns.
+	* hppa-tdep.c: Make it easy to change row and column counts.
+	Switch to three columns, instead of four, and adjust spacing.
+
+	First cut at supporting HPPA2.0 in "wide" (64-bit) mode.
+	* configure.tgt: Add hppa2.0w target.
+	* config/pa/hppa64.mt, config/pa/tm-hppa64.h: New files.
+	* hppa-tdep.c (hppa_fix_call_dummy): Dyke out code to tweak the
+	call dummy, if target is PA2.0w.  This is temporary, until I get
+	function calls working.
+	* hppah-nat.c (fetch_register): Rewritten to handle both narrow
+	and wide register requests.
+	(HPPAH_OFFSETOF): New macro.
+
+	* gdbtypes.c (is_integral_type): New function.
+	* gdbtypes.h: Prototype for above.
+
+1999-07-15  J.T. Conklin  <jtc@redback.com>
+
+	* configure.tgt (i[3456]86-*-vxworks*): New target.
+	* config/i386/vxworks.mt: New file, x86 VxWorks target
+	* config/i386/tm-vxworks.h: New file.
+
+	* configure.tgt (powerpc-*-vxworks*): New target.
+	* config/powerpc/vxworks.mt: New file, PowerPC VxWorks target
+	* config/powerpc/tm-vxworks.h: New file.
+
+	* NEWS: Mention the new configs.
+
+1999-07-15  Fernando Nasser  <fnasser@cygnus.com>
+
+	* target.c (target_preopen): Prevent query when not from_tty.
+	* infcmd.c (run_command): Prevent query when not from_tty.
+
+1999-07-15  Fernando Nasser  <fnasser@cygnus.com>
+
+	* event-loop.c: Fix typo in comment.
+
+Wed Jul 14 17:29:31 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* ser-pipe.c (struct pipe_state): Define.
+ 	(pipe_close): Retain the PID of the sub-process using ``struct
+ 	pipe_state''.  Delete #ifdef code that used popen().
+	(pipe_close): Kill of the sub-process as part of the cleanup.
+
+	* serial.h (struct _serial_t): Add field ``state''.
+
+1999-07-13  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+	* event-top.c (display_gdb_prompt): Don't display the prompt if we
+ 	are in the middle of an execution command. Also trick readline so
+ 	it doesn't try to display the prompt.
+	(command_line_handler): Get rid of change_prompt, unused variable.
+	Use {push, pop}_prompt mechanism in case of multiline commands.
+
+	* infrun.c (complete_execution): Set target_executing to 0 as
+ 	first thing, so that display_gdb_prompt does the right thing.
+
+Tue Jul 13 20:29:46 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* parse.c (build_parse): Fix conditional increment of num_std_regs
+ 	for SP_REGNUM. Was conditional on FP_REGNUM.
+
+Tue Jul 13 16:44:58 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* gdbarch.h, gdbarch.c: Revert 1999-07-07 Stan Shebs
+ 	<shebs@andros.cygnus.com> indentation change.  Don't let indent
+ 	mess with these files.
+
 Mon Jul 12 11:15:09 1999  Andrew Cagney  <cagney@b1.cygnus.com>
 
 	* config/mips/tm-mips.h (REGISTER_CONVERT_TO_RAW,
@@ -17,6 +92,13 @@ Mon Jul 12 11:15:09 1999  Andrew Cagney  <cagney@b1.cygnus.com>
 
 	* NEWS: Document protocol change.
 
+1999-07-12  Keith Seitz  <keiths@cygnus.com>
+
+        * rdi-share/unixcomm.c (Unix_ResetSerial): Remove CYGWIN32
+	conditional.  It's no longer needed.
+        (SERPORT1, SERPORT2): Linux serial ports are "/dev/ttyX", not
+        "/dev/cuaX" (X=0,1,2,3,...).
+
 Mon Jul 12 02:02:00 1999  Andrew Cagney  <cagney@amy.cygnus.com>
 
 	* defs.h, utils.c (fputstrn_filtered, fputstrn_unfiltered,
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 772a6c7..74aada1 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -224,7 +224,7 @@ CDEPS = $(XM_CDEPS) $(TM_CDEPS) $(NAT_CDEPS) $(SIM) $(BFD) $(READLINE) \
 ADD_FILES = $(REGEX) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
 ADD_DEPS = $(REGEX1) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
 
-VERSION = 19990712
+VERSION = 19990719
 DIST=gdb
 
 LINT=/usr/5bin/lint
diff --git a/gdb/NEWS b/gdb/NEWS
index d08274b..080bfb2 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -3,18 +3,10 @@
 
 *** Changes since GDB-4.18:
 
-* Remote targets can connect to a sub-program
-
-A popen(3) style serial-device has been added.  This device starts a
-sub-process (such as a stand-alone simulator) and then communicates
-with that.  The sub-program to run is specified using the syntax
-``|<program> <args>'' vis:
-
-	(gdb) set remotedebug 1
-	(gdb) target extended-remote |mn10300-elf-sim program-args
-
 * New targets
 
+x86 VxWorks					i[3456]86-*-vxworks*
+PowerPC VxWorks					powerpc-*-vxworks*
 TI TMS320C80					tic80-*-*
 
 * OBSOLETE configurations
@@ -23,6 +15,16 @@ Altos 3068					m68*-altos-*
 Convex						c1-*-*, c2-*-*
 Pyramid						pyramid-*-*
 
+* Remote targets can connect to a sub-program
+
+A popen(3) style serial-device has been added.  This device starts a
+sub-process (such as a stand-alone simulator) and then communicates
+with that.  The sub-program to run is specified using the syntax
+``|<program> <args>'' vis:
+
+	(gdb) set remotedebug 1
+	(gdb) target extended-remote |mn10300-elf-sim program-args
+
 * MIPS 64 remote protocol
 
 A long standing bug in the mips64 remote protocol where by GDB
diff --git a/gdb/config/i386/tm-vxworks.h b/gdb/config/i386/tm-vxworks.h
new file mode 100644
index 0000000..efd2665
--- /dev/null
+++ b/gdb/config/i386/tm-vxworks.h
@@ -0,0 +1,28 @@
+/* Target machine description for VxWorks on the 80[3456]86,
+   for GDB, the GNU debugger.
+   Copyright (C) 1999 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.  */
+
+#ifndef TM_VXWORKS_H
+#define TM_VXWORKS_H
+
+#include "i386/tm-i386v.h"
+#include "tm-vxworks.h"
+
+#endif /* ifndef TM_VXWORKS_H */
diff --git a/gdb/config/i386/vxworks.mt b/gdb/config/i386/vxworks.mt
new file mode 100644
index 0000000..a14aacc
--- /dev/null
+++ b/gdb/config/i386/vxworks.mt
@@ -0,0 +1,3 @@
+# Target: i386 running VxWorks
+TDEPFILES= i386-tdep.o i387-tdep.o 
+TM_FILE= tm-vxworks.h
diff --git a/gdb/config/pa/hppa64.mt b/gdb/config/pa/hppa64.mt
new file mode 100644
index 0000000..ea7559f
--- /dev/null
+++ b/gdb/config/pa/hppa64.mt
@@ -0,0 +1,4 @@
+# Target: HP PA-RISC 2.0 running HPUX 11.00 in wide mode
+TDEPFILES= hppa-tdep.o # pa64-solib.o
+TM_FILE= tm-hppa64.h
+TM_CLIBS= # $(srcdir)/libxpdl.a 
diff --git a/gdb/config/pa/tm-hppa64.h b/gdb/config/pa/tm-hppa64.h
new file mode 100644
index 0000000..3aaeaee
--- /dev/null
+++ b/gdb/config/pa/tm-hppa64.h
@@ -0,0 +1,320 @@
+/* Parameters for execution on any Hewlett-Packard PA-RISC machine.
+   Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1995
+   Free Software Foundation, Inc. 
+
+   Contributed by the Center for Software Science at the
+   University of Utah (pa-gdb-bugs@cs.utah.edu).
+
+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.  */
+
+/* PA 64-bit specific definitions.  Override those which are in
+   tm-hppa.h */
+
+#include "pa/tm-hppah.h"
+
+#define HPUX_1100 1
+
+/* jimb: this must go.  I'm just using it to disable code I haven't
+   gotten working yet.  */
+#define GDB_TARGET_IS_HPPA_20W
+
+/* The low two bits of the IA are the privilege level of the instruction.  */
+#define ADDR_BITS_REMOVE(addr) ((CORE_ADDR)addr & (CORE_ADDR)~3)
+
+/* Say how long (ordinary) registers are.  This is used in
+   push_word and a few other places, but REGISTER_RAW_SIZE is
+   the real way to know how big a register is.  */
+
+#undef REGISTER_SIZE
+#define REGISTER_SIZE 8
+
+/* Number of bytes of storage in the actual machine representation
+   for register N.  On the PA-RISC 2.0, all regs are 8 bytes, including
+   the FP registers (they're accessed as two 4 byte halves).  */
+
+#undef REGISTER_RAW_SIZE
+#define REGISTER_RAW_SIZE(N) 8
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+
+#undef MAX_REGISTER_RAW_SIZE
+#define MAX_REGISTER_RAW_SIZE 8
+
+/* Total amount of space needed to store our copies of the machine's
+   register state, the array `registers'.  */
+
+#undef REGISTER_BYTES
+#define REGISTER_BYTES (NUM_REGS * 8)
+
+/* Index within `registers' of the first byte of the space for
+   register N.  */
+
+#undef REGISTER_BYTE
+#define REGISTER_BYTE(N) ((N) * 8)
+
+#undef REGISTER_VIRTUAL_TYPE
+#define REGISTER_VIRTUAL_TYPE(N) \
+ ((N) < FP4_REGNUM ? builtin_type_unsigned_long_long : builtin_type_double)
+
+
+/* Number of machine registers */
+#undef NUM_REGS
+#define NUM_REGS 96
+
+/* Initializer for an array of names of registers.
+   There should be NUM_REGS strings in this initializer.
+   They are in rows of eight entries  */
+#undef REGISTER_NAMES
+#define REGISTER_NAMES	\
+ {"flags",  "r1",      "rp",      "r3",    "r4",     "r5",      "r6",     "r7",    \
+  "r8",     "r9",      "r10",     "r11",   "r12",    "r13",     "r14",    "r15",   \
+  "r16",    "r17",     "r18",     "r19",   "r20",    "r21",     "r22",    "r23",   \
+  "r24",    "r25",     "r26",     "dp",    "ret0",   "ret1",    "sp",     "r31",   \
+  "sar",    "pcoqh",   "pcsqh",   "pcoqt", "pcsqt",  "eiem",    "iir",    "isr",   \
+  "ior",    "ipsw",    "goto",    "sr4",   "sr0",    "sr1",     "sr2",    "sr3",   \
+  "sr5",    "sr6",     "sr7",     "cr0",   "cr8",    "cr9",     "ccr",    "cr12",  \
+  "cr13",   "cr24",    "cr25",    "cr26",  "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",\
+  "fpsr",    "fpe1",   "fpe2",    "fpe3",  "fr4",    "fr5",     "fr6",    "fr7", \
+  "fr8",     "fr9",    "fr10",    "fr11",  "fr12",   "fr13",    "fr14",   "fr15", \
+  "fr16",    "fr17",   "fr18",    "fr19",  "fr20",   "fr21",    "fr22",   "fr23", \
+  "fr24",    "fr25",   "fr26",    "fr27",   "fr28",  "fr29",    "fr30",   "fr31"}
+
+#undef FP0_REGNUM
+#undef FP4_REGNUM
+#define FP0_REGNUM 64		/* floating point reg. 0 (fspr)*/
+#define FP4_REGNUM 68
+
+/* Redefine some target bit sizes from the default.  */
+
+/* Number of bits in a long or unsigned long for the target machine. */
+
+#define TARGET_LONG_BIT 64
+
+/* Number of bits in a long long or unsigned long long for the 
+   target machine.  */
+
+#define TARGET_LONG_LONG_BIT 64
+
+/* Number of bits in a pointer for the target machine */
+
+#define TARGET_PTR_BIT 64
+
+/* Argument Pointer Register */
+#define AP_REGNUM 29
+
+#define DP_REGNUM 27
+
+#define FP5_REGNUM 70
+
+#define SR5_REGNUM 48
+
+#undef FRAME_ARGS_ADDRESS
+#define FRAME_ARGS_ADDRESS(fi) ((fi)->ap)
+
+/* We access locals from SP. This may not work for frames which call
+   alloca; for those, we may need to consult unwind tables.
+   jimb: FIXME.  */
+#undef FRAME_LOCALS_ADDRESS
+#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
+
+#define INIT_FRAME_AP init_frame_ap
+  
+#define EXTRA_FRAME_INFO  \
+  CORE_ADDR ap;
+
+/* For a number of horrible reasons we may have to adjust the location
+   of variables on the stack.  Ugh.  jimb: why? */
+#define HPREAD_ADJUST_STACK_ADDRESS(ADDR) hpread_adjust_stack_address(ADDR)
+
+extern int hpread_adjust_stack_address PARAMS ((CORE_ADDR));
+
+
+/* jimb: omitted dynamic linking stuff here */
+
+/* This sequence of words is the instructions
+
+; Call stack frame has already been built by gdb. Since we could be calling
+; a varargs function, and we do not have the benefit of a stub to put things in
+; the right place, we load the first 8 word of arguments into both the general
+; and fp registers.
+call_dummy
+        copy %r4,%r29
+        copy %r5,%r22
+        copy %r6,%r27
+        fldd -64(0,%r29),%fr4
+        fldd -56(0,%r29),%fr5
+        fldd -48(0,%r29),%fr6
+        fldd -40(0,%r29),%fr7
+        fldd -32(0,%r29),%fr8
+        fldd -24(0,%r29),%fr9
+        fldd -16(0,%r29),%fr10
+        fldd -8(0,%r29),%fr11
+        copy %r22,%r1
+        ldd -64(%r29), %r26
+        ldd -56(%r29), %r25
+        ldd -48(%r29), %r24
+        ldd -40(%r29), %r23
+        ldd -32(%r29), %r22
+        ldd -24(%r29), %r21
+        ldd -16(%r29), %r20
+        bve,l (%r1),%r2
+        ldd -8(%r29), %r19
+        break 4, 8
+	mtsp %r21, %sr0
+	ble 0(%sr0, %r22)
+        nop
+*/
+
+#undef CALL_DUMMY
+#define CALL_DUMMY {0x349d0000, 0x34b60000, 0x34db0000, \
+                    0x53a43f83, 0x53a53f93, 0x53a63fa3, 0x53a73fb3,\
+                    0x53a83fc3, 0x53a93fd3, 0x2fa1100a, 0x2fb1100b,\
+                    0x36c10000, 0x53ba3f81, 0x53b93f91, 0x53b83fa1,\
+                    0x53b73fb1, 0x53b63fc1, 0x53b53fd1, 0x0fa110d4,\
+                    0xe820f000, 0x0fb110d3, 0x00010004, 0x00151820,\
+                    0xe6c00000, 0x08000240}
+
+#undef CALL_DUMMY_LENGTH
+#define CALL_DUMMY_LENGTH (INSTRUCTION_SIZE * 25)
+
+#undef FUNC_LDIL_OFFSET
+#undef FUNC_LDO_OFFSET
+#undef SR4EXPORT_LDIL_OFFSET
+#undef SR4EXPORT_LDO_OFFSET
+#undef CALL_DUMMY_LOCATION
+/* jimb: need to find out what AT_WDB_CALL_DUMMY is about */
+#if 0
+#define CALL_DUMMY_LOCATION AFTER_TEXT_END
+extern CORE_ADDR wdb_call_dummy_addr;
+#undef PC_IN_CALL_DUMMY
+#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \
+   ((pc) >= wdb_call_dummy_addr && \
+    (pc) <= wdb_call_dummy_addr + CALL_DUMMY_LENGTH)
+#endif
+
+#undef REG_STRUCT_HAS_ADDR
+
+#undef EXTRACT_RETURN_VALUE
+/* RM: floats are returned in FR4R, doubles in FR4
+ *     integral values are in r28, padded on the left 
+ *     aggregates less that 65 bits are in r28, right padded 
+ *     aggregates upto 128 bits are in r28 and r29, right padded
+ */ 
+#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
+  { \
+    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT && !SOFT_FLOAT) \
+      memcpy ((VALBUF), \
+	      ((char *)(REGBUF)) + REGISTER_BYTE (FP4_REGNUM) + \
+              (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+	      TYPE_LENGTH (TYPE)); \
+    else if  (is_integral_type(TYPE) || SOFT_FLOAT)   \
+       memcpy ((VALBUF), \
+               (char *)(REGBUF) + REGISTER_BYTE (28) + \
+               (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+               TYPE_LENGTH (TYPE)); \
+    else if (TYPE_LENGTH (TYPE) <= 8)   \
+       memcpy ((VALBUF), \
+               (char *)(REGBUF) + REGISTER_BYTE (28), \
+               TYPE_LENGTH (TYPE)); \
+    else if (TYPE_LENGTH (TYPE) <= 16)   \
+      { \
+        memcpy ((VALBUF), \
+                (char *)(REGBUF) + REGISTER_BYTE (28), \
+                8); \
+        memcpy (((char *) VALBUF + 8), \
+                (char *)(REGBUF) + REGISTER_BYTE (29), \
+                TYPE_LENGTH (TYPE) - 8); \
+       } \
+  }
+
+/* RM: struct upto 128 bits are returned in registers */
+#undef USE_STRUCT_CONVENTION
+#define USE_STRUCT_CONVENTION(gcc_p, value_type)\
+  (TYPE_LENGTH (value_type) > 16)                
+
+/* RM: for return command */
+#undef STORE_RETURN_VALUE
+#define STORE_RETURN_VALUE(TYPE,VALBUF) \
+  { \
+    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT && !SOFT_FLOAT) \
+      write_register_bytes \
+	      (REGISTER_BYTE (FP4_REGNUM) + \
+              (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+              (VALBUF), \
+	      TYPE_LENGTH (TYPE)); \
+    else if (is_integral_type(TYPE) || SOFT_FLOAT)   \
+       write_register_bytes \
+              (REGISTER_BYTE (28) + \
+                 (REGISTER_SIZE - TYPE_LENGTH (TYPE)), \
+               (VALBUF), \
+               TYPE_LENGTH (TYPE)); \
+    else if (TYPE_LENGTH (TYPE) <= 8)   \
+       write_register_bytes \
+             ( REGISTER_BYTE (28), \
+               (VALBUF), \
+               TYPE_LENGTH (TYPE)); \
+    else if (TYPE_LENGTH (TYPE) <= 16)   \
+      { \
+        write_register_bytes \
+               (REGISTER_BYTE (28), \
+                (VALBUF), \
+                8); \
+        write_register_bytes \
+               (REGISTER_BYTE (29), \
+                ((char *) VALBUF + 8), \
+                TYPE_LENGTH (TYPE) - 8); \
+       } \
+  }
+
+/* RM: these are the PA64 equivalents of the macros in tm-hppah.h --
+ * see comments there.  For PA64, the save_state structure is at an
+ * offset of 24 32-bit words from the sigcontext structure. The 64 bit
+ * general registers are at an offset of 640 bytes from the beginning of the
+ * save_state structure, and the floating pointer register are at an offset
+ * of 256 bytes from the beginning of the save_state structure.
+ */
+#undef FRAME_SAVED_PC_IN_SIGTRAMP
+#define FRAME_SAVED_PC_IN_SIGTRAMP(FRAME, TMP) \
+{ \
+  *(TMP) = read_memory_integer ((FRAME)->frame + (24 * 4) + 640 + (33 * 8), 8); \
+}
+
+#undef FRAME_BASE_BEFORE_SIGTRAMP
+#define FRAME_BASE_BEFORE_SIGTRAMP(FRAME, TMP) \
+{ \
+  *(TMP) = read_memory_integer ((FRAME)->frame + (24 * 4) + 640 + (30 * 8), 8); \
+}
+
+#undef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP
+#define FRAME_FIND_SAVED_REGS_IN_SIGTRAMP(FRAME, FSR) \
+{ \
+  int i; \
+  CORE_ADDR TMP1, TMP2; \
+  TMP1 = (FRAME)->frame + (24 * 4) + 640; \
+  TMP2 = (FRAME)->frame + (24 * 4) + 256; \
+  for (i = 0; i < NUM_REGS; i++) \
+    { \
+      if (i == SP_REGNUM) \
+        (FSR)->regs[SP_REGNUM] = read_memory_integer (TMP1 + SP_REGNUM * 8, 8); \
+      else if (i >= FP0_REGNUM) \
+        (FSR)->regs[i] = TMP2 + (i - FP0_REGNUM) * 8; \
+      else \
+        (FSR)->regs[i] = TMP1 + i * 8; \
+    } \
+}
+
+/* jimb: omitted purify call support */
diff --git a/gdb/config/powerpc/tm-vxworks.h b/gdb/config/powerpc/tm-vxworks.h
new file mode 100644
index 0000000..a31846a
--- /dev/null
+++ b/gdb/config/powerpc/tm-vxworks.h
@@ -0,0 +1,28 @@
+/* Target machine description for VxWorks on the PowerPC, 
+   for GDB, the GNU debugger.
+   Copyright 1999 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.  */
+
+#ifndef TM_VXWORKS_H
+#define TM_VXWORKS_H
+
+#include "powerpc/tm-ppc-eabi.h"
+#include "tm-vxworks.h"
+
+#endif /* ifndef TM_VXWORKS_H */
diff --git a/gdb/config/powerpc/vxworks.mt b/gdb/config/powerpc/vxworks.mt
new file mode 100644
index 0000000..1c71413
--- /dev/null
+++ b/gdb/config/powerpc/vxworks.mt
@@ -0,0 +1,3 @@
+# Target: Powerpc running VxWorks
+TDEPFILES= rs6000-tdep.o
+TM_FILE= tm-vxworks.h
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index bca34ac..60a02e3 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -63,8 +63,10 @@ h8500-*-*)		gdb_target=h8500 ;;
 
 fr30-*-elf*)		gdb_target=fr30 ;;
 
+
 hppa*-*-bsd*)		gdb_target=hppabsd ;;
 hppa*-*-pro*)		gdb_target=hppapro ;;
+hppa2.0w-*-hpux11*)	gdb_target=hppa64 ;;
 hppa*-*-hpux*)		gdb_target=hppahpux ;;
 hppa*-*-hiux*)		gdb_target=hppahpux ;;
 hppa*-*-osf*)		gdb_target=hppaosf ;;
@@ -107,6 +109,7 @@ i[3456]86-*-netware*)	gdb_target=i386nw
 		configdirs="${configdirs} nlm" ;;
 i[3456]86-*-osf1mk*)	gdb_target=i386mk ;;
 i[3456]86-*-cygwin*)	gdb_target=cygwin  ;;
+i[3456]86-*-vxworks*)	gdb_target=vxworks ;;
 
 i960-*-bout*)		gdb_target=vxworks960 ;;
 i960-nindy-coff*)	gdb_target=nindy960 ;;
@@ -223,6 +226,7 @@ powerpcle-*-eabi* | powerpcle-*-sysv* | powerpcle-*-elf*)
 			else
 			  gdb_target=ppcle-eabi
 			fi ;;
+powerpc-*-vxworks*)	gdb_target=vxworks ;;
 
 # OBSOLETE pyramid-*-*)		gdb_target=pyramid ;;
 
diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog
index bc9e6aa..a6507bd 100644
--- a/gdb/doc/ChangeLog
+++ b/gdb/doc/ChangeLog
@@ -1,3 +1,8 @@
+1999-07-14  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+	* gdbint.texinfo (PREPARE_TO_PROCEED, ADDR_BITS_REMOVE): Doc
+	fixes.
+
 Tue Jun 29 11:43:55 1999  Andrew Cagney  <cagney@b1.cygnus.com>
 
 	* gdbint.texinfo (SAVE_DUMMY_FRAME_TOS): Define.
diff --git a/gdb/doc/gdbint.texinfo b/gdb/doc/gdbint.texinfo
index 40a43a0..a94fcc4 100644
--- a/gdb/doc/gdbint.texinfo
+++ b/gdb/doc/gdbint.texinfo
@@ -1163,13 +1163,17 @@ line options to GDB.  They are currently used only for the unsupported
 i960 Nindy target, and should not be used in any other configuration.
 
 @item ADDR_BITS_REMOVE (addr)
-If a raw machine address includes any bits that are not really part of
-the address, then define this macro to expand into an expression that
-zeros those bits in @var{addr}.  For example, the two low-order bits of
-a Motorola 88K address may be used by some kernels for their own
-purposes, since addresses must always be 4-byte aligned, and so are of
-no use for addressing.  Those bits should be filtered out with an
-expression such as @code{((addr) & ~3)}.
+If a raw machine instruction address includes any bits that are not
+really part of the address, then define this macro to expand into an
+expression that zeros those bits in @var{addr}.  This is only used for
+addresses of instructions, and even then not in all contexts.
+
+For example, the two low-order bits of the PC on the Hewlett-Packard PA
+2.0 architecture contain the privilege level of the corresponding
+instruction.  Since instructions must always be aligned on four-byte
+boundaries, the processor masks out these bits to generate the actual
+address of the instruction.  ADDR_BITS_REMOVE should filter out these
+bits with an expression such as @code{((addr) & ~3)}.
 
 @item BEFORE_MAIN_LOOP_HOOK
 Define this to expand into any code that you want to execute before the
@@ -2043,6 +2047,22 @@ root directory.
 Define this to be able to, when a breakpoint insertion fails, warn the
 user that another process may be running with the same executable.
 
+@item PREPARE_TO_PROCEED @var{select_it}
+This (ugly) macro allows a native configuration to customize the way the
+@code{proceed} function in @file{infrun.c} deals with switching between
+threads.
+
+In a multi-threaded task we may select another thread and then continue
+or step.  But if the old thread was stopped at a breakpoint, it will
+immediately cause another breakpoint stop without any execution (i.e. it
+will report a breakpoint hit incorrectly).  So GDB must step over it
+first.
+
+If defined, @code{PREPARE_TO_PROCEED} should check the current thread
+against the thread that reported the most recent event.  If a step-over
+is required, it returns TRUE.  If @var{select_it} is non-zero, it should
+reselect the old thread.
+
 @item PROC_NAME_FMT
 Defines the format for the name of a @file{/proc} device.  Should be
 defined in @file{nm.h} @emph{only} in order to override the default
diff --git a/gdb/event-loop.c b/gdb/event-loop.c
index f47257e..4d35ed7 100644
--- a/gdb/event-loop.c
+++ b/gdb/event-loop.c
@@ -38,7 +38,7 @@
    Events can be inserted at the front of the queue or at the end of
    the queue.  Events will be extracted from the queue for processing
    starting from the head.  Therefore, events inserted at the head of
-   the queue will be processed in a last in first out fashoin, while
+   the queue will be processed in a last in first out fashion, while
    those inserted at the tail of the queue will be processed in a first
    in first out manner.  All the fields are NULL if the queue is
    empty. */
diff --git a/gdb/event-top.c b/gdb/event-top.c
index 2bb95a4..376352e 100644
--- a/gdb/event-top.c
+++ b/gdb/event-top.c
@@ -245,6 +245,28 @@ display_gdb_prompt (new_prompt)
   int prompt_length = 0;
   char *gdb_prompt = get_prompt ();
 
+
+  if (target_executing && sync_execution) 
+    {
+      /* This is to trick readline into not trying to display the
+	 prompt.  Even though we display the prompt using this
+	 function, readline still tries to do its own display if we
+	 don't call rl_callback_handler_install and
+	 rl_callback_handler_remove (which readline detects because a
+	 global variable is not set). If readline did that, it could
+	 mess up gdb signal handlers for SIGINT.  Readline assumes
+	 that between calls to rl_set_signals and rl_clear_signals gdb
+	 doesn't do anything with the signal handlers. Well, that's
+	 not the case, because when the target executes we change the
+	 SIGINT signal handler. If we allowed readline to display the
+	 prompt, the signal handler change would happen exactly
+	 between the calls to the above two functions.
+	 Calling rl_callback_handler_remove(), does the job. */
+
+      rl_callback_handler_remove ();
+      return;
+    }
+
   if (!new_prompt)
     {
       /* Just use the top of the prompt stack. */
@@ -267,6 +289,7 @@ display_gdb_prompt (new_prompt)
       rl_callback_handler_remove ();
       rl_callback_handler_install (new_prompt, input_handler);
     }
+  /* new_prompt at this point can be the top of the stack or the one passed in */
   else if (new_prompt)
     {
       /* Don't use a _filtered function here.  It causes the assumed
@@ -287,7 +310,7 @@ display_gdb_prompt (new_prompt)
    'set annotate'. It pushes a new prompt (with prefix and suffix) on top
    of the prompt stack, if the annotation level desired is 2, otherwise
    it pops the top of the prompt stack when we want the annotation level
-   to be the normal ones (1 or 2). */
+   to be the normal ones (1 or 0). */
 static void
 change_annotation_level ()
 {
@@ -535,7 +558,6 @@ command_line_handler (rl)
   static unsigned linelength = 0;
   register char *p;
   char *p1;
-  int change_prompt = 0;
   extern char *line;
   extern int linesize;
   char *nline;
@@ -565,7 +587,7 @@ command_line_handler (rl)
       p = readline_input_state.linebuffer_ptr;
       free (readline_input_state.linebuffer);
       more_to_come = 0;
-      change_prompt = 1;
+      pop_prompt ();
     }
 
 #ifdef STOP_SIGNAL
@@ -626,8 +648,10 @@ command_line_handler (rl)
 	  /* We will not invoke a execute_command if there is more
 	     input expected to complete the command. So, we need to
 	     print an empty prompt here. */
-	  display_gdb_prompt ("");
 	  more_to_come = 1;
+	  push_prompt ("", "", "");
+	  display_gdb_prompt (0);
+	  return;
 	}
     }
 
diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 6e736fa..65d76f8 100644
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -1,28 +1,29 @@
-/* Semi-dynamic architecture support for GDB, the GNU debugger.
+/* *INDENT-OFF* */ /* typedef (f)();'' confuses indent */
+/* Dynamic architecture support for GDB, the GNU debugger.
    Copyright 1998-1999, Free Software Foundation, Inc.
 
-   This file is part of GDB.
+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 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.
+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.  */
 
-   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.  */
 
 #include "defs.h"
 
 #if GDB_MULTI_ARCH
 #include "gdbcmd.h"
-#include "inferior.h"		/* enum CALL_DUMMY_LOCATION et.al. */
+#include "inferior.h" /* enum CALL_DUMMY_LOCATION et.al. */
 #else
 /* Just include everything in sight so that the every old definition
    of macro is visible. */
@@ -61,127 +62,127 @@ int gdbarch_debug = GDBARCH_DEBUG;
 /* Maintain the struct gdbarch object */
 
 struct gdbarch
-  {
-    /* basic architectural information */
-    const struct bfd_arch_info *bfd_arch_info;
-    int byte_order;
+{
+  /* basic architectural information */
+  const struct bfd_arch_info * bfd_arch_info;
+  int byte_order;
 
-    /* target specific vector. */
-    struct gdbarch_tdep *tdep;
+  /* target specific vector. */
+  struct gdbarch_tdep *tdep;
 
-    /* per-architecture data-pointers */
-    int nr_data;
-    void **data;
+  /* per-architecture data-pointers */
+  int nr_data;
+  void **data;
 
-    /* per-architecture swap-regions */
-    struct gdbarch_swap *swap;
+  /* per-architecture swap-regions */
+  struct gdbarch_swap *swap;
 
-    /* Multi-arch values.
+  /* Multi-arch values.
 
-       When extending this structure you must:
+     When extending this structure you must:
 
-       Add the field below.
+     Add the field below.
 
-       Declare set/get functions and define the corresponding
-       macro in gdbarch.h.
+     Declare set/get functions and define the corresponding
+     macro in gdbarch.h.
 
-       gdbarch_alloc(): If zero/NULL is not a suitable default,
-       initialize the new field.
+     gdbarch_alloc(): If zero/NULL is not a suitable default,
+     initialize the new field.
 
-       verify_gdbarch(): Confirm that the target updated the field
-       correctly.
+     verify_gdbarch(): Confirm that the target updated the field
+     correctly.
 
-       gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
-       field is dumped out
+     gdbarch_dump(): Add a fprintf_unfiltered call to so that the new
+     field is dumped out
 
-       ``default_gdbarch()'': Append an initial value to the static
-       variable (base values on the host's c-type system).
+     ``default_gdbarch()'': Append an initial value to the static
+     variable (base values on the host's c-type system).
 
-       get_gdbarch(): Implement the set/get functions (probably using
-       the macro's as shortcuts).
+     get_gdbarch(): Implement the set/get functions (probably using
+     the macro's as shortcuts).
 
      */
 
-    int ptr_bit;
-    int short_bit;
-    int int_bit;
-    int long_bit;
-    int long_long_bit;
-    int float_bit;
-    int double_bit;
-    int long_double_bit;
-    gdbarch_read_pc_ftype *read_pc;
-    gdbarch_write_pc_ftype *write_pc;
-    gdbarch_read_fp_ftype *read_fp;
-    gdbarch_write_fp_ftype *write_fp;
-    gdbarch_read_sp_ftype *read_sp;
-    gdbarch_write_sp_ftype *write_sp;
-    int num_regs;
-    int sp_regnum;
-    int fp_regnum;
-    int pc_regnum;
-    gdbarch_register_name_ftype *register_name;
-    int register_size;
-    int register_bytes;
-    gdbarch_register_byte_ftype *register_byte;
-    gdbarch_register_raw_size_ftype *register_raw_size;
-    int max_register_raw_size;
-    gdbarch_register_virtual_size_ftype *register_virtual_size;
-    int max_register_virtual_size;
-    gdbarch_register_virtual_type_ftype *register_virtual_type;
-    int use_generic_dummy_frames;
-    int call_dummy_location;
-    gdbarch_call_dummy_address_ftype *call_dummy_address;
-    CORE_ADDR call_dummy_start_offset;
-    CORE_ADDR call_dummy_breakpoint_offset;
-    int call_dummy_breakpoint_offset_p;
-    int call_dummy_length;
-    gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy;
-    int call_dummy_p;
-    LONGEST *call_dummy_words;
-    int sizeof_call_dummy_words;
-    int call_dummy_stack_adjust_p;
-    int call_dummy_stack_adjust;
-    gdbarch_fix_call_dummy_ftype *fix_call_dummy;
-    int believe_pcc_promotion;
-    int believe_pcc_promotion_type;
-    gdbarch_get_saved_register_ftype *get_saved_register;
-    gdbarch_register_convertible_ftype *register_convertible;
-    gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
-    gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
-    gdbarch_extract_return_value_ftype *extract_return_value;
-    gdbarch_push_arguments_ftype *push_arguments;
-    gdbarch_push_dummy_frame_ftype *push_dummy_frame;
-    gdbarch_push_return_address_ftype *push_return_address;
-    gdbarch_pop_frame_ftype *pop_frame;
-    gdbarch_d10v_make_daddr_ftype *d10v_make_daddr;
-    gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr;
-    gdbarch_d10v_daddr_p_ftype *d10v_daddr_p;
-    gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p;
-    gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw;
-    gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw;
-    gdbarch_store_struct_return_ftype *store_struct_return;
-    gdbarch_store_return_value_ftype *store_return_value;
-    gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
-    gdbarch_use_struct_convention_ftype *use_struct_convention;
-    gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;
-    gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;
-    gdbarch_skip_prologue_ftype *skip_prologue;
-    gdbarch_inner_than_ftype *inner_than;
-    gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
-    CORE_ADDR decr_pc_after_break;
-    CORE_ADDR function_start_offset;
-    gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
-    CORE_ADDR frame_args_skip;
-    gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
-    gdbarch_frame_chain_ftype *frame_chain;
-    gdbarch_frame_chain_valid_ftype *frame_chain_valid;
-    gdbarch_frame_saved_pc_ftype *frame_saved_pc;
-    gdbarch_frame_args_address_ftype *frame_args_address;
-    gdbarch_frame_locals_address_ftype *frame_locals_address;
-    gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
-    gdbarch_frame_num_args_ftype *frame_num_args;
-  };
+  int ptr_bit;
+  int short_bit;
+  int int_bit;
+  int long_bit;
+  int long_long_bit;
+  int float_bit;
+  int double_bit;
+  int long_double_bit;
+  gdbarch_read_pc_ftype *read_pc;
+  gdbarch_write_pc_ftype *write_pc;
+  gdbarch_read_fp_ftype *read_fp;
+  gdbarch_write_fp_ftype *write_fp;
+  gdbarch_read_sp_ftype *read_sp;
+  gdbarch_write_sp_ftype *write_sp;
+  int num_regs;
+  int sp_regnum;
+  int fp_regnum;
+  int pc_regnum;
+  gdbarch_register_name_ftype *register_name;
+  int register_size;
+  int register_bytes;
+  gdbarch_register_byte_ftype *register_byte;
+  gdbarch_register_raw_size_ftype *register_raw_size;
+  int max_register_raw_size;
+  gdbarch_register_virtual_size_ftype *register_virtual_size;
+  int max_register_virtual_size;
+  gdbarch_register_virtual_type_ftype *register_virtual_type;
+  int use_generic_dummy_frames;
+  int call_dummy_location;
+  gdbarch_call_dummy_address_ftype *call_dummy_address;
+  CORE_ADDR call_dummy_start_offset;
+  CORE_ADDR call_dummy_breakpoint_offset;
+  int call_dummy_breakpoint_offset_p;
+  int call_dummy_length;
+  gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy;
+  int call_dummy_p;
+  LONGEST * call_dummy_words;
+  int sizeof_call_dummy_words;
+  int call_dummy_stack_adjust_p;
+  int call_dummy_stack_adjust;
+  gdbarch_fix_call_dummy_ftype *fix_call_dummy;
+  int believe_pcc_promotion;
+  int believe_pcc_promotion_type;
+  gdbarch_get_saved_register_ftype *get_saved_register;
+  gdbarch_register_convertible_ftype *register_convertible;
+  gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual;
+  gdbarch_register_convert_to_raw_ftype *register_convert_to_raw;
+  gdbarch_extract_return_value_ftype *extract_return_value;
+  gdbarch_push_arguments_ftype *push_arguments;
+  gdbarch_push_dummy_frame_ftype *push_dummy_frame;
+  gdbarch_push_return_address_ftype *push_return_address;
+  gdbarch_pop_frame_ftype *pop_frame;
+  gdbarch_d10v_make_daddr_ftype *d10v_make_daddr;
+  gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr;
+  gdbarch_d10v_daddr_p_ftype *d10v_daddr_p;
+  gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p;
+  gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw;
+  gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw;
+  gdbarch_store_struct_return_ftype *store_struct_return;
+  gdbarch_store_return_value_ftype *store_return_value;
+  gdbarch_extract_struct_value_address_ftype *extract_struct_value_address;
+  gdbarch_use_struct_convention_ftype *use_struct_convention;
+  gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs;
+  gdbarch_init_extra_frame_info_ftype *init_extra_frame_info;
+  gdbarch_skip_prologue_ftype *skip_prologue;
+  gdbarch_inner_than_ftype *inner_than;
+  gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc;
+  CORE_ADDR decr_pc_after_break;
+  CORE_ADDR function_start_offset;
+  gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address;
+  CORE_ADDR frame_args_skip;
+  gdbarch_frameless_function_invocation_ftype *frameless_function_invocation;
+  gdbarch_frame_chain_ftype *frame_chain;
+  gdbarch_frame_chain_valid_ftype *frame_chain_valid;
+  gdbarch_frame_saved_pc_ftype *frame_saved_pc;
+  gdbarch_frame_args_address_ftype *frame_args_address;
+  gdbarch_frame_locals_address_ftype *frame_locals_address;
+  gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
+  gdbarch_frame_num_args_ftype *frame_num_args;
+};
 
 
 /* The default architecture uses host values (for want of a better
@@ -189,8 +190,7 @@ struct gdbarch
 
 extern const struct bfd_arch_info bfd_default_arch_struct;
 
-struct gdbarch default_gdbarch =
-{
+struct gdbarch default_gdbarch = {
   /* basic architecture information */
   &bfd_default_arch_struct,
   BIG_ENDIAN,
@@ -199,7 +199,7 @@ struct gdbarch default_gdbarch =
   /*per-architecture data-pointers and swap regions */
   0, NULL, NULL,
   /* Multi-arch values */
-  8 * sizeof (void *),
+  8 * sizeof (void*),
   8 * sizeof (short),
   8 * sizeof (int),
   8 * sizeof (long),
@@ -326,7 +326,7 @@ gdbarch_alloc (info, tdep)
 
 /* Ensure that all values in a GDBARCH are reasonable. */
 
-static void verify_gdbarch PARAMS ((struct gdbarch * gdbarch));
+static void verify_gdbarch PARAMS ((struct gdbarch *gdbarch));
 static void
 verify_gdbarch (gdbarch)
      struct gdbarch *gdbarch;
@@ -575,306 +575,306 @@ gdbarch_dump ()
 {
   if (TARGET_ARCHITECTURE != NULL)
     fprintf_unfiltered (gdb_stdlog,
-			"gdbarch_update: TARGET_ARCHITECTURE = %s\n",
-			TARGET_ARCHITECTURE->printable_name);
+                        "gdbarch_update: TARGET_ARCHITECTURE = %s\n",
+                        TARGET_ARCHITECTURE->printable_name);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_BYTE_ORDER = %ld\n",
-		      (long) TARGET_BYTE_ORDER);
+                      "gdbarch_update: TARGET_BYTE_ORDER = %ld\n",
+                      (long) TARGET_BYTE_ORDER);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_PTR_BIT = %ld\n",
-		      (long) TARGET_PTR_BIT);
+                      "gdbarch_update: TARGET_PTR_BIT = %ld\n",
+                      (long) TARGET_PTR_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_SHORT_BIT = %ld\n",
-		      (long) TARGET_SHORT_BIT);
+                      "gdbarch_update: TARGET_SHORT_BIT = %ld\n",
+                      (long) TARGET_SHORT_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_INT_BIT = %ld\n",
-		      (long) TARGET_INT_BIT);
+                      "gdbarch_update: TARGET_INT_BIT = %ld\n",
+                      (long) TARGET_INT_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_LONG_BIT = %ld\n",
-		      (long) TARGET_LONG_BIT);
+                      "gdbarch_update: TARGET_LONG_BIT = %ld\n",
+                      (long) TARGET_LONG_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_LONG_LONG_BIT = %ld\n",
-		      (long) TARGET_LONG_LONG_BIT);
+                      "gdbarch_update: TARGET_LONG_LONG_BIT = %ld\n",
+                      (long) TARGET_LONG_LONG_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_FLOAT_BIT = %ld\n",
-		      (long) TARGET_FLOAT_BIT);
+                      "gdbarch_update: TARGET_FLOAT_BIT = %ld\n",
+                      (long) TARGET_FLOAT_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_DOUBLE_BIT = %ld\n",
-		      (long) TARGET_DOUBLE_BIT);
+                      "gdbarch_update: TARGET_DOUBLE_BIT = %ld\n",
+                      (long) TARGET_DOUBLE_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_LONG_DOUBLE_BIT = %ld\n",
-		      (long) TARGET_LONG_DOUBLE_BIT);
+                      "gdbarch_update: TARGET_LONG_DOUBLE_BIT = %ld\n",
+                      (long) TARGET_LONG_DOUBLE_BIT);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_READ_PC = 0x%08lx\n",
-		      (long) current_gdbarch->read_pc
-  /*TARGET_READ_PC () */ );
+                      "gdbarch_update: TARGET_READ_PC = 0x%08lx\n",
+                      (long) current_gdbarch->read_pc
+                      /*TARGET_READ_PC ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_WRITE_PC = 0x%08lx\n",
-		      (long) current_gdbarch->write_pc
-  /*TARGET_WRITE_PC () */ );
+                      "gdbarch_update: TARGET_WRITE_PC = 0x%08lx\n",
+                      (long) current_gdbarch->write_pc
+                      /*TARGET_WRITE_PC ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_READ_FP = 0x%08lx\n",
-		      (long) current_gdbarch->read_fp
-  /*TARGET_READ_FP () */ );
+                      "gdbarch_update: TARGET_READ_FP = 0x%08lx\n",
+                      (long) current_gdbarch->read_fp
+                      /*TARGET_READ_FP ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_WRITE_FP = 0x%08lx\n",
-		      (long) current_gdbarch->write_fp
-  /*TARGET_WRITE_FP () */ );
+                      "gdbarch_update: TARGET_WRITE_FP = 0x%08lx\n",
+                      (long) current_gdbarch->write_fp
+                      /*TARGET_WRITE_FP ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_READ_SP = 0x%08lx\n",
-		      (long) current_gdbarch->read_sp
-  /*TARGET_READ_SP () */ );
+                      "gdbarch_update: TARGET_READ_SP = 0x%08lx\n",
+                      (long) current_gdbarch->read_sp
+                      /*TARGET_READ_SP ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: TARGET_WRITE_SP = 0x%08lx\n",
-		      (long) current_gdbarch->write_sp
-  /*TARGET_WRITE_SP () */ );
+                      "gdbarch_update: TARGET_WRITE_SP = 0x%08lx\n",
+                      (long) current_gdbarch->write_sp
+                      /*TARGET_WRITE_SP ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: NUM_REGS = %ld\n",
-		      (long) NUM_REGS);
+                      "gdbarch_update: NUM_REGS = %ld\n",
+                      (long) NUM_REGS);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: SP_REGNUM = %ld\n",
-		      (long) SP_REGNUM);
+                      "gdbarch_update: SP_REGNUM = %ld\n",
+                      (long) SP_REGNUM);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FP_REGNUM = %ld\n",
-		      (long) FP_REGNUM);
+                      "gdbarch_update: FP_REGNUM = %ld\n",
+                      (long) FP_REGNUM);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: PC_REGNUM = %ld\n",
-		      (long) PC_REGNUM);
+                      "gdbarch_update: PC_REGNUM = %ld\n",
+                      (long) PC_REGNUM);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_NAME = 0x%08lx\n",
-		      (long) current_gdbarch->register_name
-  /*REGISTER_NAME () */ );
+                      "gdbarch_update: REGISTER_NAME = 0x%08lx\n",
+                      (long) current_gdbarch->register_name
+                      /*REGISTER_NAME ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_SIZE = %ld\n",
-		      (long) REGISTER_SIZE);
+                      "gdbarch_update: REGISTER_SIZE = %ld\n",
+                      (long) REGISTER_SIZE);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_BYTES = %ld\n",
-		      (long) REGISTER_BYTES);
+                      "gdbarch_update: REGISTER_BYTES = %ld\n",
+                      (long) REGISTER_BYTES);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_BYTE = 0x%08lx\n",
-		      (long) current_gdbarch->register_byte
-  /*REGISTER_BYTE () */ );
+                      "gdbarch_update: REGISTER_BYTE = 0x%08lx\n",
+                      (long) current_gdbarch->register_byte
+                      /*REGISTER_BYTE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_RAW_SIZE = 0x%08lx\n",
-		      (long) current_gdbarch->register_raw_size
-  /*REGISTER_RAW_SIZE () */ );
+                      "gdbarch_update: REGISTER_RAW_SIZE = 0x%08lx\n",
+                      (long) current_gdbarch->register_raw_size
+                      /*REGISTER_RAW_SIZE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: MAX_REGISTER_RAW_SIZE = %ld\n",
-		      (long) MAX_REGISTER_RAW_SIZE);
+                      "gdbarch_update: MAX_REGISTER_RAW_SIZE = %ld\n",
+                      (long) MAX_REGISTER_RAW_SIZE);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
-		      (long) current_gdbarch->register_virtual_size
-  /*REGISTER_VIRTUAL_SIZE () */ );
+                      "gdbarch_update: REGISTER_VIRTUAL_SIZE = 0x%08lx\n",
+                      (long) current_gdbarch->register_virtual_size
+                      /*REGISTER_VIRTUAL_SIZE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
-		      (long) MAX_REGISTER_VIRTUAL_SIZE);
+                      "gdbarch_update: MAX_REGISTER_VIRTUAL_SIZE = %ld\n",
+                      (long) MAX_REGISTER_VIRTUAL_SIZE);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
-		      (long) current_gdbarch->register_virtual_type
-  /*REGISTER_VIRTUAL_TYPE () */ );
+                      "gdbarch_update: REGISTER_VIRTUAL_TYPE = 0x%08lx\n",
+                      (long) current_gdbarch->register_virtual_type
+                      /*REGISTER_VIRTUAL_TYPE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: USE_GENERIC_DUMMY_FRAMES = %ld\n",
-		      (long) USE_GENERIC_DUMMY_FRAMES);
+                      "gdbarch_update: USE_GENERIC_DUMMY_FRAMES = %ld\n",
+                      (long) USE_GENERIC_DUMMY_FRAMES);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: CALL_DUMMY_LOCATION = %ld\n",
-		      (long) CALL_DUMMY_LOCATION);
+                      "gdbarch_update: CALL_DUMMY_LOCATION = %ld\n",
+                      (long) CALL_DUMMY_LOCATION);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: CALL_DUMMY_ADDRESS = 0x%08lx\n",
-		      (long) current_gdbarch->call_dummy_address
-  /*CALL_DUMMY_ADDRESS () */ );
+                      "gdbarch_update: CALL_DUMMY_ADDRESS = 0x%08lx\n",
+                      (long) current_gdbarch->call_dummy_address
+                      /*CALL_DUMMY_ADDRESS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
-		      (long) CALL_DUMMY_START_OFFSET);
+                      "gdbarch_update: CALL_DUMMY_START_OFFSET = 0x%08lx\n",
+                      (long) CALL_DUMMY_START_OFFSET);
   fprintf_unfiltered (gdb_stdlog,
-		 "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
-		      (long) CALL_DUMMY_BREAKPOINT_OFFSET);
+                      "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET = 0x%08lx\n",
+                      (long) CALL_DUMMY_BREAKPOINT_OFFSET);
   fprintf_unfiltered (gdb_stdlog,
-		   "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
-		      (long) CALL_DUMMY_BREAKPOINT_OFFSET_P);
+                      "gdbarch_update: CALL_DUMMY_BREAKPOINT_OFFSET_P = %ld\n",
+                      (long) CALL_DUMMY_BREAKPOINT_OFFSET_P);
   if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END || CALL_DUMMY_LOCATION == AFTER_TEXT_END)
     fprintf_unfiltered (gdb_stdlog,
-			"gdbarch_update: CALL_DUMMY_LENGTH = %ld\n",
-			(long) CALL_DUMMY_LENGTH);
+                        "gdbarch_update: CALL_DUMMY_LENGTH = %ld\n",
+                        (long) CALL_DUMMY_LENGTH);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: PC_IN_CALL_DUMMY = 0x%08lx\n",
-		      (long) current_gdbarch->pc_in_call_dummy
-  /*PC_IN_CALL_DUMMY () */ );
+                      "gdbarch_update: PC_IN_CALL_DUMMY = 0x%08lx\n",
+                      (long) current_gdbarch->pc_in_call_dummy
+                      /*PC_IN_CALL_DUMMY ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: CALL_DUMMY_P = %ld\n",
-		      (long) CALL_DUMMY_P);
+                      "gdbarch_update: CALL_DUMMY_P = %ld\n",
+                      (long) CALL_DUMMY_P);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: CALL_DUMMY_WORDS = 0x%08lx\n",
-		      (long) CALL_DUMMY_WORDS);
+                      "gdbarch_update: CALL_DUMMY_WORDS = 0x%08lx\n",
+                      (long) CALL_DUMMY_WORDS);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
-		      (long) SIZEOF_CALL_DUMMY_WORDS);
+                      "gdbarch_update: SIZEOF_CALL_DUMMY_WORDS = 0x%08lx\n",
+                      (long) SIZEOF_CALL_DUMMY_WORDS);
   fprintf_unfiltered (gdb_stdlog,
-		    "gdbarch_update: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
-		      (long) CALL_DUMMY_STACK_ADJUST_P);
+                      "gdbarch_update: CALL_DUMMY_STACK_ADJUST_P = 0x%08lx\n",
+                      (long) CALL_DUMMY_STACK_ADJUST_P);
   if (CALL_DUMMY_STACK_ADJUST_P)
     fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
-			(long) CALL_DUMMY_STACK_ADJUST);
+                        "gdbarch_update: CALL_DUMMY_STACK_ADJUST = 0x%08lx\n",
+                        (long) CALL_DUMMY_STACK_ADJUST);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FIX_CALL_DUMMY = 0x%08lx\n",
-		      (long) current_gdbarch->fix_call_dummy
-  /*FIX_CALL_DUMMY () */ );
+                      "gdbarch_update: FIX_CALL_DUMMY = 0x%08lx\n",
+                      (long) current_gdbarch->fix_call_dummy
+                      /*FIX_CALL_DUMMY ()*/);
 #ifdef BELIEVE_PCC_PROMOTION
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: BELIEVE_PCC_PROMOTION = %ld\n",
-		      (long) BELIEVE_PCC_PROMOTION);
+                      "gdbarch_update: BELIEVE_PCC_PROMOTION = %ld\n",
+                      (long) BELIEVE_PCC_PROMOTION);
 #endif
 #ifdef BELIEVE_PCC_PROMOTION_TYPE
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
-		      (long) BELIEVE_PCC_PROMOTION_TYPE);
+                      "gdbarch_update: BELIEVE_PCC_PROMOTION_TYPE = %ld\n",
+                      (long) BELIEVE_PCC_PROMOTION_TYPE);
 #endif
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: GET_SAVED_REGISTER = 0x%08lx\n",
-		      (long) current_gdbarch->get_saved_register
-  /*GET_SAVED_REGISTER () */ );
+                      "gdbarch_update: GET_SAVED_REGISTER = 0x%08lx\n",
+                      (long) current_gdbarch->get_saved_register
+                      /*GET_SAVED_REGISTER ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_CONVERTIBLE = 0x%08lx\n",
-		      (long) current_gdbarch->register_convertible
-  /*REGISTER_CONVERTIBLE () */ );
+                      "gdbarch_update: REGISTER_CONVERTIBLE = 0x%08lx\n",
+                      (long) current_gdbarch->register_convertible
+                      /*REGISTER_CONVERTIBLE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		  "gdbarch_update: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
-		      (long) current_gdbarch->register_convert_to_virtual
-  /*REGISTER_CONVERT_TO_VIRTUAL () */ );
+                      "gdbarch_update: REGISTER_CONVERT_TO_VIRTUAL = 0x%08lx\n",
+                      (long) current_gdbarch->register_convert_to_virtual
+                      /*REGISTER_CONVERT_TO_VIRTUAL ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
-		      (long) current_gdbarch->register_convert_to_raw
-  /*REGISTER_CONVERT_TO_RAW () */ );
+                      "gdbarch_update: REGISTER_CONVERT_TO_RAW = 0x%08lx\n",
+                      (long) current_gdbarch->register_convert_to_raw
+                      /*REGISTER_CONVERT_TO_RAW ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: EXTRACT_RETURN_VALUE = 0x%08lx\n",
-		      (long) current_gdbarch->extract_return_value
-  /*EXTRACT_RETURN_VALUE () */ );
+                      "gdbarch_update: EXTRACT_RETURN_VALUE = 0x%08lx\n",
+                      (long) current_gdbarch->extract_return_value
+                      /*EXTRACT_RETURN_VALUE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: PUSH_ARGUMENTS = 0x%08lx\n",
-		      (long) current_gdbarch->push_arguments
-  /*PUSH_ARGUMENTS () */ );
+                      "gdbarch_update: PUSH_ARGUMENTS = 0x%08lx\n",
+                      (long) current_gdbarch->push_arguments
+                      /*PUSH_ARGUMENTS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: PUSH_DUMMY_FRAME = 0x%08lx\n",
-		      (long) current_gdbarch->push_dummy_frame
-  /*PUSH_DUMMY_FRAME () */ );
+                      "gdbarch_update: PUSH_DUMMY_FRAME = 0x%08lx\n",
+                      (long) current_gdbarch->push_dummy_frame
+                      /*PUSH_DUMMY_FRAME ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: PUSH_RETURN_ADDRESS = 0x%08lx\n",
-		      (long) current_gdbarch->push_return_address
-  /*PUSH_RETURN_ADDRESS () */ );
+                      "gdbarch_update: PUSH_RETURN_ADDRESS = 0x%08lx\n",
+                      (long) current_gdbarch->push_return_address
+                      /*PUSH_RETURN_ADDRESS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: POP_FRAME = 0x%08lx\n",
-		      (long) current_gdbarch->pop_frame
-  /*POP_FRAME () */ );
+                      "gdbarch_update: POP_FRAME = 0x%08lx\n",
+                      (long) current_gdbarch->pop_frame
+                      /*POP_FRAME ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: D10V_MAKE_DADDR = 0x%08lx\n",
-		      (long) current_gdbarch->d10v_make_daddr
-  /*D10V_MAKE_DADDR () */ );
+                      "gdbarch_update: D10V_MAKE_DADDR = 0x%08lx\n",
+                      (long) current_gdbarch->d10v_make_daddr
+                      /*D10V_MAKE_DADDR ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: D10V_MAKE_IADDR = 0x%08lx\n",
-		      (long) current_gdbarch->d10v_make_iaddr
-  /*D10V_MAKE_IADDR () */ );
+                      "gdbarch_update: D10V_MAKE_IADDR = 0x%08lx\n",
+                      (long) current_gdbarch->d10v_make_iaddr
+                      /*D10V_MAKE_IADDR ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: D10V_DADDR_P = 0x%08lx\n",
-		      (long) current_gdbarch->d10v_daddr_p
-  /*D10V_DADDR_P () */ );
+                      "gdbarch_update: D10V_DADDR_P = 0x%08lx\n",
+                      (long) current_gdbarch->d10v_daddr_p
+                      /*D10V_DADDR_P ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: D10V_IADDR_P = 0x%08lx\n",
-		      (long) current_gdbarch->d10v_iaddr_p
-  /*D10V_IADDR_P () */ );
+                      "gdbarch_update: D10V_IADDR_P = 0x%08lx\n",
+                      (long) current_gdbarch->d10v_iaddr_p
+                      /*D10V_IADDR_P ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		    "gdbarch_update: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
-		      (long) current_gdbarch->d10v_convert_daddr_to_raw
-  /*D10V_CONVERT_DADDR_TO_RAW () */ );
+                      "gdbarch_update: D10V_CONVERT_DADDR_TO_RAW = 0x%08lx\n",
+                      (long) current_gdbarch->d10v_convert_daddr_to_raw
+                      /*D10V_CONVERT_DADDR_TO_RAW ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		    "gdbarch_update: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
-		      (long) current_gdbarch->d10v_convert_iaddr_to_raw
-  /*D10V_CONVERT_IADDR_TO_RAW () */ );
+                      "gdbarch_update: D10V_CONVERT_IADDR_TO_RAW = 0x%08lx\n",
+                      (long) current_gdbarch->d10v_convert_iaddr_to_raw
+                      /*D10V_CONVERT_IADDR_TO_RAW ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: STORE_STRUCT_RETURN = 0x%08lx\n",
-		      (long) current_gdbarch->store_struct_return
-  /*STORE_STRUCT_RETURN () */ );
+                      "gdbarch_update: STORE_STRUCT_RETURN = 0x%08lx\n",
+                      (long) current_gdbarch->store_struct_return
+                      /*STORE_STRUCT_RETURN ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: STORE_RETURN_VALUE = 0x%08lx\n",
-		      (long) current_gdbarch->store_return_value
-  /*STORE_RETURN_VALUE () */ );
+                      "gdbarch_update: STORE_RETURN_VALUE = 0x%08lx\n",
+                      (long) current_gdbarch->store_return_value
+                      /*STORE_RETURN_VALUE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		 "gdbarch_update: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
-		      (long) current_gdbarch->extract_struct_value_address
-  /*EXTRACT_STRUCT_VALUE_ADDRESS () */ );
+                      "gdbarch_update: EXTRACT_STRUCT_VALUE_ADDRESS = 0x%08lx\n",
+                      (long) current_gdbarch->extract_struct_value_address
+                      /*EXTRACT_STRUCT_VALUE_ADDRESS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: USE_STRUCT_CONVENTION = 0x%08lx\n",
-		      (long) current_gdbarch->use_struct_convention
-  /*USE_STRUCT_CONVENTION () */ );
+                      "gdbarch_update: USE_STRUCT_CONVENTION = 0x%08lx\n",
+                      (long) current_gdbarch->use_struct_convention
+                      /*USE_STRUCT_CONVENTION ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
-		      (long) current_gdbarch->frame_init_saved_regs
-  /*FRAME_INIT_SAVED_REGS () */ );
+                      "gdbarch_update: FRAME_INIT_SAVED_REGS = 0x%08lx\n",
+                      (long) current_gdbarch->frame_init_saved_regs
+                      /*FRAME_INIT_SAVED_REGS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
-		      (long) current_gdbarch->init_extra_frame_info
-  /*INIT_EXTRA_FRAME_INFO () */ );
+                      "gdbarch_update: INIT_EXTRA_FRAME_INFO = 0x%08lx\n",
+                      (long) current_gdbarch->init_extra_frame_info
+                      /*INIT_EXTRA_FRAME_INFO ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: SKIP_PROLOGUE = 0x%08lx\n",
-		      (long) current_gdbarch->skip_prologue
-  /*SKIP_PROLOGUE () */ );
+                      "gdbarch_update: SKIP_PROLOGUE = 0x%08lx\n",
+                      (long) current_gdbarch->skip_prologue
+                      /*SKIP_PROLOGUE ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: INNER_THAN = 0x%08lx\n",
-		      (long) current_gdbarch->inner_than
-  /*INNER_THAN () */ );
+                      "gdbarch_update: INNER_THAN = 0x%08lx\n",
+                      (long) current_gdbarch->inner_than
+                      /*INNER_THAN ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: BREAKPOINT_FROM_PC = 0x%08lx\n",
-		      (long) current_gdbarch->breakpoint_from_pc
-  /*BREAKPOINT_FROM_PC () */ );
+                      "gdbarch_update: BREAKPOINT_FROM_PC = 0x%08lx\n",
+                      (long) current_gdbarch->breakpoint_from_pc
+                      /*BREAKPOINT_FROM_PC ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: DECR_PC_AFTER_BREAK = %ld\n",
-		      (long) DECR_PC_AFTER_BREAK);
+                      "gdbarch_update: DECR_PC_AFTER_BREAK = %ld\n",
+                      (long) DECR_PC_AFTER_BREAK);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FUNCTION_START_OFFSET = %ld\n",
-		      (long) FUNCTION_START_OFFSET);
+                      "gdbarch_update: FUNCTION_START_OFFSET = %ld\n",
+                      (long) FUNCTION_START_OFFSET);
   fprintf_unfiltered (gdb_stdlog,
-		"gdbarch_update: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
-		      (long) current_gdbarch->remote_translate_xfer_address
-  /*REMOTE_TRANSLATE_XFER_ADDRESS () */ );
+                      "gdbarch_update: REMOTE_TRANSLATE_XFER_ADDRESS = 0x%08lx\n",
+                      (long) current_gdbarch->remote_translate_xfer_address
+                      /*REMOTE_TRANSLATE_XFER_ADDRESS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_ARGS_SKIP = %ld\n",
-		      (long) FRAME_ARGS_SKIP);
+                      "gdbarch_update: FRAME_ARGS_SKIP = %ld\n",
+                      (long) FRAME_ARGS_SKIP);
   fprintf_unfiltered (gdb_stdlog,
-		"gdbarch_update: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
-		      (long) current_gdbarch->frameless_function_invocation
-  /*FRAMELESS_FUNCTION_INVOCATION () */ );
+                      "gdbarch_update: FRAMELESS_FUNCTION_INVOCATION = 0x%08lx\n",
+                      (long) current_gdbarch->frameless_function_invocation
+                      /*FRAMELESS_FUNCTION_INVOCATION ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_CHAIN = 0x%08lx\n",
-		      (long) current_gdbarch->frame_chain
-  /*FRAME_CHAIN () */ );
+                      "gdbarch_update: FRAME_CHAIN = 0x%08lx\n",
+                      (long) current_gdbarch->frame_chain
+                      /*FRAME_CHAIN ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_CHAIN_VALID = 0x%08lx\n",
-		      (long) current_gdbarch->frame_chain_valid
-  /*FRAME_CHAIN_VALID () */ );
+                      "gdbarch_update: FRAME_CHAIN_VALID = 0x%08lx\n",
+                      (long) current_gdbarch->frame_chain_valid
+                      /*FRAME_CHAIN_VALID ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_SAVED_PC = 0x%08lx\n",
-		      (long) current_gdbarch->frame_saved_pc
-  /*FRAME_SAVED_PC () */ );
+                      "gdbarch_update: FRAME_SAVED_PC = 0x%08lx\n",
+                      (long) current_gdbarch->frame_saved_pc
+                      /*FRAME_SAVED_PC ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_ARGS_ADDRESS = 0x%08lx\n",
-		      (long) current_gdbarch->frame_args_address
-  /*FRAME_ARGS_ADDRESS () */ );
+                      "gdbarch_update: FRAME_ARGS_ADDRESS = 0x%08lx\n",
+                      (long) current_gdbarch->frame_args_address
+                      /*FRAME_ARGS_ADDRESS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
-		      (long) current_gdbarch->frame_locals_address
-  /*FRAME_LOCALS_ADDRESS () */ );
+                      "gdbarch_update: FRAME_LOCALS_ADDRESS = 0x%08lx\n",
+                      (long) current_gdbarch->frame_locals_address
+                      /*FRAME_LOCALS_ADDRESS ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: SAVED_PC_AFTER_CALL = 0x%08lx\n",
-		      (long) current_gdbarch->saved_pc_after_call
-  /*SAVED_PC_AFTER_CALL () */ );
+                      "gdbarch_update: SAVED_PC_AFTER_CALL = 0x%08lx\n",
+                      (long) current_gdbarch->saved_pc_after_call
+                      /*SAVED_PC_AFTER_CALL ()*/);
   fprintf_unfiltered (gdb_stdlog,
-		      "gdbarch_update: FRAME_NUM_ARGS = 0x%08lx\n",
-		      (long) current_gdbarch->frame_num_args
-  /*FRAME_NUM_ARGS () */ );
+                      "gdbarch_update: FRAME_NUM_ARGS = 0x%08lx\n",
+                      (long) current_gdbarch->frame_num_args
+                      /*FRAME_NUM_ARGS ()*/);
 }
 
 struct gdbarch_tdep *
 gdbarch_tdep (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch_debug >= 2)
     /* FIXME: gdb_std??? */
@@ -885,7 +885,7 @@ gdbarch_tdep (gdbarch)
 
 const struct bfd_arch_info *
 gdbarch_bfd_arch_info (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch_debug >= 2)
     /* FIXME: gdb_std??? */
@@ -895,7 +895,7 @@ gdbarch_bfd_arch_info (gdbarch)
 
 int
 gdbarch_byte_order (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch_debug >= 2)
     /* FIXME: gdb_std??? */
@@ -905,7 +905,7 @@ gdbarch_byte_order (gdbarch)
 
 int
 gdbarch_ptr_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->ptr_bit == 0)
     fatal ("gdbarch: gdbarch_ptr_bit invalid");
@@ -917,15 +917,15 @@ gdbarch_ptr_bit (gdbarch)
 
 void
 set_gdbarch_ptr_bit (gdbarch, ptr_bit)
-     struct gdbarch *gdbarch;
-     int ptr_bit;
+    struct gdbarch *gdbarch;
+    int ptr_bit;
 {
   gdbarch->ptr_bit = ptr_bit;
 }
 
 int
 gdbarch_short_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->short_bit == 0)
     fatal ("gdbarch: gdbarch_short_bit invalid");
@@ -937,15 +937,15 @@ gdbarch_short_bit (gdbarch)
 
 void
 set_gdbarch_short_bit (gdbarch, short_bit)
-     struct gdbarch *gdbarch;
-     int short_bit;
+    struct gdbarch *gdbarch;
+    int short_bit;
 {
   gdbarch->short_bit = short_bit;
 }
 
 int
 gdbarch_int_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->int_bit == 0)
     fatal ("gdbarch: gdbarch_int_bit invalid");
@@ -957,15 +957,15 @@ gdbarch_int_bit (gdbarch)
 
 void
 set_gdbarch_int_bit (gdbarch, int_bit)
-     struct gdbarch *gdbarch;
-     int int_bit;
+    struct gdbarch *gdbarch;
+    int int_bit;
 {
   gdbarch->int_bit = int_bit;
 }
 
 int
 gdbarch_long_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->long_bit == 0)
     fatal ("gdbarch: gdbarch_long_bit invalid");
@@ -977,15 +977,15 @@ gdbarch_long_bit (gdbarch)
 
 void
 set_gdbarch_long_bit (gdbarch, long_bit)
-     struct gdbarch *gdbarch;
-     int long_bit;
+    struct gdbarch *gdbarch;
+    int long_bit;
 {
   gdbarch->long_bit = long_bit;
 }
 
 int
 gdbarch_long_long_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->long_long_bit == 0)
     fatal ("gdbarch: gdbarch_long_long_bit invalid");
@@ -997,15 +997,15 @@ gdbarch_long_long_bit (gdbarch)
 
 void
 set_gdbarch_long_long_bit (gdbarch, long_long_bit)
-     struct gdbarch *gdbarch;
-     int long_long_bit;
+    struct gdbarch *gdbarch;
+    int long_long_bit;
 {
   gdbarch->long_long_bit = long_long_bit;
 }
 
 int
 gdbarch_float_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->float_bit == 0)
     fatal ("gdbarch: gdbarch_float_bit invalid");
@@ -1017,15 +1017,15 @@ gdbarch_float_bit (gdbarch)
 
 void
 set_gdbarch_float_bit (gdbarch, float_bit)
-     struct gdbarch *gdbarch;
-     int float_bit;
+    struct gdbarch *gdbarch;
+    int float_bit;
 {
   gdbarch->float_bit = float_bit;
 }
 
 int
 gdbarch_double_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->double_bit == 0)
     fatal ("gdbarch: gdbarch_double_bit invalid");
@@ -1037,15 +1037,15 @@ gdbarch_double_bit (gdbarch)
 
 void
 set_gdbarch_double_bit (gdbarch, double_bit)
-     struct gdbarch *gdbarch;
-     int double_bit;
+    struct gdbarch *gdbarch;
+    int double_bit;
 {
   gdbarch->double_bit = double_bit;
 }
 
 int
 gdbarch_long_double_bit (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->long_double_bit == 0)
     fatal ("gdbarch: gdbarch_long_double_bit invalid");
@@ -1057,8 +1057,8 @@ gdbarch_long_double_bit (gdbarch)
 
 void
 set_gdbarch_long_double_bit (gdbarch, long_double_bit)
-     struct gdbarch *gdbarch;
-     int long_double_bit;
+    struct gdbarch *gdbarch;
+    int long_double_bit;
 {
   gdbarch->long_double_bit = long_double_bit;
 }
@@ -1076,8 +1076,8 @@ gdbarch_read_pc (struct gdbarch *gdbarch, int pid)
 
 void
 set_gdbarch_read_pc (gdbarch, read_pc)
-     struct gdbarch *gdbarch;
-     gdbarch_read_pc_ftype read_pc;
+    struct gdbarch *gdbarch;
+    gdbarch_read_pc_ftype read_pc;
 {
   gdbarch->read_pc = read_pc;
 }
@@ -1095,8 +1095,8 @@ gdbarch_write_pc (struct gdbarch *gdbarch, CORE_ADDR val, int pid)
 
 void
 set_gdbarch_write_pc (gdbarch, write_pc)
-     struct gdbarch *gdbarch;
-     gdbarch_write_pc_ftype write_pc;
+    struct gdbarch *gdbarch;
+    gdbarch_write_pc_ftype write_pc;
 {
   gdbarch->write_pc = write_pc;
 }
@@ -1114,8 +1114,8 @@ gdbarch_read_fp (struct gdbarch *gdbarch)
 
 void
 set_gdbarch_read_fp (gdbarch, read_fp)
-     struct gdbarch *gdbarch;
-     gdbarch_read_fp_ftype read_fp;
+    struct gdbarch *gdbarch;
+    gdbarch_read_fp_ftype read_fp;
 {
   gdbarch->read_fp = read_fp;
 }
@@ -1133,8 +1133,8 @@ gdbarch_write_fp (struct gdbarch *gdbarch, CORE_ADDR val)
 
 void
 set_gdbarch_write_fp (gdbarch, write_fp)
-     struct gdbarch *gdbarch;
-     gdbarch_write_fp_ftype write_fp;
+    struct gdbarch *gdbarch;
+    gdbarch_write_fp_ftype write_fp;
 {
   gdbarch->write_fp = write_fp;
 }
@@ -1152,8 +1152,8 @@ gdbarch_read_sp (struct gdbarch *gdbarch)
 
 void
 set_gdbarch_read_sp (gdbarch, read_sp)
-     struct gdbarch *gdbarch;
-     gdbarch_read_sp_ftype read_sp;
+    struct gdbarch *gdbarch;
+    gdbarch_read_sp_ftype read_sp;
 {
   gdbarch->read_sp = read_sp;
 }
@@ -1171,15 +1171,15 @@ gdbarch_write_sp (struct gdbarch *gdbarch, CORE_ADDR val)
 
 void
 set_gdbarch_write_sp (gdbarch, write_sp)
-     struct gdbarch *gdbarch;
-     gdbarch_write_sp_ftype write_sp;
+    struct gdbarch *gdbarch;
+    gdbarch_write_sp_ftype write_sp;
 {
   gdbarch->write_sp = write_sp;
 }
 
 int
 gdbarch_num_regs (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->num_regs == -1)
     fatal ("gdbarch: gdbarch_num_regs invalid");
@@ -1191,15 +1191,15 @@ gdbarch_num_regs (gdbarch)
 
 void
 set_gdbarch_num_regs (gdbarch, num_regs)
-     struct gdbarch *gdbarch;
-     int num_regs;
+    struct gdbarch *gdbarch;
+    int num_regs;
 {
   gdbarch->num_regs = num_regs;
 }
 
 int
 gdbarch_sp_regnum (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->sp_regnum == -1)
     fatal ("gdbarch: gdbarch_sp_regnum invalid");
@@ -1211,15 +1211,15 @@ gdbarch_sp_regnum (gdbarch)
 
 void
 set_gdbarch_sp_regnum (gdbarch, sp_regnum)
-     struct gdbarch *gdbarch;
-     int sp_regnum;
+    struct gdbarch *gdbarch;
+    int sp_regnum;
 {
   gdbarch->sp_regnum = sp_regnum;
 }
 
 int
 gdbarch_fp_regnum (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->fp_regnum == -1)
     fatal ("gdbarch: gdbarch_fp_regnum invalid");
@@ -1231,15 +1231,15 @@ gdbarch_fp_regnum (gdbarch)
 
 void
 set_gdbarch_fp_regnum (gdbarch, fp_regnum)
-     struct gdbarch *gdbarch;
-     int fp_regnum;
+    struct gdbarch *gdbarch;
+    int fp_regnum;
 {
   gdbarch->fp_regnum = fp_regnum;
 }
 
 int
 gdbarch_pc_regnum (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->pc_regnum == -1)
     fatal ("gdbarch: gdbarch_pc_regnum invalid");
@@ -1251,8 +1251,8 @@ gdbarch_pc_regnum (gdbarch)
 
 void
 set_gdbarch_pc_regnum (gdbarch, pc_regnum)
-     struct gdbarch *gdbarch;
-     int pc_regnum;
+    struct gdbarch *gdbarch;
+    int pc_regnum;
 {
   gdbarch->pc_regnum = pc_regnum;
 }
@@ -1270,15 +1270,15 @@ gdbarch_register_name (struct gdbarch *gdbarch, int regnr)
 
 void
 set_gdbarch_register_name (gdbarch, register_name)
-     struct gdbarch *gdbarch;
-     gdbarch_register_name_ftype register_name;
+    struct gdbarch *gdbarch;
+    gdbarch_register_name_ftype register_name;
 {
   gdbarch->register_name = register_name;
 }
 
 int
 gdbarch_register_size (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->register_size == -1)
     fatal ("gdbarch: gdbarch_register_size invalid");
@@ -1290,15 +1290,15 @@ gdbarch_register_size (gdbarch)
 
 void
 set_gdbarch_register_size (gdbarch, register_size)
-     struct gdbarch *gdbarch;
-     int register_size;
+    struct gdbarch *gdbarch;
+    int register_size;
 {
   gdbarch->register_size = register_size;
 }
 
 int
 gdbarch_register_bytes (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->register_bytes == -1)
     fatal ("gdbarch: gdbarch_register_bytes invalid");
@@ -1310,8 +1310,8 @@ gdbarch_register_bytes (gdbarch)
 
 void
 set_gdbarch_register_bytes (gdbarch, register_bytes)
-     struct gdbarch *gdbarch;
-     int register_bytes;
+    struct gdbarch *gdbarch;
+    int register_bytes;
 {
   gdbarch->register_bytes = register_bytes;
 }
@@ -1329,8 +1329,8 @@ gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr)
 
 void
 set_gdbarch_register_byte (gdbarch, register_byte)
-     struct gdbarch *gdbarch;
-     gdbarch_register_byte_ftype register_byte;
+    struct gdbarch *gdbarch;
+    gdbarch_register_byte_ftype register_byte;
 {
   gdbarch->register_byte = register_byte;
 }
@@ -1348,15 +1348,15 @@ gdbarch_register_raw_size (struct gdbarch *gdbarch, int reg_nr)
 
 void
 set_gdbarch_register_raw_size (gdbarch, register_raw_size)
-     struct gdbarch *gdbarch;
-     gdbarch_register_raw_size_ftype register_raw_size;
+    struct gdbarch *gdbarch;
+    gdbarch_register_raw_size_ftype register_raw_size;
 {
   gdbarch->register_raw_size = register_raw_size;
 }
 
 int
 gdbarch_max_register_raw_size (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->max_register_raw_size == -1)
     fatal ("gdbarch: gdbarch_max_register_raw_size invalid");
@@ -1368,8 +1368,8 @@ gdbarch_max_register_raw_size (gdbarch)
 
 void
 set_gdbarch_max_register_raw_size (gdbarch, max_register_raw_size)
-     struct gdbarch *gdbarch;
-     int max_register_raw_size;
+    struct gdbarch *gdbarch;
+    int max_register_raw_size;
 {
   gdbarch->max_register_raw_size = max_register_raw_size;
 }
@@ -1387,15 +1387,15 @@ gdbarch_register_virtual_size (struct gdbarch *gdbarch, int reg_nr)
 
 void
 set_gdbarch_register_virtual_size (gdbarch, register_virtual_size)
-     struct gdbarch *gdbarch;
-     gdbarch_register_virtual_size_ftype register_virtual_size;
+    struct gdbarch *gdbarch;
+    gdbarch_register_virtual_size_ftype register_virtual_size;
 {
   gdbarch->register_virtual_size = register_virtual_size;
 }
 
 int
 gdbarch_max_register_virtual_size (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->max_register_virtual_size == -1)
     fatal ("gdbarch: gdbarch_max_register_virtual_size invalid");
@@ -1407,8 +1407,8 @@ gdbarch_max_register_virtual_size (gdbarch)
 
 void
 set_gdbarch_max_register_virtual_size (gdbarch, max_register_virtual_size)
-     struct gdbarch *gdbarch;
-     int max_register_virtual_size;
+    struct gdbarch *gdbarch;
+    int max_register_virtual_size;
 {
   gdbarch->max_register_virtual_size = max_register_virtual_size;
 }
@@ -1426,15 +1426,15 @@ gdbarch_register_virtual_type (struct gdbarch *gdbarch, int reg_nr)
 
 void
 set_gdbarch_register_virtual_type (gdbarch, register_virtual_type)
-     struct gdbarch *gdbarch;
-     gdbarch_register_virtual_type_ftype register_virtual_type;
+    struct gdbarch *gdbarch;
+    gdbarch_register_virtual_type_ftype register_virtual_type;
 {
   gdbarch->register_virtual_type = register_virtual_type;
 }
 
 int
 gdbarch_use_generic_dummy_frames (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->use_generic_dummy_frames == -1)
     fatal ("gdbarch: gdbarch_use_generic_dummy_frames invalid");
@@ -1446,15 +1446,15 @@ gdbarch_use_generic_dummy_frames (gdbarch)
 
 void
 set_gdbarch_use_generic_dummy_frames (gdbarch, use_generic_dummy_frames)
-     struct gdbarch *gdbarch;
-     int use_generic_dummy_frames;
+    struct gdbarch *gdbarch;
+    int use_generic_dummy_frames;
 {
   gdbarch->use_generic_dummy_frames = use_generic_dummy_frames;
 }
 
 int
 gdbarch_call_dummy_location (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_location == 0)
     fatal ("gdbarch: gdbarch_call_dummy_location invalid");
@@ -1466,8 +1466,8 @@ gdbarch_call_dummy_location (gdbarch)
 
 void
 set_gdbarch_call_dummy_location (gdbarch, call_dummy_location)
-     struct gdbarch *gdbarch;
-     int call_dummy_location;
+    struct gdbarch *gdbarch;
+    int call_dummy_location;
 {
   gdbarch->call_dummy_location = call_dummy_location;
 }
@@ -1485,15 +1485,15 @@ gdbarch_call_dummy_address (struct gdbarch *gdbarch)
 
 void
 set_gdbarch_call_dummy_address (gdbarch, call_dummy_address)
-     struct gdbarch *gdbarch;
-     gdbarch_call_dummy_address_ftype call_dummy_address;
+    struct gdbarch *gdbarch;
+    gdbarch_call_dummy_address_ftype call_dummy_address;
 {
   gdbarch->call_dummy_address = call_dummy_address;
 }
 
 CORE_ADDR
 gdbarch_call_dummy_start_offset (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_start_offset == -1)
     fatal ("gdbarch: gdbarch_call_dummy_start_offset invalid");
@@ -1505,15 +1505,15 @@ gdbarch_call_dummy_start_offset (gdbarch)
 
 void
 set_gdbarch_call_dummy_start_offset (gdbarch, call_dummy_start_offset)
-     struct gdbarch *gdbarch;
-     CORE_ADDR call_dummy_start_offset;
+    struct gdbarch *gdbarch;
+    CORE_ADDR call_dummy_start_offset;
 {
   gdbarch->call_dummy_start_offset = call_dummy_start_offset;
 }
 
 CORE_ADDR
 gdbarch_call_dummy_breakpoint_offset (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_breakpoint_offset == -1)
     fatal ("gdbarch: gdbarch_call_dummy_breakpoint_offset invalid");
@@ -1525,15 +1525,15 @@ gdbarch_call_dummy_breakpoint_offset (gdbarch)
 
 void
 set_gdbarch_call_dummy_breakpoint_offset (gdbarch, call_dummy_breakpoint_offset)
-     struct gdbarch *gdbarch;
-     CORE_ADDR call_dummy_breakpoint_offset;
+    struct gdbarch *gdbarch;
+    CORE_ADDR call_dummy_breakpoint_offset;
 {
   gdbarch->call_dummy_breakpoint_offset = call_dummy_breakpoint_offset;
 }
 
 int
 gdbarch_call_dummy_breakpoint_offset_p (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_breakpoint_offset_p == -1)
     fatal ("gdbarch: gdbarch_call_dummy_breakpoint_offset_p invalid");
@@ -1545,15 +1545,15 @@ gdbarch_call_dummy_breakpoint_offset_p (gdbarch)
 
 void
 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, call_dummy_breakpoint_offset_p)
-     struct gdbarch *gdbarch;
-     int call_dummy_breakpoint_offset_p;
+    struct gdbarch *gdbarch;
+    int call_dummy_breakpoint_offset_p;
 {
   gdbarch->call_dummy_breakpoint_offset_p = call_dummy_breakpoint_offset_p;
 }
 
 int
 gdbarch_call_dummy_length (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_length == -1)
     fatal ("gdbarch: gdbarch_call_dummy_length invalid");
@@ -1565,8 +1565,8 @@ gdbarch_call_dummy_length (gdbarch)
 
 void
 set_gdbarch_call_dummy_length (gdbarch, call_dummy_length)
-     struct gdbarch *gdbarch;
-     int call_dummy_length;
+    struct gdbarch *gdbarch;
+    int call_dummy_length;
 {
   gdbarch->call_dummy_length = call_dummy_length;
 }
@@ -1584,15 +1584,15 @@ gdbarch_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, C
 
 void
 set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy)
-     struct gdbarch *gdbarch;
-     gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy;
+    struct gdbarch *gdbarch;
+    gdbarch_pc_in_call_dummy_ftype pc_in_call_dummy;
 {
   gdbarch->pc_in_call_dummy = pc_in_call_dummy;
 }
 
 int
 gdbarch_call_dummy_p (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_p == -1)
     fatal ("gdbarch: gdbarch_call_dummy_p invalid");
@@ -1604,15 +1604,15 @@ gdbarch_call_dummy_p (gdbarch)
 
 void
 set_gdbarch_call_dummy_p (gdbarch, call_dummy_p)
-     struct gdbarch *gdbarch;
-     int call_dummy_p;
+    struct gdbarch *gdbarch;
+    int call_dummy_p;
 {
   gdbarch->call_dummy_p = call_dummy_p;
 }
 
 LONGEST *
 gdbarch_call_dummy_words (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch_debug >= 2)
     /* FIXME: gdb_std??? */
@@ -1622,15 +1622,15 @@ gdbarch_call_dummy_words (gdbarch)
 
 void
 set_gdbarch_call_dummy_words (gdbarch, call_dummy_words)
-     struct gdbarch *gdbarch;
-     LONGEST *call_dummy_words;
+    struct gdbarch *gdbarch;
+    LONGEST * call_dummy_words;
 {
   gdbarch->call_dummy_words = call_dummy_words;
 }
 
 int
 gdbarch_sizeof_call_dummy_words (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch_debug >= 2)
     /* FIXME: gdb_std??? */
@@ -1640,15 +1640,15 @@ gdbarch_sizeof_call_dummy_words (gdbarch)
 
 void
 set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_call_dummy_words)
-     struct gdbarch *gdbarch;
-     int sizeof_call_dummy_words;
+    struct gdbarch *gdbarch;
+    int sizeof_call_dummy_words;
 {
   gdbarch->sizeof_call_dummy_words = sizeof_call_dummy_words;
 }
 
 int
 gdbarch_call_dummy_stack_adjust_p (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_stack_adjust_p == -1)
     fatal ("gdbarch: gdbarch_call_dummy_stack_adjust_p invalid");
@@ -1660,15 +1660,15 @@ gdbarch_call_dummy_stack_adjust_p (gdbarch)
 
 void
 set_gdbarch_call_dummy_stack_adjust_p (gdbarch, call_dummy_stack_adjust_p)
-     struct gdbarch *gdbarch;
-     int call_dummy_stack_adjust_p;
+    struct gdbarch *gdbarch;
+    int call_dummy_stack_adjust_p;
 {
   gdbarch->call_dummy_stack_adjust_p = call_dummy_stack_adjust_p;
 }
 
 int
 gdbarch_call_dummy_stack_adjust (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->call_dummy_stack_adjust_p && gdbarch->call_dummy_stack_adjust == 0)
     fatal ("gdbarch: gdbarch_call_dummy_stack_adjust invalid");
@@ -1680,8 +1680,8 @@ gdbarch_call_dummy_stack_adjust (gdbarch)
 
 void
 set_gdbarch_call_dummy_stack_adjust (gdbarch, call_dummy_stack_adjust)
-     struct gdbarch *gdbarch;
-     int call_dummy_stack_adjust;
+    struct gdbarch *gdbarch;
+    int call_dummy_stack_adjust;
 {
   gdbarch->call_dummy_stack_adjust = call_dummy_stack_adjust;
 }
@@ -1699,15 +1699,15 @@ gdbarch_fix_call_dummy (struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE
 
 void
 set_gdbarch_fix_call_dummy (gdbarch, fix_call_dummy)
-     struct gdbarch *gdbarch;
-     gdbarch_fix_call_dummy_ftype fix_call_dummy;
+    struct gdbarch *gdbarch;
+    gdbarch_fix_call_dummy_ftype fix_call_dummy;
 {
   gdbarch->fix_call_dummy = fix_call_dummy;
 }
 
 int
 gdbarch_believe_pcc_promotion (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch_debug >= 2)
     /* FIXME: gdb_std??? */
@@ -1717,15 +1717,15 @@ gdbarch_believe_pcc_promotion (gdbarch)
 
 void
 set_gdbarch_believe_pcc_promotion (gdbarch, believe_pcc_promotion)
-     struct gdbarch *gdbarch;
-     int believe_pcc_promotion;
+    struct gdbarch *gdbarch;
+    int believe_pcc_promotion;
 {
   gdbarch->believe_pcc_promotion = believe_pcc_promotion;
 }
 
 int
 gdbarch_believe_pcc_promotion_type (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch_debug >= 2)
     /* FIXME: gdb_std??? */
@@ -1735,14 +1735,14 @@ gdbarch_believe_pcc_promotion_type (gdbarch)
 
 void
 set_gdbarch_believe_pcc_promotion_type (gdbarch, believe_pcc_promotion_type)
-     struct gdbarch *gdbarch;
-     int believe_pcc_promotion_type;
+    struct gdbarch *gdbarch;
+    int believe_pcc_promotion_type;
 {
   gdbarch->believe_pcc_promotion_type = believe_pcc_promotion_type;
 }
 
 void
-gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR * addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
+gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval)
 {
   if (gdbarch->get_saved_register == 0)
     fatal ("gdbarch: gdbarch_get_saved_register invalid");
@@ -1754,8 +1754,8 @@ gdbarch_get_saved_register (struct gdbarch *gdbarch, char *raw_buffer, int *opti
 
 void
 set_gdbarch_get_saved_register (gdbarch, get_saved_register)
-     struct gdbarch *gdbarch;
-     gdbarch_get_saved_register_ftype get_saved_register;
+    struct gdbarch *gdbarch;
+    gdbarch_get_saved_register_ftype get_saved_register;
 {
   gdbarch->get_saved_register = get_saved_register;
 }
@@ -1773,8 +1773,8 @@ gdbarch_register_convertible (struct gdbarch *gdbarch, int nr)
 
 void
 set_gdbarch_register_convertible (gdbarch, register_convertible)
-     struct gdbarch *gdbarch;
-     gdbarch_register_convertible_ftype register_convertible;
+    struct gdbarch *gdbarch;
+    gdbarch_register_convertible_ftype register_convertible;
 {
   gdbarch->register_convertible = register_convertible;
 }
@@ -1792,8 +1792,8 @@ gdbarch_register_convert_to_virtual (struct gdbarch *gdbarch, int regnum, struct
 
 void
 set_gdbarch_register_convert_to_virtual (gdbarch, register_convert_to_virtual)
-     struct gdbarch *gdbarch;
-     gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual;
+    struct gdbarch *gdbarch;
+    gdbarch_register_convert_to_virtual_ftype register_convert_to_virtual;
 {
   gdbarch->register_convert_to_virtual = register_convert_to_virtual;
 }
@@ -1811,8 +1811,8 @@ gdbarch_register_convert_to_raw (struct gdbarch *gdbarch, struct type *type, int
 
 void
 set_gdbarch_register_convert_to_raw (gdbarch, register_convert_to_raw)
-     struct gdbarch *gdbarch;
-     gdbarch_register_convert_to_raw_ftype register_convert_to_raw;
+    struct gdbarch *gdbarch;
+    gdbarch_register_convert_to_raw_ftype register_convert_to_raw;
 {
   gdbarch->register_convert_to_raw = register_convert_to_raw;
 }
@@ -1830,8 +1830,8 @@ gdbarch_extract_return_value (struct gdbarch *gdbarch, struct type *type, char *
 
 void
 set_gdbarch_extract_return_value (gdbarch, extract_return_value)
-     struct gdbarch *gdbarch;
-     gdbarch_extract_return_value_ftype extract_return_value;
+    struct gdbarch *gdbarch;
+    gdbarch_extract_return_value_ftype extract_return_value;
 {
   gdbarch->extract_return_value = extract_return_value;
 }
@@ -1849,8 +1849,8 @@ gdbarch_push_arguments (struct gdbarch *gdbarch, int nargs, struct value **args,
 
 void
 set_gdbarch_push_arguments (gdbarch, push_arguments)
-     struct gdbarch *gdbarch;
-     gdbarch_push_arguments_ftype push_arguments;
+    struct gdbarch *gdbarch;
+    gdbarch_push_arguments_ftype push_arguments;
 {
   gdbarch->push_arguments = push_arguments;
 }
@@ -1868,8 +1868,8 @@ gdbarch_push_dummy_frame (struct gdbarch *gdbarch)
 
 void
 set_gdbarch_push_dummy_frame (gdbarch, push_dummy_frame)
-     struct gdbarch *gdbarch;
-     gdbarch_push_dummy_frame_ftype push_dummy_frame;
+    struct gdbarch *gdbarch;
+    gdbarch_push_dummy_frame_ftype push_dummy_frame;
 {
   gdbarch->push_dummy_frame = push_dummy_frame;
 }
@@ -1887,8 +1887,8 @@ gdbarch_push_return_address (struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp
 
 void
 set_gdbarch_push_return_address (gdbarch, push_return_address)
-     struct gdbarch *gdbarch;
-     gdbarch_push_return_address_ftype push_return_address;
+    struct gdbarch *gdbarch;
+    gdbarch_push_return_address_ftype push_return_address;
 {
   gdbarch->push_return_address = push_return_address;
 }
@@ -1906,8 +1906,8 @@ gdbarch_pop_frame (struct gdbarch *gdbarch)
 
 void
 set_gdbarch_pop_frame (gdbarch, pop_frame)
-     struct gdbarch *gdbarch;
-     gdbarch_pop_frame_ftype pop_frame;
+    struct gdbarch *gdbarch;
+    gdbarch_pop_frame_ftype pop_frame;
 {
   gdbarch->pop_frame = pop_frame;
 }
@@ -1925,8 +1925,8 @@ gdbarch_d10v_make_daddr (struct gdbarch *gdbarch, CORE_ADDR x)
 
 void
 set_gdbarch_d10v_make_daddr (gdbarch, d10v_make_daddr)
-     struct gdbarch *gdbarch;
-     gdbarch_d10v_make_daddr_ftype d10v_make_daddr;
+    struct gdbarch *gdbarch;
+    gdbarch_d10v_make_daddr_ftype d10v_make_daddr;
 {
   gdbarch->d10v_make_daddr = d10v_make_daddr;
 }
@@ -1944,8 +1944,8 @@ gdbarch_d10v_make_iaddr (struct gdbarch *gdbarch, CORE_ADDR x)
 
 void
 set_gdbarch_d10v_make_iaddr (gdbarch, d10v_make_iaddr)
-     struct gdbarch *gdbarch;
-     gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr;
+    struct gdbarch *gdbarch;
+    gdbarch_d10v_make_iaddr_ftype d10v_make_iaddr;
 {
   gdbarch->d10v_make_iaddr = d10v_make_iaddr;
 }
@@ -1963,8 +1963,8 @@ gdbarch_d10v_daddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
 
 void
 set_gdbarch_d10v_daddr_p (gdbarch, d10v_daddr_p)
-     struct gdbarch *gdbarch;
-     gdbarch_d10v_daddr_p_ftype d10v_daddr_p;
+    struct gdbarch *gdbarch;
+    gdbarch_d10v_daddr_p_ftype d10v_daddr_p;
 {
   gdbarch->d10v_daddr_p = d10v_daddr_p;
 }
@@ -1982,8 +1982,8 @@ gdbarch_d10v_iaddr_p (struct gdbarch *gdbarch, CORE_ADDR x)
 
 void
 set_gdbarch_d10v_iaddr_p (gdbarch, d10v_iaddr_p)
-     struct gdbarch *gdbarch;
-     gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p;
+    struct gdbarch *gdbarch;
+    gdbarch_d10v_iaddr_p_ftype d10v_iaddr_p;
 {
   gdbarch->d10v_iaddr_p = d10v_iaddr_p;
 }
@@ -2001,8 +2001,8 @@ gdbarch_d10v_convert_daddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
 
 void
 set_gdbarch_d10v_convert_daddr_to_raw (gdbarch, d10v_convert_daddr_to_raw)
-     struct gdbarch *gdbarch;
-     gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw;
+    struct gdbarch *gdbarch;
+    gdbarch_d10v_convert_daddr_to_raw_ftype d10v_convert_daddr_to_raw;
 {
   gdbarch->d10v_convert_daddr_to_raw = d10v_convert_daddr_to_raw;
 }
@@ -2020,8 +2020,8 @@ gdbarch_d10v_convert_iaddr_to_raw (struct gdbarch *gdbarch, CORE_ADDR x)
 
 void
 set_gdbarch_d10v_convert_iaddr_to_raw (gdbarch, d10v_convert_iaddr_to_raw)
-     struct gdbarch *gdbarch;
-     gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw;
+    struct gdbarch *gdbarch;
+    gdbarch_d10v_convert_iaddr_to_raw_ftype d10v_convert_iaddr_to_raw;
 {
   gdbarch->d10v_convert_iaddr_to_raw = d10v_convert_iaddr_to_raw;
 }
@@ -2039,8 +2039,8 @@ gdbarch_store_struct_return (struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR
 
 void
 set_gdbarch_store_struct_return (gdbarch, store_struct_return)
-     struct gdbarch *gdbarch;
-     gdbarch_store_struct_return_ftype store_struct_return;
+    struct gdbarch *gdbarch;
+    gdbarch_store_struct_return_ftype store_struct_return;
 {
   gdbarch->store_struct_return = store_struct_return;
 }
@@ -2058,8 +2058,8 @@ gdbarch_store_return_value (struct gdbarch *gdbarch, struct type *type, char *va
 
 void
 set_gdbarch_store_return_value (gdbarch, store_return_value)
-     struct gdbarch *gdbarch;
-     gdbarch_store_return_value_ftype store_return_value;
+    struct gdbarch *gdbarch;
+    gdbarch_store_return_value_ftype store_return_value;
 {
   gdbarch->store_return_value = store_return_value;
 }
@@ -2077,8 +2077,8 @@ gdbarch_extract_struct_value_address (struct gdbarch *gdbarch, char *regbuf)
 
 void
 set_gdbarch_extract_struct_value_address (gdbarch, extract_struct_value_address)
-     struct gdbarch *gdbarch;
-     gdbarch_extract_struct_value_address_ftype extract_struct_value_address;
+    struct gdbarch *gdbarch;
+    gdbarch_extract_struct_value_address_ftype extract_struct_value_address;
 {
   gdbarch->extract_struct_value_address = extract_struct_value_address;
 }
@@ -2096,8 +2096,8 @@ gdbarch_use_struct_convention (struct gdbarch *gdbarch, int gcc_p, struct type *
 
 void
 set_gdbarch_use_struct_convention (gdbarch, use_struct_convention)
-     struct gdbarch *gdbarch;
-     gdbarch_use_struct_convention_ftype use_struct_convention;
+    struct gdbarch *gdbarch;
+    gdbarch_use_struct_convention_ftype use_struct_convention;
 {
   gdbarch->use_struct_convention = use_struct_convention;
 }
@@ -2115,8 +2115,8 @@ gdbarch_frame_init_saved_regs (struct gdbarch *gdbarch, struct frame_info *frame
 
 void
 set_gdbarch_frame_init_saved_regs (gdbarch, frame_init_saved_regs)
-     struct gdbarch *gdbarch;
-     gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs;
+    struct gdbarch *gdbarch;
+    gdbarch_frame_init_saved_regs_ftype frame_init_saved_regs;
 {
   gdbarch->frame_init_saved_regs = frame_init_saved_regs;
 }
@@ -2134,8 +2134,8 @@ gdbarch_init_extra_frame_info (struct gdbarch *gdbarch, int fromleaf, struct fra
 
 void
 set_gdbarch_init_extra_frame_info (gdbarch, init_extra_frame_info)
-     struct gdbarch *gdbarch;
-     gdbarch_init_extra_frame_info_ftype init_extra_frame_info;
+    struct gdbarch *gdbarch;
+    gdbarch_init_extra_frame_info_ftype init_extra_frame_info;
 {
   gdbarch->init_extra_frame_info = init_extra_frame_info;
 }
@@ -2153,8 +2153,8 @@ gdbarch_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR ip)
 
 void
 set_gdbarch_skip_prologue (gdbarch, skip_prologue)
-     struct gdbarch *gdbarch;
-     gdbarch_skip_prologue_ftype skip_prologue;
+    struct gdbarch *gdbarch;
+    gdbarch_skip_prologue_ftype skip_prologue;
 {
   gdbarch->skip_prologue = skip_prologue;
 }
@@ -2172,14 +2172,14 @@ gdbarch_inner_than (struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs)
 
 void
 set_gdbarch_inner_than (gdbarch, inner_than)
-     struct gdbarch *gdbarch;
-     gdbarch_inner_than_ftype inner_than;
+    struct gdbarch *gdbarch;
+    gdbarch_inner_than_ftype inner_than;
 {
   gdbarch->inner_than = inner_than;
 }
 
 unsigned char *
-gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *lenptr)
+gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 {
   if (gdbarch->breakpoint_from_pc == 0)
     fatal ("gdbarch: gdbarch_breakpoint_from_pc invalid");
@@ -2191,15 +2191,15 @@ gdbarch_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR * pcptr, int *len
 
 void
 set_gdbarch_breakpoint_from_pc (gdbarch, breakpoint_from_pc)
-     struct gdbarch *gdbarch;
-     gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc;
+    struct gdbarch *gdbarch;
+    gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc;
 {
   gdbarch->breakpoint_from_pc = breakpoint_from_pc;
 }
 
 CORE_ADDR
 gdbarch_decr_pc_after_break (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->decr_pc_after_break == -1)
     fatal ("gdbarch: gdbarch_decr_pc_after_break invalid");
@@ -2211,15 +2211,15 @@ gdbarch_decr_pc_after_break (gdbarch)
 
 void
 set_gdbarch_decr_pc_after_break (gdbarch, decr_pc_after_break)
-     struct gdbarch *gdbarch;
-     CORE_ADDR decr_pc_after_break;
+    struct gdbarch *gdbarch;
+    CORE_ADDR decr_pc_after_break;
 {
   gdbarch->decr_pc_after_break = decr_pc_after_break;
 }
 
 CORE_ADDR
 gdbarch_function_start_offset (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->function_start_offset == -1)
     fatal ("gdbarch: gdbarch_function_start_offset invalid");
@@ -2231,14 +2231,14 @@ gdbarch_function_start_offset (gdbarch)
 
 void
 set_gdbarch_function_start_offset (gdbarch, function_start_offset)
-     struct gdbarch *gdbarch;
-     CORE_ADDR function_start_offset;
+    struct gdbarch *gdbarch;
+    CORE_ADDR function_start_offset;
 {
   gdbarch->function_start_offset = function_start_offset;
 }
 
 void
-gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR * rem_addr, int *rem_len)
+gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len)
 {
   if (gdbarch->remote_translate_xfer_address == 0)
     fatal ("gdbarch: gdbarch_remote_translate_xfer_address invalid");
@@ -2250,15 +2250,15 @@ gdbarch_remote_translate_xfer_address (struct gdbarch *gdbarch, CORE_ADDR gdb_ad
 
 void
 set_gdbarch_remote_translate_xfer_address (gdbarch, remote_translate_xfer_address)
-     struct gdbarch *gdbarch;
-     gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address;
+    struct gdbarch *gdbarch;
+    gdbarch_remote_translate_xfer_address_ftype remote_translate_xfer_address;
 {
   gdbarch->remote_translate_xfer_address = remote_translate_xfer_address;
 }
 
 CORE_ADDR
 gdbarch_frame_args_skip (gdbarch)
-     struct gdbarch *gdbarch;
+    struct gdbarch *gdbarch;
 {
   if (gdbarch->frame_args_skip == -1)
     fatal ("gdbarch: gdbarch_frame_args_skip invalid");
@@ -2270,8 +2270,8 @@ gdbarch_frame_args_skip (gdbarch)
 
 void
 set_gdbarch_frame_args_skip (gdbarch, frame_args_skip)
-     struct gdbarch *gdbarch;
-     CORE_ADDR frame_args_skip;
+    struct gdbarch *gdbarch;
+    CORE_ADDR frame_args_skip;
 {
   gdbarch->frame_args_skip = frame_args_skip;
 }
@@ -2289,8 +2289,8 @@ gdbarch_frameless_function_invocation (struct gdbarch *gdbarch, struct frame_inf
 
 void
 set_gdbarch_frameless_function_invocation (gdbarch, frameless_function_invocation)
-     struct gdbarch *gdbarch;
-     gdbarch_frameless_function_invocation_ftype frameless_function_invocation;
+    struct gdbarch *gdbarch;
+    gdbarch_frameless_function_invocation_ftype frameless_function_invocation;
 {
   gdbarch->frameless_function_invocation = frameless_function_invocation;
 }
@@ -2308,8 +2308,8 @@ gdbarch_frame_chain (struct gdbarch *gdbarch, struct frame_info *frame)
 
 void
 set_gdbarch_frame_chain (gdbarch, frame_chain)
-     struct gdbarch *gdbarch;
-     gdbarch_frame_chain_ftype frame_chain;
+    struct gdbarch *gdbarch;
+    gdbarch_frame_chain_ftype frame_chain;
 {
   gdbarch->frame_chain = frame_chain;
 }
@@ -2327,8 +2327,8 @@ gdbarch_frame_chain_valid (struct gdbarch *gdbarch, CORE_ADDR chain, struct fram
 
 void
 set_gdbarch_frame_chain_valid (gdbarch, frame_chain_valid)
-     struct gdbarch *gdbarch;
-     gdbarch_frame_chain_valid_ftype frame_chain_valid;
+    struct gdbarch *gdbarch;
+    gdbarch_frame_chain_valid_ftype frame_chain_valid;
 {
   gdbarch->frame_chain_valid = frame_chain_valid;
 }
@@ -2346,8 +2346,8 @@ gdbarch_frame_saved_pc (struct gdbarch *gdbarch, struct frame_info *fi)
 
 void
 set_gdbarch_frame_saved_pc (gdbarch, frame_saved_pc)
-     struct gdbarch *gdbarch;
-     gdbarch_frame_saved_pc_ftype frame_saved_pc;
+    struct gdbarch *gdbarch;
+    gdbarch_frame_saved_pc_ftype frame_saved_pc;
 {
   gdbarch->frame_saved_pc = frame_saved_pc;
 }
@@ -2365,8 +2365,8 @@ gdbarch_frame_args_address (struct gdbarch *gdbarch, struct frame_info *fi)
 
 void
 set_gdbarch_frame_args_address (gdbarch, frame_args_address)
-     struct gdbarch *gdbarch;
-     gdbarch_frame_args_address_ftype frame_args_address;
+    struct gdbarch *gdbarch;
+    gdbarch_frame_args_address_ftype frame_args_address;
 {
   gdbarch->frame_args_address = frame_args_address;
 }
@@ -2384,8 +2384,8 @@ gdbarch_frame_locals_address (struct gdbarch *gdbarch, struct frame_info *fi)
 
 void
 set_gdbarch_frame_locals_address (gdbarch, frame_locals_address)
-     struct gdbarch *gdbarch;
-     gdbarch_frame_locals_address_ftype frame_locals_address;
+    struct gdbarch *gdbarch;
+    gdbarch_frame_locals_address_ftype frame_locals_address;
 {
   gdbarch->frame_locals_address = frame_locals_address;
 }
@@ -2403,8 +2403,8 @@ gdbarch_saved_pc_after_call (struct gdbarch *gdbarch, struct frame_info *frame)
 
 void
 set_gdbarch_saved_pc_after_call (gdbarch, saved_pc_after_call)
-     struct gdbarch *gdbarch;
-     gdbarch_saved_pc_after_call_ftype saved_pc_after_call;
+    struct gdbarch *gdbarch;
+    gdbarch_saved_pc_after_call_ftype saved_pc_after_call;
 {
   gdbarch->saved_pc_after_call = saved_pc_after_call;
 }
@@ -2422,8 +2422,8 @@ gdbarch_frame_num_args (struct gdbarch *gdbarch, struct frame_info *frame)
 
 void
 set_gdbarch_frame_num_args (gdbarch, frame_num_args)
-     struct gdbarch *gdbarch;
-     gdbarch_frame_num_args_ftype frame_num_args;
+    struct gdbarch *gdbarch;
+    gdbarch_frame_num_args_ftype frame_num_args;
 {
   gdbarch->frame_num_args = frame_num_args;
 }
@@ -2438,17 +2438,17 @@ struct gdbarch_data
 };
 
 struct gdbarch_data_registration
-  {
-    gdbarch_data_ftype *init;
-    struct gdbarch_data *data;
-    struct gdbarch_data_registration *next;
-  };
+{
+  gdbarch_data_ftype *init;
+  struct gdbarch_data *data;
+  struct gdbarch_data_registration *next;
+};
 
 struct gdbarch_data_registrary
-  {
-    int nr;
-    struct gdbarch_data_registration *registrations;
-  };
+{
+  int nr;
+  struct gdbarch_data_registration *registrations;
+};
 
 struct gdbarch_data_registrary gdbarch_data_registrary =
 {
@@ -2481,7 +2481,7 @@ init_gdbarch_data (gdbarch)
 {
   struct gdbarch_data_registration *rego;
   gdbarch->nr_data = gdbarch_data_registrary.nr + 1;
-  gdbarch->data = xmalloc (sizeof (void *) * gdbarch->nr_data);
+  gdbarch->data = xmalloc (sizeof (void*) * gdbarch->nr_data);
   for (rego = gdbarch_data_registrary.registrations;
        rego != NULL;
        rego = rego->next)
@@ -2516,20 +2516,20 @@ struct gdbarch_swap
 };
 
 struct gdbarch_swap_registration
-  {
-    void *data;
-    unsigned long sizeof_data;
-    gdbarch_swap_ftype *init;
-    struct gdbarch_swap_registration *next;
-  };
+{
+  void *data;
+  unsigned long sizeof_data;
+  gdbarch_swap_ftype *init;
+  struct gdbarch_swap_registration *next;
+};
 
 struct gdbarch_swap_registrary
-  {
-    int nr;
-    struct gdbarch_swap_registration *registrations;
-  };
+{
+  int nr;
+  struct gdbarch_swap_registration *registrations;
+};
 
-struct gdbarch_swap_registrary gdbarch_swap_registrary =
+struct gdbarch_swap_registrary gdbarch_swap_registrary = 
 {
   0, NULL,
 };
@@ -2648,7 +2648,7 @@ register_gdbarch_init (bfd_architecture, init)
   (*curr)->arches = NULL;
   (*curr)->next = NULL;
 }
-
+  
 
 
 /* Look for an architecture using gdbarch_info.  Base search on only
@@ -2729,7 +2729,7 @@ gdbarch_update (info)
       fprintf_unfiltered (gdb_stdlog,
 			  "gdbarch_update: info.bfd_architecture %d (%s)\n",
 			  info.bfd_architecture,
-		bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
+			  bfd_lookup_arch (info.bfd_architecture, 0)->printable_name);
       fprintf_unfiltered (gdb_stdlog,
 			  "gdbarch_update: info.bfd_arch_info %s\n",
 			  (info.bfd_arch_info != NULL
@@ -2789,7 +2789,7 @@ gdbarch_update (info)
 	  return 1;
 	}
     }
-
+    
   /* Append this new architecture to this targets list. */
   (*list) = XMALLOC (struct gdbarch_list);
   (*list)->next = NULL;
@@ -2800,12 +2800,12 @@ gdbarch_update (info)
   if (gdbarch_debug)
     {
       fprintf_unfiltered (gdb_stdlog,
-		 "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
+			  "gdbarch_update: New architecture 0x%08lx (%s) selected\n",
 			  (long) new_gdbarch,
 			  new_gdbarch->bfd_arch_info->printable_name);
       gdbarch_dump ();
     }
-
+  
   /* Check that the newly installed architecture is valid.  */
   verify_gdbarch (new_gdbarch);
 
@@ -2813,12 +2813,12 @@ gdbarch_update (info)
      CURRENT_GDBARCH must be update before these modules are
      called. */
   init_gdbarch_swap (new_gdbarch);
-
+  
   /* Initialize the per-architecture data-pointer of all parties that
      registered an interest in this architecture.  CURRENT_GDBARCH
      must be updated before these modules are called. */
   init_gdbarch_data (new_gdbarch);
-
+  
   return 1;
 }
 
@@ -2844,7 +2844,7 @@ gdbarch_update (info)
 #endif
 #endif
 #ifndef TARGET_BYTE_ORDER_DEFAULT
-#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN	/* arbitrary */
+#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
 #endif
 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
 int target_byte_order_auto = 1;
@@ -2860,9 +2860,9 @@ show_endian (args, from_tty)
      int from_tty;
 {
   char *msg =
-  (TARGET_BYTE_ORDER_AUTO
-   ? "The target endianness is set automatically (currently %s endian)\n"
-   : "The target is assumed to be %s endian\n");
+    (TARGET_BYTE_ORDER_AUTO
+     ? "The target endianness is set automatically (currently %s endian)\n"
+     : "The target is assumed to be %s endian\n");
   printf_unfiltered (msg, (TARGET_BYTE_ORDER == BIG_ENDIAN ? "big" : "little"));
 }
 
@@ -2956,7 +2956,7 @@ set_endian_from_file (abfd)
   if (TARGET_BYTE_ORDER_SELECTABLE_P)
     {
       int want;
-
+      
       if (bfd_big_endian (abfd))
 	want = BIG_ENDIAN;
       else
@@ -2986,11 +2986,11 @@ set_endian_from_file (abfd)
 int target_architecture_auto = 1;
 extern const struct bfd_arch_info bfd_default_arch_struct;
 const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
-int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info * ap));
+int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *ap));
 
 /* Do the real work of changing the current architecture */
 
-static int arch_ok PARAMS ((const struct bfd_arch_info * arch));
+static int arch_ok PARAMS ((const struct bfd_arch_info *arch));
 static int
 arch_ok (arch)
      const struct bfd_arch_info *arch;
@@ -3002,12 +3002,9 @@ arch_ok (arch)
 	  || target_architecture_hook (arch));
 }
 
-enum set_arch
-{
-  set_arch_auto, set_arch_manual
-};
+enum set_arch { set_arch_auto, set_arch_manual };
 
-static void set_arch PARAMS ((const struct bfd_arch_info * arch, enum set_arch type));
+static void set_arch PARAMS ((const struct bfd_arch_info *arch, enum set_arch type));
 static void
 set_arch (arch, type)
      const struct bfd_arch_info *arch;
@@ -3199,7 +3196,7 @@ generic_register_convertible_not (num)
 {
   return 0;
 }
-
+  
 /* Disassembler */
 
 /* Pointer to the target-dependent disassembly function.  */
@@ -3259,7 +3256,7 @@ _initialize_gdbarch ()
   add_cmd ("architecture", class_support, info_architecture,
 	   "List supported target architectures", &infolist);
 
-  INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype) fprintf_filtered);
+  INIT_DISASSEMBLE_INFO_NO_ARCH (tm_print_insn_info, gdb_stdout, (fprintf_ftype)fprintf_filtered);
   tm_print_insn_info.flavour = bfd_target_unknown_flavour;
   tm_print_insn_info.read_memory_func = dis_asm_read_memory;
   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
@@ -3268,7 +3265,7 @@ _initialize_gdbarch ()
   add_show_from_set (add_set_cmd ("archdebug",
 				  class_maintenance,
 				  var_zinteger,
-				  (char *) &gdbarch_debug,
+				  (char *)&gdbarch_debug,
 				  "Set architecture debugging.\n\
 When non-zero, architecture debugging is enabled.", &setlist),
 		     &showlist);
diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 65ff69d..7daabca 100644
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -1,4 +1,4 @@
-/* Architecture commands for GDB, the GNU debugger.
+/* Dynamic architecture support for GDB, the GNU debugger.
    Copyright 1998-1999, Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -18,6 +18,8 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
+/* *INDENT-OFF* */ /* typedef (f)();'' confuses indent */
+
 #ifndef GDBARCH_H
 #define GDBARCH_H
 
@@ -69,7 +71,7 @@ extern struct gdbarch *current_gdbarch;
 
 /* The following are pre-initialized by GDBARCH. */
 
-extern const struct bfd_arch_info *gdbarch_bfd_arch_info PARAMS ((struct gdbarch * gdbarch));
+extern const struct bfd_arch_info * gdbarch_bfd_arch_info PARAMS ((struct gdbarch *gdbarch));
 /* set_gdbarch_bfd_arch_info() - not applicable - pre-initialized. */
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_ARCHITECTURE)
@@ -77,7 +79,7 @@ extern const struct bfd_arch_info *gdbarch_bfd_arch_info PARAMS ((struct gdbarch
 #endif
 #endif
 
-extern int gdbarch_byte_order PARAMS ((struct gdbarch * gdbarch));
+extern int gdbarch_byte_order PARAMS ((struct gdbarch *gdbarch));
 /* set_gdbarch_byte_order() - not applicable - pre-initialized. */
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_BYTE_ORDER)
@@ -88,687 +90,686 @@ extern int gdbarch_byte_order PARAMS ((struct gdbarch * gdbarch));
 
 /* The following are initialized by the target dependant code. */
 
-extern int gdbarch_ptr_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_ptr_bit PARAMS ((struct gdbarch * gdbarch, int ptr_bit));
+extern int gdbarch_ptr_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_ptr_bit PARAMS ((struct gdbarch *gdbarch, int ptr_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_PTR_BIT)
 #define TARGET_PTR_BIT (gdbarch_ptr_bit (current_gdbarch))
 #endif
 #endif
 
-extern int gdbarch_short_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_short_bit PARAMS ((struct gdbarch * gdbarch, int short_bit));
+extern int gdbarch_short_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_short_bit PARAMS ((struct gdbarch *gdbarch, int short_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_SHORT_BIT)
 #define TARGET_SHORT_BIT (gdbarch_short_bit (current_gdbarch))
 #endif
 #endif
 
-extern int gdbarch_int_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_int_bit PARAMS ((struct gdbarch * gdbarch, int int_bit));
+extern int gdbarch_int_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_int_bit PARAMS ((struct gdbarch *gdbarch, int int_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_INT_BIT)
 #define TARGET_INT_BIT (gdbarch_int_bit (current_gdbarch))
 #endif
 #endif
 
-extern int gdbarch_long_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_long_bit PARAMS ((struct gdbarch * gdbarch, int long_bit));
+extern int gdbarch_long_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_long_bit PARAMS ((struct gdbarch *gdbarch, int long_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_BIT)
 #define TARGET_LONG_BIT (gdbarch_long_bit (current_gdbarch))
 #endif
 #endif
 
-extern int gdbarch_long_long_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_long_long_bit PARAMS ((struct gdbarch * gdbarch, int long_long_bit));
+extern int gdbarch_long_long_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_long_long_bit PARAMS ((struct gdbarch *gdbarch, int long_long_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_LONG_BIT)
 #define TARGET_LONG_LONG_BIT (gdbarch_long_long_bit (current_gdbarch))
 #endif
 #endif
 
-extern int gdbarch_float_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_float_bit PARAMS ((struct gdbarch * gdbarch, int float_bit));
+extern int gdbarch_float_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_float_bit PARAMS ((struct gdbarch *gdbarch, int float_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_FLOAT_BIT)
 #define TARGET_FLOAT_BIT (gdbarch_float_bit (current_gdbarch))
 #endif
 #endif
 
-extern int gdbarch_double_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_double_bit PARAMS ((struct gdbarch * gdbarch, int double_bit));
+extern int gdbarch_double_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_double_bit PARAMS ((struct gdbarch *gdbarch, int double_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_DOUBLE_BIT)
 #define TARGET_DOUBLE_BIT (gdbarch_double_bit (current_gdbarch))
 #endif
 #endif
 
-extern int gdbarch_long_double_bit PARAMS ((struct gdbarch * gdbarch));
-extern void set_gdbarch_long_double_bit PARAMS ((struct gdbarch * gdbarch, int long_double_bit));
+extern int gdbarch_long_double_bit PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_long_double_bit PARAMS ((struct gdbarch *gdbarch, int long_double_bit));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_LONG_DOUBLE_BIT)
 #define TARGET_LONG_DOUBLE_BIT (gdbarch_long_double_bit (current_gdbarch))
 #endif
 #endif
 
-typedef
-CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
-     extern CORE_ADDR gdbarch_read_pc PARAMS ((struct gdbarch * gdbarch, int pid));
-     extern void set_gdbarch_read_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_read_pc_ftype * read_pc));
+typedef CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
+extern CORE_ADDR gdbarch_read_pc PARAMS ((struct gdbarch *gdbarch, int pid));
+extern void set_gdbarch_read_pc PARAMS ((struct gdbarch *gdbarch, gdbarch_read_pc_ftype *read_pc));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_PC)
 #define TARGET_READ_PC(pid) (gdbarch_read_pc (current_gdbarch, pid))
 #endif
 #endif
 
-     typedef void (gdbarch_write_pc_ftype) PARAMS ((CORE_ADDR val, int pid));
-     extern void gdbarch_write_pc PARAMS ((struct gdbarch * gdbarch, CORE_ADDR val, int pid));
-     extern void set_gdbarch_write_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_write_pc_ftype * write_pc));
+typedef void (gdbarch_write_pc_ftype) PARAMS ((CORE_ADDR val, int pid));
+extern void gdbarch_write_pc PARAMS ((struct gdbarch *gdbarch, CORE_ADDR val, int pid));
+extern void set_gdbarch_write_pc PARAMS ((struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_PC)
 #define TARGET_WRITE_PC(val, pid) (gdbarch_write_pc (current_gdbarch, val, pid))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_read_fp_ftype) PARAMS ((void));
-     extern CORE_ADDR gdbarch_read_fp PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_read_fp PARAMS ((struct gdbarch * gdbarch, gdbarch_read_fp_ftype * read_fp));
+typedef CORE_ADDR (gdbarch_read_fp_ftype) PARAMS ((void));
+extern CORE_ADDR gdbarch_read_fp PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_read_fp PARAMS ((struct gdbarch *gdbarch, gdbarch_read_fp_ftype *read_fp));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_FP)
 #define TARGET_READ_FP() (gdbarch_read_fp (current_gdbarch))
 #endif
 #endif
 
-     typedef void (gdbarch_write_fp_ftype) PARAMS ((CORE_ADDR val));
-     extern void gdbarch_write_fp PARAMS ((struct gdbarch * gdbarch, CORE_ADDR val));
-     extern void set_gdbarch_write_fp PARAMS ((struct gdbarch * gdbarch, gdbarch_write_fp_ftype * write_fp));
+typedef void (gdbarch_write_fp_ftype) PARAMS ((CORE_ADDR val));
+extern void gdbarch_write_fp PARAMS ((struct gdbarch *gdbarch, CORE_ADDR val));
+extern void set_gdbarch_write_fp PARAMS ((struct gdbarch *gdbarch, gdbarch_write_fp_ftype *write_fp));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_FP)
 #define TARGET_WRITE_FP(val) (gdbarch_write_fp (current_gdbarch, val))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_read_sp_ftype) PARAMS ((void));
-     extern CORE_ADDR gdbarch_read_sp PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_read_sp PARAMS ((struct gdbarch * gdbarch, gdbarch_read_sp_ftype * read_sp));
+typedef CORE_ADDR (gdbarch_read_sp_ftype) PARAMS ((void));
+extern CORE_ADDR gdbarch_read_sp PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_read_sp PARAMS ((struct gdbarch *gdbarch, gdbarch_read_sp_ftype *read_sp));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_READ_SP)
 #define TARGET_READ_SP() (gdbarch_read_sp (current_gdbarch))
 #endif
 #endif
 
-     typedef void (gdbarch_write_sp_ftype) PARAMS ((CORE_ADDR val));
-     extern void gdbarch_write_sp PARAMS ((struct gdbarch * gdbarch, CORE_ADDR val));
-     extern void set_gdbarch_write_sp PARAMS ((struct gdbarch * gdbarch, gdbarch_write_sp_ftype * write_sp));
+typedef void (gdbarch_write_sp_ftype) PARAMS ((CORE_ADDR val));
+extern void gdbarch_write_sp PARAMS ((struct gdbarch *gdbarch, CORE_ADDR val));
+extern void set_gdbarch_write_sp PARAMS ((struct gdbarch *gdbarch, gdbarch_write_sp_ftype *write_sp));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (TARGET_WRITE_SP)
 #define TARGET_WRITE_SP(val) (gdbarch_write_sp (current_gdbarch, val))
 #endif
 #endif
 
-     extern int gdbarch_num_regs PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_num_regs PARAMS ((struct gdbarch * gdbarch, int num_regs));
+extern int gdbarch_num_regs PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_num_regs PARAMS ((struct gdbarch *gdbarch, int num_regs));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (NUM_REGS)
 #define NUM_REGS (gdbarch_num_regs (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_sp_regnum PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_sp_regnum PARAMS ((struct gdbarch * gdbarch, int sp_regnum));
+extern int gdbarch_sp_regnum PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_sp_regnum PARAMS ((struct gdbarch *gdbarch, int sp_regnum));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (SP_REGNUM)
 #define SP_REGNUM (gdbarch_sp_regnum (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_fp_regnum PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_fp_regnum PARAMS ((struct gdbarch * gdbarch, int fp_regnum));
+extern int gdbarch_fp_regnum PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_fp_regnum PARAMS ((struct gdbarch *gdbarch, int fp_regnum));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FP_REGNUM)
 #define FP_REGNUM (gdbarch_fp_regnum (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_pc_regnum PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_pc_regnum PARAMS ((struct gdbarch * gdbarch, int pc_regnum));
+extern int gdbarch_pc_regnum PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_pc_regnum PARAMS ((struct gdbarch *gdbarch, int pc_regnum));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (PC_REGNUM)
 #define PC_REGNUM (gdbarch_pc_regnum (current_gdbarch))
 #endif
 #endif
 
-     typedef char *(gdbarch_register_name_ftype) PARAMS ((int regnr));
-     extern char *gdbarch_register_name PARAMS ((struct gdbarch * gdbarch, int regnr));
-     extern void set_gdbarch_register_name PARAMS ((struct gdbarch * gdbarch, gdbarch_register_name_ftype * register_name));
+typedef char * (gdbarch_register_name_ftype) PARAMS ((int regnr));
+extern char * gdbarch_register_name PARAMS ((struct gdbarch *gdbarch, int regnr));
+extern void set_gdbarch_register_name PARAMS ((struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_NAME)
 #define REGISTER_NAME(regnr) (gdbarch_register_name (current_gdbarch, regnr))
 #endif
 #endif
 
-     extern int gdbarch_register_size PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_register_size PARAMS ((struct gdbarch * gdbarch, int register_size));
+extern int gdbarch_register_size PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_register_size PARAMS ((struct gdbarch *gdbarch, int register_size));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_SIZE)
 #define REGISTER_SIZE (gdbarch_register_size (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_register_bytes PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_register_bytes PARAMS ((struct gdbarch * gdbarch, int register_bytes));
+extern int gdbarch_register_bytes PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_register_bytes PARAMS ((struct gdbarch *gdbarch, int register_bytes));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_BYTES)
 #define REGISTER_BYTES (gdbarch_register_bytes (current_gdbarch))
 #endif
 #endif
 
-     typedef int (gdbarch_register_byte_ftype) PARAMS ((int reg_nr));
-     extern int gdbarch_register_byte PARAMS ((struct gdbarch * gdbarch, int reg_nr));
-     extern void set_gdbarch_register_byte PARAMS ((struct gdbarch * gdbarch, gdbarch_register_byte_ftype * register_byte));
+typedef int (gdbarch_register_byte_ftype) PARAMS ((int reg_nr));
+extern int gdbarch_register_byte PARAMS ((struct gdbarch *gdbarch, int reg_nr));
+extern void set_gdbarch_register_byte PARAMS ((struct gdbarch *gdbarch, gdbarch_register_byte_ftype *register_byte));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_BYTE)
 #define REGISTER_BYTE(reg_nr) (gdbarch_register_byte (current_gdbarch, reg_nr))
 #endif
 #endif
 
-     typedef int (gdbarch_register_raw_size_ftype) PARAMS ((int reg_nr));
-     extern int gdbarch_register_raw_size PARAMS ((struct gdbarch * gdbarch, int reg_nr));
-     extern void set_gdbarch_register_raw_size PARAMS ((struct gdbarch * gdbarch, gdbarch_register_raw_size_ftype * register_raw_size));
+typedef int (gdbarch_register_raw_size_ftype) PARAMS ((int reg_nr));
+extern int gdbarch_register_raw_size PARAMS ((struct gdbarch *gdbarch, int reg_nr));
+extern void set_gdbarch_register_raw_size PARAMS ((struct gdbarch *gdbarch, gdbarch_register_raw_size_ftype *register_raw_size));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_RAW_SIZE)
 #define REGISTER_RAW_SIZE(reg_nr) (gdbarch_register_raw_size (current_gdbarch, reg_nr))
 #endif
 #endif
 
-     extern int gdbarch_max_register_raw_size PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_max_register_raw_size PARAMS ((struct gdbarch * gdbarch, int max_register_raw_size));
+extern int gdbarch_max_register_raw_size PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_max_register_raw_size PARAMS ((struct gdbarch *gdbarch, int max_register_raw_size));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (MAX_REGISTER_RAW_SIZE)
 #define MAX_REGISTER_RAW_SIZE (gdbarch_max_register_raw_size (current_gdbarch))
 #endif
 #endif
 
-     typedef int (gdbarch_register_virtual_size_ftype) PARAMS ((int reg_nr));
-     extern int gdbarch_register_virtual_size PARAMS ((struct gdbarch * gdbarch, int reg_nr));
-     extern void set_gdbarch_register_virtual_size PARAMS ((struct gdbarch * gdbarch, gdbarch_register_virtual_size_ftype * register_virtual_size));
+typedef int (gdbarch_register_virtual_size_ftype) PARAMS ((int reg_nr));
+extern int gdbarch_register_virtual_size PARAMS ((struct gdbarch *gdbarch, int reg_nr));
+extern void set_gdbarch_register_virtual_size PARAMS ((struct gdbarch *gdbarch, gdbarch_register_virtual_size_ftype *register_virtual_size));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_VIRTUAL_SIZE)
 #define REGISTER_VIRTUAL_SIZE(reg_nr) (gdbarch_register_virtual_size (current_gdbarch, reg_nr))
 #endif
 #endif
 
-     extern int gdbarch_max_register_virtual_size PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_max_register_virtual_size PARAMS ((struct gdbarch * gdbarch, int max_register_virtual_size));
+extern int gdbarch_max_register_virtual_size PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_max_register_virtual_size PARAMS ((struct gdbarch *gdbarch, int max_register_virtual_size));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (MAX_REGISTER_VIRTUAL_SIZE)
 #define MAX_REGISTER_VIRTUAL_SIZE (gdbarch_max_register_virtual_size (current_gdbarch))
 #endif
 #endif
 
-     typedef struct type *(gdbarch_register_virtual_type_ftype) PARAMS ((int reg_nr));
-     extern struct type *gdbarch_register_virtual_type PARAMS ((struct gdbarch * gdbarch, int reg_nr));
-     extern void set_gdbarch_register_virtual_type PARAMS ((struct gdbarch * gdbarch, gdbarch_register_virtual_type_ftype * register_virtual_type));
+typedef struct type * (gdbarch_register_virtual_type_ftype) PARAMS ((int reg_nr));
+extern struct type * gdbarch_register_virtual_type PARAMS ((struct gdbarch *gdbarch, int reg_nr));
+extern void set_gdbarch_register_virtual_type PARAMS ((struct gdbarch *gdbarch, gdbarch_register_virtual_type_ftype *register_virtual_type));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_VIRTUAL_TYPE)
 #define REGISTER_VIRTUAL_TYPE(reg_nr) (gdbarch_register_virtual_type (current_gdbarch, reg_nr))
 #endif
 #endif
 
-     extern int gdbarch_use_generic_dummy_frames PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_use_generic_dummy_frames PARAMS ((struct gdbarch * gdbarch, int use_generic_dummy_frames));
+extern int gdbarch_use_generic_dummy_frames PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_use_generic_dummy_frames PARAMS ((struct gdbarch *gdbarch, int use_generic_dummy_frames));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (USE_GENERIC_DUMMY_FRAMES)
 #define USE_GENERIC_DUMMY_FRAMES (gdbarch_use_generic_dummy_frames (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_call_dummy_location PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_location PARAMS ((struct gdbarch * gdbarch, int call_dummy_location));
+extern int gdbarch_call_dummy_location PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_location PARAMS ((struct gdbarch *gdbarch, int call_dummy_location));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_LOCATION)
 #define CALL_DUMMY_LOCATION (gdbarch_call_dummy_location (current_gdbarch))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_call_dummy_address_ftype) PARAMS ((void));
-     extern CORE_ADDR gdbarch_call_dummy_address PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_address PARAMS ((struct gdbarch * gdbarch, gdbarch_call_dummy_address_ftype * call_dummy_address));
+typedef CORE_ADDR (gdbarch_call_dummy_address_ftype) PARAMS ((void));
+extern CORE_ADDR gdbarch_call_dummy_address PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_address PARAMS ((struct gdbarch *gdbarch, gdbarch_call_dummy_address_ftype *call_dummy_address));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_ADDRESS)
 #define CALL_DUMMY_ADDRESS() (gdbarch_call_dummy_address (current_gdbarch))
 #endif
 #endif
 
-     extern CORE_ADDR gdbarch_call_dummy_start_offset PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_start_offset PARAMS ((struct gdbarch * gdbarch, CORE_ADDR call_dummy_start_offset));
+extern CORE_ADDR gdbarch_call_dummy_start_offset PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_start_offset PARAMS ((struct gdbarch *gdbarch, CORE_ADDR call_dummy_start_offset));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_START_OFFSET)
 #define CALL_DUMMY_START_OFFSET (gdbarch_call_dummy_start_offset (current_gdbarch))
 #endif
 #endif
 
-     extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_breakpoint_offset PARAMS ((struct gdbarch * gdbarch, CORE_ADDR call_dummy_breakpoint_offset));
+extern CORE_ADDR gdbarch_call_dummy_breakpoint_offset PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_breakpoint_offset PARAMS ((struct gdbarch *gdbarch, CORE_ADDR call_dummy_breakpoint_offset));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
 #define CALL_DUMMY_BREAKPOINT_OFFSET (gdbarch_call_dummy_breakpoint_offset (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_call_dummy_breakpoint_offset_p PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_breakpoint_offset_p PARAMS ((struct gdbarch * gdbarch, int call_dummy_breakpoint_offset_p));
+extern int gdbarch_call_dummy_breakpoint_offset_p PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_breakpoint_offset_p PARAMS ((struct gdbarch *gdbarch, int call_dummy_breakpoint_offset_p));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_BREAKPOINT_OFFSET_P)
 #define CALL_DUMMY_BREAKPOINT_OFFSET_P (gdbarch_call_dummy_breakpoint_offset_p (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_call_dummy_length PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_length PARAMS ((struct gdbarch * gdbarch, int call_dummy_length));
+extern int gdbarch_call_dummy_length PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_length PARAMS ((struct gdbarch *gdbarch, int call_dummy_length));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_LENGTH)
 #define CALL_DUMMY_LENGTH (gdbarch_call_dummy_length (current_gdbarch))
 #endif
 #endif
 
-     typedef int (gdbarch_pc_in_call_dummy_ftype) PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
-     extern int gdbarch_pc_in_call_dummy PARAMS ((struct gdbarch * gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
-     extern void set_gdbarch_pc_in_call_dummy PARAMS ((struct gdbarch * gdbarch, gdbarch_pc_in_call_dummy_ftype * pc_in_call_dummy));
+typedef int (gdbarch_pc_in_call_dummy_ftype) PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
+extern int gdbarch_pc_in_call_dummy PARAMS ((struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
+extern void set_gdbarch_pc_in_call_dummy PARAMS ((struct gdbarch *gdbarch, gdbarch_pc_in_call_dummy_ftype *pc_in_call_dummy));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (PC_IN_CALL_DUMMY)
 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) (gdbarch_pc_in_call_dummy (current_gdbarch, pc, sp, frame_address))
 #endif
 #endif
 
-     extern int gdbarch_call_dummy_p PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_p PARAMS ((struct gdbarch * gdbarch, int call_dummy_p));
+extern int gdbarch_call_dummy_p PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_p PARAMS ((struct gdbarch *gdbarch, int call_dummy_p));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_P)
 #define CALL_DUMMY_P (gdbarch_call_dummy_p (current_gdbarch))
 #endif
 #endif
 
-     extern LONGEST *gdbarch_call_dummy_words PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_words PARAMS ((struct gdbarch * gdbarch, LONGEST * call_dummy_words));
+extern LONGEST * gdbarch_call_dummy_words PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_words PARAMS ((struct gdbarch *gdbarch, LONGEST * call_dummy_words));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_WORDS)
 #define CALL_DUMMY_WORDS (gdbarch_call_dummy_words (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_sizeof_call_dummy_words PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_sizeof_call_dummy_words PARAMS ((struct gdbarch * gdbarch, int sizeof_call_dummy_words));
+extern int gdbarch_sizeof_call_dummy_words PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_sizeof_call_dummy_words PARAMS ((struct gdbarch *gdbarch, int sizeof_call_dummy_words));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (SIZEOF_CALL_DUMMY_WORDS)
 #define SIZEOF_CALL_DUMMY_WORDS (gdbarch_sizeof_call_dummy_words (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_call_dummy_stack_adjust_p PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_stack_adjust_p PARAMS ((struct gdbarch * gdbarch, int call_dummy_stack_adjust_p));
+extern int gdbarch_call_dummy_stack_adjust_p PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_stack_adjust_p PARAMS ((struct gdbarch *gdbarch, int call_dummy_stack_adjust_p));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_STACK_ADJUST_P)
 #define CALL_DUMMY_STACK_ADJUST_P (gdbarch_call_dummy_stack_adjust_p (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_call_dummy_stack_adjust PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_call_dummy_stack_adjust PARAMS ((struct gdbarch * gdbarch, int call_dummy_stack_adjust));
+extern int gdbarch_call_dummy_stack_adjust PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_call_dummy_stack_adjust PARAMS ((struct gdbarch *gdbarch, int call_dummy_stack_adjust));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (CALL_DUMMY_STACK_ADJUST)
 #define CALL_DUMMY_STACK_ADJUST (gdbarch_call_dummy_stack_adjust (current_gdbarch))
 #endif
 #endif
 
-     typedef void (gdbarch_fix_call_dummy_ftype) PARAMS ((char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value ** args, struct type * type, int gcc_p));
-     extern void gdbarch_fix_call_dummy PARAMS ((struct gdbarch * gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value ** args, struct type * type, int gcc_p));
-     extern void set_gdbarch_fix_call_dummy PARAMS ((struct gdbarch * gdbarch, gdbarch_fix_call_dummy_ftype * fix_call_dummy));
+typedef void (gdbarch_fix_call_dummy_ftype) PARAMS ((char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p));
+extern void gdbarch_fix_call_dummy PARAMS ((struct gdbarch *gdbarch, char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs, struct value **args, struct type *type, int gcc_p));
+extern void set_gdbarch_fix_call_dummy PARAMS ((struct gdbarch *gdbarch, gdbarch_fix_call_dummy_ftype *fix_call_dummy));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FIX_CALL_DUMMY)
 #define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p) (gdbarch_fix_call_dummy (current_gdbarch, dummy, pc, fun, nargs, args, type, gcc_p))
 #endif
 #endif
 
-     extern int gdbarch_believe_pcc_promotion PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_believe_pcc_promotion PARAMS ((struct gdbarch * gdbarch, int believe_pcc_promotion));
+extern int gdbarch_believe_pcc_promotion PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_believe_pcc_promotion PARAMS ((struct gdbarch *gdbarch, int believe_pcc_promotion));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (BELIEVE_PCC_PROMOTION)
 #define BELIEVE_PCC_PROMOTION (gdbarch_believe_pcc_promotion (current_gdbarch))
 #endif
 #endif
 
-     extern int gdbarch_believe_pcc_promotion_type PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_believe_pcc_promotion_type PARAMS ((struct gdbarch * gdbarch, int believe_pcc_promotion_type));
+extern int gdbarch_believe_pcc_promotion_type PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_believe_pcc_promotion_type PARAMS ((struct gdbarch *gdbarch, int believe_pcc_promotion_type));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (BELIEVE_PCC_PROMOTION_TYPE)
 #define BELIEVE_PCC_PROMOTION_TYPE (gdbarch_believe_pcc_promotion_type (current_gdbarch))
 #endif
 #endif
 
-     typedef void (gdbarch_get_saved_register_ftype) PARAMS ((char *raw_buffer, int *optimized, CORE_ADDR * addrp, struct frame_info * frame, int regnum, enum lval_type * lval));
-     extern void gdbarch_get_saved_register PARAMS ((struct gdbarch * gdbarch, char *raw_buffer, int *optimized, CORE_ADDR * addrp, struct frame_info * frame, int regnum, enum lval_type * lval));
-     extern void set_gdbarch_get_saved_register PARAMS ((struct gdbarch * gdbarch, gdbarch_get_saved_register_ftype * get_saved_register));
+typedef void (gdbarch_get_saved_register_ftype) PARAMS ((char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval));
+extern void gdbarch_get_saved_register PARAMS ((struct gdbarch *gdbarch, char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lval));
+extern void set_gdbarch_get_saved_register PARAMS ((struct gdbarch *gdbarch, gdbarch_get_saved_register_ftype *get_saved_register));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (GET_SAVED_REGISTER)
 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) (gdbarch_get_saved_register (current_gdbarch, raw_buffer, optimized, addrp, frame, regnum, lval))
 #endif
 #endif
 
-     typedef int (gdbarch_register_convertible_ftype) PARAMS ((int nr));
-     extern int gdbarch_register_convertible PARAMS ((struct gdbarch * gdbarch, int nr));
-     extern void set_gdbarch_register_convertible PARAMS ((struct gdbarch * gdbarch, gdbarch_register_convertible_ftype * register_convertible));
+typedef int (gdbarch_register_convertible_ftype) PARAMS ((int nr));
+extern int gdbarch_register_convertible PARAMS ((struct gdbarch *gdbarch, int nr));
+extern void set_gdbarch_register_convertible PARAMS ((struct gdbarch *gdbarch, gdbarch_register_convertible_ftype *register_convertible));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERTIBLE)
 #define REGISTER_CONVERTIBLE(nr) (gdbarch_register_convertible (current_gdbarch, nr))
 #endif
 #endif
 
-     typedef void (gdbarch_register_convert_to_virtual_ftype) PARAMS ((int regnum, struct type * type, char *from, char *to));
-     extern void gdbarch_register_convert_to_virtual PARAMS ((struct gdbarch * gdbarch, int regnum, struct type * type, char *from, char *to));
-     extern void set_gdbarch_register_convert_to_virtual PARAMS ((struct gdbarch * gdbarch, gdbarch_register_convert_to_virtual_ftype * register_convert_to_virtual));
+typedef void (gdbarch_register_convert_to_virtual_ftype) PARAMS ((int regnum, struct type *type, char *from, char *to));
+extern void gdbarch_register_convert_to_virtual PARAMS ((struct gdbarch *gdbarch, int regnum, struct type *type, char *from, char *to));
+extern void set_gdbarch_register_convert_to_virtual PARAMS ((struct gdbarch *gdbarch, gdbarch_register_convert_to_virtual_ftype *register_convert_to_virtual));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERT_TO_VIRTUAL)
 #define REGISTER_CONVERT_TO_VIRTUAL(regnum, type, from, to) (gdbarch_register_convert_to_virtual (current_gdbarch, regnum, type, from, to))
 #endif
 #endif
 
-     typedef void (gdbarch_register_convert_to_raw_ftype) PARAMS ((struct type * type, int regnum, char *from, char *to));
-     extern void gdbarch_register_convert_to_raw PARAMS ((struct gdbarch * gdbarch, struct type * type, int regnum, char *from, char *to));
-     extern void set_gdbarch_register_convert_to_raw PARAMS ((struct gdbarch * gdbarch, gdbarch_register_convert_to_raw_ftype * register_convert_to_raw));
+typedef void (gdbarch_register_convert_to_raw_ftype) PARAMS ((struct type *type, int regnum, char *from, char *to));
+extern void gdbarch_register_convert_to_raw PARAMS ((struct gdbarch *gdbarch, struct type *type, int regnum, char *from, char *to));
+extern void set_gdbarch_register_convert_to_raw PARAMS ((struct gdbarch *gdbarch, gdbarch_register_convert_to_raw_ftype *register_convert_to_raw));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REGISTER_CONVERT_TO_RAW)
 #define REGISTER_CONVERT_TO_RAW(type, regnum, from, to) (gdbarch_register_convert_to_raw (current_gdbarch, type, regnum, from, to))
 #endif
 #endif
 
-     typedef void (gdbarch_extract_return_value_ftype) PARAMS ((struct type * type, char *regbuf, char *valbuf));
-     extern void gdbarch_extract_return_value PARAMS ((struct gdbarch * gdbarch, struct type * type, char *regbuf, char *valbuf));
-     extern void set_gdbarch_extract_return_value PARAMS ((struct gdbarch * gdbarch, gdbarch_extract_return_value_ftype * extract_return_value));
+typedef void (gdbarch_extract_return_value_ftype) PARAMS ((struct type *type, char *regbuf, char *valbuf));
+extern void gdbarch_extract_return_value PARAMS ((struct gdbarch *gdbarch, struct type *type, char *regbuf, char *valbuf));
+extern void set_gdbarch_extract_return_value PARAMS ((struct gdbarch *gdbarch, gdbarch_extract_return_value_ftype *extract_return_value));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (EXTRACT_RETURN_VALUE)
 #define EXTRACT_RETURN_VALUE(type, regbuf, valbuf) (gdbarch_extract_return_value (current_gdbarch, type, regbuf, valbuf))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_push_arguments_ftype) PARAMS ((int nargs, struct value ** args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr));
-     extern CORE_ADDR gdbarch_push_arguments PARAMS ((struct gdbarch * gdbarch, int nargs, struct value ** args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr));
-     extern void set_gdbarch_push_arguments PARAMS ((struct gdbarch * gdbarch, gdbarch_push_arguments_ftype * push_arguments));
+typedef CORE_ADDR (gdbarch_push_arguments_ftype) PARAMS ((int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr));
+extern CORE_ADDR gdbarch_push_arguments PARAMS ((struct gdbarch *gdbarch, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr));
+extern void set_gdbarch_push_arguments PARAMS ((struct gdbarch *gdbarch, gdbarch_push_arguments_ftype *push_arguments));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (PUSH_ARGUMENTS)
 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) (gdbarch_push_arguments (current_gdbarch, nargs, args, sp, struct_return, struct_addr))
 #endif
 #endif
 
-     typedef void (gdbarch_push_dummy_frame_ftype) PARAMS ((void));
-     extern void gdbarch_push_dummy_frame PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_push_dummy_frame PARAMS ((struct gdbarch * gdbarch, gdbarch_push_dummy_frame_ftype * push_dummy_frame));
+typedef void (gdbarch_push_dummy_frame_ftype) PARAMS ((void));
+extern void gdbarch_push_dummy_frame PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_push_dummy_frame PARAMS ((struct gdbarch *gdbarch, gdbarch_push_dummy_frame_ftype *push_dummy_frame));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (PUSH_DUMMY_FRAME)
 #define PUSH_DUMMY_FRAME (gdbarch_push_dummy_frame (current_gdbarch))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_push_return_address_ftype) PARAMS ((CORE_ADDR pc, CORE_ADDR sp));
-     extern CORE_ADDR gdbarch_push_return_address PARAMS ((struct gdbarch * gdbarch, CORE_ADDR pc, CORE_ADDR sp));
-     extern void set_gdbarch_push_return_address PARAMS ((struct gdbarch * gdbarch, gdbarch_push_return_address_ftype * push_return_address));
+typedef CORE_ADDR (gdbarch_push_return_address_ftype) PARAMS ((CORE_ADDR pc, CORE_ADDR sp));
+extern CORE_ADDR gdbarch_push_return_address PARAMS ((struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR sp));
+extern void set_gdbarch_push_return_address PARAMS ((struct gdbarch *gdbarch, gdbarch_push_return_address_ftype *push_return_address));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (PUSH_RETURN_ADDRESS)
 #define PUSH_RETURN_ADDRESS(pc, sp) (gdbarch_push_return_address (current_gdbarch, pc, sp))
 #endif
 #endif
 
-     typedef void (gdbarch_pop_frame_ftype) PARAMS ((void));
-     extern void gdbarch_pop_frame PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_pop_frame PARAMS ((struct gdbarch * gdbarch, gdbarch_pop_frame_ftype * pop_frame));
+typedef void (gdbarch_pop_frame_ftype) PARAMS ((void));
+extern void gdbarch_pop_frame PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_pop_frame PARAMS ((struct gdbarch *gdbarch, gdbarch_pop_frame_ftype *pop_frame));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (POP_FRAME)
 #define POP_FRAME (gdbarch_pop_frame (current_gdbarch))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_d10v_make_daddr_ftype) PARAMS ((CORE_ADDR x));
-     extern CORE_ADDR gdbarch_d10v_make_daddr PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
-     extern void set_gdbarch_d10v_make_daddr PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_make_daddr_ftype * d10v_make_daddr));
+typedef CORE_ADDR (gdbarch_d10v_make_daddr_ftype) PARAMS ((CORE_ADDR x));
+extern CORE_ADDR gdbarch_d10v_make_daddr PARAMS ((struct gdbarch *gdbarch, CORE_ADDR x));
+extern void set_gdbarch_d10v_make_daddr PARAMS ((struct gdbarch *gdbarch, gdbarch_d10v_make_daddr_ftype *d10v_make_daddr));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_MAKE_DADDR)
 #define D10V_MAKE_DADDR(x) (gdbarch_d10v_make_daddr (current_gdbarch, x))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_d10v_make_iaddr_ftype) PARAMS ((CORE_ADDR x));
-     extern CORE_ADDR gdbarch_d10v_make_iaddr PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
-     extern void set_gdbarch_d10v_make_iaddr PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_make_iaddr_ftype * d10v_make_iaddr));
+typedef CORE_ADDR (gdbarch_d10v_make_iaddr_ftype) PARAMS ((CORE_ADDR x));
+extern CORE_ADDR gdbarch_d10v_make_iaddr PARAMS ((struct gdbarch *gdbarch, CORE_ADDR x));
+extern void set_gdbarch_d10v_make_iaddr PARAMS ((struct gdbarch *gdbarch, gdbarch_d10v_make_iaddr_ftype *d10v_make_iaddr));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_MAKE_IADDR)
 #define D10V_MAKE_IADDR(x) (gdbarch_d10v_make_iaddr (current_gdbarch, x))
 #endif
 #endif
 
-     typedef int (gdbarch_d10v_daddr_p_ftype) PARAMS ((CORE_ADDR x));
-     extern int gdbarch_d10v_daddr_p PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
-     extern void set_gdbarch_d10v_daddr_p PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_daddr_p_ftype * d10v_daddr_p));
+typedef int (gdbarch_d10v_daddr_p_ftype) PARAMS ((CORE_ADDR x));
+extern int gdbarch_d10v_daddr_p PARAMS ((struct gdbarch *gdbarch, CORE_ADDR x));
+extern void set_gdbarch_d10v_daddr_p PARAMS ((struct gdbarch *gdbarch, gdbarch_d10v_daddr_p_ftype *d10v_daddr_p));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_DADDR_P)
 #define D10V_DADDR_P(x) (gdbarch_d10v_daddr_p (current_gdbarch, x))
 #endif
 #endif
 
-     typedef int (gdbarch_d10v_iaddr_p_ftype) PARAMS ((CORE_ADDR x));
-     extern int gdbarch_d10v_iaddr_p PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
-     extern void set_gdbarch_d10v_iaddr_p PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_iaddr_p_ftype * d10v_iaddr_p));
+typedef int (gdbarch_d10v_iaddr_p_ftype) PARAMS ((CORE_ADDR x));
+extern int gdbarch_d10v_iaddr_p PARAMS ((struct gdbarch *gdbarch, CORE_ADDR x));
+extern void set_gdbarch_d10v_iaddr_p PARAMS ((struct gdbarch *gdbarch, gdbarch_d10v_iaddr_p_ftype *d10v_iaddr_p));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_IADDR_P)
 #define D10V_IADDR_P(x) (gdbarch_d10v_iaddr_p (current_gdbarch, x))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_d10v_convert_daddr_to_raw_ftype) PARAMS ((CORE_ADDR x));
-     extern CORE_ADDR gdbarch_d10v_convert_daddr_to_raw PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
-     extern void set_gdbarch_d10v_convert_daddr_to_raw PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_convert_daddr_to_raw_ftype * d10v_convert_daddr_to_raw));
+typedef CORE_ADDR (gdbarch_d10v_convert_daddr_to_raw_ftype) PARAMS ((CORE_ADDR x));
+extern CORE_ADDR gdbarch_d10v_convert_daddr_to_raw PARAMS ((struct gdbarch *gdbarch, CORE_ADDR x));
+extern void set_gdbarch_d10v_convert_daddr_to_raw PARAMS ((struct gdbarch *gdbarch, gdbarch_d10v_convert_daddr_to_raw_ftype *d10v_convert_daddr_to_raw));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_CONVERT_DADDR_TO_RAW)
 #define D10V_CONVERT_DADDR_TO_RAW(x) (gdbarch_d10v_convert_daddr_to_raw (current_gdbarch, x))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_d10v_convert_iaddr_to_raw_ftype) PARAMS ((CORE_ADDR x));
-     extern CORE_ADDR gdbarch_d10v_convert_iaddr_to_raw PARAMS ((struct gdbarch * gdbarch, CORE_ADDR x));
-     extern void set_gdbarch_d10v_convert_iaddr_to_raw PARAMS ((struct gdbarch * gdbarch, gdbarch_d10v_convert_iaddr_to_raw_ftype * d10v_convert_iaddr_to_raw));
+typedef CORE_ADDR (gdbarch_d10v_convert_iaddr_to_raw_ftype) PARAMS ((CORE_ADDR x));
+extern CORE_ADDR gdbarch_d10v_convert_iaddr_to_raw PARAMS ((struct gdbarch *gdbarch, CORE_ADDR x));
+extern void set_gdbarch_d10v_convert_iaddr_to_raw PARAMS ((struct gdbarch *gdbarch, gdbarch_d10v_convert_iaddr_to_raw_ftype *d10v_convert_iaddr_to_raw));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (D10V_CONVERT_IADDR_TO_RAW)
 #define D10V_CONVERT_IADDR_TO_RAW(x) (gdbarch_d10v_convert_iaddr_to_raw (current_gdbarch, x))
 #endif
 #endif
 
-     typedef void (gdbarch_store_struct_return_ftype) PARAMS ((CORE_ADDR addr, CORE_ADDR sp));
-     extern void gdbarch_store_struct_return PARAMS ((struct gdbarch * gdbarch, CORE_ADDR addr, CORE_ADDR sp));
-     extern void set_gdbarch_store_struct_return PARAMS ((struct gdbarch * gdbarch, gdbarch_store_struct_return_ftype * store_struct_return));
+typedef void (gdbarch_store_struct_return_ftype) PARAMS ((CORE_ADDR addr, CORE_ADDR sp));
+extern void gdbarch_store_struct_return PARAMS ((struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR sp));
+extern void set_gdbarch_store_struct_return PARAMS ((struct gdbarch *gdbarch, gdbarch_store_struct_return_ftype *store_struct_return));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (STORE_STRUCT_RETURN)
 #define STORE_STRUCT_RETURN(addr, sp) (gdbarch_store_struct_return (current_gdbarch, addr, sp))
 #endif
 #endif
 
-     typedef void (gdbarch_store_return_value_ftype) PARAMS ((struct type * type, char *valbuf));
-     extern void gdbarch_store_return_value PARAMS ((struct gdbarch * gdbarch, struct type * type, char *valbuf));
-     extern void set_gdbarch_store_return_value PARAMS ((struct gdbarch * gdbarch, gdbarch_store_return_value_ftype * store_return_value));
+typedef void (gdbarch_store_return_value_ftype) PARAMS ((struct type *type, char *valbuf));
+extern void gdbarch_store_return_value PARAMS ((struct gdbarch *gdbarch, struct type *type, char *valbuf));
+extern void set_gdbarch_store_return_value PARAMS ((struct gdbarch *gdbarch, gdbarch_store_return_value_ftype *store_return_value));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (STORE_RETURN_VALUE)
 #define STORE_RETURN_VALUE(type, valbuf) (gdbarch_store_return_value (current_gdbarch, type, valbuf))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) PARAMS ((char *regbuf));
-     extern CORE_ADDR gdbarch_extract_struct_value_address PARAMS ((struct gdbarch * gdbarch, char *regbuf));
-     extern void set_gdbarch_extract_struct_value_address PARAMS ((struct gdbarch * gdbarch, gdbarch_extract_struct_value_address_ftype * extract_struct_value_address));
+typedef CORE_ADDR (gdbarch_extract_struct_value_address_ftype) PARAMS ((char *regbuf));
+extern CORE_ADDR gdbarch_extract_struct_value_address PARAMS ((struct gdbarch *gdbarch, char *regbuf));
+extern void set_gdbarch_extract_struct_value_address PARAMS ((struct gdbarch *gdbarch, gdbarch_extract_struct_value_address_ftype *extract_struct_value_address));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (EXTRACT_STRUCT_VALUE_ADDRESS)
 #define EXTRACT_STRUCT_VALUE_ADDRESS(regbuf) (gdbarch_extract_struct_value_address (current_gdbarch, regbuf))
 #endif
 #endif
 
-     typedef int (gdbarch_use_struct_convention_ftype) PARAMS ((int gcc_p, struct type * value_type));
-     extern int gdbarch_use_struct_convention PARAMS ((struct gdbarch * gdbarch, int gcc_p, struct type * value_type));
-     extern void set_gdbarch_use_struct_convention PARAMS ((struct gdbarch * gdbarch, gdbarch_use_struct_convention_ftype * use_struct_convention));
+typedef int (gdbarch_use_struct_convention_ftype) PARAMS ((int gcc_p, struct type *value_type));
+extern int gdbarch_use_struct_convention PARAMS ((struct gdbarch *gdbarch, int gcc_p, struct type *value_type));
+extern void set_gdbarch_use_struct_convention PARAMS ((struct gdbarch *gdbarch, gdbarch_use_struct_convention_ftype *use_struct_convention));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (USE_STRUCT_CONVENTION)
 #define USE_STRUCT_CONVENTION(gcc_p, value_type) (gdbarch_use_struct_convention (current_gdbarch, gcc_p, value_type))
 #endif
 #endif
 
-     typedef void (gdbarch_frame_init_saved_regs_ftype) PARAMS ((struct frame_info * frame));
-     extern void gdbarch_frame_init_saved_regs PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
-     extern void set_gdbarch_frame_init_saved_regs PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_init_saved_regs_ftype * frame_init_saved_regs));
+typedef void (gdbarch_frame_init_saved_regs_ftype) PARAMS ((struct frame_info *frame));
+extern void gdbarch_frame_init_saved_regs PARAMS ((struct gdbarch *gdbarch, struct frame_info *frame));
+extern void set_gdbarch_frame_init_saved_regs PARAMS ((struct gdbarch *gdbarch, gdbarch_frame_init_saved_regs_ftype *frame_init_saved_regs));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_INIT_SAVED_REGS)
 #define FRAME_INIT_SAVED_REGS(frame) (gdbarch_frame_init_saved_regs (current_gdbarch, frame))
 #endif
 #endif
 
-     typedef void (gdbarch_init_extra_frame_info_ftype) PARAMS ((int fromleaf, struct frame_info * frame));
-     extern void gdbarch_init_extra_frame_info PARAMS ((struct gdbarch * gdbarch, int fromleaf, struct frame_info * frame));
-     extern void set_gdbarch_init_extra_frame_info PARAMS ((struct gdbarch * gdbarch, gdbarch_init_extra_frame_info_ftype * init_extra_frame_info));
+typedef void (gdbarch_init_extra_frame_info_ftype) PARAMS ((int fromleaf, struct frame_info *frame));
+extern void gdbarch_init_extra_frame_info PARAMS ((struct gdbarch *gdbarch, int fromleaf, struct frame_info *frame));
+extern void set_gdbarch_init_extra_frame_info PARAMS ((struct gdbarch *gdbarch, gdbarch_init_extra_frame_info_ftype *init_extra_frame_info));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (INIT_EXTRA_FRAME_INFO)
 #define INIT_EXTRA_FRAME_INFO(fromleaf, frame) (gdbarch_init_extra_frame_info (current_gdbarch, fromleaf, frame))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_skip_prologue_ftype) PARAMS ((CORE_ADDR ip));
-     extern CORE_ADDR gdbarch_skip_prologue PARAMS ((struct gdbarch * gdbarch, CORE_ADDR ip));
-     extern void set_gdbarch_skip_prologue PARAMS ((struct gdbarch * gdbarch, gdbarch_skip_prologue_ftype * skip_prologue));
+typedef CORE_ADDR (gdbarch_skip_prologue_ftype) PARAMS ((CORE_ADDR ip));
+extern CORE_ADDR gdbarch_skip_prologue PARAMS ((struct gdbarch *gdbarch, CORE_ADDR ip));
+extern void set_gdbarch_skip_prologue PARAMS ((struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (SKIP_PROLOGUE)
 #define SKIP_PROLOGUE(ip) (gdbarch_skip_prologue (current_gdbarch, ip))
 #endif
 #endif
 
-     typedef int (gdbarch_inner_than_ftype) PARAMS ((CORE_ADDR lhs, CORE_ADDR rhs));
-     extern int gdbarch_inner_than PARAMS ((struct gdbarch * gdbarch, CORE_ADDR lhs, CORE_ADDR rhs));
-     extern void set_gdbarch_inner_than PARAMS ((struct gdbarch * gdbarch, gdbarch_inner_than_ftype * inner_than));
+typedef int (gdbarch_inner_than_ftype) PARAMS ((CORE_ADDR lhs, CORE_ADDR rhs));
+extern int gdbarch_inner_than PARAMS ((struct gdbarch *gdbarch, CORE_ADDR lhs, CORE_ADDR rhs));
+extern void set_gdbarch_inner_than PARAMS ((struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (INNER_THAN)
 #define INNER_THAN(lhs, rhs) (gdbarch_inner_than (current_gdbarch, lhs, rhs))
 #endif
 #endif
 
-     typedef unsigned char *(gdbarch_breakpoint_from_pc_ftype) PARAMS ((CORE_ADDR * pcptr, int *lenptr));
-     extern unsigned char *gdbarch_breakpoint_from_pc PARAMS ((struct gdbarch * gdbarch, CORE_ADDR * pcptr, int *lenptr));
-     extern void set_gdbarch_breakpoint_from_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_breakpoint_from_pc_ftype * breakpoint_from_pc));
+typedef unsigned char * (gdbarch_breakpoint_from_pc_ftype) PARAMS ((CORE_ADDR *pcptr, int *lenptr));
+extern unsigned char * gdbarch_breakpoint_from_pc PARAMS ((struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr));
+extern void set_gdbarch_breakpoint_from_pc PARAMS ((struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype *breakpoint_from_pc));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (BREAKPOINT_FROM_PC)
 #define BREAKPOINT_FROM_PC(pcptr, lenptr) (gdbarch_breakpoint_from_pc (current_gdbarch, pcptr, lenptr))
 #endif
 #endif
 
-     extern CORE_ADDR gdbarch_decr_pc_after_break PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_decr_pc_after_break PARAMS ((struct gdbarch * gdbarch, CORE_ADDR decr_pc_after_break));
+extern CORE_ADDR gdbarch_decr_pc_after_break PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_decr_pc_after_break PARAMS ((struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (DECR_PC_AFTER_BREAK)
 #define DECR_PC_AFTER_BREAK (gdbarch_decr_pc_after_break (current_gdbarch))
 #endif
 #endif
 
-     extern CORE_ADDR gdbarch_function_start_offset PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_function_start_offset PARAMS ((struct gdbarch * gdbarch, CORE_ADDR function_start_offset));
+extern CORE_ADDR gdbarch_function_start_offset PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_function_start_offset PARAMS ((struct gdbarch *gdbarch, CORE_ADDR function_start_offset));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FUNCTION_START_OFFSET)
 #define FUNCTION_START_OFFSET (gdbarch_function_start_offset (current_gdbarch))
 #endif
 #endif
 
-     typedef void (gdbarch_remote_translate_xfer_address_ftype) PARAMS ((CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR * rem_addr, int *rem_len));
-     extern void gdbarch_remote_translate_xfer_address PARAMS ((struct gdbarch * gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR * rem_addr, int *rem_len));
-     extern void set_gdbarch_remote_translate_xfer_address PARAMS ((struct gdbarch * gdbarch, gdbarch_remote_translate_xfer_address_ftype * remote_translate_xfer_address));
+typedef void (gdbarch_remote_translate_xfer_address_ftype) PARAMS ((CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len));
+extern void gdbarch_remote_translate_xfer_address PARAMS ((struct gdbarch *gdbarch, CORE_ADDR gdb_addr, int gdb_len, CORE_ADDR *rem_addr, int *rem_len));
+extern void set_gdbarch_remote_translate_xfer_address PARAMS ((struct gdbarch *gdbarch, gdbarch_remote_translate_xfer_address_ftype *remote_translate_xfer_address));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (REMOTE_TRANSLATE_XFER_ADDRESS)
 #define REMOTE_TRANSLATE_XFER_ADDRESS(gdb_addr, gdb_len, rem_addr, rem_len) (gdbarch_remote_translate_xfer_address (current_gdbarch, gdb_addr, gdb_len, rem_addr, rem_len))
 #endif
 #endif
 
-     extern CORE_ADDR gdbarch_frame_args_skip PARAMS ((struct gdbarch * gdbarch));
-     extern void set_gdbarch_frame_args_skip PARAMS ((struct gdbarch * gdbarch, CORE_ADDR frame_args_skip));
+extern CORE_ADDR gdbarch_frame_args_skip PARAMS ((struct gdbarch *gdbarch));
+extern void set_gdbarch_frame_args_skip PARAMS ((struct gdbarch *gdbarch, CORE_ADDR frame_args_skip));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_ARGS_SKIP)
 #define FRAME_ARGS_SKIP (gdbarch_frame_args_skip (current_gdbarch))
 #endif
 #endif
 
-     typedef int (gdbarch_frameless_function_invocation_ftype) PARAMS ((struct frame_info * fi));
-     extern int gdbarch_frameless_function_invocation PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
-     extern void set_gdbarch_frameless_function_invocation PARAMS ((struct gdbarch * gdbarch, gdbarch_frameless_function_invocation_ftype * frameless_function_invocation));
+typedef int (gdbarch_frameless_function_invocation_ftype) PARAMS ((struct frame_info *fi));
+extern int gdbarch_frameless_function_invocation PARAMS ((struct gdbarch *gdbarch, struct frame_info *fi));
+extern void set_gdbarch_frameless_function_invocation PARAMS ((struct gdbarch *gdbarch, gdbarch_frameless_function_invocation_ftype *frameless_function_invocation));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAMELESS_FUNCTION_INVOCATION)
 #define FRAMELESS_FUNCTION_INVOCATION(fi) (gdbarch_frameless_function_invocation (current_gdbarch, fi))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_frame_chain_ftype) PARAMS ((struct frame_info * frame));
-     extern CORE_ADDR gdbarch_frame_chain PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
-     extern void set_gdbarch_frame_chain PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_chain_ftype * frame_chain));
+typedef CORE_ADDR (gdbarch_frame_chain_ftype) PARAMS ((struct frame_info *frame));
+extern CORE_ADDR gdbarch_frame_chain PARAMS ((struct gdbarch *gdbarch, struct frame_info *frame));
+extern void set_gdbarch_frame_chain PARAMS ((struct gdbarch *gdbarch, gdbarch_frame_chain_ftype *frame_chain));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_CHAIN)
 #define FRAME_CHAIN(frame) (gdbarch_frame_chain (current_gdbarch, frame))
 #endif
 #endif
 
-     typedef int (gdbarch_frame_chain_valid_ftype) PARAMS ((CORE_ADDR chain, struct frame_info * thisframe));
-     extern int gdbarch_frame_chain_valid PARAMS ((struct gdbarch * gdbarch, CORE_ADDR chain, struct frame_info * thisframe));
-     extern void set_gdbarch_frame_chain_valid PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_chain_valid_ftype * frame_chain_valid));
+typedef int (gdbarch_frame_chain_valid_ftype) PARAMS ((CORE_ADDR chain, struct frame_info *thisframe));
+extern int gdbarch_frame_chain_valid PARAMS ((struct gdbarch *gdbarch, CORE_ADDR chain, struct frame_info *thisframe));
+extern void set_gdbarch_frame_chain_valid PARAMS ((struct gdbarch *gdbarch, gdbarch_frame_chain_valid_ftype *frame_chain_valid));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_CHAIN_VALID)
 #define FRAME_CHAIN_VALID(chain, thisframe) (gdbarch_frame_chain_valid (current_gdbarch, chain, thisframe))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_frame_saved_pc_ftype) PARAMS ((struct frame_info * fi));
-     extern CORE_ADDR gdbarch_frame_saved_pc PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
-     extern void set_gdbarch_frame_saved_pc PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_saved_pc_ftype * frame_saved_pc));
+typedef CORE_ADDR (gdbarch_frame_saved_pc_ftype) PARAMS ((struct frame_info *fi));
+extern CORE_ADDR gdbarch_frame_saved_pc PARAMS ((struct gdbarch *gdbarch, struct frame_info *fi));
+extern void set_gdbarch_frame_saved_pc PARAMS ((struct gdbarch *gdbarch, gdbarch_frame_saved_pc_ftype *frame_saved_pc));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_SAVED_PC)
 #define FRAME_SAVED_PC(fi) (gdbarch_frame_saved_pc (current_gdbarch, fi))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_frame_args_address_ftype) PARAMS ((struct frame_info * fi));
-     extern CORE_ADDR gdbarch_frame_args_address PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
-     extern void set_gdbarch_frame_args_address PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_args_address_ftype * frame_args_address));
+typedef CORE_ADDR (gdbarch_frame_args_address_ftype) PARAMS ((struct frame_info *fi));
+extern CORE_ADDR gdbarch_frame_args_address PARAMS ((struct gdbarch *gdbarch, struct frame_info *fi));
+extern void set_gdbarch_frame_args_address PARAMS ((struct gdbarch *gdbarch, gdbarch_frame_args_address_ftype *frame_args_address));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_ARGS_ADDRESS)
 #define FRAME_ARGS_ADDRESS(fi) (gdbarch_frame_args_address (current_gdbarch, fi))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_frame_locals_address_ftype) PARAMS ((struct frame_info * fi));
-     extern CORE_ADDR gdbarch_frame_locals_address PARAMS ((struct gdbarch * gdbarch, struct frame_info * fi));
-     extern void set_gdbarch_frame_locals_address PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_locals_address_ftype * frame_locals_address));
+typedef CORE_ADDR (gdbarch_frame_locals_address_ftype) PARAMS ((struct frame_info *fi));
+extern CORE_ADDR gdbarch_frame_locals_address PARAMS ((struct gdbarch *gdbarch, struct frame_info *fi));
+extern void set_gdbarch_frame_locals_address PARAMS ((struct gdbarch *gdbarch, gdbarch_frame_locals_address_ftype *frame_locals_address));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_LOCALS_ADDRESS)
 #define FRAME_LOCALS_ADDRESS(fi) (gdbarch_frame_locals_address (current_gdbarch, fi))
 #endif
 #endif
 
-     typedef CORE_ADDR (gdbarch_saved_pc_after_call_ftype) PARAMS ((struct frame_info * frame));
-     extern CORE_ADDR gdbarch_saved_pc_after_call PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
-     extern void set_gdbarch_saved_pc_after_call PARAMS ((struct gdbarch * gdbarch, gdbarch_saved_pc_after_call_ftype * saved_pc_after_call));
+typedef CORE_ADDR (gdbarch_saved_pc_after_call_ftype) PARAMS ((struct frame_info *frame));
+extern CORE_ADDR gdbarch_saved_pc_after_call PARAMS ((struct gdbarch *gdbarch, struct frame_info *frame));
+extern void set_gdbarch_saved_pc_after_call PARAMS ((struct gdbarch *gdbarch, gdbarch_saved_pc_after_call_ftype *saved_pc_after_call));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (SAVED_PC_AFTER_CALL)
 #define SAVED_PC_AFTER_CALL(frame) (gdbarch_saved_pc_after_call (current_gdbarch, frame))
 #endif
 #endif
 
-     typedef int (gdbarch_frame_num_args_ftype) PARAMS ((struct frame_info * frame));
-     extern int gdbarch_frame_num_args PARAMS ((struct gdbarch * gdbarch, struct frame_info * frame));
-     extern void set_gdbarch_frame_num_args PARAMS ((struct gdbarch * gdbarch, gdbarch_frame_num_args_ftype * frame_num_args));
+typedef int (gdbarch_frame_num_args_ftype) PARAMS ((struct frame_info *frame));
+extern int gdbarch_frame_num_args PARAMS ((struct gdbarch *gdbarch, struct frame_info *frame));
+extern void set_gdbarch_frame_num_args PARAMS ((struct gdbarch *gdbarch, gdbarch_frame_num_args_ftype *frame_num_args));
 #if GDB_MULTI_ARCH
 #if (GDB_MULTI_ARCH > 1) || !defined (FRAME_NUM_ARGS)
 #define FRAME_NUM_ARGS(frame) (gdbarch_frame_num_args (current_gdbarch, frame))
 #endif
 #endif
 
-     extern struct gdbarch_tdep *gdbarch_tdep PARAMS ((struct gdbarch * gdbarch));
+extern struct gdbarch_tdep *gdbarch_tdep PARAMS ((struct gdbarch *gdbarch));
 
 
 /* Mechanism for co-ordinating the selection of a specific
@@ -821,39 +822,39 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
    - that describes the selected architecture (see
    gdbarch_alloc()). */
 
-     struct gdbarch_list
-       {
-	 struct gdbarch *gdbarch;
-	 struct gdbarch_list *next;
-       };
+struct gdbarch_list
+{
+  struct gdbarch *gdbarch;
+  struct gdbarch_list *next;
+};
 
-     struct gdbarch_info
-       {
-	 /* Use default: bfd_arch_unknown (ZERO). */
-	 enum bfd_architecture bfd_architecture;
+struct gdbarch_info
+{
+  /* Use default: bfd_arch_unknown (ZERO). */
+  enum bfd_architecture bfd_architecture;
 
-	 /* Use default: NULL (ZERO). */
-	 const struct bfd_arch_info *bfd_arch_info;
+  /* Use default: NULL (ZERO). */
+  const struct bfd_arch_info *bfd_arch_info;
 
-	 /* Use default: 0 (ZERO). */
-	 int byte_order;
+  /* Use default: 0 (ZERO). */
+  int byte_order;
 
-	 /* Use default: NULL (ZERO). */
-	 bfd *abfd;
+  /* Use default: NULL (ZERO). */
+  bfd *abfd;
 
-	 /* Use default: NULL (ZERO). */
-	 struct gdbarch_tdep_info *tdep_info;
-       };
+  /* Use default: NULL (ZERO). */
+  struct gdbarch_tdep_info *tdep_info;
+};
 
-     typedef struct gdbarch *(gdbarch_init_ftype) PARAMS ((struct gdbarch_info info, struct gdbarch_list * arches));
+typedef struct gdbarch *(gdbarch_init_ftype) PARAMS ((struct gdbarch_info info, struct gdbarch_list *arches));
 
-     extern void register_gdbarch_init PARAMS ((enum bfd_architecture architecture, gdbarch_init_ftype *));
+extern void register_gdbarch_init PARAMS ((enum bfd_architecture architecture, gdbarch_init_ftype *));
 
 
 /* Helper function.  Search the list of ARCHES for a GDBARCH that
    matches the information provided by INFO. */
 
-     extern struct gdbarch_list *gdbarch_list_lookup_by_info PARAMS ((struct gdbarch_list * arches, const struct gdbarch_info * info));
+extern struct gdbarch_list *gdbarch_list_lookup_by_info PARAMS ((struct gdbarch_list *arches,  const struct gdbarch_info *info));
 
 
 /* Helper function.  Create a preliminary ``struct gdbarch''.  Perform
@@ -861,7 +862,7 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
    parameters.  set_gdbarch_*() functions are called to complete the
    initialization of the object. */
 
-     extern struct gdbarch *gdbarch_alloc PARAMS ((const struct gdbarch_info * info, struct gdbarch_tdep * tdep));
+extern struct gdbarch *gdbarch_alloc PARAMS ((const struct gdbarch_info *info, struct gdbarch_tdep *tdep));
 
 
 /* Helper function. Force an update of the current architecture.  Used
@@ -875,7 +876,7 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
    INFO.ABFD (if specified) before calling the corresponding
    architectures INIT function. */
 
-     extern int gdbarch_update PARAMS ((struct gdbarch_info info));
+extern int gdbarch_update PARAMS ((struct gdbarch_info info));
 
 
 
@@ -896,13 +897,13 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
    Multiple registrarants for any architecture are allowed (and
    strongly encouraged).  */
 
-     typedef void *(gdbarch_data_ftype) PARAMS ((void));
-     extern struct gdbarch_data *register_gdbarch_data PARAMS ((gdbarch_data_ftype * init));
+typedef void *(gdbarch_data_ftype) PARAMS ((void));
+extern struct gdbarch_data *register_gdbarch_data PARAMS ((gdbarch_data_ftype *init));
 
 /* Return the value of the per-architecture data-pointer for the
    current architecture. */
 
-     extern void *gdbarch_data PARAMS ((struct gdbarch_data *));
+extern void *gdbarch_data PARAMS ((struct gdbarch_data*));
 
 
 
@@ -918,8 +919,8 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 
    New code should use register_gdbarch_data(). */
 
-     typedef void (gdbarch_swap_ftype) PARAMS ((void));
-     extern void register_gdbarch_swap PARAMS ((void *data, unsigned long size, gdbarch_swap_ftype * init));
+typedef void (gdbarch_swap_ftype) PARAMS ((void));
+extern void register_gdbarch_swap PARAMS ((void *data, unsigned long size, gdbarch_swap_ftype *init));
 
 
 
@@ -946,7 +947,7 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 #endif
 #endif
 
-     extern int target_byte_order;
+extern int target_byte_order;
 #ifdef TARGET_BYTE_ORDER_SELECTABLE
 /* compat - Catch old targets that define TARGET_BYTE_ORDER_SELECTABLE
    and expect defs.h to re-define TARGET_BYTE_ORDER. */
@@ -956,7 +957,7 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 #define TARGET_BYTE_ORDER (target_byte_order + 0)
 #endif
 
-     extern int target_byte_order_auto;
+extern int target_byte_order_auto;
 #ifndef TARGET_BYTE_ORDER_AUTO
 #define TARGET_BYTE_ORDER_AUTO (target_byte_order_auto + 0)
 #endif
@@ -965,12 +966,12 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 
 /* The target-system-dependant BFD architecture is dynamic */
 
-     extern int target_architecture_auto;
+extern int target_architecture_auto;
 #ifndef TARGET_ARCHITECTURE_AUTO
 #define TARGET_ARCHITECTURE_AUTO (target_architecture_auto + 0)
 #endif
 
-     extern const struct bfd_arch_info *target_architecture;
+extern const struct bfd_arch_info *target_architecture;
 #ifndef TARGET_ARCHITECTURE
 #define TARGET_ARCHITECTURE (target_architecture + 0)
 #endif
@@ -979,7 +980,7 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
    architecture. A zero return status indicates that the target did
    not like the change. */
 
-     extern int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *));
+extern int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *)); 
 
 
 
@@ -987,17 +988,17 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 
 #include "dis-asm.h"		/* Get defs for disassemble_info */
 
-     extern int dis_asm_read_memory PARAMS ((bfd_vma memaddr, bfd_byte * myaddr,
-					 int len, disassemble_info * info));
+extern int dis_asm_read_memory PARAMS ((bfd_vma memaddr, bfd_byte *myaddr,
+					int len, disassemble_info *info));
 
-     extern void dis_asm_memory_error PARAMS ((int status, bfd_vma memaddr,
-					       disassemble_info * info));
+extern void dis_asm_memory_error PARAMS ((int status, bfd_vma memaddr,
+					  disassemble_info *info));
 
-     extern void dis_asm_print_address PARAMS ((bfd_vma addr,
-						disassemble_info * info));
+extern void dis_asm_print_address PARAMS ((bfd_vma addr,
+					   disassemble_info *info));
 
-     extern int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info *));
-     extern disassemble_info tm_print_insn_info;
+extern int (*tm_print_insn) PARAMS ((bfd_vma, disassemble_info*));
+extern disassemble_info tm_print_insn_info;
 #ifndef TARGET_PRINT_INSN
 #define TARGET_PRINT_INSN(vma, info) (*tm_print_insn) (vma, info)
 #endif
@@ -1026,7 +1027,7 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 
 
 /* Fallback definition of REGISTER_CONVERTIBLE etc */
-     extern int generic_register_convertible_not PARAMS ((int reg_nr));
+extern int generic_register_convertible_not PARAMS ((int reg_nr));
 #ifndef REGISTER_CONVERTIBLE
 #define REGISTER_CONVERTIBLE(x) (0)
 #endif
@@ -1052,7 +1053,7 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 /* Fallback definition for REGISTER_NAME for systems still defining
    REGISTER_NAMES. */
 #ifndef REGISTER_NAME
-     extern char *gdb_register_names[];
+extern char *gdb_register_names[];
 #define REGISTER_NAME(i) gdb_register_names[i]
 #endif
 
@@ -1060,24 +1061,24 @@ CORE_ADDR (gdbarch_read_pc_ftype) PARAMS ((int pid));
 /* Set the dynamic target-system-dependant parameters (architecture,
    byte-order, ...) using information found in the BFD */
 
-     extern void set_gdbarch_from_file PARAMS ((bfd *));
+extern void set_gdbarch_from_file PARAMS ((bfd *));
 
 
 /* Explicitly set the dynamic target-system-dependant parameters based
    on bfd_architecture and machine. */
 
-     extern void set_architecture_from_arch_mach PARAMS ((enum bfd_architecture, unsigned long));
+extern void set_architecture_from_arch_mach PARAMS ((enum bfd_architecture, unsigned long));
 
 
 /* Helper function for targets that don't know how my arguments are
    being passed */
 
-     extern int frame_num_args_unknown PARAMS ((struct frame_info * fi));
+extern int frame_num_args_unknown PARAMS ((struct frame_info *fi));
 
 
 /* gdbarch trace variable */
-     extern int gdbarch_debug;
+extern int gdbarch_debug;
 
-     extern void gdbarch_dump PARAMS ((void));
+extern void gdbarch_dump PARAMS ((void));
 
 #endif
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 6e013af..dba4f34 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1616,6 +1616,20 @@ can_dereference (t)
      && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
 }
 
+int
+is_integral_type (t)
+     struct type *t;
+{
+  CHECK_TYPEDEF (t);
+  return
+    ((t != NULL)
+     && ((TYPE_CODE(t) == TYPE_CODE_INT)
+         || (TYPE_CODE(t) == TYPE_CODE_ENUM)
+         || (TYPE_CODE(t) == TYPE_CODE_CHAR)
+         || (TYPE_CODE(t) == TYPE_CODE_RANGE)
+         || (TYPE_CODE(t) == TYPE_CODE_BOOL)));
+}
+
 /* Chill varying string and arrays are represented as follows:
 
    struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 21fb905..dcd65ee 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -1138,6 +1138,8 @@ print_scalar_formatted PARAMS ((char *, struct type *, int, int, GDB_FILE *));
 
 extern int can_dereference PARAMS ((struct type *));
 
+extern int is_integral_type PARAMS ((struct type *));
+
 extern void maintenance_print_type PARAMS ((char *, int));
 
 /* typeprint.c */
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 82ac67b..abd3b90 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -2127,6 +2127,7 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
 	}
     }
 
+#ifndef GDB_TARGET_IS_HPPA_20W
   /* Store upper 21 bits of function address into ldil.  fun will either be
      the final target (most cases) or __d_plt_call when calling into a shared
      library and __gcc_plt_call is not available.  */
@@ -2144,6 +2145,7 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
      deposit_14 (fun & MASK_11,
 		 extract_unsigned_integer (&dummy[FUNC_LDO_OFFSET],
 					   INSTRUCTION_SIZE)));
+#endif /* GDB_TARGET_IS_HPPA_20W */
 #ifdef SR4EXPORT_LDIL_OFFSET
 
   {
@@ -2514,17 +2516,22 @@ pa_print_registers (raw_regs, regnum, fpregs)
      int fpregs;
 {
   int i, j;
-  long raw_val[2];		/* Alas, we are compiled so that "long long" is 32 bits */
+  /* Alas, we are compiled so that "long long" is 32 bits */
+  long raw_val[2];
   long long_val;
+  int rows = 24, columns = 3;
 
-  for (i = 0; i < 18; i++)
+  for (i = 0; i < rows; i++)
     {
-      for (j = 0; j < 4; j++)
+      for (j = 0; j < columns; j++)
 	{
+	  /* We display registers in column-major order.  */
+	  int regnum = i + j * rows;
+
 	  /* Q: Why is the value passed through "extract_signed_integer",
 	     while above, in "pa_do_registers_info" it isn't?
 	     A: ? */
-	  pa_register_look_aside (raw_regs, i + (j * 18), &raw_val[0]);
+	  pa_register_look_aside (raw_regs, regnum, &raw_val[0]);
 
 	  /* Even fancier % formats to prevent leading zeros
 	     and still maintain the output in columns. */
@@ -2533,17 +2540,17 @@ pa_print_registers (raw_regs, regnum, fpregs)
 	      /* Being big-endian, on this machine the low bits
 	         (the ones we want to look at) are in the second longword. */
 	      long_val = extract_signed_integer (&raw_val[1], 4);
-	      printf_filtered ("%8.8s: %8x  ",
-			       REGISTER_NAME (i + (j * 18)), long_val);
+	      printf_filtered ("%8.8s: %8x",
+			       REGISTER_NAME (regnum), long_val);
 	    }
 	  else
 	    {
 	      /* raw_val = extract_signed_integer(&raw_val, 8); */
 	      if (raw_val[0] == 0)
-		printf_filtered ("%8.8s:         %8x  ",
-				 REGISTER_NAME (i + (j * 18)), raw_val[1]);
+		printf_filtered ("%8.8s:         %8x",
+				 REGISTER_NAME (regnum), raw_val[1]);
 	      else
-		printf_filtered ("%8.8s: %8x%8.8x  ", REGISTER_NAME (i + (j * 18)),
+		printf_filtered ("%8.8s: %8x%8.8x", REGISTER_NAME (regnum),
 				 raw_val[0], raw_val[1]);
 	    }
 	}
diff --git a/gdb/hppah-nat.c b/gdb/hppah-nat.c
index 4ade6f2..627760d 100644
--- a/gdb/hppah-nat.c
+++ b/gdb/hppah-nat.c
@@ -104,45 +104,92 @@ store_inferior_registers (regno)
       store_inferior_registers (regno);
 }
 
-/* Fetch one register.  */
 
+/* Our own version of the offsetof macro, since we can't assume ANSI C.  */
+#define HPPAH_OFFSETOF(type, member) ((int) (&((type *) 0)->member))
+
+/* Fetch a register's value from the process's U area.  */
 static void
 fetch_register (regno)
      int regno;
 {
-  register unsigned int regaddr;
   char buf[MAX_REGISTER_RAW_SIZE];
-  register int i;
+  unsigned int addr, len, offset;
+  int i;
+
+  offset = 0;
+  len = REGISTER_RAW_SIZE (regno);
+
+  /* Requests for register zero actually want the save_state's
+     ss_flags member.  As RM says: "Oh, what a hack!"  */
+  if (regno == 0)
+    {
+      save_state_t ss;
+      addr = HPPAH_OFFSETOF (save_state_t, ss_flags);
+      len = sizeof (ss.ss_flags);
+
+      /* Note that ss_flags is always an int, no matter what
+	 REGISTER_RAW_SIZE(0) says.  Assuming all HP-UX PA machines
+	 are big-endian, put it at the least significant end of the
+	 value, and zap the rest of the buffer.  */
+      offset = REGISTER_RAW_SIZE (0) - len;
+      memset (buf, 0, sizeof (buf));
+    }
 
-  /* Offset of registers within the u area.  */
-  unsigned int offset;
+  /* Floating-point registers come from the ss_fpblock area.  */
+  else if (regno >= FP0_REGNUM)
+    addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock) 
+	    + (REGISTER_BYTE (regno) - REGISTER_BYTE (FP0_REGNUM)));
+
+  /* Wide registers come from the ss_wide area.
+     I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
+     between ss_wide and ss_narrow than to use the raw register size.
+     But checking ss_flags would require an extra ptrace call for
+     every register reference.  Bleah.  */
+  else if (len == 8)
+    addr = (HPPAH_OFFSETOF (save_state_t, ss_wide) 
+	    + REGISTER_BYTE (regno));
+
+  /* Narrow registers come from the ss_narrow area.  Note that
+     ss_narrow starts with gr1, not gr0.  */
+  else if (len == 4)
+    addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow)
+	    + (REGISTER_BYTE (regno) - REGISTER_BYTE (1)));
 
-  offset = U_REGS_OFFSET;
+  else
+    fatal ("hppa-nat.c (fetch_register): unexpected register size");
 
-  regaddr = register_addr (regno, offset);
-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+  for (i = 0; i < len; i += sizeof (int))
     {
       errno = 0;
-      *(int *) &buf[i] = call_ptrace (PT_RUREGS, inferior_pid,
-				      (PTRACE_ARG3_TYPE) regaddr, 0);
-      regaddr += sizeof (int);
+      /* Copy an int from the U area to buf.  Fill the least
+         significant end if len != raw_size.  */
+      * (int *) &buf[offset + i] =
+	  call_ptrace (PT_RUREGS, inferior_pid,
+		       (PTRACE_ARG3_TYPE) addr + i, 0);
       if (errno != 0)
 	{
-	  /* Warning, not error, in case we are attached; sometimes the
-	     kernel doesn't let us at the registers.  */
+	  /* Warning, not error, in case we are attached; sometimes
+	     the kernel doesn't let us at the registers. */
 	  char *err = safe_strerror (errno);
 	  char *msg = alloca (strlen (err) + 128);
-	  sprintf (msg, "reading register %s: %s", REGISTER_NAME (regno), err);
+	  sprintf (msg, "reading `%s' register: %s",
+		   REGISTER_NAME (regno), err);
 	  warning (msg);
-	  goto error_exit;
+	  return;
 	}
     }
+
+  /* If we're reading an address from the instruction address queue,
+     mask out the bottom two bits --- they contain the privilege
+     level.  */
   if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
-    buf[3] &= ~0x3;
+    buf[len - 1] &= ~0x3;
+
   supply_register (regno, buf);
-error_exit:;
 }
 
+
 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
    to debugger memory starting at MYADDR.   Copy to inferior if
    WRITE is nonzero.
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index a3807de..297b2a0 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -244,8 +244,8 @@ run_command (args, from_tty)
 
   if (inferior_pid != 0 && target_has_execution)
     {
-      if (
-	   !query ("The program being debugged has been started already.\n\
+      if (from_tty
+	  && !query ("The program being debugged has been started already.\n\
 Start it from the beginning? "))
 	error ("Program not restarted.");
       target_kill ();
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 8fa98ae..08e6f64 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1262,6 +1262,9 @@ fetch_inferior_event ()
 
   if (!async_ecs->wait_some_more)
     {
+      /* Do only the cleanups that have been added by this
+	 function. Let the continuations for the commands do the rest,
+	 if there are any. */
       do_exec_cleanups (old_cleanups);
       normal_stop ();
       /* Is there anything left to do for the command issued to
@@ -3112,6 +3115,7 @@ complete_execution ()
 {
   extern cleanup_sigint_signal_handler PARAMS ((void));
 
+  target_executing = 0;
   if (sync_execution)
     {
       add_file_handler (input_fd, (file_handler_func *) call_readline, 0);
@@ -3120,7 +3124,6 @@ complete_execution ()
       cleanup_sigint_signal_handler ();
       display_gdb_prompt (0);
     }
-  target_executing = 0;
 }
 
 /* Here to return control to GDB when the inferior stops for real.
diff --git a/gdb/parse.c b/gdb/parse.c
index 9876817..c28d283 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -1324,7 +1324,7 @@ build_parse ()
   if (FP_REGNUM >= 0)
     num_std_regs++;
 #endif
-#ifdef FP_REGNUM
+#ifdef SP_REGNUM
   if (SP_REGNUM >= 0)
     num_std_regs++;
 #endif
diff --git a/gdb/rdi-share/unixcomm.c b/gdb/rdi-share/unixcomm.c
index 7c2183d..61d84e3 100644
--- a/gdb/rdi-share/unixcomm.c
+++ b/gdb/rdi-share/unixcomm.c
@@ -82,8 +82,8 @@
 #endif
 
 #ifdef __linux__
-#define SERPORT1   "/dev/cua0"
-#define SERPORT2   "/dev/cua1"
+#define SERPORT1   "/dev/ttyS0"
+#define SERPORT2   "/dev/ttyS1"
 #define PARPORT1   "/dev/par0"
 #define PARPORT2   "/dev/par1"
 #endif
@@ -305,15 +305,6 @@ extern void Unix_ResetSerial(void)
     struct termios terminfo;
 
     tcgetattr(serpfd, &terminfo);
-#ifdef __CYGWIN32__
-    /* Expedient, but it works.  */
-    terminfo.c_iflag = 0;
-    terminfo.c_oflag = 0;
-    terminfo.c_cflag = 48;
-    terminfo.c_lflag = 0;
-    terminfo.c_cc[VMIN] = 0;
-    terminfo.c_cc[VTIME] = 1;
-#else
     terminfo.c_lflag &= ~(ICANON | ISIG | ECHO | IEXTEN);
     terminfo.c_iflag &= ~(IGNCR | INPCK | ISTRIP | ICRNL | BRKINT);
     terminfo.c_iflag |= (IXON | IXOFF | IGNBRK);
@@ -322,7 +313,6 @@ extern void Unix_ResetSerial(void)
     terminfo.c_cc[VMIN] = 1;
     terminfo.c_cc[VTIME] = 0;
     terminfo.c_oflag &= ~OPOST;
-#endif
     tcsetattr(serpfd, TCSAFLUSH, &terminfo);
 }
 
diff --git a/gdb/remote.c b/gdb/remote.c
index 00b9661..48edb1e 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -4832,7 +4832,7 @@ terminating `#' character and checksum.",
 
   add_show_from_set
     (add_set_cmd ("remotebreak", no_class,
-		  var_integer, (char *) &remote_break,
+		  var_boolean, (char *) &remote_break,
 		  "Set whether to send break if interrupted.\n",
 		  &setlist),
      &showlist);
diff --git a/gdb/ser-pipe.c b/gdb/ser-pipe.c
index 4dc2a7df..3c37f14 100644
--- a/gdb/ser-pipe.c
+++ b/gdb/ser-pipe.c
@@ -54,6 +54,15 @@ static void pipe_print_tty_state PARAMS ((serial_t, serial_ttystate));
 
 extern void _initialize_ser_pipe PARAMS ((void));
 
+#undef XMALLOC
+#define XMALLOC(T) ((T*) xmalloc (sizeof (T)))
+
+
+struct pipe_state
+  {
+    int pid;
+  };
+
 /* Open up a raw pipe */
 
 static int
@@ -64,23 +73,8 @@ pipe_open (scb, name)
 #if !defined(O_NONBLOCK) || !defined(F_GETFL) || !defined(F_SETFL)
   return -1;
 #else
-#if defined (__NetBSD__) || defined (__FreeBSD__)
-
-  /* check the BSD popen sources for where "r+" comes from :-) */
-  FILE *stream;
-  stream = popen (name + 1, "r+");
-  if (stream == NULL)
-    {
-      fprintf_unfiltered (gdb_stderr, "%s: popen failed\n", name + 1);
-      return -1;
-    }
-  scb->ttystate = stream;	/* borrow that space */
-  scb->fd = fileno (stream);
-
-#else
-
+  struct pipe_state *state;
   /* This chunk: */
-
   /* Copyright (c) 1988, 1993
    *      The Regents of the University of California.  All rights reserved.
    *
@@ -92,20 +86,20 @@ pipe_open (scb, name)
   if (socketpair (AF_UNIX, SOCK_STREAM, 0, pdes) < 0)
     return -1;
 
-  switch (pid = vfork ())
+  pid = vfork ();
+  
+  /* Error. */
+  if (pid == -1)
     {
-    case -1:			/* Error. */
       close (pdes[0]);
       close (pdes[1]);
       return -1;
-    case 0:			/* Child. */
-#if 0
-      /* POSIX.2 B.3.2.2 "popen() shall ensure that any streams
-         from previous popen() calls that remain open in the 
-         parent process are closed in the new child process. */
-      for (old = pidlist; old; old = old->next)
-	close (fileno (old->fp));	/* don't allow a flush */
-#endif
+    }
+
+  /* Child. */
+  if (pid == 0)
+    {
+      /* re-wire pdes[1] to stdin/stdout */
       close (pdes[0]);
       if (pdes[1] != STDOUT_FILENO)
 	{
@@ -113,15 +107,25 @@ pipe_open (scb, name)
 	  close (pdes[1]);
 	}
       dup2 (STDOUT_FILENO, STDIN_FILENO);
+#if 0
+      /* close any stray FD's - FIXME - how? */
+      /* POSIX.2 B.3.2.2 "popen() shall ensure that any streams
+         from previous popen() calls that remain open in the 
+         parent process are closed in the new child process. */
+      for (old = pidlist; old; old = old->next)
+	close (fileno (old->fp));	/* don't allow a flush */
+#endif
       execl ("/bin/sh", "sh", "-c", name + 1, NULL);
       _exit (127);
     }
 
-  /* Parent; assume fdopen can't fail. */
+  /* Parent. */
   close (pdes[1]);
+  /* :end chunk */
+  state = XMALLOC (struct pipe_state);
+  state->pid = pid;
   scb->fd = pdes[0];
-  scb->ttystate = NULL;
-#endif
+  scb->state = state;
 
   /* Make it non-blocking */
   {
@@ -359,14 +363,17 @@ static void
 pipe_close (scb)
      serial_t scb;
 {
-  if (scb->fd < 0)
-    return;
-  if (scb->ttystate != NULL)
-    pclose ((FILE *) scb->ttystate);
-  else
-    close (scb->fd);
-  scb->ttystate = NULL;
-  scb->fd = -1;
+  struct pipe_state *state = scb->state;
+  if (state != NULL)
+    {
+      int pid = state->pid;
+      close (scb->fd);
+      scb->fd = -1;
+      free (state);
+      scb->state = NULL;
+      kill (pid, SIGTERM);
+      /* Might be useful to check that the child does die. */
+    }
 }
 
 static struct serial_ops pipe_ops =
diff --git a/gdb/serial.h b/gdb/serial.h
index fa37cab..09916fe 100644
--- a/gdb/serial.h
+++ b/gdb/serial.h
@@ -29,6 +29,7 @@ struct _serial_t
   {
     int fd;			/* File descriptor */
     struct serial_ops *ops;	/* Function vector */
+    void *state;       		/* Local context info for open FD */
     serial_ttystate ttystate;	/* Not used (yet) */
     int bufcnt;			/* Amount of data in receive buffer */
     unsigned char *bufp;	/* Current byte */
diff --git a/gdb/target.c b/gdb/target.c
index 9ba43fd..3c18b40 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -962,7 +962,8 @@ target_preopen (from_tty)
 
   if (target_has_execution)
     {
-      if (query ("A program is being debugged already.  Kill it? "))
+      if (!from_tty
+          || query ("A program is being debugged already.  Kill it? "))
 	target_kill ();
       else
 	error ("Program not killed.");
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 711e9f0..acf71ac 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,19 @@
+Tue Jul 13 23:37:18 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+	* gdb.base/configure.in: Check for gdbvars.exp instead of
+ 	a1-selftest.exp.
+	* gdb.base/configure: Re-generate.
+
+1999-07-12  Stan Shebs  <shebs@andros.cygnus.com>
+
+	* gdb.base/selftest.exp: Rename from a1-selftest.exp, no point
+	in trying to run first and name is too long.
+
+	* gdb.base/pointers.c, gdb.base/pointers.exp: Add contents of
+	pointers2.c and pointers2.exp, respectively.
+	* gdb.base/pointers2.c, gdb.base/pointers2.exp: Remove, makes
+	doschk happier.
+
 1999-07-08  Stan Shebs  <shebs@andros.cygnus.com>
 
 	* gdb.base/callfwmall.c, gdb.base/callfwmall.exp: Renamed from
diff --git a/gdb/testsuite/gdb.base/configure b/gdb/testsuite/gdb.base/configure
index 29e69bf..77d2d14 100644
--- a/gdb/testsuite/gdb.base/configure
+++ b/gdb/testsuite/gdb.base/configure
@@ -1,7 +1,7 @@
 #! /bin/sh
 
 # Guess values for system-dependent variables and create Makefiles.
-# Generated automatically using autoconf version 2.12.1 
+# Generated automatically using autoconf version 2.13 
 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
 #
 # This configure script is free software; the Free Software Foundation
@@ -333,7 +333,7 @@ EOF
     verbose=yes ;;
 
   -version | --version | --versio | --versi | --vers)
-    echo "configure generated by autoconf version 2.12.1"
+    echo "configure generated by autoconf version 2.13"
     exit 0 ;;
 
   -with-* | --with-*)
@@ -451,7 +451,7 @@ echo > confdefs.h
 
 # A filename unique to this package, relative to the directory that
 # configure is in, which we can look for to find out if srcdir is correct.
-ac_unique_file=a1-selftest.exp
+ac_unique_file=gdbvars.exp
 
 # Find the source files, if location was not specified.
 if test -z "$srcdir"; then
@@ -503,9 +503,11 @@ ac_ext=c
 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
-ac_link='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 cross_compiling=$ac_cv_prog_cc_cross
 
+ac_exeext=
+ac_objext=o
 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
@@ -569,7 +571,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:573: checking host system type" >&5
+echo "configure:575: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -590,7 +592,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:594: checking target system type" >&5
+echo "configure:596: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -608,7 +610,7 @@ target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$target" 1>&6
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:612: checking build system type" >&5
+echo "configure:614: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -654,7 +656,7 @@ EOF
 # Ultrix sh set writes to stderr and can't be redirected directly,
 # and sets the high bit in the cache file unless we assign to the vars.
 (set) 2>&1 |
-  case `(ac_space=' '; set) 2>&1 | grep ac_space` in
+  case `(ac_space=' '; set | grep ac_space) 2>&1` in
   *ac_space=\ *)
     # `set' does not quote correctly, so add quotes (double-quote substitution
     # turns \\\\ into \\, and sed turns \\ into \).
@@ -733,7 +735,7 @@ do
     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
-    echo "$CONFIG_STATUS generated by autoconf version 2.12.1"
+    echo "$CONFIG_STATUS generated by autoconf version 2.13"
     exit 0 ;;
   -help | --help | --hel | --he | --h)
     echo "\$ac_cs_usage"; exit 0 ;;
@@ -756,6 +758,7 @@ s%@SHELL@%$SHELL%g
 s%@CFLAGS@%$CFLAGS%g
 s%@CPPFLAGS@%$CPPFLAGS%g
 s%@CXXFLAGS@%$CXXFLAGS%g
+s%@FFLAGS@%$FFLAGS%g
 s%@DEFS@%$DEFS%g
 s%@LDFLAGS@%$LDFLAGS%g
 s%@LIBS@%$LIBS%g
diff --git a/gdb/testsuite/gdb.base/configure.in b/gdb/testsuite/gdb.base/configure.in
index e5bcb19..7c4e397 100644
--- a/gdb/testsuite/gdb.base/configure.in
+++ b/gdb/testsuite/gdb.base/configure.in
@@ -5,7 +5,7 @@ dnl script appropriate for this directory.  For more information, check
 dnl any existing configure script.
 
 AC_PREREQ(2.5)
-AC_INIT(a1-selftest.exp)
+AC_INIT(gdbvars.exp)
 
 CC=${CC-cc}
 AC_SUBST(CC)
diff --git a/gdb/testsuite/gdb.base/maint.exp b/gdb/testsuite/gdb.base/maint.exp
index ba59ed1..29e3134 100644
--- a/gdb/testsuite/gdb.base/maint.exp
+++ b/gdb/testsuite/gdb.base/maint.exp
@@ -176,29 +176,41 @@ gdb_expect  {
         }
 
 send_gdb "maint print objfiles\n"
+
 # To avoid timeouts, we avoid expects with many .* patterns that match
-# many lines.
-gdb_expect  {
-    -re ".*Object file.*break:  Objfile at $hex, bfd at $hex, \[0-9\]* minsyms\[\r\t \]+\n"
-                            { pass "maint print objfiles: header" }
-    -re ".*$gdb_prompt $"   { fail "maint print objfiles: header" }
-    timeout                 { fail "(timeout) maint print objfiles: header" }
-}
-gdb_expect {
-    -re ".*Psymtabs:\[\r\t \]+\n" { pass "maint print objfiles: psymtabs" }
-    -re ".*$gdb_prompt $"         { fail "maint print objfiles: psymtabs" }
-    timeout                { fail "(timeout) maint print objfiles: psymtabs" }
-}
-gdb_expect {
-    -re ".*Symtabs:\[\r\t \]+\n"  { pass "maint print objfiles: symtabs" }
-    -re ".*$gdb_prompt $"         { fail "maint print objfiles: symtabs" }
-    timeout                { fail "(timeout) maint print objfiles: symtabs" }
+# many lines.  Instead, we keep track of which milestones we've seen
+# in the output, and stop when we've seen all of them.
+
+set header 0
+set psymtabs 0
+set symtabs 0
+set keep_looking 1
+
+while {$keep_looking} {
+    gdb_expect  {
+
+	-re ".*Object file.*break:  Objfile at $hex, bfd at $hex, \[0-9\]* minsyms\[\r\t \]+\n" { set header 1 }
+	-re ".*Psymtabs:\[\r\t \]+\n" { set psymtabs 1 }
+	-re ".*Symtabs:\[\r\t \]+\n" { set symtabs 1 }
+
+	-re ".*$gdb_prompt $" { 
+	    set keep_looking 0
+	}
+	timeout { 
+	    fail "(timeout) maint print objfiles" 
+	    set keep_looking 0
+	}
+    }
 }
-gdb_expect {
-    -re ".*$gdb_prompt $"   { pass "maint print objfiles: prompt" }
-    timeout                 { fail "(timeout) maint print objfiles: prompt" }
+
+proc maint_pass_if {val name} {
+    if $val { pass $name } else { fail $name }
 }
 
+maint_pass_if $header   "maint print objfiles: header"
+maint_pass_if $psymtabs "maint print objfiles: psymtabs"
+maint_pass_if $symtabs  "maint print objfiles: symtabs"
+
 send_gdb "maint print psymbols\n"
 gdb_expect  {
         -re "print-psymbols takes an output file name and optional symbol file name.*$gdb_prompt $"\
@@ -282,6 +294,13 @@ gdb_expect  {
         timeout         { fail "(timeout) maint print symbols w/o args" }
         }
 
+# This command can legitimately take many minutes to execute.  If the
+# executable is dynamically linked, then you get all the debugging
+# info for the entire library --- 89Mb on my system.  -jimb
+
+set old_timeout $timeout
+set timeout 600
+
 send_gdb "maint print symbols symbols_output\n"
 gdb_expect  {
         -re "^maint print symbols symbols_output\r\n$gdb_prompt $"\
@@ -291,7 +310,7 @@ gdb_expect  {
                 -re "symbols_output\r\n$gdb_prompt $"\
                  {
 	          # See comments for `maint print psymbols'.
-                  send_gdb "shell grep 'main.*block' symbols_output\n"
+                  send_gdb "shell grep 'main(.*block' symbols_output\n"
                   gdb_expect {
                         -re "int main\\(int, char \\*\\*, char \\*\\*\\); block.*$gdb_prompt $"\
                                                { pass "maint print symbols" }
@@ -309,6 +328,7 @@ gdb_expect  {
         timeout         { fail "(timeout) maint print symbols" }
         }
 
+set timeout $old_timeout
 
 send_gdb "maint print type argc\n"
 gdb_expect  {
@@ -356,7 +376,9 @@ gdb_expect {
 }
 
 # Try it again, and check for shlib event info.  Not supported everywhere.
-if {! [istarget "hppa*-*-hpux*"]} then {
+if {! ([istarget "hppa*-*-hpux*"] 
+       || [istarget "*-*-linux*"]
+       || [istarget "*-*-solaris*"])} then {
     setup_xfail "*-*-*"
 }
 send_gdb "maint info breakpoints\n"
diff --git a/gdb/testsuite/gdb.base/pointers.c b/gdb/testsuite/gdb.base/pointers.c
index 8cac2c2..60e6444 100644
--- a/gdb/testsuite/gdb.base/pointers.c
+++ b/gdb/testsuite/gdb.base/pointers.c
@@ -97,7 +97,9 @@ int main ()
   v_unsigned_int_pointer = v_double_pointer;
   
   v_unsigned_int_pointer = v_unsigned_int;*/
-  
+
+  more_code ();
+
   return 0;
   
 }
@@ -172,5 +174,49 @@ void dummy()
 
 }
 
+void marker1 ()
+{
+}
 
-
+int more_code()
+{
+    char C, *pC, **ppC, ***pppC, ****ppppC, *****pppppC, ******ppppppC;
+    unsigned char UC, *pUC;
+    short S, *pS;
+    unsigned short US, *pUS;
+    int I, *pI;
+    unsigned int UI, *pUI;
+    long L, *pL;
+    unsigned long UL, *pUL;
+    float F, *pF;
+    double D, *pD;
+
+    C = 'A';
+    UC = 21;
+    S = -14;
+    US = 7;
+    I = 102;
+    UI = 1002;
+    L = -234;
+    UL = 234;
+    F = 1.25E10;
+    D = -1.375E-123;
+    pC = &C;
+    ppC = &pC;
+    pppC = &ppC;
+    ppppC = &pppC;
+    pppppC = &ppppC;
+    ppppppC = &pppppC;
+    pUC = &UC;
+    pS = &S;
+    pUS = &US;
+    pI = &I;
+    pUI = &UI;
+    pL = &L;
+    pUL = &UL;
+    pF = &F;
+    pD = &D;
+    
+    marker1();
+    return 0;
+}
diff --git a/gdb/testsuite/gdb.base/pointers.exp b/gdb/testsuite/gdb.base/pointers.exp
index 6b9f135..bccda66 100644
--- a/gdb/testsuite/gdb.base/pointers.exp
+++ b/gdb/testsuite/gdb.base/pointers.exp
@@ -62,7 +62,7 @@ if ![runto_main] then {
     continue
 }
 
-gdb_test "next" "return 0;" "continuing after dummy()"
+gdb_test "next" "" "continuing after dummy()"
 
 
 #
@@ -359,3 +359,233 @@ gdb_expect {
     -re ".*$gdb_prompt $" { fail "print through ptr to ptr" }
     timeout           { fail "(timeout) print through ptr to ptr" }    
   }
+
+# tests for pointers 
+# with elementary type variables and pointers.
+# 
+
+send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $"
+
+    send_gdb "cont\n"
+    gdb_expect {
+        -re "Break.* marker1 \\(\\) at .*:$decimal.*$gdb_prompt $" {
+            send_gdb "up\n"
+            gdb_expect {
+                -re ".*$gdb_prompt $" {}
+                timeout { fail "up from marker1" }
+            }
+        }
+        -re "$gdb_prompt $" { fail "continue to marker1"  }
+        timeout { fail "(timeout) continue to marker1"  }
+    }
+
+
+send_gdb "print *pUC\n"
+gdb_expect {
+    -re ".\[0-9\]* = 21 \'.025\'.*$gdb_prompt $" {
+        pass "print value of *pUC"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pUC" }
+    timeout           { fail "(timeout) print value of *pUC" }
+  }
+
+
+send_gdb "ptype pUC\n"
+gdb_expect {
+    -re "type = unsigned char \\*.*$gdb_prompt $"  { pass "ptype pUC" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pUC" }
+    timeout             { fail "(timeout) ptype pUC" }
+}
+
+send_gdb "print *pS\n"
+gdb_expect {
+    -re ".\[0-9\]* = -14.*$gdb_prompt $" {
+        pass "print value of *pS"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pS" }
+    timeout           { fail "(timeout) print value of *pS" }
+  }
+
+
+send_gdb "ptype pS\n"
+gdb_expect {
+    -re "type = short \\*.*$gdb_prompt $"  { pass "ptype pS" }
+    -re "type = short int \\*.*$gdb_prompt $"  { pass "ptype pS" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pS" }
+    timeout             { fail "(timeout) ptype pS" }
+}
+
+send_gdb "print *pUS\n"
+gdb_expect {
+    -re ".\[0-9\]* = 7.*$gdb_prompt $" {
+        pass "print value of *pUS"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pUS" }
+    timeout           { fail "(timeout) print value of *pUS" }
+  }
+
+
+send_gdb "ptype pUS\n"
+gdb_expect {
+    -re "type = unsigned short \\*.*$gdb_prompt $"  { pass "ptype pUS" }
+    -re "type = short unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUS" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pUS" }
+    timeout             { fail "(timeout) ptype pUS" }
+}
+
+send_gdb "print *pI\n"
+gdb_expect {
+    -re ".\[0-9\]* = 102.*$gdb_prompt $" {
+        pass "print value of *pI"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pI" }
+    timeout           { fail "(timeout) print value of *pI" }
+  }
+
+
+send_gdb "ptype pI\n"
+gdb_expect {
+    -re "type = int \\*.*$gdb_prompt $"  { pass "ptype pI" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pI" }
+    timeout             { fail "(timeout) ptype pI" }
+}
+
+send_gdb "print *pUI\n"
+gdb_expect {
+    -re ".\[0-9\]* = 1002.*$gdb_prompt $" {
+        pass "print value of *pUI"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pUI" }
+    timeout           { fail "(timeout) print value of *pUI" }
+  }
+
+
+send_gdb "ptype pUI\n"
+gdb_expect {
+    -re "type = unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUI" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pUI" }
+    timeout             { fail "(timeout) ptype pUI" }
+}
+
+send_gdb "print *pL\n"
+gdb_expect {
+    -re ".\[0-9\]* = -234.*$gdb_prompt $" {
+        pass "print value of *pL"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pL" }
+    timeout           { fail "(timeout) print value of *pL" }
+  }
+
+
+send_gdb "ptype pL\n"
+gdb_expect {
+    -re "type = long \\*.*$gdb_prompt $"  { pass "ptype pL" }
+    -re "type = long int \\*.*$gdb_prompt $"  { pass "ptype pL" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pL" }
+    timeout             { fail "(timeout) ptype pL" }
+}
+
+send_gdb "print *pUL\n"
+gdb_expect {
+    -re ".\[0-9\]* = 234.*$gdb_prompt $" {
+        pass "print value of *pUL"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pUL" }
+    timeout           { fail "(timeout) print value of *pUL" }
+  }
+
+
+send_gdb "ptype pUL\n"
+gdb_expect {
+    -re "type = unsigned long \\*.*$gdb_prompt $"  { pass "ptype pUL" }
+    -re "type = long unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUL" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pUL" }
+    timeout             { fail "(timeout) ptype pUL" }
+}
+
+send_gdb "print *pF\n"
+gdb_expect {
+    -re ".\[0-9\]* = 1.2\[0-9\]*e\\+10.*$gdb_prompt $" {
+        pass "print value of *pF"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pF" }
+    timeout           { fail "(timeout) print value of *pF" }
+  }
+
+
+send_gdb "ptype pF\n"
+gdb_expect {
+    -re "type = float \\*.*$gdb_prompt $"  { pass "ptype pF" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pF" }
+    timeout             { fail "(timeout) ptype pF" }
+}
+
+send_gdb "print *pD\n"
+gdb_expect {
+    -re ".\[0-9\]* = -1.375e-123.*$gdb_prompt $" {
+        pass "print value of *pD"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of *pD" }
+    timeout           { fail "(timeout) print value of *pD" }
+  }
+
+
+send_gdb "ptype pD\n"
+gdb_expect {
+    -re "type = double \\*.*$gdb_prompt $"  { pass "ptype pD" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pD" }
+    timeout             { fail "(timeout) ptype pD" }
+}
+
+send_gdb "print ******ppppppC\n"
+gdb_expect {
+    -re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {
+        pass "print value of ******ppppppC"
+      }
+    -re ".*$gdb_prompt $" { fail "print value of ******ppppppC" }
+    timeout           { fail "(timeout) print value of ******ppppppC" }
+  }
+
+
+send_gdb "ptype pC\n"
+gdb_expect {
+    -re "type = char \\*.*$gdb_prompt $"  { pass "ptype pC" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pC" }
+    timeout             { fail "(timeout) ptype pC" }
+}
+
+send_gdb "ptype ppC\n"
+gdb_expect {
+    -re "type = char \\*\\*.*$gdb_prompt $"  { pass "ptype ppC" }
+    -re ".*$gdb_prompt $"   {  fail "ptype ppC" }
+    timeout             { fail "(timeout) ptype ppC" }
+}
+
+send_gdb "ptype pppC\n"
+gdb_expect {
+    -re "type = char \\*\\*\\*.*$gdb_prompt $"  { pass "ptype  pppC" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pppC" }
+    timeout             { fail "(timeout) ptype pppC" }
+}
+
+send_gdb "ptype ppppC\n"
+gdb_expect {
+    -re "type = char \\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype ppppC" }
+    -re ".*$gdb_prompt $"   {  fail "ptype ppppC" }
+    timeout             { fail "(timeout) ptype ppppC" }
+}
+
+send_gdb "ptype pppppC\n"
+gdb_expect {
+    -re "type = char \\*\\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype pppppC" }
+    -re ".*$gdb_prompt $"   {  fail "ptype pppppC" }
+    timeout             { fail "(timeout) ptype pppppC" }
+}
+
+send_gdb "ptype ppppppC\n"
+gdb_expect {
+    -re "type = char \\*\\*\\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype ppppppC" }
+    -re ".*$gdb_prompt $"   {  fail "ptype ppppppC" }
+    timeout             { fail "(timeout) ptype ppppppC" }
+}
+
diff --git a/gdb/testsuite/gdb.base/selftest.exp b/gdb/testsuite/gdb.base/selftest.exp
new file mode 100644
index 0000000..c0d17c8
--- /dev/null
+++ b/gdb/testsuite/gdb.base/selftest.exp
@@ -0,0 +1,430 @@
+#   Copyright (C) 1988, 1990, 1991, 1992, 1994, 1997 Free Software Foundation, Inc.
+
+# 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.  
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gdb@prep.ai.mit.edu
+
+# This file was written by Rob Savoye. (rob@cygnus.com)
+
+if $tracelevel then {
+    strace $tracelevel
+}
+
+set prms_id 0
+set bug_id 0
+
+# are we on a target board
+if [is_remote target] {
+    return
+}
+
+if [istarget "m68k*-*-hpux*"] then {
+    # The top-level makefile passes CFLAGS= (no -g) for hp300.  This probably
+    # should be fixed (it is only needed for gcc bootstrapping, not gdb),
+    # but until then.....
+    setup_xfail "*-*-*"
+    fail "cannot test self if compiled without debug info"
+    return -1
+}
+
+# Not all of the lines of code near the start of main are executed for
+# every machine.  Also, optimization may reorder some of the lines.
+# So all we do is try to step or next over everything until we get
+# to a line that we know is always executed.
+
+proc do_steps_and_nexts {} {
+    global gdb_prompt
+    global srcdir
+ 
+    gdb_reinitialize_dir $srcdir/..
+
+    for {set count 0} {$count < 20} {incr count} {
+	send_gdb "list\n"
+	gdb_expect {
+	    -re ".*symarg = NULL.*$gdb_prompt $" {
+		set description "step over symarg initialization"
+		set command "step"
+	    }
+	    -re ".*execarg = NULL.*$gdb_prompt $" {
+		set description "step over execarg initialization"
+		set command "step"
+	    }
+	    -re ".*corearg = NULL.*$gdb_prompt $" {
+		set description "step over corearg initialization"
+		set command "step"
+	    }
+	    -re ".*cdarg = NULL.*$gdb_prompt $" {
+		set description "step over cdarg initialization"
+		set command "step"
+	    }
+	    -re ".*ttyarg = NULL.*$gdb_prompt $" {
+		set description "step over ttyarg initialization"
+		set command "step"
+	    }
+	    -re ".*interparg = NULL.*$gdb_prompt $" {
+		set description "step over interparg initialization"
+		set command "step"
+	    }
+	    -re ".*time_at_startup = get_run_time.*$gdb_prompt $" {
+		set description "next over get_run_time and everything it calls"
+		set command "next"
+	    }
+	    -re ".*START_PROGRESS.*$gdb_prompt $" {
+		set description "next over START_PROGRESS and everything it calls"
+		set command "next"
+	    }
+	    -re ".*mac_init.*$gdb_prompt $" {
+		set description "next over mac_init and everything it calls"
+		set command "next"
+	    }
+	    -re ".*init_malloc.*$gdb_prompt $" {
+		set description "next over init_malloc and everything it calls"
+		set command "next"
+	    }
+	    -re ".*count . 0x3.*$gdb_prompt $" {
+		set description "next over conditional stack alignment code 1"
+		set command "next"
+	    }
+	    -re ".*if .i != 0.*$gdb_prompt $" {
+		set description "next over conditional stack alignment code 2"
+		set command "next"
+	    }
+	    -re ".*alloca .i - 4.*$gdb_prompt $" {
+		set description "next over conditional stack alignment alloca"
+		set command "next"
+	    }
+	    -re ".*SET_TOP_LEVEL.*$gdb_prompt $" {
+		set description "next over SET_TOP_LEVEL call"
+		set command "next"
+	    }
+	    -re ".*cmdsize = 1.*$gdb_prompt $" {
+		set description "step over cmdsize initialization"
+		set command "next"
+	    }
+	    -re ".*cmdarg = .* xmalloc.*$gdb_prompt $" {
+		set description "next over cmdarg initialization via xmalloc"
+		set command "next"
+	    }
+	    -re ".*ncmd = 0.*$gdb_prompt $" {
+		set description "next over ncmd initialization"
+		set command "next"
+	    }
+	    -re ".*dirsize = 1.*$gdb_prompt $" {
+		set description "next over dirsize initialization"
+		set command "next"
+	    }
+	    -re ".*dirarg = .* xmalloc.*$gdb_prompt $" {
+		return
+	    }
+	    -re "\[ \t\]+\{\r\n$gdb_prompt $" {
+		setup_xfail "mips-*-irix5*"
+		fail "$description ended up at odd location"
+	    }
+	    -re ".*main.c.*No such file or directory.*$gdb_prompt $" {
+		setup_xfail "rs6000-*-aix3*"
+		fail "must be able to list source lines"
+		return
+	    }
+	    -re ".*$gdb_prompt $" {
+		fail "unknown source line after $description"
+		return
+	    }
+	    default {
+		fail "unknown source line near main"
+		return
+	    }
+	}
+	send_gdb "$command\n"
+	gdb_expect {
+	    -re ".*No such file or directory.\r\n$gdb_prompt $" {
+		fail "$description (no source available)"
+	    }
+	    -re ".*A file or directory .* does not exist..\r\n$gdb_prompt $" {
+		fail "$description (no source available)"
+	    }
+	    -re ".*$gdb_prompt $" {
+		pass "$description"
+	    }
+	    timeout {
+		fail "$description (timeout)"
+	    }
+	}
+    }
+}
+
+proc test_with_self { executable } {
+    global gdb_prompt
+    global tool
+    global det_file
+    global decimal
+    global timeout
+
+    # load yourself into the debugger
+    # This can take a relatively long time, particularly for testing where
+    # the executable is being accessed over a network, or where gdb does not
+    # support partial symbols for a particular target and has to load the
+    # entire symbol table.  Set the timeout to 10 minutes, which should be
+    # adequate for most environments (it *has* timed out with 5 min on a
+    # SPARCstation SLC under moderate load, so this isn't unreasonable).
+    # After gdb is started, set the timeout to 30 seconds for the duration
+    # of this test, and then back to the original value.
+
+    set oldtimeout $timeout
+    set timeout 600
+    verbose "Timeout is now $timeout seconds" 2
+    if {[gdb_load $executable] <0} then {
+	set timeout $oldtimeout
+	verbose "Timeout is now $timeout seconds" 2
+	return -1
+    }
+    set timeout $oldtimeout
+    verbose "Timeout is now $timeout seconds" 2
+
+    # disassemble yourself
+    gdb_test "x/10i main" \
+	    "x/10i.*main.*main.$decimal.*main.$decimal.*" \
+	    "Disassemble main"
+
+    # Set a breakpoint at main
+    gdb_test "break main" \
+	    "Breakpoint.*at.* file.*, line.*" \
+	    "breakpoint in main"
+
+    # We'll need this when we send a ^C to GDB.  Need to do it before we
+    # run the program and gdb starts saving and restoring tty states.
+    # On Ultrix, we don't need it and it is really slow (because shell_escape
+    # doesn't use vfork).
+    if ![istarget "*-*-ultrix*"] then {
+	gdb_test "shell stty intr '^C'" "" \
+	    "set interrupt character in test_with_self"
+    }
+
+    # FIXME: If we put this after the run to main, the first list
+    # command doesn't print the same line as the current line where
+    # gdb is stopped.
+    gdb_test "set listsize 1" "" "set listsize to 1"
+
+    # run yourself
+    # It may take a very long time for the inferior gdb to start (lynx),
+    # so we bump it back up for the duration of this command.
+    set timeout 600
+
+    set description "run until breakpoint at main"
+    send_gdb "run -nw\n"
+    gdb_expect {
+	-re "Starting program.*Breakpoint \[0-9\]+,.*main .argc.*argv.* at .*main.c:.*$gdb_prompt $" {
+	    pass "$description"
+	}
+	-re "Starting program.*Breakpoint \[0-9\]+,.*main .argc.*argv.*$gdb_prompt $" {
+	    xfail "$description (line numbers scrambled?)"
+	}
+	-re "vfork: No more processes.*$gdb_prompt $" {
+	    fail "$description (out of virtual memory)"
+	    set timeout $oldtimeout
+	    verbose "Timeout is now $timeout seconds" 2
+	    return -1
+	}
+	-re ".*$gdb_prompt $" {
+	    fail "$description"
+	    set timeout $oldtimeout
+	    verbose "Timeout is now $timeout seconds" 2
+	    return -1
+	}
+	timeout {
+	    fail "$description (timeout)"
+	}
+    }
+
+    set timeout $oldtimeout
+    verbose "Timeout is now $timeout seconds" 2
+
+    # do we have a version number ?
+    send_gdb "print version\n"
+    gdb_expect {
+	-re ".\[0-9\]+ = +0x.*\[0-9.\]+.*$gdb_prompt $" {
+	    pass "printed version"
+	}
+	-re ".\[0-9\]+ = +.+ +0x.*\[0-9.\]+.*$gdb_prompt $" {
+	    pass "printed version with cast"
+	}
+	-re ".*$gdb_prompt $"	{ fail "printed version" }
+	timeout		{ fail "(timeout) printed version" }
+    }
+
+    do_steps_and_nexts
+
+    gdb_test "print \"foo\"" ".\[0-9\]+ = \"foo\"" "print a string"
+
+    # do_steps_and_nexts left us ready to execute an xmalloc call,
+    # so give that a try.
+    # If we don't actually enter the xmalloc call when we give a
+    # step command that seems like a genuine bug.  It seems to happen
+    # on most RISC processors.
+    setup_xfail "alpha-*-*" "mips-*-*"
+    set description "step into xmalloc call"
+    send_gdb "step\n"
+    gdb_expect {
+	-re "xmalloc.*size=.*at.*utils.c.*$gdb_prompt $" {
+	    pass "$description"
+	}
+	-re ".*No such file or directory.\r\n$gdb_prompt $" {
+	    pass "$description (no source available)"
+	}
+	-re "A file or directory .* does not exist..\r\n$gdb_prompt $" {
+	    pass "$description (no source available)"
+	}
+	-re ".*$gdb_prompt $" {
+	    fail "$description"
+	}
+	timeout {
+	    fail "$description (timeout)"
+	}
+    }
+
+    # start the "xgdb" process
+    send_gdb "continue\n"
+    gdb_expect {
+	-re "GNU gdb \[0-9\.\]*.*
+Copyright \[0-9\]* Free Software Foundation, Inc.*
+GDB is free software, covered by the GNU General Public License, and you are.*
+welcome to change it and/or distribute copies of it under certain conditions.*
+Type \"show copying\" to see the conditions.*
+There is absolutely no warranty for GDB.  Type \"show warranty\" for details.*
+This GDB was configured as .*$gdb_prompt $"\
+	    { pass "xgdb is at prompt" }
+	-re "GDB is free software and you are welcome to distribute copies of it.*
+ under certain conditions; type \"show copying\" to see the conditions..*
+There is absolutely no warranty for GDB; type \"show warranty\" for details..*
+GDB.*Copyright \[0-9\]+ Free Software Foundation, Inc..*$gdb_prompt $"\
+	    { pass "xgdb is at prompt (obsolescent gdb)" }
+	-re ".*$gdb_prompt $"       { fail "xgdb is at prompt" }
+	timeout	            { fail "(timeout) xgdb is at prompt" }
+    }
+    
+    # set xgdb prompt so we can tell which is which
+    send_gdb "set prompt (xgdb) \n"
+    gdb_expect {
+	-re "\[(\]xgdb\[)\].*\[(\]xgdb\[)\] $"	{ pass "Set xgdb prompt" }
+	-re ".*$gdb_prompt $"		{ fail "Set xgdb prompt" }
+	default				{ fail "(timeout) Set xgdb prompt" }
+    }
+    
+    # kill the xgdb process
+    set description "send ^C to child process"
+    send_gdb "\003"
+    gdb_expect {
+	-re "Program received signal SIGINT.*$gdb_prompt $" {
+	    pass "$description"
+	}
+	-re ".*$gdb_prompt $" {
+	    fail "$description"
+	}
+	timeout {
+	    fail "$description (timeout)"
+	}
+    }
+    
+    set description "send SIGINT signal to child process"
+    send_gdb "signal SIGINT\n"
+    gdb_expect {
+	-re "Continuing with signal SIGINT.*$gdb_prompt $" {
+	    pass "$description"
+	}
+	-re ".*$gdb_prompt $" {
+	    fail "$description"
+	}
+	timeout {
+	    fail "$description (timeout)"
+	}
+    }
+    
+    # get a stack trace
+    #
+    # This fails on some linux systems for unknown reasons.  On the
+    # systems where it fails, sometimes it works fine when run manually.
+    # The testsuite failures may not be limited to just aout systems.
+    setup_xfail "i*86-pc-linuxaout-gnu" "hppa*-*-hpux*"
+    set description "backtrace through signal handler"
+    send_gdb "backtrace\n"
+    gdb_expect {
+	-re "#0.*read.*in main \\(.*\\) at .*main\\.c.*$gdb_prompt $" {
+	    pass "$description"
+	}
+	-re ".*$gdb_prompt $" {
+	    # On the alpha, we hit the infamous problem about gdb
+	    # being unable to get the frame pointer (mentioned in
+	    # gdb/README).  As it is intermittent, there is no way to
+	    # XFAIL it which will give us an XPASS if the problem goes
+	    # away.
+	    setup_xfail "alpha*-*-osf*"
+	    fail "$description"
+	}
+	timeout {
+	    fail "$description (timeout)"
+	}
+    }
+
+
+    # Set the timeout back to the value it had when we were called.
+    set timeout $oldtimeout
+    verbose "Timeout is now $timeout seconds" 2
+
+    # Restart gdb in case next test expects it to be started already.
+    return 0
+}
+
+# Find a pathname to a file that we would execute if the shell was asked
+# to run $arg using the current PATH.
+
+proc find_gdb { arg } {
+
+    # If the arg directly specifies an existing executable file, then
+    # simply use it.
+
+    if [file executable $arg] then {
+	return $arg
+    }
+
+    set result [which $arg]
+    if [string match "/" [ string range $result 0 0 ]] then {
+	return $result
+    }
+
+    # If everything fails, just return the unqualified pathname as default
+    # and hope for best.
+
+    return $arg
+}
+
+# Run the test with self.
+# Copy the file executable file in case this OS doesn't like to edit its own
+# text space.
+
+set GDB_FULLPATH [find_gdb $GDB]
+
+# Remove any old copy lying around.
+remote_file host delete x$tool
+
+gdb_start
+set file [remote_download host $GDB_FULLPATH x$tool]
+set result [test_with_self $file];
+gdb_exit;
+catch "remote_file host delete $file";
+
+if {$result <0} then {
+    warning "Couldn't test self"
+    return -1
+}
diff --git a/gdb/testsuite/gdb.c++/derivation.exp b/gdb/testsuite/gdb.c++/derivation.exp
index 80baf75..657b166 100644
--- a/gdb/testsuite/gdb.c++/derivation.exp
+++ b/gdb/testsuite/gdb.c++/derivation.exp
@@ -1,4 +1,4 @@
-# Copyright (C) 1998 Free Software Foundation, Inc.
+# Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 
 # 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
@@ -265,6 +265,10 @@ gdb_expect {
 
 send_gdb "print g_instance.a\n"
 gdb_expect {
+    -re "warning.*$gdb_prompt $" {
+	# The compiler doesn't think this is ambiguous.
+	fail "print value of g_instance.a"
+    }
     -re ".\[0-9\]* = 15.*$gdb_prompt $" {
         pass "print value of g_instance.a"
       }
@@ -274,6 +278,10 @@ gdb_expect {
 
 send_gdb "print g_instance.b\n"
 gdb_expect {
+    -re "warning.*$gdb_prompt $" {
+	# The compiler doesn't think this is ambiguous.
+	fail "print value of g_instance.b"
+    }
     -re ".\[0-9\]* = 16.*$gdb_prompt $" {
         pass "print value of g_instance.b"
       }
@@ -283,6 +291,10 @@ gdb_expect {
 
 send_gdb "print g_instance.c\n"
 gdb_expect {
+    -re "warning.*$gdb_prompt $" {
+	# The compiler doesn't think this is ambiguous.
+	fail "print value of g_instance.c"
+    }
     -re ".\[0-9\]* = 17.*$gdb_prompt $" {
         pass "print value of g_instance.c"
       }