Commit | Line | Data |
---|---|---|
871fbe6a | 1 | /* Target-dependent code for GNU/Linux i386. |
ca557f44 | 2 | |
61baf725 | 3 | Copyright (C) 2000-2017 Free Software Foundation, Inc. |
e7ee86a9 JB |
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 | |
a9762ec7 | 9 | the Free Software Foundation; either version 3 of the License, or |
e7ee86a9 JB |
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 | |
a9762ec7 | 18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
e7ee86a9 JB |
19 | |
20 | #include "defs.h" | |
21 | #include "gdbcore.h" | |
22 | #include "frame.h" | |
23 | #include "value.h" | |
4e052eda | 24 | #include "regcache.h" |
c131fcee | 25 | #include "regset.h" |
6441c4a0 | 26 | #include "inferior.h" |
0670c0aa | 27 | #include "osabi.h" |
38c968cf | 28 | #include "reggroups.h" |
5cb2fe25 | 29 | #include "dwarf2-frame.h" |
8201327c MK |
30 | #include "i386-tdep.h" |
31 | #include "i386-linux-tdep.h" | |
4aa995e1 | 32 | #include "linux-tdep.h" |
012b3a21 | 33 | #include "utils.h" |
0670c0aa | 34 | #include "glibc-tdep.h" |
871fbe6a | 35 | #include "solib-svr4.h" |
982e9687 | 36 | #include "symtab.h" |
237fc4c9 | 37 | #include "arch-utils.h" |
a96d9b2e SDJ |
38 | #include "xml-syscall.h" |
39 | ||
c131fcee | 40 | #include "i387-tdep.h" |
df7e5265 | 41 | #include "x86-xstate.h" |
c131fcee | 42 | |
a96d9b2e SDJ |
43 | /* The syscall's XML filename for i386. */ |
44 | #define XML_SYSCALL_FILENAME_I386 "syscalls/i386-linux.xml" | |
17ea7499 | 45 | |
d02ed0bb | 46 | #include "record-full.h" |
77fcef51 | 47 | #include "linux-record.h" |
ea03d0d3 YQ |
48 | |
49 | #include "features/i386/32bit-core.c" | |
50 | #include "features/i386/32bit-sse.c" | |
51 | #include "features/i386/32bit-linux.c" | |
52 | #include "features/i386/32bit-avx.c" | |
53 | #include "features/i386/32bit-mpx.c" | |
54 | #include "features/i386/32bit-avx512.c" | |
55 | #include "features/i386/32bit-pkeys.c" | |
f49ff000 | 56 | #include "target-descriptions.h" |
90884b2b | 57 | |
38c968cf AC |
58 | /* Return non-zero, when the register is in the corresponding register |
59 | group. Put the LINUX_ORIG_EAX register in the system group. */ | |
60 | static int | |
61 | i386_linux_register_reggroup_p (struct gdbarch *gdbarch, int regnum, | |
62 | struct reggroup *group) | |
63 | { | |
64 | if (regnum == I386_LINUX_ORIG_EAX_REGNUM) | |
65 | return (group == system_reggroup | |
66 | || group == save_reggroup | |
67 | || group == restore_reggroup); | |
68 | return i386_register_reggroup_p (gdbarch, regnum, group); | |
69 | } | |
70 | ||
e7ee86a9 JB |
71 | \f |
72 | /* Recognizing signal handler frames. */ | |
73 | ||
ca557f44 | 74 | /* GNU/Linux has two flavors of signals. Normal signal handlers, and |
e7ee86a9 JB |
75 | "realtime" (RT) signals. The RT signals can provide additional |
76 | information to the signal handler if the SA_SIGINFO flag is set | |
77 | when establishing a signal handler using `sigaction'. It is not | |
ca557f44 AC |
78 | unlikely that future versions of GNU/Linux will support SA_SIGINFO |
79 | for normal signals too. */ | |
e7ee86a9 JB |
80 | |
81 | /* When the i386 Linux kernel calls a signal handler and the | |
82 | SA_RESTORER flag isn't set, the return address points to a bit of | |
83 | code on the stack. This function returns whether the PC appears to | |
84 | be within this bit of code. | |
85 | ||
86 | The instruction sequence for normal signals is | |
87 | pop %eax | |
acd5c798 | 88 | mov $0x77, %eax |
e7ee86a9 JB |
89 | int $0x80 |
90 | or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80. | |
91 | ||
92 | Checking for the code sequence should be somewhat reliable, because | |
93 | the effect is to call the system call sigreturn. This is unlikely | |
911bc6ee | 94 | to occur anywhere other than in a signal trampoline. |
e7ee86a9 JB |
95 | |
96 | It kind of sucks that we have to read memory from the process in | |
97 | order to identify a signal trampoline, but there doesn't seem to be | |
911bc6ee MK |
98 | any other way. Therefore we only do the memory reads if no |
99 | function name could be identified, which should be the case since | |
100 | the code is on the stack. | |
e7ee86a9 JB |
101 | |
102 | Detection of signal trampolines for handlers that set the | |
103 | SA_RESTORER flag is in general not possible. Unfortunately this is | |
104 | what the GNU C Library has been doing for quite some time now. | |
105 | However, as of version 2.1.2, the GNU C Library uses signal | |
106 | trampolines (named __restore and __restore_rt) that are identical | |
107 | to the ones used by the kernel. Therefore, these trampolines are | |
108 | supported too. */ | |
109 | ||
acd5c798 MK |
110 | #define LINUX_SIGTRAMP_INSN0 0x58 /* pop %eax */ |
111 | #define LINUX_SIGTRAMP_OFFSET0 0 | |
112 | #define LINUX_SIGTRAMP_INSN1 0xb8 /* mov $NNNN, %eax */ | |
113 | #define LINUX_SIGTRAMP_OFFSET1 1 | |
114 | #define LINUX_SIGTRAMP_INSN2 0xcd /* int */ | |
115 | #define LINUX_SIGTRAMP_OFFSET2 6 | |
e7ee86a9 | 116 | |
4252dc94 | 117 | static const gdb_byte linux_sigtramp_code[] = |
e7ee86a9 JB |
118 | { |
119 | LINUX_SIGTRAMP_INSN0, /* pop %eax */ | |
acd5c798 | 120 | LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00, /* mov $0x77, %eax */ |
e7ee86a9 JB |
121 | LINUX_SIGTRAMP_INSN2, 0x80 /* int $0x80 */ |
122 | }; | |
123 | ||
124 | #define LINUX_SIGTRAMP_LEN (sizeof linux_sigtramp_code) | |
125 | ||
10458914 DJ |
126 | /* If THIS_FRAME is a sigtramp routine, return the address of the |
127 | start of the routine. Otherwise, return 0. */ | |
e7ee86a9 JB |
128 | |
129 | static CORE_ADDR | |
10458914 | 130 | i386_linux_sigtramp_start (struct frame_info *this_frame) |
e7ee86a9 | 131 | { |
10458914 | 132 | CORE_ADDR pc = get_frame_pc (this_frame); |
4252dc94 | 133 | gdb_byte buf[LINUX_SIGTRAMP_LEN]; |
e7ee86a9 JB |
134 | |
135 | /* We only recognize a signal trampoline if PC is at the start of | |
136 | one of the three instructions. We optimize for finding the PC at | |
137 | the start, as will be the case when the trampoline is not the | |
138 | first frame on the stack. We assume that in the case where the | |
139 | PC is not at the start of the instruction sequence, there will be | |
140 | a few trailing readable bytes on the stack. */ | |
141 | ||
10458914 | 142 | if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN)) |
e7ee86a9 JB |
143 | return 0; |
144 | ||
145 | if (buf[0] != LINUX_SIGTRAMP_INSN0) | |
146 | { | |
147 | int adjust; | |
148 | ||
149 | switch (buf[0]) | |
150 | { | |
151 | case LINUX_SIGTRAMP_INSN1: | |
152 | adjust = LINUX_SIGTRAMP_OFFSET1; | |
153 | break; | |
154 | case LINUX_SIGTRAMP_INSN2: | |
155 | adjust = LINUX_SIGTRAMP_OFFSET2; | |
156 | break; | |
157 | default: | |
158 | return 0; | |
159 | } | |
160 | ||
161 | pc -= adjust; | |
162 | ||
10458914 | 163 | if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN)) |
e7ee86a9 JB |
164 | return 0; |
165 | } | |
166 | ||
167 | if (memcmp (buf, linux_sigtramp_code, LINUX_SIGTRAMP_LEN) != 0) | |
168 | return 0; | |
169 | ||
170 | return pc; | |
171 | } | |
172 | ||
173 | /* This function does the same for RT signals. Here the instruction | |
174 | sequence is | |
acd5c798 | 175 | mov $0xad, %eax |
e7ee86a9 JB |
176 | int $0x80 |
177 | or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80. | |
178 | ||
179 | The effect is to call the system call rt_sigreturn. */ | |
180 | ||
acd5c798 MK |
181 | #define LINUX_RT_SIGTRAMP_INSN0 0xb8 /* mov $NNNN, %eax */ |
182 | #define LINUX_RT_SIGTRAMP_OFFSET0 0 | |
183 | #define LINUX_RT_SIGTRAMP_INSN1 0xcd /* int */ | |
184 | #define LINUX_RT_SIGTRAMP_OFFSET1 5 | |
e7ee86a9 | 185 | |
4252dc94 | 186 | static const gdb_byte linux_rt_sigtramp_code[] = |
e7ee86a9 | 187 | { |
acd5c798 | 188 | LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00, /* mov $0xad, %eax */ |
e7ee86a9 JB |
189 | LINUX_RT_SIGTRAMP_INSN1, 0x80 /* int $0x80 */ |
190 | }; | |
191 | ||
192 | #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code) | |
193 | ||
10458914 DJ |
194 | /* If THIS_FRAME is an RT sigtramp routine, return the address of the |
195 | start of the routine. Otherwise, return 0. */ | |
e7ee86a9 JB |
196 | |
197 | static CORE_ADDR | |
10458914 | 198 | i386_linux_rt_sigtramp_start (struct frame_info *this_frame) |
e7ee86a9 | 199 | { |
10458914 | 200 | CORE_ADDR pc = get_frame_pc (this_frame); |
4252dc94 | 201 | gdb_byte buf[LINUX_RT_SIGTRAMP_LEN]; |
e7ee86a9 JB |
202 | |
203 | /* We only recognize a signal trampoline if PC is at the start of | |
204 | one of the two instructions. We optimize for finding the PC at | |
205 | the start, as will be the case when the trampoline is not the | |
206 | first frame on the stack. We assume that in the case where the | |
207 | PC is not at the start of the instruction sequence, there will be | |
208 | a few trailing readable bytes on the stack. */ | |
209 | ||
10458914 | 210 | if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_RT_SIGTRAMP_LEN)) |
e7ee86a9 JB |
211 | return 0; |
212 | ||
213 | if (buf[0] != LINUX_RT_SIGTRAMP_INSN0) | |
214 | { | |
215 | if (buf[0] != LINUX_RT_SIGTRAMP_INSN1) | |
216 | return 0; | |
217 | ||
218 | pc -= LINUX_RT_SIGTRAMP_OFFSET1; | |
219 | ||
10458914 | 220 | if (!safe_frame_unwind_memory (this_frame, pc, buf, |
8e6bed05 | 221 | LINUX_RT_SIGTRAMP_LEN)) |
e7ee86a9 JB |
222 | return 0; |
223 | } | |
224 | ||
225 | if (memcmp (buf, linux_rt_sigtramp_code, LINUX_RT_SIGTRAMP_LEN) != 0) | |
226 | return 0; | |
227 | ||
228 | return pc; | |
229 | } | |
230 | ||
10458914 DJ |
231 | /* Return whether THIS_FRAME corresponds to a GNU/Linux sigtramp |
232 | routine. */ | |
e7ee86a9 | 233 | |
8201327c | 234 | static int |
10458914 | 235 | i386_linux_sigtramp_p (struct frame_info *this_frame) |
e7ee86a9 | 236 | { |
10458914 | 237 | CORE_ADDR pc = get_frame_pc (this_frame); |
2c02bd72 | 238 | const char *name; |
911bc6ee MK |
239 | |
240 | find_pc_partial_function (pc, &name, NULL, NULL); | |
241 | ||
ef17e74b DJ |
242 | /* If we have NAME, we can optimize the search. The trampolines are |
243 | named __restore and __restore_rt. However, they aren't dynamically | |
244 | exported from the shared C library, so the trampoline may appear to | |
245 | be part of the preceding function. This should always be sigaction, | |
246 | __sigaction, or __libc_sigaction (all aliases to the same function). */ | |
247 | if (name == NULL || strstr (name, "sigaction") != NULL) | |
10458914 DJ |
248 | return (i386_linux_sigtramp_start (this_frame) != 0 |
249 | || i386_linux_rt_sigtramp_start (this_frame) != 0); | |
ef17e74b DJ |
250 | |
251 | return (strcmp ("__restore", name) == 0 | |
252 | || strcmp ("__restore_rt", name) == 0); | |
e7ee86a9 JB |
253 | } |
254 | ||
4a4e5149 DJ |
255 | /* Return one if the PC of THIS_FRAME is in a signal trampoline which |
256 | may have DWARF-2 CFI. */ | |
12b8a2cb DJ |
257 | |
258 | static int | |
259 | i386_linux_dwarf_signal_frame_p (struct gdbarch *gdbarch, | |
4a4e5149 | 260 | struct frame_info *this_frame) |
12b8a2cb | 261 | { |
4a4e5149 | 262 | CORE_ADDR pc = get_frame_pc (this_frame); |
2c02bd72 | 263 | const char *name; |
12b8a2cb DJ |
264 | |
265 | find_pc_partial_function (pc, &name, NULL, NULL); | |
266 | ||
267 | /* If a vsyscall DSO is in use, the signal trampolines may have these | |
268 | names. */ | |
269 | if (name && (strcmp (name, "__kernel_sigreturn") == 0 | |
270 | || strcmp (name, "__kernel_rt_sigreturn") == 0)) | |
271 | return 1; | |
272 | ||
273 | return 0; | |
274 | } | |
275 | ||
acd5c798 MK |
276 | /* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>. */ |
277 | #define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20 | |
278 | ||
10458914 DJ |
279 | /* Assuming THIS_FRAME is a GNU/Linux sigtramp routine, return the |
280 | address of the associated sigcontext structure. */ | |
e7ee86a9 | 281 | |
b7d15bf7 | 282 | static CORE_ADDR |
10458914 | 283 | i386_linux_sigcontext_addr (struct frame_info *this_frame) |
e7ee86a9 | 284 | { |
e17a4113 UW |
285 | struct gdbarch *gdbarch = get_frame_arch (this_frame); |
286 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
e7ee86a9 | 287 | CORE_ADDR pc; |
acd5c798 | 288 | CORE_ADDR sp; |
4252dc94 | 289 | gdb_byte buf[4]; |
acd5c798 | 290 | |
10458914 | 291 | get_frame_register (this_frame, I386_ESP_REGNUM, buf); |
e17a4113 | 292 | sp = extract_unsigned_integer (buf, 4, byte_order); |
e7ee86a9 | 293 | |
10458914 | 294 | pc = i386_linux_sigtramp_start (this_frame); |
e7ee86a9 JB |
295 | if (pc) |
296 | { | |
acd5c798 MK |
297 | /* The sigcontext structure lives on the stack, right after |
298 | the signum argument. We determine the address of the | |
299 | sigcontext structure by looking at the frame's stack | |
300 | pointer. Keep in mind that the first instruction of the | |
301 | sigtramp code is "pop %eax". If the PC is after this | |
302 | instruction, adjust the returned value accordingly. */ | |
10458914 | 303 | if (pc == get_frame_pc (this_frame)) |
e7ee86a9 JB |
304 | return sp + 4; |
305 | return sp; | |
306 | } | |
307 | ||
10458914 | 308 | pc = i386_linux_rt_sigtramp_start (this_frame); |
e7ee86a9 JB |
309 | if (pc) |
310 | { | |
acd5c798 MK |
311 | CORE_ADDR ucontext_addr; |
312 | ||
313 | /* The sigcontext structure is part of the user context. A | |
314 | pointer to the user context is passed as the third argument | |
315 | to the signal handler. */ | |
316 | read_memory (sp + 8, buf, 4); | |
e17a4113 | 317 | ucontext_addr = extract_unsigned_integer (buf, 4, byte_order); |
acd5c798 | 318 | return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET; |
e7ee86a9 JB |
319 | } |
320 | ||
8a3fe4f8 | 321 | error (_("Couldn't recognize signal trampoline.")); |
e7ee86a9 JB |
322 | return 0; |
323 | } | |
324 | ||
6441c4a0 MK |
325 | /* Set the program counter for process PTID to PC. */ |
326 | ||
8201327c | 327 | static void |
61a1198a | 328 | i386_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) |
6441c4a0 | 329 | { |
61a1198a | 330 | regcache_cooked_write_unsigned (regcache, I386_EIP_REGNUM, pc); |
6441c4a0 MK |
331 | |
332 | /* We must be careful with modifying the program counter. If we | |
333 | just interrupted a system call, the kernel might try to restart | |
334 | it when we resume the inferior. On restarting the system call, | |
335 | the kernel will try backing up the program counter even though it | |
336 | no longer points at the system call. This typically results in a | |
337 | SIGSEGV or SIGILL. We can prevent this by writing `-1' in the | |
338 | "orig_eax" pseudo-register. | |
339 | ||
340 | Note that "orig_eax" is saved when setting up a dummy call frame. | |
341 | This means that it is properly restored when that frame is | |
342 | popped, and that the interrupted system call will be restarted | |
343 | when we resume the inferior on return from a function call from | |
344 | within GDB. In all other cases the system call will not be | |
345 | restarted. */ | |
61a1198a | 346 | regcache_cooked_write_unsigned (regcache, I386_LINUX_ORIG_EAX_REGNUM, -1); |
6441c4a0 | 347 | } |
77fcef51 | 348 | |
8a2e0e28 HZ |
349 | /* Record all registers but IP register for process-record. */ |
350 | ||
351 | static int | |
352 | i386_all_but_ip_registers_record (struct regcache *regcache) | |
353 | { | |
25ea693b | 354 | if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM)) |
8a2e0e28 | 355 | return -1; |
25ea693b | 356 | if (record_full_arch_list_add_reg (regcache, I386_ECX_REGNUM)) |
8a2e0e28 | 357 | return -1; |
25ea693b | 358 | if (record_full_arch_list_add_reg (regcache, I386_EDX_REGNUM)) |
8a2e0e28 | 359 | return -1; |
25ea693b | 360 | if (record_full_arch_list_add_reg (regcache, I386_EBX_REGNUM)) |
8a2e0e28 | 361 | return -1; |
25ea693b | 362 | if (record_full_arch_list_add_reg (regcache, I386_ESP_REGNUM)) |
8a2e0e28 | 363 | return -1; |
25ea693b | 364 | if (record_full_arch_list_add_reg (regcache, I386_EBP_REGNUM)) |
8a2e0e28 | 365 | return -1; |
25ea693b | 366 | if (record_full_arch_list_add_reg (regcache, I386_ESI_REGNUM)) |
8a2e0e28 | 367 | return -1; |
25ea693b | 368 | if (record_full_arch_list_add_reg (regcache, I386_EDI_REGNUM)) |
8a2e0e28 | 369 | return -1; |
25ea693b | 370 | if (record_full_arch_list_add_reg (regcache, I386_EFLAGS_REGNUM)) |
8a2e0e28 HZ |
371 | return -1; |
372 | ||
373 | return 0; | |
374 | } | |
13b6d1d4 MS |
375 | |
376 | /* i386_canonicalize_syscall maps from the native i386 Linux set | |
377 | of syscall ids into a canonical set of syscall ids used by | |
378 | process record (a mostly trivial mapping, since the canonical | |
379 | set was originally taken from the i386 set). */ | |
380 | ||
381 | static enum gdb_syscall | |
382 | i386_canonicalize_syscall (int syscall) | |
383 | { | |
384 | enum { i386_syscall_max = 499 }; | |
385 | ||
386 | if (syscall <= i386_syscall_max) | |
aead7601 | 387 | return (enum gdb_syscall) syscall; |
13b6d1d4 | 388 | else |
f486487f | 389 | return gdb_sys_no_syscall; |
13b6d1d4 MS |
390 | } |
391 | ||
012b3a21 WT |
392 | /* Value of the sigcode in case of a boundary fault. */ |
393 | ||
394 | #define SIG_CODE_BONDARY_FAULT 3 | |
395 | ||
396 | /* i386 GNU/Linux implementation of the handle_segmentation_fault | |
397 | gdbarch hook. Displays information related to MPX bound | |
398 | violations. */ | |
399 | void | |
400 | i386_linux_handle_segmentation_fault (struct gdbarch *gdbarch, | |
401 | struct ui_out *uiout) | |
402 | { | |
166616ce SM |
403 | /* -Wmaybe-uninitialized */ |
404 | CORE_ADDR lower_bound = 0, upper_bound = 0, access = 0; | |
012b3a21 WT |
405 | int is_upper; |
406 | long sig_code = 0; | |
407 | ||
408 | if (!i386_mpx_enabled ()) | |
409 | return; | |
410 | ||
411 | TRY | |
412 | { | |
413 | /* Sigcode evaluates if the actual segfault is a boundary violation. */ | |
414 | sig_code = parse_and_eval_long ("$_siginfo.si_code\n"); | |
415 | ||
416 | lower_bound | |
417 | = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._lower"); | |
418 | upper_bound | |
419 | = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._upper"); | |
420 | access | |
421 | = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr"); | |
422 | } | |
423 | CATCH (exception, RETURN_MASK_ALL) | |
424 | { | |
425 | return; | |
426 | } | |
427 | END_CATCH | |
428 | ||
429 | /* If this is not a boundary violation just return. */ | |
430 | if (sig_code != SIG_CODE_BONDARY_FAULT) | |
431 | return; | |
432 | ||
433 | is_upper = (access > upper_bound ? 1 : 0); | |
434 | ||
112e8700 | 435 | uiout->text ("\n"); |
012b3a21 | 436 | if (is_upper) |
112e8700 | 437 | uiout->field_string ("sigcode-meaning", _("Upper bound violation")); |
012b3a21 | 438 | else |
112e8700 | 439 | uiout->field_string ("sigcode-meaning", _("Lower bound violation")); |
012b3a21 | 440 | |
112e8700 SM |
441 | uiout->text (_(" while accessing address ")); |
442 | uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, access)); | |
012b3a21 | 443 | |
112e8700 SM |
444 | uiout->text (_("\nBounds: [lower = ")); |
445 | uiout->field_fmt ("lower-bound", "%s", paddress (gdbarch, lower_bound)); | |
012b3a21 | 446 | |
112e8700 SM |
447 | uiout->text (_(", upper = ")); |
448 | uiout->field_fmt ("upper-bound", "%s", paddress (gdbarch, upper_bound)); | |
012b3a21 | 449 | |
112e8700 | 450 | uiout->text (_("]")); |
012b3a21 WT |
451 | } |
452 | ||
77fcef51 HZ |
453 | /* Parse the arguments of current system call instruction and record |
454 | the values of the registers and memory that will be changed into | |
455 | "record_arch_list". This instruction is "int 0x80" (Linux | |
456 | Kernel2.4) or "sysenter" (Linux Kernel 2.6). | |
457 | ||
458 | Return -1 if something wrong. */ | |
459 | ||
8a2e0e28 HZ |
460 | static struct linux_record_tdep i386_linux_record_tdep; |
461 | ||
77fcef51 | 462 | static int |
ffdf6de5 | 463 | i386_linux_intx80_sysenter_syscall_record (struct regcache *regcache) |
77fcef51 HZ |
464 | { |
465 | int ret; | |
13b6d1d4 MS |
466 | LONGEST syscall_native; |
467 | enum gdb_syscall syscall_gdb; | |
468 | ||
469 | regcache_raw_read_signed (regcache, I386_EAX_REGNUM, &syscall_native); | |
77fcef51 | 470 | |
13b6d1d4 | 471 | syscall_gdb = i386_canonicalize_syscall (syscall_native); |
2c543fc4 | 472 | |
13b6d1d4 | 473 | if (syscall_gdb < 0) |
2c543fc4 HZ |
474 | { |
475 | printf_unfiltered (_("Process record and replay target doesn't " | |
13b6d1d4 MS |
476 | "support syscall number %s\n"), |
477 | plongest (syscall_native)); | |
2c543fc4 HZ |
478 | return -1; |
479 | } | |
77fcef51 | 480 | |
8a2e0e28 HZ |
481 | if (syscall_gdb == gdb_sys_sigreturn |
482 | || syscall_gdb == gdb_sys_rt_sigreturn) | |
483 | { | |
484 | if (i386_all_but_ip_registers_record (regcache)) | |
485 | return -1; | |
486 | return 0; | |
487 | } | |
488 | ||
13b6d1d4 | 489 | ret = record_linux_system_call (syscall_gdb, regcache, |
77fcef51 HZ |
490 | &i386_linux_record_tdep); |
491 | if (ret) | |
492 | return ret; | |
493 | ||
494 | /* Record the return value of the system call. */ | |
25ea693b | 495 | if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM)) |
77fcef51 HZ |
496 | return -1; |
497 | ||
498 | return 0; | |
499 | } | |
8a2e0e28 HZ |
500 | |
501 | #define I386_LINUX_xstate 270 | |
502 | #define I386_LINUX_frame_size 732 | |
503 | ||
70221824 | 504 | static int |
8a2e0e28 HZ |
505 | i386_linux_record_signal (struct gdbarch *gdbarch, |
506 | struct regcache *regcache, | |
2ea28649 | 507 | enum gdb_signal signal) |
8a2e0e28 HZ |
508 | { |
509 | ULONGEST esp; | |
510 | ||
511 | if (i386_all_but_ip_registers_record (regcache)) | |
512 | return -1; | |
513 | ||
25ea693b | 514 | if (record_full_arch_list_add_reg (regcache, I386_EIP_REGNUM)) |
8a2e0e28 HZ |
515 | return -1; |
516 | ||
517 | /* Record the change in the stack. */ | |
518 | regcache_raw_read_unsigned (regcache, I386_ESP_REGNUM, &esp); | |
519 | /* This is for xstate. | |
520 | sp -= sizeof (struct _fpstate); */ | |
521 | esp -= I386_LINUX_xstate; | |
522 | /* This is for frame_size. | |
523 | sp -= sizeof (struct rt_sigframe); */ | |
524 | esp -= I386_LINUX_frame_size; | |
25ea693b MM |
525 | if (record_full_arch_list_add_mem (esp, |
526 | I386_LINUX_xstate + I386_LINUX_frame_size)) | |
8a2e0e28 HZ |
527 | return -1; |
528 | ||
25ea693b | 529 | if (record_full_arch_list_add_end ()) |
8a2e0e28 HZ |
530 | return -1; |
531 | ||
532 | return 0; | |
533 | } | |
6441c4a0 | 534 | \f |
8201327c | 535 | |
9a7f938f JK |
536 | /* Core of the implementation for gdbarch get_syscall_number. Get pending |
537 | syscall number from REGCACHE. If there is no pending syscall -1 will be | |
538 | returned. Pending syscall means ptrace has stepped into the syscall but | |
539 | another ptrace call will step out. PC is right after the int $0x80 | |
540 | / syscall / sysenter instruction in both cases, PC does not change during | |
541 | the second ptrace step. */ | |
542 | ||
a96d9b2e | 543 | static LONGEST |
9a7f938f | 544 | i386_linux_get_syscall_number_from_regcache (struct regcache *regcache) |
a96d9b2e | 545 | { |
9a7f938f | 546 | struct gdbarch *gdbarch = get_regcache_arch (regcache); |
a96d9b2e SDJ |
547 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); |
548 | /* The content of a register. */ | |
549 | gdb_byte buf[4]; | |
550 | /* The result. */ | |
551 | LONGEST ret; | |
552 | ||
553 | /* Getting the system call number from the register. | |
554 | When dealing with x86 architecture, this information | |
555 | is stored at %eax register. */ | |
556 | regcache_cooked_read (regcache, I386_LINUX_ORIG_EAX_REGNUM, buf); | |
557 | ||
558 | ret = extract_signed_integer (buf, 4, byte_order); | |
559 | ||
560 | return ret; | |
561 | } | |
562 | ||
9a7f938f JK |
563 | /* Wrapper for i386_linux_get_syscall_number_from_regcache to make it |
564 | compatible with gdbarch get_syscall_number method prototype. */ | |
565 | ||
566 | static LONGEST | |
567 | i386_linux_get_syscall_number (struct gdbarch *gdbarch, | |
568 | ptid_t ptid) | |
569 | { | |
570 | struct regcache *regcache = get_thread_regcache (ptid); | |
571 | ||
572 | return i386_linux_get_syscall_number_from_regcache (regcache); | |
573 | } | |
574 | ||
e9f1aad5 MK |
575 | /* The register sets used in GNU/Linux ELF core-dumps are identical to |
576 | the register sets in `struct user' that are used for a.out | |
577 | core-dumps. These are also used by ptrace(2). The corresponding | |
578 | types are `elf_gregset_t' for the general-purpose registers (with | |
579 | `elf_greg_t' the type of a single GP register) and `elf_fpregset_t' | |
580 | for the floating-point registers. | |
581 | ||
582 | Those types used to be available under the names `gregset_t' and | |
583 | `fpregset_t' too, and GDB used those names in the past. But those | |
584 | names are now used for the register sets used in the `mcontext_t' | |
585 | type, which have a different size and layout. */ | |
586 | ||
587 | /* Mapping between the general-purpose registers in `struct user' | |
588 | format and GDB's register cache layout. */ | |
589 | ||
590 | /* From <sys/reg.h>. */ | |
be0d2954 | 591 | int i386_linux_gregset_reg_offset[] = |
e9f1aad5 MK |
592 | { |
593 | 6 * 4, /* %eax */ | |
594 | 1 * 4, /* %ecx */ | |
595 | 2 * 4, /* %edx */ | |
596 | 0 * 4, /* %ebx */ | |
597 | 15 * 4, /* %esp */ | |
598 | 5 * 4, /* %ebp */ | |
599 | 3 * 4, /* %esi */ | |
600 | 4 * 4, /* %edi */ | |
601 | 12 * 4, /* %eip */ | |
602 | 14 * 4, /* %eflags */ | |
603 | 13 * 4, /* %cs */ | |
604 | 16 * 4, /* %ss */ | |
605 | 7 * 4, /* %ds */ | |
606 | 8 * 4, /* %es */ | |
607 | 9 * 4, /* %fs */ | |
608 | 10 * 4, /* %gs */ | |
609 | -1, -1, -1, -1, -1, -1, -1, -1, | |
610 | -1, -1, -1, -1, -1, -1, -1, -1, | |
611 | -1, -1, -1, -1, -1, -1, -1, -1, | |
612 | -1, | |
c131fcee | 613 | -1, -1, -1, -1, -1, -1, -1, -1, |
01f9f808 MS |
614 | -1, -1, -1, -1, /* MPX registers BND0 ... BND3. */ |
615 | -1, -1, /* MPX registers BNDCFGU, BNDSTATUS. */ | |
616 | -1, -1, -1, -1, -1, -1, -1, -1, /* k0 ... k7 (AVX512) */ | |
617 | -1, -1, -1, -1, -1, -1, -1, -1, /* zmm0 ... zmm7 (AVX512) */ | |
51547df6 | 618 | -1, /* PKRU register */ |
01f9f808 | 619 | 11 * 4, /* "orig_eax" */ |
e9f1aad5 MK |
620 | }; |
621 | ||
622 | /* Mapping between the general-purpose registers in `struct | |
623 | sigcontext' format and GDB's register cache layout. */ | |
624 | ||
a3386186 | 625 | /* From <asm/sigcontext.h>. */ |
bb489b3c | 626 | static int i386_linux_sc_reg_offset[] = |
a3386186 MK |
627 | { |
628 | 11 * 4, /* %eax */ | |
629 | 10 * 4, /* %ecx */ | |
630 | 9 * 4, /* %edx */ | |
631 | 8 * 4, /* %ebx */ | |
632 | 7 * 4, /* %esp */ | |
633 | 6 * 4, /* %ebp */ | |
634 | 5 * 4, /* %esi */ | |
635 | 4 * 4, /* %edi */ | |
636 | 14 * 4, /* %eip */ | |
637 | 16 * 4, /* %eflags */ | |
638 | 15 * 4, /* %cs */ | |
639 | 18 * 4, /* %ss */ | |
640 | 3 * 4, /* %ds */ | |
641 | 2 * 4, /* %es */ | |
642 | 1 * 4, /* %fs */ | |
643 | 0 * 4 /* %gs */ | |
644 | }; | |
645 | ||
c131fcee L |
646 | /* Get XSAVE extended state xcr0 from core dump. */ |
647 | ||
648 | uint64_t | |
6df81a63 | 649 | i386_linux_core_read_xcr0 (bfd *abfd) |
c131fcee L |
650 | { |
651 | asection *xstate = bfd_get_section_by_name (abfd, ".reg-xstate"); | |
652 | uint64_t xcr0; | |
653 | ||
654 | if (xstate) | |
655 | { | |
656 | size_t size = bfd_section_size (abfd, xstate); | |
657 | ||
658 | /* Check extended state size. */ | |
df7e5265 GB |
659 | if (size < X86_XSTATE_AVX_SIZE) |
660 | xcr0 = X86_XSTATE_SSE_MASK; | |
c131fcee L |
661 | else |
662 | { | |
663 | char contents[8]; | |
664 | ||
665 | if (! bfd_get_section_contents (abfd, xstate, contents, | |
666 | I386_LINUX_XSAVE_XCR0_OFFSET, | |
667 | 8)) | |
668 | { | |
1777feb0 MS |
669 | warning (_("Couldn't read `xcr0' bytes from " |
670 | "`.reg-xstate' section in core file.")); | |
c131fcee L |
671 | return 0; |
672 | } | |
673 | ||
674 | xcr0 = bfd_get_64 (abfd, contents); | |
675 | } | |
676 | } | |
677 | else | |
f335d1b3 | 678 | xcr0 = 0; |
c131fcee L |
679 | |
680 | return xcr0; | |
681 | } | |
682 | ||
35b4818d | 683 | /* See i386-linux-tdep.h. */ |
90884b2b | 684 | |
35b4818d YQ |
685 | const struct target_desc * |
686 | i386_linux_read_description (uint64_t xcr0) | |
90884b2b | 687 | { |
ea03d0d3 YQ |
688 | if (xcr0 == 0) |
689 | return NULL; | |
690 | ||
691 | static struct target_desc *i386_linux_tdescs \ | |
692 | [2/*X87*/][2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/] = {}; | |
693 | struct target_desc **tdesc; | |
694 | ||
695 | tdesc = &i386_linux_tdescs[(xcr0 & X86_XSTATE_X87) ? 1 : 0] | |
696 | [(xcr0 & X86_XSTATE_SSE) ? 1 : 0] | |
697 | [(xcr0 & X86_XSTATE_AVX) ? 1 : 0] | |
698 | [(xcr0 & X86_XSTATE_MPX) ? 1 : 0] | |
699 | [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0] | |
700 | [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]; | |
701 | ||
702 | if (*tdesc == NULL) | |
f335d1b3 | 703 | { |
ea03d0d3 YQ |
704 | *tdesc = allocate_target_description (); |
705 | set_tdesc_architecture (*tdesc, bfd_scan_arch ("i386")); | |
706 | set_tdesc_osabi (*tdesc, osabi_from_tdesc_string ("GNU/Linux")); | |
707 | ||
708 | long regnum = 0; | |
709 | ||
710 | if (xcr0 & X86_XSTATE_X87) | |
711 | regnum = create_feature_i386_32bit_core (*tdesc, regnum); | |
712 | ||
713 | if (xcr0 & X86_XSTATE_SSE) | |
714 | regnum = create_feature_i386_32bit_sse (*tdesc, regnum); | |
715 | ||
716 | regnum = create_feature_i386_32bit_linux (*tdesc, regnum); | |
717 | ||
718 | if (xcr0 & X86_XSTATE_AVX) | |
719 | regnum = create_feature_i386_32bit_avx (*tdesc, regnum); | |
720 | ||
721 | if (xcr0 & X86_XSTATE_MPX) | |
722 | regnum = create_feature_i386_32bit_mpx (*tdesc, regnum); | |
723 | ||
724 | if (xcr0 & X86_XSTATE_AVX512) | |
725 | regnum = create_feature_i386_32bit_avx512 (*tdesc, regnum); | |
726 | ||
727 | if (xcr0 & X86_XSTATE_PKRU) | |
728 | regnum = create_feature_i386_32bit_pkeys (*tdesc, regnum); | |
f335d1b3 L |
729 | } |
730 | ||
ea03d0d3 | 731 | return *tdesc; |
35b4818d YQ |
732 | } |
733 | ||
734 | /* Get Linux/x86 target description from core dump. */ | |
735 | ||
736 | static const struct target_desc * | |
737 | i386_linux_core_read_description (struct gdbarch *gdbarch, | |
738 | struct target_ops *target, | |
739 | bfd *abfd) | |
740 | { | |
741 | /* Linux/i386. */ | |
742 | uint64_t xcr0 = i386_linux_core_read_xcr0 (abfd); | |
743 | const struct target_desc *tdesc = i386_linux_read_description (xcr0); | |
744 | ||
745 | if (tdesc != NULL) | |
746 | return tdesc; | |
747 | ||
f335d1b3 | 748 | if (bfd_get_section_by_name (abfd, ".reg-xfp") != NULL) |
35b4818d | 749 | return i386_linux_read_description (X86_XSTATE_SSE_MASK); |
f335d1b3 | 750 | else |
35b4818d | 751 | return i386_linux_read_description (X86_XSTATE_X87_MASK); |
90884b2b L |
752 | } |
753 | ||
8f0435f7 AA |
754 | /* Similar to i386_supply_fpregset, but use XSAVE extended state. */ |
755 | ||
756 | static void | |
757 | i386_linux_supply_xstateregset (const struct regset *regset, | |
758 | struct regcache *regcache, int regnum, | |
759 | const void *xstateregs, size_t len) | |
760 | { | |
761 | i387_supply_xsave (regcache, regnum, xstateregs); | |
762 | } | |
763 | ||
190b495d WT |
764 | struct type * |
765 | x86_linux_get_siginfo_type (struct gdbarch *gdbarch) | |
766 | { | |
767 | return linux_get_siginfo_type_with_fields (gdbarch, LINUX_SIGINFO_FIELD_ADDR_BND); | |
768 | } | |
769 | ||
8f0435f7 AA |
770 | /* Similar to i386_collect_fpregset, but use XSAVE extended state. */ |
771 | ||
772 | static void | |
773 | i386_linux_collect_xstateregset (const struct regset *regset, | |
774 | const struct regcache *regcache, | |
775 | int regnum, void *xstateregs, size_t len) | |
776 | { | |
777 | i387_collect_xsave (regcache, regnum, xstateregs, 1); | |
778 | } | |
779 | ||
780 | /* Register set definitions. */ | |
781 | ||
782 | static const struct regset i386_linux_xstateregset = | |
783 | { | |
784 | NULL, | |
785 | i386_linux_supply_xstateregset, | |
786 | i386_linux_collect_xstateregset | |
787 | }; | |
788 | ||
5aa82d05 AA |
789 | /* Iterate over core file register note sections. */ |
790 | ||
791 | static void | |
792 | i386_linux_iterate_over_regset_sections (struct gdbarch *gdbarch, | |
793 | iterate_over_regset_sections_cb *cb, | |
794 | void *cb_data, | |
795 | const struct regcache *regcache) | |
796 | { | |
797 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
798 | ||
8f0435f7 | 799 | cb (".reg", 68, &i386_gregset, NULL, cb_data); |
5aa82d05 AA |
800 | |
801 | if (tdep->xcr0 & X86_XSTATE_AVX) | |
dde9acd6 | 802 | cb (".reg-xstate", X86_XSTATE_SIZE (tdep->xcr0), |
8f0435f7 | 803 | &i386_linux_xstateregset, "XSAVE extended state", cb_data); |
5aa82d05 | 804 | else if (tdep->xcr0 & X86_XSTATE_SSE) |
8f0435f7 AA |
805 | cb (".reg-xfp", 512, &i386_fpregset, "extended floating-point", |
806 | cb_data); | |
5aa82d05 | 807 | else |
8f0435f7 | 808 | cb (".reg2", 108, &i386_fpregset, NULL, cb_data); |
5aa82d05 AA |
809 | } |
810 | ||
9a7f938f JK |
811 | /* Linux kernel shows PC value after the 'int $0x80' instruction even if |
812 | inferior is still inside the syscall. On next PTRACE_SINGLESTEP it will | |
813 | finish the syscall but PC will not change. | |
814 | ||
815 | Some vDSOs contain 'int $0x80; ret' and during stepping out of the syscall | |
816 | i386_displaced_step_fixup would keep PC at the displaced pad location. | |
817 | As PC is pointing to the 'ret' instruction before the step | |
818 | i386_displaced_step_fixup would expect inferior has just executed that 'ret' | |
819 | and PC should not be adjusted. In reality it finished syscall instead and | |
820 | PC should get relocated back to its vDSO address. Hide the 'ret' | |
821 | instruction by 'nop' so that i386_displaced_step_fixup is not confused. | |
822 | ||
823 | It is not fully correct as the bytes in struct displaced_step_closure will | |
824 | not match the inferior code. But we would need some new flag in | |
825 | displaced_step_closure otherwise to keep the state that syscall is finishing | |
826 | for the later i386_displaced_step_fixup execution as the syscall execution | |
827 | is already no longer detectable there. The new flag field would mean | |
828 | i386-linux-tdep.c needs to wrap all the displacement methods of i386-tdep.c | |
829 | which does not seem worth it. The same effect is achieved by patching that | |
830 | 'nop' instruction there instead. */ | |
831 | ||
693be288 | 832 | static struct displaced_step_closure * |
9a7f938f JK |
833 | i386_linux_displaced_step_copy_insn (struct gdbarch *gdbarch, |
834 | CORE_ADDR from, CORE_ADDR to, | |
835 | struct regcache *regs) | |
836 | { | |
837 | struct displaced_step_closure *closure; | |
838 | ||
839 | closure = i386_displaced_step_copy_insn (gdbarch, from, to, regs); | |
840 | ||
841 | if (i386_linux_get_syscall_number_from_regcache (regs) != -1) | |
842 | { | |
843 | /* Since we use simple_displaced_step_copy_insn, our closure is a | |
844 | copy of the instruction. */ | |
845 | gdb_byte *insn = (gdb_byte *) closure; | |
846 | ||
847 | /* Fake nop. */ | |
848 | insn[0] = 0x90; | |
849 | } | |
850 | ||
851 | return closure; | |
852 | } | |
853 | ||
8201327c MK |
854 | static void |
855 | i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
856 | { | |
857 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
90884b2b | 858 | const struct target_desc *tdesc = info.target_desc; |
0dba2a6c | 859 | struct tdesc_arch_data *tdesc_data = info.tdesc_data; |
90884b2b L |
860 | const struct tdesc_feature *feature; |
861 | int valid_p; | |
862 | ||
863 | gdb_assert (tdesc_data); | |
8201327c | 864 | |
a5ee0f0c PA |
865 | linux_init_abi (info, gdbarch); |
866 | ||
8201327c MK |
867 | /* GNU/Linux uses ELF. */ |
868 | i386_elf_init_abi (info, gdbarch); | |
869 | ||
90884b2b L |
870 | /* Reserve a number for orig_eax. */ |
871 | set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS); | |
872 | ||
873 | if (! tdesc_has_registers (tdesc)) | |
35b4818d | 874 | tdesc = i386_linux_read_description (X86_XSTATE_SSE_MASK); |
90884b2b L |
875 | tdep->tdesc = tdesc; |
876 | ||
877 | feature = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.linux"); | |
878 | if (feature == NULL) | |
879 | return; | |
8201327c | 880 | |
90884b2b L |
881 | valid_p = tdesc_numbered_register (feature, tdesc_data, |
882 | I386_LINUX_ORIG_EAX_REGNUM, | |
883 | "orig_eax"); | |
884 | if (!valid_p) | |
885 | return; | |
886 | ||
887 | /* Add the %orig_eax register used for syscall restarting. */ | |
8201327c | 888 | set_gdbarch_write_pc (gdbarch, i386_linux_write_pc); |
90884b2b L |
889 | |
890 | tdep->register_reggroup_p = i386_linux_register_reggroup_p; | |
8201327c | 891 | |
e9f1aad5 MK |
892 | tdep->gregset_reg_offset = i386_linux_gregset_reg_offset; |
893 | tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset); | |
894 | tdep->sizeof_gregset = 17 * 4; | |
895 | ||
8201327c MK |
896 | tdep->jb_pc_offset = 20; /* From <bits/setjmp.h>. */ |
897 | ||
911bc6ee | 898 | tdep->sigtramp_p = i386_linux_sigtramp_p; |
b7d15bf7 | 899 | tdep->sigcontext_addr = i386_linux_sigcontext_addr; |
a3386186 | 900 | tdep->sc_reg_offset = i386_linux_sc_reg_offset; |
bb489b3c | 901 | tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset); |
8201327c | 902 | |
c131fcee L |
903 | tdep->xsave_xcr0_offset = I386_LINUX_XSAVE_XCR0_OFFSET; |
904 | ||
a6b808b4 | 905 | set_gdbarch_process_record (gdbarch, i386_process_record); |
8a2e0e28 | 906 | set_gdbarch_process_record_signal (gdbarch, i386_linux_record_signal); |
a6b808b4 | 907 | |
77fcef51 | 908 | /* Initialize the i386_linux_record_tdep. */ |
5e31abdf HZ |
909 | /* These values are the size of the type that will be used in a system |
910 | call. They are obtained from Linux Kernel source. */ | |
2c543fc4 HZ |
911 | i386_linux_record_tdep.size_pointer |
912 | = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT; | |
5e31abdf HZ |
913 | i386_linux_record_tdep.size__old_kernel_stat = 32; |
914 | i386_linux_record_tdep.size_tms = 16; | |
915 | i386_linux_record_tdep.size_loff_t = 8; | |
916 | i386_linux_record_tdep.size_flock = 16; | |
917 | i386_linux_record_tdep.size_oldold_utsname = 45; | |
918 | i386_linux_record_tdep.size_ustat = 20; | |
7571f7f2 MK |
919 | i386_linux_record_tdep.size_old_sigaction = 16; |
920 | i386_linux_record_tdep.size_old_sigset_t = 4; | |
5e31abdf HZ |
921 | i386_linux_record_tdep.size_rlimit = 8; |
922 | i386_linux_record_tdep.size_rusage = 72; | |
923 | i386_linux_record_tdep.size_timeval = 8; | |
924 | i386_linux_record_tdep.size_timezone = 8; | |
925 | i386_linux_record_tdep.size_old_gid_t = 2; | |
926 | i386_linux_record_tdep.size_old_uid_t = 2; | |
927 | i386_linux_record_tdep.size_fd_set = 128; | |
72aded86 | 928 | i386_linux_record_tdep.size_old_dirent = 268; |
5e31abdf HZ |
929 | i386_linux_record_tdep.size_statfs = 64; |
930 | i386_linux_record_tdep.size_statfs64 = 84; | |
931 | i386_linux_record_tdep.size_sockaddr = 16; | |
2c543fc4 HZ |
932 | i386_linux_record_tdep.size_int |
933 | = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT; | |
934 | i386_linux_record_tdep.size_long | |
935 | = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; | |
936 | i386_linux_record_tdep.size_ulong | |
937 | = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT; | |
5e31abdf HZ |
938 | i386_linux_record_tdep.size_msghdr = 28; |
939 | i386_linux_record_tdep.size_itimerval = 16; | |
940 | i386_linux_record_tdep.size_stat = 88; | |
941 | i386_linux_record_tdep.size_old_utsname = 325; | |
942 | i386_linux_record_tdep.size_sysinfo = 64; | |
943 | i386_linux_record_tdep.size_msqid_ds = 88; | |
944 | i386_linux_record_tdep.size_shmid_ds = 84; | |
945 | i386_linux_record_tdep.size_new_utsname = 390; | |
946 | i386_linux_record_tdep.size_timex = 128; | |
947 | i386_linux_record_tdep.size_mem_dqinfo = 24; | |
948 | i386_linux_record_tdep.size_if_dqblk = 68; | |
949 | i386_linux_record_tdep.size_fs_quota_stat = 68; | |
950 | i386_linux_record_tdep.size_timespec = 8; | |
951 | i386_linux_record_tdep.size_pollfd = 8; | |
952 | i386_linux_record_tdep.size_NFS_FHSIZE = 32; | |
953 | i386_linux_record_tdep.size_knfsd_fh = 132; | |
954 | i386_linux_record_tdep.size_TASK_COMM_LEN = 16; | |
7571f7f2 | 955 | i386_linux_record_tdep.size_sigaction = 20; |
5e31abdf HZ |
956 | i386_linux_record_tdep.size_sigset_t = 8; |
957 | i386_linux_record_tdep.size_siginfo_t = 128; | |
958 | i386_linux_record_tdep.size_cap_user_data_t = 12; | |
959 | i386_linux_record_tdep.size_stack_t = 12; | |
960 | i386_linux_record_tdep.size_off_t = i386_linux_record_tdep.size_long; | |
961 | i386_linux_record_tdep.size_stat64 = 96; | |
d625f9a9 MK |
962 | i386_linux_record_tdep.size_gid_t = 4; |
963 | i386_linux_record_tdep.size_uid_t = 4; | |
5e31abdf HZ |
964 | i386_linux_record_tdep.size_PAGE_SIZE = 4096; |
965 | i386_linux_record_tdep.size_flock64 = 24; | |
966 | i386_linux_record_tdep.size_user_desc = 16; | |
967 | i386_linux_record_tdep.size_io_event = 32; | |
968 | i386_linux_record_tdep.size_iocb = 64; | |
969 | i386_linux_record_tdep.size_epoll_event = 12; | |
2c543fc4 HZ |
970 | i386_linux_record_tdep.size_itimerspec |
971 | = i386_linux_record_tdep.size_timespec * 2; | |
5e31abdf | 972 | i386_linux_record_tdep.size_mq_attr = 32; |
5e31abdf HZ |
973 | i386_linux_record_tdep.size_termios = 36; |
974 | i386_linux_record_tdep.size_termios2 = 44; | |
975 | i386_linux_record_tdep.size_pid_t = 4; | |
976 | i386_linux_record_tdep.size_winsize = 8; | |
977 | i386_linux_record_tdep.size_serial_struct = 60; | |
978 | i386_linux_record_tdep.size_serial_icounter_struct = 80; | |
979 | i386_linux_record_tdep.size_hayes_esp_config = 12; | |
2c543fc4 HZ |
980 | i386_linux_record_tdep.size_size_t = 4; |
981 | i386_linux_record_tdep.size_iovec = 8; | |
b80d067f | 982 | i386_linux_record_tdep.size_time_t = 4; |
5e31abdf HZ |
983 | |
984 | /* These values are the second argument of system call "sys_ioctl". | |
985 | They are obtained from Linux Kernel source. */ | |
986 | i386_linux_record_tdep.ioctl_TCGETS = 0x5401; | |
987 | i386_linux_record_tdep.ioctl_TCSETS = 0x5402; | |
988 | i386_linux_record_tdep.ioctl_TCSETSW = 0x5403; | |
989 | i386_linux_record_tdep.ioctl_TCSETSF = 0x5404; | |
990 | i386_linux_record_tdep.ioctl_TCGETA = 0x5405; | |
991 | i386_linux_record_tdep.ioctl_TCSETA = 0x5406; | |
992 | i386_linux_record_tdep.ioctl_TCSETAW = 0x5407; | |
993 | i386_linux_record_tdep.ioctl_TCSETAF = 0x5408; | |
994 | i386_linux_record_tdep.ioctl_TCSBRK = 0x5409; | |
995 | i386_linux_record_tdep.ioctl_TCXONC = 0x540A; | |
996 | i386_linux_record_tdep.ioctl_TCFLSH = 0x540B; | |
997 | i386_linux_record_tdep.ioctl_TIOCEXCL = 0x540C; | |
998 | i386_linux_record_tdep.ioctl_TIOCNXCL = 0x540D; | |
999 | i386_linux_record_tdep.ioctl_TIOCSCTTY = 0x540E; | |
1000 | i386_linux_record_tdep.ioctl_TIOCGPGRP = 0x540F; | |
1001 | i386_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410; | |
1002 | i386_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411; | |
1003 | i386_linux_record_tdep.ioctl_TIOCSTI = 0x5412; | |
1004 | i386_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413; | |
1005 | i386_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414; | |
1006 | i386_linux_record_tdep.ioctl_TIOCMGET = 0x5415; | |
1007 | i386_linux_record_tdep.ioctl_TIOCMBIS = 0x5416; | |
1008 | i386_linux_record_tdep.ioctl_TIOCMBIC = 0x5417; | |
1009 | i386_linux_record_tdep.ioctl_TIOCMSET = 0x5418; | |
1010 | i386_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419; | |
1011 | i386_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541A; | |
1012 | i386_linux_record_tdep.ioctl_FIONREAD = 0x541B; | |
1013 | i386_linux_record_tdep.ioctl_TIOCINQ = i386_linux_record_tdep.ioctl_FIONREAD; | |
1014 | i386_linux_record_tdep.ioctl_TIOCLINUX = 0x541C; | |
1015 | i386_linux_record_tdep.ioctl_TIOCCONS = 0x541D; | |
1016 | i386_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541E; | |
1017 | i386_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541F; | |
1018 | i386_linux_record_tdep.ioctl_TIOCPKT = 0x5420; | |
1019 | i386_linux_record_tdep.ioctl_FIONBIO = 0x5421; | |
1020 | i386_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422; | |
1021 | i386_linux_record_tdep.ioctl_TIOCSETD = 0x5423; | |
1022 | i386_linux_record_tdep.ioctl_TIOCGETD = 0x5424; | |
1023 | i386_linux_record_tdep.ioctl_TCSBRKP = 0x5425; | |
1024 | i386_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426; | |
1025 | i386_linux_record_tdep.ioctl_TIOCSBRK = 0x5427; | |
1026 | i386_linux_record_tdep.ioctl_TIOCCBRK = 0x5428; | |
1027 | i386_linux_record_tdep.ioctl_TIOCGSID = 0x5429; | |
1028 | i386_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a; | |
1029 | i386_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b; | |
1030 | i386_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c; | |
1031 | i386_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d; | |
1032 | i386_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430; | |
1033 | i386_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431; | |
1034 | i386_linux_record_tdep.ioctl_FIONCLEX = 0x5450; | |
1035 | i386_linux_record_tdep.ioctl_FIOCLEX = 0x5451; | |
1036 | i386_linux_record_tdep.ioctl_FIOASYNC = 0x5452; | |
1037 | i386_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453; | |
1038 | i386_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454; | |
1039 | i386_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455; | |
1040 | i386_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456; | |
1041 | i386_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457; | |
1042 | i386_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458; | |
1043 | i386_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459; | |
1044 | i386_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545A; | |
1045 | i386_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545B; | |
1046 | i386_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545C; | |
1047 | i386_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545D; | |
1048 | i386_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545E; | |
1049 | i386_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545F; | |
1050 | i386_linux_record_tdep.ioctl_FIOQSIZE = 0x5460; | |
1051 | ||
1052 | /* These values are the second argument of system call "sys_fcntl" | |
1053 | and "sys_fcntl64". They are obtained from Linux Kernel source. */ | |
1054 | i386_linux_record_tdep.fcntl_F_GETLK = 5; | |
1055 | i386_linux_record_tdep.fcntl_F_GETLK64 = 12; | |
1056 | i386_linux_record_tdep.fcntl_F_SETLK64 = 13; | |
1057 | i386_linux_record_tdep.fcntl_F_SETLKW64 = 14; | |
50ef67b3 | 1058 | |
77fcef51 HZ |
1059 | i386_linux_record_tdep.arg1 = I386_EBX_REGNUM; |
1060 | i386_linux_record_tdep.arg2 = I386_ECX_REGNUM; | |
1061 | i386_linux_record_tdep.arg3 = I386_EDX_REGNUM; | |
1062 | i386_linux_record_tdep.arg4 = I386_ESI_REGNUM; | |
1063 | i386_linux_record_tdep.arg5 = I386_EDI_REGNUM; | |
2c543fc4 | 1064 | i386_linux_record_tdep.arg6 = I386_EBP_REGNUM; |
77fcef51 | 1065 | |
ffdf6de5 JK |
1066 | tdep->i386_intx80_record = i386_linux_intx80_sysenter_syscall_record; |
1067 | tdep->i386_sysenter_record = i386_linux_intx80_sysenter_syscall_record; | |
1068 | tdep->i386_syscall_record = i386_linux_intx80_sysenter_syscall_record; | |
77fcef51 | 1069 | |
203c3895 | 1070 | /* N_FUN symbols in shared libaries have 0 for their values and need |
1777feb0 | 1071 | to be relocated. */ |
203c3895 UW |
1072 | set_gdbarch_sofun_address_maybe_missing (gdbarch, 1); |
1073 | ||
871fbe6a | 1074 | /* GNU/Linux uses SVR4-style shared libraries. */ |
982e9687 | 1075 | set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); |
871fbe6a MK |
1076 | set_solib_svr4_fetch_link_map_offsets |
1077 | (gdbarch, svr4_ilp32_fetch_link_map_offsets); | |
1078 | ||
1079 | /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ | |
bb41a796 | 1080 | set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); |
12b8a2cb DJ |
1081 | |
1082 | dwarf2_frame_set_signal_frame_p (gdbarch, i386_linux_dwarf_signal_frame_p); | |
b2756930 KB |
1083 | |
1084 | /* Enable TLS support. */ | |
1085 | set_gdbarch_fetch_tls_load_module_address (gdbarch, | |
1086 | svr4_fetch_objfile_link_map); | |
237fc4c9 | 1087 | |
5aa82d05 AA |
1088 | /* Core file support. */ |
1089 | set_gdbarch_iterate_over_regset_sections | |
1090 | (gdbarch, i386_linux_iterate_over_regset_sections); | |
90884b2b L |
1091 | set_gdbarch_core_read_description (gdbarch, |
1092 | i386_linux_core_read_description); | |
1093 | ||
237fc4c9 PA |
1094 | /* Displaced stepping. */ |
1095 | set_gdbarch_displaced_step_copy_insn (gdbarch, | |
9a7f938f | 1096 | i386_linux_displaced_step_copy_insn); |
237fc4c9 | 1097 | set_gdbarch_displaced_step_fixup (gdbarch, i386_displaced_step_fixup); |
237fc4c9 | 1098 | set_gdbarch_displaced_step_location (gdbarch, |
906d60cf | 1099 | linux_displaced_step_location); |
4aa995e1 | 1100 | |
a96d9b2e | 1101 | /* Functions for 'catch syscall'. */ |
458c8db8 | 1102 | set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_I386); |
a96d9b2e SDJ |
1103 | set_gdbarch_get_syscall_number (gdbarch, |
1104 | i386_linux_get_syscall_number); | |
190b495d WT |
1105 | |
1106 | set_gdbarch_get_siginfo_type (gdbarch, x86_linux_get_siginfo_type); | |
012b3a21 WT |
1107 | set_gdbarch_handle_segmentation_fault (gdbarch, |
1108 | i386_linux_handle_segmentation_fault); | |
8201327c MK |
1109 | } |
1110 | ||
1111 | /* Provide a prototype to silence -Wmissing-prototypes. */ | |
1112 | extern void _initialize_i386_linux_tdep (void); | |
1113 | ||
1114 | void | |
1115 | _initialize_i386_linux_tdep (void) | |
1116 | { | |
05816f70 | 1117 | gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX, |
8201327c | 1118 | i386_linux_init_abi); |
27d41eac YQ |
1119 | |
1120 | #if GDB_SELF_TEST | |
1121 | struct | |
1122 | { | |
1123 | const char *xml; | |
1124 | uint64_t mask; | |
1125 | } xml_masks[] = { | |
1126 | { "i386/i386-linux.xml", X86_XSTATE_SSE_MASK }, | |
1127 | { "i386/i386-mmx-linux.xml", X86_XSTATE_X87_MASK }, | |
1128 | { "i386/i386-avx-linux.xml", X86_XSTATE_AVX_MASK }, | |
1129 | { "i386/i386-mpx-linux.xml", X86_XSTATE_MPX_MASK }, | |
1130 | { "i386/i386-avx-mpx-linux.xml", X86_XSTATE_AVX_MPX_MASK }, | |
1131 | { "i386/i386-avx-avx512-linux.xml", X86_XSTATE_AVX_AVX512_MASK }, | |
1132 | { "i386/i386-avx-mpx-avx512-pku-linux.xml", | |
1133 | X86_XSTATE_AVX_MPX_AVX512_PKU_MASK }, | |
1134 | }; | |
1135 | ||
1136 | for (auto &a : xml_masks) | |
1137 | { | |
1138 | auto tdesc = i386_linux_read_description (a.mask); | |
1139 | ||
1140 | selftests::record_xml_tdesc (a.xml, tdesc); | |
1141 | } | |
1142 | #endif /* GDB_SELF_TEST */ | |
8201327c | 1143 | } |