[binutils.git] / gdb / arm-linux-tdep.c

/* GNU/Linux on ARM target support.
   Copyright 1999, 2000 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "target.h"
#include "value.h"
#include "gdbtypes.h"
#include "floatformat.h"

#ifdef GET_LONGJMP_TARGET

/* Figure out where the longjmp will land.  We expect that we have
   just entered longjmp and haven't yet altered r0, r1, so the
   arguments are still in the registers.  (A1_REGNUM) points at the
   jmp_buf structure from which we extract the pc (JB_PC) that we will
   land at.  The pc is copied into ADDR.  This routine returns true on
   success. */

#define LONGJMP_TARGET_SIZE 	sizeof(int)
#define JB_ELEMENT_SIZE		sizeof(int)
#define JB_SL			18
#define JB_FP			19
#define JB_SP			20
#define JB_PC			21

int
arm_get_longjmp_target (CORE_ADDR * pc)
{
  CORE_ADDR jb_addr;
  char buf[LONGJMP_TARGET_SIZE];

  jb_addr = read_register (A1_REGNUM);

  if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
			  LONGJMP_TARGET_SIZE))
    return 0;

  *pc = extract_address (buf, LONGJMP_TARGET_SIZE);
  return 1;
}

#endif /* GET_LONGJMP_TARGET */

/* Extract from an array REGBUF containing the (raw) register state
   a function return value of type TYPE, and copy that, in virtual format,
   into VALBUF.  */

void
arm_linux_extract_return_value (struct type *type,
				char regbuf[REGISTER_BYTES],
				char *valbuf)
{
  /* ScottB: This needs to be looked at to handle the different
     floating point emulators on ARM Linux.  Right now the code
     assumes that fetch inferior registers does the right thing for
     GDB.  I suspect this won't handle NWFPE registers correctly, nor
     will the default ARM version (arm_extract_return_value()).  */

  int regnum = (TYPE_CODE_FLT == TYPE_CODE (type)) ? F0_REGNUM : A1_REGNUM;
  memcpy (valbuf, &regbuf[REGISTER_BYTE (regnum)], TYPE_LENGTH (type));
}

/* Note: ScottB

   This function does not support passing parameters using the FPA
   variant of the APCS.  It passes any floating point arguments in the
   general registers and/or on the stack.
   
   FIXME:  This and arm_push_arguments should be merged.  However this 
   	   function breaks on a little endian host, big endian target
   	   using the COFF file format.  ELF is ok.  
   	   
   	   ScottB.  */
   	   
/* Addresses for calling Thumb functions have the bit 0 set.
   Here are some macros to test, set, or clear bit 0 of addresses.  */
#define IS_THUMB_ADDR(addr)	((addr) & 1)
#define MAKE_THUMB_ADDR(addr)	((addr) | 1)
#define UNMAKE_THUMB_ADDR(addr) ((addr) & ~1)
   	  
CORE_ADDR
arm_linux_push_arguments (int nargs, value_ptr * args, CORE_ADDR sp,
		          int struct_return, CORE_ADDR struct_addr)
{
  char *fp;
  int argnum, argreg, nstack_size;

  /* Walk through the list of args and determine how large a temporary
     stack is required.  Need to take care here as structs may be
     passed on the stack, and we have to to push them.  */
  nstack_size = -4 * REGISTER_SIZE;	/* Some arguments go into A1-A4.  */

  if (struct_return)			/* The struct address goes in A1.  */
    nstack_size += REGISTER_SIZE;

  /* Walk through the arguments and add their size to nstack_size.  */
  for (argnum = 0; argnum < nargs; argnum++)
    {
      int len;
      struct type *arg_type;

      arg_type = check_typedef (VALUE_TYPE (args[argnum]));
      len = TYPE_LENGTH (arg_type);

      /* ANSI C code passes float arguments as integers, K&R code
         passes float arguments as doubles.  Correct for this here.  */
      if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && REGISTER_SIZE == len)
	nstack_size += FP_REGISTER_VIRTUAL_SIZE;
      else
	nstack_size += len;
    }

  /* Allocate room on the stack, and initialize our stack frame
     pointer.  */
  fp = NULL;
  if (nstack_size > 0)
    {
      sp -= nstack_size;
      fp = (char *) sp;
    }

  /* Initialize the integer argument register pointer.  */
  argreg = A1_REGNUM;

  /* The struct_return pointer occupies the first parameter passing
     register.  */
  if (struct_return)
    write_register (argreg++, struct_addr);

  /* Process arguments from left to right.  Store as many as allowed
     in the parameter passing registers (A1-A4), and save the rest on
     the temporary stack.  */
  for (argnum = 0; argnum < nargs; argnum++)
    {
      int len;
      char *val;
      double dbl_arg;
      CORE_ADDR regval;
      enum type_code typecode;
      struct type *arg_type, *target_type;

      arg_type = check_typedef (VALUE_TYPE (args[argnum]));
      target_type = TYPE_TARGET_TYPE (arg_type);
      len = TYPE_LENGTH (arg_type);
      typecode = TYPE_CODE (arg_type);
      val = (char *) VALUE_CONTENTS (args[argnum]);

      /* ANSI C code passes float arguments as integers, K&R code
         passes float arguments as doubles.  The .stabs record for 
         for ANSI prototype floating point arguments records the
         type as FP_INTEGER, while a K&R style (no prototype)
         .stabs records the type as FP_FLOAT.  In this latter case
         the compiler converts the float arguments to double before
         calling the function.  */
      if (TYPE_CODE_FLT == typecode && REGISTER_SIZE == len)
	{
	  /* Float argument in buffer is in host format.  Read it and 
	     convert to DOUBLEST, and store it in target double.  */
	  DOUBLEST dblval;
	  
	  len = TARGET_DOUBLE_BIT / TARGET_CHAR_BIT;
	  floatformat_to_doublest (HOST_FLOAT_FORMAT, val, &dblval);
	  store_floating (&dbl_arg, len, dblval);
	  val = (char *) &dbl_arg;
	}

      /* If the argument is a pointer to a function, and it is a Thumb
         function, set the low bit of the pointer.  */
      if (TYPE_CODE_PTR == typecode
	  && NULL != target_type
	  && TYPE_CODE_FUNC == TYPE_CODE (target_type))
	{
	  CORE_ADDR regval = extract_address (val, len);
	  if (arm_pc_is_thumb (regval))
	    store_address (val, len, MAKE_THUMB_ADDR (regval));
	}

      /* Copy the argument to general registers or the stack in
         register-sized pieces.  Large arguments are split between
         registers and stack.  */
      while (len > 0)
	{
	  int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;

	  if (argreg <= ARM_LAST_ARG_REGNUM)
	    {
	      /* It's an argument being passed in a general register.  */
	      regval = extract_address (val, partial_len);
	      write_register (argreg++, regval);
	    }
	  else
	    {
	      /* Push the arguments onto the stack.  */
	      write_memory ((CORE_ADDR) fp, val, REGISTER_SIZE);
	      fp += REGISTER_SIZE;
	    }

	  len -= partial_len;
	  val += partial_len;
	}
    }

  /* Return adjusted stack pointer.  */
  return sp;
}

/*
   Dynamic Linking on ARM Linux
   ----------------------------

   Note: PLT = procedure linkage table
   GOT = global offset table

   As much as possible, ELF dynamic linking defers the resolution of
   jump/call addresses until the last minute. The technique used is
   inspired by the i386 ELF design, and is based on the following
   constraints.

   1) The calling technique should not force a change in the assembly
   code produced for apps; it MAY cause changes in the way assembly
   code is produced for position independent code (i.e. shared
   libraries).

   2) The technique must be such that all executable areas must not be
   modified; and any modified areas must not be executed.

   To do this, there are three steps involved in a typical jump:

   1) in the code
   2) through the PLT
   3) using a pointer from the GOT

   When the executable or library is first loaded, each GOT entry is
   initialized to point to the code which implements dynamic name
   resolution and code finding.  This is normally a function in the
   program interpreter (on ARM Linux this is usually ld-linux.so.2,
   but it does not have to be).  On the first invocation, the function
   is located and the GOT entry is replaced with the real function
   address.  Subsequent calls go through steps 1, 2 and 3 and end up
   calling the real code.

   1) In the code: 

   b    function_call
   bl   function_call

   This is typical ARM code using the 26 bit relative branch or branch
   and link instructions.  The target of the instruction
   (function_call is usually the address of the function to be called.
   In position independent code, the target of the instruction is
   actually an entry in the PLT when calling functions in a shared
   library.  Note that this call is identical to a normal function
   call, only the target differs.

   2) In the PLT:

   The PLT is a synthetic area, created by the linker. It exists in
   both executables and libraries. It is an array of stubs, one per
   imported function call. It looks like this:

   PLT[0]:
   str     lr, [sp, #-4]!       @push the return address (lr)
   ldr     lr, [pc, #16]   @load from 6 words ahead
   add     lr, pc, lr      @form an address for GOT[0]
   ldr     pc, [lr, #8]!   @jump to the contents of that addr

   The return address (lr) is pushed on the stack and used for
   calculations.  The load on the second line loads the lr with
   &GOT[3] - . - 20.  The addition on the third leaves:

   lr = (&GOT[3] - . - 20) + (. + 8)
   lr = (&GOT[3] - 12)
   lr = &GOT[0]

   On the fourth line, the pc and lr are both updated, so that:

   pc = GOT[2]
   lr = &GOT[0] + 8
   = &GOT[2]

   NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
   "tight", but allows us to keep all the PLT entries the same size.

   PLT[n+1]:
   ldr     ip, [pc, #4]    @load offset from gotoff
   add     ip, pc, ip      @add the offset to the pc
   ldr     pc, [ip]        @jump to that address
   gotoff: .word   GOT[n+3] - .

   The load on the first line, gets an offset from the fourth word of
   the PLT entry.  The add on the second line makes ip = &GOT[n+3],
   which contains either a pointer to PLT[0] (the fixup trampoline) or
   a pointer to the actual code.

   3) In the GOT:

   The GOT contains helper pointers for both code (PLT) fixups and
   data fixups.  The first 3 entries of the GOT are special. The next
   M entries (where M is the number of entries in the PLT) belong to
   the PLT fixups. The next D (all remaining) entries belong to
   various data fixups. The actual size of the GOT is 3 + M + D.

   The GOT is also a synthetic area, created by the linker. It exists
   in both executables and libraries.  When the GOT is first
   initialized , all the GOT entries relating to PLT fixups are
   pointing to code back at PLT[0].

   The special entries in the GOT are:

   GOT[0] = linked list pointer used by the dynamic loader
   GOT[1] = pointer to the reloc table for this module
   GOT[2] = pointer to the fixup/resolver code

   The first invocation of function call comes through and uses the
   fixup/resolver code.  On the entry to the fixup/resolver code:

   ip = &GOT[n+3]
   lr = &GOT[2]
   stack[0] = return address (lr) of the function call
   [r0, r1, r2, r3] are still the arguments to the function call

   This is enough information for the fixup/resolver code to work
   with.  Before the fixup/resolver code returns, it actually calls
   the requested function and repairs &GOT[n+3].  */

CORE_ADDR
arm_skip_solib_resolver (CORE_ADDR pc)
{
  /* FIXME */
  return 0;
}

void
_initialize_arm_linux_tdep (void)
{
}
Commit	Line	Data
faf5f7ad SB	1	/* GNU/Linux on ARM target support.
	2	Copyright 1999, 2000 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	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.
	10
	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.
	15
	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. */
	20
	21	#include "defs.h"
c20f6dea SB	22	#include "target.h"
c20f6dea SB	23	#include "value.h"
faf5f7ad	24	#include "gdbtypes.h"
134e61c4	25	#include "floatformat.h"
faf5f7ad SB	26
	27	#ifdef GET_LONGJMP_TARGET
	28
	29	/* Figure out where the longjmp will land. We expect that we have
	30	just entered longjmp and haven't yet altered r0, r1, so the
	31	arguments are still in the registers. (A1_REGNUM) points at the
	32	jmp_buf structure from which we extract the pc (JB_PC) that we will
	33	land at. The pc is copied into ADDR. This routine returns true on
	34	success. */
	35
	36	#define LONGJMP_TARGET_SIZE sizeof(int)
	37	#define JB_ELEMENT_SIZE sizeof(int)
	38	#define JB_SL 18
	39	#define JB_FP 19
	40	#define JB_SP 20
	41	#define JB_PC 21
	42
	43	int
	44	arm_get_longjmp_target (CORE_ADDR * pc)
	45	{
	46	CORE_ADDR jb_addr;
	47	char buf[LONGJMP_TARGET_SIZE];
	48
	49	jb_addr = read_register (A1_REGNUM);
	50
	51	if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
	52	LONGJMP_TARGET_SIZE))
	53	return 0;
	54
	55	*pc = extract_address (buf, LONGJMP_TARGET_SIZE);
	56	return 1;
	57	}
	58
	59	#endif /* GET_LONGJMP_TARGET */
	60
	61	/* Extract from an array REGBUF containing the (raw) register state
	62	a function return value of type TYPE, and copy that, in virtual format,
	63	into VALBUF. */
	64
	65	void
	66	arm_linux_extract_return_value (struct type *type,
	67	char regbuf[REGISTER_BYTES],
	68	char *valbuf)
	69	{
	70	/* ScottB: This needs to be looked at to handle the different
	71	floating point emulators on ARM Linux. Right now the code
	72	assumes that fetch inferior registers does the right thing for
	73	GDB. I suspect this won't handle NWFPE registers correctly, nor
	74	will the default ARM version (arm_extract_return_value()). */
	75
	76	int regnum = (TYPE_CODE_FLT == TYPE_CODE (type)) ? F0_REGNUM : A1_REGNUM;
	77	memcpy (valbuf, &regbuf[REGISTER_BYTE (regnum)], TYPE_LENGTH (type));
	78	}
	79
134e61c4 SB	80	/* Note: ScottB
	81
	82	This function does not support passing parameters using the FPA
	83	variant of the APCS. It passes any floating point arguments in the
	84	general registers and/or on the stack.
	85
	86	FIXME: This and arm_push_arguments should be merged. However this
	87	function breaks on a little endian host, big endian target
	88	using the COFF file format. ELF is ok.
	89
	90	ScottB. */
	91
	92	/* Addresses for calling Thumb functions have the bit 0 set.
	93	Here are some macros to test, set, or clear bit 0 of addresses. */
	94	#define IS_THUMB_ADDR(addr) ((addr) & 1)
	95	#define MAKE_THUMB_ADDR(addr) ((addr) \| 1)
	96	#define UNMAKE_THUMB_ADDR(addr) ((addr) & ~1)
	97
	98	CORE_ADDR
	99	arm_linux_push_arguments (int nargs, value_ptr * args, CORE_ADDR sp,
	100	int struct_return, CORE_ADDR struct_addr)
	101	{
	102	char *fp;
	103	int argnum, argreg, nstack_size;
	104
	105	/* Walk through the list of args and determine how large a temporary
	106	stack is required. Need to take care here as structs may be
	107	passed on the stack, and we have to to push them. */
	108	nstack_size = -4 * REGISTER_SIZE; /* Some arguments go into A1-A4. */
	109
	110	if (struct_return) /* The struct address goes in A1. */
	111	nstack_size += REGISTER_SIZE;
	112
	113	/* Walk through the arguments and add their size to nstack_size. */
	114	for (argnum = 0; argnum < nargs; argnum++)
	115	{
	116	int len;
	117	struct type *arg_type;
	118
	119	arg_type = check_typedef (VALUE_TYPE (args[argnum]));
	120	len = TYPE_LENGTH (arg_type);
	121
	122	/* ANSI C code passes float arguments as integers, K&R code
	123	passes float arguments as doubles. Correct for this here. */
	124	if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && REGISTER_SIZE == len)
	125	nstack_size += FP_REGISTER_VIRTUAL_SIZE;
	126	else
	127	nstack_size += len;
	128	}
	129
	130	/* Allocate room on the stack, and initialize our stack frame
	131	pointer. */
	132	fp = NULL;
	133	if (nstack_size > 0)
	134	{
	135	sp -= nstack_size;
	136	fp = (char *) sp;
	137	}
	138
	139	/* Initialize the integer argument register pointer. */
	140	argreg = A1_REGNUM;
	141
	142	/* The struct_return pointer occupies the first parameter passing
	143	register. */
144	if (struct_return)
145	write_register (argreg++, struct_addr);
146
147	/* Process arguments from left to right. Store as many as allowed
148	in the parameter passing registers (A1-A4), and save the rest on
149	the temporary stack. */
150	for (argnum = 0; argnum < nargs; argnum++)
151	{
152	int len;
153	char *val;
154	double dbl_arg;
155	CORE_ADDR regval;
156	enum type_code typecode;
157	struct type arg_type, target_type;
158
159	arg_type = check_typedef (VALUE_TYPE (args[argnum]));
160	target_type = TYPE_TARGET_TYPE (arg_type);
161	len = TYPE_LENGTH (arg_type);
162	typecode = TYPE_CODE (arg_type);
163	val = (char *) VALUE_CONTENTS (args[argnum]);
164
165	/* ANSI C code passes float arguments as integers, K&R code
166	passes float arguments as doubles. The .stabs record for
167	for ANSI prototype floating point arguments records the
168	type as FP_INTEGER, while a K&R style (no prototype)
169	.stabs records the type as FP_FLOAT. In this latter case
170	the compiler converts the float arguments to double before
171	calling the function. */
172	if (TYPE_CODE_FLT == typecode && REGISTER_SIZE == len)
173	{
174	/* Float argument in buffer is in host format. Read it and
175	convert to DOUBLEST, and store it in target double. */
176	DOUBLEST dblval;
177
178	len = TARGET_DOUBLE_BIT / TARGET_CHAR_BIT;
179	floatformat_to_doublest (HOST_FLOAT_FORMAT, val, &dblval);
180	store_floating (&dbl_arg, len, dblval);
181	val = (char *) &dbl_arg;
182	}
183
184	/* If the argument is a pointer to a function, and it is a Thumb
185	function, set the low bit of the pointer. */
186	if (TYPE_CODE_PTR == typecode
187	&& NULL != target_type
188	&& TYPE_CODE_FUNC == TYPE_CODE (target_type))
189	{
190	CORE_ADDR regval = extract_address (val, len);
191	if (arm_pc_is_thumb (regval))
192	store_address (val, len, MAKE_THUMB_ADDR (regval));
193	}
194
195	/* Copy the argument to general registers or the stack in
196	register-sized pieces. Large arguments are split between
197	registers and stack. */
198	while (len > 0)
199	{
200	int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
201
202	if (argreg <= ARM_LAST_ARG_REGNUM)
203	{
204	/* It's an argument being passed in a general register. */
205	regval = extract_address (val, partial_len);
206	write_register (argreg++, regval);
207	}
208	else
209	{
210	/* Push the arguments onto the stack. */
211	write_memory ((CORE_ADDR) fp, val, REGISTER_SIZE);
212	fp += REGISTER_SIZE;
213	}
214
215	len -= partial_len;
216	val += partial_len;
217	}
218	}
219
220	/* Return adjusted stack pointer. */
221	return sp;
222	}
223
f38e884d SB	224	/*
	225	Dynamic Linking on ARM Linux
	226	----------------------------
	227
	228	Note: PLT = procedure linkage table
	229	GOT = global offset table
	230
	231	As much as possible, ELF dynamic linking defers the resolution of
	232	jump/call addresses until the last minute. The technique used is
	233	inspired by the i386 ELF design, and is based on the following
	234	constraints.
	235
	236	1) The calling technique should not force a change in the assembly
	237	code produced for apps; it MAY cause changes in the way assembly
	238	code is produced for position independent code (i.e. shared
	239	libraries).
	240
	241	2) The technique must be such that all executable areas must not be
	242	modified; and any modified areas must not be executed.
	243
	244	To do this, there are three steps involved in a typical jump:
	245
	246	1) in the code
	247	2) through the PLT
	248	3) using a pointer from the GOT
	249
	250	When the executable or library is first loaded, each GOT entry is
	251	initialized to point to the code which implements dynamic name
	252	resolution and code finding. This is normally a function in the
	253	program interpreter (on ARM Linux this is usually ld-linux.so.2,
	254	but it does not have to be). On the first invocation, the function
	255	is located and the GOT entry is replaced with the real function
	256	address. Subsequent calls go through steps 1, 2 and 3 and end up
	257	calling the real code.
	258
	259	1) In the code:
	260
	261	b function_call
	262	bl function_call
	263
	264	This is typical ARM code using the 26 bit relative branch or branch
	265	and link instructions. The target of the instruction
	266	(function_call is usually the address of the function to be called.
	267	In position independent code, the target of the instruction is
	268	actually an entry in the PLT when calling functions in a shared
	269	library. Note that this call is identical to a normal function
	270	call, only the target differs.
	271
	272	2) In the PLT:
	273
	274	The PLT is a synthetic area, created by the linker. It exists in
	275	both executables and libraries. It is an array of stubs, one per
	276	imported function call. It looks like this:
	277
	278	PLT[0]:
	279	str lr, [sp, #-4]! @push the return address (lr)
	280	ldr lr, [pc, #16] @load from 6 words ahead
	281	add lr, pc, lr @form an address for GOT[0]
	282	ldr pc, [lr, #8]! @jump to the contents of that addr
	283
	284	The return address (lr) is pushed on the stack and used for
	285	calculations. The load on the second line loads the lr with
	286	&GOT[3] - . - 20. The addition on the third leaves:
	287
288	lr = (&GOT[3] - . - 20) + (. + 8)
289	lr = (&GOT[3] - 12)
290	lr = &GOT[0]
291
292	On the fourth line, the pc and lr are both updated, so that:
293
294	pc = GOT[2]
295	lr = &GOT[0] + 8
296	= &GOT[2]
297
298	NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
299	"tight", but allows us to keep all the PLT entries the same size.
300
301	PLT[n+1]:
302	ldr ip, [pc, #4] @load offset from gotoff
303	add ip, pc, ip @add the offset to the pc
304	ldr pc, [ip] @jump to that address
305	gotoff: .word GOT[n+3] - .
306
307	The load on the first line, gets an offset from the fourth word of
308	the PLT entry. The add on the second line makes ip = &GOT[n+3],
309	which contains either a pointer to PLT[0] (the fixup trampoline) or
310	a pointer to the actual code.
311
312	3) In the GOT:
313
314	The GOT contains helper pointers for both code (PLT) fixups and
315	data fixups. The first 3 entries of the GOT are special. The next
316	M entries (where M is the number of entries in the PLT) belong to
317	the PLT fixups. The next D (all remaining) entries belong to
318	various data fixups. The actual size of the GOT is 3 + M + D.
319
320	The GOT is also a synthetic area, created by the linker. It exists
321	in both executables and libraries. When the GOT is first
322	initialized , all the GOT entries relating to PLT fixups are
323	pointing to code back at PLT[0].
324
325	The special entries in the GOT are:
326
327	GOT[0] = linked list pointer used by the dynamic loader
328	GOT[1] = pointer to the reloc table for this module
329	GOT[2] = pointer to the fixup/resolver code
330
331	The first invocation of function call comes through and uses the
332	fixup/resolver code. On the entry to the fixup/resolver code:
333
334	ip = &GOT[n+3]
335	lr = &GOT[2]
336	stack[0] = return address (lr) of the function call
337	[r0, r1, r2, r3] are still the arguments to the function call
338
339	This is enough information for the fixup/resolver code to work
340	with. Before the fixup/resolver code returns, it actually calls
341	the requested function and repairs &GOT[n+3]. */
342
343	CORE_ADDR
344	arm_skip_solib_resolver (CORE_ADDR pc)
345	{
346	/* FIXME */
347	return 0;
348	}
349
faf5f7ad SB	350	void
	351	_initialize_arm_linux_tdep (void)
	352	{
	353	}