1 /* GNU/Linux on ARM target support.
2 Copyright 1999, 2000, 2001, 2002, 2003 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 #include "solib-svr4.h"
34 #include "glibc-tdep.h"
36 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
37 is to execute a particular software interrupt, rather than use a
38 particular undefined instruction to provoke a trap. Upon exection
39 of the software interrupt the kernel stops the inferior with a
40 SIGTRAP, and wakes the debugger. Since ARM GNU/Linux doesn't support
41 Thumb at the moment we only override the ARM breakpoints. */
43 static const char arm_linux_arm_le_breakpoint
[] = { 0x01, 0x00, 0x9f, 0xef };
45 static const char arm_linux_arm_be_breakpoint
[] = { 0xef, 0x9f, 0x00, 0x01 };
47 /* DEPRECATED_CALL_DUMMY_WORDS:
48 This sequence of words is the instructions
54 Note this is 12 bytes. */
56 LONGEST arm_linux_call_dummy_words
[] =
58 0xe1a0e00f, 0xe1a0f004, 0xef9f001
61 /* Description of the longjmp buffer. */
62 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_RAW_SIZE
63 #define ARM_LINUX_JB_PC 21
65 /* Extract from an array REGBUF containing the (raw) register state
66 a function return value of type TYPE, and copy that, in virtual format,
68 /* FIXME rearnsha/2002-02-23: This function shouldn't be necessary.
69 The ARM generic one should be able to handle the model used by
70 linux and the low-level formatting of the registers should be
71 hidden behind the regcache abstraction. */
73 arm_linux_extract_return_value (struct type
*type
,
77 /* ScottB: This needs to be looked at to handle the different
78 floating point emulators on ARM GNU/Linux. Right now the code
79 assumes that fetch inferior registers does the right thing for
80 GDB. I suspect this won't handle NWFPE registers correctly, nor
81 will the default ARM version (arm_extract_return_value()). */
83 int regnum
= ((TYPE_CODE_FLT
== TYPE_CODE (type
))
84 ? ARM_F0_REGNUM
: ARM_A1_REGNUM
);
85 memcpy (valbuf
, ®buf
[DEPRECATED_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 * DEPRECATED_REGISTER_SIZE
; /* Some arguments go into A1-A4. */
118 if (struct_return
) /* The struct address goes in A1. */
119 nstack_size
+= DEPRECATED_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
) && DEPRECATED_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. */
148 argreg
= ARM_A1_REGNUM
;
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
++)
163 enum type_code typecode
;
164 struct type
*arg_type
, *target_type
;
166 arg_type
= check_typedef (VALUE_TYPE (args
[argnum
]));
167 target_type
= TYPE_TARGET_TYPE (arg_type
);
168 len
= TYPE_LENGTH (arg_type
);
169 typecode
= TYPE_CODE (arg_type
);
170 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
172 /* ANSI C code passes float arguments as integers, K&R code
173 passes float arguments as doubles. The .stabs record for
174 for ANSI prototype floating point arguments records the
175 type as FP_INTEGER, while a K&R style (no prototype)
176 .stabs records the type as FP_FLOAT. In this latter case
177 the compiler converts the float arguments to double before
178 calling the function. */
179 if (TYPE_CODE_FLT
== typecode
&& DEPRECATED_REGISTER_SIZE
== len
)
182 dblval
= deprecated_extract_floating (val
, len
);
183 len
= TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
;
185 deprecated_store_floating (val
, len
, dblval
);
188 /* If the argument is a pointer to a function, and it is a Thumb
189 function, set the low bit of the pointer. */
190 if (TYPE_CODE_PTR
== typecode
191 && NULL
!= target_type
192 && TYPE_CODE_FUNC
== TYPE_CODE (target_type
))
194 CORE_ADDR regval
= extract_unsigned_integer (val
, len
);
195 if (arm_pc_is_thumb (regval
))
196 store_unsigned_integer (val
, len
, MAKE_THUMB_ADDR (regval
));
199 /* Copy the argument to general registers or the stack in
200 register-sized pieces. Large arguments are split between
201 registers and stack. */
204 int partial_len
= len
< DEPRECATED_REGISTER_SIZE
? len
: DEPRECATED_REGISTER_SIZE
;
206 if (argreg
<= ARM_LAST_ARG_REGNUM
)
208 /* It's an argument being passed in a general register. */
209 regval
= extract_unsigned_integer (val
, partial_len
);
210 write_register (argreg
++, regval
);
214 /* Push the arguments onto the stack. */
215 write_memory ((CORE_ADDR
) fp
, val
, DEPRECATED_REGISTER_SIZE
);
216 fp
+= DEPRECATED_REGISTER_SIZE
;
224 /* Return adjusted stack pointer. */
229 Dynamic Linking on ARM GNU/Linux
230 --------------------------------
232 Note: PLT = procedure linkage table
233 GOT = global offset table
235 As much as possible, ELF dynamic linking defers the resolution of
236 jump/call addresses until the last minute. The technique used is
237 inspired by the i386 ELF design, and is based on the following
240 1) The calling technique should not force a change in the assembly
241 code produced for apps; it MAY cause changes in the way assembly
242 code is produced for position independent code (i.e. shared
245 2) The technique must be such that all executable areas must not be
246 modified; and any modified areas must not be executed.
248 To do this, there are three steps involved in a typical jump:
252 3) using a pointer from the GOT
254 When the executable or library is first loaded, each GOT entry is
255 initialized to point to the code which implements dynamic name
256 resolution and code finding. This is normally a function in the
257 program interpreter (on ARM GNU/Linux this is usually
258 ld-linux.so.2, but it does not have to be). On the first
259 invocation, the function is located and the GOT entry is replaced
260 with the real function address. Subsequent calls go through steps
261 1, 2 and 3 and end up calling the real code.
268 This is typical ARM code using the 26 bit relative branch or branch
269 and link instructions. The target of the instruction
270 (function_call is usually the address of the function to be called.
271 In position independent code, the target of the instruction is
272 actually an entry in the PLT when calling functions in a shared
273 library. Note that this call is identical to a normal function
274 call, only the target differs.
278 The PLT is a synthetic area, created by the linker. It exists in
279 both executables and libraries. It is an array of stubs, one per
280 imported function call. It looks like this:
283 str lr, [sp, #-4]! @push the return address (lr)
284 ldr lr, [pc, #16] @load from 6 words ahead
285 add lr, pc, lr @form an address for GOT[0]
286 ldr pc, [lr, #8]! @jump to the contents of that addr
288 The return address (lr) is pushed on the stack and used for
289 calculations. The load on the second line loads the lr with
290 &GOT[3] - . - 20. The addition on the third leaves:
292 lr = (&GOT[3] - . - 20) + (. + 8)
296 On the fourth line, the pc and lr are both updated, so that:
302 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
303 "tight", but allows us to keep all the PLT entries the same size.
306 ldr ip, [pc, #4] @load offset from gotoff
307 add ip, pc, ip @add the offset to the pc
308 ldr pc, [ip] @jump to that address
309 gotoff: .word GOT[n+3] - .
311 The load on the first line, gets an offset from the fourth word of
312 the PLT entry. The add on the second line makes ip = &GOT[n+3],
313 which contains either a pointer to PLT[0] (the fixup trampoline) or
314 a pointer to the actual code.
318 The GOT contains helper pointers for both code (PLT) fixups and
319 data fixups. The first 3 entries of the GOT are special. The next
320 M entries (where M is the number of entries in the PLT) belong to
321 the PLT fixups. The next D (all remaining) entries belong to
322 various data fixups. The actual size of the GOT is 3 + M + D.
324 The GOT is also a synthetic area, created by the linker. It exists
325 in both executables and libraries. When the GOT is first
326 initialized , all the GOT entries relating to PLT fixups are
327 pointing to code back at PLT[0].
329 The special entries in the GOT are:
331 GOT[0] = linked list pointer used by the dynamic loader
332 GOT[1] = pointer to the reloc table for this module
333 GOT[2] = pointer to the fixup/resolver code
335 The first invocation of function call comes through and uses the
336 fixup/resolver code. On the entry to the fixup/resolver code:
340 stack[0] = return address (lr) of the function call
341 [r0, r1, r2, r3] are still the arguments to the function call
343 This is enough information for the fixup/resolver code to work
344 with. Before the fixup/resolver code returns, it actually calls
345 the requested function and repairs &GOT[n+3]. */
347 /* Fetch, and possibly build, an appropriate link_map_offsets structure
348 for ARM linux targets using the struct offsets defined in <link.h>.
349 Note, however, that link.h is not actually referred to in this file.
350 Instead, the relevant structs offsets were obtained from examining
351 link.h. (We can't refer to link.h from this file because the host
352 system won't necessarily have it, or if it does, the structs which
353 it defines will refer to the host system, not the target). */
355 static struct link_map_offsets
*
356 arm_linux_svr4_fetch_link_map_offsets (void)
358 static struct link_map_offsets lmo
;
359 static struct link_map_offsets
*lmp
= 0;
365 lmo
.r_debug_size
= 8; /* Actual size is 20, but this is all we
368 lmo
.r_map_offset
= 4;
371 lmo
.link_map_size
= 20; /* Actual size is 552, but this is all we
374 lmo
.l_addr_offset
= 0;
377 lmo
.l_name_offset
= 4;
380 lmo
.l_next_offset
= 12;
383 lmo
.l_prev_offset
= 16;
391 arm_linux_skip_solib_resolver (CORE_ADDR pc
)
393 return glibc_skip_solib_resolver (pc
);
396 /* The constants below were determined by examining the following files
397 in the linux kernel sources:
399 arch/arm/kernel/signal.c
400 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
401 include/asm-arm/unistd.h
402 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
404 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
405 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
407 /* arm_linux_in_sigtramp determines if PC points at one of the
408 instructions which cause control to return to the Linux kernel upon
409 return from a signal handler. FUNC_NAME is unused. */
412 arm_linux_in_sigtramp (CORE_ADDR pc
, char *func_name
)
416 inst
= read_memory_integer (pc
, 4);
418 return (inst
== ARM_LINUX_SIGRETURN_INSTR
419 || inst
== ARM_LINUX_RT_SIGRETURN_INSTR
);
423 /* arm_linux_sigcontext_register_address returns the address in the
424 sigcontext of register REGNO given a stack pointer value SP and
425 program counter value PC. The value 0 is returned if PC is not
426 pointing at one of the signal return instructions or if REGNO is
427 not saved in the sigcontext struct. */
430 arm_linux_sigcontext_register_address (CORE_ADDR sp
, CORE_ADDR pc
, int regno
)
433 CORE_ADDR reg_addr
= 0;
435 inst
= read_memory_integer (pc
, 4);
437 if (inst
== ARM_LINUX_SIGRETURN_INSTR
438 || inst
== ARM_LINUX_RT_SIGRETURN_INSTR
)
440 CORE_ADDR sigcontext_addr
;
442 /* The sigcontext structure is at different places for the two
443 signal return instructions. For ARM_LINUX_SIGRETURN_INSTR,
444 it starts at the SP value. For ARM_LINUX_RT_SIGRETURN_INSTR,
445 it is at SP+8. For the latter instruction, it may also be
446 the case that the address of this structure may be determined
447 by reading the 4 bytes at SP, but I'm not convinced this is
450 In any event, these magic constants (0 and 8) may be
451 determined by examining struct sigframe and struct
452 rt_sigframe in arch/arm/kernel/signal.c in the Linux kernel
455 if (inst
== ARM_LINUX_RT_SIGRETURN_INSTR
)
456 sigcontext_addr
= sp
+ 8;
457 else /* inst == ARM_LINUX_SIGRETURN_INSTR */
458 sigcontext_addr
= sp
+ 0;
460 /* The layout of the sigcontext structure for ARM GNU/Linux is
461 in include/asm-arm/sigcontext.h in the Linux kernel sources.
463 There are three 4-byte fields which precede the saved r0
464 field. (This accounts for the 12 in the code below.) The
465 sixteen registers (4 bytes per field) follow in order. The
466 PSR value follows the sixteen registers which accounts for
467 the constant 19 below. */
469 if (0 <= regno
&& regno
<= ARM_PC_REGNUM
)
470 reg_addr
= sigcontext_addr
+ 12 + (4 * regno
);
471 else if (regno
== ARM_PS_REGNUM
)
472 reg_addr
= sigcontext_addr
+ 19 * 4;
479 arm_linux_init_abi (struct gdbarch_info info
,
480 struct gdbarch
*gdbarch
)
482 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
484 tdep
->lowest_pc
= 0x8000;
485 if (info
.byte_order
== BFD_ENDIAN_BIG
)
486 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
488 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
489 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
491 tdep
->fp_model
= ARM_FLOAT_FPA
;
493 tdep
->jb_pc
= ARM_LINUX_JB_PC
;
494 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
496 set_solib_svr4_fetch_link_map_offsets
497 (gdbarch
, arm_linux_svr4_fetch_link_map_offsets
);
499 set_gdbarch_deprecated_call_dummy_words (gdbarch
, arm_linux_call_dummy_words
);
500 set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch
, sizeof (arm_linux_call_dummy_words
));
502 /* The following two overrides shouldn't be needed. */
503 set_gdbarch_deprecated_extract_return_value (gdbarch
, arm_linux_extract_return_value
);
504 set_gdbarch_deprecated_push_arguments (gdbarch
, arm_linux_push_arguments
);
506 /* Shared library handling. */
507 set_gdbarch_in_solib_call_trampoline (gdbarch
, in_plt_section
);
508 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
512 _initialize_arm_linux_tdep (void)
514 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,