GDB (xrefs)
/tmp/gdb-7.10/gdb/spu-tdep.c
Go to the documentation of this file.
1 /* SPU target-dependent code for GDB, the GNU debugger.
2  Copyright (C) 2006-2015 Free Software Foundation, Inc.
3 
4  Contributed by Ulrich Weigand <uweigand@de.ibm.com>.
5  Based on a port by Sid Manning <sid@us.ibm.com>.
6 
7  This file is part of GDB.
8 
9  This program is free software; you can redistribute it and/or modify
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation; either version 3 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include "gdbtypes.h"
25 #include "gdbcmd.h"
26 #include "gdbcore.h"
27 #include "frame.h"
28 #include "frame-unwind.h"
29 #include "frame-base.h"
30 #include "trad-frame.h"
31 #include "symtab.h"
32 #include "symfile.h"
33 #include "value.h"
34 #include "inferior.h"
35 #include "dis-asm.h"
36 #include "objfiles.h"
37 #include "language.h"
38 #include "regcache.h"
39 #include "reggroups.h"
40 #include "floatformat.h"
41 #include "block.h"
42 #include "observer.h"
43 #include "infcall.h"
44 #include "dwarf2.h"
45 #include "dwarf2-frame.h"
46 #include "ax.h"
47 #include "spu-tdep.h"
48 
49 
50 /* The list of available "set spu " and "show spu " commands. */
51 static struct cmd_list_element *setspucmdlist = NULL;
52 static struct cmd_list_element *showspucmdlist = NULL;
53 
54 /* Whether to stop for new SPE contexts. */
55 static int spu_stop_on_load_p = 0;
56 /* Whether to automatically flush the SW-managed cache. */
57 static int spu_auto_flush_cache_p = 1;
58 
59 
60 /* The tdep structure. */
61 struct gdbarch_tdep
62 {
63  /* The spufs ID identifying our address space. */
64  int id;
65 
66  /* SPU-specific vector type. */
68 };
69 
70 
71 /* SPU-specific vector type. */
72 static struct type *
73 spu_builtin_type_vec128 (struct gdbarch *gdbarch)
74 {
75  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
76 
77  if (!tdep->spu_builtin_type_vec128)
78  {
79  const struct builtin_type *bt = builtin_type (gdbarch);
80  struct type *t;
81 
82  t = arch_composite_type (gdbarch,
83  "__spu_builtin_type_vec128", TYPE_CODE_UNION);
84  append_composite_type_field (t, "uint128", bt->builtin_int128);
85  append_composite_type_field (t, "v2_int64",
87  append_composite_type_field (t, "v4_int32",
89  append_composite_type_field (t, "v8_int16",
91  append_composite_type_field (t, "v16_int8",
92  init_vector_type (bt->builtin_int8, 16));
93  append_composite_type_field (t, "v2_double",
95  append_composite_type_field (t, "v4_float",
97 
98  TYPE_VECTOR (t) = 1;
99  TYPE_NAME (t) = "spu_builtin_type_vec128";
100 
101  tdep->spu_builtin_type_vec128 = t;
102  }
103 
104  return tdep->spu_builtin_type_vec128;
105 }
106 
107 
108 /* The list of available "info spu " commands. */
109 static struct cmd_list_element *infospucmdlist = NULL;
110 
111 /* Registers. */
112 
113 static const char *
114 spu_register_name (struct gdbarch *gdbarch, int reg_nr)
115 {
116  static char *register_names[] =
117  {
118  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
119  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
120  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
121  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
122  "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
123  "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
124  "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
125  "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
126  "r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
127  "r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
128  "r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
129  "r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
130  "r96", "r97", "r98", "r99", "r100", "r101", "r102", "r103",
131  "r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
132  "r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
133  "r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
134  "id", "pc", "sp", "fpscr", "srr0", "lslr", "decr", "decr_status"
135  };
136 
137  if (reg_nr < 0)
138  return NULL;
139  if (reg_nr >= sizeof register_names / sizeof *register_names)
140  return NULL;
141 
142  return register_names[reg_nr];
143 }
144 
145 static struct type *
146 spu_register_type (struct gdbarch *gdbarch, int reg_nr)
147 {
148  if (reg_nr < SPU_NUM_GPRS)
149  return spu_builtin_type_vec128 (gdbarch);
150 
151  switch (reg_nr)
152  {
153  case SPU_ID_REGNUM:
154  return builtin_type (gdbarch)->builtin_uint32;
155 
156  case SPU_PC_REGNUM:
157  return builtin_type (gdbarch)->builtin_func_ptr;
158 
159  case SPU_SP_REGNUM:
160  return builtin_type (gdbarch)->builtin_data_ptr;
161 
162  case SPU_FPSCR_REGNUM:
163  return builtin_type (gdbarch)->builtin_uint128;
164 
165  case SPU_SRR0_REGNUM:
166  return builtin_type (gdbarch)->builtin_uint32;
167 
168  case SPU_LSLR_REGNUM:
169  return builtin_type (gdbarch)->builtin_uint32;
170 
171  case SPU_DECR_REGNUM:
172  return builtin_type (gdbarch)->builtin_uint32;
173 
175  return builtin_type (gdbarch)->builtin_uint32;
176 
177  default:
178  internal_error (__FILE__, __LINE__, _("invalid regnum"));
179  }
180 }
181 
182 /* Pseudo registers for preferred slots - stack pointer. */
183 
184 static enum register_status
185 spu_pseudo_register_read_spu (struct regcache *regcache, const char *regname,
186  gdb_byte *buf)
187 {
188  struct gdbarch *gdbarch = get_regcache_arch (regcache);
189  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
190  enum register_status status;
191  gdb_byte reg[32];
192  char annex[32];
193  ULONGEST id;
194  ULONGEST ul;
195 
196  status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id);
197  if (status != REG_VALID)
198  return status;
199  xsnprintf (annex, sizeof annex, "%d/%s", (int) id, regname);
200  memset (reg, 0, sizeof reg);
202  reg, 0, sizeof reg);
203 
204  ul = strtoulst ((char *) reg, NULL, 16);
205  store_unsigned_integer (buf, 4, byte_order, ul);
206  return REG_VALID;
207 }
208 
209 static enum register_status
210 spu_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
211  int regnum, gdb_byte *buf)
212 {
213  gdb_byte reg[16];
214  char annex[32];
215  ULONGEST id;
216  enum register_status status;
217 
218  switch (regnum)
219  {
220  case SPU_SP_REGNUM:
221  status = regcache_raw_read (regcache, SPU_RAW_SP_REGNUM, reg);
222  if (status != REG_VALID)
223  return status;
224  memcpy (buf, reg, 4);
225  return status;
226 
227  case SPU_FPSCR_REGNUM:
228  status = regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id);
229  if (status != REG_VALID)
230  return status;
231  xsnprintf (annex, sizeof annex, "%d/fpcr", (int) id);
232  target_read (&current_target, TARGET_OBJECT_SPU, annex, buf, 0, 16);
233  return status;
234 
235  case SPU_SRR0_REGNUM:
236  return spu_pseudo_register_read_spu (regcache, "srr0", buf);
237 
238  case SPU_LSLR_REGNUM:
239  return spu_pseudo_register_read_spu (regcache, "lslr", buf);
240 
241  case SPU_DECR_REGNUM:
242  return spu_pseudo_register_read_spu (regcache, "decr", buf);
243 
245  return spu_pseudo_register_read_spu (regcache, "decr_status", buf);
246 
247  default:
248  internal_error (__FILE__, __LINE__, _("invalid regnum"));
249  }
250 }
251 
252 static void
253 spu_pseudo_register_write_spu (struct regcache *regcache, const char *regname,
254  const gdb_byte *buf)
255 {
256  struct gdbarch *gdbarch = get_regcache_arch (regcache);
257  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
258  char reg[32];
259  char annex[32];
260  ULONGEST id;
261 
262  regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id);
263  xsnprintf (annex, sizeof annex, "%d/%s", (int) id, regname);
264  xsnprintf (reg, sizeof reg, "0x%s",
265  phex_nz (extract_unsigned_integer (buf, 4, byte_order), 4));
267  (gdb_byte *) reg, 0, strlen (reg));
268 }
269 
270 static void
271 spu_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
272  int regnum, const gdb_byte *buf)
273 {
274  gdb_byte reg[16];
275  char annex[32];
276  ULONGEST id;
277 
278  switch (regnum)
279  {
280  case SPU_SP_REGNUM:
281  regcache_raw_read (regcache, SPU_RAW_SP_REGNUM, reg);
282  memcpy (reg, buf, 4);
283  regcache_raw_write (regcache, SPU_RAW_SP_REGNUM, reg);
284  break;
285 
286  case SPU_FPSCR_REGNUM:
287  regcache_raw_read_unsigned (regcache, SPU_ID_REGNUM, &id);
288  xsnprintf (annex, sizeof annex, "%d/fpcr", (int) id);
289  target_write (&current_target, TARGET_OBJECT_SPU, annex, buf, 0, 16);
290  break;
291 
292  case SPU_SRR0_REGNUM:
293  spu_pseudo_register_write_spu (regcache, "srr0", buf);
294  break;
295 
296  case SPU_LSLR_REGNUM:
297  spu_pseudo_register_write_spu (regcache, "lslr", buf);
298  break;
299 
300  case SPU_DECR_REGNUM:
301  spu_pseudo_register_write_spu (regcache, "decr", buf);
302  break;
303 
305  spu_pseudo_register_write_spu (regcache, "decr_status", buf);
306  break;
307 
308  default:
309  internal_error (__FILE__, __LINE__, _("invalid regnum"));
310  }
311 }
312 
313 static int
314 spu_ax_pseudo_register_collect (struct gdbarch *gdbarch,
315  struct agent_expr *ax, int regnum)
316 {
317  switch (regnum)
318  {
319  case SPU_SP_REGNUM:
321  return 0;
322 
323  case SPU_FPSCR_REGNUM:
324  case SPU_SRR0_REGNUM:
325  case SPU_LSLR_REGNUM:
326  case SPU_DECR_REGNUM:
328  return -1;
329 
330  default:
331  internal_error (__FILE__, __LINE__, _("invalid regnum"));
332  }
333 }
334 
335 static int
336 spu_ax_pseudo_register_push_stack (struct gdbarch *gdbarch,
337  struct agent_expr *ax, int regnum)
338 {
339  switch (regnum)
340  {
341  case SPU_SP_REGNUM:
343  return 0;
344 
345  case SPU_FPSCR_REGNUM:
346  case SPU_SRR0_REGNUM:
347  case SPU_LSLR_REGNUM:
348  case SPU_DECR_REGNUM:
350  return -1;
351 
352  default:
353  internal_error (__FILE__, __LINE__, _("invalid regnum"));
354  }
355 }
356 
357 
358 /* Value conversion -- access scalar values at the preferred slot. */
359 
360 static struct value *
361 spu_value_from_register (struct gdbarch *gdbarch, struct type *type,
362  int regnum, struct frame_id frame_id)
363 {
364  struct value *value = default_value_from_register (gdbarch, type,
365  regnum, frame_id);
366  int len = TYPE_LENGTH (type);
367 
368  if (regnum < SPU_NUM_GPRS && len < 16)
369  {
370  int preferred_slot = len < 4 ? 4 - len : 0;
371  set_value_offset (value, preferred_slot);
372  }
373 
374  return value;
375 }
376 
377 /* Register groups. */
378 
379 static int
380 spu_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
381  struct reggroup *group)
382 {
383  /* Registers displayed via 'info regs'. */
384  if (group == general_reggroup)
385  return 1;
386 
387  /* Registers displayed via 'info float'. */
388  if (group == float_reggroup)
389  return 0;
390 
391  /* Registers that need to be saved/restored in order to
392  push or pop frames. */
393  if (group == save_reggroup || group == restore_reggroup)
394  return 1;
395 
396  return default_register_reggroup_p (gdbarch, regnum, group);
397 }
398 
399 /* DWARF-2 register numbers. */
400 
401 static int
402 spu_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
403 {
404  /* Use cooked instead of raw SP. */
405  return (reg == SPU_RAW_SP_REGNUM)? SPU_SP_REGNUM : reg;
406 }
407 
408 
409 /* Address handling. */
410 
411 static int
412 spu_gdbarch_id (struct gdbarch *gdbarch)
413 {
414  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
415  int id = tdep->id;
416 
417  /* The objfile architecture of a standalone SPU executable does not
418  provide an SPU ID. Retrieve it from the objfile's relocated
419  address range in this special case. */
420  if (id == -1
421  && symfile_objfile && symfile_objfile->obfd
422  && bfd_get_arch (symfile_objfile->obfd) == bfd_arch_spu
423  && symfile_objfile->sections != symfile_objfile->sections_end)
424  id = SPUADDR_SPU (obj_section_addr (symfile_objfile->sections));
425 
426  return id;
427 }
428 
429 static int
430 spu_address_class_type_flags (int byte_size, int dwarf2_addr_class)
431 {
432  if (dwarf2_addr_class == 1)
434  else
435  return 0;
436 }
437 
438 static const char *
439 spu_address_class_type_flags_to_name (struct gdbarch *gdbarch, int type_flags)
440 {
441  if (type_flags & TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1)
442  return "__ea";
443  else
444  return NULL;
445 }
446 
447 static int
448 spu_address_class_name_to_type_flags (struct gdbarch *gdbarch,
449  const char *name, int *type_flags_ptr)
450 {
451  if (strcmp (name, "__ea") == 0)
452  {
453  *type_flags_ptr = TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1;
454  return 1;
455  }
456  else
457  return 0;
458 }
459 
460 static void
461 spu_address_to_pointer (struct gdbarch *gdbarch,
462  struct type *type, gdb_byte *buf, CORE_ADDR addr)
463 {
464  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
465  store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
466  SPUADDR_ADDR (addr));
467 }
468 
469 static CORE_ADDR
470 spu_pointer_to_address (struct gdbarch *gdbarch,
471  struct type *type, const gdb_byte *buf)
472 {
473  int id = spu_gdbarch_id (gdbarch);
474  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
475  ULONGEST addr
476  = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
477 
478  /* Do not convert __ea pointers. */
479  if (TYPE_ADDRESS_CLASS_1 (type))
480  return addr;
481 
482  return addr? SPUADDR (id, addr) : 0;
483 }
484 
485 static CORE_ADDR
486 spu_integer_to_address (struct gdbarch *gdbarch,
487  struct type *type, const gdb_byte *buf)
488 {
489  int id = spu_gdbarch_id (gdbarch);
490  ULONGEST addr = unpack_long (type, buf);
491 
492  return SPUADDR (id, addr);
493 }
494 
495 
496 /* Decoding SPU instructions. */
497 
498 enum
499  {
500  op_lqd = 0x34,
501  op_lqx = 0x3c4,
502  op_lqa = 0x61,
503  op_lqr = 0x67,
504  op_stqd = 0x24,
505  op_stqx = 0x144,
506  op_stqa = 0x41,
507  op_stqr = 0x47,
508 
509  op_il = 0x081,
510  op_ila = 0x21,
511  op_a = 0x0c0,
512  op_ai = 0x1c,
513 
514  op_selb = 0x8,
515 
516  op_br = 0x64,
517  op_bra = 0x60,
518  op_brsl = 0x66,
519  op_brasl = 0x62,
520  op_brnz = 0x42,
521  op_brz = 0x40,
522  op_brhnz = 0x46,
523  op_brhz = 0x44,
524  op_bi = 0x1a8,
525  op_bisl = 0x1a9,
526  op_biz = 0x128,
527  op_binz = 0x129,
528  op_bihz = 0x12a,
529  op_bihnz = 0x12b,
530  };
531 
532 static int
533 is_rr (unsigned int insn, int op, int *rt, int *ra, int *rb)
534 {
535  if ((insn >> 21) == op)
536  {
537  *rt = insn & 127;
538  *ra = (insn >> 7) & 127;
539  *rb = (insn >> 14) & 127;
540  return 1;
541  }
542 
543  return 0;
544 }
545 
546 static int
547 is_rrr (unsigned int insn, int op, int *rt, int *ra, int *rb, int *rc)
548 {
549  if ((insn >> 28) == op)
550  {
551  *rt = (insn >> 21) & 127;
552  *ra = (insn >> 7) & 127;
553  *rb = (insn >> 14) & 127;
554  *rc = insn & 127;
555  return 1;
556  }
557 
558  return 0;
559 }
560 
561 static int
562 is_ri7 (unsigned int insn, int op, int *rt, int *ra, int *i7)
563 {
564  if ((insn >> 21) == op)
565  {
566  *rt = insn & 127;
567  *ra = (insn >> 7) & 127;
568  *i7 = (((insn >> 14) & 127) ^ 0x40) - 0x40;
569  return 1;
570  }
571 
572  return 0;
573 }
574 
575 static int
576 is_ri10 (unsigned int insn, int op, int *rt, int *ra, int *i10)
577 {
578  if ((insn >> 24) == op)
579  {
580  *rt = insn & 127;
581  *ra = (insn >> 7) & 127;
582  *i10 = (((insn >> 14) & 0x3ff) ^ 0x200) - 0x200;
583  return 1;
584  }
585 
586  return 0;
587 }
588 
589 static int
590 is_ri16 (unsigned int insn, int op, int *rt, int *i16)
591 {
592  if ((insn >> 23) == op)
593  {
594  *rt = insn & 127;
595  *i16 = (((insn >> 7) & 0xffff) ^ 0x8000) - 0x8000;
596  return 1;
597  }
598 
599  return 0;
600 }
601 
602 static int
603 is_ri18 (unsigned int insn, int op, int *rt, int *i18)
604 {
605  if ((insn >> 25) == op)
606  {
607  *rt = insn & 127;
608  *i18 = (((insn >> 7) & 0x3ffff) ^ 0x20000) - 0x20000;
609  return 1;
610  }
611 
612  return 0;
613 }
614 
615 static int
616 is_branch (unsigned int insn, int *offset, int *reg)
617 {
618  int rt, i7, i16;
619 
620  if (is_ri16 (insn, op_br, &rt, &i16)
621  || is_ri16 (insn, op_brsl, &rt, &i16)
622  || is_ri16 (insn, op_brnz, &rt, &i16)
623  || is_ri16 (insn, op_brz, &rt, &i16)
624  || is_ri16 (insn, op_brhnz, &rt, &i16)
625  || is_ri16 (insn, op_brhz, &rt, &i16))
626  {
627  *reg = SPU_PC_REGNUM;
628  *offset = i16 << 2;
629  return 1;
630  }
631 
632  if (is_ri16 (insn, op_bra, &rt, &i16)
633  || is_ri16 (insn, op_brasl, &rt, &i16))
634  {
635  *reg = -1;
636  *offset = i16 << 2;
637  return 1;
638  }
639 
640  if (is_ri7 (insn, op_bi, &rt, reg, &i7)
641  || is_ri7 (insn, op_bisl, &rt, reg, &i7)
642  || is_ri7 (insn, op_biz, &rt, reg, &i7)
643  || is_ri7 (insn, op_binz, &rt, reg, &i7)
644  || is_ri7 (insn, op_bihz, &rt, reg, &i7)
645  || is_ri7 (insn, op_bihnz, &rt, reg, &i7))
646  {
647  *offset = 0;
648  return 1;
649  }
650 
651  return 0;
652 }
653 
654 
655 /* Prolog parsing. */
656 
658  {
659  /* Stack frame size. -1 if analysis was unsuccessful. */
660  int size;
661 
662  /* How to find the CFA. The CFA is equal to SP at function entry. */
663  int cfa_reg;
665 
666  /* Offset relative to CFA where a register is saved. -1 if invalid. */
668  };
669 
670 static CORE_ADDR
671 spu_analyze_prologue (struct gdbarch *gdbarch,
672  CORE_ADDR start_pc, CORE_ADDR end_pc,
673  struct spu_prologue_data *data)
674 {
675  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
676  int found_sp = 0;
677  int found_fp = 0;
678  int found_lr = 0;
679  int found_bc = 0;
680  int reg_immed[SPU_NUM_GPRS];
681  gdb_byte buf[16];
682  CORE_ADDR prolog_pc = start_pc;
683  CORE_ADDR pc;
684  int i;
685 
686 
687  /* Initialize DATA to default values. */
688  data->size = -1;
689 
690  data->cfa_reg = SPU_RAW_SP_REGNUM;
691  data->cfa_offset = 0;
692 
693  for (i = 0; i < SPU_NUM_GPRS; i++)
694  data->reg_offset[i] = -1;
695 
696  /* Set up REG_IMMED array. This is non-zero for a register if we know its
697  preferred slot currently holds this immediate value. */
698  for (i = 0; i < SPU_NUM_GPRS; i++)
699  reg_immed[i] = 0;
700 
701  /* Scan instructions until the first branch.
702 
703  The following instructions are important prolog components:
704 
705  - The first instruction to set up the stack pointer.
706  - The first instruction to set up the frame pointer.
707  - The first instruction to save the link register.
708  - The first instruction to save the backchain.
709 
710  We return the instruction after the latest of these four,
711  or the incoming PC if none is found. The first instruction
712  to set up the stack pointer also defines the frame size.
713 
714  Note that instructions saving incoming arguments to their stack
715  slots are not counted as important, because they are hard to
716  identify with certainty. This should not matter much, because
717  arguments are relevant only in code compiled with debug data,
718  and in such code the GDB core will advance until the first source
719  line anyway, using SAL data.
720 
721  For purposes of stack unwinding, we analyze the following types
722  of instructions in addition:
723 
724  - Any instruction adding to the current frame pointer.
725  - Any instruction loading an immediate constant into a register.
726  - Any instruction storing a register onto the stack.
727 
728  These are used to compute the CFA and REG_OFFSET output. */
729 
730  for (pc = start_pc; pc < end_pc; pc += 4)
731  {
732  unsigned int insn;
733  int rt, ra, rb, rc, immed;
734 
735  if (target_read_memory (pc, buf, 4))
736  break;
737  insn = extract_unsigned_integer (buf, 4, byte_order);
738 
739  /* AI is the typical instruction to set up a stack frame.
740  It is also used to initialize the frame pointer. */
741  if (is_ri10 (insn, op_ai, &rt, &ra, &immed))
742  {
743  if (rt == data->cfa_reg && ra == data->cfa_reg)
744  data->cfa_offset -= immed;
745 
746  if (rt == SPU_RAW_SP_REGNUM && ra == SPU_RAW_SP_REGNUM
747  && !found_sp)
748  {
749  found_sp = 1;
750  prolog_pc = pc + 4;
751 
752  data->size = -immed;
753  }
754  else if (rt == SPU_FP_REGNUM && ra == SPU_RAW_SP_REGNUM
755  && !found_fp)
756  {
757  found_fp = 1;
758  prolog_pc = pc + 4;
759 
760  data->cfa_reg = SPU_FP_REGNUM;
761  data->cfa_offset -= immed;
762  }
763  }
764 
765  /* A is used to set up stack frames of size >= 512 bytes.
766  If we have tracked the contents of the addend register,
767  we can handle this as well. */
768  else if (is_rr (insn, op_a, &rt, &ra, &rb))
769  {
770  if (rt == data->cfa_reg && ra == data->cfa_reg)
771  {
772  if (reg_immed[rb] != 0)
773  data->cfa_offset -= reg_immed[rb];
774  else
775  data->cfa_reg = -1; /* We don't know the CFA any more. */
776  }
777 
778  if (rt == SPU_RAW_SP_REGNUM && ra == SPU_RAW_SP_REGNUM
779  && !found_sp)
780  {
781  found_sp = 1;
782  prolog_pc = pc + 4;
783 
784  if (reg_immed[rb] != 0)
785  data->size = -reg_immed[rb];
786  }
787  }
788 
789  /* We need to track IL and ILA used to load immediate constants
790  in case they are later used as input to an A instruction. */
791  else if (is_ri16 (insn, op_il, &rt, &immed))
792  {
793  reg_immed[rt] = immed;
794 
795  if (rt == SPU_RAW_SP_REGNUM && !found_sp)
796  found_sp = 1;
797  }
798 
799  else if (is_ri18 (insn, op_ila, &rt, &immed))
800  {
801  reg_immed[rt] = immed & 0x3ffff;
802 
803  if (rt == SPU_RAW_SP_REGNUM && !found_sp)
804  found_sp = 1;
805  }
806 
807  /* STQD is used to save registers to the stack. */
808  else if (is_ri10 (insn, op_stqd, &rt, &ra, &immed))
809  {
810  if (ra == data->cfa_reg)
811  data->reg_offset[rt] = data->cfa_offset - (immed << 4);
812 
813  if (ra == data->cfa_reg && rt == SPU_LR_REGNUM
814  && !found_lr)
815  {
816  found_lr = 1;
817  prolog_pc = pc + 4;
818  }
819 
820  if (ra == SPU_RAW_SP_REGNUM
821  && (found_sp? immed == 0 : rt == SPU_RAW_SP_REGNUM)
822  && !found_bc)
823  {
824  found_bc = 1;
825  prolog_pc = pc + 4;
826  }
827  }
828 
829  /* _start uses SELB to set up the stack pointer. */
830  else if (is_rrr (insn, op_selb, &rt, &ra, &rb, &rc))
831  {
832  if (rt == SPU_RAW_SP_REGNUM && !found_sp)
833  found_sp = 1;
834  }
835 
836  /* We terminate if we find a branch. */
837  else if (is_branch (insn, &immed, &ra))
838  break;
839  }
840 
841 
842  /* If we successfully parsed until here, and didn't find any instruction
843  modifying SP, we assume we have a frameless function. */
844  if (!found_sp)
845  data->size = 0;
846 
847  /* Return cooked instead of raw SP. */
848  if (data->cfa_reg == SPU_RAW_SP_REGNUM)
849  data->cfa_reg = SPU_SP_REGNUM;
850 
851  return prolog_pc;
852 }
853 
854 /* Return the first instruction after the prologue starting at PC. */
855 static CORE_ADDR
856 spu_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
857 {
858  struct spu_prologue_data data;
859  return spu_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
860 }
861 
862 /* Return the frame pointer in use at address PC. */
863 static void
864 spu_virtual_frame_pointer (struct gdbarch *gdbarch, CORE_ADDR pc,
865  int *reg, LONGEST *offset)
866 {
867  struct spu_prologue_data data;
868  spu_analyze_prologue (gdbarch, pc, (CORE_ADDR)-1, &data);
869 
870  if (data.size != -1 && data.cfa_reg != -1)
871  {
872  /* The 'frame pointer' address is CFA minus frame size. */
873  *reg = data.cfa_reg;
874  *offset = data.cfa_offset - data.size;
875  }
876  else
877  {
878  /* ??? We don't really know ... */
879  *reg = SPU_SP_REGNUM;
880  *offset = 0;
881  }
882 }
883 
884 /* Implement the stack_frame_destroyed_p gdbarch method.
885 
886  1) scan forward from the point of execution:
887  a) If you find an instruction that modifies the stack pointer
888  or transfers control (except a return), execution is not in
889  an epilogue, return.
890  b) Stop scanning if you find a return instruction or reach the
891  end of the function or reach the hard limit for the size of
892  an epilogue.
893  2) scan backward from the point of execution:
894  a) If you find an instruction that modifies the stack pointer,
895  execution *is* in an epilogue, return.
896  b) Stop scanning if you reach an instruction that transfers
897  control or the beginning of the function or reach the hard
898  limit for the size of an epilogue. */
899 
900 static int
901 spu_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
902 {
903  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
904  CORE_ADDR scan_pc, func_start, func_end, epilogue_start, epilogue_end;
905  bfd_byte buf[4];
906  unsigned int insn;
907  int rt, ra, rb, immed;
908 
909  /* Find the search limits based on function boundaries and hard limit.
910  We assume the epilogue can be up to 64 instructions long. */
911 
912  const int spu_max_epilogue_size = 64 * 4;
913 
914  if (!find_pc_partial_function (pc, NULL, &func_start, &func_end))
915  return 0;
916 
917  if (pc - func_start < spu_max_epilogue_size)
918  epilogue_start = func_start;
919  else
920  epilogue_start = pc - spu_max_epilogue_size;
921 
922  if (func_end - pc < spu_max_epilogue_size)
923  epilogue_end = func_end;
924  else
925  epilogue_end = pc + spu_max_epilogue_size;
926 
927  /* Scan forward until next 'bi $0'. */
928 
929  for (scan_pc = pc; scan_pc < epilogue_end; scan_pc += 4)
930  {
931  if (target_read_memory (scan_pc, buf, 4))
932  return 0;
933  insn = extract_unsigned_integer (buf, 4, byte_order);
934 
935  if (is_branch (insn, &immed, &ra))
936  {
937  if (immed == 0 && ra == SPU_LR_REGNUM)
938  break;
939 
940  return 0;
941  }
942 
943  if (is_ri10 (insn, op_ai, &rt, &ra, &immed)
944  || is_rr (insn, op_a, &rt, &ra, &rb)
945  || is_ri10 (insn, op_lqd, &rt, &ra, &immed))
946  {
947  if (rt == SPU_RAW_SP_REGNUM)
948  return 0;
949  }
950  }
951 
952  if (scan_pc >= epilogue_end)
953  return 0;
954 
955  /* Scan backward until adjustment to stack pointer (R1). */
956 
957  for (scan_pc = pc - 4; scan_pc >= epilogue_start; scan_pc -= 4)
958  {
959  if (target_read_memory (scan_pc, buf, 4))
960  return 0;
961  insn = extract_unsigned_integer (buf, 4, byte_order);
962 
963  if (is_branch (insn, &immed, &ra))
964  return 0;
965 
966  if (is_ri10 (insn, op_ai, &rt, &ra, &immed)
967  || is_rr (insn, op_a, &rt, &ra, &rb)
968  || is_ri10 (insn, op_lqd, &rt, &ra, &immed))
969  {
970  if (rt == SPU_RAW_SP_REGNUM)
971  return 1;
972  }
973  }
974 
975  return 0;
976 }
977 
978 
979 /* Normal stack frames. */
980 
982 {
986 
988 };
989 
990 static struct spu_unwind_cache *
991 spu_frame_unwind_cache (struct frame_info *this_frame,
992  void **this_prologue_cache)
993 {
994  struct gdbarch *gdbarch = get_frame_arch (this_frame);
995  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
996  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
997  struct spu_unwind_cache *info;
998  struct spu_prologue_data data;
999  CORE_ADDR id = tdep->id;
1000  gdb_byte buf[16];
1001 
1002  if (*this_prologue_cache)
1003  return *this_prologue_cache;
1004 
1005  info = FRAME_OBSTACK_ZALLOC (struct spu_unwind_cache);
1006  *this_prologue_cache = info;
1007  info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1008  info->frame_base = 0;
1009  info->local_base = 0;
1010 
1011  /* Find the start of the current function, and analyze its prologue. */
1012  info->func = get_frame_func (this_frame);
1013  if (info->func == 0)
1014  {
1015  /* Fall back to using the current PC as frame ID. */
1016  info->func = get_frame_pc (this_frame);
1017  data.size = -1;
1018  }
1019  else
1020  spu_analyze_prologue (gdbarch, info->func, get_frame_pc (this_frame),
1021  &data);
1022 
1023  /* If successful, use prologue analysis data. */
1024  if (data.size != -1 && data.cfa_reg != -1)
1025  {
1026  CORE_ADDR cfa;
1027  int i;
1028 
1029  /* Determine CFA via unwound CFA_REG plus CFA_OFFSET. */
1030  get_frame_register (this_frame, data.cfa_reg, buf);
1031  cfa = extract_unsigned_integer (buf, 4, byte_order) + data.cfa_offset;
1032  cfa = SPUADDR (id, cfa);
1033 
1034  /* Call-saved register slots. */
1035  for (i = 0; i < SPU_NUM_GPRS; i++)
1036  if (i == SPU_LR_REGNUM
1037  || (i >= SPU_SAVED1_REGNUM && i <= SPU_SAVEDN_REGNUM))
1038  if (data.reg_offset[i] != -1)
1039  info->saved_regs[i].addr = cfa - data.reg_offset[i];
1040 
1041  /* Frame bases. */
1042  info->frame_base = cfa;
1043  info->local_base = cfa - data.size;
1044  }
1045 
1046  /* Otherwise, fall back to reading the backchain link. */
1047  else
1048  {
1049  CORE_ADDR reg;
1050  LONGEST backchain;
1051  ULONGEST lslr;
1052  int status;
1053 
1054  /* Get local store limit. */
1055  lslr = get_frame_register_unsigned (this_frame, SPU_LSLR_REGNUM);
1056  if (!lslr)
1057  lslr = (ULONGEST) -1;
1058 
1059  /* Get the backchain. */
1060  reg = get_frame_register_unsigned (this_frame, SPU_SP_REGNUM);
1061  status = safe_read_memory_integer (SPUADDR (id, reg), 4, byte_order,
1062  &backchain);
1063 
1064  /* A zero backchain terminates the frame chain. Also, sanity
1065  check against the local store size limit. */
1066  if (status && backchain > 0 && backchain <= lslr)
1067  {
1068  /* Assume the link register is saved into its slot. */
1069  if (backchain + 16 <= lslr)
1070  info->saved_regs[SPU_LR_REGNUM].addr = SPUADDR (id,
1071  backchain + 16);
1072 
1073  /* Frame bases. */
1074  info->frame_base = SPUADDR (id, backchain);
1075  info->local_base = SPUADDR (id, reg);
1076  }
1077  }
1078 
1079  /* If we didn't find a frame, we cannot determine SP / return address. */
1080  if (info->frame_base == 0)
1081  return info;
1082 
1083  /* The previous SP is equal to the CFA. */
1085  SPUADDR_ADDR (info->frame_base));
1086 
1087  /* Read full contents of the unwound link register in order to
1088  be able to determine the return address. */
1090  target_read_memory (info->saved_regs[SPU_LR_REGNUM].addr, buf, 16);
1091  else
1092  get_frame_register (this_frame, SPU_LR_REGNUM, buf);
1093 
1094  /* Normally, the return address is contained in the slot 0 of the
1095  link register, and slots 1-3 are zero. For an overlay return,
1096  slot 0 contains the address of the overlay manager return stub,
1097  slot 1 contains the partition number of the overlay section to
1098  be returned to, and slot 2 contains the return address within
1099  that section. Return the latter address in that case. */
1100  if (extract_unsigned_integer (buf + 8, 4, byte_order) != 0)
1102  extract_unsigned_integer (buf + 8, 4, byte_order));
1103  else
1105  extract_unsigned_integer (buf, 4, byte_order));
1106 
1107  return info;
1108 }
1109 
1110 static void
1111 spu_frame_this_id (struct frame_info *this_frame,
1112  void **this_prologue_cache, struct frame_id *this_id)
1113 {
1114  struct spu_unwind_cache *info =
1115  spu_frame_unwind_cache (this_frame, this_prologue_cache);
1116 
1117  if (info->frame_base == 0)
1118  return;
1119 
1120  *this_id = frame_id_build (info->frame_base, info->func);
1121 }
1122 
1123 static struct value *
1125  void **this_prologue_cache, int regnum)
1126 {
1127  struct spu_unwind_cache *info
1128  = spu_frame_unwind_cache (this_frame, this_prologue_cache);
1129 
1130  /* Special-case the stack pointer. */
1131  if (regnum == SPU_RAW_SP_REGNUM)
1132  regnum = SPU_SP_REGNUM;
1133 
1134  return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1135 }
1136 
1137 static const struct frame_unwind spu_frame_unwind = {
1138  NORMAL_FRAME,
1142  NULL,
1144 };
1145 
1146 static CORE_ADDR
1147 spu_frame_base_address (struct frame_info *this_frame, void **this_cache)
1148 {
1149  struct spu_unwind_cache *info
1150  = spu_frame_unwind_cache (this_frame, this_cache);
1151  return info->local_base;
1152 }
1153 
1154 static const struct frame_base spu_frame_base = {
1158  spu_frame_base_address
1159 };
1160 
1161 static CORE_ADDR
1162 spu_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1163 {
1164  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1166  /* Mask off interrupt enable bit. */
1167  return SPUADDR (tdep->id, pc & -4);
1168 }
1169 
1170 static CORE_ADDR
1171 spu_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1172 {
1173  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1175  return SPUADDR (tdep->id, sp);
1176 }
1177 
1178 static CORE_ADDR
1180 {
1181  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
1182  ULONGEST pc;
1184  /* Mask off interrupt enable bit. */
1185  return SPUADDR (tdep->id, pc & -4);
1186 }
1187 
1188 static void
1190 {
1191  /* Keep interrupt enabled state unchanged. */
1192  ULONGEST old_pc;
1193 
1194  regcache_cooked_read_unsigned (regcache, SPU_PC_REGNUM, &old_pc);
1196  (SPUADDR_ADDR (pc) & -4) | (old_pc & 3));
1197 }
1198 
1199 
1200 /* Cell/B.E. cross-architecture unwinder support. */
1201 
1203 {
1206 };
1207 
1208 static struct gdbarch *
1209 spu2ppu_prev_arch (struct frame_info *this_frame, void **this_cache)
1210 {
1211  struct spu2ppu_cache *cache = *this_cache;
1212  return get_regcache_arch (cache->regcache);
1213 }
1214 
1215 static void
1216 spu2ppu_this_id (struct frame_info *this_frame,
1217  void **this_cache, struct frame_id *this_id)
1218 {
1219  struct spu2ppu_cache *cache = *this_cache;
1220  *this_id = cache->frame_id;
1221 }
1222 
1223 static struct value *
1224 spu2ppu_prev_register (struct frame_info *this_frame,
1225  void **this_cache, int regnum)
1226 {
1227  struct spu2ppu_cache *cache = *this_cache;
1228  struct gdbarch *gdbarch = get_regcache_arch (cache->regcache);
1229  gdb_byte *buf;
1230 
1231  buf = alloca (register_size (gdbarch, regnum));
1232  regcache_cooked_read (cache->regcache, regnum, buf);
1233  return frame_unwind_got_bytes (this_frame, regnum, buf);
1234 }
1235 
1236 static int
1237 spu2ppu_sniffer (const struct frame_unwind *self,
1238  struct frame_info *this_frame, void **this_prologue_cache)
1239 {
1240  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1241  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1242  CORE_ADDR base, func, backchain;
1243  gdb_byte buf[4];
1244 
1245  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_spu)
1246  return 0;
1247 
1248  base = get_frame_sp (this_frame);
1249  func = get_frame_pc (this_frame);
1250  if (target_read_memory (base, buf, 4))
1251  return 0;
1252  backchain = extract_unsigned_integer (buf, 4, byte_order);
1253 
1254  if (!backchain)
1255  {
1256  struct frame_info *fi;
1257 
1258  struct spu2ppu_cache *cache
1259  = FRAME_OBSTACK_CALLOC (1, struct spu2ppu_cache);
1260 
1261  cache->frame_id = frame_id_build (base + 16, func);
1262 
1263  for (fi = get_next_frame (this_frame); fi; fi = get_next_frame (fi))
1264  if (gdbarch_bfd_arch_info (get_frame_arch (fi))->arch != bfd_arch_spu)
1265  break;
1266 
1267  if (fi)
1268  {
1269  cache->regcache = frame_save_as_regcache (fi);
1270  *this_prologue_cache = cache;
1271  return 1;
1272  }
1273  else
1274  {
1275  struct regcache *regcache;
1277  cache->regcache = regcache_dup (regcache);
1278  *this_prologue_cache = cache;
1279  return 1;
1280  }
1281  }
1282 
1283  return 0;
1284 }
1285 
1286 static void
1287 spu2ppu_dealloc_cache (struct frame_info *self, void *this_cache)
1288 {
1289  struct spu2ppu_cache *cache = this_cache;
1290  regcache_xfree (cache->regcache);
1291 }
1292 
1293 static const struct frame_unwind spu2ppu_unwind = {
1294  ARCH_FRAME,
1298  NULL,
1302 };
1303 
1304 
1305 /* Function calling convention. */
1306 
1307 static CORE_ADDR
1308 spu_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
1309 {
1310  return sp & ~15;
1311 }
1312 
1313 static CORE_ADDR
1314 spu_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr,
1315  struct value **args, int nargs, struct type *value_type,
1316  CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
1317  struct regcache *regcache)
1318 {
1319  /* Allocate space sufficient for a breakpoint, keeping the stack aligned. */
1320  sp = (sp - 4) & ~15;
1321  /* Store the address of that breakpoint */
1322  *bp_addr = sp;
1323  /* The call starts at the callee's entry point. */
1324  *real_pc = funaddr;
1325 
1326  return sp;
1327 }
1328 
1329 static int
1331 {
1332  switch (TYPE_CODE (type))
1333  {
1334  case TYPE_CODE_INT:
1335  case TYPE_CODE_ENUM:
1336  case TYPE_CODE_RANGE:
1337  case TYPE_CODE_CHAR:
1338  case TYPE_CODE_BOOL:
1339  case TYPE_CODE_PTR:
1340  case TYPE_CODE_REF:
1341  return TYPE_LENGTH (type) <= 16;
1342 
1343  default:
1344  return 0;
1345  }
1346 }
1347 
1348 static void
1350  struct type *type, const gdb_byte *in)
1351 {
1352  int len = TYPE_LENGTH (type);
1353 
1354  if (spu_scalar_value_p (type))
1355  {
1356  int preferred_slot = len < 4 ? 4 - len : 0;
1357  regcache_cooked_write_part (regcache, regnum, preferred_slot, len, in);
1358  }
1359  else
1360  {
1361  while (len >= 16)
1362  {
1363  regcache_cooked_write (regcache, regnum++, in);
1364  in += 16;
1365  len -= 16;
1366  }
1367 
1368  if (len > 0)
1369  regcache_cooked_write_part (regcache, regnum, 0, len, in);
1370  }
1371 }
1372 
1373 static void
1375  struct type *type, gdb_byte *out)
1376 {
1377  int len = TYPE_LENGTH (type);
1378 
1379  if (spu_scalar_value_p (type))
1380  {
1381  int preferred_slot = len < 4 ? 4 - len : 0;
1382  regcache_cooked_read_part (regcache, regnum, preferred_slot, len, out);
1383  }
1384  else
1385  {
1386  while (len >= 16)
1387  {
1388  regcache_cooked_read (regcache, regnum++, out);
1389  out += 16;
1390  len -= 16;
1391  }
1392 
1393  if (len > 0)
1394  regcache_cooked_read_part (regcache, regnum, 0, len, out);
1395  }
1396 }
1397 
1398 static CORE_ADDR
1399 spu_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1400  struct regcache *regcache, CORE_ADDR bp_addr,
1401  int nargs, struct value **args, CORE_ADDR sp,
1402  int struct_return, CORE_ADDR struct_addr)
1403 {
1404  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1405  CORE_ADDR sp_delta;
1406  int i;
1407  int regnum = SPU_ARG1_REGNUM;
1408  int stack_arg = -1;
1409  gdb_byte buf[16];
1410 
1411  /* Set the return address. */
1412  memset (buf, 0, sizeof buf);
1413  store_unsigned_integer (buf, 4, byte_order, SPUADDR_ADDR (bp_addr));
1414  regcache_cooked_write (regcache, SPU_LR_REGNUM, buf);
1415 
1416  /* If STRUCT_RETURN is true, then the struct return address (in
1417  STRUCT_ADDR) will consume the first argument-passing register.
1418  Both adjust the register count and store that value. */
1419  if (struct_return)
1420  {
1421  memset (buf, 0, sizeof buf);
1422  store_unsigned_integer (buf, 4, byte_order, SPUADDR_ADDR (struct_addr));
1423  regcache_cooked_write (regcache, regnum++, buf);
1424  }
1425 
1426  /* Fill in argument registers. */
1427  for (i = 0; i < nargs; i++)
1428  {
1429  struct value *arg = args[i];
1430  struct type *type = check_typedef (value_type (arg));
1431  const gdb_byte *contents = value_contents (arg);
1432  int n_regs = align_up (TYPE_LENGTH (type), 16) / 16;
1433 
1434  /* If the argument doesn't wholly fit into registers, it and
1435  all subsequent arguments go to the stack. */
1436  if (regnum + n_regs - 1 > SPU_ARGN_REGNUM)
1437  {
1438  stack_arg = i;
1439  break;
1440  }
1441 
1442  spu_value_to_regcache (regcache, regnum, type, contents);
1443  regnum += n_regs;
1444  }
1445 
1446  /* Overflow arguments go to the stack. */
1447  if (stack_arg != -1)
1448  {
1449  CORE_ADDR ap;
1450 
1451  /* Allocate all required stack size. */
1452  for (i = stack_arg; i < nargs; i++)
1453  {
1454  struct type *type = check_typedef (value_type (args[i]));
1455  sp -= align_up (TYPE_LENGTH (type), 16);
1456  }
1457 
1458  /* Fill in stack arguments. */
1459  ap = sp;
1460  for (i = stack_arg; i < nargs; i++)
1461  {
1462  struct value *arg = args[i];
1463  struct type *type = check_typedef (value_type (arg));
1464  int len = TYPE_LENGTH (type);
1465  int preferred_slot;
1466 
1467  if (spu_scalar_value_p (type))
1468  preferred_slot = len < 4 ? 4 - len : 0;
1469  else
1470  preferred_slot = 0;
1471 
1472  target_write_memory (ap + preferred_slot, value_contents (arg), len);
1473  ap += align_up (TYPE_LENGTH (type), 16);
1474  }
1475  }
1476 
1477  /* Allocate stack frame header. */
1478  sp -= 32;
1479 
1480  /* Store stack back chain. */
1481  regcache_cooked_read (regcache, SPU_RAW_SP_REGNUM, buf);
1482  target_write_memory (sp, buf, 16);
1483 
1484  /* Finally, update all slots of the SP register. */
1485  sp_delta = sp - extract_unsigned_integer (buf, 4, byte_order);
1486  for (i = 0; i < 4; i++)
1487  {
1488  CORE_ADDR sp_slot = extract_unsigned_integer (buf + 4*i, 4, byte_order);
1489  store_unsigned_integer (buf + 4*i, 4, byte_order, sp_slot + sp_delta);
1490  }
1491  regcache_cooked_write (regcache, SPU_RAW_SP_REGNUM, buf);
1492 
1493  return sp;
1494 }
1495 
1496 static struct frame_id
1497 spu_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1498 {
1499  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1502  return frame_id_build (SPUADDR (tdep->id, sp), SPUADDR (tdep->id, pc & -4));
1503 }
1504 
1505 /* Function return value access. */
1506 
1507 static enum return_value_convention
1508 spu_return_value (struct gdbarch *gdbarch, struct value *function,
1509  struct type *type, struct regcache *regcache,
1510  gdb_byte *out, const gdb_byte *in)
1511 {
1512  struct type *func_type = function ? value_type (function) : NULL;
1513  enum return_value_convention rvc;
1514  int opencl_vector = 0;
1515 
1516  if (func_type)
1517  {
1518  func_type = check_typedef (func_type);
1519 
1520  if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
1521  func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
1522 
1523  if (TYPE_CODE (func_type) == TYPE_CODE_FUNC
1524  && TYPE_CALLING_CONVENTION (func_type) == DW_CC_GDB_IBM_OpenCL
1525  && TYPE_CODE (type) == TYPE_CODE_ARRAY
1526  && TYPE_VECTOR (type))
1527  opencl_vector = 1;
1528  }
1529 
1530  if (TYPE_LENGTH (type) <= (SPU_ARGN_REGNUM - SPU_ARG1_REGNUM + 1) * 16)
1532  else
1534 
1535  if (in)
1536  {
1537  switch (rvc)
1538  {
1540  if (opencl_vector && TYPE_LENGTH (type) == 2)
1541  regcache_cooked_write_part (regcache, SPU_ARG1_REGNUM, 2, 2, in);
1542  else
1543  spu_value_to_regcache (regcache, SPU_ARG1_REGNUM, type, in);
1544  break;
1545 
1547  error (_("Cannot set function return value."));
1548  break;
1549  }
1550  }
1551  else if (out)
1552  {
1553  switch (rvc)
1554  {
1556  if (opencl_vector && TYPE_LENGTH (type) == 2)
1557  regcache_cooked_read_part (regcache, SPU_ARG1_REGNUM, 2, 2, out);
1558  else
1559  spu_regcache_to_value (regcache, SPU_ARG1_REGNUM, type, out);
1560  break;
1561 
1563  error (_("Function return value unknown."));
1564  break;
1565  }
1566  }
1567 
1568  return rvc;
1569 }
1570 
1571 
1572 /* Breakpoints. */
1573 
1574 static const gdb_byte *
1575 spu_breakpoint_from_pc (struct gdbarch *gdbarch,
1576  CORE_ADDR * pcptr, int *lenptr)
1577 {
1578  static const gdb_byte breakpoint[] = { 0x00, 0x00, 0x3f, 0xff };
1579 
1580  *lenptr = sizeof breakpoint;
1581  return breakpoint;
1582 }
1583 
1584 static int
1585 spu_memory_remove_breakpoint (struct gdbarch *gdbarch,
1586  struct bp_target_info *bp_tgt)
1587 {
1588  /* We work around a problem in combined Cell/B.E. debugging here. Consider
1589  that in a combined application, we have some breakpoints inserted in SPU
1590  code, and now the application forks (on the PPU side). GDB common code
1591  will assume that the fork system call copied all breakpoints into the new
1592  process' address space, and that all those copies now need to be removed
1593  (see breakpoint.c:detach_breakpoints).
1594 
1595  While this is certainly true for PPU side breakpoints, it is not true
1596  for SPU side breakpoints. fork will clone the SPU context file
1597  descriptors, so that all the existing SPU contexts are in accessible
1598  in the new process. However, the contents of the SPU contexts themselves
1599  are *not* cloned. Therefore the effect of detach_breakpoints is to
1600  remove SPU breakpoints from the *original* SPU context's local store
1601  -- this is not the correct behaviour.
1602 
1603  The workaround is to check whether the PID we are asked to remove this
1604  breakpoint from (i.e. ptid_get_pid (inferior_ptid)) is different from the
1605  PID of the current inferior (i.e. current_inferior ()->pid). This is only
1606  true in the context of detach_breakpoints. If so, we simply do nothing.
1607  [ Note that for the fork child process, it does not matter if breakpoints
1608  remain inserted, because those SPU contexts are not runnable anyway --
1609  the Linux kernel allows only the original process to invoke spu_run. */
1610 
1612  return 0;
1613 
1614  return default_memory_remove_breakpoint (gdbarch, bp_tgt);
1615 }
1616 
1617 
1618 /* Software single-stepping support. */
1619 
1620 static int
1622 {
1623  struct gdbarch *gdbarch = get_frame_arch (frame);
1624  struct address_space *aspace = get_frame_address_space (frame);
1625  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1626  CORE_ADDR pc, next_pc;
1627  unsigned int insn;
1628  int offset, reg;
1629  gdb_byte buf[4];
1630  ULONGEST lslr;
1631 
1632  pc = get_frame_pc (frame);
1633 
1634  if (target_read_memory (pc, buf, 4))
1635  return 1;
1636  insn = extract_unsigned_integer (buf, 4, byte_order);
1637 
1638  /* Get local store limit. */
1640  if (!lslr)
1641  lslr = (ULONGEST) -1;
1642 
1643  /* Next sequential instruction is at PC + 4, except if the current
1644  instruction is a PPE-assisted call, in which case it is at PC + 8.
1645  Wrap around LS limit to be on the safe side. */
1646  if ((insn & 0xffffff00) == 0x00002100)
1647  next_pc = (SPUADDR_ADDR (pc) + 8) & lslr;
1648  else
1649  next_pc = (SPUADDR_ADDR (pc) + 4) & lslr;
1650 
1652  aspace, SPUADDR (SPUADDR_SPU (pc), next_pc));
1653 
1654  if (is_branch (insn, &offset, &reg))
1655  {
1656  CORE_ADDR target = offset;
1657 
1658  if (reg == SPU_PC_REGNUM)
1659  target += SPUADDR_ADDR (pc);
1660  else if (reg != -1)
1661  {
1662  int optim, unavail;
1663 
1664  if (get_frame_register_bytes (frame, reg, 0, 4, buf,
1665  &optim, &unavail))
1666  target += extract_unsigned_integer (buf, 4, byte_order) & -4;
1667  else
1668  {
1669  if (optim)
1671  _("Could not determine address of "
1672  "single-step breakpoint."));
1673  if (unavail)
1675  _("Could not determine address of "
1676  "single-step breakpoint."));
1677  }
1678  }
1679 
1680  target = target & lslr;
1681  if (target != next_pc)
1682  insert_single_step_breakpoint (gdbarch, aspace,
1683  SPUADDR (SPUADDR_SPU (pc), target));
1684  }
1685 
1686  return 1;
1687 }
1688 
1689 
1690 /* Longjmp support. */
1691 
1692 static int
1694 {
1695  struct gdbarch *gdbarch = get_frame_arch (frame);
1696  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1697  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1698  gdb_byte buf[4];
1699  CORE_ADDR jb_addr;
1700  int optim, unavail;
1701 
1702  /* Jump buffer is pointed to by the argument register $r3. */
1703  if (!get_frame_register_bytes (frame, SPU_ARG1_REGNUM, 0, 4, buf,
1704  &optim, &unavail))
1705  return 0;
1706 
1707  jb_addr = extract_unsigned_integer (buf, 4, byte_order);
1708  if (target_read_memory (SPUADDR (tdep->id, jb_addr), buf, 4))
1709  return 0;
1710 
1711  *pc = extract_unsigned_integer (buf, 4, byte_order);
1712  *pc = SPUADDR (tdep->id, *pc);
1713  return 1;
1714 }
1715 
1716 
1717 /* Disassembler. */
1718 
1720 {
1721  struct gdbarch *gdbarch;
1722  int id;
1723 };
1724 
1725 static void
1726 spu_dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
1727 {
1728  struct spu_dis_asm_data *data = info->application_data;
1729  print_address (data->gdbarch, SPUADDR (data->id, addr), info->stream);
1730 }
1731 
1732 static int
1733 gdb_print_insn_spu (bfd_vma memaddr, struct disassemble_info *info)
1734 {
1735  /* The opcodes disassembler does 18-bit address arithmetic. Make
1736  sure the SPU ID encoded in the high bits is added back when we
1737  call print_address. */
1738  struct disassemble_info spu_info = *info;
1739  struct spu_dis_asm_data data;
1740  data.gdbarch = info->application_data;
1741  data.id = SPUADDR_SPU (memaddr);
1742 
1743  spu_info.application_data = &data;
1744  spu_info.print_address_func = spu_dis_asm_print_address;
1745  return print_insn_spu (memaddr, &spu_info);
1746 }
1747 
1748 
1749 /* Target overlays for the SPU overlay manager.
1750 
1751  See the documentation of simple_overlay_update for how the
1752  interface is supposed to work.
1753 
1754  Data structures used by the overlay manager:
1755 
1756  struct ovly_table
1757  {
1758  u32 vma;
1759  u32 size;
1760  u32 pos;
1761  u32 buf;
1762  } _ovly_table[]; -- one entry per overlay section
1763 
1764  struct ovly_buf_table
1765  {
1766  u32 mapped;
1767  } _ovly_buf_table[]; -- one entry per overlay buffer
1768 
1769  _ovly_table should never change.
1770 
1771  Both tables are aligned to a 16-byte boundary, the symbols
1772  _ovly_table and _ovly_buf_table are of type STT_OBJECT and their
1773  size set to the size of the respective array. buf in _ovly_table is
1774  an index into _ovly_buf_table.
1775 
1776  mapped is an index into _ovly_table. Both the mapped and buf indices start
1777  from one to reference the first entry in their respective tables. */
1778 
1779 /* Using the per-objfile private data mechanism, we store for each
1780  objfile an array of "struct spu_overlay_table" structures, one
1781  for each obj_section of the objfile. This structure holds two
1782  fields, MAPPED_PTR and MAPPED_VAL. If MAPPED_PTR is zero, this
1783  is *not* an overlay section. If it is non-zero, it represents
1784  a target address. The overlay section is mapped iff the target
1785  integer at this location equals MAPPED_VAL. */
1786 
1787 static const struct objfile_data *spu_overlay_data;
1788 
1790  {
1793  };
1794 
1795 /* Retrieve the overlay table for OBJFILE. If not already cached, read
1796  the _ovly_table data structure from the target and initialize the
1797  spu_overlay_table data structure from it. */
1798 static struct spu_overlay_table *
1800 {
1801  enum bfd_endian byte_order = bfd_big_endian (objfile->obfd)?
1802  BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
1803  struct bound_minimal_symbol ovly_table_msym, ovly_buf_table_msym;
1804  CORE_ADDR ovly_table_base, ovly_buf_table_base;
1805  unsigned ovly_table_size, ovly_buf_table_size;
1806  struct spu_overlay_table *tbl;
1807  struct obj_section *osect;
1808  gdb_byte *ovly_table;
1809  int i;
1810 
1811  tbl = objfile_data (objfile, spu_overlay_data);
1812  if (tbl)
1813  return tbl;
1814 
1815  ovly_table_msym = lookup_minimal_symbol ("_ovly_table", NULL, objfile);
1816  if (!ovly_table_msym.minsym)
1817  return NULL;
1818 
1819  ovly_buf_table_msym = lookup_minimal_symbol ("_ovly_buf_table",
1820  NULL, objfile);
1821  if (!ovly_buf_table_msym.minsym)
1822  return NULL;
1823 
1824  ovly_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_table_msym);
1825  ovly_table_size = MSYMBOL_SIZE (ovly_table_msym.minsym);
1826 
1827  ovly_buf_table_base = BMSYMBOL_VALUE_ADDRESS (ovly_buf_table_msym);
1828  ovly_buf_table_size = MSYMBOL_SIZE (ovly_buf_table_msym.minsym);
1829 
1830  ovly_table = xmalloc (ovly_table_size);
1831  read_memory (ovly_table_base, ovly_table, ovly_table_size);
1832 
1833  tbl = OBSTACK_CALLOC (&objfile->objfile_obstack,
1834  objfile->sections_end - objfile->sections,
1835  struct spu_overlay_table);
1836 
1837  for (i = 0; i < ovly_table_size / 16; i++)
1838  {
1839  CORE_ADDR vma = extract_unsigned_integer (ovly_table + 16*i + 0,
1840  4, byte_order);
1841  CORE_ADDR size = extract_unsigned_integer (ovly_table + 16*i + 4,
1842  4, byte_order);
1843  CORE_ADDR pos = extract_unsigned_integer (ovly_table + 16*i + 8,
1844  4, byte_order);
1845  CORE_ADDR buf = extract_unsigned_integer (ovly_table + 16*i + 12,
1846  4, byte_order);
1847 
1848  if (buf == 0 || (buf - 1) * 4 >= ovly_buf_table_size)
1849  continue;
1850 
1851  ALL_OBJFILE_OSECTIONS (objfile, osect)
1852  if (vma == bfd_section_vma (objfile->obfd, osect->the_bfd_section)
1853  && pos == osect->the_bfd_section->filepos)
1854  {
1855  int ndx = osect - objfile->sections;
1856  tbl[ndx].mapped_ptr = ovly_buf_table_base + (buf - 1) * 4;
1857  tbl[ndx].mapped_val = i + 1;
1858  break;
1859  }
1860  }
1861 
1862  xfree (ovly_table);
1863  set_objfile_data (objfile, spu_overlay_data, tbl);
1864  return tbl;
1865 }
1866 
1867 /* Read _ovly_buf_table entry from the target to dermine whether
1868  OSECT is currently mapped, and update the mapped state. */
1869 static void
1871 {
1872  enum bfd_endian byte_order = bfd_big_endian (osect->objfile->obfd)?
1873  BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
1874  struct spu_overlay_table *ovly_table;
1875  CORE_ADDR id, val;
1876 
1877  ovly_table = spu_get_overlay_table (osect->objfile);
1878  if (!ovly_table)
1879  return;
1880 
1881  ovly_table += osect - osect->objfile->sections;
1882  if (ovly_table->mapped_ptr == 0)
1883  return;
1884 
1885  id = SPUADDR_SPU (obj_section_addr (osect));
1886  val = read_memory_unsigned_integer (SPUADDR (id, ovly_table->mapped_ptr),
1887  4, byte_order);
1888  osect->ovly_mapped = (val == ovly_table->mapped_val);
1889 }
1890 
1891 /* If OSECT is NULL, then update all sections' mapped state.
1892  If OSECT is non-NULL, then update only OSECT's mapped state. */
1893 static void
1895 {
1896  /* Just one section. */
1897  if (osect)
1898  spu_overlay_update_osect (osect);
1899 
1900  /* All sections. */
1901  else
1902  {
1903  struct objfile *objfile;
1904 
1905  ALL_OBJSECTIONS (objfile, osect)
1906  if (section_is_overlay (osect))
1907  spu_overlay_update_osect (osect);
1908  }
1909 }
1910 
1911 /* Whenever a new objfile is loaded, read the target's _ovly_table.
1912  If there is one, go through all sections and make sure for non-
1913  overlay sections LMA equals VMA, while for overlay sections LMA
1914  is larger than SPU_OVERLAY_LMA. */
1915 static void
1917 {
1918  struct spu_overlay_table *ovly_table;
1919  struct obj_section *osect;
1920 
1921  /* If we've already touched this file, do nothing. */
1922  if (!objfile || objfile_data (objfile, spu_overlay_data) != NULL)
1923  return;
1924 
1925  /* Consider only SPU objfiles. */
1926  if (bfd_get_arch (objfile->obfd) != bfd_arch_spu)
1927  return;
1928 
1929  /* Check if this objfile has overlays. */
1930  ovly_table = spu_get_overlay_table (objfile);
1931  if (!ovly_table)
1932  return;
1933 
1934  /* Now go and fiddle with all the LMAs. */
1935  ALL_OBJFILE_OSECTIONS (objfile, osect)
1936  {
1937  bfd *obfd = objfile->obfd;
1938  asection *bsect = osect->the_bfd_section;
1939  int ndx = osect - objfile->sections;
1940 
1941  if (ovly_table[ndx].mapped_ptr == 0)
1942  bfd_section_lma (obfd, bsect) = bfd_section_vma (obfd, bsect);
1943  else
1944  bfd_section_lma (obfd, bsect) = SPU_OVERLAY_LMA + bsect->filepos;
1945  }
1946 }
1947 
1948 
1949 /* Insert temporary breakpoint on "main" function of newly loaded
1950  SPE context OBJFILE. */
1951 static void
1953 {
1954  struct bound_minimal_symbol minsym;
1955  struct compunit_symtab *cust;
1956  CORE_ADDR pc;
1957  char buf[32];
1958 
1959  /* Do this only if requested by "set spu stop-on-load on". */
1960  if (!spu_stop_on_load_p)
1961  return;
1962 
1963  /* Consider only SPU objfiles. */
1964  if (!objfile || bfd_get_arch (objfile->obfd) != bfd_arch_spu)
1965  return;
1966 
1967  /* The main objfile is handled differently. */
1968  if (objfile == symfile_objfile)
1969  return;
1970 
1971  /* There can be multiple symbols named "main". Search for the
1972  "main" in *this* objfile. */
1973  minsym = lookup_minimal_symbol ("main", NULL, objfile);
1974  if (!minsym.minsym)
1975  return;
1976 
1977  /* If we have debugging information, try to use it -- this
1978  will allow us to properly skip the prologue. */
1979  pc = BMSYMBOL_VALUE_ADDRESS (minsym);
1980  cust
1982  minsym.minsym));
1983  if (cust != NULL)
1984  {
1985  const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
1986  struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1987  struct symbol *sym;
1988  struct symtab_and_line sal;
1989 
1990  sym = block_lookup_symbol (block, "main", VAR_DOMAIN);
1991  if (sym)
1992  {
1993  fixup_symbol_section (sym, objfile);
1994  sal = find_function_start_sal (sym, 1);
1995  pc = sal.pc;
1996  }
1997  }
1998 
1999  /* Use a numerical address for the set_breakpoint command to avoid having
2000  the breakpoint re-set incorrectly. */
2001  xsnprintf (buf, sizeof buf, "*%s", core_addr_to_string (pc));
2002  create_breakpoint (get_objfile_arch (objfile), buf /* arg */,
2003  NULL /* cond_string */, -1 /* thread */,
2004  NULL /* extra_string */,
2005  0 /* parse_condition_and_thread */, 1 /* tempflag */,
2006  bp_breakpoint /* type_wanted */,
2007  0 /* ignore_count */,
2008  AUTO_BOOLEAN_FALSE /* pending_break_support */,
2009  &bkpt_breakpoint_ops /* ops */, 0 /* from_tty */,
2010  1 /* enabled */, 0 /* internal */, 0);
2011 }
2012 
2013 
2014 /* Look up OBJFILE loaded into FRAME's SPU context. */
2015 static struct objfile *
2017 {
2018  struct gdbarch *gdbarch = get_frame_arch (frame);
2019  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2020  struct objfile *obj;
2021 
2022  if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
2023  return NULL;
2024 
2025  ALL_OBJFILES (obj)
2026  {
2027  if (obj->sections != obj->sections_end
2028  && SPUADDR_SPU (obj_section_addr (obj->sections)) == tdep->id)
2029  return obj;
2030  }
2031 
2032  return NULL;
2033 }
2034 
2035 /* Flush cache for ea pointer access if available. */
2036 static void
2038 {
2039  struct bound_minimal_symbol msymbol;
2040  struct objfile *obj;
2041 
2042  if (!has_stack_frames ())
2043  return;
2044 
2046  if (obj == NULL)
2047  return;
2048 
2049  /* Lookup inferior function __cache_flush. */
2050  msymbol = lookup_minimal_symbol ("__cache_flush", NULL, obj);
2051  if (msymbol.minsym != NULL)
2052  {
2053  struct type *type;
2054  CORE_ADDR addr;
2055 
2056  type = objfile_type (obj)->builtin_void;
2057  type = lookup_function_type (type);
2058  type = lookup_pointer_type (type);
2059  addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
2060 
2061  call_function_by_hand (value_from_pointer (type, addr), 0, NULL);
2062  }
2063 }
2064 
2065 /* This handler is called when the inferior has stopped. If it is stopped in
2066  SPU architecture then flush the ea cache if used. */
2067 static void
2069 {
2071  return;
2072 
2073  /* Temporarily reset spu_auto_flush_cache_p to avoid recursively
2074  re-entering this function when __cache_flush stops. */
2076  flush_ea_cache ();
2078 }
2079 
2080 
2081 /* "info spu" commands. */
2082 
2083 static void
2084 info_spu_event_command (char *args, int from_tty)
2085 {
2086  struct frame_info *frame = get_selected_frame (NULL);
2087  ULONGEST event_status = 0;
2088  ULONGEST event_mask = 0;
2089  struct cleanup *chain;
2090  gdb_byte buf[100];
2091  char annex[32];
2092  LONGEST len;
2093  int id;
2094 
2095  if (gdbarch_bfd_arch_info (get_frame_arch (frame))->arch != bfd_arch_spu)
2096  error (_("\"info spu\" is only supported on the SPU architecture."));
2097 
2099 
2100  xsnprintf (annex, sizeof annex, "%d/event_status", id);
2102  buf, 0, (sizeof (buf) - 1));
2103  if (len <= 0)
2104  error (_("Could not read event_status."));
2105  buf[len] = '\0';
2106  event_status = strtoulst ((char *) buf, NULL, 16);
2107 
2108  xsnprintf (annex, sizeof annex, "%d/event_mask", id);
2110  buf, 0, (sizeof (buf) - 1));
2111  if (len <= 0)
2112  error (_("Could not read event_mask."));
2113  buf[len] = '\0';
2114  event_mask = strtoulst ((char *) buf, NULL, 16);
2115 
2116  chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoEvent");
2117 
2119  {
2120  ui_out_field_fmt (current_uiout, "event_status",
2121  "0x%s", phex_nz (event_status, 4));
2122  ui_out_field_fmt (current_uiout, "event_mask",
2123  "0x%s", phex_nz (event_mask, 4));
2124  }
2125  else
2126  {
2127  printf_filtered (_("Event Status 0x%s\n"), phex (event_status, 4));
2128  printf_filtered (_("Event Mask 0x%s\n"), phex (event_mask, 4));
2129  }
2130 
2131  do_cleanups (chain);
2132 }
2133 
2134 static void
2135 info_spu_signal_command (char *args, int from_tty)
2136 {
2137  struct frame_info *frame = get_selected_frame (NULL);
2138  struct gdbarch *gdbarch = get_frame_arch (frame);
2139  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2140  ULONGEST signal1 = 0;
2141  ULONGEST signal1_type = 0;
2142  int signal1_pending = 0;
2143  ULONGEST signal2 = 0;
2144  ULONGEST signal2_type = 0;
2145  int signal2_pending = 0;
2146  struct cleanup *chain;
2147  char annex[32];
2148  gdb_byte buf[100];
2149  LONGEST len;
2150  int id;
2151 
2152  if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
2153  error (_("\"info spu\" is only supported on the SPU architecture."));
2154 
2156 
2157  xsnprintf (annex, sizeof annex, "%d/signal1", id);
2158  len = target_read (&current_target, TARGET_OBJECT_SPU, annex, buf, 0, 4);
2159  if (len < 0)
2160  error (_("Could not read signal1."));
2161  else if (len == 4)
2162  {
2163  signal1 = extract_unsigned_integer (buf, 4, byte_order);
2164  signal1_pending = 1;
2165  }
2166 
2167  xsnprintf (annex, sizeof annex, "%d/signal1_type", id);
2169  buf, 0, (sizeof (buf) - 1));
2170  if (len <= 0)
2171  error (_("Could not read signal1_type."));
2172  buf[len] = '\0';
2173  signal1_type = strtoulst ((char *) buf, NULL, 16);
2174 
2175  xsnprintf (annex, sizeof annex, "%d/signal2", id);
2176  len = target_read (&current_target, TARGET_OBJECT_SPU, annex, buf, 0, 4);
2177  if (len < 0)
2178  error (_("Could not read signal2."));
2179  else if (len == 4)
2180  {
2181  signal2 = extract_unsigned_integer (buf, 4, byte_order);
2182  signal2_pending = 1;
2183  }
2184 
2185  xsnprintf (annex, sizeof annex, "%d/signal2_type", id);
2187  buf, 0, (sizeof (buf) - 1));
2188  if (len <= 0)
2189  error (_("Could not read signal2_type."));
2190  buf[len] = '\0';
2191  signal2_type = strtoulst ((char *) buf, NULL, 16);
2192 
2193  chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoSignal");
2194 
2196  {
2197  ui_out_field_int (current_uiout, "signal1_pending", signal1_pending);
2198  ui_out_field_fmt (current_uiout, "signal1", "0x%s", phex_nz (signal1, 4));
2199  ui_out_field_int (current_uiout, "signal1_type", signal1_type);
2200  ui_out_field_int (current_uiout, "signal2_pending", signal2_pending);
2201  ui_out_field_fmt (current_uiout, "signal2", "0x%s", phex_nz (signal2, 4));
2202  ui_out_field_int (current_uiout, "signal2_type", signal2_type);
2203  }
2204  else
2205  {
2206  if (signal1_pending)
2207  printf_filtered (_("Signal 1 control word 0x%s "), phex (signal1, 4));
2208  else
2209  printf_filtered (_("Signal 1 not pending "));
2210 
2211  if (signal1_type)
2212  printf_filtered (_("(Type Or)\n"));
2213  else
2214  printf_filtered (_("(Type Overwrite)\n"));
2215 
2216  if (signal2_pending)
2217  printf_filtered (_("Signal 2 control word 0x%s "), phex (signal2, 4));
2218  else
2219  printf_filtered (_("Signal 2 not pending "));
2220 
2221  if (signal2_type)
2222  printf_filtered (_("(Type Or)\n"));
2223  else
2224  printf_filtered (_("(Type Overwrite)\n"));
2225  }
2226 
2227  do_cleanups (chain);
2228 }
2229 
2230 static void
2231 info_spu_mailbox_list (gdb_byte *buf, int nr, enum bfd_endian byte_order,
2232  const char *field, const char *msg)
2233 {
2234  struct cleanup *chain;
2235  int i;
2236 
2237  if (nr <= 0)
2238  return;
2239 
2240  chain = make_cleanup_ui_out_table_begin_end (current_uiout, 1, nr, "mbox");
2241 
2242  ui_out_table_header (current_uiout, 32, ui_left, field, msg);
2244 
2245  for (i = 0; i < nr; i++)
2246  {
2247  struct cleanup *val_chain;
2248  ULONGEST val;
2249  val_chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "mbox");
2250  val = extract_unsigned_integer (buf + 4*i, 4, byte_order);
2251  ui_out_field_fmt (current_uiout, field, "0x%s", phex (val, 4));
2252  do_cleanups (val_chain);
2253 
2255  printf_filtered ("\n");
2256  }
2257 
2258  do_cleanups (chain);
2259 }
2260 
2261 static void
2262 info_spu_mailbox_command (char *args, int from_tty)
2263 {
2264  struct frame_info *frame = get_selected_frame (NULL);
2265  struct gdbarch *gdbarch = get_frame_arch (frame);
2266  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2267  struct cleanup *chain;
2268  char annex[32];
2269  gdb_byte buf[1024];
2270  LONGEST len;
2271  int id;
2272 
2273  if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
2274  error (_("\"info spu\" is only supported on the SPU architecture."));
2275 
2277 
2278  chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoMailbox");
2279 
2280  xsnprintf (annex, sizeof annex, "%d/mbox_info", id);
2282  buf, 0, sizeof buf);
2283  if (len < 0)
2284  error (_("Could not read mbox_info."));
2285 
2286  info_spu_mailbox_list (buf, len / 4, byte_order,
2287  "mbox", "SPU Outbound Mailbox");
2288 
2289  xsnprintf (annex, sizeof annex, "%d/ibox_info", id);
2291  buf, 0, sizeof buf);
2292  if (len < 0)
2293  error (_("Could not read ibox_info."));
2294 
2295  info_spu_mailbox_list (buf, len / 4, byte_order,
2296  "ibox", "SPU Outbound Interrupt Mailbox");
2297 
2298  xsnprintf (annex, sizeof annex, "%d/wbox_info", id);
2300  buf, 0, sizeof buf);
2301  if (len < 0)
2302  error (_("Could not read wbox_info."));
2303 
2304  info_spu_mailbox_list (buf, len / 4, byte_order,
2305  "wbox", "SPU Inbound Mailbox");
2306 
2307  do_cleanups (chain);
2308 }
2309 
2310 static ULONGEST
2311 spu_mfc_get_bitfield (ULONGEST word, int first, int last)
2312 {
2313  ULONGEST mask = ~(~(ULONGEST)0 << (last - first + 1));
2314  return (word >> (63 - last)) & mask;
2315 }
2316 
2317 static void
2318 info_spu_dma_cmdlist (gdb_byte *buf, int nr, enum bfd_endian byte_order)
2319 {
2320  static char *spu_mfc_opcode[256] =
2321  {
2322  /* 00 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2323  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2324  /* 10 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2325  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2326  /* 20 */ "put", "putb", "putf", NULL, "putl", "putlb", "putlf", NULL,
2327  "puts", "putbs", "putfs", NULL, NULL, NULL, NULL, NULL,
2328  /* 30 */ "putr", "putrb", "putrf", NULL, "putrl", "putrlb", "putrlf", NULL,
2329  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2330  /* 40 */ "get", "getb", "getf", NULL, "getl", "getlb", "getlf", NULL,
2331  "gets", "getbs", "getfs", NULL, NULL, NULL, NULL, NULL,
2332  /* 50 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2333  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2334  /* 60 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2335  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2336  /* 70 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2337  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2338  /* 80 */ "sdcrt", "sdcrtst", NULL, NULL, NULL, NULL, NULL, NULL,
2339  NULL, "sdcrz", NULL, NULL, NULL, "sdcrst", NULL, "sdcrf",
2340  /* 90 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2341  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2342  /* a0 */ "sndsig", "sndsigb", "sndsigf", NULL, NULL, NULL, NULL, NULL,
2343  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2344  /* b0 */ "putlluc", NULL, NULL, NULL, "putllc", NULL, NULL, NULL,
2345  "putqlluc", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2346  /* c0 */ "barrier", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2347  "mfceieio", NULL, NULL, NULL, "mfcsync", NULL, NULL, NULL,
2348  /* d0 */ "getllar", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2349  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2350  /* e0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2351  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2352  /* f0 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2353  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
2354  };
2355 
2356  int *seq = alloca (nr * sizeof (int));
2357  int done = 0;
2358  struct cleanup *chain;
2359  int i, j;
2360 
2361 
2362  /* Determine sequence in which to display (valid) entries. */
2363  for (i = 0; i < nr; i++)
2364  {
2365  /* Search for the first valid entry all of whose
2366  dependencies are met. */
2367  for (j = 0; j < nr; j++)
2368  {
2369  ULONGEST mfc_cq_dw3;
2370  ULONGEST dependencies;
2371 
2372  if (done & (1 << (nr - 1 - j)))
2373  continue;
2374 
2375  mfc_cq_dw3
2376  = extract_unsigned_integer (buf + 32*j + 24,8, byte_order);
2377  if (!spu_mfc_get_bitfield (mfc_cq_dw3, 16, 16))
2378  continue;
2379 
2380  dependencies = spu_mfc_get_bitfield (mfc_cq_dw3, 0, nr - 1);
2381  if ((dependencies & done) != dependencies)
2382  continue;
2383 
2384  seq[i] = j;
2385  done |= 1 << (nr - 1 - j);
2386  break;
2387  }
2388 
2389  if (j == nr)
2390  break;
2391  }
2392 
2393  nr = i;
2394 
2395 
2397  "dma_cmd");
2398 
2399  ui_out_table_header (current_uiout, 7, ui_left, "opcode", "Opcode");
2400  ui_out_table_header (current_uiout, 3, ui_left, "tag", "Tag");
2401  ui_out_table_header (current_uiout, 3, ui_left, "tid", "TId");
2402  ui_out_table_header (current_uiout, 3, ui_left, "rid", "RId");
2403  ui_out_table_header (current_uiout, 18, ui_left, "ea", "EA");
2404  ui_out_table_header (current_uiout, 7, ui_left, "lsa", "LSA");
2405  ui_out_table_header (current_uiout, 7, ui_left, "size", "Size");
2406  ui_out_table_header (current_uiout, 7, ui_left, "lstaddr", "LstAddr");
2407  ui_out_table_header (current_uiout, 7, ui_left, "lstsize", "LstSize");
2408  ui_out_table_header (current_uiout, 1, ui_left, "error_p", "E");
2409 
2411 
2412  for (i = 0; i < nr; i++)
2413  {
2414  struct cleanup *cmd_chain;
2415  ULONGEST mfc_cq_dw0;
2416  ULONGEST mfc_cq_dw1;
2417  ULONGEST mfc_cq_dw2;
2418  int mfc_cmd_opcode, mfc_cmd_tag, rclass_id, tclass_id;
2419  int list_lsa, list_size, mfc_lsa, mfc_size;
2420  ULONGEST mfc_ea;
2421  int list_valid_p, noop_valid_p, qw_valid_p, ea_valid_p, cmd_error_p;
2422 
2423  /* Decode contents of MFC Command Queue Context Save/Restore Registers.
2424  See "Cell Broadband Engine Registers V1.3", section 3.3.2.1. */
2425 
2426  mfc_cq_dw0
2427  = extract_unsigned_integer (buf + 32*seq[i], 8, byte_order);
2428  mfc_cq_dw1
2429  = extract_unsigned_integer (buf + 32*seq[i] + 8, 8, byte_order);
2430  mfc_cq_dw2
2431  = extract_unsigned_integer (buf + 32*seq[i] + 16, 8, byte_order);
2432 
2433  list_lsa = spu_mfc_get_bitfield (mfc_cq_dw0, 0, 14);
2434  list_size = spu_mfc_get_bitfield (mfc_cq_dw0, 15, 26);
2435  mfc_cmd_opcode = spu_mfc_get_bitfield (mfc_cq_dw0, 27, 34);
2436  mfc_cmd_tag = spu_mfc_get_bitfield (mfc_cq_dw0, 35, 39);
2437  list_valid_p = spu_mfc_get_bitfield (mfc_cq_dw0, 40, 40);
2438  rclass_id = spu_mfc_get_bitfield (mfc_cq_dw0, 41, 43);
2439  tclass_id = spu_mfc_get_bitfield (mfc_cq_dw0, 44, 46);
2440 
2441  mfc_ea = spu_mfc_get_bitfield (mfc_cq_dw1, 0, 51) << 12
2442  | spu_mfc_get_bitfield (mfc_cq_dw2, 25, 36);
2443 
2444  mfc_lsa = spu_mfc_get_bitfield (mfc_cq_dw2, 0, 13);
2445  mfc_size = spu_mfc_get_bitfield (mfc_cq_dw2, 14, 24);
2446  noop_valid_p = spu_mfc_get_bitfield (mfc_cq_dw2, 37, 37);
2447  qw_valid_p = spu_mfc_get_bitfield (mfc_cq_dw2, 38, 38);
2448  ea_valid_p = spu_mfc_get_bitfield (mfc_cq_dw2, 39, 39);
2449  cmd_error_p = spu_mfc_get_bitfield (mfc_cq_dw2, 40, 40);
2450 
2452 
2453  if (spu_mfc_opcode[mfc_cmd_opcode])
2454  ui_out_field_string (current_uiout, "opcode", spu_mfc_opcode[mfc_cmd_opcode]);
2455  else
2456  ui_out_field_int (current_uiout, "opcode", mfc_cmd_opcode);
2457 
2458  ui_out_field_int (current_uiout, "tag", mfc_cmd_tag);
2459  ui_out_field_int (current_uiout, "tid", tclass_id);
2460  ui_out_field_int (current_uiout, "rid", rclass_id);
2461 
2462  if (ea_valid_p)
2463  ui_out_field_fmt (current_uiout, "ea", "0x%s", phex (mfc_ea, 8));
2464  else
2466 
2467  ui_out_field_fmt (current_uiout, "lsa", "0x%05x", mfc_lsa << 4);
2468  if (qw_valid_p)
2469  ui_out_field_fmt (current_uiout, "size", "0x%05x", mfc_size << 4);
2470  else
2471  ui_out_field_fmt (current_uiout, "size", "0x%05x", mfc_size);
2472 
2473  if (list_valid_p)
2474  {
2475  ui_out_field_fmt (current_uiout, "lstaddr", "0x%05x", list_lsa << 3);
2476  ui_out_field_fmt (current_uiout, "lstsize", "0x%05x", list_size << 3);
2477  }
2478  else
2479  {
2480  ui_out_field_skip (current_uiout, "lstaddr");
2481  ui_out_field_skip (current_uiout, "lstsize");
2482  }
2483 
2484  if (cmd_error_p)
2485  ui_out_field_string (current_uiout, "error_p", "*");
2486  else
2487  ui_out_field_skip (current_uiout, "error_p");
2488 
2489  do_cleanups (cmd_chain);
2490 
2492  printf_filtered ("\n");
2493  }
2494 
2495  do_cleanups (chain);
2496 }
2497 
2498 static void
2499 info_spu_dma_command (char *args, int from_tty)
2500 {
2501  struct frame_info *frame = get_selected_frame (NULL);
2502  struct gdbarch *gdbarch = get_frame_arch (frame);
2503  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2504  ULONGEST dma_info_type;
2505  ULONGEST dma_info_mask;
2506  ULONGEST dma_info_status;
2507  ULONGEST dma_info_stall_and_notify;
2508  ULONGEST dma_info_atomic_command_status;
2509  struct cleanup *chain;
2510  char annex[32];
2511  gdb_byte buf[1024];
2512  LONGEST len;
2513  int id;
2514 
2515  if (gdbarch_bfd_arch_info (get_frame_arch (frame))->arch != bfd_arch_spu)
2516  error (_("\"info spu\" is only supported on the SPU architecture."));
2517 
2519 
2520  xsnprintf (annex, sizeof annex, "%d/dma_info", id);
2522  buf, 0, 40 + 16 * 32);
2523  if (len <= 0)
2524  error (_("Could not read dma_info."));
2525 
2526  dma_info_type
2527  = extract_unsigned_integer (buf, 8, byte_order);
2528  dma_info_mask
2529  = extract_unsigned_integer (buf + 8, 8, byte_order);
2530  dma_info_status
2531  = extract_unsigned_integer (buf + 16, 8, byte_order);
2532  dma_info_stall_and_notify
2533  = extract_unsigned_integer (buf + 24, 8, byte_order);
2534  dma_info_atomic_command_status
2535  = extract_unsigned_integer (buf + 32, 8, byte_order);
2536 
2537  chain = make_cleanup_ui_out_tuple_begin_end (current_uiout, "SPUInfoDMA");
2538 
2540  {
2541  ui_out_field_fmt (current_uiout, "dma_info_type", "0x%s",
2542  phex_nz (dma_info_type, 4));
2543  ui_out_field_fmt (current_uiout, "dma_info_mask", "0x%s",
2544  phex_nz (dma_info_mask, 4));
2545  ui_out_field_fmt (current_uiout, "dma_info_status", "0x%s",
2546  phex_nz (dma_info_status, 4));
2547  ui_out_field_fmt (current_uiout, "dma_info_stall_and_notify", "0x%s",
2548  phex_nz (dma_info_stall_and_notify, 4));
2549  ui_out_field_fmt (current_uiout, "dma_info_atomic_command_status", "0x%s",
2550  phex_nz (dma_info_atomic_command_status, 4));
2551  }
2552  else
2553  {
2554  const char *query_msg = _("no query pending");
2555 
2556  if (dma_info_type & 4)
2557  switch (dma_info_type & 3)
2558  {
2559  case 1: query_msg = _("'any' query pending"); break;
2560  case 2: query_msg = _("'all' query pending"); break;
2561  default: query_msg = _("undefined query type"); break;
2562  }
2563 
2564  printf_filtered (_("Tag-Group Status 0x%s\n"),
2565  phex (dma_info_status, 4));
2566  printf_filtered (_("Tag-Group Mask 0x%s (%s)\n"),
2567  phex (dma_info_mask, 4), query_msg);
2568  printf_filtered (_("Stall-and-Notify 0x%s\n"),
2569  phex (dma_info_stall_and_notify, 4));
2570  printf_filtered (_("Atomic Cmd Status 0x%s\n"),
2571  phex (dma_info_atomic_command_status, 4));
2572  printf_filtered ("\n");
2573  }
2574 
2575  info_spu_dma_cmdlist (buf + 40, 16, byte_order);
2576  do_cleanups (chain);
2577 }
2578 
2579 static void
2580 info_spu_proxydma_command (char *args, int from_tty)
2581 {
2582  struct frame_info *frame = get_selected_frame (NULL);
2583  struct gdbarch *gdbarch = get_frame_arch (frame);
2584  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2585  ULONGEST dma_info_type;
2586  ULONGEST dma_info_mask;
2587  ULONGEST dma_info_status;
2588  struct cleanup *chain;
2589  char annex[32];
2590  gdb_byte buf[1024];
2591  LONGEST len;
2592  int id;
2593 
2594  if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
2595  error (_("\"info spu\" is only supported on the SPU architecture."));
2596 
2598 
2599  xsnprintf (annex, sizeof annex, "%d/proxydma_info", id);
2601  buf, 0, 24 + 8 * 32);
2602  if (len <= 0)
2603  error (_("Could not read proxydma_info."));
2604 
2605  dma_info_type = extract_unsigned_integer (buf, 8, byte_order);
2606  dma_info_mask = extract_unsigned_integer (buf + 8, 8, byte_order);
2607  dma_info_status = extract_unsigned_integer (buf + 16, 8, byte_order);
2608 
2610  "SPUInfoProxyDMA");
2611 
2613  {
2614  ui_out_field_fmt (current_uiout, "proxydma_info_type", "0x%s",
2615  phex_nz (dma_info_type, 4));
2616  ui_out_field_fmt (current_uiout, "proxydma_info_mask", "0x%s",
2617  phex_nz (dma_info_mask, 4));
2618  ui_out_field_fmt (current_uiout, "proxydma_info_status", "0x%s",
2619  phex_nz (dma_info_status, 4));
2620  }
2621  else
2622  {
2623  const char *query_msg;
2624 
2625  switch (dma_info_type & 3)
2626  {
2627  case 0: query_msg = _("no query pending"); break;
2628  case 1: query_msg = _("'any' query pending"); break;
2629  case 2: query_msg = _("'all' query pending"); break;
2630  default: query_msg = _("undefined query type"); break;
2631  }
2632 
2633  printf_filtered (_("Tag-Group Status 0x%s\n"),
2634  phex (dma_info_status, 4));
2635  printf_filtered (_("Tag-Group Mask 0x%s (%s)\n"),
2636  phex (dma_info_mask, 4), query_msg);
2637  printf_filtered ("\n");
2638  }
2639 
2640  info_spu_dma_cmdlist (buf + 24, 8, byte_order);
2641  do_cleanups (chain);
2642 }
2643 
2644 static void
2645 info_spu_command (char *args, int from_tty)
2646 {
2647  printf_unfiltered (_("\"info spu\" must be followed by "
2648  "the name of an SPU facility.\n"));
2649  help_list (infospucmdlist, "info spu ", all_commands, gdb_stdout);
2650 }
2651 
2652 
2653 /* Root of all "set spu "/"show spu " commands. */
2654 
2655 static void
2656 show_spu_command (char *args, int from_tty)
2657 {
2658  help_list (showspucmdlist, "show spu ", all_commands, gdb_stdout);
2659 }
2660 
2661 static void
2662 set_spu_command (char *args, int from_tty)
2663 {
2664  help_list (setspucmdlist, "set spu ", all_commands, gdb_stdout);
2665 }
2666 
2667 static void
2668 show_spu_stop_on_load (struct ui_file *file, int from_tty,
2669  struct cmd_list_element *c, const char *value)
2670 {
2671  fprintf_filtered (file, _("Stopping for new SPE threads is %s.\n"),
2672  value);
2673 }
2674 
2675 static void
2676 show_spu_auto_flush_cache (struct ui_file *file, int from_tty,
2677  struct cmd_list_element *c, const char *value)
2678 {
2679  fprintf_filtered (file, _("Automatic software-cache flush is %s.\n"),
2680  value);
2681 }
2682 
2683 
2684 /* Set up gdbarch struct. */
2685 
2686 static struct gdbarch *
2687 spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2688 {
2689  struct gdbarch *gdbarch;
2690  struct gdbarch_tdep *tdep;
2691  int id = -1;
2692 
2693  /* Which spufs ID was requested as address space? */
2694  if (info.tdep_info)
2695  id = *(int *)info.tdep_info;
2696  /* For objfile architectures of SPU solibs, decode the ID from the name.
2697  This assumes the filename convention employed by solib-spu.c. */
2698  else if (info.abfd)
2699  {
2700  const char *name = strrchr (info.abfd->filename, '@');
2701  if (name)
2702  sscanf (name, "@0x%*x <%d>", &id);
2703  }
2704 
2705  /* Find a candidate among extant architectures. */
2706  for (arches = gdbarch_list_lookup_by_info (arches, &info);
2707  arches != NULL;
2708  arches = gdbarch_list_lookup_by_info (arches->next, &info))
2709  {
2710  tdep = gdbarch_tdep (arches->gdbarch);
2711  if (tdep && tdep->id == id)
2712  return arches->gdbarch;
2713  }
2714 
2715  /* None found, so create a new architecture. */
2716  tdep = XCNEW (struct gdbarch_tdep);
2717  tdep->id = id;
2718  gdbarch = gdbarch_alloc (&info, tdep);
2719 
2720  /* Disassembler. */
2722 
2723  /* Registers. */
2728  set_gdbarch_read_pc (gdbarch, spu_read_pc);
2738  (gdbarch, spu_ax_pseudo_register_collect);
2741 
2742  /* Data types. */
2743  set_gdbarch_char_signed (gdbarch, 0);
2744  set_gdbarch_ptr_bit (gdbarch, 32);
2745  set_gdbarch_addr_bit (gdbarch, 32);
2746  set_gdbarch_short_bit (gdbarch, 16);
2747  set_gdbarch_int_bit (gdbarch, 32);
2748  set_gdbarch_long_bit (gdbarch, 32);
2749  set_gdbarch_long_long_bit (gdbarch, 64);
2750  set_gdbarch_float_bit (gdbarch, 32);
2751  set_gdbarch_double_bit (gdbarch, 64);
2752  set_gdbarch_long_double_bit (gdbarch, 64);
2756 
2757  /* Address handling. */
2766 
2767 
2768  /* Inferior function calls. */
2771  set_gdbarch_frame_red_zone_size (gdbarch, 2000);
2776 
2777  /* Frame handling. */
2779  dwarf2_append_unwinders (gdbarch);
2780  frame_unwind_append_unwinder (gdbarch, &spu_frame_unwind);
2781  frame_base_set_default (gdbarch, &spu_frame_base);
2785  set_gdbarch_frame_args_skip (gdbarch, 0);
2788 
2789  /* Cell/B.E. cross-architecture unwinder support. */
2790  frame_unwind_prepend_unwinder (gdbarch, &spu2ppu_unwind);
2791 
2792  /* Breakpoints. */
2793  set_gdbarch_decr_pc_after_break (gdbarch, 4);
2798 
2799  /* Overlays. */
2801 
2802  return gdbarch;
2803 }
2804 
2805 /* Provide a prototype to silence -Wmissing-prototypes. */
2807 
2808 void
2810 {
2811  register_gdbarch_init (bfd_arch_spu, spu_gdbarch_init);
2812 
2813  /* Add ourselves to objfile event chain. */
2815  spu_overlay_data = register_objfile_data ();
2816 
2817  /* Install spu stop-on-load handler. */
2819 
2820  /* Add ourselves to normal_stop event chain. */
2822 
2823  /* Add root prefix command for all "set spu"/"show spu" commands. */
2825  _("Various SPU specific commands."),
2826  &setspucmdlist, "set spu ", 0, &setlist);
2828  _("Various SPU specific commands."),
2829  &showspucmdlist, "show spu ", 0, &showlist);
2830 
2831  /* Toggle whether or not to add a temporary breakpoint at the "main"
2832  function of new SPE contexts. */
2833  add_setshow_boolean_cmd ("stop-on-load", class_support,
2834  &spu_stop_on_load_p, _("\
2835 Set whether to stop for new SPE threads."),
2836  _("\
2837 Show whether to stop for new SPE threads."),
2838  _("\
2839 Use \"on\" to give control to the user when a new SPE thread\n\
2840 enters its \"main\" function.\n\
2841 Use \"off\" to disable stopping for new SPE threads."),
2842  NULL,
2844  &setspucmdlist, &showspucmdlist);
2845 
2846  /* Toggle whether or not to automatically flush the software-managed
2847  cache whenever SPE execution stops. */
2848  add_setshow_boolean_cmd ("auto-flush-cache", class_support,
2850 Set whether to automatically flush the software-managed cache."),
2851  _("\
2852 Show whether to automatically flush the software-managed cache."),
2853  _("\
2854 Use \"on\" to automatically flush the software-managed cache\n\
2855 whenever SPE execution stops.\n\
2856 Use \"off\" to never automatically flush the software-managed cache."),
2857  NULL,
2859  &setspucmdlist, &showspucmdlist);
2860 
2861  /* Add root prefix command for all "info spu" commands. */
2863  _("Various SPU specific commands."),
2864  &infospucmdlist, "info spu ", 0, &infolist);
2865 
2866  /* Add various "info spu" commands. */
2868  _("Display SPU event facility status.\n"),
2869  &infospucmdlist);
2871  _("Display SPU signal notification facility status.\n"),
2872  &infospucmdlist);
2874  _("Display SPU mailbox facility status.\n"),
2875  &infospucmdlist);
2877  _("Display MFC DMA status.\n"),
2878  &infospucmdlist);
2880  _("Display MFC Proxy-DMA status.\n"),
2881  &infospucmdlist);
2882 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:1909
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
Definition: gdbarch.c:1634
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
Definition: gdbarch.c:2935
void set_gdbarch_float_format(struct gdbarch *gdbarch, const struct floatformat **float_format)
Definition: gdbarch.c:1617
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static void info_spu_proxydma_command(char *args, int from_tty)
Definition: spu-tdep.c:2580
void set_gdbarch_address_class_type_flags_to_name(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_to_name_ftype address_class_type_flags_to_name)
Definition: gdbarch.c:3309
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
struct value * call_function_by_hand(struct value *function, int nargs, struct value **args)
Definition: infcall.c:488
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
#define SPUADDR(spu, addr)
Definition: spu-tdep.h:104
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype get_longjmp_target)
Definition: gdbarch.c:2390
struct value * frame_unwind_got_bytes(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame-unwind.c:255
#define OBSTACK_CALLOC(OBSTACK, NUMBER, TYPE)
Definition: gdb_obstack.h:30
static void spu_dis_asm_print_address(bfd_vma addr, struct disassemble_info *info)
Definition: spu-tdep.c:1726
bfd * obfd
Definition: objfiles.h:313
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
Definition: gdbarch.c:1601
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
static int is_ri7(unsigned int insn, int op, int *rt, int *ra, int *i7)
Definition: spu-tdep.c:562
static void spu_overlay_update_osect(struct obj_section *osect)
Definition: spu-tdep.c:1870
void ui_out_field_int(struct ui_out *uiout, const char *fldname, int value)
Definition: ui-out.c:467
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
struct type * builtin_void
Definition: gdbtypes.h:1570
static struct type * spu_register_type(struct gdbarch *gdbarch, int reg_nr)
Definition: spu-tdep.c:146
bfd_vma CORE_ADDR
Definition: common-types.h:41
static int spu_auto_flush_cache_p
Definition: spu-tdep.c:57
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1474
initialize_file_ftype _initialize_spu_tdep
void print_address(struct gdbarch *, CORE_ADDR, struct ui_file *)
Definition: printcmd.c:741
CORE_ADDR mapped_val
Definition: spu-tdep.c:1792
int reg_offset[SPU_NUM_GPRS]
Definition: spu-tdep.c:667
void ax_reg_mask(struct agent_expr *ax, int reg)
Definition: ax-general.c:438
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:135
void xfree(void *)
Definition: common-utils.c:97
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:74
static void spu_virtual_frame_pointer(struct gdbarch *gdbarch, CORE_ADDR pc, int *reg, LONGEST *offset)
Definition: spu-tdep.c:864
int trad_frame_addr_p(struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:77
static void show_spu_stop_on_load(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: spu-tdep.c:2668
int section_is_overlay(struct obj_section *section)
Definition: symfile.c:3089
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void(* func)(char *)
if(!(yy_init))
Definition: ada-lex.c:1072
static CORE_ADDR spu_read_pc(struct regcache *regcache)
Definition: spu-tdep.c:1179
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
Definition: trad-frame.c:92
#define SPUADDR_SPU(addr)
Definition: spu-tdep.h:107
struct gdbarch * gdbarch
Definition: spu-tdep.c:1721
static struct value * spu_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
Definition: spu-tdep.c:361
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
void set_gdbarch_overlay_update(struct gdbarch *gdbarch, gdbarch_overlay_update_ftype overlay_update)
Definition: gdbarch.c:3792
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype write_pc)
Definition: gdbarch.c:1802
CORE_ADDR mapped_ptr
Definition: spu-tdep.c:1791
LONGEST target_write(struct target_ops *ops, enum target_object object, const char *annex, const gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1894
static void show_spu_auto_flush_cache(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: spu-tdep.c:2676
static int spu_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: spu-tdep.c:901
static CORE_ADDR spu_frame_base_address(struct frame_info *this_frame, void **this_cache)
Definition: spu-tdep.c:1147
Definition: spu-tdep.c:511
struct cleanup * make_cleanup_ui_out_table_begin_end(struct ui_out *ui_out, int nr_cols, int nr_rows, const char *tblid)
Definition: ui-out.c:369
void set_gdbarch_integer_to_address(struct gdbarch *gdbarch, gdbarch_integer_to_address_ftype integer_to_address)
Definition: gdbarch.c:2532
static void spu_value_to_regcache(struct regcache *regcache, int regnum, struct type *type, const gdb_byte *in)
Definition: spu-tdep.c:1349
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1182
static void spu2ppu_dealloc_cache(struct frame_info *self, void *this_cache)
Definition: spu-tdep.c:1287
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
Definition: gdbarch.c:1483
static void spu_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: spu-tdep.c:271
struct ui_file * gdb_stdout
Definition: main.c:71
static void show_spu_command(char *args, int from_tty)
Definition: spu-tdep.c:2656
static const char * spu_register_name(struct gdbarch *gdbarch, int reg_nr)
Definition: spu-tdep.c:114
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
static void spu_catch_start(struct objfile *objfile)
Definition: spu-tdep.c:1952
static int is_ri16(unsigned int insn, int op, int *rt, int *i16)
Definition: spu-tdep.c:590
const struct objfile_type * objfile_type(struct objfile *objfile)
Definition: gdbtypes.c:4909
static CORE_ADDR spu_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: spu-tdep.c:470
CORE_ADDR get_frame_sp(struct frame_info *this_frame)
Definition: frame.c:2577
void set_gdbarch_frame_red_zone_size(struct gdbarch *gdbarch, int frame_red_zone_size)
Definition: gdbarch.c:2968
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
void set_gdbarch_ax_pseudo_register_collect(struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_collect_ftype ax_pseudo_register_collect)
Definition: gdbarch.c:1950
struct m32c_reg * pc
Definition: m32c-tdep.c:111
return_value_convention
Definition: defs.h:206
int ui_out_is_mi_like_p(struct ui_out *uiout)
Definition: ui-out.c:655
static ULONGEST spu_mfc_get_bitfield(ULONGEST word, int first, int last)
Definition: spu-tdep.c:2311
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype register_reggroup_p)
Definition: gdbarch.c:3350
struct regcache * frame_save_as_regcache(struct frame_info *this_frame)
Definition: frame.c:940
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
Definition: corefile.c:297
#define ON_STACK
Definition: inferior.h:258
#define ALL_OBJSECTIONS(objfile, osect)
Definition: objfiles.h:660
static void spu_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition: spu-tdep.c:1111
Definition: ax.h:95
void regcache_cooked_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:1028
struct type * arch_composite_type(struct gdbarch *gdbarch, char *name, enum type_code code)
Definition: gdbtypes.c:4682
static int is_ri18(unsigned int insn, int op, int *rt, int *i18)
Definition: spu-tdep.c:603
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
struct gdbarch_list * next
Definition: gdbarch.h:1543
struct reggroup *const restore_reggroup
Definition: reggroups.c:298
static CORE_ADDR spu_integer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: spu-tdep.c:486
void ax_reg(struct agent_expr *x, int reg)
Definition: ax-general.c:290
static struct gdbarch * spu_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: spu-tdep.c:2687
struct address_space * get_frame_address_space(struct frame_info *frame)
Definition: frame.c:2490
#define _(String)
Definition: gdb_locale.h:40
struct type * spu_builtin_type_vec128
Definition: spu-tdep.c:67
struct symtab_and_line find_function_start_sal(struct symbol *sym, int funfirstline)
Definition: symtab.c:3613
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
Definition: gdbarch.c:2110
struct gdbarch_tdep_info * tdep_info
Definition: gdbarch.h:1560
Definition: ui-out.h:40
static void info_spu_mailbox_command(char *args, int from_tty)
Definition: spu-tdep.c:2262
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
static enum register_status spu_pseudo_register_read_spu(struct regcache *regcache, const char *regname, gdb_byte *buf)
Definition: spu-tdep.c:185
void frame_unwind_prepend_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:64
void ui_out_field_fmt(struct ui_out *uiout, const char *fldname, const char *format,...)
Definition: ui-out.c:556
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
struct type * builtin_int32
Definition: gdbtypes.h:1518
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
static void spu_overlay_new_objfile(struct objfile *objfile)
Definition: spu-tdep.c:1916
void printf_filtered(const char *format,...)
Definition: utils.c:2388
static void info_spu_signal_command(char *args, int from_tty)
Definition: spu-tdep.c:2135
struct regcache * regcache_dup(struct regcache *src)
Definition: regcache.c:436
static int spu_ax_pseudo_register_push_stack(struct gdbarch *gdbarch, struct agent_expr *ax, int regnum)
Definition: spu-tdep.c:336
#define obj_section_addr(s)
Definition: objfiles.h:135
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:402
struct obstack objfile_obstack
Definition: objfiles.h:328
void set_gdbarch_addr_bit(struct gdbarch *gdbarch, int addr_bit)
Definition: gdbarch.c:1718
struct reggroup *const float_reggroup
Definition: reggroups.c:293
struct cmd_list_element * infolist
Definition: cli-cmds.c:107
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:94
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
static const gdb_byte * spu_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: spu-tdep.c:1575
struct type * builtin_int128
Definition: gdbtypes.h:1522
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
Definition: gdbarch.c:1891
static const char * spu_address_class_type_flags_to_name(struct gdbarch *gdbarch, int type_flags)
Definition: spu-tdep.c:439
static void spu_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition: spu-tdep.c:461
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2151
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
struct reggroup *const general_reggroup
Definition: reggroups.c:292
#define SPU_OVERLAY_LMA
Definition: spu-tdep.h:115
static struct spu_overlay_table * spu_get_overlay_table(struct objfile *objfile)
Definition: spu-tdep.c:1799
void ui_out_field_skip(struct ui_out *uiout, const char *fldname)
Definition: ui-out.c:528
static CORE_ADDR spu_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc, CORE_ADDR end_pc, struct spu_prologue_data *data)
Definition: spu-tdep.c:671
static struct objfile * spu_objfile_from_frame(struct frame_info *frame)
Definition: spu-tdep.c:2016
struct target_ops current_target
void initialize_file_ftype(void)
Definition: defs.h:281
struct cleanup * make_cleanup_ui_out_tuple_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:451
static int spu_address_class_name_to_type_flags(struct gdbarch *gdbarch, const char *name, int *type_flags_ptr)
Definition: spu-tdep.c:448
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
register_status
Definition: regcache.h:50
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype stack_frame_destroyed_p)
Definition: gdbarch.c:3135
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
static void info_spu_event_command(char *args, int from_tty)
Definition: spu-tdep.c:2084
bfd * abfd
Definition: gdbarch.h:1557
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
Definition: gdbarch.c:2764
static int is_ri10(unsigned int insn, int op, int *rt, int *ra, int *i10)
Definition: spu-tdep.c:576
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
#define SPU_NUM_REGS
Definition: spu-tdep.h:23
static int spu_software_single_step(struct frame_info *frame)
Definition: spu-tdep.c:1621
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
struct_return
Definition: arm-tdep.h:148
void set_gdbarch_address_to_pointer(struct gdbarch *gdbarch, gdbarch_address_to_pointer_ftype address_to_pointer)
Definition: gdbarch.c:2508
#define TYPE_VECTOR(t)
Definition: gdbtypes.h:287
void insert_single_step_breakpoint(struct gdbarch *gdbarch, struct address_space *aspace, CORE_ADDR next_pc)
Definition: breakpoint.c:14816
struct type * builtin_int16
Definition: gdbtypes.h:1516
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
#define MSYMBOL_SIZE(msymbol)
Definition: symtab.h:374
static void info_spu_dma_command(char *args, int from_tty)
Definition: spu-tdep.c:2499
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
struct obj_section * sections
Definition: objfiles.h:386
Definition: gdbtypes.h:749
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
const char * word
Definition: symtab.h:1448
struct type * init_vector_type(struct type *elt_type, int n)
Definition: gdbtypes.c:1229
static const struct frame_unwind spu_frame_unwind
Definition: spu-tdep.c:1137
#define SPU_NUM_GPRS
Definition: spu-tdep.h:25
void set_gdbarch_value_from_register(struct gdbarch *gdbarch, gdbarch_value_from_register_ftype value_from_register)
Definition: gdbarch.c:2474
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
Definition: gdbarch.c:2863
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
Definition: gdbarch.c:2672
struct type * builtin_uint32
Definition: gdbtypes.h:1519
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:170
static const char * type
Definition: language.c:103
static CORE_ADDR spu_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
Definition: spu-tdep.c:1308
static CORE_ADDR spu_push_dummy_code(struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
Definition: spu-tdep.c:1314
void set_value_offset(struct value *value, int offset)
Definition: value.c:1037
static struct value * spu2ppu_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: spu-tdep.c:1224
struct compunit_symtab * find_pc_sect_compunit_symtab(CORE_ADDR pc, struct obj_section *section)
Definition: symtab.c:2935
#define symfile_objfile
Definition: progspace.h:216
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:690
void set_gdbarch_read_pc(struct gdbarch *gdbarch, gdbarch_read_pc_ftype read_pc)
Definition: gdbarch.c:1778
void set_gdbarch_pointer_to_address(struct gdbarch *gdbarch, gdbarch_pointer_to_address_ftype pointer_to_address)
Definition: gdbarch.c:2491
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
Definition: gdbarch.c:2887
struct regcache * regcache
Definition: spu-tdep.c:1205
ULONGEST strtoulst(const char *num, const char **trailer, int base)
Definition: common-utils.c:188
static void info_spu_command(char *args, int from_tty)
Definition: spu-tdep.c:2645
struct symbol * block_lookup_symbol(const struct block *block, const char *name, const domain_enum domain)
Definition: block.c:734
struct gdbarch * gdbarch
Definition: gdbarch.h:1542
void set_gdbarch_ax_pseudo_register_push_stack(struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_push_stack_ftype ax_pseudo_register_push_stack)
Definition: gdbarch.c:1974
int regnum
Definition: aarch64-tdep.c:69
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
#define TYPE_ADDRESS_CLASS_1(t)
Definition: gdbtypes.h:397
CORE_ADDR local_base
Definition: spu-tdep.c:985
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
struct breakpoint_ops bkpt_breakpoint_ops
Definition: breakpoint.c:313
void * xmalloc(YYSIZE_T)
struct type * builtin_uint128
Definition: gdbtypes.h:1523
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
Definition: gdbarch.c:2839
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition: gdbarch.c:1534
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2797
static int spu_get_longjmp_target(struct frame_info *frame, CORE_ADDR *pc)
Definition: spu-tdep.c:1693
Definition: regdef.h:22
static int gdb_print_insn_spu(bfd_vma memaddr, struct disassemble_info *info)
Definition: spu-tdep.c:1733
static int spu_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
Definition: spu-tdep.c:380
static struct frame_id spu_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: spu-tdep.c:1497
Definition: block.h:60
Definition: value.c:172
static enum return_value_convention spu_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *out, const gdb_byte *in)
Definition: spu-tdep.c:1508
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype software_single_step)
Definition: gdbarch.c:3026
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:70
static void set_spu_command(char *args, int from_tty)
Definition: spu-tdep.c:2662
void set_gdbarch_push_dummy_code(struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype push_dummy_code)
Definition: gdbarch.c:2257
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
Definition: trad-frame.c:52
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1099
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1809
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:138
bfd_byte gdb_byte
Definition: common-types.h:38
struct frame_id frame_id
Definition: spu-tdep.c:1204
struct frame_info * get_next_frame(struct frame_info *this_frame)
Definition: frame.c:1668
void append_composite_type_field(struct type *t, char *name, struct type *field)
Definition: gdbtypes.c:4757
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3490
static void print_frame(struct frame_info *frame, int print_level, enum print_what print_what, int print_args, struct symtab_and_line sal)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
Definition: gdbarch.c:1843
ULONGEST align_up(ULONGEST v, int n)
Definition: utils.c:2963
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
Definition: gdbarch.c:1754
int create_breakpoint(struct gdbarch *gdbarch, char *arg, char *cond_string, int thread, char *extra_string, int parse_arg, int tempflag, enum bptype type_wanted, int ignore_count, enum auto_boolean pending_break_support, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:9585
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
struct type * builtin_double
Definition: gdbtypes.h:1491
void set_gdbarch_address_class_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_type_flags_ftype address_class_type_flags)
Definition: gdbarch.c:3285
static int is_branch(unsigned int insn, int *offset, int *reg)
Definition: spu-tdep.c:616
static int spu_gdbarch_id(struct gdbarch *gdbarch)
Definition: spu-tdep.c:412
static void spu2ppu_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: spu-tdep.c:1216
static CORE_ADDR spu_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: spu-tdep.c:1171
static void spu_attach_normal_stop(struct bpstats *bs, int print_frame)
Definition: spu-tdep.c:2068
int default_memory_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: mem-break.c:79
void set_gdbarch_address_class_name_to_type_flags(struct gdbarch *gdbarch, gdbarch_address_class_name_to_type_flags_ftype address_class_name_to_type_flags)
Definition: gdbarch.c:3333
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
static struct gdbarch * spu2ppu_prev_arch(struct frame_info *this_frame, void **this_cache)
Definition: spu-tdep.c:1209
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:637
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
static void spu_pseudo_register_write_spu(struct regcache *regcache, const char *regname, const gdb_byte *buf)
Definition: spu-tdep.c:253
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct obj_section * sections_end
Definition: objfiles.h:386
static int spu_scalar_value_p(struct type *type)
Definition: spu-tdep.c:1330
ptid_t inferior_ptid
Definition: infcmd.c:124
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
#define TYPE_CALLING_CONVENTION(thistype)
Definition: gdbtypes.h:1323
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition: gdbarch.c:1500
struct minimal_symbol * minsym
Definition: minsyms.h:32
static int spu_address_class_type_flags(int byte_size, int dwarf2_addr_class)
Definition: spu-tdep.c:430
static struct value * spu_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
Definition: spu-tdep.c:1124
CORE_ADDR frame_base
Definition: spu-tdep.c:984
static int spu_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
Definition: spu-tdep.c:402
int offset
Definition: agent.c:65
void set_gdbarch_virtual_frame_pointer(struct gdbarch *gdbarch, gdbarch_virtual_frame_pointer_ftype virtual_frame_pointer)
Definition: gdbarch.c:1819
static struct spu_unwind_cache * spu_frame_unwind_cache(struct frame_info *this_frame, void **this_prologue_cache)
Definition: spu-tdep.c:991
void get_frame_register(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame.c:1085
struct objfile * objfile
Definition: objfiles.h:124
struct value * default_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
Definition: findvar.c:626
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition: gdbarch.c:1926
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
static int spu_stop_on_load_p
Definition: spu-tdep.c:55
static void spu_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: spu-tdep.c:1189
static CORE_ADDR spu_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: spu-tdep.c:1162
void ui_out_table_header(struct ui_out *uiout, int width, enum ui_align alignment, const char *col_name, const char *colhdr)
Definition: ui-out.c:346
CORE_ADDR pc
Definition: symtab.h:1376
static void spu_overlay_update(struct obj_section *osect)
Definition: spu-tdep.c:1894
struct m32c_reg * sp
Definition: m32c-tdep.c:114
void regcache_xfree(struct regcache *regcache)
Definition: regcache.c:247
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
Definition: gdbarch.c:1650
void set_gdbarch_memory_remove_breakpoint(struct gdbarch *gdbarch, gdbarch_memory_remove_breakpoint_ftype memory_remove_breakpoint)
Definition: gdbarch.c:2747
static void info_spu_mailbox_list(gdb_byte *buf, int nr, enum bfd_endian byte_order, const char *field, const char *msg)
Definition: spu-tdep.c:2231
struct inferior * current_inferior(void)
Definition: inferior.c:57
#define SPU_NUM_PSEUDO_REGS
Definition: spu-tdep.h:24
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
Definition: frame.c:1274
static void spu_regcache_to_value(struct regcache *regcache, int regnum, struct type *type, gdb_byte *out)
Definition: spu-tdep.c:1374
void set_gdbarch_call_dummy_location(struct gdbarch *gdbarch, int call_dummy_location)
Definition: gdbarch.c:2233
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
static int is_rr(unsigned int insn, int op, int *rt, int *ra, int *rb)
Definition: spu-tdep.c:533
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
struct observer * observer_attach_normal_stop(observer_normal_stop_ftype *f)
struct observer * observer_attach_new_objfile(observer_new_objfile_ftype *f)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
static int spu_memory_remove_breakpoint(struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: spu-tdep.c:1585
struct type * value_type(const struct value *value)
Definition: value.c:1021
static const struct objfile_data * spu_overlay_data
Definition: spu-tdep.c:1787
struct type * builtin_int64
Definition: gdbtypes.h:1520
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1517
enum register_status regcache_cooked_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
Definition: regcache.c:1017
Definition: symtab.h:703
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1590
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition: gdbarch.c:1683
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
Definition: reggroups.c:184
struct reggroup *const save_reggroup
Definition: reggroups.c:297
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition: gdbarch.c:1700
void ui_out_table_body(struct ui_out *uiout)
Definition: ui-out.c:309
struct objfile * objfile
Definition: minsyms.h:37
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
CORE_ADDR func
Definition: spu-tdep.c:983
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
static CORE_ADDR spu_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: spu-tdep.c:1399
struct ui_out * current_uiout
Definition: ui-out.c:233
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
Definition: gdbarch.c:4975
int ovly_mapped
Definition: objfiles.h:127
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2590
struct type * builtin_int8
Definition: gdbtypes.h:1514
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
struct trad_frame_saved_reg * saved_regs
Definition: spu-tdep.c:987
enum bfd_endian byte_order
Definition: gdbarch.c:128
static int spu_ax_pseudo_register_collect(struct gdbarch *gdbarch, struct agent_expr *ax, int regnum)
Definition: spu-tdep.c:314
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2008
int has_stack_frames(void)
Definition: frame.c:1506
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
Definition: gdbarch.c:2127
static enum register_status spu_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: spu-tdep.c:210
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
Definition: gdbarch.c:339
#define SPUADDR_ADDR(addr)
Definition: spu-tdep.h:112
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
Definition: gdbarch.c:2655
static struct type * spu_builtin_type_vec128(struct gdbarch *gdbarch)
Definition: spu-tdep.c:73
static void flush_ea_cache(void)
Definition: spu-tdep.c:2037
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
#define FRAME_OBSTACK_CALLOC(NUMBER, TYPE)
Definition: frame.h:662
void throw_error(enum errors error, const char *fmt,...)
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:930
struct regcache * get_thread_arch_regcache(ptid_t ptid, struct gdbarch *gdbarch)
Definition: regcache.c:508
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:482
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
static CORE_ADDR spu_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: spu-tdep.c:856
struct type * builtin_float
Definition: gdbtypes.h:1490
static int is_rrr(unsigned int insn, int op, int *rt, int *ra, int *rb, int *rc)
Definition: spu-tdep.c:547
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:885
const ULONGEST const LONGEST len
Definition: target.h:309
static void info_spu_dma_cmdlist(gdb_byte *buf, int nr, enum bfd_endian byte_order)
Definition: spu-tdep.c:2318
static int spu2ppu_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: spu-tdep.c:1237