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