1 /* Native-dependent code for PowerPC's running FreeBSD, for GDB. 2 3 Copyright (C) 2013-2019 Free Software Foundation, 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 3 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, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "gdbcore.h" 22 #include "inferior.h" 23 #include "regcache.h" 24 25 #include <sys/types.h> 26 #include <sys/procfs.h> 27 #include <sys/ptrace.h> 28 #include <sys/signal.h> 29 #include <machine/frame.h> 30 #include <machine/pcb.h> 31 #include <machine/reg.h> 32 33 #include "fbsd-nat.h" 34 #include "gregset.h" 35 #include "ppc-tdep.h" 36 #include "ppc-fbsd-tdep.h" 37 #include "inf-ptrace.h" 38 #include "bsd-kvm.h" 39 40 struct ppc_fbsd_nat_target final : public fbsd_nat_target 41 { 42 void fetch_registers (struct regcache *, int) override; 43 void store_registers (struct regcache *, int) override; 44 }; 45 46 static ppc_fbsd_nat_target the_ppc_fbsd_nat_target; 47 48 /* Fill GDB's register array with the general-purpose register values 49 in *GREGSETP. */ 50 51 void 52 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp) 53 { 54 const struct regset *regset = ppc_fbsd_gregset (sizeof (long)); 55 56 ppc_supply_gregset (regset, regcache, -1, gregsetp, sizeof (*gregsetp)); 57 } 58 59 /* Fill register REGNO (if a gpr) in *GREGSETP with the value in GDB's 60 register array. If REGNO is -1 do it for all registers. */ 61 62 void 63 fill_gregset (const struct regcache *regcache, 64 gdb_gregset_t *gregsetp, int regno) 65 { 66 const struct regset *regset = ppc_fbsd_gregset (sizeof (long)); 67 68 if (regno == -1) 69 memset (gregsetp, 0, sizeof (*gregsetp)); 70 ppc_collect_gregset (regset, regcache, regno, gregsetp, sizeof (*gregsetp)); 71 } 72 73 /* Fill GDB's register array with the floating-point register values 74 in *FPREGSETP. */ 75 76 void 77 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t * fpregsetp) 78 { 79 const struct regset *regset = ppc_fbsd_fpregset (); 80 81 ppc_supply_fpregset (regset, regcache, -1, 82 fpregsetp, sizeof (*fpregsetp)); 83 } 84 85 /* Fill register REGNO in *FGREGSETP with the value in GDB's 86 register array. If REGNO is -1 do it for all registers. */ 87 88 void 89 fill_fpregset (const struct regcache *regcache, 90 gdb_fpregset_t *fpregsetp, int regno) 91 { 92 const struct regset *regset = ppc_fbsd_fpregset (); 93 94 ppc_collect_fpregset (regset, regcache, regno, 95 fpregsetp, sizeof (*fpregsetp)); 96 } 97 98 /* Returns true if PT_GETFPREGS fetches this register. */ 99 100 static int 101 getfpregs_supplies (struct gdbarch *gdbarch, int regno) 102 { 103 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 104 105 /* FIXME: jimb/2004-05-05: Some PPC variants don't have floating 106 point registers. Traditionally, GDB's register set has still 107 listed the floating point registers for such machines, so this 108 code is harmless. However, the new E500 port actually omits the 109 floating point registers entirely from the register set --- they 110 don't even have register numbers assigned to them. 111 112 It's not clear to me how best to update this code, so this assert 113 will alert the first person to encounter the NetBSD/E500 114 combination to the problem. */ 115 116 gdb_assert (ppc_floating_point_unit_p (gdbarch)); 117 118 return ((regno >= tdep->ppc_fp0_regnum 119 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs) 120 || regno == tdep->ppc_fpscr_regnum); 121 } 122 123 /* Fetch register REGNO from the child process. If REGNO is -1, do it 124 for all registers. */ 125 126 void 127 ppc_fbsd_nat_target::fetch_registers (struct regcache *regcache, int regno) 128 { 129 gdb_gregset_t regs; 130 pid_t pid = regcache->ptid ().lwp (); 131 132 if (ptrace (PT_GETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 0) == -1) 133 perror_with_name (_("Couldn't get registers")); 134 135 supply_gregset (regcache, ®s); 136 137 if (regno == -1 || getfpregs_supplies (regcache->arch (), regno)) 138 { 139 const struct regset *fpregset = ppc_fbsd_fpregset (); 140 gdb_fpregset_t fpregs; 141 142 if (ptrace (PT_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1) 143 perror_with_name (_("Couldn't get FP registers")); 144 145 ppc_supply_fpregset (fpregset, regcache, regno, &fpregs, sizeof fpregs); 146 } 147 } 148 149 /* Store register REGNO back into the child process. If REGNO is -1, 150 do this for all registers. */ 151 152 void 153 ppc_fbsd_nat_target::store_registers (struct regcache *regcache, int regno) 154 { 155 gdb_gregset_t regs; 156 pid_t pid = regcache->ptid ().lwp (); 157 158 if (ptrace (PT_GETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 0) == -1) 159 perror_with_name (_("Couldn't get registers")); 160 161 fill_gregset (regcache, ®s, regno); 162 163 if (ptrace (PT_SETREGS, pid, (PTRACE_TYPE_ARG3) ®s, 0) == -1) 164 perror_with_name (_("Couldn't write registers")); 165 166 if (regno == -1 || getfpregs_supplies (regcache->arch (), regno)) 167 { 168 gdb_fpregset_t fpregs; 169 170 if (ptrace (PT_GETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1) 171 perror_with_name (_("Couldn't get FP registers")); 172 173 fill_fpregset (regcache, &fpregs, regno); 174 175 if (ptrace (PT_SETFPREGS, pid, (PTRACE_TYPE_ARG3) &fpregs, 0) == -1) 176 perror_with_name (_("Couldn't set FP registers")); 177 } 178 } 179 180 /* Architecture specific function that reconstructs the 181 register state from PCB (Process Control Block) and supplies it 182 to REGCACHE. */ 183 184 static int 185 ppcfbsd_supply_pcb (struct regcache *regcache, struct pcb *pcb) 186 { 187 struct gdbarch *gdbarch = regcache->arch (); 188 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 189 int i, regnum; 190 191 /* The stack pointer shouldn't be zero. */ 192 if (pcb->pcb_sp == 0) 193 return 0; 194 195 regcache->raw_supply (gdbarch_sp_regnum (gdbarch), &pcb->pcb_sp); 196 regcache->raw_supply (tdep->ppc_cr_regnum, &pcb->pcb_cr); 197 regcache->raw_supply (tdep->ppc_lr_regnum, &pcb->pcb_lr); 198 for (i = 0, regnum = tdep->ppc_gp0_regnum + 14; i < 20; i++, regnum++) 199 regcache->raw_supply (regnum, &pcb->pcb_context[i]); 200 201 return 1; 202 } 203 204 void 205 _initialize_ppcfbsd_nat (void) 206 { 207 add_inf_child_target (&the_ppc_fbsd_nat_target); 208 209 /* Support debugging kernel virtual memory images. */ 210 bsd_kvm_add_target (ppcfbsd_supply_pcb); 211 } 212