* rs6000-tdep.c: Changes throughout for multi-arch 64-bit

	support.  Incorporate most of tm-rs6000.h.
	(find_toc_address_hook): Rename to rs6000_find_toc_address_hook.
	(rs6000_set_host_arch_hook): Declare.
	(read_memory_addr): Define.
	(pop_frame): Rename to rs6000_pop_frame.
	(rs6000_pop_frame, rs6000_fix_call_dummy, rs6000_push_arguments,
	rs6000_frame_saved_pc, rs6000_frame_chain): Remove non-generic
	dummy frame handling.
	(branch_dest, rs6000_pop_frame, rs6000_skip_trampoline_code,
	rs6000_frame_saved_pc, frame_get_saved_regs,
	frame_initial_stack_address, rs6000_frame_chain,
	rs6000_convert_from_func_ptr_addr): Call read_memory_addr instead
	of read_memory_integer.
	(branch_dest, rs6000_pop_frame, rs6000_push_arguments,
	rs6000_skip_trampoline_code, rs6000_frame_saved_pc,
	frame_get_saved_regs, frame_initial_stack_address,
	rs6000_frame_chain): Replace 4 with TDEP->wordsize.
	(skip_prologue): Recognize some 64-bit stack adjustments.
	(push_dummy_frame, pop_dummy_frame, set_processor,
	show_processor): Delete.
	(frame_get_saved_regs): Manipulate saved register addresses using
	CORE_ADDR instead of int.
	(rs6000_create_inferior): New function.
	(register_names_*[]): Change to struct reg registers_*[].
	(variants[]): Assimilate into multi-arch approach.
	(register_names_*[], variants[]): Refer to pre-PowerPC
	architectures as POWER instead of RS6000.
	* rs6000-nat.c: Ubiquitous changes for 64-bit support.
	(vmap_secs, xcoff_relocate_symtab): Cast addresses
	to unsigned long to avoid sign-extension errors.
	(set_host_arch): New function.
	(xcoff_relocate_symtab): Try disabling usleep(36000) workaround.
	(rs6000_core_fns): Use new bfd_target_xcoff_flavour.
	(_initialize_core_rs6000): Initialize rs6000_set_host_arch_hook.
	* symfile.c (find_sym_fns): Remove special xcoff kludge.
	* xcoffread.c (secnum_to_bfd_section): Initialize args.objfile.
	(process_linenos): Query line struct size from coff
	backend instead of using compile-time constant.
	(enter_line_range): Likewise.
	(read_xcoff_symtab): Pass "XCOFF64" instead of "XCOFF" to
	record_debugformat() if appropriate.
	(process_xcoff_symbol): Access symbol addresses using
	SYMBOL_VALUE_ADDRESS instead of SYMBOL_VALUE.
	(read_symbol_lineno): Retrieve XCOFF64 symbol names from strtbl.
	(scan_xcoff_symtab): Likewise.  Query syment struct size from
	coff backend instead of using compile-time constant.
	(xcoff_sym_fns): Set flavour to bfd_target_xcoff_flavour.
	* Makefile.in (INTERNAL_LDFLAGS): Add $(MH_LDFLAGS) to list of flags
	that this Makefile variable get set to.  (From Kevin Buettner.)
	* config/powerpc/aix.mh (MH_LDFLAGS): Add linker flags so that
	the TOC doesn't overflow.  (From Kevin Buettner.)
	* config/powerpc/tm-ppc-aix.h: Move config decisions to
	multi-arched rs6000-tdep.c.
	* config/rs6000/tm-rs6000.h: Likewise.
	(GDB_MULTI_ARCH): Define.
	(skip_trampoline_code): Rename to rs6000_skip_trampoline_code.
	(is_magic_function_pointer): Replace with
	rs6000_convert_from_func_ptr_addr.
	(TARGET_CREATE_INFERIOR_HOOK): Define.
	(find_toc_address_hook): Rename to rs6000_find_toc_address_hook.
	(rs6000_set_host_arch_hook): Declare.
	* config/rs6000/nm-rs6000.h (CHILD_XFER_MEMORY): Define.

4 files changed, 24 insertions, 462 deletions

diff --git a/gdb/config/powerpc/aix.mh b/gdb/config/powerpc/aix.mh
index bac3e30..ba3e0c2 100644
--- a/gdb/config/powerpc/aix.mh
+++ b/gdb/config/powerpc/aix.mh
@@ -9,3 +9,6 @@ NATDEPFILES= fork-child.o infptrace.o inftarg.o corelow.o rs6000-nat.o xcoffread
 # When compiled with cc, for debugging, this argument should be passed.
 # We have no idea who our current compiler is though, so we skip it.
 # MH_CFLAGS = -bnodelcsect
+
+# gdb is too big for all of its external symbols to fit in a small TOC
+MH_LDFLAGS = -Wl,-bbigtoc
diff --git a/gdb/config/powerpc/tm-ppc-aix.h b/gdb/config/powerpc/tm-ppc-aix.h
index ae55e07..eae2362 100644
--- a/gdb/config/powerpc/tm-ppc-aix.h
+++ b/gdb/config/powerpc/tm-ppc-aix.h
@@ -24,23 +24,4 @@
 /* Use generic RS6000 definitions. */
 #include "rs6000/tm-rs6000.h"
 
-#define GDB_TARGET_POWERPC
-
-#undef PUSH_DUMMY_FRAME
-#define PUSH_DUMMY_FRAME             generic_push_dummy_frame ()
-
-#define PUSH_RETURN_ADDRESS(PC, SP)      ppc_push_return_address (PC, SP)
-
-/* override the standard get_saved_register function with 
-   one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
-      generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-
-#define USE_GENERIC_DUMMY_FRAMES 1
-#define CALL_DUMMY_BREAKPOINT_OFFSET (0)
-#define CALL_DUMMY_LOCATION          AT_ENTRY_POINT
-#define CALL_DUMMY_ADDRESS()         entry_point_address ()
-#undef CALL_DUMMY_START_OFFSET
-#define CALL_DUMMY_START_OFFSET      0
-
 #endif /* TM_PPC_AIX_H */
diff --git a/gdb/config/rs6000/nm-rs6000.h b/gdb/config/rs6000/nm-rs6000.h
index 3d237bc..66a8652 100644
--- a/gdb/config/rs6000/nm-rs6000.h
+++ b/gdb/config/rs6000/nm-rs6000.h
@@ -29,6 +29,10 @@
 
 #define FETCH_INFERIOR_REGISTERS
 
+/* Override child_xfer_memory in infptrace.c. */
+
+#define CHILD_XFER_MEMORY
+
 /* When a child process is just starting, we sneak in and relocate
    the symbol table (and other stuff) after the dynamic linker has
    figured out where they go.  */
diff --git a/gdb/config/rs6000/tm-rs6000.h b/gdb/config/rs6000/tm-rs6000.h
index 5bba778..8f45521 100644
--- a/gdb/config/rs6000/tm-rs6000.h
+++ b/gdb/config/rs6000/tm-rs6000.h
@@ -20,10 +20,7 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
-/* Forward decls for prototypes */
-struct frame_info;
-struct type;
-struct value;
+#define GDB_MULTI_ARCH 1
 
 /* Minimum possible text address in AIX */
 
@@ -34,83 +31,16 @@ struct value;
 #define	PC_LOAD_SEGMENT(PC)	pc_load_segment_name(PC)
 extern char *pc_load_segment_name (CORE_ADDR);
 
-/* AIX cc seems to get this right.  */
-
-#define BELIEVE_PCC_PROMOTION 1
-
-/* return true if a given `pc' value is in `call dummy' function. */
-/* FIXME: This just checks for the end of the stack, which is broken
-   for things like stepping through gcc nested function stubs.  */
-#define	PC_IN_CALL_DUMMY(STOP_PC, STOP_SP, STOP_FRAME_ADDR)	\
-	(STOP_SP < STOP_PC && STOP_PC < STACK_END_ADDR)
-
-#if 0
-extern unsigned int text_start, data_start;
-extern char *corefile;
-#endif
-extern int inferior_pid;
-
-/* We are missing register descriptions in the system header files. Sigh! */
-
-struct regs
-  {
-    int gregs[32];		/* general purpose registers */
-    int pc;			/* program conter       */
-    int ps;			/* processor status, or machine state */
-  };
-
-struct fp_status
-  {
-    double fpregs[32];		/* floating GP registers */
-  };
-
-
-/* To be used by skip_prologue. */
-
-struct rs6000_framedata
-  {
-    int offset;			/* total size of frame --- the distance
-				   by which we decrement sp to allocate
-				   the frame */
-    int saved_gpr;		/* smallest # of saved gpr */
-    int saved_fpr;		/* smallest # of saved fpr */
-    int alloca_reg;		/* alloca register number (frame ptr) */
-    char frameless;		/* true if frameless functions. */
-    char nosavedpc;		/* true if pc not saved. */
-    int gpr_offset;		/* offset of saved gprs from prev sp */
-    int fpr_offset;		/* offset of saved fprs from prev sp */
-    int lr_offset;		/* offset of saved lr */
-    int cr_offset;		/* offset of saved cr */
-  };
-
-/* Define the byte order of the machine.  */
-
-#define TARGET_BYTE_ORDER_DEFAULT	BIG_ENDIAN
-
 /* AIX's assembler doesn't grok dollar signs in identifiers.
    So we use dots instead.  This item must be coordinated with G++. */
 #undef CPLUS_MARKER
 #define CPLUS_MARKER '.'
 
-/* Offset from address of function to start of its code.
-   Zero on most machines.  */
-
-#define FUNCTION_START_OFFSET 0
-
-/* Advance PC across any function entry prologue instructions
-   to reach some "real" code.  */
-
-extern CORE_ADDR rs6000_skip_prologue (CORE_ADDR);
-#define SKIP_PROLOGUE(pc) (rs6000_skip_prologue (pc))
-
-extern CORE_ADDR skip_prologue (CORE_ADDR, struct rs6000_framedata *);
-
-
 /* If PC is in some function-call trampoline code, return the PC
    where the function itself actually starts.  If not, return NULL.  */
 
-#define	SKIP_TRAMPOLINE_CODE(pc)	skip_trampoline_code (pc)
-extern CORE_ADDR skip_trampoline_code (CORE_ADDR);
+#define	SKIP_TRAMPOLINE_CODE(pc)	rs6000_skip_trampoline_code (pc)
+extern CORE_ADDR rs6000_skip_trampoline_code (CORE_ADDR);
 
 /* Number of trap signals we need to skip over, once the inferior process
    starts running. */
@@ -138,57 +68,6 @@ extern CORE_ADDR skip_trampoline_code (CORE_ADDR);
 #define	PROCESS_LINENUMBER_HOOK()	aix_process_linenos ()
 extern void aix_process_linenos (void);
 
-/* Immediately after a function call, return the saved pc.
-   Can't go through the frames for this because on some machines
-   the new frame is not set up until the new function executes
-   some instructions.  */
-
-#define	SAVED_PC_AFTER_CALL(frame) read_register (LR_REGNUM)
-
-/* Address of end of stack space.  */
-
-#define STACK_END_ADDR 0x2ff80000
-
-/* Stack grows downward.  */
-
-#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
-
-/* This is how arguments pushed onto stack or passed in registers.
-   Stack must be aligned on 64-bit boundaries when synthesizing
-   function calls.  We don't need STACK_ALIGN, PUSH_ARGUMENTS will
-   handle it. */
-
-#define	PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
-  (rs6000_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
-extern CORE_ADDR rs6000_push_arguments (int, struct value **, CORE_ADDR, int,
-					CORE_ADDR);
-
-/* BREAKPOINT_FROM_PC uses the program counter value to determine the
-   breakpoint that should be used */
-extern breakpoint_from_pc_fn rs6000_breakpoint_from_pc;
-#define BREAKPOINT_FROM_PC(pcptr, lenptr) rs6000_breakpoint_from_pc (pcptr, lenptr)
-
-/* Amount PC must be decremented by after a breakpoint.
-   This is often the number of bytes in BREAKPOINT
-   but not always.  */
-
-#define DECR_PC_AFTER_BREAK 0
-
-/* Say how long (ordinary) registers are.  This is a piece of bogosity
-   used in push_word and a few other places; REGISTER_RAW_SIZE is the
-   real way to know how big a register is.  */
-#define REGISTER_SIZE 4
-
-
-/* Return the name of register number REG.  This may return "" to
-   indicate a register number that's not used on this variant.
-   (Register numbers may be sparse for consistency between variants.)  */
-#define REGISTER_NAME(reg) (rs6000_register_name(reg))
-extern char *rs6000_register_name (int reg);
-
-/* Number of machine registers */
-#define NUM_REGS 183
-
 /* Register numbers of various important registers.
    Note that some of these values are "real" register numbers,
    and correspond to the general registers of the machine,
@@ -196,331 +75,24 @@ extern char *rs6000_register_name (int reg);
    to be actual register numbers as far as the user is concerned
    but do serve to get the desired values when passed to read_register.  */
 
-#define FP_REGNUM 1		/* Contains address of executing stack frame */
-#define SP_REGNUM 1		/* Contains address of top of stack */
-#define	TOC_REGNUM 2		/* TOC register */
 #define FP0_REGNUM 32		/* Floating point register 0 */
-#define	GP0_REGNUM 0		/* GPR register 0 */
-#define FP0_REGNUM 32		/* FPR (Floating point) register 0 */
 #define FPLAST_REGNUM 63	/* Last floating point register */
 
-/* Special purpose registers... */
-/* P.S. keep these in the same order as in /usr/mstsave.h `mstsave'
-   structure, for easier processing */
-
-#define PC_REGNUM 64		/* Program counter (instruction address %iar) */
-#define PS_REGNUM 65		/* Processor (or machine) status (%msr) */
-#define	CR_REGNUM 66		/* Condition register */
-#define	LR_REGNUM 67		/* Link register */
-#define	CTR_REGNUM 68		/* Count register */
-#define	XER_REGNUM 69		/* Fixed point exception registers */
-#define	MQ_REGNUM 70		/* Multiply/quotient register */
-
 /* These #defines are used to parse core files and talk to ptrace, so they
    must remain fixed.  */
 #define	FIRST_UISA_SP_REGNUM 64	/* first special register number */
 #define LAST_UISA_SP_REGNUM  70	/* last special register number */
 
-/* This is the offset in REG_NAMES at which the `set processor'
-   command starts plugging in its names.  */
-#define FIRST_VARIANT_REGISTER 66
-
-/* Total amount of space needed to store our copies of the machine's
-   register state, the array `registers'.
-   32 4-byte gpr's
-   32 8-byte fpr's
-   7  4-byte UISA special purpose registers, 
-   16 4-byte segment registers,
-   32 4-byte standard OEA special-purpose registers,
-   and up to 64 4-byte non-standard OEA special purpose regs.
-   total: (+ (* 32 4) (* 32 8) (* 7 4) (* 16 4) (* 32 4) (* 64 4)) 860 bytes
-   Keep some extra space for now, in case to add more. */
-#define REGISTER_BYTES 880
-
-
-/* Index within `registers' of the first byte of the space for
-   register N.  */
-
-#define REGISTER_BYTE(N)  \
- (								\
-  ((N) > FPLAST_REGNUM) ? ((((N) - FPLAST_REGNUM -1) * 4) + 384)\
-  :((N) >= FP0_REGNUM) ? ((((N) - FP0_REGNUM) * 8) + 128)	\
-  :((N) * 4) )
-
-/* Number of bytes of storage in the actual machine representation
-   for register N. */
-/* Note that the unsigned cast here forces the result of the
-   subtraction to very high positive values if N < FP0_REGNUM */
-
-#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
-
-/* Number of bytes of storage in the program's representation
-   for register N.  On the RS6000, all regs are 4 bytes
-   except the floating point regs which are 8-byte doubles.  */
-
-#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
-
-/* Largest value REGISTER_RAW_SIZE can have.  */
-
-#define MAX_REGISTER_RAW_SIZE 8
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
 /* convert a dbx stab register number (from `r' declaration) to a gdb REGNUM */
 
 #define STAB_REG_TO_REGNUM(value)	(value)
 
-/* Nonzero if register N requires conversion
-   from raw format to virtual format.
-   The register format for rs6000 floating point registers is always
-   double, we need a conversion if the memory format is float.  */
-
-#define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM && (N) <= FPLAST_REGNUM)
-
-/* Convert data from raw format for register REGNUM in buffer FROM
-   to virtual format with type TYPE in buffer TO.  */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \
-{ \
-  if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
-    { \
-      double val = extract_floating ((FROM), REGISTER_RAW_SIZE (REGNUM)); \
-      store_floating ((TO), TYPE_LENGTH (TYPE), val); \
-    } \
-  else \
-    memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
-}
-
-/* Convert data from virtual format with type TYPE in buffer FROM
-   to raw format for register REGNUM in buffer TO.  */
-
-#define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO)	\
-{ \
-  if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
-    { \
-      double val = extract_floating ((FROM), TYPE_LENGTH (TYPE)); \
-      store_floating ((TO), REGISTER_RAW_SIZE (REGNUM), val); \
-    } \
-  else \
-    memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
-}
-
-/* Return the GDB type object for the "standard" data type
-   of data in register N.  */
-
-#define REGISTER_VIRTUAL_TYPE(N) \
- (((unsigned)(N) - FP0_REGNUM) < 32 ? builtin_type_double : builtin_type_int)
-
-/* Store the address of the place in which to copy the structure the
-   subroutine will return.  This is called from call_function. */
-/* in RS6000, struct return addresses are passed as an extra parameter in r3.
-   In function return, callee is not responsible of returning this address back.
-   Since gdb needs to find it, we will store in a designated variable
-   `rs6000_struct_return_address'. */
-
-extern CORE_ADDR rs6000_struct_return_address;
-
-#define STORE_STRUCT_RETURN(ADDR, SP)	\
-  { write_register (3, (ADDR));		\
-    rs6000_struct_return_address = (ADDR); }
-
-/* Extract from an array REGBUF containing the (raw) register state
-   a function return value of type TYPE, and copy that, in virtual format,
-   into VALBUF.  */
-
-/* #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
-   memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE)) */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
-  extract_return_value(TYPE,REGBUF,VALBUF)
-extern void extract_return_value (struct type *, char[], char *);
-
-/* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format.  */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
-  {									\
-    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)				\
-									\
-     /* Floating point values are returned starting from FPR1 and up.	\
-	Say a double_double_double type could be returned in		\
-	FPR1/FPR2/FPR3 triple. */					\
-									\
-      write_register_bytes (REGISTER_BYTE (FP0_REGNUM+1), (VALBUF),	\
-						TYPE_LENGTH (TYPE));	\
-    else								\
-      /* Everything else is returned in GPR3 and up. */			\
-      write_register_bytes (REGISTER_BYTE (GP0_REGNUM+3), (VALBUF),	\
-						TYPE_LENGTH (TYPE));	\
-  }
-
-
-/* Extract from an array REGBUF containing the (raw) register state
-   the address in which a function should return its structure value,
-   as a CORE_ADDR (or an expression that can be used as one).  */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF)	rs6000_struct_return_address
-
-/* Describe the pointer in each stack frame to the previous stack frame
-   (its caller).  */
-
-/* FRAME_CHAIN takes a frame's nominal address
-   and produces the frame's chain-pointer. */
-
-/* In the case of the RS6000, the frame's nominal address
-   is the address of a 4-byte word containing the calling frame's address.  */
-
-#define FRAME_CHAIN(thisframe) rs6000_frame_chain (thisframe)
-CORE_ADDR rs6000_frame_chain (struct frame_info *);
-
 /* Define other aspects of the stack frame.  */
 
-/* A macro that tells us whether the function invocation represented
-   by FI does not have a frame on the stack associated with it.  If it
-   does not, FRAMELESS is set to 1, else 0.  */
-
-extern int rs6000_frameless_function_invocation (struct frame_info *);
-#define FRAMELESS_FUNCTION_INVOCATION(FI) \
-  (rs6000_frameless_function_invocation (FI))
-
 #define INIT_FRAME_PC_FIRST(fromleaf, prev) \
   prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
 	      prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
 #define INIT_FRAME_PC(fromleaf, prev)	/* nothing */
-extern void rs6000_init_extra_frame_info (int fromleaf, struct frame_info *);
-#define	INIT_EXTRA_FRAME_INFO(fromleaf, fi) rs6000_init_extra_frame_info (fromleaf, fi)
-
-/* If the kernel has to deliver a signal, it pushes a sigcontext
-   structure on the stack and then calls the signal handler, passing
-   the address of the sigcontext in an argument register. Usually
-   the signal handler doesn't save this register, so we have to
-   access the sigcontext structure via an offset from the signal handler
-   frame.
-   The following constants were determined by experimentation on AIX 3.2.  */
-#define SIG_FRAME_PC_OFFSET 96
-#define SIG_FRAME_LR_OFFSET 108
-#define SIG_FRAME_FP_OFFSET 284
-
-/* Default offset from SP where the LR is stored */
-#define	DEFAULT_LR_SAVE 8
-
-/* Return saved PC from a frame */
-#define FRAME_SAVED_PC(FRAME)  rs6000_frame_saved_pc (FRAME)
-
-extern unsigned long rs6000_frame_saved_pc (struct frame_info *);
-
-extern CORE_ADDR rs6000_frame_args_address (struct frame_info *);
-#define FRAME_ARGS_ADDRESS(FI) rs6000_frame_args_address (FI)
-
-#define FRAME_LOCALS_ADDRESS(FI)	FRAME_ARGS_ADDRESS(FI)
-
-
-/* Set VAL to the number of args passed to frame described by FI.
-   Can set VAL to -1, meaning no way to tell.  */
-
-/* We can't tell how many args there are
-   now that the C compiler delays popping them.  */
-
-#define FRAME_NUM_ARGS(fi) (-1)
-
-/* Return number of bytes at start of arglist that are not really args.  */
-
-#define FRAME_ARGS_SKIP 8	/* Not sure on this. FIXMEmgo */
-
-/* Put here the code to store, into a struct frame_saved_regs,
-   the addresses of the saved registers of frame described by FRAME_INFO.
-   This includes special registers such as pc and fp saved in special
-   ways in the stack frame.  sp is even more special:
-   the address we return for it IS the sp for the next frame.  */
-/* In the following implementation for RS6000, we did *not* save sp. I am
-   not sure if it will be needed. The following macro takes care of gpr's
-   and fpr's only. */
-
-extern void rs6000_frame_init_saved_regs (struct frame_info *);
-#define FRAME_INIT_SAVED_REGS(FI) rs6000_frame_init_saved_regs (FI)
-
-/* Things needed for making the inferior call functions.  */
-
-/* Push an empty stack frame, to record the current PC, etc.  */
-/* Change these names into rs6k_{push, pop}_frame(). FIXMEmgo. */
-
-#define PUSH_DUMMY_FRAME	push_dummy_frame ()
-extern void push_dummy_frame (void);
-
-/* Discard from the stack the innermost frame, 
-   restoring all saved registers.  */
-
-#define POP_FRAME	pop_frame ()
-extern void pop_frame (void);
-
-/* This sequence of words is the instructions:
-
-   mflr r0              // 0x7c0802a6
-   // save fpr's
-   stfd r?, num(r1)     // 0xd8010000 there should be 32 of this??
-   // save gpr's
-   stm  r0, num(r1)     // 0xbc010000
-   stu  r1, num(r1)     // 0x94210000
-
-   // the function we want to branch might be in a different load 
-   // segment. reset the toc register. Note that the actual toc address
-   // will be fix by fix_call_dummy () along with function address.
-
-   st   r2, 0x14(r1)    // 0x90410014 save toc register
-   liu  r2, 0x1234      // 0x3c401234 reset a new toc value 0x12345678
-   oril r2, r2,0x5678   // 0x60425678   
-
-   // load absolute address 0x12345678 to r0
-   liu  r0, 0x1234      // 0x3c001234
-   oril r0, r0,0x5678   // 0x60005678
-   mtctr        r0              // 0x7c0903a6 ctr <- r0
-   bctrl                        // 0x4e800421 jump subroutine 0x12345678 (%ctr)
-   cror 0xf, 0xf, 0xf   // 0x4def7b82
-   brpt                 // 0x7d821008, breakpoint
-   cror 0xf, 0xf, 0xf   // 0x4def7b82 (for 8 byte alignment)
-
-
-   We actually start executing by saving the toc register first, since the pushing 
-   of the registers is done by PUSH_DUMMY_FRAME.  If this were real code,
-   the arguments for the function called by the `bctrl' would be pushed
-   between the `stu' and the `bctrl', and we could allow it to execute through.
-   But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
-   and we cannot allow to push the registers again.
- */
-
-#define CALL_DUMMY {0x7c0802a6, 0xd8010000, 0xbc010000, 0x94210000, \
-		    0x90410014, 0x3c401234, 0x60425678,		    \
-		    0x3c001234, 0x60005678, 0x7c0903a6, 0x4e800421, \
-		    0x4def7b82, 0x7d821008, 0x4def7b82 }
-
-
-/* keep this as multiple of 8 (%sp requires 8 byte alignment) */
-#define CALL_DUMMY_LENGTH 56
-
-#define CALL_DUMMY_START_OFFSET 16
-
-/* Insert the specified number of args and function address into a
-   call sequence of the above form stored at DUMMYNAME.  */
-
-#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
-  rs6000_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p)
-extern void rs6000_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR,
-				   int, struct value **, struct type *, int);
-
-/* Hook in rs6000-tdep.c for determining the TOC address when
-   calling functions in the inferior.  */
-extern
-CORE_ADDR (*find_toc_address_hook) (CORE_ADDR);
-
-/* xcoffread.c provides a function to determine the TOC offset
-   for a given object file.
-   It is used under native AIX configurations for determining the
-   TOC address when calling functions in the inferior.  */
-
-struct objfile;
-extern CORE_ADDR get_toc_offset (struct objfile *);
 
 /* Usually a function pointer's representation is simply the address
    of the function. On the RS/6000 however, a function pointer is
@@ -536,9 +108,8 @@ extern CORE_ADDR get_toc_offset (struct objfile *);
    function pointers), find_function_addr uses this macro to get the
    function address from a function pointer.  */
 
-#define CONVERT_FROM_FUNC_PTR_ADDR(ADDR) \
-  (is_magic_function_pointer (ADDR) ? read_memory_integer (ADDR, 4) : (ADDR))
-extern int is_magic_function_pointer (CORE_ADDR);
+#define CONVERT_FROM_FUNC_PTR_ADDR rs6000_convert_from_func_ptr_addr
+extern CORE_ADDR rs6000_convert_from_func_ptr_addr (CORE_ADDR);
 
 /* Flag for machine-specific stuff in shared files.  FIXME */
 #define IBM6000_TARGET
@@ -549,14 +120,17 @@ extern int is_magic_function_pointer (CORE_ADDR);
 extern void rs6000_software_single_step (unsigned int, int);
 #define SOFTWARE_SINGLE_STEP(sig,bp_p) rs6000_software_single_step (sig, bp_p)
 
-/* If the current gcc for for this target does not produce correct debugging
-   information for float parameters, both prototyped and unprototyped, then
-   define this macro.  This forces gdb to  always assume that floats are
-   passed as doubles and then converted in the callee.
+/* Notice when a new child process is started. */
+
+#define TARGET_CREATE_INFERIOR_HOOK rs6000_create_inferior
+extern void rs6000_create_inferior (int);
+
+/* Hook in rs6000-tdep.c for determining the TOC address when
+   calling functions in the inferior.  */
+
+extern CORE_ADDR (*rs6000_find_toc_address_hook) (CORE_ADDR);
 
-   For the PowerPC, it appears that the debug info marks the parameters as
-   floats regardless of whether the function is prototyped, but the actual
-   values are always passed in as doubles.  Thus by setting this to 1, both
-   types of calls will work. */
+/* Hook in rs6000-tdep.c to set the current architecture when starting a
+   child process. */
 
-#define COERCE_FLOAT_TO_DOUBLE(formal, actual) (1)
+extern void (*rs6000_set_host_arch_hook) (int);