1 /* Target-dependent code for GNU/Linux running on i386's, for GDB.
3 Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
29 /* For i386_linux_skip_solib_resolver. */
34 #include "solib-svr4.h" /* For struct link_map_offsets. */
36 #include "i386-tdep.h"
37 #include "i386-linux-tdep.h"
39 /* Return the name of register REG. */
42 i386_linux_register_name (int reg
)
44 /* Deal with the extra "orig_eax" pseudo register. */
45 if (reg
== I386_LINUX_ORIG_EAX_REGNUM
)
48 return i386_register_name (reg
);
52 i386_linux_register_byte (int reg
)
54 /* Deal with the extra "orig_eax" pseudo register. */
55 if (reg
== I386_LINUX_ORIG_EAX_REGNUM
)
56 return (i386_register_byte (I386_LINUX_ORIG_EAX_REGNUM
- 1)
57 + i386_register_raw_size (I386_LINUX_ORIG_EAX_REGNUM
- 1));
59 return i386_register_byte (reg
);
63 i386_linux_register_raw_size (int reg
)
65 /* Deal with the extra "orig_eax" pseudo register. */
66 if (reg
== I386_LINUX_ORIG_EAX_REGNUM
)
69 return i386_register_raw_size (reg
);
72 /* Recognizing signal handler frames. */
74 /* GNU/Linux has two flavors of signals. Normal signal handlers, and
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
78 unlikely that future versions of GNU/Linux will support SA_SIGINFO
79 for normal signals too. */
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.
86 The instruction sequence for normal signals is
90 or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80.
92 Checking for the code sequence should be somewhat reliable, because
93 the effect is to call the system call sigreturn. This is unlikely
94 to occur anywhere other than a signal trampoline.
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
98 any other way. The PC_IN_SIGTRAMP macro in tm-linux.h arranges to
99 only call us if no function name could be identified, which should
100 be the case since the code is on the stack.
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
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)
117 static const unsigned char linux_sigtramp_code
[] =
119 LINUX_SIGTRAMP_INSN0
, /* pop %eax */
120 LINUX_SIGTRAMP_INSN1
, 0x77, 0x00, 0x00, 0x00, /* mov $0x77,%eax */
121 LINUX_SIGTRAMP_INSN2
, 0x80 /* int $0x80 */
124 #define LINUX_SIGTRAMP_LEN (sizeof linux_sigtramp_code)
126 /* If PC is in a sigtramp routine, return the address of the start of
127 the routine. Otherwise, return 0. */
130 i386_linux_sigtramp_start (CORE_ADDR pc
)
132 unsigned char buf
[LINUX_SIGTRAMP_LEN
];
134 /* We only recognize a signal trampoline if PC is at the start of
135 one of the three instructions. We optimize for finding the PC at
136 the start, as will be the case when the trampoline is not the
137 first frame on the stack. We assume that in the case where the
138 PC is not at the start of the instruction sequence, there will be
139 a few trailing readable bytes on the stack. */
141 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_SIGTRAMP_LEN
) != 0)
144 if (buf
[0] != LINUX_SIGTRAMP_INSN0
)
150 case LINUX_SIGTRAMP_INSN1
:
151 adjust
= LINUX_SIGTRAMP_OFFSET1
;
153 case LINUX_SIGTRAMP_INSN2
:
154 adjust
= LINUX_SIGTRAMP_OFFSET2
;
162 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_SIGTRAMP_LEN
) != 0)
166 if (memcmp (buf
, linux_sigtramp_code
, LINUX_SIGTRAMP_LEN
) != 0)
172 /* This function does the same for RT signals. Here the instruction
176 or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80.
178 The effect is to call the system call rt_sigreturn. */
180 #define LINUX_RT_SIGTRAMP_INSN0 (0xb8) /* mov $NNNN,%eax */
181 #define LINUX_RT_SIGTRAMP_OFFSET0 (0)
182 #define LINUX_RT_SIGTRAMP_INSN1 (0xcd) /* int */
183 #define LINUX_RT_SIGTRAMP_OFFSET1 (5)
185 static const unsigned char linux_rt_sigtramp_code
[] =
187 LINUX_RT_SIGTRAMP_INSN0
, 0xad, 0x00, 0x00, 0x00, /* mov $0xad,%eax */
188 LINUX_RT_SIGTRAMP_INSN1
, 0x80 /* int $0x80 */
191 #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code)
193 /* If PC is in a RT sigtramp routine, return the address of the start
194 of the routine. Otherwise, return 0. */
197 i386_linux_rt_sigtramp_start (CORE_ADDR pc
)
199 unsigned char buf
[LINUX_RT_SIGTRAMP_LEN
];
201 /* We only recognize a signal trampoline if PC is at the start of
202 one of the two instructions. We optimize for finding the PC at
203 the start, as will be the case when the trampoline is not the
204 first frame on the stack. We assume that in the case where the
205 PC is not at the start of the instruction sequence, there will be
206 a few trailing readable bytes on the stack. */
208 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_RT_SIGTRAMP_LEN
) != 0)
211 if (buf
[0] != LINUX_RT_SIGTRAMP_INSN0
)
213 if (buf
[0] != LINUX_RT_SIGTRAMP_INSN1
)
216 pc
-= LINUX_RT_SIGTRAMP_OFFSET1
;
218 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_RT_SIGTRAMP_LEN
) != 0)
222 if (memcmp (buf
, linux_rt_sigtramp_code
, LINUX_RT_SIGTRAMP_LEN
) != 0)
228 /* Return whether PC is in a GNU/Linux sigtramp routine. */
231 i386_linux_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
234 return STREQ ("__restore", name
) || STREQ ("__restore_rt", name
);
236 return (i386_linux_sigtramp_start (pc
) != 0
237 || i386_linux_rt_sigtramp_start (pc
) != 0);
240 /* Assuming FRAME is for a GNU/Linux sigtramp routine, return the
241 address of the associated sigcontext structure. */
244 i386_linux_sigcontext_addr (struct frame_info
*frame
)
248 pc
= i386_linux_sigtramp_start (frame
->pc
);
254 /* If this isn't the top frame, the next frame must be for the
255 signal handler itself. The sigcontext structure lives on
256 the stack, right after the signum argument. */
257 return frame
->next
->frame
+ 12;
259 /* This is the top frame. We'll have to find the address of the
260 sigcontext structure by looking at the stack pointer. Keep
261 in mind that the first instruction of the sigtramp code is
262 "pop %eax". If the PC is at this instruction, adjust the
263 returned value accordingly. */
264 sp
= read_register (SP_REGNUM
);
270 pc
= i386_linux_rt_sigtramp_start (frame
->pc
);
274 /* If this isn't the top frame, the next frame must be for the
275 signal handler itself. The sigcontext structure is part of
276 the user context. A pointer to the user context is passed
277 as the third argument to the signal handler. */
278 return read_memory_integer (frame
->next
->frame
+ 16, 4) + 20;
280 /* This is the top frame. Again, use the stack pointer to find
281 the address of the sigcontext structure. */
282 return read_memory_integer (read_register (SP_REGNUM
) + 8, 4) + 20;
285 error ("Couldn't recognize signal trampoline.");
289 /* Set the program counter for process PTID to PC. */
292 i386_linux_write_pc (CORE_ADDR pc
, ptid_t ptid
)
294 write_register_pid (PC_REGNUM
, pc
, ptid
);
296 /* We must be careful with modifying the program counter. If we
297 just interrupted a system call, the kernel might try to restart
298 it when we resume the inferior. On restarting the system call,
299 the kernel will try backing up the program counter even though it
300 no longer points at the system call. This typically results in a
301 SIGSEGV or SIGILL. We can prevent this by writing `-1' in the
302 "orig_eax" pseudo-register.
304 Note that "orig_eax" is saved when setting up a dummy call frame.
305 This means that it is properly restored when that frame is
306 popped, and that the interrupted system call will be restarted
307 when we resume the inferior on return from a function call from
308 within GDB. In all other cases the system call will not be
310 write_register_pid (I386_LINUX_ORIG_EAX_REGNUM
, -1, ptid
);
313 /* Calling functions in shared libraries. */
315 /* Find the minimal symbol named NAME, and return both the minsym
316 struct and its objfile. This probably ought to be in minsym.c, but
317 everything there is trying to deal with things like C++ and
318 SOFUN_ADDRESS_MAYBE_TURQUOISE, ... Since this is so simple, it may
319 be considered too special-purpose for general consumption. */
321 static struct minimal_symbol
*
322 find_minsym_and_objfile (char *name
, struct objfile
**objfile_p
)
324 struct objfile
*objfile
;
326 ALL_OBJFILES (objfile
)
328 struct minimal_symbol
*msym
;
330 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
332 if (SYMBOL_NAME (msym
)
333 && STREQ (SYMBOL_NAME (msym
), name
))
335 *objfile_p
= objfile
;
345 skip_hurd_resolver (CORE_ADDR pc
)
347 /* The HURD dynamic linker is part of the GNU C library, so many
348 GNU/Linux distributions use it. (All ELF versions, as far as I
349 know.) An unresolved PLT entry points to "_dl_runtime_resolve",
350 which calls "fixup" to patch the PLT, and then passes control to
353 We look for the symbol `_dl_runtime_resolve', and find `fixup' in
354 the same objfile. If we are at the entry point of `fixup', then
355 we set a breakpoint at the return address (at the top of the
356 stack), and continue.
358 It's kind of gross to do all these checks every time we're
359 called, since they don't change once the executable has gotten
360 started. But this is only a temporary hack --- upcoming versions
361 of GNU/Linux will provide a portable, efficient interface for
362 debugging programs that use shared libraries. */
364 struct objfile
*objfile
;
365 struct minimal_symbol
*resolver
366 = find_minsym_and_objfile ("_dl_runtime_resolve", &objfile
);
370 struct minimal_symbol
*fixup
371 = lookup_minimal_symbol ("fixup", NULL
, objfile
);
373 if (fixup
&& SYMBOL_VALUE_ADDRESS (fixup
) == pc
)
374 return (SAVED_PC_AFTER_CALL (get_current_frame ()));
380 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c.
382 1) decides whether a PLT has sent us into the linker to resolve
383 a function reference, and
384 2) if so, tells us where to set a temporary breakpoint that will
385 trigger when the dynamic linker is done. */
388 i386_linux_skip_solib_resolver (CORE_ADDR pc
)
392 /* Plug in functions for other kinds of resolvers here. */
393 result
= skip_hurd_resolver (pc
);
400 /* Fetch (and possibly build) an appropriate link_map_offsets
401 structure for native GNU/Linux x86 targets using the struct offsets
402 defined in link.h (but without actual reference to that file).
404 This makes it possible to access GNU/Linux x86 shared libraries
405 from a GDB that was not built on an GNU/Linux x86 host (for cross
408 static struct link_map_offsets
*
409 i386_linux_svr4_fetch_link_map_offsets (void)
411 static struct link_map_offsets lmo
;
412 static struct link_map_offsets
*lmp
= NULL
;
418 lmo
.r_debug_size
= 8; /* The actual size is 20 bytes, but
419 this is all we need. */
420 lmo
.r_map_offset
= 4;
423 lmo
.link_map_size
= 20; /* The actual size is 552 bytes, but
424 this is all we need. */
425 lmo
.l_addr_offset
= 0;
428 lmo
.l_name_offset
= 4;
431 lmo
.l_next_offset
= 12;
434 lmo
.l_prev_offset
= 16;
443 i386_linux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
445 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
447 /* GNU/Linux uses ELF. */
448 i386_elf_init_abi (info
, gdbarch
);
450 /* We support the SSE registers on GNU/Linux. */
451 tdep
->num_xmm_regs
= I386_NUM_XREGS
- 1;
452 /* set_gdbarch_num_regs (gdbarch, I386_SSE_NUM_REGS); */
454 /* Since we have the extra "orig_eax" register on GNU/Linux, we have
455 to adjust a few things. */
457 set_gdbarch_write_pc (gdbarch
, i386_linux_write_pc
);
458 set_gdbarch_num_regs (gdbarch
, I386_SSE_NUM_REGS
+ 1);
459 set_gdbarch_register_name (gdbarch
, i386_linux_register_name
);
460 set_gdbarch_register_bytes (gdbarch
, I386_SSE_SIZEOF_REGS
+ 4);
461 set_gdbarch_register_byte (gdbarch
, i386_linux_register_byte
);
462 set_gdbarch_register_raw_size (gdbarch
, i386_linux_register_raw_size
);
464 tdep
->jb_pc_offset
= 20; /* From <bits/setjmp.h>. */
466 tdep
->sigcontext_addr
= i386_linux_sigcontext_addr
;
467 tdep
->sc_pc_offset
= 14 * 4; /* From <asm/sigcontext.h>. */
468 tdep
->sc_sp_offset
= 7 * 4;
470 /* When the i386 Linux kernel calls a signal handler, the return
471 address points to a bit of code on the stack. This function is
472 used to identify this bit of code as a signal trampoline in order
473 to support backtracing through calls to signal handlers. */
474 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_linux_pc_in_sigtramp
);
476 set_solib_svr4_fetch_link_map_offsets (gdbarch
,
477 i386_linux_svr4_fetch_link_map_offsets
);
480 /* Provide a prototype to silence -Wmissing-prototypes. */
481 extern void _initialize_i386_linux_tdep (void);
484 _initialize_i386_linux_tdep (void)
486 gdbarch_register_osabi (bfd_arch_i386
, GDB_OSABI_LINUX
,
487 i386_linux_init_abi
);