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