gdb/v850-tdep.c

   1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
   2
   3    Copyright (C) 1996, 1998-2005, 2007-2012 Free Software Foundation,
   4    Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "frame-base.h"
  24 #include "trad-frame.h"
  25 #include "frame-unwind.h"
  26 #include "dwarf2-frame.h"
  27 #include "gdbtypes.h"
  28 #include "inferior.h"
  29 #include "gdb_string.h"
  30 #include "gdb_assert.h"
  31 #include "gdbcore.h"
  32 #include "arch-utils.h"
  33 #include "regcache.h"
  34 #include "dis-asm.h"
  35 #include "osabi.h"
  36
  37 enum
  38   {
  39     E_R0_REGNUM,
  40     E_R1_REGNUM,
  41     E_R2_REGNUM,
  42     E_R3_REGNUM, E_SP_REGNUM = E_R3_REGNUM,
  43     E_R4_REGNUM,
  44     E_R5_REGNUM,
  45     E_R6_REGNUM, E_ARG0_REGNUM = E_R6_REGNUM,
  46     E_R7_REGNUM,
  47     E_R8_REGNUM,
  48     E_R9_REGNUM, E_ARGLAST_REGNUM = E_R9_REGNUM,
  49     E_R10_REGNUM, E_V0_REGNUM = E_R10_REGNUM,
  50     E_R11_REGNUM, E_V1_REGNUM = E_R11_REGNUM,
  51     E_R12_REGNUM,
  52     E_R13_REGNUM,
  53     E_R14_REGNUM,
  54     E_R15_REGNUM,
  55     E_R16_REGNUM,
  56     E_R17_REGNUM,
  57     E_R18_REGNUM,
  58     E_R19_REGNUM,
  59     E_R20_REGNUM,
  60     E_R21_REGNUM,
  61     E_R22_REGNUM,
  62     E_R23_REGNUM,
  63     E_R24_REGNUM,
  64     E_R25_REGNUM,
  65     E_R26_REGNUM,
  66     E_R27_REGNUM,
  67     E_R28_REGNUM,
  68     E_R29_REGNUM, E_FP_REGNUM = E_R29_REGNUM,
  69     E_R30_REGNUM, E_EP_REGNUM = E_R30_REGNUM,
  70     E_R31_REGNUM, E_LP_REGNUM = E_R31_REGNUM,
  71     E_R32_REGNUM, E_SR0_REGNUM = E_R32_REGNUM,
  72     E_R33_REGNUM,
  73     E_R34_REGNUM,
  74     E_R35_REGNUM,
  75     E_R36_REGNUM,
  76     E_R37_REGNUM, E_PS_REGNUM = E_R37_REGNUM,
  77     E_R38_REGNUM,
  78     E_R39_REGNUM,
  79     E_R40_REGNUM,
  80     E_R41_REGNUM,
  81     E_R42_REGNUM,
  82     E_R43_REGNUM,
  83     E_R44_REGNUM,
  84     E_R45_REGNUM,
  85     E_R46_REGNUM,
  86     E_R47_REGNUM,
  87     E_R48_REGNUM,
  88     E_R49_REGNUM,
  89     E_R50_REGNUM,
  90     E_R51_REGNUM,
  91     E_R52_REGNUM, E_CTBP_REGNUM = E_R52_REGNUM,
  92     E_R53_REGNUM,
  93     E_R54_REGNUM,
  94     E_R55_REGNUM,
  95     E_R56_REGNUM,
  96     E_R57_REGNUM,
  97     E_R58_REGNUM,
  98     E_R59_REGNUM,
  99     E_R60_REGNUM,
 100     E_R61_REGNUM,
 101     E_R62_REGNUM,
 102     E_R63_REGNUM,
 103     E_R64_REGNUM, E_PC_REGNUM = E_R64_REGNUM,
 104     E_R65_REGNUM,
 105     E_NUM_OF_V850_REGS,
 106     E_NUM_OF_V850E_REGS = E_NUM_OF_V850_REGS,
 107
 108     /* mpu0 system registers */
 109     E_R66_REGNUM = E_NUM_OF_V850_REGS,
 110     E_R67_REGNUM,
 111     E_R68_REGNUM,
 112     E_R69_REGNUM,
 113     E_R70_REGNUM,
 114     E_R71_REGNUM,
 115     E_R72_REGNUM,
 116     E_R73_REGNUM,
 117     E_R74_REGNUM,
 118     E_R75_REGNUM,
 119     E_R76_REGNUM,
 120     E_R77_REGNUM,
 121     E_R78_REGNUM,
 122     E_R79_REGNUM,
 123     E_R80_REGNUM,
 124     E_R81_REGNUM,
 125     E_R82_REGNUM,
 126     E_R83_REGNUM,
 127     E_R84_REGNUM,
 128     E_R85_REGNUM,
 129     E_R86_REGNUM,
 130     E_R87_REGNUM,
 131     E_R88_REGNUM,
 132     E_R89_REGNUM,
 133     E_R90_REGNUM,
 134     E_R91_REGNUM,
 135     E_R92_REGNUM,
 136     E_R93_REGNUM,
 137
 138     /* mpu1 system registers */
 139
 140     E_R94_REGNUM,
 141     E_R95_REGNUM,
 142     E_R96_REGNUM,
 143     E_R97_REGNUM,
 144     E_R98_REGNUM,
 145     E_R99_REGNUM,
 146     E_R100_REGNUM,
 147     E_R101_REGNUM,
 148     E_R102_REGNUM,
 149     E_R103_REGNUM,
 150     E_R104_REGNUM,
 151     E_R105_REGNUM,
 152     E_R106_REGNUM,
 153     E_R107_REGNUM,
 154     E_R108_REGNUM,
 155     E_R109_REGNUM,
 156     E_R110_REGNUM,
 157     E_R111_REGNUM,
 158     E_R112_REGNUM,
 159     E_R113_REGNUM,
 160     E_R114_REGNUM,
 161     E_R115_REGNUM,
 162     E_R116_REGNUM,
 163     E_R117_REGNUM,
 164     E_R118_REGNUM,
 165     E_R119_REGNUM,
 166     E_R120_REGNUM,
 167     E_R121_REGNUM,
 168
 169     /* fpu system registers */
 170     E_R122_REGNUM,
 171     E_R123_REGNUM,
 172     E_R124_REGNUM,
 173     E_R125_REGNUM,
 174     E_R126_REGNUM,
 175     E_R127_REGNUM,
 176     E_R128_REGNUM, E_FPSR_REGNUM = E_R128_REGNUM,
 177     E_R129_REGNUM, E_FPEPC_REGNUM = E_R129_REGNUM,
 178     E_R130_REGNUM, E_FPST_REGNUM = E_R130_REGNUM,
 179     E_R131_REGNUM, E_FPCC_REGNUM = E_R131_REGNUM,
 180     E_R132_REGNUM, E_FPCFG_REGNUM = E_R132_REGNUM,
 181     E_R133_REGNUM,
 182     E_R134_REGNUM,
 183     E_R135_REGNUM,
 184     E_R136_REGNUM,
 185     E_R137_REGNUM,
 186     E_R138_REGNUM,
 187     E_R139_REGNUM,
 188     E_R140_REGNUM,
 189     E_R141_REGNUM,
 190     E_R142_REGNUM,
 191     E_R143_REGNUM,
 192     E_R144_REGNUM,
 193     E_R145_REGNUM,
 194     E_R146_REGNUM,
 195     E_R147_REGNUM,
 196     E_R148_REGNUM,
 197     E_NUM_REGS
 198   };
 199
 200 enum
 201 {
 202   v850_reg_size = 4
 203 };
 204
 205 /* Size of return datatype which fits into all return registers.  */
 206 enum
 207 {
 208   E_MAX_RETTYPE_SIZE_IN_REGS = 2 * v850_reg_size
 209 };
 210
 211 struct v850_frame_cache
 212 {
 213   /* Base address.  */
 214   CORE_ADDR base;
 215   LONGEST sp_offset;
 216   CORE_ADDR pc;
 217
 218   /* Flag showing that a frame has been created in the prologue code.  */
 219   int uses_fp;
 220
 221   /* Saved registers.  */
 222   struct trad_frame_saved_reg *saved_regs;
 223 };
 224
 225 /* Info gleaned from scanning a function's prologue.  */
 226 struct pifsr            /* Info about one saved register.  */
 227 {
 228   int offset;           /* Offset from sp or fp.  */
 229   int cur_frameoffset;  /* Current frameoffset.  */
 230   int reg;              /* Saved register number.  */
 231 };
 232
 233 static const char *
 234 v850_register_name (struct gdbarch *gdbarch, int regnum)
 235 {
 236   static const char *v850_reg_names[] =
 237   { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 238     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 239     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 240     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 241     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
 242     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
 243     "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
 244     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
 245     "pc", "fp"
 246   };
 247   if (regnum < 0 || regnum > E_NUM_OF_V850_REGS)
 248     return NULL;
 249   return v850_reg_names[regnum];
 250 }
 251
 252 static const char *
 253 v850e_register_name (struct gdbarch *gdbarch, int regnum)
 254 {
 255   static const char *v850e_reg_names[] =
 256   {
 257     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 258     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 259     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 260     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 261     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
 262     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
 263     "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
 264     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
 265     "pc", "fp"
 266   };
 267   if (regnum < 0 || regnum > E_NUM_OF_V850E_REGS)
 268     return NULL;
 269   return v850e_reg_names[regnum];
 270 }
 271
 272 static const char *
 273 v850e2_register_name (struct gdbarch *gdbarch, int regnum)
 274 {
 275   static const char *v850e2_reg_names[] =
 276   {
 277     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 278     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 279     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 280     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 281
 282     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
 283     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
 284     "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
 285     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
 286     "pc", "fp"
 287
 288     /* mpu0 system registers */
 289     "vip", "sr33", "sr34", "sr35", "vmecr", "vmtid", "vmadr", "sr39",
 290     "vpecr", "vptid", "vpadr", "sr43", "vdecr", "vdtid", "sr46", "sr47",
 291     "sr48", "sr49", "sr50", "sr51", "sr52", "sr53", "sr54", "sr55",
 292     "sr56", "sr57", "sr58", "sr59",
 293
 294     /* mpu1 system registers */
 295     "mpm", "mpc", "tid", "ppa", "ppm", "ppc", "dcc", "dcv0",
 296     "dcv1", "sr69", "spal", "spau", "ipa0l", "ipa0u", "ipa1l", "ipa1u",
 297     "iap2l", "ipa2u", "ipa3l", "ipa3u", "dpa0l", "dpa0u", "dpa1l", "dpa1u",
 298     "dpa2l", "dpa2u", "dpa3l", "dpa3u",
 299
 300     /* fpu system registers */
 301     "sr88", "sr89", "sr90", "sr91", "sr92", "sr93", "fpsr", "fpepc",
 302     "fpst", "fpcc", "fpcfg", "sr99", "sr100", "sr101", "sr102", "sr103",
 303     "sr104", "sr105", "sr106", "sr107", "sr108", "sr109", "sr110", "sr111",
 304     "sr112", "sr113", "sr114", "sr115"
 305   };
 306   if (regnum < 0 || regnum >= E_NUM_REGS)
 307     return NULL;
 308   return v850e2_reg_names[regnum];
 309 }
 310
 311 /* Returns the default type for register N.  */
 312
 313 static struct type *
 314 v850_register_type (struct gdbarch *gdbarch, int regnum)
 315 {
 316   if (regnum == E_PC_REGNUM)
 317     return builtin_type (gdbarch)->builtin_func_ptr;
 318   return builtin_type (gdbarch)->builtin_int32;
 319 }
 320
 321 static int
 322 v850_type_is_scalar (struct type *t)
 323 {
 324   return (TYPE_CODE (t) != TYPE_CODE_STRUCT
 325           && TYPE_CODE (t) != TYPE_CODE_UNION
 326           && TYPE_CODE (t) != TYPE_CODE_ARRAY);
 327 }
 328
 329 /* Should call_function allocate stack space for a struct return?  */
 330 static int
 331 v850_use_struct_convention (struct type *type)
 332 {
 333   int i;
 334   struct type *fld_type, *tgt_type;
 335
 336   /* 1. The value is greater than 8 bytes -> returned by copying.  */
 337   if (TYPE_LENGTH (type) > 8)
 338     return 1;
 339
 340   /* 2. The value is a single basic type -> returned in register.  */
 341   if (v850_type_is_scalar (type))
 342     return 0;
 343
 344   /* The value is a structure or union with a single element and that
 345      element is either a single basic type or an array of a single basic
 346      type whose size is greater than or equal to 4 -> returned in register.  */
 347   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
 348        || TYPE_CODE (type) == TYPE_CODE_UNION)
 349        && TYPE_NFIELDS (type) == 1)
 350     {
 351       fld_type = TYPE_FIELD_TYPE (type, 0);
 352       if (v850_type_is_scalar (fld_type) && TYPE_LENGTH (fld_type) >= 4)
 353         return 0;
 354
 355       if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
 356         {
 357           tgt_type = TYPE_TARGET_TYPE (fld_type);
 358           if (v850_type_is_scalar (tgt_type) && TYPE_LENGTH (tgt_type) >= 4)
 359             return 0;
 360         }
 361     }
 362
 363   /* The value is a structure whose first element is an integer or a float,
 364      and which contains no arrays of more than two elements -> returned in
 365      register.  */
 366   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 367       && v850_type_is_scalar (TYPE_FIELD_TYPE (type, 0))
 368       && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
 369     {
 370       for (i = 1; i < TYPE_NFIELDS (type); ++i)
 371         {
 372           fld_type = TYPE_FIELD_TYPE (type, 0);
 373           if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
 374             {
 375               tgt_type = TYPE_TARGET_TYPE (fld_type);
 376               if (TYPE_LENGTH (fld_type) >= 0 && TYPE_LENGTH (tgt_type) >= 0
 377                   && TYPE_LENGTH (fld_type) / TYPE_LENGTH (tgt_type) > 2)
 378                 return 1;
 379             }
 380         }
 381       return 0;
 382     }
 383
 384   /* The value is a union which contains at least one field which
 385      would be returned in registers according to these rules ->
 386      returned in register.  */
 387   if (TYPE_CODE (type) == TYPE_CODE_UNION)
 388     {
 389       for (i = 0; i < TYPE_NFIELDS (type); ++i)
 390         {
 391           fld_type = TYPE_FIELD_TYPE (type, 0);
 392           if (!v850_use_struct_convention (fld_type))
 393             return 0;
 394         }
 395     }
 396
 397   return 1;
 398 }
 399
 400 /* Structure for mapping bits in register lists to register numbers.  */
 401 struct reg_list
 402 {
 403   long mask;
 404   int regno;
 405 };
 406
 407 /* Helper function for v850_scan_prologue to handle prepare instruction.  */
 408
 409 static void
 410 v850_handle_prepare (int insn, int insn2, CORE_ADDR * current_pc_ptr,
 411                      struct v850_frame_cache *pi, struct pifsr **pifsr_ptr)
 412 {
 413   CORE_ADDR current_pc = *current_pc_ptr;
 414   struct pifsr *pifsr = *pifsr_ptr;
 415   long next = insn2 & 0xffff;
 416   long list12 = ((insn & 1) << 16) + (next & 0xffe0);
 417   long offset = (insn & 0x3e) << 1;
 418   static struct reg_list reg_table[] =
 419   {
 420     {0x00800, 20},              /* r20 */
 421     {0x00400, 21},              /* r21 */
 422     {0x00200, 22},              /* r22 */
 423     {0x00100, 23},              /* r23 */
 424     {0x08000, 24},              /* r24 */
 425     {0x04000, 25},              /* r25 */
 426     {0x02000, 26},              /* r26 */
 427     {0x01000, 27},              /* r27 */
 428     {0x00080, 28},              /* r28 */
 429     {0x00040, 29},              /* r29 */
 430     {0x10000, 30},              /* ep */
 431     {0x00020, 31},              /* lp */
 432     {0, 0}                      /* end of table */
 433   };
 434   int i;
 435
 436   if ((next & 0x1f) == 0x0b)            /* skip imm16 argument */
 437     current_pc += 2;
 438   else if ((next & 0x1f) == 0x13)       /* skip imm16 argument */
 439     current_pc += 2;
 440   else if ((next & 0x1f) == 0x1b)       /* skip imm32 argument */
 441     current_pc += 4;
 442
 443   /* Calculate the total size of the saved registers, and add it to the
 444      immediate value used to adjust SP.  */
 445   for (i = 0; reg_table[i].mask != 0; i++)
 446     if (list12 & reg_table[i].mask)
 447       offset += v850_reg_size;
 448   pi->sp_offset -= offset;
 449
 450   /* Calculate the offsets of the registers relative to the value the SP
 451      will have after the registers have been pushed and the imm5 value has
 452      been subtracted from it.  */
 453   if (pifsr)
 454     {
 455       for (i = 0; reg_table[i].mask != 0; i++)
 456         {
 457           if (list12 & reg_table[i].mask)
 458             {
 459               int reg = reg_table[i].regno;
 460               offset -= v850_reg_size;
 461               pifsr->reg = reg;
 462               pifsr->offset = offset;
 463               pifsr->cur_frameoffset = pi->sp_offset;
 464               pifsr++;
 465             }
 466         }
 467     }
 468
 469   /* Set result parameters.  */
 470   *current_pc_ptr = current_pc;
 471   *pifsr_ptr = pifsr;
 472 }
 473
 474
 475 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
 476    The SR bit of the register list is not supported.  gcc does not generate
 477    this bit.  */
 478
 479 static void
 480 v850_handle_pushm (int insn, int insn2, struct v850_frame_cache *pi,
 481                    struct pifsr **pifsr_ptr)
 482 {
 483   struct pifsr *pifsr = *pifsr_ptr;
 484   long list12 = ((insn & 0x0f) << 16) + (insn2 & 0xfff0);
 485   long offset = 0;
 486   static struct reg_list pushml_reg_table[] =
 487   {
 488     {0x80000, E_PS_REGNUM},     /* PSW */
 489     {0x40000, 1},               /* r1 */
 490     {0x20000, 2},               /* r2 */
 491     {0x10000, 3},               /* r3 */
 492     {0x00800, 4},               /* r4 */
 493     {0x00400, 5},               /* r5 */
 494     {0x00200, 6},               /* r6 */
 495     {0x00100, 7},               /* r7 */
 496     {0x08000, 8},               /* r8 */
 497     {0x04000, 9},               /* r9 */
 498     {0x02000, 10},              /* r10 */
 499     {0x01000, 11},              /* r11 */
 500     {0x00080, 12},              /* r12 */
 501     {0x00040, 13},              /* r13 */
 502     {0x00020, 14},              /* r14 */
 503     {0x00010, 15},              /* r15 */
 504     {0, 0}                      /* end of table */
 505   };
 506   static struct reg_list pushmh_reg_table[] =
 507   {
 508     {0x80000, 16},              /* r16 */
 509     {0x40000, 17},              /* r17 */
 510     {0x20000, 18},              /* r18 */
 511     {0x10000, 19},              /* r19 */
 512     {0x00800, 20},              /* r20 */
 513     {0x00400, 21},              /* r21 */
 514     {0x00200, 22},              /* r22 */
 515     {0x00100, 23},              /* r23 */
 516     {0x08000, 24},              /* r24 */
 517     {0x04000, 25},              /* r25 */
 518     {0x02000, 26},              /* r26 */
 519     {0x01000, 27},              /* r27 */
 520     {0x00080, 28},              /* r28 */
 521     {0x00040, 29},              /* r29 */
 522     {0x00010, 30},              /* r30 */
 523     {0x00020, 31},              /* r31 */
 524     {0, 0}                      /* end of table */
 525   };
 526   struct reg_list *reg_table;
 527   int i;
 528
 529   /* Is this a pushml or a pushmh?  */
 530   if ((insn2 & 7) == 1)
 531     reg_table = pushml_reg_table;
 532   else
 533     reg_table = pushmh_reg_table;
 534
 535   /* Calculate the total size of the saved registers, and add it to the
 536      immediate value used to adjust SP.  */
 537   for (i = 0; reg_table[i].mask != 0; i++)
 538     if (list12 & reg_table[i].mask)
 539       offset += v850_reg_size;
 540   pi->sp_offset -= offset;
 541
 542   /* Calculate the offsets of the registers relative to the value the SP
 543      will have after the registers have been pushed and the imm5 value is
 544      subtracted from it.  */
 545   if (pifsr)
 546     {
 547       for (i = 0; reg_table[i].mask != 0; i++)
 548         {
 549           if (list12 & reg_table[i].mask)
 550             {
 551               int reg = reg_table[i].regno;
 552               offset -= v850_reg_size;
 553               pifsr->reg = reg;
 554               pifsr->offset = offset;
 555               pifsr->cur_frameoffset = pi->sp_offset;
 556               pifsr++;
 557             }
 558         }
 559     }
 560
 561   /* Set result parameters.  */
 562   *pifsr_ptr = pifsr;
 563 }
 564
 565 /* Helper function to evaluate if register is one of the "save" registers.
 566    This allows to simplify conditionals in v850_analyze_prologue a lot.  */
 567
 568 static int
 569 v850_is_save_register (int reg)
 570 {
 571  /* The caller-save registers are R2, R20 - R29 and R31.  All other
 572     registers are either special purpose (PC, SP), argument registers,
 573     or just considered free for use in the caller.  */
 574  return reg == E_R2_REGNUM
 575         || (reg >= E_R20_REGNUM && reg <= E_R29_REGNUM)
 576         || reg == E_R31_REGNUM;
 577 }
 578
 579 /* Scan the prologue of the function that contains PC, and record what
 580    we find in PI.  Returns the pc after the prologue.  Note that the
 581    addresses saved in frame->saved_regs are just frame relative (negative
 582    offsets from the frame pointer).  This is because we don't know the
 583    actual value of the frame pointer yet.  In some circumstances, the
 584    frame pointer can't be determined till after we have scanned the
 585    prologue.  */
 586
 587 static CORE_ADDR
 588 v850_analyze_prologue (struct gdbarch *gdbarch,
 589                        CORE_ADDR func_addr, CORE_ADDR pc,
 590                        struct v850_frame_cache *pi, ULONGEST ctbp)
 591 {
 592   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 593   CORE_ADDR prologue_end, current_pc;
 594   struct pifsr pifsrs[E_NUM_REGS + 1];
 595   struct pifsr *pifsr, *pifsr_tmp;
 596   int ep_used;
 597   int reg;
 598   CORE_ADDR save_pc, save_end;
 599   int regsave_func_p;
 600   int r12_tmp;
 601
 602   memset (&pifsrs, 0, sizeof pifsrs);
 603   pifsr = &pifsrs[0];
 604
 605   prologue_end = pc;
 606
 607   /* Now, search the prologue looking for instructions that setup fp, save
 608      rp, adjust sp and such.  We also record the frame offset of any saved
 609      registers.  */
 610
 611   pi->sp_offset = 0;
 612   pi->uses_fp = 0;
 613   ep_used = 0;
 614   regsave_func_p = 0;
 615   save_pc = 0;
 616   save_end = 0;
 617   r12_tmp = 0;
 618
 619   for (current_pc = func_addr; current_pc < prologue_end;)
 620     {
 621       int insn;
 622       int insn2 = -1; /* dummy value */
 623
 624       insn = read_memory_integer (current_pc, 2, byte_order);
 625       current_pc += 2;
 626       if ((insn & 0x0780) >= 0x0600)    /* Four byte instruction?  */
 627         {
 628           insn2 = read_memory_integer (current_pc, 2, byte_order);
 629           current_pc += 2;
 630         }
 631
 632       if ((insn & 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p)
 633         {                       /* jarl <func>,10 */
 634           long low_disp = insn2 & ~(long) 1;
 635           long disp = (((((insn & 0x3f) << 16) + low_disp)
 636                         & ~(long) 1) ^ 0x00200000) - 0x00200000;
 637
 638           save_pc = current_pc;
 639           save_end = prologue_end;
 640           regsave_func_p = 1;
 641           current_pc += disp - 4;
 642           prologue_end = (current_pc
 643                           + (2 * 3)     /* moves to/from ep */
 644                           + 4           /* addi <const>,sp,sp */
 645                           + 2           /* jmp [r10] */
 646                           + (2 * 12)    /* sst.w to save r2, r20-r29, r31 */
 647                           + 20);        /* slop area */
 648         }
 649       else if ((insn & 0xffc0) == 0x0200 && !regsave_func_p)
 650         {                       /* callt <imm6> */
 651           long adr = ctbp + ((insn & 0x3f) << 1);
 652
 653           save_pc = current_pc;
 654           save_end = prologue_end;
 655           regsave_func_p = 1;
 656           current_pc = ctbp + (read_memory_unsigned_integer (adr, 2, byte_order)
 657                                & 0xffff);
 658           prologue_end = (current_pc
 659                           + (2 * 3)     /* prepare list2,imm5,sp/imm */
 660                           + 4           /* ctret */
 661                           + 20);        /* slop area */
 662           continue;
 663         }
 664       else if ((insn & 0xffc0) == 0x0780)       /* prepare list2,imm5 */
 665         {
 666           v850_handle_prepare (insn, insn2, &current_pc, pi, &pifsr);
 667           continue;
 668         }
 669       else if (insn == 0x07e0 && regsave_func_p && insn2 == 0x0144)
 670         {                       /* ctret after processing register save.  */
 671           current_pc = save_pc;
 672           prologue_end = save_end;
 673           regsave_func_p = 0;
 674           continue;
 675         }
 676       else if ((insn & 0xfff0) == 0x07e0 && (insn2 & 5) == 1)
 677         {                       /* pushml, pushmh */
 678           v850_handle_pushm (insn, insn2, pi, &pifsr);
 679           continue;
 680         }
 681       else if ((insn & 0xffe0) == 0x0060 && regsave_func_p)
 682         {                       /* jmp after processing register save.  */
 683           current_pc = save_pc;
 684           prologue_end = save_end;
 685           regsave_func_p = 0;
 686           continue;
 687         }
 688       else if ((insn & 0x07c0) == 0x0780        /* jarl or jr */
 689                || (insn & 0xffe0) == 0x0060     /* jmp */
 690                || (insn & 0x0780) == 0x0580)    /* branch */
 691         {
 692           break;                /* Ran into end of prologue.  */
 693         }
 694
 695       else if ((insn & 0xffe0) == ((E_SP_REGNUM << 11) | 0x0240))
 696         /* add <imm>,sp */
 697         pi->sp_offset += ((insn & 0x1f) ^ 0x10) - 0x10;
 698       else if (insn == ((E_SP_REGNUM << 11) | 0x0600 | E_SP_REGNUM))
 699         /* addi <imm>,sp,sp */
 700         pi->sp_offset += insn2;
 701       else if (insn == ((E_FP_REGNUM << 11) | 0x0000 | E_SP_REGNUM))
 702         /* mov sp,fp */
 703         pi->uses_fp = 1;
 704       else if (insn == ((E_R12_REGNUM << 11) | 0x0640 | E_R0_REGNUM))
 705         /* movhi hi(const),r0,r12 */
 706         r12_tmp = insn2 << 16;
 707       else if (insn == ((E_R12_REGNUM << 11) | 0x0620 | E_R12_REGNUM))
 708         /* movea lo(const),r12,r12 */
 709         r12_tmp += insn2;
 710       else if (insn == ((E_SP_REGNUM << 11) | 0x01c0 | E_R12_REGNUM) && r12_tmp)
 711         /* add r12,sp */
 712         pi->sp_offset += r12_tmp;
 713       else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_SP_REGNUM))
 714         /* mov sp,ep */
 715         ep_used = 1;
 716       else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_R1_REGNUM))
 717         /* mov r1,ep */
 718         ep_used = 0;
 719       else if (((insn & 0x07ff) == (0x0760 | E_SP_REGNUM)
 720                 || (pi->uses_fp
 721                     && (insn & 0x07ff) == (0x0760 | E_FP_REGNUM)))
 722                && pifsr
 723                && v850_is_save_register (reg = (insn >> 11) & 0x1f))
 724         {
 725           /* st.w <reg>,<offset>[sp] or st.w <reg>,<offset>[fp] */
 726           pifsr->reg = reg;
 727           pifsr->offset = insn2 & ~1;
 728           pifsr->cur_frameoffset = pi->sp_offset;
 729           pifsr++;
 730         }
 731       else if (ep_used
 732                && ((insn & 0x0781) == 0x0501)
 733                && pifsr
 734                && v850_is_save_register (reg = (insn >> 11) & 0x1f))
 735         {
 736           /* sst.w <reg>,<offset>[ep] */
 737           pifsr->reg = reg;
 738           pifsr->offset = (insn & 0x007e) << 1;
 739           pifsr->cur_frameoffset = pi->sp_offset;
 740           pifsr++;
 741         }
 742     }
 743
 744   /* Fix up any offsets to the final offset.  If a frame pointer was created,
 745      use it instead of the stack pointer.  */
 746   for (pifsr_tmp = pifsrs; pifsr_tmp != pifsr; pifsr_tmp++)
 747     {
 748       pifsr_tmp->offset -= pi->sp_offset - pifsr_tmp->cur_frameoffset;
 749       pi->saved_regs[pifsr_tmp->reg].addr = pifsr_tmp->offset;
 750     }
 751
 752   return current_pc;
 753 }
 754
 755 /* Return the address of the first code past the prologue of the function.  */
 756
 757 static CORE_ADDR
 758 v850_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 759 {
 760   CORE_ADDR func_addr, func_end;
 761
 762   /* See what the symbol table says.  */
 763
 764   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 765     {
 766       struct symtab_and_line sal;
 767
 768       sal = find_pc_line (func_addr, 0);
 769       if (sal.line != 0 && sal.end < func_end)
 770         return sal.end;
 771
 772       /* Either there's no line info, or the line after the prologue is after
 773          the end of the function.  In this case, there probably isn't a
 774          prologue.  */
 775       return pc;
 776     }
 777
 778   /* We can't find the start of this function, so there's nothing we
 779      can do.  */
 780   return pc;
 781 }
 782
 783 static CORE_ADDR
 784 v850_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 785 {
 786   return sp & ~3;
 787 }
 788
 789 /* Setup arguments and LP for a call to the target.  First four args
 790    go in R6->R9, subsequent args go into sp + 16 -> sp + ...  Structs
 791    are passed by reference.  64 bit quantities (doubles and long longs)
 792    may be split between the regs and the stack.  When calling a function
 793    that returns a struct, a pointer to the struct is passed in as a secret
 794    first argument (always in R6).
 795
 796    Stack space for the args has NOT been allocated: that job is up to us.  */
 797
 798 static CORE_ADDR
 799 v850_push_dummy_call (struct gdbarch *gdbarch,
 800                       struct value *function,
 801                       struct regcache *regcache,
 802                       CORE_ADDR bp_addr,
 803                       int nargs,
 804                       struct value **args,
 805                       CORE_ADDR sp,
 806                       int struct_return,
 807                       CORE_ADDR struct_addr)
 808 {
 809   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 810   int argreg;
 811   int argnum;
 812   int len = 0;
 813   int stack_offset;
 814
 815   /* The offset onto the stack at which we will start copying parameters
 816      (after the registers are used up) begins at 16 rather than at zero.
 817      That's how the ABI is defined, though there's no indication that these
 818      16 bytes are used for anything, not even for saving incoming
 819      argument registers.  */
 820   stack_offset = 16;
 821
 822   /* Now make space on the stack for the args.  */
 823   for (argnum = 0; argnum < nargs; argnum++)
 824     len += ((TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3);
 825   sp -= len + stack_offset;
 826
 827   argreg = E_ARG0_REGNUM;
 828   /* The struct_return pointer occupies the first parameter register.  */
 829   if (struct_return)
 830     regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
 831
 832   /* Now load as many as possible of the first arguments into
 833      registers, and push the rest onto the stack.  There are 16 bytes
 834      in four registers available.  Loop thru args from first to last.  */
 835   for (argnum = 0; argnum < nargs; argnum++)
 836     {
 837       int len;
 838       gdb_byte *val;
 839       gdb_byte valbuf[v850_reg_size];
 840
 841       if (!v850_type_is_scalar (value_type (*args))
 842           && TYPE_LENGTH (value_type (*args)) > E_MAX_RETTYPE_SIZE_IN_REGS)
 843         {
 844           store_unsigned_integer (valbuf, 4, byte_order,
 845                                   value_address (*args));
 846           len = 4;
 847           val = valbuf;
 848         }
 849       else
 850         {
 851           len = TYPE_LENGTH (value_type (*args));
 852           val = (gdb_byte *) value_contents (*args);
 853         }
 854
 855       while (len > 0)
 856         if (argreg <= E_ARGLAST_REGNUM)
 857           {
 858             CORE_ADDR regval;
 859
 860             regval = extract_unsigned_integer (val, v850_reg_size, byte_order);
 861             regcache_cooked_write_unsigned (regcache, argreg, regval);
 862
 863             len -= v850_reg_size;
 864             val += v850_reg_size;
 865             argreg++;
 866           }
 867         else
 868           {
 869             write_memory (sp + stack_offset, val, 4);
 870
 871             len -= 4;
 872             val += 4;
 873             stack_offset += 4;
 874           }
 875       args++;
 876     }
 877
 878   /* Store return address.  */
 879   regcache_cooked_write_unsigned (regcache, E_LP_REGNUM, bp_addr);
 880
 881   /* Update stack pointer.  */
 882   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 883
 884   return sp;
 885 }
 886
 887 static void
 888 v850_extract_return_value (struct type *type, struct regcache *regcache,
 889                            gdb_byte *valbuf)
 890 {
 891   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 892   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 893   int len = TYPE_LENGTH (type);
 894
 895   if (len <= v850_reg_size)
 896     {
 897       ULONGEST val;
 898
 899       regcache_cooked_read_unsigned (regcache, E_V0_REGNUM, &val);
 900       store_unsigned_integer (valbuf, len, byte_order, val);
 901     }
 902   else if (len <= 2 * v850_reg_size)
 903     {
 904       int i, regnum = E_V0_REGNUM;
 905       gdb_byte buf[v850_reg_size];
 906       for (i = 0; len > 0; i += 4, len -= 4)
 907         {
 908           regcache_raw_read (regcache, regnum++, buf);
 909           memcpy (valbuf + i, buf, len > 4 ? 4 : len);
 910         }
 911     }
 912 }
 913
 914 static void
 915 v850_store_return_value (struct type *type, struct regcache *regcache,
 916                          const gdb_byte *valbuf)
 917 {
 918   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 919   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 920   int len = TYPE_LENGTH (type);
 921
 922   if (len <= v850_reg_size)
 923       regcache_cooked_write_unsigned
 924         (regcache, E_V0_REGNUM,
 925          extract_unsigned_integer (valbuf, len, byte_order));
 926   else if (len <= 2 * v850_reg_size)
 927     {
 928       int i, regnum = E_V0_REGNUM;
 929       for (i = 0; i < len; i += 4)
 930         regcache_raw_write (regcache, regnum++, valbuf + i);
 931     }
 932 }
 933
 934 static enum return_value_convention
 935 v850_return_value (struct gdbarch *gdbarch, struct value *function,
 936                    struct type *type, struct regcache *regcache,
 937                    gdb_byte *readbuf, const gdb_byte *writebuf)
 938 {
 939   if (v850_use_struct_convention (type))
 940     return RETURN_VALUE_STRUCT_CONVENTION;
 941   if (writebuf)
 942     v850_store_return_value (type, regcache, writebuf);
 943   else if (readbuf)
 944     v850_extract_return_value (type, regcache, readbuf);
 945   return RETURN_VALUE_REGISTER_CONVENTION;
 946 }
 947
 948 const static unsigned char *
 949 v850_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 950 {
 951   static unsigned char breakpoint[] = { 0x85, 0x05 };
 952   *lenptr = sizeof (breakpoint);
 953   return breakpoint;
 954 }
 955
 956 static struct v850_frame_cache *
 957 v850_alloc_frame_cache (struct frame_info *this_frame)
 958 {
 959   struct v850_frame_cache *cache;
 960
 961   cache = FRAME_OBSTACK_ZALLOC (struct v850_frame_cache);
 962   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 963
 964   /* Base address.  */
 965   cache->base = 0;
 966   cache->sp_offset = 0;
 967   cache->pc = 0;
 968
 969   /* Frameless until proven otherwise.  */
 970   cache->uses_fp = 0;
 971
 972   return cache;
 973 }
 974
 975 static struct v850_frame_cache *
 976 v850_frame_cache (struct frame_info *this_frame, void **this_cache)
 977 {
 978   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 979   struct v850_frame_cache *cache;
 980   CORE_ADDR current_pc;
 981   int i;
 982
 983   if (*this_cache)
 984     return *this_cache;
 985
 986   cache = v850_alloc_frame_cache (this_frame);
 987   *this_cache = cache;
 988
 989   /* In principle, for normal frames, fp holds the frame pointer,
 990      which holds the base address for the current stack frame.
 991      However, for functions that don't need it, the frame pointer is
 992      optional.  For these "frameless" functions the frame pointer is
 993      actually the frame pointer of the calling frame.  */
 994   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 995   if (cache->base == 0)
 996     return cache;
 997
 998   cache->pc = get_frame_func (this_frame);
 999   current_pc = get_frame_pc (this_frame);
1000   if (cache->pc != 0)
1001     {
1002       ULONGEST ctbp;
1003       ctbp = get_frame_register_unsigned (this_frame, E_CTBP_REGNUM);
1004       v850_analyze_prologue (gdbarch, cache->pc, current_pc, cache, ctbp);
1005     }
1006
1007   if (!cache->uses_fp)
1008     {
1009       /* We didn't find a valid frame, which means that CACHE->base
1010          currently holds the frame pointer for our calling frame.  If
1011          we're at the start of a function, or somewhere half-way its
1012          prologue, the function's frame probably hasn't been fully
1013          setup yet.  Try to reconstruct the base address for the stack
1014          frame by looking at the stack pointer.  For truly "frameless"
1015          functions this might work too.  */
1016       cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
1017     }
1018
1019   /* Now that we have the base address for the stack frame we can
1020      calculate the value of sp in the calling frame.  */
1021   trad_frame_set_value (cache->saved_regs, E_SP_REGNUM,
1022                         cache->base - cache->sp_offset);
1023
1024   /* Adjust all the saved registers such that they contain addresses
1025      instead of offsets.  */
1026   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
1027     if (trad_frame_addr_p (cache->saved_regs, i))
1028       cache->saved_regs[i].addr += cache->base;
1029
1030   /* The call instruction moves the caller's PC in the callee's LP.
1031      Since this is an unwind, do the reverse.  Copy the location of LP
1032      into PC (the address / regnum) so that a request for PC will be
1033      converted into a request for the LP.  */
1034
1035   cache->saved_regs[E_PC_REGNUM] = cache->saved_regs[E_LP_REGNUM];
1036
1037   return cache;
1038 }
1039
1040
1041 static struct value *
1042 v850_frame_prev_register (struct frame_info *this_frame,
1043                           void **this_cache, int regnum)
1044 {
1045   struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
1046
1047   gdb_assert (regnum >= 0);
1048
1049   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
1050 }
1051
1052 static void
1053 v850_frame_this_id (struct frame_info *this_frame, void **this_cache,
1054                     struct frame_id *this_id)
1055 {
1056   struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
1057
1058   /* This marks the outermost frame.  */
1059   if (cache->base == 0)
1060     return;
1061
1062   *this_id = frame_id_build (cache->saved_regs[E_SP_REGNUM].addr, cache->pc);
1063 }
1064
1065 static const struct frame_unwind v850_frame_unwind = {
1066   NORMAL_FRAME,
1067   default_frame_unwind_stop_reason,
1068   v850_frame_this_id,
1069   v850_frame_prev_register,
1070   NULL,
1071   default_frame_sniffer
1072 };
1073
1074 static CORE_ADDR
1075 v850_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1076 {
1077   return frame_unwind_register_unsigned (next_frame,
1078                                          gdbarch_sp_regnum (gdbarch));
1079 }
1080
1081 static CORE_ADDR
1082 v850_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1083 {
1084   return frame_unwind_register_unsigned (next_frame,
1085                                          gdbarch_pc_regnum (gdbarch));
1086 }
1087
1088 static struct frame_id
1089 v850_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1090 {
1091   CORE_ADDR sp = get_frame_register_unsigned (this_frame,
1092                                               gdbarch_sp_regnum (gdbarch));
1093   return frame_id_build (sp, get_frame_pc (this_frame));
1094 }
1095
1096 static CORE_ADDR
1097 v850_frame_base_address (struct frame_info *this_frame, void **this_cache)
1098 {
1099   struct v850_frame_cache *cache = v850_frame_cache (this_frame, this_cache);
1100
1101   return cache->base;
1102 }
1103
1104 static const struct frame_base v850_frame_base = {
1105   &v850_frame_unwind,
1106   v850_frame_base_address,
1107   v850_frame_base_address,
1108   v850_frame_base_address
1109 };
1110
1111 static struct gdbarch *
1112 v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1113 {
1114   struct gdbarch *gdbarch;
1115
1116   /* Change the register names based on the current machine type.  */
1117   if (info.bfd_arch_info->arch != bfd_arch_v850)
1118     return NULL;
1119
1120   gdbarch = gdbarch_alloc (&info, NULL);
1121
1122   switch (info.bfd_arch_info->mach)
1123     {
1124     case bfd_mach_v850:
1125       set_gdbarch_register_name (gdbarch, v850_register_name);
1126       set_gdbarch_num_regs (gdbarch, E_NUM_OF_V850_REGS);
1127       break;
1128     case bfd_mach_v850e:
1129     case bfd_mach_v850e1:
1130       set_gdbarch_register_name (gdbarch, v850e_register_name);
1131       set_gdbarch_num_regs (gdbarch, E_NUM_OF_V850E_REGS);
1132       break;
1133     case bfd_mach_v850e2:
1134     case bfd_mach_v850e2v3:
1135       set_gdbarch_register_name (gdbarch, v850e2_register_name);
1136       set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1137       break;
1138     }
1139
1140   set_gdbarch_num_pseudo_regs (gdbarch, 0);
1141   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1142   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1143   set_gdbarch_fp0_regnum (gdbarch, -1);
1144
1145   set_gdbarch_register_type (gdbarch, v850_register_type);
1146
1147   set_gdbarch_char_signed (gdbarch, 1);
1148   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1149   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1150   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1151   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1152
1153   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1154   set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1155   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1156
1157   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1158   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1159
1160   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1161   set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
1162
1163   set_gdbarch_return_value (gdbarch, v850_return_value);
1164   set_gdbarch_push_dummy_call (gdbarch, v850_push_dummy_call);
1165   set_gdbarch_skip_prologue (gdbarch, v850_skip_prologue);
1166
1167   set_gdbarch_print_insn (gdbarch, print_insn_v850);
1168
1169   set_gdbarch_frame_align (gdbarch, v850_frame_align);
1170   set_gdbarch_unwind_sp (gdbarch, v850_unwind_sp);
1171   set_gdbarch_unwind_pc (gdbarch, v850_unwind_pc);
1172   set_gdbarch_dummy_id (gdbarch, v850_dummy_id);
1173   frame_base_set_default (gdbarch, &v850_frame_base);
1174
1175   /* Hook in ABI-specific overrides, if they have been registered.  */
1176   gdbarch_init_osabi (info, gdbarch);
1177
1178   dwarf2_append_unwinders (gdbarch);
1179   frame_unwind_append_unwinder (gdbarch, &v850_frame_unwind);
1180
1181   return gdbarch;
1182 }
1183
1184 extern initialize_file_ftype _initialize_v850_tdep; /* -Wmissing-prototypes */
1185
1186 void
1187 _initialize_v850_tdep (void)
1188 {
1189   register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);
1190 }