gdb/frv-tdep.c

   1 /* Target-dependent code for the Fujitsu FR-V, for GDB, the GNU Debugger.
   2    Copyright 2002, 2003, 2004 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "gdb_string.h"
  23 #include "inferior.h"
  24 #include "gdbcore.h"
  25 #include "arch-utils.h"
  26 #include "regcache.h"
  27 #include "frame.h"
  28 #include "frame-unwind.h"
  29 #include "frame-base.h"
  30 #include "trad-frame.h"
  31 #include "dis-asm.h"
  32 #include "gdb_assert.h"
  33 #include "sim-regno.h"
  34 #include "gdb/sim-frv.h"
  35 #include "opcodes/frv-desc.h"   /* for the H_SPR_... enums */
  36 #include "symtab.h"
  37 #include "elf-bfd.h"
  38 #include "elf/frv.h"
  39 #include "osabi.h"
  40 #include "frv-tdep.h"
  41
  42 extern void _initialize_frv_tdep (void);
  43
  44 static gdbarch_init_ftype frv_gdbarch_init;
  45
  46 static gdbarch_register_name_ftype frv_register_name;
  47 static gdbarch_breakpoint_from_pc_ftype frv_breakpoint_from_pc;
  48 static gdbarch_adjust_breakpoint_address_ftype frv_gdbarch_adjust_breakpoint_address;
  49 static gdbarch_skip_prologue_ftype frv_skip_prologue;
  50
  51 static LONGEST frv_call_dummy_words[] =
  52 {0};
  53
  54
  55 struct frv_unwind_cache         /* was struct frame_extra_info */
  56   {
  57     /* The previous frame's inner-most stack address.  Used as this
  58        frame ID's stack_addr.  */
  59     CORE_ADDR prev_sp;
  60
  61     /* The frame's base, optionally used by the high-level debug info.  */
  62     CORE_ADDR base;
  63
  64     /* Table indicating the location of each and every register.  */
  65     struct trad_frame_saved_reg *saved_regs;
  66   };
  67
  68
  69 /* A structure describing a particular variant of the FRV.
  70    We allocate and initialize one of these structures when we create
  71    the gdbarch object for a variant.
  72
  73    At the moment, all the FR variants we support differ only in which
  74    registers are present; the portable code of GDB knows that
  75    registers whose names are the empty string don't exist, so the
  76    `register_names' array captures all the per-variant information we
  77    need.
  78
  79    in the future, if we need to have per-variant maps for raw size,
  80    virtual type, etc., we should replace register_names with an array
  81    of structures, each of which gives all the necessary info for one
  82    register.  Don't stick parallel arrays in here --- that's so
  83    Fortran.  */
  84 struct gdbarch_tdep
  85 {
  86   /* Which ABI is in use?  */
  87   enum frv_abi frv_abi;
  88
  89   /* How many general-purpose registers does this variant have?  */
  90   int num_gprs;
  91
  92   /* How many floating-point registers does this variant have?  */
  93   int num_fprs;
  94
  95   /* How many hardware watchpoints can it support?  */
  96   int num_hw_watchpoints;
  97
  98   /* How many hardware breakpoints can it support?  */
  99   int num_hw_breakpoints;
 100
 101   /* Register names.  */
 102   char **register_names;
 103 };
 104
 105 #define CURRENT_VARIANT (gdbarch_tdep (current_gdbarch))
 106
 107 /* Return the FR-V ABI associated with GDBARCH.  */
 108 enum frv_abi
 109 frv_abi (struct gdbarch *gdbarch)
 110 {
 111   return gdbarch_tdep (gdbarch)->frv_abi;
 112 }
 113
 114 /* Fetch the interpreter and executable loadmap addresses (for shared
 115    library support) for the FDPIC ABI.  Return 0 if successful, -1 if
 116    not.  (E.g, -1 will be returned if the ABI isn't the FDPIC ABI.)  */
 117 int
 118 frv_fdpic_loadmap_addresses (struct gdbarch *gdbarch, CORE_ADDR *interp_addr,
 119                              CORE_ADDR *exec_addr)
 120 {
 121   if (frv_abi (gdbarch) != FRV_ABI_FDPIC)
 122     return -1;
 123   else
 124     {
 125       if (interp_addr != NULL)
 126         {
 127           ULONGEST val;
 128           regcache_cooked_read_unsigned (current_regcache,
 129                                          fdpic_loadmap_interp_regnum, &val);
 130           *interp_addr = val;
 131         }
 132       if (exec_addr != NULL)
 133         {
 134           ULONGEST val;
 135           regcache_cooked_read_unsigned (current_regcache,
 136                                          fdpic_loadmap_exec_regnum, &val);
 137           *exec_addr = val;
 138         }
 139       return 0;
 140     }
 141 }
 142
 143 /* Allocate a new variant structure, and set up default values for all
 144    the fields.  */
 145 static struct gdbarch_tdep *
 146 new_variant (void)
 147 {
 148   struct gdbarch_tdep *var;
 149   int r;
 150   char buf[20];
 151
 152   var = xmalloc (sizeof (*var));
 153   memset (var, 0, sizeof (*var));
 154
 155   var->frv_abi = FRV_ABI_EABI;
 156   var->num_gprs = 64;
 157   var->num_fprs = 64;
 158   var->num_hw_watchpoints = 0;
 159   var->num_hw_breakpoints = 0;
 160
 161   /* By default, don't supply any general-purpose or floating-point
 162      register names.  */
 163   var->register_names
 164     = (char **) xmalloc ((frv_num_regs + frv_num_pseudo_regs)
 165                          * sizeof (char *));
 166   for (r = 0; r < frv_num_regs + frv_num_pseudo_regs; r++)
 167     var->register_names[r] = "";
 168
 169   /* Do, however, supply default names for the known special-purpose
 170      registers.  */
 171
 172   var->register_names[pc_regnum] = "pc";
 173   var->register_names[lr_regnum] = "lr";
 174   var->register_names[lcr_regnum] = "lcr";
 175
 176   var->register_names[psr_regnum] = "psr";
 177   var->register_names[ccr_regnum] = "ccr";
 178   var->register_names[cccr_regnum] = "cccr";
 179   var->register_names[tbr_regnum] = "tbr";
 180
 181   /* Debug registers.  */
 182   var->register_names[brr_regnum] = "brr";
 183   var->register_names[dbar0_regnum] = "dbar0";
 184   var->register_names[dbar1_regnum] = "dbar1";
 185   var->register_names[dbar2_regnum] = "dbar2";
 186   var->register_names[dbar3_regnum] = "dbar3";
 187
 188   /* iacc0 (Only found on MB93405.)  */
 189   var->register_names[iacc0h_regnum] = "iacc0h";
 190   var->register_names[iacc0l_regnum] = "iacc0l";
 191   var->register_names[iacc0_regnum] = "iacc0";
 192
 193   return var;
 194 }
 195
 196
 197 /* Indicate that the variant VAR has NUM_GPRS general-purpose
 198    registers, and fill in the names array appropriately.  */
 199 static void
 200 set_variant_num_gprs (struct gdbarch_tdep *var, int num_gprs)
 201 {
 202   int r;
 203
 204   var->num_gprs = num_gprs;
 205
 206   for (r = 0; r < num_gprs; ++r)
 207     {
 208       char buf[20];
 209
 210       sprintf (buf, "gr%d", r);
 211       var->register_names[first_gpr_regnum + r] = xstrdup (buf);
 212     }
 213 }
 214
 215
 216 /* Indicate that the variant VAR has NUM_FPRS floating-point
 217    registers, and fill in the names array appropriately.  */
 218 static void
 219 set_variant_num_fprs (struct gdbarch_tdep *var, int num_fprs)
 220 {
 221   int r;
 222
 223   var->num_fprs = num_fprs;
 224
 225   for (r = 0; r < num_fprs; ++r)
 226     {
 227       char buf[20];
 228
 229       sprintf (buf, "fr%d", r);
 230       var->register_names[first_fpr_regnum + r] = xstrdup (buf);
 231     }
 232 }
 233
 234 static void
 235 set_variant_abi_fdpic (struct gdbarch_tdep *var)
 236 {
 237   var->frv_abi = FRV_ABI_FDPIC;
 238   var->register_names[fdpic_loadmap_exec_regnum] = xstrdup ("loadmap_exec");
 239   var->register_names[fdpic_loadmap_interp_regnum] = xstrdup ("loadmap_interp");
 240 }
 241
 242 static const char *
 243 frv_register_name (int reg)
 244 {
 245   if (reg < 0)
 246     return "?toosmall?";
 247   if (reg >= frv_num_regs + frv_num_pseudo_regs)
 248     return "?toolarge?";
 249
 250   return CURRENT_VARIANT->register_names[reg];
 251 }
 252
 253
 254 static struct type *
 255 frv_register_type (struct gdbarch *gdbarch, int reg)
 256 {
 257   if (reg >= first_fpr_regnum && reg <= last_fpr_regnum)
 258     return builtin_type_float;
 259   else if (reg == iacc0_regnum)
 260     return builtin_type_int64;
 261   else
 262     return builtin_type_int32;
 263 }
 264
 265 static void
 266 frv_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 267                           int reg, void *buffer)
 268 {
 269   if (reg == iacc0_regnum)
 270     {
 271       regcache_raw_read (regcache, iacc0h_regnum, buffer);
 272       regcache_raw_read (regcache, iacc0l_regnum, (bfd_byte *) buffer + 4);
 273     }
 274 }
 275
 276 static void
 277 frv_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 278                           int reg, const void *buffer)
 279 {
 280   if (reg == iacc0_regnum)
 281     {
 282       regcache_raw_write (regcache, iacc0h_regnum, buffer);
 283       regcache_raw_write (regcache, iacc0l_regnum, (bfd_byte *) buffer + 4);
 284     }
 285 }
 286
 287 static int
 288 frv_register_sim_regno (int reg)
 289 {
 290   static const int spr_map[] =
 291     {
 292       H_SPR_PSR,                /* psr_regnum */
 293       H_SPR_CCR,                /* ccr_regnum */
 294       H_SPR_CCCR,               /* cccr_regnum */
 295       -1,                       /* 132 */
 296       -1,                       /* 133 */
 297       -1,                       /* 134 */
 298       H_SPR_TBR,                /* tbr_regnum */
 299       H_SPR_BRR,                /* brr_regnum */
 300       H_SPR_DBAR0,              /* dbar0_regnum */
 301       H_SPR_DBAR1,              /* dbar1_regnum */
 302       H_SPR_DBAR2,              /* dbar2_regnum */
 303       H_SPR_DBAR3,              /* dbar3_regnum */
 304       -1,                       /* 141 */
 305       -1,                       /* 142 */
 306       -1,                       /* 143 */
 307       -1,                       /* 144 */
 308       H_SPR_LR,                 /* lr_regnum */
 309       H_SPR_LCR,                /* lcr_regnum */
 310       H_SPR_IACC0H,             /* iacc0h_regnum */
 311       H_SPR_IACC0L              /* iacc0l_regnum */
 312     };
 313
 314   gdb_assert (reg >= 0 && reg < NUM_REGS);
 315
 316   if (first_gpr_regnum <= reg && reg <= last_gpr_regnum)
 317     return reg - first_gpr_regnum + SIM_FRV_GR0_REGNUM;
 318   else if (first_fpr_regnum <= reg && reg <= last_fpr_regnum)
 319     return reg - first_fpr_regnum + SIM_FRV_FR0_REGNUM;
 320   else if (pc_regnum == reg)
 321     return SIM_FRV_PC_REGNUM;
 322   else if (reg >= first_spr_regnum
 323            && reg < first_spr_regnum + sizeof (spr_map) / sizeof (spr_map[0]))
 324     {
 325       int spr_reg_offset = spr_map[reg - first_spr_regnum];
 326
 327       if (spr_reg_offset < 0)
 328         return SIM_REGNO_DOES_NOT_EXIST;
 329       else
 330         return SIM_FRV_SPR0_REGNUM + spr_reg_offset;
 331     }
 332
 333   internal_error (__FILE__, __LINE__, "Bad register number %d", reg);
 334 }
 335
 336 static const unsigned char *
 337 frv_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenp)
 338 {
 339   static unsigned char breakpoint[] = {0xc0, 0x70, 0x00, 0x01};
 340   *lenp = sizeof (breakpoint);
 341   return breakpoint;
 342 }
 343
 344 /* Define the maximum number of instructions which may be packed into a
 345    bundle (VLIW instruction).  */
 346 static const int max_instrs_per_bundle = 8;
 347
 348 /* Define the size (in bytes) of an FR-V instruction.  */
 349 static const int frv_instr_size = 4;
 350
 351 /* Adjust a breakpoint's address to account for the FR-V architecture's
 352    constraint that a break instruction must not appear as any but the
 353    first instruction in the bundle.  */
 354 static CORE_ADDR
 355 frv_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
 356 {
 357   int count = max_instrs_per_bundle;
 358   CORE_ADDR addr = bpaddr - frv_instr_size;
 359   CORE_ADDR func_start = get_pc_function_start (bpaddr);
 360
 361   /* Find the end of the previous packing sequence.  This will be indicated
 362      by either attempting to access some inaccessible memory or by finding
 363      an instruction word whose packing bit is set to one. */
 364   while (count-- > 0 && addr >= func_start)
 365     {
 366       char instr[frv_instr_size];
 367       int status;
 368
 369       status = read_memory_nobpt (addr, instr, sizeof instr);
 370
 371       if (status != 0)
 372         break;
 373
 374       /* This is a big endian architecture, so byte zero will have most
 375          significant byte.  The most significant bit of this byte is the
 376          packing bit.  */
 377       if (instr[0] & 0x80)
 378         break;
 379
 380       addr -= frv_instr_size;
 381     }
 382
 383   if (count > 0)
 384     bpaddr = addr + frv_instr_size;
 385
 386   return bpaddr;
 387 }
 388
 389
 390 /* Return true if REG is a caller-saves ("scratch") register,
 391    false otherwise.  */
 392 static int
 393 is_caller_saves_reg (int reg)
 394 {
 395   return ((4 <= reg && reg <= 7)
 396           || (14 <= reg && reg <= 15)
 397           || (32 <= reg && reg <= 47));
 398 }
 399
 400
 401 /* Return true if REG is a callee-saves register, false otherwise.  */
 402 static int
 403 is_callee_saves_reg (int reg)
 404 {
 405   return ((16 <= reg && reg <= 31)
 406           || (48 <= reg && reg <= 63));
 407 }
 408
 409
 410 /* Return true if REG is an argument register, false otherwise.  */
 411 static int
 412 is_argument_reg (int reg)
 413 {
 414   return (8 <= reg && reg <= 13);
 415 }
 416
 417 /* Scan an FR-V prologue, starting at PC, until frame->PC.
 418    If FRAME is non-zero, fill in its saved_regs with appropriate addresses.
 419    We assume FRAME's saved_regs array has already been allocated and cleared.
 420    Return the first PC value after the prologue.
 421
 422    Note that, for unoptimized code, we almost don't need this function
 423    at all; all arguments and locals live on the stack, so we just need
 424    the FP to find everything.  The catch: structures passed by value
 425    have their addresses living in registers; they're never spilled to
 426    the stack.  So if you ever want to be able to get to these
 427    arguments in any frame but the top, you'll need to do this serious
 428    prologue analysis.  */
 429 static CORE_ADDR
 430 frv_analyze_prologue (CORE_ADDR pc, struct frame_info *next_frame,
 431                       struct frv_unwind_cache *info)
 432 {
 433   /* When writing out instruction bitpatterns, we use the following
 434      letters to label instruction fields:
 435      P - The parallel bit.  We don't use this.
 436      J - The register number of GRj in the instruction description.
 437      K - The register number of GRk in the instruction description.
 438      I - The register number of GRi.
 439      S - a signed imediate offset.
 440      U - an unsigned immediate offset.
 441
 442      The dots below the numbers indicate where hex digit boundaries
 443      fall, to make it easier to check the numbers.  */
 444
 445   /* Non-zero iff we've seen the instruction that initializes the
 446      frame pointer for this function's frame.  */
 447   int fp_set = 0;
 448
 449   /* If fp_set is non_zero, then this is the distance from
 450      the stack pointer to frame pointer: fp = sp + fp_offset.  */
 451   int fp_offset = 0;
 452
 453   /* Total size of frame prior to any alloca operations. */
 454   int framesize = 0;
 455
 456   /* Flag indicating if lr has been saved on the stack.  */
 457   int lr_saved_on_stack = 0;
 458
 459   /* The number of the general-purpose register we saved the return
 460      address ("link register") in, or -1 if we haven't moved it yet.  */
 461   int lr_save_reg = -1;
 462
 463   /* Offset (from sp) at which lr has been saved on the stack.  */
 464
 465   int lr_sp_offset = 0;
 466
 467   /* If gr_saved[i] is non-zero, then we've noticed that general
 468      register i has been saved at gr_sp_offset[i] from the stack
 469      pointer.  */
 470   char gr_saved[64];
 471   int gr_sp_offset[64];
 472
 473   /* The address of the most recently scanned prologue instruction.  */
 474   CORE_ADDR last_prologue_pc;
 475
 476   /* The address of the next instruction. */
 477   CORE_ADDR next_pc;
 478
 479   /* The upper bound to of the pc values to scan.  */
 480   CORE_ADDR lim_pc;
 481
 482   memset (gr_saved, 0, sizeof (gr_saved));
 483
 484   last_prologue_pc = pc;
 485
 486   /* Try to compute an upper limit (on how far to scan) based on the
 487      line number info.  */
 488   lim_pc = skip_prologue_using_sal (pc);
 489   /* If there's no line number info, lim_pc will be 0.  In that case,
 490      set the limit to be 100 instructions away from pc.  Hopefully, this
 491      will be far enough away to account for the entire prologue.  Don't
 492      worry about overshooting the end of the function.  The scan loop
 493      below contains some checks to avoid scanning unreasonably far.  */
 494   if (lim_pc == 0)
 495     lim_pc = pc + 400;
 496
 497   /* If we have a frame, we don't want to scan past the frame's pc.  This
 498      will catch those cases where the pc is in the prologue.  */
 499   if (next_frame)
 500     {
 501       CORE_ADDR frame_pc = frame_pc_unwind (next_frame);
 502       if (frame_pc < lim_pc)
 503         lim_pc = frame_pc;
 504     }
 505
 506   /* Scan the prologue.  */
 507   while (pc < lim_pc)
 508     {
 509       LONGEST op = read_memory_integer (pc, 4);
 510       next_pc = pc + 4;
 511
 512       /* The tests in this chain of ifs should be in order of
 513          decreasing selectivity, so that more particular patterns get
 514          to fire before less particular patterns.  */
 515
 516       /* Some sort of control transfer instruction: stop scanning prologue.
 517          Integer Conditional Branch:
 518           X XXXX XX 0000110 XX XXXXXXXXXXXXXXXX
 519          Floating-point / media Conditional Branch:
 520           X XXXX XX 0000111 XX XXXXXXXXXXXXXXXX
 521          LCR Conditional Branch to LR
 522           X XXXX XX 0001110 XX XX 001 X XXXXXXXXXX
 523          Integer conditional Branches to LR
 524           X XXXX XX 0001110 XX XX 010 X XXXXXXXXXX
 525           X XXXX XX 0001110 XX XX 011 X XXXXXXXXXX
 526          Floating-point/Media Branches to LR
 527           X XXXX XX 0001110 XX XX 110 X XXXXXXXXXX
 528           X XXXX XX 0001110 XX XX 111 X XXXXXXXXXX
 529          Jump and Link
 530           X XXXXX X 0001100 XXXXXX XXXXXX XXXXXX
 531           X XXXXX X 0001101 XXXXXX XXXXXX XXXXXX
 532          Call
 533           X XXXXXX 0001111 XXXXXXXXXXXXXXXXXX
 534          Return from Trap
 535           X XXXXX X 0000101 XXXXXX XXXXXX XXXXXX
 536          Integer Conditional Trap
 537           X XXXX XX 0000100 XXXXXX XXXX 00 XXXXXX
 538           X XXXX XX 0011100 XXXXXX XXXXXXXXXXXX
 539          Floating-point /media Conditional Trap
 540           X XXXX XX 0000100 XXXXXX XXXX 01 XXXXXX
 541           X XXXX XX 0011101 XXXXXX XXXXXXXXXXXX
 542          Break
 543           X XXXX XX 0000100 XXXXXX XXXX 11 XXXXXX
 544          Media Trap
 545           X XXXX XX 0000100 XXXXXX XXXX 10 XXXXXX */
 546       if ((op & 0x01d80000) == 0x00180000 /* Conditional branches and Call */
 547           || (op & 0x01f80000) == 0x00300000  /* Jump and Link */
 548           || (op & 0x01f80000) == 0x00100000  /* Return from Trap, Trap */
 549           || (op & 0x01f80000) == 0x00700000) /* Trap immediate */
 550         {
 551           /* Stop scanning; not in prologue any longer.  */
 552           break;
 553         }
 554
 555       /* Loading something from memory into fp probably means that
 556          we're in the epilogue.  Stop scanning the prologue.
 557          ld @(GRi, GRk), fp
 558          X 000010 0000010 XXXXXX 000100 XXXXXX
 559          ldi @(GRi, d12), fp
 560          X 000010 0110010 XXXXXX XXXXXXXXXXXX */
 561       else if ((op & 0x7ffc0fc0) == 0x04080100
 562                || (op & 0x7ffc0000) == 0x04c80000)
 563         {
 564           break;
 565         }
 566
 567       /* Setting the FP from the SP:
 568          ori sp, 0, fp
 569          P 000010 0100010 000001 000000000000 = 0x04881000
 570          0 111111 1111111 111111 111111111111 = 0x7fffffff
 571              .    .   .    .   .    .   .   .
 572          We treat this as part of the prologue.  */
 573       else if ((op & 0x7fffffff) == 0x04881000)
 574         {
 575           fp_set = 1;
 576           fp_offset = 0;
 577           last_prologue_pc = next_pc;
 578         }
 579
 580       /* Move the link register to the scratch register grJ, before saving:
 581          movsg lr, grJ
 582          P 000100 0000011 010000 000111 JJJJJJ = 0x080d01c0
 583          0 111111 1111111 111111 111111 000000 = 0x7fffffc0
 584              .    .   .    .   .    .    .   .
 585          We treat this as part of the prologue.  */
 586       else if ((op & 0x7fffffc0) == 0x080d01c0)
 587         {
 588           int gr_j = op & 0x3f;
 589
 590           /* If we're moving it to a scratch register, that's fine.  */
 591           if (is_caller_saves_reg (gr_j))
 592             {
 593               lr_save_reg = gr_j;
 594               last_prologue_pc = next_pc;
 595             }
 596         }
 597
 598       /* To save multiple callee-saves registers on the stack, at
 599          offset zero:
 600
 601          std grK,@(sp,gr0)
 602          P KKKKKK 0000011 000001 000011 000000 = 0x000c10c0
 603          0 000000 1111111 111111 111111 111111 = 0x01ffffff
 604
 605          stq grK,@(sp,gr0)
 606          P KKKKKK 0000011 000001 000100 000000 = 0x000c1100
 607          0 000000 1111111 111111 111111 111111 = 0x01ffffff
 608              .    .   .    .   .    .    .   .
 609          We treat this as part of the prologue, and record the register's
 610          saved address in the frame structure.  */
 611       else if ((op & 0x01ffffff) == 0x000c10c0
 612             || (op & 0x01ffffff) == 0x000c1100)
 613         {
 614           int gr_k = ((op >> 25) & 0x3f);
 615           int ope  = ((op >> 6)  & 0x3f);
 616           int count;
 617           int i;
 618
 619           /* Is it an std or an stq?  */
 620           if (ope == 0x03)
 621             count = 2;
 622           else
 623             count = 4;
 624
 625           /* Is it really a callee-saves register?  */
 626           if (is_callee_saves_reg (gr_k))
 627             {
 628               for (i = 0; i < count; i++)
 629                 {
 630                   gr_saved[gr_k + i] = 1;
 631                   gr_sp_offset[gr_k + i] = 4 * i;
 632                 }
 633               last_prologue_pc = next_pc;
 634             }
 635         }
 636
 637       /* Adjusting the stack pointer.  (The stack pointer is GR1.)
 638          addi sp, S, sp
 639          P 000001 0010000 000001 SSSSSSSSSSSS = 0x02401000
 640          0 111111 1111111 111111 000000000000 = 0x7ffff000
 641              .    .   .    .   .    .   .   .
 642          We treat this as part of the prologue.  */
 643       else if ((op & 0x7ffff000) == 0x02401000)
 644         {
 645           if (framesize == 0)
 646             {
 647               /* Sign-extend the twelve-bit field.
 648                  (Isn't there a better way to do this?)  */
 649               int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
 650
 651               framesize -= s;
 652               last_prologue_pc = pc;
 653             }
 654           else
 655             {
 656               /* If the prologue is being adjusted again, we've
 657                  likely gone too far; i.e. we're probably in the
 658                  epilogue.  */
 659               break;
 660             }
 661         }
 662
 663       /* Setting the FP to a constant distance from the SP:
 664          addi sp, S, fp
 665          P 000010 0010000 000001 SSSSSSSSSSSS = 0x04401000
 666          0 111111 1111111 111111 000000000000 = 0x7ffff000
 667              .    .   .    .   .    .   .   .
 668          We treat this as part of the prologue.  */
 669       else if ((op & 0x7ffff000) == 0x04401000)
 670         {
 671           /* Sign-extend the twelve-bit field.
 672              (Isn't there a better way to do this?)  */
 673           int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
 674           fp_set = 1;
 675           fp_offset = s;
 676           last_prologue_pc = pc;
 677         }
 678
 679       /* To spill an argument register to a scratch register:
 680             ori GRi, 0, GRk
 681          P KKKKKK 0100010 IIIIII 000000000000 = 0x00880000
 682          0 000000 1111111 000000 111111111111 = 0x01fc0fff
 683              .    .   .    .   .    .   .   .
 684          For the time being, we treat this as a prologue instruction,
 685          assuming that GRi is an argument register.  This one's kind
 686          of suspicious, because it seems like it could be part of a
 687          legitimate body instruction.  But we only come here when the
 688          source info wasn't helpful, so we have to do the best we can.
 689          Hopefully once GCC and GDB agree on how to emit line number
 690          info for prologues, then this code will never come into play.  */
 691       else if ((op & 0x01fc0fff) == 0x00880000)
 692         {
 693           int gr_i = ((op >> 12) & 0x3f);
 694
 695           /* Make sure that the source is an arg register; if it is, we'll
 696              treat it as a prologue instruction.  */
 697           if (is_argument_reg (gr_i))
 698             last_prologue_pc = next_pc;
 699         }
 700
 701       /* To spill 16-bit values to the stack:
 702              sthi GRk, @(fp, s)
 703          P KKKKKK 1010001 000010 SSSSSSSSSSSS = 0x01442000
 704          0 000000 1111111 111111 000000000000 = 0x01fff000
 705              .    .   .    .   .    .   .   .
 706          And for 8-bit values, we use STB instructions.
 707              stbi GRk, @(fp, s)
 708          P KKKKKK 1010000 000010 SSSSSSSSSSSS = 0x01402000
 709          0 000000 1111111 111111 000000000000 = 0x01fff000
 710              .    .   .    .   .    .   .   .
 711          We check that GRk is really an argument register, and treat
 712          all such as part of the prologue.  */
 713       else if (   (op & 0x01fff000) == 0x01442000
 714                || (op & 0x01fff000) == 0x01402000)
 715         {
 716           int gr_k = ((op >> 25) & 0x3f);
 717
 718           /* Make sure that GRk is really an argument register; treat
 719              it as a prologue instruction if so.  */
 720           if (is_argument_reg (gr_k))
 721             last_prologue_pc = next_pc;
 722         }
 723
 724       /* To save multiple callee-saves register on the stack, at a
 725          non-zero offset:
 726
 727          stdi GRk, @(sp, s)
 728          P KKKKKK 1010011 000001 SSSSSSSSSSSS = 0x014c1000
 729          0 000000 1111111 111111 000000000000 = 0x01fff000
 730              .    .   .    .   .    .   .   .
 731          stqi GRk, @(sp, s)
 732          P KKKKKK 1010100 000001 SSSSSSSSSSSS = 0x01501000
 733          0 000000 1111111 111111 000000000000 = 0x01fff000
 734              .    .   .    .   .    .   .   .
 735          We treat this as part of the prologue, and record the register's
 736          saved address in the frame structure.  */
 737       else if ((op & 0x01fff000) == 0x014c1000
 738             || (op & 0x01fff000) == 0x01501000)
 739         {
 740           int gr_k = ((op >> 25) & 0x3f);
 741           int count;
 742           int i;
 743
 744           /* Is it a stdi or a stqi?  */
 745           if ((op & 0x01fff000) == 0x014c1000)
 746             count = 2;
 747           else
 748             count = 4;
 749
 750           /* Is it really a callee-saves register?  */
 751           if (is_callee_saves_reg (gr_k))
 752             {
 753               /* Sign-extend the twelve-bit field.
 754                  (Isn't there a better way to do this?)  */
 755               int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
 756
 757               for (i = 0; i < count; i++)
 758                 {
 759                   gr_saved[gr_k + i] = 1;
 760                   gr_sp_offset[gr_k + i] = s + (4 * i);
 761                 }
 762               last_prologue_pc = next_pc;
 763             }
 764         }
 765
 766       /* Storing any kind of integer register at any constant offset
 767          from any other register.
 768
 769          st GRk, @(GRi, gr0)
 770          P KKKKKK 0000011 IIIIII 000010 000000 = 0x000c0080
 771          0 000000 1111111 000000 111111 111111 = 0x01fc0fff
 772              .    .   .    .   .    .    .   .
 773          sti GRk, @(GRi, d12)
 774          P KKKKKK 1010010 IIIIII SSSSSSSSSSSS = 0x01480000
 775          0 000000 1111111 000000 000000000000 = 0x01fc0000
 776              .    .   .    .   .    .   .   .
 777          These could be almost anything, but a lot of prologue
 778          instructions fall into this pattern, so let's decode the
 779          instruction once, and then work at a higher level.  */
 780       else if (((op & 0x01fc0fff) == 0x000c0080)
 781             || ((op & 0x01fc0000) == 0x01480000))
 782         {
 783           int gr_k = ((op >> 25) & 0x3f);
 784           int gr_i = ((op >> 12) & 0x3f);
 785           int offset;
 786
 787           /* Are we storing with gr0 as an offset, or using an
 788              immediate value?  */
 789           if ((op & 0x01fc0fff) == 0x000c0080)
 790             offset = 0;
 791           else
 792             offset = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
 793
 794           /* If the address isn't relative to the SP or FP, it's not a
 795              prologue instruction.  */
 796           if (gr_i != sp_regnum && gr_i != fp_regnum)
 797             {
 798               /* Do nothing; not a prologue instruction.  */
 799             }
 800
 801           /* Saving the old FP in the new frame (relative to the SP).  */
 802           else if (gr_k == fp_regnum && gr_i == sp_regnum)
 803             {
 804               gr_saved[fp_regnum] = 1;
 805               gr_sp_offset[fp_regnum] = offset;
 806               last_prologue_pc = next_pc;
 807             }
 808
 809           /* Saving callee-saves register(s) on the stack, relative to
 810              the SP.  */
 811           else if (gr_i == sp_regnum
 812                    && is_callee_saves_reg (gr_k))
 813             {
 814               gr_saved[gr_k] = 1;
 815               if (gr_i == sp_regnum)
 816                 gr_sp_offset[gr_k] = offset;
 817               else
 818                 gr_sp_offset[gr_k] = offset + fp_offset;
 819               last_prologue_pc = next_pc;
 820             }
 821
 822           /* Saving the scratch register holding the return address.  */
 823           else if (lr_save_reg != -1
 824                    && gr_k == lr_save_reg)
 825             {
 826               lr_saved_on_stack = 1;
 827               if (gr_i == sp_regnum)
 828                 lr_sp_offset = offset;
 829               else
 830                 lr_sp_offset = offset + fp_offset;
 831               last_prologue_pc = next_pc;
 832             }
 833
 834           /* Spilling int-sized arguments to the stack.  */
 835           else if (is_argument_reg (gr_k))
 836             last_prologue_pc = next_pc;
 837         }
 838       pc = next_pc;
 839     }
 840
 841   if (next_frame && info)
 842     {
 843       int i;
 844       ULONGEST this_base;
 845
 846       /* If we know the relationship between the stack and frame
 847          pointers, record the addresses of the registers we noticed.
 848          Note that we have to do this as a separate step at the end,
 849          because instructions may save relative to the SP, but we need
 850          their addresses relative to the FP.  */
 851       if (fp_set)
 852           frame_unwind_unsigned_register (next_frame, fp_regnum, &this_base);
 853       else
 854           frame_unwind_unsigned_register (next_frame, sp_regnum, &this_base);
 855
 856       for (i = 0; i < 64; i++)
 857         if (gr_saved[i])
 858           info->saved_regs[i].addr = this_base - fp_offset + gr_sp_offset[i];
 859
 860       info->prev_sp = this_base - fp_offset + framesize;
 861       info->base = this_base;
 862
 863       /* If LR was saved on the stack, record its location.  */
 864       if (lr_saved_on_stack)
 865         info->saved_regs[lr_regnum].addr = this_base - fp_offset + lr_sp_offset;
 866
 867       /* The call instruction moves the caller's PC in the callee's LR.
 868          Since this is an unwind, do the reverse.  Copy the location of LR
 869          into PC (the address / regnum) so that a request for PC will be
 870          converted into a request for the LR.  */
 871       info->saved_regs[pc_regnum] = info->saved_regs[lr_regnum];
 872
 873       /* Save the previous frame's computed SP value.  */
 874       trad_frame_set_value (info->saved_regs, sp_regnum, info->prev_sp);
 875     }
 876
 877   return last_prologue_pc;
 878 }
 879
 880
 881 static CORE_ADDR
 882 frv_skip_prologue (CORE_ADDR pc)
 883 {
 884   CORE_ADDR func_addr, func_end, new_pc;
 885
 886   new_pc = pc;
 887
 888   /* If the line table has entry for a line *within* the function
 889      (i.e., not in the prologue, and not past the end), then that's
 890      our location.  */
 891   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 892     {
 893       struct symtab_and_line sal;
 894
 895       sal = find_pc_line (func_addr, 0);
 896
 897       if (sal.line != 0 && sal.end < func_end)
 898         {
 899           new_pc = sal.end;
 900         }
 901     }
 902
 903   /* The FR-V prologue is at least five instructions long (twenty bytes).
 904      If we didn't find a real source location past that, then
 905      do a full analysis of the prologue.  */
 906   if (new_pc < pc + 20)
 907     new_pc = frv_analyze_prologue (pc, 0, 0);
 908
 909   return new_pc;
 910 }
 911
 912
 913 static struct frv_unwind_cache *
 914 frv_frame_unwind_cache (struct frame_info *next_frame,
 915                          void **this_prologue_cache)
 916 {
 917   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 918   CORE_ADDR pc;
 919   ULONGEST prev_sp;
 920   ULONGEST this_base;
 921   struct frv_unwind_cache *info;
 922
 923   if ((*this_prologue_cache))
 924     return (*this_prologue_cache);
 925
 926   info = FRAME_OBSTACK_ZALLOC (struct frv_unwind_cache);
 927   (*this_prologue_cache) = info;
 928   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 929
 930   /* Prologue analysis does the rest...  */
 931   frv_analyze_prologue (frame_func_unwind (next_frame), next_frame, info);
 932
 933   return info;
 934 }
 935
 936 static void
 937 frv_extract_return_value (struct type *type, struct regcache *regcache,
 938                           void *valbuf)
 939 {
 940   int len = TYPE_LENGTH (type);
 941
 942   if (len <= 4)
 943     {
 944       ULONGEST gpr8_val;
 945       regcache_cooked_read_unsigned (regcache, 8, &gpr8_val);
 946       store_unsigned_integer (valbuf, len, gpr8_val);
 947     }
 948   else if (len == 8)
 949     {
 950       ULONGEST regval;
 951       regcache_cooked_read_unsigned (regcache, 8, &regval);
 952       store_unsigned_integer (valbuf, 4, regval);
 953       regcache_cooked_read_unsigned (regcache, 9, &regval);
 954       store_unsigned_integer ((bfd_byte *) valbuf + 4, 4, regval);
 955     }
 956   else
 957     internal_error (__FILE__, __LINE__, "Illegal return value length: %d", len);
 958 }
 959
 960 static CORE_ADDR
 961 frv_extract_struct_value_address (struct regcache *regcache)
 962 {
 963   ULONGEST addr;
 964   regcache_cooked_read_unsigned (regcache, struct_return_regnum, &addr);
 965   return addr;
 966 }
 967
 968 static void
 969 frv_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 970 {
 971   write_register (struct_return_regnum, addr);
 972 }
 973
 974 static int
 975 frv_frameless_function_invocation (struct frame_info *frame)
 976 {
 977   return legacy_frameless_look_for_prologue (frame);
 978 }
 979
 980 static CORE_ADDR
 981 frv_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 982 {
 983   /* Require dword alignment.  */
 984   return align_down (sp, 8);
 985 }
 986
 987 static CORE_ADDR
 988 find_func_descr (struct gdbarch *gdbarch, CORE_ADDR entry_point)
 989 {
 990   CORE_ADDR descr;
 991   char valbuf[4];
 992
 993   descr = frv_fdpic_find_canonical_descriptor (entry_point);
 994
 995   if (descr != 0)
 996     return descr;
 997
 998   /* Construct a non-canonical descriptor from space allocated on
 999      the stack.  */
1000
1001   descr = value_as_long (value_allocate_space_in_inferior (8));
1002   store_unsigned_integer (valbuf, 4, entry_point);
1003   write_memory (descr, valbuf, 4);
1004   store_unsigned_integer (valbuf, 4,
1005                           frv_fdpic_find_global_pointer (entry_point));
1006   write_memory (descr + 4, valbuf, 4);
1007   return descr;
1008 }
1009
1010 static CORE_ADDR
1011 frv_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1012                                 struct target_ops *targ)
1013 {
1014   CORE_ADDR entry_point;
1015   CORE_ADDR got_address;
1016
1017   entry_point = get_target_memory_unsigned (targ, addr, 4);
1018   got_address = get_target_memory_unsigned (targ, addr + 4, 4);
1019
1020   if (got_address == frv_fdpic_find_global_pointer (entry_point))
1021     return entry_point;
1022   else
1023     return addr;
1024 }
1025
1026 static CORE_ADDR
1027 frv_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
1028                      struct regcache *regcache, CORE_ADDR bp_addr,
1029                      int nargs, struct value **args, CORE_ADDR sp,
1030                      int struct_return, CORE_ADDR struct_addr)
1031 {
1032   int argreg;
1033   int argnum;
1034   char *val;
1035   char valbuf[4];
1036   struct value *arg;
1037   struct type *arg_type;
1038   int len;
1039   enum type_code typecode;
1040   CORE_ADDR regval;
1041   int stack_space;
1042   int stack_offset;
1043   enum frv_abi abi = frv_abi (gdbarch);
1044
1045 #if 0
1046   printf("Push %d args at sp = %x, struct_return=%d (%x)\n",
1047          nargs, (int) sp, struct_return, struct_addr);
1048 #endif
1049
1050   stack_space = 0;
1051   for (argnum = 0; argnum < nargs; ++argnum)
1052     stack_space += align_up (TYPE_LENGTH (VALUE_TYPE (args[argnum])), 4);
1053
1054   stack_space -= (6 * 4);
1055   if (stack_space > 0)
1056     sp -= stack_space;
1057
1058   /* Make sure stack is dword aligned. */
1059   sp = align_down (sp, 8);
1060
1061   stack_offset = 0;
1062
1063   argreg = 8;
1064
1065   if (struct_return)
1066     regcache_cooked_write_unsigned (regcache, struct_return_regnum,
1067                                     struct_addr);
1068
1069   for (argnum = 0; argnum < nargs; ++argnum)
1070     {
1071       arg = args[argnum];
1072       arg_type = check_typedef (VALUE_TYPE (arg));
1073       len = TYPE_LENGTH (arg_type);
1074       typecode = TYPE_CODE (arg_type);
1075
1076       if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
1077         {
1078           store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (arg));
1079           typecode = TYPE_CODE_PTR;
1080           len = 4;
1081           val = valbuf;
1082         }
1083       else if (abi == FRV_ABI_FDPIC
1084                && len == 4
1085                && typecode == TYPE_CODE_PTR
1086                && TYPE_CODE (TYPE_TARGET_TYPE (arg_type)) == TYPE_CODE_FUNC)
1087         {
1088           /* The FDPIC ABI requires function descriptors to be passed instead
1089              of entry points.  */
1090           store_unsigned_integer
1091             (valbuf, 4,
1092              find_func_descr (gdbarch,
1093                               extract_unsigned_integer (VALUE_CONTENTS (arg),
1094                                                         4)));
1095           typecode = TYPE_CODE_PTR;
1096           len = 4;
1097           val = valbuf;
1098         }
1099       else
1100         {
1101           val = (char *) VALUE_CONTENTS (arg);
1102         }
1103
1104       while (len > 0)
1105         {
1106           int partial_len = (len < 4 ? len : 4);
1107
1108           if (argreg < 14)
1109             {
1110               regval = extract_unsigned_integer (val, partial_len);
1111 #if 0
1112               printf("  Argnum %d data %x -> reg %d\n",
1113                      argnum, (int) regval, argreg);
1114 #endif
1115               regcache_cooked_write_unsigned (regcache, argreg, regval);
1116               ++argreg;
1117             }
1118           else
1119             {
1120 #if 0
1121               printf("  Argnum %d data %x -> offset %d (%x)\n",
1122                      argnum, *((int *)val), stack_offset, (int) (sp + stack_offset));
1123 #endif
1124               write_memory (sp + stack_offset, val, partial_len);
1125               stack_offset += align_up (partial_len, 4);
1126             }
1127           len -= partial_len;
1128           val += partial_len;
1129         }
1130     }
1131
1132   /* Set the return address.  For the frv, the return breakpoint is
1133      always at BP_ADDR.  */
1134   regcache_cooked_write_unsigned (regcache, lr_regnum, bp_addr);
1135
1136   if (abi == FRV_ABI_FDPIC)
1137     {
1138       /* Set the GOT register for the FDPIC ABI.  */
1139       regcache_cooked_write_unsigned
1140         (regcache, first_gpr_regnum + 15,
1141          frv_fdpic_find_global_pointer (func_addr));
1142     }
1143
1144   /* Finally, update the SP register.  */
1145   regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
1146
1147   return sp;
1148 }
1149
1150 static void
1151 frv_store_return_value (struct type *type, struct regcache *regcache,
1152                         const void *valbuf)
1153 {
1154   int len = TYPE_LENGTH (type);
1155
1156   if (len <= 4)
1157     {
1158       bfd_byte val[4];
1159       memset (val, 0, sizeof (val));
1160       memcpy (val + (4 - len), valbuf, len);
1161       regcache_cooked_write (regcache, 8, val);
1162     }
1163   else if (len == 8)
1164     {
1165       regcache_cooked_write (regcache, 8, valbuf);
1166       regcache_cooked_write (regcache, 9, (bfd_byte *) valbuf + 4);
1167     }
1168   else
1169     internal_error (__FILE__, __LINE__,
1170                     "Don't know how to return a %d-byte value.", len);
1171 }
1172
1173
1174 /* Hardware watchpoint / breakpoint support for the FR500
1175    and FR400.  */
1176
1177 int
1178 frv_check_watch_resources (int type, int cnt, int ot)
1179 {
1180   struct gdbarch_tdep *var = CURRENT_VARIANT;
1181
1182   /* Watchpoints not supported on simulator.  */
1183   if (strcmp (target_shortname, "sim") == 0)
1184     return 0;
1185
1186   if (type == bp_hardware_breakpoint)
1187     {
1188       if (var->num_hw_breakpoints == 0)
1189         return 0;
1190       else if (cnt <= var->num_hw_breakpoints)
1191         return 1;
1192     }
1193   else
1194     {
1195       if (var->num_hw_watchpoints == 0)
1196         return 0;
1197       else if (ot)
1198         return -1;
1199       else if (cnt <= var->num_hw_watchpoints)
1200         return 1;
1201     }
1202   return -1;
1203 }
1204
1205
1206 CORE_ADDR
1207 frv_stopped_data_address (void)
1208 {
1209   CORE_ADDR brr, dbar0, dbar1, dbar2, dbar3;
1210
1211   brr = read_register (brr_regnum);
1212   dbar0 = read_register (dbar0_regnum);
1213   dbar1 = read_register (dbar1_regnum);
1214   dbar2 = read_register (dbar2_regnum);
1215   dbar3 = read_register (dbar3_regnum);
1216
1217   if (brr & (1<<11))
1218     return dbar0;
1219   else if (brr & (1<<10))
1220     return dbar1;
1221   else if (brr & (1<<9))
1222     return dbar2;
1223   else if (brr & (1<<8))
1224     return dbar3;
1225   else
1226     return 0;
1227 }
1228
1229 static CORE_ADDR
1230 frv_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1231 {
1232   return frame_unwind_register_unsigned (next_frame, pc_regnum);
1233 }
1234
1235 /* Given a GDB frame, determine the address of the calling function's
1236    frame.  This will be used to create a new GDB frame struct.  */
1237
1238 static void
1239 frv_frame_this_id (struct frame_info *next_frame,
1240                     void **this_prologue_cache, struct frame_id *this_id)
1241 {
1242   struct frv_unwind_cache *info
1243     = frv_frame_unwind_cache (next_frame, this_prologue_cache);
1244   CORE_ADDR base;
1245   CORE_ADDR func;
1246   struct minimal_symbol *msym_stack;
1247   struct frame_id id;
1248
1249   /* The FUNC is easy.  */
1250   func = frame_func_unwind (next_frame);
1251
1252   /* Check if the stack is empty.  */
1253   msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
1254   if (msym_stack && info->base == SYMBOL_VALUE_ADDRESS (msym_stack))
1255     return;
1256
1257   /* Hopefully the prologue analysis either correctly determined the
1258      frame's base (which is the SP from the previous frame), or set
1259      that base to "NULL".  */
1260   base = info->prev_sp;
1261   if (base == 0)
1262     return;
1263
1264   id = frame_id_build (base, func);
1265
1266   /* Check that we're not going round in circles with the same frame
1267      ID (but avoid applying the test to sentinel frames which do go
1268      round in circles).  Can't use frame_id_eq() as that doesn't yet
1269      compare the frame's PC value.  */
1270   if (frame_relative_level (next_frame) >= 0
1271       && get_frame_type (next_frame) != DUMMY_FRAME
1272       && frame_id_eq (get_frame_id (next_frame), id))
1273     return;
1274
1275   (*this_id) = id;
1276 }
1277
1278 static void
1279 frv_frame_prev_register (struct frame_info *next_frame,
1280                           void **this_prologue_cache,
1281                           int regnum, int *optimizedp,
1282                           enum lval_type *lvalp, CORE_ADDR *addrp,
1283                           int *realnump, void *bufferp)
1284 {
1285   struct frv_unwind_cache *info
1286     = frv_frame_unwind_cache (next_frame, this_prologue_cache);
1287   trad_frame_prev_register (next_frame, info->saved_regs, regnum,
1288                             optimizedp, lvalp, addrp, realnump, bufferp);
1289 }
1290
1291 static const struct frame_unwind frv_frame_unwind = {
1292   NORMAL_FRAME,
1293   frv_frame_this_id,
1294   frv_frame_prev_register
1295 };
1296
1297 static const struct frame_unwind *
1298 frv_frame_sniffer (struct frame_info *next_frame)
1299 {
1300   return &frv_frame_unwind;
1301 }
1302
1303 static CORE_ADDR
1304 frv_frame_base_address (struct frame_info *next_frame, void **this_cache)
1305 {
1306   struct frv_unwind_cache *info
1307     = frv_frame_unwind_cache (next_frame, this_cache);
1308   return info->base;
1309 }
1310
1311 static const struct frame_base frv_frame_base = {
1312   &frv_frame_unwind,
1313   frv_frame_base_address,
1314   frv_frame_base_address,
1315   frv_frame_base_address
1316 };
1317
1318 static CORE_ADDR
1319 frv_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1320 {
1321   return frame_unwind_register_unsigned (next_frame, sp_regnum);
1322 }
1323
1324
1325 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1326    dummy frame.  The frame ID's base needs to match the TOS value
1327    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1328    breakpoint.  */
1329
1330 static struct frame_id
1331 frv_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
1332 {
1333   return frame_id_build (frv_unwind_sp (gdbarch, next_frame),
1334                          frame_pc_unwind (next_frame));
1335 }
1336
1337
1338 static struct gdbarch *
1339 frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1340 {
1341   struct gdbarch *gdbarch;
1342   struct gdbarch_tdep *var;
1343   int elf_flags = 0;
1344
1345   /* Check to see if we've already built an appropriate architecture
1346      object for this executable.  */
1347   arches = gdbarch_list_lookup_by_info (arches, &info);
1348   if (arches)
1349     return arches->gdbarch;
1350
1351   /* Select the right tdep structure for this variant.  */
1352   var = new_variant ();
1353   switch (info.bfd_arch_info->mach)
1354     {
1355     case bfd_mach_frv:
1356     case bfd_mach_frvsimple:
1357     case bfd_mach_fr500:
1358     case bfd_mach_frvtomcat:
1359     case bfd_mach_fr550:
1360       set_variant_num_gprs (var, 64);
1361       set_variant_num_fprs (var, 64);
1362       break;
1363
1364     case bfd_mach_fr400:
1365       set_variant_num_gprs (var, 32);
1366       set_variant_num_fprs (var, 32);
1367       break;
1368
1369     default:
1370       /* Never heard of this variant.  */
1371       return 0;
1372     }
1373
1374   /* Extract the ELF flags, if available.  */
1375   if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
1376     elf_flags = elf_elfheader (info.abfd)->e_flags;
1377
1378   if (elf_flags & EF_FRV_FDPIC)
1379     set_variant_abi_fdpic (var);
1380
1381   gdbarch = gdbarch_alloc (&info, var);
1382
1383   set_gdbarch_short_bit (gdbarch, 16);
1384   set_gdbarch_int_bit (gdbarch, 32);
1385   set_gdbarch_long_bit (gdbarch, 32);
1386   set_gdbarch_long_long_bit (gdbarch, 64);
1387   set_gdbarch_float_bit (gdbarch, 32);
1388   set_gdbarch_double_bit (gdbarch, 64);
1389   set_gdbarch_long_double_bit (gdbarch, 64);
1390   set_gdbarch_ptr_bit (gdbarch, 32);
1391
1392   set_gdbarch_num_regs (gdbarch, frv_num_regs);
1393   set_gdbarch_num_pseudo_regs (gdbarch, frv_num_pseudo_regs);
1394
1395   set_gdbarch_sp_regnum (gdbarch, sp_regnum);
1396   set_gdbarch_deprecated_fp_regnum (gdbarch, fp_regnum);
1397   set_gdbarch_pc_regnum (gdbarch, pc_regnum);
1398
1399   set_gdbarch_register_name (gdbarch, frv_register_name);
1400   set_gdbarch_register_type (gdbarch, frv_register_type);
1401   set_gdbarch_register_sim_regno (gdbarch, frv_register_sim_regno);
1402
1403   set_gdbarch_pseudo_register_read (gdbarch, frv_pseudo_register_read);
1404   set_gdbarch_pseudo_register_write (gdbarch, frv_pseudo_register_write);
1405
1406   set_gdbarch_skip_prologue (gdbarch, frv_skip_prologue);
1407   set_gdbarch_breakpoint_from_pc (gdbarch, frv_breakpoint_from_pc);
1408   set_gdbarch_adjust_breakpoint_address (gdbarch, frv_gdbarch_adjust_breakpoint_address);
1409
1410   set_gdbarch_deprecated_frameless_function_invocation (gdbarch, frv_frameless_function_invocation);
1411
1412   set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention);
1413   set_gdbarch_extract_return_value (gdbarch, frv_extract_return_value);
1414
1415   set_gdbarch_deprecated_store_struct_return (gdbarch, frv_store_struct_return);
1416   set_gdbarch_store_return_value (gdbarch, frv_store_return_value);
1417   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, frv_extract_struct_value_address);
1418
1419   /* Frame stuff.  */
1420   set_gdbarch_unwind_pc (gdbarch, frv_unwind_pc);
1421   set_gdbarch_unwind_sp (gdbarch, frv_unwind_sp);
1422   set_gdbarch_frame_align (gdbarch, frv_frame_align);
1423   frame_unwind_append_sniffer (gdbarch, frv_frame_sniffer);
1424   frame_base_set_default (gdbarch, &frv_frame_base);
1425
1426   /* Settings for calling functions in the inferior.  */
1427   set_gdbarch_push_dummy_call (gdbarch, frv_push_dummy_call);
1428   set_gdbarch_unwind_dummy_id (gdbarch, frv_unwind_dummy_id);
1429
1430   /* Settings that should be unnecessary.  */
1431   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1432
1433   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
1434
1435   set_gdbarch_remote_translate_xfer_address
1436     (gdbarch, generic_remote_translate_xfer_address);
1437
1438   /* Hardware watchpoint / breakpoint support.  */
1439   switch (info.bfd_arch_info->mach)
1440     {
1441     case bfd_mach_frv:
1442     case bfd_mach_frvsimple:
1443     case bfd_mach_fr500:
1444     case bfd_mach_frvtomcat:
1445       /* fr500-style hardware debugging support.  */
1446       var->num_hw_watchpoints = 4;
1447       var->num_hw_breakpoints = 4;
1448       break;
1449
1450     case bfd_mach_fr400:
1451       /* fr400-style hardware debugging support.  */
1452       var->num_hw_watchpoints = 2;
1453       var->num_hw_breakpoints = 4;
1454       break;
1455
1456     default:
1457       /* Otherwise, assume we don't have hardware debugging support.  */
1458       var->num_hw_watchpoints = 0;
1459       var->num_hw_breakpoints = 0;
1460       break;
1461     }
1462
1463   set_gdbarch_print_insn (gdbarch, print_insn_frv);
1464   if (frv_abi (gdbarch) == FRV_ABI_FDPIC)
1465     set_gdbarch_convert_from_func_ptr_addr (gdbarch,
1466                                             frv_convert_from_func_ptr_addr);
1467
1468   return gdbarch;
1469 }
1470
1471 void
1472 _initialize_frv_tdep (void)
1473 {
1474   register_gdbarch_init (bfd_arch_frv, frv_gdbarch_init);
1475 }