Split size in regset section iterators
[external/binutils.git] / gdb / frv-linux-tdep.c
1 /* Target-dependent code for GNU/Linux running on the Fujitsu FR-V,
2    for GDB.
3
4    Copyright (C) 2004-2018 Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21 #include "defs.h"
22 #include "gdbcore.h"
23 #include "target.h"
24 #include "frame.h"
25 #include "osabi.h"
26 #include "regcache.h"
27 #include "elf-bfd.h"
28 #include "elf/frv.h"
29 #include "frv-tdep.h"
30 #include "trad-frame.h"
31 #include "frame-unwind.h"
32 #include "regset.h"
33 #include "linux-tdep.h"
34
35 /* Define the size (in bytes) of an FR-V instruction.  */
36 static const int frv_instr_size = 4;
37
38 enum {
39   NORMAL_SIGTRAMP = 1,
40   RT_SIGTRAMP = 2
41 };
42
43 static int
44 frv_linux_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc,
45                           const char *name)
46 {
47   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
48   gdb_byte buf[frv_instr_size];
49   LONGEST instr;
50   int retval = 0;
51
52   if (target_read_memory (pc, buf, sizeof buf) != 0)
53     return 0;
54
55   instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
56
57   if (instr == 0x8efc0077)      /* setlos #__NR_sigreturn, gr7 */
58     retval = NORMAL_SIGTRAMP;
59   else if (instr == 0x8efc00ad) /* setlos #__NR_rt_sigreturn, gr7 */
60     retval = RT_SIGTRAMP;
61   else
62     return 0;
63
64   if (target_read_memory (pc + frv_instr_size, buf, sizeof buf) != 0)
65     return 0;
66   instr = extract_unsigned_integer (buf, sizeof buf, byte_order);
67   if (instr != 0xc0700000)      /* tira gr0, 0 */
68     return 0;
69
70   /* If we get this far, we'll return a non-zero value, either
71      NORMAL_SIGTRAMP (1) or RT_SIGTRAMP (2).  */
72   return retval;
73 }
74
75 /* Given NEXT_FRAME, the "callee" frame of the sigtramp frame that we
76    wish to decode, and REGNO, one of the frv register numbers defined
77    in frv-tdep.h, return the address of the saved register (corresponding
78    to REGNO) in the sigtramp frame.  Return -1 if the register is not
79    found in the sigtramp frame.  The magic numbers in the code below
80    were computed by examining the following kernel structs:
81
82    From arch/frv/kernel/signal.c:
83
84       struct sigframe
85       {
86               void (*pretcode)(void);
87               int sig;
88               struct sigcontext sc;
89               unsigned long extramask[_NSIG_WORDS-1];
90               uint32_t retcode[2];
91       };
92
93       struct rt_sigframe
94       {
95               void (*pretcode)(void);
96               int sig;
97               struct siginfo *pinfo;
98               void *puc;
99               struct siginfo info;
100               struct ucontext uc;
101               uint32_t retcode[2];
102       };
103
104    From include/asm-frv/ucontext.h:
105
106       struct ucontext {
107               unsigned long             uc_flags;
108               struct ucontext           *uc_link;
109               stack_t                   uc_stack;
110               struct sigcontext uc_mcontext;
111               sigset_t          uc_sigmask;
112       };
113
114    From include/asm-frv/signal.h:
115
116       typedef struct sigaltstack {
117               void *ss_sp;
118               int ss_flags;
119               size_t ss_size;
120       } stack_t;
121
122    From include/asm-frv/sigcontext.h:
123
124       struct sigcontext {
125               struct user_context       sc_context;
126               unsigned long             sc_oldmask;
127       } __attribute__((aligned(8)));
128
129    From include/asm-frv/registers.h:
130       struct user_int_regs
131       {
132               unsigned long             psr;
133               unsigned long             isr;
134               unsigned long             ccr;
135               unsigned long             cccr;
136               unsigned long             lr;
137               unsigned long             lcr;
138               unsigned long             pc;
139               unsigned long             __status;
140               unsigned long             syscallno;
141               unsigned long             orig_gr8;
142               unsigned long             gner[2];
143               unsigned long long        iacc[1];
144
145               union {
146                       unsigned long     tbr;
147                       unsigned long     gr[64];
148               };
149       };
150
151       struct user_fpmedia_regs
152       {
153               unsigned long     fr[64];
154               unsigned long     fner[2];
155               unsigned long     msr[2];
156               unsigned long     acc[8];
157               unsigned char     accg[8];
158               unsigned long     fsr[1];
159       };
160
161       struct user_context
162       {
163               struct user_int_regs              i;
164               struct user_fpmedia_regs  f;
165
166               void *extension;
167       } __attribute__((aligned(8)));  */
168
169 static LONGEST
170 frv_linux_sigcontext_reg_addr (struct frame_info *this_frame, int regno,
171                                CORE_ADDR *sc_addr_cache_ptr)
172 {
173   struct gdbarch *gdbarch = get_frame_arch (this_frame);
174   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
175   CORE_ADDR sc_addr;
176
177   if (sc_addr_cache_ptr && *sc_addr_cache_ptr)
178     {
179       sc_addr = *sc_addr_cache_ptr;
180     }
181   else
182     {
183       CORE_ADDR pc, sp;
184       gdb_byte buf[4];
185       int tramp_type;
186
187       pc = get_frame_pc (this_frame);
188       tramp_type = frv_linux_pc_in_sigtramp (gdbarch, pc, 0);
189
190       get_frame_register (this_frame, sp_regnum, buf);
191       sp = extract_unsigned_integer (buf, sizeof buf, byte_order);
192
193       if (tramp_type == NORMAL_SIGTRAMP)
194         {
195           /* For a normal sigtramp frame, the sigcontext struct starts
196              at SP + 8.  */
197           sc_addr = sp + 8;
198         }
199       else if (tramp_type == RT_SIGTRAMP)
200         {
201           /* For a realtime sigtramp frame, SP + 12 contains a pointer
202              to a ucontext struct.  The ucontext struct contains a
203              sigcontext struct starting 24 bytes in.  (The offset of
204              uc_mcontext within struct ucontext is derived as follows: 
205              stack_t is a 12-byte struct and struct sigcontext is
206              8-byte aligned.  This gives an offset of 8 + 12 + 4 (for
207              padding) = 24.)  */
208           if (target_read_memory (sp + 12, buf, sizeof buf) != 0)
209             {
210               warning (_("Can't read realtime sigtramp frame."));
211               return 0;
212             }
213           sc_addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
214           sc_addr += 24;
215         }
216       else
217         internal_error (__FILE__, __LINE__, _("not a signal trampoline"));
218
219       if (sc_addr_cache_ptr)
220         *sc_addr_cache_ptr = sc_addr;
221     }
222
223   switch (regno)
224     {
225     case psr_regnum :
226       return sc_addr + 0;
227     /* sc_addr + 4 has "isr", the Integer Status Register.  */
228     case ccr_regnum :
229       return sc_addr + 8;
230     case cccr_regnum :
231       return sc_addr + 12;
232     case lr_regnum :
233       return sc_addr + 16;
234     case lcr_regnum :
235       return sc_addr + 20;
236     case pc_regnum :
237       return sc_addr + 24;
238     /* sc_addr + 28 is __status, the exception status.
239        sc_addr + 32 is syscallno, the syscall number or -1.
240        sc_addr + 36 is orig_gr8, the original syscall arg #1.
241        sc_addr + 40 is gner[0].
242        sc_addr + 44 is gner[1].  */
243     case iacc0h_regnum :
244       return sc_addr + 48;
245     case iacc0l_regnum :
246       return sc_addr + 52;
247     default : 
248       if (first_gpr_regnum <= regno && regno <= last_gpr_regnum)
249         return sc_addr + 56 + 4 * (regno - first_gpr_regnum);
250       else if (first_fpr_regnum <= regno && regno <= last_fpr_regnum)
251         return sc_addr + 312 + 4 * (regno - first_fpr_regnum);
252       else
253         return -1;  /* not saved.  */
254     }
255 }
256
257 /* Signal trampolines.  */
258
259 static struct trad_frame_cache *
260 frv_linux_sigtramp_frame_cache (struct frame_info *this_frame,
261                                 void **this_cache)
262 {
263   struct gdbarch *gdbarch = get_frame_arch (this_frame);
264   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
265   struct trad_frame_cache *cache;
266   CORE_ADDR addr;
267   gdb_byte buf[4];
268   int regnum;
269   CORE_ADDR sc_addr_cache_val = 0;
270   struct frame_id this_id;
271
272   if (*this_cache)
273     return (struct trad_frame_cache *) *this_cache;
274
275   cache = trad_frame_cache_zalloc (this_frame);
276
277   /* FIXME: cagney/2004-05-01: This is is long standing broken code.
278      The frame ID's code address should be the start-address of the
279      signal trampoline and not the current PC within that
280      trampoline.  */
281   get_frame_register (this_frame, sp_regnum, buf);
282   addr = extract_unsigned_integer (buf, sizeof buf, byte_order);
283   this_id = frame_id_build (addr, get_frame_pc (this_frame));
284   trad_frame_set_id (cache, this_id);
285
286   for (regnum = 0; regnum < frv_num_regs; regnum++)
287     {
288       LONGEST reg_addr = frv_linux_sigcontext_reg_addr (this_frame, regnum,
289                                                         &sc_addr_cache_val);
290       if (reg_addr != -1)
291         trad_frame_set_reg_addr (cache, regnum, reg_addr);
292     }
293
294   *this_cache = cache;
295   return cache;
296 }
297
298 static void
299 frv_linux_sigtramp_frame_this_id (struct frame_info *this_frame,
300                                   void **this_cache,
301                                   struct frame_id *this_id)
302 {
303   struct trad_frame_cache *cache
304     = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
305   trad_frame_get_id (cache, this_id);
306 }
307
308 static struct value *
309 frv_linux_sigtramp_frame_prev_register (struct frame_info *this_frame,
310                                         void **this_cache, int regnum)
311 {
312   /* Make sure we've initialized the cache.  */
313   struct trad_frame_cache *cache
314     = frv_linux_sigtramp_frame_cache (this_frame, this_cache);
315   return trad_frame_get_register (cache, this_frame, regnum);
316 }
317
318 static int
319 frv_linux_sigtramp_frame_sniffer (const struct frame_unwind *self,
320                                   struct frame_info *this_frame,
321                                   void **this_cache)
322 {
323   struct gdbarch *gdbarch = get_frame_arch (this_frame);
324   CORE_ADDR pc = get_frame_pc (this_frame);
325   const char *name;
326
327   find_pc_partial_function (pc, &name, NULL, NULL);
328   if (frv_linux_pc_in_sigtramp (gdbarch, pc, name))
329     return 1;
330
331   return 0;
332 }
333
334 static const struct frame_unwind frv_linux_sigtramp_frame_unwind =
335 {
336   SIGTRAMP_FRAME,
337   default_frame_unwind_stop_reason,
338   frv_linux_sigtramp_frame_this_id,
339   frv_linux_sigtramp_frame_prev_register,
340   NULL,
341   frv_linux_sigtramp_frame_sniffer
342 };
343 \f
344 /* The FRV kernel defines ELF_NGREG as 46.  We add 2 in order to include
345    the loadmap addresses in the register set.  (See below for more info.)  */
346 #define FRV_ELF_NGREG (46 + 2)
347 typedef unsigned char frv_elf_greg_t[4];
348 typedef struct { frv_elf_greg_t reg[FRV_ELF_NGREG]; } frv_elf_gregset_t;
349
350 typedef unsigned char frv_elf_fpreg_t[4];
351 typedef struct
352 {
353   frv_elf_fpreg_t fr[64];
354   frv_elf_fpreg_t fner[2];
355   frv_elf_fpreg_t msr[2];
356   frv_elf_fpreg_t acc[8];
357   unsigned char accg[8];
358   frv_elf_fpreg_t fsr[1];
359 } frv_elf_fpregset_t;
360
361 /* Register maps.  */
362
363 static const struct regcache_map_entry frv_linux_gregmap[] =
364   {
365     { 1, psr_regnum, 4 },
366     { 1, REGCACHE_MAP_SKIP, 4 }, /* isr */
367     { 1, ccr_regnum, 4 },
368     { 1, cccr_regnum, 4 },
369     { 1, lr_regnum, 4 },
370     { 1, lcr_regnum, 4 },
371     { 1, pc_regnum, 4 },
372     { 1, REGCACHE_MAP_SKIP, 4 }, /* __status */
373     { 1, REGCACHE_MAP_SKIP, 4 }, /* syscallno */
374     { 1, REGCACHE_MAP_SKIP, 4 }, /* orig_gr8 */
375     { 1, gner0_regnum, 4 },
376     { 1, gner1_regnum, 4 },
377     { 1, REGCACHE_MAP_SKIP, 8 }, /* iacc0 */
378     { 1, tbr_regnum, 4 },
379     { 31, first_gpr_regnum + 1, 4 }, /* gr1 ... gr31 */
380
381     /* Technically, the loadmap addresses are not part of `pr_reg' as
382        found in the elf_prstatus struct.  The fields which communicate
383        the loadmap address appear (by design) immediately after
384        `pr_reg' though, and the BFD function elf32_frv_grok_prstatus()
385        has been implemented to include these fields in the register
386        section that it extracts from the core file.  So, for our
387        purposes, they may be viewed as registers.  */
388
389     { 1, fdpic_loadmap_exec_regnum, 4 },
390     { 1, fdpic_loadmap_interp_regnum, 4 },
391     { 0 }
392   };
393
394 static const struct regcache_map_entry frv_linux_fpregmap[] =
395   {
396     { 64, first_fpr_regnum, 4 }, /* fr0 ... fr63 */
397     { 1, fner0_regnum, 4 },
398     { 1, fner1_regnum, 4 },
399     { 1, msr0_regnum, 4 },
400     { 1, msr1_regnum, 4 },
401     { 8, acc0_regnum, 4 },      /* acc0 ... acc7 */
402     { 1, accg0123_regnum, 4 },
403     { 1, accg4567_regnum, 4 },
404     { 1, fsr0_regnum, 4 },
405     { 0 }
406   };
407
408 /* Unpack an frv_elf_gregset_t into GDB's register cache.  */
409
410 static void 
411 frv_linux_supply_gregset (const struct regset *regset,
412                           struct regcache *regcache,
413                           int regnum, const void *gregs, size_t len)
414 {
415   int regi;
416
417   /* gr0 always contains 0.  Also, the kernel passes the TBR value in
418      this slot.  */
419   regcache->raw_supply_zeroed (first_gpr_regnum);
420
421   /* Fill gr32, ..., gr63 with zeros. */
422   for (regi = first_gpr_regnum + 32; regi <= last_gpr_regnum; regi++)
423     regcache->raw_supply_zeroed (regi);
424
425   regcache_supply_regset (regset, regcache, regnum, gregs, len);
426 }
427
428 /* FRV Linux kernel register sets.  */
429
430 static const struct regset frv_linux_gregset =
431 {
432   frv_linux_gregmap,
433   frv_linux_supply_gregset, regcache_collect_regset
434 };
435
436 static const struct regset frv_linux_fpregset =
437 {
438   frv_linux_fpregmap,
439   regcache_supply_regset, regcache_collect_regset
440 };
441
442 static void
443 frv_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
444                                         iterate_over_regset_sections_cb *cb,
445                                         void *cb_data,
446                                         const struct regcache *regcache)
447 {
448   cb (".reg", sizeof (frv_elf_gregset_t), sizeof (frv_elf_gregset_t),
449       &frv_linux_gregset, NULL, cb_data);
450   cb (".reg2", sizeof (frv_elf_fpregset_t), sizeof (frv_elf_fpregset_t),
451       &frv_linux_fpregset, NULL, cb_data);
452 }
453
454 \f
455 static void
456 frv_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
457 {
458   linux_init_abi (info, gdbarch);
459
460   /* Set the sigtramp frame sniffer.  */
461   frame_unwind_append_unwinder (gdbarch, &frv_linux_sigtramp_frame_unwind); 
462
463   set_gdbarch_iterate_over_regset_sections
464     (gdbarch, frv_linux_iterate_over_regset_sections);
465 }
466
467 static enum gdb_osabi
468 frv_linux_elf_osabi_sniffer (bfd *abfd)
469 {
470   int elf_flags;
471
472   elf_flags = elf_elfheader (abfd)->e_flags;
473
474   /* Assume GNU/Linux if using the FDPIC ABI.  If/when another OS shows
475      up that uses this ABI, we'll need to start using .note sections
476      or some such.  */
477   if (elf_flags & EF_FRV_FDPIC)
478     return GDB_OSABI_LINUX;
479   else
480     return GDB_OSABI_UNKNOWN;
481 }
482
483 void
484 _initialize_frv_linux_tdep (void)
485 {
486   gdbarch_register_osabi (bfd_arch_frv, 0, GDB_OSABI_LINUX,
487                           frv_linux_init_abi);
488   gdbarch_register_osabi_sniffer (bfd_arch_frv,
489                                   bfd_target_elf_flavour,
490                                   frv_linux_elf_osabi_sniffer);
491 }