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   if (!inferior_pid)
 511     return;
 512
 513   op  = read_memory_integer (pc, 4);
 514   if (op == 0x7c0802a6) {               /* mflr r0 */
 515     pc += 4;
 516     op = read_memory_integer (pc, 4);
 517     *frameless = 0;
 518   }
 519   else                          /* else, this is a frameless invocation */
 520     *frameless = 1;
 521
 522
 523   if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
 524     pc += 4;
 525     op = read_memory_integer (pc, 4);
 526   }
 527
 528   if ((op & 0xfc000000) == 0x48000000) { /* bl foo, to save fprs??? */
 529     pc += 4;
 530     op = read_memory_integer (pc, 4);
 531   }
 532
 533   if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
 534     pc += 4;                             /* store floating register double */
 535     op = read_memory_integer (pc, 4);
 536   }
 537
 538   if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
 539     int tmp2;
 540     *saved_gpr = (op >> 21) & 0x1f;
 541     tmp2 = op & 0xffff;
 542     if (tmp2 > 0x7fff)
 543       tmp2 = 0xffff0000 | tmp2;
 544
 545     if (tmp2 < 0) {
 546       tmp2 = tmp2 * -1;
 547       *saved_fpr = (tmp2 - ((32 - *saved_gpr) * 4)) / 8;
 548       if ( *saved_fpr > 0)
 549         *saved_fpr = 32 - *saved_fpr;
 550       else
 551         *saved_fpr = -1;
 552     }
 553     *offset = tmp2;
 554   }
 555 }
 556
 557
 558 /* Pass the arguments in either registers, or in the stack. In RS6000, the first
 559    eight words of the argument list (that might be less than eight parameters if
 560    some parameters occupy more than one word) are passed in r3..r11 registers.
 561    float and double parameters are passed in fpr's, in addition to that. Rest of
 562    the parameters if any are passed in user stack. There might be cases in which
 563    half of the parameter is copied into registers, the other half is pushed into
 564    stack.
 565
 566    If the function is returning a structure, then the return address is passed
 567    in r3, then the first 7 words of the parametes can be passed in registers,
 568    starting from r4. */
 569
 570 CORE_ADDR
 571 push_arguments (nargs, args, sp, struct_return, struct_addr)
 572   int nargs;
 573   value *args;
 574   CORE_ADDR sp;
 575   int struct_return;
 576   CORE_ADDR struct_addr;
 577 {
 578   int ii, len;
 579   int argno;                                    /* current argument number */
 580   int argbytes;                                 /* current argument byte */
 581   char tmp_buffer [50];
 582   value arg;
 583   int f_argno = 0;                              /* current floating point argno */
 584
 585   CORE_ADDR saved_sp, pc;
 586
 587   if ( dummy_frame_count <= 0)
 588     printf ("FATAL ERROR -push_arguments()! frame not found!!\n");
 589
 590   /* The first eight words of ther arguments are passed in registers. Copy
 591      them appropriately.
 592
 593      If the function is returning a `struct', then the first word (which
 594      will be passed in r3) is used for struct return address. In that
 595      case we should advance one word and start from r4 register to copy
 596      parameters. */
 597
 598   ii =  struct_return ? 1 : 0;
 599
 600   for (argno=0, argbytes=0; argno < nargs && ii<8; ++ii) {
 601
 602     arg = value_arg_coerce (args[argno]);
 603     len = TYPE_LENGTH (VALUE_TYPE (arg));
 604
 605     if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FLT) {
 606
 607       /* floating point arguments are passed in fpr's, as well as gpr's.
 608          There are 13 fpr's reserved for passing parameters. At this point
 609          there is no way we would run out of them. */
 610
 611       if (len > 8)
 612         printf (
 613 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 614
 615       bcopy (VALUE_CONTENTS (arg),
 616          &registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
 617       ++f_argno;
 618     }
 619
 620     if (len > 4) {
 621
 622       /* Argument takes more than one register. */
 623       while (argbytes < len) {
 624
 625         *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 626         bcopy ( ((char*)VALUE_CONTENTS (arg))+argbytes,
 627                         &registers[REGISTER_BYTE(ii+3)],
 628                         (len - argbytes) > 4 ? 4 : len - argbytes);
 629         ++ii, argbytes += 4;
 630
 631         if (ii >= 8)
 632           goto ran_out_of_registers_for_arguments;
 633       }
 634       argbytes = 0;
 635       --ii;
 636     }
 637     else {        /* Argument can fit in one register. No problem. */
 638       *(int*)&registers[REGISTER_BYTE(ii+3)] = 0;
 639       bcopy (VALUE_CONTENTS (arg), &registers[REGISTER_BYTE(ii+3)], len);
 640     }
 641     ++argno;
 642   }
 643
 644 ran_out_of_registers_for_arguments:
 645
 646   /* location for 8 parameters are always reserved. */
 647   sp -= 4 * 8;
 648
 649   /* another six words for back chain, TOC register, link register, etc. */
 650   sp -= 24;
 651
 652   /* if there are more arguments, allocate space for them in
 653      the stack, then push them starting from the ninth one. */
 654
 655   if ((argno < nargs) || argbytes) {
 656     int space = 0, jj;
 657     value val;
 658
 659     if (argbytes) {
 660       space += ((len - argbytes + 3) & -4);
 661       jj = argno + 1;
 662     }
 663     else
 664       jj = argno;
 665
 666     for (; jj < nargs; ++jj) {
 667       val = value_arg_coerce (args[jj]);
 668       space += ((TYPE_LENGTH (VALUE_TYPE (val))) + 3) & -4;
 669     }
 670
 671     /* add location required for the rest of the parameters */
 672     space = (space + 7) & -8;
 673     sp -= space;
 674
 675     /* This is another instance we need to be concerned about securing our
 676         stack space. If we write anything underneath %sp (r1), we might conflict
 677         with the kernel who thinks he is free to use this area. So, update %sp
 678         first before doing anything else. */
 679
 680     write_register (SP_REGNUM, sp);
 681
 682 #if 0
 683     pc = read_pc ();
 684     flush_cached_frames ();
 685     set_current_frame (create_new_frame (sp, pc));
 686 #endif
 687
 688     /* if the last argument copied into the registers didn't fit there
 689        completely, push the rest of it into stack. */
 690
 691     if (argbytes) {
 692       write_memory (
 693         sp+24+(ii*4), ((char*)VALUE_CONTENTS (arg))+argbytes, len - argbytes);
 694       ++argno;
 695       ii += ((len - argbytes + 3) & -4) / 4;
 696     }
 697
 698     /* push the rest of the arguments into stack. */
 699     for (; argno < nargs; ++argno) {
 700
 701       arg = value_arg_coerce (args[argno]);
 702       len = TYPE_LENGTH (VALUE_TYPE (arg));
 703
 704
 705       /* float types should be passed in fpr's, as well as in the stack. */
 706       if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FLT && f_argno < 13) {
 707
 708         if (len > 8)
 709           printf (
 710 "Fatal Error: a floating point parameter #%d with a size > 8 is found!\n", argno);
 711
 712         bcopy (VALUE_CONTENTS (arg),
 713            &registers[REGISTER_BYTE(FP0_REGNUM + 1 + f_argno)], len);
 714         ++f_argno;
 715       }
 716
 717       write_memory (sp+24+(ii*4), VALUE_CONTENTS (arg), len);
 718       ii += ((len + 3) & -4) / 4;
 719     }
 720   }
 721   else {
 722
 723     /* Secure stack areas first, before doing anything else. */
 724     write_register (SP_REGNUM, sp);
 725
 726 #if 0
 727     pc = read_pc ();
 728     flush_cached_frames ();
 729     set_current_frame (create_new_frame (sp, pc));
 730 #endif
 731   }
 732
 733   saved_sp = dummy_frame_addr [dummy_frame_count - 1];
 734   read_memory (saved_sp, tmp_buffer, 24);
 735   write_memory (sp, tmp_buffer, 24);
 736
 737     write_memory (sp, &saved_sp, 4);    /* set back chain properly */
 738
 739   store_inferior_registers (-1);
 740   return sp;
 741 }
 742
 743 /* a given return value in `regbuf' with a type `valtype', extract and copy its
 744    value into `valbuf' */
 745
 746 extract_return_value (valtype, regbuf, valbuf)
 747   struct type *valtype;
 748   char regbuf[REGISTER_BYTES];
 749   char *valbuf;
 750 {
 751
 752   if (TYPE_CODE (valtype) == TYPE_CODE_FLT) {
 753
 754     double dd; float ff;
 755     /* floats and doubles are returned in fpr1. fpr's have a size of 8 bytes.
 756        We need to truncate the return value into float size (4 byte) if
 757        necessary. */
 758
 759     if (TYPE_LENGTH (valtype) > 4)              /* this is a double */
 760       bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], valbuf,
 761                                                 TYPE_LENGTH (valtype));
 762     else {              /* float */
 763       bcopy (&regbuf[REGISTER_BYTE (FP0_REGNUM + 1)], &dd, 8);
 764       ff = (float)dd;
 765       bcopy (&ff, valbuf, sizeof(float));
 766     }
 767   }
 768   else
 769     /* return value is copied starting from r3. */
 770     bcopy (&regbuf[REGISTER_BYTE (3)], valbuf, TYPE_LENGTH (valtype));
 771 }
 772
 773
 774 /* keep keep structure return address in this variable. */
 775
 776 CORE_ADDR rs6000_struct_return_address;
 777
 778
 779 /* Throw away this debugging code. FIXMEmgo. */
 780 print_frame(fram)
 781 int fram;
 782 {
 783   int ii, val;
 784   for (ii=0; ii<40; ++ii) {
 785     if ((ii % 4) == 0)
 786       printf ("\n");
 787     val = read_memory_integer (fram + ii * 4, 4);
 788     printf ("0x%08x\t", val);
 789   }
 790   printf ("\n");
 791 }
 792
 793
 794
 795 /* Indirect function calls use a piece of trampoline code do co context switching,
 796    i.e. to set the new TOC table. Skip such code if exists. */
 797
 798 skip_trampoline_code (pc)
 799 int pc;
 800 {
 801   register unsigned int ii, op;
 802
 803   static unsigned trampoline_code[] = {
 804         0x800b0000,                     /*     l   r0,0x0(r11)  */
 805         0x90410014,                     /*    st   r2,0x14(r1)  */
 806         0x7c0903a6,                     /* mtctr   r0           */
 807         0x804b0004,                     /*     l   r2,0x4(r11)  */
 808         0x816b0008,                     /*     l  r11,0x8(r11)  */
 809         0x4e800420,                     /*  bctr                */
 810         0x4e800020,                     /*    br                */
 811         0
 812   };
 813
 814   for (ii=0; trampoline_code[ii]; ++ii) {
 815     op  = read_memory_integer (pc + (ii*4), 4);
 816     if (op != trampoline_code [ii])
 817       return NULL;
 818   }
 819   ii = read_register (11);              /* r11 holds destination addr   */
 820   pc = read_memory_integer (ii, 4);     /* (r11) value                  */
 821   return pc;
 822 }
 823