* i386-tdep.c (i386_match_insn_block): Use length of the proper
[platform/upstream/binutils.git] / gdb / mips-linux-tdep.c
1 /* Target-dependent code for GNU/Linux on MIPS processors.
2
3    Copyright (C) 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4    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 "solib-svr4.h"
25 #include "osabi.h"
26 #include "mips-tdep.h"
27 #include "gdb_string.h"
28 #include "gdb_assert.h"
29 #include "frame.h"
30 #include "regcache.h"
31 #include "trad-frame.h"
32 #include "tramp-frame.h"
33 #include "gdbtypes.h"
34 #include "solib.h"
35 #include "solib-svr4.h"
36 #include "solist.h"
37 #include "symtab.h"
38 #include "target-descriptions.h"
39 #include "regset.h"
40 #include "mips-linux-tdep.h"
41 #include "glibc-tdep.h"
42 #include "linux-tdep.h"
43 #include "xml-syscall.h"
44
45 static struct target_so_ops mips_svr4_so_ops;
46
47 /* Figure out where the longjmp will land.
48    We expect the first arg to be a pointer to the jmp_buf structure
49    from which we extract the pc (MIPS_LINUX_JB_PC) that we will land
50    at.  The pc is copied into PC.  This routine returns 1 on
51    success.  */
52
53 #define MIPS_LINUX_JB_ELEMENT_SIZE 4
54 #define MIPS_LINUX_JB_PC 0
55
56 static int
57 mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
58 {
59   CORE_ADDR jb_addr;
60   struct gdbarch *gdbarch = get_frame_arch (frame);
61   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
62   char buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
63
64   jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
65
66   if (target_read_memory (jb_addr
67                             + MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
68                           buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
69     return 0;
70
71   *pc = extract_unsigned_integer (buf,
72                                   gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT,
73                                   byte_order);
74
75   return 1;
76 }
77
78 /* Transform the bits comprising a 32-bit register to the right size
79    for regcache_raw_supply().  This is needed when mips_isa_regsize()
80    is 8.  */
81
82 static void
83 supply_32bit_reg (struct regcache *regcache, int regnum, const void *addr)
84 {
85   struct gdbarch *gdbarch = get_regcache_arch (regcache);
86   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
87   gdb_byte buf[MAX_REGISTER_SIZE];
88   store_signed_integer (buf, register_size (gdbarch, regnum), byte_order,
89                         extract_signed_integer (addr, 4, byte_order));
90   regcache_raw_supply (regcache, regnum, buf);
91 }
92
93 /* Unpack an elf_gregset_t into GDB's register cache.  */
94
95 void
96 mips_supply_gregset (struct regcache *regcache,
97                      const mips_elf_gregset_t *gregsetp)
98 {
99   int regi;
100   const mips_elf_greg_t *regp = *gregsetp;
101   char zerobuf[MAX_REGISTER_SIZE];
102   struct gdbarch *gdbarch = get_regcache_arch (regcache);
103
104   memset (zerobuf, 0, MAX_REGISTER_SIZE);
105
106   for (regi = EF_REG0 + 1; regi <= EF_REG31; regi++)
107     supply_32bit_reg (regcache, regi - EF_REG0, regp + regi);
108
109   if (mips_linux_restart_reg_p (gdbarch))
110     supply_32bit_reg (regcache, MIPS_RESTART_REGNUM, regp + EF_REG0);
111
112   supply_32bit_reg (regcache, mips_regnum (gdbarch)->lo, regp + EF_LO);
113   supply_32bit_reg (regcache, mips_regnum (gdbarch)->hi, regp + EF_HI);
114
115   supply_32bit_reg (regcache, mips_regnum (gdbarch)->pc,
116                     regp + EF_CP0_EPC);
117   supply_32bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
118                     regp + EF_CP0_BADVADDR);
119   supply_32bit_reg (regcache, MIPS_PS_REGNUM, regp + EF_CP0_STATUS);
120   supply_32bit_reg (regcache, mips_regnum (gdbarch)->cause,
121                     regp + EF_CP0_CAUSE);
122
123   /* Fill inaccessible registers with zero.  */
124   regcache_raw_supply (regcache, MIPS_ZERO_REGNUM, zerobuf);
125   regcache_raw_supply (regcache, MIPS_UNUSED_REGNUM, zerobuf);
126   for (regi = MIPS_FIRST_EMBED_REGNUM;
127        regi <= MIPS_LAST_EMBED_REGNUM;
128        regi++)
129     regcache_raw_supply (regcache, regi, zerobuf);
130 }
131
132 static void
133 mips_supply_gregset_wrapper (const struct regset *regset,
134                              struct regcache *regcache,
135                              int regnum, const void *gregs, size_t len)
136 {
137   gdb_assert (len == sizeof (mips_elf_gregset_t));
138
139   mips_supply_gregset (regcache, (const mips_elf_gregset_t *)gregs);
140 }
141
142 /* Pack our registers (or one register) into an elf_gregset_t.  */
143
144 void
145 mips_fill_gregset (const struct regcache *regcache,
146                    mips_elf_gregset_t *gregsetp, int regno)
147 {
148   struct gdbarch *gdbarch = get_regcache_arch (regcache);
149   int regaddr, regi;
150   mips_elf_greg_t *regp = *gregsetp;
151   void *dst;
152
153   if (regno == -1)
154     {
155       memset (regp, 0, sizeof (mips_elf_gregset_t));
156       for (regi = 1; regi < 32; regi++)
157         mips_fill_gregset (regcache, gregsetp, regi);
158       mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
159       mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
160       mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
161       mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
162       mips_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
163       mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->cause);
164       mips_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
165       return;
166    }
167
168   if (regno > 0 && regno < 32)
169     {
170       dst = regp + regno + EF_REG0;
171       regcache_raw_collect (regcache, regno, dst);
172       return;
173     }
174
175   if (regno == mips_regnum (gdbarch)->lo)
176      regaddr = EF_LO;
177   else if (regno == mips_regnum (gdbarch)->hi)
178     regaddr = EF_HI;
179   else if (regno == mips_regnum (gdbarch)->pc)
180     regaddr = EF_CP0_EPC;
181   else if (regno == mips_regnum (gdbarch)->badvaddr)
182     regaddr = EF_CP0_BADVADDR;
183   else if (regno == MIPS_PS_REGNUM)
184     regaddr = EF_CP0_STATUS;
185   else if (regno == mips_regnum (gdbarch)->cause)
186     regaddr = EF_CP0_CAUSE;
187   else if (mips_linux_restart_reg_p (gdbarch)
188            && regno == MIPS_RESTART_REGNUM)
189     regaddr = EF_REG0;
190   else
191     regaddr = -1;
192
193   if (regaddr != -1)
194     {
195       dst = regp + regaddr;
196       regcache_raw_collect (regcache, regno, dst);
197     }
198 }
199
200 static void
201 mips_fill_gregset_wrapper (const struct regset *regset,
202                            const struct regcache *regcache,
203                            int regnum, void *gregs, size_t len)
204 {
205   gdb_assert (len == sizeof (mips_elf_gregset_t));
206
207   mips_fill_gregset (regcache, (mips_elf_gregset_t *)gregs, regnum);
208 }
209
210 /* Likewise, unpack an elf_fpregset_t.  */
211
212 void
213 mips_supply_fpregset (struct regcache *regcache,
214                       const mips_elf_fpregset_t *fpregsetp)
215 {
216   struct gdbarch *gdbarch = get_regcache_arch (regcache);
217   int regi;
218   char zerobuf[MAX_REGISTER_SIZE];
219
220   memset (zerobuf, 0, MAX_REGISTER_SIZE);
221
222   for (regi = 0; regi < 32; regi++)
223     regcache_raw_supply (regcache,
224                          gdbarch_fp0_regnum (gdbarch) + regi,
225                          *fpregsetp + regi);
226
227   regcache_raw_supply (regcache,
228                        mips_regnum (gdbarch)->fp_control_status,
229                        *fpregsetp + 32);
230
231   /* FIXME: how can we supply FCRIR?  The ABI doesn't tell us.  */
232   regcache_raw_supply (regcache,
233                        mips_regnum (gdbarch)->fp_implementation_revision,
234                        zerobuf);
235 }
236
237 static void
238 mips_supply_fpregset_wrapper (const struct regset *regset,
239                               struct regcache *regcache,
240                               int regnum, const void *gregs, size_t len)
241 {
242   gdb_assert (len == sizeof (mips_elf_fpregset_t));
243
244   mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *)gregs);
245 }
246
247 /* Likewise, pack one or all floating point registers into an
248    elf_fpregset_t.  */
249
250 void
251 mips_fill_fpregset (const struct regcache *regcache,
252                     mips_elf_fpregset_t *fpregsetp, int regno)
253 {
254   struct gdbarch *gdbarch = get_regcache_arch (regcache);
255   char *from, *to;
256
257   if ((regno >= gdbarch_fp0_regnum (gdbarch))
258       && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
259     {
260       to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
261       regcache_raw_collect (regcache, regno, to);
262     }
263   else if (regno == mips_regnum (gdbarch)->fp_control_status)
264     {
265       to = (char *) (*fpregsetp + 32);
266       regcache_raw_collect (regcache, regno, to);
267     }
268   else if (regno == -1)
269     {
270       int regi;
271
272       for (regi = 0; regi < 32; regi++)
273         mips_fill_fpregset (regcache, fpregsetp,
274                             gdbarch_fp0_regnum (gdbarch) + regi);
275       mips_fill_fpregset (regcache, fpregsetp,
276                           mips_regnum (gdbarch)->fp_control_status);
277     }
278 }
279
280 static void
281 mips_fill_fpregset_wrapper (const struct regset *regset,
282                             const struct regcache *regcache,
283                             int regnum, void *gregs, size_t len)
284 {
285   gdb_assert (len == sizeof (mips_elf_fpregset_t));
286
287   mips_fill_fpregset (regcache, (mips_elf_fpregset_t *)gregs, regnum);
288 }
289
290 /* Support for 64-bit ABIs.  */
291
292 /* Figure out where the longjmp will land.
293    We expect the first arg to be a pointer to the jmp_buf structure
294    from which we extract the pc (MIPS_LINUX_JB_PC) that we will land
295    at.  The pc is copied into PC.  This routine returns 1 on
296    success.  */
297
298 /* Details about jmp_buf.  */
299
300 #define MIPS64_LINUX_JB_PC 0
301
302 static int
303 mips64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
304 {
305   CORE_ADDR jb_addr;
306   struct gdbarch *gdbarch = get_frame_arch (frame);
307   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
308   void *buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
309   int element_size = gdbarch_ptr_bit (gdbarch) == 32 ? 4 : 8;
310
311   jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
312
313   if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size,
314                           buf,
315                           gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
316     return 0;
317
318   *pc = extract_unsigned_integer (buf,
319                                   gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT,
320                                   byte_order);
321
322   return 1;
323 }
324
325 /* Register set support functions.  These operate on standard 64-bit
326    regsets, but work whether the target is 32-bit or 64-bit.  A 32-bit
327    target will still use the 64-bit format for PTRACE_GETREGS.  */
328
329 /* Supply a 64-bit register.  */
330
331 static void
332 supply_64bit_reg (struct regcache *regcache, int regnum,
333                   const gdb_byte *buf)
334 {
335   struct gdbarch *gdbarch = get_regcache_arch (regcache);
336   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
337       && register_size (gdbarch, regnum) == 4)
338     regcache_raw_supply (regcache, regnum, buf + 4);
339   else
340     regcache_raw_supply (regcache, regnum, buf);
341 }
342
343 /* Unpack a 64-bit elf_gregset_t into GDB's register cache.  */
344
345 void
346 mips64_supply_gregset (struct regcache *regcache,
347                        const mips64_elf_gregset_t *gregsetp)
348 {
349   int regi;
350   const mips64_elf_greg_t *regp = *gregsetp;
351   gdb_byte zerobuf[MAX_REGISTER_SIZE];
352   struct gdbarch *gdbarch = get_regcache_arch (regcache);
353
354   memset (zerobuf, 0, MAX_REGISTER_SIZE);
355
356   for (regi = MIPS64_EF_REG0 + 1; regi <= MIPS64_EF_REG31; regi++)
357     supply_64bit_reg (regcache, regi - MIPS64_EF_REG0,
358                       (const gdb_byte *)(regp + regi));
359
360   if (mips_linux_restart_reg_p (gdbarch))
361     supply_64bit_reg (regcache, MIPS_RESTART_REGNUM,
362                       (const gdb_byte *)(regp + MIPS64_EF_REG0));
363
364   supply_64bit_reg (regcache, mips_regnum (gdbarch)->lo,
365                     (const gdb_byte *) (regp + MIPS64_EF_LO));
366   supply_64bit_reg (regcache, mips_regnum (gdbarch)->hi,
367                     (const gdb_byte *) (regp + MIPS64_EF_HI));
368
369   supply_64bit_reg (regcache, mips_regnum (gdbarch)->pc,
370                     (const gdb_byte *) (regp + MIPS64_EF_CP0_EPC));
371   supply_64bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
372                     (const gdb_byte *) (regp + MIPS64_EF_CP0_BADVADDR));
373   supply_64bit_reg (regcache, MIPS_PS_REGNUM,
374                     (const gdb_byte *) (regp + MIPS64_EF_CP0_STATUS));
375   supply_64bit_reg (regcache, mips_regnum (gdbarch)->cause,
376                     (const gdb_byte *) (regp + MIPS64_EF_CP0_CAUSE));
377
378   /* Fill inaccessible registers with zero.  */
379   regcache_raw_supply (regcache, MIPS_ZERO_REGNUM, zerobuf);
380   regcache_raw_supply (regcache, MIPS_UNUSED_REGNUM, zerobuf);
381   for (regi = MIPS_FIRST_EMBED_REGNUM;
382        regi <= MIPS_LAST_EMBED_REGNUM;
383        regi++)
384     regcache_raw_supply (regcache, regi, zerobuf);
385 }
386
387 static void
388 mips64_supply_gregset_wrapper (const struct regset *regset,
389                                struct regcache *regcache,
390                                int regnum, const void *gregs, size_t len)
391 {
392   gdb_assert (len == sizeof (mips64_elf_gregset_t));
393
394   mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *)gregs);
395 }
396
397 /* Pack our registers (or one register) into a 64-bit elf_gregset_t.  */
398
399 void
400 mips64_fill_gregset (const struct regcache *regcache,
401                      mips64_elf_gregset_t *gregsetp, int regno)
402 {
403   struct gdbarch *gdbarch = get_regcache_arch (regcache);
404   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
405   int regaddr, regi;
406   mips64_elf_greg_t *regp = *gregsetp;
407   void *dst;
408
409   if (regno == -1)
410     {
411       memset (regp, 0, sizeof (mips64_elf_gregset_t));
412       for (regi = 1; regi < 32; regi++)
413         mips64_fill_gregset (regcache, gregsetp, regi);
414       mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
415       mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
416       mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
417       mips64_fill_gregset (regcache, gregsetp,
418                            mips_regnum (gdbarch)->badvaddr);
419       mips64_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
420       mips64_fill_gregset (regcache, gregsetp,  mips_regnum (gdbarch)->cause);
421       mips64_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
422       return;
423    }
424
425   if (regno > 0 && regno < 32)
426     regaddr = regno + MIPS64_EF_REG0;
427   else if (regno == mips_regnum (gdbarch)->lo)
428     regaddr = MIPS64_EF_LO;
429   else if (regno == mips_regnum (gdbarch)->hi)
430     regaddr = MIPS64_EF_HI;
431   else if (regno == mips_regnum (gdbarch)->pc)
432     regaddr = MIPS64_EF_CP0_EPC;
433   else if (regno == mips_regnum (gdbarch)->badvaddr)
434     regaddr = MIPS64_EF_CP0_BADVADDR;
435   else if (regno == MIPS_PS_REGNUM)
436     regaddr = MIPS64_EF_CP0_STATUS;
437   else if (regno == mips_regnum (gdbarch)->cause)
438     regaddr = MIPS64_EF_CP0_CAUSE;
439   else if (mips_linux_restart_reg_p (gdbarch)
440            && regno == MIPS_RESTART_REGNUM)
441     regaddr = MIPS64_EF_REG0;
442   else
443     regaddr = -1;
444
445   if (regaddr != -1)
446     {
447       gdb_byte buf[MAX_REGISTER_SIZE];
448       LONGEST val;
449
450       regcache_raw_collect (regcache, regno, buf);
451       val = extract_signed_integer (buf, register_size (gdbarch, regno),
452                                     byte_order);
453       dst = regp + regaddr;
454       store_signed_integer (dst, 8, byte_order, val);
455     }
456 }
457
458 static void
459 mips64_fill_gregset_wrapper (const struct regset *regset,
460                              const struct regcache *regcache,
461                              int regnum, void *gregs, size_t len)
462 {
463   gdb_assert (len == sizeof (mips64_elf_gregset_t));
464
465   mips64_fill_gregset (regcache, (mips64_elf_gregset_t *)gregs, regnum);
466 }
467
468 /* Likewise, unpack an elf_fpregset_t.  */
469
470 void
471 mips64_supply_fpregset (struct regcache *regcache,
472                         const mips64_elf_fpregset_t *fpregsetp)
473 {
474   struct gdbarch *gdbarch = get_regcache_arch (regcache);
475   int regi;
476
477   /* See mips_linux_o32_sigframe_init for a description of the
478      peculiar FP register layout.  */
479   if (register_size (gdbarch, gdbarch_fp0_regnum (gdbarch)) == 4)
480     for (regi = 0; regi < 32; regi++)
481       {
482         const gdb_byte *reg_ptr = (const gdb_byte *)(*fpregsetp + (regi & ~1));
483         if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
484           reg_ptr += 4;
485         regcache_raw_supply (regcache,
486                              gdbarch_fp0_regnum (gdbarch) + regi,
487                              reg_ptr);
488       }
489   else
490     for (regi = 0; regi < 32; regi++)
491       regcache_raw_supply (regcache,
492                            gdbarch_fp0_regnum (gdbarch) + regi,
493                            (const char *)(*fpregsetp + regi));
494
495   supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_control_status,
496                     (const gdb_byte *)(*fpregsetp + 32));
497
498   /* The ABI doesn't tell us how to supply FCRIR, and core dumps don't
499      include it - but the result of PTRACE_GETFPREGS does.  The best we
500      can do is to assume that its value is present.  */
501   supply_32bit_reg (regcache,
502                     mips_regnum (gdbarch)->fp_implementation_revision,
503                     (const gdb_byte *)(*fpregsetp + 32) + 4);
504 }
505
506 static void
507 mips64_supply_fpregset_wrapper (const struct regset *regset,
508                                 struct regcache *regcache,
509                                 int regnum, const void *gregs, size_t len)
510 {
511   gdb_assert (len == sizeof (mips64_elf_fpregset_t));
512
513   mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *)gregs);
514 }
515
516 /* Likewise, pack one or all floating point registers into an
517    elf_fpregset_t.  */
518
519 void
520 mips64_fill_fpregset (const struct regcache *regcache,
521                       mips64_elf_fpregset_t *fpregsetp, int regno)
522 {
523   struct gdbarch *gdbarch = get_regcache_arch (regcache);
524   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
525   gdb_byte *to;
526
527   if ((regno >= gdbarch_fp0_regnum (gdbarch))
528       && (regno < gdbarch_fp0_regnum (gdbarch) + 32))
529     {
530       /* See mips_linux_o32_sigframe_init for a description of the
531          peculiar FP register layout.  */
532       if (register_size (gdbarch, regno) == 4)
533         {
534           int regi = regno - gdbarch_fp0_regnum (gdbarch);
535
536           to = (gdb_byte *) (*fpregsetp + (regi & ~1));
537           if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
538             to += 4;
539           regcache_raw_collect (regcache, regno, to);
540         }
541       else
542         {
543           to = (gdb_byte *) (*fpregsetp + regno
544                              - gdbarch_fp0_regnum (gdbarch));
545           regcache_raw_collect (regcache, regno, to);
546         }
547     }
548   else if (regno == mips_regnum (gdbarch)->fp_control_status)
549     {
550       gdb_byte buf[MAX_REGISTER_SIZE];
551       LONGEST val;
552
553       regcache_raw_collect (regcache, regno, buf);
554       val = extract_signed_integer (buf, register_size (gdbarch, regno),
555                                     byte_order);
556       to = (gdb_byte *) (*fpregsetp + 32);
557       store_signed_integer (to, 4, byte_order, val);
558     }
559   else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
560     {
561       gdb_byte buf[MAX_REGISTER_SIZE];
562       LONGEST val;
563
564       regcache_raw_collect (regcache, regno, buf);
565       val = extract_signed_integer (buf, register_size (gdbarch, regno),
566                                     byte_order);
567       to = (gdb_byte *) (*fpregsetp + 32) + 4;
568       store_signed_integer (to, 4, byte_order, val);
569     }
570   else if (regno == -1)
571     {
572       int regi;
573
574       for (regi = 0; regi < 32; regi++)
575         mips64_fill_fpregset (regcache, fpregsetp,
576                               gdbarch_fp0_regnum (gdbarch) + regi);
577       mips64_fill_fpregset (regcache, fpregsetp,
578                             mips_regnum (gdbarch)->fp_control_status);
579       mips64_fill_fpregset (regcache, fpregsetp,
580                             (mips_regnum (gdbarch)
581                               ->fp_implementation_revision));
582     }
583 }
584
585 static void
586 mips64_fill_fpregset_wrapper (const struct regset *regset,
587                               const struct regcache *regcache,
588                               int regnum, void *gregs, size_t len)
589 {
590   gdb_assert (len == sizeof (mips64_elf_fpregset_t));
591
592   mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *)gregs, regnum);
593 }
594
595 const struct regset *
596 mips_linux_regset_from_core_section (struct gdbarch *gdbarch,
597                                      const char *sect_name, size_t sect_size)
598 {
599   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
600   mips_elf_gregset_t gregset;
601   mips_elf_fpregset_t fpregset;
602   mips64_elf_gregset_t gregset64;
603   mips64_elf_fpregset_t fpregset64;
604
605   if (strcmp (sect_name, ".reg") == 0)
606     {
607       if (sect_size == sizeof (gregset))
608         {
609           if (tdep->gregset == NULL)
610             tdep->gregset = regset_alloc (gdbarch,
611                                           mips_supply_gregset_wrapper,
612                                           mips_fill_gregset_wrapper);
613           return tdep->gregset;
614         }
615       else if (sect_size == sizeof (gregset64))
616         {
617           if (tdep->gregset64 == NULL)
618             tdep->gregset64 = regset_alloc (gdbarch,
619                                             mips64_supply_gregset_wrapper,
620                                             mips64_fill_gregset_wrapper);
621           return tdep->gregset64;
622         }
623       else
624         {
625           warning (_("wrong size gregset struct in core file"));
626         }
627     }
628   else if (strcmp (sect_name, ".reg2") == 0)
629     {
630       if (sect_size == sizeof (fpregset))
631         {
632           if (tdep->fpregset == NULL)
633             tdep->fpregset = regset_alloc (gdbarch,
634                                            mips_supply_fpregset_wrapper,
635                                            mips_fill_fpregset_wrapper);
636           return tdep->fpregset;
637         }
638       else if (sect_size == sizeof (fpregset64))
639         {
640           if (tdep->fpregset64 == NULL)
641             tdep->fpregset64 = regset_alloc (gdbarch,
642                                              mips64_supply_fpregset_wrapper,
643                                              mips64_fill_fpregset_wrapper);
644           return tdep->fpregset64;
645         }
646       else
647         {
648           warning (_("wrong size fpregset struct in core file"));
649         }
650     }
651
652   return NULL;
653 }
654
655 static const struct target_desc *
656 mips_linux_core_read_description (struct gdbarch *gdbarch,
657                                   struct target_ops *target,
658                                   bfd *abfd)
659 {
660   asection *section = bfd_get_section_by_name (abfd, ".reg");
661   if (! section)
662     return NULL;
663
664   switch (bfd_section_size (abfd, section))
665     {
666     case sizeof (mips_elf_gregset_t):
667       return mips_tdesc_gp32;
668
669     case sizeof (mips64_elf_gregset_t):
670       return mips_tdesc_gp64;
671
672     default:
673       return NULL;
674     }
675 }
676
677
678 /* Check the code at PC for a dynamic linker lazy resolution stub.
679    Because they aren't in the .plt section, we pattern-match on the
680    code generated by GNU ld.  They look like this:
681
682    lw t9,0x8010(gp)
683    addu t7,ra
684    jalr t9,ra
685    addiu t8,zero,INDEX
686
687    (with the appropriate doubleword instructions for N64).  Also
688    return the dynamic symbol index used in the last instruction.  */
689
690 static int
691 mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
692 {
693   unsigned char buf[28], *p;
694   ULONGEST insn, insn1;
695   int n64 = (mips_abi (target_gdbarch) == MIPS_ABI_N64);
696   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
697
698   read_memory (pc - 12, buf, 28);
699
700   if (n64)
701     {
702       /* ld t9,0x8010(gp) */
703       insn1 = 0xdf998010;
704     }
705   else
706     {
707       /* lw t9,0x8010(gp) */
708       insn1 = 0x8f998010;
709     }
710
711   p = buf + 12;
712   while (p >= buf)
713     {
714       insn = extract_unsigned_integer (p, 4, byte_order);
715       if (insn == insn1)
716         break;
717       p -= 4;
718     }
719   if (p < buf)
720     return 0;
721
722   insn = extract_unsigned_integer (p + 4, 4, byte_order);
723   if (n64)
724     {
725       /* daddu t7,ra */
726       if (insn != 0x03e0782d)
727         return 0;
728     }
729   else
730     {
731       /* addu t7,ra */
732       if (insn != 0x03e07821)
733         return 0;
734     }
735
736   insn = extract_unsigned_integer (p + 8, 4, byte_order);
737   /* jalr t9,ra */
738   if (insn != 0x0320f809)
739     return 0;
740
741   insn = extract_unsigned_integer (p + 12, 4, byte_order);
742   if (n64)
743     {
744       /* daddiu t8,zero,0 */
745       if ((insn & 0xffff0000) != 0x64180000)
746         return 0;
747     }
748   else
749     {
750       /* addiu t8,zero,0 */
751       if ((insn & 0xffff0000) != 0x24180000)
752         return 0;
753     }
754
755   return (insn & 0xffff);
756 }
757
758 /* Return non-zero iff PC belongs to the dynamic linker resolution
759    code, a PLT entry, or a lazy binding stub.  */
760
761 static int
762 mips_linux_in_dynsym_resolve_code (CORE_ADDR pc)
763 {
764   /* Check whether PC is in the dynamic linker.  This also checks
765      whether it is in the .plt section, used by non-PIC executables.  */
766   if (svr4_in_dynsym_resolve_code (pc))
767     return 1;
768
769   /* Pattern match for the stub.  It would be nice if there were a
770      more efficient way to avoid this check.  */
771   if (mips_linux_in_dynsym_stub (pc, NULL))
772     return 1;
773
774   return 0;
775 }
776
777 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c,
778    and glibc_skip_solib_resolver in glibc-tdep.c.  The normal glibc
779    implementation of this triggers at "fixup" from the same objfile as
780    "_dl_runtime_resolve"; MIPS GNU/Linux can trigger at
781    "__dl_runtime_resolve" directly.  An unresolved lazy binding
782    stub will point to _dl_runtime_resolve, which will first call
783    __dl_runtime_resolve, and then pass control to the resolved
784    function.  */
785
786 static CORE_ADDR
787 mips_linux_skip_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
788 {
789   struct minimal_symbol *resolver;
790
791   resolver = lookup_minimal_symbol ("__dl_runtime_resolve", NULL, NULL);
792
793   if (resolver && SYMBOL_VALUE_ADDRESS (resolver) == pc)
794     return frame_unwind_caller_pc (get_current_frame ());
795
796   return glibc_skip_solib_resolver (gdbarch, pc);
797 }
798
799 /* Signal trampoline support.  There are four supported layouts for a
800    signal frame: o32 sigframe, o32 rt_sigframe, n32 rt_sigframe, and
801    n64 rt_sigframe.  We handle them all independently; not the most
802    efficient way, but simplest.  First, declare all the unwinders.  */
803
804 static void mips_linux_o32_sigframe_init (const struct tramp_frame *self,
805                                           struct frame_info *this_frame,
806                                           struct trad_frame_cache *this_cache,
807                                           CORE_ADDR func);
808
809 static void mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
810                                              struct frame_info *this_frame,
811                                              struct trad_frame_cache *this_cache,
812                                              CORE_ADDR func);
813
814 #define MIPS_NR_LINUX 4000
815 #define MIPS_NR_N64_LINUX 5000
816 #define MIPS_NR_N32_LINUX 6000
817
818 #define MIPS_NR_sigreturn MIPS_NR_LINUX + 119
819 #define MIPS_NR_rt_sigreturn MIPS_NR_LINUX + 193
820 #define MIPS_NR_N64_rt_sigreturn MIPS_NR_N64_LINUX + 211
821 #define MIPS_NR_N32_rt_sigreturn MIPS_NR_N32_LINUX + 211
822
823 #define MIPS_INST_LI_V0_SIGRETURN 0x24020000 + MIPS_NR_sigreturn
824 #define MIPS_INST_LI_V0_RT_SIGRETURN 0x24020000 + MIPS_NR_rt_sigreturn
825 #define MIPS_INST_LI_V0_N64_RT_SIGRETURN 0x24020000 + MIPS_NR_N64_rt_sigreturn
826 #define MIPS_INST_LI_V0_N32_RT_SIGRETURN 0x24020000 + MIPS_NR_N32_rt_sigreturn
827 #define MIPS_INST_SYSCALL 0x0000000c
828
829 static const struct tramp_frame mips_linux_o32_sigframe = {
830   SIGTRAMP_FRAME,
831   4,
832   {
833     { MIPS_INST_LI_V0_SIGRETURN, -1 },
834     { MIPS_INST_SYSCALL, -1 },
835     { TRAMP_SENTINEL_INSN, -1 }
836   },
837   mips_linux_o32_sigframe_init
838 };
839
840 static const struct tramp_frame mips_linux_o32_rt_sigframe = {
841   SIGTRAMP_FRAME,
842   4,
843   {
844     { MIPS_INST_LI_V0_RT_SIGRETURN, -1 },
845     { MIPS_INST_SYSCALL, -1 },
846     { TRAMP_SENTINEL_INSN, -1 } },
847   mips_linux_o32_sigframe_init
848 };
849
850 static const struct tramp_frame mips_linux_n32_rt_sigframe = {
851   SIGTRAMP_FRAME,
852   4,
853   {
854     { MIPS_INST_LI_V0_N32_RT_SIGRETURN, -1 },
855     { MIPS_INST_SYSCALL, -1 },
856     { TRAMP_SENTINEL_INSN, -1 }
857   },
858   mips_linux_n32n64_sigframe_init
859 };
860
861 static const struct tramp_frame mips_linux_n64_rt_sigframe = {
862   SIGTRAMP_FRAME,
863   4,
864   {
865     { MIPS_INST_LI_V0_N64_RT_SIGRETURN, -1 },
866     { MIPS_INST_SYSCALL, -1 },
867     { TRAMP_SENTINEL_INSN, -1 }
868   },
869   mips_linux_n32n64_sigframe_init
870 };
871
872 /* *INDENT-OFF* */
873 /* The unwinder for o32 signal frames.  The legacy structures look
874    like this:
875
876    struct sigframe {
877      u32 sf_ass[4];            [argument save space for o32]
878      u32 sf_code[2];           [signal trampoline or fill]
879      struct sigcontext sf_sc;
880      sigset_t sf_mask;
881    };
882
883    struct sigcontext {
884         unsigned int       sc_regmask;          [Unused]
885         unsigned int       sc_status;
886         unsigned long long sc_pc;
887         unsigned long long sc_regs[32];
888         unsigned long long sc_fpregs[32];
889         unsigned int       sc_ownedfp;
890         unsigned int       sc_fpc_csr;
891         unsigned int       sc_fpc_eir;          [Unused]
892         unsigned int       sc_used_math;
893         unsigned int       sc_ssflags;          [Unused]
894         [Alignment hole of four bytes]
895         unsigned long long sc_mdhi;
896         unsigned long long sc_mdlo;
897
898         unsigned int       sc_cause;            [Unused]
899         unsigned int       sc_badvaddr;         [Unused]
900
901         unsigned long      sc_sigset[4];        [kernel's sigset_t]
902    };
903
904    The RT signal frames look like this:
905
906    struct rt_sigframe {
907      u32 rs_ass[4];            [argument save space for o32]
908      u32 rs_code[2]            [signal trampoline or fill]
909      struct siginfo rs_info;
910      struct ucontext rs_uc;
911    };
912
913    struct ucontext {
914      unsigned long     uc_flags;
915      struct ucontext  *uc_link;
916      stack_t           uc_stack;
917      [Alignment hole of four bytes]
918      struct sigcontext uc_mcontext;
919      sigset_t          uc_sigmask;
920    };  */
921 /* *INDENT-ON* */
922
923 #define SIGFRAME_SIGCONTEXT_OFFSET   (6 * 4)
924
925 #define RTSIGFRAME_SIGINFO_SIZE      128
926 #define STACK_T_SIZE                 (3 * 4)
927 #define UCONTEXT_SIGCONTEXT_OFFSET   (2 * 4 + STACK_T_SIZE + 4)
928 #define RTSIGFRAME_SIGCONTEXT_OFFSET (SIGFRAME_SIGCONTEXT_OFFSET \
929                                       + RTSIGFRAME_SIGINFO_SIZE \
930                                       + UCONTEXT_SIGCONTEXT_OFFSET)
931
932 #define SIGCONTEXT_PC       (1 * 8)
933 #define SIGCONTEXT_REGS     (2 * 8)
934 #define SIGCONTEXT_FPREGS   (34 * 8)
935 #define SIGCONTEXT_FPCSR    (66 * 8 + 4)
936 #define SIGCONTEXT_HI       (69 * 8)
937 #define SIGCONTEXT_LO       (70 * 8)
938 #define SIGCONTEXT_CAUSE    (71 * 8 + 0)
939 #define SIGCONTEXT_BADVADDR (71 * 8 + 4)
940
941 #define SIGCONTEXT_REG_SIZE 8
942
943 static void
944 mips_linux_o32_sigframe_init (const struct tramp_frame *self,
945                               struct frame_info *this_frame,
946                               struct trad_frame_cache *this_cache,
947                               CORE_ADDR func)
948 {
949   struct gdbarch *gdbarch = get_frame_arch (this_frame);
950   int ireg, reg_position;
951   CORE_ADDR frame_sp = get_frame_sp (this_frame);
952   CORE_ADDR sigcontext_base;
953   const struct mips_regnum *regs = mips_regnum (gdbarch);
954   CORE_ADDR regs_base;
955
956   if (self == &mips_linux_o32_sigframe)
957     sigcontext_base = frame_sp + SIGFRAME_SIGCONTEXT_OFFSET;
958   else
959     sigcontext_base = frame_sp + RTSIGFRAME_SIGCONTEXT_OFFSET;
960
961   /* I'm not proud of this hack.  Eventually we will have the
962      infrastructure to indicate the size of saved registers on a
963      per-frame basis, but right now we don't; the kernel saves eight
964      bytes but we only want four.  Use regs_base to access any
965      64-bit fields.  */
966   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
967     regs_base = sigcontext_base + 4;
968   else
969     regs_base = sigcontext_base;
970
971   if (mips_linux_restart_reg_p (gdbarch))
972     trad_frame_set_reg_addr (this_cache,
973                              (MIPS_RESTART_REGNUM
974                               + gdbarch_num_regs (gdbarch)),
975                              regs_base + SIGCONTEXT_REGS);
976
977   for (ireg = 1; ireg < 32; ireg++)
978     trad_frame_set_reg_addr (this_cache,
979                              ireg + MIPS_ZERO_REGNUM
980                                + gdbarch_num_regs (gdbarch),
981                              regs_base + SIGCONTEXT_REGS
982                              + ireg * SIGCONTEXT_REG_SIZE);
983
984   /* The way that floating point registers are saved, unfortunately,
985      depends on the architecture the kernel is built for.  For the r3000 and
986      tx39, four bytes of each register are at the beginning of each of the
987      32 eight byte slots.  For everything else, the registers are saved
988      using double precision; only the even-numbered slots are initialized,
989      and the high bits are the odd-numbered register.  Assume the latter
990      layout, since we can't tell, and it's much more common.  Which bits are
991      the "high" bits depends on endianness.  */
992   for (ireg = 0; ireg < 32; ireg++)
993     if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1))
994       trad_frame_set_reg_addr (this_cache,
995                                ireg + regs->fp0 +
996                                  gdbarch_num_regs (gdbarch),
997                                sigcontext_base + SIGCONTEXT_FPREGS + 4
998                                + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
999     else
1000       trad_frame_set_reg_addr (this_cache,
1001                                ireg + regs->fp0
1002                                  + gdbarch_num_regs (gdbarch),
1003                                sigcontext_base + SIGCONTEXT_FPREGS
1004                                + (ireg & ~1) * SIGCONTEXT_REG_SIZE);
1005
1006   trad_frame_set_reg_addr (this_cache,
1007                            regs->pc + gdbarch_num_regs (gdbarch),
1008                            regs_base + SIGCONTEXT_PC);
1009
1010   trad_frame_set_reg_addr (this_cache,
1011                            regs->fp_control_status
1012                            + gdbarch_num_regs (gdbarch),
1013                            sigcontext_base + SIGCONTEXT_FPCSR);
1014   trad_frame_set_reg_addr (this_cache,
1015                            regs->hi + gdbarch_num_regs (gdbarch),
1016                            regs_base + SIGCONTEXT_HI);
1017   trad_frame_set_reg_addr (this_cache,
1018                            regs->lo + gdbarch_num_regs (gdbarch),
1019                            regs_base + SIGCONTEXT_LO);
1020   trad_frame_set_reg_addr (this_cache,
1021                            regs->cause + gdbarch_num_regs (gdbarch),
1022                            sigcontext_base + SIGCONTEXT_CAUSE);
1023   trad_frame_set_reg_addr (this_cache,
1024                            regs->badvaddr + gdbarch_num_regs (gdbarch),
1025                            sigcontext_base + SIGCONTEXT_BADVADDR);
1026
1027   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
1028   trad_frame_set_id (this_cache, frame_id_build (frame_sp, func));
1029 }
1030
1031 /* *INDENT-OFF* */
1032 /* For N32/N64 things look different.  There is no non-rt signal frame.
1033
1034   struct rt_sigframe_n32 {
1035     u32 rs_ass[4];                  [ argument save space for o32 ]
1036     u32 rs_code[2];                 [ signal trampoline or fill ]
1037     struct siginfo rs_info;
1038     struct ucontextn32 rs_uc;
1039   };
1040
1041   struct ucontextn32 {
1042     u32                 uc_flags;
1043     s32                 uc_link;
1044     stack32_t           uc_stack;
1045     struct sigcontext   uc_mcontext;
1046     sigset_t            uc_sigmask;   [ mask last for extensibility ]
1047   };
1048
1049   struct rt_sigframe {
1050     u32 rs_ass[4];                  [ argument save space for o32 ]
1051     u32 rs_code[2];                 [ signal trampoline ]
1052     struct siginfo rs_info;
1053     struct ucontext rs_uc;
1054   };
1055
1056   struct ucontext {
1057     unsigned long     uc_flags;
1058     struct ucontext  *uc_link;
1059     stack_t           uc_stack;
1060     struct sigcontext uc_mcontext;
1061     sigset_t          uc_sigmask;   [ mask last for extensibility ]
1062   };
1063
1064   And the sigcontext is different (this is for both n32 and n64):
1065
1066   struct sigcontext {
1067     unsigned long long sc_regs[32];
1068     unsigned long long sc_fpregs[32];
1069     unsigned long long sc_mdhi;
1070     unsigned long long sc_hi1;
1071     unsigned long long sc_hi2;
1072     unsigned long long sc_hi3;
1073     unsigned long long sc_mdlo;
1074     unsigned long long sc_lo1;
1075     unsigned long long sc_lo2;
1076     unsigned long long sc_lo3;
1077     unsigned long long sc_pc;
1078     unsigned int       sc_fpc_csr;
1079     unsigned int       sc_used_math;
1080     unsigned int       sc_dsp;
1081     unsigned int       sc_reserved;
1082   };
1083
1084   That is the post-2.6.12 definition of the 64-bit sigcontext; before
1085   then, there were no hi1-hi3 or lo1-lo3.  Cause and badvaddr were
1086   included too.  */
1087 /* *INDENT-ON* */
1088
1089 #define N32_STACK_T_SIZE                STACK_T_SIZE
1090 #define N64_STACK_T_SIZE                (2 * 8 + 4)
1091 #define N32_UCONTEXT_SIGCONTEXT_OFFSET  (2 * 4 + N32_STACK_T_SIZE + 4)
1092 #define N64_UCONTEXT_SIGCONTEXT_OFFSET  (2 * 8 + N64_STACK_T_SIZE + 4)
1093 #define N32_SIGFRAME_SIGCONTEXT_OFFSET  (SIGFRAME_SIGCONTEXT_OFFSET \
1094                                          + RTSIGFRAME_SIGINFO_SIZE \
1095                                          + N32_UCONTEXT_SIGCONTEXT_OFFSET)
1096 #define N64_SIGFRAME_SIGCONTEXT_OFFSET  (SIGFRAME_SIGCONTEXT_OFFSET \
1097                                          + RTSIGFRAME_SIGINFO_SIZE \
1098                                          + N64_UCONTEXT_SIGCONTEXT_OFFSET)
1099
1100 #define N64_SIGCONTEXT_REGS     (0 * 8)
1101 #define N64_SIGCONTEXT_FPREGS   (32 * 8)
1102 #define N64_SIGCONTEXT_HI       (64 * 8)
1103 #define N64_SIGCONTEXT_LO       (68 * 8)
1104 #define N64_SIGCONTEXT_PC       (72 * 8)
1105 #define N64_SIGCONTEXT_FPCSR    (73 * 8)
1106
1107 #define N64_SIGCONTEXT_REG_SIZE 8
1108
1109 static void
1110 mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
1111                                  struct frame_info *this_frame,
1112                                  struct trad_frame_cache *this_cache,
1113                                  CORE_ADDR func)
1114 {
1115   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1116   int ireg, reg_position;
1117   CORE_ADDR frame_sp = get_frame_sp (this_frame);
1118   CORE_ADDR sigcontext_base;
1119   const struct mips_regnum *regs = mips_regnum (gdbarch);
1120
1121   if (self == &mips_linux_n32_rt_sigframe)
1122     sigcontext_base = frame_sp + N32_SIGFRAME_SIGCONTEXT_OFFSET;
1123   else
1124     sigcontext_base = frame_sp + N64_SIGFRAME_SIGCONTEXT_OFFSET;
1125
1126   if (mips_linux_restart_reg_p (gdbarch))
1127     trad_frame_set_reg_addr (this_cache,
1128                              (MIPS_RESTART_REGNUM
1129                               + gdbarch_num_regs (gdbarch)),
1130                              sigcontext_base + N64_SIGCONTEXT_REGS);
1131
1132   for (ireg = 1; ireg < 32; ireg++)
1133     trad_frame_set_reg_addr (this_cache,
1134                              ireg + MIPS_ZERO_REGNUM
1135                              + gdbarch_num_regs (gdbarch),
1136                              sigcontext_base + N64_SIGCONTEXT_REGS
1137                              + ireg * N64_SIGCONTEXT_REG_SIZE);
1138
1139   for (ireg = 0; ireg < 32; ireg++)
1140     trad_frame_set_reg_addr (this_cache,
1141                              ireg + regs->fp0
1142                              + gdbarch_num_regs (gdbarch),
1143                              sigcontext_base + N64_SIGCONTEXT_FPREGS
1144                              + ireg * N64_SIGCONTEXT_REG_SIZE);
1145
1146   trad_frame_set_reg_addr (this_cache,
1147                            regs->pc + gdbarch_num_regs (gdbarch),
1148                            sigcontext_base + N64_SIGCONTEXT_PC);
1149
1150   trad_frame_set_reg_addr (this_cache,
1151                            regs->fp_control_status
1152                            + gdbarch_num_regs (gdbarch),
1153                            sigcontext_base + N64_SIGCONTEXT_FPCSR);
1154   trad_frame_set_reg_addr (this_cache,
1155                            regs->hi + gdbarch_num_regs (gdbarch),
1156                            sigcontext_base + N64_SIGCONTEXT_HI);
1157   trad_frame_set_reg_addr (this_cache,
1158                            regs->lo + gdbarch_num_regs (gdbarch),
1159                            sigcontext_base + N64_SIGCONTEXT_LO);
1160
1161   /* Choice of the bottom of the sigframe is somewhat arbitrary.  */
1162   trad_frame_set_id (this_cache, frame_id_build (frame_sp, func));
1163 }
1164
1165 static void
1166 mips_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
1167 {
1168   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1169   regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), pc);
1170
1171   /* Clear the syscall restart flag.  */
1172   if (mips_linux_restart_reg_p (gdbarch))
1173     regcache_cooked_write_unsigned (regcache, MIPS_RESTART_REGNUM, 0);
1174 }
1175
1176 /* Return 1 if MIPS_RESTART_REGNUM is usable.  */
1177
1178 int
1179 mips_linux_restart_reg_p (struct gdbarch *gdbarch)
1180 {
1181   /* If we do not have a target description with registers, then
1182      MIPS_RESTART_REGNUM will not be included in the register set.  */
1183   if (!tdesc_has_registers (gdbarch_target_desc (gdbarch)))
1184     return 0;
1185
1186   /* If we do, then MIPS_RESTART_REGNUM is safe to check; it will
1187      either be GPR-sized or missing.  */
1188   return register_size (gdbarch, MIPS_RESTART_REGNUM) > 0;
1189 }
1190
1191 /* When FRAME is at a syscall instruction, return the PC of the next
1192    instruction to be executed.  */
1193
1194 static CORE_ADDR
1195 mips_linux_syscall_next_pc (struct frame_info *frame)
1196 {
1197   CORE_ADDR pc = get_frame_pc (frame);
1198   ULONGEST v0 = get_frame_register_unsigned (frame, MIPS_V0_REGNUM);
1199
1200   /* If we are about to make a sigreturn syscall, use the unwinder to
1201      decode the signal frame.  */
1202   if (v0 == MIPS_NR_sigreturn
1203       || v0 == MIPS_NR_rt_sigreturn
1204       || v0 == MIPS_NR_N64_rt_sigreturn
1205       || v0 == MIPS_NR_N32_rt_sigreturn)
1206     return frame_unwind_caller_pc (get_current_frame ());
1207
1208   return pc + 4;
1209 }
1210
1211 /* Return the current system call's number present in the
1212    v0 register.  When the function fails, it returns -1.  */
1213
1214 static LONGEST
1215 mips_linux_get_syscall_number (struct gdbarch *gdbarch,
1216                                ptid_t ptid)
1217 {
1218   struct regcache *regcache = get_thread_regcache (ptid);
1219   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1220   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1221   int regsize = register_size (gdbarch, MIPS_V0_REGNUM);
1222   /* The content of a register */
1223   gdb_byte buf[8];
1224   /* The result */
1225   LONGEST ret;
1226
1227   /* Make sure we're in a known ABI */
1228   gdb_assert (tdep->mips_abi == MIPS_ABI_O32
1229               || tdep->mips_abi == MIPS_ABI_N32
1230               || tdep->mips_abi == MIPS_ABI_N64);
1231
1232   gdb_assert (regsize <= sizeof (buf));
1233
1234   /* Getting the system call number from the register.
1235      syscall number is in v0 or $2.  */
1236   regcache_cooked_read (regcache, MIPS_V0_REGNUM, buf);
1237
1238   ret = extract_signed_integer (buf, regsize, byte_order);
1239
1240   return ret;
1241 }
1242
1243 /* Initialize one of the GNU/Linux OS ABIs.  */
1244
1245 static void
1246 mips_linux_init_abi (struct gdbarch_info info,
1247                      struct gdbarch *gdbarch)
1248 {
1249   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1250   enum mips_abi abi = mips_abi (gdbarch);
1251   struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info;
1252
1253   linux_init_abi (info, gdbarch);
1254
1255   /* Get the syscall number from the arch's register.  */
1256   set_gdbarch_get_syscall_number (gdbarch, mips_linux_get_syscall_number);
1257
1258   switch (abi)
1259     {
1260       case MIPS_ABI_O32:
1261         set_gdbarch_get_longjmp_target (gdbarch,
1262                                         mips_linux_get_longjmp_target);
1263         set_solib_svr4_fetch_link_map_offsets
1264           (gdbarch, svr4_ilp32_fetch_link_map_offsets);
1265         tramp_frame_prepend_unwinder (gdbarch, &mips_linux_o32_sigframe);
1266         tramp_frame_prepend_unwinder (gdbarch, &mips_linux_o32_rt_sigframe);
1267         set_xml_syscall_file_name ("syscalls/mips-o32-linux.xml");
1268         break;
1269       case MIPS_ABI_N32:
1270         set_gdbarch_get_longjmp_target (gdbarch,
1271                                         mips_linux_get_longjmp_target);
1272         set_solib_svr4_fetch_link_map_offsets
1273           (gdbarch, svr4_ilp32_fetch_link_map_offsets);
1274         set_gdbarch_long_double_bit (gdbarch, 128);
1275         /* These floatformats should probably be renamed.  MIPS uses
1276            the same 128-bit IEEE floating point format that IA-64 uses,
1277            except that the quiet/signalling NaN bit is reversed (GDB
1278            does not distinguish between quiet and signalling NaNs).  */
1279         set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
1280         tramp_frame_prepend_unwinder (gdbarch, &mips_linux_n32_rt_sigframe);
1281         set_xml_syscall_file_name ("syscalls/mips-n32-linux.xml");
1282         break;
1283       case MIPS_ABI_N64:
1284         set_gdbarch_get_longjmp_target (gdbarch,
1285                                         mips64_linux_get_longjmp_target);
1286         set_solib_svr4_fetch_link_map_offsets
1287           (gdbarch, svr4_lp64_fetch_link_map_offsets);
1288         set_gdbarch_long_double_bit (gdbarch, 128);
1289         /* These floatformats should probably be renamed.  MIPS uses
1290            the same 128-bit IEEE floating point format that IA-64 uses,
1291            except that the quiet/signalling NaN bit is reversed (GDB
1292            does not distinguish between quiet and signalling NaNs).  */
1293         set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
1294         tramp_frame_prepend_unwinder (gdbarch, &mips_linux_n64_rt_sigframe);
1295         set_xml_syscall_file_name ("syscalls/mips-n64-linux.xml");
1296         break;
1297       default:
1298         break;
1299     }
1300
1301   set_gdbarch_skip_solib_resolver (gdbarch, mips_linux_skip_resolver);
1302
1303   set_gdbarch_software_single_step (gdbarch, mips_software_single_step);
1304
1305   /* Enable TLS support.  */
1306   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1307                                              svr4_fetch_objfile_link_map);
1308
1309   /* Initialize this lazily, to avoid an initialization order
1310      dependency on solib-svr4.c's _initialize routine.  */
1311   if (mips_svr4_so_ops.in_dynsym_resolve_code == NULL)
1312     {
1313       mips_svr4_so_ops = svr4_so_ops;
1314       mips_svr4_so_ops.in_dynsym_resolve_code
1315         = mips_linux_in_dynsym_resolve_code;
1316     }
1317   set_solib_ops (gdbarch, &mips_svr4_so_ops);
1318
1319   set_gdbarch_write_pc (gdbarch, mips_linux_write_pc);
1320
1321   set_gdbarch_core_read_description (gdbarch,
1322                                      mips_linux_core_read_description);
1323
1324   set_gdbarch_regset_from_core_section (gdbarch,
1325                                         mips_linux_regset_from_core_section);
1326
1327   tdep->syscall_next_pc = mips_linux_syscall_next_pc;
1328
1329   if (tdesc_data)
1330     {
1331       const struct tdesc_feature *feature;
1332
1333       /* If we have target-described registers, then we can safely
1334          reserve a number for MIPS_RESTART_REGNUM (whether it is
1335          described or not).  */
1336       gdb_assert (gdbarch_num_regs (gdbarch) <= MIPS_RESTART_REGNUM);
1337       set_gdbarch_num_regs (gdbarch, MIPS_RESTART_REGNUM + 1);
1338
1339       /* If it's present, then assign it to the reserved number.  */
1340       feature = tdesc_find_feature (info.target_desc,
1341                                     "org.gnu.gdb.mips.linux");
1342       if (feature != NULL)
1343         tdesc_numbered_register (feature, tdesc_data, MIPS_RESTART_REGNUM,
1344                                  "restart");
1345     }
1346 }
1347
1348 /* Provide a prototype to silence -Wmissing-prototypes.  */
1349 extern initialize_file_ftype _initialize_mips_linux_tdep;
1350
1351 void
1352 _initialize_mips_linux_tdep (void)
1353 {
1354   const struct bfd_arch_info *arch_info;
1355
1356   for (arch_info = bfd_lookup_arch (bfd_arch_mips, 0);
1357        arch_info != NULL;
1358        arch_info = arch_info->next)
1359     {
1360       gdbarch_register_osabi (bfd_arch_mips, arch_info->mach,
1361                               GDB_OSABI_LINUX,
1362                               mips_linux_init_abi);
1363     }
1364 }