gdb/arm-linux-tdep.c

   1 /* GNU/Linux on ARM target support.
   2    Copyright 1999, 2000, 2001, 2002 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"
  22 #include "target.h"
  23 #include "value.h"
  24 #include "gdbtypes.h"
  25 #include "floatformat.h"
  26 #include "gdbcore.h"
  27 #include "frame.h"
  28 #include "regcache.h"
  29 #include "doublest.h"
  30
  31 #include "arm-tdep.h"
  32
  33 /* For shared library handling.  */
  34 #include "symtab.h"
  35 #include "symfile.h"
  36 #include "objfiles.h"
  37
  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.  */
  45
  46 static const char arm_linux_arm_le_breakpoint[] = {0x01,0x00,0x9f,0xef};
  47
  48 /* CALL_DUMMY_WORDS:
  49    This sequence of words is the instructions
  50
  51    mov  lr, pc
  52    mov  pc, r4
  53    swi  bkpt_swi
  54
  55    Note this is 12 bytes.  */
  56
  57 LONGEST arm_linux_call_dummy_words[] =
  58 {
  59   0xe1a0e00f, 0xe1a0f004, 0xef9f001
  60 };
  61
  62 /* Description of the longjmp buffer.  */
  63 #define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_RAW_SIZE
  64 #define ARM_LINUX_JB_PC                 21
  65
  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,
  68    into VALBUF.  */
  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.  */
  73 static void
  74 arm_linux_extract_return_value (struct type *type,
  75                                 char regbuf[REGISTER_BYTES],
  76                                 char *valbuf)
  77 {
  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()).  */
  83
  84   int regnum = ((TYPE_CODE_FLT == TYPE_CODE (type))
  85                 ? ARM_F0_REGNUM : ARM_A1_REGNUM);
  86   memcpy (valbuf, &regbuf[REGISTER_BYTE (regnum)], TYPE_LENGTH (type));
  87 }
  88
  89 /* Note: ScottB
  90
  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.
  94
  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.
  98
  99            ScottB.  */
 100
 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)
 106
 107 static CORE_ADDR
 108 arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 109                           int struct_return, CORE_ADDR struct_addr)
 110 {
 111   char *fp;
 112   int argnum, argreg, nstack_size;
 113
 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.  */
 118
 119   if (struct_return)                    /* The struct address goes in A1.  */
 120     nstack_size += REGISTER_SIZE;
 121
 122   /* Walk through the arguments and add their size to nstack_size.  */
 123   for (argnum = 0; argnum < nargs; argnum++)
 124     {
 125       int len;
 126       struct type *arg_type;
 127
 128       arg_type = check_typedef (VALUE_TYPE (args[argnum]));
 129       len = TYPE_LENGTH (arg_type);
 130
 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;
 135       else
 136         nstack_size += len;
 137     }
 138
 139   /* Allocate room on the stack, and initialize our stack frame
 140      pointer.  */
 141   fp = NULL;
 142   if (nstack_size > 0)
 143     {
 144       sp -= nstack_size;
 145       fp = (char *) sp;
 146     }
 147
 148   /* Initialize the integer argument register pointer.  */
 149   argreg = ARM_A1_REGNUM;
 150
 151   /* The struct_return pointer occupies the first parameter passing
 152      register.  */
 153   if (struct_return)
 154     write_register (argreg++, struct_addr);
 155
 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++)
 160     {
 161       int len;
 162       char *val;
 163       CORE_ADDR regval;
 164       enum type_code typecode;
 165       struct type *arg_type, *target_type;
 166
 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]);
 172
 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)
 181         {
 182           DOUBLEST dblval;
 183           dblval = extract_floating (val, len);
 184           len = TARGET_DOUBLE_BIT / TARGET_CHAR_BIT;
 185           val = alloca (len);
 186           store_floating (val, len, dblval);
 187         }
 188
 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))
 194         {
 195           CORE_ADDR regval = extract_address (val, len);
 196           if (arm_pc_is_thumb (regval))
 197             store_address (val, len, MAKE_THUMB_ADDR (regval));
 198         }
 199
 200       /* Copy the argument to general registers or the stack in
 201          register-sized pieces.  Large arguments are split between
 202          registers and stack.  */
 203       while (len > 0)
 204         {
 205           int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
 206
 207           if (argreg <= ARM_LAST_ARG_REGNUM)
 208             {
 209               /* It's an argument being passed in a general register.  */
 210               regval = extract_address (val, partial_len);
 211               write_register (argreg++, regval);
 212             }
 213           else
 214             {
 215               /* Push the arguments onto the stack.  */
 216               write_memory ((CORE_ADDR) fp, val, REGISTER_SIZE);
 217               fp += REGISTER_SIZE;
 218             }
 219
 220           len -= partial_len;
 221           val += partial_len;
 222         }
 223     }
 224
 225   /* Return adjusted stack pointer.  */
 226   return sp;
 227 }
 228
 229 /*
 230    Dynamic Linking on ARM GNU/Linux
 231    --------------------------------
 232
 233    Note: PLT = procedure linkage table
 234    GOT = global offset table
 235
 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
 239    constraints.
 240
 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
 244    libraries).
 245
 246    2) The technique must be such that all executable areas must not be
 247    modified; and any modified areas must not be executed.
 248
 249    To do this, there are three steps involved in a typical jump:
 250
 251    1) in the code
 252    2) through the PLT
 253    3) using a pointer from the GOT
 254
 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.
 263
 264    1) In the code:
 265
 266    b    function_call
 267    bl   function_call
 268
 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.
 276
 277    2) In the PLT:
 278
 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:
 282
 283    PLT[0]:
 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
 288
 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:
 292
 293    lr = (&GOT[3] - . - 20) + (. + 8)
 294    lr = (&GOT[3] - 12)
 295    lr = &GOT[0]
 296
 297    On the fourth line, the pc and lr are both updated, so that:
 298
 299    pc = GOT[2]
 300    lr = &GOT[0] + 8
 301    = &GOT[2]
 302
 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.
 305
 306    PLT[n+1]:
 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] - .
 311
 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.
 316
 317    3) In the GOT:
 318
 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.
 324
 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].
 329
 330    The special entries in the GOT are:
 331
 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
 335
 336    The first invocation of function call comes through and uses the
 337    fixup/resolver code.  On the entry to the fixup/resolver code:
 338
 339    ip = &GOT[n+3]
 340    lr = &GOT[2]
 341    stack[0] = return address (lr) of the function call
 342    [r0, r1, r2, r3] are still the arguments to the function call
 343
 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].  */
 347
 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.  */
 353
 354 static struct minimal_symbol *
 355 find_minsym_and_objfile (char *name, struct objfile **objfile_p)
 356 {
 357   struct objfile *objfile;
 358
 359   ALL_OBJFILES (objfile)
 360     {
 361       struct minimal_symbol *msym;
 362
 363       ALL_OBJFILE_MSYMBOLS (objfile, msym)
 364         {
 365           if (SYMBOL_NAME (msym)
 366               && strcmp (SYMBOL_NAME (msym), name) == 0)
 367             {
 368               *objfile_p = objfile;
 369               return msym;
 370             }
 371         }
 372     }
 373
 374   return 0;
 375 }
 376
 377
 378 static CORE_ADDR
 379 skip_hurd_resolver (CORE_ADDR pc)
 380 {
 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
 385      the function.
 386
 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.
 391
 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.  */
 397
 398   struct objfile *objfile;
 399   struct minimal_symbol *resolver
 400     = find_minsym_and_objfile ("_dl_runtime_resolve", &objfile);
 401
 402   if (resolver)
 403     {
 404       struct minimal_symbol *fixup
 405         = lookup_minimal_symbol ("fixup", NULL, objfile);
 406
 407       if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc)
 408         return (SAVED_PC_AFTER_CALL (get_current_frame ()));
 409     }
 410
 411   return 0;
 412 }
 413
 414 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c.
 415    This function:
 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.  */
 420
 421 CORE_ADDR
 422 arm_linux_skip_solib_resolver (CORE_ADDR pc)
 423 {
 424   CORE_ADDR result;
 425
 426   /* Plug in functions for other kinds of resolvers here.  */
 427   result = skip_hurd_resolver (pc);
 428
 429   if (result)
 430     return result;
 431
 432   return 0;
 433 }
 434
 435 /* The constants below were determined by examining the following files
 436    in the linux kernel sources:
 437
 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 */
 442
 443 #define ARM_LINUX_SIGRETURN_INSTR       0xef900077
 444 #define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
 445
 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.  */
 449
 450 int
 451 arm_linux_in_sigtramp (CORE_ADDR pc, char *func_name)
 452 {
 453   unsigned long inst;
 454
 455   inst = read_memory_integer (pc, 4);
 456
 457   return (inst == ARM_LINUX_SIGRETURN_INSTR
 458           || inst == ARM_LINUX_RT_SIGRETURN_INSTR);
 459
 460 }
 461
 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.  */
 467
 468 CORE_ADDR
 469 arm_linux_sigcontext_register_address (CORE_ADDR sp, CORE_ADDR pc, int regno)
 470 {
 471   unsigned long inst;
 472   CORE_ADDR reg_addr = 0;
 473
 474   inst = read_memory_integer (pc, 4);
 475
 476   if (inst == ARM_LINUX_SIGRETURN_INSTR
 477       || inst == ARM_LINUX_RT_SIGRETURN_INSTR)
 478     {
 479       CORE_ADDR sigcontext_addr;
 480
 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
 487          reliable.
 488
 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
 492          sources.  */
 493
 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;
 498
 499       /* The layout of the sigcontext structure for ARM GNU/Linux is
 500          in include/asm-arm/sigcontext.h in the Linux kernel sources.
 501
 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. */
 507
 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;
 512     }
 513
 514   return reg_addr;
 515 }
 516
 517 static void
 518 arm_linux_init_abi (struct gdbarch_info info,
 519                     struct gdbarch *gdbarch)
 520 {
 521   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 522
 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);
 526
 527   tdep->jb_pc = ARM_LINUX_JB_PC;
 528   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
 529
 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));
 533
 534   /* The following two overrides shouldn't be needed.  */
 535   set_gdbarch_deprecated_extract_return_value (gdbarch, arm_linux_extract_return_value);
 536   set_gdbarch_push_arguments (gdbarch, arm_linux_push_arguments);
 537
 538   /* Shared library handling.  */
 539   set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section);
 540   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 541 }
 542
 543 void
 544 _initialize_arm_linux_tdep (void)
 545 {
 546   gdbarch_register_osabi (bfd_arch_arm, GDB_OSABI_LINUX, arm_linux_init_abi);
 547 }