home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / gdb / hppa-tdep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  22.4 KB  |  964 lines
  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.  
  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.  
  245. static int use_unwind = 0;
  246.  
  247. /* Lookup the unwind (stack backtrace) info for the given PC.  We search all
  248.    of the objfiles seeking the unwind table entry for this PC.  Each objfile
  249.    contains a sorted list of struct unwind_table_entry.  Since we do a binary
  250.    search of the unwind tables, we depend upon them to be sorted.  */
  251.  
  252. static struct unwind_table_entry *
  253. find_unwind_entry(pc)
  254.      CORE_ADDR pc;
  255. {
  256.   int first, middle, last;
  257.   struct objfile *objfile;
  258.  
  259.   ALL_OBJFILES (objfile)
  260.     {
  261.       struct obj_unwind_info *ui;
  262.  
  263.       ui = OBJ_UNWIND_INFO (objfile);
  264.  
  265.       if (!ui)
  266.     continue;
  267.  
  268.       /* First, check the cache */
  269.  
  270.       if (ui->cache
  271.       && pc >= ui->cache->region_start
  272.       && pc <= ui->cache->region_end)
  273.     return ui->cache;
  274.  
  275.       /* Not in the cache, do a binary search */
  276.  
  277.       first = 0;
  278.       last = ui->last;
  279.  
  280.       while (first <= last)
  281.     {
  282.       middle = (first + last) / 2;
  283.       if (pc >= ui->table[middle].region_start
  284.           && pc <= ui->table[middle].region_end)
  285.         {
  286.           ui->cache = &ui->table[middle];
  287.           return &ui->table[middle];
  288.         }
  289.  
  290.       if (pc < ui->table[middle].region_start)
  291.         last = middle - 1;
  292.       else
  293.         first = middle + 1;
  294.     }
  295.     }                /* ALL_OBJFILES() */
  296.   return NULL;
  297. }
  298.  
  299. static int
  300. find_return_regnum(pc)
  301.      CORE_ADDR pc;
  302. {
  303.   struct unwind_table_entry *u;
  304.  
  305.   u = find_unwind_entry (pc);
  306.  
  307.   if (!u)
  308.     return RP_REGNUM;
  309.  
  310.   if (u->Millicode)
  311.     return 31;
  312.  
  313.   return RP_REGNUM;
  314. }
  315.  
  316. int
  317. find_proc_framesize(pc)
  318.      CORE_ADDR pc;
  319. {
  320.   struct unwind_table_entry *u;
  321.  
  322.   if (!use_unwind)
  323.     return -1;
  324.  
  325.   u = find_unwind_entry (pc);
  326.  
  327.   if (!u)
  328.     return -1;
  329.  
  330.   return u->Total_frame_size << 3;
  331. }
  332.  
  333. int
  334. rp_saved(pc)
  335. {
  336.   struct unwind_table_entry *u;
  337.  
  338.   u = find_unwind_entry (pc);
  339.  
  340.   if (!u)
  341.     return 0;
  342.  
  343.   if (u->Save_RP)
  344.     return 1;
  345.   else
  346.     return 0;
  347. }
  348.  
  349. int
  350. frameless_function_invocation (frame)
  351.      FRAME frame;
  352. {
  353.  
  354.   if (use_unwind)
  355.     {
  356.       struct unwind_table_entry *u;
  357.  
  358.       u = find_unwind_entry (frame->pc);
  359.  
  360.       if (u == 0)
  361.     return 0;
  362.  
  363.       return (u->Total_frame_size == 0);
  364.     }
  365.   else
  366.     return frameless_look_for_prologue (frame);
  367. }
  368.  
  369. CORE_ADDR
  370. saved_pc_after_call (frame)
  371.      FRAME frame;
  372. {
  373.   int ret_regnum;
  374.  
  375.   ret_regnum = find_return_regnum (get_frame_pc (frame));
  376.  
  377.   return read_register (ret_regnum) & ~0x3;
  378. }
  379.  
  380. CORE_ADDR
  381. frame_saved_pc (frame)
  382.      FRAME frame;
  383. {
  384.   CORE_ADDR pc = get_frame_pc (frame);
  385.  
  386.   if (frameless_function_invocation (frame))
  387.     {
  388.       int ret_regnum;
  389.  
  390.       ret_regnum = find_return_regnum (pc);
  391.  
  392.       return read_register (ret_regnum) & ~0x3;
  393.     }
  394.   else if (rp_saved (pc))
  395.     return read_memory_integer (frame->frame - 20, 4) & ~0x3;
  396.   else
  397.     return read_register (RP_REGNUM) & ~0x3;
  398. }
  399.  
  400. /* We need to correct the PC and the FP for the outermost frame when we are
  401.    in a system call.  */
  402.  
  403. void
  404. init_extra_frame_info (fromleaf, frame)
  405.      int fromleaf;
  406.      struct frame_info *frame;
  407. {
  408.   int flags;
  409.   int framesize;
  410.  
  411.   if (frame->next)        /* Only do this for outermost frame */
  412.     return;
  413.  
  414.   flags = read_register (FLAGS_REGNUM);
  415.   if (flags & 2)    /* In system call? */
  416.     frame->pc = read_register (31) & ~0x3;
  417.  
  418.   /* The outermost frame is always derived from PC-framesize */
  419.   framesize = find_proc_framesize(frame->pc);
  420.   if (framesize == -1)
  421.     frame->frame = read_register (FP_REGNUM);
  422.   else
  423.     frame->frame = read_register (SP_REGNUM) - framesize;
  424.  
  425.   if (!frameless_function_invocation (frame)) /* Frameless? */
  426.     return;                    /* No, quit now */
  427.  
  428.   /* For frameless functions, we need to look at the caller's frame */
  429.   framesize = find_proc_framesize(FRAME_SAVED_PC(frame));
  430.   if (framesize != -1)
  431.     frame->frame -= framesize;
  432. }
  433.  
  434. FRAME_ADDR
  435. frame_chain (frame)
  436.      struct frame_info *frame;
  437. {
  438.   int framesize;
  439.  
  440.   framesize = find_proc_framesize(FRAME_SAVED_PC(frame));
  441.  
  442.   if (framesize != -1)
  443.     return frame->frame - framesize;
  444.  
  445.   return read_memory_integer (frame->frame, 4);
  446. }
  447.  
  448. /* To see if a frame chain is valid, see if the caller looks like it
  449.    was compiled with gcc. */
  450.  
  451. int
  452. frame_chain_valid (chain, thisframe)
  453.      FRAME_ADDR chain;
  454.      FRAME thisframe;
  455. {
  456.   struct minimal_symbol *msym;
  457.  
  458.   if (!chain)
  459.     return 0;
  460.  
  461.   if (use_unwind)
  462.     {
  463.  
  464.       struct unwind_table_entry *u;
  465.  
  466.       u = find_unwind_entry (thisframe->pc);
  467.  
  468.       if (u && (u->Save_SP || u->Total_frame_size))
  469.     return 1;
  470.       else
  471.     return 0;
  472.     }
  473.   else
  474.     {
  475.       msym = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe));
  476.  
  477.       if (msym
  478.       && (strcmp (SYMBOL_NAME (msym), "_start") == 0))
  479.     return 0;
  480.       else
  481.     return 1;
  482.     }
  483. }
  484.  
  485. /*
  486.  * These functions deal with saving and restoring register state
  487.  * around a function call in the inferior. They keep the stack
  488.  * double-word aligned; eventually, on an hp700, the stack will have
  489.  * to be aligned to a 64-byte boundary.
  490.  */
  491.  
  492. int
  493. push_dummy_frame ()
  494. {
  495.   register CORE_ADDR sp;
  496.   register int regnum;
  497.   int int_buffer;
  498.   double freg_buffer;
  499.  
  500.   /* Space for "arguments"; the RP goes in here. */
  501.   sp = read_register (SP_REGNUM) + 48;
  502.   int_buffer = read_register (RP_REGNUM) | 0x3;
  503.   write_memory (sp - 20, (char *)&int_buffer, 4);
  504.  
  505.   int_buffer = read_register (FP_REGNUM);
  506.   write_memory (sp, (char *)&int_buffer, 4);
  507.  
  508.   write_register (FP_REGNUM, sp);
  509.  
  510.   sp += 8;
  511.  
  512.   for (regnum = 1; regnum < 32; regnum++)
  513.     if (regnum != RP_REGNUM && regnum != FP_REGNUM)
  514.       sp = push_word (sp, read_register (regnum));
  515.  
  516.   sp += 4;
  517.  
  518.   for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
  519.     {
  520.       read_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
  521.       sp = push_bytes (sp, (char *)&freg_buffer, 8);
  522.     }
  523.   sp = push_word (sp, read_register (IPSW_REGNUM));
  524.   sp = push_word (sp, read_register (SAR_REGNUM));
  525.   sp = push_word (sp, read_register (PCOQ_HEAD_REGNUM));
  526.   sp = push_word (sp, read_register (PCSQ_HEAD_REGNUM));
  527.   sp = push_word (sp, read_register (PCOQ_TAIL_REGNUM));
  528.   sp = push_word (sp, read_register (PCSQ_TAIL_REGNUM));
  529.   write_register (SP_REGNUM, sp);
  530. }
  531.  
  532. find_dummy_frame_regs (frame, frame_saved_regs)
  533.      struct frame_info *frame;
  534.      struct frame_saved_regs *frame_saved_regs;
  535. {
  536.   CORE_ADDR fp = frame->frame;
  537.   int i;
  538.  
  539.   frame_saved_regs->regs[RP_REGNUM] = fp - 20 & ~0x3;
  540.   frame_saved_regs->regs[FP_REGNUM] = fp;
  541.   frame_saved_regs->regs[1] = fp + 8;
  542.  
  543.   for (fp += 12, i = 3; i < 32; i++)
  544.     {
  545.       if (i != FP_REGNUM)
  546.     {
  547.       frame_saved_regs->regs[i] = fp;
  548.       fp += 4;
  549.     }
  550.     }
  551.  
  552.   fp += 4;
  553.   for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
  554.     frame_saved_regs->regs[i] = fp;
  555.  
  556.   frame_saved_regs->regs[IPSW_REGNUM] = fp;
  557.   frame_saved_regs->regs[SAR_REGNUM] = fp + 4;
  558.   frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 8;
  559.   frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 12;
  560.   frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 16;
  561.   frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 20;
  562. }
  563.  
  564. int
  565. hppa_pop_frame ()
  566. {
  567.   register FRAME frame = get_current_frame ();
  568.   register CORE_ADDR fp;
  569.   register int regnum;
  570.   struct frame_saved_regs fsr;
  571.   struct frame_info *fi;
  572.   double freg_buffer;
  573.  
  574.   fi = get_frame_info (frame);
  575.   fp = fi->frame;
  576.   get_frame_saved_regs (fi, &fsr);
  577.  
  578.   if (fsr.regs[IPSW_REGNUM])    /* Restoring a call dummy frame */
  579.     restore_pc_queue (&fsr);
  580.  
  581.   for (regnum = 31; regnum > 0; regnum--)
  582.     if (fsr.regs[regnum])
  583.       write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
  584.  
  585.   for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM ; regnum--)
  586.     if (fsr.regs[regnum])
  587.       {
  588.     read_memory (fsr.regs[regnum], (char *)&freg_buffer, 8);
  589.         write_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
  590.       }
  591.  
  592.   if (fsr.regs[IPSW_REGNUM])
  593.     write_register (IPSW_REGNUM,
  594.                     read_memory_integer (fsr.regs[IPSW_REGNUM], 4));
  595.  
  596.   if (fsr.regs[SAR_REGNUM])
  597.     write_register (SAR_REGNUM,
  598.                     read_memory_integer (fsr.regs[SAR_REGNUM], 4));
  599.  
  600.   if (fsr.regs[PCOQ_TAIL_REGNUM])
  601.     write_register (PCOQ_TAIL_REGNUM,
  602.                     read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM], 4));
  603.  
  604.   write_register (FP_REGNUM, read_memory_integer (fp, 4));
  605.  
  606.   if (fsr.regs[IPSW_REGNUM])    /* call dummy */
  607.     write_register (SP_REGNUM, fp - 48);
  608.   else
  609.     write_register (SP_REGNUM, fp);
  610.  
  611.   flush_cached_frames ();
  612.   set_current_frame (create_new_frame (read_register (FP_REGNUM),
  613.                                        read_pc ()));
  614. }
  615.  
  616. /*
  617.  * After returning to a dummy on the stack, restore the instruction
  618.  * queue space registers. */
  619.  
  620. static int
  621. restore_pc_queue (fsr)
  622.      struct frame_saved_regs *fsr;
  623. {
  624.   CORE_ADDR pc = read_pc ();
  625.   CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM], 4);
  626.   int pid;
  627.   WAITTYPE w;
  628.   int insn_count;
  629.  
  630.   /* Advance past break instruction in the call dummy. */
  631.   write_register (PCOQ_HEAD_REGNUM, pc + 4);
  632.   write_register (PCOQ_TAIL_REGNUM, pc + 8);
  633.  
  634.   /*
  635.    * HPUX doesn't let us set the space registers or the space
  636.    * registers of the PC queue through ptrace. Boo, hiss.
  637.    * Conveniently, the call dummy has this sequence of instructions
  638.    * after the break:
  639.    *    mtsp r21, sr0
  640.    *    ble,n 0(sr0, r22)
  641.    *
  642.    * So, load up the registers and single step until we are in the
  643.    * right place.
  644.    */
  645.  
  646.   write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM], 4));
  647.   write_register (22, new_pc);
  648.  
  649.   for (insn_count = 0; insn_count < 3; insn_count++)
  650.     {
  651.       resume (1, 0);
  652.       target_wait(&w);
  653.  
  654.       if (!WIFSTOPPED (w))
  655.         {
  656.           stop_signal = WTERMSIG (w);
  657.           terminal_ours_for_output ();
  658.           printf ("\nProgram terminated with signal %d, %s\n",
  659.                   stop_signal, safe_strsignal (stop_signal));
  660.           fflush (stdout);
  661.           return 0;
  662.         }
  663.     }
  664.   fetch_inferior_registers (-1);
  665.   return 1;
  666. }
  667.  
  668. CORE_ADDR
  669. hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
  670.      int nargs;
  671.      value *args;
  672.      CORE_ADDR sp;
  673.      int struct_return;
  674.      CORE_ADDR struct_addr;
  675. {
  676.   /* array of arguments' offsets */
  677.   int *offset = (int *)alloca(nargs * sizeof (int));
  678.   int cum = 0;
  679.   int i, alignment;
  680.   
  681.   for (i = 0; i < nargs; i++)
  682.     {
  683.       /* Coerce chars to int & float to double if necessary */
  684.       args[i] = value_arg_coerce (args[i]);
  685.  
  686.       cum += TYPE_LENGTH (VALUE_TYPE (args[i]));
  687.  
  688.     /* value must go at proper alignment. Assume alignment is a
  689.      power of two.*/
  690.       alignment = hppa_alignof (VALUE_TYPE (args[i]));
  691.       if (cum % alignment)
  692.     cum = (cum + alignment) & -alignment;
  693.       offset[i] = -cum;
  694.     }
  695.   sp += min ((cum + 7) & -8, 16);
  696.  
  697.   for (i = 0; i < nargs; i++)
  698.     write_memory (sp + offset[i], VALUE_CONTENTS (args[i]),
  699.           TYPE_LENGTH (VALUE_TYPE (args[i])));
  700.  
  701.   if (struct_return)
  702.     write_register (28, struct_addr);
  703.   return sp + 32;
  704. }
  705.  
  706. /*
  707.  * Insert the specified number of args and function address
  708.  * into a call sequence of the above form stored at DUMMYNAME.
  709.  *
  710.  * On the hppa we need to call the stack dummy through $$dyncall.
  711.  * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
  712.  * real_pc, which is the location where gdb should start up the
  713.  * inferior to do the function call.
  714.  */
  715.  
  716. CORE_ADDR
  717. hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
  718.      REGISTER_TYPE *dummy;
  719.      CORE_ADDR pc;
  720.      CORE_ADDR fun;
  721.      int nargs;
  722.      value *args;
  723.      struct type *type;
  724.      int gcc_p;
  725. {
  726.   CORE_ADDR dyncall_addr, sr4export_addr;
  727.   struct minimal_symbol *msymbol;
  728.  
  729.   msymbol = lookup_minimal_symbol ("$$dyncall", (struct objfile *) NULL);
  730.   if (msymbol == NULL)
  731.     error ("Can't find an address for $$dyncall trampoline");
  732.  
  733.   dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
  734.  
  735.   msymbol = lookup_minimal_symbol ("_sr4export", (struct objfile *) NULL);
  736.   if (msymbol == NULL)
  737.     error ("Can't find an address for _sr4export trampoline");
  738.  
  739.   sr4export_addr = SYMBOL_VALUE_ADDRESS (msymbol);
  740.  
  741.   dummy[9] = deposit_21 (fun >> 11, dummy[9]);
  742.   dummy[10] = deposit_14 (fun & MASK_11, dummy[10]);
  743.   dummy[12] = deposit_21 (sr4export_addr >> 11, dummy[12]);
  744.   dummy[13] = deposit_14 (sr4export_addr & MASK_11, dummy[13]);
  745.  
  746.   write_register (22, pc);
  747.  
  748.   return dyncall_addr;
  749. }
  750.  
  751. /* return the alignment of a type in bytes. Structures have the maximum
  752.    alignment required by their fields. */
  753.  
  754. static int
  755. hppa_alignof (arg)
  756.      struct type *arg;
  757. {
  758.   int max_align, align, i;
  759.   switch (TYPE_CODE (arg))
  760.     {
  761.     case TYPE_CODE_PTR:
  762.     case TYPE_CODE_INT:
  763.     case TYPE_CODE_FLT:
  764.       return TYPE_LENGTH (arg);
  765.     case TYPE_CODE_ARRAY:
  766.       return hppa_alignof (TYPE_FIELD_TYPE (arg, 0));
  767.     case TYPE_CODE_STRUCT:
  768.     case TYPE_CODE_UNION:
  769.       max_align = 2;
  770.       for (i = 0; i < TYPE_NFIELDS (arg); i++)
  771.     {
  772.       /* Bit fields have no real alignment. */
  773.       if (!TYPE_FIELD_BITPOS (arg, i))
  774.         {
  775.           align = hppa_alignof (TYPE_FIELD_TYPE (arg, i));
  776.           max_align = max (max_align, align);
  777.         }
  778.     }
  779.       return max_align;
  780.     default:
  781.       return 4;
  782.     }
  783. }
  784.  
  785. /* Print the register regnum, or all registers if regnum is -1 */
  786.  
  787. pa_do_registers_info (regnum, fpregs)
  788.      int regnum;
  789.      int fpregs;
  790. {
  791.   char raw_regs [REGISTER_BYTES];
  792.   int i;
  793.   
  794.   for (i = 0; i < NUM_REGS; i++)
  795.     read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
  796.   if (regnum == -1)
  797.     pa_print_registers (raw_regs, regnum, fpregs);
  798.   else if (regnum < FP0_REGNUM)
  799.     printf ("%s %x\n", reg_names[regnum], *(long *)(raw_regs +
  800.                             REGISTER_BYTE (regnum)));
  801.   else
  802.     pa_print_fp_reg (regnum);
  803. }
  804.  
  805. pa_print_registers (raw_regs, regnum, fpregs)
  806.      char *raw_regs;
  807.      int regnum;
  808.      int fpregs;
  809. {
  810.   int i;
  811.  
  812.   for (i = 0; i < 18; i++)
  813.     printf ("%8.8s: %8x  %8.8s: %8x  %8.8s: %8x  %8.8s: %8x\n",
  814.         reg_names[i],
  815.         *(int *)(raw_regs + REGISTER_BYTE (i)),
  816.         reg_names[i + 18],
  817.         *(int *)(raw_regs + REGISTER_BYTE (i + 18)),
  818.         reg_names[i + 36],
  819.         *(int *)(raw_regs + REGISTER_BYTE (i + 36)),
  820.         reg_names[i + 54],
  821.         *(int *)(raw_regs + REGISTER_BYTE (i + 54)));
  822.  
  823.   if (fpregs)
  824.     for (i = 72; i < NUM_REGS; i++)
  825.       pa_print_fp_reg (i);
  826. }
  827.  
  828. pa_print_fp_reg (i)
  829.      int i;
  830. {
  831.   unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
  832.   unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
  833.   REGISTER_TYPE val;
  834.  
  835.   /* Get the data in raw format, then convert also to virtual format.  */
  836.   read_relative_register_raw_bytes (i, raw_buffer);
  837.   REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
  838.  
  839.   fputs_filtered (reg_names[i], stdout);
  840.   print_spaces_filtered (15 - strlen (reg_names[i]), stdout);
  841.  
  842.   val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout, 0,
  843.          1, 0, Val_pretty_default);
  844.   printf_filtered ("\n");
  845. }
  846.  
  847. /* Function calls that pass into a new compilation unit must pass through a
  848.    small piece of code that does long format (`external' in HPPA parlance)
  849.    jumps.  We figure out where the trampoline is going to end up, and return
  850.    the PC of the final destination.  If we aren't in a trampoline, we just
  851.    return NULL. 
  852.  
  853.    For computed calls, we just extract the new PC from r22.  */
  854.  
  855. CORE_ADDR
  856. skip_trampoline_code (pc, name)
  857.      CORE_ADDR pc;
  858.      char *name;
  859. {
  860.   long inst0, inst1;
  861.   static CORE_ADDR dyncall = 0;
  862.   struct minimal_symbol *msym;
  863.  
  864. /* FIXME XXX - dyncall must be initialized whenever we get a new exec file */
  865.  
  866.   if (!dyncall)
  867.     {
  868.       msym = lookup_minimal_symbol ("$$dyncall", NULL);
  869.       if (msym)
  870.     dyncall = SYMBOL_VALUE_ADDRESS (msym);
  871.       else
  872.     dyncall = -1;
  873.     }
  874.  
  875.   if (pc == dyncall)
  876.     return (CORE_ADDR)(read_register (22) & ~0x3);
  877.  
  878.   inst0 = read_memory_integer (pc, 4);
  879.   inst1 = read_memory_integer (pc+4, 4);
  880.  
  881.   if (   (inst0 & 0xffe00000) == 0x20200000 /* ldil xxx, r1 */
  882.       && (inst1 & 0xffe0e002) == 0xe0202002) /* be,n yyy(sr4, r1) */
  883.     pc = extract_21 (inst0) + extract_17 (inst1);
  884.   else
  885.     pc = (CORE_ADDR)NULL;
  886.  
  887.   return pc;
  888. }
  889.  
  890. /* Advance PC across any function entry prologue instructions
  891.    to reach some "real" code.  */
  892.  
  893. /* skip (stw rp, -20(0,sp)); copy 4,1; copy sp, 4; stwm 1,framesize(sp) 
  894.    for gcc, or (stw rp, -20(0,sp); stwm 1, framesize(sp) for hcc */
  895.  
  896. CORE_ADDR
  897. skip_prologue(pc)
  898.      CORE_ADDR pc;
  899. {
  900.   int inst;
  901.   int status;
  902.  
  903.   status = target_read_memory (pc, (char *)&inst, 4);
  904.   SWAP_TARGET_AND_HOST (&inst, sizeof (inst));
  905.   if (status != 0)
  906.     return pc;
  907.  
  908.   if (inst == 0x6BC23FD9)    /* stw rp,-20(sp) */
  909.     {
  910.       if (read_memory_integer (pc + 4, 4) == 0x8040241)    /* copy r4,r1 */
  911.     pc += 16;
  912.       else if ((read_memory_integer (pc + 4, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
  913.     pc += 8;
  914.     }
  915.   else if (read_memory_integer (pc, 4) == 0x8040241) /* copy r4,r1 */
  916.     pc += 12;
  917.   else if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
  918.     pc += 4;
  919.  
  920.   return pc;
  921. }
  922.  
  923. static void
  924. unwind_command (exp, from_tty)
  925.      char *exp;
  926.      int from_tty;
  927. {
  928.   CORE_ADDR address;
  929.   union
  930.     {
  931.       int *foo;
  932.       struct unwind_table_entry *u;
  933.     } xxx;
  934.  
  935.   /* If we have an expression, evaluate it and use it as the address.  */
  936.  
  937.   if (exp != 0 && *exp != 0)
  938.     address = parse_and_eval_address (exp);
  939.   else
  940.     return;
  941.  
  942.   xxx.u = find_unwind_entry (address);
  943.  
  944.   if (!xxx.u)
  945.     {
  946.       printf ("Can't find unwind table entry for PC 0x%x\n", address);
  947.       return;
  948.     }
  949.  
  950.   printf ("%08x\n%08X\n%08X\n%08X\n", xxx.foo[0], xxx.foo[1], xxx.foo[2],
  951.       xxx.foo[3]);
  952. }
  953.  
  954. void
  955. _initialize_hppah_tdep ()
  956. {
  957.   add_com ("unwind", class_obscure, unwind_command, "Print unwind info\n");
  958.   add_show_from_set
  959.     (add_set_cmd ("use_unwind", class_obscure, var_boolean,
  960.           (char *)&use_unwind,
  961.           "Set the usage of unwind info", &setlist),
  962.      &showlist);
  963. }
  964.