gdb/rs6000-tdep.c

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