gdb/score-tdep.c

   1 /* Target-dependent code for the S+core architecture, for GDB,
   2    the GNU Debugger.
   3
   4    Copyright (C) 2006-2015 Free Software Foundation, Inc.
   5
   6    Contributed by Qinwei (qinwei@sunnorth.com.cn)
   7    Contributed by Ching-Peng Lin (cplin@sunplus.com)
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "symtab.h"
  27 #include "objfiles.h"
  28 #include "gdbcore.h"
  29 #include "target.h"
  30 #include "arch-utils.h"
  31 #include "regcache.h"
  32 #include "regset.h"
  33 #include "dis-asm.h"
  34 #include "frame-unwind.h"
  35 #include "frame-base.h"
  36 #include "trad-frame.h"
  37 #include "dwarf2-frame.h"
  38 #include "score-tdep.h"
  39
  40 #define G_FLD(_i,_ms,_ls) \
  41     ((unsigned)((_i) << (31 - (_ms))) >> (31 - (_ms) + (_ls)))
  42
  43 typedef struct{
  44   unsigned long long v;
  45   unsigned long long raw;
  46   unsigned int len;
  47 }inst_t;
  48
  49 struct score_frame_cache
  50 {
  51   CORE_ADDR base;
  52   CORE_ADDR fp;
  53   struct trad_frame_saved_reg *saved_regs;
  54 };
  55
  56 static int target_mach = bfd_mach_score7;
  57
  58 static struct type *
  59 score_register_type (struct gdbarch *gdbarch, int regnum)
  60 {
  61   gdb_assert (regnum >= 0
  62               && regnum < ((target_mach == bfd_mach_score7)
  63                            ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
  64   return builtin_type (gdbarch)->builtin_uint32;
  65 }
  66
  67 static CORE_ADDR
  68 score_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
  69 {
  70   return frame_unwind_register_unsigned (next_frame, SCORE_SP_REGNUM);
  71 }
  72
  73 static CORE_ADDR
  74 score_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
  75 {
  76   return frame_unwind_register_unsigned (next_frame, SCORE_PC_REGNUM);
  77 }
  78
  79 static const char *
  80 score7_register_name (struct gdbarch *gdbarch, int regnum)
  81 {
  82   const char *score_register_names[] = {
  83     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
  84     "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
  85     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
  86     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
  87
  88     "PSR",     "COND",  "ECR",     "EXCPVEC", "CCR",
  89     "EPC",     "EMA",   "TLBLOCK", "TLBPT",   "PEADDR",
  90     "TLBRPT",  "PEVN",  "PECTX",   "LIMPFN",  "LDMPFN",
  91     "PREV",    "DREG",  "PC",      "DSAVE",   "COUNTER",
  92     "LDCR",    "STCR",  "CEH",     "CEL",
  93   };
  94
  95   gdb_assert (regnum >= 0 && regnum < SCORE7_NUM_REGS);
  96   return score_register_names[regnum];
  97 }
  98
  99 static const char *
 100 score3_register_name (struct gdbarch *gdbarch, int regnum)
 101 {
 102   const char *score_register_names[] = {
 103     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
 104     "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
 105     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 106     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 107
 108     "PSR",      "COND",   "ECR",   "EXCPVEC",  "CCR",
 109     "EPC",      "EMA",    "PREV",  "DREG",     "DSAVE",
 110     "COUNTER",  "LDCR",   "STCR",  "CEH",      "CEL",
 111     "",         "",       "PC",
 112   };
 113
 114   gdb_assert (regnum >= 0 && regnum < SCORE3_NUM_REGS);
 115   return score_register_names[regnum];
 116 }
 117
 118 #if WITH_SIM
 119 static int
 120 score_register_sim_regno (struct gdbarch *gdbarch, int regnum)
 121 {
 122   gdb_assert (regnum >= 0
 123               && regnum < ((target_mach == bfd_mach_score7)
 124                            ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
 125   return regnum;
 126 }
 127 #endif
 128
 129 static int
 130 score_print_insn (bfd_vma memaddr, struct disassemble_info *info)
 131 {
 132   if (info->endian == BFD_ENDIAN_BIG)
 133     return print_insn_big_score (memaddr, info);
 134   else
 135     return print_insn_little_score (memaddr, info);
 136 }
 137
 138 static inst_t *
 139 score7_fetch_inst (struct gdbarch *gdbarch, CORE_ADDR addr, gdb_byte *memblock)
 140 {
 141   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 142   static inst_t inst = { 0, 0, 0 };
 143   gdb_byte buf[SCORE_INSTLEN] = { 0 };
 144   int big;
 145   int ret;
 146
 147   if (target_has_execution && memblock != NULL)
 148     {
 149       /* Fetch instruction from local MEMBLOCK.  */
 150       memcpy (buf, memblock, SCORE_INSTLEN);
 151     }
 152   else
 153     {
 154       /* Fetch instruction from target.  */
 155       ret = target_read_memory (addr & ~0x3, buf, SCORE_INSTLEN);
 156       if (ret)
 157         {
 158           error (_("Error: target_read_memory in file:%s, line:%d!"),
 159                   __FILE__, __LINE__);
 160           return 0;
 161         }
 162     }
 163
 164   inst.raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
 165   inst.len = (inst.raw & 0x80008000) ? 4 : 2;
 166   inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
 167   big = (byte_order == BFD_ENDIAN_BIG);
 168   if (inst.len == 2)
 169     {
 170       if (big ^ ((addr & 0x2) == 2))
 171         inst.v = G_FLD (inst.v, 29, 15);
 172       else
 173         inst.v = G_FLD (inst.v, 14, 0);
 174     }
 175   return &inst;
 176 }
 177
 178 static inst_t *
 179 score3_adjust_pc_and_fetch_inst (CORE_ADDR *pcptr, int *lenptr,
 180                                  enum bfd_endian byte_order)
 181 {
 182   static inst_t inst = { 0, 0, 0 };
 183
 184   struct breakplace
 185   {
 186     int break_offset;
 187     int inst_len;
 188   };
 189   /*     raw        table 1 (column 2, 3, 4)
 190     *  0  1  0  *   # 2
 191     *  0  1  1  0   # 3
 192     0  1  1  0  *   # 6
 193                     table 2 (column 1, 2, 3)
 194     *  0  0  *  *   # 0, 4
 195     0  1  0  *  *   # 2
 196     1  1  0  *  *   # 6
 197    */
 198
 199   static const struct breakplace bk_table[16] =
 200     {
 201       /* table 1 */
 202       {0, 0},
 203       {0, 0},
 204       {0, 4},
 205       {0, 6},
 206       {0, 0},
 207       {0, 0},
 208       {-2, 6},
 209       {0, 0},
 210       /* table 2 */
 211       {0, 2},
 212       {0, 0},
 213       {-2, 4},
 214       {0, 0},
 215       {0, 2},
 216       {0, 0},
 217       {-4, 6},
 218       {0, 0}
 219     };
 220
 221 #define EXTRACT_LEN 2
 222   CORE_ADDR adjust_pc = *pcptr & ~0x1;
 223   gdb_byte buf[5][EXTRACT_LEN] =
 224     {
 225       {'\0', '\0'},
 226       {'\0', '\0'},
 227       {'\0', '\0'},
 228       {'\0', '\0'},
 229       {'\0', '\0'}
 230     };
 231   int ret;
 232   unsigned int raw;
 233   unsigned int cbits = 0;
 234   int bk_index;
 235   int i, count;
 236
 237   inst.v = 0;
 238   inst.raw = 0;
 239   inst.len = 0;
 240
 241   adjust_pc -= 4;
 242   for (i = 0; i < 5; i++)
 243     {
 244       ret = target_read_memory (adjust_pc + 2 * i, buf[i], EXTRACT_LEN);
 245       if (ret != 0)
 246         {
 247           buf[i][0] = '\0';
 248           buf[i][1] = '\0';
 249           if (i == 2)
 250             error (_("Error: target_read_memory in file:%s, line:%d!"),
 251                    __FILE__, __LINE__);
 252         }
 253
 254       raw = extract_unsigned_integer (buf[i], EXTRACT_LEN, byte_order);
 255       cbits = (cbits << 1) | (raw >> 15);
 256     }
 257   adjust_pc += 4;
 258
 259   if (cbits & 0x4)
 260     {
 261       /* table 1 */
 262       cbits = (cbits >> 1) & 0x7;
 263       bk_index = cbits;
 264     }
 265   else
 266     {
 267       /* table 2 */
 268       cbits = (cbits >> 2) & 0x7;
 269       bk_index = cbits + 8;
 270     }
 271
 272   gdb_assert (!((bk_table[bk_index].break_offset == 0)
 273                 && (bk_table[bk_index].inst_len == 0)));
 274
 275   inst.len = bk_table[bk_index].inst_len;
 276
 277   i = (bk_table[bk_index].break_offset + 4) / 2;
 278   count = inst.len / 2;
 279   for (; count > 0; i++, count--)
 280     {
 281       inst.raw = (inst.raw << 16)
 282                  | extract_unsigned_integer (buf[i], EXTRACT_LEN, byte_order);
 283     }
 284
 285   switch (inst.len)
 286     {
 287     case 2:
 288       inst.v = inst.raw & 0x7FFF;
 289       break;
 290     case 4:
 291       inst.v = ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
 292       break;
 293     case 6:
 294       inst.v = ((inst.raw >> 32 & 0x7FFF) << 30)
 295                | ((inst.raw >> 16 & 0x7FFF) << 15) | (inst.raw & 0x7FFF);
 296       break;
 297     }
 298
 299   if (pcptr)
 300     *pcptr = adjust_pc + bk_table[bk_index].break_offset;
 301   if (lenptr)
 302     *lenptr = bk_table[bk_index].inst_len;
 303
 304 #undef EXTRACT_LEN
 305
 306   return &inst;
 307 }
 308
 309 static const gdb_byte *
 310 score7_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 311                            int *lenptr)
 312 {
 313   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 314   gdb_byte buf[SCORE_INSTLEN] = { 0 };
 315   int ret;
 316   unsigned int raw;
 317
 318   if ((ret = target_read_memory (*pcptr & ~0x3, buf, SCORE_INSTLEN)) != 0)
 319     {
 320       error (_("Error: target_read_memory in file:%s, line:%d!"),
 321              __FILE__, __LINE__);
 322     }
 323   raw = extract_unsigned_integer (buf, SCORE_INSTLEN, byte_order);
 324
 325   if (byte_order == BFD_ENDIAN_BIG)
 326     {
 327       if (!(raw & 0x80008000))
 328         {
 329           /* 16bits instruction.  */
 330           static gdb_byte big_breakpoint16[] = { 0x60, 0x02 };
 331           *pcptr &= ~0x1;
 332           *lenptr = sizeof (big_breakpoint16);
 333           return big_breakpoint16;
 334         }
 335       else
 336         {
 337           /* 32bits instruction.  */
 338           static gdb_byte big_breakpoint32[] = { 0x80, 0x00, 0x80, 0x06 };
 339           *pcptr &= ~0x3;
 340           *lenptr = sizeof (big_breakpoint32);
 341           return big_breakpoint32;
 342         }
 343     }
 344   else
 345     {
 346       if (!(raw & 0x80008000))
 347         {
 348           /* 16bits instruction.  */
 349           static gdb_byte little_breakpoint16[] = { 0x02, 0x60 };
 350           *pcptr &= ~0x1;
 351           *lenptr = sizeof (little_breakpoint16);
 352           return little_breakpoint16;
 353         }
 354       else
 355         {
 356           /* 32bits instruction.  */
 357           static gdb_byte little_breakpoint32[] = { 0x06, 0x80, 0x00, 0x80 };
 358           *pcptr &= ~0x3;
 359           *lenptr = sizeof (little_breakpoint32);
 360           return little_breakpoint32;
 361         }
 362     }
 363 }
 364
 365 static const gdb_byte *
 366 score3_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
 367                            int *lenptr)
 368 {
 369   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 370   CORE_ADDR adjust_pc = *pcptr;
 371   int len;
 372   static gdb_byte score_break_insns[6][6] = {
 373     /* The following three instructions are big endian.  */
 374     { 0x00, 0x20 },
 375     { 0x80, 0x00, 0x00, 0x06 },
 376     { 0x80, 0x00, 0x80, 0x00, 0x00, 0x00 },
 377     /* The following three instructions are little endian.  */
 378     { 0x20, 0x00 },
 379     { 0x00, 0x80, 0x06, 0x00 },
 380     { 0x00, 0x80, 0x00, 0x80, 0x00, 0x00 }};
 381
 382   gdb_byte *p = NULL;
 383   int index = 0;
 384
 385   score3_adjust_pc_and_fetch_inst (&adjust_pc, &len, byte_order);
 386
 387   index = ((byte_order == BFD_ENDIAN_BIG) ? 0 : 3) + (len / 2 - 1);
 388   p = score_break_insns[index];
 389
 390   *pcptr = adjust_pc;
 391   *lenptr = len;
 392
 393   return p;
 394 }
 395
 396 static CORE_ADDR
 397 score_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
 398 {
 399   CORE_ADDR adjust_pc = bpaddr;
 400
 401   if (target_mach == bfd_mach_score3)
 402     score3_adjust_pc_and_fetch_inst (&adjust_pc, NULL,
 403                                      gdbarch_byte_order (gdbarch));
 404   else
 405     adjust_pc = align_down (adjust_pc, 2);
 406
 407   return adjust_pc;
 408 }
 409
 410 static CORE_ADDR
 411 score_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
 412 {
 413   return align_down (addr, 16);
 414 }
 415
 416 static void
 417 score_xfer_register (struct regcache *regcache, int regnum, int length,
 418                      enum bfd_endian endian, gdb_byte *readbuf,
 419                      const gdb_byte *writebuf, int buf_offset)
 420 {
 421   int reg_offset = 0;
 422   gdb_assert (regnum >= 0
 423               && regnum < ((target_mach == bfd_mach_score7)
 424                            ? SCORE7_NUM_REGS : SCORE3_NUM_REGS));
 425
 426   switch (endian)
 427     {
 428     case BFD_ENDIAN_BIG:
 429       reg_offset = SCORE_REGSIZE - length;
 430       break;
 431     case BFD_ENDIAN_LITTLE:
 432       reg_offset = 0;
 433       break;
 434     case BFD_ENDIAN_UNKNOWN:
 435       reg_offset = 0;
 436       break;
 437     default:
 438       error (_("Error: score_xfer_register in file:%s, line:%d!"),
 439              __FILE__, __LINE__);
 440     }
 441
 442   if (readbuf != NULL)
 443     regcache_cooked_read_part (regcache, regnum, reg_offset, length,
 444                                readbuf + buf_offset);
 445   if (writebuf != NULL)
 446     regcache_cooked_write_part (regcache, regnum, reg_offset, length,
 447                                 writebuf + buf_offset);
 448 }
 449
 450 static enum return_value_convention
 451 score_return_value (struct gdbarch *gdbarch, struct value *function,
 452                     struct type *type, struct regcache *regcache,
 453                     gdb_byte * readbuf, const gdb_byte * writebuf)
 454 {
 455   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 456       || TYPE_CODE (type) == TYPE_CODE_UNION
 457       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
 458     return RETURN_VALUE_STRUCT_CONVENTION;
 459   else
 460     {
 461       int offset;
 462       int regnum;
 463       for (offset = 0, regnum = SCORE_A0_REGNUM;
 464            offset < TYPE_LENGTH (type);
 465            offset += SCORE_REGSIZE, regnum++)
 466         {
 467           int xfer = SCORE_REGSIZE;
 468
 469           if (offset + xfer > TYPE_LENGTH (type))
 470             xfer = TYPE_LENGTH (type) - offset;
 471           score_xfer_register (regcache, regnum, xfer,
 472                                gdbarch_byte_order(gdbarch),
 473                                readbuf, writebuf, offset);
 474         }
 475       return RETURN_VALUE_REGISTER_CONVENTION;
 476     }
 477 }
 478
 479 static struct frame_id
 480 score_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 481 {
 482   return frame_id_build (get_frame_register_unsigned (this_frame,
 483                                                       SCORE_SP_REGNUM),
 484                          get_frame_pc (this_frame));
 485 }
 486
 487 static int
 488 score_type_needs_double_align (struct type *type)
 489 {
 490   enum type_code typecode = TYPE_CODE (type);
 491
 492   if ((typecode == TYPE_CODE_INT && TYPE_LENGTH (type) == 8)
 493       || (typecode == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8))
 494     return 1;
 495   else if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
 496     {
 497       int i, n;
 498
 499       n = TYPE_NFIELDS (type);
 500       for (i = 0; i < n; i++)
 501         if (score_type_needs_double_align (TYPE_FIELD_TYPE (type, i)))
 502           return 1;
 503       return 0;
 504     }
 505   return 0;
 506 }
 507
 508 static CORE_ADDR
 509 score_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 510                        struct regcache *regcache, CORE_ADDR bp_addr,
 511                        int nargs, struct value **args, CORE_ADDR sp,
 512                        int struct_return, CORE_ADDR struct_addr)
 513 {
 514   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 515   int argnum;
 516   int argreg;
 517   int arglen = 0;
 518   CORE_ADDR stack_offset = 0;
 519   CORE_ADDR addr = 0;
 520
 521   /* Step 1, Save RA.  */
 522   regcache_cooked_write_unsigned (regcache, SCORE_RA_REGNUM, bp_addr);
 523
 524   /* Step 2, Make space on the stack for the args.  */
 525   struct_addr = align_down (struct_addr, 16);
 526   sp = align_down (sp, 16);
 527   for (argnum = 0; argnum < nargs; argnum++)
 528     arglen += align_up (TYPE_LENGTH (value_type (args[argnum])),
 529                         SCORE_REGSIZE);
 530   sp -= align_up (arglen, 16);
 531
 532   argreg = SCORE_BEGIN_ARG_REGNUM;
 533
 534   /* Step 3, Check if struct return then save the struct address to
 535      r4 and increase the stack_offset by 4.  */
 536   if (struct_return)
 537     {
 538       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
 539       stack_offset += SCORE_REGSIZE;
 540     }
 541
 542   /* Step 4, Load arguments:
 543      If arg length is too long (> 4 bytes), then split the arg and
 544      save every parts.  */
 545   for (argnum = 0; argnum < nargs; argnum++)
 546     {
 547       struct value *arg = args[argnum];
 548       struct type *arg_type = check_typedef (value_type (arg));
 549       enum type_code typecode = TYPE_CODE (arg_type);
 550       const gdb_byte *val = value_contents (arg);
 551       int downward_offset = 0;
 552       int odd_sized_struct_p;
 553       int arg_last_part_p = 0;
 554
 555       arglen = TYPE_LENGTH (arg_type);
 556       odd_sized_struct_p = (arglen > SCORE_REGSIZE
 557                             && arglen % SCORE_REGSIZE != 0);
 558
 559       /* If a arg should be aligned to 8 bytes (long long or double),
 560          the value should be put to even register numbers.  */
 561       if (score_type_needs_double_align (arg_type))
 562         {
 563           if (argreg & 1)
 564             argreg++;
 565         }
 566
 567       /* If sizeof a block < SCORE_REGSIZE, then Score GCC will chose
 568          the default "downward"/"upward" method:
 569
 570          Example:
 571
 572          struct struc
 573          {
 574            char a; char b; char c;
 575          } s = {'a', 'b', 'c'};
 576
 577          Big endian:    s = {X, 'a', 'b', 'c'}
 578          Little endian: s = {'a', 'b', 'c', X}
 579
 580          Where X is a hole.  */
 581
 582       if (gdbarch_byte_order(gdbarch) == BFD_ENDIAN_BIG
 583           && (typecode == TYPE_CODE_STRUCT
 584               || typecode == TYPE_CODE_UNION)
 585           && argreg > SCORE_LAST_ARG_REGNUM
 586           && arglen < SCORE_REGSIZE)
 587         downward_offset += (SCORE_REGSIZE - arglen);
 588
 589       while (arglen > 0)
 590         {
 591           int partial_len = arglen < SCORE_REGSIZE ? arglen : SCORE_REGSIZE;
 592           ULONGEST regval = extract_unsigned_integer (val, partial_len,
 593                                                       byte_order);
 594
 595           /* The last part of a arg should shift left when
 596              gdbarch_byte_order is BFD_ENDIAN_BIG.  */
 597           if (byte_order == BFD_ENDIAN_BIG
 598               && arg_last_part_p == 1
 599               && (typecode == TYPE_CODE_STRUCT
 600                   || typecode == TYPE_CODE_UNION))
 601             regval <<= ((SCORE_REGSIZE - partial_len) * TARGET_CHAR_BIT);
 602
 603           /* Always increase the stack_offset and save args to stack.  */
 604           addr = sp + stack_offset + downward_offset;
 605           write_memory (addr, val, partial_len);
 606
 607           if (argreg <= SCORE_LAST_ARG_REGNUM)
 608             {
 609               regcache_cooked_write_unsigned (regcache, argreg++, regval);
 610               if (arglen > SCORE_REGSIZE && arglen < SCORE_REGSIZE * 2)
 611                 arg_last_part_p = 1;
 612             }
 613
 614           val += partial_len;
 615           arglen -= partial_len;
 616           stack_offset += align_up (partial_len, SCORE_REGSIZE);
 617         }
 618     }
 619
 620   /* Step 5, Save SP.  */
 621   regcache_cooked_write_unsigned (regcache, SCORE_SP_REGNUM, sp);
 622
 623   return sp;
 624 }
 625
 626 static CORE_ADDR
 627 score7_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 628 {
 629   CORE_ADDR cpc = pc;
 630   int iscan = 32, stack_sub = 0;
 631   while (iscan-- > 0)
 632     {
 633       inst_t *inst = score7_fetch_inst (gdbarch, cpc, NULL);
 634       if (!inst)
 635         break;
 636       if ((inst->len == 4) && !stack_sub
 637           && (G_FLD (inst->v, 29, 25) == 0x1
 638               && G_FLD (inst->v, 24, 20) == 0x0))
 639         {
 640           /* addi r0, offset */
 641           stack_sub = cpc + SCORE_INSTLEN;
 642           pc = cpc + SCORE_INSTLEN;
 643         }
 644       else if ((inst->len == 4)
 645                && (G_FLD (inst->v, 29, 25) == 0x0)
 646                && (G_FLD (inst->v, 24, 20) == 0x2)
 647                && (G_FLD (inst->v, 19, 15) == 0x0)
 648                && (G_FLD (inst->v, 14, 10) == 0xF)
 649                && (G_FLD (inst->v, 9, 0) == 0x56))
 650         {
 651           /* mv r2, r0  */
 652           pc = cpc + SCORE_INSTLEN;
 653           break;
 654         }
 655       else if ((inst->len == 2)
 656                && (G_FLD (inst->v, 14, 12) == 0x0)
 657                && (G_FLD (inst->v, 11, 8) == 0x2)
 658                && (G_FLD (inst->v, 7, 4) == 0x0)
 659                && (G_FLD (inst->v, 3, 0) == 0x3))
 660         {
 661           /* mv! r2, r0 */
 662           pc = cpc + SCORE16_INSTLEN;
 663           break;
 664         }
 665       else if ((inst->len == 2)
 666                && ((G_FLD (inst->v, 14, 12) == 3)    /* j15 form */
 667                    || (G_FLD (inst->v, 14, 12) == 4) /* b15 form */
 668                    || (G_FLD (inst->v, 14, 12) == 0x0
 669                        && G_FLD (inst->v, 3, 0) == 0x4))) /* br! */
 670         break;
 671       else if ((inst->len == 4)
 672                && ((G_FLD (inst->v, 29, 25) == 2)    /* j32 form */
 673                    || (G_FLD (inst->v, 29, 25) == 4) /* b32 form */
 674                    || (G_FLD (inst->v, 29, 25) == 0x0
 675                        && G_FLD (inst->v, 6, 1) == 0x4)))  /* br */
 676         break;
 677
 678       cpc += (inst->len == 2) ? SCORE16_INSTLEN : SCORE_INSTLEN;
 679     }
 680   return pc;
 681 }
 682
 683 static CORE_ADDR
 684 score3_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 685 {
 686   CORE_ADDR cpc = pc;
 687   int iscan = 32, stack_sub = 0;
 688   while (iscan-- > 0)
 689     {
 690       inst_t *inst
 691         = score3_adjust_pc_and_fetch_inst (&cpc, NULL,
 692                                            gdbarch_byte_order (gdbarch));
 693
 694       if (!inst)
 695         break;
 696       if (inst->len == 4 && !stack_sub
 697           && (G_FLD (inst->v, 29, 25) == 0x1)
 698           && (G_FLD (inst->v, 19, 17) == 0x0)
 699           && (G_FLD (inst->v, 24, 20) == 0x0))
 700         {
 701           /* addi r0, offset */
 702           stack_sub = cpc + inst->len;
 703           pc = cpc + inst->len;
 704         }
 705       else if (inst->len == 4
 706                && (G_FLD (inst->v, 29, 25) == 0x0)
 707                && (G_FLD (inst->v, 24, 20) == 0x2)
 708                && (G_FLD (inst->v, 19, 15) == 0x0)
 709                && (G_FLD (inst->v, 14, 10) == 0xF)
 710                && (G_FLD (inst->v, 9, 0) == 0x56))
 711         {
 712           /* mv r2, r0  */
 713           pc = cpc + inst->len;
 714           break;
 715         }
 716       else if ((inst->len == 2)
 717                && (G_FLD (inst->v, 14, 10) == 0x10)
 718                && (G_FLD (inst->v, 9, 5) == 0x2)
 719                && (G_FLD (inst->v, 4, 0) == 0x0))
 720         {
 721           /* mv! r2, r0 */
 722           pc = cpc + inst->len;
 723           break;
 724         }
 725       else if (inst->len == 2
 726                && ((G_FLD (inst->v, 14, 12) == 3) /* b15 form */
 727                    || (G_FLD (inst->v, 14, 12) == 0x0
 728                        && G_FLD (inst->v, 11, 5) == 0x4))) /* br! */
 729         break;
 730       else if (inst->len == 4
 731                && ((G_FLD (inst->v, 29, 25) == 2)    /* j32 form */
 732                    || (G_FLD (inst->v, 29, 25) == 4))) /* b32 form */
 733         break;
 734
 735       cpc += inst->len;
 736     }
 737   return pc;
 738 }
 739
 740 static int
 741 score7_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
 742 {
 743   inst_t *inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
 744
 745   if (inst->v == 0x23)
 746     return 1;   /* mv! r0, r2 */
 747   else if (G_FLD (inst->v, 14, 12) == 0x2
 748            && G_FLD (inst->v, 3, 0) == 0xa)
 749     return 1;   /* pop! */
 750   else if (G_FLD (inst->v, 14, 12) == 0x0
 751            && G_FLD (inst->v, 7, 0) == 0x34)
 752     return 1;   /* br! r3 */
 753   else if (G_FLD (inst->v, 29, 15) == 0x2
 754            && G_FLD (inst->v, 6, 1) == 0x2b)
 755     return 1;   /* mv r0, r2 */
 756   else if (G_FLD (inst->v, 29, 25) == 0x0
 757            && G_FLD (inst->v, 6, 1) == 0x4
 758            && G_FLD (inst->v, 19, 15) == 0x3)
 759     return 1;   /* br r3 */
 760   else
 761     return 0;
 762 }
 763
 764 static int
 765 score3_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR cur_pc)
 766 {
 767   CORE_ADDR pc = cur_pc;
 768   inst_t *inst
 769     = score3_adjust_pc_and_fetch_inst (&pc, NULL,
 770                                        gdbarch_byte_order (gdbarch));
 771
 772   if (inst->len == 2
 773       && (G_FLD (inst->v, 14, 10) == 0x10)
 774       && (G_FLD (inst->v, 9, 5) == 0x0)
 775       && (G_FLD (inst->v, 4, 0) == 0x2))
 776     return 1;   /* mv! r0, r2 */
 777   else if (inst->len == 4
 778            && (G_FLD (inst->v, 29, 25) == 0x0)
 779            && (G_FLD (inst->v, 24, 20) == 0x2)
 780            && (G_FLD (inst->v, 19, 15) == 0x0)
 781            && (G_FLD (inst->v, 14, 10) == 0xF)
 782            && (G_FLD (inst->v, 9, 0) == 0x56))
 783     return 1;   /* mv r0, r2 */
 784   else if (inst->len == 2
 785            && (G_FLD (inst->v, 14, 12) == 0x0)
 786            && (G_FLD (inst->v, 11, 5) == 0x2))
 787     return 1;   /* pop! */
 788   else if (inst->len == 2
 789            && (G_FLD (inst->v, 14, 12) == 0x0)
 790            && (G_FLD (inst->v, 11, 7) == 0x0)
 791            && (G_FLD (inst->v, 6, 5) == 0x2))
 792     return 1;   /* rpop! */
 793   else if (inst->len == 2
 794            && (G_FLD (inst->v, 14, 12) == 0x0)
 795            && (G_FLD (inst->v, 11, 5) == 0x4)
 796            && (G_FLD (inst->v, 4, 0) == 0x3))
 797     return 1;   /* br! r3 */
 798   else if (inst->len == 4
 799            && (G_FLD (inst->v, 29, 25) == 0x0)
 800            && (G_FLD (inst->v, 24, 20) == 0x0)
 801            && (G_FLD (inst->v, 19, 15) == 0x3)
 802            && (G_FLD (inst->v, 14, 10) == 0xF)
 803            && (G_FLD (inst->v, 9, 0) == 0x8))
 804     return 1;   /* br r3 */
 805   else
 806     return 0;
 807 }
 808
 809 static gdb_byte *
 810 score7_malloc_and_get_memblock (CORE_ADDR addr, CORE_ADDR size)
 811 {
 812   int ret;
 813   gdb_byte *memblock = NULL;
 814
 815   if (size < 0)
 816     {
 817       error (_("Error: malloc size < 0 in file:%s, line:%d!"),
 818              __FILE__, __LINE__);
 819       return NULL;
 820     }
 821   else if (size == 0)
 822     return NULL;
 823
 824   memblock = xmalloc (size);
 825   memset (memblock, 0, size);
 826   ret = target_read_memory (addr & ~0x3, memblock, size);
 827   if (ret)
 828     {
 829       error (_("Error: target_read_memory in file:%s, line:%d!"),
 830              __FILE__, __LINE__);
 831       return NULL;
 832     }
 833   return memblock;
 834 }
 835
 836 static void
 837 score7_free_memblock (gdb_byte *memblock)
 838 {
 839   xfree (memblock);
 840 }
 841
 842 static void
 843 score7_adjust_memblock_ptr (gdb_byte **memblock, CORE_ADDR prev_pc,
 844                            CORE_ADDR cur_pc)
 845 {
 846   if (prev_pc == -1)
 847     {
 848       /* First time call this function, do nothing.  */
 849     }
 850   else if (cur_pc - prev_pc == 2 && (cur_pc & 0x3) == 0)
 851     {
 852       /* First 16-bit instruction, then 32-bit instruction.  */
 853       *memblock += SCORE_INSTLEN;
 854     }
 855   else if (cur_pc - prev_pc == 4)
 856     {
 857       /* Is 32-bit instruction, increase MEMBLOCK by 4.  */
 858       *memblock += SCORE_INSTLEN;
 859     }
 860 }
 861
 862 static void
 863 score7_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
 864                         struct frame_info *this_frame,
 865                         struct score_frame_cache *this_cache)
 866 {
 867   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 868   CORE_ADDR sp;
 869   CORE_ADDR fp;
 870   CORE_ADDR cur_pc = startaddr;
 871
 872   int sp_offset = 0;
 873   int ra_offset = 0;
 874   int fp_offset = 0;
 875   int ra_offset_p = 0;
 876   int fp_offset_p = 0;
 877   int inst_len = 0;
 878
 879   gdb_byte *memblock = NULL;
 880   gdb_byte *memblock_ptr = NULL;
 881   CORE_ADDR prev_pc = -1;
 882
 883   /* Allocate MEMBLOCK if PC - STARTADDR > 0.  */
 884   memblock_ptr = memblock =
 885     score7_malloc_and_get_memblock (startaddr, pc - startaddr);
 886
 887   sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
 888   fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
 889
 890   for (; cur_pc < pc; prev_pc = cur_pc, cur_pc += inst_len)
 891     {
 892       inst_t *inst = NULL;
 893       if (memblock != NULL)
 894         {
 895           /* Reading memory block from target succefully and got all
 896              the instructions(from STARTADDR to PC) needed.  */
 897           score7_adjust_memblock_ptr (&memblock, prev_pc, cur_pc);
 898           inst = score7_fetch_inst (gdbarch, cur_pc, memblock);
 899         }
 900       else
 901         {
 902           /* Otherwise, we fetch 4 bytes from target, and GDB also
 903              work correctly.  */
 904           inst = score7_fetch_inst (gdbarch, cur_pc, NULL);
 905         }
 906
 907       /* FIXME: make a full-power prologue analyzer.  */
 908       if (inst->len == 2)
 909         {
 910           inst_len = SCORE16_INSTLEN;
 911
 912           if (G_FLD (inst->v, 14, 12) == 0x2
 913               && G_FLD (inst->v, 3, 0) == 0xe)
 914             {
 915               /* push! */
 916               sp_offset += 4;
 917
 918               if (G_FLD (inst->v, 11, 7) == 0x6
 919                   && ra_offset_p == 0)
 920                 {
 921                   /* push! r3, [r0] */
 922                   ra_offset = sp_offset;
 923                   ra_offset_p = 1;
 924                 }
 925               else if (G_FLD (inst->v, 11, 7) == 0x4
 926                        && fp_offset_p == 0)
 927                 {
 928                   /* push! r2, [r0] */
 929                   fp_offset = sp_offset;
 930                   fp_offset_p = 1;
 931                 }
 932             }
 933           else if (G_FLD (inst->v, 14, 12) == 0x2
 934                    && G_FLD (inst->v, 3, 0) == 0xa)
 935             {
 936               /* pop! */
 937               sp_offset -= 4;
 938             }
 939           else if (G_FLD (inst->v, 14, 7) == 0xc1
 940                    && G_FLD (inst->v, 2, 0) == 0x0)
 941             {
 942               /* subei! r0, n */
 943               sp_offset += (int) pow (2, G_FLD (inst->v, 6, 3));
 944             }
 945           else if (G_FLD (inst->v, 14, 7) == 0xc0
 946                    && G_FLD (inst->v, 2, 0) == 0x0)
 947             {
 948               /* addei! r0, n */
 949               sp_offset -= (int) pow (2, G_FLD (inst->v, 6, 3));
 950             }
 951         }
 952       else
 953         {
 954           inst_len = SCORE_INSTLEN;
 955
 956           if (G_FLD(inst->v, 29, 25) == 0x3
 957               && G_FLD(inst->v, 2, 0) == 0x4
 958               && G_FLD(inst->v, 19, 15) == 0)
 959             {
 960                 /* sw rD, [r0, offset]+ */
 961                 sp_offset += SCORE_INSTLEN;
 962
 963                 if (G_FLD(inst->v, 24, 20) == 0x3)
 964                   {
 965                       /* rD = r3 */
 966                       if (ra_offset_p == 0)
 967                         {
 968                             ra_offset = sp_offset;
 969                             ra_offset_p = 1;
 970                         }
 971                   }
 972                 else if (G_FLD(inst->v, 24, 20) == 0x2)
 973                   {
 974                       /* rD = r2 */
 975                       if (fp_offset_p == 0)
 976                         {
 977                             fp_offset = sp_offset;
 978                             fp_offset_p = 1;
 979                         }
 980                   }
 981             }
 982           else if (G_FLD(inst->v, 29, 25) == 0x14
 983                    && G_FLD(inst->v, 19,15) == 0)
 984             {
 985                 /* sw rD, [r0, offset] */
 986                 if (G_FLD(inst->v, 24, 20) == 0x3)
 987                   {
 988                       /* rD = r3 */
 989                       ra_offset = sp_offset - G_FLD(inst->v, 14, 0);
 990                       ra_offset_p = 1;
 991                   }
 992                 else if (G_FLD(inst->v, 24, 20) == 0x2)
 993                   {
 994                       /* rD = r2 */
 995                       fp_offset = sp_offset - G_FLD(inst->v, 14, 0);
 996                       fp_offset_p = 1;
 997                   }
 998             }
 999           else if (G_FLD (inst->v, 29, 15) == 0x1c60
1000                    && G_FLD (inst->v, 2, 0) == 0x0)
1001             {
1002               /* lw r3, [r0]+, 4 */
1003               sp_offset -= SCORE_INSTLEN;
1004               ra_offset_p = 1;
1005             }
1006           else if (G_FLD (inst->v, 29, 15) == 0x1c40
1007                    && G_FLD (inst->v, 2, 0) == 0x0)
1008             {
1009               /* lw r2, [r0]+, 4 */
1010               sp_offset -= SCORE_INSTLEN;
1011               fp_offset_p = 1;
1012             }
1013
1014           else if (G_FLD (inst->v, 29, 17) == 0x100
1015                    && G_FLD (inst->v, 0, 0) == 0x0)
1016             {
1017               /* addi r0, -offset */
1018               sp_offset += 65536 - G_FLD (inst->v, 16, 1);
1019             }
1020           else if (G_FLD (inst->v, 29, 17) == 0x110
1021                    && G_FLD (inst->v, 0, 0) == 0x0)
1022             {
1023               /* addi r2, offset */
1024               if (pc - cur_pc > 4)
1025                 {
1026                   unsigned int save_v = inst->v;
1027                   inst_t *inst2 =
1028                     score7_fetch_inst (gdbarch, cur_pc + SCORE_INSTLEN, NULL);
1029                   if (inst2->v == 0x23)
1030                     {
1031                       /* mv! r0, r2 */
1032                       sp_offset -= G_FLD (save_v, 16, 1);
1033                     }
1034                 }
1035             }
1036         }
1037     }
1038
1039   /* Save RA.  */
1040   if (ra_offset_p == 1)
1041     {
1042       if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
1043         this_cache->saved_regs[SCORE_PC_REGNUM].addr =
1044           sp + sp_offset - ra_offset;
1045     }
1046   else
1047     {
1048       this_cache->saved_regs[SCORE_PC_REGNUM] =
1049         this_cache->saved_regs[SCORE_RA_REGNUM];
1050     }
1051
1052   /* Save FP.  */
1053   if (fp_offset_p == 1)
1054     {
1055       if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
1056         this_cache->saved_regs[SCORE_FP_REGNUM].addr =
1057           sp + sp_offset - fp_offset;
1058     }
1059
1060   /* Save SP and FP.  */
1061   this_cache->base = sp + sp_offset;
1062   this_cache->fp = fp;
1063
1064   /* Don't forget to free MEMBLOCK if we allocated it.  */
1065   if (memblock_ptr != NULL)
1066     score7_free_memblock (memblock_ptr);
1067 }
1068
1069 static void
1070 score3_analyze_prologue (CORE_ADDR startaddr, CORE_ADDR pc,
1071                         struct frame_info *this_frame,
1072                         struct score_frame_cache *this_cache)
1073 {
1074   CORE_ADDR sp;
1075   CORE_ADDR fp;
1076   CORE_ADDR cur_pc = startaddr;
1077   enum bfd_endian byte_order
1078     = gdbarch_byte_order (get_frame_arch (this_frame));
1079
1080   int sp_offset = 0;
1081   int ra_offset = 0;
1082   int fp_offset = 0;
1083   int ra_offset_p = 0;
1084   int fp_offset_p = 0;
1085   int inst_len = 0;
1086
1087   CORE_ADDR prev_pc = -1;
1088
1089   sp = get_frame_register_unsigned (this_frame, SCORE_SP_REGNUM);
1090   fp = get_frame_register_unsigned (this_frame, SCORE_FP_REGNUM);
1091
1092   for (; cur_pc < pc; prev_pc = cur_pc, cur_pc += inst_len)
1093     {
1094       inst_t *inst = NULL;
1095
1096       inst = score3_adjust_pc_and_fetch_inst (&cur_pc, &inst_len, byte_order);
1097
1098       /* FIXME: make a full-power prologue analyzer.  */
1099       if (inst->len == 2)
1100         {
1101           if (G_FLD (inst->v, 14, 12) == 0x0
1102               && G_FLD (inst->v, 11, 7) == 0x0
1103               && G_FLD (inst->v, 6, 5) == 0x3)
1104             {
1105               /* push! */
1106               sp_offset += 4;
1107
1108               if (G_FLD (inst->v, 4, 0) == 0x3
1109                   && ra_offset_p == 0)
1110                 {
1111                   /* push! r3, [r0] */
1112                   ra_offset = sp_offset;
1113                   ra_offset_p = 1;
1114                 }
1115               else if (G_FLD (inst->v, 4, 0) == 0x2
1116                        && fp_offset_p == 0)
1117                 {
1118                   /* push! r2, [r0] */
1119                   fp_offset = sp_offset;
1120                   fp_offset_p = 1;
1121                 }
1122             }
1123           else if (G_FLD (inst->v, 14, 12) == 0x6
1124                    && G_FLD (inst->v, 11, 10) == 0x3)
1125             {
1126               /* rpush! */
1127               int start_r = G_FLD (inst->v, 9, 5);
1128               int cnt = G_FLD (inst->v, 4, 0);
1129
1130               if ((ra_offset_p == 0)
1131                   && (start_r <= SCORE_RA_REGNUM)
1132                   && (SCORE_RA_REGNUM < start_r + cnt))
1133                 {
1134                   /* rpush! contains r3 */
1135                   ra_offset_p = 1;
1136                   ra_offset = sp_offset + 4 * (SCORE_RA_REGNUM - start_r) + 4;
1137                 }
1138
1139               if ((fp_offset_p == 0)
1140                   && (start_r <= SCORE_FP_REGNUM)
1141                   && (SCORE_FP_REGNUM < start_r + cnt))
1142                 {
1143                   /* rpush! contains r2 */
1144                   fp_offset_p = 1;
1145                   fp_offset = sp_offset + 4 * (SCORE_FP_REGNUM - start_r) + 4;
1146                 }
1147
1148               sp_offset += 4 * cnt;
1149             }
1150           else if (G_FLD (inst->v, 14, 12) == 0x0
1151                    && G_FLD (inst->v, 11, 7) == 0x0
1152                    && G_FLD (inst->v, 6, 5) == 0x2)
1153             {
1154               /* pop! */
1155               sp_offset -= 4;
1156             }
1157           else if (G_FLD (inst->v, 14, 12) == 0x6
1158                    && G_FLD (inst->v, 11, 10) == 0x2)
1159             {
1160               /* rpop! */
1161               sp_offset -= 4 * G_FLD (inst->v, 4, 0);
1162             }
1163           else if (G_FLD (inst->v, 14, 12) == 0x5
1164                    && G_FLD (inst->v, 11, 10) == 0x3
1165                    && G_FLD (inst->v, 9, 6) == 0x0)
1166             {
1167               /* addi! r0, -offset */
1168               int imm = G_FLD (inst->v, 5, 0);
1169               if (imm >> 5)
1170                 imm = -(0x3F - imm + 1);
1171               sp_offset -= imm;
1172             }
1173           else if (G_FLD (inst->v, 14, 12) == 0x5
1174                    && G_FLD (inst->v, 11, 10) == 0x3
1175                    && G_FLD (inst->v, 9, 6) == 0x2)
1176             {
1177               /* addi! r2, offset */
1178               if (pc - cur_pc >= 2)
1179                 {
1180                   unsigned int save_v = inst->v;
1181                   inst_t *inst2;
1182
1183                   cur_pc += inst->len;
1184                   inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL,
1185                                                            byte_order);
1186
1187                   if (inst2->len == 2
1188                       && G_FLD (inst2->v, 14, 10) == 0x10
1189                       && G_FLD (inst2->v, 9, 5) == 0x0
1190                       && G_FLD (inst2->v, 4, 0) == 0x2)
1191                     {
1192                       /* mv! r0, r2 */
1193                       int imm = G_FLD (inst->v, 5, 0);
1194                       if (imm >> 5)
1195                         imm = -(0x3F - imm + 1);
1196                       sp_offset -= imm;
1197                     }
1198                 }
1199             }
1200         }
1201       else if (inst->len == 4)
1202         {
1203           if (G_FLD (inst->v, 29, 25) == 0x3
1204               && G_FLD (inst->v, 2, 0) == 0x4
1205               && G_FLD (inst->v, 24, 20) == 0x3
1206               && G_FLD (inst->v, 19, 15) == 0x0)
1207             {
1208               /* sw r3, [r0, offset]+ */
1209               sp_offset += inst->len;
1210               if (ra_offset_p == 0)
1211                 {
1212                   ra_offset = sp_offset;
1213                   ra_offset_p = 1;
1214                 }
1215             }
1216           else if (G_FLD (inst->v, 29, 25) == 0x3
1217                    && G_FLD (inst->v, 2, 0) == 0x4
1218                    && G_FLD (inst->v, 24, 20) == 0x2
1219                    && G_FLD (inst->v, 19, 15) == 0x0)
1220             {
1221               /* sw r2, [r0, offset]+ */
1222               sp_offset += inst->len;
1223               if (fp_offset_p == 0)
1224                 {
1225                   fp_offset = sp_offset;
1226                   fp_offset_p = 1;
1227                 }
1228             }
1229           else if (G_FLD (inst->v, 29, 25) == 0x7
1230                    && G_FLD (inst->v, 2, 0) == 0x0
1231                    && G_FLD (inst->v, 24, 20) == 0x3
1232                    && G_FLD (inst->v, 19, 15) == 0x0)
1233             {
1234               /* lw r3, [r0]+, 4 */
1235               sp_offset -= inst->len;
1236               ra_offset_p = 1;
1237             }
1238           else if (G_FLD (inst->v, 29, 25) == 0x7
1239                    && G_FLD (inst->v, 2, 0) == 0x0
1240                    && G_FLD (inst->v, 24, 20) == 0x2
1241                    && G_FLD (inst->v, 19, 15) == 0x0)
1242             {
1243               /* lw r2, [r0]+, 4 */
1244               sp_offset -= inst->len;
1245               fp_offset_p = 1;
1246             }
1247           else if (G_FLD (inst->v, 29, 25) == 0x1
1248                    && G_FLD (inst->v, 19, 17) == 0x0
1249                    && G_FLD (inst->v, 24, 20) == 0x0
1250                    && G_FLD (inst->v, 0, 0) == 0x0)
1251             {
1252               /* addi r0, -offset */
1253               int imm = G_FLD (inst->v, 16, 1);
1254               if (imm >> 15)
1255                 imm = -(0xFFFF - imm + 1);
1256               sp_offset -= imm;
1257             }
1258           else if (G_FLD (inst->v, 29, 25) == 0x1
1259                    && G_FLD (inst->v, 19, 17) == 0x0
1260                    && G_FLD (inst->v, 24, 20) == 0x2
1261                    && G_FLD (inst->v, 0, 0) == 0x0)
1262             {
1263               /* addi r2, offset */
1264               if (pc - cur_pc >= 2)
1265                 {
1266                   unsigned int save_v = inst->v;
1267                   inst_t *inst2;
1268
1269                   cur_pc += inst->len;
1270                   inst2 = score3_adjust_pc_and_fetch_inst (&cur_pc, NULL,
1271                                                            byte_order);
1272
1273                   if (inst2->len == 2
1274                       && G_FLD (inst2->v, 14, 10) == 0x10
1275                       && G_FLD (inst2->v, 9, 5) == 0x0
1276                       && G_FLD (inst2->v, 4, 0) == 0x2)
1277                     {
1278                       /* mv! r0, r2 */
1279                       int imm = G_FLD (inst->v, 16, 1);
1280                       if (imm >> 15)
1281                         imm = -(0xFFFF - imm + 1);
1282                       sp_offset -= imm;
1283                     }
1284                 }
1285             }
1286         }
1287     }
1288
1289   /* Save RA.  */
1290   if (ra_offset_p == 1)
1291     {
1292       if (this_cache->saved_regs[SCORE_PC_REGNUM].addr == -1)
1293         this_cache->saved_regs[SCORE_PC_REGNUM].addr =
1294           sp + sp_offset - ra_offset;
1295     }
1296   else
1297     {
1298       this_cache->saved_regs[SCORE_PC_REGNUM] =
1299         this_cache->saved_regs[SCORE_RA_REGNUM];
1300     }
1301
1302   /* Save FP.  */
1303   if (fp_offset_p == 1)
1304     {
1305       if (this_cache->saved_regs[SCORE_FP_REGNUM].addr == -1)
1306         this_cache->saved_regs[SCORE_FP_REGNUM].addr =
1307           sp + sp_offset - fp_offset;
1308     }
1309
1310   /* Save SP and FP.  */
1311   this_cache->base = sp + sp_offset;
1312   this_cache->fp = fp;
1313 }
1314
1315 static struct score_frame_cache *
1316 score_make_prologue_cache (struct frame_info *this_frame, void **this_cache)
1317 {
1318   struct score_frame_cache *cache;
1319
1320   if ((*this_cache) != NULL)
1321     return (*this_cache);
1322
1323   cache = FRAME_OBSTACK_ZALLOC (struct score_frame_cache);
1324   (*this_cache) = cache;
1325   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1326
1327   /* Analyze the prologue.  */
1328   {
1329     const CORE_ADDR pc = get_frame_pc (this_frame);
1330     CORE_ADDR start_addr;
1331
1332     find_pc_partial_function (pc, NULL, &start_addr, NULL);
1333     if (start_addr == 0)
1334       return cache;
1335
1336     if (target_mach == bfd_mach_score3)
1337       score3_analyze_prologue (start_addr, pc, this_frame, *this_cache);
1338     else
1339       score7_analyze_prologue (start_addr, pc, this_frame, *this_cache);
1340   }
1341
1342   /* Save SP.  */
1343   trad_frame_set_value (cache->saved_regs, SCORE_SP_REGNUM, cache->base);
1344
1345   return (*this_cache);
1346 }
1347
1348 static void
1349 score_prologue_this_id (struct frame_info *this_frame, void **this_cache,
1350                         struct frame_id *this_id)
1351 {
1352   struct score_frame_cache *info = score_make_prologue_cache (this_frame,
1353                                                               this_cache);
1354   (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
1355 }
1356
1357 static struct value *
1358 score_prologue_prev_register (struct frame_info *this_frame,
1359                               void **this_cache, int regnum)
1360 {
1361   struct score_frame_cache *info = score_make_prologue_cache (this_frame,
1362                                                               this_cache);
1363   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1364 }
1365
1366 static const struct frame_unwind score_prologue_unwind =
1367 {
1368   NORMAL_FRAME,
1369   default_frame_unwind_stop_reason,
1370   score_prologue_this_id,
1371   score_prologue_prev_register,
1372   NULL,
1373   default_frame_sniffer,
1374   NULL
1375 };
1376
1377 static CORE_ADDR
1378 score_prologue_frame_base_address (struct frame_info *this_frame,
1379                                    void **this_cache)
1380 {
1381   struct score_frame_cache *info =
1382     score_make_prologue_cache (this_frame, this_cache);
1383   return info->fp;
1384 }
1385
1386 static const struct frame_base score_prologue_frame_base =
1387 {
1388   &score_prologue_unwind,
1389   score_prologue_frame_base_address,
1390   score_prologue_frame_base_address,
1391   score_prologue_frame_base_address,
1392 };
1393
1394 static const struct frame_base *
1395 score_prologue_frame_base_sniffer (struct frame_info *this_frame)
1396 {
1397   return &score_prologue_frame_base;
1398 }
1399
1400 /* Core file support.  */
1401
1402 static const struct regcache_map_entry score7_linux_gregmap[] =
1403   {
1404     /* FIXME: According to the current Linux kernel, r0 is preceded by
1405        9 rather than 7 words.  */
1406     { 7, REGCACHE_MAP_SKIP, 4 },
1407     { 32, 0, 4 },               /* r0 ... r31 */
1408     { 1, 55, 4 },               /* CEL */
1409     { 1, 54, 4 },               /* CEH */
1410     { 1, 53, 4 },               /* sr0, i.e. cnt or COUNTER */
1411     { 1, 52, 4 },               /* sr1, i.e. lcr or LDCR */
1412     { 1, 51, 4 },               /* sr2, i.e. scr or STCR */
1413     { 1, 49, 4 },               /* PC (same slot as EPC) */
1414     { 1, 38, 4 },               /* EMA */
1415     { 1, 32, 4 },               /* PSR */
1416     { 1, 34, 4 },               /* ECR */
1417     { 1, 33, 4 },               /* COND */
1418     { 0 }
1419   };
1420
1421 #define SCORE7_LINUX_EPC_OFFSET (44 * 4)
1422 #define SCORE7_LINUX_SIZEOF_GREGSET (49 * 4)
1423
1424 static void
1425 score7_linux_supply_gregset(const struct regset *regset,
1426                             struct regcache *regcache,
1427                             int regnum, const void *buf,
1428                             size_t size)
1429 {
1430   regcache_supply_regset (regset, regcache, regnum, buf, size);
1431
1432   /* Supply the EPC from the same slot as the PC.  Note that the
1433      collect function will store the PC in that slot.  */
1434   if ((regnum == -1 || regnum == SCORE_EPC_REGNUM)
1435       && size >= SCORE7_LINUX_EPC_OFFSET + 4)
1436     regcache_raw_supply (regcache, SCORE_EPC_REGNUM,
1437                          (const gdb_byte *) buf
1438                          + SCORE7_LINUX_EPC_OFFSET);
1439 }
1440
1441 static const struct regset score7_linux_gregset =
1442   {
1443     score7_linux_gregmap,
1444     score7_linux_supply_gregset,
1445     regcache_collect_regset
1446   };
1447
1448 /* Iterate over core file register note sections.  */
1449
1450 static void
1451 score7_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
1452                                            iterate_over_regset_sections_cb *cb,
1453                                            void *cb_data,
1454                                            const struct regcache *regcache)
1455 {
1456   cb (".reg", SCORE7_LINUX_SIZEOF_GREGSET, &score7_linux_gregset,
1457       NULL, cb_data);
1458 }
1459
1460 static struct gdbarch *
1461 score_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1462 {
1463   struct gdbarch *gdbarch;
1464   target_mach = info.bfd_arch_info->mach;
1465
1466   arches = gdbarch_list_lookup_by_info (arches, &info);
1467   if (arches != NULL)
1468     {
1469       return (arches->gdbarch);
1470     }
1471   gdbarch = gdbarch_alloc (&info, NULL);
1472
1473   set_gdbarch_short_bit (gdbarch, 16);
1474   set_gdbarch_int_bit (gdbarch, 32);
1475   set_gdbarch_float_bit (gdbarch, 32);
1476   set_gdbarch_double_bit (gdbarch, 64);
1477   set_gdbarch_long_double_bit (gdbarch, 64);
1478 #if WITH_SIM
1479   set_gdbarch_register_sim_regno (gdbarch, score_register_sim_regno);
1480 #endif
1481   set_gdbarch_pc_regnum (gdbarch, SCORE_PC_REGNUM);
1482   set_gdbarch_sp_regnum (gdbarch, SCORE_SP_REGNUM);
1483   set_gdbarch_adjust_breakpoint_address (gdbarch,
1484                                          score_adjust_breakpoint_address);
1485   set_gdbarch_register_type (gdbarch, score_register_type);
1486   set_gdbarch_frame_align (gdbarch, score_frame_align);
1487   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1488   set_gdbarch_unwind_sp (gdbarch, score_unwind_sp);
1489   set_gdbarch_unwind_pc (gdbarch, score_unwind_pc);
1490   set_gdbarch_print_insn (gdbarch, score_print_insn);
1491
1492   switch (target_mach)
1493     {
1494     case bfd_mach_score7:
1495       set_gdbarch_breakpoint_from_pc (gdbarch, score7_breakpoint_from_pc);
1496       set_gdbarch_skip_prologue (gdbarch, score7_skip_prologue);
1497       set_gdbarch_in_function_epilogue_p (gdbarch,
1498                                           score7_in_function_epilogue_p);
1499       set_gdbarch_register_name (gdbarch, score7_register_name);
1500       set_gdbarch_num_regs (gdbarch, SCORE7_NUM_REGS);
1501       /* Core file support.  */
1502       set_gdbarch_iterate_over_regset_sections
1503         (gdbarch, score7_linux_iterate_over_regset_sections);
1504       break;
1505
1506     case bfd_mach_score3:
1507       set_gdbarch_breakpoint_from_pc (gdbarch, score3_breakpoint_from_pc);
1508       set_gdbarch_skip_prologue (gdbarch, score3_skip_prologue);
1509       set_gdbarch_in_function_epilogue_p (gdbarch,
1510                                           score3_in_function_epilogue_p);
1511       set_gdbarch_register_name (gdbarch, score3_register_name);
1512       set_gdbarch_num_regs (gdbarch, SCORE3_NUM_REGS);
1513       break;
1514     }
1515
1516   /* Watchpoint hooks.  */
1517   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
1518
1519   /* Dummy frame hooks.  */
1520   set_gdbarch_return_value (gdbarch, score_return_value);
1521   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1522   set_gdbarch_dummy_id (gdbarch, score_dummy_id);
1523   set_gdbarch_push_dummy_call (gdbarch, score_push_dummy_call);
1524
1525   /* Normal frame hooks.  */
1526   dwarf2_append_unwinders (gdbarch);
1527   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
1528   frame_unwind_append_unwinder (gdbarch, &score_prologue_unwind);
1529   frame_base_append_sniffer (gdbarch, score_prologue_frame_base_sniffer);
1530
1531   return gdbarch;
1532 }
1533
1534 extern initialize_file_ftype _initialize_score_tdep;
1535
1536 void
1537 _initialize_score_tdep (void)
1538 {
1539   gdbarch_register (bfd_arch_score, score_gdbarch_init, NULL);
1540 }