gdb/ppc-linux-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    2000, 2001 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "inferior.h"
  26 #include "symtab.h"
  27 #include "target.h"
  28 #include "gdbcore.h"
  29 #include "gdbcmd.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "regcache.h"
  33 #include "value.h"
  34
  35 #include "solib-svr4.h"
  36 #include "ppc-tdep.h"
  37
  38 /* The following two instructions are used in the signal trampoline
  39    code on linux/ppc */
  40 #define INSTR_LI_R0_0x7777      0x38007777
  41 #define INSTR_SC                0x44000002
  42
  43 /* Since the *-tdep.c files are platform independent (i.e, they may be
  44    used to build cross platform debuggers), we can't include system
  45    headers.  Therefore, details concerning the sigcontext structure
  46    must be painstakingly rerecorded.  What's worse, if these details
  47    ever change in the header files, they'll have to be changed here
  48    as well. */
  49
  50 /* __SIGNAL_FRAMESIZE from <asm/ptrace.h> */
  51 #define PPC_LINUX_SIGNAL_FRAMESIZE 64
  52
  53 /* From <asm/sigcontext.h>, offsetof(struct sigcontext_struct, regs) == 0x1c */
  54 #define PPC_LINUX_REGS_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x1c)
  55
  56 /* From <asm/sigcontext.h>,
  57    offsetof(struct sigcontext_struct, handler) == 0x14 */
  58 #define PPC_LINUX_HANDLER_PTR_OFFSET (PPC_LINUX_SIGNAL_FRAMESIZE + 0x14)
  59
  60 /* From <asm/ptrace.h>, values for PT_NIP, PT_R1, and PT_LNK */
  61 #define PPC_LINUX_PT_R0         0
  62 #define PPC_LINUX_PT_R1         1
  63 #define PPC_LINUX_PT_R2         2
  64 #define PPC_LINUX_PT_R3         3
  65 #define PPC_LINUX_PT_R4         4
  66 #define PPC_LINUX_PT_R5         5
  67 #define PPC_LINUX_PT_R6         6
  68 #define PPC_LINUX_PT_R7         7
  69 #define PPC_LINUX_PT_R8         8
  70 #define PPC_LINUX_PT_R9         9
  71 #define PPC_LINUX_PT_R10        10
  72 #define PPC_LINUX_PT_R11        11
  73 #define PPC_LINUX_PT_R12        12
  74 #define PPC_LINUX_PT_R13        13
  75 #define PPC_LINUX_PT_R14        14
  76 #define PPC_LINUX_PT_R15        15
  77 #define PPC_LINUX_PT_R16        16
  78 #define PPC_LINUX_PT_R17        17
  79 #define PPC_LINUX_PT_R18        18
  80 #define PPC_LINUX_PT_R19        19
  81 #define PPC_LINUX_PT_R20        20
  82 #define PPC_LINUX_PT_R21        21
  83 #define PPC_LINUX_PT_R22        22
  84 #define PPC_LINUX_PT_R23        23
  85 #define PPC_LINUX_PT_R24        24
  86 #define PPC_LINUX_PT_R25        25
  87 #define PPC_LINUX_PT_R26        26
  88 #define PPC_LINUX_PT_R27        27
  89 #define PPC_LINUX_PT_R28        28
  90 #define PPC_LINUX_PT_R29        29
  91 #define PPC_LINUX_PT_R30        30
  92 #define PPC_LINUX_PT_R31        31
  93 #define PPC_LINUX_PT_NIP        32
  94 #define PPC_LINUX_PT_MSR        33
  95 #define PPC_LINUX_PT_CTR        35
  96 #define PPC_LINUX_PT_LNK        36
  97 #define PPC_LINUX_PT_XER        37
  98 #define PPC_LINUX_PT_CCR        38
  99 #define PPC_LINUX_PT_MQ         39
 100 #define PPC_LINUX_PT_FPR0       48      /* each FP reg occupies 2 slots in this space */
 101 #define PPC_LINUX_PT_FPR31 (PPC_LINUX_PT_FPR0 + 2*31)
 102 #define PPC_LINUX_PT_FPSCR (PPC_LINUX_PT_FPR0 + 2*32 + 1)
 103
 104 static int ppc_linux_at_sigtramp_return_path (CORE_ADDR pc);
 105
 106 /* Determine if pc is in a signal trampoline...
 107
 108    Ha!  That's not what this does at all.  wait_for_inferior in infrun.c
 109    calls IN_SIGTRAMP in order to detect entry into a signal trampoline
 110    just after delivery of a signal.  But on linux, signal trampolines
 111    are used for the return path only.  The kernel sets things up so that
 112    the signal handler is called directly.
 113
 114    If we use in_sigtramp2() in place of in_sigtramp() (see below)
 115    we'll (often) end up with stop_pc in the trampoline and prev_pc in
 116    the (now exited) handler.  The code there will cause a temporary
 117    breakpoint to be set on prev_pc which is not very likely to get hit
 118    again.
 119
 120    If this is confusing, think of it this way...  the code in
 121    wait_for_inferior() needs to be able to detect entry into a signal
 122    trampoline just after a signal is delivered, not after the handler
 123    has been run.
 124
 125    So, we define in_sigtramp() below to return 1 if the following is
 126    true:
 127
 128    1) The previous frame is a real signal trampoline.
 129
 130    - and -
 131
 132    2) pc is at the first or second instruction of the corresponding
 133    handler.
 134
 135    Why the second instruction?  It seems that wait_for_inferior()
 136    never sees the first instruction when single stepping.  When a
 137    signal is delivered while stepping, the next instruction that
 138    would've been stepped over isn't, instead a signal is delivered and
 139    the first instruction of the handler is stepped over instead.  That
 140    puts us on the second instruction.  (I added the test for the
 141    first instruction long after the fact, just in case the observed
 142    behavior is ever fixed.)
 143
 144    IN_SIGTRAMP is called from blockframe.c as well in order to set
 145    the signal_handler_caller flag.  Because of our strange definition
 146    of in_sigtramp below, we can't rely on signal_handler_caller getting
 147    set correctly from within blockframe.c.  This is why we take pains
 148    to set it in init_extra_frame_info().  */
 149
 150 int
 151 ppc_linux_in_sigtramp (CORE_ADDR pc, char *func_name)
 152 {
 153   CORE_ADDR lr;
 154   CORE_ADDR sp;
 155   CORE_ADDR tramp_sp;
 156   char buf[4];
 157   CORE_ADDR handler;
 158
 159   lr = read_register (PPC_LR_REGNUM);
 160   if (!ppc_linux_at_sigtramp_return_path (lr))
 161     return 0;
 162
 163   sp = read_register (SP_REGNUM);
 164
 165   if (target_read_memory (sp, buf, sizeof (buf)) != 0)
 166     return 0;
 167
 168   tramp_sp = extract_unsigned_integer (buf, 4);
 169
 170   if (target_read_memory (tramp_sp + PPC_LINUX_HANDLER_PTR_OFFSET, buf,
 171                           sizeof (buf)) != 0)
 172     return 0;
 173
 174   handler = extract_unsigned_integer (buf, 4);
 175
 176   return (pc == handler || pc == handler + 4);
 177 }
 178
 179 /*
 180  * The signal handler trampoline is on the stack and consists of exactly
 181  * two instructions.  The easiest and most accurate way of determining
 182  * whether the pc is in one of these trampolines is by inspecting the
 183  * instructions.  It'd be faster though if we could find a way to do this
 184  * via some simple address comparisons.
 185  */
 186 static int
 187 ppc_linux_at_sigtramp_return_path (CORE_ADDR pc)
 188 {
 189   char buf[12];
 190   unsigned long pcinsn;
 191   if (target_read_memory (pc - 4, buf, sizeof (buf)) != 0)
 192     return 0;
 193
 194   /* extract the instruction at the pc */
 195   pcinsn = extract_unsigned_integer (buf + 4, 4);
 196
 197   return (
 198            (pcinsn == INSTR_LI_R0_0x7777
 199             && extract_unsigned_integer (buf + 8, 4) == INSTR_SC)
 200            ||
 201            (pcinsn == INSTR_SC
 202             && extract_unsigned_integer (buf, 4) == INSTR_LI_R0_0x7777));
 203 }
 204
 205 CORE_ADDR
 206 ppc_linux_skip_trampoline_code (CORE_ADDR pc)
 207 {
 208   char buf[4];
 209   struct obj_section *sect;
 210   struct objfile *objfile;
 211   unsigned long insn;
 212   CORE_ADDR plt_start = 0;
 213   CORE_ADDR symtab = 0;
 214   CORE_ADDR strtab = 0;
 215   int num_slots = -1;
 216   int reloc_index = -1;
 217   CORE_ADDR plt_table;
 218   CORE_ADDR reloc;
 219   CORE_ADDR sym;
 220   long symidx;
 221   char symname[1024];
 222   struct minimal_symbol *msymbol;
 223
 224   /* Find the section pc is in; return if not in .plt */
 225   sect = find_pc_section (pc);
 226   if (!sect || strcmp (sect->the_bfd_section->name, ".plt") != 0)
 227     return 0;
 228
 229   objfile = sect->objfile;
 230
 231   /* Pick up the instruction at pc.  It had better be of the
 232      form
 233      li r11, IDX
 234
 235      where IDX is an index into the plt_table.  */
 236
 237   if (target_read_memory (pc, buf, 4) != 0)
 238     return 0;
 239   insn = extract_unsigned_integer (buf, 4);
 240
 241   if ((insn & 0xffff0000) != 0x39600000 /* li r11, VAL */ )
 242     return 0;
 243
 244   reloc_index = (insn << 16) >> 16;
 245
 246   /* Find the objfile that pc is in and obtain the information
 247      necessary for finding the symbol name. */
 248   for (sect = objfile->sections; sect < objfile->sections_end; ++sect)
 249     {
 250       const char *secname = sect->the_bfd_section->name;
 251       if (strcmp (secname, ".plt") == 0)
 252         plt_start = sect->addr;
 253       else if (strcmp (secname, ".rela.plt") == 0)
 254         num_slots = ((int) sect->endaddr - (int) sect->addr) / 12;
 255       else if (strcmp (secname, ".dynsym") == 0)
 256         symtab = sect->addr;
 257       else if (strcmp (secname, ".dynstr") == 0)
 258         strtab = sect->addr;
 259     }
 260
 261   /* Make sure we have all the information we need. */
 262   if (plt_start == 0 || num_slots == -1 || symtab == 0 || strtab == 0)
 263     return 0;
 264
 265   /* Compute the value of the plt table */
 266   plt_table = plt_start + 72 + 8 * num_slots;
 267
 268   /* Get address of the relocation entry (Elf32_Rela) */
 269   if (target_read_memory (plt_table + reloc_index, buf, 4) != 0)
 270     return 0;
 271   reloc = extract_address (buf, 4);
 272
 273   sect = find_pc_section (reloc);
 274   if (!sect)
 275     return 0;
 276
 277   if (strcmp (sect->the_bfd_section->name, ".text") == 0)
 278     return reloc;
 279
 280   /* Now get the r_info field which is the relocation type and symbol
 281      index. */
 282   if (target_read_memory (reloc + 4, buf, 4) != 0)
 283     return 0;
 284   symidx = extract_unsigned_integer (buf, 4);
 285
 286   /* Shift out the relocation type leaving just the symbol index */
 287   /* symidx = ELF32_R_SYM(symidx); */
 288   symidx = symidx >> 8;
 289
 290   /* compute the address of the symbol */
 291   sym = symtab + symidx * 4;
 292
 293   /* Fetch the string table index */
 294   if (target_read_memory (sym, buf, 4) != 0)
 295     return 0;
 296   symidx = extract_unsigned_integer (buf, 4);
 297
 298   /* Fetch the string; we don't know how long it is.  Is it possible
 299      that the following will fail because we're trying to fetch too
 300      much? */
 301   if (target_read_memory (strtab + symidx, symname, sizeof (symname)) != 0)
 302     return 0;
 303
 304   /* This might not work right if we have multiple symbols with the
 305      same name; the only way to really get it right is to perform
 306      the same sort of lookup as the dynamic linker. */
 307   msymbol = lookup_minimal_symbol_text (symname, NULL, NULL);
 308   if (!msymbol)
 309     return 0;
 310
 311   return SYMBOL_VALUE_ADDRESS (msymbol);
 312 }
 313
 314 /* The rs6000 version of FRAME_SAVED_PC will almost work for us.  The
 315    signal handler details are different, so we'll handle those here
 316    and call the rs6000 version to do the rest. */
 317 CORE_ADDR
 318 ppc_linux_frame_saved_pc (struct frame_info *fi)
 319 {
 320   if (fi->signal_handler_caller)
 321     {
 322       CORE_ADDR regs_addr =
 323         read_memory_integer (fi->frame + PPC_LINUX_REGS_PTR_OFFSET, 4);
 324       /* return the NIP in the regs array */
 325       return read_memory_integer (regs_addr + 4 * PPC_LINUX_PT_NIP, 4);
 326     }
 327   else if (fi->next && fi->next->signal_handler_caller)
 328     {
 329       CORE_ADDR regs_addr =
 330         read_memory_integer (fi->next->frame + PPC_LINUX_REGS_PTR_OFFSET, 4);
 331       /* return LNK in the regs array */
 332       return read_memory_integer (regs_addr + 4 * PPC_LINUX_PT_LNK, 4);
 333     }
 334   else
 335     return rs6000_frame_saved_pc (fi);
 336 }
 337
 338 void
 339 ppc_linux_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 340 {
 341   rs6000_init_extra_frame_info (fromleaf, fi);
 342
 343   if (fi->next != 0)
 344     {
 345       /* We're called from get_prev_frame_info; check to see if
 346          this is a signal frame by looking to see if the pc points
 347          at trampoline code */
 348       if (ppc_linux_at_sigtramp_return_path (fi->pc))
 349         fi->signal_handler_caller = 1;
 350       else
 351         fi->signal_handler_caller = 0;
 352     }
 353 }
 354
 355 int
 356 ppc_linux_frameless_function_invocation (struct frame_info *fi)
 357 {
 358   /* We'll find the wrong thing if we let
 359      rs6000_frameless_function_invocation () search for a signal trampoline */
 360   if (ppc_linux_at_sigtramp_return_path (fi->pc))
 361     return 0;
 362   else
 363     return rs6000_frameless_function_invocation (fi);
 364 }
 365
 366 void
 367 ppc_linux_frame_init_saved_regs (struct frame_info *fi)
 368 {
 369   if (fi->signal_handler_caller)
 370     {
 371       CORE_ADDR regs_addr;
 372       int i;
 373       if (fi->saved_regs)
 374         return;
 375
 376       frame_saved_regs_zalloc (fi);
 377
 378       regs_addr =
 379         read_memory_integer (fi->frame + PPC_LINUX_REGS_PTR_OFFSET, 4);
 380       fi->saved_regs[PC_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_NIP;
 381       fi->saved_regs[PPC_PS_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_MSR;
 382       fi->saved_regs[PPC_CR_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_CCR;
 383       fi->saved_regs[PPC_LR_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_LNK;
 384       fi->saved_regs[PPC_CTR_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_CTR;
 385       fi->saved_regs[PPC_XER_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_XER;
 386       fi->saved_regs[PPC_MQ_REGNUM] = regs_addr + 4 * PPC_LINUX_PT_MQ;
 387       for (i = 0; i < 32; i++)
 388         fi->saved_regs[PPC_GP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_R0 + 4 * i;
 389       for (i = 0; i < 32; i++)
 390         fi->saved_regs[FP0_REGNUM + i] = regs_addr + 4 * PPC_LINUX_PT_FPR0 + 8 * i;
 391     }
 392   else
 393     rs6000_frame_init_saved_regs (fi);
 394 }
 395
 396 CORE_ADDR
 397 ppc_linux_frame_chain (struct frame_info *thisframe)
 398 {
 399   /* Kernel properly constructs the frame chain for the handler */
 400   if (thisframe->signal_handler_caller)
 401     return read_memory_integer ((thisframe)->frame, 4);
 402   else
 403     return rs6000_frame_chain (thisframe);
 404 }
 405
 406 /* FIXME: Move the following to rs6000-tdep.c (or some other file where
 407    it may be used generically by ports which use either the SysV ABI or
 408    the EABI */
 409
 410 /* round2 rounds x up to the nearest multiple of s assuming that s is a
 411    power of 2 */
 412
 413 #undef round2
 414 #define round2(x,s) ((((long) (x) - 1) & ~(long)((s)-1)) + (s))
 415
 416 /* Pass the arguments in either registers, or in the stack. Using the
 417    ppc sysv ABI, the first eight words of the argument list (that might
 418    be less than eight parameters if some parameters occupy more than one
 419    word) are passed in r3..r10 registers.  float and double parameters are
 420    passed in fpr's, in addition to that. Rest of the parameters if any
 421    are passed in user stack.
 422
 423    If the function is returning a structure, then the return address is passed
 424    in r3, then the first 7 words of the parametes can be passed in registers,
 425    starting from r4. */
 426
 427 CORE_ADDR
 428 ppc_sysv_abi_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 429                              int struct_return, CORE_ADDR struct_addr)
 430 {
 431   int argno;
 432   int greg, freg;
 433   int argstkspace;
 434   int structstkspace;
 435   int argoffset;
 436   int structoffset;
 437   struct value *arg;
 438   struct type *type;
 439   int len;
 440   char old_sp_buf[4];
 441   CORE_ADDR saved_sp;
 442
 443   greg = struct_return ? 4 : 3;
 444   freg = 1;
 445   argstkspace = 0;
 446   structstkspace = 0;
 447
 448   /* Figure out how much new stack space is required for arguments
 449      which don't fit in registers.  Unlike the PowerOpen ABI, the
 450      SysV ABI doesn't reserve any extra space for parameters which
 451      are put in registers. */
 452   for (argno = 0; argno < nargs; argno++)
 453     {
 454       arg = args[argno];
 455       type = check_typedef (VALUE_TYPE (arg));
 456       len = TYPE_LENGTH (type);
 457
 458       if (TYPE_CODE (type) == TYPE_CODE_FLT)
 459         {
 460           if (freg <= 8)
 461             freg++;
 462           else
 463             {
 464               /* SysV ABI converts floats to doubles when placed in
 465                  memory and requires 8 byte alignment */
 466               if (argstkspace & 0x4)
 467                 argstkspace += 4;
 468               argstkspace += 8;
 469             }
 470         }
 471       else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8)   /* long long */
 472         {
 473           if (greg > 9)
 474             {
 475               greg = 11;
 476               if (argstkspace & 0x4)
 477                 argstkspace += 4;
 478               argstkspace += 8;
 479             }
 480           else
 481             {
 482               if ((greg & 1) == 0)
 483                 greg++;
 484               greg += 2;
 485             }
 486         }
 487       else
 488         {
 489           if (len > 4
 490               || TYPE_CODE (type) == TYPE_CODE_STRUCT
 491               || TYPE_CODE (type) == TYPE_CODE_UNION)
 492             {
 493               /* Rounding to the nearest multiple of 8 may not be necessary,
 494                  but it is safe.  Particularly since we don't know the
 495                  field types of the structure */
 496               structstkspace += round2 (len, 8);
 497             }
 498           if (greg <= 10)
 499             greg++;
 500           else
 501             argstkspace += 4;
 502         }
 503     }
 504
 505   /* Get current SP location */
 506   saved_sp = read_sp ();
 507
 508   sp -= argstkspace + structstkspace;
 509
 510   /* Allocate space for backchain and callee's saved lr */
 511   sp -= 8;
 512
 513   /* Make sure that we maintain 16 byte alignment */
 514   sp &= ~0x0f;
 515
 516   /* Update %sp before proceeding any further */
 517   write_register (SP_REGNUM, sp);
 518
 519   /* write the backchain */
 520   store_address (old_sp_buf, 4, saved_sp);
 521   write_memory (sp, old_sp_buf, 4);
 522
 523   argoffset = 8;
 524   structoffset = argoffset + argstkspace;
 525   freg = 1;
 526   greg = 3;
 527   /* Fill in r3 with the return structure, if any */
 528   if (struct_return)
 529     {
 530       char val_buf[4];
 531       store_address (val_buf, 4, struct_addr);
 532       memcpy (&registers[REGISTER_BYTE (greg)], val_buf, 4);
 533       greg++;
 534     }
 535   /* Now fill in the registers and stack... */
 536   for (argno = 0; argno < nargs; argno++)
 537     {
 538       arg = args[argno];
 539       type = check_typedef (VALUE_TYPE (arg));
 540       len = TYPE_LENGTH (type);
 541
 542       if (TYPE_CODE (type) == TYPE_CODE_FLT)
 543         {
 544           if (freg <= 8)
 545             {
 546               if (len > 8)
 547                 printf_unfiltered (
 548                                     "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 549               memcpy (&registers[REGISTER_BYTE (FP0_REGNUM + freg)],
 550                       VALUE_CONTENTS (arg), len);
 551               freg++;
 552             }
 553           else
 554             {
 555               /* SysV ABI converts floats to doubles when placed in
 556                  memory and requires 8 byte alignment */
 557               /* FIXME: Convert floats to doubles */
 558               if (argoffset & 0x4)
 559                 argoffset += 4;
 560               write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
 561               argoffset += 8;
 562             }
 563         }
 564       else if (TYPE_CODE (type) == TYPE_CODE_INT && len == 8)   /* long long */
 565         {
 566           if (greg > 9)
 567             {
 568               greg = 11;
 569               if (argoffset & 0x4)
 570                 argoffset += 4;
 571               write_memory (sp + argoffset, (char *) VALUE_CONTENTS (arg), len);
 572               argoffset += 8;
 573             }
 574           else
 575             {
 576               if ((greg & 1) == 0)
 577                 greg++;
 578
 579               memcpy (&registers[REGISTER_BYTE (greg)],
 580                       VALUE_CONTENTS (arg), 4);
 581               memcpy (&registers[REGISTER_BYTE (greg + 1)],
 582                       VALUE_CONTENTS (arg) + 4, 4);
 583               greg += 2;
 584             }
 585         }
 586       else
 587         {
 588           char val_buf[4];
 589           if (len > 4
 590               || TYPE_CODE (type) == TYPE_CODE_STRUCT
 591               || TYPE_CODE (type) == TYPE_CODE_UNION)
 592             {
 593               write_memory (sp + structoffset, VALUE_CONTENTS (arg), len);
 594               store_address (val_buf, 4, sp + structoffset);
 595               structoffset += round2 (len, 8);
 596             }
 597           else
 598             {
 599               memset (val_buf, 0, 4);
 600               memcpy (val_buf, VALUE_CONTENTS (arg), len);
 601             }
 602           if (greg <= 10)
 603             {
 604               *(int *) &registers[REGISTER_BYTE (greg)] = 0;
 605               memcpy (&registers[REGISTER_BYTE (greg)], val_buf, 4);
 606               greg++;
 607             }
 608           else
 609             {
 610               write_memory (sp + argoffset, val_buf, 4);
 611               argoffset += 4;
 612             }
 613         }
 614     }
 615
 616   target_store_registers (-1);
 617   return sp;
 618 }
 619
 620 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
 621    in much the same fashion as memory_remove_breakpoint in mem-break.c,
 622    but is careful not to write back the previous contents if the code
 623    in question has changed in between inserting the breakpoint and
 624    removing it.
 625
 626    Here is the problem that we're trying to solve...
 627
 628    Once upon a time, before introducing this function to remove
 629    breakpoints from the inferior, setting a breakpoint on a shared
 630    library function prior to running the program would not work
 631    properly.  In order to understand the problem, it is first
 632    necessary to understand a little bit about dynamic linking on
 633    this platform.
 634
 635    A call to a shared library function is accomplished via a bl
 636    (branch-and-link) instruction whose branch target is an entry
 637    in the procedure linkage table (PLT).  The PLT in the object
 638    file is uninitialized.  To gdb, prior to running the program, the
 639    entries in the PLT are all zeros.
 640
 641    Once the program starts running, the shared libraries are loaded
 642    and the procedure linkage table is initialized, but the entries in
 643    the table are not (necessarily) resolved.  Once a function is
 644    actually called, the code in the PLT is hit and the function is
 645    resolved.  In order to better illustrate this, an example is in
 646    order; the following example is from the gdb testsuite.
 647
 648         We start the program shmain.
 649
 650             [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
 651             [...]
 652
 653         We place two breakpoints, one on shr1 and the other on main.
 654
 655             (gdb) b shr1
 656             Breakpoint 1 at 0x100409d4
 657             (gdb) b main
 658             Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
 659
 660         Examine the instruction (and the immediatly following instruction)
 661         upon which the breakpoint was placed.  Note that the PLT entry
 662         for shr1 contains zeros.
 663
 664             (gdb) x/2i 0x100409d4
 665             0x100409d4 <shr1>:      .long 0x0
 666             0x100409d8 <shr1+4>:    .long 0x0
 667
 668         Now run 'til main.
 669
 670             (gdb) r
 671             Starting program: gdb.base/shmain
 672             Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
 673
 674             Breakpoint 2, main ()
 675                 at gdb.base/shmain.c:44
 676             44        g = 1;
 677
 678         Examine the PLT again.  Note that the loading of the shared
 679         library has initialized the PLT to code which loads a constant
 680         (which I think is an index into the GOT) into r11 and then
 681         branchs a short distance to the code which actually does the
 682         resolving.
 683
 684             (gdb) x/2i 0x100409d4
 685             0x100409d4 <shr1>:      li      r11,4
 686             0x100409d8 <shr1+4>:    b       0x10040984 <sg+4>
 687             (gdb) c
 688             Continuing.
 689
 690             Breakpoint 1, shr1 (x=1)
 691                 at gdb.base/shr1.c:19
 692             19        l = 1;
 693
 694         Now we've hit the breakpoint at shr1.  (The breakpoint was
 695         reset from the PLT entry to the actual shr1 function after the
 696         shared library was loaded.) Note that the PLT entry has been
 697         resolved to contain a branch that takes us directly to shr1.
 698         (The real one, not the PLT entry.)
 699
 700             (gdb) x/2i 0x100409d4
 701             0x100409d4 <shr1>:      b       0xffaf76c <shr1>
 702             0x100409d8 <shr1+4>:    b       0x10040984 <sg+4>
 703
 704    The thing to note here is that the PLT entry for shr1 has been
 705    changed twice.
 706
 707    Now the problem should be obvious.  GDB places a breakpoint (a
 708    trap instruction) on the zero value of the PLT entry for shr1.
 709    Later on, after the shared library had been loaded and the PLT
 710    initialized, GDB gets a signal indicating this fact and attempts
 711    (as it always does when it stops) to remove all the breakpoints.
 712
 713    The breakpoint removal was causing the former contents (a zero
 714    word) to be written back to the now initialized PLT entry thus
 715    destroying a portion of the initialization that had occurred only a
 716    short time ago.  When execution continued, the zero word would be
 717    executed as an instruction an an illegal instruction trap was
 718    generated instead.  (0 is not a legal instruction.)
 719
 720    The fix for this problem was fairly straightforward.  The function
 721    memory_remove_breakpoint from mem-break.c was copied to this file,
 722    modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
 723    In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
 724    function.
 725
 726    The differences between ppc_linux_memory_remove_breakpoint () and
 727    memory_remove_breakpoint () are minor.  All that the former does
 728    that the latter does not is check to make sure that the breakpoint
 729    location actually contains a breakpoint (trap instruction) prior
 730    to attempting to write back the old contents.  If it does contain
 731    a trap instruction, we allow the old contents to be written back.
 732    Otherwise, we silently do nothing.
 733
 734    The big question is whether memory_remove_breakpoint () should be
 735    changed to have the same functionality.  The downside is that more
 736    traffic is generated for remote targets since we'll have an extra
 737    fetch of a memory word each time a breakpoint is removed.
 738
 739    For the time being, we'll leave this self-modifying-code-friendly
 740    version in ppc-linux-tdep.c, but it ought to be migrated somewhere
 741    else in the event that some other platform has similar needs with
 742    regard to removing breakpoints in some potentially self modifying
 743    code.  */
 744 int
 745 ppc_linux_memory_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 746 {
 747   unsigned char *bp;
 748   int val;
 749   int bplen;
 750   char old_contents[BREAKPOINT_MAX];
 751
 752   /* Determine appropriate breakpoint contents and size for this address.  */
 753   bp = BREAKPOINT_FROM_PC (&addr, &bplen);
 754   if (bp == NULL)
 755     error ("Software breakpoints not implemented for this target.");
 756
 757   val = target_read_memory (addr, old_contents, bplen);
 758
 759   /* If our breakpoint is no longer at the address, this means that the
 760      program modified the code on us, so it is wrong to put back the
 761      old value */
 762   if (val == 0 && memcmp (bp, old_contents, bplen) == 0)
 763     val = target_write_memory (addr, contents_cache, bplen);
 764
 765   return val;
 766 }
 767
 768 /* Fetch (and possibly build) an appropriate link_map_offsets
 769    structure for Linux/PPC targets using the struct offsets
 770    defined in link.h (but without actual reference to that file).
 771
 772    This makes it possible to access Linux/PPC shared libraries from a
 773    GDB that was not built on an Linux/PPC host (for cross debugging).  */
 774
 775 struct link_map_offsets *
 776 ppc_linux_svr4_fetch_link_map_offsets (void)
 777 {
 778   static struct link_map_offsets lmo;
 779   static struct link_map_offsets *lmp = NULL;
 780
 781   if (lmp == NULL)
 782     {
 783       lmp = &lmo;
 784
 785       lmo.r_debug_size = 8;     /* The actual size is 20 bytes, but
 786                                    this is all we need.  */
 787       lmo.r_map_offset = 4;
 788       lmo.r_map_size   = 4;
 789
 790       lmo.link_map_size = 20;   /* The actual size is 560 bytes, but
 791                                    this is all we need.  */
 792       lmo.l_addr_offset = 0;
 793       lmo.l_addr_size   = 4;
 794
 795       lmo.l_name_offset = 4;
 796       lmo.l_name_size   = 4;
 797
 798       lmo.l_next_offset = 12;
 799       lmo.l_next_size   = 4;
 800
 801       lmo.l_prev_offset = 16;
 802       lmo.l_prev_size   = 4;
 803     }
 804
 805   return lmp;
 806 }