gdb/rs6000-tdep.c

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