gdb/v850-tdep.c

   1 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
   2
   3    Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
   4    Software Foundation, 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 2 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, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "target.h"
  27 #include "value.h"
  28 #include "bfd.h"
  29 #include "gdb_string.h"
  30 #include "gdbcore.h"
  31 #include "symfile.h"
  32 #include "arch-utils.h"
  33 #include "regcache.h"
  34 #include "symtab.h"
  35 #include "dis-asm.h"
  36
  37 struct gdbarch_tdep
  38 {
  39   /* gdbarch target dependent data here. Currently unused for v850. */
  40 };
  41
  42 /* Extra info which is saved in each frame_info. */
  43 struct frame_extra_info
  44 {
  45 };
  46
  47 enum {
  48  E_R0_REGNUM,
  49  E_R1_REGNUM,
  50  E_R2_REGNUM, E_SAVE1_START_REGNUM = E_R2_REGNUM, E_SAVE1_END_REGNUM = E_R2_REGNUM,
  51  E_R3_REGNUM, E_SP_REGNUM = E_R3_REGNUM,
  52  E_R4_REGNUM,
  53  E_R5_REGNUM,
  54  E_R6_REGNUM, E_ARG0_REGNUM = E_R6_REGNUM,
  55  E_R7_REGNUM,
  56  E_R8_REGNUM,
  57  E_R9_REGNUM, E_ARGLAST_REGNUM = E_R9_REGNUM,
  58  E_R10_REGNUM, E_V0_REGNUM = E_R10_REGNUM,
  59  E_R11_REGNUM, E_V1_REGNUM = E_R11_REGNUM,
  60  E_R12_REGNUM,
  61  E_R13_REGNUM,
  62  E_R14_REGNUM,
  63  E_R15_REGNUM,
  64  E_R16_REGNUM,
  65  E_R17_REGNUM,
  66  E_R18_REGNUM,
  67  E_R19_REGNUM,
  68  E_R20_REGNUM, E_SAVE2_START_REGNUM = E_R20_REGNUM,
  69  E_R21_REGNUM,
  70  E_R22_REGNUM,
  71  E_R23_REGNUM,
  72  E_R24_REGNUM,
  73  E_R25_REGNUM,
  74  E_R26_REGNUM,
  75  E_R27_REGNUM,
  76  E_R28_REGNUM,
  77  E_R29_REGNUM, E_SAVE2_END_REGNUM = E_R29_REGNUM, E_FP_RAW_REGNUM = E_R29_REGNUM,
  78  E_R30_REGNUM, E_EP_REGNUM = E_R30_REGNUM,
  79  E_R31_REGNUM, E_SAVE3_START_REGNUM = E_R31_REGNUM, E_SAVE3_END_REGNUM = E_R31_REGNUM, E_RP_REGNUM = E_R31_REGNUM,
  80  E_R32_REGNUM, E_SR0_REGNUM = E_R32_REGNUM,
  81  E_R33_REGNUM,
  82  E_R34_REGNUM,
  83  E_R35_REGNUM,
  84  E_R36_REGNUM,
  85  E_R37_REGNUM, E_PS_REGNUM = E_R37_REGNUM,
  86  E_R38_REGNUM,
  87  E_R39_REGNUM,
  88  E_R40_REGNUM,
  89  E_R41_REGNUM,
  90  E_R42_REGNUM,
  91  E_R43_REGNUM,
  92  E_R44_REGNUM,
  93  E_R45_REGNUM,
  94  E_R46_REGNUM,
  95  E_R47_REGNUM,
  96  E_R48_REGNUM,
  97  E_R49_REGNUM,
  98  E_R50_REGNUM,
  99  E_R51_REGNUM,
 100  E_R52_REGNUM, E_CTBP_REGNUM = E_R52_REGNUM,
 101  E_R53_REGNUM,
 102  E_R54_REGNUM,
 103  E_R55_REGNUM,
 104  E_R56_REGNUM,
 105  E_R57_REGNUM,
 106  E_R58_REGNUM,
 107  E_R59_REGNUM,
 108  E_R60_REGNUM,
 109  E_R61_REGNUM,
 110  E_R62_REGNUM,
 111  E_R63_REGNUM,
 112  E_R64_REGNUM, E_PC_REGNUM = E_R64_REGNUM,
 113  E_R65_REGNUM, E_FP_REGNUM = E_R65_REGNUM,
 114  E_NUM_REGS
 115 };
 116
 117 enum
 118 {
 119   v850_reg_size = 4
 120 };
 121
 122 /* Size of all registers as a whole. */
 123 enum
 124 {
 125   E_ALL_REGS_SIZE = (E_NUM_REGS) * v850_reg_size
 126 };
 127
 128 /* Size of return datatype which fits into all return registers. */
 129 enum
 130 {
 131   E_MAX_RETTYPE_SIZE_IN_REGS = 2 * v850_reg_size
 132 };
 133
 134 static LONGEST call_dummy_nil[] = {0};
 135
 136 static char *v850_generic_reg_names[] =
 137 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 138   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 139   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 140   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 141   "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
 142   "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
 143   "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
 144   "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
 145   "pc", "fp"
 146 };
 147
 148 static char *v850e_reg_names[] =
 149 {
 150   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 151   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 152   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 153   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 154   "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
 155   "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
 156   "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
 157   "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
 158   "pc", "fp"
 159 };
 160
 161 char **v850_register_names = v850_generic_reg_names;
 162
 163 struct
 164   {
 165     char **regnames;
 166     int mach;
 167   }
 168 v850_processor_type_table[] =
 169 {
 170   {
 171     v850_generic_reg_names, bfd_mach_v850
 172   }
 173   ,
 174   {
 175     v850e_reg_names, bfd_mach_v850e
 176   }
 177   ,
 178   {
 179     v850e_reg_names, bfd_mach_v850e1
 180   }
 181   ,
 182   {
 183     NULL, 0
 184   }
 185 };
 186
 187 /* Info gleaned from scanning a function's prologue.  */
 188
 189 struct pifsr                    /* Info about one saved reg */
 190   {
 191     int framereg;               /* Frame reg (SP or FP) */
 192     int offset;                 /* Offset from framereg */
 193     int cur_frameoffset;        /* Current frameoffset */
 194     int reg;                    /* Saved register number */
 195   };
 196
 197 struct prologue_info
 198   {
 199     int framereg;
 200     int frameoffset;
 201     int start_function;
 202     struct pifsr *pifsrs;
 203   };
 204
 205 static CORE_ADDR v850_scan_prologue (CORE_ADDR pc, struct prologue_info *fs);
 206
 207 /* Function: v850_register_name
 208    Returns the name of the v850/v850e register N. */
 209
 210 static const char *
 211 v850_register_name (int regnum)
 212 {
 213   if (regnum < 0 || regnum >= E_NUM_REGS)
 214     internal_error (__FILE__, __LINE__,
 215                     "v850_register_name: illegal register number %d",
 216                     regnum);
 217   else
 218     return v850_register_names[regnum];
 219
 220 }
 221
 222 /* Function: v850_register_byte
 223    Returns the byte position in the register cache for register N. */
 224
 225 static int
 226 v850_register_byte (int regnum)
 227 {
 228   if (regnum < 0 || regnum >= E_NUM_REGS)
 229     internal_error (__FILE__, __LINE__,
 230                     "v850_register_byte: illegal register number %d",
 231                     regnum);
 232   else
 233     return regnum * v850_reg_size;
 234 }
 235
 236 /* Function: v850_register_raw_size
 237    Returns the number of bytes occupied by the register on the target. */
 238
 239 static int
 240 v850_register_raw_size (int regnum)
 241 {
 242   if (regnum < 0 || regnum >= E_NUM_REGS)
 243     internal_error (__FILE__, __LINE__,
 244                     "v850_register_raw_size: illegal register number %d",
 245                     regnum);
 246   /* Only the PC has 4 Byte, all other registers 2 Byte. */
 247   else
 248     return v850_reg_size;
 249 }
 250
 251 /* Function: v850_reg_virtual_type
 252    Returns the default type for register N. */
 253
 254 static struct type *
 255 v850_reg_virtual_type (int regnum)
 256 {
 257   if (regnum < 0 || regnum >= E_NUM_REGS)
 258     internal_error (__FILE__, __LINE__,
 259                     "v850_register_virtual_type: illegal register number %d",
 260                     regnum);
 261   else if (regnum == E_PC_REGNUM)
 262     return builtin_type_uint32;
 263   else
 264     return builtin_type_int32;
 265 }
 266
 267 static int
 268 v850_type_is_scalar (struct type *t)
 269 {
 270   return (TYPE_CODE (t) != TYPE_CODE_STRUCT
 271           && TYPE_CODE (t) != TYPE_CODE_UNION
 272           && TYPE_CODE (t) != TYPE_CODE_ARRAY);
 273 }
 274
 275 /* Should call_function allocate stack space for a struct return?  */
 276 static int
 277 v850_use_struct_convention (int gcc_p, struct type *type)
 278 {
 279   /* According to ABI:
 280    * return TYPE_LENGTH (type) > 8);
 281    */
 282
 283   /* Current implementation in gcc: */
 284
 285   int i;
 286   struct type *fld_type, *tgt_type;
 287
 288   /* 1. The value is greater than 8 bytes -> returned by copying */
 289   if (TYPE_LENGTH (type) > 8)
 290     return 1;
 291
 292   /* 2. The value is a single basic type -> returned in register */
 293   if (v850_type_is_scalar (type))
 294     return 0;
 295
 296   /* The value is a structure or union with a single element
 297    * and that element is either a single basic type or an array of
 298    * a single basic type whoes size is greater than or equal to 4
 299    * -> returned in register */
 300   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
 301        || TYPE_CODE (type) == TYPE_CODE_UNION)
 302        && TYPE_NFIELDS (type) == 1)
 303     {
 304       fld_type = TYPE_FIELD_TYPE (type, 0);
 305       if (v850_type_is_scalar (fld_type) && TYPE_LENGTH (fld_type) >= 4)
 306         return 0;
 307
 308       if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
 309         {
 310           tgt_type = TYPE_TARGET_TYPE (fld_type);
 311           if (v850_type_is_scalar (tgt_type) && TYPE_LENGTH (tgt_type) >= 4)
 312             return 0;
 313         }
 314     }
 315
 316   /* The value is a structure whose first element is an integer or
 317    * a float, and which contains no arrays of more than two elements
 318    * -> returned in register */
 319   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 320       && v850_type_is_scalar (TYPE_FIELD_TYPE (type, 0))
 321       && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
 322     {
 323       for (i = 1; i < TYPE_NFIELDS (type); ++i)
 324         {
 325           fld_type = TYPE_FIELD_TYPE (type, 0);
 326           if (TYPE_CODE (fld_type) == TYPE_CODE_ARRAY)
 327             {
 328               tgt_type = TYPE_TARGET_TYPE (fld_type);
 329               if (TYPE_LENGTH (fld_type) >= 0 && TYPE_LENGTH (tgt_type) >= 0
 330                   && TYPE_LENGTH (fld_type) / TYPE_LENGTH (tgt_type) > 2)
 331                 return 1;
 332             }
 333         }
 334       return 0;
 335     }
 336
 337   /* The value is a union which contains at least one field which
 338    * would be returned in registers according to these rules
 339    * -> returned in register */
 340   if (TYPE_CODE (type) == TYPE_CODE_UNION)
 341     {
 342       for (i = 0; i < TYPE_NFIELDS (type); ++i)
 343         {
 344           fld_type = TYPE_FIELD_TYPE (type, 0);
 345           if (!v850_use_struct_convention (0, fld_type))
 346             return 0;
 347         }
 348     }
 349
 350   return 1;
 351 }
 352 \f
 353
 354
 355 /* Structure for mapping bits in register lists to register numbers. */
 356 struct reg_list
 357 {
 358   long mask;
 359   int regno;
 360 };
 361
 362 /* Helper function for v850_scan_prologue to handle prepare instruction. */
 363
 364 static void
 365 handle_prepare (int insn, int insn2, CORE_ADDR * current_pc_ptr,
 366                 struct prologue_info *pi, struct pifsr **pifsr_ptr)
 367 {
 368   CORE_ADDR current_pc = *current_pc_ptr;
 369   struct pifsr *pifsr = *pifsr_ptr;
 370   long next = insn2 & 0xffff;
 371   long list12 = ((insn & 1) << 16) + (next & 0xffe0);
 372   long offset = (insn & 0x3e) << 1;
 373   static struct reg_list reg_table[] =
 374   {
 375     {0x00800, 20},              /* r20 */
 376     {0x00400, 21},              /* r21 */
 377     {0x00200, 22},              /* r22 */
 378     {0x00100, 23},              /* r23 */
 379     {0x08000, 24},              /* r24 */
 380     {0x04000, 25},              /* r25 */
 381     {0x02000, 26},              /* r26 */
 382     {0x01000, 27},              /* r27 */
 383     {0x00080, 28},              /* r28 */
 384     {0x00040, 29},              /* r29 */
 385     {0x10000, 30},              /* ep */
 386     {0x00020, 31},              /* lp */
 387     {0, 0}                      /* end of table */
 388   };
 389   int i;
 390
 391   if ((next & 0x1f) == 0x0b)    /* skip imm16 argument */
 392     current_pc += 2;
 393   else if ((next & 0x1f) == 0x13)       /* skip imm16 argument */
 394     current_pc += 2;
 395   else if ((next & 0x1f) == 0x1b)       /* skip imm32 argument */
 396     current_pc += 4;
 397
 398   /* Calculate the total size of the saved registers, and add it
 399      it to the immediate value used to adjust SP. */
 400   for (i = 0; reg_table[i].mask != 0; i++)
 401     if (list12 & reg_table[i].mask)
 402       offset += v850_register_raw_size (reg_table[i].regno);
 403   pi->frameoffset -= offset;
 404
 405   /* Calculate the offsets of the registers relative to the value
 406      the SP will have after the registers have been pushed and the
 407      imm5 value has been subtracted from it. */
 408   if (pifsr)
 409     {
 410       for (i = 0; reg_table[i].mask != 0; i++)
 411         {
 412           if (list12 & reg_table[i].mask)
 413             {
 414               int reg = reg_table[i].regno;
 415               offset -= v850_register_raw_size (reg);
 416               pifsr->reg = reg;
 417               pifsr->offset = offset;
 418               pifsr->cur_frameoffset = pi->frameoffset;
 419 #ifdef DEBUG
 420               printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
 421 #endif
 422               pifsr++;
 423             }
 424         }
 425     }
 426 #ifdef DEBUG
 427   printf_filtered ("\tfound ctret after regsave func");
 428 #endif
 429
 430   /* Set result parameters. */
 431   *current_pc_ptr = current_pc;
 432   *pifsr_ptr = pifsr;
 433 }
 434
 435
 436 /* Helper function for v850_scan_prologue to handle pushm/pushl instructions.
 437    FIXME: the SR bit of the register list is not supported; must check
 438    that the compiler does not ever generate this bit. */
 439
 440 static void
 441 handle_pushm (int insn, int insn2, struct prologue_info *pi,
 442               struct pifsr **pifsr_ptr)
 443 {
 444   struct pifsr *pifsr = *pifsr_ptr;
 445   long list12 = ((insn & 0x0f) << 16) + (insn2 & 0xfff0);
 446   long offset = 0;
 447   static struct reg_list pushml_reg_table[] =
 448   {
 449     {0x80000, E_PS_REGNUM},     /* PSW */
 450     {0x40000, 1},               /* r1 */
 451     {0x20000, 2},               /* r2 */
 452     {0x10000, 3},               /* r3 */
 453     {0x00800, 4},               /* r4 */
 454     {0x00400, 5},               /* r5 */
 455     {0x00200, 6},               /* r6 */
 456     {0x00100, 7},               /* r7 */
 457     {0x08000, 8},               /* r8 */
 458     {0x04000, 9},               /* r9 */
 459     {0x02000, 10},              /* r10 */
 460     {0x01000, 11},              /* r11 */
 461     {0x00080, 12},              /* r12 */
 462     {0x00040, 13},              /* r13 */
 463     {0x00020, 14},              /* r14 */
 464     {0x00010, 15},              /* r15 */
 465     {0, 0}                      /* end of table */
 466   };
 467   static struct reg_list pushmh_reg_table[] =
 468   {
 469     {0x80000, 16},              /* r16 */
 470     {0x40000, 17},              /* r17 */
 471     {0x20000, 18},              /* r18 */
 472     {0x10000, 19},              /* r19 */
 473     {0x00800, 20},              /* r20 */
 474     {0x00400, 21},              /* r21 */
 475     {0x00200, 22},              /* r22 */
 476     {0x00100, 23},              /* r23 */
 477     {0x08000, 24},              /* r24 */
 478     {0x04000, 25},              /* r25 */
 479     {0x02000, 26},              /* r26 */
 480     {0x01000, 27},              /* r27 */
 481     {0x00080, 28},              /* r28 */
 482     {0x00040, 29},              /* r29 */
 483     {0x00010, 30},              /* r30 */
 484     {0x00020, 31},              /* r31 */
 485     {0, 0}                      /* end of table */
 486   };
 487   struct reg_list *reg_table;
 488   int i;
 489
 490   /* Is this a pushml or a pushmh? */
 491   if ((insn2 & 7) == 1)
 492     reg_table = pushml_reg_table;
 493   else
 494     reg_table = pushmh_reg_table;
 495
 496   /* Calculate the total size of the saved registers, and add it
 497      it to the immediate value used to adjust SP. */
 498   for (i = 0; reg_table[i].mask != 0; i++)
 499     if (list12 & reg_table[i].mask)
 500       offset += v850_register_raw_size (reg_table[i].regno);
 501   pi->frameoffset -= offset;
 502
 503   /* Calculate the offsets of the registers relative to the value
 504      the SP will have after the registers have been pushed and the
 505      imm5 value is subtracted from it. */
 506   if (pifsr)
 507     {
 508       for (i = 0; reg_table[i].mask != 0; i++)
 509         {
 510           if (list12 & reg_table[i].mask)
 511             {
 512               int reg = reg_table[i].regno;
 513               offset -= v850_register_raw_size (reg);
 514               pifsr->reg = reg;
 515               pifsr->offset = offset;
 516               pifsr->cur_frameoffset = pi->frameoffset;
 517 #ifdef DEBUG
 518               printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
 519 #endif
 520               pifsr++;
 521             }
 522         }
 523     }
 524 #ifdef DEBUG
 525   printf_filtered ("\tfound ctret after regsave func");
 526 #endif
 527
 528   /* Set result parameters. */
 529   *pifsr_ptr = pifsr;
 530 }
 531 \f
 532
 533
 534
 535 /* Function: scan_prologue
 536    Scan the prologue of the function that contains PC, and record what
 537    we find in PI.  Returns the pc after the prologue.  Note that the
 538    addresses saved in frame->saved_regs are just frame relative (negative
 539    offsets from the frame pointer).  This is because we don't know the
 540    actual value of the frame pointer yet.  In some circumstances, the
 541    frame pointer can't be determined till after we have scanned the
 542    prologue.  */
 543
 544 static CORE_ADDR
 545 v850_scan_prologue (CORE_ADDR pc, struct prologue_info *pi)
 546 {
 547   CORE_ADDR func_addr, prologue_end, current_pc;
 548   struct pifsr *pifsr, *pifsr_tmp;
 549   int fp_used;
 550   int ep_used;
 551   int reg;
 552   CORE_ADDR save_pc, save_end;
 553   int regsave_func_p;
 554   int r12_tmp;
 555
 556   /* First, figure out the bounds of the prologue so that we can limit the
 557      search to something reasonable.  */
 558
 559   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
 560     {
 561       struct symtab_and_line sal;
 562
 563       sal = find_pc_line (func_addr, 0);
 564
 565       if (func_addr == entry_point_address ())
 566         pi->start_function = 1;
 567       else
 568         pi->start_function = 0;
 569
 570 #if 0
 571       if (sal.line == 0)
 572         prologue_end = pc;
 573       else
 574         prologue_end = sal.end;
 575 #else
 576       prologue_end = pc;
 577 #endif
 578     }
 579   else
 580     {                           /* We're in the boondocks */
 581       func_addr = pc - 100;
 582       prologue_end = pc;
 583     }
 584
 585   prologue_end = min (prologue_end, pc);
 586
 587   /* Now, search the prologue looking for instructions that setup fp, save
 588      rp, adjust sp and such.  We also record the frame offset of any saved
 589      registers. */
 590
 591   pi->frameoffset = 0;
 592   pi->framereg = E_SP_REGNUM;
 593   fp_used = 0;
 594   ep_used = 0;
 595   pifsr = pi->pifsrs;
 596   regsave_func_p = 0;
 597   save_pc = 0;
 598   save_end = 0;
 599   r12_tmp = 0;
 600
 601 #ifdef DEBUG
 602   printf_filtered ("Current_pc = 0x%.8lx, prologue_end = 0x%.8lx\n",
 603                    (long) func_addr, (long) prologue_end);
 604 #endif
 605
 606   for (current_pc = func_addr; current_pc < prologue_end;)
 607     {
 608       int insn;
 609       int insn2 = -1; /* dummy value */
 610
 611 #ifdef DEBUG
 612       fprintf_filtered (gdb_stdlog, "0x%.8lx ", (long) current_pc);
 613       gdb_print_insn (current_pc, gdb_stdlog);
 614 #endif
 615
 616       insn = read_memory_unsigned_integer (current_pc, 2);
 617       current_pc += 2;
 618       if ((insn & 0x0780) >= 0x0600)    /* Four byte instruction? */
 619         {
 620           insn2 = read_memory_unsigned_integer (current_pc, 2);
 621           current_pc += 2;
 622         }
 623
 624       if ((insn & 0xffc0) == ((10 << 11) | 0x0780) && !regsave_func_p)
 625         {                       /* jarl <func>,10 */
 626           long low_disp = insn2 & ~(long) 1;
 627           long disp = (((((insn & 0x3f) << 16) + low_disp)
 628                         & ~(long) 1) ^ 0x00200000) - 0x00200000;
 629
 630           save_pc = current_pc;
 631           save_end = prologue_end;
 632           regsave_func_p = 1;
 633           current_pc += disp - 4;
 634           prologue_end = (current_pc
 635                           + (2 * 3)     /* moves to/from ep */
 636                           + 4   /* addi <const>,sp,sp */
 637                           + 2   /* jmp [r10] */
 638                           + (2 * 12)    /* sst.w to save r2, r20-r29, r31 */
 639                           + 20);        /* slop area */
 640
 641 #ifdef DEBUG
 642           printf_filtered ("\tfound jarl <func>,r10, disp = %ld, low_disp = %ld, new pc = 0x%.8lx\n",
 643                            disp, low_disp, (long) current_pc + 2);
 644 #endif
 645           continue;
 646         }
 647       else if ((insn & 0xffc0) == 0x0200 && !regsave_func_p)
 648         {                       /* callt <imm6> */
 649           long ctbp = read_register (E_CTBP_REGNUM);
 650           long adr = ctbp + ((insn & 0x3f) << 1);
 651
 652           save_pc = current_pc;
 653           save_end = prologue_end;
 654           regsave_func_p = 1;
 655           current_pc = ctbp + (read_memory_unsigned_integer (adr, 2) & 0xffff);
 656           prologue_end = (current_pc
 657                           + (2 * 3)     /* prepare list2,imm5,sp/imm */
 658                           + 4   /* ctret */
 659                           + 20);        /* slop area */
 660
 661 #ifdef DEBUG
 662           printf_filtered ("\tfound callt,  ctbp = 0x%.8lx, adr = %.8lx, new pc = 0x%.8lx\n",
 663                            ctbp, adr, (long) current_pc);
 664 #endif
 665           continue;
 666         }
 667       else if ((insn & 0xffc0) == 0x0780)       /* prepare list2,imm5 */
 668         {
 669           handle_prepare (insn, insn2, &current_pc, pi, &pifsr);
 670           continue;
 671         }
 672       else if (insn == 0x07e0 && regsave_func_p && insn2 == 0x0144)
 673         {                       /* ctret after processing register save function */
 674           current_pc = save_pc;
 675           prologue_end = save_end;
 676           regsave_func_p = 0;
 677 #ifdef DEBUG
 678           printf_filtered ("\tfound ctret after regsave func");
 679 #endif
 680           continue;
 681         }
 682       else if ((insn & 0xfff0) == 0x07e0 && (insn2 & 5) == 1)
 683         {                       /* pushml, pushmh */
 684           handle_pushm (insn, insn2, pi, &pifsr);
 685           continue;
 686         }
 687       else if ((insn & 0xffe0) == 0x0060 && regsave_func_p)
 688         {                       /* jmp after processing register save function */
 689           current_pc = save_pc;
 690           prologue_end = save_end;
 691           regsave_func_p = 0;
 692 #ifdef DEBUG
 693           printf_filtered ("\tfound jmp after regsave func");
 694 #endif
 695           continue;
 696         }
 697       else if ((insn & 0x07c0) == 0x0780        /* jarl or jr */
 698                || (insn & 0xffe0) == 0x0060     /* jmp */
 699                || (insn & 0x0780) == 0x0580)    /* branch */
 700         {
 701 #ifdef DEBUG
 702           printf_filtered ("\n");
 703 #endif
 704           break;                /* Ran into end of prologue */
 705         }
 706
 707       else if ((insn & 0xffe0) == ((E_SP_REGNUM << 11) | 0x0240))               /* add <imm>,sp */
 708         pi->frameoffset += ((insn & 0x1f) ^ 0x10) - 0x10;
 709       else if (insn == ((E_SP_REGNUM << 11) | 0x0600 | E_SP_REGNUM))    /* addi <imm>,sp,sp */
 710         pi->frameoffset += insn2;
 711       else if (insn == ((E_FP_RAW_REGNUM << 11) | 0x0000 | E_SP_REGNUM))        /* mov sp,fp */
 712         {
 713           fp_used = 1;
 714           pi->framereg = E_FP_RAW_REGNUM;
 715         }
 716
 717       else if (insn == ((E_R12_REGNUM << 11) | 0x0640 | E_R0_REGNUM))   /* movhi hi(const),r0,r12 */
 718         r12_tmp = insn2 << 16;
 719       else if (insn == ((E_R12_REGNUM << 11) | 0x0620 | E_R12_REGNUM))  /* movea lo(const),r12,r12 */
 720         r12_tmp += insn2;
 721       else if (insn == ((E_SP_REGNUM << 11) | 0x01c0 | E_R12_REGNUM) && r12_tmp)        /* add r12,sp */
 722         pi->frameoffset = r12_tmp;
 723       else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_SP_REGNUM))    /* mov sp,ep */
 724         ep_used = 1;
 725       else if (insn == ((E_EP_REGNUM << 11) | 0x0000 | E_R1_REGNUM))    /* mov r1,ep */
 726         ep_used = 0;
 727       else if (((insn & 0x07ff) == (0x0760 | E_SP_REGNUM)               /* st.w <reg>,<offset>[sp] */
 728                 || (fp_used
 729                     && (insn & 0x07ff) == (0x0760 | E_FP_RAW_REGNUM)))  /* st.w <reg>,<offset>[fp] */
 730                && pifsr
 731                && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
 732                    || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
 733                  || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
 734         {
 735           pifsr->reg = reg;
 736           pifsr->offset = insn2 & ~1;
 737           pifsr->cur_frameoffset = pi->frameoffset;
 738 #ifdef DEBUG
 739           printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
 740 #endif
 741           pifsr++;
 742         }
 743
 744       else if (ep_used          /* sst.w <reg>,<offset>[ep] */
 745                && ((insn & 0x0781) == 0x0501)
 746                && pifsr
 747                && (((reg = (insn >> 11) & 0x1f) >= E_SAVE1_START_REGNUM && reg <= E_SAVE1_END_REGNUM)
 748                    || (reg >= E_SAVE2_START_REGNUM && reg <= E_SAVE2_END_REGNUM)
 749                  || (reg >= E_SAVE3_START_REGNUM && reg <= E_SAVE3_END_REGNUM)))
 750         {
 751           pifsr->reg = reg;
 752           pifsr->offset = (insn & 0x007e) << 1;
 753           pifsr->cur_frameoffset = pi->frameoffset;
 754 #ifdef DEBUG
 755           printf_filtered ("\tSaved register r%d, offset %d", reg, pifsr->offset);
 756 #endif
 757           pifsr++;
 758         }
 759
 760 #ifdef DEBUG
 761       printf_filtered ("\n");
 762 #endif
 763     }
 764
 765   if (pifsr)
 766     pifsr->framereg = 0;        /* Tie off last entry */
 767
 768   /* Fix up any offsets to the final offset.  If a frame pointer was created, use it
 769      instead of the stack pointer.  */
 770   for (pifsr_tmp = pi->pifsrs; pifsr_tmp && pifsr_tmp != pifsr; pifsr_tmp++)
 771     {
 772       pifsr_tmp->offset -= pi->frameoffset - pifsr_tmp->cur_frameoffset;
 773       pifsr_tmp->framereg = pi->framereg;
 774
 775 #ifdef DEBUG
 776       printf_filtered ("Saved register r%d, offset = %d, framereg = r%d\n",
 777                     pifsr_tmp->reg, pifsr_tmp->offset, pifsr_tmp->framereg);
 778 #endif
 779     }
 780
 781 #ifdef DEBUG
 782   printf_filtered ("Framereg = r%d, frameoffset = %d\n", pi->framereg, pi->frameoffset);
 783 #endif
 784
 785   return current_pc;
 786 }
 787
 788 /* Function: find_callers_reg
 789    Find REGNUM on the stack.  Otherwise, it's in an active register.
 790    One thing we might want to do here is to check REGNUM against the
 791    clobber mask, and somehow flag it as invalid if it isn't saved on
 792    the stack somewhere.  This would provide a graceful failure mode
 793    when trying to get the value of caller-saves registers for an inner
 794    frame.  */
 795
 796 static CORE_ADDR
 797 v850_find_callers_reg (struct frame_info *fi, int regnum)
 798 {
 799   for (; fi; fi = get_next_frame (fi))
 800     if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
 801                                      get_frame_base (fi)))
 802       return deprecated_read_register_dummy (get_frame_pc (fi),
 803                                              get_frame_base (fi), regnum);
 804     else if (deprecated_get_frame_saved_regs (fi)[regnum] != 0)
 805       return read_memory_unsigned_integer (deprecated_get_frame_saved_regs (fi)[regnum],
 806                                            v850_register_raw_size (regnum));
 807
 808   return read_register (regnum);
 809 }
 810
 811 /* Function: frame_chain
 812    Figure out the frame prior to FI.  Unfortunately, this involves
 813    scanning the prologue of the caller, which will also be done
 814    shortly by v850_init_extra_frame_info.  For the dummy frame, we
 815    just return the stack pointer that was in use at the time the
 816    function call was made.  */
 817
 818 static CORE_ADDR
 819 v850_frame_chain (struct frame_info *fi)
 820 {
 821   struct prologue_info pi;
 822   CORE_ADDR callers_pc, fp;
 823
 824   /* First, find out who called us */
 825   callers_pc = DEPRECATED_FRAME_SAVED_PC (fi);
 826   /* If caller is a call-dummy, then our FP bears no relation to his FP! */
 827   fp = v850_find_callers_reg (fi, E_FP_RAW_REGNUM);
 828   if (DEPRECATED_PC_IN_CALL_DUMMY (callers_pc, fp, fp))
 829     return fp;                  /* caller is call-dummy: return oldest value of FP */
 830
 831   /* Caller is NOT a call-dummy, so everything else should just work.
 832      Even if THIS frame is a call-dummy! */
 833   pi.pifsrs = NULL;
 834
 835   v850_scan_prologue (callers_pc, &pi);
 836
 837   if (pi.start_function)
 838     return 0;                   /* Don't chain beyond the start function */
 839
 840   if (pi.framereg == E_FP_RAW_REGNUM)
 841     return v850_find_callers_reg (fi, pi.framereg);
 842
 843   return get_frame_base (fi) - pi.frameoffset;
 844 }
 845
 846 /* Function: skip_prologue
 847    Return the address of the first code past the prologue of the function.  */
 848
 849 static CORE_ADDR
 850 v850_skip_prologue (CORE_ADDR pc)
 851 {
 852   CORE_ADDR func_addr, func_end;
 853
 854   /* See what the symbol table says */
 855
 856   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 857     {
 858       struct symtab_and_line sal;
 859
 860       sal = find_pc_line (func_addr, 0);
 861
 862       if (sal.line != 0 && sal.end < func_end)
 863         return sal.end;
 864       else
 865         /* Either there's no line info, or the line after the prologue is after
 866            the end of the function.  In this case, there probably isn't a
 867            prologue.  */
 868         return pc;
 869     }
 870
 871 /* We can't find the start of this function, so there's nothing we can do. */
 872   return pc;
 873 }
 874
 875 /* Function: pop_frame
 876    This routine gets called when either the user uses the `return'
 877    command, or the call dummy breakpoint gets hit.  */
 878
 879 static void
 880 v850_pop_frame (void)
 881 {
 882   struct frame_info *frame = get_current_frame ();
 883   int regnum;
 884
 885   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 886                                    get_frame_base (frame),
 887                                    get_frame_base (frame)))
 888     generic_pop_dummy_frame ();
 889   else
 890     {
 891       write_register (E_PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
 892
 893       for (regnum = 0; regnum < E_NUM_REGS; regnum++)
 894         if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
 895           write_register (regnum,
 896                       read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
 897                                              v850_register_raw_size (regnum)));
 898
 899       write_register (E_SP_REGNUM, get_frame_base (frame));
 900     }
 901
 902   flush_cached_frames ();
 903 }
 904
 905 /* Function: push_arguments
 906    Setup arguments and RP for a call to the target.  First four args
 907    go in R6->R9, subsequent args go into sp + 16 -> sp + ...  Structs
 908    are passed by reference.  64 bit quantities (doubles and long
 909    longs) may be split between the regs and the stack.  When calling a
 910    function that returns a struct, a pointer to the struct is passed
 911    in as a secret first argument (always in R6).
 912
 913    Stack space for the args has NOT been allocated: that job is up to us.
 914  */
 915
 916 static CORE_ADDR
 917 v850_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 918                      int struct_return, CORE_ADDR struct_addr)
 919 {
 920   int argreg;
 921   int argnum;
 922   int len = 0;
 923   int stack_offset;
 924
 925   /* First, just for safety, make sure stack is aligned */
 926   sp &= ~3;
 927
 928   /* The offset onto the stack at which we will start copying parameters
 929      (after the registers are used up) begins at 16 rather than at zero.
 930      I don't really know why, that's just the way it seems to work.  */
 931   stack_offset = 16;
 932
 933   /* Now make space on the stack for the args. */
 934   for (argnum = 0; argnum < nargs; argnum++)
 935     len += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
 936   sp -= len + stack_offset;     /* possibly over-allocating, but it works... */
 937   /* (you might think we could allocate 16 bytes */
 938   /* less, but the ABI seems to use it all! )  */
 939
 940   argreg = E_ARG0_REGNUM;
 941   /* the struct_return pointer occupies the first parameter-passing reg */
 942   if (struct_return)
 943     argreg++;
 944
 945   /* Now load as many as possible of the first arguments into
 946      registers, and push the rest onto the stack.  There are 16 bytes
 947      in four registers available.  Loop thru args from first to last.  */
 948   for (argnum = 0; argnum < nargs; argnum++)
 949     {
 950       int len;
 951       char *val;
 952       char valbuf[v850_register_raw_size (E_ARG0_REGNUM)];
 953
 954       if (!v850_type_is_scalar (VALUE_TYPE (*args))
 955           && TYPE_LENGTH (VALUE_TYPE (*args)) > E_MAX_RETTYPE_SIZE_IN_REGS)
 956         {
 957           store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (*args));
 958           len = 4;
 959           val = valbuf;
 960         }
 961       else
 962         {
 963           len = TYPE_LENGTH (VALUE_TYPE (*args));
 964           val = (char *) VALUE_CONTENTS (*args);
 965         }
 966
 967       while (len > 0)
 968         if (argreg <= E_ARGLAST_REGNUM)
 969           {
 970             CORE_ADDR regval;
 971
 972             regval = extract_unsigned_integer (val, v850_register_raw_size (argreg));
 973             write_register (argreg, regval);
 974
 975             len -= v850_register_raw_size (argreg);
 976             val += v850_register_raw_size (argreg);
 977             argreg++;
 978           }
 979         else
 980           {
 981             write_memory (sp + stack_offset, val, 4);
 982
 983             len -= 4;
 984             val += 4;
 985             stack_offset += 4;
 986           }
 987       args++;
 988     }
 989   return sp;
 990 }
 991
 992 /* Function: push_return_address (pc)
 993    Set up the return address for the inferior function call.
 994    Needed for targets where we don't actually execute a JSR/BSR instruction */
 995
 996 static CORE_ADDR
 997 v850_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 998 {
 999   write_register (E_RP_REGNUM, entry_point_address ());
1000   return sp;
1001 }
1002
1003 /* Function: frame_saved_pc
1004    Find the caller of this frame.  We do this by seeing if E_RP_REGNUM
1005    is saved in the stack anywhere, otherwise we get it from the
1006    registers.  If the inner frame is a dummy frame, return its PC
1007    instead of RP, because that's where "caller" of the dummy-frame
1008    will be found.  */
1009
1010 static CORE_ADDR
1011 v850_frame_saved_pc (struct frame_info *fi)
1012 {
1013   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
1014                                    get_frame_base (fi)))
1015     return deprecated_read_register_dummy (get_frame_pc (fi),
1016                                            get_frame_base (fi), E_PC_REGNUM);
1017   else
1018     return v850_find_callers_reg (fi, E_RP_REGNUM);
1019 }
1020
1021
1022 /* Function: fix_call_dummy
1023    Pokes the callee function's address into the CALL_DUMMY assembly stub.
1024    Assumes that the CALL_DUMMY looks like this:
1025    jarl <offset24>, r31
1026    trap
1027  */
1028
1029 static void
1030 v850_fix_call_dummy (char *dummy, CORE_ADDR sp, CORE_ADDR fun, int nargs,
1031                      struct value **args, struct type *type, int gcc_p)
1032 {
1033   long offset24;
1034
1035   offset24 = (long) fun - (long) entry_point_address ();
1036   offset24 &= 0x3fffff;
1037   offset24 |= 0xff800000;       /* jarl <offset24>, r31 */
1038
1039   store_unsigned_integer ((unsigned int *) &dummy[2], 2, offset24 & 0xffff);
1040   store_unsigned_integer ((unsigned int *) &dummy[0], 2, offset24 >> 16);
1041 }
1042
1043 static CORE_ADDR
1044 v850_saved_pc_after_call (struct frame_info *ignore)
1045 {
1046   return read_register (E_RP_REGNUM);
1047 }
1048
1049 static void
1050 v850_extract_return_value (struct type *type, char *regbuf, char *valbuf)
1051 {
1052   CORE_ADDR return_buffer;
1053
1054   if (!v850_use_struct_convention (0, type))
1055     {
1056       /* Scalar return values of <= 8 bytes are returned in
1057          E_V0_REGNUM to E_V1_REGNUM. */
1058       memcpy (valbuf,
1059               &regbuf[DEPRECATED_REGISTER_BYTE (E_V0_REGNUM)],
1060               TYPE_LENGTH (type));
1061     }
1062   else
1063     {
1064       /* Aggregates and return values > 8 bytes are returned in memory,
1065          pointed to by R6. */
1066       return_buffer =
1067         extract_unsigned_integer (regbuf + DEPRECATED_REGISTER_BYTE (E_V0_REGNUM),
1068                                   DEPRECATED_REGISTER_RAW_SIZE (E_V0_REGNUM));
1069
1070       read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
1071     }
1072 }
1073
1074 const static unsigned char *
1075 v850_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1076 {
1077   static unsigned char breakpoint[] = { 0x85, 0x05 };
1078   *lenptr = sizeof (breakpoint);
1079   return breakpoint;
1080 }
1081
1082 static void
1083 v850_store_return_value (struct type *type, char *valbuf)
1084 {
1085   CORE_ADDR return_buffer;
1086
1087   if (!v850_use_struct_convention (0, type))
1088     deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (E_V0_REGNUM), valbuf,
1089                                      TYPE_LENGTH (type));
1090   else
1091     {
1092       return_buffer = read_register (E_V0_REGNUM);
1093       write_memory (return_buffer, valbuf, TYPE_LENGTH (type));
1094     }
1095 }
1096
1097 static void
1098 v850_frame_init_saved_regs (struct frame_info *fi)
1099 {
1100   struct prologue_info pi;
1101   struct pifsr pifsrs[E_NUM_REGS + 1], *pifsr;
1102   CORE_ADDR func_addr, func_end;
1103
1104   if (!deprecated_get_frame_saved_regs (fi))
1105     {
1106       frame_saved_regs_zalloc (fi);
1107
1108       /* The call dummy doesn't save any registers on the stack, so we
1109          can return now.  */
1110       if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), get_frame_base (fi),
1111                                        get_frame_base (fi)))
1112         return;
1113
1114       /* Find the beginning of this function, so we can analyze its
1115          prologue. */
1116       if (find_pc_partial_function (get_frame_pc (fi), NULL, &func_addr, &func_end))
1117         {
1118           pi.pifsrs = pifsrs;
1119
1120           v850_scan_prologue (get_frame_pc (fi), &pi);
1121
1122           if (!get_next_frame (fi) && pi.framereg == E_SP_REGNUM)
1123             deprecated_update_frame_base_hack (fi, read_register (pi.framereg) - pi.frameoffset);
1124
1125           for (pifsr = pifsrs; pifsr->framereg; pifsr++)
1126             {
1127               deprecated_get_frame_saved_regs (fi)[pifsr->reg] = pifsr->offset + get_frame_base (fi);
1128
1129               if (pifsr->framereg == E_SP_REGNUM)
1130                 deprecated_get_frame_saved_regs (fi)[pifsr->reg] += pi.frameoffset;
1131             }
1132         }
1133       /* Else we're out of luck (can't debug completely stripped code).
1134          FIXME. */
1135     }
1136 }
1137
1138 /* Function: init_extra_frame_info
1139    Setup the frame's frame pointer, pc, and frame addresses for saved
1140    registers.  Most of the work is done in scan_prologue().
1141
1142    Note that when we are called for the last frame (currently active frame),
1143    that get_frame_pc (fi) and fi->frame will already be setup.  However, fi->frame will
1144    be valid only if this routine uses FP.  For previous frames, fi-frame will
1145    always be correct (since that is derived from v850_frame_chain ()).
1146
1147    We can be called with the PC in the call dummy under two
1148    circumstances.  First, during normal backtracing, second, while
1149    figuring out the frame pointer just prior to calling the target
1150    function (see call_function_by_hand).  */
1151
1152 static void
1153 v850_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1154 {
1155   struct prologue_info pi;
1156
1157   if (get_next_frame (fi))
1158     deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
1159
1160   v850_frame_init_saved_regs (fi);
1161 }
1162
1163 static void
1164 v850_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1165 {
1166   write_register (E_ARG0_REGNUM, addr);
1167 }
1168
1169 static CORE_ADDR
1170 v850_target_read_fp (void)
1171 {
1172   return read_register (E_FP_RAW_REGNUM);
1173 }
1174
1175 static struct gdbarch *
1176 v850_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1177 {
1178   static LONGEST call_dummy_words[1] = { 0 };
1179   struct gdbarch_tdep *tdep = NULL;
1180   struct gdbarch *gdbarch;
1181   int i;
1182
1183   /* find a candidate among the list of pre-declared architectures. */
1184   arches = gdbarch_list_lookup_by_info (arches, &info);
1185   if (arches != NULL)
1186     return (arches->gdbarch);
1187
1188 #if 0
1189   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1190 #endif
1191
1192   /* Change the register names based on the current machine type. */
1193   if (info.bfd_arch_info->arch != bfd_arch_v850)
1194     return 0;
1195
1196   gdbarch = gdbarch_alloc (&info, 0);
1197
1198   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1199      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
1200   set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
1201
1202   for (i = 0; v850_processor_type_table[i].regnames != NULL; i++)
1203     {
1204       if (v850_processor_type_table[i].mach == info.bfd_arch_info->mach)
1205         {
1206           v850_register_names = v850_processor_type_table[i].regnames;
1207           break;
1208         }
1209     }
1210
1211   /*
1212    * Basic register fields and methods.
1213    */
1214   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
1215   set_gdbarch_num_pseudo_regs (gdbarch, 0);
1216   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1217   set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
1218   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1219   set_gdbarch_register_name (gdbarch, v850_register_name);
1220   set_gdbarch_deprecated_register_size (gdbarch, v850_reg_size);
1221   set_gdbarch_deprecated_register_bytes (gdbarch, E_ALL_REGS_SIZE);
1222   set_gdbarch_deprecated_register_byte (gdbarch, v850_register_byte);
1223   set_gdbarch_deprecated_register_raw_size (gdbarch, v850_register_raw_size);
1224   set_gdbarch_deprecated_max_register_raw_size (gdbarch, v850_reg_size);
1225   set_gdbarch_deprecated_register_virtual_size (gdbarch, v850_register_raw_size);
1226   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, v850_reg_size);
1227   set_gdbarch_deprecated_register_virtual_type (gdbarch, v850_reg_virtual_type);
1228
1229   set_gdbarch_deprecated_target_read_fp (gdbarch, v850_target_read_fp);
1230
1231   /*
1232    * Frame Info
1233    */
1234   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, v850_frame_init_saved_regs);
1235   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, v850_init_extra_frame_info);
1236   set_gdbarch_deprecated_frame_chain (gdbarch, v850_frame_chain);
1237   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, v850_saved_pc_after_call);
1238   set_gdbarch_deprecated_frame_saved_pc (gdbarch, v850_frame_saved_pc);
1239   set_gdbarch_skip_prologue (gdbarch, v850_skip_prologue);
1240
1241   /*
1242    * Miscelany
1243    */
1244   /* Stack grows up. */
1245   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1246   /* This value is almost never non-zero... */
1247   set_gdbarch_frame_args_skip (gdbarch, 0);
1248
1249   /*
1250    * Call Dummies
1251    *
1252    * These values and methods are used when gdb calls a target function.  */
1253   set_gdbarch_deprecated_push_return_address (gdbarch, v850_push_return_address);
1254   set_gdbarch_deprecated_extract_return_value (gdbarch, v850_extract_return_value);
1255   set_gdbarch_deprecated_push_arguments (gdbarch, v850_push_arguments);
1256   set_gdbarch_deprecated_pop_frame (gdbarch, v850_pop_frame);
1257   set_gdbarch_deprecated_store_struct_return (gdbarch, v850_store_struct_return);
1258   set_gdbarch_deprecated_store_return_value (gdbarch, v850_store_return_value);
1259   set_gdbarch_use_struct_convention (gdbarch, v850_use_struct_convention);
1260   set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_nil);
1261   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, 0);
1262   set_gdbarch_deprecated_fix_call_dummy (gdbarch, v850_fix_call_dummy);
1263   set_gdbarch_breakpoint_from_pc (gdbarch, v850_breakpoint_from_pc);
1264
1265   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1266   set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1267   set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1268   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1269
1270   /* Should be using push_dummy_call.  */
1271   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1272
1273   set_gdbarch_print_insn (gdbarch, print_insn_v850);
1274
1275   return gdbarch;
1276 }
1277
1278 extern initialize_file_ftype _initialize_v850_tdep; /* -Wmissing-prototypes */
1279
1280 void
1281 _initialize_v850_tdep (void)
1282 {
1283   register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);
1284 }