gdb/rs6000-tdep.c

   1 /* Target-dependent code for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1987, 1989, 1991 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 <stdio.h>
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "inferior.h"
  25 #include "symtab.h"
  26 #include "target.h"
  27
  28 #include <sys/param.h>
  29 #include <sys/dir.h>
  30 #include <sys/user.h>
  31 #include <signal.h>
  32 #include <sys/ioctl.h>
  33 #include <fcntl.h>
  34
  35 #include <sys/ptrace.h>
  36 #include <sys/reg.h>
  37
  38 #include <a.out.h>
  39 #include <sys/file.h>
  40 #include <sys/stat.h>
  41 #include <sys/core.h>
  42
  43 extern int errno;
  44 extern int attach_flag;
  45
  46 /* Nonzero if we just simulated a single step break. */
  47 int one_stepped;
  48
  49 /* Breakpoint shadows for the single step instructions will be kept here. */
  50
  51 static struct sstep_breaks {
  52         int address;
  53         int data;
  54 } stepBreaks[2];
  55
  56
  57 /*
  58  * Calculate the destination of a branch/jump.  Return -1 if not a branch.
  59  */
  60 static int
  61 branch_dest (opcode, instr, pc, safety)
  62  int opcode, instr, pc, safety;
  63 {
  64   register long offset;
  65   unsigned dest;
  66   int immediate;
  67   int absolute;
  68   int ext_op;
  69
  70   absolute = (int) ((instr >> 1) & 1);
  71
  72   switch (opcode) {
  73      case 18    :
  74         immediate = ((instr & ~3) << 6) >> 6;   /* br unconditionl */
  75
  76      case 16    :
  77         if (opcode != 18)                       /* br conditional */
  78           immediate = ((instr & ~3) << 16) >> 16;
  79         if (absolute)
  80           dest = immediate;
  81         else
  82           dest = pc + immediate;
  83         break;
  84
  85       case 19   :
  86         ext_op = (instr>>1) & 0x3ff;
  87
  88         if (ext_op == 16)                       /* br conditional register */
  89           dest = read_register (LR_REGNUM) & ~3;
  90
  91         else if (ext_op == 528)                 /* br cond to count reg */
  92           dest = read_register (CTR_REGNUM) & ~3;
  93
  94         else return -1;
  95         break;
  96
  97        default: return -1;
  98   }
  99   return (dest < TEXT_SEGMENT_BASE) ? safety : dest;
 100 }
 101
 102
 103
 104 /* AIX does not support PT_STEP. Simulate it. */
 105
 106 int
 107 single_step (signal)
 108 int signal;
 109 {
 110 #define INSNLEN(OPCODE)  4
 111
 112   static char breakp[] = BREAKPOINT;
 113   int ii, insn, ret, loc;
 114   int breaks[2], opcode;
 115
 116   if (!one_stepped) {
 117     extern CORE_ADDR text_start;
 118     loc = read_pc ();
 119
 120     ret = read_memory (loc, &insn, sizeof (int));
 121     if (ret)
 122       printf ("Error in single_step()!!\n");
 123
 124     breaks[0] = loc + INSNLEN(insn);
 125     opcode = insn >> 26;
 126     breaks[1] = branch_dest (opcode, insn, loc, breaks[0]);
 127
 128     /* Don't put two breakpoints on the same address. */
 129     if (breaks[1] == breaks[0])
 130       breaks[1] = -1;
 131
 132     stepBreaks[1].address = -1;
 133
 134     for (ii=0; ii < 2; ++ii) {
 135
 136       /* ignore invalid breakpoint. */
 137       if ( breaks[ii] == -1)
 138         continue;
 139
 140       read_memory (breaks[ii], &(stepBreaks[ii].data), sizeof(int));
 141
 142       ret = write_memory (breaks[ii], breakp, sizeof(int));
 143       stepBreaks[ii].address = breaks[ii];
 144     }
 145
 146     one_stepped = 1;
 147     ptrace (PT_CONTINUE, inferior_pid, 1, signal, 0);
 148   }
 149   else {
 150
 151     /* remove step breakpoints. */
 152     for (ii=0; ii < 2; ++ii)
 153       if (stepBreaks[ii].address != -1)
 154         write_memory
 155            (stepBreaks[ii].address, &(stepBreaks[ii].data), sizeof(int));
 156
 157     one_stepped = 0;
 158   }
 159   errno = 0;
 160   return 1;
 161 }
 162
 163
 164 /* return pc value after skipping a function prologue. */
 165
 166 skip_prologue (pc)
 167 int pc;
 168 {
 169   unsigned int tmp;
 170   unsigned int op;
 171
 172   if (target_read_memory (pc, (char *)&op, sizeof (op)))
 173     return pc;                  /* Can't access it -- assume no prologue. */
 174   SWAP_TARGET_AND_HOST (&op, sizeof (op));
 175
 176   /* Assume that subsequent fetches can fail with low probability.  */
 177
 178   if (op == 0x7c0802a6) {               /* mflr r0 */
 179     pc += 4;
 180     op = read_memory_integer (pc, 4);
 181   }
 182
 183   if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
 184     pc += 4;
 185     op = read_memory_integer (pc, 4);
 186   }
 187
 188   if ((op & 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
 189     pc += 4;
 190     op = read_memory_integer (pc, 4);
 191   }
 192
 193 #if 0
 194   if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
 195     pc += 4;                             /* store floating register double */
 196     op = read_memory_integer (pc, 4);
 197   }
 198 #endif
 199
 200   if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
 201     pc += 4;
 202     op = read_memory_integer (pc, 4);
 203   }
 204
 205   while (((tmp = op >> 16) == 0x9001) || /* st   r0, NUM(r1) */
 206          (tmp == 0x9421) ||             /* stu  r1, NUM(r1) */
 207          (op == 0x93e1fffc))            /* st   r31,-4(r1) */
 208   {
 209     pc += 4;
 210     op = read_memory_integer (pc, 4);
 211   }
 212
 213   while ((tmp = (op >> 22)) == 0x20f) { /* l    r31, ... or */
 214     pc += 4;                            /* l    r30, ...    */
 215     op = read_memory_integer (pc, 4);
 216   }
 217
 218    /* store parameters into stack */
 219   while(
 220         (op & 0xfc1f0000) == 0xd8010000 ||      /* stfd Rx,NUM(r1) */
 221         (op & 0xfc1f0000) == 0x90010000 ||      /* st r?, NUM(r1)  */
 222         (op & 0xfc000000) == 0xfc000000 ||      /* frsp, fp?, .. */
 223         (op & 0xd0000000) == 0xd0000000)        /* stfs, fp?, .. */
 224     {
 225       pc += 4;                                  /* store fpr double */
 226       op = read_memory_integer (pc, 4);
 227     }
 228
 229   if (op == 0x603f0000) {                       /* oril r31, r1, 0x0 */
 230     pc += 4;                                    /* this happens if r31 is used as */
 231     op = read_memory_integer (pc, 4);           /* frame ptr. (gcc does that)     */
 232
 233     tmp = 0;
 234     while ((op >> 16) == (0x907f + tmp)) {      /* st r3, NUM(r31) */
 235       pc += 4;                                  /* st r4, NUM(r31), ... */
 236       op = read_memory_integer (pc, 4);
 237       tmp += 0x20;
 238     }
 239   }
 240   return pc;
 241 }
 242
 243
 244 /* text start and end addresses in virtual memory. */
 245
 246 CORE_ADDR text_start;
 247 CORE_ADDR text_end;
 248
 249
 250 /*************************************************************************
 251   Support for creating pushind a dummy frame into the stack, and popping
 252   frames, etc.
 253 *************************************************************************/
 254
 255 /* The total size of dummy frame is 436, which is;
 256
 257         32 gpr's        - 128 bytes
 258         32 fpr's        - 256   "
 259         7  the rest     - 28    "
 260         and 24 extra bytes for the callee's link area. The last 24 bytes
 261         for the link area might not be necessary, since it will be taken
 262         care of by push_arguments(). */
 263
 264 #define DUMMY_FRAME_SIZE 436
 265
 266 #define DUMMY_FRAME_ADDR_SIZE 10
 267
 268 /* Make sure you initialize these in somewhere, in case gdb gives up what it
 269    was debugging and starts debugging something else. FIXMEibm */
 270
 271 static int dummy_frame_count = 0;
 272 static int dummy_frame_size = 0;
 273 static CORE_ADDR *dummy_frame_addr = 0;
 274
 275 extern int stop_stack_dummy;
 276
 277 /* push a dummy frame into stack, save all register. Currently we are saving
 278    only gpr's and fpr's, which is not good enough! FIXMEmgo */
 279
 280 push_dummy_frame ()
 281 {
 282   int sp, pc;                           /* stack pointer and link register */
 283   int ii;
 284
 285   if (dummy_frame_count >= dummy_frame_size) {
 286     dummy_frame_size += DUMMY_FRAME_ADDR_SIZE;
 287     if (dummy_frame_addr)
 288       dummy_frame_addr = (CORE_ADDR*) xrealloc
 289         (dummy_frame_addr, sizeof(CORE_ADDR) * (dummy_frame_size));
 290     else
 291       dummy_frame_addr = (CORE_ADDR*)
 292         xmalloc (sizeof(CORE_ADDR) * (dummy_frame_size));
 293   }
 294
 295   sp = read_register(SP_REGNUM);
 296   pc = read_register(PC_REGNUM);
 297
 298   dummy_frame_addr [dummy_frame_count++] = sp;
 299
 300   /* Be careful! If the stack pointer is not decremented first, then kernel
 301      thinks he is free to use the sapce underneath it. And kernel actually
 302      uses that area for IPC purposes when executing ptrace(2) calls. So
 303      before writing register values into the new frame, decrement and update
 304      %sp first in order to secure your frame. */
 305
 306   write_register (SP_REGNUM, sp-DUMMY_FRAME_SIZE);
 307
 308   /* gdb relies on the state of current_frame. We'd better update it,
 309      otherwise things like do_registers_info() wouldn't work properly! */
 310
 311   flush_cached_frames ();
 312   set_current_frame (create_new_frame (sp-DUMMY_FRAME_SIZE, pc));
 313
 314   /* save program counter in link register's space. */
 315   write_memory (sp+8, &pc, 4);
 316
 317   /* save full floating point registers here. They will be from F14..F31
 318      for know. I am not sure if we need to save everything here! */
 319
 320   /* fpr's, f0..f31 */
 321   for (ii = 0; ii < 32; ++ii)
 322     write_memory (sp-8-(ii*8), &registers[REGISTER_BYTE (31-ii+FP0_REGNUM)], 8);
 323
 324   /* gpr's r0..r31 */
 325   for (ii=1; ii <=32; ++ii)
 326     write_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
 327
 328   /* so far, 32*2 + 32 words = 384 bytes have been written.
 329      7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
 330
 331   for (ii=1; ii <= (LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii) {
 332     write_memory (sp-384-(ii*4),
 333                &registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
 334   }
 335
 336   /* Save sp or so called back chain right here. */
 337   write_memory (sp-DUMMY_FRAME_SIZE, &sp, 4);
 338   sp -= DUMMY_FRAME_SIZE;
 339
 340   /* And finally, this is the back chain. */
 341   write_memory (sp+8, &pc, 4);
 342 }
 343
 344
 345 /* Pop a dummy frame.
 346
 347    In rs6000 when we push a dummy frame, we save all of the registers. This
 348    is usually done before user calls a function explicitly.
 349
 350    After a dummy frame is pushed, some instructions are copied into stack,
 351    and stack pointer is decremented even more.  Since we don't have a frame
 352    pointer to get back to the parent frame of the dummy, we start having
 353    trouble poping it.  Therefore, we keep a dummy frame stack, keeping
 354    addresses of dummy frames as such.  When poping happens and when we
 355    detect that was a dummy frame, we pop it back to its parent by using
 356    dummy frame stack (`dummy_frame_addr' array).
 357  */
 358
 359 pop_dummy_frame ()
 360 {
 361   CORE_ADDR sp, pc;
 362   int ii;
 363   sp = dummy_frame_addr [--dummy_frame_count];
 364
 365   /* restore all fpr's. */
 366   for (ii = 1; ii <= 32; ++ii)
 367     read_memory (sp-(ii*8), &registers[REGISTER_BYTE (32-ii+FP0_REGNUM)], 8);
 368
 369   /* restore all gpr's */
 370   for (ii=1; ii <= 32; ++ii) {
 371     read_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
 372   }
 373
 374   /* restore the rest of the registers. */
 375   for (ii=1; ii <=(LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii)
 376     read_memory (sp-384-(ii*4),
 377                 &registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
 378
 379   read_memory (sp-(DUMMY_FRAME_SIZE-8),
 380                                 &registers [REGISTER_BYTE(PC_REGNUM)], 4);
 381
 382   /* when a dummy frame was being pushed, we had to decrement %sp first, in
 383      order to secure astack space. Thus, saved %sp (or %r1) value, is not the
 384      one we should restore. Change it with the one we need. */
 385
 386   *(int*)&registers [REGISTER_BYTE(FP_REGNUM)] = sp;
 387
 388   /* Now we can restore all registers. */
 389
 390   store_inferior_registers (-1);
 391   pc = read_pc ();
 392   flush_cached_frames ();
 393   set_current_frame (create_new_frame (sp, pc));
 394 }
 395
 396
 397 /* pop the innermost frame, go back to the caller. */
 398
 399 pop_frame ()
 400 {
 401   int pc, lr, sp, prev_sp;              /* %pc, %lr, %sp */
 402   FRAME fr = get_current_frame ();
 403   int offset = 0;
 404   int frameless = 0;                    /* TRUE if function is frameless */
 405   int addr, ii;
 406   int saved_gpr, saved_fpr;             /* # of saved gpr's and fpr's */
 407
 408   pc = read_pc ();
 409   sp = FRAME_FP (fr);
 410
 411   if (stop_stack_dummy && dummy_frame_count) {
 412     pop_dummy_frame ();
 413     return;
 414   }
 415
 416   /* figure out previous %pc value. If the function is frameless, it is
 417      still in the link register, otherwise walk the frames and retrieve the
 418      saved %pc value in the previous frame. */
 419
 420   addr = get_pc_function_start (fr->pc) + FUNCTION_START_OFFSET;
 421   function_frame_info (addr, &frameless, &offset, &saved_gpr, &saved_fpr);
 422
 423   read_memory (sp, &prev_sp, 4);
 424   if (frameless)
 425     lr = read_register (LR_REGNUM);
 426   else
 427     read_memory (prev_sp+8, &lr, 4);
 428
 429   /* reset %pc value. */
 430   write_register (PC_REGNUM, lr);
 431
 432   /* reset register values if any was saved earlier. */
 433   addr = prev_sp - offset;
 434
 435   if (saved_gpr != -1)
 436     for (ii=saved_gpr; ii <= 31; ++ii) {
 437       read_memory (addr, &registers [REGISTER_BYTE (ii)], 4);
 438       addr += sizeof (int);
 439     }
 440
 441   if (saved_fpr != -1)
 442     for (ii=saved_fpr; ii <= 31; ++ii) {
 443       read_memory (addr, &registers [REGISTER_BYTE (ii+FP0_REGNUM)], 8);
 444       addr += 8;
 445   }
 446
 447   write_register (SP_REGNUM, prev_sp);
 448   store_inferior_registers (-1);
 449   flush_cached_frames ();
 450   set_current_frame (create_new_frame (prev_sp, lr));
 451 }
 452
 453
 454 /* fixup the call sequence of a dummy function, with the real function address.
 455    its argumets will be passed by gdb. */
 456
 457 fix_call_dummy(dummyname, pc, fun, nargs, type)
 458   char *dummyname;
 459   int pc;
 460   int fun;
 461   int nargs;                                    /* not used */
 462   int type;                                     /* not used */
 463
 464 {
 465 #define TOC_ADDR_OFFSET         20
 466 #define TARGET_ADDR_OFFSET      28
 467
 468   int ii;
 469   unsigned long target_addr;
 470   unsigned long tocvalue;
 471
 472   target_addr = fun;
 473   tocvalue = find_toc_address (target_addr);
 474
 475   ii  = *(int*)((char*)dummyname + TOC_ADDR_OFFSET);
 476   ii = (ii & 0xffff0000) | (tocvalue >> 16);
 477   *(int*)((char*)dummyname + TOC_ADDR_OFFSET) = ii;
 478
 479   ii  = *(int*)((char*)dummyname + TOC_ADDR_OFFSET+4);
 480   ii = (ii & 0xffff0000) | (tocvalue & 0x0000ffff);
 481   *(int*)((char*)dummyname + TOC_ADDR_OFFSET+4) = ii;
 482
 483   ii  = *(int*)((char*)dummyname + TARGET_ADDR_OFFSET);
 484   ii = (ii & 0xffff0000) | (target_addr >> 16);
 485   *(int*)((char*)dummyname + TARGET_ADDR_OFFSET) = ii;
 486
 487   ii  = *(int*)((char*)dummyname + TARGET_ADDR_OFFSET+4);
 488   ii = (ii & 0xffff0000) | (target_addr & 0x0000ffff);
 489   *(int*)((char*)dummyname + TARGET_ADDR_OFFSET+4) = ii;
 490 }
 491
 492
 493
 494 /* return information about a function frame.
 495     - frameless is TRUE, if function does not save %pc value in its frame.
 496     - offset is the number of bytes used in the frame to save registers.
 497     - saved_gpr is the number of the first saved gpr.
 498     - saved_fpr is the number of the first saved fpr.
 499  */
 500 function_frame_info (pc, frameless, offset, saved_gpr, saved_fpr)
 501   int pc;
 502   int *frameless, *offset, *saved_gpr, *saved_fpr;
 503 {
 504   unsigned int tmp;
 505   register unsigned int op;
 506
 507   *offset = 0;
 508   *saved_gpr = *saved_fpr = -1;
 509
 510   op  = read_memory_integer (pc, 4);
 511   if (op == 0x7c0802a6) {               /* mflr r0 */
 512     pc += 4;
 513     op = read_memory_integer (pc, 4);
 514     *frameless = 0;
 515   }
 516   else                          /* else, this is a frameless invocation */
 517     *frameless = 1;
 518
 519
 520   if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
 521     pc += 4;
 522     op = read_memory_integer (pc, 4);
 523   }
 524
 525   if ((op & 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
 526     pc += 4;
 527     op = read_memory_integer (pc, 4);
 528   }
 529
 530   if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
 531     pc += 4;                             /* store floating register double */
 532     op = read_memory_integer (pc, 4);
 533   }
 534
 535   if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
 536     int tmp2;
 537     *saved_gpr = (op >> 21) & 0x1f;
 538     tmp2 = op & 0xffff;
 539     if (tmp2 > 0x7fff)
 540       tmp2 = 0xffff0000 | tmp2;
 541
 542     if (tmp2 < 0) {
 543       tmp2 = tmp2 * -1;
 544       *saved_fpr = (tmp2 - ((32 - *saved_gpr) * 4)) / 8;
 545       if ( *saved_fpr > 0)
 546         *saved_fpr = 32 - *saved_fpr;
 547       else
 548         *saved_fpr = -1;
 549     }
 550     *offset = tmp2;
 551   }
 552 }
 553
 554
 555 /* Pass the arguments in either registers, or in the stack. In RS6000, the first
 556    eight words of the argument list (that might be less than eight parameters if
 557    some parameters occupy more than one word) are passed in r3..r11 registers.
 558    float and double parameters are passed in fpr's, in addition to that. Rest of
 559    the parameters if any are passed in user stack. There might be cases in which
 560    half of the parameter is copied into registers, the other half is pushed into
 561    stack.
 562
 563    If the function is returning a structure, then the return address is passed
 564    in r3, then the first 7 words of the parametes can be passed in registers,
 565    starting from r4. */
 566
 567 CORE_ADDR
 568 push_arguments (nargs, args, sp, struct_return, struct_addr)
 569   int nargs;
 570   value *args;
 571   CORE_ADDR sp;
 572   int struct_return;
 573   CORE_ADDR struct_addr;
 574 {
 575   int ii, len;
 576   int argno;                                    /* current argument number */
 577   int argbytes;                                 /* current argument byte */
 578   char tmp_buffer [50];
 579   value arg;
 580   int f_argno = 0;                              /* current floating point argno */
 581
 582   CORE_ADDR saved_sp, pc;
 583
 584   if ( dummy_frame_count <= 0)
 585     printf ("FATAL ERROR -push_arguments()! frame not found!!\n");
 586
 587   /* The first eight words of ther arguments are passed in registers. Copy
 588      them appropriately.
 589
 590      If the function is returning a `struct', then the first word (which
 591      will be passed in r3) is used for struct return address. In that
 592      case we should advance one word and start from r4 register to copy
 593      parameters. */
 594
 595   ii =  struct_return ? 1 : 0;
 596
 597   for (argno=0, argbytes=0; argno < nargs && ii<8; ++ii) {
 598
 599     arg = value_arg_coerce (args[argno]);
 600     len = TYPE_LENGTH (VALUE_TYPE (arg));
 601
 602     if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FLT) {
 603
 604       /* floating point arguments are passed in fpr's, as well as gpr's.
 605          There are 13 fpr's reserved for passing parameters. At this point
 606          there is no way we would run out of them. */
 607
 608       if (len > 8)
 609         printf (
 610 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 611
 612       bcopy (VALUE_CONTENTS (arg),
 613          &registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
 614       ++f_argno;
 615     }
 616
 617     if (len > 4) {
 618
 619       /* Argument takes more than one register. */
 620       while (argbytes < len) {
 621
 622         *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 623         bcopy ( ((char*)VALUE_CONTENTS (arg))+argbytes,
 624                         &registers[REGISTER_BYTE(ii+3)],
 625                         (len - argbytes) > 4 ? 4 : len - argbytes);
 626         ++ii, argbytes += 4;
 627
 628         if (ii >= 8)
 629           goto ran_out_of_registers_for_arguments;
 630       }
 631       argbytes = 0;
 632       --ii;
 633     }
 634     else {        /* Argument can fit in one register. No problem. */
 635       *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 636       bcopy (VALUE_CONTENTS (arg), &registers[REGISTER_BYTE(ii+3)], len);
 637     }
 638     ++argno;
 639   }
 640
 641 ran_out_of_registers_for_arguments:
 642
 643   /* location for 8 parameters are always reserved. */
 644   sp -= 4 * 8;
 645
 646   /* another six words for back chain, TOC register, link register, etc. */
 647   sp -= 24;
 648
 649   /* if there are more arguments, allocate space for them in
 650      the stack, then push them starting from the ninth one. */
 651
 652   if ((argno < nargs) || argbytes) {
 653     int space = 0, jj;
 654     value val;
 655
 656     if (argbytes) {
 657       space += ((len - argbytes + 3) & -4);
 658       jj = argno + 1;
 659     }
 660     else
 661       jj = argno;
 662
 663     for (; jj < nargs; ++jj) {
 664       val = value_arg_coerce (args[jj]);
 665       space += ((TYPE_LENGTH (VALUE_TYPE (val))) + 3) & -4;
 666     }
 667
 668     /* add location required for the rest of the parameters */
 669     space = (space + 7) & -8;
 670     sp -= space;
 671
 672     /* This is another instance we need to be concerned about securing our
 673         stack space. If we write anything underneath %sp (r1), we might conflict
 674         with the kernel who thinks he is free to use this area. So, update %sp
 675         first before doing anything else. */
 676
 677     write_register (SP_REGNUM, sp);
 678
 679 #if 0
 680     pc = read_pc ();
 681     flush_cached_frames ();
 682     set_current_frame (create_new_frame (sp, pc));
 683 #endif
 684
 685     /* if the last argument copied into the registers didn't fit there
 686        completely, push the rest of it into stack. */
 687
 688     if (argbytes) {
 689       write_memory (
 690         sp+24+(ii*4), ((char*)VALUE_CONTENTS (arg))+argbytes, len - argbytes);
 691       ++argno;
 692       ii += ((len - argbytes + 3) & -4) / 4;
 693     }
 694
 695     /* push the rest of the arguments into stack. */
 696     for (; argno < nargs; ++argno) {
 697
 698       arg = value_arg_coerce (args[argno]);
 699       len = TYPE_LENGTH (VALUE_TYPE (arg));
 700
 701
 702       /* float types should be passed in fpr's, as well as in the stack. */
 703       if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FLT && f_argno < 13) {
 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       write_memory (sp+24+(ii*4), VALUE_CONTENTS (arg), len);
 715       ii += ((len + 3) & -4) / 4;
 716     }
 717   }
 718   else {
 719
 720     /* Secure stack areas first, before doing anything else. */
 721     write_register (SP_REGNUM, sp);
 722
 723 #if 0
 724     pc = read_pc ();
 725     flush_cached_frames ();
 726     set_current_frame (create_new_frame (sp, pc));
 727 #endif
 728   }
 729
 730   saved_sp = dummy_frame_addr [dummy_frame_count - 1];
 731   read_memory (saved_sp, tmp_buffer, 24);
 732   write_memory (sp, tmp_buffer, 24);
 733
 734     write_memory (sp, &saved_sp, 4);    /* set back chain properly */
 735
 736   store_inferior_registers (-1);
 737   return sp;
 738 }
 739
 740 /* a given return value in `regbuf' with a type `valtype', extract and copy its
 741    value into `valbuf' */
 742
 743 extract_return_value (valtype, regbuf, valbuf)
 744   struct type *valtype;
 745   char regbuf[REGISTER_BYTES];
 746   char *valbuf;
 747 {
 748
 749   if (TYPE_CODE (valtype) == TYPE_CODE_FLT) {
 750
 751     double dd; float ff;
 752     /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
 753        We need to truncate the return value into float size (4 byte) if
 754        necessary. */
 755
 756     if (TYPE_LENGTH (valtype) > 4)              /* this is a double */
 757       bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], valbuf,
 758                                                 TYPE_LENGTH (valtype));
 759     else {              /* float */
 760       bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], &dd, 8);
 761       ff = (float)dd;
 762       bcopy (&ff, valbuf, sizeof(float));
 763     }
 764   }
 765   else
 766     /* return value is copied starting from r3. */
 767     bcopy (&regbuf[REGISTER_BYTE (3)], valbuf, TYPE_LENGTH (valtype));
 768 }
 769
 770
 771 /* keep keep structure return address in this variable. */
 772
 773 CORE_ADDR rs6000_struct_return_address;
 774
 775
 776 /* Throw away this debugging code. FIXMEmgo. */
 777 print_frame(fram)
 778 int fram;
 779 {
 780   int ii, val;
 781   for (ii=0; ii<40; ++ii) {
 782     if ((ii % 4) == 0)
 783       printf ("\n");
 784     val = read_memory_integer (fram + ii * 4, 4);
 785     printf ("0x%08x\t", val);
 786   }
 787   printf ("\n");
 788 }
 789
 790
 791
 792 /* Indirect function calls use a piece of trampoline code do co context switching,
 793    i.e. to set the new TOC table. Skip such code if exists. */
 794
 795 skip_trampoline_code (pc)
 796 int pc;
 797 {
 798   register unsigned int ii, op;
 799
 800   static unsigned trampoline_code[] = {
 801         0x800b0000,                     /*     l   r0,0x0(r11)  */
 802         0x90410014,                     /*    st   r2,0x14(r1)  */
 803         0x7c0903a6,                     /* mtctr   r0           */
 804         0x804b0004,                     /*     l   r2,0x4(r11)  */
 805         0x816b0008,                     /*     l  r11,0x8(r11)  */
 806         0x4e800420,                     /*  bctr                */
 807         0x4e800020,                     /*    br                */
 808         0
 809   };
 810
 811   for (ii=0; trampoline_code[ii]; ++ii) {
 812     op  = read_memory_integer (pc + (ii*4), 4);
 813     if (op != trampoline_code [ii])
 814       return NULL;
 815   }
 816   ii = read_register (11);              /* r11 holds destination addr   */
 817   pc = read_memory_integer (ii, 4);     /* (r11) value                  */
 818   return pc;
 819 }
 820