gdb/gdbserver/linux-ppc64-low.c

   1 /* GNU/Linux/PowerPC64 specific low level interface, for the remote server for
   2    GDB.
   3    Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2005, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "server.h"
  22 #include "linux-low.h"
  23
  24 /* Defined in auto-generated file reg-ppc64.c.  */
  25 void init_registers_ppc64 (void);
  26 /* Defined in auto-generated file powerpc-64.c.  */
  27 void init_registers_powerpc_64 (void);
  28
  29 #include <asm/ptrace.h>
  30
  31 #define ppc_num_regs 71
  32
  33 /* We use a constant for FPSCR instead of PT_FPSCR, because
  34    many shipped PPC64 kernels had the wrong value in ptrace.h.  */
  35 static int ppc_regmap[] =
  36  {PT_R0 * 8,     PT_R1 * 8,     PT_R2 * 8,     PT_R3 * 8,
  37   PT_R4 * 8,     PT_R5 * 8,     PT_R6 * 8,     PT_R7 * 8,
  38   PT_R8 * 8,     PT_R9 * 8,     PT_R10 * 8,    PT_R11 * 8,
  39   PT_R12 * 8,    PT_R13 * 8,    PT_R14 * 8,    PT_R15 * 8,
  40   PT_R16 * 8,    PT_R17 * 8,    PT_R18 * 8,    PT_R19 * 8,
  41   PT_R20 * 8,    PT_R21 * 8,    PT_R22 * 8,    PT_R23 * 8,
  42   PT_R24 * 8,    PT_R25 * 8,    PT_R26 * 8,    PT_R27 * 8,
  43   PT_R28 * 8,    PT_R29 * 8,    PT_R30 * 8,    PT_R31 * 8,
  44   PT_FPR0*8,     PT_FPR0*8 + 8, PT_FPR0*8+16,  PT_FPR0*8+24,
  45   PT_FPR0*8+32,  PT_FPR0*8+40,  PT_FPR0*8+48,  PT_FPR0*8+56,
  46   PT_FPR0*8+64,  PT_FPR0*8+72,  PT_FPR0*8+80,  PT_FPR0*8+88,
  47   PT_FPR0*8+96,  PT_FPR0*8+104,  PT_FPR0*8+112,  PT_FPR0*8+120,
  48   PT_FPR0*8+128, PT_FPR0*8+136,  PT_FPR0*8+144,  PT_FPR0*8+152,
  49   PT_FPR0*8+160,  PT_FPR0*8+168,  PT_FPR0*8+176,  PT_FPR0*8+184,
  50   PT_FPR0*8+192,  PT_FPR0*8+200,  PT_FPR0*8+208,  PT_FPR0*8+216,
  51   PT_FPR0*8+224,  PT_FPR0*8+232,  PT_FPR0*8+240,  PT_FPR0*8+248,
  52   PT_NIP * 8,    PT_MSR * 8,    PT_CCR * 8,    PT_LNK * 8,
  53   PT_CTR * 8,    PT_XER * 8,    PT_FPR0*8 + 256 };
  54
  55 static int
  56 ppc_cannot_store_register (int regno)
  57 {
  58   return 0;
  59 }
  60
  61 static int
  62 ppc_cannot_fetch_register (int regno)
  63 {
  64   return 0;
  65 }
  66
  67 static void
  68 ppc_collect_ptrace_register (int regno, char *buf)
  69 {
  70   int size = register_size (regno);
  71   if (size < sizeof (long))
  72     collect_register (regno, buf + sizeof (long) - size);
  73   else
  74     collect_register (regno, buf);
  75 }
  76
  77 static void
  78 ppc_supply_ptrace_register (int regno, const char *buf)
  79 {
  80   int size = register_size (regno);
  81   if (size < sizeof (long))
  82     supply_register (regno, buf + sizeof (long) - size);
  83   else
  84     supply_register (regno, buf);
  85 }
  86
  87 static CORE_ADDR
  88 ppc_get_pc (void)
  89 {
  90   unsigned long pc;
  91
  92   collect_register_by_name ("pc", &pc);
  93   return (CORE_ADDR) pc;
  94 }
  95
  96 static void
  97 ppc_set_pc (CORE_ADDR pc)
  98 {
  99   unsigned long newpc = pc;
 100
 101   supply_register_by_name ("pc", &newpc);
 102 }
 103
 104 /* Correct in either endianness.
 105    This instruction is "twge r2, r2", which GDB uses as a software
 106    breakpoint.  */
 107 static const unsigned int ppc_breakpoint = 0x7d821008;
 108 #define ppc_breakpoint_len 4
 109
 110 static int
 111 ppc_breakpoint_at (CORE_ADDR where)
 112 {
 113   unsigned int insn;
 114
 115   (*the_target->read_memory) (where, (unsigned char *) &insn, 4);
 116   if (insn == ppc_breakpoint)
 117     return 1;
 118   /* If necessary, recognize more trap instructions here.  GDB only uses the
 119      one.  */
 120   return 0;
 121 }
 122
 123 /* Provide only a fill function for the general register set.  ps_lgetregs
 124    will use this for NPTL support.  */
 125
 126 static void ppc_fill_gregset (void *buf)
 127 {
 128   int i;
 129
 130   for (i = 0; i < 32; i++)
 131     collect_register (i, (char *) buf + ppc_regmap[i]);
 132
 133   for (i = 64; i < 70; i++)
 134     collect_register (i, (char *) buf + ppc_regmap[i]);
 135 }
 136
 137 #ifdef __ALTIVEC__
 138
 139 #ifndef PTRACE_GETVRREGS
 140 #define PTRACE_GETVRREGS 18
 141 #define PTRACE_SETVRREGS 19
 142 #endif
 143
 144 #define SIZEOF_VRREGS 33*16+4
 145
 146 static void
 147 ppc_fill_vrregset (void *buf)
 148 {
 149   int i, base;
 150   char *regset = buf;
 151
 152   base = find_regno ("vr0");
 153   for (i = 0; i < 32; i++)
 154     collect_register (base + i, &regset[i * 16]);
 155
 156   collect_register_by_name ("vscr", &regset[32 * 16 + 12]);
 157   collect_register_by_name ("vrsave", &regset[33 * 16]);
 158 }
 159
 160 static void
 161 ppc_store_vrregset (const void *buf)
 162 {
 163   int i, base;
 164   const char *regset = buf;
 165
 166   base = find_regno ("vr0");
 167   for (i = 0; i < 32; i++)
 168     supply_register (base + i, &regset[i * 16]);
 169
 170   supply_register_by_name ("vscr", &regset[32 * 16 + 12]);
 171   supply_register_by_name ("vrsave", &regset[33 * 16]);
 172 }
 173
 174 #endif /* __ALTIVEC__ */
 175
 176 struct regset_info target_regsets[] = {
 177   /* List the extra register sets before GENERAL_REGS.  That way we will
 178      fetch them every time, but still fall back to PTRACE_PEEKUSER for the
 179      general registers.  Some kernels support these, but not the newer
 180      PPC_PTRACE_GETREGS.  */
 181 #ifdef __ALTIVEC__
 182   { PTRACE_GETVRREGS, PTRACE_SETVRREGS, SIZEOF_VRREGS, EXTENDED_REGS,
 183     ppc_fill_vrregset, ppc_store_vrregset },
 184 #endif
 185   { 0, 0, 0, GENERAL_REGS, ppc_fill_gregset, NULL },
 186   { 0, 0, -1, -1, NULL, NULL }
 187 };
 188
 189 struct linux_target_ops the_low_target = {
 190 #ifdef __ALTIVEC__
 191   init_registers_powerpc_64,
 192 #else
 193   init_registers_ppc64,
 194 #endif
 195   ppc_num_regs,
 196   ppc_regmap,
 197   ppc_cannot_fetch_register,
 198   ppc_cannot_store_register,
 199   ppc_get_pc,
 200   ppc_set_pc,
 201   (const unsigned char *) &ppc_breakpoint,
 202   ppc_breakpoint_len,
 203   NULL,
 204   0,
 205   ppc_breakpoint_at,
 206   NULL,
 207   NULL,
 208   NULL,
 209   NULL,
 210   ppc_collect_ptrace_register,
 211   ppc_supply_ptrace_register,
 212 };