URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [sparcnbsd-tdep.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* Target-dependent code for SPARC systems running NetBSD.
   Copyright 2002 Free Software Foundation, Inc.
   Contributed by Wasabi Systems, 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.  */
 
#include "defs.h"
#include "gdbcore.h"
#include "regcache.h"
#include "target.h"
#include "value.h"
#include "osabi.h"
 
#include "sparcnbsd-tdep.h"
#include "nbsd-tdep.h"
 
#include "solib-svr4.h"
 
#define REG32_OFFSET_PSR        (0 * 4)
#define REG32_OFFSET_PC         (1 * 4)
#define REG32_OFFSET_NPC        (2 * 4)
#define REG32_OFFSET_Y          (3 * 4)
#define REG32_OFFSET_GLOBAL     (4 * 4)
#define REG32_OFFSET_OUT        (12 * 4)
 
#define REG64_OFFSET_TSTATE     (0 * 8)
#define REG64_OFFSET_PC         (1 * 8)
#define REG64_OFFSET_NPC        (2 * 8)
#define REG64_OFFSET_Y          (3 * 8)
#define REG64_OFFSET_GLOBAL     (4 * 8)
#define REG64_OFFSET_OUT        (12 * 8)
 
void
sparcnbsd_supply_reg32 (char *regs, int regno)
{
  int i;
 
  if (regno == PS_REGNUM || regno == -1)
    supply_register (PS_REGNUM, regs + REG32_OFFSET_PSR);
 
  if (regno == PC_REGNUM || regno == -1)
    supply_register (PC_REGNUM, regs + REG32_OFFSET_PC);
 
  if (regno == NPC_REGNUM || regno == -1)
    supply_register (NPC_REGNUM, regs + REG32_OFFSET_NPC);
 
  if (regno == Y_REGNUM || regno == -1)
    supply_register (Y_REGNUM, regs + REG32_OFFSET_Y);
 
  if ((regno >= G0_REGNUM && regno <= G7_REGNUM) || regno == -1)
    {
      if (regno == G0_REGNUM || regno == -1)
        supply_register (G0_REGNUM, NULL);      /* %g0 is always zero */
      for (i = G1_REGNUM; i <= G7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            supply_register (i, regs + REG32_OFFSET_GLOBAL +
                             ((i - G0_REGNUM) * 4));
        }
    }
 
  if ((regno >= O0_REGNUM && regno <= O7_REGNUM) || regno == -1)
    {
      for (i = O0_REGNUM; i <= O7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            supply_register (i, regs + REG32_OFFSET_OUT +
                             ((i - O0_REGNUM) * 4));
        }
    }
 
  /* Inputs and Locals are stored onto the stack by by the kernel.  */
  if ((regno >= L0_REGNUM && regno <= I7_REGNUM) || regno == -1)
    {
      CORE_ADDR sp = read_register (SP_REGNUM);
      char buf[4];
 
      for (i = L0_REGNUM; i <= I7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            {
              target_read_memory (sp + ((i - L0_REGNUM) * 4),
                                  buf, sizeof (buf));
              supply_register (i, buf);
            }
        }
    }
 
  /* FIXME: If we don't set these valid, read_register_bytes() rereads
     all the regs every time it is called!  */
  if (regno == WIM_REGNUM || regno == -1)
    supply_register (WIM_REGNUM, NULL);
  if (regno == TBR_REGNUM || regno == -1)
    supply_register (TBR_REGNUM, NULL);
  if (regno == CPS_REGNUM || regno == -1)
    supply_register (CPS_REGNUM, NULL);
}
 
void
sparcnbsd_supply_reg64 (char *regs, int regno)
{
  int i;
  char buf[8];
 
  if (regno == TSTATE_REGNUM || regno == -1)
    supply_register (PS_REGNUM, regs + REG64_OFFSET_TSTATE);
 
  if (regno == PC_REGNUM || regno == -1)
    supply_register (PC_REGNUM, regs + REG64_OFFSET_PC);
 
  if (regno == NPC_REGNUM || regno == -1)
    supply_register (NPC_REGNUM, regs + REG64_OFFSET_NPC);
 
  if (regno == Y_REGNUM || regno == -1)
    {
      memset (buf, 0, sizeof (buf));
      memcpy (&buf[4], regs + REG64_OFFSET_Y, 4);
      supply_register (Y_REGNUM, buf);
    }
 
  if ((regno >= G0_REGNUM && regno <= G7_REGNUM) || regno == -1)
    {
      if (regno == G0_REGNUM || regno == -1)
        supply_register (G0_REGNUM, NULL);      /* %g0 is always zero */
      for (i = G1_REGNUM; i <= G7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            supply_register (i, regs + REG64_OFFSET_GLOBAL +
                             ((i - G0_REGNUM) * 8));
        }
    }
 
  if ((regno >= O0_REGNUM && regno <= O7_REGNUM) || regno == -1)
    {
      for (i = O0_REGNUM; i <= O7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            supply_register (i, regs + REG64_OFFSET_OUT +
                             ((i - O0_REGNUM) * 8));
        }
    }
 
  /* Inputs and Locals are stored onto the stack by by the kernel.  */
  if ((regno >= L0_REGNUM && regno <= I7_REGNUM) || regno == -1)
    {
      CORE_ADDR sp = read_register (SP_REGNUM);
      char buf[8];
 
      if (sp & 1)
        {
          /* Registers are 64-bit.  */
          sp += 2047;
 
          for (i = L0_REGNUM; i <= I7_REGNUM; i++)
            {
              if (regno == i || regno == -1)
                {
                  target_read_memory (sp + ((i - L0_REGNUM) * 8),
                                      buf, sizeof (buf));
                  supply_register (i, buf);
                }
            }
        }
      else
        {
          /* Registers are 32-bit.  Toss any sign-extension of the stack
             pointer, clear out the top half of the temporary buffer, and
             put the register value in the bottom half.  */
 
          sp &= 0xffffffffUL;
          memset (buf, 0, sizeof (buf));
          for (i = L0_REGNUM; i <= I7_REGNUM; i++)
            {
              if (regno == i || regno == -1)
                {
                  target_read_memory (sp + ((i - L0_REGNUM) * 4),
                                      &buf[4], sizeof (buf));
                  supply_register (i, buf);
                }
            }
        }
    }
 
  /* FIXME: If we don't set these valid, read_register_bytes() rereads
     all the regs every time it is called!  */
  if (regno == WIM_REGNUM || regno == -1)
    supply_register (WIM_REGNUM, NULL);
  if (regno == TBR_REGNUM || regno == -1)
    supply_register (TBR_REGNUM, NULL);
  if (regno == CPS_REGNUM || regno == -1)
    supply_register (CPS_REGNUM, NULL);
}
 
void
sparcnbsd_fill_reg32 (char *regs, int regno)
{
  int i;
 
  if (regno == PS_REGNUM || regno == -1)
    regcache_collect (PS_REGNUM, regs + REG32_OFFSET_PSR);
 
  if (regno == PC_REGNUM || regno == -1)
    regcache_collect (PC_REGNUM, regs + REG32_OFFSET_PC);
 
  if (regno == NPC_REGNUM || regno == -1)
    regcache_collect (NPC_REGNUM, regs + REG32_OFFSET_NPC);
 
  if (regno == Y_REGNUM || regno == -1)
    regcache_collect (Y_REGNUM, regs + REG32_OFFSET_Y);
 
  if ((regno >= G0_REGNUM && regno <= G7_REGNUM) || regno == -1)
    {
      /* %g0 is always zero */
      for (i = G1_REGNUM; i <= G7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            regcache_collect (i, regs + REG32_OFFSET_GLOBAL +
                              ((i - G0_REGNUM) * 4));
        }
    }
 
  if ((regno >= O0_REGNUM && regno <= O7_REGNUM) || regno == -1)
    {
      for (i = O0_REGNUM; i <= O7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            regcache_collect (i, regs + REG32_OFFSET_OUT +
                              ((i - O0_REGNUM) * 4));
        }
    }
 
  /* Responsibility for the stack regs is pushed off onto the caller.  */
}
 
void
sparcnbsd_fill_reg64 (char *regs, int regno)
{
  int i;
 
  if (regno == TSTATE_REGNUM || regno == -1)
    regcache_collect (TSTATE_REGNUM, regs + REG64_OFFSET_TSTATE);
 
  if (regno == PC_REGNUM || regno == -1)
    regcache_collect (PC_REGNUM, regs + REG64_OFFSET_PC);
 
  if (regno == NPC_REGNUM || regno == -1)
    regcache_collect (NPC_REGNUM, regs + REG64_OFFSET_NPC);
 
  if (regno == Y_REGNUM || regno == -1)
    regcache_collect (Y_REGNUM, regs + REG64_OFFSET_Y);
 
  if ((regno >= G0_REGNUM && regno <= G7_REGNUM) || regno == -1)
    {
      /* %g0 is always zero */
      for (i = G1_REGNUM; i <= G7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            regcache_collect (i, regs + REG64_OFFSET_GLOBAL +
                              ((i - G0_REGNUM) * 4));
        }
    }
 
  if ((regno >= O0_REGNUM && regno <= O7_REGNUM) || regno == -1)
    {
      for (i = O0_REGNUM; i <= O7_REGNUM; i++)
        {
          if (regno == i || regno == -1)
            regcache_collect (i, regs + REG64_OFFSET_OUT +
                              ((i - O0_REGNUM) * 4));
        }
    }
 
  /* Responsibility for the stack regs is pushed off onto the caller.  */
}
 
void
sparcnbsd_supply_fpreg32 (char *fpregs, int regno)
{
  int i;
 
  for (i = 0; i <= 31; i++)
    {
      if (regno == (FP0_REGNUM + i) || regno == -1)
        supply_register (FP0_REGNUM + i, fpregs + (i * 4));
    }
 
  if (regno == FPS_REGNUM || regno == -1)
    supply_register (FPS_REGNUM, fpregs + (32 * 4));
}
 
void
sparcnbsd_supply_fpreg64 (char *fpregs, int regno)
{
  int i;
 
  for (i = 0; i <= 31; i++)
    {
      if (regno == (FP0_REGNUM + i) || regno == -1)
        supply_register (FP0_REGNUM + i, fpregs + (i * 4));
    }
 
  for (; i <= 47; i++)
    {
      if (regno == (FP0_REGNUM + i) || regno == -1)
        supply_register (FP0_REGNUM + i, fpregs + (32 * 4) + (i * 8));
    }
 
  if (regno == FPS_REGNUM || regno == -1)
    supply_register (FPS_REGNUM, fpregs + (32 * 4) + (16 * 8));
 
  /* XXX %gsr */
}
 
void
sparcnbsd_fill_fpreg32 (char *fpregs, int regno)
{
  int i;
 
  for (i = 0; i <= 31; i++)
    {
      if (regno == (FP0_REGNUM + i) || regno == -1)
        regcache_collect (FP0_REGNUM + i, fpregs + (i * 4));
    }
 
  if (regno == FPS_REGNUM || regno == -1)
    regcache_collect (FPS_REGNUM, fpregs + (32 * 4));
}
 
void
sparcnbsd_fill_fpreg64 (char *fpregs, int regno)
{
  int i;
 
  for (i = 0; i <= 31; i++)
    {
      if (regno == (FP0_REGNUM + i) || regno == -1)
        regcache_collect (FP0_REGNUM + i, fpregs + (i * 4));
    }
 
  for (; i <= 47; i++)
    {
      if (regno == (FP0_REGNUM + i) || regno == -1)
        regcache_collect (FP0_REGNUM + i, fpregs + (32 * 4) + (i * 8));
    }
 
  if (regno == FPS_REGNUM || regno == -1)
    regcache_collect (FPS_REGNUM, fpregs + (32 * 4) + (16 * 8));
 
  /* XXX %gsr */
}
 
/* Unlike other NetBSD implementations, the SPARC port historically used
   .reg and .reg2 (see bfd/netbsd-core.c), and as such, we can share one
   routine for a.out and ELF core files.  */
static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
                      CORE_ADDR ignore)
{
  int reg_size, fpreg_size;
 
  if (gdbarch_ptr_bit (current_gdbarch) == 32)
    {
      reg_size = (20 * 4);
      fpreg_size = (33 * 4);
    }
  else
    {
      reg_size = (20 * 8);
      fpreg_size = (64 * 4)
        + 8  /* fsr */
        + 4  /* gsr */
        + 4; /* pad */
    }
 
  switch (which)
    {
    case 0:  /* Integer registers */
      if (core_reg_size != reg_size)
        warning ("Wrong size register set in core file.");
      else if (gdbarch_ptr_bit (current_gdbarch) == 32)
        sparcnbsd_supply_reg32 (core_reg_sect, -1);
      else
        sparcnbsd_supply_reg64 (core_reg_sect, -1);
      break;
 
    case 2:  /* Floating pointer registers */
      if (core_reg_size != fpreg_size)
        warning ("Wrong size FP register set in core file.");
      else if (gdbarch_ptr_bit (current_gdbarch) == 32)
        sparcnbsd_supply_fpreg32 (core_reg_sect, -1);
      else
        sparcnbsd_supply_fpreg64 (core_reg_sect, -1);
      break;
 
    default:
      /* Don't know what kind of register request this is; just ignore it.  */
      break;
    }
}
 
static struct core_fns sparcnbsd_core_fns =
{
  bfd_target_unknown_flavour,           /* core_flavour */
  default_check_format,                 /* check_format */
  default_core_sniffer,                 /* core_sniffer */
  fetch_core_registers,                 /* core_read_registers */
  NULL
};
 
static struct core_fns sparcnbsd_elfcore_fns =
{
  bfd_target_elf_flavour,               /* core_flavour */
  default_check_format,                 /* check_format */
  default_core_sniffer,                 /* core_sniffer */
  fetch_core_registers,                 /* core_read_registers */
  NULL
};
 
/* FIXME: Need PC_IN_SIGTRAMP() support, but NetBSD/sparc signal trampolines
   aren't easily identified.  */
 
static int
sparcnbsd_get_longjmp_target_32 (CORE_ADDR *pc)
{
  CORE_ADDR jb_addr;
  char buf[4];
 
  jb_addr = read_register (O0_REGNUM);
 
  if (target_read_memory (jb_addr + 12, buf, sizeof (buf)))
    return 0;
 
  *pc = extract_address (buf, sizeof (buf));
 
  return 1;
}
 
static int
sparcnbsd_get_longjmp_target_64 (CORE_ADDR *pc)
{
  CORE_ADDR jb_addr;
  char buf[8];
 
  jb_addr = read_register (O0_REGNUM);
 
  if (target_read_memory (jb_addr + 16, buf, sizeof (buf)))
    return 0;
 
  *pc = extract_address (buf, sizeof (buf));
 
  return 1;
}
 
static int
sparcnbsd_aout_in_solib_call_trampoline (CORE_ADDR pc, char *name)
{
  if (strcmp (name, "_DYNAMIC") == 0)
    return 1;
 
  return 0;
}
 
static void
sparcnbsd_init_abi_common (struct gdbarch_info info,
                           struct gdbarch *gdbarch)
{
  set_gdbarch_get_longjmp_target (gdbarch, gdbarch_ptr_bit (gdbarch) == 32 ?
                                           sparcnbsd_get_longjmp_target_32 :
                                           sparcnbsd_get_longjmp_target_64);
}
 
static void
sparcnbsd_init_abi_aout (struct gdbarch_info info,
                         struct gdbarch *gdbarch)
{
  sparcnbsd_init_abi_common (info, gdbarch);
 
  set_gdbarch_in_solib_call_trampoline (gdbarch,
                                     sparcnbsd_aout_in_solib_call_trampoline);
}
 
static void
sparcnbsd_init_abi_elf (struct gdbarch_info info,
                        struct gdbarch *gdbarch)
{
  sparcnbsd_init_abi_common (info, gdbarch);
 
  set_gdbarch_pc_in_sigtramp (gdbarch, nbsd_pc_in_sigtramp);
 
  set_solib_svr4_fetch_link_map_offsets (gdbarch,
                                         gdbarch_ptr_bit (gdbarch) == 32 ?
                                nbsd_ilp32_solib_svr4_fetch_link_map_offsets :
                                nbsd_lp64_solib_svr4_fetch_link_map_offsets);
}
 
static enum gdb_osabi
sparcnbsd_aout_osabi_sniffer (bfd *abfd)
{
  if (strcmp (bfd_get_target (abfd), "a.out-sparc-netbsd") == 0)
    return GDB_OSABI_NETBSD_AOUT;
 
  return GDB_OSABI_UNKNOWN;
}
 
void
_initialize_sparnbsd_tdep (void)
{
  gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_aout_flavour,
                                  sparcnbsd_aout_osabi_sniffer);
 
  gdbarch_register_osabi (bfd_arch_sparc, GDB_OSABI_NETBSD_AOUT,
                          sparcnbsd_init_abi_aout);
  gdbarch_register_osabi (bfd_arch_sparc, GDB_OSABI_NETBSD_ELF,
                          sparcnbsd_init_abi_elf);
 
  add_core_fns (&sparcnbsd_core_fns);
  add_core_fns (&sparcnbsd_elfcore_fns);
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [sparcnbsd-tdep.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1181	sfurman	`/* Target-dependent code for SPARC systems running NetBSD.`
2			`Copyright 2002 Free Software Foundation, Inc.`
3			`Contributed by Wasabi Systems, Inc.`
4
5			`This file is part of GDB.`
6
7			`This program is free software; you can redistribute it and/or modify`
8			`it under the terms of the GNU General Public License as published by`
9			`the Free Software Foundation; either version 2 of the License, or`
10			`(at your option) any later version.`
11
12			`This program is distributed in the hope that it will be useful,`
13			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`GNU General Public License for more details.`
16
17			`You should have received a copy of the GNU General Public License`
18			`along with this program; if not, write to the Free Software`
19			`Foundation, Inc., 59 Temple Place - Suite 330,`
20			`Boston, MA 02111-1307, USA. */`
21
22			`#include "defs.h"`
23			`#include "gdbcore.h"`
24			`#include "regcache.h"`
25			`#include "target.h"`
26			`#include "value.h"`
27			`#include "osabi.h"`
28
29			`#include "sparcnbsd-tdep.h"`
30			`#include "nbsd-tdep.h"`
31
32			`#include "solib-svr4.h"`
33
34			`#define REG32_OFFSET_PSR (0 * 4)`
35			`#define REG32_OFFSET_PC (1 * 4)`
36			`#define REG32_OFFSET_NPC (2 * 4)`
37			`#define REG32_OFFSET_Y (3 * 4)`
38			`#define REG32_OFFSET_GLOBAL (4 * 4)`
39			`#define REG32_OFFSET_OUT (12 * 4)`
40
41			`#define REG64_OFFSET_TSTATE (0 * 8)`
42			`#define REG64_OFFSET_PC (1 * 8)`
43			`#define REG64_OFFSET_NPC (2 * 8)`
44			`#define REG64_OFFSET_Y (3 * 8)`
45			`#define REG64_OFFSET_GLOBAL (4 * 8)`
46			`#define REG64_OFFSET_OUT (12 * 8)`
47
48			`void`
49			`sparcnbsd_supply_reg32 (char *regs, int regno)`
50			`{`
51			`int i;`
52
53			`if (regno == PS_REGNUM \|\| regno == -1)`
54			`supply_register (PS_REGNUM, regs + REG32_OFFSET_PSR);`
55
56			`if (regno == PC_REGNUM \|\| regno == -1)`
57			`supply_register (PC_REGNUM, regs + REG32_OFFSET_PC);`
58
59			`if (regno == NPC_REGNUM \|\| regno == -1)`
60			`supply_register (NPC_REGNUM, regs + REG32_OFFSET_NPC);`
61
62			`if (regno == Y_REGNUM \|\| regno == -1)`
63			`supply_register (Y_REGNUM, regs + REG32_OFFSET_Y);`
64
65			`if ((regno >= G0_REGNUM && regno <= G7_REGNUM) \|\| regno == -1)`
66			`{`
67			`if (regno == G0_REGNUM \|\| regno == -1)`
68			`supply_register (G0_REGNUM, NULL); /* %g0 is always zero */`
69			`for (i = G1_REGNUM; i <= G7_REGNUM; i++)`
70			`{`
71			`if (regno == i \|\| regno == -1)`
72			`supply_register (i, regs + REG32_OFFSET_GLOBAL +`
73			`((i - G0_REGNUM) * 4));`
74			`}`
75			`}`
76
77			`if ((regno >= O0_REGNUM && regno <= O7_REGNUM) \|\| regno == -1)`
78			`{`
79			`for (i = O0_REGNUM; i <= O7_REGNUM; i++)`
80			`{`
81			`if (regno == i \|\| regno == -1)`
82			`supply_register (i, regs + REG32_OFFSET_OUT +`
83			`((i - O0_REGNUM) * 4));`
84			`}`
85			`}`
86
87			`/* Inputs and Locals are stored onto the stack by by the kernel. */`
88			`if ((regno >= L0_REGNUM && regno <= I7_REGNUM) \|\| regno == -1)`
89			`{`
90			`CORE_ADDR sp = read_register (SP_REGNUM);`
91			`char buf[4];`
92
93			`for (i = L0_REGNUM; i <= I7_REGNUM; i++)`
94			`{`
95			`if (regno == i \|\| regno == -1)`
96			`{`
97			`target_read_memory (sp + ((i - L0_REGNUM) * 4),`
98			`buf, sizeof (buf));`
99			`supply_register (i, buf);`
100			`}`
101			`}`
102			`}`
103
104			`/* FIXME: If we don't set these valid, read_register_bytes() rereads`
105			`all the regs every time it is called! */`
106			`if (regno == WIM_REGNUM \|\| regno == -1)`
107			`supply_register (WIM_REGNUM, NULL);`
108			`if (regno == TBR_REGNUM \|\| regno == -1)`
109			`supply_register (TBR_REGNUM, NULL);`
110			`if (regno == CPS_REGNUM \|\| regno == -1)`
111			`supply_register (CPS_REGNUM, NULL);`
112			`}`
113
114			`void`
115			`sparcnbsd_supply_reg64 (char *regs, int regno)`
116			`{`
117			`int i;`
118			`char buf[8];`
119
120			`if (regno == TSTATE_REGNUM \|\| regno == -1)`
121			`supply_register (PS_REGNUM, regs + REG64_OFFSET_TSTATE);`
122
123			`if (regno == PC_REGNUM \|\| regno == -1)`
124			`supply_register (PC_REGNUM, regs + REG64_OFFSET_PC);`
125
126			`if (regno == NPC_REGNUM \|\| regno == -1)`
127			`supply_register (NPC_REGNUM, regs + REG64_OFFSET_NPC);`
128
129			`if (regno == Y_REGNUM \|\| regno == -1)`
130			`{`
131			`memset (buf, 0, sizeof (buf));`
132			`memcpy (&buf[4], regs + REG64_OFFSET_Y, 4);`
133			`supply_register (Y_REGNUM, buf);`
134			`}`
135
136			`if ((regno >= G0_REGNUM && regno <= G7_REGNUM) \|\| regno == -1)`
137			`{`
138			`if (regno == G0_REGNUM \|\| regno == -1)`
139			`supply_register (G0_REGNUM, NULL); /* %g0 is always zero */`
140			`for (i = G1_REGNUM; i <= G7_REGNUM; i++)`
141			`{`
142			`if (regno == i \|\| regno == -1)`
143			`supply_register (i, regs + REG64_OFFSET_GLOBAL +`
144			`((i - G0_REGNUM) * 8));`
145			`}`
146			`}`
147
148			`if ((regno >= O0_REGNUM && regno <= O7_REGNUM) \|\| regno == -1)`
149			`{`
150			`for (i = O0_REGNUM; i <= O7_REGNUM; i++)`
151			`{`
152			`if (regno == i \|\| regno == -1)`
153			`supply_register (i, regs + REG64_OFFSET_OUT +`
154			`((i - O0_REGNUM) * 8));`
155			`}`
156			`}`
157
158			`/* Inputs and Locals are stored onto the stack by by the kernel. */`
159			`if ((regno >= L0_REGNUM && regno <= I7_REGNUM) \|\| regno == -1)`
160			`{`
161			`CORE_ADDR sp = read_register (SP_REGNUM);`
162			`char buf[8];`
163
164			`if (sp & 1)`
165			`{`
166			`/* Registers are 64-bit. */`
167			`sp += 2047;`
168
169			`for (i = L0_REGNUM; i <= I7_REGNUM; i++)`
170			`{`
171			`if (regno == i \|\| regno == -1)`
172			`{`
173			`target_read_memory (sp + ((i - L0_REGNUM) * 8),`
174			`buf, sizeof (buf));`
175			`supply_register (i, buf);`
176			`}`
177			`}`
178			`}`
179			`else`
180			`{`
181			`/* Registers are 32-bit. Toss any sign-extension of the stack`
182			`pointer, clear out the top half of the temporary buffer, and`
183			`put the register value in the bottom half. */`
184
185			`sp &= 0xffffffffUL;`
186			`memset (buf, 0, sizeof (buf));`
187			`for (i = L0_REGNUM; i <= I7_REGNUM; i++)`
188			`{`
189			`if (regno == i \|\| regno == -1)`
190			`{`
191			`target_read_memory (sp + ((i - L0_REGNUM) * 4),`
192			`&buf[4], sizeof (buf));`
193			`supply_register (i, buf);`
194			`}`
195			`}`
196			`}`
197			`}`
198
199			`/* FIXME: If we don't set these valid, read_register_bytes() rereads`
200			`all the regs every time it is called! */`
201			`if (regno == WIM_REGNUM \|\| regno == -1)`
202			`supply_register (WIM_REGNUM, NULL);`
203			`if (regno == TBR_REGNUM \|\| regno == -1)`
204			`supply_register (TBR_REGNUM, NULL);`
205			`if (regno == CPS_REGNUM \|\| regno == -1)`
206			`supply_register (CPS_REGNUM, NULL);`
207			`}`
208
209			`void`
210			`sparcnbsd_fill_reg32 (char *regs, int regno)`
211			`{`
212			`int i;`
213
214			`if (regno == PS_REGNUM \|\| regno == -1)`
215			`regcache_collect (PS_REGNUM, regs + REG32_OFFSET_PSR);`
216
217			`if (regno == PC_REGNUM \|\| regno == -1)`
218			`regcache_collect (PC_REGNUM, regs + REG32_OFFSET_PC);`
219
220			`if (regno == NPC_REGNUM \|\| regno == -1)`
221			`regcache_collect (NPC_REGNUM, regs + REG32_OFFSET_NPC);`
222
223			`if (regno == Y_REGNUM \|\| regno == -1)`
224			`regcache_collect (Y_REGNUM, regs + REG32_OFFSET_Y);`
225
226			`if ((regno >= G0_REGNUM && regno <= G7_REGNUM) \|\| regno == -1)`
227			`{`
228			`/* %g0 is always zero */`
229			`for (i = G1_REGNUM; i <= G7_REGNUM; i++)`
230			`{`
231			`if (regno == i \|\| regno == -1)`
232			`regcache_collect (i, regs + REG32_OFFSET_GLOBAL +`
233			`((i - G0_REGNUM) * 4));`
234			`}`
235			`}`
236
237			`if ((regno >= O0_REGNUM && regno <= O7_REGNUM) \|\| regno == -1)`
238			`{`
239			`for (i = O0_REGNUM; i <= O7_REGNUM; i++)`
240			`{`
241			`if (regno == i \|\| regno == -1)`
242			`regcache_collect (i, regs + REG32_OFFSET_OUT +`
243			`((i - O0_REGNUM) * 4));`
244			`}`
245			`}`
246
247			`/* Responsibility for the stack regs is pushed off onto the caller. */`
248			`}`
249
250			`void`
251			`sparcnbsd_fill_reg64 (char *regs, int regno)`
252			`{`
253			`int i;`
254
255			`if (regno == TSTATE_REGNUM \|\| regno == -1)`
256			`regcache_collect (TSTATE_REGNUM, regs + REG64_OFFSET_TSTATE);`
257
258			`if (regno == PC_REGNUM \|\| regno == -1)`
259			`regcache_collect (PC_REGNUM, regs + REG64_OFFSET_PC);`
260
261			`if (regno == NPC_REGNUM \|\| regno == -1)`
262			`regcache_collect (NPC_REGNUM, regs + REG64_OFFSET_NPC);`
263
264			`if (regno == Y_REGNUM \|\| regno == -1)`
265			`regcache_collect (Y_REGNUM, regs + REG64_OFFSET_Y);`
266
267			`if ((regno >= G0_REGNUM && regno <= G7_REGNUM) \|\| regno == -1)`
268			`{`
269			`/* %g0 is always zero */`
270			`for (i = G1_REGNUM; i <= G7_REGNUM; i++)`
271			`{`
272			`if (regno == i \|\| regno == -1)`
273			`regcache_collect (i, regs + REG64_OFFSET_GLOBAL +`
274			`((i - G0_REGNUM) * 4));`
275			`}`
276			`}`
277
278			`if ((regno >= O0_REGNUM && regno <= O7_REGNUM) \|\| regno == -1)`
279			`{`
280			`for (i = O0_REGNUM; i <= O7_REGNUM; i++)`
281			`{`
282			`if (regno == i \|\| regno == -1)`
283			`regcache_collect (i, regs + REG64_OFFSET_OUT +`
284			`((i - O0_REGNUM) * 4));`
285			`}`
286			`}`
287
288			`/* Responsibility for the stack regs is pushed off onto the caller. */`
289			`}`
290
291			`void`
292			`sparcnbsd_supply_fpreg32 (char *fpregs, int regno)`
293			`{`
294			`int i;`
295
296			`for (i = 0; i <= 31; i++)`
297			`{`
298			`if (regno == (FP0_REGNUM + i) \|\| regno == -1)`
299			`supply_register (FP0_REGNUM + i, fpregs + (i * 4));`
300			`}`
301
302			`if (regno == FPS_REGNUM \|\| regno == -1)`
303			`supply_register (FPS_REGNUM, fpregs + (32 * 4));`
304			`}`
305
306			`void`
307			`sparcnbsd_supply_fpreg64 (char *fpregs, int regno)`
308			`{`
309			`int i;`
310
311			`for (i = 0; i <= 31; i++)`
312			`{`
313			`if (regno == (FP0_REGNUM + i) \|\| regno == -1)`
314			`supply_register (FP0_REGNUM + i, fpregs + (i * 4));`
315			`}`
316
317			`for (; i <= 47; i++)`
318			`{`
319			`if (regno == (FP0_REGNUM + i) \|\| regno == -1)`
320			`supply_register (FP0_REGNUM + i, fpregs + (32 * 4) + (i * 8));`
321			`}`
322
323			`if (regno == FPS_REGNUM \|\| regno == -1)`
324			`supply_register (FPS_REGNUM, fpregs + (32 * 4) + (16 * 8));`
325
326			`/* XXX %gsr */`
327			`}`
328
329			`void`
330			`sparcnbsd_fill_fpreg32 (char *fpregs, int regno)`
331			`{`
332			`int i;`
333
334			`for (i = 0; i <= 31; i++)`
335			`{`
336			`if (regno == (FP0_REGNUM + i) \|\| regno == -1)`
337			`regcache_collect (FP0_REGNUM + i, fpregs + (i * 4));`
338			`}`
339
340			`if (regno == FPS_REGNUM \|\| regno == -1)`
341			`regcache_collect (FPS_REGNUM, fpregs + (32 * 4));`
342			`}`
343
344			`void`
345			`sparcnbsd_fill_fpreg64 (char *fpregs, int regno)`
346			`{`
347			`int i;`
348
349			`for (i = 0; i <= 31; i++)`
350			`{`
351			`if (regno == (FP0_REGNUM + i) \|\| regno == -1)`
352			`regcache_collect (FP0_REGNUM + i, fpregs + (i * 4));`
353			`}`
354
355			`for (; i <= 47; i++)`
356			`{`
357			`if (regno == (FP0_REGNUM + i) \|\| regno == -1)`
358			`regcache_collect (FP0_REGNUM + i, fpregs + (32 * 4) + (i * 8));`
359			`}`
360
361			`if (regno == FPS_REGNUM \|\| regno == -1)`
362			`regcache_collect (FPS_REGNUM, fpregs + (32 * 4) + (16 * 8));`
363
364			`/* XXX %gsr */`
365			`}`
366
367			`/* Unlike other NetBSD implementations, the SPARC port historically used`
368			`.reg and .reg2 (see bfd/netbsd-core.c), and as such, we can share one`
369			`routine for a.out and ELF core files. */`
370			`static void`
371			`fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,`
372			`CORE_ADDR ignore)`
373			`{`
374			`int reg_size, fpreg_size;`
375
376			`if (gdbarch_ptr_bit (current_gdbarch) == 32)`
377			`{`
378			`reg_size = (20 * 4);`
379			`fpreg_size = (33 * 4);`
380			`}`
381			`else`
382			`{`
383			`reg_size = (20 * 8);`
384			`fpreg_size = (64 * 4)`
385			`+ 8 /* fsr */`
386			`+ 4 /* gsr */`
387			`+ 4; /* pad */`
388			`}`
389
390			`switch (which)`
391			`{`
392			`case 0: /* Integer registers */`
393			`if (core_reg_size != reg_size)`
394			`warning ("Wrong size register set in core file.");`
395			`else if (gdbarch_ptr_bit (current_gdbarch) == 32)`
396			`sparcnbsd_supply_reg32 (core_reg_sect, -1);`
397			`else`
398			`sparcnbsd_supply_reg64 (core_reg_sect, -1);`
399			`break;`
400
401			`case 2: /* Floating pointer registers */`
402			`if (core_reg_size != fpreg_size)`
403			`warning ("Wrong size FP register set in core file.");`
404			`else if (gdbarch_ptr_bit (current_gdbarch) == 32)`
405			`sparcnbsd_supply_fpreg32 (core_reg_sect, -1);`
406			`else`
407			`sparcnbsd_supply_fpreg64 (core_reg_sect, -1);`
408			`break;`
409
410			`default:`
411			`/* Don't know what kind of register request this is; just ignore it. */`
412			`break;`
413			`}`
414			`}`
415
416			`static struct core_fns sparcnbsd_core_fns =`
417			`{`
418			`bfd_target_unknown_flavour, /* core_flavour */`
419			`default_check_format, /* check_format */`
420			`default_core_sniffer, /* core_sniffer */`
421			`fetch_core_registers, /* core_read_registers */`
422			`NULL`
423			`};`
424
425			`static struct core_fns sparcnbsd_elfcore_fns =`
426			`{`
427			`bfd_target_elf_flavour, /* core_flavour */`
428			`default_check_format, /* check_format */`
429			`default_core_sniffer, /* core_sniffer */`
430			`fetch_core_registers, /* core_read_registers */`
431			`NULL`
432			`};`
433
434			`/* FIXME: Need PC_IN_SIGTRAMP() support, but NetBSD/sparc signal trampolines`
435			`aren't easily identified. */`
436
437			`static int`
438			`sparcnbsd_get_longjmp_target_32 (CORE_ADDR *pc)`
439			`{`
440			`CORE_ADDR jb_addr;`
441			`char buf[4];`
442
443			`jb_addr = read_register (O0_REGNUM);`
444
445			`if (target_read_memory (jb_addr + 12, buf, sizeof (buf)))`
446			`return 0;`
447
448			`*pc = extract_address (buf, sizeof (buf));`
449
450			`return 1;`
451			`}`
452
453			`static int`
454			`sparcnbsd_get_longjmp_target_64 (CORE_ADDR *pc)`
455			`{`
456			`CORE_ADDR jb_addr;`
457			`char buf[8];`
458
459			`jb_addr = read_register (O0_REGNUM);`
460
461			`if (target_read_memory (jb_addr + 16, buf, sizeof (buf)))`
462			`return 0;`
463
464			`*pc = extract_address (buf, sizeof (buf));`
465
466			`return 1;`
467			`}`
468
469			`static int`
470			`sparcnbsd_aout_in_solib_call_trampoline (CORE_ADDR pc, char *name)`
471			`{`
472			`if (strcmp (name, "_DYNAMIC") == 0)`
473			`return 1;`
474
475			`return 0;`
476			`}`
477
478			`static void`
479			`sparcnbsd_init_abi_common (struct gdbarch_info info,`
480			`struct gdbarch *gdbarch)`
481			`{`
482			`set_gdbarch_get_longjmp_target (gdbarch, gdbarch_ptr_bit (gdbarch) == 32 ?`
483			`sparcnbsd_get_longjmp_target_32 :`
484			`sparcnbsd_get_longjmp_target_64);`
485			`}`
486
487			`static void`
488			`sparcnbsd_init_abi_aout (struct gdbarch_info info,`
489			`struct gdbarch *gdbarch)`
490			`{`
491			`sparcnbsd_init_abi_common (info, gdbarch);`
492
493			`set_gdbarch_in_solib_call_trampoline (gdbarch,`
494			`sparcnbsd_aout_in_solib_call_trampoline);`
495			`}`
496
497			`static void`
498			`sparcnbsd_init_abi_elf (struct gdbarch_info info,`
499			`struct gdbarch *gdbarch)`
500			`{`
501			`sparcnbsd_init_abi_common (info, gdbarch);`
502
503			`set_gdbarch_pc_in_sigtramp (gdbarch, nbsd_pc_in_sigtramp);`
504
505			`set_solib_svr4_fetch_link_map_offsets (gdbarch,`
506			`gdbarch_ptr_bit (gdbarch) == 32 ?`
507			`nbsd_ilp32_solib_svr4_fetch_link_map_offsets :`
508			`nbsd_lp64_solib_svr4_fetch_link_map_offsets);`
509			`}`
510
511			`static enum gdb_osabi`
512			`sparcnbsd_aout_osabi_sniffer (bfd *abfd)`
513			`{`
514			`if (strcmp (bfd_get_target (abfd), "a.out-sparc-netbsd") == 0)`
515			`return GDB_OSABI_NETBSD_AOUT;`
516
517			`return GDB_OSABI_UNKNOWN;`
518			`}`
519
520			`void`
521			`_initialize_sparnbsd_tdep (void)`
522			`{`
523			`gdbarch_register_osabi_sniffer (bfd_arch_sparc, bfd_target_aout_flavour,`
524			`sparcnbsd_aout_osabi_sniffer);`
525
526			`gdbarch_register_osabi (bfd_arch_sparc, GDB_OSABI_NETBSD_AOUT,`
527			`sparcnbsd_init_abi_aout);`
528			`gdbarch_register_osabi (bfd_arch_sparc, GDB_OSABI_NETBSD_ELF,`
529			`sparcnbsd_init_abi_elf);`
530
531			`add_core_fns (&sparcnbsd_core_fns);`
532			`add_core_fns (&sparcnbsd_elfcore_fns);`
533			`}`