tizen 2.4 release
[external/binutils.git] / gdb / sparc-linux-tdep.c
1 /* Target-dependent code for GNU/Linux SPARC.
2
3    Copyright (C) 2003-2014 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 "dwarf2-frame.h"
22 #include "frame.h"
23 #include "frame-unwind.h"
24 #include "gdbtypes.h"
25 #include "regset.h"
26 #include "gdbarch.h"
27 #include "gdbcore.h"
28 #include "osabi.h"
29 #include "regcache.h"
30 #include "solib-svr4.h"
31 #include "symtab.h"
32 #include "trad-frame.h"
33 #include "tramp-frame.h"
34 #include "xml-syscall.h"
35 #include "linux-tdep.h"
36
37 /* The syscall's XML filename for sparc 32-bit.  */
38 #define XML_SYSCALL_FILENAME_SPARC32 "syscalls/sparc-linux.xml"
39
40 #include "sparc-tdep.h"
41
42 /* Signal trampoline support.  */
43
44 static void sparc32_linux_sigframe_init (const struct tramp_frame *self,
45                                          struct frame_info *this_frame,
46                                          struct trad_frame_cache *this_cache,
47                                          CORE_ADDR func);
48
49 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
50    "realtime" (RT) signals.  The RT signals can provide additional
51    information to the signal handler if the SA_SIGINFO flag is set
52    when establishing a signal handler using `sigaction'.  It is not
53    unlikely that future versions of GNU/Linux will support SA_SIGINFO
54    for normal signals too.  */
55
56 /* When the sparc Linux kernel calls a signal handler and the
57    SA_RESTORER flag isn't set, the return address points to a bit of
58    code on the stack.  This code checks whether the PC appears to be
59    within this bit of code.
60
61    The instruction sequence for normal signals is encoded below.
62    Checking for the code sequence should be somewhat reliable, because
63    the effect is to call the system call sigreturn.  This is unlikely
64    to occur anywhere other than a signal trampoline.  */
65
66 static const struct tramp_frame sparc32_linux_sigframe =
67 {
68   SIGTRAMP_FRAME,
69   4,
70   {
71     { 0x821020d8, -1 },         /* mov __NR_sugreturn, %g1 */
72     { 0x91d02010, -1 },         /* ta  0x10 */
73     { TRAMP_SENTINEL_INSN, -1 }
74   },
75   sparc32_linux_sigframe_init
76 };
77
78 /* The instruction sequence for RT signals is slightly different.  The
79    effect is to call the system call rt_sigreturn.  */
80
81 static const struct tramp_frame sparc32_linux_rt_sigframe =
82 {
83   SIGTRAMP_FRAME,
84   4,
85   {
86     { 0x82102065, -1 },         /* mov __NR_rt_sigreturn, %g1 */
87     { 0x91d02010, -1 },         /* ta  0x10 */
88     { TRAMP_SENTINEL_INSN, -1 }
89   },
90   sparc32_linux_sigframe_init
91 };
92
93 /* This enum represents the signals' numbers on the SPARC
94    architecture.  It just contains the signal definitions which are
95    different from the generic implementation.
96
97    It is derived from the file <arch/sparc/include/uapi/asm/signal.h>,
98    from the Linux kernel tree.  */
99
100 enum
101   {
102     SPARC_LINUX_SIGEMT = 7,
103     SPARC_LINUX_SIGBUS = 10,
104     SPARC_LINUX_SIGSYS = 12,
105     SPARC_LINUX_SIGURG = 16,
106     SPARC_LINUX_SIGSTOP = 17,
107     SPARC_LINUX_SIGTSTP = 18,
108     SPARC_LINUX_SIGCONT = 19,
109     SPARC_LINUX_SIGCHLD = 20,
110     SPARC_LINUX_SIGIO = 23,
111     SPARC_LINUX_SIGPOLL = SPARC_LINUX_SIGIO,
112     SPARC_LINUX_SIGLOST = 29,
113     SPARC_LINUX_SIGPWR = SPARC_LINUX_SIGLOST,
114     SPARC_LINUX_SIGUSR1 = 30,
115     SPARC_LINUX_SIGUSR2 = 31,
116   };
117
118 static void
119 sparc32_linux_sigframe_init (const struct tramp_frame *self,
120                              struct frame_info *this_frame,
121                              struct trad_frame_cache *this_cache,
122                              CORE_ADDR func)
123 {
124   CORE_ADDR base, addr, sp_addr;
125   int regnum;
126
127   base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM);
128   if (self == &sparc32_linux_rt_sigframe)
129     base += 128;
130
131   /* Offsets from <bits/sigcontext.h>.  */
132
133   trad_frame_set_reg_addr (this_cache, SPARC32_PSR_REGNUM, base + 0);
134   trad_frame_set_reg_addr (this_cache, SPARC32_PC_REGNUM, base + 4);
135   trad_frame_set_reg_addr (this_cache, SPARC32_NPC_REGNUM, base + 8);
136   trad_frame_set_reg_addr (this_cache, SPARC32_Y_REGNUM, base + 12);
137
138   /* Since %g0 is always zero, keep the identity encoding.  */
139   addr = base + 20;
140   sp_addr = base + 16 + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 4);
141   for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
142     {
143       trad_frame_set_reg_addr (this_cache, regnum, addr);
144       addr += 4;
145     }
146
147   base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
148   addr = get_frame_memory_unsigned (this_frame, sp_addr, 4);
149
150   for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
151     {
152       trad_frame_set_reg_addr (this_cache, regnum, addr);
153       addr += 4;
154     }
155   trad_frame_set_id (this_cache, frame_id_build (base, func));
156 }
157 \f
158 /* Return the address of a system call's alternative return
159    address.  */
160
161 static CORE_ADDR
162 sparc32_linux_step_trap (struct frame_info *frame, unsigned long insn)
163 {
164   if (insn == 0x91d02010)
165     {
166       ULONGEST sc_num = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
167
168       /* __NR_rt_sigreturn is 101 and __NR_sigreturn is 216.  */
169       if (sc_num == 101 || sc_num == 216)
170         {
171           struct gdbarch *gdbarch = get_frame_arch (frame);
172           enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
173
174           ULONGEST sp, pc_offset;
175
176           sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
177
178           /* The kernel puts the sigreturn registers on the stack,
179              and this is where the signal unwinding state is take from
180              when returning from a signal.
181
182              For __NR_sigreturn, this register area sits 96 bytes from
183              the base of the stack.  The saved PC sits 4 bytes into the
184              sigreturn register save area.
185
186              For __NR_rt_sigreturn a siginfo_t, which is 128 bytes, sits
187              right before the sigreturn register save area.  */
188
189           pc_offset = 96 + 4;
190           if (sc_num == 101)
191             pc_offset += 128;
192
193           return read_memory_unsigned_integer (sp + pc_offset, 4, byte_order);
194         }
195     }
196
197   return 0;
198 }
199 \f
200
201 const struct sparc_gregmap sparc32_linux_core_gregmap =
202 {
203   32 * 4,                       /* %psr */
204   33 * 4,                       /* %pc */
205   34 * 4,                       /* %npc */
206   35 * 4,                       /* %y */
207   -1,                           /* %wim */
208   -1,                           /* %tbr */
209   1 * 4,                        /* %g1 */
210   16 * 4,                       /* %l0 */
211   4,                            /* y size */
212 };
213 \f
214
215 static void
216 sparc32_linux_supply_core_gregset (const struct regset *regset,
217                                    struct regcache *regcache,
218                                    int regnum, const void *gregs, size_t len)
219 {
220   sparc32_supply_gregset (&sparc32_linux_core_gregmap,
221                           regcache, regnum, gregs);
222 }
223
224 static void
225 sparc32_linux_collect_core_gregset (const struct regset *regset,
226                                     const struct regcache *regcache,
227                                     int regnum, void *gregs, size_t len)
228 {
229   sparc32_collect_gregset (&sparc32_linux_core_gregmap,
230                            regcache, regnum, gregs);
231 }
232
233 static void
234 sparc32_linux_supply_core_fpregset (const struct regset *regset,
235                                     struct regcache *regcache,
236                                     int regnum, const void *fpregs, size_t len)
237 {
238   sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
239 }
240
241 static void
242 sparc32_linux_collect_core_fpregset (const struct regset *regset,
243                                      const struct regcache *regcache,
244                                      int regnum, void *fpregs, size_t len)
245 {
246   sparc32_collect_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
247 }
248
249 /* Set the program counter for process PTID to PC.  */
250
251 #define PSR_SYSCALL     0x00004000
252
253 static void
254 sparc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
255 {
256   struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
257   ULONGEST psr;
258
259   regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
260   regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
261
262   /* Clear the "in syscall" bit to prevent the kernel from
263      messing with the PCs we just installed, if we happen to be
264      within an interrupted system call that the kernel wants to
265      restart.
266
267      Note that after we return from the dummy call, the PSR et al.
268      registers will be automatically restored, and the kernel
269      continues to restart the system call at this point.  */
270   regcache_cooked_read_unsigned (regcache, SPARC32_PSR_REGNUM, &psr);
271   psr &= ~PSR_SYSCALL;
272   regcache_cooked_write_unsigned (regcache, SPARC32_PSR_REGNUM, psr);
273 }
274
275 static LONGEST
276 sparc32_linux_get_syscall_number (struct gdbarch *gdbarch,
277                                   ptid_t ptid)
278 {
279   struct regcache *regcache = get_thread_regcache (ptid);
280   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
281   /* The content of a register.  */
282   gdb_byte buf[4];
283   /* The result.  */
284   LONGEST ret;
285
286   /* Getting the system call number from the register.
287      When dealing with the sparc architecture, this information
288      is stored at the %g1 register.  */
289   regcache_cooked_read (regcache, SPARC_G1_REGNUM, buf);
290
291   ret = extract_signed_integer (buf, 4, byte_order);
292
293   return ret;
294 }
295
296 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
297    gdbarch.h.  */
298
299 static enum gdb_signal
300 sparc32_linux_gdb_signal_from_target (struct gdbarch *gdbarch,
301                                       int signal)
302 {
303   switch (signal)
304     {
305     case SPARC_LINUX_SIGEMT:
306       return GDB_SIGNAL_EMT;
307
308     case SPARC_LINUX_SIGBUS:
309       return GDB_SIGNAL_BUS;
310
311     case SPARC_LINUX_SIGSYS:
312       return GDB_SIGNAL_SYS;
313
314     case SPARC_LINUX_SIGURG:
315       return GDB_SIGNAL_URG;
316
317     case SPARC_LINUX_SIGSTOP:
318       return GDB_SIGNAL_STOP;
319
320     case SPARC_LINUX_SIGTSTP:
321       return GDB_SIGNAL_TSTP;
322
323     case SPARC_LINUX_SIGCONT:
324       return GDB_SIGNAL_CONT;
325
326     case SPARC_LINUX_SIGCHLD:
327       return GDB_SIGNAL_CHLD;
328
329     /* No way to differentiate between SIGIO and SIGPOLL.
330        Therefore, we just handle the first one.  */
331     case SPARC_LINUX_SIGIO:
332       return GDB_SIGNAL_IO;
333
334     /* No way to differentiate between SIGLOST and SIGPWR.
335        Therefore, we just handle the first one.  */
336     case SPARC_LINUX_SIGLOST:
337       return GDB_SIGNAL_LOST;
338
339     case SPARC_LINUX_SIGUSR1:
340       return GDB_SIGNAL_USR1;
341
342     case SPARC_LINUX_SIGUSR2:
343       return GDB_SIGNAL_USR2;
344     }
345
346   return linux_gdb_signal_from_target (gdbarch, signal);
347 }
348
349 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
350    gdbarch.h.  */
351
352 static int
353 sparc32_linux_gdb_signal_to_target (struct gdbarch *gdbarch,
354                                     enum gdb_signal signal)
355 {
356   switch (signal)
357     {
358     case GDB_SIGNAL_EMT:
359       return SPARC_LINUX_SIGEMT;
360
361     case GDB_SIGNAL_BUS:
362       return SPARC_LINUX_SIGBUS;
363
364     case GDB_SIGNAL_SYS:
365       return SPARC_LINUX_SIGSYS;
366
367     case GDB_SIGNAL_URG:
368       return SPARC_LINUX_SIGURG;
369
370     case GDB_SIGNAL_STOP:
371       return SPARC_LINUX_SIGSTOP;
372
373     case GDB_SIGNAL_TSTP:
374       return SPARC_LINUX_SIGTSTP;
375
376     case GDB_SIGNAL_CONT:
377       return SPARC_LINUX_SIGCONT;
378
379     case GDB_SIGNAL_CHLD:
380       return SPARC_LINUX_SIGCHLD;
381
382     case GDB_SIGNAL_IO:
383       return SPARC_LINUX_SIGIO;
384
385     case GDB_SIGNAL_POLL:
386       return SPARC_LINUX_SIGPOLL;
387
388     case GDB_SIGNAL_LOST:
389       return SPARC_LINUX_SIGLOST;
390
391     case GDB_SIGNAL_PWR:
392       return SPARC_LINUX_SIGPWR;
393
394     case GDB_SIGNAL_USR1:
395       return SPARC_LINUX_SIGUSR1;
396
397     case GDB_SIGNAL_USR2:
398       return SPARC_LINUX_SIGUSR2;
399     }
400
401   return linux_gdb_signal_to_target (gdbarch, signal);
402 }
403
404 \f
405
406 static const struct regset sparc32_linux_gregset =
407   {
408     NULL,
409     sparc32_linux_supply_core_gregset,
410     sparc32_linux_collect_core_gregset
411   };
412
413 static const struct regset sparc32_linux_fpregset =
414   {
415     NULL,
416     sparc32_linux_supply_core_fpregset,
417     sparc32_linux_collect_core_fpregset
418   };
419
420 static void
421 sparc32_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
422 {
423   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
424
425   linux_init_abi (info, gdbarch);
426
427   tdep->gregset = &sparc32_linux_gregset;
428   tdep->sizeof_gregset = 152;
429
430   tdep->fpregset = &sparc32_linux_fpregset;
431   tdep->sizeof_fpregset = 396;
432
433   tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_sigframe);
434   tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_rt_sigframe);
435
436   /* GNU/Linux has SVR4-style shared libraries...  */
437   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
438   set_solib_svr4_fetch_link_map_offsets
439     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
440
441   /* ...which means that we need some special handling when doing
442      prologue analysis.  */
443   tdep->plt_entry_size = 12;
444
445   /* Enable TLS support.  */
446   set_gdbarch_fetch_tls_load_module_address (gdbarch,
447                                              svr4_fetch_objfile_link_map);
448
449   /* Make sure we can single-step over signal return system calls.  */
450   tdep->step_trap = sparc32_linux_step_trap;
451
452   /* Hook in the DWARF CFI frame unwinder.  */
453   dwarf2_append_unwinders (gdbarch);
454
455   set_gdbarch_write_pc (gdbarch, sparc_linux_write_pc);
456
457   /* Functions for 'catch syscall'.  */
458   set_xml_syscall_file_name (XML_SYSCALL_FILENAME_SPARC32);
459   set_gdbarch_get_syscall_number (gdbarch,
460                                   sparc32_linux_get_syscall_number);
461
462   set_gdbarch_gdb_signal_from_target (gdbarch,
463                                       sparc32_linux_gdb_signal_from_target);
464   set_gdbarch_gdb_signal_to_target (gdbarch,
465                                     sparc32_linux_gdb_signal_to_target);
466 }
467
468 /* Provide a prototype to silence -Wmissing-prototypes.  */
469 extern void _initialize_sparc_linux_tdep (void);
470
471 void
472 _initialize_sparc_linux_tdep (void)
473 {
474   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
475                           sparc32_linux_init_abi);
476 }