gdb/arm-linux-tdep.c

   1 /* GNU/Linux on ARM target support.
   2    Copyright 1999, 2000, 2001, 2002, 2003 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 #include "solib-svr4.h"
  31 #include "osabi.h"
  32
  33 #include "arm-tdep.h"
  34
  35 /* For shared library handling.  */
  36 #include "symtab.h"
  37 #include "symfile.h"
  38 #include "objfiles.h"
  39
  40 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
  41    is to execute a particular software interrupt, rather than use a
  42    particular undefined instruction to provoke a trap.  Upon exection
  43    of the software interrupt the kernel stops the inferior with a
  44    SIGTRAP, and wakes the debugger.  Since ARM GNU/Linux doesn't support
  45    Thumb at the moment we only override the ARM breakpoints.  */
  46
  47 static const char arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
  48
  49 static const char arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
  50
  51 /* DEPRECATED_CALL_DUMMY_WORDS:
  52    This sequence of words is the instructions
  53
  54    mov  lr, pc
  55    mov  pc, r4
  56    swi  bkpt_swi
  57
  58    Note this is 12 bytes.  */
  59
  60 LONGEST arm_linux_call_dummy_words[] =
  61 {
  62   0xe1a0e00f, 0xe1a0f004, 0xef9f001
  63 };
  64
  65 /* Description of the longjmp buffer.  */
  66 #define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_RAW_SIZE
  67 #define ARM_LINUX_JB_PC                 21
  68
  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,
  71    into VALBUF.  */
  72 /* FIXME rearnsha/2002-02-23: This function shouldn't be necessary.
  73    The ARM generic one should be able to handle the model used by
  74    linux and the low-level formatting of the registers should be
  75    hidden behind the regcache abstraction.  */
  76 static void
  77 arm_linux_extract_return_value (struct type *type,
  78                                 char regbuf[],
  79                                 char *valbuf)
  80 {
  81   /* ScottB: This needs to be looked at to handle the different
  82      floating point emulators on ARM GNU/Linux.  Right now the code
  83      assumes that fetch inferior registers does the right thing for
  84      GDB.  I suspect this won't handle NWFPE registers correctly, nor
  85      will the default ARM version (arm_extract_return_value()).  */
  86
  87   int regnum = ((TYPE_CODE_FLT == TYPE_CODE (type))
  88                 ? ARM_F0_REGNUM : ARM_A1_REGNUM);
  89   memcpy (valbuf, &regbuf[REGISTER_BYTE (regnum)], TYPE_LENGTH (type));
  90 }
  91
  92 /* Note: ScottB
  93
  94    This function does not support passing parameters using the FPA
  95    variant of the APCS.  It passes any floating point arguments in the
  96    general registers and/or on the stack.
  97
  98    FIXME:  This and arm_push_arguments should be merged.  However this
  99            function breaks on a little endian host, big endian target
 100            using the COFF file format.  ELF is ok.
 101
 102            ScottB.  */
 103
 104 /* Addresses for calling Thumb functions have the bit 0 set.
 105    Here are some macros to test, set, or clear bit 0 of addresses.  */
 106 #define IS_THUMB_ADDR(addr)     ((addr) & 1)
 107 #define MAKE_THUMB_ADDR(addr)   ((addr) | 1)
 108 #define UNMAKE_THUMB_ADDR(addr) ((addr) & ~1)
 109
 110 static CORE_ADDR
 111 arm_linux_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 112                           int struct_return, CORE_ADDR struct_addr)
 113 {
 114   char *fp;
 115   int argnum, argreg, nstack_size;
 116
 117   /* Walk through the list of args and determine how large a temporary
 118      stack is required.  Need to take care here as structs may be
 119      passed on the stack, and we have to to push them.  */
 120   nstack_size = -4 * DEPRECATED_REGISTER_SIZE;  /* Some arguments go into A1-A4.  */
 121
 122   if (struct_return)                    /* The struct address goes in A1.  */
 123     nstack_size += DEPRECATED_REGISTER_SIZE;
 124
 125   /* Walk through the arguments and add their size to nstack_size.  */
 126   for (argnum = 0; argnum < nargs; argnum++)
 127     {
 128       int len;
 129       struct type *arg_type;
 130
 131       arg_type = check_typedef (VALUE_TYPE (args[argnum]));
 132       len = TYPE_LENGTH (arg_type);
 133
 134       /* ANSI C code passes float arguments as integers, K&R code
 135          passes float arguments as doubles.  Correct for this here.  */
 136       if (TYPE_CODE_FLT == TYPE_CODE (arg_type) && DEPRECATED_REGISTER_SIZE == len)
 137         nstack_size += FP_REGISTER_VIRTUAL_SIZE;
 138       else
 139         nstack_size += len;
 140     }
 141
 142   /* Allocate room on the stack, and initialize our stack frame
 143      pointer.  */
 144   fp = NULL;
 145   if (nstack_size > 0)
 146     {
 147       sp -= nstack_size;
 148       fp = (char *) sp;
 149     }
 150
 151   /* Initialize the integer argument register pointer.  */
 152   argreg = ARM_A1_REGNUM;
 153
 154   /* The struct_return pointer occupies the first parameter passing
 155      register.  */
 156   if (struct_return)
 157     write_register (argreg++, struct_addr);
 158
 159   /* Process arguments from left to right.  Store as many as allowed
 160      in the parameter passing registers (A1-A4), and save the rest on
 161      the temporary stack.  */
 162   for (argnum = 0; argnum < nargs; argnum++)
 163     {
 164       int len;
 165       char *val;
 166       CORE_ADDR regval;
 167       enum type_code typecode;
 168       struct type *arg_type, *target_type;
 169
 170       arg_type = check_typedef (VALUE_TYPE (args[argnum]));
 171       target_type = TYPE_TARGET_TYPE (arg_type);
 172       len = TYPE_LENGTH (arg_type);
 173       typecode = TYPE_CODE (arg_type);
 174       val = (char *) VALUE_CONTENTS (args[argnum]);
 175
 176       /* ANSI C code passes float arguments as integers, K&R code
 177          passes float arguments as doubles.  The .stabs record for
 178          for ANSI prototype floating point arguments records the
 179          type as FP_INTEGER, while a K&R style (no prototype)
 180          .stabs records the type as FP_FLOAT.  In this latter case
 181          the compiler converts the float arguments to double before
 182          calling the function.  */
 183       if (TYPE_CODE_FLT == typecode && DEPRECATED_REGISTER_SIZE == len)
 184         {
 185           DOUBLEST dblval;
 186           dblval = deprecated_extract_floating (val, len);
 187           len = TARGET_DOUBLE_BIT / TARGET_CHAR_BIT;
 188           val = alloca (len);
 189           deprecated_store_floating (val, len, dblval);
 190         }
 191
 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))
 197         {
 198           CORE_ADDR regval = extract_unsigned_integer (val, len);
 199           if (arm_pc_is_thumb (regval))
 200             store_unsigned_integer (val, len, MAKE_THUMB_ADDR (regval));
 201         }
 202
 203       /* Copy the argument to general registers or the stack in
 204          register-sized pieces.  Large arguments are split between
 205          registers and stack.  */
 206       while (len > 0)
 207         {
 208           int partial_len = len < DEPRECATED_REGISTER_SIZE ? len : DEPRECATED_REGISTER_SIZE;
 209
 210           if (argreg <= ARM_LAST_ARG_REGNUM)
 211             {
 212               /* It's an argument being passed in a general register.  */
 213               regval = extract_unsigned_integer (val, partial_len);
 214               write_register (argreg++, regval);
 215             }
 216           else
 217             {
 218               /* Push the arguments onto the stack.  */
 219               write_memory ((CORE_ADDR) fp, val, DEPRECATED_REGISTER_SIZE);
 220               fp += DEPRECATED_REGISTER_SIZE;
 221             }
 222
 223           len -= partial_len;
 224           val += partial_len;
 225         }
 226     }
 227
 228   /* Return adjusted stack pointer.  */
 229   return sp;
 230 }
 231
 232 /*
 233    Dynamic Linking on ARM GNU/Linux
 234    --------------------------------
 235
 236    Note: PLT = procedure linkage table
 237    GOT = global offset table
 238
 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
 242    constraints.
 243
 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
 247    libraries).
 248
 249    2) The technique must be such that all executable areas must not be
 250    modified; and any modified areas must not be executed.
 251
 252    To do this, there are three steps involved in a typical jump:
 253
 254    1) in the code
 255    2) through the PLT
 256    3) using a pointer from the GOT
 257
 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 GNU/Linux this is usually
 262    ld-linux.so.2, but it does not have to be).  On the first
 263    invocation, the function is located and the GOT entry is replaced
 264    with the real function address.  Subsequent calls go through steps
 265    1, 2 and 3 and end up calling the real code.
 266
 267    1) In the code:
 268
 269    b    function_call
 270    bl   function_call
 271
 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.
 279
 280    2) In the PLT:
 281
 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:
 285
 286    PLT[0]:
 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
 291
 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:
 295
 296    lr = (&GOT[3] - . - 20) + (. + 8)
 297    lr = (&GOT[3] - 12)
 298    lr = &GOT[0]
 299
 300    On the fourth line, the pc and lr are both updated, so that:
 301
 302    pc = GOT[2]
 303    lr = &GOT[0] + 8
 304    = &GOT[2]
 305
 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.
 308
 309    PLT[n+1]:
 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] - .
 314
 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.
 319
 320    3) In the GOT:
 321
 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.
 327
 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].
 332
 333    The special entries in the GOT are:
 334
 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
 338
 339    The first invocation of function call comes through and uses the
 340    fixup/resolver code.  On the entry to the fixup/resolver code:
 341
 342    ip = &GOT[n+3]
 343    lr = &GOT[2]
 344    stack[0] = return address (lr) of the function call
 345    [r0, r1, r2, r3] are still the arguments to the function call
 346
 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].  */
 350
 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.  */
 356
 357 static struct minimal_symbol *
 358 find_minsym_and_objfile (char *name, struct objfile **objfile_p)
 359 {
 360   struct objfile *objfile;
 361
 362   ALL_OBJFILES (objfile)
 363     {
 364       struct minimal_symbol *msym;
 365
 366       ALL_OBJFILE_MSYMBOLS (objfile, msym)
 367         {
 368           if (DEPRECATED_SYMBOL_NAME (msym)
 369               && strcmp (DEPRECATED_SYMBOL_NAME (msym), name) == 0)
 370             {
 371               *objfile_p = objfile;
 372               return msym;
 373             }
 374         }
 375     }
 376
 377   return 0;
 378 }
 379
 380
 381 /* Fetch, and possibly build, an appropriate link_map_offsets structure
 382    for ARM linux targets using the struct offsets defined in <link.h>.
 383    Note, however, that link.h is not actually referred to in this file.
 384    Instead, the relevant structs offsets were obtained from examining
 385    link.h.  (We can't refer to link.h from this file because the host
 386    system won't necessarily have it, or if it does, the structs which
 387    it defines will refer to the host system, not the target).  */
 388
 389 static struct link_map_offsets *
 390 arm_linux_svr4_fetch_link_map_offsets (void)
 391 {
 392   static struct link_map_offsets lmo;
 393   static struct link_map_offsets *lmp = 0;
 394
 395   if (lmp == 0)
 396     {
 397       lmp = &lmo;
 398
 399       lmo.r_debug_size = 8;     /* Actual size is 20, but this is all we
 400                                    need.  */
 401
 402       lmo.r_map_offset = 4;
 403       lmo.r_map_size   = 4;
 404
 405       lmo.link_map_size = 20;   /* Actual size is 552, but this is all we
 406                                    need.  */
 407
 408       lmo.l_addr_offset = 0;
 409       lmo.l_addr_size   = 4;
 410
 411       lmo.l_name_offset = 4;
 412       lmo.l_name_size   = 4;
 413
 414       lmo.l_next_offset = 12;
 415       lmo.l_next_size   = 4;
 416
 417       lmo.l_prev_offset = 16;
 418       lmo.l_prev_size   = 4;
 419     }
 420
 421     return lmp;
 422 }
 423
 424 static CORE_ADDR
 425 skip_hurd_resolver (CORE_ADDR pc)
 426 {
 427   /* The HURD dynamic linker is part of the GNU C library, so many
 428      GNU/Linux distributions use it.  (All ELF versions, as far as I
 429      know.)  An unresolved PLT entry points to "_dl_runtime_resolve",
 430      which calls "fixup" to patch the PLT, and then passes control to
 431      the function.
 432
 433      We look for the symbol `_dl_runtime_resolve', and find `fixup' in
 434      the same objfile.  If we are at the entry point of `fixup', then
 435      we set a breakpoint at the return address (at the top of the
 436      stack), and continue.
 437
 438      It's kind of gross to do all these checks every time we're
 439      called, since they don't change once the executable has gotten
 440      started.  But this is only a temporary hack --- upcoming versions
 441      of GNU/Linux will provide a portable, efficient interface for
 442      debugging programs that use shared libraries.  */
 443
 444   struct objfile *objfile;
 445   struct minimal_symbol *resolver
 446     = find_minsym_and_objfile ("_dl_runtime_resolve", &objfile);
 447
 448   if (resolver)
 449     {
 450       struct minimal_symbol *fixup
 451         = lookup_minimal_symbol ("fixup", NULL, objfile);
 452
 453       if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc)
 454         return (DEPRECATED_SAVED_PC_AFTER_CALL (get_current_frame ()));
 455     }
 456
 457   return 0;
 458 }
 459
 460 /* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c.
 461    This function:
 462    1) decides whether a PLT has sent us into the linker to resolve
 463       a function reference, and
 464    2) if so, tells us where to set a temporary breakpoint that will
 465       trigger when the dynamic linker is done.  */
 466
 467 CORE_ADDR
 468 arm_linux_skip_solib_resolver (CORE_ADDR pc)
 469 {
 470   CORE_ADDR result;
 471
 472   /* Plug in functions for other kinds of resolvers here.  */
 473   result = skip_hurd_resolver (pc);
 474
 475   if (result)
 476     return result;
 477
 478   return 0;
 479 }
 480
 481 /* The constants below were determined by examining the following files
 482    in the linux kernel sources:
 483
 484       arch/arm/kernel/signal.c
 485           - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
 486       include/asm-arm/unistd.h
 487           - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
 488
 489 #define ARM_LINUX_SIGRETURN_INSTR       0xef900077
 490 #define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
 491
 492 /* arm_linux_in_sigtramp determines if PC points at one of the
 493    instructions which cause control to return to the Linux kernel upon
 494    return from a signal handler.  FUNC_NAME is unused.  */
 495
 496 int
 497 arm_linux_in_sigtramp (CORE_ADDR pc, char *func_name)
 498 {
 499   unsigned long inst;
 500
 501   inst = read_memory_integer (pc, 4);
 502
 503   return (inst == ARM_LINUX_SIGRETURN_INSTR
 504           || inst == ARM_LINUX_RT_SIGRETURN_INSTR);
 505
 506 }
 507
 508 /* arm_linux_sigcontext_register_address returns the address in the
 509    sigcontext of register REGNO given a stack pointer value SP and
 510    program counter value PC.  The value 0 is returned if PC is not
 511    pointing at one of the signal return instructions or if REGNO is
 512    not saved in the sigcontext struct.  */
 513
 514 CORE_ADDR
 515 arm_linux_sigcontext_register_address (CORE_ADDR sp, CORE_ADDR pc, int regno)
 516 {
 517   unsigned long inst;
 518   CORE_ADDR reg_addr = 0;
 519
 520   inst = read_memory_integer (pc, 4);
 521
 522   if (inst == ARM_LINUX_SIGRETURN_INSTR
 523       || inst == ARM_LINUX_RT_SIGRETURN_INSTR)
 524     {
 525       CORE_ADDR sigcontext_addr;
 526
 527       /* The sigcontext structure is at different places for the two
 528          signal return instructions.  For ARM_LINUX_SIGRETURN_INSTR,
 529          it starts at the SP value.  For ARM_LINUX_RT_SIGRETURN_INSTR,
 530          it is at SP+8.  For the latter instruction, it may also be
 531          the case that the address of this structure may be determined
 532          by reading the 4 bytes at SP, but I'm not convinced this is
 533          reliable.
 534
 535          In any event, these magic constants (0 and 8) may be
 536          determined by examining struct sigframe and struct
 537          rt_sigframe in arch/arm/kernel/signal.c in the Linux kernel
 538          sources.  */
 539
 540       if (inst == ARM_LINUX_RT_SIGRETURN_INSTR)
 541         sigcontext_addr = sp + 8;
 542       else /* inst == ARM_LINUX_SIGRETURN_INSTR */
 543         sigcontext_addr = sp + 0;
 544
 545       /* The layout of the sigcontext structure for ARM GNU/Linux is
 546          in include/asm-arm/sigcontext.h in the Linux kernel sources.
 547
 548          There are three 4-byte fields which precede the saved r0
 549          field.  (This accounts for the 12 in the code below.)  The
 550          sixteen registers (4 bytes per field) follow in order.  The
 551          PSR value follows the sixteen registers which accounts for
 552          the constant 19 below. */
 553
 554       if (0 <= regno && regno <= ARM_PC_REGNUM)
 555         reg_addr = sigcontext_addr + 12 + (4 * regno);
 556       else if (regno == ARM_PS_REGNUM)
 557         reg_addr = sigcontext_addr + 19 * 4;
 558     }
 559
 560   return reg_addr;
 561 }
 562
 563 static void
 564 arm_linux_init_abi (struct gdbarch_info info,
 565                     struct gdbarch *gdbarch)
 566 {
 567   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 568
 569   tdep->lowest_pc = 0x8000;
 570   if (info.byte_order == BFD_ENDIAN_BIG)
 571     tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
 572   else
 573     tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
 574   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
 575
 576   tdep->fp_model = ARM_FLOAT_FPA;
 577
 578   tdep->jb_pc = ARM_LINUX_JB_PC;
 579   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
 580
 581   set_solib_svr4_fetch_link_map_offsets
 582     (gdbarch, arm_linux_svr4_fetch_link_map_offsets);
 583
 584   set_gdbarch_deprecated_call_dummy_words (gdbarch, arm_linux_call_dummy_words);
 585   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (arm_linux_call_dummy_words));
 586
 587   /* The following two overrides shouldn't be needed.  */
 588   set_gdbarch_deprecated_extract_return_value (gdbarch, arm_linux_extract_return_value);
 589   set_gdbarch_deprecated_push_arguments (gdbarch, arm_linux_push_arguments);
 590
 591   /* Shared library handling.  */
 592   set_gdbarch_in_solib_call_trampoline (gdbarch, in_plt_section);
 593   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 594 }
 595
 596 void
 597 _initialize_arm_linux_tdep (void)
 598 {
 599   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
 600                           arm_linux_init_abi);
 601 }