[gdb, hurd] Repair build after "Convert struct target_ops to C++" changes
[external/binutils.git] / gdb / i386-gnu-nat.c
1 /* Low level interface to i386 running the GNU Hurd.
2
3    Copyright (C) 1992-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 this first, to pick up the <mach.h> 'thread_info' diversion.  */
21 #include "gnu-nat.h"
22
23 /* Mach/Hurd headers are not yet ready for C++ compilation.  */
24 extern "C"
25 {
26 #include <mach.h>
27 #include <mach_error.h>
28 #include <mach/message.h>
29 #include <mach/exception.h>
30 }
31
32 #include "defs.h"
33 #include "x86-nat.h"
34 #include "inferior.h"
35 #include "floatformat.h"
36 #include "regcache.h"
37
38 #include "i386-tdep.h"
39
40 #include "inf-child.h"
41 #include "i387-tdep.h"
42
43 /* Offset to the thread_state_t location where REG is stored.  */
44 #define REG_OFFSET(reg) offsetof (struct i386_thread_state, reg)
45
46 /* At REG_OFFSET[N] is the offset to the thread_state_t location where
47    the GDB register N is stored.  */
48 static int reg_offset[] =
49 {
50   REG_OFFSET (eax), REG_OFFSET (ecx), REG_OFFSET (edx), REG_OFFSET (ebx),
51   REG_OFFSET (uesp), REG_OFFSET (ebp), REG_OFFSET (esi), REG_OFFSET (edi),
52   REG_OFFSET (eip), REG_OFFSET (efl), REG_OFFSET (cs), REG_OFFSET (ss),
53   REG_OFFSET (ds), REG_OFFSET (es), REG_OFFSET (fs), REG_OFFSET (gs)
54 };
55
56 #define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum])
57
58 \f
59
60 /* The i386 GNU Hurd target.  */
61
62 #ifdef i386_DEBUG_STATE
63 using gnu_base_target = x86_nat_target<gnu_nat_target>;
64 #else
65 using gnu_base_target = gnu_nat_target;
66 #endif
67
68 struct i386_gnu_nat_target final : public gnu_base_target
69 {
70   void fetch_registers (struct regcache *, int) override;
71   void store_registers (struct regcache *, int) override;
72 };
73
74 static i386_gnu_nat_target the_i386_gnu_nat_target;
75
76 /* Get the whole floating-point state of THREAD and record the values
77    of the corresponding (pseudo) registers.  */
78
79 static void
80 fetch_fpregs (struct regcache *regcache, struct proc *thread)
81 {
82   mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
83   struct i386_float_state state;
84   kern_return_t err;
85
86   err = thread_get_state (thread->port, i386_FLOAT_STATE,
87                           (thread_state_t) &state, &count);
88   if (err)
89     {
90       warning (_("Couldn't fetch floating-point state from %s"),
91                proc_string (thread));
92       return;
93     }
94
95   if (!state.initialized)
96     {
97       /* The floating-point state isn't initialized.  */
98       i387_supply_fsave (regcache, -1, NULL);
99     }
100   else
101     {
102       /* Supply the floating-point registers.  */
103       i387_supply_fsave (regcache, -1, state.hw_state);
104     }
105 }
106
107 /* Fetch register REGNO, or all regs if REGNO is -1.  */
108 void
109 i386_gnu_nat_target::fetch_registers (struct regcache *regcache, int regno)
110 {
111   struct proc *thread;
112   ptid_t ptid = regcache->ptid ();
113
114   /* Make sure we know about new threads.  */
115   inf_update_procs (gnu_current_inf);
116
117   thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ());
118   if (!thread)
119     error (_("Can't fetch registers from thread %s: No such thread"),
120            target_pid_to_str (ptid));
121
122   if (regno < I386_NUM_GREGS || regno == -1)
123     {
124       thread_state_t state;
125
126       /* This does the dirty work for us.  */
127       state = proc_get_state (thread, 0);
128       if (!state)
129         {
130           warning (_("Couldn't fetch registers from %s"),
131                    proc_string (thread));
132           return;
133         }
134
135       if (regno == -1)
136         {
137           int i;
138
139           proc_debug (thread, "fetching all register");
140
141           for (i = 0; i < I386_NUM_GREGS; i++)
142             regcache->raw_supply (i, REG_ADDR (state, i));
143           thread->fetched_regs = ~0;
144         }
145       else
146         {
147           proc_debug (thread, "fetching register %s",
148                       gdbarch_register_name (regcache->arch (),
149                                              regno));
150
151           regcache->raw_supply (regno, REG_ADDR (state, regno));
152           thread->fetched_regs |= (1 << regno);
153         }
154     }
155
156   if (regno >= I386_NUM_GREGS || regno == -1)
157     {
158       proc_debug (thread, "fetching floating-point registers");
159
160       fetch_fpregs (regcache, thread);
161     }
162 }
163 \f
164
165 /* Store the whole floating-point state into THREAD using information
166    from the corresponding (pseudo) registers.  */
167 static void
168 store_fpregs (const struct regcache *regcache, struct proc *thread, int regno)
169 {
170   mach_msg_type_number_t count = i386_FLOAT_STATE_COUNT;
171   struct i386_float_state state;
172   kern_return_t err;
173
174   err = thread_get_state (thread->port, i386_FLOAT_STATE,
175                           (thread_state_t) &state, &count);
176   if (err)
177     {
178       warning (_("Couldn't fetch floating-point state from %s"),
179                proc_string (thread));
180       return;
181     }
182
183   /* FIXME: kettenis/2001-07-15: Is this right?  Should we somehow
184      take into account DEPRECATED_REGISTER_VALID like the old code did?  */
185   i387_collect_fsave (regcache, regno, state.hw_state);
186
187   err = thread_set_state (thread->port, i386_FLOAT_STATE,
188                           (thread_state_t) &state, i386_FLOAT_STATE_COUNT);
189   if (err)
190     {
191       warning (_("Couldn't store floating-point state into %s"),
192                proc_string (thread));
193       return;
194     }
195 }
196
197 /* Store at least register REGNO, or all regs if REGNO == -1.  */
198 void
199 i386_gnu_nat_target::store_registers (struct regcache *regcache, int regno)
200 {
201   struct proc *thread;
202   struct gdbarch *gdbarch = regcache->arch ();
203   ptid_t ptid = regcache->ptid ();
204
205   /* Make sure we know about new threads.  */
206   inf_update_procs (gnu_current_inf);
207
208   thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ());
209   if (!thread)
210     error (_("Couldn't store registers into thread %s: No such thread"),
211            target_pid_to_str (ptid));
212
213   if (regno < I386_NUM_GREGS || regno == -1)
214     {
215       thread_state_t state;
216       thread_state_data_t old_state;
217       int was_aborted = thread->aborted;
218       int was_valid = thread->state_valid;
219       int trace;
220
221       if (!was_aborted && was_valid)
222         memcpy (&old_state, &thread->state, sizeof (old_state));
223
224       state = proc_get_state (thread, 1);
225       if (!state)
226         {
227           warning (_("Couldn't store registers into %s"),
228                    proc_string (thread));
229           return;
230         }
231
232       /* Save the T bit.  We might try to restore the %eflags register
233          below, but changing the T bit would seriously confuse GDB.  */
234       trace = ((struct i386_thread_state *)state)->efl & 0x100;
235
236       if (!was_aborted && was_valid)
237         /* See which registers have changed after aborting the thread.  */
238         {
239           int check_regno;
240
241           for (check_regno = 0; check_regno < I386_NUM_GREGS; check_regno++)
242             if ((thread->fetched_regs & (1 << check_regno))
243                 && memcpy (REG_ADDR (&old_state, check_regno),
244                            REG_ADDR (state, check_regno),
245                            register_size (gdbarch, check_regno)))
246               /* Register CHECK_REGNO has changed!  Ack!  */
247               {
248                 warning (_("Register %s changed after the thread was aborted"),
249                          gdbarch_register_name (gdbarch, check_regno));
250                 if (regno >= 0 && regno != check_regno)
251                   /* Update GDB's copy of the register.  */
252                   regcache->raw_supply (check_regno,
253                                         REG_ADDR (state, check_regno));
254                 else
255                   warning (_("... also writing this register!  "
256                              "Suspicious..."));
257               }
258         }
259
260       if (regno == -1)
261         {
262           int i;
263
264           proc_debug (thread, "storing all registers");
265
266           for (i = 0; i < I386_NUM_GREGS; i++)
267             if (REG_VALID == regcache->get_register_status (i))
268               regcache->raw_collect (i, REG_ADDR (state, i));
269         }
270       else
271         {
272           proc_debug (thread, "storing register %s",
273                       gdbarch_register_name (gdbarch, regno));
274
275           gdb_assert (REG_VALID == regcache->get_register_status (regno));
276           regcache->raw_collect (regno, REG_ADDR (state, regno));
277         }
278
279       /* Restore the T bit.  */
280       ((struct i386_thread_state *)state)->efl &= ~0x100;
281       ((struct i386_thread_state *)state)->efl |= trace;
282     }
283
284   if (regno >= I386_NUM_GREGS || regno == -1)
285     {
286       proc_debug (thread, "storing floating-point registers");
287
288       store_fpregs (regcache, thread, regno);
289     }
290 }
291
292 \f
293 /* Support for debug registers.  */
294
295 #ifdef i386_DEBUG_STATE
296 /* Get debug registers for thread THREAD.  */
297
298 static void
299 i386_gnu_dr_get (struct i386_debug_state *regs, struct proc *thread)
300 {
301   mach_msg_type_number_t count = i386_DEBUG_STATE_COUNT;
302   kern_return_t err;
303
304   err = thread_get_state (thread->port, i386_DEBUG_STATE,
305                           (thread_state_t) regs, &count);
306   if (err != 0 || count != i386_DEBUG_STATE_COUNT)
307     warning (_("Couldn't fetch debug state from %s"),
308              proc_string (thread));
309 }
310
311 /* Set debug registers for thread THREAD.  */
312
313 static void
314 i386_gnu_dr_set (const struct i386_debug_state *regs, struct proc *thread)
315 {
316   kern_return_t err;
317
318   err = thread_set_state (thread->port, i386_DEBUG_STATE,
319                           (thread_state_t) regs, i386_DEBUG_STATE_COUNT);
320   if (err != 0)
321     warning (_("Couldn't store debug state into %s"),
322              proc_string (thread));
323 }
324
325 /* Set DR_CONTROL in THREAD.  */
326
327 static void
328 i386_gnu_dr_set_control_one (struct proc *thread, void *arg)
329 {
330   unsigned long *control = (unsigned long *) arg;
331   struct i386_debug_state regs;
332
333   i386_gnu_dr_get (&regs, thread);
334   regs.dr[DR_CONTROL] = *control;
335   i386_gnu_dr_set (&regs, thread);
336 }
337
338 /* Set DR_CONTROL to CONTROL in all threads.  */
339
340 static void
341 i386_gnu_dr_set_control (unsigned long control)
342 {
343   inf_update_procs (gnu_current_inf);
344   inf_threads (gnu_current_inf, i386_gnu_dr_set_control_one, &control);
345 }
346
347 /* Parameters to set a debugging address.  */
348
349 struct reg_addr
350 {
351   int regnum;           /* Register number (zero based).  */
352   CORE_ADDR addr;       /* Address.  */
353 };
354
355 /* Set address REGNUM (zero based) to ADDR in THREAD.  */
356
357 static void
358 i386_gnu_dr_set_addr_one (struct proc *thread, void *arg)
359 {
360   struct reg_addr *reg_addr = (struct reg_addr *) arg;
361   struct i386_debug_state regs;
362
363   i386_gnu_dr_get (&regs, thread);
364   regs.dr[reg_addr->regnum] = reg_addr->addr;
365   i386_gnu_dr_set (&regs, thread);
366 }
367
368 /* Set address REGNUM (zero based) to ADDR in all threads.  */
369
370 static void
371 i386_gnu_dr_set_addr (int regnum, CORE_ADDR addr)
372 {
373   struct reg_addr reg_addr;
374
375   gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
376
377   reg_addr.regnum = regnum;
378   reg_addr.addr = addr;
379
380   inf_update_procs (gnu_current_inf);
381   inf_threads (gnu_current_inf, i386_gnu_dr_set_addr_one, &reg_addr);
382 }
383
384 /* Get debug register REGNUM value from only the one LWP of PTID.  */
385
386 static unsigned long
387 i386_gnu_dr_get_reg (ptid_t ptid, int regnum)
388 {
389   struct i386_debug_state regs;
390   struct proc *thread;
391
392   /* Make sure we know about new threads.  */
393   inf_update_procs (gnu_current_inf);
394
395   thread = inf_tid_to_thread (gnu_current_inf, ptid.lwp ());
396   i386_gnu_dr_get (&regs, thread);
397
398   return regs.dr[regnum];
399 }
400
401 /* Return the inferior's debug register REGNUM.  */
402
403 static CORE_ADDR
404 i386_gnu_dr_get_addr (int regnum)
405 {
406   gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
407
408   return i386_gnu_dr_get_reg (inferior_ptid, regnum);
409 }
410
411 /* Get DR_STATUS from only the one thread of INFERIOR_PTID.  */
412
413 static unsigned long
414 i386_gnu_dr_get_status (void)
415 {
416   return i386_gnu_dr_get_reg (inferior_ptid, DR_STATUS);
417 }
418
419 /* Return the inferior's DR7 debug control register.  */
420
421 static unsigned long
422 i386_gnu_dr_get_control (void)
423 {
424   return i386_gnu_dr_get_reg (inferior_ptid, DR_CONTROL);
425 }
426 #endif /* i386_DEBUG_STATE */
427
428 void
429 _initialize_i386gnu_nat (void)
430 {
431 #ifdef i386_DEBUG_STATE
432   x86_dr_low.set_control = i386_gnu_dr_set_control;
433   gdb_assert (DR_FIRSTADDR == 0 && DR_LASTADDR < i386_DEBUG_STATE_COUNT);
434   x86_dr_low.set_addr = i386_gnu_dr_set_addr;
435   x86_dr_low.get_addr = i386_gnu_dr_get_addr;
436   x86_dr_low.get_status = i386_gnu_dr_get_status;
437   x86_dr_low.get_control = i386_gnu_dr_get_control;
438   x86_set_debug_register_length (4);
439 #endif /* i386_DEBUG_STATE */
440
441   /* Register the target.  */
442   add_inf_child_target (&the_i386_gnu_nat_target);
443 }