Automatic date update in version.in
[external/binutils.git] / gdb / xtensa-linux-nat.c
1 /* Xtensa GNU/Linux native support.
2
3    Copyright (C) 2007-2019 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 "frame.h"
22 #include "inferior.h"
23 #include "gdbcore.h"
24 #include "regcache.h"
25 #include "target.h"
26 #include "linux-nat.h"
27 #include <sys/types.h>
28 #include <signal.h>
29 #include <sys/user.h>
30 #include <sys/ioctl.h>
31 #include "common/gdb_wait.h"
32 #include <fcntl.h>
33 #include <sys/procfs.h>
34 #include "nat/gdb_ptrace.h"
35 #include <asm/ptrace.h>
36
37 #include "gregset.h"
38 #include "xtensa-tdep.h"
39
40 /* Defines ps_err_e, struct ps_prochandle.  */
41 #include "gdb_proc_service.h"
42
43 /* Extended register set depends on hardware configs.
44    Keeping these definitions separately allows to introduce
45    hardware-specific overlays.  */
46 #include "xtensa-xtregs.c"
47
48 class xtensa_linux_nat_target final : public linux_nat_target
49 {
50 public:
51   /* Add our register access methods.  */
52   void fetch_registers (struct regcache *, int) override;
53   void store_registers (struct regcache *, int) override;
54 };
55
56 static xtensa_linux_nat_target the_xtensa_linux_nat_target;
57
58 void
59 fill_gregset (const struct regcache *regcache,
60               gdb_gregset_t *gregsetp, int regnum)
61 {
62   int i;
63   xtensa_elf_gregset_t *regs = (xtensa_elf_gregset_t *) gregsetp;
64   struct gdbarch *gdbarch = regcache->arch ();
65
66   if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == -1)
67     regcache->raw_collect (gdbarch_pc_regnum (gdbarch), &regs->pc);
68   if (regnum == gdbarch_ps_regnum (gdbarch) || regnum == -1)
69     regcache->raw_collect (gdbarch_ps_regnum (gdbarch), &regs->ps);
70
71   if (regnum == gdbarch_tdep (gdbarch)->wb_regnum || regnum == -1)
72     regcache->raw_collect (gdbarch_tdep (gdbarch)->wb_regnum,
73                            &regs->windowbase);
74   if (regnum == gdbarch_tdep (gdbarch)->ws_regnum || regnum == -1)
75     regcache->raw_collect (gdbarch_tdep (gdbarch)->ws_regnum,
76                            &regs->windowstart);
77   if (regnum == gdbarch_tdep (gdbarch)->lbeg_regnum || regnum == -1)
78     regcache->raw_collect (gdbarch_tdep (gdbarch)->lbeg_regnum,
79                            &regs->lbeg);
80   if (regnum == gdbarch_tdep (gdbarch)->lend_regnum || regnum == -1)
81     regcache->raw_collect (gdbarch_tdep (gdbarch)->lend_regnum,
82                            &regs->lend);
83   if (regnum == gdbarch_tdep (gdbarch)->lcount_regnum || regnum == -1)
84     regcache->raw_collect (gdbarch_tdep (gdbarch)->lcount_regnum,
85                            &regs->lcount);
86   if (regnum == gdbarch_tdep (gdbarch)->sar_regnum || regnum == -1)
87     regcache->raw_collect (gdbarch_tdep (gdbarch)->sar_regnum,
88                            &regs->sar);
89   if (regnum == gdbarch_tdep (gdbarch)->threadptr_regnum || regnum == -1)
90     regcache->raw_collect (gdbarch_tdep (gdbarch)->threadptr_regnum,
91                            &regs->threadptr);
92   if (regnum >=gdbarch_tdep (gdbarch)->ar_base
93       && regnum < gdbarch_tdep (gdbarch)->ar_base
94                     + gdbarch_tdep (gdbarch)->num_aregs)
95     regcache->raw_collect (regnum,
96                            &regs->ar[regnum - gdbarch_tdep (gdbarch)->ar_base]);
97   else if (regnum == -1)
98     {
99       for (i = 0; i < gdbarch_tdep (gdbarch)->num_aregs; ++i)
100         regcache->raw_collect (gdbarch_tdep (gdbarch)->ar_base + i,
101                                &regs->ar[i]);
102     }
103   if (regnum >= gdbarch_tdep (gdbarch)->a0_base
104       && regnum < gdbarch_tdep (gdbarch)->a0_base + C0_NREGS)
105     regcache->raw_collect (regnum,
106                            &regs->ar[(4 * regs->windowbase + regnum
107                                       - gdbarch_tdep (gdbarch)->a0_base)
108                           % gdbarch_tdep (gdbarch)->num_aregs]);
109   else if (regnum == -1)
110     {
111       for (i = 0; i < C0_NREGS; ++i)
112         regcache->raw_collect (gdbarch_tdep (gdbarch)->a0_base + i,
113                                (&regs->ar[(4 * regs->windowbase + i)
114                                 % gdbarch_tdep (gdbarch)->num_aregs]));
115     }
116 }
117
118 static void
119 supply_gregset_reg (struct regcache *regcache,
120                     const gdb_gregset_t *gregsetp, int regnum)
121 {
122   int i;
123   xtensa_elf_gregset_t *regs = (xtensa_elf_gregset_t *) gregsetp;
124
125   struct gdbarch *gdbarch = regcache->arch ();
126
127   if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == -1)
128     regcache->raw_supply (gdbarch_pc_regnum (gdbarch), &regs->pc);
129   if (regnum == gdbarch_ps_regnum (gdbarch) || regnum == -1)
130     regcache->raw_supply (gdbarch_ps_regnum (gdbarch), &regs->ps);
131
132   if (regnum == gdbarch_tdep (gdbarch)->wb_regnum || regnum == -1)
133     regcache->raw_supply (gdbarch_tdep (gdbarch)->wb_regnum,
134                           &regs->windowbase);
135   if (regnum == gdbarch_tdep (gdbarch)->ws_regnum || regnum == -1)
136     regcache->raw_supply (gdbarch_tdep (gdbarch)->ws_regnum,
137                           &regs->windowstart);
138   if (regnum == gdbarch_tdep (gdbarch)->lbeg_regnum || regnum == -1)
139     regcache->raw_supply (gdbarch_tdep (gdbarch)->lbeg_regnum,
140                           &regs->lbeg);
141   if (regnum == gdbarch_tdep (gdbarch)->lend_regnum || regnum == -1)
142     regcache->raw_supply (gdbarch_tdep (gdbarch)->lend_regnum,
143                           &regs->lend);
144   if (regnum == gdbarch_tdep (gdbarch)->lcount_regnum || regnum == -1)
145     regcache->raw_supply (gdbarch_tdep (gdbarch)->lcount_regnum,
146                           &regs->lcount);
147   if (regnum == gdbarch_tdep (gdbarch)->sar_regnum || regnum == -1)
148     regcache->raw_supply (gdbarch_tdep (gdbarch)->sar_regnum,
149                           &regs->sar);
150   if (regnum == gdbarch_tdep (gdbarch)->threadptr_regnum || regnum == -1)
151     regcache->raw_supply (gdbarch_tdep (gdbarch)->threadptr_regnum,
152                           &regs->threadptr);
153   if (regnum >=gdbarch_tdep (gdbarch)->ar_base
154       && regnum < gdbarch_tdep (gdbarch)->ar_base
155                     + gdbarch_tdep (gdbarch)->num_aregs)
156     regcache->raw_supply (regnum,
157                           &regs->ar[regnum - gdbarch_tdep (gdbarch)->ar_base]);
158   else if (regnum == -1)
159     {
160       for (i = 0; i < gdbarch_tdep (gdbarch)->num_aregs; ++i)
161         regcache->raw_supply (gdbarch_tdep (gdbarch)->ar_base + i,
162                               &regs->ar[i]);
163     }
164   if (regnum >= gdbarch_tdep (gdbarch)->a0_base
165       && regnum < gdbarch_tdep (gdbarch)->a0_base + C0_NREGS)
166     regcache->raw_supply (regnum,
167                           &regs->ar[(4 * regs->windowbase + regnum
168                                      - gdbarch_tdep (gdbarch)->a0_base)
169                          % gdbarch_tdep (gdbarch)->num_aregs]);
170   else if (regnum == -1)
171     {
172       for (i = 0; i < C0_NREGS; ++i)
173         regcache->raw_supply (gdbarch_tdep (gdbarch)->a0_base + i,
174                               &regs->ar[(4 * regs->windowbase + i)
175                                         % gdbarch_tdep (gdbarch)->num_aregs]);
176     }
177 }
178
179 void
180 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
181 {
182   supply_gregset_reg (regcache, gregsetp, -1);
183 }
184
185 void
186 fill_fpregset (const struct regcache *regcache,
187                gdb_fpregset_t *fpregsetp, int regnum)
188 {
189   return;
190 }
191
192 void 
193 supply_fpregset (struct regcache *regcache,
194                  const gdb_fpregset_t *fpregsetp)
195 {
196   return;
197 }
198
199 /* Fetch greg-register(s) from process/thread TID
200    and store value(s) in GDB's register array.  */
201
202 static void
203 fetch_gregs (struct regcache *regcache, int regnum)
204 {
205   int tid = regcache->ptid ().lwp ();
206   gdb_gregset_t regs;
207   int areg;
208   
209   if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
210     {
211       perror_with_name (_("Couldn't get registers"));
212       return;
213     }
214  
215   supply_gregset_reg (regcache, &regs, regnum);
216 }
217
218 /* Store greg-register(s) in GDB's register 
219    array into the process/thread specified by TID.  */
220
221 static void
222 store_gregs (struct regcache *regcache, int regnum)
223 {
224   int tid = regcache->ptid ().lwp ();
225   gdb_gregset_t regs;
226   int areg;
227
228   if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
229     {
230       perror_with_name (_("Couldn't get registers"));
231       return;
232     }
233
234   fill_gregset (regcache, &regs, regnum);
235
236   if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
237     {
238       perror_with_name (_("Couldn't write registers"));
239       return;
240     }
241 }
242
243 static int xtreg_lo;
244 static int xtreg_high;
245
246 /* Fetch/Store Xtensa TIE registers.  Xtensa GNU/Linux PTRACE
247    interface provides special requests for this.  */
248
249 static void
250 fetch_xtregs (struct regcache *regcache, int regnum)
251 {
252   int tid = regcache->ptid ().lwp ();
253   const xtensa_regtable_t *ptr;
254   char xtregs [XTENSA_ELF_XTREG_SIZE];
255
256   if (ptrace (PTRACE_GETXTREGS, tid, 0, (long)&xtregs) < 0)
257     perror_with_name (_("Couldn't get extended registers"));
258
259   for (ptr = xtensa_regmap_table; ptr->name; ptr++)
260     if (regnum == ptr->gdb_regnum || regnum == -1)
261       regcache->raw_supply (ptr->gdb_regnum, xtregs + ptr->ptrace_offset);
262 }
263
264 static void
265 store_xtregs (struct regcache *regcache, int regnum)
266 {
267   int tid = regcache->ptid ().lwp ();
268   const xtensa_regtable_t *ptr;
269   char xtregs [XTENSA_ELF_XTREG_SIZE];
270
271   if (ptrace (PTRACE_GETXTREGS, tid, 0, (long)&xtregs) < 0)
272     perror_with_name (_("Couldn't get extended registers"));
273
274   for (ptr = xtensa_regmap_table; ptr->name; ptr++)
275     if (regnum == ptr->gdb_regnum || regnum == -1)
276       regcache->raw_collect (ptr->gdb_regnum, xtregs + ptr->ptrace_offset);
277
278   if (ptrace (PTRACE_SETXTREGS, tid, 0, (long)&xtregs) < 0)
279     perror_with_name (_("Couldn't write extended registers"));
280 }
281
282 void
283 xtensa_linux_nat_target::fetch_registers (struct regcache *regcache,
284                                           int regnum)
285 {
286   if (regnum == -1)
287     {
288       fetch_gregs (regcache, regnum);
289       fetch_xtregs (regcache, regnum);
290     }
291   else if ((regnum < xtreg_lo) || (regnum > xtreg_high))
292     fetch_gregs (regcache, regnum);
293   else
294     fetch_xtregs (regcache, regnum);
295 }
296
297 void
298 xtensa_linux_nat_target::store_registers (struct regcache *regcache,
299                                           int regnum)
300 {
301   if (regnum == -1)
302     {
303       store_gregs (regcache, regnum);
304       store_xtregs (regcache, regnum);
305     }
306   else if ((regnum < xtreg_lo) || (regnum > xtreg_high))
307     store_gregs (regcache, regnum);
308   else
309     store_xtregs (regcache, regnum);
310 }
311
312 /* Called by libthread_db.  */
313
314 ps_err_e
315 ps_get_thread_area (struct ps_prochandle *ph,
316                     lwpid_t lwpid, int idx, void **base)
317 {
318   xtensa_elf_gregset_t regs;
319
320   if (ptrace (PTRACE_GETREGS, lwpid, NULL, &regs) != 0)
321     return PS_ERR;
322
323   /* IDX is the bias from the thread pointer to the beginning of the
324      thread descriptor.  It has to be subtracted due to implementation
325      quirks in libthread_db.  */
326   *base = (void *) ((char *) regs.threadptr - idx);
327
328   return PS_OK;
329 }
330
331 void
332 _initialize_xtensa_linux_nat (void)
333 {
334   const xtensa_regtable_t *ptr;
335
336   /* Calculate the number range for extended registers.  */
337   xtreg_lo = 1000000000;
338   xtreg_high = -1;
339   for (ptr = xtensa_regmap_table; ptr->name; ptr++)
340     {
341       if (ptr->gdb_regnum < xtreg_lo)
342         xtreg_lo = ptr->gdb_regnum;
343       if (ptr->gdb_regnum > xtreg_high)
344         xtreg_high = ptr->gdb_regnum;
345     }
346
347   linux_target = &the_xtensa_linux_nat_target;
348   add_inf_child_target (&the_xtensa_linux_nat_target);
349 }