1 /* GNU/Linux on ARM target support.
2 Copyright 1999, 2000, 2001 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"
30 /* For arm_linux_skip_solib_resolver. */
35 #ifdef GET_LONGJMP_TARGET
37 /* Figure out where the longjmp will land. We expect that we have
38 just entered longjmp and haven't yet altered r0, r1, so the
39 arguments are still in the registers. (A1_REGNUM) points at the
40 jmp_buf structure from which we extract the pc (JB_PC) that we will
41 land at. The pc is copied into ADDR. This routine returns true on
44 #define LONGJMP_TARGET_SIZE sizeof(int)
45 #define JB_ELEMENT_SIZE sizeof(int)
52 arm_get_longjmp_target (CORE_ADDR
* pc
)
55 char buf
[LONGJMP_TARGET_SIZE
];
57 jb_addr
= read_register (A1_REGNUM
);
59 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
63 *pc
= extract_address (buf
, LONGJMP_TARGET_SIZE
);
67 #endif /* GET_LONGJMP_TARGET */
69 /* Extract from an array REGBUF containing the (raw) register state
70 a function return value of type TYPE, and copy that, in virtual format,
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 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
)) ? F0_REGNUM
: A1_REGNUM
;
85 memcpy (valbuf
, ®buf
[REGISTER_BYTE (regnum
)], TYPE_LENGTH (type
));
90 This function does not support passing parameters using the FPA
91 variant of the APCS. It passes any floating point arguments in the
92 general registers and/or on the stack.
94 FIXME: This and arm_push_arguments should be merged. However this
95 function breaks on a little endian host, big endian target
96 using the COFF file format. ELF is ok.
100 /* Addresses for calling Thumb functions have the bit 0 set.
101 Here are some macros to test, set, or clear bit 0 of addresses. */
102 #define IS_THUMB_ADDR(addr) ((addr) & 1)
103 #define MAKE_THUMB_ADDR(addr) ((addr) | 1)
104 #define UNMAKE_THUMB_ADDR(addr) ((addr) & ~1)
107 arm_linux_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
108 int struct_return
, CORE_ADDR struct_addr
)
111 int argnum
, argreg
, nstack_size
;
113 /* Walk through the list of args and determine how large a temporary
114 stack is required. Need to take care here as structs may be
115 passed on the stack, and we have to to push them. */
116 nstack_size
= -4 * REGISTER_SIZE
; /* Some arguments go into A1-A4. */
118 if (struct_return
) /* The struct address goes in A1. */
119 nstack_size
+= REGISTER_SIZE
;
121 /* Walk through the arguments and add their size to nstack_size. */
122 for (argnum
= 0; argnum
< nargs
; argnum
++)
125 struct type
*arg_type
;
127 arg_type
= check_typedef (VALUE_TYPE (args
[argnum
]));
128 len
= TYPE_LENGTH (arg_type
);
130 /* ANSI C code passes float arguments as integers, K&R code
131 passes float arguments as doubles. Correct for this here. */
132 if (TYPE_CODE_FLT
== TYPE_CODE (arg_type
) && REGISTER_SIZE
== len
)
133 nstack_size
+= FP_REGISTER_VIRTUAL_SIZE
;
138 /* Allocate room on the stack, and initialize our stack frame
147 /* Initialize the integer argument register pointer. */
150 /* The struct_return pointer occupies the first parameter passing
153 write_register (argreg
++, struct_addr
);
155 /* Process arguments from left to right. Store as many as allowed
156 in the parameter passing registers (A1-A4), and save the rest on
157 the temporary stack. */
158 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
)
182 /* Float argument in buffer is in host format. Read it and
183 convert to DOUBLEST, and store it in target double. */
186 len
= TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
;
187 floatformat_to_doublest (HOST_FLOAT_FORMAT
, val
, &dblval
);
188 store_floating (&dbl_arg
, len
, dblval
);
189 val
= (char *) &dbl_arg
;
192 /* If the argument is a pointer to a function, and it is a Thumb
193 function, set the low bit of the pointer. */
194 if (TYPE_CODE_PTR
== typecode
195 && NULL
!= target_type
196 && TYPE_CODE_FUNC
== TYPE_CODE (target_type
))
198 CORE_ADDR regval
= extract_address (val
, len
);
199 if (arm_pc_is_thumb (regval
))
200 store_address (val
, len
, MAKE_THUMB_ADDR (regval
));
203 /* Copy the argument to general registers or the stack in
204 register-sized pieces. Large arguments are split between
205 registers and stack. */
208 int partial_len
= len
< REGISTER_SIZE
? len
: REGISTER_SIZE
;
210 if (argreg
<= ARM_LAST_ARG_REGNUM
)
212 /* It's an argument being passed in a general register. */
213 regval
= extract_address (val
, partial_len
);
214 write_register (argreg
++, regval
);
218 /* Push the arguments onto the stack. */
219 write_memory ((CORE_ADDR
) fp
, val
, REGISTER_SIZE
);
228 /* Return adjusted stack pointer. */
233 Dynamic Linking on ARM Linux
234 ----------------------------
236 Note: PLT = procedure linkage table
237 GOT = global offset table
239 As much as possible, ELF dynamic linking defers the resolution of
240 jump/call addresses until the last minute. The technique used is
241 inspired by the i386 ELF design, and is based on the following
244 1) The calling technique should not force a change in the assembly
245 code produced for apps; it MAY cause changes in the way assembly
246 code is produced for position independent code (i.e. shared
249 2) The technique must be such that all executable areas must not be
250 modified; and any modified areas must not be executed.
252 To do this, there are three steps involved in a typical jump:
256 3) using a pointer from the GOT
258 When the executable or library is first loaded, each GOT entry is
259 initialized to point to the code which implements dynamic name
260 resolution and code finding. This is normally a function in the
261 program interpreter (on ARM Linux this is usually ld-linux.so.2,
262 but it does not have to be). On the first invocation, the function
263 is located and the GOT entry is replaced with the real function
264 address. Subsequent calls go through steps 1, 2 and 3 and end up
265 calling the real code.
272 This is typical ARM code using the 26 bit relative branch or branch
273 and link instructions. The target of the instruction
274 (function_call is usually the address of the function to be called.
275 In position independent code, the target of the instruction is
276 actually an entry in the PLT when calling functions in a shared
277 library. Note that this call is identical to a normal function
278 call, only the target differs.
282 The PLT is a synthetic area, created by the linker. It exists in
283 both executables and libraries. It is an array of stubs, one per
284 imported function call. It looks like this:
287 str lr, [sp, #-4]! @push the return address (lr)
288 ldr lr, [pc, #16] @load from 6 words ahead
289 add lr, pc, lr @form an address for GOT[0]
290 ldr pc, [lr, #8]! @jump to the contents of that addr
292 The return address (lr) is pushed on the stack and used for
293 calculations. The load on the second line loads the lr with
294 &GOT[3] - . - 20. The addition on the third leaves:
296 lr = (&GOT[3] - . - 20) + (. + 8)
300 On the fourth line, the pc and lr are both updated, so that:
306 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
307 "tight", but allows us to keep all the PLT entries the same size.
310 ldr ip, [pc, #4] @load offset from gotoff
311 add ip, pc, ip @add the offset to the pc
312 ldr pc, [ip] @jump to that address
313 gotoff: .word GOT[n+3] - .
315 The load on the first line, gets an offset from the fourth word of
316 the PLT entry. The add on the second line makes ip = &GOT[n+3],
317 which contains either a pointer to PLT[0] (the fixup trampoline) or
318 a pointer to the actual code.
322 The GOT contains helper pointers for both code (PLT) fixups and
323 data fixups. The first 3 entries of the GOT are special. The next
324 M entries (where M is the number of entries in the PLT) belong to
325 the PLT fixups. The next D (all remaining) entries belong to
326 various data fixups. The actual size of the GOT is 3 + M + D.
328 The GOT is also a synthetic area, created by the linker. It exists
329 in both executables and libraries. When the GOT is first
330 initialized , all the GOT entries relating to PLT fixups are
331 pointing to code back at PLT[0].
333 The special entries in the GOT are:
335 GOT[0] = linked list pointer used by the dynamic loader
336 GOT[1] = pointer to the reloc table for this module
337 GOT[2] = pointer to the fixup/resolver code
339 The first invocation of function call comes through and uses the
340 fixup/resolver code. On the entry to the fixup/resolver code:
344 stack[0] = return address (lr) of the function call
345 [r0, r1, r2, r3] are still the arguments to the function call
347 This is enough information for the fixup/resolver code to work
348 with. Before the fixup/resolver code returns, it actually calls
349 the requested function and repairs &GOT[n+3]. */
351 /* Find the minimal symbol named NAME, and return both the minsym
352 struct and its objfile. This probably ought to be in minsym.c, but
353 everything there is trying to deal with things like C++ and
354 SOFUN_ADDRESS_MAYBE_TURQUOISE, ... Since this is so simple, it may
355 be considered too special-purpose for general consumption. */
357 static struct minimal_symbol
*
358 find_minsym_and_objfile (char *name
, struct objfile
**objfile_p
)
360 struct objfile
*objfile
;
362 ALL_OBJFILES (objfile
)
364 struct minimal_symbol
*msym
;
366 ALL_OBJFILE_MSYMBOLS (objfile
, msym
)
368 if (SYMBOL_NAME (msym
)
369 && STREQ (SYMBOL_NAME (msym
), name
))
371 *objfile_p
= objfile
;
382 skip_hurd_resolver (CORE_ADDR pc
)
384 /* The HURD dynamic linker is part of the GNU C library, so many
385 GNU/Linux distributions use it. (All ELF versions, as far as I
386 know.) An unresolved PLT entry points to "_dl_runtime_resolve",
387 which calls "fixup" to patch the PLT, and then passes control to
390 We look for the symbol `_dl_runtime_resolve', and find `fixup' in
391 the same objfile. If we are at the entry point of `fixup', then
392 we set a breakpoint at the return address (at the top of the
393 stack), and continue.
395 It's kind of gross to do all these checks every time we're
396 called, since they don't change once the executable has gotten
397 started. But this is only a temporary hack --- upcoming versions
398 of Linux will provide a portable, efficient interface for
399 debugging programs that use shared libraries. */
401 struct objfile
*objfile
;
402 struct minimal_symbol
*resolver
403 = find_minsym_and_objfile ("_dl_runtime_resolve", &objfile
);
407 struct minimal_symbol
*fixup
408 = lookup_minimal_symbol ("fixup", 0, objfile
);
410 if (fixup
&& SYMBOL_VALUE_ADDRESS (fixup
) == pc
)
411 return (SAVED_PC_AFTER_CALL (get_current_frame ()));
417 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c.
419 1) decides whether a PLT has sent us into the linker to resolve
420 a function reference, and
421 2) if so, tells us where to set a temporary breakpoint that will
422 trigger when the dynamic linker is done. */
425 arm_linux_skip_solib_resolver (CORE_ADDR pc
)
429 /* Plug in functions for other kinds of resolvers here. */
430 result
= skip_hurd_resolver (pc
);
438 /* The constants below were determined by examining the following files
439 in the linux kernel sources:
441 arch/arm/kernel/signal.c
442 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
443 include/asm-arm/unistd.h
444 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
446 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
447 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
449 /* arm_linux_in_sigtramp determines if PC points at one of the
450 instructions which cause control to return to the Linux kernel upon
451 return from a signal handler. FUNC_NAME is unused. */
454 arm_linux_in_sigtramp (CORE_ADDR pc
, char *func_name
)
458 inst
= read_memory_integer (pc
, 4);
460 return (inst
== ARM_LINUX_SIGRETURN_INSTR
461 || inst
== ARM_LINUX_RT_SIGRETURN_INSTR
);
465 /* arm_linux_sigcontext_register_address returns the address in the
466 sigcontext of register REGNO given a stack pointer value SP and
467 program counter value PC. The value 0 is returned if PC is not
468 pointing at one of the signal return instructions or if REGNO is
469 not saved in the sigcontext struct. */
472 arm_linux_sigcontext_register_address (CORE_ADDR sp
, CORE_ADDR pc
, int regno
)
475 CORE_ADDR reg_addr
= 0;
477 inst
= read_memory_integer (pc
, 4);
479 if (inst
== ARM_LINUX_SIGRETURN_INSTR
|| inst
== ARM_LINUX_RT_SIGRETURN_INSTR
)
481 CORE_ADDR sigcontext_addr
;
483 /* The sigcontext structure is at different places for the two
484 signal return instructions. For ARM_LINUX_SIGRETURN_INSTR,
485 it starts at the SP value. For ARM_LINUX_RT_SIGRETURN_INSTR,
486 it is at SP+8. For the latter instruction, it may also be
487 the case that the address of this structure may be determined
488 by reading the 4 bytes at SP, but I'm not convinced this is
491 In any event, these magic constants (0 and 8) may be
492 determined by examining struct sigframe and struct
493 rt_sigframe in arch/arm/kernel/signal.c in the Linux kernel
496 if (inst
== ARM_LINUX_RT_SIGRETURN_INSTR
)
497 sigcontext_addr
= sp
+ 8;
498 else /* inst == ARM_LINUX_SIGRETURN_INSTR */
499 sigcontext_addr
= sp
+ 0;
501 /* The layout of the sigcontext structure for ARM GNU/Linux is
502 in include/asm-arm/sigcontext.h in the Linux kernel sources.
504 There are three 4-byte fields which precede the saved r0
505 field. (This accounts for the 12 in the code below.) The
506 sixteen registers (4 bytes per field) follow in order. The
507 PSR value follows the sixteen registers which accounts for
508 the constant 19 below. */
510 if (0 <= regno
&& regno
<= PC_REGNUM
)
511 reg_addr
= sigcontext_addr
+ 12 + (4 * regno
);
512 else if (regno
== PS_REGNUM
)
513 reg_addr
= sigcontext_addr
+ 19 * 4;
520 _initialize_arm_linux_tdep (void)