Merge GDB 7.5.1

gdb/v850-tdep.c

 /* Target-dependent code for the NEC V850 for GDB, the GNU debugger.
 
    Copyright (C) 1996, 1998-2005, 2007-2012 Free Software Foundation,
    Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
@@ skipping 84 matching lines @@
     E_R56_REGNUM,
     E_R57_REGNUM,
     E_R58_REGNUM,
     E_R59_REGNUM,
     E_R60_REGNUM,
     E_R61_REGNUM,
     E_R62_REGNUM,
     E_R63_REGNUM,
     E_R64_REGNUM, E_PC_REGNUM = E_R64_REGNUM,
     E_R65_REGNUM,
+    E_NUM_OF_V850_REGS,
+    E_NUM_OF_V850E_REGS = E_NUM_OF_V850_REGS,
+
+    /* mpu0 system registers */
+    E_R66_REGNUM = E_NUM_OF_V850_REGS,
+    E_R67_REGNUM,
+    E_R68_REGNUM,
+    E_R69_REGNUM,
+    E_R70_REGNUM,
+    E_R71_REGNUM,
+    E_R72_REGNUM,
+    E_R73_REGNUM,
+    E_R74_REGNUM,
+    E_R75_REGNUM,
+    E_R76_REGNUM,
+    E_R77_REGNUM,
+    E_R78_REGNUM,
+    E_R79_REGNUM,
+    E_R80_REGNUM,
+    E_R81_REGNUM,
+    E_R82_REGNUM,
+    E_R83_REGNUM,
+    E_R84_REGNUM,
+    E_R85_REGNUM,
+    E_R86_REGNUM,
+    E_R87_REGNUM,
+    E_R88_REGNUM,
+    E_R89_REGNUM,
+    E_R90_REGNUM,
+    E_R91_REGNUM,
+    E_R92_REGNUM,
+    E_R93_REGNUM,
+
+    /* mpu1 system registers */
+
+    E_R94_REGNUM,
+    E_R95_REGNUM,
+    E_R96_REGNUM,
+    E_R97_REGNUM,
+    E_R98_REGNUM,
+    E_R99_REGNUM,
+    E_R100_REGNUM,
+    E_R101_REGNUM,
+    E_R102_REGNUM,
+    E_R103_REGNUM,
+    E_R104_REGNUM,
+    E_R105_REGNUM,
+    E_R106_REGNUM,
+    E_R107_REGNUM,
+    E_R108_REGNUM,
+    E_R109_REGNUM,
+    E_R110_REGNUM,
+    E_R111_REGNUM,
+    E_R112_REGNUM,
+    E_R113_REGNUM,
+    E_R114_REGNUM,
+    E_R115_REGNUM,
+    E_R116_REGNUM,
+    E_R117_REGNUM,
+    E_R118_REGNUM,
+    E_R119_REGNUM,
+    E_R120_REGNUM,
+    E_R121_REGNUM,
+
+    /* fpu system registers */
+    E_R122_REGNUM,
+    E_R123_REGNUM,
+    E_R124_REGNUM,
+    E_R125_REGNUM,
+    E_R126_REGNUM,
+    E_R127_REGNUM,
+    E_R128_REGNUM, E_FPSR_REGNUM = E_R128_REGNUM,
+    E_R129_REGNUM, E_FPEPC_REGNUM = E_R129_REGNUM,
+    E_R130_REGNUM, E_FPST_REGNUM = E_R130_REGNUM,
+    E_R131_REGNUM, E_FPCC_REGNUM = E_R131_REGNUM,
+    E_R132_REGNUM, E_FPCFG_REGNUM = E_R132_REGNUM,
+    E_R133_REGNUM,
+    E_R134_REGNUM,
+    E_R135_REGNUM,
+    E_R136_REGNUM,
+    E_R137_REGNUM,
+    E_R138_REGNUM,
+    E_R139_REGNUM,
+    E_R140_REGNUM,
+    E_R141_REGNUM,
+    E_R142_REGNUM,
+    E_R143_REGNUM,
+    E_R144_REGNUM,
+    E_R145_REGNUM,
+    E_R146_REGNUM,
+    E_R147_REGNUM,
+    E_R148_REGNUM,
     E_NUM_REGS
   };
 
 enum
 {
   v850_reg_size = 4
 };
 
 /* Size of return datatype which fits into all return registers.  */
 enum
@@ skipping 30 matching lines @@
   { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 
     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 
     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", 
     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
     "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
     "pc", "fp"
   };
-  if (regnum < 0 || regnum >= E_NUM_REGS)
+  if (regnum < 0 || regnum > E_NUM_OF_V850_REGS)
     return NULL;
   return v850_reg_names[regnum];
 }
 
 static const char *
 v850e_register_name (struct gdbarch *gdbarch, int regnum)
 {
   static const char *v850e_reg_names[] =
   {
     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
     "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
     "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
     "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
     "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
     "pc", "fp"
   };
+  if (regnum < 0 || regnum > E_NUM_OF_V850E_REGS)
+    return NULL;
+  return v850e_reg_names[regnum];
+}
+
+static const char *
+v850e2_register_name (struct gdbarch *gdbarch, int regnum)
+{
+  static const char *v850e2_reg_names[] =
+  {
+    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+    "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
+    "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
+
+    "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
+    "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
+    "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
+    "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
+    "pc", "fp"
+
+    /* mpu0 system registers */
+    "vip", "sr33", "sr34", "sr35", "vmecr", "vmtid", "vmadr", "sr39",
+    "vpecr", "vptid", "vpadr", "sr43", "vdecr", "vdtid", "sr46", "sr47",
+    "sr48", "sr49", "sr50", "sr51", "sr52", "sr53", "sr54", "sr55",
+    "sr56", "sr57", "sr58", "sr59",
+
+    /* mpu1 system registers */
+    "mpm", "mpc", "tid", "ppa", "ppm", "ppc", "dcc", "dcv0",
+    "dcv1", "sr69", "spal", "spau", "ipa0l", "ipa0u", "ipa1l", "ipa1u",
+    "iap2l", "ipa2u", "ipa3l", "ipa3u", "dpa0l", "dpa0u", "dpa1l", "dpa1u",
+    "dpa2l", "dpa2u", "dpa3l", "dpa3u",
+
+    /* fpu system registers */
+    "sr88", "sr89", "sr90", "sr91", "sr92", "sr93", "fpsr", "fpepc",
+    "fpst", "fpcc", "fpcfg", "sr99", "sr100", "sr101", "sr102", "sr103",
+    "sr104", "sr105", "sr106", "sr107", "sr108", "sr109", "sr110", "sr111",
+    "sr112", "sr113", "sr114", "sr115"
+  };
   if (regnum < 0 || regnum >= E_NUM_REGS)
     return NULL;
-  return v850e_reg_names[regnum];
+  return v850e2_reg_names[regnum];
 }
 
 /* Returns the default type for register N.  */
 
 static struct type *
 v850_register_type (struct gdbarch *gdbarch, int regnum)
 {
   if (regnum == E_PC_REGNUM)
     return builtin_type (gdbarch)->builtin_func_ptr;
   return builtin_type (gdbarch)->builtin_int32;
@@ skipping 267 matching lines @@
 
 static CORE_ADDR
 v850_analyze_prologue (struct gdbarch *gdbarch,
                        CORE_ADDR func_addr, CORE_ADDR pc,
                        struct v850_frame_cache *pi, ULONGEST ctbp)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   CORE_ADDR prologue_end, current_pc;
   struct pifsr pifsrs[E_NUM_REGS + 1];
   struct pifsr *pifsr, *pifsr_tmp;
-  int fp_used;
   int ep_used;
   int reg;
   CORE_ADDR save_pc, save_end;
   int regsave_func_p;
   int r12_tmp;
 
   memset (&pifsrs, 0, sizeof pifsrs);
   pifsr = &pifsrs[0];
 
   prologue_end = pc;
@@ skipping 319 matching lines @@
          extract_unsigned_integer (valbuf, len, byte_order));
   else if (len <= 2 * v850_reg_size)
     {
       int i, regnum = E_V0_REGNUM;
       for (i = 0; i < len; i += 4)
         regcache_raw_write (regcache, regnum++, valbuf + i);
     }
 }
 
 static enum return_value_convention
-v850_return_value (struct gdbarch *gdbarch, struct type *func_type,
+v850_return_value (struct gdbarch *gdbarch, struct value *function,
                    struct type *type, struct regcache *regcache,
                    gdb_byte *readbuf, const gdb_byte *writebuf)
 {
   if (v850_use_struct_convention (type))
     return RETURN_VALUE_STRUCT_CONVENTION;
   if (writebuf)
     v850_store_return_value (type, regcache, writebuf);
   else if (readbuf)
     v850_extract_return_value (type, regcache, readbuf);
   return RETURN_VALUE_REGISTER_CONVENTION;
 }
 
 const static unsigned char *
 v850_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 {
   static unsigned char breakpoint[] = { 0x85, 0x05 };
   *lenptr = sizeof (breakpoint);
   return breakpoint;
 }
 
 static struct v850_frame_cache *
 v850_alloc_frame_cache (struct frame_info *this_frame)
 {
   struct v850_frame_cache *cache;
-  int i;
 
   cache = FRAME_OBSTACK_ZALLOC (struct v850_frame_cache);
   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 
   /* Base address.  */
   cache->base = 0;
   cache->sp_offset = 0;
   cache->pc = 0;
 
   /* Frameless until proven otherwise.  */
@@ skipping 46 matching lines @@
       cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
     }
 
   /* Now that we have the base address for the stack frame we can
      calculate the value of sp in the calling frame.  */
   trad_frame_set_value (cache->saved_regs, E_SP_REGNUM,
                         cache->base - cache->sp_offset);
 
   /* Adjust all the saved registers such that they contain addresses
      instead of offsets.  */
-  for (i = 0; i < E_NUM_REGS; i++)
+  for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
     if (trad_frame_addr_p (cache->saved_regs, i))
       cache->saved_regs[i].addr += cache->base;
 
   /* The call instruction moves the caller's PC in the callee's LP.
      Since this is an unwind, do the reverse.  Copy the location of LP
      into PC (the address / regnum) so that a request for PC will be
      converted into a request for the LP.  */
 
   cache->saved_regs[E_PC_REGNUM] = cache->saved_regs[E_LP_REGNUM];
 
@@ skipping 79 matching lines @@
   /* Change the register names based on the current machine type.  */
   if (info.bfd_arch_info->arch != bfd_arch_v850)
     return NULL;
 
   gdbarch = gdbarch_alloc (&info, NULL);
 
   switch (info.bfd_arch_info->mach)
     {
     case bfd_mach_v850:
       set_gdbarch_register_name (gdbarch, v850_register_name);
+      set_gdbarch_num_regs (gdbarch, E_NUM_OF_V850_REGS);
       break;
     case bfd_mach_v850e:
     case bfd_mach_v850e1:
       set_gdbarch_register_name (gdbarch, v850e_register_name);
+      set_gdbarch_num_regs (gdbarch, E_NUM_OF_V850E_REGS);
+      break;
+    case bfd_mach_v850e2:
+    case bfd_mach_v850e2v3:
+      set_gdbarch_register_name (gdbarch, v850e2_register_name);
+      set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
       break;
     }
 
-  set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
   set_gdbarch_num_pseudo_regs (gdbarch, 0);
   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
   set_gdbarch_fp0_regnum (gdbarch, -1);
 
   set_gdbarch_register_type (gdbarch, v850_register_type);
 
   set_gdbarch_char_signed (gdbarch, 1);
   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
   set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
@@ skipping 31 matching lines @@
   return gdbarch;
 }
 
 extern initialize_file_ftype _initialize_v850_tdep; /* -Wmissing-prototypes */
 
 void
 _initialize_v850_tdep (void)
 {
   register_gdbarch_init (bfd_arch_v850, v850_gdbarch_init);
 }