gdb/rs6000-tdep.c

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