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