gdb/spu-tdep.c

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