gdb/csky-tdep.c

   1 /* Target-dependent code for the CSKY architecture, for GDB.
   2
   3    Copyright (C) 2010-2022 Free Software Foundation, Inc.
   4
   5    Contributed by C-SKY Microsystems and Mentor Graphics.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "gdbsupport/gdb_assert.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "symtab.h"
  27 #include "value.h"
  28 #include "gdbcmd.h"
  29 #include "language.h"
  30 #include "gdbcore.h"
  31 #include "symfile.h"
  32 #include "objfiles.h"
  33 #include "gdbtypes.h"
  34 #include "target.h"
  35 #include "arch-utils.h"
  36 #include "regcache.h"
  37 #include "osabi.h"
  38 #include "block.h"
  39 #include "reggroups.h"
  40 #include "elf/csky.h"
  41 #include "elf-bfd.h"
  42 #include "symcat.h"
  43 #include "sim-regno.h"
  44 #include "dis-asm.h"
  45 #include "frame-unwind.h"
  46 #include "frame-base.h"
  47 #include "trad-frame.h"
  48 #include "infcall.h"
  49 #include "floatformat.h"
  50 #include "remote.h"
  51 #include "target-descriptions.h"
  52 #include "dwarf2/frame.h"
  53 #include "user-regs.h"
  54 #include "valprint.h"
  55 #include "csky-tdep.h"
  56 #include "regset.h"
  57 #include "opcode/csky.h"
  58 #include <algorithm>
  59 #include <vector>
  60
  61 /* Control debugging information emitted in this file.  */
  62
  63 static bool csky_debug = false;
  64
  65 static const reggroup *cr_reggroup;
  66 static const reggroup *fr_reggroup;
  67 static const reggroup *vr_reggroup;
  68 static const reggroup *mmu_reggroup;
  69 static const reggroup *prof_reggroup;
  70
  71 static const char *csky_supported_tdesc_feature_names[] = {
  72   (const char *)"org.gnu.csky.abiv2.gpr",
  73   (const char *)"org.gnu.csky.abiv2.fpu",
  74   (const char *)"org.gnu.csky.abiv2.cr",
  75   (const char *)"org.gnu.csky.abiv2.fvcr",
  76   (const char *)"org.gnu.csky.abiv2.mmu",
  77   (const char *)"org.gnu.csky.abiv2.tee",
  78   (const char *)"org.gnu.csky.abiv2.fpu2",
  79   (const char *)"org.gnu.csky.abiv2.bank0",
  80   (const char *)"org.gnu.csky.abiv2.bank1",
  81   (const char *)"org.gnu.csky.abiv2.bank2",
  82   (const char *)"org.gnu.csky.abiv2.bank3",
  83   (const char *)"org.gnu.csky.abiv2.bank4",
  84   (const char *)"org.gnu.csky.abiv2.bank5",
  85   (const char *)"org.gnu.csky.abiv2.bank6",
  86   (const char *)"org.gnu.csky.abiv2.bank7",
  87   (const char *)"org.gnu.csky.abiv2.bank8",
  88   (const char *)"org.gnu.csky.abiv2.bank9",
  89   (const char *)"org.gnu.csky.abiv2.bank10",
  90   (const char *)"org.gnu.csky.abiv2.bank11",
  91   (const char *)"org.gnu.csky.abiv2.bank12",
  92   (const char *)"org.gnu.csky.abiv2.bank13",
  93   (const char *)"org.gnu.csky.abiv2.bank14",
  94   (const char *)"org.gnu.csky.abiv2.bank15",
  95   (const char *)"org.gnu.csky.abiv2.bank16",
  96   (const char *)"org.gnu.csky.abiv2.bank17",
  97   (const char *)"org.gnu.csky.abiv2.bank18",
  98   (const char *)"org.gnu.csky.abiv2.bank19",
  99   (const char *)"org.gnu.csky.abiv2.bank20",
 100   (const char *)"org.gnu.csky.abiv2.bank21",
 101   (const char *)"org.gnu.csky.abiv2.bank22",
 102   (const char *)"org.gnu.csky.abiv2.bank23",
 103   (const char *)"org.gnu.csky.abiv2.bank24",
 104   (const char *)"org.gnu.csky.abiv2.bank25",
 105   (const char *)"org.gnu.csky.abiv2.bank26",
 106   (const char *)"org.gnu.csky.abiv2.bank27",
 107   (const char *)"org.gnu.csky.abiv2.bank28",
 108   (const char *)"org.gnu.csky.abiv2.bank29",
 109   (const char *)"org.gnu.csky.abiv2.bank30",
 110   (const char *)"org.gnu.csky.abiv2.bank31"
 111 };
 112
 113 struct csky_supported_tdesc_register
 114 {
 115   char name[16];
 116   int num;
 117 };
 118
 119 static const struct csky_supported_tdesc_register csky_supported_gpr_regs[] = {
 120   {"r0", 0},
 121   {"r1", 1},
 122   {"r2", 2},
 123   {"r3", 3},
 124   {"r4", 4},
 125   {"r5", 5},
 126   {"r6", 6},
 127   {"r7", 7},
 128   {"r8", 8},
 129   {"r9", 9},
 130   {"r10", 10},
 131   {"r11", 11},
 132   {"r12", 12},
 133   {"r13", 13},
 134   {"r14", 14},
 135   {"r15", 15},
 136   {"r16", 16},
 137   {"r17", 17},
 138   {"r18", 18},
 139   {"r19", 19},
 140   {"r20", 20},
 141   {"r21", 21},
 142   {"r22", 22},
 143   {"r23", 23},
 144   {"r24", 24},
 145   {"r25", 25},
 146   {"r26", 26},
 147   {"r27", 27},
 148   {"r28", 28},
 149   {"r28", 28},
 150   {"r29", 29},
 151   {"r30", 30},
 152   {"r31", 31},
 153   {"hi", CSKY_HI_REGNUM},
 154   {"lo", CSKY_LO_REGNUM},
 155   {"pc", CSKY_PC_REGNUM}
 156 };
 157
 158 static const struct csky_supported_tdesc_register csky_supported_fpu_regs[] = {
 159   /* fr0~fr15.  */
 160   {"fr0",  CSKY_FR0_REGNUM + 0},
 161   {"fr1",  CSKY_FR0_REGNUM + 1},
 162   {"fr2",  CSKY_FR0_REGNUM + 2},
 163   {"fr3",  CSKY_FR0_REGNUM + 3},
 164   {"fr4",  CSKY_FR0_REGNUM + 4},
 165   {"fr5",  CSKY_FR0_REGNUM + 5},
 166   {"fr6",  CSKY_FR0_REGNUM + 6},
 167   {"fr7",  CSKY_FR0_REGNUM + 7},
 168   {"fr8",  CSKY_FR0_REGNUM + 8},
 169   {"fr9",  CSKY_FR0_REGNUM + 9},
 170   {"fr10", CSKY_FR0_REGNUM + 10},
 171   {"fr11", CSKY_FR0_REGNUM + 11},
 172   {"fr12", CSKY_FR0_REGNUM + 12},
 173   {"fr13", CSKY_FR0_REGNUM + 13},
 174   {"fr14", CSKY_FR0_REGNUM + 14},
 175   {"fr15", CSKY_FR0_REGNUM + 15},
 176   /* fr16~fr31.  */
 177   {"fr16", CSKY_FR16_REGNUM + 0},
 178   {"fr17", CSKY_FR16_REGNUM + 1},
 179   {"fr18", CSKY_FR16_REGNUM + 2},
 180   {"fr19", CSKY_FR16_REGNUM + 3},
 181   {"fr20", CSKY_FR16_REGNUM + 4},
 182   {"fr21", CSKY_FR16_REGNUM + 5},
 183   {"fr22", CSKY_FR16_REGNUM + 6},
 184   {"fr23", CSKY_FR16_REGNUM + 7},
 185   {"fr24", CSKY_FR16_REGNUM + 8},
 186   {"fr25", CSKY_FR16_REGNUM + 9},
 187   {"fr26", CSKY_FR16_REGNUM + 10},
 188   {"fr27", CSKY_FR16_REGNUM + 11},
 189   {"fr28", CSKY_FR16_REGNUM + 12},
 190   {"fr29", CSKY_FR16_REGNUM + 13},
 191   {"fr30", CSKY_FR16_REGNUM + 14},
 192   {"fr31", CSKY_FR16_REGNUM + 15},
 193   /* vr0~vr15.  */
 194   {"vr0",  CSKY_VR0_REGNUM + 0},
 195   {"vr1",  CSKY_VR0_REGNUM + 1},
 196   {"vr2",  CSKY_VR0_REGNUM + 2},
 197   {"vr3",  CSKY_VR0_REGNUM + 3},
 198   {"vr4",  CSKY_VR0_REGNUM + 4},
 199   {"vr5",  CSKY_VR0_REGNUM + 5},
 200   {"vr6",  CSKY_VR0_REGNUM + 6},
 201   {"vr7",  CSKY_VR0_REGNUM + 7},
 202   {"vr8",  CSKY_VR0_REGNUM + 8},
 203   {"vr9",  CSKY_VR0_REGNUM + 9},
 204   {"vr10", CSKY_VR0_REGNUM + 10},
 205   {"vr11", CSKY_VR0_REGNUM + 11},
 206   {"vr12", CSKY_VR0_REGNUM + 12},
 207   {"vr13", CSKY_VR0_REGNUM + 13},
 208   {"vr14", CSKY_VR0_REGNUM + 14},
 209   {"vr15", CSKY_VR0_REGNUM + 15},
 210   /* fpu control registers.  */
 211   {"fcr",  CSKY_FCR_REGNUM + 0},
 212   {"fid",  CSKY_FCR_REGNUM + 1},
 213   {"fesr", CSKY_FCR_REGNUM + 2},
 214 };
 215
 216 static const struct csky_supported_tdesc_register csky_supported_ar_regs[] = {
 217   {"ar0",  CSKY_AR0_REGNUM + 0},
 218   {"ar1",  CSKY_AR0_REGNUM + 1},
 219   {"ar2",  CSKY_AR0_REGNUM + 2},
 220   {"ar3",  CSKY_AR0_REGNUM + 3},
 221   {"ar4",  CSKY_AR0_REGNUM + 4},
 222   {"ar5",  CSKY_AR0_REGNUM + 5},
 223   {"ar6",  CSKY_AR0_REGNUM + 6},
 224   {"ar7",  CSKY_AR0_REGNUM + 7},
 225   {"ar8",  CSKY_AR0_REGNUM + 8},
 226   {"ar9",  CSKY_AR0_REGNUM + 9},
 227   {"ar10", CSKY_AR0_REGNUM + 10},
 228   {"ar11", CSKY_AR0_REGNUM + 11},
 229   {"ar12", CSKY_AR0_REGNUM + 12},
 230   {"ar13", CSKY_AR0_REGNUM + 13},
 231   {"ar14", CSKY_AR0_REGNUM + 14},
 232   {"ar15", CSKY_AR0_REGNUM + 15},
 233 };
 234
 235 static const struct csky_supported_tdesc_register csky_supported_bank0_regs[] = {
 236   {"cr0",  CSKY_CR0_REGNUM + 0},
 237   {"cr1",  CSKY_CR0_REGNUM + 1},
 238   {"cr2",  CSKY_CR0_REGNUM + 2},
 239   {"cr3",  CSKY_CR0_REGNUM + 3},
 240   {"cr4",  CSKY_CR0_REGNUM + 4},
 241   {"cr5",  CSKY_CR0_REGNUM + 5},
 242   {"cr6",  CSKY_CR0_REGNUM + 6},
 243   {"cr7",  CSKY_CR0_REGNUM + 7},
 244   {"cr8",  CSKY_CR0_REGNUM + 8},
 245   {"cr9",  CSKY_CR0_REGNUM + 9},
 246   {"cr10", CSKY_CR0_REGNUM + 10},
 247   {"cr11", CSKY_CR0_REGNUM + 11},
 248   {"cr12", CSKY_CR0_REGNUM + 12},
 249   {"cr13", CSKY_CR0_REGNUM + 13},
 250   {"cr14", CSKY_CR0_REGNUM + 14},
 251   {"cr15", CSKY_CR0_REGNUM + 15},
 252   {"cr16", CSKY_CR0_REGNUM + 16},
 253   {"cr17", CSKY_CR0_REGNUM + 17},
 254   {"cr18", CSKY_CR0_REGNUM + 18},
 255   {"cr19", CSKY_CR0_REGNUM + 19},
 256   {"cr20", CSKY_CR0_REGNUM + 20},
 257   {"cr21", CSKY_CR0_REGNUM + 21},
 258   {"cr22", CSKY_CR0_REGNUM + 22},
 259   {"cr23", CSKY_CR0_REGNUM + 23},
 260   {"cr24", CSKY_CR0_REGNUM + 24},
 261   {"cr25", CSKY_CR0_REGNUM + 25},
 262   {"cr26", CSKY_CR0_REGNUM + 26},
 263   {"cr27", CSKY_CR0_REGNUM + 27},
 264   {"cr28", CSKY_CR0_REGNUM + 28},
 265   {"cr29", CSKY_CR0_REGNUM + 29},
 266   {"cr30", CSKY_CR0_REGNUM + 30},
 267   {"cr31", CSKY_CR0_REGNUM + 31}
 268 };
 269
 270 static const struct csky_supported_tdesc_register csky_supported_mmu_regs[] = {
 271   {"mcr0",  128},
 272   {"mcr2",  129},
 273   {"mcr3",  130},
 274   {"mcr4",  131},
 275   {"mcr6",  132},
 276   {"mcr8",  133},
 277   {"mcr29", 134},
 278   {"mcr30", 135},
 279   {"mcr31", 136}
 280 };
 281
 282 static const struct csky_supported_tdesc_register csky_supported_bank15_regs[] = {
 283   {"cp15cp1",   253},
 284   {"cp15cp5",   254},
 285   {"cp15cp7",   255},
 286   {"cp15cp9",   256},
 287   {"cp15cp10",  257},
 288   {"cp15cp11",  258},
 289   {"cp15cp12",  259},
 290   {"cp15cp13",  260},
 291   {"cp15cp14",  261},
 292   {"cp15cp15",  262},
 293   {"cp15cp16",  263},
 294   {"cp15cp17",  264},
 295   {"cp15cp18",  265},
 296   {"cp15cp19",  266},
 297   {"cp15cp20",  267},
 298   {"cp15cp21",  268},
 299   {"cp15cp22",  269},
 300   {"cp15cp23",  270},
 301   {"cp15cp24",  271},
 302   {"cp15cp25",  272},
 303   {"cp15cp26",  273},
 304   {"cp15cp27",  274},
 305   {"cp15cp28",  275},
 306 };
 307
 308 static const struct csky_supported_tdesc_register csky_supported_alias_regs[] = {
 309   /* Alias register names for Bank0.  */
 310   {"psr",   CSKY_CR0_REGNUM + 0},
 311   {"vbr",   CSKY_CR0_REGNUM + 1},
 312   {"epsr",  CSKY_CR0_REGNUM + 2},
 313   {"fpsr",  CSKY_CR0_REGNUM + 3},
 314   {"epc",   CSKY_CR0_REGNUM + 4},
 315   {"fpc",   CSKY_CR0_REGNUM + 5},
 316   {"ss0",   CSKY_CR0_REGNUM + 6},
 317   {"ss1",   CSKY_CR0_REGNUM + 7},
 318   {"ss2",   CSKY_CR0_REGNUM + 8},
 319   {"ss3",   CSKY_CR0_REGNUM + 9},
 320   {"ss4",   CSKY_CR0_REGNUM + 10},
 321   {"gcr",   CSKY_CR0_REGNUM + 11},
 322   {"gsr",   CSKY_CR0_REGNUM + 12},
 323   {"cpuid", CSKY_CR0_REGNUM + 13},
 324   {"ccr",   CSKY_CR0_REGNUM + 18},
 325   {"capr",  CSKY_CR0_REGNUM + 19},
 326   {"pacr",  CSKY_CR0_REGNUM + 20},
 327   {"prsr",  CSKY_CR0_REGNUM + 21},
 328   {"chr",   CSKY_CR0_REGNUM + 31},
 329   /* Alias register names for MMU.  */
 330   {"mir",   128},
 331   {"mel0",  129},
 332   {"mel1",  130},
 333   {"meh",   131},
 334   {"mpr",   132},
 335   {"mcir",  133},
 336   {"mpgd",  134},
 337   {"msa0",  135},
 338   {"msa1",  136},
 339   /* Alias register names for Bank1.  */
 340   {"ebr",     190},
 341   {"errlc",   195},
 342   {"erraddr", 196},
 343   {"errsts",  197},
 344   {"errinj",  198},
 345   {"usp",     203},
 346   {"int_sp",  204},
 347   {"itcmcr",  211},
 348   {"dtcmcr",  212},
 349   {"cindex",  215},
 350   {"cdata0",  216},
 351   {"cdata1",  217},
 352   {"cdata2",  218},
 353   {"cins",    220},
 354   /* Alias register names for Bank3.  */
 355   {"sepsr",   221},
 356   {"t_wssr",  221},
 357   {"sevbr",   222},
 358   {"t_wrcr",  222},
 359   {"seepsr",  223},
 360   {"seepc",   225},
 361   {"nsssp",   227},
 362   {"t_usp",   228},
 363   {"dcr",     229},
 364   {"t_pcr",   230},
 365 };
 366
 367 /* Functions declaration.  */
 368
 369 static const char *
 370 csky_pseudo_register_name (struct gdbarch *gdbarch, int regno);
 371
 372 /* Get csky supported registers's count for tdesc xml.  */
 373
 374 static int
 375 csky_get_supported_tdesc_registers_count()
 376 {
 377   int count = 0;
 378   count += ARRAY_SIZE (csky_supported_gpr_regs);
 379   count += ARRAY_SIZE (csky_supported_fpu_regs);
 380   count += ARRAY_SIZE (csky_supported_ar_regs);
 381   count += ARRAY_SIZE (csky_supported_bank0_regs);
 382   count += ARRAY_SIZE (csky_supported_mmu_regs);
 383   count += ARRAY_SIZE (csky_supported_bank15_regs);
 384   count += ARRAY_SIZE (csky_supported_alias_regs);
 385   /* Bank1~Bank14, Bank16~Bank31. */
 386   count += 32 * (14 + 16);
 387   return count;
 388 }
 389
 390 /* Return a supported register according to index.  */
 391
 392 static const struct csky_supported_tdesc_register *
 393 csky_get_supported_register_by_index (int index)
 394 {
 395   static struct csky_supported_tdesc_register tdesc_reg;
 396   int count = 0;
 397   int multi, remain;
 398   int count_gpr = ARRAY_SIZE (csky_supported_gpr_regs);
 399   int count_fpu = ARRAY_SIZE (csky_supported_fpu_regs);
 400   int count_ar = ARRAY_SIZE (csky_supported_ar_regs);
 401   int count_bank0 = ARRAY_SIZE (csky_supported_bank0_regs);
 402   int count_mmu = ARRAY_SIZE (csky_supported_mmu_regs);
 403   int count_bank15 = ARRAY_SIZE (csky_supported_bank15_regs);
 404   int count_alias = ARRAY_SIZE (csky_supported_alias_regs);
 405
 406   count = count_gpr;
 407   if (index < count)
 408     return &csky_supported_gpr_regs[index];
 409   if (index < (count + count_fpu))
 410     return &csky_supported_fpu_regs[index - count];
 411   count += count_fpu;
 412   if (index < (count + count_ar))
 413     return &csky_supported_ar_regs[index - count];
 414   count += count_ar;
 415   if (index < (count + count_bank0))
 416     return &csky_supported_bank0_regs[index - count];
 417   count += count_bank0;
 418   if (index < (count + count_mmu))
 419     return &csky_supported_mmu_regs[index - count];
 420   count += count_mmu;
 421   if (index < (count + count_bank15))
 422     return &csky_supported_bank15_regs[index - count];
 423   count += count_bank15;
 424   if (index < (count + count_alias))
 425     return &csky_supported_alias_regs[index - count];
 426   count += count_alias;
 427   index -= count;
 428   multi = index / 32;
 429   remain = index % 32;
 430   switch (multi)
 431     {
 432       case 0: /* Bank1.  */
 433         {
 434           sprintf (tdesc_reg.name, "cp1cr%d", remain);
 435           tdesc_reg.num = 189 + remain;
 436         }
 437         break;
 438       case 1: /* Bank2.  */
 439         {
 440           sprintf (tdesc_reg.name, "cp2cr%d", remain);
 441           tdesc_reg.num = 276 + remain;
 442         }
 443         break;
 444       case 2: /* Bank3.  */
 445         {
 446           sprintf (tdesc_reg.name, "cp3cr%d", remain);
 447           tdesc_reg.num = 221 + remain;
 448         }
 449         break;
 450       case 3:  /* Bank4.  */
 451       case 4:  /* Bank5.  */
 452       case 5:  /* Bank6.  */
 453       case 6:  /* Bank7.  */
 454       case 7:  /* Bank8.  */
 455       case 8:  /* Bank9.  */
 456       case 9:  /* Bank10.  */
 457       case 10: /* Bank11.  */
 458       case 11: /* Bank12.  */
 459       case 12: /* Bank13.  */
 460       case 13: /* Bank14.  */
 461         {
 462           /* Regitsers in Bank4~14 have continuous regno with start 308.  */
 463           sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 1), remain);
 464           tdesc_reg.num = 308 + ((multi - 3) * 32) + remain;
 465         }
 466         break;
 467       case 14: /* Bank16.  */
 468       case 15: /* Bank17.  */
 469       case 16: /* Bank18.  */
 470       case 17: /* Bank19.  */
 471       case 18: /* Bank20.  */
 472       case 19: /* Bank21.  */
 473       case 20: /* Bank22.  */
 474       case 21: /* Bank23.  */
 475       case 22: /* Bank24.  */
 476       case 23: /* Bank25.  */
 477       case 24: /* Bank26.  */
 478       case 25: /* Bank27.  */
 479       case 26: /* Bank28.  */
 480       case 27: /* Bank29.  */
 481       case 28: /* Bank30.  */
 482       case 29: /* Bank31.  */
 483         {
 484           /* Regitsers in Bank16~31 have continuous regno with start 660.  */
 485           sprintf (tdesc_reg.name, "cp%dcr%d", (multi + 2), remain);
 486           tdesc_reg.num = 660 + ((multi - 14) * 32) + remain;
 487         }
 488         break;
 489       default:
 490         return NULL;
 491     }
 492   return &tdesc_reg;
 493 }
 494
 495 /* Convenience function to print debug messages in prologue analysis.  */
 496
 497 static void
 498 print_savedreg_msg (int regno, int offsets[], bool print_continuing)
 499 {
 500   gdb_printf (gdb_stdlog, "csky: r%d saved at offset 0x%x\n",
 501               regno, offsets[regno]);
 502   if (print_continuing)
 503     gdb_printf (gdb_stdlog, "csky: continuing\n");
 504 }
 505
 506 /*  Check whether the instruction at ADDR is 16-bit or not.  */
 507
 508 static int
 509 csky_pc_is_csky16 (struct gdbarch *gdbarch, CORE_ADDR addr)
 510 {
 511   gdb_byte target_mem[2];
 512   int status;
 513   unsigned int insn;
 514   int ret = 1;
 515   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 516
 517   status = target_read_memory (addr, target_mem, 2);
 518   /* Assume a 16-bit instruction if we can't read memory.  */
 519   if (status)
 520     return 1;
 521
 522   /* Get instruction from memory.  */
 523   insn = extract_unsigned_integer (target_mem, 2, byte_order);
 524   if ((insn & CSKY_32_INSN_MASK) == CSKY_32_INSN_MASK)
 525     ret = 0;
 526   else if (insn == CSKY_BKPT_INSN)
 527     {
 528       /* Check for 32-bit bkpt instruction which is all 0.  */
 529       status = target_read_memory (addr + 2, target_mem, 2);
 530       if (status)
 531         return 1;
 532
 533       insn = extract_unsigned_integer (target_mem, 2, byte_order);
 534       if (insn == CSKY_BKPT_INSN)
 535         ret = 0;
 536     }
 537   return ret;
 538 }
 539
 540 /* Get one instruction at ADDR and store it in INSN.  Return 2 for
 541    a 16-bit instruction or 4 for a 32-bit instruction.  */
 542
 543 static int
 544 csky_get_insn (struct gdbarch *gdbarch, CORE_ADDR addr, unsigned int *insn)
 545 {
 546   gdb_byte target_mem[2];
 547   unsigned int insn_type;
 548   int status;
 549   int insn_len = 2;
 550   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 551
 552   status = target_read_memory (addr, target_mem, 2);
 553   if (status)
 554     memory_error (TARGET_XFER_E_IO, addr);
 555
 556   insn_type = extract_unsigned_integer (target_mem, 2, byte_order);
 557   if (CSKY_32_INSN_MASK == (insn_type & CSKY_32_INSN_MASK))
 558     {
 559       status = target_read_memory (addr + 2, target_mem, 2);
 560       if (status)
 561         memory_error (TARGET_XFER_E_IO, addr);
 562       insn_type = ((insn_type << 16)
 563                    | extract_unsigned_integer (target_mem, 2, byte_order));
 564       insn_len = 4;
 565     }
 566   *insn = insn_type;
 567   return insn_len;
 568 }
 569
 570 /* Implement the read_pc gdbarch method.  */
 571
 572 static CORE_ADDR
 573 csky_read_pc (readable_regcache *regcache)
 574 {
 575   ULONGEST pc;
 576   regcache->cooked_read (CSKY_PC_REGNUM, &pc);
 577   return pc;
 578 }
 579
 580 /* Implement the write_pc gdbarch method.  */
 581
 582 static void
 583 csky_write_pc (regcache *regcache, CORE_ADDR val)
 584 {
 585   regcache_cooked_write_unsigned (regcache, CSKY_PC_REGNUM, val);
 586 }
 587
 588 /* C-Sky ABI register names.  */
 589
 590 static const char * const csky_register_names[] =
 591 {
 592   /* General registers 0 - 31.  */
 593   "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
 594   "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
 595   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 596   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 597
 598   /* DSP hilo registers 36 and 37.  */
 599   "",      "",    "",     "",     "hi",    "lo",   "",    "",
 600
 601   /* FPU/VPU general registers 40 - 71.  */
 602   "fr0", "fr1", "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
 603   "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 604   "vr0", "vr1", "vr2",  "vr3",  "vr4",  "vr5",  "vr6",  "vr7",
 605   "vr8", "vr9", "vr10", "vr11", "vr12", "vr13", "vr14", "vr15",
 606
 607   /* Program counter 72.  */
 608   "pc",
 609
 610   /* Optional registers (ar) 73 - 88.  */
 611   "ar0", "ar1", "ar2",  "ar3",  "ar4",  "ar5",  "ar6",  "ar7",
 612   "ar8", "ar9", "ar10", "ar11", "ar12", "ar13", "ar14", "ar15",
 613
 614   /* Control registers (cr) 89 - 119.  */
 615   "psr",  "vbr",  "epsr", "fpsr", "epc",  "fpc",  "ss0",  "ss1",
 616   "ss2",  "ss3",  "ss4",  "gcr",  "gsr",  "cr13", "cr14", "cr15",
 617   "cr16", "cr17", "cr18", "cr19", "cr20", "cr21", "cr22", "cr23",
 618   "cr24", "cr25", "cr26", "cr27", "cr28", "cr29", "cr30", "cr31",
 619
 620   /* FPU/VPU control registers 121 ~ 123.  */
 621   /* User sp 127.  */
 622   "fid", "fcr", "fesr", "", "", "", "usp",
 623
 624   /* MMU control registers: 128 - 136.  */
 625   "mcr0", "mcr2", "mcr3", "mcr4", "mcr6", "mcr8", "mcr29", "mcr30",
 626   "mcr31", "", "", "",
 627
 628   /* Profiling control registers 140 - 143.  */
 629   /* Profiling software general registers 144 - 157.  */
 630   "profcr0",  "profcr1",  "profcr2",  "profcr3",  "profsgr0",  "profsgr1",
 631   "profsgr2", "profsgr3", "profsgr4", "profsgr5", "profsgr6",  "profsgr7",
 632   "profsgr8", "profsgr9", "profsgr10","profsgr11","profsgr12", "profsgr13",
 633   "",    "",
 634
 635   /* Profiling architecture general registers 160 - 174.  */
 636   "profagr0", "profagr1", "profagr2", "profagr3", "profagr4", "profagr5",
 637   "profagr6", "profagr7", "profagr8", "profagr9", "profagr10","profagr11",
 638   "profagr12","profagr13","profagr14", "",
 639
 640   /* Profiling extension general registers 176 - 188.  */
 641   "profxgr0", "profxgr1", "profxgr2", "profxgr3", "profxgr4", "profxgr5",
 642   "profxgr6", "profxgr7", "profxgr8", "profxgr9", "profxgr10","profxgr11",
 643   "profxgr12",
 644
 645   /* Control registers in bank1.  */
 646   "", "", "", "", "", "", "", "",
 647   "", "", "", "", "", "", "", "",
 648   "cp1cr16", "cp1cr17", "cp1cr18", "cp1cr19", "cp1cr20", "", "", "",
 649   "", "", "", "", "", "", "", "",
 650
 651   /* Control registers in bank3 (ICE).  */
 652   "sepsr", "sevbr", "seepsr", "", "seepc", "", "nsssp", "seusp",
 653   "sedcr", "", "", "", "", "", "", "",
 654   "", "", "", "", "", "", "", "",
 655   "", "", "", "", "", "", "", ""
 656 };
 657
 658 /* Implement the register_name gdbarch method.  */
 659
 660 static const char *
 661 csky_register_name (struct gdbarch *gdbarch, int reg_nr)
 662 {
 663   if (reg_nr >= gdbarch_num_regs (gdbarch))
 664     return csky_pseudo_register_name (gdbarch, reg_nr);
 665
 666   if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
 667     return tdesc_register_name (gdbarch, reg_nr);
 668
 669   return csky_register_names[reg_nr];
 670 }
 671
 672 /* Construct vector type for vrx registers.  */
 673
 674 static struct type *
 675 csky_vector_type (struct gdbarch *gdbarch)
 676 {
 677   const struct builtin_type *bt = builtin_type (gdbarch);
 678
 679   struct type *t;
 680
 681   t = arch_composite_type (gdbarch, "__gdb_builtin_type_vec128i",
 682                            TYPE_CODE_UNION);
 683
 684   append_composite_type_field (t, "u32",
 685                                init_vector_type (bt->builtin_int32, 4));
 686   append_composite_type_field (t, "u16",
 687                                init_vector_type (bt->builtin_int16, 8));
 688   append_composite_type_field (t, "u8",
 689                                init_vector_type (bt->builtin_int8, 16));
 690
 691   t->set_is_vector (true);
 692   t->set_name ("builtin_type_vec128i");
 693
 694   return t;
 695 }
 696
 697 /* Return the GDB type object for the "standard" data type
 698    of data in register N.  */
 699
 700 static struct type *
 701 csky_register_type (struct gdbarch *gdbarch, int reg_nr)
 702 {
 703   int num_regs = gdbarch_num_regs (gdbarch);
 704   csky_gdbarch_tdep *tdep
 705     = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
 706
 707   if (tdep->fv_pseudo_registers_count)
 708     {
 709       if ((reg_nr >= num_regs)
 710           && (reg_nr < (num_regs + tdep->fv_pseudo_registers_count)))
 711         return builtin_type (gdbarch)->builtin_int32;
 712     }
 713
 714   /* Vector register has 128 bits, and only in ck810. Just return
 715      csky_vector_type(), not check tdesc_has_registers(), is in case
 716      of some GDB stub does not describe type for Vector resgisters
 717      in the target-description-xml.  */
 718   if ((reg_nr >= CSKY_VR0_REGNUM) && (reg_nr <= CSKY_VR0_REGNUM + 15))
 719     return csky_vector_type (gdbarch);
 720
 721   /* If type has been described in tdesc-xml, use it.  */
 722   if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
 723     {
 724       struct type *tdesc_t = tdesc_register_type (gdbarch, reg_nr);
 725       if (tdesc_t)
 726         return tdesc_t;
 727     }
 728
 729   /* PC, EPC, FPC is a text pointer.  */
 730   if ((reg_nr == CSKY_PC_REGNUM)  || (reg_nr == CSKY_EPC_REGNUM)
 731       || (reg_nr == CSKY_FPC_REGNUM))
 732     return builtin_type (gdbarch)->builtin_func_ptr;
 733
 734   /* VBR is a data pointer.  */
 735   if (reg_nr == CSKY_VBR_REGNUM)
 736     return builtin_type (gdbarch)->builtin_data_ptr;
 737
 738   /* Float register has 64 bits, and only in ck810.  */
 739   if ((reg_nr >=CSKY_FR0_REGNUM) && (reg_nr <= CSKY_FR0_REGNUM + 15))
 740       return arch_float_type (gdbarch, 64, "builtin_type_csky_ext",
 741                               floatformats_ieee_double);
 742
 743   /* Profiling general register has 48 bits, we use 64bit.  */
 744   if ((reg_nr >= CSKY_PROFGR_REGNUM) && (reg_nr <= CSKY_PROFGR_REGNUM + 44))
 745     return builtin_type (gdbarch)->builtin_uint64;
 746
 747   if (reg_nr == CSKY_SP_REGNUM)
 748     return builtin_type (gdbarch)->builtin_data_ptr;
 749
 750   /* Others are 32 bits.  */
 751   return builtin_type (gdbarch)->builtin_int32;
 752 }
 753
 754 /* Data structure to marshall items in a dummy stack frame when
 755    calling a function in the inferior.  */
 756
 757 struct csky_stack_item
 758 {
 759   csky_stack_item (int len_, const gdb_byte *data_)
 760   : len (len_), data (data_)
 761   {}
 762
 763   int len;
 764   const gdb_byte *data;
 765 };
 766
 767 /* Implement the push_dummy_call gdbarch method.  */
 768
 769 static CORE_ADDR
 770 csky_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 771                       struct regcache *regcache, CORE_ADDR bp_addr,
 772                       int nargs, struct value **args, CORE_ADDR sp,
 773                       function_call_return_method return_method,
 774                       CORE_ADDR struct_addr)
 775 {
 776   int argnum;
 777   int argreg = CSKY_ABI_A0_REGNUM;
 778   int last_arg_regnum = CSKY_ABI_LAST_ARG_REGNUM;
 779   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 780   std::vector<csky_stack_item> stack_items;
 781
 782   /* Set the return address.  For CSKY, the return breakpoint is
 783      always at BP_ADDR.  */
 784   regcache_cooked_write_unsigned (regcache, CSKY_LR_REGNUM, bp_addr);
 785
 786   /* The struct_return pointer occupies the first parameter
 787      passing register.  */
 788   if (return_method == return_method_struct)
 789     {
 790       if (csky_debug)
 791         {
 792           gdb_printf (gdb_stdlog,
 793                       "csky: struct return in %s = %s\n",
 794                       gdbarch_register_name (gdbarch, argreg),
 795                       paddress (gdbarch, struct_addr));
 796         }
 797       regcache_cooked_write_unsigned (regcache, argreg, struct_addr);
 798       argreg++;
 799     }
 800
 801   /* Put parameters into argument registers in REGCACHE.
 802      In ABI argument registers are r0 through r3.  */
 803   for (argnum = 0; argnum < nargs; argnum++)
 804     {
 805       int len;
 806       struct type *arg_type;
 807       const gdb_byte *val;
 808
 809       arg_type = check_typedef (value_type (args[argnum]));
 810       len = arg_type->length ();
 811       val = value_contents (args[argnum]).data ();
 812
 813       /* Copy the argument to argument registers or the dummy stack.
 814          Large arguments are split between registers and stack.
 815
 816          If len < 4, there is no need to worry about endianness since
 817          the arguments will always be stored in the low address.  */
 818       if (len < 4)
 819         {
 820           CORE_ADDR regval
 821             = extract_unsigned_integer (val, len, byte_order);
 822           regcache_cooked_write_unsigned (regcache, argreg, regval);
 823           argreg++;
 824         }
 825       else
 826         {
 827           while (len > 0)
 828             {
 829               int partial_len = len < 4 ? len : 4;
 830               if (argreg <= last_arg_regnum)
 831                 {
 832                   /* The argument is passed in an argument register.  */
 833                   CORE_ADDR regval
 834                     = extract_unsigned_integer (val, partial_len,
 835                                                 byte_order);
 836                   if (byte_order == BFD_ENDIAN_BIG)
 837                     regval <<= (4 - partial_len) * 8;
 838
 839                   /* Put regval into register in REGCACHE.  */
 840                   regcache_cooked_write_unsigned (regcache, argreg,
 841                                                   regval);
 842                   argreg++;
 843                 }
 844               else
 845                 {
 846                   /* The argument should be pushed onto the dummy stack.  */
 847                   stack_items.emplace_back (4, val);
 848                 }
 849               len -= partial_len;
 850               val += partial_len;
 851             }
 852         }
 853     }
 854
 855   /* Transfer the dummy stack frame to the target.  */
 856   std::vector<csky_stack_item>::reverse_iterator iter;
 857   for (iter = stack_items.rbegin (); iter != stack_items.rend (); ++iter)
 858     {
 859       sp -= iter->len;
 860       write_memory (sp, iter->data, iter->len);
 861     }
 862
 863   /* Finally, update the SP register.  */
 864   regcache_cooked_write_unsigned (regcache, CSKY_SP_REGNUM, sp);
 865   return sp;
 866 }
 867
 868 /* Implement the return_value gdbarch method.  */
 869
 870 static enum return_value_convention
 871 csky_return_value (struct gdbarch *gdbarch, struct value *function,
 872                    struct type *valtype, struct regcache *regcache,
 873                    gdb_byte *readbuf, const gdb_byte *writebuf)
 874 {
 875   CORE_ADDR regval;
 876   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 877   int len = valtype->length ();
 878   unsigned int ret_regnum = CSKY_RET_REGNUM;
 879
 880   /* Csky abi specifies that return values larger than 8 bytes
 881      are put on the stack.  */
 882   if (len > 8)
 883     return RETURN_VALUE_STRUCT_CONVENTION;
 884   else
 885     {
 886       if (readbuf != NULL)
 887         {
 888           ULONGEST tmp;
 889           /* By using store_unsigned_integer we avoid having to do
 890              anything special for small big-endian values.  */
 891           regcache->cooked_read (ret_regnum, &tmp);
 892           store_unsigned_integer (readbuf, (len > 4 ? 4 : len),
 893                                   byte_order, tmp);
 894           if (len > 4)
 895             {
 896               regcache->cooked_read (ret_regnum + 1, &tmp);
 897               store_unsigned_integer (readbuf + 4,  4, byte_order, tmp);
 898             }
 899         }
 900       if (writebuf != NULL)
 901         {
 902           regval = extract_unsigned_integer (writebuf, len > 4 ? 4 : len,
 903                                              byte_order);
 904           regcache_cooked_write_unsigned (regcache, ret_regnum, regval);
 905           if (len > 4)
 906             {
 907               regval = extract_unsigned_integer ((gdb_byte *) writebuf + 4,
 908                                                  4, byte_order);
 909               regcache_cooked_write_unsigned (regcache, ret_regnum + 1,
 910                                               regval);
 911             }
 912
 913         }
 914       return RETURN_VALUE_REGISTER_CONVENTION;
 915     }
 916 }
 917
 918 /* Implement the frame_align gdbarch method.
 919
 920    Adjust the address downward (direction of stack growth) so that it
 921    is correctly aligned for a new stack frame.  */
 922
 923 static CORE_ADDR
 924 csky_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
 925 {
 926   return align_down (addr, 4);
 927 }
 928
 929 /* Unwind cache used for gdbarch fallback unwinder.  */
 930
 931 struct csky_unwind_cache
 932 {
 933   /* The stack pointer at the time this frame was created; i.e. the
 934      caller's stack pointer when this function was called.  It is used
 935      to identify this frame.  */
 936   CORE_ADDR prev_sp;
 937
 938   /* The frame base for this frame is just prev_sp - frame size.
 939      FRAMESIZE is the distance from the frame pointer to the
 940      initial stack pointer.  */
 941   int framesize;
 942
 943   /* The register used to hold the frame pointer for this frame.  */
 944   int framereg;
 945
 946   /* Saved register offsets.  */
 947   trad_frame_saved_reg *saved_regs;
 948 };
 949
 950 /* Do prologue analysis, returning the PC of the first instruction
 951    after the function prologue.  */
 952
 953 static CORE_ADDR
 954 csky_analyze_prologue (struct gdbarch *gdbarch,
 955                        CORE_ADDR start_pc,
 956                        CORE_ADDR limit_pc,
 957                        CORE_ADDR end_pc,
 958                        frame_info_ptr this_frame,
 959                        struct csky_unwind_cache *this_cache,
 960                        lr_type_t lr_type)
 961 {
 962   CORE_ADDR addr;
 963   unsigned int insn, rn;
 964   int framesize = 0;
 965   int stacksize = 0;
 966   int register_offsets[CSKY_NUM_GREGS_SAVED_GREGS];
 967   int insn_len;
 968   /* For adjusting fp.  */
 969   int is_fp_saved = 0;
 970   int adjust_fp = 0;
 971
 972   /* REGISTER_OFFSETS will contain offsets from the top of the frame
 973      (NOT the frame pointer) for the various saved registers, or -1
 974      if the register is not saved.  */
 975   for (rn = 0; rn < CSKY_NUM_GREGS_SAVED_GREGS; rn++)
 976     register_offsets[rn] = -1;
 977
 978   /* Analyze the prologue.  Things we determine from analyzing the
 979      prologue include the size of the frame and which registers are
 980      saved (and where).  */
 981   if (csky_debug)
 982     {
 983       gdb_printf (gdb_stdlog,
 984                   "csky: Scanning prologue: start_pc = 0x%x,"
 985                   "limit_pc = 0x%x\n", (unsigned int) start_pc,
 986                   (unsigned int) limit_pc);
 987     }
 988
 989   /* Default to 16 bit instruction.  */
 990   insn_len = 2;
 991   stacksize = 0;
 992   for (addr = start_pc; addr < limit_pc; addr += insn_len)
 993     {
 994       /* Get next insn.  */
 995       insn_len = csky_get_insn (gdbarch, addr, &insn);
 996
 997       /* Check if 32 bit.  */
 998       if (insn_len == 4)
 999         {
1000           /* subi32 sp,sp oimm12.  */
1001           if (CSKY_32_IS_SUBI0 (insn))
1002             {
1003               /* Got oimm12.  */
1004               int offset = CSKY_32_SUBI_IMM (insn);
1005               if (csky_debug)
1006                 {
1007                   gdb_printf (gdb_stdlog,
1008                               "csky: got subi sp,%d; continuing\n",
1009                               offset);
1010                 }
1011               stacksize += offset;
1012               continue;
1013             }
1014           /* stm32 ry-rz,(sp).  */
1015           else if (CSKY_32_IS_STMx0 (insn))
1016             {
1017               /* Spill register(s).  */
1018               int start_register;
1019               int reg_count;
1020               int offset;
1021
1022               /* BIG WARNING! The CKCore ABI does not restrict functions
1023                  to taking only one stack allocation.  Therefore, when
1024                  we save a register, we record the offset of where it was
1025                  saved relative to the current stacksize.  This will
1026                  then give an offset from the SP upon entry to our
1027                  function.  Remember, stacksize is NOT constant until
1028                  we're done scanning the prologue.  */
1029               start_register = CSKY_32_STM_VAL_REGNUM (insn);
1030               reg_count = CSKY_32_STM_SIZE (insn);
1031               if (csky_debug)
1032                 {
1033                   gdb_printf (gdb_stdlog,
1034                               "csky: got stm r%d-r%d,(sp)\n",
1035                               start_register,
1036                               start_register + reg_count);
1037                 }
1038
1039               for (rn = start_register, offset = 0;
1040                    rn <= start_register + reg_count;
1041                    rn++, offset += 4)
1042                 {
1043                   register_offsets[rn] = stacksize - offset;
1044                   if (csky_debug)
1045                     {
1046                       gdb_printf (gdb_stdlog,
1047                                   "csky: r%d saved at 0x%x"
1048                                   " (offset %d)\n",
1049                                   rn, register_offsets[rn],
1050                                   offset);
1051                     }
1052                 }
1053               if (csky_debug)
1054                 gdb_printf (gdb_stdlog, "csky: continuing\n");
1055               continue;
1056             }
1057           /* stw ry,(sp,disp).  */
1058           else if (CSKY_32_IS_STWx0 (insn))
1059             {
1060               /* Spill register: see note for IS_STM above.  */
1061               int disp;
1062
1063               rn = CSKY_32_ST_VAL_REGNUM (insn);
1064               disp = CSKY_32_ST_OFFSET (insn);
1065               register_offsets[rn] = stacksize - disp;
1066               if (csky_debug)
1067                 print_savedreg_msg (rn, register_offsets, true);
1068               continue;
1069             }
1070           else if (CSKY_32_IS_MOV_FP_SP (insn))
1071             {
1072               /* SP is saved to FP reg, means code afer prologue may
1073                  modify SP.  */
1074               is_fp_saved = 1;
1075               adjust_fp = stacksize;
1076               continue;
1077             }
1078           else if (CSKY_32_IS_MFCR_EPSR (insn))
1079             {
1080               unsigned int insn2;
1081               addr += 4;
1082               int mfcr_regnum = insn & 0x1f;
1083               insn_len = csky_get_insn (gdbarch, addr, &insn2);
1084               if (insn_len == 2)
1085                 {
1086                   int stw_regnum = (insn2 >> 5) & 0x7;
1087                   if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1088                     {
1089                       int offset;
1090
1091                       /* CSKY_EPSR_REGNUM.  */
1092                       rn  = CSKY_NUM_GREGS;
1093                       offset = CSKY_16_STWx0_OFFSET (insn2);
1094                       register_offsets[rn] = stacksize - offset;
1095                       if (csky_debug)
1096                         print_savedreg_msg (rn, register_offsets, true);
1097                       continue;
1098                     }
1099                   break;
1100                 }
1101               else
1102                 {
1103                   /* INSN_LEN == 4.  */
1104                   int stw_regnum = (insn2 >> 21) & 0x1f;
1105                   if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1106                     {
1107                       int offset;
1108
1109                       /* CSKY_EPSR_REGNUM.  */
1110                       rn  = CSKY_NUM_GREGS;
1111                       offset = CSKY_32_ST_OFFSET (insn2);
1112                       register_offsets[rn] = framesize - offset;
1113                       if (csky_debug)
1114                         print_savedreg_msg (rn, register_offsets, true);
1115                       continue;
1116                     }
1117                   break;
1118                 }
1119             }
1120           else if (CSKY_32_IS_MFCR_FPSR (insn))
1121             {
1122               unsigned int insn2;
1123               addr += 4;
1124               int mfcr_regnum = insn & 0x1f;
1125               insn_len = csky_get_insn (gdbarch, addr, &insn2);
1126               if (insn_len == 2)
1127                 {
1128                   int stw_regnum = (insn2 >> 5) & 0x7;
1129                   if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum
1130                                                  == stw_regnum))
1131                     {
1132                       int offset;
1133
1134                       /* CSKY_FPSR_REGNUM.  */
1135                       rn  = CSKY_NUM_GREGS + 1;
1136                       offset = CSKY_16_STWx0_OFFSET (insn2);
1137                       register_offsets[rn] = stacksize - offset;
1138                       if (csky_debug)
1139                         print_savedreg_msg (rn, register_offsets, true);
1140                       continue;
1141                     }
1142                   break;
1143                 }
1144               else
1145                 {
1146                   /* INSN_LEN == 4.  */
1147                   int stw_regnum = (insn2 >> 21) & 0x1f;
1148                   if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1149                     {
1150                       int offset;
1151
1152                       /* CSKY_FPSR_REGNUM.  */
1153                       rn  = CSKY_NUM_GREGS + 1;
1154                       offset = CSKY_32_ST_OFFSET (insn2);
1155                       register_offsets[rn] = framesize - offset;
1156                       if (csky_debug)
1157                         print_savedreg_msg (rn, register_offsets, true);
1158                       continue;
1159                     }
1160                   break;
1161                 }
1162             }
1163           else if (CSKY_32_IS_MFCR_EPC (insn))
1164             {
1165               unsigned int insn2;
1166               addr += 4;
1167               int mfcr_regnum = insn & 0x1f;
1168               insn_len = csky_get_insn (gdbarch, addr, &insn2);
1169               if (insn_len == 2)
1170                 {
1171                   int stw_regnum = (insn2 >> 5) & 0x7;
1172                   if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1173                     {
1174                       int offset;
1175
1176                       /* CSKY_EPC_REGNUM.  */
1177                       rn  = CSKY_NUM_GREGS + 2;
1178                       offset = CSKY_16_STWx0_OFFSET (insn2);
1179                       register_offsets[rn] = stacksize - offset;
1180                       if (csky_debug)
1181                         print_savedreg_msg (rn, register_offsets, true);
1182                       continue;
1183                     }
1184                   break;
1185                 }
1186               else
1187                 {
1188                   /* INSN_LEN == 4.  */
1189                   int stw_regnum = (insn2 >> 21) & 0x1f;
1190                   if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1191                     {
1192                       int offset;
1193
1194                       /* CSKY_EPC_REGNUM.  */
1195                       rn  = CSKY_NUM_GREGS + 2;
1196                       offset = CSKY_32_ST_OFFSET (insn2);
1197                       register_offsets[rn] = framesize - offset;
1198                       if (csky_debug)
1199                         print_savedreg_msg (rn, register_offsets, true);
1200                       continue;
1201                     }
1202                   break;
1203                 }
1204             }
1205           else if (CSKY_32_IS_MFCR_FPC (insn))
1206             {
1207               unsigned int insn2;
1208               addr += 4;
1209               int mfcr_regnum = insn & 0x1f;
1210               insn_len = csky_get_insn (gdbarch, addr, &insn2);
1211               if (insn_len == 2)
1212                 {
1213                   int stw_regnum = (insn2 >> 5) & 0x7;
1214                   if (CSKY_16_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1215                     {
1216                       int offset;
1217
1218                       /* CSKY_FPC_REGNUM.  */
1219                       rn  = CSKY_NUM_GREGS + 3;
1220                       offset = CSKY_16_STWx0_OFFSET (insn2);
1221                       register_offsets[rn] = stacksize - offset;
1222                       if (csky_debug)
1223                         print_savedreg_msg (rn, register_offsets, true);
1224                       continue;
1225                     }
1226                   break;
1227                 }
1228               else
1229                 {
1230                   /* INSN_LEN == 4.  */
1231                   int stw_regnum = (insn2 >> 21) & 0x1f;
1232                   if (CSKY_32_IS_STWx0 (insn2) && (mfcr_regnum == stw_regnum))
1233                     {
1234                       int offset;
1235
1236                       /* CSKY_FPC_REGNUM.  */
1237                       rn  = CSKY_NUM_GREGS + 3;
1238                       offset = CSKY_32_ST_OFFSET (insn2);
1239                       register_offsets[rn] = framesize - offset;
1240                       if (csky_debug)
1241                         print_savedreg_msg (rn, register_offsets, true);
1242                       continue;
1243                     }
1244                   break;
1245                 }
1246             }
1247           else if (CSKY_32_IS_PUSH (insn))
1248             {
1249               /* Push for 32_bit.  */
1250               if (CSKY_32_IS_PUSH_R29 (insn))
1251                 {
1252                   stacksize += 4;
1253                   register_offsets[29] = stacksize;
1254                   if (csky_debug)
1255                     print_savedreg_msg (29, register_offsets, false);
1256                 }
1257               if (CSKY_32_PUSH_LIST2 (insn))
1258                 {
1259                   int num = CSKY_32_PUSH_LIST2 (insn);
1260                   int tmp = 0;
1261                   stacksize += num * 4;
1262                   if (csky_debug)
1263                     {
1264                       gdb_printf (gdb_stdlog,
1265                                   "csky: push regs_array: r16-r%d\n",
1266                                   16 + num - 1);
1267                     }
1268                   for (rn = 16; rn <= 16 + num - 1; rn++)
1269                     {
1270                        register_offsets[rn] = stacksize - tmp;
1271                        if (csky_debug)
1272                          {
1273                            gdb_printf (gdb_stdlog,
1274                                        "csky: r%d saved at 0x%x"
1275                                        " (offset %d)\n", rn,
1276                                        register_offsets[rn], tmp);
1277                          }
1278                        tmp += 4;
1279                     }
1280                 }
1281               if (CSKY_32_IS_PUSH_R15 (insn))
1282                 {
1283                   stacksize += 4;
1284                   register_offsets[15] = stacksize;
1285                   if (csky_debug)
1286                     print_savedreg_msg (15, register_offsets, false);
1287                 }
1288               if (CSKY_32_PUSH_LIST1 (insn))
1289                 {
1290                   int num = CSKY_32_PUSH_LIST1 (insn);
1291                   int tmp = 0;
1292                   stacksize += num * 4;
1293                   if (csky_debug)
1294                     {
1295                       gdb_printf (gdb_stdlog,
1296                                   "csky: push regs_array: r4-r%d\n",
1297                                   4 + num - 1);
1298                     }
1299                   for (rn = 4; rn <= 4 + num - 1; rn++)
1300                     {
1301                        register_offsets[rn] = stacksize - tmp;
1302                        if (csky_debug)
1303                          {
1304                            gdb_printf (gdb_stdlog,
1305                                        "csky: r%d saved at 0x%x"
1306                                        " (offset %d)\n", rn,
1307                                        register_offsets[rn], tmp);
1308                          }
1309                         tmp += 4;
1310                     }
1311                 }
1312
1313               framesize = stacksize;
1314               if (csky_debug)
1315                 gdb_printf (gdb_stdlog, "csky: continuing\n");
1316               continue;
1317             }
1318           else if (CSKY_32_IS_LRW4 (insn) || CSKY_32_IS_MOVI4 (insn)
1319                    || CSKY_32_IS_MOVIH4 (insn) || CSKY_32_IS_BMASKI4 (insn))
1320             {
1321               int adjust = 0;
1322               int offset = 0;
1323               unsigned int insn2;
1324
1325               if (csky_debug)
1326                 {
1327                   gdb_printf (gdb_stdlog,
1328                               "csky: looking at large frame\n");
1329                 }
1330               if (CSKY_32_IS_LRW4 (insn))
1331                 {
1332                   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1333                   int literal_addr = (addr + ((insn & 0xffff) << 2))
1334                                      & 0xfffffffc;
1335                   adjust = read_memory_unsigned_integer (literal_addr, 4,
1336                                                          byte_order);
1337                 }
1338               else if (CSKY_32_IS_MOVI4 (insn))
1339                 adjust = (insn  & 0xffff);
1340               else if (CSKY_32_IS_MOVIH4 (insn))
1341                 adjust = (insn & 0xffff) << 16;
1342               else
1343                 {
1344                   /* CSKY_32_IS_BMASKI4 (insn).  */
1345                   adjust = (1 << (((insn & 0x3e00000) >> 21) + 1)) - 1;
1346                 }
1347
1348               if (csky_debug)
1349                 {
1350                   gdb_printf (gdb_stdlog,
1351                               "csky: base stacksize=0x%x\n", adjust);
1352
1353                   /* May have zero or more insns which modify r4.  */
1354                   gdb_printf (gdb_stdlog,
1355                               "csky: looking for r4 adjusters...\n");
1356                 }
1357
1358               offset = 4;
1359               insn_len = csky_get_insn (gdbarch, addr + offset, &insn2);
1360               while (CSKY_IS_R4_ADJUSTER (insn2))
1361                 {
1362                   if (CSKY_32_IS_ADDI4 (insn2))
1363                     {
1364                       int imm = (insn2 & 0xfff) + 1;
1365                       adjust += imm;
1366                       if (csky_debug)
1367                         {
1368                           gdb_printf (gdb_stdlog,
1369                                       "csky: addi r4,%d\n", imm);
1370                         }
1371                     }
1372                   else if (CSKY_32_IS_SUBI4 (insn2))
1373                     {
1374                       int imm = (insn2 & 0xfff) + 1;
1375                       adjust -= imm;
1376                       if (csky_debug)
1377                         {
1378                           gdb_printf (gdb_stdlog,
1379                                       "csky: subi r4,%d\n", imm);
1380                         }
1381                     }
1382                   else if (CSKY_32_IS_NOR4 (insn2))
1383                     {
1384                       adjust = ~adjust;
1385                       if (csky_debug)
1386                         {
1387                           gdb_printf (gdb_stdlog,
1388                                       "csky: nor r4,r4,r4\n");
1389                         }
1390                     }
1391                   else if (CSKY_32_IS_ROTLI4 (insn2))
1392                     {
1393                       int imm = ((insn2 >> 21) & 0x1f);
1394                       int temp = adjust >> (32 - imm);
1395                       adjust <<= imm;
1396                       adjust |= temp;
1397                       if (csky_debug)
1398                         {
1399                           gdb_printf (gdb_stdlog,
1400                                       "csky: rotli r4,r4,%d\n", imm);
1401                         }
1402                     }
1403                   else if (CSKY_32_IS_LISI4 (insn2))
1404                     {
1405                       int imm = ((insn2 >> 21) & 0x1f);
1406                       adjust <<= imm;
1407                       if (csky_debug)
1408                         {
1409                           gdb_printf (gdb_stdlog,
1410                                       "csky: lsli r4,r4,%d\n", imm);
1411                         }
1412                     }
1413                   else if (CSKY_32_IS_BSETI4 (insn2))
1414                     {
1415                       int imm = ((insn2 >> 21) & 0x1f);
1416                       adjust |= (1 << imm);
1417                       if (csky_debug)
1418                         {
1419                           gdb_printf (gdb_stdlog,
1420                                       "csky: bseti r4,r4 %d\n", imm);
1421                         }
1422                     }
1423                   else if (CSKY_32_IS_BCLRI4 (insn2))
1424                     {
1425                       int imm = ((insn2 >> 21) & 0x1f);
1426                       adjust &= ~(1 << imm);
1427                       if (csky_debug)
1428                         {
1429                           gdb_printf (gdb_stdlog,
1430                                       "csky: bclri r4,r4 %d\n", imm);
1431                         }
1432                     }
1433                   else if (CSKY_32_IS_IXH4 (insn2))
1434                     {
1435                       adjust *= 3;
1436                       if (csky_debug)
1437                         {
1438                           gdb_printf (gdb_stdlog,
1439                                       "csky: ixh r4,r4,r4\n");
1440                         }
1441                     }
1442                   else if (CSKY_32_IS_IXW4 (insn2))
1443                     {
1444                       adjust *= 5;
1445                       if (csky_debug)
1446                         {
1447                           gdb_printf (gdb_stdlog,
1448                                       "csky: ixw r4,r4,r4\n");
1449                         }
1450                     }
1451                   else if (CSKY_16_IS_ADDI4 (insn2))
1452                     {
1453                       int imm = (insn2 & 0xff) + 1;
1454                       adjust += imm;
1455                       if (csky_debug)
1456                         {
1457                           gdb_printf (gdb_stdlog,
1458                                       "csky: addi r4,%d\n", imm);
1459                         }
1460                     }
1461                   else if (CSKY_16_IS_SUBI4 (insn2))
1462                     {
1463                       int imm = (insn2 & 0xff) + 1;
1464                       adjust -= imm;
1465                       if (csky_debug)
1466                         {
1467                           gdb_printf (gdb_stdlog,
1468                                       "csky: subi r4,%d\n", imm);
1469                         }
1470                     }
1471                   else if (CSKY_16_IS_NOR4 (insn2))
1472                     {
1473                       adjust = ~adjust;
1474                       if (csky_debug)
1475                         {
1476                           gdb_printf (gdb_stdlog,
1477                                       "csky: nor r4,r4\n");
1478                         }
1479                     }
1480                   else if (CSKY_16_IS_BSETI4 (insn2))
1481                     {
1482                       int imm = (insn2 & 0x1f);
1483                       adjust |= (1 << imm);
1484                       if (csky_debug)
1485                         {
1486                           gdb_printf (gdb_stdlog,
1487                                       "csky: bseti r4, %d\n", imm);
1488                         }
1489                     }
1490                   else if (CSKY_16_IS_BCLRI4 (insn2))
1491                     {
1492                       int imm = (insn2 & 0x1f);
1493                       adjust &= ~(1 << imm);
1494                       if (csky_debug)
1495                         {
1496                           gdb_printf (gdb_stdlog,
1497                                       "csky: bclri r4, %d\n", imm);
1498                         }
1499                     }
1500                   else if (CSKY_16_IS_LSLI4 (insn2))
1501                     {
1502                       int imm = (insn2 & 0x1f);
1503                       adjust <<= imm;
1504                       if (csky_debug)
1505                         {
1506                           gdb_printf (gdb_stdlog,
1507                                       "csky: lsli r4,r4, %d\n", imm);
1508                         }
1509                     }
1510
1511                   offset += insn_len;
1512                   insn_len =  csky_get_insn (gdbarch, addr + offset, &insn2);
1513                 };
1514
1515               if (csky_debug)
1516                 {
1517                   gdb_printf (gdb_stdlog, "csky: done looking for"
1518                               " r4 adjusters\n");
1519                 }
1520
1521               /* If the next insn adjusts the stack pointer, we keep
1522                  everything; if not, we scrap it and we've found the
1523                  end of the prologue.  */
1524               if (CSKY_IS_SUBU4 (insn2))
1525                 {
1526                   addr += offset;
1527                   stacksize += adjust;
1528                   if (csky_debug)
1529                     {
1530                       gdb_printf (gdb_stdlog,
1531                                   "csky: found stack adjustment of"
1532                                   " 0x%x bytes.\n", adjust);
1533                       gdb_printf (gdb_stdlog,
1534                                   "csky: skipping to new address %s\n",
1535                                   core_addr_to_string_nz (addr));
1536                       gdb_printf (gdb_stdlog,
1537                                   "csky: continuing\n");
1538                     }
1539                   continue;
1540                 }
1541
1542               /* None of these instructions are prologue, so don't touch
1543                  anything.  */
1544               if (csky_debug)
1545                 {
1546                   gdb_printf (gdb_stdlog,
1547                               "csky: no subu sp,sp,r4; NOT altering"
1548                               " stacksize.\n");
1549                 }
1550               break;
1551             }
1552         }
1553       else
1554         {
1555           /* insn_len != 4.  */
1556
1557           /* subi.sp sp,disp.  */
1558           if (CSKY_16_IS_SUBI0 (insn))
1559             {
1560               int offset = CSKY_16_SUBI_IMM (insn);
1561               if (csky_debug)
1562                 {
1563                   gdb_printf (gdb_stdlog,
1564                               "csky: got subi r0,%d; continuing\n",
1565                               offset);
1566                 }
1567               stacksize += offset;
1568               continue;
1569             }
1570           /* stw.16 rz,(sp,disp).  */
1571           else if (CSKY_16_IS_STWx0 (insn))
1572             {
1573               /* Spill register: see note for IS_STM above.  */
1574               int disp;
1575
1576               rn = CSKY_16_ST_VAL_REGNUM (insn);
1577               disp = CSKY_16_ST_OFFSET (insn);
1578               register_offsets[rn] = stacksize - disp;
1579               if (csky_debug)
1580                 print_savedreg_msg (rn, register_offsets, true);
1581               continue;
1582             }
1583           else if (CSKY_16_IS_MOV_FP_SP (insn))
1584             {
1585               /* SP is saved to FP reg, means prologue may modify SP.  */
1586               is_fp_saved = 1;
1587               adjust_fp = stacksize;
1588               continue;
1589             }
1590           else if (CSKY_16_IS_PUSH (insn))
1591             {
1592               /* Push for 16_bit.  */
1593               int offset = 0;
1594               if (CSKY_16_IS_PUSH_R15 (insn))
1595                 {
1596                   stacksize += 4;
1597                   register_offsets[15] = stacksize;
1598                   if (csky_debug)
1599                     print_savedreg_msg (15, register_offsets, false);
1600                   offset += 4;
1601                  }
1602               if (CSKY_16_PUSH_LIST1 (insn))
1603                 {
1604                   int num = CSKY_16_PUSH_LIST1 (insn);
1605                   int tmp = 0;
1606                   stacksize += num * 4;
1607                   offset += num * 4;
1608                   if (csky_debug)
1609                     {
1610                       gdb_printf (gdb_stdlog,
1611                                   "csky: push regs_array: r4-r%d\n",
1612                                   4 + num - 1);
1613                     }
1614                   for (rn = 4; rn <= 4 + num - 1; rn++)
1615                     {
1616                        register_offsets[rn] = stacksize - tmp;
1617                        if (csky_debug)
1618                          {
1619                            gdb_printf (gdb_stdlog,
1620                                        "csky: r%d saved at 0x%x"
1621                                        " (offset %d)\n", rn,
1622                                        register_offsets[rn], offset);
1623                          }
1624                        tmp += 4;
1625                     }
1626                 }
1627
1628               framesize = stacksize;
1629               if (csky_debug)
1630                 gdb_printf (gdb_stdlog, "csky: continuing\n");
1631               continue;
1632             }
1633           else if (CSKY_16_IS_LRW4 (insn) || CSKY_16_IS_MOVI4 (insn))
1634             {
1635               int adjust = 0;
1636               unsigned int insn2;
1637
1638               if (csky_debug)
1639                 {
1640                   gdb_printf (gdb_stdlog,
1641                               "csky: looking at large frame\n");
1642                 }
1643               if (CSKY_16_IS_LRW4 (insn))
1644                 {
1645                   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1646                   int offset = ((insn & 0x300) >> 3) | (insn & 0x1f);
1647                   int literal_addr = (addr + ( offset << 2)) & 0xfffffffc;
1648                   adjust = read_memory_unsigned_integer (literal_addr, 4,
1649                                                          byte_order);
1650                 }
1651               else
1652                 {
1653                   /* CSKY_16_IS_MOVI4 (insn).  */
1654                   adjust = (insn  & 0xff);
1655                 }
1656
1657               if (csky_debug)
1658                 {
1659                   gdb_printf (gdb_stdlog,
1660                               "csky: base stacksize=0x%x\n", adjust);
1661                 }
1662
1663               /* May have zero or more instructions which modify r4.  */
1664               if (csky_debug)
1665                 {
1666                   gdb_printf (gdb_stdlog,
1667                               "csky: looking for r4 adjusters...\n");
1668                 }
1669               int offset = 2;
1670               insn_len = csky_get_insn (gdbarch, addr + offset, &insn2);
1671               while (CSKY_IS_R4_ADJUSTER (insn2))
1672                 {
1673                   if (CSKY_32_IS_ADDI4 (insn2))
1674                     {
1675                       int imm = (insn2 & 0xfff) + 1;
1676                       adjust += imm;
1677                       if (csky_debug)
1678                         {
1679                           gdb_printf (gdb_stdlog,
1680                                       "csky: addi r4,%d\n", imm);
1681                         }
1682                     }
1683                   else if (CSKY_32_IS_SUBI4 (insn2))
1684                     {
1685                       int imm = (insn2 & 0xfff) + 1;
1686                       adjust -= imm;
1687                       if (csky_debug)
1688                         {
1689                           gdb_printf (gdb_stdlog,
1690                                       "csky: subi r4,%d\n", imm);
1691                         }
1692                     }
1693                   else if (CSKY_32_IS_NOR4 (insn2))
1694                     {
1695                       adjust = ~adjust;
1696                       if (csky_debug)
1697                         {
1698                           gdb_printf (gdb_stdlog,
1699                                       "csky: nor r4,r4,r4\n");
1700                         }
1701                     }
1702                   else if (CSKY_32_IS_ROTLI4 (insn2))
1703                     {
1704                       int imm = ((insn2 >> 21) & 0x1f);
1705                       int temp = adjust >> (32 - imm);
1706                       adjust <<= imm;
1707                       adjust |= temp;
1708                       if (csky_debug)
1709                         {
1710                           gdb_printf (gdb_stdlog,
1711                                       "csky: rotli r4,r4,%d\n", imm);
1712                         }
1713                     }
1714                   else if (CSKY_32_IS_LISI4 (insn2))
1715                     {
1716                       int imm = ((insn2 >> 21) & 0x1f);
1717                       adjust <<= imm;
1718                       if (csky_debug)
1719                         {
1720                           gdb_printf (gdb_stdlog,
1721                                       "csky: lsli r4,r4,%d\n", imm);
1722                         }
1723                     }
1724                   else if (CSKY_32_IS_BSETI4 (insn2))
1725                     {
1726                       int imm = ((insn2 >> 21) & 0x1f);
1727                       adjust |= (1 << imm);
1728                       if (csky_debug)
1729                         {
1730                           gdb_printf (gdb_stdlog,
1731                                       "csky: bseti r4,r4 %d\n", imm);
1732                         }
1733                     }
1734                   else if (CSKY_32_IS_BCLRI4 (insn2))
1735                     {
1736                       int imm = ((insn2 >> 21) & 0x1f);
1737                       adjust &= ~(1 << imm);
1738                       if (csky_debug)
1739                         {
1740                           gdb_printf (gdb_stdlog,
1741                                       "csky: bclri r4,r4 %d\n", imm);
1742                         }
1743                     }
1744                   else if (CSKY_32_IS_IXH4 (insn2))
1745                     {
1746                       adjust *= 3;
1747                       if (csky_debug)
1748                         {
1749                           gdb_printf (gdb_stdlog,
1750                                       "csky: ixh r4,r4,r4\n");
1751                         }
1752                     }
1753                   else if (CSKY_32_IS_IXW4 (insn2))
1754                     {
1755                       adjust *= 5;
1756                       if (csky_debug)
1757                         {
1758                           gdb_printf (gdb_stdlog,
1759                                       "csky: ixw r4,r4,r4\n");
1760                         }
1761                     }
1762                   else if (CSKY_16_IS_ADDI4 (insn2))
1763                     {
1764                       int imm = (insn2 & 0xff) + 1;
1765                       adjust += imm;
1766                       if (csky_debug)
1767                         {
1768                           gdb_printf (gdb_stdlog,
1769                                       "csky: addi r4,%d\n", imm);
1770                         }
1771                     }
1772                   else if (CSKY_16_IS_SUBI4 (insn2))
1773                     {
1774                       int imm = (insn2 & 0xff) + 1;
1775                       adjust -= imm;
1776                       if (csky_debug)
1777                         {
1778                           gdb_printf (gdb_stdlog,
1779                                       "csky: subi r4,%d\n", imm);
1780                         }
1781                     }
1782                   else if (CSKY_16_IS_NOR4 (insn2))
1783                     {
1784                       adjust = ~adjust;
1785                       if (csky_debug)
1786                         {
1787                           gdb_printf (gdb_stdlog,
1788                                       "csky: nor r4,r4\n");
1789                         }
1790                     }
1791                   else if (CSKY_16_IS_BSETI4 (insn2))
1792                     {
1793                       int imm = (insn2 & 0x1f);
1794                       adjust |= (1 << imm);
1795                       if (csky_debug)
1796                         {
1797                           gdb_printf (gdb_stdlog,
1798                                       "csky: bseti r4, %d\n", imm);
1799                         }
1800                     }
1801                   else if (CSKY_16_IS_BCLRI4 (insn2))
1802                     {
1803                       int imm = (insn2 & 0x1f);
1804                       adjust &= ~(1 << imm);
1805                       if (csky_debug)
1806                         {
1807                           gdb_printf (gdb_stdlog,
1808                                       "csky: bclri r4, %d\n", imm);
1809                         }
1810                     }
1811                   else if (CSKY_16_IS_LSLI4 (insn2))
1812                     {
1813                       int imm = (insn2 & 0x1f);
1814                       adjust <<= imm;
1815                       if (csky_debug)
1816                         {
1817                           gdb_printf (gdb_stdlog,
1818                                       "csky: lsli r4,r4, %d\n", imm);
1819                         }
1820                     }
1821
1822                   offset += insn_len;
1823                   insn_len = csky_get_insn (gdbarch, addr + offset, &insn2);
1824                 };
1825
1826               if (csky_debug)
1827                 {
1828                   gdb_printf (gdb_stdlog, "csky: "
1829                               "done looking for r4 adjusters\n");
1830                 }
1831
1832               /* If the next instruction adjusts the stack pointer, we keep
1833                  everything; if not, we scrap it and we've found the end
1834                  of the prologue.  */
1835               if (CSKY_IS_SUBU4 (insn2))
1836                 {
1837                   addr += offset;
1838                   stacksize += adjust;
1839                   if (csky_debug)
1840                     {
1841                       gdb_printf (gdb_stdlog, "csky: "
1842                                   "found stack adjustment of 0x%x"
1843                                   " bytes.\n", adjust);
1844                       gdb_printf (gdb_stdlog, "csky: "
1845                                   "skipping to new address %s\n",
1846                                   core_addr_to_string_nz (addr));
1847                       gdb_printf (gdb_stdlog, "csky: continuing\n");
1848                     }
1849                   continue;
1850                 }
1851
1852               /* None of these instructions are prologue, so don't touch
1853                  anything.  */
1854               if (csky_debug)
1855                 {
1856                   gdb_printf (gdb_stdlog, "csky: no subu sp,r4; "
1857                               "NOT altering stacksize.\n");
1858                 }
1859               break;
1860             }
1861         }
1862
1863       /* This is not a prologue instruction, so stop here.  */
1864       if (csky_debug)
1865         {
1866           gdb_printf (gdb_stdlog, "csky: insn is not a prologue"
1867                       " insn -- ending scan\n");
1868         }
1869       break;
1870     }
1871
1872   if (this_cache)
1873     {
1874       CORE_ADDR unwound_fp;
1875       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1876       this_cache->framesize = framesize;
1877
1878       if (is_fp_saved)
1879         {
1880           this_cache->framereg = CSKY_FP_REGNUM;
1881           unwound_fp = get_frame_register_unsigned (this_frame,
1882                                                     this_cache->framereg);
1883           this_cache->prev_sp = unwound_fp + adjust_fp;
1884         }
1885       else
1886         {
1887           this_cache->framereg = CSKY_SP_REGNUM;
1888           unwound_fp = get_frame_register_unsigned (this_frame,
1889                                                     this_cache->framereg);
1890           this_cache->prev_sp = unwound_fp + stacksize;
1891         }
1892
1893       /* Note where saved registers are stored.  The offsets in
1894          REGISTER_OFFSETS are computed relative to the top of the frame.  */
1895       for (rn = 0; rn < CSKY_NUM_GREGS; rn++)
1896         {
1897           if (register_offsets[rn] >= 0)
1898             {
1899               this_cache->saved_regs[rn].set_addr (this_cache->prev_sp
1900                                                    - register_offsets[rn]);
1901               if (csky_debug)
1902                 {
1903                   CORE_ADDR rn_value = read_memory_unsigned_integer (
1904                     this_cache->saved_regs[rn].addr (), 4, byte_order);
1905                   gdb_printf (gdb_stdlog, "Saved register %s "
1906                               "stored at 0x%08lx, value=0x%08lx\n",
1907                               csky_register_names[rn],
1908                               (unsigned long)
1909                               this_cache->saved_regs[rn].addr (),
1910                               (unsigned long) rn_value);
1911                 }
1912             }
1913         }
1914       if (lr_type == LR_TYPE_EPC)
1915         {
1916           /* rte || epc .  */
1917           this_cache->saved_regs[CSKY_PC_REGNUM]
1918             = this_cache->saved_regs[CSKY_EPC_REGNUM];
1919         }
1920       else if (lr_type == LR_TYPE_FPC)
1921         {
1922           /* rfi || fpc .  */
1923           this_cache->saved_regs[CSKY_PC_REGNUM]
1924             = this_cache->saved_regs[CSKY_FPC_REGNUM];
1925         }
1926       else
1927         {
1928           this_cache->saved_regs[CSKY_PC_REGNUM]
1929             = this_cache->saved_regs[CSKY_LR_REGNUM];
1930         }
1931     }
1932
1933   return addr;
1934 }
1935
1936 /* Detect whether PC is at a point where the stack frame has been
1937    destroyed.  */
1938
1939 static int
1940 csky_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1941 {
1942   unsigned int insn;
1943   CORE_ADDR addr;
1944   CORE_ADDR func_start, func_end;
1945
1946   if (!find_pc_partial_function (pc, NULL, &func_start, &func_end))
1947     return 0;
1948
1949   bool fp_saved = false;
1950   int insn_len;
1951   for (addr = func_start; addr < func_end; addr += insn_len)
1952     {
1953       /* Get next insn.  */
1954       insn_len = csky_get_insn (gdbarch, addr, &insn);
1955
1956       if (insn_len == 2)
1957         {
1958           /* Is sp is saved to fp.  */
1959           if (CSKY_16_IS_MOV_FP_SP (insn))
1960             fp_saved = true;
1961           /* If sp was saved to fp and now being restored from
1962              fp then it indicates the start of epilog.  */
1963           else if (fp_saved && CSKY_16_IS_MOV_SP_FP (insn))
1964             return pc >= addr;
1965         }
1966     }
1967   return 0;
1968 }
1969
1970 /* Implement the skip_prologue gdbarch hook.  */
1971
1972 static CORE_ADDR
1973 csky_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1974 {
1975   CORE_ADDR func_addr, func_end;
1976   const int default_search_limit = 128;
1977
1978   /* See if we can find the end of the prologue using the symbol table.  */
1979   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1980     {
1981       CORE_ADDR post_prologue_pc
1982         = skip_prologue_using_sal (gdbarch, func_addr);
1983
1984       if (post_prologue_pc != 0)
1985         return std::max (pc, post_prologue_pc);
1986     }
1987   else
1988     func_end = pc + default_search_limit;
1989
1990   /* Find the end of prologue.  Default lr_type.  */
1991   return csky_analyze_prologue (gdbarch, pc, func_end, func_end,
1992                                 NULL, NULL, LR_TYPE_R15);
1993 }
1994
1995 /* Implement the breakpoint_kind_from_pc gdbarch method.  */
1996
1997 static int
1998 csky_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
1999 {
2000   if (csky_pc_is_csky16 (gdbarch, *pcptr))
2001     return CSKY_INSN_SIZE16;
2002   else
2003     return CSKY_INSN_SIZE32;
2004 }
2005
2006 /* Implement the sw_breakpoint_from_kind gdbarch method.  */
2007
2008 static const gdb_byte *
2009 csky_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
2010 {
2011   *size = kind;
2012   if (kind == CSKY_INSN_SIZE16)
2013     {
2014       static gdb_byte csky_16_breakpoint[] = { 0, 0 };
2015       return csky_16_breakpoint;
2016     }
2017   else
2018     {
2019       static gdb_byte csky_32_breakpoint[] = { 0, 0, 0, 0 };
2020       return csky_32_breakpoint;
2021     }
2022 }
2023
2024 /* Determine link register type.  */
2025
2026 static lr_type_t
2027 csky_analyze_lr_type (struct gdbarch *gdbarch,
2028                       CORE_ADDR start_pc, CORE_ADDR end_pc)
2029 {
2030   CORE_ADDR addr;
2031   unsigned int insn, insn_len;
2032   insn_len = 2;
2033
2034   for (addr = start_pc; addr < end_pc; addr += insn_len)
2035     {
2036       insn_len = csky_get_insn (gdbarch, addr, &insn);
2037       if (insn_len == 4)
2038         {
2039           if (CSKY_32_IS_MFCR_EPSR (insn) || CSKY_32_IS_MFCR_EPC (insn)
2040               || CSKY_32_IS_RTE (insn))
2041             return LR_TYPE_EPC;
2042         }
2043       else if (CSKY_32_IS_MFCR_FPSR (insn) || CSKY_32_IS_MFCR_FPC (insn)
2044                || CSKY_32_IS_RFI (insn))
2045         return LR_TYPE_FPC;
2046       else if (CSKY_32_IS_JMP (insn) || CSKY_32_IS_BR (insn)
2047                || CSKY_32_IS_JMPIX (insn) || CSKY_32_IS_JMPI (insn))
2048         return LR_TYPE_R15;
2049       else
2050         {
2051           /* 16 bit instruction.  */
2052           if (CSKY_16_IS_JMP (insn) || CSKY_16_IS_BR (insn)
2053               || CSKY_16_IS_JMPIX (insn))
2054             return LR_TYPE_R15;
2055         }
2056     }
2057     return LR_TYPE_R15;
2058 }
2059
2060 /* Heuristic unwinder.  */
2061
2062 static struct csky_unwind_cache *
2063 csky_frame_unwind_cache (frame_info_ptr this_frame)
2064 {
2065   CORE_ADDR prologue_start, prologue_end, func_end, prev_pc, block_addr;
2066   struct csky_unwind_cache *cache;
2067   const struct block *bl;
2068   unsigned long func_size = 0;
2069   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2070   unsigned int sp_regnum = CSKY_SP_REGNUM;
2071
2072   /* Default lr type is r15.  */
2073   lr_type_t lr_type = LR_TYPE_R15;
2074
2075   cache = FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache);
2076   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2077
2078   /* Assume there is no frame until proven otherwise.  */
2079   cache->framereg = sp_regnum;
2080
2081   cache->framesize = 0;
2082
2083   prev_pc = get_frame_pc (this_frame);
2084   block_addr = get_frame_address_in_block (this_frame);
2085   if (find_pc_partial_function (block_addr, NULL, &prologue_start,
2086                                 &func_end) == 0)
2087     /* We couldn't find a function containing block_addr, so bail out
2088        and hope for the best.  */
2089     return cache;
2090
2091   /* Get the (function) symbol matching prologue_start.  */
2092   bl = block_for_pc (prologue_start);
2093   if (bl != NULL)
2094     func_size = bl->end () - bl->start ();
2095   else
2096     {
2097       struct bound_minimal_symbol msymbol
2098         = lookup_minimal_symbol_by_pc (prologue_start);
2099       if (msymbol.minsym != NULL)
2100         func_size = msymbol.minsym->size ();
2101     }
2102
2103   /* If FUNC_SIZE is 0 we may have a special-case use of lr
2104      e.g. exception or interrupt.  */
2105   if (func_size == 0)
2106     lr_type = csky_analyze_lr_type (gdbarch, prologue_start, func_end);
2107
2108   prologue_end = std::min (func_end, prev_pc);
2109
2110   /* Analyze the function prologue.  */
2111   csky_analyze_prologue (gdbarch, prologue_start, prologue_end,
2112                             func_end, this_frame, cache, lr_type);
2113
2114   /* gdbarch_sp_regnum contains the value and not the address.  */
2115   cache->saved_regs[sp_regnum].set_value (cache->prev_sp);
2116   return cache;
2117 }
2118
2119 /* Implement the this_id function for the normal unwinder.  */
2120
2121 static void
2122 csky_frame_this_id (frame_info_ptr this_frame,
2123                     void **this_prologue_cache, struct frame_id *this_id)
2124 {
2125   struct csky_unwind_cache *cache;
2126   struct frame_id id;
2127
2128   if (*this_prologue_cache == NULL)
2129     *this_prologue_cache = csky_frame_unwind_cache (this_frame);
2130   cache = (struct csky_unwind_cache *) *this_prologue_cache;
2131
2132   /* This marks the outermost frame.  */
2133   if (cache->prev_sp == 0)
2134     return;
2135
2136   id = frame_id_build (cache->prev_sp, get_frame_func (this_frame));
2137   *this_id = id;
2138 }
2139
2140 /* Implement the prev_register function for the normal unwinder.  */
2141
2142 static struct value *
2143 csky_frame_prev_register (frame_info_ptr this_frame,
2144                           void **this_prologue_cache, int regnum)
2145 {
2146   struct csky_unwind_cache *cache;
2147
2148   if (*this_prologue_cache == NULL)
2149     *this_prologue_cache = csky_frame_unwind_cache (this_frame);
2150   cache = (struct csky_unwind_cache *) *this_prologue_cache;
2151
2152   return trad_frame_get_prev_register (this_frame, cache->saved_regs,
2153                                        regnum);
2154 }
2155
2156 /* Data structures for the normal prologue-analysis-based
2157    unwinder.  */
2158
2159 static const struct frame_unwind csky_unwind_cache = {
2160   "cski prologue",
2161   NORMAL_FRAME,
2162   default_frame_unwind_stop_reason,
2163   csky_frame_this_id,
2164   csky_frame_prev_register,
2165   NULL,
2166   default_frame_sniffer,
2167   NULL,
2168   NULL
2169 };
2170
2171 static CORE_ADDR
2172 csky_check_long_branch (frame_info_ptr frame, CORE_ADDR pc)
2173 {
2174   gdb_byte buf[8];
2175   struct gdbarch *gdbarch = get_frame_arch (frame);
2176   enum bfd_endian byte_order_for_code
2177         = gdbarch_byte_order_for_code (gdbarch);
2178
2179   if (target_read_memory (pc, buf, 8) == 0)
2180     {
2181       unsigned int data0
2182         = extract_unsigned_integer (buf, 4, byte_order_for_code);
2183       unsigned int data1
2184         = extract_unsigned_integer (buf + 4, 4, byte_order_for_code);
2185
2186       /* Case: jmpi [pc+4] : 0xeac00001
2187          .long addr   */
2188       if (data0 == CSKY_JMPI_PC_4)
2189         return data1;
2190
2191       /* Case: lrw t1, [pc+8] : 0xea8d0002
2192                jmp t1         : 0x7834
2193                nop            : 0x6c03
2194                .long addr  */
2195       if ((data0 == CSKY_LRW_T1_PC_8) && (data1 == CSKY_JMP_T1_VS_NOP))
2196         {
2197           if (target_read_memory (pc + 8, buf, 4) == 0)
2198             return  extract_unsigned_integer (buf, 4, byte_order_for_code);
2199         }
2200
2201       return 0;
2202     }
2203
2204   return 0;
2205 }
2206
2207 static int
2208 csky_stub_unwind_sniffer (const struct frame_unwind *self,
2209                           frame_info_ptr this_frame,
2210                           void **this_prologue_cache)
2211 {
2212   CORE_ADDR addr_in_block, pc;
2213   gdb_byte dummy[4];
2214   const char *name;
2215   CORE_ADDR start_addr;
2216
2217   /* Get pc */
2218   addr_in_block = get_frame_address_in_block (this_frame);
2219   pc = get_frame_pc (this_frame);
2220
2221   if (in_plt_section (addr_in_block)
2222       || target_read_memory (pc, dummy, 4) != 0)
2223     return 1;
2224
2225   /* Find the starting address and name of the function containing the PC.  */
2226   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
2227     {
2228       start_addr = csky_check_long_branch (this_frame, pc);
2229       /* if not long branch, return 0.  */
2230       if (start_addr != 0)
2231         return 1;
2232
2233       return 0;
2234     }
2235
2236   return 0;
2237 }
2238
2239 static struct csky_unwind_cache *
2240 csky_make_stub_cache (frame_info_ptr this_frame)
2241 {
2242   struct csky_unwind_cache *cache;
2243
2244   cache = FRAME_OBSTACK_ZALLOC (struct csky_unwind_cache);
2245   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2246   cache->prev_sp = get_frame_register_unsigned (this_frame, CSKY_SP_REGNUM);
2247
2248   return cache;
2249 }
2250
2251 static void
2252 csky_stub_this_id (frame_info_ptr this_frame,
2253                   void **this_cache,
2254                   struct frame_id *this_id)
2255 {
2256   struct csky_unwind_cache *cache;
2257
2258   if (*this_cache == NULL)
2259     *this_cache = csky_make_stub_cache (this_frame);
2260   cache = (struct csky_unwind_cache *) *this_cache;
2261
2262   /* Our frame ID for a stub frame is the current SP and LR.  */
2263   *this_id = frame_id_build (cache->prev_sp, get_frame_pc (this_frame));
2264 }
2265
2266 static struct value *
2267 csky_stub_prev_register (frame_info_ptr this_frame,
2268                             void **this_cache,
2269                             int prev_regnum)
2270 {
2271   struct csky_unwind_cache *cache;
2272
2273   if (*this_cache == NULL)
2274     *this_cache = csky_make_stub_cache (this_frame);
2275   cache = (struct csky_unwind_cache *) *this_cache;
2276
2277   /* If we are asked to unwind the PC, then return the LR.  */
2278   if (prev_regnum == CSKY_PC_REGNUM)
2279     {
2280       CORE_ADDR lr;
2281
2282       lr = frame_unwind_register_unsigned (this_frame, CSKY_LR_REGNUM);
2283       return frame_unwind_got_constant (this_frame, prev_regnum, lr);
2284     }
2285
2286   if (prev_regnum == CSKY_SP_REGNUM)
2287     return frame_unwind_got_constant (this_frame, prev_regnum, cache->prev_sp);
2288
2289   return trad_frame_get_prev_register (this_frame, cache->saved_regs,
2290                                        prev_regnum);
2291 }
2292
2293 static frame_unwind csky_stub_unwind = {
2294   "csky stub",
2295   NORMAL_FRAME,
2296   default_frame_unwind_stop_reason,
2297   csky_stub_this_id,
2298   csky_stub_prev_register,
2299   NULL,
2300   csky_stub_unwind_sniffer
2301 };
2302
2303 /* Implement the this_base, this_locals, and this_args hooks
2304    for the normal unwinder.  */
2305
2306 static CORE_ADDR
2307 csky_frame_base_address (frame_info_ptr this_frame, void **this_cache)
2308 {
2309   struct csky_unwind_cache *cache;
2310
2311   if (*this_cache == NULL)
2312     *this_cache = csky_frame_unwind_cache (this_frame);
2313   cache = (struct csky_unwind_cache *) *this_cache;
2314
2315   return cache->prev_sp - cache->framesize;
2316 }
2317
2318 static const struct frame_base csky_frame_base = {
2319   &csky_unwind_cache,
2320   csky_frame_base_address,
2321   csky_frame_base_address,
2322   csky_frame_base_address
2323 };
2324
2325 /* Initialize register access method.  */
2326
2327 static void
2328 csky_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
2329                             struct dwarf2_frame_state_reg *reg,
2330                             frame_info_ptr this_frame)
2331 {
2332   if (regnum == gdbarch_pc_regnum (gdbarch))
2333     reg->how = DWARF2_FRAME_REG_RA;
2334   else if (regnum == gdbarch_sp_regnum (gdbarch))
2335     reg->how = DWARF2_FRAME_REG_CFA;
2336 }
2337
2338 /* Create csky register groups.  */
2339
2340 static void
2341 csky_init_reggroup ()
2342 {
2343   cr_reggroup = reggroup_new ("cr", USER_REGGROUP);
2344   fr_reggroup = reggroup_new ("fr", USER_REGGROUP);
2345   vr_reggroup = reggroup_new ("vr", USER_REGGROUP);
2346   mmu_reggroup = reggroup_new ("mmu", USER_REGGROUP);
2347   prof_reggroup = reggroup_new ("profiling", USER_REGGROUP);
2348 }
2349
2350 /* Add register groups into reggroup list.  */
2351
2352 static void
2353 csky_add_reggroups (struct gdbarch *gdbarch)
2354 {
2355   reggroup_add (gdbarch, cr_reggroup);
2356   reggroup_add (gdbarch, fr_reggroup);
2357   reggroup_add (gdbarch, vr_reggroup);
2358   reggroup_add (gdbarch, mmu_reggroup);
2359   reggroup_add (gdbarch, prof_reggroup);
2360 }
2361
2362 /* Return the groups that a CSKY register can be categorised into.  */
2363
2364 static int
2365 csky_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
2366                           const struct reggroup *reggroup)
2367 {
2368   int raw_p;
2369
2370   if (gdbarch_register_name (gdbarch, regnum)[0] == '\0')
2371     return 0;
2372
2373   if (reggroup == all_reggroup)
2374     return 1;
2375
2376   raw_p = regnum < gdbarch_num_regs (gdbarch);
2377   if (reggroup == save_reggroup || reggroup == restore_reggroup)
2378     return raw_p;
2379
2380   if ((((regnum >= CSKY_R0_REGNUM) && (regnum <= CSKY_R0_REGNUM + 31))
2381        || (regnum == CSKY_PC_REGNUM)
2382        || (regnum == CSKY_EPC_REGNUM)
2383        || (regnum == CSKY_CR0_REGNUM)
2384        || (regnum == CSKY_EPSR_REGNUM))
2385       && (reggroup == general_reggroup))
2386     return 1;
2387
2388   if (((regnum == CSKY_PC_REGNUM)
2389        || ((regnum >= CSKY_CR0_REGNUM)
2390            && (regnum <= CSKY_CR0_REGNUM + 30)))
2391       && (reggroup == cr_reggroup))
2392     return 2;
2393
2394   if ((((regnum >= CSKY_VR0_REGNUM) && (regnum <= CSKY_VR0_REGNUM + 15))
2395        || ((regnum >= CSKY_FCR_REGNUM)
2396            && (regnum <= CSKY_FCR_REGNUM + 2)))
2397       && (reggroup == vr_reggroup))
2398     return 3;
2399
2400   if (((regnum >= CSKY_MMU_REGNUM) && (regnum <= CSKY_MMU_REGNUM + 8))
2401       && (reggroup == mmu_reggroup))
2402     return 4;
2403
2404   if (((regnum >= CSKY_PROFCR_REGNUM)
2405        && (regnum <= CSKY_PROFCR_REGNUM + 48))
2406       && (reggroup == prof_reggroup))
2407     return 5;
2408
2409   if ((((regnum >= CSKY_FR0_REGNUM) && (regnum <= CSKY_FR0_REGNUM + 15))
2410        || ((regnum >= CSKY_FCR_REGNUM) && (regnum <= CSKY_FCR_REGNUM + 2)))
2411       && (reggroup == fr_reggroup))
2412     return 6;
2413
2414   if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
2415     {
2416       if (tdesc_register_in_reggroup_p (gdbarch, regnum, reggroup) > 0)
2417         return 7;
2418     }
2419
2420   return 0;
2421 }
2422
2423 /* Implement the dwarf2_reg_to_regnum gdbarch method.  */
2424
2425 static int
2426 csky_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dw_reg)
2427 {
2428   /* For GPRs.  */
2429   if (dw_reg >= CSKY_R0_REGNUM && dw_reg <= CSKY_R0_REGNUM + 31)
2430     return dw_reg;
2431
2432   /* For Hi, Lo, PC.  */
2433   if (dw_reg == CSKY_HI_REGNUM || dw_reg == CSKY_LO_REGNUM
2434       || dw_reg == CSKY_PC_REGNUM)
2435     return dw_reg;
2436
2437   /* For Float and Vector pseudo registers.  */
2438   if (dw_reg >= FV_PSEUDO_REGNO_FIRST && dw_reg <= FV_PSEUDO_REGNO_LAST)
2439     {
2440       char name_buf[4];
2441
2442       xsnprintf (name_buf, sizeof (name_buf), "s%d",
2443                  dw_reg - FV_PSEUDO_REGNO_FIRST);
2444       return user_reg_map_name_to_regnum (gdbarch, name_buf,
2445                                           strlen (name_buf));
2446     }
2447
2448   /* Others, unknown.  */
2449   return -1;
2450 }
2451
2452 /* Check whether xml has discribled the essential regs.  */
2453
2454 static int
2455 csky_essential_reg_check (const struct csky_supported_tdesc_register *reg)
2456 {
2457   if ((strcmp (reg->name , "pc") == 0)
2458       && (reg->num == CSKY_PC_REGNUM))
2459     return CSKY_TDESC_REGS_PC_NUMBERED;
2460   else if ((strcmp (reg->name , "r14") == 0)
2461       && (reg->num == CSKY_SP_REGNUM))
2462     return CSKY_TDESC_REGS_SP_NUMBERED;
2463   else if ((strcmp (reg->name , "r15") == 0)
2464       && (reg->num == CSKY_LR_REGNUM))
2465     return CSKY_TDESC_REGS_LR_NUMBERED;
2466   else
2467     return 0;
2468 }
2469
2470 /* Check whether xml has discribled the fr0~fr15 regs.  */
2471
2472 static int
2473 csky_fr0_fr15_reg_check (const struct csky_supported_tdesc_register *reg) {
2474   int i = 0;
2475   for (i = 0; i < 16; i++)
2476     {
2477       if ((strcmp (reg->name, csky_supported_fpu_regs[i].name) == 0)
2478           && (csky_supported_fpu_regs[i].num == reg->num))
2479         return (1 << i);
2480     }
2481
2482   return 0;
2483 };
2484
2485 /* Check whether xml has discribled the fr16~fr31 regs.  */
2486
2487 static int
2488 csky_fr16_fr31_reg_check (const struct csky_supported_tdesc_register *reg) {
2489   int i = 0;
2490   for (i = 0; i < 16; i++)
2491     {
2492       if ((strcmp (reg->name, csky_supported_fpu_regs[i + 16].name) == 0)
2493           && (csky_supported_fpu_regs[i + 16].num == reg->num))
2494         return (1 << i);
2495     }
2496
2497   return 0;
2498 };
2499
2500 /* Check whether xml has discribled the vr0~vr15 regs.  */
2501
2502 static int
2503 csky_vr0_vr15_reg_check (const struct csky_supported_tdesc_register *reg) {
2504   int i = 0;
2505   for (i = 0; i < 16; i++)
2506     {
2507       if ((strcmp (reg->name, csky_supported_fpu_regs[i + 32].name) == 0)
2508           && (csky_supported_fpu_regs[i + 32].num == reg->num))
2509         return (1 << i);
2510     }
2511
2512   return 0;
2513 };
2514
2515 /* Return pseudo reg's name.  */
2516
2517 static const char *
2518 csky_pseudo_register_name (struct gdbarch *gdbarch, int regno)
2519 {
2520   int num_regs = gdbarch_num_regs (gdbarch);
2521   csky_gdbarch_tdep *tdep
2522     = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
2523
2524   regno -= num_regs;
2525
2526   if (tdep->fv_pseudo_registers_count)
2527     {
2528       static const char *const fv_pseudo_names[] = {
2529         "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2530         "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2531         "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
2532         "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
2533         "s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39",
2534         "s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47",
2535         "s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55",
2536         "s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63",
2537         "s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71",
2538         "s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79",
2539         "s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87",
2540         "s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95",
2541         "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
2542         "s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111",
2543         "s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119",
2544         "s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127",
2545       };
2546
2547       if (regno < tdep->fv_pseudo_registers_count)
2548         {
2549           if ((regno < 64) && ((regno % 4) >= 2) && !tdep->has_vr0)
2550             return "";
2551           else if ((regno >= 64) && ((regno % 4) >= 2))
2552             return "";
2553           else
2554             return fv_pseudo_names[regno];
2555         }
2556     }
2557
2558   return "";
2559 }
2560
2561 /* Read for csky pseudo regs.  */
2562
2563 static enum register_status
2564 csky_pseudo_register_read (struct gdbarch *gdbarch,
2565                            struct readable_regcache *regcache,
2566                            int regnum, gdb_byte *buf)
2567 {
2568   int num_regs = gdbarch_num_regs (gdbarch);
2569   csky_gdbarch_tdep *tdep
2570     = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
2571
2572   regnum -= num_regs;
2573
2574   if (regnum < tdep->fv_pseudo_registers_count)
2575     {
2576       enum register_status status;
2577       int gdb_regnum = 0;
2578       int offset = 0;
2579       gdb_byte reg_buf[16];
2580
2581       /* Ensure getting s0~s63 from vrx if tdep->has_vr0 is ture.  */
2582       if (tdep->has_vr0)
2583         {
2584           if (regnum < 64)
2585             {
2586               gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
2587               offset = (regnum % 4) * 4;
2588             }
2589           else
2590             {
2591               gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
2592               if ((regnum % 4) >= 2)
2593                  return REG_UNAVAILABLE;
2594               offset = (regnum % 2) * 4;
2595             }
2596         }
2597       else
2598         {
2599            gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
2600            if ((regnum % 4) >= 2)
2601               return REG_UNAVAILABLE;
2602            offset = (regnum % 2) * 4;
2603         }
2604
2605       status = regcache->raw_read (gdb_regnum, reg_buf);
2606       if (status == REG_VALID)
2607         memcpy (buf, reg_buf + offset, 4);
2608       return status;
2609     }
2610
2611   return REG_UNKNOWN;
2612 }
2613
2614 /* Write for csky pseudo regs.  */
2615
2616 static void
2617 csky_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
2618                             int regnum, const gdb_byte *buf)
2619 {
2620   int num_regs = gdbarch_num_regs (gdbarch);
2621   csky_gdbarch_tdep *tdep
2622     = gdbarch_tdep<csky_gdbarch_tdep> (gdbarch);
2623
2624   regnum -= num_regs;
2625
2626   if (regnum < tdep->fv_pseudo_registers_count)
2627     {
2628       gdb_byte reg_buf[16];
2629       int gdb_regnum = 0;
2630       int offset = 0;
2631
2632       if (tdep->has_vr0)
2633         {
2634           if (regnum < 64)
2635             {
2636               gdb_regnum = CSKY_VR0_REGNUM + (regnum / 4);
2637               offset = (regnum % 4) * 4;
2638             }
2639           else
2640             {
2641               gdb_regnum = CSKY_FR16_REGNUM + ((regnum - 64) / 4);
2642               if ((regnum % 4) >= 2)
2643                 return;
2644               offset = (regnum % 2) * 4;
2645             }
2646         }
2647       else
2648         {
2649            gdb_regnum = CSKY_FR0_REGNUM + (regnum / 4);
2650            if ((regnum % 4) >= 2)
2651              return;
2652            offset = (regnum % 2) * 4;
2653         }
2654
2655       regcache->raw_read (gdb_regnum, reg_buf);
2656       memcpy (reg_buf + offset, buf, 4);
2657       regcache->raw_write (gdb_regnum, reg_buf);
2658       return;
2659     }
2660
2661   return;
2662 }
2663
2664 /* Initialize the current architecture based on INFO.  If possible,
2665    re-use an architecture from ARCHES, which is a list of
2666    architectures already created during this debugging session.
2667
2668    Called at program startup, when reading a core file, and when
2669    reading a binary file.  */
2670
2671 static struct gdbarch *
2672 csky_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2673 {
2674   struct gdbarch *gdbarch;
2675   /* Analyze info.abfd.  */
2676   unsigned int fpu_abi = 0;
2677   unsigned int vdsp_version = 0;
2678   unsigned int fpu_hardfp = 0;
2679   /* Analyze info.target_desc */
2680   int num_regs = 0;
2681   int has_fr0 = 0;
2682   int has_fr16 = 0;
2683   int has_vr0 = 0;
2684   tdesc_arch_data_up tdesc_data;
2685
2686   if (tdesc_has_registers (info.target_desc))
2687     {
2688       int valid_p = 0;
2689       int numbered = 0;
2690       int index = 0;
2691       int i = 0;
2692       int feature_names_count = ARRAY_SIZE (csky_supported_tdesc_feature_names);
2693       int support_tdesc_regs_count
2694             = csky_get_supported_tdesc_registers_count();
2695       const struct csky_supported_tdesc_register *tdesc_reg;
2696       const struct tdesc_feature *feature;
2697
2698       tdesc_data = tdesc_data_alloc ();
2699       for (index = 0; index < feature_names_count; index ++)
2700         {
2701           feature = tdesc_find_feature (info.target_desc,
2702                       csky_supported_tdesc_feature_names[index]);
2703           if (feature != NULL)
2704             {
2705               for (i = 0; i < support_tdesc_regs_count; i++)
2706                 {
2707                   tdesc_reg = csky_get_supported_register_by_index (i);
2708                   if (!tdesc_reg)
2709                     break;
2710                   numbered = tdesc_numbered_register (feature, tdesc_data.get(),
2711                                                       tdesc_reg->num,
2712                                                       tdesc_reg->name);
2713                   if (numbered) {
2714                     valid_p |= csky_essential_reg_check (tdesc_reg);
2715                     has_fr0 |= csky_fr0_fr15_reg_check (tdesc_reg);
2716                     has_fr16 |= csky_fr16_fr31_reg_check (tdesc_reg);
2717                     has_vr0 |= csky_vr0_vr15_reg_check (tdesc_reg);
2718                     if (num_regs < tdesc_reg->num)
2719                       num_regs = tdesc_reg->num;
2720                   }
2721                 }
2722             }
2723         }
2724       if (valid_p != CSKY_TDESC_REGS_ESSENTIAL_VALUE)
2725         return NULL;
2726     }
2727
2728   /* When the type of bfd file is srec(or any files are not elf),
2729      the E_FLAGS will be not credible.  */
2730   if (info.abfd != NULL && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2731     {
2732       /* Get FPU, VDSP build options.  */
2733       fpu_abi = bfd_elf_get_obj_attr_int (info.abfd,
2734                                           OBJ_ATTR_PROC,
2735                                           Tag_CSKY_FPU_ABI);
2736       vdsp_version = bfd_elf_get_obj_attr_int (info.abfd,
2737                                                OBJ_ATTR_PROC,
2738                                                Tag_CSKY_VDSP_VERSION);
2739       fpu_hardfp = bfd_elf_get_obj_attr_int (info.abfd,
2740                                              OBJ_ATTR_PROC,
2741                                              Tag_CSKY_FPU_HARDFP);
2742     }
2743
2744   /* Find a candidate among the list of pre-declared architectures.  */
2745   for (arches = gdbarch_list_lookup_by_info (arches, &info);
2746        arches != NULL;
2747        arches = gdbarch_list_lookup_by_info (arches->next, &info))
2748     {
2749       csky_gdbarch_tdep *tdep
2750         = gdbarch_tdep<csky_gdbarch_tdep> (arches->gdbarch);
2751       if (fpu_abi != tdep->fpu_abi)
2752         continue;
2753       if (vdsp_version != tdep->vdsp_version)
2754         continue;
2755       if (fpu_hardfp != tdep->fpu_hardfp)
2756         continue;
2757
2758       /* Found a match.  */
2759       return arches->gdbarch;
2760     }
2761
2762   /* None found, create a new architecture from the information
2763      provided.  */
2764   csky_gdbarch_tdep *tdep = new csky_gdbarch_tdep;
2765   gdbarch = gdbarch_alloc (&info, tdep);
2766   tdep->fpu_abi = fpu_abi;
2767   tdep->vdsp_version = vdsp_version;
2768   tdep->fpu_hardfp = fpu_hardfp;
2769
2770   if (tdesc_data != NULL)
2771     {
2772       if ((has_vr0 == CSKY_FULL16_ONEHOT_VALUE)
2773           && (has_fr16 == CSKY_FULL16_ONEHOT_VALUE))
2774         {
2775           tdep->has_vr0 = 1;
2776           tdep->fv_pseudo_registers_count = 128;
2777         }
2778       else if ((has_vr0 == CSKY_FULL16_ONEHOT_VALUE)
2779                && (has_fr16 != CSKY_FULL16_ONEHOT_VALUE))
2780         {
2781           tdep->has_vr0 = 1;
2782           tdep->fv_pseudo_registers_count = 64;
2783         }
2784       else if ((has_fr0 == CSKY_FULL16_ONEHOT_VALUE)
2785                && (has_vr0 != CSKY_FULL16_ONEHOT_VALUE))
2786         {
2787           tdep->has_vr0 = 0;
2788           tdep->fv_pseudo_registers_count = 64;
2789         }
2790       else
2791         {
2792           tdep->has_vr0 = 0;
2793           tdep->fv_pseudo_registers_count = 0;
2794         }
2795     }
2796   else
2797     {
2798       tdep->has_vr0 = 1;
2799       tdep->fv_pseudo_registers_count = 64;
2800     }
2801
2802   /* Target data types.  */
2803   set_gdbarch_ptr_bit (gdbarch, 32);
2804   set_gdbarch_addr_bit (gdbarch, 32);
2805   set_gdbarch_short_bit (gdbarch, 16);
2806   set_gdbarch_int_bit (gdbarch, 32);
2807   set_gdbarch_long_bit (gdbarch, 32);
2808   set_gdbarch_long_long_bit (gdbarch, 64);
2809   set_gdbarch_float_bit (gdbarch, 32);
2810   set_gdbarch_double_bit (gdbarch, 64);
2811   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
2812   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
2813
2814   /* Information about the target architecture.  */
2815   set_gdbarch_return_value (gdbarch, csky_return_value);
2816   set_gdbarch_breakpoint_kind_from_pc (gdbarch, csky_breakpoint_kind_from_pc);
2817   set_gdbarch_sw_breakpoint_from_kind (gdbarch, csky_sw_breakpoint_from_kind);
2818
2819   /* Register architecture.  */
2820   set_gdbarch_num_regs (gdbarch, CSKY_NUM_REGS);
2821   set_gdbarch_pc_regnum (gdbarch, CSKY_PC_REGNUM);
2822   set_gdbarch_sp_regnum (gdbarch, CSKY_SP_REGNUM);
2823   set_gdbarch_register_name (gdbarch, csky_register_name);
2824   set_gdbarch_register_type (gdbarch, csky_register_type);
2825   set_gdbarch_read_pc (gdbarch, csky_read_pc);
2826   set_gdbarch_write_pc (gdbarch, csky_write_pc);
2827   csky_add_reggroups (gdbarch);
2828   set_gdbarch_register_reggroup_p (gdbarch, csky_register_reggroup_p);
2829   set_gdbarch_stab_reg_to_regnum (gdbarch, csky_dwarf_reg_to_regnum);
2830   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, csky_dwarf_reg_to_regnum);
2831   dwarf2_frame_set_init_reg (gdbarch, csky_dwarf2_frame_init_reg);
2832
2833   /* Functions to analyze frames.  */
2834   frame_base_set_default (gdbarch, &csky_frame_base);
2835   set_gdbarch_skip_prologue (gdbarch, csky_skip_prologue);
2836   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2837   set_gdbarch_frame_align (gdbarch, csky_frame_align);
2838   set_gdbarch_stack_frame_destroyed_p (gdbarch, csky_stack_frame_destroyed_p);
2839
2840   /* Functions handling dummy frames.  */
2841   set_gdbarch_push_dummy_call (gdbarch, csky_push_dummy_call);
2842
2843   /* Frame unwinders.  Use DWARF debug info if available,
2844      otherwise use our own unwinder.  */
2845   dwarf2_append_unwinders (gdbarch);
2846   frame_unwind_append_unwinder (gdbarch, &csky_stub_unwind);
2847   frame_unwind_append_unwinder (gdbarch, &csky_unwind_cache);
2848
2849   /* Hook in ABI-specific overrides, if they have been registered.  */
2850   gdbarch_init_osabi (info, gdbarch);
2851
2852   /* Support simple overlay manager.  */
2853   set_gdbarch_overlay_update (gdbarch, simple_overlay_update);
2854   set_gdbarch_char_signed (gdbarch, 0);
2855
2856   if (tdesc_data != nullptr)
2857     {
2858       set_gdbarch_num_regs (gdbarch, (num_regs + 1));
2859       tdesc_use_registers (gdbarch, info.target_desc, std::move (tdesc_data));
2860       set_gdbarch_register_type (gdbarch, csky_register_type);
2861       set_gdbarch_register_reggroup_p (gdbarch,
2862                                        csky_register_reggroup_p);
2863     }
2864
2865   if (tdep->fv_pseudo_registers_count)
2866     {
2867       set_gdbarch_num_pseudo_regs (gdbarch,
2868                                    tdep->fv_pseudo_registers_count);
2869       set_gdbarch_pseudo_register_read (gdbarch,
2870                                         csky_pseudo_register_read);
2871       set_gdbarch_pseudo_register_write (gdbarch,
2872                                          csky_pseudo_register_write);
2873       set_tdesc_pseudo_register_name (gdbarch, csky_pseudo_register_name);
2874     }
2875
2876   return gdbarch;
2877 }
2878
2879 void _initialize_csky_tdep ();
2880 void
2881 _initialize_csky_tdep ()
2882 {
2883
2884   gdbarch_register (bfd_arch_csky, csky_gdbarch_init);
2885
2886   csky_init_reggroup ();
2887
2888   /* Allow debugging this file's internals.  */
2889   add_setshow_boolean_cmd ("csky", class_maintenance, &csky_debug,
2890                            _("Set C-Sky debugging."),
2891                            _("Show C-Sky debugging."),
2892                            _("When on, C-Sky specific debugging is enabled."),
2893                            NULL,
2894                            NULL,
2895                            &setdebuglist, &showdebuglist);
2896 }