Automatic date update in version.in
[external/binutils.git] / gdb / i386-sol2-nat.c
1 /* Native-dependent code for Solaris x86.
2
3    Copyright (C) 1988-2018 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 "regcache.h"
22
23 #include <sys/reg.h>
24 #include <sys/procfs.h>
25 #include "gregset.h"
26 #include "target.h"
27 #include "procfs.h"
28
29 /* This file provids the (temporary) glue between the Solaris x86
30    target dependent code and the machine independent SVR4 /proc
31    support.  */
32
33 /* Solaris 10 (Solaris 2.10, SunOS 5.10) and up support two process
34    data models, the traditional 32-bit data model (ILP32) and the
35    64-bit data model (LP64).  The format of /proc depends on the data
36    model of the observer (the controlling process, GDB in our case).
37    The Solaris header files conveniently define PR_MODEL_NATIVE to the
38    data model of the controlling process.  If its value is
39    PR_MODEL_LP64, we know that GDB is being compiled as a 64-bit
40    program.
41
42    Note that a 32-bit GDB won't be able to debug a 64-bit target
43    process using /proc on Solaris.  */
44
45 #if PR_MODEL_NATIVE == PR_MODEL_LP64
46
47 #include "amd64-nat.h"
48 #include "amd64-tdep.h"
49
50 /* Mapping between the general-purpose registers in gregset_t format
51    and GDB's register cache layout.  */
52
53 /* From <sys/regset.h>.  */
54 static int amd64_sol2_gregset64_reg_offset[] = {
55   14 * 8,                       /* %rax */
56   11 * 8,                       /* %rbx */
57   13 * 8,                       /* %rcx */
58   12 * 8,                       /* %rdx */
59   9 * 8,                        /* %rsi */
60   8 * 8,                        /* %rdi */
61   10 * 8,                       /* %rbp */
62   20 * 8,                       /* %rsp */
63   7 * 8,                        /* %r8 ...  */
64   6 * 8,
65   5 * 8,
66   4 * 8,
67   3 * 8,
68   2 * 8,
69   1 * 8,
70   0 * 8,                        /* ... %r15 */
71   17 * 8,                       /* %rip */
72   19 * 8,                       /* %eflags */
73   18 * 8,                       /* %cs */
74   21 * 8,                       /* %ss */
75   25 * 8,                       /* %ds */
76   24 * 8,                       /* %es */
77   22 * 8,                       /* %fs */
78   23 * 8                        /* %gs */
79 };
80
81 /* 32-bit registers are provided by Solaris in 64-bit format, so just
82    give a subset of the list above.  */
83 static int amd64_sol2_gregset32_reg_offset[] = {
84   14 * 8,                       /* %eax */
85   13 * 8,                       /* %ecx */
86   12 * 8,                       /* %edx */
87   11 * 8,                       /* %ebx */
88   20 * 8,                       /* %esp */
89   10 * 8,                       /* %ebp */
90   9 * 8,                        /* %esi */
91   8 * 8,                        /* %edi */
92   17 * 8,                       /* %eip */
93   19 * 8,                       /* %eflags */
94   18 * 8,                       /* %cs */
95   21 * 8,                       /* %ss */
96   25 * 8,                       /* %ds */
97   24 * 8,                       /* %es */
98   22 * 8,                       /* %fs */
99   23 * 8                        /* %gs */
100 };
101
102 void
103 supply_gregset (struct regcache *regcache, const prgregset_t *gregs)
104 {
105   amd64_supply_native_gregset (regcache, gregs, -1);
106 }
107
108 void
109 supply_fpregset (struct regcache *regcache, const prfpregset_t *fpregs)
110 {
111   amd64_supply_fxsave (regcache, -1, fpregs);
112 }
113
114 void
115 fill_gregset (const struct regcache *regcache,
116               prgregset_t *gregs, int regnum)
117 {
118   amd64_collect_native_gregset (regcache, gregs, regnum);
119 }
120
121 void
122 fill_fpregset (const struct regcache *regcache,
123                prfpregset_t *fpregs, int regnum)
124 {
125   amd64_collect_fxsave (regcache, regnum, fpregs);
126 }
127
128 #else /* PR_MODEL_NATIVE != PR_MODEL_LP64 */
129
130 #include "i386-tdep.h"
131 #include "i387-tdep.h"
132
133 /* The `/proc' interface divides the target machine's register set up
134    into two different sets, the general purpose register set (gregset)
135    and the floating-point register set (fpregset).
136
137    The actual structure is, of course, naturally machine dependent, and is
138    different for each set of registers.  For the i386 for example, the
139    general-purpose register set is typically defined by:
140
141    typedef int gregset_t[19];           (in <sys/regset.h>)
142
143    #define GS   0                       (in <sys/reg.h>)
144    #define FS   1
145    ...
146    #define UESP 17
147    #define SS   18
148
149    and the floating-point set by:
150
151    typedef struct fpregset   {
152            union {
153                    struct fpchip_state            // fp extension state //
154                    {
155                            int     state[27];     // 287/387 saved state //
156                            int     status;        // status word saved at //
157                                                   // exception //
158                    } fpchip_state;
159                    struct fp_emul_space           // for emulators //
160                    {
161                            char    fp_emul[246];
162                            char    fp_epad[2];
163                    } fp_emul_space;
164                    int     f_fpregs[62];          // union of the above //
165            } fp_reg_set;
166            long            f_wregs[33];           // saved weitek state //
167    } fpregset_t;
168
169    Incidentally fpchip_state contains the FPU state in the same format
170    as used by the "fsave" instruction, and that's the only thing we
171    support here.  I don't know how the emulator stores it state.  The
172    Weitek stuff definitely isn't supported.
173
174    The routines defined here, provide the packing and unpacking of
175    gregset_t and fpregset_t formatted data.  */
176
177 /* Mapping between the general-purpose registers in `/proc'
178    format and GDB's register array layout.  */
179 static int regmap[] =
180 {
181   EAX, ECX, EDX, EBX,
182   UESP, EBP, ESI, EDI,
183   EIP, EFL, CS, SS,
184   DS, ES, FS, GS
185 };
186
187 /* Fill GDB's register array with the general-purpose register values
188    in *GREGSETP.  */
189
190 void
191 supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
192 {
193   const greg_t *regp = (const greg_t *) gregsetp;
194   int regnum;
195
196   for (regnum = 0; regnum < I386_NUM_GREGS; regnum++)
197     regcache->raw_supply (regnum, regp + regmap[regnum]);
198 }
199
200 /* Fill register REGNUM (if it is a general-purpose register) in
201    *GREGSETPS with the value in GDB's register array.  If REGNUM is -1,
202    do this for all registers.  */
203
204 void
205 fill_gregset (const struct regcache *regcache,
206               gregset_t *gregsetp, int regnum)
207 {
208   greg_t *regp = (greg_t *) gregsetp;
209   int i;
210
211   for (i = 0; i < I386_NUM_GREGS; i++)
212     if (regnum == -1 || regnum == i)
213       regcache->raw_collect (i, regp + regmap[i]);
214 }
215
216 /* Fill GDB's register array with the floating-point register values in
217    *FPREGSETP.  */
218
219 void
220 supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
221 {
222   if (gdbarch_fp0_regnum (regcache->arch ()) == 0)
223     return;
224
225   i387_supply_fsave (regcache, -1, fpregsetp);
226 }
227
228 /* Fill register REGNO (if it is a floating-point register) in
229    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
230    do this for all registers.  */
231
232 void
233 fill_fpregset (const struct regcache *regcache,
234                fpregset_t *fpregsetp, int regno)
235 {
236   if (gdbarch_fp0_regnum (regcache->arch ()) == 0)
237     return;
238
239   i387_collect_fsave (regcache, regno, fpregsetp);
240 }
241
242 #endif
243
244 void
245 _initialize_amd64_sol2_nat (void)
246 {
247 #if PR_MODEL_NATIVE == PR_MODEL_LP64
248   amd64_native_gregset32_reg_offset = amd64_sol2_gregset32_reg_offset;
249   amd64_native_gregset32_num_regs =
250     ARRAY_SIZE (amd64_sol2_gregset32_reg_offset);
251   amd64_native_gregset64_reg_offset = amd64_sol2_gregset64_reg_offset;
252   amd64_native_gregset64_num_regs =
253     ARRAY_SIZE (amd64_sol2_gregset64_reg_offset);
254 #endif
255 }