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