gdb/rs6000-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23 #include "symtab.h"
  24 #include "target.h"
  25 #include "gdbcore.h"
  26
  27 #include "xcoffsolib.h"
  28
  29 #include <sys/param.h>
  30 #include <sys/dir.h>
  31 #include <sys/user.h>
  32 #include <signal.h>
  33 #include <sys/ioctl.h>
  34 #include <fcntl.h>
  35
  36 #include <a.out.h>
  37 #include <sys/file.h>
  38 #include <sys/stat.h>
  39 #include <sys/core.h>
  40 #include <sys/ldr.h>
  41
  42
  43 extern struct obstack frame_cache_obstack;
  44
  45 extern int errno;
  46
  47 /* Nonzero if we just simulated a single step break. */
  48 int one_stepped;
  49
  50 /* Breakpoint shadows for the single step instructions will be kept here. */
  51
  52 static struct sstep_breaks {
  53   /* Address, or 0 if this is not in use.  */
  54   CORE_ADDR address;
  55   /* Shadow contents.  */
  56   char data[4];
  57 } stepBreaks[2];
  58
  59 /* Static function prototypes */
  60
  61 static CORE_ADDR
  62 find_toc_address PARAMS ((CORE_ADDR pc));
  63
  64 static CORE_ADDR
  65 branch_dest PARAMS ((int opcode, int instr, CORE_ADDR pc, CORE_ADDR safety));
  66
  67 static void
  68 frame_get_cache_fsr PARAMS ((struct frame_info *fi,
  69                              struct aix_framedata *fdatap));
  70
  71 /*
  72  * Calculate the destination of a branch/jump.  Return -1 if not a branch.
  73  */
  74 static CORE_ADDR
  75 branch_dest (opcode, instr, pc, safety)
  76      int opcode;
  77      int instr;
  78      CORE_ADDR pc;
  79      CORE_ADDR safety;
  80 {
  81   register long offset;
  82   CORE_ADDR dest;
  83   int immediate;
  84   int absolute;
  85   int ext_op;
  86
  87   absolute = (int) ((instr >> 1) & 1);
  88
  89   switch (opcode) {
  90      case 18    :
  91         immediate = ((instr & ~3) << 6) >> 6;   /* br unconditional */
  92
  93      case 16    :
  94         if (opcode != 18)                       /* br conditional */
  95           immediate = ((instr & ~3) << 16) >> 16;
  96         if (absolute)
  97           dest = immediate;
  98         else
  99           dest = pc + immediate;
 100         break;
 101
 102       case 19   :
 103         ext_op = (instr>>1) & 0x3ff;
 104
 105         if (ext_op == 16)                       /* br conditional register */
 106           dest = read_register (LR_REGNUM) & ~3;
 107
 108         else if (ext_op == 528)                 /* br cond to count reg */
 109           {
 110             dest = read_register (CTR_REGNUM) & ~3;
 111
 112             /* If we are about to execute a system call, dest is something
 113                like 0x22fc or 0x3b00.  Upon completion the system call
 114                will return to the address in the link register.  */
 115             if (dest < TEXT_SEGMENT_BASE)
 116               dest = read_register (LR_REGNUM) & ~3;
 117           }
 118         else return -1;
 119         break;
 120
 121        default: return -1;
 122   }
 123   return (dest < TEXT_SEGMENT_BASE) ? safety : dest;
 124 }
 125
 126
 127
 128 /* AIX does not support PT_STEP. Simulate it. */
 129
 130 void
 131 single_step (signal)
 132      int signal;
 133 {
 134 #define INSNLEN(OPCODE)  4
 135
 136   static char breakp[] = BREAKPOINT;
 137   int ii, insn;
 138   CORE_ADDR loc;
 139   CORE_ADDR breaks[2];
 140   int opcode;
 141
 142   if (!one_stepped) {
 143     loc = read_pc ();
 144
 145     read_memory (loc, (char *) &insn, 4);
 146
 147     breaks[0] = loc + INSNLEN(insn);
 148     opcode = insn >> 26;
 149     breaks[1] = branch_dest (opcode, insn, loc, breaks[0]);
 150
 151     /* Don't put two breakpoints on the same address. */
 152     if (breaks[1] == breaks[0])
 153       breaks[1] = -1;
 154
 155     stepBreaks[1].address = 0;
 156
 157     for (ii=0; ii < 2; ++ii) {
 158
 159       /* ignore invalid breakpoint. */
 160       if ( breaks[ii] == -1)
 161         continue;
 162
 163       read_memory (breaks[ii], stepBreaks[ii].data, 4);
 164
 165       write_memory (breaks[ii], breakp, 4);
 166       stepBreaks[ii].address = breaks[ii];
 167     }
 168
 169     one_stepped = 1;
 170   } else {
 171
 172     /* remove step breakpoints. */
 173     for (ii=0; ii < 2; ++ii)
 174       if (stepBreaks[ii].address != 0)
 175         write_memory
 176            (stepBreaks[ii].address, stepBreaks[ii].data, 4);
 177
 178     one_stepped = 0;
 179   }
 180   errno = 0;                    /* FIXME, don't ignore errors! */
 181                         /* What errors?  {read,write}_memory call error().  */
 182 }
 183
 184
 185 /* return pc value after skipping a function prologue. */
 186
 187 skip_prologue (pc)
 188 CORE_ADDR pc;
 189 {
 190   unsigned int tmp;
 191   unsigned int op;    /* FIXME, assumes instruction size matches host int!!! */
 192
 193   if (target_read_memory (pc, (char *)&op, sizeof (op)))
 194     return pc;                  /* Can't access it -- assume no prologue. */
 195   SWAP_TARGET_AND_HOST (&op, sizeof (op));
 196
 197   /* Assume that subsequent fetches can fail with low probability.  */
 198
 199   if (op == 0x7c0802a6) {               /* mflr r0 */
 200     pc += 4;
 201     op = read_memory_integer (pc, 4);
 202   }
 203
 204   if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
 205     pc += 4;
 206     op = read_memory_integer (pc, 4);
 207   }
 208
 209   if ((op & 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
 210     pc += 4;
 211     op = read_memory_integer (pc, 4);
 212
 213     /* At this point, make sure this is not a trampoline function
 214        (a function that simply calls another functions, and nothing else).
 215        If the next is not a nop, this branch was part of the function
 216        prologue. */
 217
 218     if (op == 0x4def7b82 ||             /* crorc 15, 15, 15 */
 219         op == 0x0)
 220       return pc - 4;                    /* don't skip over this branch */
 221   }
 222
 223   if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
 224     pc += 4;                             /* store floating register double */
 225     op = read_memory_integer (pc, 4);
 226   }
 227
 228   if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
 229     pc += 4;
 230     op = read_memory_integer (pc, 4);
 231   }
 232
 233   while (((tmp = op >> 16) == 0x9001) || /* st   r0, NUM(r1) */
 234          (tmp == 0x9421) ||             /* stu  r1, NUM(r1) */
 235          (tmp == 0x93e1))               /* st   r31,NUM(r1) */
 236   {
 237     pc += 4;
 238     op = read_memory_integer (pc, 4);
 239   }
 240
 241   while ((tmp = (op >> 22)) == 0x20f) { /* l    r31, ... or */
 242     pc += 4;                            /* l    r30, ...    */
 243     op = read_memory_integer (pc, 4);
 244   }
 245
 246   /* store parameters into stack */
 247   while(
 248         (op & 0xfc1f0000) == 0xd8010000 ||      /* stfd Rx,NUM(r1) */
 249         (op & 0xfc1f0000) == 0x90010000 ||      /* st r?, NUM(r1)  */
 250         (op & 0xfc000000) == 0xfc000000 ||      /* frsp, fp?, .. */
 251         (op & 0xd0000000) == 0xd0000000)        /* stfs, fp?, .. */
 252     {
 253       pc += 4;                                  /* store fpr double */
 254       op = read_memory_integer (pc, 4);
 255     }
 256
 257   if (op == 0x603f0000) {                       /* oril r31, r1, 0x0 */
 258     pc += 4;                                    /* this happens if r31 is used as */
 259     op = read_memory_integer (pc, 4);           /* frame ptr. (gcc does that)     */
 260
 261     tmp = 0;
 262     while ((op >> 16) == (0x907f + tmp)) {      /* st r3, NUM(r31) */
 263       pc += 4;                                  /* st r4, NUM(r31), ... */
 264       op = read_memory_integer (pc, 4);
 265       tmp += 0x20;
 266     }
 267   }
 268 #if 0
 269 /* I have problems with skipping over __main() that I need to address
 270  * sometime. Previously, I used to use misc_function_vector which
 271  * didn't work as well as I wanted to be.  -MGO */
 272
 273   /* If the first thing after skipping a prolog is a branch to a function,
 274      this might be a call to an initializer in main(), introduced by gcc2.
 275      We'd like to skip over it as well. Fortunately, xlc does some extra
 276      work before calling a function right after a prologue, thus we can
 277      single out such gcc2 behaviour. */
 278
 279
 280   if ((op & 0xfc000001) == 0x48000001) { /* bl foo, an initializer function? */
 281     op = read_memory_integer (pc+4, 4);
 282
 283     if (op == 0x4def7b82) {             /* cror 0xf, 0xf, 0xf (nop) */
 284
 285       /* check and see if we are in main. If so, skip over this initializer
 286          function as well. */
 287
 288       tmp = find_pc_misc_function (pc);
 289       if (tmp >= 0 && STREQ (misc_function_vector [tmp].name, "main"))
 290         return pc + 8;
 291     }
 292   }
 293 #endif /* 0 */
 294
 295   return pc;
 296 }
 297
 298
 299 /*************************************************************************
 300   Support for creating pushind a dummy frame into the stack, and popping
 301   frames, etc.
 302 *************************************************************************/
 303
 304 /* The total size of dummy frame is 436, which is;
 305
 306         32 gpr's        - 128 bytes
 307         32 fpr's        - 256   "
 308         7  the rest     - 28    "
 309         and 24 extra bytes for the callee's link area. The last 24 bytes
 310         for the link area might not be necessary, since it will be taken
 311         care of by push_arguments(). */
 312
 313 #define DUMMY_FRAME_SIZE 436
 314
 315 #define DUMMY_FRAME_ADDR_SIZE 10
 316
 317 /* Make sure you initialize these in somewhere, in case gdb gives up what it
 318    was debugging and starts debugging something else. FIXMEibm */
 319
 320 static int dummy_frame_count = 0;
 321 static int dummy_frame_size = 0;
 322 static CORE_ADDR *dummy_frame_addr = 0;
 323
 324 extern int stop_stack_dummy;
 325
 326 /* push a dummy frame into stack, save all register. Currently we are saving
 327    only gpr's and fpr's, which is not good enough! FIXMEmgo */
 328
 329 void
 330 push_dummy_frame ()
 331 {
 332   /* stack pointer.  */
 333   CORE_ADDR sp;
 334
 335   /* link register.  */
 336   CORE_ADDR pc;
 337   /* Same thing, target byte order.  */
 338   char pc_targ[4];
 339
 340   int ii;
 341
 342   target_fetch_registers (-1);
 343
 344   if (dummy_frame_count >= dummy_frame_size) {
 345     dummy_frame_size += DUMMY_FRAME_ADDR_SIZE;
 346     if (dummy_frame_addr)
 347       dummy_frame_addr = (CORE_ADDR*) xrealloc
 348         (dummy_frame_addr, sizeof(CORE_ADDR) * (dummy_frame_size));
 349     else
 350       dummy_frame_addr = (CORE_ADDR*)
 351         xmalloc (sizeof(CORE_ADDR) * (dummy_frame_size));
 352   }
 353
 354   sp = read_register(SP_REGNUM);
 355   pc = read_register(PC_REGNUM);
 356   memcpy (pc_targ, (char *) &pc, 4);
 357
 358   dummy_frame_addr [dummy_frame_count++] = sp;
 359
 360   /* Be careful! If the stack pointer is not decremented first, then kernel
 361      thinks he is free to use the space underneath it. And kernel actually
 362      uses that area for IPC purposes when executing ptrace(2) calls. So
 363      before writing register values into the new frame, decrement and update
 364      %sp first in order to secure your frame. */
 365
 366   write_register (SP_REGNUM, sp-DUMMY_FRAME_SIZE);
 367
 368   /* gdb relies on the state of current_frame. We'd better update it,
 369      otherwise things like do_registers_info() wouldn't work properly! */
 370
 371   flush_cached_frames ();
 372   set_current_frame (create_new_frame (sp-DUMMY_FRAME_SIZE, pc));
 373
 374   /* save program counter in link register's space. */
 375   write_memory (sp+8, pc_targ, 4);
 376
 377   /* save all floating point and general purpose registers here. */
 378
 379   /* fpr's, f0..f31 */
 380   for (ii = 0; ii < 32; ++ii)
 381     write_memory (sp-8-(ii*8), &registers[REGISTER_BYTE (31-ii+FP0_REGNUM)], 8);
 382
 383   /* gpr's r0..r31 */
 384   for (ii=1; ii <=32; ++ii)
 385     write_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
 386
 387   /* so far, 32*2 + 32 words = 384 bytes have been written.
 388      7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
 389
 390   for (ii=1; ii <= (LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii) {
 391     write_memory (sp-384-(ii*4),
 392                &registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
 393   }
 394
 395   /* Save sp or so called back chain right here. */
 396   write_memory (sp-DUMMY_FRAME_SIZE, &sp, 4);
 397   sp -= DUMMY_FRAME_SIZE;
 398
 399   /* And finally, this is the back chain. */
 400   write_memory (sp+8, pc_targ, 4);
 401 }
 402
 403
 404 /* Pop a dummy frame.
 405
 406    In rs6000 when we push a dummy frame, we save all of the registers. This
 407    is usually done before user calls a function explicitly.
 408
 409    After a dummy frame is pushed, some instructions are copied into stack,
 410    and stack pointer is decremented even more.  Since we don't have a frame
 411    pointer to get back to the parent frame of the dummy, we start having
 412    trouble poping it.  Therefore, we keep a dummy frame stack, keeping
 413    addresses of dummy frames as such.  When poping happens and when we
 414    detect that was a dummy frame, we pop it back to its parent by using
 415    dummy frame stack (`dummy_frame_addr' array).
 416
 417 FIXME:  This whole concept is broken.  You should be able to detect
 418 a dummy stack frame *on the user's stack itself*.  When you do,
 419 then you know the format of that stack frame -- including its
 420 saved SP register!  There should *not* be a separate stack in the
 421 GDB process that keeps track of these dummy frames!  -- [email protected] Aug92
 422  */
 423
 424 pop_dummy_frame ()
 425 {
 426   CORE_ADDR sp, pc;
 427   int ii;
 428   sp = dummy_frame_addr [--dummy_frame_count];
 429
 430   /* restore all fpr's. */
 431   for (ii = 1; ii <= 32; ++ii)
 432     read_memory (sp-(ii*8), &registers[REGISTER_BYTE (32-ii+FP0_REGNUM)], 8);
 433
 434   /* restore all gpr's */
 435   for (ii=1; ii <= 32; ++ii) {
 436     read_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
 437   }
 438
 439   /* restore the rest of the registers. */
 440   for (ii=1; ii <=(LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii)
 441     read_memory (sp-384-(ii*4),
 442                 &registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
 443
 444   read_memory (sp-(DUMMY_FRAME_SIZE-8),
 445                                 &registers [REGISTER_BYTE(PC_REGNUM)], 4);
 446
 447   /* when a dummy frame was being pushed, we had to decrement %sp first, in
 448      order to secure astack space. Thus, saved %sp (or %r1) value, is not the
 449      one we should restore. Change it with the one we need. */
 450
 451   *(int*)&registers [REGISTER_BYTE(FP_REGNUM)] = sp;
 452
 453   /* Now we can restore all registers. */
 454
 455   target_store_registers (-1);
 456   pc = read_pc ();
 457   flush_cached_frames ();
 458   set_current_frame (create_new_frame (sp, pc));
 459 }
 460
 461
 462 /* pop the innermost frame, go back to the caller. */
 463
 464 void
 465 pop_frame ()
 466 {
 467   CORE_ADDR pc, lr, sp, prev_sp;                /* %pc, %lr, %sp */
 468   struct aix_framedata fdata;
 469   FRAME fr = get_current_frame ();
 470   int addr, ii;
 471
 472   pc = read_pc ();
 473   sp = FRAME_FP (fr);
 474
 475   if (stop_stack_dummy && dummy_frame_count) {
 476     pop_dummy_frame ();
 477     return;
 478   }
 479
 480   /* figure out previous %pc value. If the function is frameless, it is
 481      still in the link register, otherwise walk the frames and retrieve the
 482      saved %pc value in the previous frame. */
 483
 484   addr = get_pc_function_start (fr->pc) + FUNCTION_START_OFFSET;
 485   function_frame_info (addr, &fdata);
 486
 487   prev_sp = read_memory_integer (sp, 4);
 488   if (fdata.frameless)
 489     lr = read_register (LR_REGNUM);
 490   else
 491     lr = read_memory_integer (prev_sp+8, 4);
 492
 493   /* reset %pc value. */
 494   write_register (PC_REGNUM, lr);
 495
 496   /* reset register values if any was saved earlier. */
 497   addr = prev_sp - fdata.offset;
 498
 499   if (fdata.saved_gpr != -1)
 500     for (ii=fdata.saved_gpr; ii <= 31; ++ii) {
 501       read_memory (addr, &registers [REGISTER_BYTE (ii)], 4);
 502       addr += 4;
 503     }
 504
 505   if (fdata.saved_fpr != -1)
 506     for (ii=fdata.saved_fpr; ii <= 31; ++ii) {
 507       read_memory (addr, &registers [REGISTER_BYTE (ii+FP0_REGNUM)], 8);
 508       addr += 8;
 509   }
 510
 511   write_register (SP_REGNUM, prev_sp);
 512   target_store_registers (-1);
 513   flush_cached_frames ();
 514   set_current_frame (create_new_frame (prev_sp, lr));
 515 }
 516
 517
 518 /* fixup the call sequence of a dummy function, with the real function address.
 519    its argumets will be passed by gdb. */
 520
 521 void
 522 fix_call_dummy(dummyname, pc, fun, nargs, type)
 523   char *dummyname;
 524   CORE_ADDR pc;
 525   CORE_ADDR fun;
 526   int nargs;                                    /* not used */
 527   int type;                                     /* not used */
 528 {
 529 #define TOC_ADDR_OFFSET         20
 530 #define TARGET_ADDR_OFFSET      28
 531
 532   int ii;
 533   CORE_ADDR target_addr;
 534   CORE_ADDR tocvalue;
 535
 536   target_addr = fun;
 537   tocvalue = find_toc_address (target_addr);
 538
 539   ii  = *(int*)((char*)dummyname + TOC_ADDR_OFFSET);
 540   ii = (ii & 0xffff0000) | (tocvalue >> 16);
 541   *(int*)((char*)dummyname + TOC_ADDR_OFFSET) = ii;
 542
 543   ii  = *(int*)((char*)dummyname + TOC_ADDR_OFFSET+4);
 544   ii = (ii & 0xffff0000) | (tocvalue & 0x0000ffff);
 545   *(int*)((char*)dummyname + TOC_ADDR_OFFSET+4) = ii;
 546
 547   ii  = *(int*)((char*)dummyname + TARGET_ADDR_OFFSET);
 548   ii = (ii & 0xffff0000) | (target_addr >> 16);
 549   *(int*)((char*)dummyname + TARGET_ADDR_OFFSET) = ii;
 550
 551   ii  = *(int*)((char*)dummyname + TARGET_ADDR_OFFSET+4);
 552   ii = (ii & 0xffff0000) | (target_addr & 0x0000ffff);
 553   *(int*)((char*)dummyname + TARGET_ADDR_OFFSET+4) = ii;
 554 }
 555
 556
 557 /* return information about a function frame.
 558    in struct aix_frameinfo fdata:
 559     - frameless is TRUE, if function does not have a frame.
 560     - nosavedpc is TRUE, if function does not save %pc value in its frame.
 561     - offset is the number of bytes used in the frame to save registers.
 562     - saved_gpr is the number of the first saved gpr.
 563     - saved_fpr is the number of the first saved fpr.
 564     - alloca_reg is the number of the register used for alloca() handling.
 565       Otherwise -1.
 566  */
 567 void
 568 function_frame_info (pc, fdata)
 569   CORE_ADDR pc;
 570   struct aix_framedata *fdata;
 571 {
 572   unsigned int tmp;
 573   register unsigned int op;
 574
 575   fdata->offset = 0;
 576   fdata->saved_gpr = fdata->saved_fpr = fdata->alloca_reg = -1;
 577   fdata->frameless = 1;
 578
 579   op  = read_memory_integer (pc, 4);
 580   if (op == 0x7c0802a6) {               /* mflr r0 */
 581     pc += 4;
 582     op = read_memory_integer (pc, 4);
 583     fdata->nosavedpc = 0;
 584     fdata->frameless = 0;
 585   }
 586   else                          /* else, pc is not saved */
 587     fdata->nosavedpc = 1;
 588
 589   if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
 590     pc += 4;
 591     op = read_memory_integer (pc, 4);
 592     fdata->frameless = 0;
 593   }
 594
 595   if ((op & 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
 596     pc += 4;
 597     op = read_memory_integer (pc, 4);
 598     /* At this point, make sure this is not a trampoline function
 599        (a function that simply calls another functions, and nothing else).
 600        If the next is not a nop, this branch was part of the function
 601        prologue. */
 602
 603     if (op == 0x4def7b82 ||             /* crorc 15, 15, 15 */
 604         op == 0x0)
 605       return;                           /* prologue is over */
 606     fdata->frameless = 0;
 607   }
 608
 609   if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
 610     pc += 4;                             /* store floating register double */
 611     op = read_memory_integer (pc, 4);
 612     fdata->frameless = 0;
 613   }
 614
 615   if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
 616     int tmp2;
 617     fdata->saved_gpr = (op >> 21) & 0x1f;
 618     tmp2 = op & 0xffff;
 619     if (tmp2 > 0x7fff)
 620       tmp2 = (~0 &~ 0xffff) | tmp2;
 621
 622     if (tmp2 < 0) {
 623       tmp2 = tmp2 * -1;
 624       fdata->saved_fpr = (tmp2 - ((32 - fdata->saved_gpr) * 4)) / 8;
 625       if ( fdata->saved_fpr > 0)
 626         fdata->saved_fpr = 32 - fdata->saved_fpr;
 627       else
 628         fdata->saved_fpr = -1;
 629     }
 630     fdata->offset = tmp2;
 631     pc += 4;
 632     op = read_memory_integer (pc, 4);
 633     fdata->frameless = 0;
 634   }
 635
 636   while (((tmp = op >> 16) == 0x9001) ||        /* st   r0, NUM(r1) */
 637          (tmp == 0x9421) ||                     /* stu  r1, NUM(r1) */
 638          (tmp == 0x93e1))                       /* st r31, NUM(r1) */
 639   {
 640     int tmp2;
 641
 642     /* gcc takes a short cut and uses this instruction to save r31 only. */
 643
 644     if (tmp == 0x93e1) {
 645       if (fdata->offset)
 646 /*        fatal ("Unrecognized prolog."); */
 647         printf ("Unrecognized prolog!\n");
 648
 649       fdata->saved_gpr = 31;
 650       tmp2 = op & 0xffff;
 651       if (tmp2 > 0x7fff) {
 652         tmp2 = - ((~0 &~ 0xffff) | tmp2);
 653         fdata->saved_fpr = (tmp2 - ((32 - 31) * 4)) / 8;
 654         if ( fdata->saved_fpr > 0)
 655           fdata->saved_fpr = 32 - fdata->saved_fpr;
 656         else
 657           fdata->saved_fpr = -1;
 658       }
 659       fdata->offset = tmp2;
 660     }
 661     pc += 4;
 662     op = read_memory_integer (pc, 4);
 663     fdata->frameless = 0;
 664   }
 665
 666   while ((tmp = (op >> 22)) == 0x20f) { /* l    r31, ... or */
 667     pc += 4;                            /* l    r30, ...    */
 668     op = read_memory_integer (pc, 4);
 669     fdata->frameless = 0;
 670   }
 671
 672   /* store parameters into stack */
 673   while(
 674         (op & 0xfc1f0000) == 0xd8010000 ||      /* stfd Rx,NUM(r1) */
 675         (op & 0xfc1f0000) == 0x90010000 ||      /* st r?, NUM(r1)  */
 676         (op & 0xfc000000) == 0xfc000000 ||      /* frsp, fp?, .. */
 677         (op & 0xd0000000) == 0xd0000000)        /* stfs, fp?, .. */
 678     {
 679       pc += 4;                                  /* store fpr double */
 680       op = read_memory_integer (pc, 4);
 681       fdata->frameless = 0;
 682     }
 683
 684   if (op == 0x603f0000) {                       /* oril r31, r1, 0x0 */
 685     fdata->alloca_reg = 31;
 686     fdata->frameless = 0;
 687   }
 688 }
 689
 690
 691 /* Pass the arguments in either registers, or in the stack. In RS6000, the first
 692    eight words of the argument list (that might be less than eight parameters if
 693    some parameters occupy more than one word) are passed in r3..r11 registers.
 694    float and double parameters are passed in fpr's, in addition to that. Rest of
 695    the parameters if any are passed in user stack. There might be cases in which
 696    half of the parameter is copied into registers, the other half is pushed into
 697    stack.
 698
 699    If the function is returning a structure, then the return address is passed
 700    in r3, then the first 7 words of the parametes can be passed in registers,
 701    starting from r4. */
 702
 703 CORE_ADDR
 704 push_arguments (nargs, args, sp, struct_return, struct_addr)
 705   int nargs;
 706   value *args;
 707   CORE_ADDR sp;
 708   int struct_return;
 709   CORE_ADDR struct_addr;
 710 {
 711   int ii, len;
 712   int argno;                                    /* current argument number */
 713   int argbytes;                                 /* current argument byte */
 714   char tmp_buffer [50];
 715   value arg;
 716   int f_argno = 0;                              /* current floating point argno */
 717
 718   CORE_ADDR saved_sp, pc;
 719
 720   if ( dummy_frame_count <= 0)
 721     printf ("FATAL ERROR -push_arguments()! frame not found!!\n");
 722
 723   /* The first eight words of ther arguments are passed in registers. Copy
 724      them appropriately.
 725
 726      If the function is returning a `struct', then the first word (which
 727      will be passed in r3) is used for struct return address. In that
 728      case we should advance one word and start from r4 register to copy
 729      parameters. */
 730
 731   ii =  struct_return ? 1 : 0;
 732
 733   for (argno=0, argbytes=0; argno < nargs && ii<8; ++ii) {
 734
 735     arg = value_arg_coerce (args[argno]);
 736     len = TYPE_LENGTH (VALUE_TYPE (arg));
 737
 738     if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FLT) {
 739
 740       /* floating point arguments are passed in fpr's, as well as gpr's.
 741          There are 13 fpr's reserved for passing parameters. At this point
 742          there is no way we would run out of them. */
 743
 744       if (len > 8)
 745         printf (
 746 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 747
 748       bcopy (VALUE_CONTENTS (arg),
 749          &registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
 750       ++f_argno;
 751     }
 752
 753     if (len > 4) {
 754
 755       /* Argument takes more than one register. */
 756       while (argbytes < len) {
 757
 758         *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 759         bcopy ( ((char*)VALUE_CONTENTS (arg))+argbytes,
 760                         &registers[REGISTER_BYTE(ii+3)],
 761                         (len - argbytes) > 4 ? 4 : len - argbytes);
 762         ++ii, argbytes += 4;
 763
 764         if (ii >= 8)
 765           goto ran_out_of_registers_for_arguments;
 766       }
 767       argbytes = 0;
 768       --ii;
 769     }
 770     else {        /* Argument can fit in one register. No problem. */
 771       *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 772       bcopy (VALUE_CONTENTS (arg), &registers[REGISTER_BYTE(ii+3)], len);
 773     }
 774     ++argno;
 775   }
 776
 777 ran_out_of_registers_for_arguments:
 778
 779   /* location for 8 parameters are always reserved. */
 780   sp -= 4 * 8;
 781
 782   /* another six words for back chain, TOC register, link register, etc. */
 783   sp -= 24;
 784
 785   /* if there are more arguments, allocate space for them in
 786      the stack, then push them starting from the ninth one. */
 787
 788   if ((argno < nargs) || argbytes) {
 789     int space = 0, jj;
 790     value val;
 791
 792     if (argbytes) {
 793       space += ((len - argbytes + 3) & -4);
 794       jj = argno + 1;
 795     }
 796     else
 797       jj = argno;
 798
 799     for (; jj < nargs; ++jj) {
 800       val = value_arg_coerce (args[jj]);
 801       space += ((TYPE_LENGTH (VALUE_TYPE (val))) + 3) & -4;
 802     }
 803
 804     /* add location required for the rest of the parameters */
 805     space = (space + 7) & -8;
 806     sp -= space;
 807
 808     /* This is another instance we need to be concerned about securing our
 809         stack space. If we write anything underneath %sp (r1), we might conflict
 810         with the kernel who thinks he is free to use this area. So, update %sp
 811         first before doing anything else. */
 812
 813     write_register (SP_REGNUM, sp);
 814
 815     /* if the last argument copied into the registers didn't fit there
 816        completely, push the rest of it into stack. */
 817
 818     if (argbytes) {
 819       write_memory (
 820         sp+24+(ii*4), ((char*)VALUE_CONTENTS (arg))+argbytes, len - argbytes);
 821       ++argno;
 822       ii += ((len - argbytes + 3) & -4) / 4;
 823     }
 824
 825     /* push the rest of the arguments into stack. */
 826     for (; argno < nargs; ++argno) {
 827
 828       arg = value_arg_coerce (args[argno]);
 829       len = TYPE_LENGTH (VALUE_TYPE (arg));
 830
 831
 832       /* float types should be passed in fpr's, as well as in the stack. */
 833       if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FLT && f_argno < 13) {
 834
 835         if (len > 8)
 836           printf (
 837 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 838
 839         bcopy (VALUE_CONTENTS (arg),
 840            &registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
 841         ++f_argno;
 842       }
 843
 844       write_memory (sp+24+(ii*4), (char *) VALUE_CONTENTS (arg), len);
 845       ii += ((len + 3) & -4) / 4;
 846     }
 847   }
 848   else
 849     /* Secure stack areas first, before doing anything else. */
 850     write_register (SP_REGNUM, sp);
 851
 852   saved_sp = dummy_frame_addr [dummy_frame_count - 1];
 853   read_memory (saved_sp, tmp_buffer, 24);
 854   write_memory (sp, tmp_buffer, 24);
 855
 856     write_memory (sp, &saved_sp, 4);    /* set back chain properly */
 857
 858   target_store_registers (-1);
 859   return sp;
 860 }
 861
 862 /* a given return value in `regbuf' with a type `valtype', extract and copy its
 863    value into `valbuf' */
 864
 865 void
 866 extract_return_value (valtype, regbuf, valbuf)
 867   struct type *valtype;
 868   char regbuf[REGISTER_BYTES];
 869   char *valbuf;
 870 {
 871
 872   if (TYPE_CODE (valtype) == TYPE_CODE_FLT) {
 873
 874     double dd; float ff;
 875     /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
 876        We need to truncate the return value into float size (4 byte) if
 877        necessary. */
 878
 879     if (TYPE_LENGTH (valtype) > 4)              /* this is a double */
 880       bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], valbuf,
 881                                                 TYPE_LENGTH (valtype));
 882     else {              /* float */
 883       bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], &dd, 8);
 884       ff = (float)dd;
 885       bcopy (&ff, valbuf, sizeof(float));
 886     }
 887   }
 888   else
 889     /* return value is copied starting from r3. */
 890     bcopy (&regbuf[REGISTER_BYTE (3)], valbuf, TYPE_LENGTH (valtype));
 891 }
 892
 893
 894 /* keep structure return address in this variable.
 895    FIXME:  This is a horrid kludge which should not be allowed to continue
 896    living.  This only allows a single nested call to a structure-returning
 897    function.  Come on, guys!  -- [email protected], Aug 92  */
 898
 899 CORE_ADDR rs6000_struct_return_address;
 900
 901
 902 /* Indirect function calls use a piece of trampoline code to do context
 903    switching, i.e. to set the new TOC table. Skip such code if we are on
 904    its first instruction (as when we have single-stepped to here).
 905    Result is desired PC to step until, or NULL if we are not in
 906    trampoline code.  */
 907
 908 CORE_ADDR
 909 skip_trampoline_code (pc)
 910 CORE_ADDR pc;
 911 {
 912   register unsigned int ii, op;
 913
 914   static unsigned trampoline_code[] = {
 915         0x800b0000,                     /*     l   r0,0x0(r11)  */
 916         0x90410014,                     /*    st   r2,0x14(r1)  */
 917         0x7c0903a6,                     /* mtctr   r0           */
 918         0x804b0004,                     /*     l   r2,0x4(r11)  */
 919         0x816b0008,                     /*     l  r11,0x8(r11)  */
 920         0x4e800420,                     /*  bctr                */
 921         0x4e800020,                     /*    br                */
 922         0
 923   };
 924
 925   for (ii=0; trampoline_code[ii]; ++ii) {
 926     op  = read_memory_integer (pc + (ii*4), 4);
 927     if (op != trampoline_code [ii])
 928       return 0;
 929   }
 930   ii = read_register (11);              /* r11 holds destination addr   */
 931   pc = read_memory_integer (ii, 4);     /* (r11) value                  */
 932   return pc;
 933 }
 934
 935
 936 /* Determines whether the function FI has a frame on the stack or not.
 937    Called from the FRAMELESS_FUNCTION_INVOCATION macro in tm.h with a
 938    second argument of 0, and from the FRAME_SAVED_PC macro with a
 939    second argument of 1.  */
 940
 941 int
 942 frameless_function_invocation (fi, pcsaved)
 943 struct frame_info *fi;
 944 int pcsaved;
 945 {
 946   CORE_ADDR func_start;
 947   struct aix_framedata fdata;
 948
 949   if (fi->next != NULL)
 950     /* Don't even think about framelessness except on the innermost frame.  */
 951     return 0;
 952
 953   func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET;
 954
 955   /* If we failed to find the start of the function, it is a mistake
 956      to inspect the instructions. */
 957
 958   if (!func_start)
 959     return 0;
 960
 961   function_frame_info (func_start, &fdata);
 962   return pcsaved ? fdata.nosavedpc : fdata.frameless;
 963 }
 964
 965
 966 /* If saved registers of frame FI are not known yet, read and cache them.
 967    &FDATAP contains aix_framedata; TDATAP can be NULL,
 968    in which case the framedata are read.  */
 969
 970 static void
 971 frame_get_cache_fsr (fi, fdatap)
 972      struct frame_info *fi;
 973      struct aix_framedata *fdatap;
 974 {
 975   int ii;
 976   CORE_ADDR frame_addr;
 977   struct aix_framedata work_fdata;
 978
 979   if (fi->cache_fsr)
 980     return;
 981
 982   if (fdatap == NULL) {
 983     fdatap = &work_fdata;
 984     function_frame_info (get_pc_function_start (fi->pc), fdatap);
 985   }
 986
 987   fi->cache_fsr = (struct frame_saved_regs *)
 988       obstack_alloc (&frame_cache_obstack, sizeof (struct frame_saved_regs));
 989   bzero (fi->cache_fsr, sizeof (struct frame_saved_regs));
 990
 991   if (fi->prev && fi->prev->frame)
 992     frame_addr = fi->prev->frame;
 993   else
 994     frame_addr = read_memory_integer (fi->frame, 4);
 995
 996   /* if != -1, fdatap->saved_fpr is the smallest number of saved_fpr.
 997      All fpr's from saved_fpr to fp31 are saved right underneath caller
 998      stack pointer, starting from fp31 first. */
 999
1000   if (fdatap->saved_fpr >= 0) {
1001     for (ii=31; ii >= fdatap->saved_fpr; --ii)
1002       fi->cache_fsr->regs [FP0_REGNUM + ii] = frame_addr - ((32 - ii) * 8);
1003     frame_addr -= (32 - fdatap->saved_fpr) * 8;
1004   }
1005
1006   /* if != -1, fdatap->saved_gpr is the smallest number of saved_gpr.
1007      All gpr's from saved_gpr to gpr31 are saved right under saved fprs,
1008      starting from r31 first. */
1009
1010   if (fdatap->saved_gpr >= 0)
1011     for (ii=31; ii >= fdatap->saved_gpr; --ii)
1012       fi->cache_fsr->regs [ii] = frame_addr - ((32 - ii) * 4);
1013 }
1014
1015 /* Return the address of a frame. This is the inital %sp value when the frame
1016    was first allocated. For functions calling alloca(), it might be saved in
1017    an alloca register. */
1018
1019 CORE_ADDR
1020 frame_initial_stack_address (fi)
1021      struct frame_info *fi;
1022 {
1023   CORE_ADDR tmpaddr;
1024   struct aix_framedata fdata;
1025   struct frame_info *callee_fi;
1026
1027   /* if the initial stack pointer (frame address) of this frame is known,
1028      just return it. */
1029
1030   if (fi->initial_sp)
1031     return fi->initial_sp;
1032
1033   /* find out if this function is using an alloca register.. */
1034
1035   function_frame_info (get_pc_function_start (fi->pc), &fdata);
1036
1037   /* if saved registers of this frame are not known yet, read and cache them. */
1038
1039   if (!fi->cache_fsr)
1040     frame_get_cache_fsr (fi, &fdata);
1041
1042   /* If no alloca register used, then fi->frame is the value of the %sp for
1043      this frame, and it is good enough. */
1044
1045   if (fdata.alloca_reg < 0) {
1046     fi->initial_sp = fi->frame;
1047     return fi->initial_sp;
1048   }
1049
1050   /* This function has an alloca register. If this is the top-most frame
1051      (with the lowest address), the value in alloca register is good. */
1052
1053   if (!fi->next)
1054     return fi->initial_sp = read_register (fdata.alloca_reg);
1055
1056   /* Otherwise, this is a caller frame. Callee has usually already saved
1057      registers, but there are exceptions (such as when the callee
1058      has no parameters). Find the address in which caller's alloca
1059      register is saved. */
1060
1061   for (callee_fi = fi->next; callee_fi; callee_fi = callee_fi->next) {
1062
1063     if (!callee_fi->cache_fsr)
1064       frame_get_cache_fsr (callee_fi, NULL);
1065
1066     /* this is the address in which alloca register is saved. */
1067
1068     tmpaddr = callee_fi->cache_fsr->regs [fdata.alloca_reg];
1069     if (tmpaddr) {
1070       fi->initial_sp = read_memory_integer (tmpaddr, 4);
1071       return fi->initial_sp;
1072     }
1073
1074     /* Go look into deeper levels of the frame chain to see if any one of
1075        the callees has saved alloca register. */
1076   }
1077
1078   /* If alloca register was not saved, by the callee (or any of its callees)
1079      then the value in the register is still good. */
1080
1081   return fi->initial_sp = read_register (fdata.alloca_reg);
1082 }
1083
1084 FRAME_ADDR
1085 rs6000_frame_chain (thisframe)
1086      struct frame_info *thisframe;
1087 {
1088   FRAME_ADDR fp;
1089   if (inside_entry_file ((thisframe)->pc))
1090     return 0;
1091   if (thisframe->signal_handler_caller)
1092     {
1093       /* This was determined by experimentation on AIX 3.2.  Perhaps
1094          it corresponds to some offset in /usr/include/sys/user.h or
1095          something like that.  Using some system include file would
1096          have the advantage of probably being more robust in the face
1097          of OS upgrades, but the disadvantage of being wrong for
1098          cross-debugging.  */
1099
1100 #define SIG_FRAME_FP_OFFSET 284
1101       fp = read_memory_integer (thisframe->frame + SIG_FRAME_FP_OFFSET, 4);
1102     }
1103   else
1104     fp = read_memory_integer ((thisframe)->frame, 4);
1105
1106   return fp;
1107 }
1108
1109 \f
1110 /* xcoff_relocate_symtab -      hook for symbol table relocation.
1111    also reads shared libraries.. */
1112
1113 xcoff_relocate_symtab (pid)
1114 unsigned int pid;
1115 {
1116 #define MAX_LOAD_SEGS 64                /* maximum number of load segments */
1117
1118     struct ld_info *ldi;
1119     int temp;
1120
1121     ldi = (void *) alloca(MAX_LOAD_SEGS * sizeof (*ldi));
1122
1123     /* According to my humble theory, AIX has some timing problems and
1124        when the user stack grows, kernel doesn't update stack info in time
1125        and ptrace calls step on user stack. That is why we sleep here a little,
1126        and give kernel to update its internals. */
1127
1128     usleep (36000);
1129
1130     errno = 0;
1131     ptrace(PT_LDINFO, pid, (PTRACE_ARG3_TYPE) ldi,
1132            MAX_LOAD_SEGS * sizeof(*ldi), ldi);
1133     if (errno) {
1134       perror_with_name ("ptrace ldinfo");
1135       return 0;
1136     }
1137
1138     vmap_ldinfo(ldi);
1139
1140    do {
1141      /* We are allowed to assume CORE_ADDR == pointer.  This code is
1142         native only.  */
1143      add_text_to_loadinfo ((CORE_ADDR) ldi->ldinfo_textorg,
1144                            (CORE_ADDR) ldi->ldinfo_dataorg);
1145     } while (ldi->ldinfo_next
1146              && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
1147
1148 #if 0
1149   /* Now that we've jumbled things around, re-sort them.  */
1150   sort_minimal_symbols ();
1151 #endif
1152
1153   /* relocate the exec and core sections as well. */
1154   vmap_exec ();
1155 }
1156 \f
1157 /* Keep an array of load segment information and their TOC table addresses.
1158    This info will be useful when calling a shared library function by hand. */
1159
1160 struct loadinfo {
1161   CORE_ADDR textorg, dataorg;
1162   unsigned long toc_offset;
1163 };
1164
1165 #define LOADINFOLEN     10
1166
1167 static  struct loadinfo *loadinfo = NULL;
1168 static  int     loadinfolen = 0;
1169 static  int     loadinfotocindex = 0;
1170 static  int     loadinfotextindex = 0;
1171
1172
1173 void
1174 xcoff_init_loadinfo ()
1175 {
1176   loadinfotocindex = 0;
1177   loadinfotextindex = 0;
1178
1179   if (loadinfolen == 0) {
1180     loadinfo = (struct loadinfo *)
1181                xmalloc (sizeof (struct loadinfo) * LOADINFOLEN);
1182     loadinfolen = LOADINFOLEN;
1183   }
1184 }
1185
1186
1187 /* FIXME -- this is never called!  */
1188 void
1189 free_loadinfo ()
1190 {
1191   if (loadinfo)
1192     free (loadinfo);
1193   loadinfo = NULL;
1194   loadinfolen = 0;
1195   loadinfotocindex = 0;
1196   loadinfotextindex = 0;
1197 }
1198
1199 /* this is called from xcoffread.c */
1200
1201 void
1202 xcoff_add_toc_to_loadinfo (unsigned long tocoff)
1203 {
1204   while (loadinfotocindex >= loadinfolen) {
1205     loadinfolen += LOADINFOLEN;
1206     loadinfo = (struct loadinfo *)
1207                xrealloc (loadinfo, sizeof(struct loadinfo) * loadinfolen);
1208   }
1209   loadinfo [loadinfotocindex++].toc_offset = tocoff;
1210 }
1211
1212
1213 void
1214 add_text_to_loadinfo (textaddr, dataaddr)
1215      CORE_ADDR textaddr;
1216      CORE_ADDR dataaddr;
1217 {
1218   while (loadinfotextindex >= loadinfolen) {
1219     loadinfolen += LOADINFOLEN;
1220     loadinfo = (struct loadinfo *)
1221                xrealloc (loadinfo, sizeof(struct loadinfo) * loadinfolen);
1222   }
1223   loadinfo [loadinfotextindex].textorg = textaddr;
1224   loadinfo [loadinfotextindex].dataorg = dataaddr;
1225   ++loadinfotextindex;
1226 }
1227
1228
1229 /* FIXME:  This assumes that the "textorg" and "dataorg" elements
1230    of a member of this array are correlated with the "toc_offset"
1231    element of the same member.  But they are sequentially assigned in wildly
1232    different places, and probably there is no correlation.  FIXME!  */
1233
1234 static CORE_ADDR
1235 find_toc_address (pc)
1236      CORE_ADDR pc;
1237 {
1238   int ii, toc_entry, tocbase = 0;
1239
1240   for (ii=0; ii < loadinfotextindex; ++ii)
1241     if (pc > loadinfo[ii].textorg && loadinfo[ii].textorg > tocbase) {
1242       toc_entry = ii;
1243       tocbase = loadinfo[ii].textorg;
1244     }
1245
1246   return loadinfo[toc_entry].dataorg + loadinfo[toc_entry].toc_offset;
1247 }