1 /* GNU/Linux on ARM target support.
2 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
25 #include "floatformat.h"
33 /* For arm_linux_skip_solib_resolver. */
38 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
39 is to execute a particular software interrupt, rather than use a
40 particular undefined instruction to provoke a trap. Upon exection
41 of the software interrupt the kernel stops the inferior with a
42 SIGTRAP, and wakes the debugger. Since ARM GNU/Linux is little
43 endian, and doesn't support Thumb at the moment we only override
44 the ARM little-endian breakpoint. */
46 static const char arm_linux_arm_le_breakpoint[] = {0x01,0x00,0x9f,0xef};
49 This sequence of words is the instructions
55 Note this is 12 bytes. */
57 LONGEST arm_linux_call_dummy_words[] =
59 0xe1a0e00f, 0xe1a0f004, 0xef9f001
62 /* Description of the longjmp buffer. */
63 #define JB_ELEMENT_SIZE INT_REGISTER_RAW_SIZE
66 /* Extract from an array REGBUF containing the (raw) register state
67 a function return value of type TYPE, and copy that, in virtual format,
69 /* FIXME rearnsha/2002-02-23: This function shouldn't be necessary.
70 The ARM generic one should be able to handle the model used by
71 linux and the low-level formatting of the registers should be
72 hidden behind the regcache abstraction. */
74 arm_linux_extract_return_value (struct type *type,
75 char regbuf[REGISTER_BYTES],
78 /* ScottB: This needs to be looked at to handle the different
79 floating point emulators on ARM GNU/Linux. Right now the code
80 assumes that fetch inferior registers does the right thing for
81 GDB. I suspect this won't handle NWFPE registers correctly, nor
82 will the default ARM version (arm_extract_return_value()). */
84 int regnum = ((TYPE_CODE_FLT == TYPE_CODE (type))
85 ? ARM_F0_REGNUM : ARM_A1_REGNUM);
86 memcpy (valbuf, ®buf[REGISTER_BYTE (regnum)], TYPE_LENGTH (type));
91 This function does not support passing parameters using the FPA
92 variant of the APCS. It passes any floating point arguments in the
93 general registers and/or on the stack.
95 FIXME: This and arm_push_arguments should be merged. However this
96 function breaks on a little endian host, big endian target
97 using the COFF file format. ELF is ok.
101 /* Addresses for calling Thumb functions have the bit 0 set.
102 Here are some macros to test, set, or clear bit 0 of addresses. */
103 #define IS_THUMB_ADDR(addr) ((addr) & 1)
104 #define MAKE_THUMB_ADDR(addr) ((addr) | 1)
105 #define UNMAKE_THUMB_ADDR(addr) ((addr) & ~1)
108 arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
109 int struct_return, CORE_ADDR struct_addr)
112 int argnum, argreg, nstack_size;
114 /* Walk through the list of args and determine how large a temporary
115 stack is required. Need to take care here as structs may be
116 passed on the stack, and we have to to push them. */
117 nstack_size = -4 * REGISTER_SIZE; /* Some arguments go into A1-A4. */
119 if (struct_return) /* The struct address goes in A1. */
120 nstack_size += REGISTER_SIZE;
122 /* Walk through the arguments and add their size to nstack_size. */
123 for (argnum = 0; argnum < nargs; argnum++)
126 struct type *arg_type;
128 arg_type = check_typedef (VALUE_TYPE (args[argnum]));
129 len = TYPE_LENGTH (arg_type);
131 /* ANSI C code passes float arguments as integers, K&R code
132 passes float arguments as doubles. Correct for this here. */
133 if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && REGISTER_SIZE == len)
134 nstack_size += FP_REGISTER_VIRTUAL_SIZE;
139 /* Allocate room on the stack, and initialize our stack frame
148 /* Initialize the integer argument register pointer. */
149 argreg = ARM_A1_REGNUM;
151 /* The struct_return pointer occupies the first parameter passing
154 write_register (argreg++, struct_addr);
156 /* Process arguments from left to right. Store as many as allowed
157 in the parameter passing registers (A1-A4), and save the rest on
158 the temporary stack. */
159 for (argnum = 0; argnum < nargs; argnum++)
164 enum type_code typecode;
165 struct type *arg_type, *target_type;
167 arg_type = check_typedef (VALUE_TYPE (args[argnum]));
168 target_type = TYPE_TARGET_TYPE (arg_type);
169 len = TYPE_LENGTH (arg_type);
170 typecode = TYPE_CODE (arg_type);
171 val = (char *) VALUE_CONTENTS (args[argnum]);
173 /* ANSI C code passes float arguments as integers, K&R code
174 passes float arguments as doubles. The .stabs record for
175 for ANSI prototype floating point arguments records the
176 type as FP_INTEGER, while a K&R style (no prototype)
177 .stabs records the type as FP_FLOAT. In this latter case
178 the compiler converts the float arguments to double before
179 calling the function. */
180 if (TYPE_CODE_FLT == typecode && REGISTER_SIZE == len)
183 dblval = extract_floating (val, len);
184 len = TARGET_DOUBLE_BIT / TARGET_CHAR_BIT;
186 store_floating (val, len, dblval);
189 /* If the argument is a pointer to a function, and it is a Thumb
190 function, set the low bit of the pointer. */
191 if (TYPE_CODE_PTR == typecode
192 && NULL != target_type
193 && TYPE_CODE_FUNC == TYPE_CODE (target_type))
195 CORE_ADDR regval = extract_address (val, len);
196 if (arm_pc_is_thumb (regval))
197 store_address (val, len, MAKE_THUMB_ADDR (regval));
200 /* Copy the argument to general registers or the stack in
201 register-sized pieces. Large arguments are split between
202 registers and stack. */
205 int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
207 if (argreg <= ARM_LAST_ARG_REGNUM)
209 /* It's an argument being passed in a general register. */
210 regval = extract_address (val, partial_len);
211 write_register (argreg++, regval);
215 /* Push the arguments onto the stack. */
216 write_memory ((CORE_ADDR) fp, val, REGISTER_SIZE);
225 /* Return adjusted stack pointer. */
230 Dynamic Linking on ARM GNU/Linux
231 --------------------------------
233 Note: PLT = procedure linkage table
234 GOT = global offset table
236 As much as possible, ELF dynamic linking defers the resolution of
237 jump/call addresses until the last minute. The technique used is
238 inspired by the i386 ELF design, and is based on the following
241 1) The calling technique should not force a change in the assembly
242 code produced for apps; it MAY cause changes in the way assembly
243 code is produced for position independent code (i.e. shared
246 2) The technique must be such that all executable areas must not be
247 modified; and any modified areas must not be executed.
249 To do this, there are three steps involved in a typical jump:
253 3) using a pointer from the GOT
255 When the executable or library is first loaded, each GOT entry is
256 initialized to point to the code which implements dynamic name
257 resolution and code finding. This is normally a function in the
258 program interpreter (on ARM GNU/Linux this is usually
259 ld-linux.so.2, but it does not have to be). On the first
260 invocation, the function is located and the GOT entry is replaced
261 with the real function address. Subsequent calls go through steps
262 1, 2 and 3 and end up calling the real code.
269 This is typical ARM code using the 26 bit relative branch or branch
270 and link instructions. The target of the instruction
271 (function_call is usually the address of the function to be called.
272 In position independent code, the target of the instruction is
273 actually an entry in the PLT when calling functions in a shared
274 library. Note that this call is identical to a normal function
275 call, only the target differs.
279 The PLT is a synthetic area, created by the linker. It exists in
280 both executables and libraries. It is an array of stubs, one per
281 imported function call. It looks like this:
284 str lr, [sp, #-4]! @push the return address (lr)
285 ldr lr, [pc, #16] @load from 6 words ahead
286 add lr, pc, lr @form an address for GOT[0]
287 ldr pc, [lr, #8]! @jump to the contents of that addr
289 The return address (lr) is pushed on the stack and used for
290 calculations. The load on the second line loads the lr with
291 &GOT[3] - . - 20. The addition on the third leaves:
293 lr = (&GOT[3] - . - 20) + (. + 8)
297 On the fourth line, the pc and lr are both updated, so that:
303 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
304 "tight", but allows us to keep all the PLT entries the same size.
307 ldr ip, [pc, #4] @load offset from gotoff
308 add ip, pc, ip @add the offset to the pc
309 ldr pc, [ip] @jump to that address
310 gotoff: .word GOT[n+3] - .
312 The load on the first line, gets an offset from the fourth word of
313 the PLT entry. The add on the second line makes ip = &GOT[n+3],
314 which contains either a pointer to PLT[0] (the fixup trampoline) or
315 a pointer to the actual code.
319 The GOT contains helper pointers for both code (PLT) fixups and
320 data fixups. The first 3 entries of the GOT are special. The next
321 M entries (where M is the number of entries in the PLT) belong to
322 the PLT fixups. The next D (all remaining) entries belong to
323 various data fixups. The actual size of the GOT is 3 + M + D.
325 The GOT is also a synthetic area, created by the linker. It exists
326 in both executables and libraries. When the GOT is first
327 initialized , all the GOT entries relating to PLT fixups are
328 pointing to code back at PLT[0].
330 The special entries in the GOT are:
332 GOT[0] = linked list pointer used by the dynamic loader
333 GOT[1] = pointer to the reloc table for this module
334 GOT[2] = pointer to the fixup/resolver code
336 The first invocation of function call comes through and uses the
337 fixup/resolver code. On the entry to the fixup/resolver code:
341 stack[0] = return address (lr) of the function call
342 [r0, r1, r2, r3] are still the arguments to the function call
344 This is enough information for the fixup/resolver code to work
345 with. Before the fixup/resolver code returns, it actually calls
346 the requested function and repairs &GOT[n+3]. */
348 /* Find the minimal symbol named NAME, and return both the minsym
349 struct and its objfile. This probably ought to be in minsym.c, but
350 everything there is trying to deal with things like C++ and
351 SOFUN_ADDRESS_MAYBE_TURQUOISE, ... Since this is so simple, it may
352 be considered too special-purpose for general consumption. */
354 static struct minimal_symbol *
355 find_minsym_and_objfile (char *name, struct objfile **objfile_p)
357 struct objfile *objfile;
359 ALL_OBJFILES (objfile)
361 struct minimal_symbol *msym;
363 ALL_OBJFILE_MSYMBOLS (objfile, msym)
365 if (SYMBOL_NAME (msym)
366 && strcmp (SYMBOL_NAME (msym), name) == 0)
368 *objfile_p = objfile;
379 skip_hurd_resolver (CORE_ADDR pc)
381 /* The HURD dynamic linker is part of the GNU C library, so many
382 GNU/Linux distributions use it. (All ELF versions, as far as I
383 know.) An unresolved PLT entry points to "_dl_runtime_resolve",
384 which calls "fixup" to patch the PLT, and then passes control to
387 We look for the symbol `_dl_runtime_resolve', and find `fixup' in
388 the same objfile. If we are at the entry point of `fixup', then
389 we set a breakpoint at the return address (at the top of the
390 stack), and continue.
392 It's kind of gross to do all these checks every time we're
393 called, since they don't change once the executable has gotten
394 started. But this is only a temporary hack --- upcoming versions
395 of GNU/Linux will provide a portable, efficient interface for
396 debugging programs that use shared libraries. */
398 struct objfile *objfile;
399 struct minimal_symbol *resolver
400 = find_minsym_and_objfile ("_dl_runtime_resolve", &objfile);
404 struct minimal_symbol *fixup
405 = lookup_minimal_symbol ("fixup", NULL, objfile);
407 if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc)
408 return (SAVED_PC_AFTER_CALL (get_current_frame ()));
414 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c.
416 1) decides whether a PLT has sent us into the linker to resolve
417 a function reference, and
418 2) if so, tells us where to set a temporary breakpoint that will
419 trigger when the dynamic linker is done. */
422 arm_linux_skip_solib_resolver (CORE_ADDR pc)
426 /* Plug in functions for other kinds of resolvers here. */
427 result = skip_hurd_resolver (pc);
435 /* The constants below were determined by examining the following files
436 in the linux kernel sources:
438 arch/arm/kernel/signal.c
439 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
440 include/asm-arm/unistd.h
441 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
443 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
444 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
446 /* arm_linux_in_sigtramp determines if PC points at one of the
447 instructions which cause control to return to the Linux kernel upon
448 return from a signal handler. FUNC_NAME is unused. */
451 arm_linux_in_sigtramp (CORE_ADDR pc, char *func_name)
455 inst = read_memory_integer (pc, 4);
457 return (inst == ARM_LINUX_SIGRETURN_INSTR
458 || inst == ARM_LINUX_RT_SIGRETURN_INSTR);
462 /* arm_linux_sigcontext_register_address returns the address in the
463 sigcontext of register REGNO given a stack pointer value SP and
464 program counter value PC. The value 0 is returned if PC is not
465 pointing at one of the signal return instructions or if REGNO is
466 not saved in the sigcontext struct. */
469 arm_linux_sigcontext_register_address (CORE_ADDR sp, CORE_ADDR pc, int regno)
472 CORE_ADDR reg_addr = 0;
474 inst = read_memory_integer (pc, 4);
476 if (inst == ARM_LINUX_SIGRETURN_INSTR
477 || inst == ARM_LINUX_RT_SIGRETURN_INSTR)
479 CORE_ADDR sigcontext_addr;
481 /* The sigcontext structure is at different places for the two
482 signal return instructions. For ARM_LINUX_SIGRETURN_INSTR,
483 it starts at the SP value. For ARM_LINUX_RT_SIGRETURN_INSTR,
484 it is at SP+8. For the latter instruction, it may also be
485 the case that the address of this structure may be determined
486 by reading the 4 bytes at SP, but I'm not convinced this is
489 In any event, these magic constants (0 and 8) may be
490 determined by examining struct sigframe and struct
491 rt_sigframe in arch/arm/kernel/signal.c in the Linux kernel
494 if (inst == ARM_LINUX_RT_SIGRETURN_INSTR)
495 sigcontext_addr = sp + 8;
496 else /* inst == ARM_LINUX_SIGRETURN_INSTR */
497 sigcontext_addr = sp + 0;
499 /* The layout of the sigcontext structure for ARM GNU/Linux is
500 in include/asm-arm/sigcontext.h in the Linux kernel sources.
502 There are three 4-byte fields which precede the saved r0
503 field. (This accounts for the 12 in the code below.) The
504 sixteen registers (4 bytes per field) follow in order. The
505 PSR value follows the sixteen registers which accounts for
506 the constant 19 below. */
508 if (0 <= regno && regno <= ARM_PC_REGNUM)
509 reg_addr = sigcontext_addr + 12 + (4 * regno);
510 else if (regno == ARM_PS_REGNUM)
511 reg_addr = sigcontext_addr + 19 * 4;
518 arm_linux_init_abi (struct gdbarch_info info,
519 struct gdbarch *gdbarch)
521 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
523 tdep->lowest_pc = 0x8000;
524 tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
525 tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
528 tdep->jb_elt_size = JB_ELEMENT_SIZE;
530 set_gdbarch_call_dummy_words (gdbarch, arm_linux_call_dummy_words);
531 set_gdbarch_sizeof_call_dummy_words (gdbarch,
532 sizeof (arm_linux_call_dummy_words));
534 /* The following two overrides shouldn't be needed. */
535 set_gdbarch_extract_return_value (gdbarch, arm_linux_extract_return_value);
536 set_gdbarch_push_arguments (gdbarch, arm_linux_push_arguments);
540 _initialize_arm_linux_tdep (void)
542 arm_gdbarch_register_os_abi (ARM_ABI_LINUX, arm_linux_init_abi);