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