/* Target-dependent code for GDB, the GNU debugger.
Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
- 1998, 1999, 2000, 2001, 2002
+ 1998, 1999, 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
This file is part of GDB.
#include "doublest.h"
#include "value.h"
#include "parser-defs.h"
+#include "osabi.h"
#include "libbfd.h" /* for bfd_default_set_arch_mach */
#include "coff/internal.h" /* for libcoff.h */
#include "solib-svr4.h"
#include "ppc-tdep.h"
+#include "gdb_assert.h"
+
/* 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
struct rs6000_framedata * fdatap);
static CORE_ADDR frame_initial_stack_address (struct frame_info *);
+/* Is REGNO an AltiVec register? Return 1 if so, 0 otherwise. */
+int
+altivec_register_p (int regno)
+{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ if (tdep->ppc_vr0_regnum < 0 || tdep->ppc_vrsave_regnum < 0)
+ return 0;
+ else
+ return (regno >= tdep->ppc_vr0_regnum && regno <= tdep->ppc_vrsave_regnum);
+}
+
/* Read a LEN-byte address from debugged memory address MEMADDR. */
static CORE_ADDR
void
rs6000_init_extra_frame_info (int fromleaf, struct frame_info *fi)
{
- fi->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
- fi->extra_info->initial_sp = 0;
- if (fi->next != (CORE_ADDR) 0
- && fi->pc < TEXT_SEGMENT_BASE)
+ struct frame_extra_info *extra_info =
+ frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
+ extra_info->initial_sp = 0;
+ if (get_next_frame (fi) != NULL
+ && get_frame_pc (fi) < TEXT_SEGMENT_BASE)
/* We're in get_prev_frame */
/* and this is a special signal frame. */
/* (fi->pc will be some low address in the kernel, */
/* to which the signal handler returns). */
- fi->signal_handler_caller = 1;
+ deprecated_set_frame_type (fi, SIGTRAMP_FRAME);
}
/* Put here the code to store, into a struct frame_saved_regs,
static CORE_ADDR
rs6000_frame_args_address (struct frame_info *fi)
{
- if (fi->extra_info->initial_sp != 0)
- return fi->extra_info->initial_sp;
+ struct frame_extra_info *extra_info = get_frame_extra_info (fi);
+ if (extra_info->initial_sp != 0)
+ return extra_info->initial_sp;
else
return frame_initial_stack_address (fi);
}
fi = get_current_frame ();
if (fi != NULL)
- dest = read_memory_addr (fi->frame + SIG_FRAME_PC_OFFSET,
+ dest = read_memory_addr (get_frame_base (fi) + SIG_FRAME_PC_OFFSET,
gdbarch_tdep (current_gdbarch)->wordsize);
}
}
int prev_insn_was_prologue_insn = 1;
int num_skip_non_prologue_insns = 0;
const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (current_gdbarch);
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
/* Attempt to find the end of the prologue when no limit is specified.
Note that refine_prologue_limit() has been written so that it may
{ /* mr r31, r1 */
fdata->frameless = 0;
framep = 1;
- fdata->alloca_reg = 31;
+ fdata->alloca_reg = (tdep->ppc_gp0_regnum + 31);
continue;
/* Another way to set up the frame pointer. */
{ /* addi rX, r1, 0x0 */
fdata->frameless = 0;
framep = 1;
- fdata->alloca_reg = (op & ~0x38010000) >> 21;
+ fdata->alloca_reg = (tdep->ppc_gp0_regnum
+ + ((op & ~0x38010000) >> 21));
continue;
}
/* AltiVec related instructions. */
int ii, wordsize;
pc = read_pc ();
- sp = FRAME_FP (frame);
+ sp = get_frame_base (frame);
- if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
+ get_frame_base (frame),
+ get_frame_base (frame)))
{
generic_pop_dummy_frame ();
flush_cached_frames ();
}
/* Make sure that all registers are valid. */
- read_register_bytes (0, NULL, REGISTER_BYTES);
+ deprecated_read_register_bytes (0, NULL, REGISTER_BYTES);
/* Figure out previous %pc value. If the function is frameless, it is
still in the link register, otherwise walk the frames and retrieve the
saved %pc value in the previous frame. */
- addr = get_pc_function_start (frame->pc);
- (void) skip_prologue (addr, frame->pc, &fdata);
+ addr = get_pc_function_start (get_frame_pc (frame));
+ (void) skip_prologue (addr, get_frame_pc (frame), &fdata);
wordsize = gdbarch_tdep (current_gdbarch)->wordsize;
if (fdata.frameless)
addr = prev_sp + fdata.gpr_offset;
for (ii = fdata.saved_gpr; ii <= 31; ++ii)
{
- read_memory (addr, ®isters[REGISTER_BYTE (ii)], wordsize);
+ read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii)],
+ wordsize);
addr += wordsize;
}
}
addr = prev_sp + fdata.fpr_offset;
for (ii = fdata.saved_fpr; ii <= 31; ++ii)
{
- read_memory (addr, ®isters[REGISTER_BYTE (ii + FP0_REGNUM)], 8);
+ read_memory (addr, &deprecated_registers[REGISTER_BYTE (ii + FP0_REGNUM)], 8);
addr += 8;
}
}
}
}
+/* All the ABI's require 16 byte alignment. */
+static CORE_ADDR
+rs6000_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
+{
+ return (addr & -16);
+}
+
/* Pass the arguments in either registers, or in the stack. In RS/6000,
the first eight words of the argument list (that might be less than
eight parameters if some parameters occupy more than one word) are
printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
VALUE_CONTENTS (arg),
len);
++f_argno;
/* Argument takes more than one register. */
while (argbytes < len)
{
- memset (®isters[REGISTER_BYTE (ii + 3)], 0, reg_size);
- memcpy (®isters[REGISTER_BYTE (ii + 3)],
+ memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0,
+ reg_size);
+ memcpy (&deprecated_registers[REGISTER_BYTE (ii + 3)],
((char *) VALUE_CONTENTS (arg)) + argbytes,
(len - argbytes) > reg_size
? reg_size : len - argbytes);
{
/* Argument can fit in one register. No problem. */
int adj = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? reg_size - len : 0;
- memset (®isters[REGISTER_BYTE (ii + 3)], 0, reg_size);
- memcpy ((char *)®isters[REGISTER_BYTE (ii + 3)] + adj,
+ memset (&deprecated_registers[REGISTER_BYTE (ii + 3)], 0, reg_size);
+ memcpy ((char *)&deprecated_registers[REGISTER_BYTE (ii + 3)] + adj,
VALUE_CONTENTS (arg), len);
}
++argno;
printf_unfiltered (
"Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
- memcpy (®isters[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
+ memcpy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM + 1 + f_argno)],
VALUE_CONTENTS (arg),
len);
++f_argno;
/* Extract a function return value of type TYPE from raw register array
REGBUF, and copy that return value into VALBUF in virtual format. */
static void
-e500_extract_return_value (struct type *valtype, struct regcache *regbuf, char *valbuf)
+e500_extract_return_value (struct type *valtype, struct regcache *regbuf, void *valbuf)
{
int offset = 0;
int vallen = TYPE_LENGTH (valtype);
}
}
-/* Keep structure return address in this variable.
- FIXME: This is a horrid kludge which should not be allowed to continue
- living. This only allows a single nested call to a structure-returning
-
-static CORE_ADDR rs6000_struct_return_address;
-
/* Return whether handle_inferior_event() should proceed through code
starting at PC in function NAME when stepping.
/* Don't even think about framelessness except on the innermost frame
or if the function was interrupted by a signal. */
- if (fi->next != NULL && !fi->next->signal_handler_caller)
+ if (get_next_frame (fi) != NULL
+ && !(get_frame_type (get_next_frame (fi)) == SIGTRAMP_FRAME))
return 0;
- func_start = get_pc_function_start (fi->pc);
+ func_start = get_pc_function_start (get_frame_pc (fi));
/* If we failed to find the start of the function, it is a mistake
to inspect the instructions. */
function pointer, normally causing an immediate core dump of the
inferior. Mark function as frameless, as the inferior has no chance
of setting up a stack frame. */
- if (fi->pc == 0)
+ if (get_frame_pc (fi) == 0)
return 1;
else
return 0;
}
- (void) skip_prologue (func_start, fi->pc, &fdata);
+ (void) skip_prologue (func_start, get_frame_pc (fi), &fdata);
return fdata.frameless;
}
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
int wordsize = tdep->wordsize;
- if (fi->signal_handler_caller)
- return read_memory_addr (fi->frame + SIG_FRAME_PC_OFFSET, wordsize);
+ if ((get_frame_type (fi) == SIGTRAMP_FRAME))
+ return read_memory_addr (get_frame_base (fi) + SIG_FRAME_PC_OFFSET,
+ wordsize);
- if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
- return generic_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi),
+ get_frame_base (fi),
+ get_frame_base (fi)))
+ return deprecated_read_register_dummy (get_frame_pc (fi),
+ get_frame_base (fi), PC_REGNUM);
- func_start = get_pc_function_start (fi->pc);
+ func_start = get_pc_function_start (get_frame_pc (fi));
/* If we failed to find the start of the function, it is a mistake
to inspect the instructions. */
if (!func_start)
return 0;
- (void) skip_prologue (func_start, fi->pc, &fdata);
+ (void) skip_prologue (func_start, get_frame_pc (fi), &fdata);
- if (fdata.lr_offset == 0 && fi->next != NULL)
+ if (fdata.lr_offset == 0 && get_next_frame (fi) != NULL)
{
- if (fi->next->signal_handler_caller)
- return read_memory_addr (fi->next->frame + SIG_FRAME_LR_OFFSET,
+ if ((get_frame_type (get_next_frame (fi)) == SIGTRAMP_FRAME))
+ return read_memory_addr ((get_frame_base (get_next_frame (fi))
+ + SIG_FRAME_LR_OFFSET),
wordsize);
+ else if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (get_next_frame (fi)), 0, 0))
+ /* The link register wasn't saved by this frame and the next
+ (inner, newer) frame is a dummy. Get the link register
+ value by unwinding it from that [dummy] frame. */
+ {
+ ULONGEST lr;
+ frame_unwind_unsigned_register (get_next_frame (fi),
+ tdep->ppc_lr_regnum, &lr);
+ return lr;
+ }
else
return read_memory_addr (FRAME_CHAIN (fi) + tdep->lr_frame_offset,
wordsize);
struct gdbarch_tdep * tdep = gdbarch_tdep (current_gdbarch);
int wordsize = tdep->wordsize;
- if (fi->saved_regs)
+ if (get_frame_saved_regs (fi))
return;
if (fdatap == NULL)
{
fdatap = &work_fdata;
- (void) skip_prologue (get_pc_function_start (fi->pc), fi->pc, fdatap);
+ (void) skip_prologue (get_pc_function_start (get_frame_pc (fi)),
+ get_frame_pc (fi), fdatap);
}
frame_saved_regs_zalloc (fi);
CORE_ADDR fpr_addr = frame_addr + fdatap->fpr_offset;
for (i = fdatap->saved_fpr; i < 32; i++)
{
- fi->saved_regs[FP0_REGNUM + i] = fpr_addr;
+ get_frame_saved_regs (fi)[FP0_REGNUM + i] = fpr_addr;
fpr_addr += 8;
}
}
CORE_ADDR gpr_addr = frame_addr + fdatap->gpr_offset;
for (i = fdatap->saved_gpr; i < 32; i++)
{
- fi->saved_regs[i] = gpr_addr;
+ get_frame_saved_regs (fi)[i] = gpr_addr;
gpr_addr += wordsize;
}
}
CORE_ADDR vr_addr = frame_addr + fdatap->vr_offset;
for (i = fdatap->saved_vr; i < 32; i++)
{
- fi->saved_regs[tdep->ppc_vr0_regnum + i] = vr_addr;
+ get_frame_saved_regs (fi)[tdep->ppc_vr0_regnum + i] = vr_addr;
vr_addr += REGISTER_RAW_SIZE (tdep->ppc_vr0_regnum);
}
}
CORE_ADDR ev_addr = frame_addr + fdatap->ev_offset;
for (i = fdatap->saved_ev; i < 32; i++)
{
- fi->saved_regs[tdep->ppc_ev0_regnum + i] = ev_addr;
- fi->saved_regs[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
+ get_frame_saved_regs (fi)[tdep->ppc_ev0_regnum + i] = ev_addr;
+ get_frame_saved_regs (fi)[tdep->ppc_gp0_regnum + i] = ev_addr + 4;
ev_addr += REGISTER_RAW_SIZE (tdep->ppc_ev0_regnum);
}
}
/* If != 0, fdatap->cr_offset is the offset from the frame that holds
the CR. */
if (fdatap->cr_offset != 0)
- fi->saved_regs[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset;
+ get_frame_saved_regs (fi)[tdep->ppc_cr_regnum] = frame_addr + fdatap->cr_offset;
/* If != 0, fdatap->lr_offset is the offset from the frame that holds
the LR. */
if (fdatap->lr_offset != 0)
- fi->saved_regs[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset;
+ get_frame_saved_regs (fi)[tdep->ppc_lr_regnum] = frame_addr + fdatap->lr_offset;
/* If != 0, fdatap->vrsave_offset is the offset from the frame that holds
the VRSAVE. */
if (fdatap->vrsave_offset != 0)
- fi->saved_regs[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset;
+ get_frame_saved_regs (fi)[tdep->ppc_vrsave_regnum] = frame_addr + fdatap->vrsave_offset;
}
/* Return the address of a frame. This is the inital %sp value when the frame
/* If the initial stack pointer (frame address) of this frame is known,
just return it. */
- if (fi->extra_info->initial_sp)
- return fi->extra_info->initial_sp;
+ if (get_frame_extra_info (fi)->initial_sp)
+ return get_frame_extra_info (fi)->initial_sp;
/* Find out if this function is using an alloca register. */
- (void) skip_prologue (get_pc_function_start (fi->pc), fi->pc, &fdata);
+ (void) skip_prologue (get_pc_function_start (get_frame_pc (fi)),
+ get_frame_pc (fi), &fdata);
/* If saved registers of this frame are not known yet, read and
cache them. */
- if (!fi->saved_regs)
+ if (!get_frame_saved_regs (fi))
frame_get_saved_regs (fi, &fdata);
/* If no alloca register used, then fi->frame is the value of the %sp for
if (fdata.alloca_reg < 0)
{
- fi->extra_info->initial_sp = fi->frame;
- return fi->extra_info->initial_sp;
+ get_frame_extra_info (fi)->initial_sp = get_frame_base (fi);
+ return get_frame_extra_info (fi)->initial_sp;
}
/* There is an alloca register, use its value, in the current frame,
char *tmpbuf = alloca (MAX_REGISTER_RAW_SIZE);
if (frame_register_read (fi, fdata.alloca_reg, tmpbuf))
{
- fi->extra_info->initial_sp
+ get_frame_extra_info (fi)->initial_sp
= extract_unsigned_integer (tmpbuf,
REGISTER_RAW_SIZE (fdata.alloca_reg));
}
/* NOTE: cagney/2002-04-17: At present the only time
frame_register_read will fail is when the register isn't
available. If that does happen, use the frame. */
- fi->extra_info->initial_sp = fi->frame;
+ get_frame_extra_info (fi)->initial_sp = get_frame_base (fi);
}
- return fi->extra_info->initial_sp;
+ return get_frame_extra_info (fi)->initial_sp;
}
/* Describe the pointer in each stack frame to the previous stack frame
CORE_ADDR fp, fpp, lr;
int wordsize = gdbarch_tdep (current_gdbarch)->wordsize;
- if (PC_IN_CALL_DUMMY (thisframe->pc, thisframe->frame, thisframe->frame))
- return thisframe->frame; /* dummy frame same as caller's frame */
+ if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (thisframe),
+ get_frame_base (thisframe),
+ get_frame_base (thisframe)))
+ /* A dummy frame always correctly chains back to the previous
+ frame. */
+ return read_memory_addr (get_frame_base (thisframe), wordsize);
- if (inside_entry_file (thisframe->pc) ||
- thisframe->pc == entry_point_address ())
+ if (inside_entry_file (get_frame_pc (thisframe))
+ || get_frame_pc (thisframe) == entry_point_address ())
return 0;
- if (thisframe->signal_handler_caller)
- fp = read_memory_addr (thisframe->frame + SIG_FRAME_FP_OFFSET,
- wordsize);
- else if (thisframe->next != NULL
- && thisframe->next->signal_handler_caller
+ if ((get_frame_type (thisframe) == SIGTRAMP_FRAME))
+ fp = read_memory_addr (get_frame_base (thisframe) + SIG_FRAME_FP_OFFSET,
+ wordsize);
+ else if (get_next_frame (thisframe) != NULL
+ && (get_frame_type (get_next_frame (thisframe)) == SIGTRAMP_FRAME)
&& FRAMELESS_FUNCTION_INVOCATION (thisframe))
/* A frameless function interrupted by a signal did not change the
frame pointer. */
- fp = FRAME_FP (thisframe);
+ fp = get_frame_base (thisframe);
else
- fp = read_memory_addr ((thisframe)->frame, wordsize);
-
- lr = read_register (gdbarch_tdep (current_gdbarch)->ppc_lr_regnum);
- if (lr == entry_point_address ())
- if (fp != 0 && (fpp = read_memory_addr (fp, wordsize)) != 0)
- if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
- return fpp;
-
+ fp = read_memory_addr (get_frame_base (thisframe), wordsize);
return fp;
}
}
}
-/* For the PowerPC, it appears that the debug info marks float parameters as
- floats regardless of whether the function is prototyped, but the actual
- values are always passed in as doubles. Tell gdb to always assume that
- floats are passed as doubles and then converted in the callee. */
-
-static int
-rs6000_coerce_float_to_double (struct type *formal, struct type *actual)
-{
- return 1;
-}
-
/* Return whether register N requires conversion when moving from raw format
to virtual format.
}
/* Store the address of the place in which to copy the structure the
- subroutine will return. This is called from call_function.
-
- In RS/6000, 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'. */
+ subroutine will return. */
static void
rs6000_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
- write_register (3, addr);
- rs6000_struct_return_address = addr;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ write_register (tdep->ppc_gp0_regnum + 3, addr);
}
/* Write into appropriate registers a function return value
memcpy (reg_val_buf, valbuf + copied, reg_size);
copied += reg_size;
- write_register_gen (regnum, reg_val_buf);
+ deprecated_write_register_gen (regnum, reg_val_buf);
i++;
}
}
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));
+ deprecated_write_register_bytes (REGISTER_BYTE (FP0_REGNUM + 1), valbuf,
+ TYPE_LENGTH (type));
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
if (TYPE_LENGTH (type) == 16
&& TYPE_VECTOR (type))
- write_register_bytes (REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
- valbuf, TYPE_LENGTH (type));
+ deprecated_write_register_bytes (REGISTER_BYTE (tdep->ppc_vr0_regnum + 2),
+ valbuf, TYPE_LENGTH (type));
}
else
/* Everything else is returned in GPR3 and up. */
- write_register_bytes (REGISTER_BYTE (gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3),
- valbuf, TYPE_LENGTH (type));
+ deprecated_write_register_bytes (REGISTER_BYTE (gdbarch_tdep (current_gdbarch)->ppc_gp0_regnum + 3),
+ valbuf, TYPE_LENGTH (type));
}
/* Extract from an array REGBUF containing the (raw) register state
as a CORE_ADDR (or an expression that can be used as one). */
static CORE_ADDR
-rs6000_extract_struct_value_address (char *regbuf)
-{
- return rs6000_struct_return_address;
+rs6000_extract_struct_value_address (struct regcache *regcache)
+{
+ /* FIXME: cagney/2002-09-26: PR gdb/724: When making an inferior
+ function call GDB knows the address of the struct return value
+ and hence, should not need to call this function. Unfortunately,
+ the current hand_function_call() code only saves the most recent
+ struct address leading to occasional calls. The code should
+ instead maintain a stack of such addresses (in the dummy frame
+ object). */
+ /* NOTE: cagney/2002-09-26: Return 0 which indicates that we've
+ really got no idea where the return value is being stored. While
+ r3, on function entry, contained the address it will have since
+ been reused (scratch) and hence wouldn't be valid */
+ return 0;
}
/* Return whether PC is in a dummy function call.
/* 0 */ P(r0), P(r1), P(r2), P(r3), P(r4), P(r5), P(r6), P(r7), \
/* 8 */ P(r8), P(r9), P(r10),P(r11),P(r12),P(r13),P(r14),P(r15), \
/* 16 */ P(r16),P(r17),P(r18),P(r19),P(r20),P(r21),P(r22),P(r23), \
- /* 24 */ P(r24),P(r25),P(r26),P(r27),P(r28),P(r29),P(r30),P(r31), \
+ /* 24 */ P(r24),P(r25),P(r26),P(r27),P(r28),P(r29),P(r30),P(r31)
/* IBM POWER (pre-PowerPC) architecture, user-level view. We only cover
user-level SPR's. */
PPC_UISA_NOFP_SPRS,
/* 7...38 */
PPC_EV_REGS,
+ R8(acc), R(spefscr),
+ /* NOTE: Add new registers here the end of the raw register
+ list and just before the first pseudo register. */
/* 39...70 */
PPC_GPRS_PSEUDO_REGS
};
unsigned long mach;
bfd abfd;
int sysv_abi;
- enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
asection *sect;
from_xcoff_exec = info.abfd && info.abfd->format == bfd_object &&
sysv_abi = info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour;
- if (info.abfd)
- osabi = gdbarch_lookup_osabi (info.abfd);
-
/* Check word size. If INFO is from a binary file, infer it from
that, else choose a likely default. */
if (from_xcoff_exec)
meaningful, because 64-bit CPUs can run in 32-bit mode. So, perform
separate word size check. */
tdep = gdbarch_tdep (arches->gdbarch);
- if (tdep && tdep->wordsize == wordsize && tdep->osabi == osabi)
+ if (tdep && tdep->wordsize == wordsize)
return arches->gdbarch;
}
}
tdep = xmalloc (sizeof (struct gdbarch_tdep));
tdep->wordsize = wordsize;
- tdep->osabi = osabi;
/* For e500 executables, the apuinfo section is of help here. Such
section contains the identifier and revision number of each
set_gdbarch_fp_regnum (gdbarch, 1);
set_gdbarch_deprecated_extract_return_value (gdbarch,
rs6000_extract_return_value);
- set_gdbarch_store_return_value (gdbarch, rs6000_store_return_value);
+ set_gdbarch_deprecated_store_return_value (gdbarch, rs6000_store_return_value);
if (v->arch == bfd_arch_powerpc)
switch (v->mach)
break;
case bfd_mach_ppc_7400:
tdep->ppc_vr0_regnum = 119;
- tdep->ppc_vrsave_regnum = 153;
+ tdep->ppc_vrsave_regnum = 152;
tdep->ppc_ev0_regnum = -1;
tdep->ppc_ev31_regnum = -1;
break;
case bfd_mach_ppc_e500:
- tdep->ppc_gp0_regnum = 39;
- tdep->ppc_gplast_regnum = 70;
+ tdep->ppc_gp0_regnum = 41;
+ tdep->ppc_gplast_regnum = tdep->ppc_gp0_regnum + 32 - 1;
tdep->ppc_toc_regnum = -1;
tdep->ppc_ps_regnum = 1;
tdep->ppc_cr_regnum = 2;
tdep->ppc_ev0_regnum = 7;
tdep->ppc_ev31_regnum = 38;
set_gdbarch_pc_regnum (gdbarch, 0);
- set_gdbarch_sp_regnum (gdbarch, 40);
- set_gdbarch_fp_regnum (gdbarch, 40);
+ set_gdbarch_sp_regnum (gdbarch, tdep->ppc_gp0_regnum + 1);
+ set_gdbarch_fp_regnum (gdbarch, tdep->ppc_gp0_regnum + 1);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, e500_dwarf2_reg_to_regnum);
set_gdbarch_pseudo_register_read (gdbarch, e500_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, e500_pseudo_register_write);
set_gdbarch_extract_return_value (gdbarch, e500_extract_return_value);
- set_gdbarch_store_return_value (gdbarch, e500_store_return_value);
+ set_gdbarch_deprecated_store_return_value (gdbarch, e500_store_return_value);
break;
default:
tdep->ppc_vr0_regnum = -1;
break;
}
+ /* Sanity check on registers. */
+ gdb_assert (strcmp (tdep->regs[tdep->ppc_gp0_regnum].name, "r0") == 0);
+
/* Set lr_frame_offset. */
if (wordsize == 8)
tdep->lr_frame_offset = 16;
set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
set_gdbarch_char_signed (gdbarch, 0);
- set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
set_gdbarch_call_dummy_length (gdbarch, 0);
- set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
set_gdbarch_call_dummy_address (gdbarch, entry_point_address);
set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
set_gdbarch_call_dummy_start_offset (gdbarch, 0);
- set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
set_gdbarch_call_dummy_p (gdbarch, 1);
set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_get_saved_register (gdbarch, generic_unwind_get_saved_register);
set_gdbarch_fix_call_dummy (gdbarch, rs6000_fix_call_dummy);
+ set_gdbarch_frame_align (gdbarch, rs6000_frame_align);
set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
set_gdbarch_push_return_address (gdbarch, ppc_push_return_address);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
- set_gdbarch_coerce_float_to_double (gdbarch, rs6000_coerce_float_to_double);
set_gdbarch_register_convertible (gdbarch, rs6000_register_convertible);
set_gdbarch_register_convert_to_virtual (gdbarch, rs6000_register_convert_to_virtual);
else
set_gdbarch_push_arguments (gdbarch, rs6000_push_arguments);
- set_gdbarch_deprecated_store_return_value (gdbarch, rs6000_store_return_value);
- set_gdbarch_deprecated_extract_struct_value_address (gdbarch, rs6000_extract_struct_value_address);
+ set_gdbarch_store_struct_return (gdbarch, rs6000_store_struct_return);
+ set_gdbarch_extract_struct_value_address (gdbarch, rs6000_extract_struct_value_address);
set_gdbarch_pop_frame (gdbarch, rs6000_pop_frame);
set_gdbarch_skip_prologue (gdbarch, rs6000_skip_prologue);
set_gdbarch_use_struct_convention (gdbarch,
generic_use_struct_convention);
- set_gdbarch_frame_chain_valid (gdbarch, file_frame_chain_valid);
-
set_gdbarch_frameless_function_invocation (gdbarch,
rs6000_frameless_function_invocation);
set_gdbarch_frame_chain (gdbarch, rs6000_frame_chain);
set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
/* Hook in ABI-specific overrides, if they have been registered. */
- gdbarch_init_osabi (info, gdbarch, osabi);
+ gdbarch_init_osabi (info, gdbarch);
return gdbarch;
}
if (tdep == NULL)
return;
- fprintf_unfiltered (file, "rs6000_dump_tdep: OS ABI = %s\n",
- gdbarch_osabi_name (tdep->osabi));
+ /* FIXME: Dump gdbarch_tdep. */
}
static struct cmd_list_element *info_powerpc_cmdlist = NULL;
projects / binutils.git / blobdiff