1 /* Target-dependent code for the HP PA architecture, for GDB.
2 Copyright 1986, 1987, 1989-1996, 1999-2000 Free Software Foundation, Inc.
4 Contributed by the Center for Software Science at the
5 University of Utah (pa-gdb-bugs@cs.utah.edu).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
30 /* For argument passing to the inferior */
34 #include <sys/types.h>
38 #include <sys/param.h>
41 #include <sys/ptrace.h>
42 #include <machine/save_state.h>
44 #ifdef COFF_ENCAPSULATE
45 #include "a.out.encap.h"
49 /*#include <sys/user.h> After a.out.h */
60 /* To support detection of the pseudo-initial frame
62 #define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
63 #define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
65 static int extract_5_load (unsigned int);
67 static unsigned extract_5R_store (unsigned int);
69 static unsigned extract_5r_store (unsigned int);
71 static void find_dummy_frame_regs (struct frame_info *,
72 struct frame_saved_regs *);
74 static int find_proc_framesize (CORE_ADDR);
76 static int find_return_regnum (CORE_ADDR);
78 struct unwind_table_entry *find_unwind_entry (CORE_ADDR);
80 static int extract_17 (unsigned int);
82 static unsigned deposit_21 (unsigned int, unsigned int);
84 static int extract_21 (unsigned);
86 static unsigned deposit_14 (int, unsigned int);
88 static int extract_14 (unsigned);
90 static void unwind_command (char *, int);
92 static int low_sign_extend (unsigned int, unsigned int);
94 static int sign_extend (unsigned int, unsigned int);
96 static int restore_pc_queue (struct frame_saved_regs *);
98 static int hppa_alignof (struct type *);
100 /* To support multi-threading and stepping. */
101 int hppa_prepare_to_proceed ();
103 static int prologue_inst_adjust_sp (unsigned long);
105 static int is_branch (unsigned long);
107 static int inst_saves_gr (unsigned long);
109 static int inst_saves_fr (unsigned long);
111 static int pc_in_interrupt_handler (CORE_ADDR);
113 static int pc_in_linker_stub (CORE_ADDR);
115 static int compare_unwind_entries (const void *, const void *);
117 static void read_unwind_info (struct objfile *);
119 static void internalize_unwinds (struct objfile *,
120 struct unwind_table_entry *,
121 asection *, unsigned int,
122 unsigned int, CORE_ADDR);
123 static void pa_print_registers (char *, int, int);
124 static void pa_strcat_registers (char *, int, int, struct ui_file *);
125 static void pa_register_look_aside (char *, int, long *);
126 static void pa_print_fp_reg (int);
127 static void pa_strcat_fp_reg (int, struct ui_file *, enum precision_type);
128 static void record_text_segment_lowaddr (bfd *, asection *, void *);
132 struct minimal_symbol *msym;
133 CORE_ADDR solib_handle;
134 CORE_ADDR return_val;
138 static int cover_find_stub_with_shl_get (PTR);
140 static int is_pa_2 = 0; /* False */
142 /* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
143 extern int hp_som_som_object_present;
145 /* In breakpoint.c */
146 extern int exception_catchpoints_are_fragile;
148 /* This is defined in valops.c. */
149 extern value_ptr find_function_in_inferior (char *);
151 /* Should call_function allocate stack space for a struct return? */
153 hppa_use_struct_convention (gcc_p, type)
157 return (TYPE_LENGTH (type) > 2 * REGISTER_SIZE);
161 /* Routines to extract various sized constants out of hppa
164 /* This assumes that no garbage lies outside of the lower bits of
168 sign_extend (val, bits)
171 return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
174 /* For many immediate values the sign bit is the low bit! */
177 low_sign_extend (val, bits)
180 return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
183 /* extract the immediate field from a ld{bhw}s instruction */
186 extract_5_load (word)
189 return low_sign_extend (word >> 16 & MASK_5, 5);
192 /* extract the immediate field from a break instruction */
195 extract_5r_store (word)
198 return (word & MASK_5);
201 /* extract the immediate field from a {sr}sm instruction */
204 extract_5R_store (word)
207 return (word >> 16 & MASK_5);
210 /* extract a 14 bit immediate field */
216 return low_sign_extend (word & MASK_14, 14);
219 /* deposit a 14 bit constant in a word */
222 deposit_14 (opnd, word)
226 unsigned sign = (opnd < 0 ? 1 : 0);
228 return word | ((unsigned) opnd << 1 & MASK_14) | sign;
231 /* extract a 21 bit constant */
241 val = GET_FIELD (word, 20, 20);
243 val |= GET_FIELD (word, 9, 19);
245 val |= GET_FIELD (word, 5, 6);
247 val |= GET_FIELD (word, 0, 4);
249 val |= GET_FIELD (word, 7, 8);
250 return sign_extend (val, 21) << 11;
253 /* deposit a 21 bit constant in a word. Although 21 bit constants are
254 usually the top 21 bits of a 32 bit constant, we assume that only
255 the low 21 bits of opnd are relevant */
258 deposit_21 (opnd, word)
263 val |= GET_FIELD (opnd, 11 + 14, 11 + 18);
265 val |= GET_FIELD (opnd, 11 + 12, 11 + 13);
267 val |= GET_FIELD (opnd, 11 + 19, 11 + 20);
269 val |= GET_FIELD (opnd, 11 + 1, 11 + 11);
271 val |= GET_FIELD (opnd, 11 + 0, 11 + 0);
275 /* extract a 17 bit constant from branch instructions, returning the
276 19 bit signed value. */
282 return sign_extend (GET_FIELD (word, 19, 28) |
283 GET_FIELD (word, 29, 29) << 10 |
284 GET_FIELD (word, 11, 15) << 11 |
285 (word & 0x1) << 16, 17) << 2;
289 /* Compare the start address for two unwind entries returning 1 if
290 the first address is larger than the second, -1 if the second is
291 larger than the first, and zero if they are equal. */
294 compare_unwind_entries (arg1, arg2)
298 const struct unwind_table_entry *a = arg1;
299 const struct unwind_table_entry *b = arg2;
301 if (a->region_start > b->region_start)
303 else if (a->region_start < b->region_start)
309 static CORE_ADDR low_text_segment_address;
312 record_text_segment_lowaddr (abfd, section, ignored)
313 bfd *abfd ATTRIBUTE_UNUSED;
315 PTR ignored ATTRIBUTE_UNUSED;
317 if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
318 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
319 && section->vma < low_text_segment_address)
320 low_text_segment_address = section->vma;
324 internalize_unwinds (objfile, table, section, entries, size, text_offset)
325 struct objfile *objfile;
326 struct unwind_table_entry *table;
328 unsigned int entries, size;
329 CORE_ADDR text_offset;
331 /* We will read the unwind entries into temporary memory, then
332 fill in the actual unwind table. */
337 char *buf = alloca (size);
339 low_text_segment_address = -1;
341 /* If addresses are 64 bits wide, then unwinds are supposed to
342 be segment relative offsets instead of absolute addresses.
344 Note that when loading a shared library (text_offset != 0) the
345 unwinds are already relative to the text_offset that will be
347 if (TARGET_PTR_BIT == 64 && text_offset == 0)
349 bfd_map_over_sections (objfile->obfd,
350 record_text_segment_lowaddr, (PTR) NULL);
352 /* ?!? Mask off some low bits. Should this instead subtract
353 out the lowest section's filepos or something like that?
354 This looks very hokey to me. */
355 low_text_segment_address &= ~0xfff;
356 text_offset += low_text_segment_address;
359 bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
361 /* Now internalize the information being careful to handle host/target
363 for (i = 0; i < entries; i++)
365 table[i].region_start = bfd_get_32 (objfile->obfd,
367 table[i].region_start += text_offset;
369 table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
370 table[i].region_end += text_offset;
372 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
374 table[i].Cannot_unwind = (tmp >> 31) & 0x1;
375 table[i].Millicode = (tmp >> 30) & 0x1;
376 table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
377 table[i].Region_description = (tmp >> 27) & 0x3;
378 table[i].reserved1 = (tmp >> 26) & 0x1;
379 table[i].Entry_SR = (tmp >> 25) & 0x1;
380 table[i].Entry_FR = (tmp >> 21) & 0xf;
381 table[i].Entry_GR = (tmp >> 16) & 0x1f;
382 table[i].Args_stored = (tmp >> 15) & 0x1;
383 table[i].Variable_Frame = (tmp >> 14) & 0x1;
384 table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
385 table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
386 table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
387 table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
388 table[i].Ada_Region = (tmp >> 9) & 0x1;
389 table[i].cxx_info = (tmp >> 8) & 0x1;
390 table[i].cxx_try_catch = (tmp >> 7) & 0x1;
391 table[i].sched_entry_seq = (tmp >> 6) & 0x1;
392 table[i].reserved2 = (tmp >> 5) & 0x1;
393 table[i].Save_SP = (tmp >> 4) & 0x1;
394 table[i].Save_RP = (tmp >> 3) & 0x1;
395 table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
396 table[i].extn_ptr_defined = (tmp >> 1) & 0x1;
397 table[i].Cleanup_defined = tmp & 0x1;
398 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
400 table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
401 table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
402 table[i].Large_frame = (tmp >> 29) & 0x1;
403 table[i].Pseudo_SP_Set = (tmp >> 28) & 0x1;
404 table[i].reserved4 = (tmp >> 27) & 0x1;
405 table[i].Total_frame_size = tmp & 0x7ffffff;
407 /* Stub unwinds are handled elsewhere. */
408 table[i].stub_unwind.stub_type = 0;
409 table[i].stub_unwind.padding = 0;
414 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
415 the object file. This info is used mainly by find_unwind_entry() to find
416 out the stack frame size and frame pointer used by procedures. We put
417 everything on the psymbol obstack in the objfile so that it automatically
418 gets freed when the objfile is destroyed. */
421 read_unwind_info (objfile)
422 struct objfile *objfile;
424 asection *unwind_sec, *stub_unwind_sec;
425 unsigned unwind_size, stub_unwind_size, total_size;
426 unsigned index, unwind_entries;
427 unsigned stub_entries, total_entries;
428 CORE_ADDR text_offset;
429 struct obj_unwind_info *ui;
430 obj_private_data_t *obj_private;
432 text_offset = ANOFFSET (objfile->section_offsets, 0);
433 ui = (struct obj_unwind_info *) obstack_alloc (&objfile->psymbol_obstack,
434 sizeof (struct obj_unwind_info));
440 /* For reasons unknown the HP PA64 tools generate multiple unwinder
441 sections in a single executable. So we just iterate over every
442 section in the BFD looking for unwinder sections intead of trying
443 to do a lookup with bfd_get_section_by_name.
445 First determine the total size of the unwind tables so that we
446 can allocate memory in a nice big hunk. */
448 for (unwind_sec = objfile->obfd->sections;
450 unwind_sec = unwind_sec->next)
452 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
453 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
455 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
456 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
458 total_entries += unwind_entries;
462 /* Now compute the size of the stub unwinds. Note the ELF tools do not
463 use stub unwinds at the curren time. */
464 stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
468 stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
469 stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
473 stub_unwind_size = 0;
477 /* Compute total number of unwind entries and their total size. */
478 total_entries += stub_entries;
479 total_size = total_entries * sizeof (struct unwind_table_entry);
481 /* Allocate memory for the unwind table. */
482 ui->table = (struct unwind_table_entry *)
483 obstack_alloc (&objfile->psymbol_obstack, total_size);
484 ui->last = total_entries - 1;
486 /* Now read in each unwind section and internalize the standard unwind
489 for (unwind_sec = objfile->obfd->sections;
491 unwind_sec = unwind_sec->next)
493 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
494 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
496 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
497 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
499 internalize_unwinds (objfile, &ui->table[index], unwind_sec,
500 unwind_entries, unwind_size, text_offset);
501 index += unwind_entries;
505 /* Now read in and internalize the stub unwind entries. */
506 if (stub_unwind_size > 0)
509 char *buf = alloca (stub_unwind_size);
511 /* Read in the stub unwind entries. */
512 bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
513 0, stub_unwind_size);
515 /* Now convert them into regular unwind entries. */
516 for (i = 0; i < stub_entries; i++, index++)
518 /* Clear out the next unwind entry. */
519 memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
521 /* Convert offset & size into region_start and region_end.
522 Stuff away the stub type into "reserved" fields. */
523 ui->table[index].region_start = bfd_get_32 (objfile->obfd,
525 ui->table[index].region_start += text_offset;
527 ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
530 ui->table[index].region_end
531 = ui->table[index].region_start + 4 *
532 (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
538 /* Unwind table needs to be kept sorted. */
539 qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
540 compare_unwind_entries);
542 /* Keep a pointer to the unwind information. */
543 if (objfile->obj_private == NULL)
545 obj_private = (obj_private_data_t *)
546 obstack_alloc (&objfile->psymbol_obstack,
547 sizeof (obj_private_data_t));
548 obj_private->unwind_info = NULL;
549 obj_private->so_info = NULL;
552 objfile->obj_private = (PTR) obj_private;
554 obj_private = (obj_private_data_t *) objfile->obj_private;
555 obj_private->unwind_info = ui;
558 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
559 of the objfiles seeking the unwind table entry for this PC. Each objfile
560 contains a sorted list of struct unwind_table_entry. Since we do a binary
561 search of the unwind tables, we depend upon them to be sorted. */
563 struct unwind_table_entry *
564 find_unwind_entry (pc)
567 int first, middle, last;
568 struct objfile *objfile;
570 /* A function at address 0? Not in HP-UX! */
571 if (pc == (CORE_ADDR) 0)
574 ALL_OBJFILES (objfile)
576 struct obj_unwind_info *ui;
578 if (objfile->obj_private)
579 ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
583 read_unwind_info (objfile);
584 if (objfile->obj_private == NULL)
585 error ("Internal error reading unwind information.");
586 ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
589 /* First, check the cache */
592 && pc >= ui->cache->region_start
593 && pc <= ui->cache->region_end)
596 /* Not in the cache, do a binary search */
601 while (first <= last)
603 middle = (first + last) / 2;
604 if (pc >= ui->table[middle].region_start
605 && pc <= ui->table[middle].region_end)
607 ui->cache = &ui->table[middle];
608 return &ui->table[middle];
611 if (pc < ui->table[middle].region_start)
616 } /* ALL_OBJFILES() */
620 /* Return the adjustment necessary to make for addresses on the stack
621 as presented by hpread.c.
623 This is necessary because of the stack direction on the PA and the
624 bizarre way in which someone (?) decided they wanted to handle
625 frame pointerless code in GDB. */
627 hpread_adjust_stack_address (func_addr)
630 struct unwind_table_entry *u;
632 u = find_unwind_entry (func_addr);
636 return u->Total_frame_size << 3;
639 /* Called to determine if PC is in an interrupt handler of some
643 pc_in_interrupt_handler (pc)
646 struct unwind_table_entry *u;
647 struct minimal_symbol *msym_us;
649 u = find_unwind_entry (pc);
653 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
654 its frame isn't a pure interrupt frame. Deal with this. */
655 msym_us = lookup_minimal_symbol_by_pc (pc);
657 return u->HP_UX_interrupt_marker && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us));
660 /* Called when no unwind descriptor was found for PC. Returns 1 if it
661 appears that PC is in a linker stub.
663 ?!? Need to handle stubs which appear in PA64 code. */
666 pc_in_linker_stub (pc)
669 int found_magic_instruction = 0;
673 /* If unable to read memory, assume pc is not in a linker stub. */
674 if (target_read_memory (pc, buf, 4) != 0)
677 /* We are looking for something like
679 ; $$dyncall jams RP into this special spot in the frame (RP')
680 ; before calling the "call stub"
683 ldsid (rp),r1 ; Get space associated with RP into r1
684 mtsp r1,sp ; Move it into space register 0
685 be,n 0(sr0),rp) ; back to your regularly scheduled program */
687 /* Maximum known linker stub size is 4 instructions. Search forward
688 from the given PC, then backward. */
689 for (i = 0; i < 4; i++)
691 /* If we hit something with an unwind, stop searching this direction. */
693 if (find_unwind_entry (pc + i * 4) != 0)
696 /* Check for ldsid (rp),r1 which is the magic instruction for a
697 return from a cross-space function call. */
698 if (read_memory_integer (pc + i * 4, 4) == 0x004010a1)
700 found_magic_instruction = 1;
703 /* Add code to handle long call/branch and argument relocation stubs
707 if (found_magic_instruction != 0)
710 /* Now look backward. */
711 for (i = 0; i < 4; i++)
713 /* If we hit something with an unwind, stop searching this direction. */
715 if (find_unwind_entry (pc - i * 4) != 0)
718 /* Check for ldsid (rp),r1 which is the magic instruction for a
719 return from a cross-space function call. */
720 if (read_memory_integer (pc - i * 4, 4) == 0x004010a1)
722 found_magic_instruction = 1;
725 /* Add code to handle long call/branch and argument relocation stubs
728 return found_magic_instruction;
732 find_return_regnum (pc)
735 struct unwind_table_entry *u;
737 u = find_unwind_entry (pc);
748 /* Return size of frame, or -1 if we should use a frame pointer. */
750 find_proc_framesize (pc)
753 struct unwind_table_entry *u;
754 struct minimal_symbol *msym_us;
756 /* This may indicate a bug in our callers... */
757 if (pc == (CORE_ADDR) 0)
760 u = find_unwind_entry (pc);
764 if (pc_in_linker_stub (pc))
765 /* Linker stubs have a zero size frame. */
771 msym_us = lookup_minimal_symbol_by_pc (pc);
773 /* If Save_SP is set, and we're not in an interrupt or signal caller,
774 then we have a frame pointer. Use it. */
775 if (u->Save_SP && !pc_in_interrupt_handler (pc)
776 && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us)))
779 return u->Total_frame_size << 3;
782 /* Return offset from sp at which rp is saved, or 0 if not saved. */
783 static int rp_saved (CORE_ADDR);
789 struct unwind_table_entry *u;
791 /* A function at, and thus a return PC from, address 0? Not in HP-UX! */
792 if (pc == (CORE_ADDR) 0)
795 u = find_unwind_entry (pc);
799 if (pc_in_linker_stub (pc))
800 /* This is the so-called RP'. */
807 return (TARGET_PTR_BIT == 64 ? -16 : -20);
808 else if (u->stub_unwind.stub_type != 0)
810 switch (u->stub_unwind.stub_type)
815 case PARAMETER_RELOCATION:
826 frameless_function_invocation (frame)
827 struct frame_info *frame;
829 struct unwind_table_entry *u;
831 u = find_unwind_entry (frame->pc);
836 return (u->Total_frame_size == 0 && u->stub_unwind.stub_type == 0);
840 saved_pc_after_call (frame)
841 struct frame_info *frame;
845 struct unwind_table_entry *u;
847 ret_regnum = find_return_regnum (get_frame_pc (frame));
848 pc = read_register (ret_regnum) & ~0x3;
850 /* If PC is in a linker stub, then we need to dig the address
851 the stub will return to out of the stack. */
852 u = find_unwind_entry (pc);
853 if (u && u->stub_unwind.stub_type != 0)
854 return FRAME_SAVED_PC (frame);
860 hppa_frame_saved_pc (frame)
861 struct frame_info *frame;
863 CORE_ADDR pc = get_frame_pc (frame);
864 struct unwind_table_entry *u;
866 int spun_around_loop = 0;
869 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
870 at the base of the frame in an interrupt handler. Registers within
871 are saved in the exact same order as GDB numbers registers. How
873 if (pc_in_interrupt_handler (pc))
874 return read_memory_integer (frame->frame + PC_REGNUM * 4,
875 TARGET_PTR_BIT / 8) & ~0x3;
877 if ((frame->pc >= frame->frame
878 && frame->pc <= (frame->frame
879 /* A call dummy is sized in words, but it is
880 actually a series of instructions. Account
881 for that scaling factor. */
882 + ((REGISTER_SIZE / INSTRUCTION_SIZE)
884 /* Similarly we have to account for 64bit
885 wide register saves. */
886 + (32 * REGISTER_SIZE)
887 /* We always consider FP regs 8 bytes long. */
888 + (NUM_REGS - FP0_REGNUM) * 8
889 /* Similarly we have to account for 64bit
890 wide register saves. */
891 + (6 * REGISTER_SIZE))))
893 return read_memory_integer ((frame->frame
894 + (TARGET_PTR_BIT == 64 ? -16 : -20)),
895 TARGET_PTR_BIT / 8) & ~0x3;
898 #ifdef FRAME_SAVED_PC_IN_SIGTRAMP
899 /* Deal with signal handler caller frames too. */
900 if (frame->signal_handler_caller)
903 FRAME_SAVED_PC_IN_SIGTRAMP (frame, &rp);
908 if (frameless_function_invocation (frame))
912 ret_regnum = find_return_regnum (pc);
914 /* If the next frame is an interrupt frame or a signal
915 handler caller, then we need to look in the saved
916 register area to get the return pointer (the values
917 in the registers may not correspond to anything useful). */
919 && (frame->next->signal_handler_caller
920 || pc_in_interrupt_handler (frame->next->pc)))
922 struct frame_saved_regs saved_regs;
924 get_frame_saved_regs (frame->next, &saved_regs);
925 if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
926 TARGET_PTR_BIT / 8) & 0x2)
928 pc = read_memory_integer (saved_regs.regs[31],
929 TARGET_PTR_BIT / 8) & ~0x3;
931 /* Syscalls are really two frames. The syscall stub itself
932 with a return pointer in %rp and the kernel call with
933 a return pointer in %r31. We return the %rp variant
934 if %r31 is the same as frame->pc. */
936 pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
937 TARGET_PTR_BIT / 8) & ~0x3;
940 pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
941 TARGET_PTR_BIT / 8) & ~0x3;
944 pc = read_register (ret_regnum) & ~0x3;
948 spun_around_loop = 0;
952 rp_offset = rp_saved (pc);
954 /* Similar to code in frameless function case. If the next
955 frame is a signal or interrupt handler, then dig the right
956 information out of the saved register info. */
959 && (frame->next->signal_handler_caller
960 || pc_in_interrupt_handler (frame->next->pc)))
962 struct frame_saved_regs saved_regs;
964 get_frame_saved_regs (frame->next, &saved_regs);
965 if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
966 TARGET_PTR_BIT / 8) & 0x2)
968 pc = read_memory_integer (saved_regs.regs[31],
969 TARGET_PTR_BIT / 8) & ~0x3;
971 /* Syscalls are really two frames. The syscall stub itself
972 with a return pointer in %rp and the kernel call with
973 a return pointer in %r31. We return the %rp variant
974 if %r31 is the same as frame->pc. */
976 pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
977 TARGET_PTR_BIT / 8) & ~0x3;
980 pc = read_memory_integer (saved_regs.regs[RP_REGNUM],
981 TARGET_PTR_BIT / 8) & ~0x3;
983 else if (rp_offset == 0)
986 pc = read_register (RP_REGNUM) & ~0x3;
991 pc = read_memory_integer (frame->frame + rp_offset,
992 TARGET_PTR_BIT / 8) & ~0x3;
996 /* If PC is inside a linker stub, then dig out the address the stub
999 Don't do this for long branch stubs. Why? For some unknown reason
1000 _start is marked as a long branch stub in hpux10. */
1001 u = find_unwind_entry (pc);
1002 if (u && u->stub_unwind.stub_type != 0
1003 && u->stub_unwind.stub_type != LONG_BRANCH)
1007 /* If this is a dynamic executable, and we're in a signal handler,
1008 then the call chain will eventually point us into the stub for
1009 _sigreturn. Unlike most cases, we'll be pointed to the branch
1010 to the real sigreturn rather than the code after the real branch!.
1012 Else, try to dig the address the stub will return to in the normal
1014 insn = read_memory_integer (pc, 4);
1015 if ((insn & 0xfc00e000) == 0xe8000000)
1016 return (pc + extract_17 (insn) + 8) & ~0x3;
1022 if (spun_around_loop > 1)
1024 /* We're just about to go around the loop again with
1025 no more hope of success. Die. */
1026 error ("Unable to find return pc for this frame");
1036 /* We need to correct the PC and the FP for the outermost frame when we are
1037 in a system call. */
1040 init_extra_frame_info (fromleaf, frame)
1042 struct frame_info *frame;
1047 if (frame->next && !fromleaf)
1050 /* If the next frame represents a frameless function invocation
1051 then we have to do some adjustments that are normally done by
1052 FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
1055 /* Find the framesize of *this* frame without peeking at the PC
1056 in the current frame structure (it isn't set yet). */
1057 framesize = find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame)));
1059 /* Now adjust our base frame accordingly. If we have a frame pointer
1060 use it, else subtract the size of this frame from the current
1061 frame. (we always want frame->frame to point at the lowest address
1063 if (framesize == -1)
1064 frame->frame = TARGET_READ_FP ();
1066 frame->frame -= framesize;
1070 flags = read_register (FLAGS_REGNUM);
1071 if (flags & 2) /* In system call? */
1072 frame->pc = read_register (31) & ~0x3;
1074 /* The outermost frame is always derived from PC-framesize
1076 One might think frameless innermost frames should have
1077 a frame->frame that is the same as the parent's frame->frame.
1078 That is wrong; frame->frame in that case should be the *high*
1079 address of the parent's frame. It's complicated as hell to
1080 explain, but the parent *always* creates some stack space for
1081 the child. So the child actually does have a frame of some
1082 sorts, and its base is the high address in its parent's frame. */
1083 framesize = find_proc_framesize (frame->pc);
1084 if (framesize == -1)
1085 frame->frame = TARGET_READ_FP ();
1087 frame->frame = read_register (SP_REGNUM) - framesize;
1090 /* Given a GDB frame, determine the address of the calling function's frame.
1091 This will be used to create a new GDB frame struct, and then
1092 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
1094 This may involve searching through prologues for several functions
1095 at boundaries where GCC calls HP C code, or where code which has
1096 a frame pointer calls code without a frame pointer. */
1100 struct frame_info *frame;
1102 int my_framesize, caller_framesize;
1103 struct unwind_table_entry *u;
1104 CORE_ADDR frame_base;
1105 struct frame_info *tmp_frame;
1107 /* A frame in the current frame list, or zero. */
1108 struct frame_info *saved_regs_frame = 0;
1109 /* Where the registers were saved in saved_regs_frame.
1110 If saved_regs_frame is zero, this is garbage. */
1111 struct frame_saved_regs saved_regs;
1113 CORE_ADDR caller_pc;
1115 struct minimal_symbol *min_frame_symbol;
1116 struct symbol *frame_symbol;
1117 char *frame_symbol_name;
1119 /* If this is a threaded application, and we see the
1120 routine "__pthread_exit", treat it as the stack root
1122 min_frame_symbol = lookup_minimal_symbol_by_pc (frame->pc);
1123 frame_symbol = find_pc_function (frame->pc);
1125 if ((min_frame_symbol != 0) /* && (frame_symbol == 0) */ )
1127 /* The test above for "no user function name" would defend
1128 against the slim likelihood that a user might define a
1129 routine named "__pthread_exit" and then try to debug it.
1131 If it weren't commented out, and you tried to debug the
1132 pthread library itself, you'd get errors.
1134 So for today, we don't make that check. */
1135 frame_symbol_name = SYMBOL_NAME (min_frame_symbol);
1136 if (frame_symbol_name != 0)
1138 if (0 == strncmp (frame_symbol_name,
1139 THREAD_INITIAL_FRAME_SYMBOL,
1140 THREAD_INITIAL_FRAME_SYM_LEN))
1142 /* Pretend we've reached the bottom of the stack. */
1143 return (CORE_ADDR) 0;
1146 } /* End of hacky code for threads. */
1148 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
1149 are easy; at *sp we have a full save state strucutre which we can
1150 pull the old stack pointer from. Also see frame_saved_pc for
1151 code to dig a saved PC out of the save state structure. */
1152 if (pc_in_interrupt_handler (frame->pc))
1153 frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4,
1154 TARGET_PTR_BIT / 8);
1155 #ifdef FRAME_BASE_BEFORE_SIGTRAMP
1156 else if (frame->signal_handler_caller)
1158 FRAME_BASE_BEFORE_SIGTRAMP (frame, &frame_base);
1162 frame_base = frame->frame;
1164 /* Get frame sizes for the current frame and the frame of the
1166 my_framesize = find_proc_framesize (frame->pc);
1167 caller_pc = FRAME_SAVED_PC (frame);
1169 /* If we can't determine the caller's PC, then it's not likely we can
1170 really determine anything meaningful about its frame. We'll consider
1171 this to be stack bottom. */
1172 if (caller_pc == (CORE_ADDR) 0)
1173 return (CORE_ADDR) 0;
1175 caller_framesize = find_proc_framesize (FRAME_SAVED_PC (frame));
1177 /* If caller does not have a frame pointer, then its frame
1178 can be found at current_frame - caller_framesize. */
1179 if (caller_framesize != -1)
1181 return frame_base - caller_framesize;
1183 /* Both caller and callee have frame pointers and are GCC compiled
1184 (SAVE_SP bit in unwind descriptor is on for both functions.
1185 The previous frame pointer is found at the top of the current frame. */
1186 if (caller_framesize == -1 && my_framesize == -1)
1188 return read_memory_integer (frame_base, TARGET_PTR_BIT / 8);
1190 /* Caller has a frame pointer, but callee does not. This is a little
1191 more difficult as GCC and HP C lay out locals and callee register save
1192 areas very differently.
1194 The previous frame pointer could be in a register, or in one of
1195 several areas on the stack.
1197 Walk from the current frame to the innermost frame examining
1198 unwind descriptors to determine if %r3 ever gets saved into the
1199 stack. If so return whatever value got saved into the stack.
1200 If it was never saved in the stack, then the value in %r3 is still
1203 We use information from unwind descriptors to determine if %r3
1204 is saved into the stack (Entry_GR field has this information). */
1206 for (tmp_frame = frame; tmp_frame; tmp_frame = tmp_frame->next)
1208 u = find_unwind_entry (tmp_frame->pc);
1212 /* We could find this information by examining prologues. I don't
1213 think anyone has actually written any tools (not even "strip")
1214 which leave them out of an executable, so maybe this is a moot
1216 /* ??rehrauer: Actually, it's quite possible to stepi your way into
1217 code that doesn't have unwind entries. For example, stepping into
1218 the dynamic linker will give you a PC that has none. Thus, I've
1219 disabled this warning. */
1221 warning ("Unable to find unwind for PC 0x%x -- Help!", tmp_frame->pc);
1223 return (CORE_ADDR) 0;
1227 || tmp_frame->signal_handler_caller
1228 || pc_in_interrupt_handler (tmp_frame->pc))
1231 /* Entry_GR specifies the number of callee-saved general registers
1232 saved in the stack. It starts at %r3, so %r3 would be 1. */
1233 if (u->Entry_GR >= 1)
1235 /* The unwind entry claims that r3 is saved here. However,
1236 in optimized code, GCC often doesn't actually save r3.
1237 We'll discover this if we look at the prologue. */
1238 get_frame_saved_regs (tmp_frame, &saved_regs);
1239 saved_regs_frame = tmp_frame;
1241 /* If we have an address for r3, that's good. */
1242 if (saved_regs.regs[FP_REGNUM])
1249 /* We may have walked down the chain into a function with a frame
1252 && !tmp_frame->signal_handler_caller
1253 && !pc_in_interrupt_handler (tmp_frame->pc))
1255 return read_memory_integer (tmp_frame->frame, TARGET_PTR_BIT / 8);
1257 /* %r3 was saved somewhere in the stack. Dig it out. */
1262 For optimization purposes many kernels don't have the
1263 callee saved registers into the save_state structure upon
1264 entry into the kernel for a syscall; the optimization
1265 is usually turned off if the process is being traced so
1266 that the debugger can get full register state for the
1269 This scheme works well except for two cases:
1271 * Attaching to a process when the process is in the
1272 kernel performing a system call (debugger can't get
1273 full register state for the inferior process since
1274 the process wasn't being traced when it entered the
1277 * Register state is not complete if the system call
1278 causes the process to core dump.
1281 The following heinous code is an attempt to deal with
1282 the lack of register state in a core dump. It will
1283 fail miserably if the function which performs the
1284 system call has a variable sized stack frame. */
1286 if (tmp_frame != saved_regs_frame)
1287 get_frame_saved_regs (tmp_frame, &saved_regs);
1289 /* Abominable hack. */
1290 if (current_target.to_has_execution == 0
1291 && ((saved_regs.regs[FLAGS_REGNUM]
1292 && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
1295 || (saved_regs.regs[FLAGS_REGNUM] == 0
1296 && read_register (FLAGS_REGNUM) & 0x2)))
1298 u = find_unwind_entry (FRAME_SAVED_PC (frame));
1301 return read_memory_integer (saved_regs.regs[FP_REGNUM],
1302 TARGET_PTR_BIT / 8);
1306 return frame_base - (u->Total_frame_size << 3);
1310 return read_memory_integer (saved_regs.regs[FP_REGNUM],
1311 TARGET_PTR_BIT / 8);
1316 /* Get the innermost frame. */
1318 while (tmp_frame->next != NULL)
1319 tmp_frame = tmp_frame->next;
1321 if (tmp_frame != saved_regs_frame)
1322 get_frame_saved_regs (tmp_frame, &saved_regs);
1324 /* Abominable hack. See above. */
1325 if (current_target.to_has_execution == 0
1326 && ((saved_regs.regs[FLAGS_REGNUM]
1327 && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM],
1330 || (saved_regs.regs[FLAGS_REGNUM] == 0
1331 && read_register (FLAGS_REGNUM) & 0x2)))
1333 u = find_unwind_entry (FRAME_SAVED_PC (frame));
1336 return read_memory_integer (saved_regs.regs[FP_REGNUM],
1337 TARGET_PTR_BIT / 8);
1341 return frame_base - (u->Total_frame_size << 3);
1345 /* The value in %r3 was never saved into the stack (thus %r3 still
1346 holds the value of the previous frame pointer). */
1347 return TARGET_READ_FP ();
1352 /* To see if a frame chain is valid, see if the caller looks like it
1353 was compiled with gcc. */
1356 hppa_frame_chain_valid (chain, thisframe)
1358 struct frame_info *thisframe;
1360 struct minimal_symbol *msym_us;
1361 struct minimal_symbol *msym_start;
1362 struct unwind_table_entry *u, *next_u = NULL;
1363 struct frame_info *next;
1368 u = find_unwind_entry (thisframe->pc);
1373 /* We can't just check that the same of msym_us is "_start", because
1374 someone idiotically decided that they were going to make a Ltext_end
1375 symbol with the same address. This Ltext_end symbol is totally
1376 indistinguishable (as nearly as I can tell) from the symbol for a function
1377 which is (legitimately, since it is in the user's namespace)
1378 named Ltext_end, so we can't just ignore it. */
1379 msym_us = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe));
1380 msym_start = lookup_minimal_symbol ("_start", NULL, NULL);
1383 && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
1386 /* Grrrr. Some new idiot decided that they don't want _start for the
1387 PRO configurations; $START$ calls main directly.... Deal with it. */
1388 msym_start = lookup_minimal_symbol ("$START$", NULL, NULL);
1391 && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
1394 next = get_next_frame (thisframe);
1396 next_u = find_unwind_entry (next->pc);
1398 /* If this frame does not save SP, has no stack, isn't a stub,
1399 and doesn't "call" an interrupt routine or signal handler caller,
1400 then its not valid. */
1401 if (u->Save_SP || u->Total_frame_size || u->stub_unwind.stub_type != 0
1402 || (thisframe->next && thisframe->next->signal_handler_caller)
1403 || (next_u && next_u->HP_UX_interrupt_marker))
1406 if (pc_in_linker_stub (thisframe->pc))
1413 These functions deal with saving and restoring register state
1414 around a function call in the inferior. They keep the stack
1415 double-word aligned; eventually, on an hp700, the stack will have
1416 to be aligned to a 64-byte boundary. */
1419 push_dummy_frame (inf_status)
1420 struct inferior_status *inf_status;
1422 CORE_ADDR sp, pc, pcspace;
1423 register int regnum;
1424 CORE_ADDR int_buffer;
1427 /* Oh, what a hack. If we're trying to perform an inferior call
1428 while the inferior is asleep, we have to make sure to clear
1429 the "in system call" bit in the flag register (the call will
1430 start after the syscall returns, so we're no longer in the system
1431 call!) This state is kept in "inf_status", change it there.
1433 We also need a number of horrid hacks to deal with lossage in the
1434 PC queue registers (apparently they're not valid when the in syscall
1436 pc = target_read_pc (inferior_pid);
1437 int_buffer = read_register (FLAGS_REGNUM);
1438 if (int_buffer & 0x2)
1442 write_inferior_status_register (inf_status, 0, int_buffer);
1443 write_inferior_status_register (inf_status, PCOQ_HEAD_REGNUM, pc + 0);
1444 write_inferior_status_register (inf_status, PCOQ_TAIL_REGNUM, pc + 4);
1445 sid = (pc >> 30) & 0x3;
1447 pcspace = read_register (SR4_REGNUM);
1449 pcspace = read_register (SR4_REGNUM + 4 + sid);
1450 write_inferior_status_register (inf_status, PCSQ_HEAD_REGNUM, pcspace);
1451 write_inferior_status_register (inf_status, PCSQ_TAIL_REGNUM, pcspace);
1454 pcspace = read_register (PCSQ_HEAD_REGNUM);
1456 /* Space for "arguments"; the RP goes in here. */
1457 sp = read_register (SP_REGNUM) + 48;
1458 int_buffer = read_register (RP_REGNUM) | 0x3;
1460 /* The 32bit and 64bit ABIs save the return pointer into different
1462 if (REGISTER_SIZE == 8)
1463 write_memory (sp - 16, (char *) &int_buffer, REGISTER_SIZE);
1465 write_memory (sp - 20, (char *) &int_buffer, REGISTER_SIZE);
1467 int_buffer = TARGET_READ_FP ();
1468 write_memory (sp, (char *) &int_buffer, REGISTER_SIZE);
1470 write_register (FP_REGNUM, sp);
1472 sp += 2 * REGISTER_SIZE;
1474 for (regnum = 1; regnum < 32; regnum++)
1475 if (regnum != RP_REGNUM && regnum != FP_REGNUM)
1476 sp = push_word (sp, read_register (regnum));
1478 /* This is not necessary for the 64bit ABI. In fact it is dangerous. */
1479 if (REGISTER_SIZE != 8)
1482 for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
1484 read_register_bytes (REGISTER_BYTE (regnum), (char *) &freg_buffer, 8);
1485 sp = push_bytes (sp, (char *) &freg_buffer, 8);
1487 sp = push_word (sp, read_register (IPSW_REGNUM));
1488 sp = push_word (sp, read_register (SAR_REGNUM));
1489 sp = push_word (sp, pc);
1490 sp = push_word (sp, pcspace);
1491 sp = push_word (sp, pc + 4);
1492 sp = push_word (sp, pcspace);
1493 write_register (SP_REGNUM, sp);
1497 find_dummy_frame_regs (frame, frame_saved_regs)
1498 struct frame_info *frame;
1499 struct frame_saved_regs *frame_saved_regs;
1501 CORE_ADDR fp = frame->frame;
1504 /* The 32bit and 64bit ABIs save RP into different locations. */
1505 if (REGISTER_SIZE == 8)
1506 frame_saved_regs->regs[RP_REGNUM] = (fp - 16) & ~0x3;
1508 frame_saved_regs->regs[RP_REGNUM] = (fp - 20) & ~0x3;
1510 frame_saved_regs->regs[FP_REGNUM] = fp;
1512 frame_saved_regs->regs[1] = fp + (2 * REGISTER_SIZE);
1514 for (fp += 3 * REGISTER_SIZE, i = 3; i < 32; i++)
1518 frame_saved_regs->regs[i] = fp;
1519 fp += REGISTER_SIZE;
1523 /* This is not necessary or desirable for the 64bit ABI. */
1524 if (REGISTER_SIZE != 8)
1527 for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
1528 frame_saved_regs->regs[i] = fp;
1530 frame_saved_regs->regs[IPSW_REGNUM] = fp;
1531 frame_saved_regs->regs[SAR_REGNUM] = fp + REGISTER_SIZE;
1532 frame_saved_regs->regs[PCOQ_HEAD_REGNUM] = fp + 2 * REGISTER_SIZE;
1533 frame_saved_regs->regs[PCSQ_HEAD_REGNUM] = fp + 3 * REGISTER_SIZE;
1534 frame_saved_regs->regs[PCOQ_TAIL_REGNUM] = fp + 4 * REGISTER_SIZE;
1535 frame_saved_regs->regs[PCSQ_TAIL_REGNUM] = fp + 5 * REGISTER_SIZE;
1541 register struct frame_info *frame = get_current_frame ();
1542 register CORE_ADDR fp, npc, target_pc;
1543 register int regnum;
1544 struct frame_saved_regs fsr;
1547 fp = FRAME_FP (frame);
1548 get_frame_saved_regs (frame, &fsr);
1550 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1551 if (fsr.regs[IPSW_REGNUM]) /* Restoring a call dummy frame */
1552 restore_pc_queue (&fsr);
1555 for (regnum = 31; regnum > 0; regnum--)
1556 if (fsr.regs[regnum])
1557 write_register (regnum, read_memory_integer (fsr.regs[regnum],
1560 for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
1561 if (fsr.regs[regnum])
1563 read_memory (fsr.regs[regnum], (char *) &freg_buffer, 8);
1564 write_register_bytes (REGISTER_BYTE (regnum), (char *) &freg_buffer, 8);
1567 if (fsr.regs[IPSW_REGNUM])
1568 write_register (IPSW_REGNUM,
1569 read_memory_integer (fsr.regs[IPSW_REGNUM],
1572 if (fsr.regs[SAR_REGNUM])
1573 write_register (SAR_REGNUM,
1574 read_memory_integer (fsr.regs[SAR_REGNUM],
1577 /* If the PC was explicitly saved, then just restore it. */
1578 if (fsr.regs[PCOQ_TAIL_REGNUM])
1580 npc = read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM],
1582 write_register (PCOQ_TAIL_REGNUM, npc);
1584 /* Else use the value in %rp to set the new PC. */
1587 npc = read_register (RP_REGNUM);
1591 write_register (FP_REGNUM, read_memory_integer (fp, REGISTER_SIZE));
1593 if (fsr.regs[IPSW_REGNUM]) /* call dummy */
1594 write_register (SP_REGNUM, fp - 48);
1596 write_register (SP_REGNUM, fp);
1598 /* The PC we just restored may be inside a return trampoline. If so
1599 we want to restart the inferior and run it through the trampoline.
1601 Do this by setting a momentary breakpoint at the location the
1602 trampoline returns to.
1604 Don't skip through the trampoline if we're popping a dummy frame. */
1605 target_pc = SKIP_TRAMPOLINE_CODE (npc & ~0x3) & ~0x3;
1606 if (target_pc && !fsr.regs[IPSW_REGNUM])
1608 struct symtab_and_line sal;
1609 struct breakpoint *breakpoint;
1610 struct cleanup *old_chain;
1612 /* Set up our breakpoint. Set it to be silent as the MI code
1613 for "return_command" will print the frame we returned to. */
1614 sal = find_pc_line (target_pc, 0);
1616 breakpoint = set_momentary_breakpoint (sal, NULL, bp_finish);
1617 breakpoint->silent = 1;
1619 /* So we can clean things up. */
1620 old_chain = make_cleanup_delete_breakpoint (breakpoint);
1622 /* Start up the inferior. */
1623 clear_proceed_status ();
1624 proceed_to_finish = 1;
1625 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
1627 /* Perform our cleanups. */
1628 do_cleanups (old_chain);
1630 flush_cached_frames ();
1633 /* After returning to a dummy on the stack, restore the instruction
1634 queue space registers. */
1637 restore_pc_queue (fsr)
1638 struct frame_saved_regs *fsr;
1640 CORE_ADDR pc = read_pc ();
1641 CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM],
1642 TARGET_PTR_BIT / 8);
1643 struct target_waitstatus w;
1646 /* Advance past break instruction in the call dummy. */
1647 write_register (PCOQ_HEAD_REGNUM, pc + 4);
1648 write_register (PCOQ_TAIL_REGNUM, pc + 8);
1650 /* HPUX doesn't let us set the space registers or the space
1651 registers of the PC queue through ptrace. Boo, hiss.
1652 Conveniently, the call dummy has this sequence of instructions
1657 So, load up the registers and single step until we are in the
1660 write_register (21, read_memory_integer (fsr->regs[PCSQ_HEAD_REGNUM],
1662 write_register (22, new_pc);
1664 for (insn_count = 0; insn_count < 3; insn_count++)
1666 /* FIXME: What if the inferior gets a signal right now? Want to
1667 merge this into wait_for_inferior (as a special kind of
1668 watchpoint? By setting a breakpoint at the end? Is there
1669 any other choice? Is there *any* way to do this stuff with
1670 ptrace() or some equivalent?). */
1672 target_wait (inferior_pid, &w);
1674 if (w.kind == TARGET_WAITKIND_SIGNALLED)
1676 stop_signal = w.value.sig;
1677 terminal_ours_for_output ();
1678 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1679 target_signal_to_name (stop_signal),
1680 target_signal_to_string (stop_signal));
1681 gdb_flush (gdb_stdout);
1685 target_terminal_ours ();
1686 target_fetch_registers (-1);
1691 #ifdef PA20W_CALLING_CONVENTIONS
1693 /* This function pushes a stack frame with arguments as part of the
1694 inferior function calling mechanism.
1696 This is the version for the PA64, in which later arguments appear
1697 at higher addresses. (The stack always grows towards higher
1700 We simply allocate the appropriate amount of stack space and put
1701 arguments into their proper slots. The call dummy code will copy
1702 arguments into registers as needed by the ABI.
1704 This ABI also requires that the caller provide an argument pointer
1705 to the callee, so we do that too. */
1708 hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
1713 CORE_ADDR struct_addr;
1715 /* array of arguments' offsets */
1716 int *offset = (int *) alloca (nargs * sizeof (int));
1718 /* array of arguments' lengths: real lengths in bytes, not aligned to
1720 int *lengths = (int *) alloca (nargs * sizeof (int));
1722 /* The value of SP as it was passed into this function after
1724 CORE_ADDR orig_sp = STACK_ALIGN (sp);
1726 /* The number of stack bytes occupied by the current argument. */
1729 /* The total number of bytes reserved for the arguments. */
1730 int cum_bytes_reserved = 0;
1732 /* Similarly, but aligned. */
1733 int cum_bytes_aligned = 0;
1736 /* Iterate over each argument provided by the user. */
1737 for (i = 0; i < nargs; i++)
1739 struct type *arg_type = VALUE_TYPE (args[i]);
1741 /* Integral scalar values smaller than a register are padded on
1742 the left. We do this by promoting them to full-width,
1743 although the ABI says to pad them with garbage. */
1744 if (is_integral_type (arg_type)
1745 && TYPE_LENGTH (arg_type) < REGISTER_SIZE)
1747 args[i] = value_cast ((TYPE_UNSIGNED (arg_type)
1748 ? builtin_type_unsigned_long
1749 : builtin_type_long),
1751 arg_type = VALUE_TYPE (args[i]);
1754 lengths[i] = TYPE_LENGTH (arg_type);
1756 /* Align the size of the argument to the word size for this
1758 bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
1760 offset[i] = cum_bytes_reserved;
1762 /* Aggregates larger than eight bytes (the only types larger
1763 than eight bytes we have) are aligned on a 16-byte boundary,
1764 possibly padded on the right with garbage. This may leave an
1765 empty word on the stack, and thus an unused register, as per
1767 if (bytes_reserved > 8)
1769 /* Round up the offset to a multiple of two slots. */
1770 int new_offset = ((offset[i] + 2*REGISTER_SIZE-1)
1771 & -(2*REGISTER_SIZE));
1773 /* Note the space we've wasted, if any. */
1774 bytes_reserved += new_offset - offset[i];
1775 offset[i] = new_offset;
1778 cum_bytes_reserved += bytes_reserved;
1781 /* CUM_BYTES_RESERVED already accounts for all the arguments
1782 passed by the user. However, the ABIs mandate minimum stack space
1783 allocations for outgoing arguments.
1785 The ABIs also mandate minimum stack alignments which we must
1787 cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
1788 sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
1790 /* Now write each of the args at the proper offset down the stack. */
1791 for (i = 0; i < nargs; i++)
1792 write_memory (orig_sp + offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
1794 /* If a structure has to be returned, set up register 28 to hold its
1797 write_register (28, struct_addr);
1799 /* For the PA64 we must pass a pointer to the outgoing argument list.
1800 The ABI mandates that the pointer should point to the first byte of
1801 storage beyond the register flushback area.
1803 However, the call dummy expects the outgoing argument pointer to
1804 be passed in register %r4. */
1805 write_register (4, orig_sp + REG_PARM_STACK_SPACE);
1807 /* ?!? This needs further work. We need to set up the global data
1808 pointer for this procedure. This assumes the same global pointer
1809 for every procedure. The call dummy expects the dp value to
1810 be passed in register %r6. */
1811 write_register (6, read_register (27));
1813 /* The stack will have 64 bytes of additional space for a frame marker. */
1819 /* This function pushes a stack frame with arguments as part of the
1820 inferior function calling mechanism.
1822 This is the version of the function for the 32-bit PA machines, in
1823 which later arguments appear at lower addresses. (The stack always
1824 grows towards higher addresses.)
1826 We simply allocate the appropriate amount of stack space and put
1827 arguments into their proper slots. The call dummy code will copy
1828 arguments into registers as needed by the ABI. */
1831 hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
1836 CORE_ADDR struct_addr;
1838 /* array of arguments' offsets */
1839 int *offset = (int *) alloca (nargs * sizeof (int));
1841 /* array of arguments' lengths: real lengths in bytes, not aligned to
1843 int *lengths = (int *) alloca (nargs * sizeof (int));
1845 /* The number of stack bytes occupied by the current argument. */
1848 /* The total number of bytes reserved for the arguments. */
1849 int cum_bytes_reserved = 0;
1851 /* Similarly, but aligned. */
1852 int cum_bytes_aligned = 0;
1855 /* Iterate over each argument provided by the user. */
1856 for (i = 0; i < nargs; i++)
1858 lengths[i] = TYPE_LENGTH (VALUE_TYPE (args[i]));
1860 /* Align the size of the argument to the word size for this
1862 bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
1864 offset[i] = cum_bytes_reserved + lengths[i];
1866 /* If the argument is a double word argument, then it needs to be
1867 double word aligned. */
1868 if ((bytes_reserved == 2 * REGISTER_SIZE)
1869 && (offset[i] % 2 * REGISTER_SIZE))
1872 /* BYTES_RESERVED is already aligned to the word, so we put
1873 the argument at one word more down the stack.
1875 This will leave one empty word on the stack, and one unused
1876 register as mandated by the ABI. */
1877 new_offset = ((offset[i] + 2 * REGISTER_SIZE - 1)
1878 & -(2 * REGISTER_SIZE));
1880 if ((new_offset - offset[i]) >= 2 * REGISTER_SIZE)
1882 bytes_reserved += REGISTER_SIZE;
1883 offset[i] += REGISTER_SIZE;
1887 cum_bytes_reserved += bytes_reserved;
1891 /* CUM_BYTES_RESERVED already accounts for all the arguments passed
1892 by the user. However, the ABI mandates minimum stack space
1893 allocations for outgoing arguments.
1895 The ABI also mandates minimum stack alignments which we must
1897 cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
1898 sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
1900 /* Now write each of the args at the proper offset down the stack.
1901 ?!? We need to promote values to a full register instead of skipping
1902 words in the stack. */
1903 for (i = 0; i < nargs; i++)
1904 write_memory (sp - offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
1906 /* If a structure has to be returned, set up register 28 to hold its
1909 write_register (28, struct_addr);
1911 /* The stack will have 32 bytes of additional space for a frame marker. */
1917 /* elz: this function returns a value which is built looking at the given address.
1918 It is called from call_function_by_hand, in case we need to return a
1919 value which is larger than 64 bits, and it is stored in the stack rather than
1920 in the registers r28 and r29 or fr4.
1921 This function does the same stuff as value_being_returned in values.c, but
1922 gets the value from the stack rather than from the buffer where all the
1923 registers were saved when the function called completed. */
1925 hppa_value_returned_from_stack (valtype, addr)
1926 register struct type *valtype;
1929 register value_ptr val;
1931 val = allocate_value (valtype);
1932 CHECK_TYPEDEF (valtype);
1933 target_read_memory (addr, VALUE_CONTENTS_RAW (val), TYPE_LENGTH (valtype));
1940 /* elz: Used to lookup a symbol in the shared libraries.
1941 This function calls shl_findsym, indirectly through a
1942 call to __d_shl_get. __d_shl_get is in end.c, which is always
1943 linked in by the hp compilers/linkers.
1944 The call to shl_findsym cannot be made directly because it needs
1945 to be active in target address space.
1946 inputs: - minimal symbol pointer for the function we want to look up
1947 - address in target space of the descriptor for the library
1948 where we want to look the symbol up.
1949 This address is retrieved using the
1950 som_solib_get_solib_by_pc function (somsolib.c).
1951 output: - real address in the library of the function.
1952 note: the handle can be null, in which case shl_findsym will look for
1953 the symbol in all the loaded shared libraries.
1954 files to look at if you need reference on this stuff:
1955 dld.c, dld_shl_findsym.c
1957 man entry for shl_findsym */
1960 find_stub_with_shl_get (function, handle)
1961 struct minimal_symbol *function;
1964 struct symbol *get_sym, *symbol2;
1965 struct minimal_symbol *buff_minsym, *msymbol;
1968 value_ptr funcval, val;
1970 int x, namelen, err_value, tmp = -1;
1971 CORE_ADDR endo_buff_addr, value_return_addr, errno_return_addr;
1972 CORE_ADDR stub_addr;
1975 args = (value_ptr *) alloca (sizeof (value_ptr) * 8); /* 6 for the arguments and one null one??? */
1976 funcval = find_function_in_inferior ("__d_shl_get");
1977 get_sym = lookup_symbol ("__d_shl_get", NULL, VAR_NAMESPACE, NULL, NULL);
1978 buff_minsym = lookup_minimal_symbol ("__buffer", NULL, NULL);
1979 msymbol = lookup_minimal_symbol ("__shldp", NULL, NULL);
1980 symbol2 = lookup_symbol ("__shldp", NULL, VAR_NAMESPACE, NULL, NULL);
1981 endo_buff_addr = SYMBOL_VALUE_ADDRESS (buff_minsym);
1982 namelen = strlen (SYMBOL_NAME (function));
1983 value_return_addr = endo_buff_addr + namelen;
1984 ftype = check_typedef (SYMBOL_TYPE (get_sym));
1987 if ((x = value_return_addr % 64) != 0)
1988 value_return_addr = value_return_addr + 64 - x;
1990 errno_return_addr = value_return_addr + 64;
1993 /* set up stuff needed by __d_shl_get in buffer in end.o */
1995 target_write_memory (endo_buff_addr, SYMBOL_NAME (function), namelen);
1997 target_write_memory (value_return_addr, (char *) &tmp, 4);
1999 target_write_memory (errno_return_addr, (char *) &tmp, 4);
2001 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
2002 (char *) &handle, 4);
2004 /* now prepare the arguments for the call */
2006 args[0] = value_from_longest (TYPE_FIELD_TYPE (ftype, 0), 12);
2007 args[1] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 1), SYMBOL_VALUE_ADDRESS (msymbol));
2008 args[2] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 2), endo_buff_addr);
2009 args[3] = value_from_longest (TYPE_FIELD_TYPE (ftype, 3), TYPE_PROCEDURE);
2010 args[4] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 4), value_return_addr);
2011 args[5] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 5), errno_return_addr);
2013 /* now call the function */
2015 val = call_function_by_hand (funcval, 6, args);
2017 /* now get the results */
2019 target_read_memory (errno_return_addr, (char *) &err_value, sizeof (err_value));
2021 target_read_memory (value_return_addr, (char *) &stub_addr, sizeof (stub_addr));
2023 error ("call to __d_shl_get failed, error code is %d", err_value);
2028 /* Cover routine for find_stub_with_shl_get to pass to catch_errors */
2030 cover_find_stub_with_shl_get (PTR args_untyped)
2032 args_for_find_stub *args = args_untyped;
2033 args->return_val = find_stub_with_shl_get (args->msym, args->solib_handle);
2037 /* Insert the specified number of args and function address
2038 into a call sequence of the above form stored at DUMMYNAME.
2040 On the hppa we need to call the stack dummy through $$dyncall.
2041 Therefore our version of FIX_CALL_DUMMY takes an extra argument,
2042 real_pc, which is the location where gdb should start up the
2043 inferior to do the function call.
2045 This has to work across several versions of hpux, bsd, osf1. It has to
2046 work regardless of what compiler was used to build the inferior program.
2047 It should work regardless of whether or not end.o is available. It has
2048 to work even if gdb can not call into the dynamic loader in the inferior
2049 to query it for symbol names and addresses.
2051 Yes, all those cases should work. Luckily code exists to handle most
2052 of them. The complexity is in selecting exactly what scheme should
2053 be used to perform the inferior call.
2055 At the current time this routine is known not to handle cases where
2056 the program was linked with HP's compiler without including end.o.
2058 Please contact Jeff Law (law@cygnus.com) before changing this code. */
2061 hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
2070 CORE_ADDR dyncall_addr;
2071 struct minimal_symbol *msymbol;
2072 struct minimal_symbol *trampoline;
2073 int flags = read_register (FLAGS_REGNUM);
2074 struct unwind_table_entry *u = NULL;
2075 CORE_ADDR new_stub = 0;
2076 CORE_ADDR solib_handle = 0;
2078 /* Nonzero if we will use GCC's PLT call routine. This routine must be
2079 passed an import stub, not a PLABEL. It is also necessary to set %r19
2080 (the PIC register) before performing the call.
2082 If zero, then we are using __d_plt_call (HP's PLT call routine) or we
2083 are calling the target directly. When using __d_plt_call we want to
2084 use a PLABEL instead of an import stub. */
2085 int using_gcc_plt_call = 1;
2087 #ifdef GDB_TARGET_IS_HPPA_20W
2088 /* We currently use completely different code for the PA2.0W inferior
2089 function call sequences. This needs to be cleaned up. */
2091 CORE_ADDR pcsqh, pcsqt, pcoqh, pcoqt, sr5;
2092 struct target_waitstatus w;
2096 struct objfile *objfile;
2098 /* We can not modify the PC space queues directly, so we start
2099 up the inferior and execute a couple instructions to set the
2100 space queues so that they point to the call dummy in the stack. */
2101 pcsqh = read_register (PCSQ_HEAD_REGNUM);
2102 sr5 = read_register (SR5_REGNUM);
2105 pcoqh = read_register (PCOQ_HEAD_REGNUM);
2106 pcoqt = read_register (PCOQ_TAIL_REGNUM);
2107 if (target_read_memory (pcoqh, buf, 4) != 0)
2108 error ("Couldn't modify space queue\n");
2109 inst1 = extract_unsigned_integer (buf, 4);
2111 if (target_read_memory (pcoqt, buf, 4) != 0)
2112 error ("Couldn't modify space queue\n");
2113 inst2 = extract_unsigned_integer (buf, 4);
2116 *((int *) buf) = 0xe820d000;
2117 if (target_write_memory (pcoqh, buf, 4) != 0)
2118 error ("Couldn't modify space queue\n");
2121 *((int *) buf) = 0x08000240;
2122 if (target_write_memory (pcoqt, buf, 4) != 0)
2124 *((int *) buf) = inst1;
2125 target_write_memory (pcoqh, buf, 4);
2126 error ("Couldn't modify space queue\n");
2129 write_register (1, pc);
2131 /* Single step twice, the BVE instruction will set the space queue
2132 such that it points to the PC value written immediately above
2133 (ie the call dummy). */
2135 target_wait (inferior_pid, &w);
2137 target_wait (inferior_pid, &w);
2139 /* Restore the two instructions at the old PC locations. */
2140 *((int *) buf) = inst1;
2141 target_write_memory (pcoqh, buf, 4);
2142 *((int *) buf) = inst2;
2143 target_write_memory (pcoqt, buf, 4);
2146 /* The call dummy wants the ultimate destination address initially
2148 write_register (5, fun);
2150 /* We need to see if this objfile has a different DP value than our
2151 own (it could be a shared library for example). */
2152 ALL_OBJFILES (objfile)
2154 struct obj_section *s;
2155 obj_private_data_t *obj_private;
2157 /* See if FUN is in any section within this shared library. */
2158 for (s = objfile->sections; s < objfile->sections_end; s++)
2159 if (s->addr <= fun && fun < s->endaddr)
2162 if (s >= objfile->sections_end)
2165 obj_private = (obj_private_data_t *) objfile->obj_private;
2167 /* The DP value may be different for each objfile. But within an
2168 objfile each function uses the same dp value. Thus we do not need
2169 to grope around the opd section looking for dp values.
2171 ?!? This is not strictly correct since we may be in a shared library
2172 and want to call back into the main program. To make that case
2173 work correctly we need to set obj_private->dp for the main program's
2174 objfile, then remove this conditional. */
2175 if (obj_private->dp)
2176 write_register (27, obj_private->dp);
2183 #ifndef GDB_TARGET_IS_HPPA_20W
2184 /* Prefer __gcc_plt_call over the HP supplied routine because
2185 __gcc_plt_call works for any number of arguments. */
2187 if (lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL) == NULL)
2188 using_gcc_plt_call = 0;
2190 msymbol = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
2191 if (msymbol == NULL)
2192 error ("Can't find an address for $$dyncall trampoline");
2194 dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
2196 /* FUN could be a procedure label, in which case we have to get
2197 its real address and the value of its GOT/DP if we plan to
2198 call the routine via gcc_plt_call. */
2199 if ((fun & 0x2) && using_gcc_plt_call)
2201 /* Get the GOT/DP value for the target function. It's
2202 at *(fun+4). Note the call dummy is *NOT* allowed to
2203 trash %r19 before calling the target function. */
2204 write_register (19, read_memory_integer ((fun & ~0x3) + 4,
2207 /* Now get the real address for the function we are calling, it's
2209 fun = (CORE_ADDR) read_memory_integer (fun & ~0x3,
2210 TARGET_PTR_BIT / 8);
2215 #ifndef GDB_TARGET_IS_PA_ELF
2216 /* FUN could be an export stub, the real address of a function, or
2217 a PLABEL. When using gcc's PLT call routine we must call an import
2218 stub rather than the export stub or real function for lazy binding
2221 /* If we are using the gcc PLT call routine, then we need to
2222 get the import stub for the target function. */
2223 if (using_gcc_plt_call && som_solib_get_got_by_pc (fun))
2225 struct objfile *objfile;
2226 struct minimal_symbol *funsymbol, *stub_symbol;
2227 CORE_ADDR newfun = 0;
2229 funsymbol = lookup_minimal_symbol_by_pc (fun);
2231 error ("Unable to find minimal symbol for target function.\n");
2233 /* Search all the object files for an import symbol with the
2235 ALL_OBJFILES (objfile)
2238 = lookup_minimal_symbol_solib_trampoline
2239 (SYMBOL_NAME (funsymbol), NULL, objfile);
2242 stub_symbol = lookup_minimal_symbol (SYMBOL_NAME (funsymbol),
2245 /* Found a symbol with the right name. */
2248 struct unwind_table_entry *u;
2249 /* It must be a shared library trampoline. */
2250 if (MSYMBOL_TYPE (stub_symbol) != mst_solib_trampoline)
2253 /* It must also be an import stub. */
2254 u = find_unwind_entry (SYMBOL_VALUE (stub_symbol));
2256 || (u->stub_unwind.stub_type != IMPORT
2257 #ifdef GDB_NATIVE_HPUX_11
2258 /* Sigh. The hpux 10.20 dynamic linker will blow
2259 chunks if we perform a call to an unbound function
2260 via the IMPORT_SHLIB stub. The hpux 11.00 dynamic
2261 linker will blow chunks if we do not call the
2262 unbound function via the IMPORT_SHLIB stub.
2264 We currently have no way to select bevahior on just
2265 the target. However, we only support HPUX/SOM in
2266 native mode. So we conditinalize on a native
2267 #ifdef. Ugly. Ugly. Ugly */
2268 && u->stub_unwind.stub_type != IMPORT_SHLIB
2273 /* OK. Looks like the correct import stub. */
2274 newfun = SYMBOL_VALUE (stub_symbol);
2277 /* If we found an IMPORT stub, then we want to stop
2278 searching now. If we found an IMPORT_SHLIB, we want
2279 to continue the search in the hopes that we will find
2281 if (u->stub_unwind.stub_type == IMPORT)
2286 /* Ouch. We did not find an import stub. Make an attempt to
2287 do the right thing instead of just croaking. Most of the
2288 time this will actually work. */
2290 write_register (19, som_solib_get_got_by_pc (fun));
2292 u = find_unwind_entry (fun);
2294 && (u->stub_unwind.stub_type == IMPORT
2295 || u->stub_unwind.stub_type == IMPORT_SHLIB))
2296 trampoline = lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL);
2298 /* If we found the import stub in the shared library, then we have
2299 to set %r19 before we call the stub. */
2300 if (u && u->stub_unwind.stub_type == IMPORT_SHLIB)
2301 write_register (19, som_solib_get_got_by_pc (fun));
2306 /* If we are calling into another load module then have sr4export call the
2307 magic __d_plt_call routine which is linked in from end.o.
2309 You can't use _sr4export to make the call as the value in sp-24 will get
2310 fried and you end up returning to the wrong location. You can't call the
2311 target as the code to bind the PLT entry to a function can't return to a
2314 Also, query the dynamic linker in the inferior to provide a suitable
2315 PLABEL for the target function. */
2316 if (!using_gcc_plt_call)
2320 /* Get a handle for the shared library containing FUN. Given the
2321 handle we can query the shared library for a PLABEL. */
2322 solib_handle = som_solib_get_solib_by_pc (fun);
2326 struct minimal_symbol *fmsymbol = lookup_minimal_symbol_by_pc (fun);
2328 trampoline = lookup_minimal_symbol ("__d_plt_call", NULL, NULL);
2330 if (trampoline == NULL)
2332 error ("Can't find an address for __d_plt_call or __gcc_plt_call trampoline\nSuggest linking executable with -g or compiling with gcc.");
2335 /* This is where sr4export will jump to. */
2336 new_fun = SYMBOL_VALUE_ADDRESS (trampoline);
2338 /* If the function is in a shared library, then call __d_shl_get to
2339 get a PLABEL for the target function. */
2340 new_stub = find_stub_with_shl_get (fmsymbol, solib_handle);
2343 error ("Can't find an import stub for %s", SYMBOL_NAME (fmsymbol));
2345 /* We have to store the address of the stub in __shlib_funcptr. */
2346 msymbol = lookup_minimal_symbol ("__shlib_funcptr", NULL,
2347 (struct objfile *) NULL);
2349 if (msymbol == NULL)
2350 error ("Can't find an address for __shlib_funcptr");
2351 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
2352 (char *) &new_stub, 4);
2354 /* We want sr4export to call __d_plt_call, so we claim it is
2355 the final target. Clear trampoline. */
2361 /* Store upper 21 bits of function address into ldil. fun will either be
2362 the final target (most cases) or __d_plt_call when calling into a shared
2363 library and __gcc_plt_call is not available. */
2364 store_unsigned_integer
2365 (&dummy[FUNC_LDIL_OFFSET],
2367 deposit_21 (fun >> 11,
2368 extract_unsigned_integer (&dummy[FUNC_LDIL_OFFSET],
2369 INSTRUCTION_SIZE)));
2371 /* Store lower 11 bits of function address into ldo */
2372 store_unsigned_integer
2373 (&dummy[FUNC_LDO_OFFSET],
2375 deposit_14 (fun & MASK_11,
2376 extract_unsigned_integer (&dummy[FUNC_LDO_OFFSET],
2377 INSTRUCTION_SIZE)));
2378 #ifdef SR4EXPORT_LDIL_OFFSET
2381 CORE_ADDR trampoline_addr;
2383 /* We may still need sr4export's address too. */
2385 if (trampoline == NULL)
2387 msymbol = lookup_minimal_symbol ("_sr4export", NULL, NULL);
2388 if (msymbol == NULL)
2389 error ("Can't find an address for _sr4export trampoline");
2391 trampoline_addr = SYMBOL_VALUE_ADDRESS (msymbol);
2394 trampoline_addr = SYMBOL_VALUE_ADDRESS (trampoline);
2397 /* Store upper 21 bits of trampoline's address into ldil */
2398 store_unsigned_integer
2399 (&dummy[SR4EXPORT_LDIL_OFFSET],
2401 deposit_21 (trampoline_addr >> 11,
2402 extract_unsigned_integer (&dummy[SR4EXPORT_LDIL_OFFSET],
2403 INSTRUCTION_SIZE)));
2405 /* Store lower 11 bits of trampoline's address into ldo */
2406 store_unsigned_integer
2407 (&dummy[SR4EXPORT_LDO_OFFSET],
2409 deposit_14 (trampoline_addr & MASK_11,
2410 extract_unsigned_integer (&dummy[SR4EXPORT_LDO_OFFSET],
2411 INSTRUCTION_SIZE)));
2415 write_register (22, pc);
2417 /* If we are in a syscall, then we should call the stack dummy
2418 directly. $$dyncall is not needed as the kernel sets up the
2419 space id registers properly based on the value in %r31. In
2420 fact calling $$dyncall will not work because the value in %r22
2421 will be clobbered on the syscall exit path.
2423 Similarly if the current PC is in a shared library. Note however,
2424 this scheme won't work if the shared library isn't mapped into
2425 the same space as the stack. */
2428 #ifndef GDB_TARGET_IS_PA_ELF
2429 else if (som_solib_get_got_by_pc (target_read_pc (inferior_pid)))
2433 return dyncall_addr;
2440 /* If the pid is in a syscall, then the FP register is not readable.
2441 We'll return zero in that case, rather than attempting to read it
2442 and cause a warning. */
2444 target_read_fp (pid)
2447 int flags = read_register (FLAGS_REGNUM);
2451 return (CORE_ADDR) 0;
2454 /* This is the only site that may directly read_register () the FP
2455 register. All others must use TARGET_READ_FP (). */
2456 return read_register (FP_REGNUM);
2460 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
2464 target_read_pc (pid)
2467 int flags = read_register_pid (FLAGS_REGNUM, pid);
2469 /* The following test does not belong here. It is OS-specific, and belongs
2471 /* Test SS_INSYSCALL */
2473 return read_register_pid (31, pid) & ~0x3;
2475 return read_register_pid (PC_REGNUM, pid) & ~0x3;
2478 /* Write out the PC. If currently in a syscall, then also write the new
2479 PC value into %r31. */
2482 target_write_pc (v, pid)
2486 int flags = read_register_pid (FLAGS_REGNUM, pid);
2488 /* The following test does not belong here. It is OS-specific, and belongs
2490 /* If in a syscall, then set %r31. Also make sure to get the
2491 privilege bits set correctly. */
2492 /* Test SS_INSYSCALL */
2494 write_register_pid (31, v | 0x3, pid);
2496 write_register_pid (PC_REGNUM, v, pid);
2497 write_register_pid (NPC_REGNUM, v + 4, pid);
2500 /* return the alignment of a type in bytes. Structures have the maximum
2501 alignment required by their fields. */
2507 int max_align, align, i;
2508 CHECK_TYPEDEF (type);
2509 switch (TYPE_CODE (type))
2514 return TYPE_LENGTH (type);
2515 case TYPE_CODE_ARRAY:
2516 return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
2517 case TYPE_CODE_STRUCT:
2518 case TYPE_CODE_UNION:
2520 for (i = 0; i < TYPE_NFIELDS (type); i++)
2522 /* Bit fields have no real alignment. */
2523 /* if (!TYPE_FIELD_BITPOS (type, i)) */
2524 if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
2526 align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
2527 max_align = max (max_align, align);
2536 /* Print the register regnum, or all registers if regnum is -1 */
2539 pa_do_registers_info (regnum, fpregs)
2543 char raw_regs[REGISTER_BYTES];
2546 /* Make a copy of gdb's save area (may cause actual
2547 reads from the target). */
2548 for (i = 0; i < NUM_REGS; i++)
2549 read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
2552 pa_print_registers (raw_regs, regnum, fpregs);
2553 else if (regnum < FP4_REGNUM)
2557 /* Why is the value not passed through "extract_signed_integer"
2558 as in "pa_print_registers" below? */
2559 pa_register_look_aside (raw_regs, regnum, ®_val[0]);
2563 printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
2567 /* Fancy % formats to prevent leading zeros. */
2568 if (reg_val[0] == 0)
2569 printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
2571 printf_unfiltered ("%s %x%8.8x\n", REGISTER_NAME (regnum),
2572 reg_val[0], reg_val[1]);
2576 /* Note that real floating point values only start at
2577 FP4_REGNUM. FP0 and up are just status and error
2578 registers, which have integral (bit) values. */
2579 pa_print_fp_reg (regnum);
2582 /********** new function ********************/
2584 pa_do_strcat_registers_info (regnum, fpregs, stream, precision)
2587 struct ui_file *stream;
2588 enum precision_type precision;
2590 char raw_regs[REGISTER_BYTES];
2593 /* Make a copy of gdb's save area (may cause actual
2594 reads from the target). */
2595 for (i = 0; i < NUM_REGS; i++)
2596 read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
2599 pa_strcat_registers (raw_regs, regnum, fpregs, stream);
2601 else if (regnum < FP4_REGNUM)
2605 /* Why is the value not passed through "extract_signed_integer"
2606 as in "pa_print_registers" below? */
2607 pa_register_look_aside (raw_regs, regnum, ®_val[0]);
2611 fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum), reg_val[1]);
2615 /* Fancy % formats to prevent leading zeros. */
2616 if (reg_val[0] == 0)
2617 fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum),
2620 fprintf_unfiltered (stream, "%s %x%8.8x", REGISTER_NAME (regnum),
2621 reg_val[0], reg_val[1]);
2625 /* Note that real floating point values only start at
2626 FP4_REGNUM. FP0 and up are just status and error
2627 registers, which have integral (bit) values. */
2628 pa_strcat_fp_reg (regnum, stream, precision);
2631 /* If this is a PA2.0 machine, fetch the real 64-bit register
2632 value. Otherwise use the info from gdb's saved register area.
2634 Note that reg_val is really expected to be an array of longs,
2635 with two elements. */
2637 pa_register_look_aside (raw_regs, regnum, raw_val)
2642 static int know_which = 0; /* False */
2645 unsigned int offset;
2650 char buf[MAX_REGISTER_RAW_SIZE];
2655 if (CPU_PA_RISC2_0 == sysconf (_SC_CPU_VERSION))
2660 know_which = 1; /* True */
2668 raw_val[1] = *(long *) (raw_regs + REGISTER_BYTE (regnum));
2672 /* Code below copied from hppah-nat.c, with fixes for wide
2673 registers, using different area of save_state, etc. */
2674 if (regnum == FLAGS_REGNUM || regnum >= FP0_REGNUM ||
2675 !HAVE_STRUCT_SAVE_STATE_T || !HAVE_STRUCT_MEMBER_SS_WIDE)
2677 /* Use narrow regs area of save_state and default macro. */
2678 offset = U_REGS_OFFSET;
2679 regaddr = register_addr (regnum, offset);
2684 /* Use wide regs area, and calculate registers as 8 bytes wide.
2686 We'd like to do this, but current version of "C" doesn't
2689 offset = offsetof(save_state_t, ss_wide);
2691 Note that to avoid "C" doing typed pointer arithmetic, we
2692 have to cast away the type in our offset calculation:
2693 otherwise we get an offset of 1! */
2695 /* NB: save_state_t is not available before HPUX 9.
2696 The ss_wide field is not available previous to HPUX 10.20,
2697 so to avoid compile-time warnings, we only compile this for
2698 PA 2.0 processors. This control path should only be followed
2699 if we're debugging a PA 2.0 processor, so this should not cause
2702 /* #if the following code out so that this file can still be
2703 compiled on older HPUX boxes (< 10.20) which don't have
2704 this structure/structure member. */
2705 #if HAVE_STRUCT_SAVE_STATE_T == 1 && HAVE_STRUCT_MEMBER_SS_WIDE == 1
2708 offset = ((int) &temp.ss_wide) - ((int) &temp);
2709 regaddr = offset + regnum * 8;
2714 for (i = start; i < 2; i++)
2717 raw_val[i] = call_ptrace (PT_RUREGS, inferior_pid,
2718 (PTRACE_ARG3_TYPE) regaddr, 0);
2721 /* Warning, not error, in case we are attached; sometimes the
2722 kernel doesn't let us at the registers. */
2723 char *err = safe_strerror (errno);
2724 char *msg = alloca (strlen (err) + 128);
2725 sprintf (msg, "reading register %s: %s", REGISTER_NAME (regnum), err);
2730 regaddr += sizeof (long);
2733 if (regnum == PCOQ_HEAD_REGNUM || regnum == PCOQ_TAIL_REGNUM)
2734 raw_val[1] &= ~0x3; /* I think we're masking out space bits */
2740 /* "Info all-reg" command */
2743 pa_print_registers (raw_regs, regnum, fpregs)
2749 /* Alas, we are compiled so that "long long" is 32 bits */
2752 int rows = 48, columns = 2;
2754 for (i = 0; i < rows; i++)
2756 for (j = 0; j < columns; j++)
2758 /* We display registers in column-major order. */
2759 int regnum = i + j * rows;
2761 /* Q: Why is the value passed through "extract_signed_integer",
2762 while above, in "pa_do_registers_info" it isn't?
2764 pa_register_look_aside (raw_regs, regnum, &raw_val[0]);
2766 /* Even fancier % formats to prevent leading zeros
2767 and still maintain the output in columns. */
2770 /* Being big-endian, on this machine the low bits
2771 (the ones we want to look at) are in the second longword. */
2772 long_val = extract_signed_integer (&raw_val[1], 4);
2773 printf_filtered ("%10.10s: %8x ",
2774 REGISTER_NAME (regnum), long_val);
2778 /* raw_val = extract_signed_integer(&raw_val, 8); */
2779 if (raw_val[0] == 0)
2780 printf_filtered ("%10.10s: %8x ",
2781 REGISTER_NAME (regnum), raw_val[1]);
2783 printf_filtered ("%10.10s: %8x%8.8x ",
2784 REGISTER_NAME (regnum),
2785 raw_val[0], raw_val[1]);
2788 printf_unfiltered ("\n");
2792 for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
2793 pa_print_fp_reg (i);
2796 /************* new function ******************/
2798 pa_strcat_registers (raw_regs, regnum, fpregs, stream)
2802 struct ui_file *stream;
2805 long raw_val[2]; /* Alas, we are compiled so that "long long" is 32 bits */
2807 enum precision_type precision;
2809 precision = unspecified_precision;
2811 for (i = 0; i < 18; i++)
2813 for (j = 0; j < 4; j++)
2815 /* Q: Why is the value passed through "extract_signed_integer",
2816 while above, in "pa_do_registers_info" it isn't?
2818 pa_register_look_aside (raw_regs, i + (j * 18), &raw_val[0]);
2820 /* Even fancier % formats to prevent leading zeros
2821 and still maintain the output in columns. */
2824 /* Being big-endian, on this machine the low bits
2825 (the ones we want to look at) are in the second longword. */
2826 long_val = extract_signed_integer (&raw_val[1], 4);
2827 fprintf_filtered (stream, "%8.8s: %8x ", REGISTER_NAME (i + (j * 18)), long_val);
2831 /* raw_val = extract_signed_integer(&raw_val, 8); */
2832 if (raw_val[0] == 0)
2833 fprintf_filtered (stream, "%8.8s: %8x ", REGISTER_NAME (i + (j * 18)),
2836 fprintf_filtered (stream, "%8.8s: %8x%8.8x ", REGISTER_NAME (i + (j * 18)),
2837 raw_val[0], raw_val[1]);
2840 fprintf_unfiltered (stream, "\n");
2844 for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
2845 pa_strcat_fp_reg (i, stream, precision);
2852 char raw_buffer[MAX_REGISTER_RAW_SIZE];
2853 char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
2855 /* Get 32bits of data. */
2856 read_relative_register_raw_bytes (i, raw_buffer);
2858 /* Put it in the buffer. No conversions are ever necessary. */
2859 memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
2861 fputs_filtered (REGISTER_NAME (i), gdb_stdout);
2862 print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
2863 fputs_filtered ("(single precision) ", gdb_stdout);
2865 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, gdb_stdout, 0,
2866 1, 0, Val_pretty_default);
2867 printf_filtered ("\n");
2869 /* If "i" is even, then this register can also be a double-precision
2870 FP register. Dump it out as such. */
2873 /* Get the data in raw format for the 2nd half. */
2874 read_relative_register_raw_bytes (i + 1, raw_buffer);
2876 /* Copy it into the appropriate part of the virtual buffer. */
2877 memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer,
2878 REGISTER_RAW_SIZE (i));
2880 /* Dump it as a double. */
2881 fputs_filtered (REGISTER_NAME (i), gdb_stdout);
2882 print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
2883 fputs_filtered ("(double precision) ", gdb_stdout);
2885 val_print (builtin_type_double, virtual_buffer, 0, 0, gdb_stdout, 0,
2886 1, 0, Val_pretty_default);
2887 printf_filtered ("\n");
2891 /*************** new function ***********************/
2893 pa_strcat_fp_reg (i, stream, precision)
2895 struct ui_file *stream;
2896 enum precision_type precision;
2898 char raw_buffer[MAX_REGISTER_RAW_SIZE];
2899 char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
2901 fputs_filtered (REGISTER_NAME (i), stream);
2902 print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
2904 /* Get 32bits of data. */
2905 read_relative_register_raw_bytes (i, raw_buffer);
2907 /* Put it in the buffer. No conversions are ever necessary. */
2908 memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
2910 if (precision == double_precision && (i % 2) == 0)
2913 char raw_buf[MAX_REGISTER_RAW_SIZE];
2915 /* Get the data in raw format for the 2nd half. */
2916 read_relative_register_raw_bytes (i + 1, raw_buf);
2918 /* Copy it into the appropriate part of the virtual buffer. */
2919 memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buf, REGISTER_RAW_SIZE (i));
2921 val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0,
2922 1, 0, Val_pretty_default);
2927 val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, stream, 0,
2928 1, 0, Val_pretty_default);
2933 /* Return one if PC is in the call path of a trampoline, else return zero.
2935 Note we return one for *any* call trampoline (long-call, arg-reloc), not
2936 just shared library trampolines (import, export). */
2939 in_solib_call_trampoline (pc, name)
2943 struct minimal_symbol *minsym;
2944 struct unwind_table_entry *u;
2945 static CORE_ADDR dyncall = 0;
2946 static CORE_ADDR sr4export = 0;
2948 #ifdef GDB_TARGET_IS_HPPA_20W
2949 /* PA64 has a completely different stub/trampoline scheme. Is it
2950 better? Maybe. It's certainly harder to determine with any
2951 certainty that we are in a stub because we can not refer to the
2954 The heuristic is simple. Try to lookup the current PC value in th
2955 minimal symbol table. If that fails, then assume we are not in a
2958 Then see if the PC value falls within the section bounds for the
2959 section containing the minimal symbol we found in the first
2960 step. If it does, then assume we are not in a stub and return.
2962 Finally peek at the instructions to see if they look like a stub. */
2964 struct minimal_symbol *minsym;
2969 minsym = lookup_minimal_symbol_by_pc (pc);
2973 sec = SYMBOL_BFD_SECTION (minsym);
2976 && sec->vma + sec->_cooked_size < pc)
2979 /* We might be in a stub. Peek at the instructions. Stubs are 3
2980 instructions long. */
2981 insn = read_memory_integer (pc, 4);
2983 /* Find out where we we think we are within the stub. */
2984 if ((insn & 0xffffc00e) == 0x53610000)
2986 else if ((insn & 0xffffffff) == 0xe820d000)
2988 else if ((insn & 0xffffc00e) == 0x537b0000)
2993 /* Now verify each insn in the range looks like a stub instruction. */
2994 insn = read_memory_integer (addr, 4);
2995 if ((insn & 0xffffc00e) != 0x53610000)
2998 /* Now verify each insn in the range looks like a stub instruction. */
2999 insn = read_memory_integer (addr + 4, 4);
3000 if ((insn & 0xffffffff) != 0xe820d000)
3003 /* Now verify each insn in the range looks like a stub instruction. */
3004 insn = read_memory_integer (addr + 8, 4);
3005 if ((insn & 0xffffc00e) != 0x537b0000)
3008 /* Looks like a stub. */
3013 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3016 /* First see if PC is in one of the two C-library trampolines. */
3019 minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
3021 dyncall = SYMBOL_VALUE_ADDRESS (minsym);
3028 minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
3030 sr4export = SYMBOL_VALUE_ADDRESS (minsym);
3035 if (pc == dyncall || pc == sr4export)
3038 minsym = lookup_minimal_symbol_by_pc (pc);
3039 if (minsym && strcmp (SYMBOL_NAME (minsym), ".stub") == 0)
3042 /* Get the unwind descriptor corresponding to PC, return zero
3043 if no unwind was found. */
3044 u = find_unwind_entry (pc);
3048 /* If this isn't a linker stub, then return now. */
3049 if (u->stub_unwind.stub_type == 0)
3052 /* By definition a long-branch stub is a call stub. */
3053 if (u->stub_unwind.stub_type == LONG_BRANCH)
3056 /* The call and return path execute the same instructions within
3057 an IMPORT stub! So an IMPORT stub is both a call and return
3059 if (u->stub_unwind.stub_type == IMPORT)
3062 /* Parameter relocation stubs always have a call path and may have a
3064 if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
3065 || u->stub_unwind.stub_type == EXPORT)
3069 /* Search forward from the current PC until we hit a branch
3070 or the end of the stub. */
3071 for (addr = pc; addr <= u->region_end; addr += 4)
3075 insn = read_memory_integer (addr, 4);
3077 /* Does it look like a bl? If so then it's the call path, if
3078 we find a bv or be first, then we're on the return path. */
3079 if ((insn & 0xfc00e000) == 0xe8000000)
3081 else if ((insn & 0xfc00e001) == 0xe800c000
3082 || (insn & 0xfc000000) == 0xe0000000)
3086 /* Should never happen. */
3087 warning ("Unable to find branch in parameter relocation stub.\n");
3091 /* Unknown stub type. For now, just return zero. */
3095 /* Return one if PC is in the return path of a trampoline, else return zero.
3097 Note we return one for *any* call trampoline (long-call, arg-reloc), not
3098 just shared library trampolines (import, export). */
3101 in_solib_return_trampoline (pc, name)
3105 struct unwind_table_entry *u;
3107 /* Get the unwind descriptor corresponding to PC, return zero
3108 if no unwind was found. */
3109 u = find_unwind_entry (pc);
3113 /* If this isn't a linker stub or it's just a long branch stub, then
3115 if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH)
3118 /* The call and return path execute the same instructions within
3119 an IMPORT stub! So an IMPORT stub is both a call and return
3121 if (u->stub_unwind.stub_type == IMPORT)
3124 /* Parameter relocation stubs always have a call path and may have a
3126 if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
3127 || u->stub_unwind.stub_type == EXPORT)
3131 /* Search forward from the current PC until we hit a branch
3132 or the end of the stub. */
3133 for (addr = pc; addr <= u->region_end; addr += 4)
3137 insn = read_memory_integer (addr, 4);
3139 /* Does it look like a bl? If so then it's the call path, if
3140 we find a bv or be first, then we're on the return path. */
3141 if ((insn & 0xfc00e000) == 0xe8000000)
3143 else if ((insn & 0xfc00e001) == 0xe800c000
3144 || (insn & 0xfc000000) == 0xe0000000)
3148 /* Should never happen. */
3149 warning ("Unable to find branch in parameter relocation stub.\n");
3153 /* Unknown stub type. For now, just return zero. */
3158 /* Figure out if PC is in a trampoline, and if so find out where
3159 the trampoline will jump to. If not in a trampoline, return zero.
3161 Simple code examination probably is not a good idea since the code
3162 sequences in trampolines can also appear in user code.
3164 We use unwinds and information from the minimal symbol table to
3165 determine when we're in a trampoline. This won't work for ELF
3166 (yet) since it doesn't create stub unwind entries. Whether or
3167 not ELF will create stub unwinds or normal unwinds for linker
3168 stubs is still being debated.
3170 This should handle simple calls through dyncall or sr4export,
3171 long calls, argument relocation stubs, and dyncall/sr4export
3172 calling an argument relocation stub. It even handles some stubs
3173 used in dynamic executables. */
3176 skip_trampoline_code (pc, name)
3181 long prev_inst, curr_inst, loc;
3182 static CORE_ADDR dyncall = 0;
3183 static CORE_ADDR dyncall_external = 0;
3184 static CORE_ADDR sr4export = 0;
3185 struct minimal_symbol *msym;
3186 struct unwind_table_entry *u;
3188 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3193 msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
3195 dyncall = SYMBOL_VALUE_ADDRESS (msym);
3200 if (!dyncall_external)
3202 msym = lookup_minimal_symbol ("$$dyncall_external", NULL, NULL);
3204 dyncall_external = SYMBOL_VALUE_ADDRESS (msym);
3206 dyncall_external = -1;
3211 msym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
3213 sr4export = SYMBOL_VALUE_ADDRESS (msym);
3218 /* Addresses passed to dyncall may *NOT* be the actual address
3219 of the function. So we may have to do something special. */
3222 pc = (CORE_ADDR) read_register (22);
3224 /* If bit 30 (counting from the left) is on, then pc is the address of
3225 the PLT entry for this function, not the address of the function
3226 itself. Bit 31 has meaning too, but only for MPE. */
3228 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
3230 if (pc == dyncall_external)
3232 pc = (CORE_ADDR) read_register (22);
3233 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
3235 else if (pc == sr4export)
3236 pc = (CORE_ADDR) (read_register (22));
3238 /* Get the unwind descriptor corresponding to PC, return zero
3239 if no unwind was found. */
3240 u = find_unwind_entry (pc);
3244 /* If this isn't a linker stub, then return now. */
3245 /* elz: attention here! (FIXME) because of a compiler/linker
3246 error, some stubs which should have a non zero stub_unwind.stub_type
3247 have unfortunately a value of zero. So this function would return here
3248 as if we were not in a trampoline. To fix this, we go look at the partial
3249 symbol information, which reports this guy as a stub.
3250 (FIXME): Unfortunately, we are not that lucky: it turns out that the
3251 partial symbol information is also wrong sometimes. This is because
3252 when it is entered (somread.c::som_symtab_read()) it can happen that
3253 if the type of the symbol (from the som) is Entry, and the symbol is
3254 in a shared library, then it can also be a trampoline. This would
3255 be OK, except that I believe the way they decide if we are ina shared library
3256 does not work. SOOOO..., even if we have a regular function w/o trampolines
3257 its minimal symbol can be assigned type mst_solib_trampoline.
3258 Also, if we find that the symbol is a real stub, then we fix the unwind
3259 descriptor, and define the stub type to be EXPORT.
3260 Hopefully this is correct most of the times. */
3261 if (u->stub_unwind.stub_type == 0)
3264 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
3265 we can delete all the code which appears between the lines */
3266 /*--------------------------------------------------------------------------*/
3267 msym = lookup_minimal_symbol_by_pc (pc);
3269 if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
3270 return orig_pc == pc ? 0 : pc & ~0x3;
3272 else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
3274 struct objfile *objfile;
3275 struct minimal_symbol *msymbol;
3276 int function_found = 0;
3278 /* go look if there is another minimal symbol with the same name as
3279 this one, but with type mst_text. This would happen if the msym
3280 is an actual trampoline, in which case there would be another
3281 symbol with the same name corresponding to the real function */
3283 ALL_MSYMBOLS (objfile, msymbol)
3285 if (MSYMBOL_TYPE (msymbol) == mst_text
3286 && STREQ (SYMBOL_NAME (msymbol), SYMBOL_NAME (msym)))
3294 /* the type of msym is correct (mst_solib_trampoline), but
3295 the unwind info is wrong, so set it to the correct value */
3296 u->stub_unwind.stub_type = EXPORT;
3298 /* the stub type info in the unwind is correct (this is not a
3299 trampoline), but the msym type information is wrong, it
3300 should be mst_text. So we need to fix the msym, and also
3301 get out of this function */
3303 MSYMBOL_TYPE (msym) = mst_text;
3304 return orig_pc == pc ? 0 : pc & ~0x3;
3308 /*--------------------------------------------------------------------------*/
3311 /* It's a stub. Search for a branch and figure out where it goes.
3312 Note we have to handle multi insn branch sequences like ldil;ble.
3313 Most (all?) other branches can be determined by examining the contents
3314 of certain registers and the stack. */
3321 /* Make sure we haven't walked outside the range of this stub. */
3322 if (u != find_unwind_entry (loc))
3324 warning ("Unable to find branch in linker stub");
3325 return orig_pc == pc ? 0 : pc & ~0x3;
3328 prev_inst = curr_inst;
3329 curr_inst = read_memory_integer (loc, 4);
3331 /* Does it look like a branch external using %r1? Then it's the
3332 branch from the stub to the actual function. */
3333 if ((curr_inst & 0xffe0e000) == 0xe0202000)
3335 /* Yup. See if the previous instruction loaded
3336 a value into %r1. If so compute and return the jump address. */
3337 if ((prev_inst & 0xffe00000) == 0x20200000)
3338 return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3;
3341 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
3342 return orig_pc == pc ? 0 : pc & ~0x3;
3346 /* Does it look like a be 0(sr0,%r21)? OR
3347 Does it look like a be, n 0(sr0,%r21)? OR
3348 Does it look like a bve (r21)? (this is on PA2.0)
3349 Does it look like a bve, n(r21)? (this is also on PA2.0)
3350 That's the branch from an
3351 import stub to an export stub.
3353 It is impossible to determine the target of the branch via
3354 simple examination of instructions and/or data (consider
3355 that the address in the plabel may be the address of the
3356 bind-on-reference routine in the dynamic loader).
3358 So we have try an alternative approach.
3360 Get the name of the symbol at our current location; it should
3361 be a stub symbol with the same name as the symbol in the
3364 Then lookup a minimal symbol with the same name; we should
3365 get the minimal symbol for the target routine in the shared
3366 library as those take precedence of import/export stubs. */
3367 if ((curr_inst == 0xe2a00000) ||
3368 (curr_inst == 0xe2a00002) ||
3369 (curr_inst == 0xeaa0d000) ||
3370 (curr_inst == 0xeaa0d002))
3372 struct minimal_symbol *stubsym, *libsym;
3374 stubsym = lookup_minimal_symbol_by_pc (loc);
3375 if (stubsym == NULL)
3377 warning ("Unable to find symbol for 0x%x", loc);
3378 return orig_pc == pc ? 0 : pc & ~0x3;
3381 libsym = lookup_minimal_symbol (SYMBOL_NAME (stubsym), NULL, NULL);
3384 warning ("Unable to find library symbol for %s\n",
3385 SYMBOL_NAME (stubsym));
3386 return orig_pc == pc ? 0 : pc & ~0x3;
3389 return SYMBOL_VALUE (libsym);
3392 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
3393 branch from the stub to the actual function. */
3395 else if ((curr_inst & 0xffe0e000) == 0xe8400000
3396 || (curr_inst & 0xffe0e000) == 0xe8000000
3397 || (curr_inst & 0xffe0e000) == 0xe800A000)
3398 return (loc + extract_17 (curr_inst) + 8) & ~0x3;
3400 /* Does it look like bv (rp)? Note this depends on the
3401 current stack pointer being the same as the stack
3402 pointer in the stub itself! This is a branch on from the
3403 stub back to the original caller. */
3404 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
3405 else if ((curr_inst & 0xffe0f000) == 0xe840c000)
3407 /* Yup. See if the previous instruction loaded
3409 if (prev_inst == 0x4bc23ff1)
3410 return (read_memory_integer
3411 (read_register (SP_REGNUM) - 8, 4)) & ~0x3;
3414 warning ("Unable to find restore of %%rp before bv (%%rp).");
3415 return orig_pc == pc ? 0 : pc & ~0x3;
3419 /* elz: added this case to capture the new instruction
3420 at the end of the return part of an export stub used by
3421 the PA2.0: BVE, n (rp) */
3422 else if ((curr_inst & 0xffe0f000) == 0xe840d000)
3424 return (read_memory_integer
3425 (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
3428 /* What about be,n 0(sr0,%rp)? It's just another way we return to
3429 the original caller from the stub. Used in dynamic executables. */
3430 else if (curr_inst == 0xe0400002)
3432 /* The value we jump to is sitting in sp - 24. But that's
3433 loaded several instructions before the be instruction.
3434 I guess we could check for the previous instruction being
3435 mtsp %r1,%sr0 if we want to do sanity checking. */
3436 return (read_memory_integer
3437 (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
3440 /* Haven't found the branch yet, but we're still in the stub.
3447 /* For the given instruction (INST), return any adjustment it makes
3448 to the stack pointer or zero for no adjustment.
3450 This only handles instructions commonly found in prologues. */
3453 prologue_inst_adjust_sp (inst)
3456 /* This must persist across calls. */
3457 static int save_high21;
3459 /* The most common way to perform a stack adjustment ldo X(sp),sp */
3460 if ((inst & 0xffffc000) == 0x37de0000)
3461 return extract_14 (inst);
3464 if ((inst & 0xffe00000) == 0x6fc00000)
3465 return extract_14 (inst);
3467 /* std,ma X,D(sp) */
3468 if ((inst & 0xffe00008) == 0x73c00008)
3469 return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
3471 /* addil high21,%r1; ldo low11,(%r1),%r30)
3472 save high bits in save_high21 for later use. */
3473 if ((inst & 0xffe00000) == 0x28200000)
3475 save_high21 = extract_21 (inst);
3479 if ((inst & 0xffff0000) == 0x343e0000)
3480 return save_high21 + extract_14 (inst);
3482 /* fstws as used by the HP compilers. */
3483 if ((inst & 0xffffffe0) == 0x2fd01220)
3484 return extract_5_load (inst);
3486 /* No adjustment. */
3490 /* Return nonzero if INST is a branch of some kind, else return zero. */
3523 /* Return the register number for a GR which is saved by INST or
3524 zero it INST does not save a GR. */
3527 inst_saves_gr (inst)
3530 /* Does it look like a stw? */
3531 if ((inst >> 26) == 0x1a || (inst >> 26) == 0x1b
3532 || (inst >> 26) == 0x1f
3533 || ((inst >> 26) == 0x1f
3534 && ((inst >> 6) == 0xa)))
3535 return extract_5R_store (inst);
3537 /* Does it look like a std? */
3538 if ((inst >> 26) == 0x1c
3539 || ((inst >> 26) == 0x03
3540 && ((inst >> 6) & 0xf) == 0xb))
3541 return extract_5R_store (inst);
3543 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
3544 if ((inst >> 26) == 0x1b)
3545 return extract_5R_store (inst);
3547 /* Does it look like sth or stb? HPC versions 9.0 and later use these
3549 if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18
3550 || ((inst >> 26) == 0x3
3551 && (((inst >> 6) & 0xf) == 0x8
3552 || (inst >> 6) & 0xf) == 0x9))
3553 return extract_5R_store (inst);
3558 /* Return the register number for a FR which is saved by INST or
3559 zero it INST does not save a FR.
3561 Note we only care about full 64bit register stores (that's the only
3562 kind of stores the prologue will use).
3564 FIXME: What about argument stores with the HP compiler in ANSI mode? */
3567 inst_saves_fr (inst)
3570 /* is this an FSTD ? */
3571 if ((inst & 0xfc00dfc0) == 0x2c001200)
3572 return extract_5r_store (inst);
3573 if ((inst & 0xfc000002) == 0x70000002)
3574 return extract_5R_store (inst);
3575 /* is this an FSTW ? */
3576 if ((inst & 0xfc00df80) == 0x24001200)
3577 return extract_5r_store (inst);
3578 if ((inst & 0xfc000002) == 0x7c000000)
3579 return extract_5R_store (inst);
3583 /* Advance PC across any function entry prologue instructions
3584 to reach some "real" code.
3586 Use information in the unwind table to determine what exactly should
3587 be in the prologue. */
3591 skip_prologue_hard_way (pc)
3595 CORE_ADDR orig_pc = pc;
3596 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
3597 unsigned long args_stored, status, i, restart_gr, restart_fr;
3598 struct unwind_table_entry *u;
3604 u = find_unwind_entry (pc);
3608 /* If we are not at the beginning of a function, then return now. */
3609 if ((pc & ~0x3) != u->region_start)
3612 /* This is how much of a frame adjustment we need to account for. */
3613 stack_remaining = u->Total_frame_size << 3;
3615 /* Magic register saves we want to know about. */
3616 save_rp = u->Save_RP;
3617 save_sp = u->Save_SP;
3619 /* An indication that args may be stored into the stack. Unfortunately
3620 the HPUX compilers tend to set this in cases where no args were
3624 /* Turn the Entry_GR field into a bitmask. */
3626 for (i = 3; i < u->Entry_GR + 3; i++)
3628 /* Frame pointer gets saved into a special location. */
3629 if (u->Save_SP && i == FP_REGNUM)
3632 save_gr |= (1 << i);
3634 save_gr &= ~restart_gr;
3636 /* Turn the Entry_FR field into a bitmask too. */
3638 for (i = 12; i < u->Entry_FR + 12; i++)
3639 save_fr |= (1 << i);
3640 save_fr &= ~restart_fr;
3642 /* Loop until we find everything of interest or hit a branch.
3644 For unoptimized GCC code and for any HP CC code this will never ever
3645 examine any user instructions.
3647 For optimzied GCC code we're faced with problems. GCC will schedule
3648 its prologue and make prologue instructions available for delay slot
3649 filling. The end result is user code gets mixed in with the prologue
3650 and a prologue instruction may be in the delay slot of the first branch
3653 Some unexpected things are expected with debugging optimized code, so
3654 we allow this routine to walk past user instructions in optimized
3656 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
3659 unsigned int reg_num;
3660 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
3661 unsigned long old_save_rp, old_save_sp, next_inst;
3663 /* Save copies of all the triggers so we can compare them later
3665 old_save_gr = save_gr;
3666 old_save_fr = save_fr;
3667 old_save_rp = save_rp;
3668 old_save_sp = save_sp;
3669 old_stack_remaining = stack_remaining;
3671 status = target_read_memory (pc, buf, 4);
3672 inst = extract_unsigned_integer (buf, 4);
3678 /* Note the interesting effects of this instruction. */
3679 stack_remaining -= prologue_inst_adjust_sp (inst);
3681 /* There are limited ways to store the return pointer into the
3683 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1)
3686 /* These are the only ways we save SP into the stack. At this time
3687 the HP compilers never bother to save SP into the stack. */
3688 if ((inst & 0xffffc000) == 0x6fc10000
3689 || (inst & 0xffffc00c) == 0x73c10008)
3692 /* Are we loading some register with an offset from the argument
3694 if ((inst & 0xffe00000) == 0x37a00000
3695 || (inst & 0xffffffe0) == 0x081d0240)
3701 /* Account for general and floating-point register saves. */
3702 reg_num = inst_saves_gr (inst);
3703 save_gr &= ~(1 << reg_num);
3705 /* Ugh. Also account for argument stores into the stack.
3706 Unfortunately args_stored only tells us that some arguments
3707 where stored into the stack. Not how many or what kind!
3709 This is a kludge as on the HP compiler sets this bit and it
3710 never does prologue scheduling. So once we see one, skip past
3711 all of them. We have similar code for the fp arg stores below.
3713 FIXME. Can still die if we have a mix of GR and FR argument
3715 if (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
3717 while (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
3720 status = target_read_memory (pc, buf, 4);
3721 inst = extract_unsigned_integer (buf, 4);
3724 reg_num = inst_saves_gr (inst);
3730 reg_num = inst_saves_fr (inst);
3731 save_fr &= ~(1 << reg_num);
3733 status = target_read_memory (pc + 4, buf, 4);
3734 next_inst = extract_unsigned_integer (buf, 4);
3740 /* We've got to be read to handle the ldo before the fp register
3742 if ((inst & 0xfc000000) == 0x34000000
3743 && inst_saves_fr (next_inst) >= 4
3744 && inst_saves_fr (next_inst) <= (TARGET_PTR_BIT == 64 ? 11 : 7))
3746 /* So we drop into the code below in a reasonable state. */
3747 reg_num = inst_saves_fr (next_inst);
3751 /* Ugh. Also account for argument stores into the stack.
3752 This is a kludge as on the HP compiler sets this bit and it
3753 never does prologue scheduling. So once we see one, skip past
3755 if (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
3757 while (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
3760 status = target_read_memory (pc, buf, 4);
3761 inst = extract_unsigned_integer (buf, 4);
3764 if ((inst & 0xfc000000) != 0x34000000)
3766 status = target_read_memory (pc + 4, buf, 4);
3767 next_inst = extract_unsigned_integer (buf, 4);
3770 reg_num = inst_saves_fr (next_inst);
3776 /* Quit if we hit any kind of branch. This can happen if a prologue
3777 instruction is in the delay slot of the first call/branch. */
3778 if (is_branch (inst))
3781 /* What a crock. The HP compilers set args_stored even if no
3782 arguments were stored into the stack (boo hiss). This could
3783 cause this code to then skip a bunch of user insns (up to the
3786 To combat this we try to identify when args_stored was bogusly
3787 set and clear it. We only do this when args_stored is nonzero,
3788 all other resources are accounted for, and nothing changed on
3791 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
3792 && old_save_gr == save_gr && old_save_fr == save_fr
3793 && old_save_rp == save_rp && old_save_sp == save_sp
3794 && old_stack_remaining == stack_remaining)
3801 /* We've got a tenative location for the end of the prologue. However
3802 because of limitations in the unwind descriptor mechanism we may
3803 have went too far into user code looking for the save of a register
3804 that does not exist. So, if there registers we expected to be saved
3805 but never were, mask them out and restart.
3807 This should only happen in optimized code, and should be very rare. */
3808 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
3811 restart_gr = save_gr;
3812 restart_fr = save_fr;
3820 /* Return the address of the PC after the last prologue instruction if
3821 we can determine it from the debug symbols. Else return zero. */
3827 struct symtab_and_line sal;
3828 CORE_ADDR func_addr, func_end;
3831 /* If we can not find the symbol in the partial symbol table, then
3832 there is no hope we can determine the function's start address
3834 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
3837 /* Get the line associated with FUNC_ADDR. */
3838 sal = find_pc_line (func_addr, 0);
3840 /* There are only two cases to consider. First, the end of the source line
3841 is within the function bounds. In that case we return the end of the
3842 source line. Second is the end of the source line extends beyond the
3843 bounds of the current function. We need to use the slow code to
3844 examine instructions in that case.
3846 Anything else is simply a bug elsewhere. Fixing it here is absolutely
3847 the wrong thing to do. In fact, it should be entirely possible for this
3848 function to always return zero since the slow instruction scanning code
3849 is supposed to *always* work. If it does not, then it is a bug. */
3850 if (sal.end < func_end)
3856 /* To skip prologues, I use this predicate. Returns either PC itself
3857 if the code at PC does not look like a function prologue; otherwise
3858 returns an address that (if we're lucky) follows the prologue. If
3859 LENIENT, then we must skip everything which is involved in setting
3860 up the frame (it's OK to skip more, just so long as we don't skip
3861 anything which might clobber the registers which are being saved.
3862 Currently we must not skip more on the alpha, but we might the lenient
3866 hppa_skip_prologue (pc)
3871 CORE_ADDR post_prologue_pc;
3874 /* See if we can determine the end of the prologue via the symbol table.
3875 If so, then return either PC, or the PC after the prologue, whichever
3878 post_prologue_pc = after_prologue (pc);
3880 /* If after_prologue returned a useful address, then use it. Else
3881 fall back on the instruction skipping code.
3883 Some folks have claimed this causes problems because the breakpoint
3884 may be the first instruction of the prologue. If that happens, then
3885 the instruction skipping code has a bug that needs to be fixed. */
3886 if (post_prologue_pc != 0)
3887 return max (pc, post_prologue_pc);
3889 return (skip_prologue_hard_way (pc));
3892 /* Put here the code to store, into a struct frame_saved_regs,
3893 the addresses of the saved registers of frame described by FRAME_INFO.
3894 This includes special registers such as pc and fp saved in special
3895 ways in the stack frame. sp is even more special:
3896 the address we return for it IS the sp for the next frame. */
3899 hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
3900 struct frame_info *frame_info;
3901 struct frame_saved_regs *frame_saved_regs;
3904 struct unwind_table_entry *u;
3905 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
3909 int final_iteration;
3911 /* Zero out everything. */
3912 memset (frame_saved_regs, '\0', sizeof (struct frame_saved_regs));
3914 /* Call dummy frames always look the same, so there's no need to
3915 examine the dummy code to determine locations of saved registers;
3916 instead, let find_dummy_frame_regs fill in the correct offsets
3917 for the saved registers. */
3918 if ((frame_info->pc >= frame_info->frame
3919 && frame_info->pc <= (frame_info->frame
3920 /* A call dummy is sized in words, but it is
3921 actually a series of instructions. Account
3922 for that scaling factor. */
3923 + ((REGISTER_SIZE / INSTRUCTION_SIZE)
3924 * CALL_DUMMY_LENGTH)
3925 /* Similarly we have to account for 64bit
3926 wide register saves. */
3927 + (32 * REGISTER_SIZE)
3928 /* We always consider FP regs 8 bytes long. */
3929 + (NUM_REGS - FP0_REGNUM) * 8
3930 /* Similarly we have to account for 64bit
3931 wide register saves. */
3932 + (6 * REGISTER_SIZE))))
3933 find_dummy_frame_regs (frame_info, frame_saved_regs);
3935 /* Interrupt handlers are special too. They lay out the register
3936 state in the exact same order as the register numbers in GDB. */
3937 if (pc_in_interrupt_handler (frame_info->pc))
3939 for (i = 0; i < NUM_REGS; i++)
3941 /* SP is a little special. */
3943 frame_saved_regs->regs[SP_REGNUM]
3944 = read_memory_integer (frame_info->frame + SP_REGNUM * 4,
3945 TARGET_PTR_BIT / 8);
3947 frame_saved_regs->regs[i] = frame_info->frame + i * 4;
3952 #ifdef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP
3953 /* Handle signal handler callers. */
3954 if (frame_info->signal_handler_caller)
3956 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info, frame_saved_regs);
3961 /* Get the starting address of the function referred to by the PC
3963 pc = get_pc_function_start (frame_info->pc);
3966 u = find_unwind_entry (pc);
3970 /* This is how much of a frame adjustment we need to account for. */
3971 stack_remaining = u->Total_frame_size << 3;
3973 /* Magic register saves we want to know about. */
3974 save_rp = u->Save_RP;
3975 save_sp = u->Save_SP;
3977 /* Turn the Entry_GR field into a bitmask. */
3979 for (i = 3; i < u->Entry_GR + 3; i++)
3981 /* Frame pointer gets saved into a special location. */
3982 if (u->Save_SP && i == FP_REGNUM)
3985 save_gr |= (1 << i);
3988 /* Turn the Entry_FR field into a bitmask too. */
3990 for (i = 12; i < u->Entry_FR + 12; i++)
3991 save_fr |= (1 << i);
3993 /* The frame always represents the value of %sp at entry to the
3994 current function (and is thus equivalent to the "saved" stack
3996 frame_saved_regs->regs[SP_REGNUM] = frame_info->frame;
3998 /* Loop until we find everything of interest or hit a branch.
4000 For unoptimized GCC code and for any HP CC code this will never ever
4001 examine any user instructions.
4003 For optimized GCC code we're faced with problems. GCC will schedule
4004 its prologue and make prologue instructions available for delay slot
4005 filling. The end result is user code gets mixed in with the prologue
4006 and a prologue instruction may be in the delay slot of the first branch
4009 Some unexpected things are expected with debugging optimized code, so
4010 we allow this routine to walk past user instructions in optimized
4012 final_iteration = 0;
4013 while ((save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
4014 && pc <= frame_info->pc)
4016 status = target_read_memory (pc, buf, 4);
4017 inst = extract_unsigned_integer (buf, 4);
4023 /* Note the interesting effects of this instruction. */
4024 stack_remaining -= prologue_inst_adjust_sp (inst);
4026 /* There are limited ways to store the return pointer into the
4028 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
4031 frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 20;
4033 else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
4036 frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 16;
4039 /* Note if we saved SP into the stack. This also happens to indicate
4040 the location of the saved frame pointer. */
4041 if ( (inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
4042 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
4044 frame_saved_regs->regs[FP_REGNUM] = frame_info->frame;
4048 /* Account for general and floating-point register saves. */
4049 reg = inst_saves_gr (inst);
4050 if (reg >= 3 && reg <= 18
4051 && (!u->Save_SP || reg != FP_REGNUM))
4053 save_gr &= ~(1 << reg);
4055 /* stwm with a positive displacement is a *post modify*. */
4056 if ((inst >> 26) == 0x1b
4057 && extract_14 (inst) >= 0)
4058 frame_saved_regs->regs[reg] = frame_info->frame;
4059 /* A std has explicit post_modify forms. */
4060 else if ((inst & 0xfc00000c0) == 0x70000008)
4061 frame_saved_regs->regs[reg] = frame_info->frame;
4066 if ((inst >> 26) == 0x1c)
4067 offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
4068 else if ((inst >> 26) == 0x03)
4069 offset = low_sign_extend (inst & 0x1f, 5);
4071 offset = extract_14 (inst);
4073 /* Handle code with and without frame pointers. */
4075 frame_saved_regs->regs[reg]
4076 = frame_info->frame + offset;
4078 frame_saved_regs->regs[reg]
4079 = (frame_info->frame + (u->Total_frame_size << 3)
4085 /* GCC handles callee saved FP regs a little differently.
4087 It emits an instruction to put the value of the start of
4088 the FP store area into %r1. It then uses fstds,ma with
4089 a basereg of %r1 for the stores.
4091 HP CC emits them at the current stack pointer modifying
4092 the stack pointer as it stores each register. */
4094 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
4095 if ((inst & 0xffffc000) == 0x34610000
4096 || (inst & 0xffffc000) == 0x37c10000)
4097 fp_loc = extract_14 (inst);
4099 reg = inst_saves_fr (inst);
4100 if (reg >= 12 && reg <= 21)
4102 /* Note +4 braindamage below is necessary because the FP status
4103 registers are internally 8 registers rather than the expected
4105 save_fr &= ~(1 << reg);
4108 /* 1st HP CC FP register store. After this instruction
4109 we've set enough state that the GCC and HPCC code are
4110 both handled in the same manner. */
4111 frame_saved_regs->regs[reg + FP4_REGNUM + 4] = frame_info->frame;
4116 frame_saved_regs->regs[reg + FP0_REGNUM + 4]
4117 = frame_info->frame + fp_loc;
4122 /* Quit if we hit any kind of branch the previous iteration.
4123 if (final_iteration)
4126 /* We want to look precisely one instruction beyond the branch
4127 if we have not found everything yet. */
4128 if (is_branch (inst))
4129 final_iteration = 1;
4137 /* Exception handling support for the HP-UX ANSI C++ compiler.
4138 The compiler (aCC) provides a callback for exception events;
4139 GDB can set a breakpoint on this callback and find out what
4140 exception event has occurred. */
4142 /* The name of the hook to be set to point to the callback function */
4143 static char HP_ACC_EH_notify_hook[] = "__eh_notify_hook";
4144 /* The name of the function to be used to set the hook value */
4145 static char HP_ACC_EH_set_hook_value[] = "__eh_set_hook_value";
4146 /* The name of the callback function in end.o */
4147 static char HP_ACC_EH_notify_callback[] = "__d_eh_notify_callback";
4148 /* Name of function in end.o on which a break is set (called by above) */
4149 static char HP_ACC_EH_break[] = "__d_eh_break";
4150 /* Name of flag (in end.o) that enables catching throws */
4151 static char HP_ACC_EH_catch_throw[] = "__d_eh_catch_throw";
4152 /* Name of flag (in end.o) that enables catching catching */
4153 static char HP_ACC_EH_catch_catch[] = "__d_eh_catch_catch";
4154 /* The enum used by aCC */
4162 /* Is exception-handling support available with this executable? */
4163 static int hp_cxx_exception_support = 0;
4164 /* Has the initialize function been run? */
4165 int hp_cxx_exception_support_initialized = 0;
4166 /* Similar to above, but imported from breakpoint.c -- non-target-specific */
4167 extern int exception_support_initialized;
4168 /* Address of __eh_notify_hook */
4169 static CORE_ADDR eh_notify_hook_addr = 0;
4170 /* Address of __d_eh_notify_callback */
4171 static CORE_ADDR eh_notify_callback_addr = 0;
4172 /* Address of __d_eh_break */
4173 static CORE_ADDR eh_break_addr = 0;
4174 /* Address of __d_eh_catch_catch */
4175 static CORE_ADDR eh_catch_catch_addr = 0;
4176 /* Address of __d_eh_catch_throw */
4177 static CORE_ADDR eh_catch_throw_addr = 0;
4178 /* Sal for __d_eh_break */
4179 static struct symtab_and_line *break_callback_sal = 0;
4181 /* Code in end.c expects __d_pid to be set in the inferior,
4182 otherwise __d_eh_notify_callback doesn't bother to call
4183 __d_eh_break! So we poke the pid into this symbol
4188 setup_d_pid_in_inferior ()
4191 struct minimal_symbol *msymbol;
4192 char buf[4]; /* FIXME 32x64? */
4194 /* Slam the pid of the process into __d_pid; failing is only a warning! */
4195 msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
4196 if (msymbol == NULL)
4198 warning ("Unable to find __d_pid symbol in object file.");
4199 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4203 anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
4204 store_unsigned_integer (buf, 4, inferior_pid); /* FIXME 32x64? */
4205 if (target_write_memory (anaddr, buf, 4)) /* FIXME 32x64? */
4207 warning ("Unable to write __d_pid");
4208 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4214 /* Initialize exception catchpoint support by looking for the
4215 necessary hooks/callbacks in end.o, etc., and set the hook value to
4216 point to the required debug function
4222 initialize_hp_cxx_exception_support ()
4224 struct symtabs_and_lines sals;
4225 struct cleanup *old_chain;
4226 struct cleanup *canonical_strings_chain = NULL;
4229 char *addr_end = NULL;
4230 char **canonical = (char **) NULL;
4232 struct symbol *sym = NULL;
4233 struct minimal_symbol *msym = NULL;
4234 struct objfile *objfile;
4235 asection *shlib_info;
4237 /* Detect and disallow recursion. On HP-UX with aCC, infinite
4238 recursion is a possibility because finding the hook for exception
4239 callbacks involves making a call in the inferior, which means
4240 re-inserting breakpoints which can re-invoke this code */
4242 static int recurse = 0;
4245 hp_cxx_exception_support_initialized = 0;
4246 exception_support_initialized = 0;
4250 hp_cxx_exception_support = 0;
4252 /* First check if we have seen any HP compiled objects; if not,
4253 it is very unlikely that HP's idiosyncratic callback mechanism
4254 for exception handling debug support will be available!
4255 This will percolate back up to breakpoint.c, where our callers
4256 will decide to try the g++ exception-handling support instead. */
4257 if (!hp_som_som_object_present)
4260 /* We have a SOM executable with SOM debug info; find the hooks */
4262 /* First look for the notify hook provided by aCC runtime libs */
4263 /* If we find this symbol, we conclude that the executable must
4264 have HP aCC exception support built in. If this symbol is not
4265 found, even though we're a HP SOM-SOM file, we may have been
4266 built with some other compiler (not aCC). This results percolates
4267 back up to our callers in breakpoint.c which can decide to
4268 try the g++ style of exception support instead.
4269 If this symbol is found but the other symbols we require are
4270 not found, there is something weird going on, and g++ support
4271 should *not* be tried as an alternative.
4273 ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
4274 ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
4276 /* libCsup has this hook; it'll usually be non-debuggable */
4277 msym = lookup_minimal_symbol (HP_ACC_EH_notify_hook, NULL, NULL);
4280 eh_notify_hook_addr = SYMBOL_VALUE_ADDRESS (msym);
4281 hp_cxx_exception_support = 1;
4285 warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook);
4286 warning ("Executable may not have been compiled debuggable with HP aCC.");
4287 warning ("GDB will be unable to intercept exception events.");
4288 eh_notify_hook_addr = 0;
4289 hp_cxx_exception_support = 0;
4293 /* Next look for the notify callback routine in end.o */
4294 /* This is always available in the SOM symbol dictionary if end.o is linked in */
4295 msym = lookup_minimal_symbol (HP_ACC_EH_notify_callback, NULL, NULL);
4298 eh_notify_callback_addr = SYMBOL_VALUE_ADDRESS (msym);
4299 hp_cxx_exception_support = 1;
4303 warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback);
4304 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4305 warning ("GDB will be unable to intercept exception events.");
4306 eh_notify_callback_addr = 0;
4310 #ifndef GDB_TARGET_IS_HPPA_20W
4311 /* Check whether the executable is dynamically linked or archive bound */
4312 /* With an archive-bound executable we can use the raw addresses we find
4313 for the callback function, etc. without modification. For an executable
4314 with shared libraries, we have to do more work to find the plabel, which
4315 can be the target of a call through $$dyncall from the aCC runtime support
4316 library (libCsup) which is linked shared by default by aCC. */
4317 /* This test below was copied from somsolib.c/somread.c. It may not be a very
4318 reliable one to test that an executable is linked shared. pai/1997-07-18 */
4319 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
4320 if (shlib_info && (bfd_section_size (symfile_objfile->obfd, shlib_info) != 0))
4322 /* The minsym we have has the local code address, but that's not the
4323 plabel that can be used by an inter-load-module call. */
4324 /* Find solib handle for main image (which has end.o), and use that
4325 and the min sym as arguments to __d_shl_get() (which does the equivalent
4326 of shl_findsym()) to find the plabel. */
4328 args_for_find_stub args;
4329 static char message[] = "Error while finding exception callback hook:\n";
4331 args.solib_handle = som_solib_get_solib_by_pc (eh_notify_callback_addr);
4333 args.return_val = 0;
4336 catch_errors (cover_find_stub_with_shl_get, (PTR) &args, message,
4338 eh_notify_callback_addr = args.return_val;
4341 exception_catchpoints_are_fragile = 1;
4343 if (!eh_notify_callback_addr)
4345 /* We can get here either if there is no plabel in the export list
4346 for the main image, or if something strange happened (??) */
4347 warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
4348 warning ("GDB will not be able to intercept exception events.");
4353 exception_catchpoints_are_fragile = 0;
4356 /* Now, look for the breakpointable routine in end.o */
4357 /* This should also be available in the SOM symbol dict. if end.o linked in */
4358 msym = lookup_minimal_symbol (HP_ACC_EH_break, NULL, NULL);
4361 eh_break_addr = SYMBOL_VALUE_ADDRESS (msym);
4362 hp_cxx_exception_support = 1;
4366 warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break);
4367 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4368 warning ("GDB will be unable to intercept exception events.");
4373 /* Next look for the catch enable flag provided in end.o */
4374 sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
4375 VAR_NAMESPACE, 0, (struct symtab **) NULL);
4376 if (sym) /* sometimes present in debug info */
4378 eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (sym);
4379 hp_cxx_exception_support = 1;
4382 /* otherwise look in SOM symbol dict. */
4384 msym = lookup_minimal_symbol (HP_ACC_EH_catch_catch, NULL, NULL);
4387 eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (msym);
4388 hp_cxx_exception_support = 1;
4392 warning ("Unable to enable interception of exception catches.");
4393 warning ("Executable may not have been compiled debuggable with HP aCC.");
4394 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4399 /* Next look for the catch enable flag provided end.o */
4400 sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
4401 VAR_NAMESPACE, 0, (struct symtab **) NULL);
4402 if (sym) /* sometimes present in debug info */
4404 eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (sym);
4405 hp_cxx_exception_support = 1;
4408 /* otherwise look in SOM symbol dict. */
4410 msym = lookup_minimal_symbol (HP_ACC_EH_catch_throw, NULL, NULL);
4413 eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (msym);
4414 hp_cxx_exception_support = 1;
4418 warning ("Unable to enable interception of exception throws.");
4419 warning ("Executable may not have been compiled debuggable with HP aCC.");
4420 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
4426 hp_cxx_exception_support = 2; /* everything worked so far */
4427 hp_cxx_exception_support_initialized = 1;
4428 exception_support_initialized = 1;
4433 /* Target operation for enabling or disabling interception of
4435 KIND is either EX_EVENT_THROW or EX_EVENT_CATCH
4436 ENABLE is either 0 (disable) or 1 (enable).
4437 Return value is NULL if no support found;
4438 -1 if something went wrong,
4439 or a pointer to a symtab/line struct if the breakpointable
4440 address was found. */
4442 struct symtab_and_line *
4443 child_enable_exception_callback (kind, enable)
4444 enum exception_event_kind kind;
4449 if (!exception_support_initialized || !hp_cxx_exception_support_initialized)
4450 if (!initialize_hp_cxx_exception_support ())
4453 switch (hp_cxx_exception_support)
4456 /* Assuming no HP support at all */
4459 /* HP support should be present, but something went wrong */
4460 return (struct symtab_and_line *) -1; /* yuck! */
4461 /* there may be other cases in the future */
4464 /* Set the EH hook to point to the callback routine */
4465 store_unsigned_integer (buf, 4, enable ? eh_notify_callback_addr : 0); /* FIXME 32x64 problem */
4466 /* pai: (temp) FIXME should there be a pack operation first? */
4467 if (target_write_memory (eh_notify_hook_addr, buf, 4)) /* FIXME 32x64 problem */
4469 warning ("Could not write to target memory for exception event callback.");
4470 warning ("Interception of exception events may not work.");
4471 return (struct symtab_and_line *) -1;
4475 /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
4476 if (inferior_pid > 0)
4478 if (setup_d_pid_in_inferior ())
4479 return (struct symtab_and_line *) -1;
4483 warning ("Internal error: Invalid inferior pid? Cannot intercept exception events.");
4484 return (struct symtab_and_line *) -1;
4490 case EX_EVENT_THROW:
4491 store_unsigned_integer (buf, 4, enable ? 1 : 0);
4492 if (target_write_memory (eh_catch_throw_addr, buf, 4)) /* FIXME 32x64? */
4494 warning ("Couldn't enable exception throw interception.");
4495 return (struct symtab_and_line *) -1;
4498 case EX_EVENT_CATCH:
4499 store_unsigned_integer (buf, 4, enable ? 1 : 0);
4500 if (target_write_memory (eh_catch_catch_addr, buf, 4)) /* FIXME 32x64? */
4502 warning ("Couldn't enable exception catch interception.");
4503 return (struct symtab_and_line *) -1;
4507 error ("Request to enable unknown or unsupported exception event.");
4510 /* Copy break address into new sal struct, malloc'ing if needed. */
4511 if (!break_callback_sal)
4513 break_callback_sal = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
4515 INIT_SAL (break_callback_sal);
4516 break_callback_sal->symtab = NULL;
4517 break_callback_sal->pc = eh_break_addr;
4518 break_callback_sal->line = 0;
4519 break_callback_sal->end = eh_break_addr;
4521 return break_callback_sal;
4524 /* Record some information about the current exception event */
4525 static struct exception_event_record current_ex_event;
4526 /* Convenience struct */
4527 static struct symtab_and_line null_symtab_and_line =
4530 /* Report current exception event. Returns a pointer to a record
4531 that describes the kind of the event, where it was thrown from,
4532 and where it will be caught. More information may be reported
4534 struct exception_event_record *
4535 child_get_current_exception_event ()
4537 CORE_ADDR event_kind;
4538 CORE_ADDR throw_addr;
4539 CORE_ADDR catch_addr;
4540 struct frame_info *fi, *curr_frame;
4543 curr_frame = get_current_frame ();
4545 return (struct exception_event_record *) NULL;
4547 /* Go up one frame to __d_eh_notify_callback, because at the
4548 point when this code is executed, there's garbage in the
4549 arguments of __d_eh_break. */
4550 fi = find_relative_frame (curr_frame, &level);
4552 return (struct exception_event_record *) NULL;
4554 select_frame (fi, -1);
4556 /* Read in the arguments */
4557 /* __d_eh_notify_callback() is called with 3 arguments:
4558 1. event kind catch or throw
4559 2. the target address if known
4560 3. a flag -- not sure what this is. pai/1997-07-17 */
4561 event_kind = read_register (ARG0_REGNUM);
4562 catch_addr = read_register (ARG1_REGNUM);
4564 /* Now go down to a user frame */
4565 /* For a throw, __d_eh_break is called by
4566 __d_eh_notify_callback which is called by
4567 __notify_throw which is called
4569 For a catch, __d_eh_break is called by
4570 __d_eh_notify_callback which is called by
4571 <stackwalking stuff> which is called by
4572 __throw__<stuff> or __rethrow_<stuff> which is called
4574 /* FIXME: Don't use such magic numbers; search for the frames */
4575 level = (event_kind == EX_EVENT_THROW) ? 3 : 4;
4576 fi = find_relative_frame (curr_frame, &level);
4578 return (struct exception_event_record *) NULL;
4580 select_frame (fi, -1);
4581 throw_addr = fi->pc;
4583 /* Go back to original (top) frame */
4584 select_frame (curr_frame, -1);
4586 current_ex_event.kind = (enum exception_event_kind) event_kind;
4587 current_ex_event.throw_sal = find_pc_line (throw_addr, 1);
4588 current_ex_event.catch_sal = find_pc_line (catch_addr, 1);
4590 return ¤t_ex_event;
4594 unwind_command (exp, from_tty)
4599 struct unwind_table_entry *u;
4601 /* If we have an expression, evaluate it and use it as the address. */
4603 if (exp != 0 && *exp != 0)
4604 address = parse_and_eval_address (exp);
4608 u = find_unwind_entry (address);
4612 printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
4616 printf_unfiltered ("unwind_table_entry (0x%x):\n", u);
4618 printf_unfiltered ("\tregion_start = ");
4619 print_address (u->region_start, gdb_stdout);
4621 printf_unfiltered ("\n\tregion_end = ");
4622 print_address (u->region_end, gdb_stdout);
4625 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
4627 #define pif(FLD) if (u->FLD) printf_unfiltered (" FLD");
4630 printf_unfiltered ("\n\tflags =");
4631 pif (Cannot_unwind);
4633 pif (Millicode_save_sr0);
4636 pif (Variable_Frame);
4637 pif (Separate_Package_Body);
4638 pif (Frame_Extension_Millicode);
4639 pif (Stack_Overflow_Check);
4640 pif (Two_Instruction_SP_Increment);
4644 pif (Save_MRP_in_frame);
4645 pif (extn_ptr_defined);
4646 pif (Cleanup_defined);
4647 pif (MPE_XL_interrupt_marker);
4648 pif (HP_UX_interrupt_marker);
4651 putchar_unfiltered ('\n');
4654 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
4656 #define pin(FLD) printf_unfiltered ("\tFLD = 0x%x\n", u->FLD);
4659 pin (Region_description);
4662 pin (Total_frame_size);
4665 #ifdef PREPARE_TO_PROCEED
4667 /* If the user has switched threads, and there is a breakpoint
4668 at the old thread's pc location, then switch to that thread
4669 and return TRUE, else return FALSE and don't do a thread
4670 switch (or rather, don't seem to have done a thread switch).
4672 Ptrace-based gdb will always return FALSE to the thread-switch
4673 query, and thus also to PREPARE_TO_PROCEED.
4675 The important thing is whether there is a BPT instruction,
4676 not how many user breakpoints there are. So we have to worry
4677 about things like these:
4681 o User hits bp, no switch -- NO
4683 o User hits bp, switches threads -- YES
4685 o User hits bp, deletes bp, switches threads -- NO
4687 o User hits bp, deletes one of two or more bps
4688 at that PC, user switches threads -- YES
4690 o Plus, since we're buffering events, the user may have hit a
4691 breakpoint, deleted the breakpoint and then gotten another
4692 hit on that same breakpoint on another thread which
4693 actually hit before the delete. (FIXME in breakpoint.c
4694 so that "dead" breakpoints are ignored?) -- NO
4696 For these reasons, we have to violate information hiding and
4697 call "breakpoint_here_p". If core gdb thinks there is a bpt
4698 here, that's what counts, as core gdb is the one which is
4699 putting the BPT instruction in and taking it out. */
4701 hppa_prepare_to_proceed ()
4704 pid_t current_thread;
4706 old_thread = hppa_switched_threads (inferior_pid);
4707 if (old_thread != 0)
4709 /* Switched over from "old_thread". Try to do
4710 as little work as possible, 'cause mostly
4711 we're going to switch back. */
4713 CORE_ADDR old_pc = read_pc ();
4715 /* Yuk, shouldn't use global to specify current
4716 thread. But that's how gdb does it. */
4717 current_thread = inferior_pid;
4718 inferior_pid = old_thread;
4720 new_pc = read_pc ();
4721 if (new_pc != old_pc /* If at same pc, no need */
4722 && breakpoint_here_p (new_pc))
4724 /* User hasn't deleted the BP.
4725 Return TRUE, finishing switch to "old_thread". */
4726 flush_cached_frames ();
4727 registers_changed ();
4729 printf ("---> PREPARE_TO_PROCEED (was %d, now %d)!\n",
4730 current_thread, inferior_pid);
4736 /* Otherwise switch back to the user-chosen thread. */
4737 inferior_pid = current_thread;
4738 new_pc = read_pc (); /* Re-prime register cache */
4743 #endif /* PREPARE_TO_PROCEED */
4746 hppa_skip_permanent_breakpoint ()
4748 /* To step over a breakpoint instruction on the PA takes some
4749 fiddling with the instruction address queue.
4751 When we stop at a breakpoint, the IA queue front (the instruction
4752 we're executing now) points at the breakpoint instruction, and
4753 the IA queue back (the next instruction to execute) points to
4754 whatever instruction we would execute after the breakpoint, if it
4755 were an ordinary instruction. This is the case even if the
4756 breakpoint is in the delay slot of a branch instruction.
4758 Clearly, to step past the breakpoint, we need to set the queue
4759 front to the back. But what do we put in the back? What
4760 instruction comes after that one? Because of the branch delay
4761 slot, the next insn is always at the back + 4. */
4762 write_register (PCOQ_HEAD_REGNUM, read_register (PCOQ_TAIL_REGNUM));
4763 write_register (PCSQ_HEAD_REGNUM, read_register (PCSQ_TAIL_REGNUM));
4765 write_register (PCOQ_TAIL_REGNUM, read_register (PCOQ_TAIL_REGNUM) + 4);
4766 /* We can leave the tail's space the same, since there's no jump. */
4770 _initialize_hppa_tdep ()
4772 tm_print_insn = print_insn_hppa;
4774 add_cmd ("unwind", class_maintenance, unwind_command,
4775 "Print unwind table entry at given address.",
4776 &maintenanceprintlist);