gdb/score-tdep.c

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