]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/hppa-tdep.c
* hppa-tdep.c (frame_chain): Rework so that it correctly
[thirdparty/binutils-gdb.git] / 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 static FRAME_ADDR dig_fp_from_stack PARAMS ((FRAME frame,
65 struct unwind_table_entry *u));
66 CORE_ADDR frame_saved_pc PARAMS ((FRAME frame));
67
68 \f
69 /* Routines to extract various sized constants out of hppa
70 instructions. */
71
72 /* This assumes that no garbage lies outside of the lower bits of
73 value. */
74
75 int
76 sign_extend (val, bits)
77 unsigned val, bits;
78 {
79 return (int)(val >> bits - 1 ? (-1 << bits) | val : val);
80 }
81
82 /* For many immediate values the sign bit is the low bit! */
83
84 int
85 low_sign_extend (val, bits)
86 unsigned val, bits;
87 {
88 return (int)((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
89 }
90 /* extract the immediate field from a ld{bhw}s instruction */
91
92 unsigned
93 get_field (val, from, to)
94 unsigned val, from, to;
95 {
96 val = val >> 31 - to;
97 return val & ((1 << 32 - from) - 1);
98 }
99
100 unsigned
101 set_field (val, from, to, new_val)
102 unsigned *val, from, to;
103 {
104 unsigned mask = ~((1 << (to - from + 1)) << (31 - from));
105 return *val = *val & mask | (new_val << (31 - from));
106 }
107
108 /* extract a 3-bit space register number from a be, ble, mtsp or mfsp */
109
110 extract_3 (word)
111 unsigned word;
112 {
113 return GET_FIELD (word, 18, 18) << 2 | GET_FIELD (word, 16, 17);
114 }
115
116 extract_5_load (word)
117 unsigned word;
118 {
119 return low_sign_extend (word >> 16 & MASK_5, 5);
120 }
121
122 /* extract the immediate field from a st{bhw}s instruction */
123
124 int
125 extract_5_store (word)
126 unsigned word;
127 {
128 return low_sign_extend (word & MASK_5, 5);
129 }
130
131 /* extract the immediate field from a break instruction */
132
133 unsigned
134 extract_5r_store (word)
135 unsigned word;
136 {
137 return (word & MASK_5);
138 }
139
140 /* extract the immediate field from a {sr}sm instruction */
141
142 unsigned
143 extract_5R_store (word)
144 unsigned word;
145 {
146 return (word >> 16 & MASK_5);
147 }
148
149 /* extract an 11 bit immediate field */
150
151 int
152 extract_11 (word)
153 unsigned word;
154 {
155 return low_sign_extend (word & MASK_11, 11);
156 }
157
158 /* extract a 14 bit immediate field */
159
160 int
161 extract_14 (word)
162 unsigned word;
163 {
164 return low_sign_extend (word & MASK_14, 14);
165 }
166
167 /* deposit a 14 bit constant in a word */
168
169 unsigned
170 deposit_14 (opnd, word)
171 int opnd;
172 unsigned word;
173 {
174 unsigned sign = (opnd < 0 ? 1 : 0);
175
176 return word | ((unsigned)opnd << 1 & MASK_14) | sign;
177 }
178
179 /* extract a 21 bit constant */
180
181 int
182 extract_21 (word)
183 unsigned word;
184 {
185 int val;
186
187 word &= MASK_21;
188 word <<= 11;
189 val = GET_FIELD (word, 20, 20);
190 val <<= 11;
191 val |= GET_FIELD (word, 9, 19);
192 val <<= 2;
193 val |= GET_FIELD (word, 5, 6);
194 val <<= 5;
195 val |= GET_FIELD (word, 0, 4);
196 val <<= 2;
197 val |= GET_FIELD (word, 7, 8);
198 return sign_extend (val, 21) << 11;
199 }
200
201 /* deposit a 21 bit constant in a word. Although 21 bit constants are
202 usually the top 21 bits of a 32 bit constant, we assume that only
203 the low 21 bits of opnd are relevant */
204
205 unsigned
206 deposit_21 (opnd, word)
207 unsigned opnd, word;
208 {
209 unsigned val = 0;
210
211 val |= GET_FIELD (opnd, 11 + 14, 11 + 18);
212 val <<= 2;
213 val |= GET_FIELD (opnd, 11 + 12, 11 + 13);
214 val <<= 2;
215 val |= GET_FIELD (opnd, 11 + 19, 11 + 20);
216 val <<= 11;
217 val |= GET_FIELD (opnd, 11 + 1, 11 + 11);
218 val <<= 1;
219 val |= GET_FIELD (opnd, 11 + 0, 11 + 0);
220 return word | val;
221 }
222
223 /* extract a 12 bit constant from branch instructions */
224
225 int
226 extract_12 (word)
227 unsigned word;
228 {
229 return sign_extend (GET_FIELD (word, 19, 28) |
230 GET_FIELD (word, 29, 29) << 10 |
231 (word & 0x1) << 11, 12) << 2;
232 }
233
234 /* extract a 17 bit constant from branch instructions, returning the
235 19 bit signed value. */
236
237 int
238 extract_17 (word)
239 unsigned word;
240 {
241 return sign_extend (GET_FIELD (word, 19, 28) |
242 GET_FIELD (word, 29, 29) << 10 |
243 GET_FIELD (word, 11, 15) << 11 |
244 (word & 0x1) << 16, 17) << 2;
245 }
246 \f
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 /* Called when no unwind descriptor was found for PC. Returns 1 if it
300 appears that PC is in a linker stub. */
301 static int pc_in_linker_stub PARAMS ((CORE_ADDR));
302
303 static int
304 pc_in_linker_stub (pc)
305 CORE_ADDR pc;
306 {
307 int found_magic_instruction = 0;
308 int i;
309 char buf[4];
310
311 /* If unable to read memory, assume pc is not in a linker stub. */
312 if (target_read_memory (pc, buf, 4) != 0)
313 return 0;
314
315 /* We are looking for something like
316
317 ; $$dyncall jams RP into this special spot in the frame (RP')
318 ; before calling the "call stub"
319 ldw -18(sp),rp
320
321 ldsid (rp),r1 ; Get space associated with RP into r1
322 mtsp r1,sp ; Move it into space register 0
323 be,n 0(sr0),rp) ; back to your regularly scheduled program
324 */
325
326 /* Maximum known linker stub size is 4 instructions. Search forward
327 from the given PC, then backward. */
328 for (i = 0; i < 4; i++)
329 {
330 /* If we hit something with an unwind, stop searching this direction. */
331
332 if (find_unwind_entry (pc + i * 4) != 0)
333 break;
334
335 /* Check for ldsid (rp),r1 which is the magic instruction for a
336 return from a cross-space function call. */
337 if (read_memory_integer (pc + i * 4, 4) == 0x004010a1)
338 {
339 found_magic_instruction = 1;
340 break;
341 }
342 /* Add code to handle long call/branch and argument relocation stubs
343 here. */
344 }
345
346 if (found_magic_instruction != 0)
347 return 1;
348
349 /* Now look backward. */
350 for (i = 0; i < 4; i++)
351 {
352 /* If we hit something with an unwind, stop searching this direction. */
353
354 if (find_unwind_entry (pc - i * 4) != 0)
355 break;
356
357 /* Check for ldsid (rp),r1 which is the magic instruction for a
358 return from a cross-space function call. */
359 if (read_memory_integer (pc - i * 4, 4) == 0x004010a1)
360 {
361 found_magic_instruction = 1;
362 break;
363 }
364 /* Add code to handle long call/branch and argument relocation stubs
365 here. */
366 }
367 return found_magic_instruction;
368 }
369
370 static int
371 find_return_regnum(pc)
372 CORE_ADDR pc;
373 {
374 struct unwind_table_entry *u;
375
376 u = find_unwind_entry (pc);
377
378 if (!u)
379 return RP_REGNUM;
380
381 if (u->Millicode)
382 return 31;
383
384 return RP_REGNUM;
385 }
386
387 /* Return size of frame, or -1 if we should use a frame pointer. */
388 int
389 find_proc_framesize(pc)
390 CORE_ADDR pc;
391 {
392 struct unwind_table_entry *u;
393
394 u = find_unwind_entry (pc);
395
396 if (!u)
397 {
398 if (pc_in_linker_stub (pc))
399 /* Linker stubs have a zero size frame. */
400 return 0;
401 else
402 return -1;
403 }
404
405 if (u->Save_SP)
406 /* If this bit is set, it means there is a frame pointer and we should
407 use it. */
408 return -1;
409
410 return u->Total_frame_size << 3;
411 }
412
413 /* Return offset from sp at which rp is saved, or 0 if not saved. */
414 static int rp_saved PARAMS ((CORE_ADDR));
415
416 static int
417 rp_saved (pc)
418 CORE_ADDR pc;
419 {
420 struct unwind_table_entry *u;
421
422 u = find_unwind_entry (pc);
423
424 if (!u)
425 {
426 if (pc_in_linker_stub (pc))
427 /* This is the so-called RP'. */
428 return -24;
429 else
430 return 0;
431 }
432
433 if (u->Save_RP)
434 return -20;
435 else
436 return 0;
437 }
438 \f
439 int
440 frameless_function_invocation (frame)
441 FRAME frame;
442 {
443 struct unwind_table_entry *u;
444
445 u = find_unwind_entry (frame->pc);
446
447 if (u == 0)
448 return frameless_look_for_prologue (frame);
449
450 return (u->Total_frame_size == 0);
451 }
452
453 CORE_ADDR
454 saved_pc_after_call (frame)
455 FRAME frame;
456 {
457 int ret_regnum;
458
459 ret_regnum = find_return_regnum (get_frame_pc (frame));
460
461 return read_register (ret_regnum) & ~0x3;
462 }
463 \f
464 CORE_ADDR
465 frame_saved_pc (frame)
466 FRAME frame;
467 {
468 CORE_ADDR pc = get_frame_pc (frame);
469
470 if (frameless_function_invocation (frame))
471 {
472 int ret_regnum;
473
474 ret_regnum = find_return_regnum (pc);
475
476 return read_register (ret_regnum) & ~0x3;
477 }
478 else
479 {
480 int rp_offset = rp_saved (pc);
481
482 if (rp_offset == 0)
483 return read_register (RP_REGNUM) & ~0x3;
484 else
485 return read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
486 }
487 }
488 \f
489 /* We need to correct the PC and the FP for the outermost frame when we are
490 in a system call. */
491
492 void
493 init_extra_frame_info (fromleaf, frame)
494 int fromleaf;
495 struct frame_info *frame;
496 {
497 int flags;
498 int framesize;
499
500 if (frame->next) /* Only do this for outermost frame */
501 return;
502
503 flags = read_register (FLAGS_REGNUM);
504 if (flags & 2) /* In system call? */
505 frame->pc = read_register (31) & ~0x3;
506
507 /* The outermost frame is always derived from PC-framesize */
508 framesize = find_proc_framesize(frame->pc);
509 if (framesize == -1)
510 frame->frame = read_register (FP_REGNUM);
511 else
512 frame->frame = read_register (SP_REGNUM) - framesize;
513
514 if (!frameless_function_invocation (frame)) /* Frameless? */
515 return; /* No, quit now */
516
517 /* For frameless functions, we need to look at the caller's frame */
518 framesize = find_proc_framesize(FRAME_SAVED_PC(frame));
519 if (framesize != -1)
520 frame->frame -= framesize;
521 }
522 \f
523 /* Given a GDB frame, determine the address of the calling function's frame.
524 This will be used to create a new GDB frame struct, and then
525 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
526
527 This may involve searching through prologues for several functions
528 at boundaries where GCC calls HP C code, or where code which has
529 a frame pointer calls code without a frame pointer. */
530
531
532 FRAME_ADDR
533 frame_chain (frame)
534 struct frame_info *frame;
535 {
536 int my_framesize, caller_framesize;
537 struct unwind_table_entry *u;
538
539 /* Get frame sizes for the current frame and the frame of the
540 caller. */
541 my_framesize = find_proc_framesize (frame->pc);
542 caller_framesize = find_proc_framesize (FRAME_SAVED_PC(frame));
543
544 /* If caller does not have a frame pointer, then its frame
545 can be found at current_frame - caller_framesize. */
546 if (caller_framesize != -1)
547 return frame->frame - caller_framesize;
548
549 /* Both caller and callee have frame pointers and are GCC compiled
550 (SAVE_SP bit in unwind descriptor is on for both functions.
551 The previous frame pointer is found at the top of the current frame. */
552 if (caller_framesize == -1 && my_framesize == -1)
553 return read_memory_integer (frame->frame, 4);
554
555 /* Caller has a frame pointer, but callee does not. This is a little
556 more difficult as GCC and HP C lay out locals and callee register save
557 areas very differently.
558
559 The previous frame pointer could be in a register, or in one of
560 several areas on the stack.
561
562 Walk from the current frame to the innermost frame examining
563 unwind descriptors to determine if %r4 ever gets saved into the
564 stack. If so return whatever value got saved into the stack.
565 If it was never saved in the stack, then the value in %r4 is still
566 valid, so use it.
567
568 We use information from unwind descriptors to determine if %r4
569 is saved into the stack (Entry_GR field has this information). */
570
571 while (frame)
572 {
573 u = find_unwind_entry (frame->pc);
574
575 if (!u)
576 {
577 /* We could find this information by examining prologues. I don't
578 think anyone has actually written any tools (not even "strip")
579 which leave them out of an executable, so maybe this is a moot
580 point. */
581 warning ("Unable to find unwind for PC 0x%x -- Help!", frame->pc);
582 return 0;
583 }
584
585 /* Entry_GR specifies the number of callee-saved general registers
586 saved in the stack. It starts at %r3, so %r4 would be 2. */
587 if (u->Entry_GR >= 2 || u->Save_SP)
588 break;
589 else
590 frame = frame->next;
591 }
592
593 if (frame)
594 {
595 /* We may have walked down the chain into a function with a frame
596 pointer. */
597 if (u->Save_SP)
598 return read_memory_integer (frame->frame, 4);
599 /* %r4 was saved somewhere in the stack. Dig it out. */
600 else
601 return dig_fp_from_stack (frame, u);
602 }
603 else
604 {
605 /* The value in %r4 was never saved into the stack (thus %r4 still
606 holds the value of the previous frame pointer). */
607 return read_register (4);
608 }
609 }
610
611 /* Given a frame and an unwind descriptor return the value for %fr (aka fp)
612 which was saved into the stack. FIXME: Why can't we just use the standard
613 saved_regs stuff? */
614
615 static FRAME_ADDR
616 dig_fp_from_stack (frame, u)
617 FRAME frame;
618 struct unwind_table_entry *u;
619 {
620 CORE_ADDR pc = u->region_start;
621
622 /* Search the function for the save of %r4. */
623 while (pc != u->region_end)
624 {
625 char buf[4];
626 unsigned long inst;
627 int status;
628
629 /* We need only look for the standard stw %r4,X(%sp) instruction,
630 the other variants (eg stwm) are only used on the first register
631 save (eg %r3). */
632 status = target_read_memory (pc, buf, 4);
633 inst = extract_unsigned_integer (buf, 4);
634
635 if (status != 0)
636 memory_error (status, pc);
637
638 /* Check for stw %r4,X(%sp). */
639 if ((inst & 0xffffc000) == 0x6bc40000)
640 {
641 /* Found the instruction which saves %r4. The offset (relative
642 to this frame) is framesize + immed14 (derived from the
643 store instruction). */
644 int offset = (u->Total_frame_size << 3) + extract_14 (inst);
645
646 return read_memory_integer (frame->frame + offset, 4);
647 }
648
649 /* Keep looking. */
650 pc += 4;
651 }
652
653 warning ("Unable to find %%r4 in stack.\n");
654 return 0;
655 }
656
657 \f
658 /* To see if a frame chain is valid, see if the caller looks like it
659 was compiled with gcc. */
660
661 int
662 frame_chain_valid (chain, thisframe)
663 FRAME_ADDR chain;
664 FRAME thisframe;
665 {
666 struct minimal_symbol *msym_us;
667 struct minimal_symbol *msym_start;
668 struct unwind_table_entry *u;
669
670 if (!chain)
671 return 0;
672
673 u = find_unwind_entry (thisframe->pc);
674
675 /* We can't just check that the same of msym_us is "_start", because
676 someone idiotically decided that they were going to make a Ltext_end
677 symbol with the same address. This Ltext_end symbol is totally
678 indistinguishable (as nearly as I can tell) from the symbol for a function
679 which is (legitimately, since it is in the user's namespace)
680 named Ltext_end, so we can't just ignore it. */
681 msym_us = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe));
682 msym_start = lookup_minimal_symbol ("_start", NULL);
683 if (msym_us
684 && msym_start
685 && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
686 return 0;
687
688 if (u == NULL)
689 return 1;
690
691 if (u->Save_SP || u->Total_frame_size)
692 return 1;
693
694 if (pc_in_linker_stub (thisframe->pc))
695 return 1;
696
697 return 0;
698 }
699
700 /*
701 * These functions deal with saving and restoring register state
702 * around a function call in the inferior. They keep the stack
703 * double-word aligned; eventually, on an hp700, the stack will have
704 * to be aligned to a 64-byte boundary.
705 */
706
707 int
708 push_dummy_frame ()
709 {
710 register CORE_ADDR sp;
711 register int regnum;
712 int int_buffer;
713 double freg_buffer;
714
715 /* Space for "arguments"; the RP goes in here. */
716 sp = read_register (SP_REGNUM) + 48;
717 int_buffer = read_register (RP_REGNUM) | 0x3;
718 write_memory (sp - 20, (char *)&int_buffer, 4);
719
720 int_buffer = read_register (FP_REGNUM);
721 write_memory (sp, (char *)&int_buffer, 4);
722
723 write_register (FP_REGNUM, sp);
724
725 sp += 8;
726
727 for (regnum = 1; regnum < 32; regnum++)
728 if (regnum != RP_REGNUM && regnum != FP_REGNUM)
729 sp = push_word (sp, read_register (regnum));
730
731 sp += 4;
732
733 for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
734 {
735 read_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
736 sp = push_bytes (sp, (char *)&freg_buffer, 8);
737 }
738 sp = push_word (sp, read_register (IPSW_REGNUM));
739 sp = push_word (sp, read_register (SAR_REGNUM));
740 sp = push_word (sp, read_register (PCOQ_HEAD_REGNUM));
741 sp = push_word (sp, read_register (PCSQ_HEAD_REGNUM));
742 sp = push_word (sp, read_register (PCOQ_TAIL_REGNUM));
743 sp = push_word (sp, read_register (PCSQ_TAIL_REGNUM));
744 write_register (SP_REGNUM, sp);
745 }
746
747 find_dummy_frame_regs (frame, frame_saved_regs)
748 struct frame_info *frame;
749 struct frame_saved_regs *frame_saved_regs;
750 {
751 CORE_ADDR fp = frame->frame;
752 int i;
753
754 frame_saved_regs->regs[RP_REGNUM] = fp - 20 & ~0x3;
755 frame_saved_regs->regs[FP_REGNUM] = fp;
756 frame_saved_regs->regs[1] = fp + 8;
757
758 for (fp += 12, i = 3; i < 32; i++)
759 {
760 if (i != FP_REGNUM)
761 {
762 frame_saved_regs->regs[i] = fp;
763 fp += 4;
764 }
765 }
766
767 fp += 4;
768 for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
769 frame_saved_regs->regs[i] = fp;
770
771 frame_saved_regs->regs[IPSW_REGNUM] = fp;
772 frame_saved_regs->regs[SAR_REGNUM] = fp + 4;
773 frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 8;
774 frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 12;
775 frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 16;
776 frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 20;
777 }
778
779 int
780 hppa_pop_frame ()
781 {
782 register FRAME frame = get_current_frame ();
783 register CORE_ADDR fp;
784 register int regnum;
785 struct frame_saved_regs fsr;
786 struct frame_info *fi;
787 double freg_buffer;
788
789 fi = get_frame_info (frame);
790 fp = fi->frame;
791 get_frame_saved_regs (fi, &fsr);
792
793 if (fsr.regs[IPSW_REGNUM]) /* Restoring a call dummy frame */
794 restore_pc_queue (&fsr);
795
796 for (regnum = 31; regnum > 0; regnum--)
797 if (fsr.regs[regnum])
798 write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
799
800 for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM ; regnum--)
801 if (fsr.regs[regnum])
802 {
803 read_memory (fsr.regs[regnum], (char *)&freg_buffer, 8);
804 write_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
805 }
806
807 if (fsr.regs[IPSW_REGNUM])
808 write_register (IPSW_REGNUM,
809 read_memory_integer (fsr.regs[IPSW_REGNUM], 4));
810
811 if (fsr.regs[SAR_REGNUM])
812 write_register (SAR_REGNUM,
813 read_memory_integer (fsr.regs[SAR_REGNUM], 4));
814
815 /* If the PC was explicitly saved, then just restore it. */
816 if (fsr.regs[PCOQ_TAIL_REGNUM])
817 write_register (PCOQ_TAIL_REGNUM,
818 read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM], 4));
819
820 /* Else use the value in %rp to set the new PC. */
821 else
822 target_write_pc (read_register (RP_REGNUM));
823
824 write_register (FP_REGNUM, read_memory_integer (fp, 4));
825
826 if (fsr.regs[IPSW_REGNUM]) /* call dummy */
827 write_register (SP_REGNUM, fp - 48);
828 else
829 write_register (SP_REGNUM, fp);
830
831 flush_cached_frames ();
832 set_current_frame (create_new_frame (read_register (FP_REGNUM),
833 read_pc ()));
834 }
835
836 /*
837 * After returning to a dummy on the stack, restore the instruction
838 * queue space registers. */
839
840 static int
841 restore_pc_queue (fsr)
842 struct frame_saved_regs *fsr;
843 {
844 CORE_ADDR pc = read_pc ();
845 CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM], 4);
846 int pid;
847 WAITTYPE w;
848 int insn_count;
849
850 /* Advance past break instruction in the call dummy. */
851 write_register (PCOQ_HEAD_REGNUM, pc + 4);
852 write_register (PCOQ_TAIL_REGNUM, pc + 8);
853
854 /*
855 * HPUX doesn't let us set the space registers or the space
856 * registers of the PC queue through ptrace. Boo, hiss.
857 * Conveniently, the call dummy has this sequence of instructions
858 * after the break:
859 * mtsp r21, sr0
860 * ble,n 0(sr0, r22)
861 *
862 * So, load up the registers and single step until we are in the
863 * right place.
864 */
865
866 write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM], 4));
867 write_register (22, new_pc);
868
869 for (insn_count = 0; insn_count < 3; insn_count++)
870 {
871 resume (1, 0);
872 target_wait(&w);
873
874 if (!WIFSTOPPED (w))
875 {
876 stop_signal = WTERMSIG (w);
877 terminal_ours_for_output ();
878 printf ("\nProgram terminated with signal %d, %s\n",
879 stop_signal, safe_strsignal (stop_signal));
880 fflush (stdout);
881 return 0;
882 }
883 }
884 fetch_inferior_registers (-1);
885 return 1;
886 }
887
888 CORE_ADDR
889 hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
890 int nargs;
891 value *args;
892 CORE_ADDR sp;
893 int struct_return;
894 CORE_ADDR struct_addr;
895 {
896 /* array of arguments' offsets */
897 int *offset = (int *)alloca(nargs * sizeof (int));
898 int cum = 0;
899 int i, alignment;
900
901 for (i = 0; i < nargs; i++)
902 {
903 /* Coerce chars to int & float to double if necessary */
904 args[i] = value_arg_coerce (args[i]);
905
906 cum += TYPE_LENGTH (VALUE_TYPE (args[i]));
907
908 /* value must go at proper alignment. Assume alignment is a
909 power of two.*/
910 alignment = hppa_alignof (VALUE_TYPE (args[i]));
911 if (cum % alignment)
912 cum = (cum + alignment) & -alignment;
913 offset[i] = -cum;
914 }
915 sp += max ((cum + 7) & -8, 16);
916
917 for (i = 0; i < nargs; i++)
918 write_memory (sp + offset[i], VALUE_CONTENTS (args[i]),
919 TYPE_LENGTH (VALUE_TYPE (args[i])));
920
921 if (struct_return)
922 write_register (28, struct_addr);
923 return sp + 32;
924 }
925
926 /*
927 * Insert the specified number of args and function address
928 * into a call sequence of the above form stored at DUMMYNAME.
929 *
930 * On the hppa we need to call the stack dummy through $$dyncall.
931 * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
932 * real_pc, which is the location where gdb should start up the
933 * inferior to do the function call.
934 */
935
936 CORE_ADDR
937 hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
938 REGISTER_TYPE *dummy;
939 CORE_ADDR pc;
940 CORE_ADDR fun;
941 int nargs;
942 value *args;
943 struct type *type;
944 int gcc_p;
945 {
946 CORE_ADDR dyncall_addr, sr4export_addr;
947 struct minimal_symbol *msymbol;
948 int flags = read_register (FLAGS_REGNUM);
949
950 msymbol = lookup_minimal_symbol ("$$dyncall", (struct objfile *) NULL);
951 if (msymbol == NULL)
952 error ("Can't find an address for $$dyncall trampoline");
953
954 dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
955
956 msymbol = lookup_minimal_symbol ("_sr4export", (struct objfile *) NULL);
957 if (msymbol == NULL)
958 error ("Can't find an address for _sr4export trampoline");
959
960 sr4export_addr = SYMBOL_VALUE_ADDRESS (msymbol);
961
962 dummy[9] = deposit_21 (fun >> 11, dummy[9]);
963 dummy[10] = deposit_14 (fun & MASK_11, dummy[10]);
964 dummy[12] = deposit_21 (sr4export_addr >> 11, dummy[12]);
965 dummy[13] = deposit_14 (sr4export_addr & MASK_11, dummy[13]);
966
967 write_register (22, pc);
968
969 /* If we are in a syscall, then we should call the stack dummy
970 directly. $$dyncall is not needed as the kernel sets up the
971 space id registers properly based on the value in %r31. In
972 fact calling $$dyncall will not work because the value in %r22
973 will be clobbered on the syscall exit path. */
974 if (flags & 2)
975 return pc;
976 else
977 return dyncall_addr;
978
979 }
980
981 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
982 bits. */
983 CORE_ADDR
984 target_read_pc ()
985 {
986 int flags = read_register (FLAGS_REGNUM);
987
988 if (flags & 2)
989 return read_register (31) & ~0x3;
990 return read_register (PC_REGNUM) & ~0x3;
991 }
992
993 /* Write out the PC. If currently in a syscall, then also write the new
994 PC value into %r31. */
995 void
996 target_write_pc (v)
997 CORE_ADDR v;
998 {
999 int flags = read_register (FLAGS_REGNUM);
1000
1001 /* If in a syscall, then set %r31. Also make sure to get the
1002 privilege bits set correctly. */
1003 if (flags & 2)
1004 write_register (31, (long) (v | 0x3));
1005
1006 write_register (PC_REGNUM, (long) v);
1007 write_register (NPC_REGNUM, (long) v + 4);
1008 }
1009
1010 /* return the alignment of a type in bytes. Structures have the maximum
1011 alignment required by their fields. */
1012
1013 static int
1014 hppa_alignof (arg)
1015 struct type *arg;
1016 {
1017 int max_align, align, i;
1018 switch (TYPE_CODE (arg))
1019 {
1020 case TYPE_CODE_PTR:
1021 case TYPE_CODE_INT:
1022 case TYPE_CODE_FLT:
1023 return TYPE_LENGTH (arg);
1024 case TYPE_CODE_ARRAY:
1025 return hppa_alignof (TYPE_FIELD_TYPE (arg, 0));
1026 case TYPE_CODE_STRUCT:
1027 case TYPE_CODE_UNION:
1028 max_align = 2;
1029 for (i = 0; i < TYPE_NFIELDS (arg); i++)
1030 {
1031 /* Bit fields have no real alignment. */
1032 if (!TYPE_FIELD_BITPOS (arg, i))
1033 {
1034 align = hppa_alignof (TYPE_FIELD_TYPE (arg, i));
1035 max_align = max (max_align, align);
1036 }
1037 }
1038 return max_align;
1039 default:
1040 return 4;
1041 }
1042 }
1043
1044 /* Print the register regnum, or all registers if regnum is -1 */
1045
1046 pa_do_registers_info (regnum, fpregs)
1047 int regnum;
1048 int fpregs;
1049 {
1050 char raw_regs [REGISTER_BYTES];
1051 int i;
1052
1053 for (i = 0; i < NUM_REGS; i++)
1054 read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
1055 if (regnum == -1)
1056 pa_print_registers (raw_regs, regnum, fpregs);
1057 else if (regnum < FP0_REGNUM)
1058 printf ("%s %x\n", reg_names[regnum], *(long *)(raw_regs +
1059 REGISTER_BYTE (regnum)));
1060 else
1061 pa_print_fp_reg (regnum);
1062 }
1063
1064 pa_print_registers (raw_regs, regnum, fpregs)
1065 char *raw_regs;
1066 int regnum;
1067 int fpregs;
1068 {
1069 int i;
1070
1071 for (i = 0; i < 18; i++)
1072 printf ("%8.8s: %8x %8.8s: %8x %8.8s: %8x %8.8s: %8x\n",
1073 reg_names[i],
1074 *(int *)(raw_regs + REGISTER_BYTE (i)),
1075 reg_names[i + 18],
1076 *(int *)(raw_regs + REGISTER_BYTE (i + 18)),
1077 reg_names[i + 36],
1078 *(int *)(raw_regs + REGISTER_BYTE (i + 36)),
1079 reg_names[i + 54],
1080 *(int *)(raw_regs + REGISTER_BYTE (i + 54)));
1081
1082 if (fpregs)
1083 for (i = 72; i < NUM_REGS; i++)
1084 pa_print_fp_reg (i);
1085 }
1086
1087 pa_print_fp_reg (i)
1088 int i;
1089 {
1090 unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
1091 unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
1092 REGISTER_TYPE val;
1093
1094 /* Get the data in raw format, then convert also to virtual format. */
1095 read_relative_register_raw_bytes (i, raw_buffer);
1096 REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
1097
1098 fputs_filtered (reg_names[i], stdout);
1099 print_spaces_filtered (15 - strlen (reg_names[i]), stdout);
1100
1101 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout, 0,
1102 1, 0, Val_pretty_default);
1103 printf_filtered ("\n");
1104 }
1105
1106 /* Function calls that pass into a new compilation unit must pass through a
1107 small piece of code that does long format (`external' in HPPA parlance)
1108 jumps. We figure out where the trampoline is going to end up, and return
1109 the PC of the final destination. If we aren't in a trampoline, we just
1110 return NULL.
1111
1112 For computed calls, we just extract the new PC from r22. */
1113
1114 CORE_ADDR
1115 skip_trampoline_code (pc, name)
1116 CORE_ADDR pc;
1117 char *name;
1118 {
1119 long inst0, inst1;
1120 static CORE_ADDR dyncall = 0;
1121 struct minimal_symbol *msym;
1122
1123 /* FIXME XXX - dyncall must be initialized whenever we get a new exec file */
1124
1125 if (!dyncall)
1126 {
1127 msym = lookup_minimal_symbol ("$$dyncall", NULL);
1128 if (msym)
1129 dyncall = SYMBOL_VALUE_ADDRESS (msym);
1130 else
1131 dyncall = -1;
1132 }
1133
1134 if (pc == dyncall)
1135 return (CORE_ADDR)(read_register (22) & ~0x3);
1136
1137 inst0 = read_memory_integer (pc, 4);
1138 inst1 = read_memory_integer (pc+4, 4);
1139
1140 if ( (inst0 & 0xffe00000) == 0x20200000 /* ldil xxx, r1 */
1141 && (inst1 & 0xffe0e002) == 0xe0202002) /* be,n yyy(sr4, r1) */
1142 pc = extract_21 (inst0) + extract_17 (inst1);
1143 else
1144 pc = (CORE_ADDR)NULL;
1145
1146 return pc;
1147 }
1148
1149 /* Advance PC across any function entry prologue instructions
1150 to reach some "real" code. */
1151
1152 /* skip (stw rp, -20(0,sp)); copy 4,1; copy sp, 4; stwm 1,framesize(sp)
1153 for gcc, or (stw rp, -20(0,sp); stwm 1, framesize(sp) for hcc */
1154
1155 CORE_ADDR
1156 skip_prologue(pc)
1157 CORE_ADDR pc;
1158 {
1159 char buf[4];
1160 unsigned long inst;
1161 int status;
1162
1163 status = target_read_memory (pc, buf, 4);
1164 inst = extract_unsigned_integer (buf, 4);
1165 if (status != 0)
1166 return pc;
1167
1168 if (inst == 0x6BC23FD9) /* stw rp,-20(sp) */
1169 {
1170 if (read_memory_integer (pc + 4, 4) == 0x8040241) /* copy r4,r1 */
1171 pc += 16;
1172 else if ((read_memory_integer (pc + 4, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
1173 pc += 8;
1174 }
1175 else if (read_memory_integer (pc, 4) == 0x8040241) /* copy r4,r1 */
1176 pc += 12;
1177 else if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
1178 pc += 4;
1179
1180 return pc;
1181 }
1182
1183 #ifdef MAINTENANCE_CMDS
1184
1185 static void
1186 unwind_command (exp, from_tty)
1187 char *exp;
1188 int from_tty;
1189 {
1190 CORE_ADDR address;
1191 union
1192 {
1193 int *foo;
1194 struct unwind_table_entry *u;
1195 } xxx;
1196
1197 /* If we have an expression, evaluate it and use it as the address. */
1198
1199 if (exp != 0 && *exp != 0)
1200 address = parse_and_eval_address (exp);
1201 else
1202 return;
1203
1204 xxx.u = find_unwind_entry (address);
1205
1206 if (!xxx.u)
1207 {
1208 printf ("Can't find unwind table entry for PC 0x%x\n", address);
1209 return;
1210 }
1211
1212 printf ("%08x\n%08X\n%08X\n%08X\n", xxx.foo[0], xxx.foo[1], xxx.foo[2],
1213 xxx.foo[3]);
1214 }
1215
1216 void
1217 _initialize_hppa_tdep ()
1218 {
1219 add_cmd ("unwind", class_maintenance, unwind_command,
1220 "Print unwind table entry at given address.",
1221 &maintenanceprintlist);
1222 }
1223
1224 #endif /* MAINTENANCE_CMDS */