frame: add frame_id_build_unavailable_stack_special
[deliverable/binutils-gdb.git] / gdb / spu-multiarch.c
CommitLineData
85e747d2 1/* Cell SPU GNU/Linux multi-architecture debugging support.
ecd75fc8 2 Copyright (C) 2009-2014 Free Software Foundation, Inc.
85e747d2
UW
3
4 Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
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
dcf7800b 10 the Free Software Foundation; either version 3 of the License, or
85e747d2
UW
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
dcf7800b 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
85e747d2
UW
20
21#include "defs.h"
22#include "gdbcore.h"
23#include "gdbcmd.h"
0e9f083f 24#include <string.h>
85e747d2
UW
25#include "gdb_assert.h"
26#include "arch-utils.h"
27#include "observer.h"
28#include "inferior.h"
29#include "regcache.h"
30#include "symfile.h"
31#include "objfiles.h"
32#include "solib.h"
33#include "solist.h"
34
35#include "ppc-tdep.h"
36#include "ppc-linux-tdep.h"
37#include "spu-tdep.h"
38
39/* This module's target vector. */
40static struct target_ops spu_ops;
41
42/* Number of SPE objects loaded into the current inferior. */
43static int spu_nr_solib;
44
45/* Stand-alone SPE executable? */
46#define spu_standalone_p() \
47 (symfile_objfile && symfile_objfile->obfd \
48 && bfd_get_arch (symfile_objfile->obfd) == bfd_arch_spu)
49
50/* PPU side system calls. */
51#define INSTR_SC 0x44000002
52#define NR_spu_run 0x0116
53
54/* If the PPU thread is currently stopped on a spu_run system call,
55 return to FD and ADDR the file handle and NPC parameter address
56 used with the system call. Return non-zero if successful. */
57static int
58parse_spufs_run (ptid_t ptid, int *fd, CORE_ADDR *addr)
59{
f5656ead 60 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
85e747d2
UW
61 struct gdbarch_tdep *tdep;
62 struct regcache *regcache;
e362b510 63 gdb_byte buf[4];
85e747d2
UW
64 ULONGEST regval;
65
66 /* If we're not on PPU, there's nothing to detect. */
f5656ead 67 if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_powerpc)
85e747d2
UW
68 return 0;
69
70 /* Get PPU-side registers. */
f5656ead
TT
71 regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
72 tdep = gdbarch_tdep (target_gdbarch ());
85e747d2
UW
73
74 /* Fetch instruction preceding current NIP. */
75 if (target_read_memory (regcache_read_pc (regcache) - 4, buf, 4) != 0)
76 return 0;
77 /* It should be a "sc" instruction. */
78 if (extract_unsigned_integer (buf, 4, byte_order) != INSTR_SC)
79 return 0;
80 /* System call number should be NR_spu_run. */
81 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum, &regval);
82 if (regval != NR_spu_run)
83 return 0;
84
85 /* Register 3 contains fd, register 4 the NPC param pointer. */
86 regcache_cooked_read_unsigned (regcache, PPC_ORIG_R3_REGNUM, &regval);
87 *fd = (int) regval;
88 regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 4, &regval);
89 *addr = (CORE_ADDR) regval;
90 return 1;
91}
92
93/* Find gdbarch for SPU context SPUFS_FD. */
94static struct gdbarch *
95spu_gdbarch (int spufs_fd)
96{
97 struct gdbarch_info info;
98 gdbarch_info_init (&info);
99 info.bfd_arch_info = bfd_lookup_arch (bfd_arch_spu, bfd_mach_spu);
100 info.byte_order = BFD_ENDIAN_BIG;
101 info.osabi = GDB_OSABI_LINUX;
102 info.tdep_info = (void *) &spufs_fd;
103 return gdbarch_find_by_info (info);
104}
105
106/* Override the to_thread_architecture routine. */
107static struct gdbarch *
108spu_thread_architecture (struct target_ops *ops, ptid_t ptid)
109{
110 int spufs_fd;
111 CORE_ADDR spufs_addr;
112
113 if (parse_spufs_run (ptid, &spufs_fd, &spufs_addr))
114 return spu_gdbarch (spufs_fd);
115
f5656ead 116 return target_gdbarch ();
85e747d2
UW
117}
118
119/* Override the to_region_ok_for_hw_watchpoint routine. */
120static int
121spu_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
122{
123 struct target_ops *ops_beneath = find_target_beneath (&spu_ops);
124 while (ops_beneath && !ops_beneath->to_region_ok_for_hw_watchpoint)
125 ops_beneath = find_target_beneath (ops_beneath);
126
127 /* We cannot watch SPU local store. */
128 if (SPUADDR_SPU (addr) != -1)
129 return 0;
130
131 if (ops_beneath)
132 return ops_beneath->to_region_ok_for_hw_watchpoint (addr, len);
133
134 return 0;
135}
136
137/* Override the to_fetch_registers routine. */
138static void
139spu_fetch_registers (struct target_ops *ops,
140 struct regcache *regcache, int regno)
141{
142 struct gdbarch *gdbarch = get_regcache_arch (regcache);
143 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
144 struct target_ops *ops_beneath = find_target_beneath (ops);
145 int spufs_fd;
146 CORE_ADDR spufs_addr;
147
148 /* This version applies only if we're currently in spu_run. */
149 if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
150 {
151 while (ops_beneath && !ops_beneath->to_fetch_registers)
152 ops_beneath = find_target_beneath (ops_beneath);
153
154 gdb_assert (ops_beneath);
155 ops_beneath->to_fetch_registers (ops_beneath, regcache, regno);
156 return;
157 }
158
159 /* We must be stopped on a spu_run system call. */
160 if (!parse_spufs_run (inferior_ptid, &spufs_fd, &spufs_addr))
161 return;
162
163 /* The ID register holds the spufs file handle. */
164 if (regno == -1 || regno == SPU_ID_REGNUM)
165 {
e362b510 166 gdb_byte buf[4];
85e747d2
UW
167 store_unsigned_integer (buf, 4, byte_order, spufs_fd);
168 regcache_raw_supply (regcache, SPU_ID_REGNUM, buf);
169 }
170
171 /* The NPC register is found in PPC memory at SPUFS_ADDR. */
172 if (regno == -1 || regno == SPU_PC_REGNUM)
173 {
e362b510 174 gdb_byte buf[4];
85e747d2
UW
175
176 if (target_read (ops_beneath, TARGET_OBJECT_MEMORY, NULL,
177 buf, spufs_addr, sizeof buf) == sizeof buf)
178 regcache_raw_supply (regcache, SPU_PC_REGNUM, buf);
179 }
180
181 /* The GPRs are found in the "regs" spufs file. */
182 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
183 {
e362b510
PA
184 gdb_byte buf[16 * SPU_NUM_GPRS];
185 char annex[32];
85e747d2
UW
186 int i;
187
188 xsnprintf (annex, sizeof annex, "%d/regs", spufs_fd);
189 if (target_read (ops_beneath, TARGET_OBJECT_SPU, annex,
190 buf, 0, sizeof buf) == sizeof buf)
191 for (i = 0; i < SPU_NUM_GPRS; i++)
192 regcache_raw_supply (regcache, i, buf + i*16);
193 }
194}
195
196/* Override the to_store_registers routine. */
197static void
198spu_store_registers (struct target_ops *ops,
199 struct regcache *regcache, int regno)
200{
201 struct gdbarch *gdbarch = get_regcache_arch (regcache);
202 struct target_ops *ops_beneath = find_target_beneath (ops);
203 int spufs_fd;
204 CORE_ADDR spufs_addr;
205
206 /* This version applies only if we're currently in spu_run. */
207 if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
208 {
209 while (ops_beneath && !ops_beneath->to_fetch_registers)
210 ops_beneath = find_target_beneath (ops_beneath);
211
212 gdb_assert (ops_beneath);
213 ops_beneath->to_store_registers (ops_beneath, regcache, regno);
214 return;
215 }
216
217 /* We must be stopped on a spu_run system call. */
218 if (!parse_spufs_run (inferior_ptid, &spufs_fd, &spufs_addr))
219 return;
220
221 /* The NPC register is found in PPC memory at SPUFS_ADDR. */
222 if (regno == -1 || regno == SPU_PC_REGNUM)
223 {
e362b510 224 gdb_byte buf[4];
85e747d2
UW
225 regcache_raw_collect (regcache, SPU_PC_REGNUM, buf);
226
227 target_write (ops_beneath, TARGET_OBJECT_MEMORY, NULL,
228 buf, spufs_addr, sizeof buf);
229 }
230
231 /* The GPRs are found in the "regs" spufs file. */
232 if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS))
233 {
e362b510
PA
234 gdb_byte buf[16 * SPU_NUM_GPRS];
235 char annex[32];
85e747d2
UW
236 int i;
237
238 for (i = 0; i < SPU_NUM_GPRS; i++)
239 regcache_raw_collect (regcache, i, buf + i*16);
240
241 xsnprintf (annex, sizeof annex, "%d/regs", spufs_fd);
242 target_write (ops_beneath, TARGET_OBJECT_SPU, annex,
243 buf, 0, sizeof buf);
244 }
245}
246
247/* Override the to_xfer_partial routine. */
248static LONGEST
249spu_xfer_partial (struct target_ops *ops, enum target_object object,
250 const char *annex, gdb_byte *readbuf,
b55e14c7 251 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len)
85e747d2
UW
252{
253 struct target_ops *ops_beneath = find_target_beneath (ops);
254 while (ops_beneath && !ops_beneath->to_xfer_partial)
255 ops_beneath = find_target_beneath (ops_beneath);
256 gdb_assert (ops_beneath);
257
258 /* Use the "mem" spufs file to access SPU local store. */
259 if (object == TARGET_OBJECT_MEMORY)
260 {
261 int fd = SPUADDR_SPU (offset);
262 CORE_ADDR addr = SPUADDR_ADDR (offset);
d2ed6730
UW
263 char mem_annex[32], lslr_annex[32];
264 gdb_byte buf[32];
265 ULONGEST lslr;
266 LONGEST ret;
85e747d2 267
d2ed6730 268 if (fd >= 0)
85e747d2
UW
269 {
270 xsnprintf (mem_annex, sizeof mem_annex, "%d/mem", fd);
d2ed6730
UW
271 ret = ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
272 mem_annex, readbuf, writebuf,
273 addr, len);
274 if (ret > 0)
275 return ret;
276
277 /* SPU local store access wraps the address around at the
278 local store limit. We emulate this here. To avoid needing
279 an extra access to retrieve the LSLR, we only do that after
280 trying the original address first, and getting end-of-file. */
281 xsnprintf (lslr_annex, sizeof lslr_annex, "%d/lslr", fd);
282 memset (buf, 0, sizeof buf);
283 if (ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
284 lslr_annex, buf, NULL,
285 0, sizeof buf) <= 0)
286 return ret;
287
001f13d8 288 lslr = strtoulst ((char *) buf, NULL, 16);
85e747d2
UW
289 return ops_beneath->to_xfer_partial (ops_beneath, TARGET_OBJECT_SPU,
290 mem_annex, readbuf, writebuf,
d2ed6730 291 addr & lslr, len);
85e747d2
UW
292 }
293 }
294
295 return ops_beneath->to_xfer_partial (ops_beneath, object, annex,
296 readbuf, writebuf, offset, len);
297}
298
299/* Override the to_search_memory routine. */
300static int
301spu_search_memory (struct target_ops* ops,
302 CORE_ADDR start_addr, ULONGEST search_space_len,
303 const gdb_byte *pattern, ULONGEST pattern_len,
304 CORE_ADDR *found_addrp)
305{
306 struct target_ops *ops_beneath = find_target_beneath (ops);
307 while (ops_beneath && !ops_beneath->to_search_memory)
308 ops_beneath = find_target_beneath (ops_beneath);
309
310 /* For SPU local store, always fall back to the simple method. Likewise
311 if we do not have any target-specific special implementation. */
312 if (!ops_beneath || SPUADDR_SPU (start_addr) >= 0)
313 return simple_search_memory (ops,
314 start_addr, search_space_len,
315 pattern, pattern_len, found_addrp);
316
317 return ops_beneath->to_search_memory (ops_beneath,
318 start_addr, search_space_len,
319 pattern, pattern_len, found_addrp);
320}
321
322
323/* Push and pop the SPU multi-architecture support target. */
324
325static void
326spu_multiarch_activate (void)
327{
328 /* If GDB was configured without SPU architecture support,
329 we cannot install SPU multi-architecture support either. */
330 if (spu_gdbarch (-1) == NULL)
331 return;
332
333 push_target (&spu_ops);
334
335 /* Make sure the thread architecture is re-evaluated. */
336 registers_changed ();
337}
338
339static void
340spu_multiarch_deactivate (void)
341{
342 unpush_target (&spu_ops);
343
344 /* Make sure the thread architecture is re-evaluated. */
345 registers_changed ();
346}
347
348static void
349spu_multiarch_inferior_created (struct target_ops *ops, int from_tty)
350{
351 if (spu_standalone_p ())
352 spu_multiarch_activate ();
353}
354
355static void
356spu_multiarch_solib_loaded (struct so_list *so)
357{
358 if (!spu_standalone_p ())
359 if (so->abfd && bfd_get_arch (so->abfd) == bfd_arch_spu)
360 if (spu_nr_solib++ == 0)
361 spu_multiarch_activate ();
362}
363
364static void
365spu_multiarch_solib_unloaded (struct so_list *so)
366{
367 if (!spu_standalone_p ())
368 if (so->abfd && bfd_get_arch (so->abfd) == bfd_arch_spu)
369 if (--spu_nr_solib == 0)
370 spu_multiarch_deactivate ();
371}
372
373static void
374spu_mourn_inferior (struct target_ops *ops)
375{
376 struct target_ops *ops_beneath = find_target_beneath (ops);
377 while (ops_beneath && !ops_beneath->to_mourn_inferior)
378 ops_beneath = find_target_beneath (ops_beneath);
379
380 gdb_assert (ops_beneath);
381 ops_beneath->to_mourn_inferior (ops_beneath);
382 spu_multiarch_deactivate ();
383}
384
385
386/* Initialize the SPU multi-architecture support target. */
387
388static void
389init_spu_ops (void)
390{
391 spu_ops.to_shortname = "spu";
392 spu_ops.to_longname = "SPU multi-architecture support.";
393 spu_ops.to_doc = "SPU multi-architecture support.";
394 spu_ops.to_mourn_inferior = spu_mourn_inferior;
395 spu_ops.to_fetch_registers = spu_fetch_registers;
396 spu_ops.to_store_registers = spu_store_registers;
397 spu_ops.to_xfer_partial = spu_xfer_partial;
398 spu_ops.to_search_memory = spu_search_memory;
399 spu_ops.to_region_ok_for_hw_watchpoint = spu_region_ok_for_hw_watchpoint;
400 spu_ops.to_thread_architecture = spu_thread_architecture;
401 spu_ops.to_stratum = arch_stratum;
402 spu_ops.to_magic = OPS_MAGIC;
403}
404
693be288
JK
405/* -Wmissing-prototypes */
406extern initialize_file_ftype _initialize_spu_multiarch;
407
85e747d2
UW
408void
409_initialize_spu_multiarch (void)
410{
411 /* Install ourselves on the target stack. */
412 init_spu_ops ();
12070676 413 complete_target_initialization (&spu_ops);
85e747d2
UW
414
415 /* Install observers to watch for SPU objects. */
416 observer_attach_inferior_created (spu_multiarch_inferior_created);
417 observer_attach_solib_loaded (spu_multiarch_solib_loaded);
418 observer_attach_solib_unloaded (spu_multiarch_solib_unloaded);
419}
420
This page took 0.506198 seconds and 4 git commands to generate.