gdb/hppa-tdep.c

   1 /* Machine-dependent code which would otherwise be in inflow.c and core.c,
   2    for GDB, the GNU debugger.  This code is for the HP PA-RISC cpu.
   3    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   4
   5    Contributed by the Center for Software Science at the
   6    University of Utah (pa-gdb-bugs@cs.utah.edu).
   7
   8 This file is part of GDB.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23
  24 #include "defs.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "value.h"
  28
  29 /* For argument passing to the inferior */
  30 #include "symtab.h"
  31
  32 #ifdef USG
  33 #include <sys/types.h>
  34 #endif
  35
  36 #include <sys/param.h>
  37 #include <sys/dir.h>
  38 #include <signal.h>
  39 #include <sys/ioctl.h>
  40
  41 #ifdef COFF_ENCAPSULATE
  42 #include "a.out.encap.h"
  43 #else
  44 #include <a.out.h>
  45 #endif
  46 #ifndef N_SET_MAGIC
  47 #define N_SET_MAGIC(exec, val) ((exec).a_magic = (val))
  48 #endif
  49
  50 /*#include <sys/user.h>         After a.out.h  */
  51 #include <sys/file.h>
  52 #include <sys/stat.h>
  53 #include <machine/psl.h>
  54 #include "wait.h"
  55
  56 #include "gdbcore.h"
  57 #include "gdbcmd.h"
  58 #include "target.h"
  59 #include "symfile.h"
  60 #include "objfiles.h"
  61
  62 static int restore_pc_queue PARAMS ((struct frame_saved_regs *fsr));
  63 static int hppa_alignof PARAMS ((struct type *arg));
  64 CORE_ADDR frame_saved_pc PARAMS ((FRAME frame));
  65
  66 \f
  67 /* Routines to extract various sized constants out of hppa
  68    instructions. */
  69
  70 /* This assumes that no garbage lies outside of the lower bits of
  71    value. */
  72
  73 int
  74 sign_extend (val, bits)
  75      unsigned val, bits;
  76 {
  77   return (int)(val >> bits - 1 ? (-1 << bits) | val : val);
  78 }
  79
  80 /* For many immediate values the sign bit is the low bit! */
  81
  82 int
  83 low_sign_extend (val, bits)
  84      unsigned val, bits;
  85 {
  86   return (int)((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
  87 }
  88 /* extract the immediate field from a ld{bhw}s instruction */
  89
  90 unsigned
  91 get_field (val, from, to)
  92      unsigned val, from, to;
  93 {
  94   val = val >> 31 - to;
  95   return val & ((1 << 32 - from) - 1);
  96 }
  97
  98 unsigned
  99 set_field (val, from, to, new_val)
 100      unsigned *val, from, to;
 101 {
 102   unsigned mask = ~((1 << (to - from + 1)) << (31 - from));
 103   return *val = *val & mask | (new_val << (31 - from));
 104 }
 105
 106 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */
 107
 108 extract_3 (word)
 109      unsigned word;
 110 {
 111   return GET_FIELD (word, 18, 18) << 2 | GET_FIELD (word, 16, 17);
 112 }
 113
 114 extract_5_load (word)
 115      unsigned word;
 116 {
 117   return low_sign_extend (word >> 16 & MASK_5, 5);
 118 }
 119
 120 /* extract the immediate field from a st{bhw}s instruction */
 121
 122 int
 123 extract_5_store (word)
 124      unsigned word;
 125 {
 126   return low_sign_extend (word & MASK_5, 5);
 127 }
 128
 129 /* extract the immediate field from a break instruction */
 130
 131 unsigned
 132 extract_5r_store (word)
 133      unsigned word;
 134 {
 135   return (word & MASK_5);
 136 }
 137
 138 /* extract the immediate field from a {sr}sm instruction */
 139
 140 unsigned
 141 extract_5R_store (word)
 142      unsigned word;
 143 {
 144   return (word >> 16 & MASK_5);
 145 }
 146
 147 /* extract an 11 bit immediate field */
 148
 149 int
 150 extract_11 (word)
 151      unsigned word;
 152 {
 153   return low_sign_extend (word & MASK_11, 11);
 154 }
 155
 156 /* extract a 14 bit immediate field */
 157
 158 int
 159 extract_14 (word)
 160      unsigned word;
 161 {
 162   return low_sign_extend (word & MASK_14, 14);
 163 }
 164
 165 /* deposit a 14 bit constant in a word */
 166
 167 unsigned
 168 deposit_14 (opnd, word)
 169      int opnd;
 170      unsigned word;
 171 {
 172   unsigned sign = (opnd < 0 ? 1 : 0);
 173
 174   return word | ((unsigned)opnd << 1 & MASK_14)  | sign;
 175 }
 176
 177 /* extract a 21 bit constant */
 178
 179 int
 180 extract_21 (word)
 181      unsigned word;
 182 {
 183   int val;
 184
 185   word &= MASK_21;
 186   word <<= 11;
 187   val = GET_FIELD (word, 20, 20);
 188   val <<= 11;
 189   val |= GET_FIELD (word, 9, 19);
 190   val <<= 2;
 191   val |= GET_FIELD (word, 5, 6);
 192   val <<= 5;
 193   val |= GET_FIELD (word, 0, 4);
 194   val <<= 2;
 195   val |= GET_FIELD (word, 7, 8);
 196   return sign_extend (val, 21) << 11;
 197 }
 198
 199 /* deposit a 21 bit constant in a word. Although 21 bit constants are
 200    usually the top 21 bits of a 32 bit constant, we assume that only
 201    the low 21 bits of opnd are relevant */
 202
 203 unsigned
 204 deposit_21 (opnd, word)
 205      unsigned opnd, word;
 206 {
 207   unsigned val = 0;
 208
 209   val |= GET_FIELD (opnd, 11 + 14, 11 + 18);
 210   val <<= 2;
 211   val |= GET_FIELD (opnd, 11 + 12, 11 + 13);
 212   val <<= 2;
 213   val |= GET_FIELD (opnd, 11 + 19, 11 + 20);
 214   val <<= 11;
 215   val |= GET_FIELD (opnd, 11 + 1, 11 + 11);
 216   val <<= 1;
 217   val |= GET_FIELD (opnd, 11 + 0, 11 + 0);
 218   return word | val;
 219 }
 220
 221 /* extract a 12 bit constant from branch instructions */
 222
 223 int
 224 extract_12 (word)
 225      unsigned word;
 226 {
 227   return sign_extend (GET_FIELD (word, 19, 28) |
 228                       GET_FIELD (word, 29, 29) << 10 |
 229                       (word & 0x1) << 11, 12) << 2;
 230 }
 231
 232 /* extract a 17 bit constant from branch instructions, returning the
 233    19 bit signed value. */
 234
 235 int
 236 extract_17 (word)
 237      unsigned word;
 238 {
 239   return sign_extend (GET_FIELD (word, 19, 28) |
 240                       GET_FIELD (word, 29, 29) << 10 |
 241                       GET_FIELD (word, 11, 15) << 11 |
 242                       (word & 0x1) << 16, 17) << 2;
 243 }
 244 \f
 245 /* Lookup the unwind (stack backtrace) info for the given PC.  We search all
 246    of the objfiles seeking the unwind table entry for this PC.  Each objfile
 247    contains a sorted list of struct unwind_table_entry.  Since we do a binary
 248    search of the unwind tables, we depend upon them to be sorted.  */
 249
 250 static struct unwind_table_entry *
 251 find_unwind_entry(pc)
 252      CORE_ADDR pc;
 253 {
 254   int first, middle, last;
 255   struct objfile *objfile;
 256
 257   ALL_OBJFILES (objfile)
 258     {
 259       struct obj_unwind_info *ui;
 260
 261       ui = OBJ_UNWIND_INFO (objfile);
 262
 263       if (!ui)
 264         continue;
 265
 266       /* First, check the cache */
 267
 268       if (ui->cache
 269           && pc >= ui->cache->region_start
 270           && pc <= ui->cache->region_end)
 271         return ui->cache;
 272
 273       /* Not in the cache, do a binary search */
 274
 275       first = 0;
 276       last = ui->last;
 277
 278       while (first <= last)
 279         {
 280           middle = (first + last) / 2;
 281           if (pc >= ui->table[middle].region_start
 282               && pc <= ui->table[middle].region_end)
 283             {
 284               ui->cache = &ui->table[middle];
 285               return &ui->table[middle];
 286             }
 287
 288           if (pc < ui->table[middle].region_start)
 289             last = middle - 1;
 290           else
 291             first = middle + 1;
 292         }
 293     }                           /* ALL_OBJFILES() */
 294   return NULL;
 295 }
 296
 297 /* Called when no unwind descriptor was found for PC.  Returns 1 if it
 298    appears that PC is in a linker stub.  */
 299 static int pc_in_linker_stub PARAMS ((CORE_ADDR));
 300
 301 static int
 302 pc_in_linker_stub (pc)
 303      CORE_ADDR pc;
 304 {
 305   int found_magic_instruction = 0;
 306   int i;
 307   char buf[4];
 308
 309   /* If unable to read memory, assume pc is not in a linker stub.  */
 310   if (target_read_memory (pc, buf, 4) != 0)
 311     return 0;
 312
 313   /* We are looking for something like
 314
 315      ; $$dyncall jams RP into this special spot in the frame (RP')
 316      ; before calling the "call stub"
 317      ldw     -18(sp),rp
 318
 319      ldsid   (rp),r1         ; Get space associated with RP into r1
 320      mtsp    r1,sp           ; Move it into space register 0
 321      be,n    0(sr0),rp)      ; back to your regularly scheduled program
 322      */
 323
 324   /* Maximum known linker stub size is 4 instructions.  Search forward
 325      from the given PC, then backward.  */
 326   for (i = 0; i < 4; i++)
 327     {
 328       /* If we hit something with an unwind, stop searching this direction.  */
 329
 330       if (find_unwind_entry (pc + i * 4) != 0)
 331         break;
 332
 333       /* Check for ldsid (rp),r1 which is the magic instruction for a
 334          return from a cross-space function call.  */
 335       if (read_memory_integer (pc + i * 4, 4) == 0x004010a1)
 336         {
 337           found_magic_instruction = 1;
 338           break;
 339         }
 340       /* Add code to handle long call/branch and argument relocation stubs
 341          here.  */
 342     }
 343
 344   if (found_magic_instruction != 0)
 345     return 1;
 346
 347   /* Now look backward.  */
 348   for (i = 0; i < 4; i++)
 349     {
 350       /* If we hit something with an unwind, stop searching this direction.  */
 351
 352       if (find_unwind_entry (pc - i * 4) != 0)
 353         break;
 354
 355       /* Check for ldsid (rp),r1 which is the magic instruction for a
 356          return from a cross-space function call.  */
 357       if (read_memory_integer (pc - i * 4, 4) == 0x004010a1)
 358         {
 359           found_magic_instruction = 1;
 360           break;
 361         }
 362       /* Add code to handle long call/branch and argument relocation stubs
 363          here.  */
 364     }
 365   return found_magic_instruction;
 366 }
 367
 368 static int
 369 find_return_regnum(pc)
 370      CORE_ADDR pc;
 371 {
 372   struct unwind_table_entry *u;
 373
 374   u = find_unwind_entry (pc);
 375
 376   if (!u)
 377     return RP_REGNUM;
 378
 379   if (u->Millicode)
 380     return 31;
 381
 382   return RP_REGNUM;
 383 }
 384
 385 /* Return size of frame, or -1 if we should use a frame pointer.  */
 386 int
 387 find_proc_framesize(pc)
 388      CORE_ADDR pc;
 389 {
 390   struct unwind_table_entry *u;
 391
 392   u = find_unwind_entry (pc);
 393
 394   if (!u)
 395     {
 396       if (pc_in_linker_stub (pc))
 397         /* Linker stubs have a zero size frame.  */
 398         return 0;
 399       else
 400         return -1;
 401     }
 402
 403   if (u->Save_SP)
 404     /* If this bit is set, it means there is a frame pointer and we should
 405        use it.  */
 406     return -1;
 407
 408   return u->Total_frame_size << 3;
 409 }
 410
 411 /* Return offset from sp at which rp is saved, or 0 if not saved.  */
 412 static int rp_saved PARAMS ((CORE_ADDR));
 413
 414 static int
 415 rp_saved (pc)
 416      CORE_ADDR pc;
 417 {
 418   struct unwind_table_entry *u;
 419
 420   u = find_unwind_entry (pc);
 421
 422   if (!u)
 423     {
 424       if (pc_in_linker_stub (pc))
 425         /* This is the so-called RP'.  */
 426         return -24;
 427       else
 428         return 0;
 429     }
 430
 431   if (u->Save_RP)
 432     return -20;
 433   else
 434     return 0;
 435 }
 436 \f
 437 int
 438 frameless_function_invocation (frame)
 439      FRAME frame;
 440 {
 441   struct unwind_table_entry *u;
 442
 443   u = find_unwind_entry (frame->pc);
 444
 445   if (u == 0)
 446     return frameless_look_for_prologue (frame);
 447
 448   return (u->Total_frame_size == 0);
 449 }
 450
 451 CORE_ADDR
 452 saved_pc_after_call (frame)
 453      FRAME frame;
 454 {
 455   int ret_regnum;
 456
 457   ret_regnum = find_return_regnum (get_frame_pc (frame));
 458
 459   return read_register (ret_regnum) & ~0x3;
 460 }
 461 \f
 462 CORE_ADDR
 463 frame_saved_pc (frame)
 464      FRAME frame;
 465 {
 466   CORE_ADDR pc = get_frame_pc (frame);
 467
 468   if (frameless_function_invocation (frame))
 469     {
 470       int ret_regnum;
 471
 472       ret_regnum = find_return_regnum (pc);
 473
 474       return read_register (ret_regnum) & ~0x3;
 475     }
 476   else
 477     {
 478       int rp_offset = rp_saved (pc);
 479
 480       if (rp_offset == 0)
 481         return read_register (RP_REGNUM) & ~0x3;
 482       else
 483         return read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
 484     }
 485 }
 486 \f
 487 /* We need to correct the PC and the FP for the outermost frame when we are
 488    in a system call.  */
 489
 490 void
 491 init_extra_frame_info (fromleaf, frame)
 492      int fromleaf;
 493      struct frame_info *frame;
 494 {
 495   int flags;
 496   int framesize;
 497
 498   if (frame->next)              /* Only do this for outermost frame */
 499     return;
 500
 501   flags = read_register (FLAGS_REGNUM);
 502   if (flags & 2)        /* In system call? */
 503     frame->pc = read_register (31) & ~0x3;
 504
 505   /* The outermost frame is always derived from PC-framesize */
 506   framesize = find_proc_framesize(frame->pc);
 507   if (framesize == -1)
 508     frame->frame = read_register (FP_REGNUM);
 509   else
 510     frame->frame = read_register (SP_REGNUM) - framesize;
 511
 512   if (!frameless_function_invocation (frame)) /* Frameless? */
 513     return;                                 /* No, quit now */
 514
 515   /* For frameless functions, we need to look at the caller's frame */
 516   framesize = find_proc_framesize(FRAME_SAVED_PC(frame));
 517   if (framesize != -1)
 518     frame->frame -= framesize;
 519 }
 520 \f
 521 FRAME_ADDR
 522 frame_chain (frame)
 523      struct frame_info *frame;
 524 {
 525   int framesize;
 526
 527   framesize = find_proc_framesize(FRAME_SAVED_PC(frame));
 528
 529   if (framesize != -1)
 530     return frame->frame - framesize;
 531
 532   return read_memory_integer (frame->frame, 4);
 533 }
 534 \f
 535 /* To see if a frame chain is valid, see if the caller looks like it
 536    was compiled with gcc. */
 537
 538 int
 539 frame_chain_valid (chain, thisframe)
 540      FRAME_ADDR chain;
 541      FRAME thisframe;
 542 {
 543   struct minimal_symbol *msym_us;
 544   struct minimal_symbol *msym_start;
 545   struct unwind_table_entry *u;
 546
 547   if (!chain)
 548     return 0;
 549
 550   u = find_unwind_entry (thisframe->pc);
 551
 552   /* We can't just check that the same of msym_us is "_start", because
 553      someone idiotically decided that they were going to make a Ltext_end
 554      symbol with the same address.  This Ltext_end symbol is totally
 555      indistinguishable (as nearly as I can tell) from the symbol for a function
 556      which is (legitimately, since it is in the user's namespace)
 557      named Ltext_end, so we can't just ignore it.  */
 558   msym_us = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe));
 559   msym_start = lookup_minimal_symbol ("_start", NULL);
 560   if (msym_us
 561       && msym_start
 562       && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
 563     return 0;
 564
 565   if (u == NULL)
 566     return 1;
 567
 568   if (u->Save_SP || u->Total_frame_size)
 569     return 1;
 570
 571   if (pc_in_linker_stub (thisframe->pc))
 572     return 1;
 573
 574   return 0;
 575 }
 576
 577 /*
 578  * These functions deal with saving and restoring register state
 579  * around a function call in the inferior. They keep the stack
 580  * double-word aligned; eventually, on an hp700, the stack will have
 581  * to be aligned to a 64-byte boundary.
 582  */
 583
 584 int
 585 push_dummy_frame ()
 586 {
 587   register CORE_ADDR sp;
 588   register int regnum;
 589   int int_buffer;
 590   double freg_buffer;
 591
 592   /* Space for "arguments"; the RP goes in here. */
 593   sp = read_register (SP_REGNUM) + 48;
 594   int_buffer = read_register (RP_REGNUM) | 0x3;
 595   write_memory (sp - 20, (char *)&int_buffer, 4);
 596
 597   int_buffer = read_register (FP_REGNUM);
 598   write_memory (sp, (char *)&int_buffer, 4);
 599
 600   write_register (FP_REGNUM, sp);
 601
 602   sp += 8;
 603
 604   for (regnum = 1; regnum < 32; regnum++)
 605     if (regnum != RP_REGNUM && regnum != FP_REGNUM)
 606       sp = push_word (sp, read_register (regnum));
 607
 608   sp += 4;
 609
 610   for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
 611     {
 612       read_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
 613       sp = push_bytes (sp, (char *)&freg_buffer, 8);
 614     }
 615   sp = push_word (sp, read_register (IPSW_REGNUM));
 616   sp = push_word (sp, read_register (SAR_REGNUM));
 617   sp = push_word (sp, read_register (PCOQ_HEAD_REGNUM));
 618   sp = push_word (sp, read_register (PCSQ_HEAD_REGNUM));
 619   sp = push_word (sp, read_register (PCOQ_TAIL_REGNUM));
 620   sp = push_word (sp, read_register (PCSQ_TAIL_REGNUM));
 621   write_register (SP_REGNUM, sp);
 622 }
 623
 624 find_dummy_frame_regs (frame, frame_saved_regs)
 625      struct frame_info *frame;
 626      struct frame_saved_regs *frame_saved_regs;
 627 {
 628   CORE_ADDR fp = frame->frame;
 629   int i;
 630
 631   frame_saved_regs->regs[RP_REGNUM] = fp - 20 & ~0x3;
 632   frame_saved_regs->regs[FP_REGNUM] = fp;
 633   frame_saved_regs->regs[1] = fp + 8;
 634
 635   for (fp += 12, i = 3; i < 32; i++)
 636     {
 637       if (i != FP_REGNUM)
 638         {
 639           frame_saved_regs->regs[i] = fp;
 640           fp += 4;
 641         }
 642     }
 643
 644   fp += 4;
 645   for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
 646     frame_saved_regs->regs[i] = fp;
 647
 648   frame_saved_regs->regs[IPSW_REGNUM] = fp;
 649   frame_saved_regs->regs[SAR_REGNUM] = fp + 4;
 650   frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 8;
 651   frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 12;
 652   frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 16;
 653   frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 20;
 654 }
 655
 656 int
 657 hppa_pop_frame ()
 658 {
 659   register FRAME frame = get_current_frame ();
 660   register CORE_ADDR fp;
 661   register int regnum;
 662   struct frame_saved_regs fsr;
 663   struct frame_info *fi;
 664   double freg_buffer;
 665
 666   fi = get_frame_info (frame);
 667   fp = fi->frame;
 668   get_frame_saved_regs (fi, &fsr);
 669
 670   if (fsr.regs[IPSW_REGNUM])    /* Restoring a call dummy frame */
 671     restore_pc_queue (&fsr);
 672
 673   for (regnum = 31; regnum > 0; regnum--)
 674     if (fsr.regs[regnum])
 675       write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
 676
 677   for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM ; regnum--)
 678     if (fsr.regs[regnum])
 679       {
 680         read_memory (fsr.regs[regnum], (char *)&freg_buffer, 8);
 681         write_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
 682       }
 683
 684   if (fsr.regs[IPSW_REGNUM])
 685     write_register (IPSW_REGNUM,
 686                     read_memory_integer (fsr.regs[IPSW_REGNUM], 4));
 687
 688   if (fsr.regs[SAR_REGNUM])
 689     write_register (SAR_REGNUM,
 690                     read_memory_integer (fsr.regs[SAR_REGNUM], 4));
 691
 692   /* If the PC was explicitly saved, then just restore it.  */
 693   if (fsr.regs[PCOQ_TAIL_REGNUM])
 694     write_register (PCOQ_TAIL_REGNUM,
 695                     read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM], 4));
 696
 697   /* Else use the value in %rp to set the new PC.  */
 698   else
 699     target_write_pc (read_register (RP_REGNUM));
 700
 701   write_register (FP_REGNUM, read_memory_integer (fp, 4));
 702
 703   if (fsr.regs[IPSW_REGNUM])    /* call dummy */
 704     write_register (SP_REGNUM, fp - 48);
 705   else
 706     write_register (SP_REGNUM, fp);
 707
 708   flush_cached_frames ();
 709   set_current_frame (create_new_frame (read_register (FP_REGNUM),
 710                                        read_pc ()));
 711 }
 712
 713 /*
 714  * After returning to a dummy on the stack, restore the instruction
 715  * queue space registers. */
 716
 717 static int
 718 restore_pc_queue (fsr)
 719      struct frame_saved_regs *fsr;
 720 {
 721   CORE_ADDR pc = read_pc ();
 722   CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM], 4);
 723   int pid;
 724   WAITTYPE w;
 725   int insn_count;
 726
 727   /* Advance past break instruction in the call dummy. */
 728   write_register (PCOQ_HEAD_REGNUM, pc + 4);
 729   write_register (PCOQ_TAIL_REGNUM, pc + 8);
 730
 731   /*
 732    * HPUX doesn't let us set the space registers or the space
 733    * registers of the PC queue through ptrace. Boo, hiss.
 734    * Conveniently, the call dummy has this sequence of instructions
 735    * after the break:
 736    *    mtsp r21, sr0
 737    *    ble,n 0(sr0, r22)
 738    *
 739    * So, load up the registers and single step until we are in the
 740    * right place.
 741    */
 742
 743   write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM], 4));
 744   write_register (22, new_pc);
 745
 746   for (insn_count = 0; insn_count < 3; insn_count++)
 747     {
 748       resume (1, 0);
 749       target_wait(&w);
 750
 751       if (!WIFSTOPPED (w))
 752         {
 753           stop_signal = WTERMSIG (w);
 754           terminal_ours_for_output ();
 755           printf ("\nProgram terminated with signal %d, %s\n",
 756                   stop_signal, safe_strsignal (stop_signal));
 757           fflush (stdout);
 758           return 0;
 759         }
 760     }
 761   fetch_inferior_registers (-1);
 762   return 1;
 763 }
 764
 765 CORE_ADDR
 766 hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
 767      int nargs;
 768      value *args;
 769      CORE_ADDR sp;
 770      int struct_return;
 771      CORE_ADDR struct_addr;
 772 {
 773   /* array of arguments' offsets */
 774   int *offset = (int *)alloca(nargs * sizeof (int));
 775   int cum = 0;
 776   int i, alignment;
 777
 778   for (i = 0; i < nargs; i++)
 779     {
 780       /* Coerce chars to int & float to double if necessary */
 781       args[i] = value_arg_coerce (args[i]);
 782
 783       cum += TYPE_LENGTH (VALUE_TYPE (args[i]));
 784
 785     /* value must go at proper alignment. Assume alignment is a
 786          power of two.*/
 787       alignment = hppa_alignof (VALUE_TYPE (args[i]));
 788       if (cum % alignment)
 789         cum = (cum + alignment) & -alignment;
 790       offset[i] = -cum;
 791     }
 792   sp += max ((cum + 7) & -8, 16);
 793
 794   for (i = 0; i < nargs; i++)
 795     write_memory (sp + offset[i], VALUE_CONTENTS (args[i]),
 796                   TYPE_LENGTH (VALUE_TYPE (args[i])));
 797
 798   if (struct_return)
 799     write_register (28, struct_addr);
 800   return sp + 32;
 801 }
 802
 803 /*
 804  * Insert the specified number of args and function address
 805  * into a call sequence of the above form stored at DUMMYNAME.
 806  *
 807  * On the hppa we need to call the stack dummy through $$dyncall.
 808  * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
 809  * real_pc, which is the location where gdb should start up the
 810  * inferior to do the function call.
 811  */
 812
 813 CORE_ADDR
 814 hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
 815      REGISTER_TYPE *dummy;
 816      CORE_ADDR pc;
 817      CORE_ADDR fun;
 818      int nargs;
 819      value *args;
 820      struct type *type;
 821      int gcc_p;
 822 {
 823   CORE_ADDR dyncall_addr, sr4export_addr;
 824   struct minimal_symbol *msymbol;
 825   int flags = read_register (FLAGS_REGNUM);
 826
 827   msymbol = lookup_minimal_symbol ("$$dyncall", (struct objfile *) NULL);
 828   if (msymbol == NULL)
 829     error ("Can't find an address for $$dyncall trampoline");
 830
 831   dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
 832
 833   msymbol = lookup_minimal_symbol ("_sr4export", (struct objfile *) NULL);
 834   if (msymbol == NULL)
 835     error ("Can't find an address for _sr4export trampoline");
 836
 837   sr4export_addr = SYMBOL_VALUE_ADDRESS (msymbol);
 838
 839   dummy[9] = deposit_21 (fun >> 11, dummy[9]);
 840   dummy[10] = deposit_14 (fun & MASK_11, dummy[10]);
 841   dummy[12] = deposit_21 (sr4export_addr >> 11, dummy[12]);
 842   dummy[13] = deposit_14 (sr4export_addr & MASK_11, dummy[13]);
 843
 844   write_register (22, pc);
 845
 846   /* If we are in a syscall, then we should call the stack dummy
 847      directly.  $$dyncall is not needed as the kernel sets up the
 848      space id registers properly based on the value in %r31.  In
 849      fact calling $$dyncall will not work because the value in %r22
 850      will be clobbered on the syscall exit path.  */
 851   if (flags & 2)
 852     return pc;
 853   else
 854     return dyncall_addr;
 855
 856 }
 857
 858 /* Get the PC from %r31 if currently in a syscall.  Also mask out privilege
 859    bits.  */
 860 CORE_ADDR
 861 target_read_pc ()
 862 {
 863   int flags = read_register (FLAGS_REGNUM);
 864
 865   if (flags & 2)
 866     return read_register (31) & ~0x3;
 867   return read_register (PC_REGNUM) & ~0x3;
 868 }
 869
 870 /* Write out the PC.  If currently in a syscall, then also write the new
 871    PC value into %r31.  */
 872 void
 873 target_write_pc (v)
 874      CORE_ADDR v;
 875 {
 876   int flags = read_register (FLAGS_REGNUM);
 877
 878   /* If in a syscall, then set %r31.  Also make sure to get the
 879      privilege bits set correctly.  */
 880   if (flags & 2)
 881     write_register (31, (long) (v | 0x3));
 882
 883   write_register (PC_REGNUM, (long) v);
 884   write_register (NPC_REGNUM, (long) v + 4);
 885 }
 886
 887 /* return the alignment of a type in bytes. Structures have the maximum
 888    alignment required by their fields. */
 889
 890 static int
 891 hppa_alignof (arg)
 892      struct type *arg;
 893 {
 894   int max_align, align, i;
 895   switch (TYPE_CODE (arg))
 896     {
 897     case TYPE_CODE_PTR:
 898     case TYPE_CODE_INT:
 899     case TYPE_CODE_FLT:
 900       return TYPE_LENGTH (arg);
 901     case TYPE_CODE_ARRAY:
 902       return hppa_alignof (TYPE_FIELD_TYPE (arg, 0));
 903     case TYPE_CODE_STRUCT:
 904     case TYPE_CODE_UNION:
 905       max_align = 2;
 906       for (i = 0; i < TYPE_NFIELDS (arg); i++)
 907         {
 908           /* Bit fields have no real alignment. */
 909           if (!TYPE_FIELD_BITPOS (arg, i))
 910             {
 911               align = hppa_alignof (TYPE_FIELD_TYPE (arg, i));
 912               max_align = max (max_align, align);
 913             }
 914         }
 915       return max_align;
 916     default:
 917       return 4;
 918     }
 919 }
 920
 921 /* Print the register regnum, or all registers if regnum is -1 */
 922
 923 pa_do_registers_info (regnum, fpregs)
 924      int regnum;
 925      int fpregs;
 926 {
 927   char raw_regs [REGISTER_BYTES];
 928   int i;
 929
 930   for (i = 0; i < NUM_REGS; i++)
 931     read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
 932   if (regnum == -1)
 933     pa_print_registers (raw_regs, regnum, fpregs);
 934   else if (regnum < FP0_REGNUM)
 935     printf ("%s %x\n", reg_names[regnum], *(long *)(raw_regs +
 936                                                     REGISTER_BYTE (regnum)));
 937   else
 938     pa_print_fp_reg (regnum);
 939 }
 940
 941 pa_print_registers (raw_regs, regnum, fpregs)
 942      char *raw_regs;
 943      int regnum;
 944      int fpregs;
 945 {
 946   int i;
 947
 948   for (i = 0; i < 18; i++)
 949     printf ("%8.8s: %8x  %8.8s: %8x  %8.8s: %8x  %8.8s: %8x\n",
 950             reg_names[i],
 951             *(int *)(raw_regs + REGISTER_BYTE (i)),
 952             reg_names[i + 18],
 953             *(int *)(raw_regs + REGISTER_BYTE (i + 18)),
 954             reg_names[i + 36],
 955             *(int *)(raw_regs + REGISTER_BYTE (i + 36)),
 956             reg_names[i + 54],
 957             *(int *)(raw_regs + REGISTER_BYTE (i + 54)));
 958
 959   if (fpregs)
 960     for (i = 72; i < NUM_REGS; i++)
 961       pa_print_fp_reg (i);
 962 }
 963
 964 pa_print_fp_reg (i)
 965      int i;
 966 {
 967   unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
 968   unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 969   REGISTER_TYPE val;
 970
 971   /* Get the data in raw format, then convert also to virtual format.  */
 972   read_relative_register_raw_bytes (i, raw_buffer);
 973   REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
 974
 975   fputs_filtered (reg_names[i], stdout);
 976   print_spaces_filtered (15 - strlen (reg_names[i]), stdout);
 977
 978   val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout, 0,
 979              1, 0, Val_pretty_default);
 980   printf_filtered ("\n");
 981 }
 982
 983 /* Function calls that pass into a new compilation unit must pass through a
 984    small piece of code that does long format (`external' in HPPA parlance)
 985    jumps.  We figure out where the trampoline is going to end up, and return
 986    the PC of the final destination.  If we aren't in a trampoline, we just
 987    return NULL.
 988
 989    For computed calls, we just extract the new PC from r22.  */
 990
 991 CORE_ADDR
 992 skip_trampoline_code (pc, name)
 993      CORE_ADDR pc;
 994      char *name;
 995 {
 996   long inst0, inst1;
 997   static CORE_ADDR dyncall = 0;
 998   struct minimal_symbol *msym;
 999
1000 /* FIXME XXX - dyncall must be initialized whenever we get a new exec file */
1001
1002   if (!dyncall)
1003     {
1004       msym = lookup_minimal_symbol ("$$dyncall", NULL);
1005       if (msym)
1006         dyncall = SYMBOL_VALUE_ADDRESS (msym);
1007       else
1008         dyncall = -1;
1009     }
1010
1011   if (pc == dyncall)
1012     return (CORE_ADDR)(read_register (22) & ~0x3);
1013
1014   inst0 = read_memory_integer (pc, 4);
1015   inst1 = read_memory_integer (pc+4, 4);
1016
1017   if (   (inst0 & 0xffe00000) == 0x20200000 /* ldil xxx, r1 */
1018       && (inst1 & 0xffe0e002) == 0xe0202002) /* be,n yyy(sr4, r1) */
1019     pc = extract_21 (inst0) + extract_17 (inst1);
1020   else
1021     pc = (CORE_ADDR)NULL;
1022
1023   return pc;
1024 }
1025
1026 /* Advance PC across any function entry prologue instructions
1027    to reach some "real" code.  */
1028
1029 /* skip (stw rp, -20(0,sp)); copy 4,1; copy sp, 4; stwm 1,framesize(sp)
1030    for gcc, or (stw rp, -20(0,sp); stwm 1, framesize(sp) for hcc */
1031
1032 CORE_ADDR
1033 skip_prologue(pc)
1034      CORE_ADDR pc;
1035 {
1036   char buf[4];
1037   unsigned long inst;
1038   int status;
1039
1040   status = target_read_memory (pc, buf, 4);
1041   inst = extract_unsigned_integer (buf, 4);
1042   if (status != 0)
1043     return pc;
1044
1045   if (inst == 0x6BC23FD9)       /* stw rp,-20(sp) */
1046     {
1047       if (read_memory_integer (pc + 4, 4) == 0x8040241) /* copy r4,r1 */
1048         pc += 16;
1049       else if ((read_memory_integer (pc + 4, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
1050         pc += 8;
1051     }
1052   else if (read_memory_integer (pc, 4) == 0x8040241) /* copy r4,r1 */
1053     pc += 12;
1054   else if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
1055     pc += 4;
1056
1057   return pc;
1058 }
1059
1060 #ifdef MAINTENANCE_CMDS
1061
1062 static void
1063 unwind_command (exp, from_tty)
1064      char *exp;
1065      int from_tty;
1066 {
1067   CORE_ADDR address;
1068   union
1069     {
1070       int *foo;
1071       struct unwind_table_entry *u;
1072     } xxx;
1073
1074   /* If we have an expression, evaluate it and use it as the address.  */
1075
1076   if (exp != 0 && *exp != 0)
1077     address = parse_and_eval_address (exp);
1078   else
1079     return;
1080
1081   xxx.u = find_unwind_entry (address);
1082
1083   if (!xxx.u)
1084     {
1085       printf ("Can't find unwind table entry for PC 0x%x\n", address);
1086       return;
1087     }
1088
1089   printf ("%08x\n%08X\n%08X\n%08X\n", xxx.foo[0], xxx.foo[1], xxx.foo[2],
1090           xxx.foo[3]);
1091 }
1092
1093 void
1094 _initialize_hppa_tdep ()
1095 {
1096   add_cmd ("unwind", class_maintenance, unwind_command,
1097            "Print unwind table entry at given address.",
1098            &maintenanceprintlist);
1099 }
1100
1101 #endif /* MAINTENANCE_CMDS */