1 /* Target-dependent code for the HP PA architecture, for GDB.
3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
7 Contributed by the Center for Software Science at the
8 University of Utah (pa-gdb-bugs@cs.utah.edu).
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place - Suite 330,
25 Boston, MA 02111-1307, USA. */
33 #include "completer.h"
36 #include "gdb_assert.h"
37 #include "infttrace.h"
38 #include "arch-utils.h"
39 /* For argument passing to the inferior */
43 #include "trad-frame.h"
44 #include "frame-unwind.h"
45 #include "frame-base.h"
48 #include <sys/types.h>
52 #include <sys/param.h>
55 #include <sys/ptrace.h>
56 #include <machine/save_state.h>
58 #ifdef COFF_ENCAPSULATE
59 #include "a.out.encap.h"
63 /*#include <sys/user.h> After a.out.h */
73 #include "hppa-tdep.h"
75 /* Some local constants. */
76 static const int hppa32_num_regs = 128;
77 static const int hppa64_num_regs = 96;
79 static const int hppa64_call_dummy_breakpoint_offset = 22 * 4;
81 /* DEPRECATED_CALL_DUMMY_LENGTH is computed based on the size of a
82 word on the target machine, not the size of an instruction. Since
83 a word on this target holds two instructions we have to divide the
84 instruction size by two to get the word size of the dummy. */
85 static const int hppa32_call_dummy_length = INSTRUCTION_SIZE * 28;
86 static const int hppa64_call_dummy_length = INSTRUCTION_SIZE * 26 / 2;
88 /* Get at various relevent fields of an instruction word. */
91 #define MASK_14 0x3fff
92 #define MASK_21 0x1fffff
94 /* Define offsets into the call dummy for the target function address.
95 See comments related to CALL_DUMMY for more info. */
96 #define FUNC_LDIL_OFFSET (INSTRUCTION_SIZE * 9)
97 #define FUNC_LDO_OFFSET (INSTRUCTION_SIZE * 10)
99 /* Define offsets into the call dummy for the _sr4export address.
100 See comments related to CALL_DUMMY for more info. */
101 #define SR4EXPORT_LDIL_OFFSET (INSTRUCTION_SIZE * 12)
102 #define SR4EXPORT_LDO_OFFSET (INSTRUCTION_SIZE * 13)
104 /* To support detection of the pseudo-initial frame
105 that threads have. */
106 #define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
107 #define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
109 /* Sizes (in bytes) of the native unwind entries. */
110 #define UNWIND_ENTRY_SIZE 16
111 #define STUB_UNWIND_ENTRY_SIZE 8
113 static int get_field (unsigned word, int from, int to);
115 static int extract_5_load (unsigned int);
117 static unsigned extract_5R_store (unsigned int);
119 static unsigned extract_5r_store (unsigned int);
121 static void hppa_frame_init_saved_regs (struct frame_info *frame);
123 static void find_dummy_frame_regs (struct frame_info *, CORE_ADDR *);
125 static int find_proc_framesize (CORE_ADDR);
127 static int find_return_regnum (CORE_ADDR);
129 struct unwind_table_entry *find_unwind_entry (CORE_ADDR);
131 static int extract_17 (unsigned int);
133 static unsigned deposit_21 (unsigned int, unsigned int);
135 static int extract_21 (unsigned);
137 static unsigned deposit_14 (int, unsigned int);
139 static int extract_14 (unsigned);
141 static void unwind_command (char *, int);
143 static int low_sign_extend (unsigned int, unsigned int);
145 static int sign_extend (unsigned int, unsigned int);
147 static int restore_pc_queue (CORE_ADDR *);
149 static int hppa_alignof (struct type *);
151 static int prologue_inst_adjust_sp (unsigned long);
153 static int is_branch (unsigned long);
155 static int inst_saves_gr (unsigned long);
157 static int inst_saves_fr (unsigned long);
159 static int pc_in_interrupt_handler (CORE_ADDR);
161 static int pc_in_linker_stub (CORE_ADDR);
163 static int compare_unwind_entries (const void *, const void *);
165 static void read_unwind_info (struct objfile *);
167 static void internalize_unwinds (struct objfile *,
168 struct unwind_table_entry *,
169 asection *, unsigned int,
170 unsigned int, CORE_ADDR);
171 static void pa_print_registers (char *, int, int);
172 static void pa_strcat_registers (char *, int, int, struct ui_file *);
173 static void pa_register_look_aside (char *, int, long *);
174 static void pa_print_fp_reg (int);
175 static void pa_strcat_fp_reg (int, struct ui_file *, enum precision_type);
176 static void record_text_segment_lowaddr (bfd *, asection *, void *);
177 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
178 following functions static, once we hppa is partially multiarched. */
179 int hppa_reg_struct_has_addr (int gcc_p, struct type *type);
180 CORE_ADDR hppa_skip_prologue (CORE_ADDR pc);
181 CORE_ADDR hppa_skip_trampoline_code (CORE_ADDR pc);
182 int hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name);
183 int hppa_in_solib_return_trampoline (CORE_ADDR pc, char *name);
184 CORE_ADDR hppa_saved_pc_after_call (struct frame_info *frame);
185 int hppa_inner_than (CORE_ADDR lhs, CORE_ADDR rhs);
186 CORE_ADDR hppa64_stack_align (CORE_ADDR sp);
187 int hppa_pc_requires_run_before_use (CORE_ADDR pc);
188 int hppa_instruction_nullified (void);
189 int hppa_register_raw_size (int reg_nr);
190 int hppa_register_byte (int reg_nr);
191 struct type * hppa32_register_virtual_type (int reg_nr);
192 struct type * hppa64_register_virtual_type (int reg_nr);
193 void hppa_store_struct_return (CORE_ADDR addr, CORE_ADDR sp);
194 void hppa64_extract_return_value (struct type *type, char *regbuf,
196 int hppa64_use_struct_convention (int gcc_p, struct type *type);
197 void hppa64_store_return_value (struct type *type, char *valbuf);
198 int hppa_cannot_store_register (int regnum);
199 void hppa_init_extra_frame_info (int fromleaf, struct frame_info *frame);
200 CORE_ADDR hppa_frame_chain (struct frame_info *frame);
201 int hppa_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe);
202 int hppa_frameless_function_invocation (struct frame_info *frame);
203 CORE_ADDR hppa_frame_saved_pc (struct frame_info *frame);
204 CORE_ADDR hppa_frame_args_address (struct frame_info *fi);
205 int hppa_frame_num_args (struct frame_info *frame);
206 void hppa_push_dummy_frame (void);
207 void hppa_pop_frame (void);
208 CORE_ADDR hppa_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
209 int nargs, struct value **args,
210 struct type *type, int gcc_p);
211 CORE_ADDR hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
212 int struct_return, CORE_ADDR struct_addr);
213 CORE_ADDR hppa_smash_text_address (CORE_ADDR addr);
214 CORE_ADDR hppa_target_read_pc (ptid_t ptid);
215 void hppa_target_write_pc (CORE_ADDR v, ptid_t ptid);
216 CORE_ADDR hppa_target_read_fp (void);
220 struct minimal_symbol *msym;
221 CORE_ADDR solib_handle;
222 CORE_ADDR return_val;
226 static int cover_find_stub_with_shl_get (void *);
228 static int is_pa_2 = 0; /* False */
230 /* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
231 extern int hp_som_som_object_present;
233 /* In breakpoint.c */
234 extern int exception_catchpoints_are_fragile;
236 /* Should call_function allocate stack space for a struct return? */
239 hppa64_use_struct_convention (int gcc_p, struct type *type)
241 /* RM: struct upto 128 bits are returned in registers */
242 return TYPE_LENGTH (type) > 16;
245 /* Handle 32/64-bit struct return conventions. */
247 static enum return_value_convention
248 hppa32_return_value (struct gdbarch *gdbarch,
249 struct type *type, struct regcache *regcache,
250 void *readbuf, const void *writebuf)
252 if (TYPE_CODE (type) == TYPE_CODE_FLT)
255 regcache_cooked_read_part (regcache, FP4_REGNUM, 0,
256 TYPE_LENGTH (type), readbuf);
257 if (writebuf != NULL)
258 regcache_cooked_write_part (regcache, FP4_REGNUM, 0,
259 TYPE_LENGTH (type), writebuf);
260 return RETURN_VALUE_REGISTER_CONVENTION;
262 if (TYPE_LENGTH (type) <= 2 * 4)
264 /* The value always lives in the right hand end of the register
265 (or register pair)? */
268 int part = TYPE_LENGTH (type) % 4;
269 /* The left hand register contains only part of the value,
270 transfer that first so that the rest can be xfered as entire
275 regcache_cooked_read_part (regcache, reg, 4 - part,
277 if (writebuf != NULL)
278 regcache_cooked_write_part (regcache, reg, 4 - part,
282 /* Now transfer the remaining register values. */
283 for (b = part; b < TYPE_LENGTH (type); b += 4)
286 regcache_cooked_read (regcache, reg, (char *) readbuf + b);
287 if (writebuf != NULL)
288 regcache_cooked_write (regcache, reg, (const char *) writebuf + b);
291 return RETURN_VALUE_REGISTER_CONVENTION;
294 return RETURN_VALUE_STRUCT_CONVENTION;
297 static enum return_value_convention
298 hppa64_return_value (struct gdbarch *gdbarch,
299 struct type *type, struct regcache *regcache,
300 void *readbuf, const void *writebuf)
302 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
303 are in r28, padded on the left. Aggregates less that 65 bits are
304 in r28, right padded. Aggregates upto 128 bits are in r28 and
305 r29, right padded. */
306 if (TYPE_CODE (type) == TYPE_CODE_FLT
307 && TYPE_LENGTH (type) <= 8)
309 /* Floats are right aligned? */
310 int offset = register_size (gdbarch, FP4_REGNUM) - TYPE_LENGTH (type);
312 regcache_cooked_read_part (regcache, FP4_REGNUM, offset,
313 TYPE_LENGTH (type), readbuf);
314 if (writebuf != NULL)
315 regcache_cooked_write_part (regcache, FP4_REGNUM, offset,
316 TYPE_LENGTH (type), writebuf);
317 return RETURN_VALUE_REGISTER_CONVENTION;
319 else if (TYPE_LENGTH (type) <= 8 && is_integral_type (type))
321 /* Integrals are right aligned. */
322 int offset = register_size (gdbarch, FP4_REGNUM) - TYPE_LENGTH (type);
324 regcache_cooked_read_part (regcache, 28, offset,
325 TYPE_LENGTH (type), readbuf);
326 if (writebuf != NULL)
327 regcache_cooked_write_part (regcache, 28, offset,
328 TYPE_LENGTH (type), writebuf);
329 return RETURN_VALUE_REGISTER_CONVENTION;
331 else if (TYPE_LENGTH (type) <= 2 * 8)
333 /* Composite values are left aligned. */
335 for (b = 0; b < TYPE_LENGTH (type); b += 8)
337 int part = min (8, TYPE_LENGTH (type) - b);
339 regcache_cooked_read_part (regcache, 28 + b / 8, 0, part,
340 (char *) readbuf + b);
341 if (writebuf != NULL)
342 regcache_cooked_write_part (regcache, 28 + b / 8, 0, part,
343 (const char *) writebuf + b);
345 return RETURN_VALUE_REGISTER_CONVENTION;
348 return RETURN_VALUE_STRUCT_CONVENTION;
351 /* Routines to extract various sized constants out of hppa
354 /* This assumes that no garbage lies outside of the lower bits of
358 sign_extend (unsigned val, unsigned bits)
360 return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
363 /* For many immediate values the sign bit is the low bit! */
366 low_sign_extend (unsigned val, unsigned bits)
368 return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
371 /* Extract the bits at positions between FROM and TO, using HP's numbering
375 get_field (unsigned word, int from, int to)
377 return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
380 /* extract the immediate field from a ld{bhw}s instruction */
383 extract_5_load (unsigned word)
385 return low_sign_extend (word >> 16 & MASK_5, 5);
388 /* extract the immediate field from a break instruction */
391 extract_5r_store (unsigned word)
393 return (word & MASK_5);
396 /* extract the immediate field from a {sr}sm instruction */
399 extract_5R_store (unsigned word)
401 return (word >> 16 & MASK_5);
404 /* extract a 14 bit immediate field */
407 extract_14 (unsigned word)
409 return low_sign_extend (word & MASK_14, 14);
412 /* deposit a 14 bit constant in a word */
415 deposit_14 (int opnd, unsigned word)
417 unsigned sign = (opnd < 0 ? 1 : 0);
419 return word | ((unsigned) opnd << 1 & MASK_14) | sign;
422 /* extract a 21 bit constant */
425 extract_21 (unsigned word)
431 val = get_field (word, 20, 20);
433 val |= get_field (word, 9, 19);
435 val |= get_field (word, 5, 6);
437 val |= get_field (word, 0, 4);
439 val |= get_field (word, 7, 8);
440 return sign_extend (val, 21) << 11;
443 /* deposit a 21 bit constant in a word. Although 21 bit constants are
444 usually the top 21 bits of a 32 bit constant, we assume that only
445 the low 21 bits of opnd are relevant */
448 deposit_21 (unsigned opnd, unsigned word)
452 val |= get_field (opnd, 11 + 14, 11 + 18);
454 val |= get_field (opnd, 11 + 12, 11 + 13);
456 val |= get_field (opnd, 11 + 19, 11 + 20);
458 val |= get_field (opnd, 11 + 1, 11 + 11);
460 val |= get_field (opnd, 11 + 0, 11 + 0);
464 /* extract a 17 bit constant from branch instructions, returning the
465 19 bit signed value. */
468 extract_17 (unsigned word)
470 return sign_extend (get_field (word, 19, 28) |
471 get_field (word, 29, 29) << 10 |
472 get_field (word, 11, 15) << 11 |
473 (word & 0x1) << 16, 17) << 2;
477 /* Compare the start address for two unwind entries returning 1 if
478 the first address is larger than the second, -1 if the second is
479 larger than the first, and zero if they are equal. */
482 compare_unwind_entries (const void *arg1, const void *arg2)
484 const struct unwind_table_entry *a = arg1;
485 const struct unwind_table_entry *b = arg2;
487 if (a->region_start > b->region_start)
489 else if (a->region_start < b->region_start)
495 static CORE_ADDR low_text_segment_address;
498 record_text_segment_lowaddr (bfd *abfd, asection *section, void *ignored)
500 if (((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
501 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
502 && section->vma < low_text_segment_address)
503 low_text_segment_address = section->vma;
507 internalize_unwinds (struct objfile *objfile, struct unwind_table_entry *table,
508 asection *section, unsigned int entries, unsigned int size,
509 CORE_ADDR text_offset)
511 /* We will read the unwind entries into temporary memory, then
512 fill in the actual unwind table. */
517 char *buf = alloca (size);
519 low_text_segment_address = -1;
521 /* If addresses are 64 bits wide, then unwinds are supposed to
522 be segment relative offsets instead of absolute addresses.
524 Note that when loading a shared library (text_offset != 0) the
525 unwinds are already relative to the text_offset that will be
527 if (TARGET_PTR_BIT == 64 && text_offset == 0)
529 bfd_map_over_sections (objfile->obfd,
530 record_text_segment_lowaddr, NULL);
532 /* ?!? Mask off some low bits. Should this instead subtract
533 out the lowest section's filepos or something like that?
534 This looks very hokey to me. */
535 low_text_segment_address &= ~0xfff;
536 text_offset += low_text_segment_address;
539 bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
541 /* Now internalize the information being careful to handle host/target
543 for (i = 0; i < entries; i++)
545 table[i].region_start = bfd_get_32 (objfile->obfd,
547 table[i].region_start += text_offset;
549 table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
550 table[i].region_end += text_offset;
552 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
554 table[i].Cannot_unwind = (tmp >> 31) & 0x1;
555 table[i].Millicode = (tmp >> 30) & 0x1;
556 table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
557 table[i].Region_description = (tmp >> 27) & 0x3;
558 table[i].reserved1 = (tmp >> 26) & 0x1;
559 table[i].Entry_SR = (tmp >> 25) & 0x1;
560 table[i].Entry_FR = (tmp >> 21) & 0xf;
561 table[i].Entry_GR = (tmp >> 16) & 0x1f;
562 table[i].Args_stored = (tmp >> 15) & 0x1;
563 table[i].Variable_Frame = (tmp >> 14) & 0x1;
564 table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
565 table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
566 table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
567 table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
568 table[i].Ada_Region = (tmp >> 9) & 0x1;
569 table[i].cxx_info = (tmp >> 8) & 0x1;
570 table[i].cxx_try_catch = (tmp >> 7) & 0x1;
571 table[i].sched_entry_seq = (tmp >> 6) & 0x1;
572 table[i].reserved2 = (tmp >> 5) & 0x1;
573 table[i].Save_SP = (tmp >> 4) & 0x1;
574 table[i].Save_RP = (tmp >> 3) & 0x1;
575 table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
576 table[i].extn_ptr_defined = (tmp >> 1) & 0x1;
577 table[i].Cleanup_defined = tmp & 0x1;
578 tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
580 table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
581 table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
582 table[i].Large_frame = (tmp >> 29) & 0x1;
583 table[i].Pseudo_SP_Set = (tmp >> 28) & 0x1;
584 table[i].reserved4 = (tmp >> 27) & 0x1;
585 table[i].Total_frame_size = tmp & 0x7ffffff;
587 /* Stub unwinds are handled elsewhere. */
588 table[i].stub_unwind.stub_type = 0;
589 table[i].stub_unwind.padding = 0;
594 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
595 the object file. This info is used mainly by find_unwind_entry() to find
596 out the stack frame size and frame pointer used by procedures. We put
597 everything on the psymbol obstack in the objfile so that it automatically
598 gets freed when the objfile is destroyed. */
601 read_unwind_info (struct objfile *objfile)
603 asection *unwind_sec, *stub_unwind_sec;
604 unsigned unwind_size, stub_unwind_size, total_size;
605 unsigned index, unwind_entries;
606 unsigned stub_entries, total_entries;
607 CORE_ADDR text_offset;
608 struct obj_unwind_info *ui;
609 obj_private_data_t *obj_private;
611 text_offset = ANOFFSET (objfile->section_offsets, 0);
612 ui = (struct obj_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
613 sizeof (struct obj_unwind_info));
619 /* For reasons unknown the HP PA64 tools generate multiple unwinder
620 sections in a single executable. So we just iterate over every
621 section in the BFD looking for unwinder sections intead of trying
622 to do a lookup with bfd_get_section_by_name.
624 First determine the total size of the unwind tables so that we
625 can allocate memory in a nice big hunk. */
627 for (unwind_sec = objfile->obfd->sections;
629 unwind_sec = unwind_sec->next)
631 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
632 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
634 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
635 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
637 total_entries += unwind_entries;
641 /* Now compute the size of the stub unwinds. Note the ELF tools do not
642 use stub unwinds at the curren time. */
643 stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
647 stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
648 stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
652 stub_unwind_size = 0;
656 /* Compute total number of unwind entries and their total size. */
657 total_entries += stub_entries;
658 total_size = total_entries * sizeof (struct unwind_table_entry);
660 /* Allocate memory for the unwind table. */
661 ui->table = (struct unwind_table_entry *)
662 obstack_alloc (&objfile->objfile_obstack, total_size);
663 ui->last = total_entries - 1;
665 /* Now read in each unwind section and internalize the standard unwind
668 for (unwind_sec = objfile->obfd->sections;
670 unwind_sec = unwind_sec->next)
672 if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
673 || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
675 unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
676 unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
678 internalize_unwinds (objfile, &ui->table[index], unwind_sec,
679 unwind_entries, unwind_size, text_offset);
680 index += unwind_entries;
684 /* Now read in and internalize the stub unwind entries. */
685 if (stub_unwind_size > 0)
688 char *buf = alloca (stub_unwind_size);
690 /* Read in the stub unwind entries. */
691 bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
692 0, stub_unwind_size);
694 /* Now convert them into regular unwind entries. */
695 for (i = 0; i < stub_entries; i++, index++)
697 /* Clear out the next unwind entry. */
698 memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
700 /* Convert offset & size into region_start and region_end.
701 Stuff away the stub type into "reserved" fields. */
702 ui->table[index].region_start = bfd_get_32 (objfile->obfd,
704 ui->table[index].region_start += text_offset;
706 ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
709 ui->table[index].region_end
710 = ui->table[index].region_start + 4 *
711 (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
717 /* Unwind table needs to be kept sorted. */
718 qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
719 compare_unwind_entries);
721 /* Keep a pointer to the unwind information. */
722 if (objfile->obj_private == NULL)
724 obj_private = (obj_private_data_t *)
725 obstack_alloc (&objfile->objfile_obstack,
726 sizeof (obj_private_data_t));
727 obj_private->unwind_info = NULL;
728 obj_private->so_info = NULL;
731 objfile->obj_private = obj_private;
733 obj_private = (obj_private_data_t *) objfile->obj_private;
734 obj_private->unwind_info = ui;
737 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
738 of the objfiles seeking the unwind table entry for this PC. Each objfile
739 contains a sorted list of struct unwind_table_entry. Since we do a binary
740 search of the unwind tables, we depend upon them to be sorted. */
742 struct unwind_table_entry *
743 find_unwind_entry (CORE_ADDR pc)
745 int first, middle, last;
746 struct objfile *objfile;
748 /* A function at address 0? Not in HP-UX! */
749 if (pc == (CORE_ADDR) 0)
752 ALL_OBJFILES (objfile)
754 struct obj_unwind_info *ui;
756 if (objfile->obj_private)
757 ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
761 read_unwind_info (objfile);
762 if (objfile->obj_private == NULL)
763 error ("Internal error reading unwind information.");
764 ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
767 /* First, check the cache */
770 && pc >= ui->cache->region_start
771 && pc <= ui->cache->region_end)
774 /* Not in the cache, do a binary search */
779 while (first <= last)
781 middle = (first + last) / 2;
782 if (pc >= ui->table[middle].region_start
783 && pc <= ui->table[middle].region_end)
785 ui->cache = &ui->table[middle];
786 return &ui->table[middle];
789 if (pc < ui->table[middle].region_start)
794 } /* ALL_OBJFILES() */
798 const unsigned char *
799 hppa_breakpoint_from_pc (CORE_ADDR *pc, int *len)
801 static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
802 (*len) = sizeof (breakpoint);
806 /* Return the name of a register. */
809 hppa32_register_name (int i)
811 static char *names[] = {
812 "flags", "r1", "rp", "r3",
813 "r4", "r5", "r6", "r7",
814 "r8", "r9", "r10", "r11",
815 "r12", "r13", "r14", "r15",
816 "r16", "r17", "r18", "r19",
817 "r20", "r21", "r22", "r23",
818 "r24", "r25", "r26", "dp",
819 "ret0", "ret1", "sp", "r31",
820 "sar", "pcoqh", "pcsqh", "pcoqt",
821 "pcsqt", "eiem", "iir", "isr",
822 "ior", "ipsw", "goto", "sr4",
823 "sr0", "sr1", "sr2", "sr3",
824 "sr5", "sr6", "sr7", "cr0",
825 "cr8", "cr9", "ccr", "cr12",
826 "cr13", "cr24", "cr25", "cr26",
827 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
828 "fpsr", "fpe1", "fpe2", "fpe3",
829 "fpe4", "fpe5", "fpe6", "fpe7",
830 "fr4", "fr4R", "fr5", "fr5R",
831 "fr6", "fr6R", "fr7", "fr7R",
832 "fr8", "fr8R", "fr9", "fr9R",
833 "fr10", "fr10R", "fr11", "fr11R",
834 "fr12", "fr12R", "fr13", "fr13R",
835 "fr14", "fr14R", "fr15", "fr15R",
836 "fr16", "fr16R", "fr17", "fr17R",
837 "fr18", "fr18R", "fr19", "fr19R",
838 "fr20", "fr20R", "fr21", "fr21R",
839 "fr22", "fr22R", "fr23", "fr23R",
840 "fr24", "fr24R", "fr25", "fr25R",
841 "fr26", "fr26R", "fr27", "fr27R",
842 "fr28", "fr28R", "fr29", "fr29R",
843 "fr30", "fr30R", "fr31", "fr31R"
845 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
852 hppa64_register_name (int i)
854 static char *names[] = {
855 "flags", "r1", "rp", "r3",
856 "r4", "r5", "r6", "r7",
857 "r8", "r9", "r10", "r11",
858 "r12", "r13", "r14", "r15",
859 "r16", "r17", "r18", "r19",
860 "r20", "r21", "r22", "r23",
861 "r24", "r25", "r26", "dp",
862 "ret0", "ret1", "sp", "r31",
863 "sar", "pcoqh", "pcsqh", "pcoqt",
864 "pcsqt", "eiem", "iir", "isr",
865 "ior", "ipsw", "goto", "sr4",
866 "sr0", "sr1", "sr2", "sr3",
867 "sr5", "sr6", "sr7", "cr0",
868 "cr8", "cr9", "ccr", "cr12",
869 "cr13", "cr24", "cr25", "cr26",
870 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
871 "fpsr", "fpe1", "fpe2", "fpe3",
872 "fr4", "fr5", "fr6", "fr7",
873 "fr8", "fr9", "fr10", "fr11",
874 "fr12", "fr13", "fr14", "fr15",
875 "fr16", "fr17", "fr18", "fr19",
876 "fr20", "fr21", "fr22", "fr23",
877 "fr24", "fr25", "fr26", "fr27",
878 "fr28", "fr29", "fr30", "fr31"
880 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
888 /* Return the adjustment necessary to make for addresses on the stack
889 as presented by hpread.c.
891 This is necessary because of the stack direction on the PA and the
892 bizarre way in which someone (?) decided they wanted to handle
893 frame pointerless code in GDB. */
895 hpread_adjust_stack_address (CORE_ADDR func_addr)
897 struct unwind_table_entry *u;
899 u = find_unwind_entry (func_addr);
903 return u->Total_frame_size << 3;
906 /* Called to determine if PC is in an interrupt handler of some
910 pc_in_interrupt_handler (CORE_ADDR pc)
912 struct unwind_table_entry *u;
913 struct minimal_symbol *msym_us;
915 u = find_unwind_entry (pc);
919 /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
920 its frame isn't a pure interrupt frame. Deal with this. */
921 msym_us = lookup_minimal_symbol_by_pc (pc);
923 return (u->HP_UX_interrupt_marker
924 && !PC_IN_SIGTRAMP (pc, DEPRECATED_SYMBOL_NAME (msym_us)));
927 /* Called when no unwind descriptor was found for PC. Returns 1 if it
928 appears that PC is in a linker stub.
930 ?!? Need to handle stubs which appear in PA64 code. */
933 pc_in_linker_stub (CORE_ADDR pc)
935 int found_magic_instruction = 0;
939 /* If unable to read memory, assume pc is not in a linker stub. */
940 if (target_read_memory (pc, buf, 4) != 0)
943 /* We are looking for something like
945 ; $$dyncall jams RP into this special spot in the frame (RP')
946 ; before calling the "call stub"
949 ldsid (rp),r1 ; Get space associated with RP into r1
950 mtsp r1,sp ; Move it into space register 0
951 be,n 0(sr0),rp) ; back to your regularly scheduled program */
953 /* Maximum known linker stub size is 4 instructions. Search forward
954 from the given PC, then backward. */
955 for (i = 0; i < 4; i++)
957 /* If we hit something with an unwind, stop searching this direction. */
959 if (find_unwind_entry (pc + i * 4) != 0)
962 /* Check for ldsid (rp),r1 which is the magic instruction for a
963 return from a cross-space function call. */
964 if (read_memory_integer (pc + i * 4, 4) == 0x004010a1)
966 found_magic_instruction = 1;
969 /* Add code to handle long call/branch and argument relocation stubs
973 if (found_magic_instruction != 0)
976 /* Now look backward. */
977 for (i = 0; i < 4; i++)
979 /* If we hit something with an unwind, stop searching this direction. */
981 if (find_unwind_entry (pc - i * 4) != 0)
984 /* Check for ldsid (rp),r1 which is the magic instruction for a
985 return from a cross-space function call. */
986 if (read_memory_integer (pc - i * 4, 4) == 0x004010a1)
988 found_magic_instruction = 1;
991 /* Add code to handle long call/branch and argument relocation stubs
994 return found_magic_instruction;
998 find_return_regnum (CORE_ADDR pc)
1000 struct unwind_table_entry *u;
1002 u = find_unwind_entry (pc);
1013 /* Return size of frame, or -1 if we should use a frame pointer. */
1015 find_proc_framesize (CORE_ADDR pc)
1017 struct unwind_table_entry *u;
1018 struct minimal_symbol *msym_us;
1020 /* This may indicate a bug in our callers... */
1021 if (pc == (CORE_ADDR) 0)
1024 u = find_unwind_entry (pc);
1028 if (pc_in_linker_stub (pc))
1029 /* Linker stubs have a zero size frame. */
1035 msym_us = lookup_minimal_symbol_by_pc (pc);
1037 /* If Save_SP is set, and we're not in an interrupt or signal caller,
1038 then we have a frame pointer. Use it. */
1040 && !pc_in_interrupt_handler (pc)
1042 && !PC_IN_SIGTRAMP (pc, DEPRECATED_SYMBOL_NAME (msym_us)))
1045 return u->Total_frame_size << 3;
1048 /* Return offset from sp at which rp is saved, or 0 if not saved. */
1049 static int rp_saved (CORE_ADDR);
1052 rp_saved (CORE_ADDR pc)
1054 struct unwind_table_entry *u;
1056 /* A function at, and thus a return PC from, address 0? Not in HP-UX! */
1057 if (pc == (CORE_ADDR) 0)
1060 u = find_unwind_entry (pc);
1064 if (pc_in_linker_stub (pc))
1065 /* This is the so-called RP'. */
1072 return (TARGET_PTR_BIT == 64 ? -16 : -20);
1073 else if (u->stub_unwind.stub_type != 0)
1075 switch (u->stub_unwind.stub_type)
1080 case PARAMETER_RELOCATION:
1091 hppa_frameless_function_invocation (struct frame_info *frame)
1093 struct unwind_table_entry *u;
1095 u = find_unwind_entry (get_frame_pc (frame));
1100 return (u->Total_frame_size == 0 && u->stub_unwind.stub_type == 0);
1103 /* Immediately after a function call, return the saved pc.
1104 Can't go through the frames for this because on some machines
1105 the new frame is not set up until the new function executes
1106 some instructions. */
1109 hppa_saved_pc_after_call (struct frame_info *frame)
1113 struct unwind_table_entry *u;
1115 ret_regnum = find_return_regnum (get_frame_pc (frame));
1116 pc = read_register (ret_regnum) & ~0x3;
1118 /* If PC is in a linker stub, then we need to dig the address
1119 the stub will return to out of the stack. */
1120 u = find_unwind_entry (pc);
1121 if (u && u->stub_unwind.stub_type != 0)
1122 return DEPRECATED_FRAME_SAVED_PC (frame);
1128 hppa_frame_saved_pc (struct frame_info *frame)
1130 CORE_ADDR pc = get_frame_pc (frame);
1131 struct unwind_table_entry *u;
1132 CORE_ADDR old_pc = 0;
1133 int spun_around_loop = 0;
1136 /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
1137 at the base of the frame in an interrupt handler. Registers within
1138 are saved in the exact same order as GDB numbers registers. How
1140 if (pc_in_interrupt_handler (pc))
1141 return read_memory_integer (get_frame_base (frame) + PCOQ_HEAD_REGNUM * 4,
1142 TARGET_PTR_BIT / 8) & ~0x3;
1144 if ((get_frame_pc (frame) >= get_frame_base (frame)
1145 && (get_frame_pc (frame)
1146 <= (get_frame_base (frame)
1147 /* A call dummy is sized in words, but it is actually a
1148 series of instructions. Account for that scaling
1150 + ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
1151 * DEPRECATED_CALL_DUMMY_LENGTH)
1152 /* Similarly we have to account for 64bit wide register
1154 + (32 * DEPRECATED_REGISTER_SIZE)
1155 /* We always consider FP regs 8 bytes long. */
1156 + (NUM_REGS - FP0_REGNUM) * 8
1157 /* Similarly we have to account for 64bit wide register
1159 + (6 * DEPRECATED_REGISTER_SIZE)))))
1161 return read_memory_integer ((get_frame_base (frame)
1162 + (TARGET_PTR_BIT == 64 ? -16 : -20)),
1163 TARGET_PTR_BIT / 8) & ~0x3;
1166 #ifdef FRAME_SAVED_PC_IN_SIGTRAMP
1167 /* Deal with signal handler caller frames too. */
1168 if ((get_frame_type (frame) == SIGTRAMP_FRAME))
1171 FRAME_SAVED_PC_IN_SIGTRAMP (frame, &rp);
1176 if (hppa_frameless_function_invocation (frame))
1180 ret_regnum = find_return_regnum (pc);
1182 /* If the next frame is an interrupt frame or a signal
1183 handler caller, then we need to look in the saved
1184 register area to get the return pointer (the values
1185 in the registers may not correspond to anything useful). */
1186 if (get_next_frame (frame)
1187 && ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME)
1188 || pc_in_interrupt_handler (get_frame_pc (get_next_frame (frame)))))
1190 CORE_ADDR *saved_regs;
1191 hppa_frame_init_saved_regs (get_next_frame (frame));
1192 saved_regs = deprecated_get_frame_saved_regs (get_next_frame (frame));
1193 if (read_memory_integer (saved_regs[FLAGS_REGNUM],
1194 TARGET_PTR_BIT / 8) & 0x2)
1196 pc = read_memory_integer (saved_regs[31],
1197 TARGET_PTR_BIT / 8) & ~0x3;
1199 /* Syscalls are really two frames. The syscall stub itself
1200 with a return pointer in %rp and the kernel call with
1201 a return pointer in %r31. We return the %rp variant
1202 if %r31 is the same as frame->pc. */
1203 if (pc == get_frame_pc (frame))
1204 pc = read_memory_integer (saved_regs[RP_REGNUM],
1205 TARGET_PTR_BIT / 8) & ~0x3;
1208 pc = read_memory_integer (saved_regs[RP_REGNUM],
1209 TARGET_PTR_BIT / 8) & ~0x3;
1212 pc = read_register (ret_regnum) & ~0x3;
1216 spun_around_loop = 0;
1220 rp_offset = rp_saved (pc);
1222 /* Similar to code in frameless function case. If the next
1223 frame is a signal or interrupt handler, then dig the right
1224 information out of the saved register info. */
1226 && get_next_frame (frame)
1227 && ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME)
1228 || pc_in_interrupt_handler (get_frame_pc (get_next_frame (frame)))))
1230 CORE_ADDR *saved_regs;
1231 hppa_frame_init_saved_regs (get_next_frame (frame));
1232 saved_regs = deprecated_get_frame_saved_regs (get_next_frame (frame));
1233 if (read_memory_integer (saved_regs[FLAGS_REGNUM],
1234 TARGET_PTR_BIT / 8) & 0x2)
1236 pc = read_memory_integer (saved_regs[31],
1237 TARGET_PTR_BIT / 8) & ~0x3;
1239 /* Syscalls are really two frames. The syscall stub itself
1240 with a return pointer in %rp and the kernel call with
1241 a return pointer in %r31. We return the %rp variant
1242 if %r31 is the same as frame->pc. */
1243 if (pc == get_frame_pc (frame))
1244 pc = read_memory_integer (saved_regs[RP_REGNUM],
1245 TARGET_PTR_BIT / 8) & ~0x3;
1248 pc = read_memory_integer (saved_regs[RP_REGNUM],
1249 TARGET_PTR_BIT / 8) & ~0x3;
1251 else if (rp_offset == 0)
1254 pc = read_register (RP_REGNUM) & ~0x3;
1259 pc = read_memory_integer (get_frame_base (frame) + rp_offset,
1260 TARGET_PTR_BIT / 8) & ~0x3;
1264 /* If PC is inside a linker stub, then dig out the address the stub
1267 Don't do this for long branch stubs. Why? For some unknown reason
1268 _start is marked as a long branch stub in hpux10. */
1269 u = find_unwind_entry (pc);
1270 if (u && u->stub_unwind.stub_type != 0
1271 && u->stub_unwind.stub_type != LONG_BRANCH)
1275 /* If this is a dynamic executable, and we're in a signal handler,
1276 then the call chain will eventually point us into the stub for
1277 _sigreturn. Unlike most cases, we'll be pointed to the branch
1278 to the real sigreturn rather than the code after the real branch!.
1280 Else, try to dig the address the stub will return to in the normal
1282 insn = read_memory_integer (pc, 4);
1283 if ((insn & 0xfc00e000) == 0xe8000000)
1284 return (pc + extract_17 (insn) + 8) & ~0x3;
1290 if (spun_around_loop > 1)
1292 /* We're just about to go around the loop again with
1293 no more hope of success. Die. */
1294 error ("Unable to find return pc for this frame");
1304 /* We need to correct the PC and the FP for the outermost frame when we are
1305 in a system call. */
1308 hppa_init_extra_frame_info (int fromleaf, struct frame_info *frame)
1313 if (get_next_frame (frame) && !fromleaf)
1316 /* If the next frame represents a frameless function invocation then
1317 we have to do some adjustments that are normally done by
1318 DEPRECATED_FRAME_CHAIN. (DEPRECATED_FRAME_CHAIN is not called in
1322 /* Find the framesize of *this* frame without peeking at the PC
1323 in the current frame structure (it isn't set yet). */
1324 framesize = find_proc_framesize (DEPRECATED_FRAME_SAVED_PC (get_next_frame (frame)));
1326 /* Now adjust our base frame accordingly. If we have a frame pointer
1327 use it, else subtract the size of this frame from the current
1328 frame. (we always want frame->frame to point at the lowest address
1330 if (framesize == -1)
1331 deprecated_update_frame_base_hack (frame, deprecated_read_fp ());
1333 deprecated_update_frame_base_hack (frame, get_frame_base (frame) - framesize);
1337 flags = read_register (FLAGS_REGNUM);
1338 if (flags & 2) /* In system call? */
1339 deprecated_update_frame_pc_hack (frame, read_register (31) & ~0x3);
1341 /* The outermost frame is always derived from PC-framesize
1343 One might think frameless innermost frames should have
1344 a frame->frame that is the same as the parent's frame->frame.
1345 That is wrong; frame->frame in that case should be the *high*
1346 address of the parent's frame. It's complicated as hell to
1347 explain, but the parent *always* creates some stack space for
1348 the child. So the child actually does have a frame of some
1349 sorts, and its base is the high address in its parent's frame. */
1350 framesize = find_proc_framesize (get_frame_pc (frame));
1351 if (framesize == -1)
1352 deprecated_update_frame_base_hack (frame, deprecated_read_fp ());
1354 deprecated_update_frame_base_hack (frame, read_register (SP_REGNUM) - framesize);
1357 /* Given a GDB frame, determine the address of the calling function's
1358 frame. This will be used to create a new GDB frame struct, and
1359 then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
1360 will be called for the new frame.
1362 This may involve searching through prologues for several functions
1363 at boundaries where GCC calls HP C code, or where code which has
1364 a frame pointer calls code without a frame pointer. */
1367 hppa_frame_chain (struct frame_info *frame)
1369 int my_framesize, caller_framesize;
1370 struct unwind_table_entry *u;
1371 CORE_ADDR frame_base;
1372 struct frame_info *tmp_frame;
1374 /* A frame in the current frame list, or zero. */
1375 struct frame_info *saved_regs_frame = 0;
1376 /* Where the registers were saved in saved_regs_frame. If
1377 saved_regs_frame is zero, this is garbage. */
1378 CORE_ADDR *saved_regs = NULL;
1380 CORE_ADDR caller_pc;
1382 struct minimal_symbol *min_frame_symbol;
1383 struct symbol *frame_symbol;
1384 char *frame_symbol_name;
1386 /* If this is a threaded application, and we see the
1387 routine "__pthread_exit", treat it as the stack root
1389 min_frame_symbol = lookup_minimal_symbol_by_pc (get_frame_pc (frame));
1390 frame_symbol = find_pc_function (get_frame_pc (frame));
1392 if ((min_frame_symbol != 0) /* && (frame_symbol == 0) */ )
1394 /* The test above for "no user function name" would defend
1395 against the slim likelihood that a user might define a
1396 routine named "__pthread_exit" and then try to debug it.
1398 If it weren't commented out, and you tried to debug the
1399 pthread library itself, you'd get errors.
1401 So for today, we don't make that check. */
1402 frame_symbol_name = DEPRECATED_SYMBOL_NAME (min_frame_symbol);
1403 if (frame_symbol_name != 0)
1405 if (0 == strncmp (frame_symbol_name,
1406 THREAD_INITIAL_FRAME_SYMBOL,
1407 THREAD_INITIAL_FRAME_SYM_LEN))
1409 /* Pretend we've reached the bottom of the stack. */
1410 return (CORE_ADDR) 0;
1413 } /* End of hacky code for threads. */
1415 /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
1416 are easy; at *sp we have a full save state strucutre which we can
1417 pull the old stack pointer from. Also see frame_saved_pc for
1418 code to dig a saved PC out of the save state structure. */
1419 if (pc_in_interrupt_handler (get_frame_pc (frame)))
1420 frame_base = read_memory_integer (get_frame_base (frame) + SP_REGNUM * 4,
1421 TARGET_PTR_BIT / 8);
1422 #ifdef FRAME_BASE_BEFORE_SIGTRAMP
1423 else if ((get_frame_type (frame) == SIGTRAMP_FRAME))
1425 FRAME_BASE_BEFORE_SIGTRAMP (frame, &frame_base);
1429 frame_base = get_frame_base (frame);
1431 /* Get frame sizes for the current frame and the frame of the
1433 my_framesize = find_proc_framesize (get_frame_pc (frame));
1434 caller_pc = DEPRECATED_FRAME_SAVED_PC (frame);
1436 /* If we can't determine the caller's PC, then it's not likely we can
1437 really determine anything meaningful about its frame. We'll consider
1438 this to be stack bottom. */
1439 if (caller_pc == (CORE_ADDR) 0)
1440 return (CORE_ADDR) 0;
1442 caller_framesize = find_proc_framesize (DEPRECATED_FRAME_SAVED_PC (frame));
1444 /* If caller does not have a frame pointer, then its frame
1445 can be found at current_frame - caller_framesize. */
1446 if (caller_framesize != -1)
1448 return frame_base - caller_framesize;
1450 /* Both caller and callee have frame pointers and are GCC compiled
1451 (SAVE_SP bit in unwind descriptor is on for both functions.
1452 The previous frame pointer is found at the top of the current frame. */
1453 if (caller_framesize == -1 && my_framesize == -1)
1455 return read_memory_integer (frame_base, TARGET_PTR_BIT / 8);
1457 /* Caller has a frame pointer, but callee does not. This is a little
1458 more difficult as GCC and HP C lay out locals and callee register save
1459 areas very differently.
1461 The previous frame pointer could be in a register, or in one of
1462 several areas on the stack.
1464 Walk from the current frame to the innermost frame examining
1465 unwind descriptors to determine if %r3 ever gets saved into the
1466 stack. If so return whatever value got saved into the stack.
1467 If it was never saved in the stack, then the value in %r3 is still
1470 We use information from unwind descriptors to determine if %r3
1471 is saved into the stack (Entry_GR field has this information). */
1473 for (tmp_frame = frame; tmp_frame; tmp_frame = get_next_frame (tmp_frame))
1475 u = find_unwind_entry (get_frame_pc (tmp_frame));
1479 /* We could find this information by examining prologues. I don't
1480 think anyone has actually written any tools (not even "strip")
1481 which leave them out of an executable, so maybe this is a moot
1483 /* ??rehrauer: Actually, it's quite possible to stepi your way into
1484 code that doesn't have unwind entries. For example, stepping into
1485 the dynamic linker will give you a PC that has none. Thus, I've
1486 disabled this warning. */
1488 warning ("Unable to find unwind for PC 0x%x -- Help!", get_frame_pc (tmp_frame));
1490 return (CORE_ADDR) 0;
1494 || (get_frame_type (tmp_frame) == SIGTRAMP_FRAME)
1495 || pc_in_interrupt_handler (get_frame_pc (tmp_frame)))
1498 /* Entry_GR specifies the number of callee-saved general registers
1499 saved in the stack. It starts at %r3, so %r3 would be 1. */
1500 if (u->Entry_GR >= 1)
1502 /* The unwind entry claims that r3 is saved here. However,
1503 in optimized code, GCC often doesn't actually save r3.
1504 We'll discover this if we look at the prologue. */
1505 hppa_frame_init_saved_regs (tmp_frame);
1506 saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
1507 saved_regs_frame = tmp_frame;
1509 /* If we have an address for r3, that's good. */
1510 if (saved_regs[DEPRECATED_FP_REGNUM])
1517 /* We may have walked down the chain into a function with a frame
1520 && !(get_frame_type (tmp_frame) == SIGTRAMP_FRAME)
1521 && !pc_in_interrupt_handler (get_frame_pc (tmp_frame)))
1523 return read_memory_integer (get_frame_base (tmp_frame), TARGET_PTR_BIT / 8);
1525 /* %r3 was saved somewhere in the stack. Dig it out. */
1530 For optimization purposes many kernels don't have the
1531 callee saved registers into the save_state structure upon
1532 entry into the kernel for a syscall; the optimization
1533 is usually turned off if the process is being traced so
1534 that the debugger can get full register state for the
1537 This scheme works well except for two cases:
1539 * Attaching to a process when the process is in the
1540 kernel performing a system call (debugger can't get
1541 full register state for the inferior process since
1542 the process wasn't being traced when it entered the
1545 * Register state is not complete if the system call
1546 causes the process to core dump.
1549 The following heinous code is an attempt to deal with
1550 the lack of register state in a core dump. It will
1551 fail miserably if the function which performs the
1552 system call has a variable sized stack frame. */
1554 if (tmp_frame != saved_regs_frame)
1556 hppa_frame_init_saved_regs (tmp_frame);
1557 saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
1560 /* Abominable hack. */
1561 if (current_target.to_has_execution == 0
1562 && ((saved_regs[FLAGS_REGNUM]
1563 && (read_memory_integer (saved_regs[FLAGS_REGNUM],
1566 || (saved_regs[FLAGS_REGNUM] == 0
1567 && read_register (FLAGS_REGNUM) & 0x2)))
1569 u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
1572 return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
1573 TARGET_PTR_BIT / 8);
1577 return frame_base - (u->Total_frame_size << 3);
1581 return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
1582 TARGET_PTR_BIT / 8);
1587 /* Get the innermost frame. */
1589 while (get_next_frame (tmp_frame) != NULL)
1590 tmp_frame = get_next_frame (tmp_frame);
1592 if (tmp_frame != saved_regs_frame)
1594 hppa_frame_init_saved_regs (tmp_frame);
1595 saved_regs = deprecated_get_frame_saved_regs (tmp_frame);
1598 /* Abominable hack. See above. */
1599 if (current_target.to_has_execution == 0
1600 && ((saved_regs[FLAGS_REGNUM]
1601 && (read_memory_integer (saved_regs[FLAGS_REGNUM],
1604 || (saved_regs[FLAGS_REGNUM] == 0
1605 && read_register (FLAGS_REGNUM) & 0x2)))
1607 u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
1610 return read_memory_integer (saved_regs[DEPRECATED_FP_REGNUM],
1611 TARGET_PTR_BIT / 8);
1615 return frame_base - (u->Total_frame_size << 3);
1619 /* The value in %r3 was never saved into the stack (thus %r3 still
1620 holds the value of the previous frame pointer). */
1621 return deprecated_read_fp ();
1626 /* To see if a frame chain is valid, see if the caller looks like it
1627 was compiled with gcc. */
1630 hppa_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
1632 struct minimal_symbol *msym_us;
1633 struct minimal_symbol *msym_start;
1634 struct unwind_table_entry *u, *next_u = NULL;
1635 struct frame_info *next;
1637 u = find_unwind_entry (get_frame_pc (thisframe));
1642 /* We can't just check that the same of msym_us is "_start", because
1643 someone idiotically decided that they were going to make a Ltext_end
1644 symbol with the same address. This Ltext_end symbol is totally
1645 indistinguishable (as nearly as I can tell) from the symbol for a function
1646 which is (legitimately, since it is in the user's namespace)
1647 named Ltext_end, so we can't just ignore it. */
1648 msym_us = lookup_minimal_symbol_by_pc (DEPRECATED_FRAME_SAVED_PC (thisframe));
1649 msym_start = lookup_minimal_symbol ("_start", NULL, NULL);
1652 && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
1655 /* Grrrr. Some new idiot decided that they don't want _start for the
1656 PRO configurations; $START$ calls main directly.... Deal with it. */
1657 msym_start = lookup_minimal_symbol ("$START$", NULL, NULL);
1660 && SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
1663 next = get_next_frame (thisframe);
1665 next_u = find_unwind_entry (get_frame_pc (next));
1667 /* If this frame does not save SP, has no stack, isn't a stub,
1668 and doesn't "call" an interrupt routine or signal handler caller,
1669 then its not valid. */
1670 if (u->Save_SP || u->Total_frame_size || u->stub_unwind.stub_type != 0
1671 || (get_next_frame (thisframe) && (get_frame_type (get_next_frame (thisframe)) == SIGTRAMP_FRAME))
1672 || (next_u && next_u->HP_UX_interrupt_marker))
1675 if (pc_in_linker_stub (get_frame_pc (thisframe)))
1681 /* These functions deal with saving and restoring register state
1682 around a function call in the inferior. They keep the stack
1683 double-word aligned; eventually, on an hp700, the stack will have
1684 to be aligned to a 64-byte boundary. */
1687 hppa_push_dummy_frame (void)
1689 CORE_ADDR sp, pc, pcspace;
1691 CORE_ADDR int_buffer;
1694 pc = hppa_target_read_pc (inferior_ptid);
1695 int_buffer = read_register (FLAGS_REGNUM);
1696 if (int_buffer & 0x2)
1698 const unsigned int sid = (pc >> 30) & 0x3;
1700 pcspace = read_register (SR4_REGNUM);
1702 pcspace = read_register (SR4_REGNUM + 4 + sid);
1705 pcspace = read_register (PCSQ_HEAD_REGNUM);
1707 /* Space for "arguments"; the RP goes in here. */
1708 sp = read_register (SP_REGNUM) + 48;
1709 int_buffer = read_register (RP_REGNUM) | 0x3;
1711 /* The 32bit and 64bit ABIs save the return pointer into different
1713 if (DEPRECATED_REGISTER_SIZE == 8)
1714 write_memory (sp - 16, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
1716 write_memory (sp - 20, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
1718 int_buffer = deprecated_read_fp ();
1719 write_memory (sp, (char *) &int_buffer, DEPRECATED_REGISTER_SIZE);
1721 write_register (DEPRECATED_FP_REGNUM, sp);
1723 sp += 2 * DEPRECATED_REGISTER_SIZE;
1725 for (regnum = 1; regnum < 32; regnum++)
1726 if (regnum != RP_REGNUM && regnum != DEPRECATED_FP_REGNUM)
1727 sp = push_word (sp, read_register (regnum));
1729 /* This is not necessary for the 64bit ABI. In fact it is dangerous. */
1730 if (DEPRECATED_REGISTER_SIZE != 8)
1733 for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
1735 deprecated_read_register_bytes (DEPRECATED_REGISTER_BYTE (regnum),
1736 (char *) &freg_buffer, 8);
1737 sp = push_bytes (sp, (char *) &freg_buffer, 8);
1739 sp = push_word (sp, read_register (IPSW_REGNUM));
1740 sp = push_word (sp, read_register (SAR_REGNUM));
1741 sp = push_word (sp, pc);
1742 sp = push_word (sp, pcspace);
1743 sp = push_word (sp, pc + 4);
1744 sp = push_word (sp, pcspace);
1745 write_register (SP_REGNUM, sp);
1749 find_dummy_frame_regs (struct frame_info *frame,
1750 CORE_ADDR frame_saved_regs[])
1752 CORE_ADDR fp = get_frame_base (frame);
1755 /* The 32bit and 64bit ABIs save RP into different locations. */
1756 if (DEPRECATED_REGISTER_SIZE == 8)
1757 frame_saved_regs[RP_REGNUM] = (fp - 16) & ~0x3;
1759 frame_saved_regs[RP_REGNUM] = (fp - 20) & ~0x3;
1761 frame_saved_regs[DEPRECATED_FP_REGNUM] = fp;
1763 frame_saved_regs[1] = fp + (2 * DEPRECATED_REGISTER_SIZE);
1765 for (fp += 3 * DEPRECATED_REGISTER_SIZE, i = 3; i < 32; i++)
1767 if (i != DEPRECATED_FP_REGNUM)
1769 frame_saved_regs[i] = fp;
1770 fp += DEPRECATED_REGISTER_SIZE;
1774 /* This is not necessary or desirable for the 64bit ABI. */
1775 if (DEPRECATED_REGISTER_SIZE != 8)
1778 for (i = FP0_REGNUM; i < NUM_REGS; i++, fp += 8)
1779 frame_saved_regs[i] = fp;
1781 frame_saved_regs[IPSW_REGNUM] = fp;
1782 frame_saved_regs[SAR_REGNUM] = fp + DEPRECATED_REGISTER_SIZE;
1783 frame_saved_regs[PCOQ_HEAD_REGNUM] = fp + 2 * DEPRECATED_REGISTER_SIZE;
1784 frame_saved_regs[PCSQ_HEAD_REGNUM] = fp + 3 * DEPRECATED_REGISTER_SIZE;
1785 frame_saved_regs[PCOQ_TAIL_REGNUM] = fp + 4 * DEPRECATED_REGISTER_SIZE;
1786 frame_saved_regs[PCSQ_TAIL_REGNUM] = fp + 5 * DEPRECATED_REGISTER_SIZE;
1790 hppa_pop_frame (void)
1792 struct frame_info *frame = get_current_frame ();
1793 CORE_ADDR fp, npc, target_pc;
1798 fp = get_frame_base (frame);
1799 hppa_frame_init_saved_regs (frame);
1800 fsr = deprecated_get_frame_saved_regs (frame);
1802 #ifndef NO_PC_SPACE_QUEUE_RESTORE
1803 if (fsr[IPSW_REGNUM]) /* Restoring a call dummy frame */
1804 restore_pc_queue (fsr);
1807 for (regnum = 31; regnum > 0; regnum--)
1809 write_register (regnum, read_memory_integer (fsr[regnum],
1810 DEPRECATED_REGISTER_SIZE));
1812 for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
1815 read_memory (fsr[regnum], (char *) &freg_buffer, 8);
1816 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum),
1817 (char *) &freg_buffer, 8);
1820 if (fsr[IPSW_REGNUM])
1821 write_register (IPSW_REGNUM,
1822 read_memory_integer (fsr[IPSW_REGNUM],
1823 DEPRECATED_REGISTER_SIZE));
1825 if (fsr[SAR_REGNUM])
1826 write_register (SAR_REGNUM,
1827 read_memory_integer (fsr[SAR_REGNUM],
1828 DEPRECATED_REGISTER_SIZE));
1830 /* If the PC was explicitly saved, then just restore it. */
1831 if (fsr[PCOQ_TAIL_REGNUM])
1833 npc = read_memory_integer (fsr[PCOQ_TAIL_REGNUM],
1834 DEPRECATED_REGISTER_SIZE);
1835 write_register (PCOQ_TAIL_REGNUM, npc);
1837 /* Else use the value in %rp to set the new PC. */
1840 npc = read_register (RP_REGNUM);
1844 write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, DEPRECATED_REGISTER_SIZE));
1846 if (fsr[IPSW_REGNUM]) /* call dummy */
1847 write_register (SP_REGNUM, fp - 48);
1849 write_register (SP_REGNUM, fp);
1851 /* The PC we just restored may be inside a return trampoline. If so
1852 we want to restart the inferior and run it through the trampoline.
1854 Do this by setting a momentary breakpoint at the location the
1855 trampoline returns to.
1857 Don't skip through the trampoline if we're popping a dummy frame. */
1858 target_pc = SKIP_TRAMPOLINE_CODE (npc & ~0x3) & ~0x3;
1859 if (target_pc && !fsr[IPSW_REGNUM])
1861 struct symtab_and_line sal;
1862 struct breakpoint *breakpoint;
1863 struct cleanup *old_chain;
1865 /* Set up our breakpoint. Set it to be silent as the MI code
1866 for "return_command" will print the frame we returned to. */
1867 sal = find_pc_line (target_pc, 0);
1869 breakpoint = set_momentary_breakpoint (sal, null_frame_id, bp_finish);
1870 breakpoint->silent = 1;
1872 /* So we can clean things up. */
1873 old_chain = make_cleanup_delete_breakpoint (breakpoint);
1875 /* Start up the inferior. */
1876 clear_proceed_status ();
1877 proceed_to_finish = 1;
1878 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
1880 /* Perform our cleanups. */
1881 do_cleanups (old_chain);
1883 flush_cached_frames ();
1886 /* After returning to a dummy on the stack, restore the instruction
1887 queue space registers. */
1890 restore_pc_queue (CORE_ADDR *fsr)
1892 CORE_ADDR pc = read_pc ();
1893 CORE_ADDR new_pc = read_memory_integer (fsr[PCOQ_HEAD_REGNUM],
1894 TARGET_PTR_BIT / 8);
1895 struct target_waitstatus w;
1898 /* Advance past break instruction in the call dummy. */
1899 write_register (PCOQ_HEAD_REGNUM, pc + 4);
1900 write_register (PCOQ_TAIL_REGNUM, pc + 8);
1902 /* HPUX doesn't let us set the space registers or the space
1903 registers of the PC queue through ptrace. Boo, hiss.
1904 Conveniently, the call dummy has this sequence of instructions
1909 So, load up the registers and single step until we are in the
1912 write_register (21, read_memory_integer (fsr[PCSQ_HEAD_REGNUM],
1913 DEPRECATED_REGISTER_SIZE));
1914 write_register (22, new_pc);
1916 for (insn_count = 0; insn_count < 3; insn_count++)
1918 /* FIXME: What if the inferior gets a signal right now? Want to
1919 merge this into wait_for_inferior (as a special kind of
1920 watchpoint? By setting a breakpoint at the end? Is there
1921 any other choice? Is there *any* way to do this stuff with
1922 ptrace() or some equivalent?). */
1924 target_wait (inferior_ptid, &w);
1926 if (w.kind == TARGET_WAITKIND_SIGNALLED)
1928 stop_signal = w.value.sig;
1929 terminal_ours_for_output ();
1930 printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
1931 target_signal_to_name (stop_signal),
1932 target_signal_to_string (stop_signal));
1933 gdb_flush (gdb_stdout);
1937 target_terminal_ours ();
1938 target_fetch_registers (-1);
1943 #ifdef PA20W_CALLING_CONVENTIONS
1945 /* This function pushes a stack frame with arguments as part of the
1946 inferior function calling mechanism.
1948 This is the version for the PA64, in which later arguments appear
1949 at higher addresses. (The stack always grows towards higher
1952 We simply allocate the appropriate amount of stack space and put
1953 arguments into their proper slots. The call dummy code will copy
1954 arguments into registers as needed by the ABI.
1956 This ABI also requires that the caller provide an argument pointer
1957 to the callee, so we do that too. */
1960 hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1961 int struct_return, CORE_ADDR struct_addr)
1963 /* array of arguments' offsets */
1964 int *offset = (int *) alloca (nargs * sizeof (int));
1966 /* array of arguments' lengths: real lengths in bytes, not aligned to
1968 int *lengths = (int *) alloca (nargs * sizeof (int));
1970 /* The value of SP as it was passed into this function after
1972 CORE_ADDR orig_sp = DEPRECATED_STACK_ALIGN (sp);
1974 /* The number of stack bytes occupied by the current argument. */
1977 /* The total number of bytes reserved for the arguments. */
1978 int cum_bytes_reserved = 0;
1980 /* Similarly, but aligned. */
1981 int cum_bytes_aligned = 0;
1984 /* Iterate over each argument provided by the user. */
1985 for (i = 0; i < nargs; i++)
1987 struct type *arg_type = VALUE_TYPE (args[i]);
1989 /* Integral scalar values smaller than a register are padded on
1990 the left. We do this by promoting them to full-width,
1991 although the ABI says to pad them with garbage. */
1992 if (is_integral_type (arg_type)
1993 && TYPE_LENGTH (arg_type) < DEPRECATED_REGISTER_SIZE)
1995 args[i] = value_cast ((TYPE_UNSIGNED (arg_type)
1996 ? builtin_type_unsigned_long
1997 : builtin_type_long),
1999 arg_type = VALUE_TYPE (args[i]);
2002 lengths[i] = TYPE_LENGTH (arg_type);
2004 /* Align the size of the argument to the word size for this
2006 bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
2008 offset[i] = cum_bytes_reserved;
2010 /* Aggregates larger than eight bytes (the only types larger
2011 than eight bytes we have) are aligned on a 16-byte boundary,
2012 possibly padded on the right with garbage. This may leave an
2013 empty word on the stack, and thus an unused register, as per
2015 if (bytes_reserved > 8)
2017 /* Round up the offset to a multiple of two slots. */
2018 int new_offset = ((offset[i] + 2*DEPRECATED_REGISTER_SIZE-1)
2019 & -(2*DEPRECATED_REGISTER_SIZE));
2021 /* Note the space we've wasted, if any. */
2022 bytes_reserved += new_offset - offset[i];
2023 offset[i] = new_offset;
2026 cum_bytes_reserved += bytes_reserved;
2029 /* CUM_BYTES_RESERVED already accounts for all the arguments
2030 passed by the user. However, the ABIs mandate minimum stack space
2031 allocations for outgoing arguments.
2033 The ABIs also mandate minimum stack alignments which we must
2035 cum_bytes_aligned = DEPRECATED_STACK_ALIGN (cum_bytes_reserved);
2036 sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
2038 /* Now write each of the args at the proper offset down the stack. */
2039 for (i = 0; i < nargs; i++)
2040 write_memory (orig_sp + offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
2042 /* If a structure has to be returned, set up register 28 to hold its
2045 write_register (28, struct_addr);
2047 /* For the PA64 we must pass a pointer to the outgoing argument list.
2048 The ABI mandates that the pointer should point to the first byte of
2049 storage beyond the register flushback area.
2051 However, the call dummy expects the outgoing argument pointer to
2052 be passed in register %r4. */
2053 write_register (4, orig_sp + REG_PARM_STACK_SPACE);
2055 /* ?!? This needs further work. We need to set up the global data
2056 pointer for this procedure. This assumes the same global pointer
2057 for every procedure. The call dummy expects the dp value to
2058 be passed in register %r6. */
2059 write_register (6, read_register (27));
2061 /* The stack will have 64 bytes of additional space for a frame marker. */
2067 /* This function pushes a stack frame with arguments as part of the
2068 inferior function calling mechanism.
2070 This is the version of the function for the 32-bit PA machines, in
2071 which later arguments appear at lower addresses. (The stack always
2072 grows towards higher addresses.)
2074 We simply allocate the appropriate amount of stack space and put
2075 arguments into their proper slots. The call dummy code will copy
2076 arguments into registers as needed by the ABI. */
2079 hppa_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
2080 int struct_return, CORE_ADDR struct_addr)
2082 /* array of arguments' offsets */
2083 int *offset = (int *) alloca (nargs * sizeof (int));
2085 /* array of arguments' lengths: real lengths in bytes, not aligned to
2087 int *lengths = (int *) alloca (nargs * sizeof (int));
2089 /* The number of stack bytes occupied by the current argument. */
2092 /* The total number of bytes reserved for the arguments. */
2093 int cum_bytes_reserved = 0;
2095 /* Similarly, but aligned. */
2096 int cum_bytes_aligned = 0;
2099 /* Iterate over each argument provided by the user. */
2100 for (i = 0; i < nargs; i++)
2102 lengths[i] = TYPE_LENGTH (VALUE_TYPE (args[i]));
2104 /* Align the size of the argument to the word size for this
2106 bytes_reserved = (lengths[i] + DEPRECATED_REGISTER_SIZE - 1) & -DEPRECATED_REGISTER_SIZE;
2108 offset[i] = (cum_bytes_reserved
2109 + (lengths[i] > 4 ? bytes_reserved : lengths[i]));
2111 /* If the argument is a double word argument, then it needs to be
2112 double word aligned. */
2113 if ((bytes_reserved == 2 * DEPRECATED_REGISTER_SIZE)
2114 && (offset[i] % 2 * DEPRECATED_REGISTER_SIZE))
2117 /* BYTES_RESERVED is already aligned to the word, so we put
2118 the argument at one word more down the stack.
2120 This will leave one empty word on the stack, and one unused
2121 register as mandated by the ABI. */
2122 new_offset = ((offset[i] + 2 * DEPRECATED_REGISTER_SIZE - 1)
2123 & -(2 * DEPRECATED_REGISTER_SIZE));
2125 if ((new_offset - offset[i]) >= 2 * DEPRECATED_REGISTER_SIZE)
2127 bytes_reserved += DEPRECATED_REGISTER_SIZE;
2128 offset[i] += DEPRECATED_REGISTER_SIZE;
2132 cum_bytes_reserved += bytes_reserved;
2136 /* CUM_BYTES_RESERVED already accounts for all the arguments passed
2137 by the user. However, the ABI mandates minimum stack space
2138 allocations for outgoing arguments.
2140 The ABI also mandates minimum stack alignments which we must
2142 cum_bytes_aligned = DEPRECATED_STACK_ALIGN (cum_bytes_reserved);
2143 sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
2145 /* Now write each of the args at the proper offset down the stack.
2146 ?!? We need to promote values to a full register instead of skipping
2147 words in the stack. */
2148 for (i = 0; i < nargs; i++)
2149 write_memory (sp - offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
2151 /* If a structure has to be returned, set up register 28 to hold its
2154 write_register (28, struct_addr);
2156 /* The stack will have 32 bytes of additional space for a frame marker. */
2162 /* This function pushes a stack frame with arguments as part of the
2163 inferior function calling mechanism.
2165 This is the version of the function for the 32-bit PA machines, in
2166 which later arguments appear at lower addresses. (The stack always
2167 grows towards higher addresses.)
2169 We simply allocate the appropriate amount of stack space and put
2170 arguments into their proper slots. */
2173 hppa32_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
2174 struct regcache *regcache, CORE_ADDR bp_addr,
2175 int nargs, struct value **args, CORE_ADDR sp,
2176 int struct_return, CORE_ADDR struct_addr)
2178 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
2179 reverse engineering testsuite failures. */
2181 /* Stack base address at which any pass-by-reference parameters are
2183 CORE_ADDR struct_end = 0;
2184 /* Stack base address at which the first parameter is stored. */
2185 CORE_ADDR param_end = 0;
2187 /* The inner most end of the stack after all the parameters have
2189 CORE_ADDR new_sp = 0;
2191 /* Two passes. First pass computes the location of everything,
2192 second pass writes the bytes out. */
2194 for (write_pass = 0; write_pass < 2; write_pass++)
2196 CORE_ADDR struct_ptr = 0;
2197 CORE_ADDR param_ptr = 0;
2198 int reg = 27; /* NOTE: Registers go down. */
2200 for (i = 0; i < nargs; i++)
2202 struct value *arg = args[i];
2203 struct type *type = check_typedef (VALUE_TYPE (arg));
2204 /* The corresponding parameter that is pushed onto the
2205 stack, and [possibly] passed in a register. */
2208 memset (param_val, 0, sizeof param_val);
2209 if (TYPE_LENGTH (type) > 8)
2211 /* Large parameter, pass by reference. Store the value
2212 in "struct" area and then pass its address. */
2214 struct_ptr += align_up (TYPE_LENGTH (type), 8);
2216 write_memory (struct_end - struct_ptr, VALUE_CONTENTS (arg),
2217 TYPE_LENGTH (type));
2218 store_unsigned_integer (param_val, 4, struct_end - struct_ptr);
2220 else if (TYPE_CODE (type) == TYPE_CODE_INT
2221 || TYPE_CODE (type) == TYPE_CODE_ENUM)
2223 /* Integer value store, right aligned. "unpack_long"
2224 takes care of any sign-extension problems. */
2225 param_len = align_up (TYPE_LENGTH (type), 4);
2226 store_unsigned_integer (param_val, param_len,
2228 VALUE_CONTENTS (arg)));
2232 /* Small struct value, store right aligned? */
2233 param_len = align_up (TYPE_LENGTH (type), 4);
2234 memcpy (param_val + param_len - TYPE_LENGTH (type),
2235 VALUE_CONTENTS (arg), TYPE_LENGTH (type));
2237 param_ptr += param_len;
2238 reg -= param_len / 4;
2241 write_memory (param_end - param_ptr, param_val, param_len);
2244 regcache_cooked_write (regcache, reg, param_val);
2246 regcache_cooked_write (regcache, reg + 1, param_val + 4);
2251 /* Update the various stack pointers. */
2254 struct_end = sp + struct_ptr;
2255 /* PARAM_PTR already accounts for all the arguments passed
2256 by the user. However, the ABI mandates minimum stack
2257 space allocations for outgoing arguments. The ABI also
2258 mandates minimum stack alignments which we must
2260 param_end = struct_end + max (align_up (param_ptr, 8),
2261 REG_PARM_STACK_SPACE);
2265 /* If a structure has to be returned, set up register 28 to hold its
2268 write_register (28, struct_addr);
2270 /* Set the return address. */
2271 regcache_cooked_write_unsigned (regcache, RP_REGNUM, bp_addr);
2273 /* The stack will have 32 bytes of additional space for a frame marker. */
2274 return param_end + 32;
2277 /* This function pushes a stack frame with arguments as part of the
2278 inferior function calling mechanism.
2280 This is the version for the PA64, in which later arguments appear
2281 at higher addresses. (The stack always grows towards higher
2284 We simply allocate the appropriate amount of stack space and put
2285 arguments into their proper slots.
2287 This ABI also requires that the caller provide an argument pointer
2288 to the callee, so we do that too. */
2291 hppa64_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
2292 struct regcache *regcache, CORE_ADDR bp_addr,
2293 int nargs, struct value **args, CORE_ADDR sp,
2294 int struct_return, CORE_ADDR struct_addr)
2296 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
2297 reverse engineering testsuite failures. */
2299 /* Stack base address at which any pass-by-reference parameters are
2301 CORE_ADDR struct_end = 0;
2302 /* Stack base address at which the first parameter is stored. */
2303 CORE_ADDR param_end = 0;
2305 /* The inner most end of the stack after all the parameters have
2307 CORE_ADDR new_sp = 0;
2309 /* Two passes. First pass computes the location of everything,
2310 second pass writes the bytes out. */
2312 for (write_pass = 0; write_pass < 2; write_pass++)
2314 CORE_ADDR struct_ptr = 0;
2315 CORE_ADDR param_ptr = 0;
2317 for (i = 0; i < nargs; i++)
2319 struct value *arg = args[i];
2320 struct type *type = check_typedef (VALUE_TYPE (arg));
2321 if ((TYPE_CODE (type) == TYPE_CODE_INT
2322 || TYPE_CODE (type) == TYPE_CODE_ENUM)
2323 && TYPE_LENGTH (type) <= 8)
2325 /* Integer value store, right aligned. "unpack_long"
2326 takes care of any sign-extension problems. */
2330 ULONGEST val = unpack_long (type, VALUE_CONTENTS (arg));
2331 int reg = 27 - param_ptr / 8;
2332 write_memory_unsigned_integer (param_end - param_ptr,
2335 regcache_cooked_write_unsigned (regcache, reg, val);
2340 /* Small struct value, store left aligned? */
2342 if (TYPE_LENGTH (type) > 8)
2344 param_ptr = align_up (param_ptr, 16);
2345 reg = 26 - param_ptr / 8;
2346 param_ptr += align_up (TYPE_LENGTH (type), 16);
2350 param_ptr = align_up (param_ptr, 8);
2351 reg = 26 - param_ptr / 8;
2352 param_ptr += align_up (TYPE_LENGTH (type), 8);
2357 write_memory (param_end - param_ptr, VALUE_CONTENTS (arg),
2358 TYPE_LENGTH (type));
2359 for (byte = 0; byte < TYPE_LENGTH (type); byte += 8)
2363 int len = min (8, TYPE_LENGTH (type) - byte);
2364 regcache_cooked_write_part (regcache, reg, 0, len,
2365 VALUE_CONTENTS (arg) + byte);
2372 /* Update the various stack pointers. */
2375 struct_end = sp + struct_ptr;
2376 /* PARAM_PTR already accounts for all the arguments passed
2377 by the user. However, the ABI mandates minimum stack
2378 space allocations for outgoing arguments. The ABI also
2379 mandates minimum stack alignments which we must
2381 param_end = struct_end + max (align_up (param_ptr, 16),
2382 REG_PARM_STACK_SPACE);
2386 /* If a structure has to be returned, set up register 28 to hold its
2389 write_register (28, struct_addr);
2391 /* Set the return address. */
2392 regcache_cooked_write_unsigned (regcache, RP_REGNUM, bp_addr);
2394 /* The stack will have 32 bytes of additional space for a frame marker. */
2395 return param_end + 64;
2399 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2401 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
2403 return align_up (addr, 64);
2406 /* Force all frames to 16-byte alignment. Better safe than sorry. */
2409 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
2411 /* Just always 16-byte align. */
2412 return align_up (addr, 16);
2416 /* elz: Used to lookup a symbol in the shared libraries.
2417 This function calls shl_findsym, indirectly through a
2418 call to __d_shl_get. __d_shl_get is in end.c, which is always
2419 linked in by the hp compilers/linkers.
2420 The call to shl_findsym cannot be made directly because it needs
2421 to be active in target address space.
2422 inputs: - minimal symbol pointer for the function we want to look up
2423 - address in target space of the descriptor for the library
2424 where we want to look the symbol up.
2425 This address is retrieved using the
2426 som_solib_get_solib_by_pc function (somsolib.c).
2427 output: - real address in the library of the function.
2428 note: the handle can be null, in which case shl_findsym will look for
2429 the symbol in all the loaded shared libraries.
2430 files to look at if you need reference on this stuff:
2431 dld.c, dld_shl_findsym.c
2433 man entry for shl_findsym */
2436 find_stub_with_shl_get (struct minimal_symbol *function, CORE_ADDR handle)
2438 struct symbol *get_sym, *symbol2;
2439 struct minimal_symbol *buff_minsym, *msymbol;
2441 struct value **args;
2442 struct value *funcval;
2445 int x, namelen, err_value, tmp = -1;
2446 CORE_ADDR endo_buff_addr, value_return_addr, errno_return_addr;
2447 CORE_ADDR stub_addr;
2450 args = alloca (sizeof (struct value *) * 8); /* 6 for the arguments and one null one??? */
2451 funcval = find_function_in_inferior ("__d_shl_get");
2452 get_sym = lookup_symbol ("__d_shl_get", NULL, VAR_DOMAIN, NULL, NULL);
2453 buff_minsym = lookup_minimal_symbol ("__buffer", NULL, NULL);
2454 msymbol = lookup_minimal_symbol ("__shldp", NULL, NULL);
2455 symbol2 = lookup_symbol ("__shldp", NULL, VAR_DOMAIN, NULL, NULL);
2456 endo_buff_addr = SYMBOL_VALUE_ADDRESS (buff_minsym);
2457 namelen = strlen (DEPRECATED_SYMBOL_NAME (function));
2458 value_return_addr = endo_buff_addr + namelen;
2459 ftype = check_typedef (SYMBOL_TYPE (get_sym));
2462 if ((x = value_return_addr % 64) != 0)
2463 value_return_addr = value_return_addr + 64 - x;
2465 errno_return_addr = value_return_addr + 64;
2468 /* set up stuff needed by __d_shl_get in buffer in end.o */
2470 target_write_memory (endo_buff_addr, DEPRECATED_SYMBOL_NAME (function), namelen);
2472 target_write_memory (value_return_addr, (char *) &tmp, 4);
2474 target_write_memory (errno_return_addr, (char *) &tmp, 4);
2476 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
2477 (char *) &handle, 4);
2479 /* now prepare the arguments for the call */
2481 args[0] = value_from_longest (TYPE_FIELD_TYPE (ftype, 0), 12);
2482 args[1] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 1), SYMBOL_VALUE_ADDRESS (msymbol));
2483 args[2] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 2), endo_buff_addr);
2484 args[3] = value_from_longest (TYPE_FIELD_TYPE (ftype, 3), TYPE_PROCEDURE);
2485 args[4] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 4), value_return_addr);
2486 args[5] = value_from_pointer (TYPE_FIELD_TYPE (ftype, 5), errno_return_addr);
2488 /* now call the function */
2490 val = call_function_by_hand (funcval, 6, args);
2492 /* now get the results */
2494 target_read_memory (errno_return_addr, (char *) &err_value, sizeof (err_value));
2496 target_read_memory (value_return_addr, (char *) &stub_addr, sizeof (stub_addr));
2498 error ("call to __d_shl_get failed, error code is %d", err_value);
2503 /* Cover routine for find_stub_with_shl_get to pass to catch_errors */
2505 cover_find_stub_with_shl_get (void *args_untyped)
2507 args_for_find_stub *args = args_untyped;
2508 args->return_val = find_stub_with_shl_get (args->msym, args->solib_handle);
2512 /* Insert the specified number of args and function address
2513 into a call sequence of the above form stored at DUMMYNAME.
2515 On the hppa we need to call the stack dummy through $$dyncall.
2516 Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra
2517 argument, real_pc, which is the location where gdb should start up
2518 the inferior to do the function call.
2520 This has to work across several versions of hpux, bsd, osf1. It has to
2521 work regardless of what compiler was used to build the inferior program.
2522 It should work regardless of whether or not end.o is available. It has
2523 to work even if gdb can not call into the dynamic loader in the inferior
2524 to query it for symbol names and addresses.
2526 Yes, all those cases should work. Luckily code exists to handle most
2527 of them. The complexity is in selecting exactly what scheme should
2528 be used to perform the inferior call.
2530 At the current time this routine is known not to handle cases where
2531 the program was linked with HP's compiler without including end.o.
2533 Please contact Jeff Law (law@cygnus.com) before changing this code. */
2536 hppa_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
2537 struct value **args, struct type *type, int gcc_p)
2539 CORE_ADDR dyncall_addr;
2540 struct minimal_symbol *msymbol;
2541 struct minimal_symbol *trampoline;
2542 int flags = read_register (FLAGS_REGNUM);
2543 struct unwind_table_entry *u = NULL;
2544 CORE_ADDR new_stub = 0;
2545 CORE_ADDR solib_handle = 0;
2547 /* Nonzero if we will use GCC's PLT call routine. This routine must be
2548 passed an import stub, not a PLABEL. It is also necessary to set %r19
2549 (the PIC register) before performing the call.
2551 If zero, then we are using __d_plt_call (HP's PLT call routine) or we
2552 are calling the target directly. When using __d_plt_call we want to
2553 use a PLABEL instead of an import stub. */
2554 int using_gcc_plt_call = 1;
2556 #ifdef GDB_TARGET_IS_HPPA_20W
2557 /* We currently use completely different code for the PA2.0W inferior
2558 function call sequences. This needs to be cleaned up. */
2560 CORE_ADDR pcsqh, pcsqt, pcoqh, pcoqt, sr5;
2561 struct target_waitstatus w;
2565 struct objfile *objfile;
2567 /* We can not modify the PC space queues directly, so we start
2568 up the inferior and execute a couple instructions to set the
2569 space queues so that they point to the call dummy in the stack. */
2570 pcsqh = read_register (PCSQ_HEAD_REGNUM);
2571 sr5 = read_register (SR5_REGNUM);
2574 pcoqh = read_register (PCOQ_HEAD_REGNUM);
2575 pcoqt = read_register (PCOQ_TAIL_REGNUM);
2576 if (target_read_memory (pcoqh, buf, 4) != 0)
2577 error ("Couldn't modify space queue\n");
2578 inst1 = extract_unsigned_integer (buf, 4);
2580 if (target_read_memory (pcoqt, buf, 4) != 0)
2581 error ("Couldn't modify space queue\n");
2582 inst2 = extract_unsigned_integer (buf, 4);
2585 *((int *) buf) = 0xe820d000;
2586 if (target_write_memory (pcoqh, buf, 4) != 0)
2587 error ("Couldn't modify space queue\n");
2590 *((int *) buf) = 0x08000240;
2591 if (target_write_memory (pcoqt, buf, 4) != 0)
2593 *((int *) buf) = inst1;
2594 target_write_memory (pcoqh, buf, 4);
2595 error ("Couldn't modify space queue\n");
2598 write_register (1, pc);
2600 /* Single step twice, the BVE instruction will set the space queue
2601 such that it points to the PC value written immediately above
2602 (ie the call dummy). */
2604 target_wait (inferior_ptid, &w);
2606 target_wait (inferior_ptid, &w);
2608 /* Restore the two instructions at the old PC locations. */
2609 *((int *) buf) = inst1;
2610 target_write_memory (pcoqh, buf, 4);
2611 *((int *) buf) = inst2;
2612 target_write_memory (pcoqt, buf, 4);
2615 /* The call dummy wants the ultimate destination address initially
2617 write_register (5, fun);
2619 /* We need to see if this objfile has a different DP value than our
2620 own (it could be a shared library for example). */
2621 ALL_OBJFILES (objfile)
2623 struct obj_section *s;
2624 obj_private_data_t *obj_private;
2626 /* See if FUN is in any section within this shared library. */
2627 for (s = objfile->sections; s < objfile->sections_end; s++)
2628 if (s->addr <= fun && fun < s->endaddr)
2631 if (s >= objfile->sections_end)
2634 obj_private = (obj_private_data_t *) objfile->obj_private;
2636 /* The DP value may be different for each objfile. But within an
2637 objfile each function uses the same dp value. Thus we do not need
2638 to grope around the opd section looking for dp values.
2640 ?!? This is not strictly correct since we may be in a shared library
2641 and want to call back into the main program. To make that case
2642 work correctly we need to set obj_private->dp for the main program's
2643 objfile, then remove this conditional. */
2644 if (obj_private->dp)
2645 write_register (27, obj_private->dp);
2652 #ifndef GDB_TARGET_IS_HPPA_20W
2653 /* Prefer __gcc_plt_call over the HP supplied routine because
2654 __gcc_plt_call works for any number of arguments. */
2656 if (lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL) == NULL)
2657 using_gcc_plt_call = 0;
2659 msymbol = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
2660 if (msymbol == NULL)
2661 error ("Can't find an address for $$dyncall trampoline");
2663 dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
2665 /* FUN could be a procedure label, in which case we have to get
2666 its real address and the value of its GOT/DP if we plan to
2667 call the routine via gcc_plt_call. */
2668 if ((fun & 0x2) && using_gcc_plt_call)
2670 /* Get the GOT/DP value for the target function. It's
2671 at *(fun+4). Note the call dummy is *NOT* allowed to
2672 trash %r19 before calling the target function. */
2673 write_register (19, read_memory_integer ((fun & ~0x3) + 4,
2674 DEPRECATED_REGISTER_SIZE));
2676 /* Now get the real address for the function we are calling, it's
2678 fun = (CORE_ADDR) read_memory_integer (fun & ~0x3,
2679 TARGET_PTR_BIT / 8);
2684 #ifndef GDB_TARGET_IS_PA_ELF
2685 /* FUN could be an export stub, the real address of a function, or
2686 a PLABEL. When using gcc's PLT call routine we must call an import
2687 stub rather than the export stub or real function for lazy binding
2690 If we are using the gcc PLT call routine, then we need to
2691 get the import stub for the target function. */
2692 if (using_gcc_plt_call && som_solib_get_got_by_pc (fun))
2694 struct objfile *objfile;
2695 struct minimal_symbol *funsymbol, *stub_symbol;
2696 CORE_ADDR newfun = 0;
2698 funsymbol = lookup_minimal_symbol_by_pc (fun);
2700 error ("Unable to find minimal symbol for target function.\n");
2702 /* Search all the object files for an import symbol with the
2704 ALL_OBJFILES (objfile)
2707 = lookup_minimal_symbol_solib_trampoline
2708 (DEPRECATED_SYMBOL_NAME (funsymbol), objfile);
2711 stub_symbol = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (funsymbol),
2714 /* Found a symbol with the right name. */
2717 struct unwind_table_entry *u;
2718 /* It must be a shared library trampoline. */
2719 if (MSYMBOL_TYPE (stub_symbol) != mst_solib_trampoline)
2722 /* It must also be an import stub. */
2723 u = find_unwind_entry (SYMBOL_VALUE (stub_symbol));
2725 || (u->stub_unwind.stub_type != IMPORT
2726 #ifdef GDB_NATIVE_HPUX_11
2727 /* Sigh. The hpux 10.20 dynamic linker will blow
2728 chunks if we perform a call to an unbound function
2729 via the IMPORT_SHLIB stub. The hpux 11.00 dynamic
2730 linker will blow chunks if we do not call the
2731 unbound function via the IMPORT_SHLIB stub.
2733 We currently have no way to select bevahior on just
2734 the target. However, we only support HPUX/SOM in
2735 native mode. So we conditinalize on a native
2736 #ifdef. Ugly. Ugly. Ugly */
2737 && u->stub_unwind.stub_type != IMPORT_SHLIB
2742 /* OK. Looks like the correct import stub. */
2743 newfun = SYMBOL_VALUE (stub_symbol);
2746 /* If we found an IMPORT stub, then we want to stop
2747 searching now. If we found an IMPORT_SHLIB, we want
2748 to continue the search in the hopes that we will find
2750 if (u->stub_unwind.stub_type == IMPORT)
2755 /* Ouch. We did not find an import stub. Make an attempt to
2756 do the right thing instead of just croaking. Most of the
2757 time this will actually work. */
2759 write_register (19, som_solib_get_got_by_pc (fun));
2761 u = find_unwind_entry (fun);
2763 && (u->stub_unwind.stub_type == IMPORT
2764 || u->stub_unwind.stub_type == IMPORT_SHLIB))
2765 trampoline = lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL);
2767 /* If we found the import stub in the shared library, then we have
2768 to set %r19 before we call the stub. */
2769 if (u && u->stub_unwind.stub_type == IMPORT_SHLIB)
2770 write_register (19, som_solib_get_got_by_pc (fun));
2775 /* If we are calling into another load module then have sr4export call the
2776 magic __d_plt_call routine which is linked in from end.o.
2778 You can't use _sr4export to make the call as the value in sp-24 will get
2779 fried and you end up returning to the wrong location. You can't call the
2780 target as the code to bind the PLT entry to a function can't return to a
2783 Also, query the dynamic linker in the inferior to provide a suitable
2784 PLABEL for the target function. */
2785 if (!using_gcc_plt_call)
2789 /* Get a handle for the shared library containing FUN. Given the
2790 handle we can query the shared library for a PLABEL. */
2791 solib_handle = som_solib_get_solib_by_pc (fun);
2795 struct minimal_symbol *fmsymbol = lookup_minimal_symbol_by_pc (fun);
2797 trampoline = lookup_minimal_symbol ("__d_plt_call", NULL, NULL);
2799 if (trampoline == NULL)
2801 error ("Can't find an address for __d_plt_call or __gcc_plt_call trampoline\nSuggest linking executable with -g or compiling with gcc.");
2804 /* This is where sr4export will jump to. */
2805 new_fun = SYMBOL_VALUE_ADDRESS (trampoline);
2807 /* If the function is in a shared library, then call __d_shl_get to
2808 get a PLABEL for the target function. */
2809 new_stub = find_stub_with_shl_get (fmsymbol, solib_handle);
2812 error ("Can't find an import stub for %s", DEPRECATED_SYMBOL_NAME (fmsymbol));
2814 /* We have to store the address of the stub in __shlib_funcptr. */
2815 msymbol = lookup_minimal_symbol ("__shlib_funcptr", NULL,
2816 (struct objfile *) NULL);
2818 if (msymbol == NULL)
2819 error ("Can't find an address for __shlib_funcptr");
2820 target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
2821 (char *) &new_stub, 4);
2823 /* We want sr4export to call __d_plt_call, so we claim it is
2824 the final target. Clear trampoline. */
2830 /* Store upper 21 bits of function address into ldil. fun will either be
2831 the final target (most cases) or __d_plt_call when calling into a shared
2832 library and __gcc_plt_call is not available. */
2833 store_unsigned_integer
2834 (&dummy[FUNC_LDIL_OFFSET],
2836 deposit_21 (fun >> 11,
2837 extract_unsigned_integer (&dummy[FUNC_LDIL_OFFSET],
2838 INSTRUCTION_SIZE)));
2840 /* Store lower 11 bits of function address into ldo */
2841 store_unsigned_integer
2842 (&dummy[FUNC_LDO_OFFSET],
2844 deposit_14 (fun & MASK_11,
2845 extract_unsigned_integer (&dummy[FUNC_LDO_OFFSET],
2846 INSTRUCTION_SIZE)));
2847 #ifdef SR4EXPORT_LDIL_OFFSET
2850 CORE_ADDR trampoline_addr;
2852 /* We may still need sr4export's address too. */
2854 if (trampoline == NULL)
2856 msymbol = lookup_minimal_symbol ("_sr4export", NULL, NULL);
2857 if (msymbol == NULL)
2858 error ("Can't find an address for _sr4export trampoline");
2860 trampoline_addr = SYMBOL_VALUE_ADDRESS (msymbol);
2863 trampoline_addr = SYMBOL_VALUE_ADDRESS (trampoline);
2866 /* Store upper 21 bits of trampoline's address into ldil */
2867 store_unsigned_integer
2868 (&dummy[SR4EXPORT_LDIL_OFFSET],
2870 deposit_21 (trampoline_addr >> 11,
2871 extract_unsigned_integer (&dummy[SR4EXPORT_LDIL_OFFSET],
2872 INSTRUCTION_SIZE)));
2874 /* Store lower 11 bits of trampoline's address into ldo */
2875 store_unsigned_integer
2876 (&dummy[SR4EXPORT_LDO_OFFSET],
2878 deposit_14 (trampoline_addr & MASK_11,
2879 extract_unsigned_integer (&dummy[SR4EXPORT_LDO_OFFSET],
2880 INSTRUCTION_SIZE)));
2884 write_register (22, pc);
2886 /* If we are in a syscall, then we should call the stack dummy
2887 directly. $$dyncall is not needed as the kernel sets up the
2888 space id registers properly based on the value in %r31. In
2889 fact calling $$dyncall will not work because the value in %r22
2890 will be clobbered on the syscall exit path.
2892 Similarly if the current PC is in a shared library. Note however,
2893 this scheme won't work if the shared library isn't mapped into
2894 the same space as the stack. */
2897 #ifndef GDB_TARGET_IS_PA_ELF
2898 else if (som_solib_get_got_by_pc (hppa_target_read_pc (inferior_ptid)))
2902 return dyncall_addr;
2906 /* If the pid is in a syscall, then the FP register is not readable.
2907 We'll return zero in that case, rather than attempting to read it
2908 and cause a warning. */
2911 hppa_read_fp (int pid)
2913 int flags = read_register (FLAGS_REGNUM);
2917 return (CORE_ADDR) 0;
2920 /* This is the only site that may directly read_register () the FP
2921 register. All others must use deprecated_read_fp (). */
2922 return read_register (DEPRECATED_FP_REGNUM);
2926 hppa_target_read_fp (void)
2928 return hppa_read_fp (PIDGET (inferior_ptid));
2931 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
2935 hppa_target_read_pc (ptid_t ptid)
2937 int flags = read_register_pid (FLAGS_REGNUM, ptid);
2939 /* The following test does not belong here. It is OS-specific, and belongs
2941 /* Test SS_INSYSCALL */
2943 return read_register_pid (31, ptid) & ~0x3;
2945 return read_register_pid (PCOQ_HEAD_REGNUM, ptid) & ~0x3;
2948 /* Write out the PC. If currently in a syscall, then also write the new
2949 PC value into %r31. */
2952 hppa_target_write_pc (CORE_ADDR v, ptid_t ptid)
2954 int flags = read_register_pid (FLAGS_REGNUM, ptid);
2956 /* The following test does not belong here. It is OS-specific, and belongs
2958 /* If in a syscall, then set %r31. Also make sure to get the
2959 privilege bits set correctly. */
2960 /* Test SS_INSYSCALL */
2962 write_register_pid (31, v | 0x3, ptid);
2964 write_register_pid (PCOQ_HEAD_REGNUM, v, ptid);
2965 write_register_pid (PCOQ_TAIL_REGNUM, v + 4, ptid);
2968 /* return the alignment of a type in bytes. Structures have the maximum
2969 alignment required by their fields. */
2972 hppa_alignof (struct type *type)
2974 int max_align, align, i;
2975 CHECK_TYPEDEF (type);
2976 switch (TYPE_CODE (type))
2981 return TYPE_LENGTH (type);
2982 case TYPE_CODE_ARRAY:
2983 return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
2984 case TYPE_CODE_STRUCT:
2985 case TYPE_CODE_UNION:
2987 for (i = 0; i < TYPE_NFIELDS (type); i++)
2989 /* Bit fields have no real alignment. */
2990 /* if (!TYPE_FIELD_BITPOS (type, i)) */
2991 if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
2993 align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
2994 max_align = max (max_align, align);
3003 /* Print the register regnum, or all registers if regnum is -1 */
3006 pa_do_registers_info (int regnum, int fpregs)
3008 char *raw_regs = alloca (DEPRECATED_REGISTER_BYTES);
3011 /* Make a copy of gdb's save area (may cause actual
3012 reads from the target). */
3013 for (i = 0; i < NUM_REGS; i++)
3014 frame_register_read (deprecated_selected_frame, i,
3015 raw_regs + DEPRECATED_REGISTER_BYTE (i));
3018 pa_print_registers (raw_regs, regnum, fpregs);
3019 else if (regnum < FP4_REGNUM)
3023 /* Why is the value not passed through "extract_signed_integer"
3024 as in "pa_print_registers" below? */
3025 pa_register_look_aside (raw_regs, regnum, ®_val[0]);
3029 printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum), reg_val[1]);
3033 /* Fancy % formats to prevent leading zeros. */
3034 if (reg_val[0] == 0)
3035 printf_unfiltered ("%s %lx\n", REGISTER_NAME (regnum), reg_val[1]);
3037 printf_unfiltered ("%s %lx%8.8lx\n", REGISTER_NAME (regnum),
3038 reg_val[0], reg_val[1]);
3042 /* Note that real floating point values only start at
3043 FP4_REGNUM. FP0 and up are just status and error
3044 registers, which have integral (bit) values. */
3045 pa_print_fp_reg (regnum);
3048 /********** new function ********************/
3050 pa_do_strcat_registers_info (int regnum, int fpregs, struct ui_file *stream,
3051 enum precision_type precision)
3053 char *raw_regs = alloca (DEPRECATED_REGISTER_BYTES);
3056 /* Make a copy of gdb's save area (may cause actual
3057 reads from the target). */
3058 for (i = 0; i < NUM_REGS; i++)
3059 frame_register_read (deprecated_selected_frame, i,
3060 raw_regs + DEPRECATED_REGISTER_BYTE (i));
3063 pa_strcat_registers (raw_regs, regnum, fpregs, stream);
3065 else if (regnum < FP4_REGNUM)
3069 /* Why is the value not passed through "extract_signed_integer"
3070 as in "pa_print_registers" below? */
3071 pa_register_look_aside (raw_regs, regnum, ®_val[0]);
3075 fprintf_unfiltered (stream, "%s %lx", REGISTER_NAME (regnum), reg_val[1]);
3079 /* Fancy % formats to prevent leading zeros. */
3080 if (reg_val[0] == 0)
3081 fprintf_unfiltered (stream, "%s %lx", REGISTER_NAME (regnum),
3084 fprintf_unfiltered (stream, "%s %lx%8.8lx", REGISTER_NAME (regnum),
3085 reg_val[0], reg_val[1]);
3089 /* Note that real floating point values only start at
3090 FP4_REGNUM. FP0 and up are just status and error
3091 registers, which have integral (bit) values. */
3092 pa_strcat_fp_reg (regnum, stream, precision);
3095 /* If this is a PA2.0 machine, fetch the real 64-bit register
3096 value. Otherwise use the info from gdb's saved register area.
3098 Note that reg_val is really expected to be an array of longs,
3099 with two elements. */
3101 pa_register_look_aside (char *raw_regs, int regnum, long *raw_val)
3103 static int know_which = 0; /* False */
3106 unsigned int offset;
3111 char buf[MAX_REGISTER_SIZE];
3116 if (CPU_PA_RISC2_0 == sysconf (_SC_CPU_VERSION))
3121 know_which = 1; /* True */
3129 raw_val[1] = *(long *) (raw_regs + DEPRECATED_REGISTER_BYTE (regnum));
3133 /* Code below copied from hppah-nat.c, with fixes for wide
3134 registers, using different area of save_state, etc. */
3135 if (regnum == FLAGS_REGNUM || regnum >= FP0_REGNUM ||
3136 !HAVE_STRUCT_SAVE_STATE_T || !HAVE_STRUCT_MEMBER_SS_WIDE)
3138 /* Use narrow regs area of save_state and default macro. */
3139 offset = U_REGS_OFFSET;
3140 regaddr = register_addr (regnum, offset);
3145 /* Use wide regs area, and calculate registers as 8 bytes wide.
3147 We'd like to do this, but current version of "C" doesn't
3150 offset = offsetof(save_state_t, ss_wide);
3152 Note that to avoid "C" doing typed pointer arithmetic, we
3153 have to cast away the type in our offset calculation:
3154 otherwise we get an offset of 1! */
3156 /* NB: save_state_t is not available before HPUX 9.
3157 The ss_wide field is not available previous to HPUX 10.20,
3158 so to avoid compile-time warnings, we only compile this for
3159 PA 2.0 processors. This control path should only be followed
3160 if we're debugging a PA 2.0 processor, so this should not cause
3163 /* #if the following code out so that this file can still be
3164 compiled on older HPUX boxes (< 10.20) which don't have
3165 this structure/structure member. */
3166 #if HAVE_STRUCT_SAVE_STATE_T == 1 && HAVE_STRUCT_MEMBER_SS_WIDE == 1
3169 offset = ((int) &temp.ss_wide) - ((int) &temp);
3170 regaddr = offset + regnum * 8;
3175 for (i = start; i < 2; i++)
3178 raw_val[i] = call_ptrace (PT_RUREGS, PIDGET (inferior_ptid),
3179 (PTRACE_ARG3_TYPE) regaddr, 0);
3182 /* Warning, not error, in case we are attached; sometimes the
3183 kernel doesn't let us at the registers. */
3184 char *err = safe_strerror (errno);
3185 char *msg = alloca (strlen (err) + 128);
3186 sprintf (msg, "reading register %s: %s", REGISTER_NAME (regnum), err);
3191 regaddr += sizeof (long);
3194 if (regnum == PCOQ_HEAD_REGNUM || regnum == PCOQ_TAIL_REGNUM)
3195 raw_val[1] &= ~0x3; /* I think we're masking out space bits */
3201 /* "Info all-reg" command */
3204 pa_print_registers (char *raw_regs, int regnum, int fpregs)
3207 /* Alas, we are compiled so that "long long" is 32 bits */
3210 int rows = 48, columns = 2;
3212 for (i = 0; i < rows; i++)
3214 for (j = 0; j < columns; j++)
3216 /* We display registers in column-major order. */
3217 int regnum = i + j * rows;
3219 /* Q: Why is the value passed through "extract_signed_integer",
3220 while above, in "pa_do_registers_info" it isn't?
3222 pa_register_look_aside (raw_regs, regnum, &raw_val[0]);
3224 /* Even fancier % formats to prevent leading zeros
3225 and still maintain the output in columns. */
3228 /* Being big-endian, on this machine the low bits
3229 (the ones we want to look at) are in the second longword. */
3230 long_val = extract_signed_integer (&raw_val[1], 4);
3231 printf_filtered ("%10.10s: %8lx ",
3232 REGISTER_NAME (regnum), long_val);
3236 /* raw_val = extract_signed_integer(&raw_val, 8); */
3237 if (raw_val[0] == 0)
3238 printf_filtered ("%10.10s: %8lx ",
3239 REGISTER_NAME (regnum), raw_val[1]);
3241 printf_filtered ("%10.10s: %8lx%8.8lx ",
3242 REGISTER_NAME (regnum),
3243 raw_val[0], raw_val[1]);
3246 printf_unfiltered ("\n");
3250 for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
3251 pa_print_fp_reg (i);
3254 /************* new function ******************/
3256 pa_strcat_registers (char *raw_regs, int regnum, int fpregs,
3257 struct ui_file *stream)
3260 long raw_val[2]; /* Alas, we are compiled so that "long long" is 32 bits */
3262 enum precision_type precision;
3264 precision = unspecified_precision;
3266 for (i = 0; i < 18; i++)
3268 for (j = 0; j < 4; j++)
3270 /* Q: Why is the value passed through "extract_signed_integer",
3271 while above, in "pa_do_registers_info" it isn't?
3273 pa_register_look_aside (raw_regs, i + (j * 18), &raw_val[0]);
3275 /* Even fancier % formats to prevent leading zeros
3276 and still maintain the output in columns. */
3279 /* Being big-endian, on this machine the low bits
3280 (the ones we want to look at) are in the second longword. */
3281 long_val = extract_signed_integer (&raw_val[1], 4);
3282 fprintf_filtered (stream, "%8.8s: %8lx ",
3283 REGISTER_NAME (i + (j * 18)), long_val);
3287 /* raw_val = extract_signed_integer(&raw_val, 8); */
3288 if (raw_val[0] == 0)
3289 fprintf_filtered (stream, "%8.8s: %8lx ",
3290 REGISTER_NAME (i + (j * 18)), raw_val[1]);
3292 fprintf_filtered (stream, "%8.8s: %8lx%8.8lx ",
3293 REGISTER_NAME (i + (j * 18)), raw_val[0],
3297 fprintf_unfiltered (stream, "\n");
3301 for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
3302 pa_strcat_fp_reg (i, stream, precision);
3306 pa_print_fp_reg (int i)
3308 char raw_buffer[MAX_REGISTER_SIZE];
3309 char virtual_buffer[MAX_REGISTER_SIZE];
3311 /* Get 32bits of data. */
3312 frame_register_read (deprecated_selected_frame, i, raw_buffer);
3314 /* Put it in the buffer. No conversions are ever necessary. */
3315 memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i));
3317 fputs_filtered (REGISTER_NAME (i), gdb_stdout);
3318 print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
3319 fputs_filtered ("(single precision) ", gdb_stdout);
3321 val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, gdb_stdout, 0,
3322 1, 0, Val_pretty_default);
3323 printf_filtered ("\n");
3325 /* If "i" is even, then this register can also be a double-precision
3326 FP register. Dump it out as such. */
3329 /* Get the data in raw format for the 2nd half. */
3330 frame_register_read (deprecated_selected_frame, i + 1, raw_buffer);
3332 /* Copy it into the appropriate part of the virtual buffer. */
3333 memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buffer,
3334 DEPRECATED_REGISTER_RAW_SIZE (i));
3336 /* Dump it as a double. */
3337 fputs_filtered (REGISTER_NAME (i), gdb_stdout);
3338 print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), gdb_stdout);
3339 fputs_filtered ("(double precision) ", gdb_stdout);
3341 val_print (builtin_type_double, virtual_buffer, 0, 0, gdb_stdout, 0,
3342 1, 0, Val_pretty_default);
3343 printf_filtered ("\n");
3347 /*************** new function ***********************/
3349 pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
3351 char raw_buffer[MAX_REGISTER_SIZE];
3352 char virtual_buffer[MAX_REGISTER_SIZE];
3354 fputs_filtered (REGISTER_NAME (i), stream);
3355 print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
3357 /* Get 32bits of data. */
3358 frame_register_read (deprecated_selected_frame, i, raw_buffer);
3360 /* Put it in the buffer. No conversions are ever necessary. */
3361 memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_RAW_SIZE (i));
3363 if (precision == double_precision && (i % 2) == 0)
3366 char raw_buf[MAX_REGISTER_SIZE];
3368 /* Get the data in raw format for the 2nd half. */
3369 frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
3371 /* Copy it into the appropriate part of the virtual buffer. */
3372 memcpy (virtual_buffer + DEPRECATED_REGISTER_RAW_SIZE (i), raw_buf,
3373 DEPRECATED_REGISTER_RAW_SIZE (i));
3375 val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0,
3376 1, 0, Val_pretty_default);
3381 val_print (DEPRECATED_REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, stream, 0,
3382 1, 0, Val_pretty_default);
3387 /* Return one if PC is in the call path of a trampoline, else return zero.
3389 Note we return one for *any* call trampoline (long-call, arg-reloc), not
3390 just shared library trampolines (import, export). */
3393 hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name)
3395 struct minimal_symbol *minsym;
3396 struct unwind_table_entry *u;
3397 static CORE_ADDR dyncall = 0;
3398 static CORE_ADDR sr4export = 0;
3400 #ifdef GDB_TARGET_IS_HPPA_20W
3401 /* PA64 has a completely different stub/trampoline scheme. Is it
3402 better? Maybe. It's certainly harder to determine with any
3403 certainty that we are in a stub because we can not refer to the
3406 The heuristic is simple. Try to lookup the current PC value in th
3407 minimal symbol table. If that fails, then assume we are not in a
3410 Then see if the PC value falls within the section bounds for the
3411 section containing the minimal symbol we found in the first
3412 step. If it does, then assume we are not in a stub and return.
3414 Finally peek at the instructions to see if they look like a stub. */
3416 struct minimal_symbol *minsym;
3421 minsym = lookup_minimal_symbol_by_pc (pc);
3425 sec = SYMBOL_BFD_SECTION (minsym);
3427 if (bfd_get_section_vma (sec->owner, sec) <= pc
3428 && pc < (bfd_get_section_vma (sec->owner, sec)
3429 + bfd_section_size (sec->owner, sec)))
3432 /* We might be in a stub. Peek at the instructions. Stubs are 3
3433 instructions long. */
3434 insn = read_memory_integer (pc, 4);
3436 /* Find out where we think we are within the stub. */
3437 if ((insn & 0xffffc00e) == 0x53610000)
3439 else if ((insn & 0xffffffff) == 0xe820d000)
3441 else if ((insn & 0xffffc00e) == 0x537b0000)
3446 /* Now verify each insn in the range looks like a stub instruction. */
3447 insn = read_memory_integer (addr, 4);
3448 if ((insn & 0xffffc00e) != 0x53610000)
3451 /* Now verify each insn in the range looks like a stub instruction. */
3452 insn = read_memory_integer (addr + 4, 4);
3453 if ((insn & 0xffffffff) != 0xe820d000)
3456 /* Now verify each insn in the range looks like a stub instruction. */
3457 insn = read_memory_integer (addr + 8, 4);
3458 if ((insn & 0xffffc00e) != 0x537b0000)
3461 /* Looks like a stub. */
3466 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3469 /* First see if PC is in one of the two C-library trampolines. */
3472 minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
3474 dyncall = SYMBOL_VALUE_ADDRESS (minsym);
3481 minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
3483 sr4export = SYMBOL_VALUE_ADDRESS (minsym);
3488 if (pc == dyncall || pc == sr4export)
3491 minsym = lookup_minimal_symbol_by_pc (pc);
3492 if (minsym && strcmp (DEPRECATED_SYMBOL_NAME (minsym), ".stub") == 0)
3495 /* Get the unwind descriptor corresponding to PC, return zero
3496 if no unwind was found. */
3497 u = find_unwind_entry (pc);
3501 /* If this isn't a linker stub, then return now. */
3502 if (u->stub_unwind.stub_type == 0)
3505 /* By definition a long-branch stub is a call stub. */
3506 if (u->stub_unwind.stub_type == LONG_BRANCH)
3509 /* The call and return path execute the same instructions within
3510 an IMPORT stub! So an IMPORT stub is both a call and return
3512 if (u->stub_unwind.stub_type == IMPORT)
3515 /* Parameter relocation stubs always have a call path and may have a
3517 if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
3518 || u->stub_unwind.stub_type == EXPORT)
3522 /* Search forward from the current PC until we hit a branch
3523 or the end of the stub. */
3524 for (addr = pc; addr <= u->region_end; addr += 4)
3528 insn = read_memory_integer (addr, 4);
3530 /* Does it look like a bl? If so then it's the call path, if
3531 we find a bv or be first, then we're on the return path. */
3532 if ((insn & 0xfc00e000) == 0xe8000000)
3534 else if ((insn & 0xfc00e001) == 0xe800c000
3535 || (insn & 0xfc000000) == 0xe0000000)
3539 /* Should never happen. */
3540 warning ("Unable to find branch in parameter relocation stub.\n");
3544 /* Unknown stub type. For now, just return zero. */
3548 /* Return one if PC is in the return path of a trampoline, else return zero.
3550 Note we return one for *any* call trampoline (long-call, arg-reloc), not
3551 just shared library trampolines (import, export). */
3554 hppa_in_solib_return_trampoline (CORE_ADDR pc, char *name)
3556 struct unwind_table_entry *u;
3558 /* Get the unwind descriptor corresponding to PC, return zero
3559 if no unwind was found. */
3560 u = find_unwind_entry (pc);
3564 /* If this isn't a linker stub or it's just a long branch stub, then
3566 if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH)
3569 /* The call and return path execute the same instructions within
3570 an IMPORT stub! So an IMPORT stub is both a call and return
3572 if (u->stub_unwind.stub_type == IMPORT)
3575 /* Parameter relocation stubs always have a call path and may have a
3577 if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
3578 || u->stub_unwind.stub_type == EXPORT)
3582 /* Search forward from the current PC until we hit a branch
3583 or the end of the stub. */
3584 for (addr = pc; addr <= u->region_end; addr += 4)
3588 insn = read_memory_integer (addr, 4);
3590 /* Does it look like a bl? If so then it's the call path, if
3591 we find a bv or be first, then we're on the return path. */
3592 if ((insn & 0xfc00e000) == 0xe8000000)
3594 else if ((insn & 0xfc00e001) == 0xe800c000
3595 || (insn & 0xfc000000) == 0xe0000000)
3599 /* Should never happen. */
3600 warning ("Unable to find branch in parameter relocation stub.\n");
3604 /* Unknown stub type. For now, just return zero. */
3609 /* Figure out if PC is in a trampoline, and if so find out where
3610 the trampoline will jump to. If not in a trampoline, return zero.
3612 Simple code examination probably is not a good idea since the code
3613 sequences in trampolines can also appear in user code.
3615 We use unwinds and information from the minimal symbol table to
3616 determine when we're in a trampoline. This won't work for ELF
3617 (yet) since it doesn't create stub unwind entries. Whether or
3618 not ELF will create stub unwinds or normal unwinds for linker
3619 stubs is still being debated.
3621 This should handle simple calls through dyncall or sr4export,
3622 long calls, argument relocation stubs, and dyncall/sr4export
3623 calling an argument relocation stub. It even handles some stubs
3624 used in dynamic executables. */
3627 hppa_skip_trampoline_code (CORE_ADDR pc)
3630 long prev_inst, curr_inst, loc;
3631 static CORE_ADDR dyncall = 0;
3632 static CORE_ADDR dyncall_external = 0;
3633 static CORE_ADDR sr4export = 0;
3634 struct minimal_symbol *msym;
3635 struct unwind_table_entry *u;
3637 /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
3642 msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL);
3644 dyncall = SYMBOL_VALUE_ADDRESS (msym);
3649 if (!dyncall_external)
3651 msym = lookup_minimal_symbol ("$$dyncall_external", NULL, NULL);
3653 dyncall_external = SYMBOL_VALUE_ADDRESS (msym);
3655 dyncall_external = -1;
3660 msym = lookup_minimal_symbol ("_sr4export", NULL, NULL);
3662 sr4export = SYMBOL_VALUE_ADDRESS (msym);
3667 /* Addresses passed to dyncall may *NOT* be the actual address
3668 of the function. So we may have to do something special. */
3671 pc = (CORE_ADDR) read_register (22);
3673 /* If bit 30 (counting from the left) is on, then pc is the address of
3674 the PLT entry for this function, not the address of the function
3675 itself. Bit 31 has meaning too, but only for MPE. */
3677 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
3679 if (pc == dyncall_external)
3681 pc = (CORE_ADDR) read_register (22);
3682 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8);
3684 else if (pc == sr4export)
3685 pc = (CORE_ADDR) (read_register (22));
3687 /* Get the unwind descriptor corresponding to PC, return zero
3688 if no unwind was found. */
3689 u = find_unwind_entry (pc);
3693 /* If this isn't a linker stub, then return now. */
3694 /* elz: attention here! (FIXME) because of a compiler/linker
3695 error, some stubs which should have a non zero stub_unwind.stub_type
3696 have unfortunately a value of zero. So this function would return here
3697 as if we were not in a trampoline. To fix this, we go look at the partial
3698 symbol information, which reports this guy as a stub.
3699 (FIXME): Unfortunately, we are not that lucky: it turns out that the
3700 partial symbol information is also wrong sometimes. This is because
3701 when it is entered (somread.c::som_symtab_read()) it can happen that
3702 if the type of the symbol (from the som) is Entry, and the symbol is
3703 in a shared library, then it can also be a trampoline. This would
3704 be OK, except that I believe the way they decide if we are ina shared library
3705 does not work. SOOOO..., even if we have a regular function w/o trampolines
3706 its minimal symbol can be assigned type mst_solib_trampoline.
3707 Also, if we find that the symbol is a real stub, then we fix the unwind
3708 descriptor, and define the stub type to be EXPORT.
3709 Hopefully this is correct most of the times. */
3710 if (u->stub_unwind.stub_type == 0)
3713 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
3714 we can delete all the code which appears between the lines */
3715 /*--------------------------------------------------------------------------*/
3716 msym = lookup_minimal_symbol_by_pc (pc);
3718 if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
3719 return orig_pc == pc ? 0 : pc & ~0x3;
3721 else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
3723 struct objfile *objfile;
3724 struct minimal_symbol *msymbol;
3725 int function_found = 0;
3727 /* go look if there is another minimal symbol with the same name as
3728 this one, but with type mst_text. This would happen if the msym
3729 is an actual trampoline, in which case there would be another
3730 symbol with the same name corresponding to the real function */
3732 ALL_MSYMBOLS (objfile, msymbol)
3734 if (MSYMBOL_TYPE (msymbol) == mst_text
3735 && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol), DEPRECATED_SYMBOL_NAME (msym)))
3743 /* the type of msym is correct (mst_solib_trampoline), but
3744 the unwind info is wrong, so set it to the correct value */
3745 u->stub_unwind.stub_type = EXPORT;
3747 /* the stub type info in the unwind is correct (this is not a
3748 trampoline), but the msym type information is wrong, it
3749 should be mst_text. So we need to fix the msym, and also
3750 get out of this function */
3752 MSYMBOL_TYPE (msym) = mst_text;
3753 return orig_pc == pc ? 0 : pc & ~0x3;
3757 /*--------------------------------------------------------------------------*/
3760 /* It's a stub. Search for a branch and figure out where it goes.
3761 Note we have to handle multi insn branch sequences like ldil;ble.
3762 Most (all?) other branches can be determined by examining the contents
3763 of certain registers and the stack. */
3770 /* Make sure we haven't walked outside the range of this stub. */
3771 if (u != find_unwind_entry (loc))
3773 warning ("Unable to find branch in linker stub");
3774 return orig_pc == pc ? 0 : pc & ~0x3;
3777 prev_inst = curr_inst;
3778 curr_inst = read_memory_integer (loc, 4);
3780 /* Does it look like a branch external using %r1? Then it's the
3781 branch from the stub to the actual function. */
3782 if ((curr_inst & 0xffe0e000) == 0xe0202000)
3784 /* Yup. See if the previous instruction loaded
3785 a value into %r1. If so compute and return the jump address. */
3786 if ((prev_inst & 0xffe00000) == 0x20200000)
3787 return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3;
3790 warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
3791 return orig_pc == pc ? 0 : pc & ~0x3;
3795 /* Does it look like a be 0(sr0,%r21)? OR
3796 Does it look like a be, n 0(sr0,%r21)? OR
3797 Does it look like a bve (r21)? (this is on PA2.0)
3798 Does it look like a bve, n(r21)? (this is also on PA2.0)
3799 That's the branch from an
3800 import stub to an export stub.
3802 It is impossible to determine the target of the branch via
3803 simple examination of instructions and/or data (consider
3804 that the address in the plabel may be the address of the
3805 bind-on-reference routine in the dynamic loader).
3807 So we have try an alternative approach.
3809 Get the name of the symbol at our current location; it should
3810 be a stub symbol with the same name as the symbol in the
3813 Then lookup a minimal symbol with the same name; we should
3814 get the minimal symbol for the target routine in the shared
3815 library as those take precedence of import/export stubs. */
3816 if ((curr_inst == 0xe2a00000) ||
3817 (curr_inst == 0xe2a00002) ||
3818 (curr_inst == 0xeaa0d000) ||
3819 (curr_inst == 0xeaa0d002))
3821 struct minimal_symbol *stubsym, *libsym;
3823 stubsym = lookup_minimal_symbol_by_pc (loc);
3824 if (stubsym == NULL)
3826 warning ("Unable to find symbol for 0x%lx", loc);
3827 return orig_pc == pc ? 0 : pc & ~0x3;
3830 libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL);
3833 warning ("Unable to find library symbol for %s\n",
3834 DEPRECATED_SYMBOL_NAME (stubsym));
3835 return orig_pc == pc ? 0 : pc & ~0x3;
3838 return SYMBOL_VALUE (libsym);
3841 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
3842 branch from the stub to the actual function. */
3844 else if ((curr_inst & 0xffe0e000) == 0xe8400000
3845 || (curr_inst & 0xffe0e000) == 0xe8000000
3846 || (curr_inst & 0xffe0e000) == 0xe800A000)
3847 return (loc + extract_17 (curr_inst) + 8) & ~0x3;
3849 /* Does it look like bv (rp)? Note this depends on the
3850 current stack pointer being the same as the stack
3851 pointer in the stub itself! This is a branch on from the
3852 stub back to the original caller. */
3853 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
3854 else if ((curr_inst & 0xffe0f000) == 0xe840c000)
3856 /* Yup. See if the previous instruction loaded
3858 if (prev_inst == 0x4bc23ff1)
3859 return (read_memory_integer
3860 (read_register (SP_REGNUM) - 8, 4)) & ~0x3;
3863 warning ("Unable to find restore of %%rp before bv (%%rp).");
3864 return orig_pc == pc ? 0 : pc & ~0x3;
3868 /* elz: added this case to capture the new instruction
3869 at the end of the return part of an export stub used by
3870 the PA2.0: BVE, n (rp) */
3871 else if ((curr_inst & 0xffe0f000) == 0xe840d000)
3873 return (read_memory_integer
3874 (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
3877 /* What about be,n 0(sr0,%rp)? It's just another way we return to
3878 the original caller from the stub. Used in dynamic executables. */
3879 else if (curr_inst == 0xe0400002)
3881 /* The value we jump to is sitting in sp - 24. But that's
3882 loaded several instructions before the be instruction.
3883 I guess we could check for the previous instruction being
3884 mtsp %r1,%sr0 if we want to do sanity checking. */
3885 return (read_memory_integer
3886 (read_register (SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3;
3889 /* Haven't found the branch yet, but we're still in the stub.
3896 /* For the given instruction (INST), return any adjustment it makes
3897 to the stack pointer or zero for no adjustment.
3899 This only handles instructions commonly found in prologues. */
3902 prologue_inst_adjust_sp (unsigned long inst)
3904 /* This must persist across calls. */
3905 static int save_high21;
3907 /* The most common way to perform a stack adjustment ldo X(sp),sp */
3908 if ((inst & 0xffffc000) == 0x37de0000)
3909 return extract_14 (inst);
3912 if ((inst & 0xffe00000) == 0x6fc00000)
3913 return extract_14 (inst);
3915 /* std,ma X,D(sp) */
3916 if ((inst & 0xffe00008) == 0x73c00008)
3917 return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
3919 /* addil high21,%r1; ldo low11,(%r1),%r30)
3920 save high bits in save_high21 for later use. */
3921 if ((inst & 0xffe00000) == 0x28200000)
3923 save_high21 = extract_21 (inst);
3927 if ((inst & 0xffff0000) == 0x343e0000)
3928 return save_high21 + extract_14 (inst);
3930 /* fstws as used by the HP compilers. */
3931 if ((inst & 0xffffffe0) == 0x2fd01220)
3932 return extract_5_load (inst);
3934 /* No adjustment. */
3938 /* Return nonzero if INST is a branch of some kind, else return zero. */
3941 is_branch (unsigned long inst)
3970 /* Return the register number for a GR which is saved by INST or
3971 zero it INST does not save a GR. */
3974 inst_saves_gr (unsigned long inst)
3976 /* Does it look like a stw? */
3977 if ((inst >> 26) == 0x1a || (inst >> 26) == 0x1b
3978 || (inst >> 26) == 0x1f
3979 || ((inst >> 26) == 0x1f
3980 && ((inst >> 6) == 0xa)))
3981 return extract_5R_store (inst);
3983 /* Does it look like a std? */
3984 if ((inst >> 26) == 0x1c
3985 || ((inst >> 26) == 0x03
3986 && ((inst >> 6) & 0xf) == 0xb))
3987 return extract_5R_store (inst);
3989 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
3990 if ((inst >> 26) == 0x1b)
3991 return extract_5R_store (inst);
3993 /* Does it look like sth or stb? HPC versions 9.0 and later use these
3995 if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18
3996 || ((inst >> 26) == 0x3
3997 && (((inst >> 6) & 0xf) == 0x8
3998 || (inst >> 6) & 0xf) == 0x9))
3999 return extract_5R_store (inst);
4004 /* Return the register number for a FR which is saved by INST or
4005 zero it INST does not save a FR.
4007 Note we only care about full 64bit register stores (that's the only
4008 kind of stores the prologue will use).
4010 FIXME: What about argument stores with the HP compiler in ANSI mode? */
4013 inst_saves_fr (unsigned long inst)
4015 /* is this an FSTD ? */
4016 if ((inst & 0xfc00dfc0) == 0x2c001200)
4017 return extract_5r_store (inst);
4018 if ((inst & 0xfc000002) == 0x70000002)
4019 return extract_5R_store (inst);
4020 /* is this an FSTW ? */
4021 if ((inst & 0xfc00df80) == 0x24001200)
4022 return extract_5r_store (inst);
4023 if ((inst & 0xfc000002) == 0x7c000000)
4024 return extract_5R_store (inst);
4028 /* Advance PC across any function entry prologue instructions
4029 to reach some "real" code.
4031 Use information in the unwind table to determine what exactly should
4032 be in the prologue. */
4036 skip_prologue_hard_way (CORE_ADDR pc)
4039 CORE_ADDR orig_pc = pc;
4040 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
4041 unsigned long args_stored, status, i, restart_gr, restart_fr;
4042 struct unwind_table_entry *u;
4048 u = find_unwind_entry (pc);
4052 /* If we are not at the beginning of a function, then return now. */
4053 if ((pc & ~0x3) != u->region_start)
4056 /* This is how much of a frame adjustment we need to account for. */
4057 stack_remaining = u->Total_frame_size << 3;
4059 /* Magic register saves we want to know about. */
4060 save_rp = u->Save_RP;
4061 save_sp = u->Save_SP;
4063 /* An indication that args may be stored into the stack. Unfortunately
4064 the HPUX compilers tend to set this in cases where no args were
4068 /* Turn the Entry_GR field into a bitmask. */
4070 for (i = 3; i < u->Entry_GR + 3; i++)
4072 /* Frame pointer gets saved into a special location. */
4073 if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
4076 save_gr |= (1 << i);
4078 save_gr &= ~restart_gr;
4080 /* Turn the Entry_FR field into a bitmask too. */
4082 for (i = 12; i < u->Entry_FR + 12; i++)
4083 save_fr |= (1 << i);
4084 save_fr &= ~restart_fr;
4086 /* Loop until we find everything of interest or hit a branch.
4088 For unoptimized GCC code and for any HP CC code this will never ever
4089 examine any user instructions.
4091 For optimzied GCC code we're faced with problems. GCC will schedule
4092 its prologue and make prologue instructions available for delay slot
4093 filling. The end result is user code gets mixed in with the prologue
4094 and a prologue instruction may be in the delay slot of the first branch
4097 Some unexpected things are expected with debugging optimized code, so
4098 we allow this routine to walk past user instructions in optimized
4100 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
4103 unsigned int reg_num;
4104 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
4105 unsigned long old_save_rp, old_save_sp, next_inst;
4107 /* Save copies of all the triggers so we can compare them later
4109 old_save_gr = save_gr;
4110 old_save_fr = save_fr;
4111 old_save_rp = save_rp;
4112 old_save_sp = save_sp;
4113 old_stack_remaining = stack_remaining;
4115 status = target_read_memory (pc, buf, 4);
4116 inst = extract_unsigned_integer (buf, 4);
4122 /* Note the interesting effects of this instruction. */
4123 stack_remaining -= prologue_inst_adjust_sp (inst);
4125 /* There are limited ways to store the return pointer into the
4127 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1)
4130 /* These are the only ways we save SP into the stack. At this time
4131 the HP compilers never bother to save SP into the stack. */
4132 if ((inst & 0xffffc000) == 0x6fc10000
4133 || (inst & 0xffffc00c) == 0x73c10008)
4136 /* Are we loading some register with an offset from the argument
4138 if ((inst & 0xffe00000) == 0x37a00000
4139 || (inst & 0xffffffe0) == 0x081d0240)
4145 /* Account for general and floating-point register saves. */
4146 reg_num = inst_saves_gr (inst);
4147 save_gr &= ~(1 << reg_num);
4149 /* Ugh. Also account for argument stores into the stack.
4150 Unfortunately args_stored only tells us that some arguments
4151 where stored into the stack. Not how many or what kind!
4153 This is a kludge as on the HP compiler sets this bit and it
4154 never does prologue scheduling. So once we see one, skip past
4155 all of them. We have similar code for the fp arg stores below.
4157 FIXME. Can still die if we have a mix of GR and FR argument
4159 if (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
4161 while (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
4164 status = target_read_memory (pc, buf, 4);
4165 inst = extract_unsigned_integer (buf, 4);
4168 reg_num = inst_saves_gr (inst);
4174 reg_num = inst_saves_fr (inst);
4175 save_fr &= ~(1 << reg_num);
4177 status = target_read_memory (pc + 4, buf, 4);
4178 next_inst = extract_unsigned_integer (buf, 4);
4184 /* We've got to be read to handle the ldo before the fp register
4186 if ((inst & 0xfc000000) == 0x34000000
4187 && inst_saves_fr (next_inst) >= 4
4188 && inst_saves_fr (next_inst) <= (TARGET_PTR_BIT == 64 ? 11 : 7))
4190 /* So we drop into the code below in a reasonable state. */
4191 reg_num = inst_saves_fr (next_inst);
4195 /* Ugh. Also account for argument stores into the stack.
4196 This is a kludge as on the HP compiler sets this bit and it
4197 never does prologue scheduling. So once we see one, skip past
4199 if (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
4201 while (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
4204 status = target_read_memory (pc, buf, 4);
4205 inst = extract_unsigned_integer (buf, 4);
4208 if ((inst & 0xfc000000) != 0x34000000)
4210 status = target_read_memory (pc + 4, buf, 4);
4211 next_inst = extract_unsigned_integer (buf, 4);
4214 reg_num = inst_saves_fr (next_inst);
4220 /* Quit if we hit any kind of branch. This can happen if a prologue
4221 instruction is in the delay slot of the first call/branch. */
4222 if (is_branch (inst))
4225 /* What a crock. The HP compilers set args_stored even if no
4226 arguments were stored into the stack (boo hiss). This could
4227 cause this code to then skip a bunch of user insns (up to the
4230 To combat this we try to identify when args_stored was bogusly
4231 set and clear it. We only do this when args_stored is nonzero,
4232 all other resources are accounted for, and nothing changed on
4235 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
4236 && old_save_gr == save_gr && old_save_fr == save_fr
4237 && old_save_rp == save_rp && old_save_sp == save_sp
4238 && old_stack_remaining == stack_remaining)
4245 /* We've got a tenative location for the end of the prologue. However
4246 because of limitations in the unwind descriptor mechanism we may
4247 have went too far into user code looking for the save of a register
4248 that does not exist. So, if there registers we expected to be saved
4249 but never were, mask them out and restart.
4251 This should only happen in optimized code, and should be very rare. */
4252 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
4255 restart_gr = save_gr;
4256 restart_fr = save_fr;
4264 /* Return the address of the PC after the last prologue instruction if
4265 we can determine it from the debug symbols. Else return zero. */
4268 after_prologue (CORE_ADDR pc)
4270 struct symtab_and_line sal;
4271 CORE_ADDR func_addr, func_end;
4274 /* If we can not find the symbol in the partial symbol table, then
4275 there is no hope we can determine the function's start address
4277 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
4280 /* Get the line associated with FUNC_ADDR. */
4281 sal = find_pc_line (func_addr, 0);
4283 /* There are only two cases to consider. First, the end of the source line
4284 is within the function bounds. In that case we return the end of the
4285 source line. Second is the end of the source line extends beyond the
4286 bounds of the current function. We need to use the slow code to
4287 examine instructions in that case.
4289 Anything else is simply a bug elsewhere. Fixing it here is absolutely
4290 the wrong thing to do. In fact, it should be entirely possible for this
4291 function to always return zero since the slow instruction scanning code
4292 is supposed to *always* work. If it does not, then it is a bug. */
4293 if (sal.end < func_end)
4299 /* To skip prologues, I use this predicate. Returns either PC itself
4300 if the code at PC does not look like a function prologue; otherwise
4301 returns an address that (if we're lucky) follows the prologue. If
4302 LENIENT, then we must skip everything which is involved in setting
4303 up the frame (it's OK to skip more, just so long as we don't skip
4304 anything which might clobber the registers which are being saved.
4305 Currently we must not skip more on the alpha, but we might the lenient
4309 hppa_skip_prologue (CORE_ADDR pc)
4313 CORE_ADDR post_prologue_pc;
4316 /* See if we can determine the end of the prologue via the symbol table.
4317 If so, then return either PC, or the PC after the prologue, whichever
4320 post_prologue_pc = after_prologue (pc);
4322 /* If after_prologue returned a useful address, then use it. Else
4323 fall back on the instruction skipping code.
4325 Some folks have claimed this causes problems because the breakpoint
4326 may be the first instruction of the prologue. If that happens, then
4327 the instruction skipping code has a bug that needs to be fixed. */
4328 if (post_prologue_pc != 0)
4329 return max (pc, post_prologue_pc);
4331 return (skip_prologue_hard_way (pc));
4334 /* Put here the code to store, into the SAVED_REGS, the addresses of
4335 the saved registers of frame described by FRAME_INFO. This
4336 includes special registers such as pc and fp saved in special ways
4337 in the stack frame. sp is even more special: the address we return
4338 for it IS the sp for the next frame. */
4341 hppa_frame_find_saved_regs (struct frame_info *frame_info,
4342 CORE_ADDR frame_saved_regs[])
4345 struct unwind_table_entry *u;
4346 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
4350 int final_iteration;
4352 /* Zero out everything. */
4353 memset (frame_saved_regs, '\0', SIZEOF_FRAME_SAVED_REGS);
4355 /* Call dummy frames always look the same, so there's no need to
4356 examine the dummy code to determine locations of saved registers;
4357 instead, let find_dummy_frame_regs fill in the correct offsets
4358 for the saved registers. */
4359 if ((get_frame_pc (frame_info) >= get_frame_base (frame_info)
4360 && (get_frame_pc (frame_info)
4361 <= (get_frame_base (frame_info)
4362 /* A call dummy is sized in words, but it is actually a
4363 series of instructions. Account for that scaling
4365 + ((DEPRECATED_REGISTER_SIZE / INSTRUCTION_SIZE)
4366 * DEPRECATED_CALL_DUMMY_LENGTH)
4367 /* Similarly we have to account for 64bit wide register
4369 + (32 * DEPRECATED_REGISTER_SIZE)
4370 /* We always consider FP regs 8 bytes long. */
4371 + (NUM_REGS - FP0_REGNUM) * 8
4372 /* Similarly we have to account for 64bit wide register
4374 + (6 * DEPRECATED_REGISTER_SIZE)))))
4375 find_dummy_frame_regs (frame_info, frame_saved_regs);
4377 /* Interrupt handlers are special too. They lay out the register
4378 state in the exact same order as the register numbers in GDB. */
4379 if (pc_in_interrupt_handler (get_frame_pc (frame_info)))
4381 for (i = 0; i < NUM_REGS; i++)
4383 /* SP is a little special. */
4385 frame_saved_regs[SP_REGNUM]
4386 = read_memory_integer (get_frame_base (frame_info) + SP_REGNUM * 4,
4387 TARGET_PTR_BIT / 8);
4389 frame_saved_regs[i] = get_frame_base (frame_info) + i * 4;
4394 #ifdef FRAME_FIND_SAVED_REGS_IN_SIGTRAMP
4395 /* Handle signal handler callers. */
4396 if ((get_frame_type (frame_info) == SIGTRAMP_FRAME))
4398 FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info, frame_saved_regs);
4403 /* Get the starting address of the function referred to by the PC
4405 pc = get_frame_func (frame_info);
4408 u = find_unwind_entry (pc);
4412 /* This is how much of a frame adjustment we need to account for. */
4413 stack_remaining = u->Total_frame_size << 3;
4415 /* Magic register saves we want to know about. */
4416 save_rp = u->Save_RP;
4417 save_sp = u->Save_SP;
4419 /* Turn the Entry_GR field into a bitmask. */
4421 for (i = 3; i < u->Entry_GR + 3; i++)
4423 /* Frame pointer gets saved into a special location. */
4424 if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
4427 save_gr |= (1 << i);
4430 /* Turn the Entry_FR field into a bitmask too. */
4432 for (i = 12; i < u->Entry_FR + 12; i++)
4433 save_fr |= (1 << i);
4435 /* The frame always represents the value of %sp at entry to the
4436 current function (and is thus equivalent to the "saved" stack
4438 frame_saved_regs[SP_REGNUM] = get_frame_base (frame_info);
4440 /* Loop until we find everything of interest or hit a branch.
4442 For unoptimized GCC code and for any HP CC code this will never ever
4443 examine any user instructions.
4445 For optimized GCC code we're faced with problems. GCC will schedule
4446 its prologue and make prologue instructions available for delay slot
4447 filling. The end result is user code gets mixed in with the prologue
4448 and a prologue instruction may be in the delay slot of the first branch
4451 Some unexpected things are expected with debugging optimized code, so
4452 we allow this routine to walk past user instructions in optimized
4454 final_iteration = 0;
4455 while ((save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
4456 && pc <= get_frame_pc (frame_info))
4458 status = target_read_memory (pc, buf, 4);
4459 inst = extract_unsigned_integer (buf, 4);
4465 /* Note the interesting effects of this instruction. */
4466 stack_remaining -= prologue_inst_adjust_sp (inst);
4468 /* There are limited ways to store the return pointer into the
4470 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
4473 frame_saved_regs[RP_REGNUM] = get_frame_base (frame_info) - 20;
4475 else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
4478 frame_saved_regs[RP_REGNUM] = get_frame_base (frame_info) - 16;
4481 /* Note if we saved SP into the stack. This also happens to indicate
4482 the location of the saved frame pointer. */
4483 if ( (inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
4484 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
4486 frame_saved_regs[DEPRECATED_FP_REGNUM] = get_frame_base (frame_info);
4490 /* Account for general and floating-point register saves. */
4491 reg = inst_saves_gr (inst);
4492 if (reg >= 3 && reg <= 18
4493 && (!u->Save_SP || reg != DEPRECATED_FP_REGNUM))
4495 save_gr &= ~(1 << reg);
4497 /* stwm with a positive displacement is a *post modify*. */
4498 if ((inst >> 26) == 0x1b
4499 && extract_14 (inst) >= 0)
4500 frame_saved_regs[reg] = get_frame_base (frame_info);
4501 /* A std has explicit post_modify forms. */
4502 else if ((inst & 0xfc00000c) == 0x70000008)
4503 frame_saved_regs[reg] = get_frame_base (frame_info);
4508 if ((inst >> 26) == 0x1c)
4509 offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
4510 else if ((inst >> 26) == 0x03)
4511 offset = low_sign_extend (inst & 0x1f, 5);
4513 offset = extract_14 (inst);
4515 /* Handle code with and without frame pointers. */
4517 frame_saved_regs[reg]
4518 = get_frame_base (frame_info) + offset;
4520 frame_saved_regs[reg]
4521 = (get_frame_base (frame_info) + (u->Total_frame_size << 3)
4527 /* GCC handles callee saved FP regs a little differently.
4529 It emits an instruction to put the value of the start of
4530 the FP store area into %r1. It then uses fstds,ma with
4531 a basereg of %r1 for the stores.
4533 HP CC emits them at the current stack pointer modifying
4534 the stack pointer as it stores each register. */
4536 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
4537 if ((inst & 0xffffc000) == 0x34610000
4538 || (inst & 0xffffc000) == 0x37c10000)
4539 fp_loc = extract_14 (inst);
4541 reg = inst_saves_fr (inst);
4542 if (reg >= 12 && reg <= 21)
4544 /* Note +4 braindamage below is necessary because the FP status
4545 registers are internally 8 registers rather than the expected
4547 save_fr &= ~(1 << reg);
4550 /* 1st HP CC FP register store. After this instruction
4551 we've set enough state that the GCC and HPCC code are
4552 both handled in the same manner. */
4553 frame_saved_regs[reg + FP4_REGNUM + 4] = get_frame_base (frame_info);
4558 frame_saved_regs[reg + FP0_REGNUM + 4]
4559 = get_frame_base (frame_info) + fp_loc;
4564 /* Quit if we hit any kind of branch the previous iteration. */
4565 if (final_iteration)
4568 /* We want to look precisely one instruction beyond the branch
4569 if we have not found everything yet. */
4570 if (is_branch (inst))
4571 final_iteration = 1;
4578 /* XXX - deprecated. This is a compatibility function for targets
4579 that do not yet implement DEPRECATED_FRAME_INIT_SAVED_REGS. */
4580 /* Find the addresses in which registers are saved in FRAME. */
4583 hppa_frame_init_saved_regs (struct frame_info *frame)
4585 if (deprecated_get_frame_saved_regs (frame) == NULL)
4586 frame_saved_regs_zalloc (frame);
4587 hppa_frame_find_saved_regs (frame, deprecated_get_frame_saved_regs (frame));
4590 struct hppa_frame_cache
4593 struct trad_frame_saved_reg *saved_regs;
4596 static struct hppa_frame_cache *
4597 hppa_frame_cache (struct frame_info *next_frame, void **this_cache)
4599 struct hppa_frame_cache *cache;
4604 struct unwind_table_entry *u;
4607 if ((*this_cache) != NULL)
4608 return (*this_cache);
4609 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
4610 (*this_cache) = cache;
4611 cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
4614 u = find_unwind_entry (frame_func_unwind (next_frame));
4616 return (*this_cache);
4618 /* Turn the Entry_GR field into a bitmask. */
4620 for (i = 3; i < u->Entry_GR + 3; i++)
4622 /* Frame pointer gets saved into a special location. */
4623 if (u->Save_SP && i == DEPRECATED_FP_REGNUM)
4626 saved_gr_mask |= (1 << i);
4629 /* Turn the Entry_FR field into a bitmask too. */
4631 for (i = 12; i < u->Entry_FR + 12; i++)
4632 saved_fr_mask |= (1 << i);
4634 /* Loop until we find everything of interest or hit a branch.
4636 For unoptimized GCC code and for any HP CC code this will never ever
4637 examine any user instructions.
4639 For optimized GCC code we're faced with problems. GCC will schedule
4640 its prologue and make prologue instructions available for delay slot
4641 filling. The end result is user code gets mixed in with the prologue
4642 and a prologue instruction may be in the delay slot of the first branch
4645 Some unexpected things are expected with debugging optimized code, so
4646 we allow this routine to walk past user instructions in optimized
4649 int final_iteration = 0;
4651 CORE_ADDR end_pc = skip_prologue_using_sal (pc);
4652 int looking_for_sp = u->Save_SP;
4653 int looking_for_rp = u->Save_RP;
4656 end_pc = frame_pc_unwind (next_frame);
4658 for (pc = frame_func_unwind (next_frame);
4659 ((saved_gr_mask || saved_fr_mask
4660 || looking_for_sp || looking_for_rp
4661 || frame_size < (u->Total_frame_size << 3))
4667 long status = target_read_memory (pc, buf4, sizeof buf4);
4668 long inst = extract_unsigned_integer (buf4, sizeof buf4);
4670 /* Note the interesting effects of this instruction. */
4671 frame_size += prologue_inst_adjust_sp (inst);
4673 /* There are limited ways to store the return pointer into the
4675 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
4678 cache->saved_regs[RP_REGNUM].addr = -20;
4680 else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
4683 cache->saved_regs[RP_REGNUM].addr = -16;
4686 /* Check to see if we saved SP into the stack. This also
4687 happens to indicate the location of the saved frame
4689 if ((inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
4690 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
4693 cache->saved_regs[DEPRECATED_FP_REGNUM].addr = 0;
4696 /* Account for general and floating-point register saves. */
4697 reg = inst_saves_gr (inst);
4698 if (reg >= 3 && reg <= 18
4699 && (!u->Save_SP || reg != DEPRECATED_FP_REGNUM))
4701 saved_gr_mask &= ~(1 << reg);
4702 if ((inst >> 26) == 0x1b && extract_14 (inst) >= 0)
4703 /* stwm with a positive displacement is a _post_
4705 cache->saved_regs[reg].addr = 0;
4706 else if ((inst & 0xfc00000c) == 0x70000008)
4707 /* A std has explicit post_modify forms. */
4708 cache->saved_regs[reg].addr = 0;
4713 if ((inst >> 26) == 0x1c)
4714 offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
4715 else if ((inst >> 26) == 0x03)
4716 offset = low_sign_extend (inst & 0x1f, 5);
4718 offset = extract_14 (inst);
4720 /* Handle code with and without frame pointers. */
4722 cache->saved_regs[reg].addr = offset;
4724 cache->saved_regs[reg].addr = (u->Total_frame_size << 3) + offset;
4728 /* GCC handles callee saved FP regs a little differently.
4730 It emits an instruction to put the value of the start of
4731 the FP store area into %r1. It then uses fstds,ma with a
4732 basereg of %r1 for the stores.
4734 HP CC emits them at the current stack pointer modifying the
4735 stack pointer as it stores each register. */
4737 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
4738 if ((inst & 0xffffc000) == 0x34610000
4739 || (inst & 0xffffc000) == 0x37c10000)
4740 fp_loc = extract_14 (inst);
4742 reg = inst_saves_fr (inst);
4743 if (reg >= 12 && reg <= 21)
4745 /* Note +4 braindamage below is necessary because the FP
4746 status registers are internally 8 registers rather than
4747 the expected 4 registers. */
4748 saved_fr_mask &= ~(1 << reg);
4751 /* 1st HP CC FP register store. After this
4752 instruction we've set enough state that the GCC and
4753 HPCC code are both handled in the same manner. */
4754 cache->saved_regs[reg + FP4_REGNUM + 4].addr = 0;
4759 cache->saved_regs[reg + FP0_REGNUM + 4].addr = fp_loc;
4764 /* Quit if we hit any kind of branch the previous iteration. */
4765 if (final_iteration)
4767 /* We want to look precisely one instruction beyond the branch
4768 if we have not found everything yet. */
4769 if (is_branch (inst))
4770 final_iteration = 1;
4775 /* The frame base always represents the value of %sp at entry to
4776 the current function (and is thus equivalent to the "saved"
4778 CORE_ADDR this_sp = frame_unwind_register_unsigned (next_frame, SP_REGNUM);
4779 /* FIXME: cagney/2004-02-22: This assumes that the frame has been
4780 created. If it hasn't everything will be out-of-wack. */
4781 if (u->Save_SP && trad_frame_addr_p (cache->saved_regs, SP_REGNUM))
4782 /* Both we're expecting the SP to be saved and the SP has been
4783 saved. The entry SP value is saved at this frame's SP
4785 cache->base = read_memory_integer (this_sp, TARGET_PTR_BIT / 8);
4787 /* The prologue has been slowly allocating stack space. Adjust
4789 cache->base = this_sp - frame_size;
4790 trad_frame_set_value (cache->saved_regs, SP_REGNUM, cache->base);
4793 /* The PC is found in the "return register", "Millicode" uses "r31"
4794 as the return register while normal code uses "rp". */
4796 cache->saved_regs[PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
4798 cache->saved_regs[PCOQ_HEAD_REGNUM] = cache->saved_regs[RP_REGNUM];
4801 /* Convert all the offsets into addresses. */
4803 for (reg = 0; reg < NUM_REGS; reg++)
4805 if (trad_frame_addr_p (cache->saved_regs, reg))
4806 cache->saved_regs[reg].addr += cache->base;
4810 return (*this_cache);
4814 hppa_frame_this_id (struct frame_info *next_frame, void **this_cache,
4815 struct frame_id *this_id)
4817 struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
4818 (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame));
4822 hppa_frame_prev_register (struct frame_info *next_frame,
4824 int regnum, int *optimizedp,
4825 enum lval_type *lvalp, CORE_ADDR *addrp,
4826 int *realnump, void *valuep)
4828 struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
4829 struct gdbarch *gdbarch = get_frame_arch (next_frame);
4830 if (regnum == PCOQ_TAIL_REGNUM)
4832 /* The PCOQ TAIL, or NPC, needs to be computed from the unwound
4840 int regsize = register_size (gdbarch, PCOQ_HEAD_REGNUM);
4843 enum lval_type lval;
4846 bfd_byte value[MAX_REGISTER_SIZE];
4847 trad_frame_prev_register (next_frame, info->saved_regs,
4848 PCOQ_HEAD_REGNUM, &optimized, &lval, &addr,
4850 pc = extract_unsigned_integer (&value, regsize);
4851 store_unsigned_integer (valuep, regsize, pc + 4);
4856 trad_frame_prev_register (next_frame, info->saved_regs, regnum,
4857 optimizedp, lvalp, addrp, realnump, valuep);
4861 static const struct frame_unwind hppa_frame_unwind =
4865 hppa_frame_prev_register
4868 static const struct frame_unwind *
4869 hppa_frame_unwind_sniffer (struct frame_info *next_frame)
4871 return &hppa_frame_unwind;
4875 hppa_frame_base_address (struct frame_info *next_frame,
4878 struct hppa_frame_cache *info = hppa_frame_cache (next_frame,
4883 static const struct frame_base hppa_frame_base = {
4885 hppa_frame_base_address,
4886 hppa_frame_base_address,
4887 hppa_frame_base_address
4890 static const struct frame_base *
4891 hppa_frame_base_sniffer (struct frame_info *next_frame)
4893 return &hppa_frame_base;
4896 static struct frame_id
4897 hppa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
4899 return frame_id_build (frame_unwind_register_unsigned (next_frame,
4901 frame_pc_unwind (next_frame));
4905 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
4907 return frame_unwind_register_signed (next_frame, PCOQ_HEAD_REGNUM) & ~3;
4910 /* Exception handling support for the HP-UX ANSI C++ compiler.
4911 The compiler (aCC) provides a callback for exception events;
4912 GDB can set a breakpoint on this callback and find out what
4913 exception event has occurred. */
4915 /* The name of the hook to be set to point to the callback function */
4916 static char HP_ACC_EH_notify_hook[] = "__eh_notify_hook";
4917 /* The name of the function to be used to set the hook value */
4918 static char HP_ACC_EH_set_hook_value[] = "__eh_set_hook_value";
4919 /* The name of the callback function in end.o */
4920 static char HP_ACC_EH_notify_callback[] = "__d_eh_notify_callback";
4921 /* Name of function in end.o on which a break is set (called by above) */
4922 static char HP_ACC_EH_break[] = "__d_eh_break";
4923 /* Name of flag (in end.o) that enables catching throws */
4924 static char HP_ACC_EH_catch_throw[] = "__d_eh_catch_throw";
4925 /* Name of flag (in end.o) that enables catching catching */
4926 static char HP_ACC_EH_catch_catch[] = "__d_eh_catch_catch";
4927 /* The enum used by aCC */
4935 /* Is exception-handling support available with this executable? */
4936 static int hp_cxx_exception_support = 0;
4937 /* Has the initialize function been run? */
4938 int hp_cxx_exception_support_initialized = 0;
4939 /* Similar to above, but imported from breakpoint.c -- non-target-specific */
4940 extern int exception_support_initialized;
4941 /* Address of __eh_notify_hook */
4942 static CORE_ADDR eh_notify_hook_addr = 0;
4943 /* Address of __d_eh_notify_callback */
4944 static CORE_ADDR eh_notify_callback_addr = 0;
4945 /* Address of __d_eh_break */
4946 static CORE_ADDR eh_break_addr = 0;
4947 /* Address of __d_eh_catch_catch */
4948 static CORE_ADDR eh_catch_catch_addr = 0;
4949 /* Address of __d_eh_catch_throw */
4950 static CORE_ADDR eh_catch_throw_addr = 0;
4951 /* Sal for __d_eh_break */
4952 static struct symtab_and_line *break_callback_sal = 0;
4954 /* Code in end.c expects __d_pid to be set in the inferior,
4955 otherwise __d_eh_notify_callback doesn't bother to call
4956 __d_eh_break! So we poke the pid into this symbol
4961 setup_d_pid_in_inferior (void)
4964 struct minimal_symbol *msymbol;
4965 char buf[4]; /* FIXME 32x64? */
4967 /* Slam the pid of the process into __d_pid; failing is only a warning! */
4968 msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
4969 if (msymbol == NULL)
4971 warning ("Unable to find __d_pid symbol in object file.");
4972 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4976 anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
4977 store_unsigned_integer (buf, 4, PIDGET (inferior_ptid)); /* FIXME 32x64? */
4978 if (target_write_memory (anaddr, buf, 4)) /* FIXME 32x64? */
4980 warning ("Unable to write __d_pid");
4981 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
4987 /* Initialize exception catchpoint support by looking for the
4988 necessary hooks/callbacks in end.o, etc., and set the hook value to
4989 point to the required debug function
4995 initialize_hp_cxx_exception_support (void)
4997 struct symtabs_and_lines sals;
4998 struct cleanup *old_chain;
4999 struct cleanup *canonical_strings_chain = NULL;
5002 char *addr_end = NULL;
5003 char **canonical = (char **) NULL;
5005 struct symbol *sym = NULL;
5006 struct minimal_symbol *msym = NULL;
5007 struct objfile *objfile;
5008 asection *shlib_info;
5010 /* Detect and disallow recursion. On HP-UX with aCC, infinite
5011 recursion is a possibility because finding the hook for exception
5012 callbacks involves making a call in the inferior, which means
5013 re-inserting breakpoints which can re-invoke this code */
5015 static int recurse = 0;
5018 hp_cxx_exception_support_initialized = 0;
5019 exception_support_initialized = 0;
5023 hp_cxx_exception_support = 0;
5025 /* First check if we have seen any HP compiled objects; if not,
5026 it is very unlikely that HP's idiosyncratic callback mechanism
5027 for exception handling debug support will be available!
5028 This will percolate back up to breakpoint.c, where our callers
5029 will decide to try the g++ exception-handling support instead. */
5030 if (!hp_som_som_object_present)
5033 /* We have a SOM executable with SOM debug info; find the hooks */
5035 /* First look for the notify hook provided by aCC runtime libs */
5036 /* If we find this symbol, we conclude that the executable must
5037 have HP aCC exception support built in. If this symbol is not
5038 found, even though we're a HP SOM-SOM file, we may have been
5039 built with some other compiler (not aCC). This results percolates
5040 back up to our callers in breakpoint.c which can decide to
5041 try the g++ style of exception support instead.
5042 If this symbol is found but the other symbols we require are
5043 not found, there is something weird going on, and g++ support
5044 should *not* be tried as an alternative.
5046 ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
5047 ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
5049 /* libCsup has this hook; it'll usually be non-debuggable */
5050 msym = lookup_minimal_symbol (HP_ACC_EH_notify_hook, NULL, NULL);
5053 eh_notify_hook_addr = SYMBOL_VALUE_ADDRESS (msym);
5054 hp_cxx_exception_support = 1;
5058 warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook);
5059 warning ("Executable may not have been compiled debuggable with HP aCC.");
5060 warning ("GDB will be unable to intercept exception events.");
5061 eh_notify_hook_addr = 0;
5062 hp_cxx_exception_support = 0;
5066 /* Next look for the notify callback routine in end.o */
5067 /* This is always available in the SOM symbol dictionary if end.o is linked in */
5068 msym = lookup_minimal_symbol (HP_ACC_EH_notify_callback, NULL, NULL);
5071 eh_notify_callback_addr = SYMBOL_VALUE_ADDRESS (msym);
5072 hp_cxx_exception_support = 1;
5076 warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback);
5077 warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
5078 warning ("GDB will be unable to intercept exception events.");
5079 eh_notify_callback_addr = 0;
5083 #ifndef GDB_TARGET_IS_HPPA_20W
5084 /* Check whether the executable is dynamically linked or archive bound */
5085 /* With an archive-bound executable we can use the raw addresses we find
5086 for the callback function, etc. without modification. For an executable
5087 with shared libraries, we have to do more work to find the plabel, which
5088 can be the target of a call through $$dyncall from the aCC runtime support
5089 library (libCsup) which is linked shared by default by aCC. */
5090 /* This test below was copied from somsolib.c/somread.c. It may not be a very
5091 reliable one to test that an executable is linked shared. pai/1997-07-18 */
5092 shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
5093 if (shlib_info && (bfd_section_size (symfile_objfile->obfd, shlib_info) != 0))
5095 /* The minsym we have has the local code address, but that's not the
5096 plabel that can be used by an inter-load-module call. */
5097 /* Find solib handle for main image (which has end.o), and use that
5098 and the min sym as arguments to __d_shl_get() (which does the equivalent
5099 of shl_findsym()) to find the plabel. */
5101 args_for_find_stub args;
5102 static char message[] = "Error while finding exception callback hook:\n";
5104 args.solib_handle = som_solib_get_solib_by_pc (eh_notify_callback_addr);
5106 args.return_val = 0;
5109 catch_errors (cover_find_stub_with_shl_get, &args, message,
5111 eh_notify_callback_addr = args.return_val;
5114 exception_catchpoints_are_fragile = 1;
5116 if (!eh_notify_callback_addr)
5118 /* We can get here either if there is no plabel in the export list
5119 for the main image, or if something strange happened (?) */
5120 warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
5121 warning ("GDB will not be able to intercept exception events.");
5126 exception_catchpoints_are_fragile = 0;
5129 /* Now, look for the breakpointable routine in end.o */
5130 /* This should also be available in the SOM symbol dict. if end.o linked in */
5131 msym = lookup_minimal_symbol (HP_ACC_EH_break, NULL, NULL);
5134 eh_break_addr = SYMBOL_VALUE_ADDRESS (msym);
5135 hp_cxx_exception_support = 1;
5139 warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break);
5140 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
5141 warning ("GDB will be unable to intercept exception events.");
5146 /* Next look for the catch enable flag provided in end.o */
5147 sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
5148 VAR_DOMAIN, 0, (struct symtab **) NULL);
5149 if (sym) /* sometimes present in debug info */
5151 eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (sym);
5152 hp_cxx_exception_support = 1;
5155 /* otherwise look in SOM symbol dict. */
5157 msym = lookup_minimal_symbol (HP_ACC_EH_catch_catch, NULL, NULL);
5160 eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (msym);
5161 hp_cxx_exception_support = 1;
5165 warning ("Unable to enable interception of exception catches.");
5166 warning ("Executable may not have been compiled debuggable with HP aCC.");
5167 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
5172 /* Next look for the catch enable flag provided end.o */
5173 sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
5174 VAR_DOMAIN, 0, (struct symtab **) NULL);
5175 if (sym) /* sometimes present in debug info */
5177 eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (sym);
5178 hp_cxx_exception_support = 1;
5181 /* otherwise look in SOM symbol dict. */
5183 msym = lookup_minimal_symbol (HP_ACC_EH_catch_throw, NULL, NULL);
5186 eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (msym);
5187 hp_cxx_exception_support = 1;
5191 warning ("Unable to enable interception of exception throws.");
5192 warning ("Executable may not have been compiled debuggable with HP aCC.");
5193 warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
5199 hp_cxx_exception_support = 2; /* everything worked so far */
5200 hp_cxx_exception_support_initialized = 1;
5201 exception_support_initialized = 1;
5206 /* Target operation for enabling or disabling interception of
5208 KIND is either EX_EVENT_THROW or EX_EVENT_CATCH
5209 ENABLE is either 0 (disable) or 1 (enable).
5210 Return value is NULL if no support found;
5211 -1 if something went wrong,
5212 or a pointer to a symtab/line struct if the breakpointable
5213 address was found. */
5215 struct symtab_and_line *
5216 child_enable_exception_callback (enum exception_event_kind kind, int enable)
5220 if (!exception_support_initialized || !hp_cxx_exception_support_initialized)
5221 if (!initialize_hp_cxx_exception_support ())
5224 switch (hp_cxx_exception_support)
5227 /* Assuming no HP support at all */
5230 /* HP support should be present, but something went wrong */
5231 return (struct symtab_and_line *) -1; /* yuck! */
5232 /* there may be other cases in the future */
5235 /* Set the EH hook to point to the callback routine */
5236 store_unsigned_integer (buf, 4, enable ? eh_notify_callback_addr : 0); /* FIXME 32x64 problem */
5237 /* pai: (temp) FIXME should there be a pack operation first? */
5238 if (target_write_memory (eh_notify_hook_addr, buf, 4)) /* FIXME 32x64 problem */
5240 warning ("Could not write to target memory for exception event callback.");
5241 warning ("Interception of exception events may not work.");
5242 return (struct symtab_and_line *) -1;
5246 /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
5247 if (PIDGET (inferior_ptid) > 0)
5249 if (setup_d_pid_in_inferior ())
5250 return (struct symtab_and_line *) -1;
5254 warning ("Internal error: Invalid inferior pid? Cannot intercept exception events.");
5255 return (struct symtab_and_line *) -1;
5261 case EX_EVENT_THROW:
5262 store_unsigned_integer (buf, 4, enable ? 1 : 0);
5263 if (target_write_memory (eh_catch_throw_addr, buf, 4)) /* FIXME 32x64? */
5265 warning ("Couldn't enable exception throw interception.");
5266 return (struct symtab_and_line *) -1;
5269 case EX_EVENT_CATCH:
5270 store_unsigned_integer (buf, 4, enable ? 1 : 0);
5271 if (target_write_memory (eh_catch_catch_addr, buf, 4)) /* FIXME 32x64? */
5273 warning ("Couldn't enable exception catch interception.");
5274 return (struct symtab_and_line *) -1;
5278 error ("Request to enable unknown or unsupported exception event.");
5281 /* Copy break address into new sal struct, malloc'ing if needed. */
5282 if (!break_callback_sal)
5284 break_callback_sal = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
5286 init_sal (break_callback_sal);
5287 break_callback_sal->symtab = NULL;
5288 break_callback_sal->pc = eh_break_addr;
5289 break_callback_sal->line = 0;
5290 break_callback_sal->end = eh_break_addr;
5292 return break_callback_sal;
5295 /* Record some information about the current exception event */
5296 static struct exception_event_record current_ex_event;
5297 /* Convenience struct */
5298 static struct symtab_and_line null_symtab_and_line =
5301 /* Report current exception event. Returns a pointer to a record
5302 that describes the kind of the event, where it was thrown from,
5303 and where it will be caught. More information may be reported
5305 struct exception_event_record *
5306 child_get_current_exception_event (void)
5308 CORE_ADDR event_kind;
5309 CORE_ADDR throw_addr;
5310 CORE_ADDR catch_addr;
5311 struct frame_info *fi, *curr_frame;
5314 curr_frame = get_current_frame ();
5316 return (struct exception_event_record *) NULL;
5318 /* Go up one frame to __d_eh_notify_callback, because at the
5319 point when this code is executed, there's garbage in the
5320 arguments of __d_eh_break. */
5321 fi = find_relative_frame (curr_frame, &level);
5323 return (struct exception_event_record *) NULL;
5327 /* Read in the arguments */
5328 /* __d_eh_notify_callback() is called with 3 arguments:
5329 1. event kind catch or throw
5330 2. the target address if known
5331 3. a flag -- not sure what this is. pai/1997-07-17 */
5332 event_kind = read_register (ARG0_REGNUM);
5333 catch_addr = read_register (ARG1_REGNUM);
5335 /* Now go down to a user frame */
5336 /* For a throw, __d_eh_break is called by
5337 __d_eh_notify_callback which is called by
5338 __notify_throw which is called
5340 For a catch, __d_eh_break is called by
5341 __d_eh_notify_callback which is called by
5342 <stackwalking stuff> which is called by
5343 __throw__<stuff> or __rethrow_<stuff> which is called
5345 /* FIXME: Don't use such magic numbers; search for the frames */
5346 level = (event_kind == EX_EVENT_THROW) ? 3 : 4;
5347 fi = find_relative_frame (curr_frame, &level);
5349 return (struct exception_event_record *) NULL;
5352 throw_addr = get_frame_pc (fi);
5354 /* Go back to original (top) frame */
5355 select_frame (curr_frame);
5357 current_ex_event.kind = (enum exception_event_kind) event_kind;
5358 current_ex_event.throw_sal = find_pc_line (throw_addr, 1);
5359 current_ex_event.catch_sal = find_pc_line (catch_addr, 1);
5361 return ¤t_ex_event;
5364 /* Instead of this nasty cast, add a method pvoid() that prints out a
5365 host VOID data type (remember %p isn't portable). */
5368 hppa_pointer_to_address_hack (void *ptr)
5370 gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr));
5371 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr, &ptr);
5375 unwind_command (char *exp, int from_tty)
5378 struct unwind_table_entry *u;
5380 /* If we have an expression, evaluate it and use it as the address. */
5382 if (exp != 0 && *exp != 0)
5383 address = parse_and_eval_address (exp);
5387 u = find_unwind_entry (address);
5391 printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
5395 printf_unfiltered ("unwind_table_entry (0x%s):\n",
5396 paddr_nz (hppa_pointer_to_address_hack (u)));
5398 printf_unfiltered ("\tregion_start = ");
5399 print_address (u->region_start, gdb_stdout);
5401 printf_unfiltered ("\n\tregion_end = ");
5402 print_address (u->region_end, gdb_stdout);
5404 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
5406 printf_unfiltered ("\n\tflags =");
5407 pif (Cannot_unwind);
5409 pif (Millicode_save_sr0);
5412 pif (Variable_Frame);
5413 pif (Separate_Package_Body);
5414 pif (Frame_Extension_Millicode);
5415 pif (Stack_Overflow_Check);
5416 pif (Two_Instruction_SP_Increment);
5420 pif (Save_MRP_in_frame);
5421 pif (extn_ptr_defined);
5422 pif (Cleanup_defined);
5423 pif (MPE_XL_interrupt_marker);
5424 pif (HP_UX_interrupt_marker);
5427 putchar_unfiltered ('\n');
5429 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
5431 pin (Region_description);
5434 pin (Total_frame_size);
5438 hppa_skip_permanent_breakpoint (void)
5440 /* To step over a breakpoint instruction on the PA takes some
5441 fiddling with the instruction address queue.
5443 When we stop at a breakpoint, the IA queue front (the instruction
5444 we're executing now) points at the breakpoint instruction, and
5445 the IA queue back (the next instruction to execute) points to
5446 whatever instruction we would execute after the breakpoint, if it
5447 were an ordinary instruction. This is the case even if the
5448 breakpoint is in the delay slot of a branch instruction.
5450 Clearly, to step past the breakpoint, we need to set the queue
5451 front to the back. But what do we put in the back? What
5452 instruction comes after that one? Because of the branch delay
5453 slot, the next insn is always at the back + 4. */
5454 write_register (PCOQ_HEAD_REGNUM, read_register (PCOQ_TAIL_REGNUM));
5455 write_register (PCSQ_HEAD_REGNUM, read_register (PCSQ_TAIL_REGNUM));
5457 write_register (PCOQ_TAIL_REGNUM, read_register (PCOQ_TAIL_REGNUM) + 4);
5458 /* We can leave the tail's space the same, since there's no jump. */
5461 /* Same as hppa32_store_return_value(), but for the PA64 ABI. */
5464 hppa64_store_return_value (struct type *type, char *valbuf)
5466 if (TYPE_CODE (type) == TYPE_CODE_FLT)
5467 deprecated_write_register_bytes
5468 (DEPRECATED_REGISTER_BYTE (FP4_REGNUM)
5469 + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
5470 valbuf, TYPE_LENGTH (type));
5471 else if (is_integral_type(type))
5472 deprecated_write_register_bytes
5473 (DEPRECATED_REGISTER_BYTE (28)
5474 + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
5475 valbuf, TYPE_LENGTH (type));
5476 else if (TYPE_LENGTH (type) <= 8)
5477 deprecated_write_register_bytes
5478 (DEPRECATED_REGISTER_BYTE (28),valbuf, TYPE_LENGTH (type));
5479 else if (TYPE_LENGTH (type) <= 16)
5481 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (28),valbuf, 8);
5482 deprecated_write_register_bytes
5483 (DEPRECATED_REGISTER_BYTE (29), valbuf + 8, TYPE_LENGTH (type) - 8);
5487 /* Same as hppa32_extract_return_value but for the PA64 ABI case. */
5490 hppa64_extract_return_value (struct type *type, char *regbuf, char *valbuf)
5492 /* RM: Floats are returned in FR4R, doubles in FR4.
5493 Integral values are in r28, padded on the left.
5494 Aggregates less that 65 bits are in r28, right padded.
5495 Aggregates upto 128 bits are in r28 and r29, right padded. */
5496 if (TYPE_CODE (type) == TYPE_CODE_FLT)
5498 regbuf + DEPRECATED_REGISTER_BYTE (FP4_REGNUM)
5499 + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
5500 TYPE_LENGTH (type));
5501 else if (is_integral_type(type))
5503 regbuf + DEPRECATED_REGISTER_BYTE (28)
5504 + DEPRECATED_REGISTER_SIZE - TYPE_LENGTH (type),
5505 TYPE_LENGTH (type));
5506 else if (TYPE_LENGTH (type) <= 8)
5507 memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (28),
5508 TYPE_LENGTH (type));
5509 else if (TYPE_LENGTH (type) <= 16)
5511 memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (28), 8);
5512 memcpy (valbuf + 8, regbuf + DEPRECATED_REGISTER_BYTE (29),
5513 TYPE_LENGTH (type) - 8);
5518 hppa_reg_struct_has_addr (int gcc_p, struct type *type)
5520 /* On the PA, any pass-by-value structure > 8 bytes is actually passed
5521 via a pointer regardless of its type or the compiler used. */
5522 return (TYPE_LENGTH (type) > 8);
5526 hppa_inner_than (CORE_ADDR lhs, CORE_ADDR rhs)
5528 /* Stack grows upward */
5533 hppa64_stack_align (CORE_ADDR sp)
5535 /* The PA64 ABI mandates a 16 byte stack alignment. */
5536 return ((sp % 16) ? (sp + 15) & -16 : sp);
5540 hppa_pc_requires_run_before_use (CORE_ADDR pc)
5542 /* Sometimes we may pluck out a minimal symbol that has a negative address.
5544 An example of this occurs when an a.out is linked against a foo.sl.
5545 The foo.sl defines a global bar(), and the a.out declares a signature
5546 for bar(). However, the a.out doesn't directly call bar(), but passes
5547 its address in another call.
5549 If you have this scenario and attempt to "break bar" before running,
5550 gdb will find a minimal symbol for bar() in the a.out. But that
5551 symbol's address will be negative. What this appears to denote is
5552 an index backwards from the base of the procedure linkage table (PLT)
5553 into the data linkage table (DLT), the end of which is contiguous
5554 with the start of the PLT. This is clearly not a valid address for
5555 us to set a breakpoint on.
5557 Note that one must be careful in how one checks for a negative address.
5558 0xc0000000 is a legitimate address of something in a shared text
5559 segment, for example. Since I don't know what the possible range
5560 is of these "really, truly negative" addresses that come from the
5561 minimal symbols, I'm resorting to the gross hack of checking the
5562 top byte of the address for all 1's. Sigh. */
5564 return (!target_has_stack && (pc & 0xFF000000));
5568 hppa_instruction_nullified (void)
5570 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
5571 avoid the type cast. I'm leaving it as is for now as I'm doing
5572 semi-mechanical multiarching-related changes. */
5573 const int ipsw = (int) read_register (IPSW_REGNUM);
5574 const int flags = (int) read_register (FLAGS_REGNUM);
5576 return ((ipsw & 0x00200000) && !(flags & 0x2));
5580 hppa_register_raw_size (int reg_nr)
5582 /* All registers have the same size. */
5583 return DEPRECATED_REGISTER_SIZE;
5586 /* Index within the register vector of the first byte of the space i
5587 used for register REG_NR. */
5590 hppa_register_byte (int reg_nr)
5592 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
5594 return reg_nr * tdep->bytes_per_address;
5597 /* Return the GDB type object for the "standard" data type of data
5601 hppa32_register_virtual_type (int reg_nr)
5603 if (reg_nr < FP4_REGNUM)
5604 return builtin_type_int;
5606 return builtin_type_float;
5609 /* Return the GDB type object for the "standard" data type of data
5610 in register N. hppa64 version. */
5613 hppa64_register_virtual_type (int reg_nr)
5615 if (reg_nr < FP4_REGNUM)
5616 return builtin_type_unsigned_long_long;
5618 return builtin_type_double;
5621 /* Store the address of the place in which to copy the structure the
5622 subroutine will return. This is called from call_function. */
5625 hppa_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
5627 write_register (28, addr);
5629 /* Return True if REGNUM is not a register available to the user
5630 through ptrace(). */
5633 hppa_cannot_store_register (int regnum)
5636 || regnum == PCSQ_HEAD_REGNUM
5637 || (regnum >= PCSQ_TAIL_REGNUM && regnum < IPSW_REGNUM)
5638 || (regnum > IPSW_REGNUM && regnum < FP4_REGNUM));
5643 hppa_smash_text_address (CORE_ADDR addr)
5645 /* The low two bits of the PC on the PA contain the privilege level.
5646 Some genius implementing a (non-GCC) compiler apparently decided
5647 this means that "addresses" in a text section therefore include a
5648 privilege level, and thus symbol tables should contain these bits.
5649 This seems like a bonehead thing to do--anyway, it seems to work
5650 for our purposes to just ignore those bits. */
5652 return (addr &= ~0x3);
5655 /* Get the ith function argument for the current function. */
5657 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
5661 get_frame_register (frame, R0_REGNUM + 26 - argi, &addr);
5665 /* Here is a table of C type sizes on hppa with various compiles
5666 and options. I measured this on PA 9000/800 with HP-UX 11.11
5667 and these compilers:
5669 /usr/ccs/bin/cc HP92453-01 A.11.01.21
5670 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
5671 /opt/aCC/bin/aCC B3910B A.03.45
5672 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
5674 cc : 1 2 4 4 8 : 4 8 -- : 4 4
5675 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
5676 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
5677 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
5678 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
5679 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
5680 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
5681 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
5685 compiler and options
5686 char, short, int, long, long long
5687 float, double, long double
5690 So all these compilers use either ILP32 or LP64 model.
5691 TODO: gcc has more options so it needs more investigation.
5693 For floating point types, see:
5695 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
5696 HP-UX floating-point guide, hpux 11.00
5698 -- chastain 2003-12-18 */
5700 static struct gdbarch *
5701 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
5703 struct gdbarch_tdep *tdep;
5704 struct gdbarch *gdbarch;
5706 /* Try to determine the ABI of the object we are loading. */
5707 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
5709 /* If it's a SOM file, assume it's HP/UX SOM. */
5710 if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
5711 info.osabi = GDB_OSABI_HPUX_SOM;
5714 /* find a candidate among the list of pre-declared architectures. */
5715 arches = gdbarch_list_lookup_by_info (arches, &info);
5717 return (arches->gdbarch);
5719 /* If none found, then allocate and initialize one. */
5720 tdep = XMALLOC (struct gdbarch_tdep);
5721 gdbarch = gdbarch_alloc (&info, tdep);
5723 /* Determine from the bfd_arch_info structure if we are dealing with
5724 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
5725 then default to a 32bit machine. */
5726 if (info.bfd_arch_info != NULL)
5727 tdep->bytes_per_address =
5728 info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
5730 tdep->bytes_per_address = 4;
5732 /* Some parts of the gdbarch vector depend on whether we are running
5733 on a 32 bits or 64 bits target. */
5734 switch (tdep->bytes_per_address)
5737 set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
5738 set_gdbarch_register_name (gdbarch, hppa32_register_name);
5739 set_gdbarch_deprecated_register_virtual_type
5740 (gdbarch, hppa32_register_virtual_type);
5743 set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
5744 set_gdbarch_register_name (gdbarch, hppa64_register_name);
5745 set_gdbarch_deprecated_register_virtual_type
5746 (gdbarch, hppa64_register_virtual_type);
5749 internal_error (__FILE__, __LINE__, "Unsupported address size: %d",
5750 tdep->bytes_per_address);
5753 /* The following gdbarch vector elements depend on other parts of this
5754 vector which have been set above, depending on the ABI. */
5755 set_gdbarch_deprecated_register_bytes
5756 (gdbarch, gdbarch_num_regs (gdbarch) * tdep->bytes_per_address);
5757 set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
5758 set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
5760 /* The following gdbarch vector elements are the same in both ILP32
5761 and LP64, but might show differences some day. */
5762 set_gdbarch_long_long_bit (gdbarch, 64);
5763 set_gdbarch_long_double_bit (gdbarch, 128);
5764 set_gdbarch_long_double_format (gdbarch, &floatformat_ia64_quad_big);
5766 /* The following gdbarch vector elements do not depend on the address
5767 size, or in any other gdbarch element previously set. */
5768 set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
5769 set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code);
5770 set_gdbarch_in_solib_call_trampoline (gdbarch, hppa_in_solib_call_trampoline);
5771 set_gdbarch_in_solib_return_trampoline (gdbarch,
5772 hppa_in_solib_return_trampoline);
5773 set_gdbarch_inner_than (gdbarch, hppa_inner_than);
5774 set_gdbarch_deprecated_register_size (gdbarch, tdep->bytes_per_address);
5775 set_gdbarch_deprecated_fp_regnum (gdbarch, 3);
5776 set_gdbarch_sp_regnum (gdbarch, 30);
5777 set_gdbarch_fp0_regnum (gdbarch, 64);
5778 set_gdbarch_deprecated_register_raw_size (gdbarch, hppa_register_raw_size);
5779 set_gdbarch_deprecated_register_byte (gdbarch, hppa_register_byte);
5780 set_gdbarch_deprecated_register_virtual_size (gdbarch, hppa_register_raw_size);
5781 set_gdbarch_deprecated_max_register_raw_size (gdbarch, tdep->bytes_per_address);
5782 set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
5783 set_gdbarch_cannot_store_register (gdbarch, hppa_cannot_store_register);
5784 set_gdbarch_addr_bits_remove (gdbarch, hppa_smash_text_address);
5785 set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
5786 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
5787 set_gdbarch_read_pc (gdbarch, hppa_target_read_pc);
5788 set_gdbarch_write_pc (gdbarch, hppa_target_write_pc);
5789 set_gdbarch_deprecated_target_read_fp (gdbarch, hppa_target_read_fp);
5791 /* Helper for function argument information. */
5792 set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
5794 set_gdbarch_print_insn (gdbarch, print_insn_hppa);
5796 /* When a hardware watchpoint triggers, we'll move the inferior past
5797 it by removing all eventpoints; stepping past the instruction
5798 that caused the trigger; reinserting eventpoints; and checking
5799 whether any watched location changed. */
5800 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
5802 /* Inferior function call methods. */
5803 switch (tdep->bytes_per_address)
5806 set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
5807 set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
5810 set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
5811 set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
5814 internal_error (__FILE__, __LINE__, "bad switch");
5817 /* Struct return methods. */
5818 switch (tdep->bytes_per_address)
5821 set_gdbarch_return_value (gdbarch, hppa32_return_value);
5824 set_gdbarch_return_value (gdbarch, hppa64_return_value);
5826 internal_error (__FILE__, __LINE__, "bad switch");
5829 /* Frame unwind methods. */
5830 set_gdbarch_unwind_dummy_id (gdbarch, hppa_unwind_dummy_id);
5831 set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
5832 frame_unwind_append_sniffer (gdbarch, hppa_frame_unwind_sniffer);
5833 frame_base_append_sniffer (gdbarch, hppa_frame_base_sniffer);
5835 /* Hook in ABI-specific overrides, if they have been registered. */
5836 gdbarch_init_osabi (info, gdbarch);
5842 hppa_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
5844 /* Nothing to print for the moment. */
5848 _initialize_hppa_tdep (void)
5850 struct cmd_list_element *c;
5851 void break_at_finish_command (char *arg, int from_tty);
5852 void tbreak_at_finish_command (char *arg, int from_tty);
5853 void break_at_finish_at_depth_command (char *arg, int from_tty);
5855 gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
5857 add_cmd ("unwind", class_maintenance, unwind_command,
5858 "Print unwind table entry at given address.",
5859 &maintenanceprintlist);
5861 deprecate_cmd (add_com ("xbreak", class_breakpoint,
5862 break_at_finish_command,
5863 concat ("Set breakpoint at procedure exit. \n\
5864 Argument may be function name, or \"*\" and an address.\n\
5865 If function is specified, break at end of code for that function.\n\
5866 If an address is specified, break at the end of the function that contains \n\
5867 that exact address.\n",
5868 "With no arg, uses current execution address of selected stack frame.\n\
5869 This is useful for breaking on return to a stack frame.\n\
5871 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
5873 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL)), NULL);
5874 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint, 1), NULL);
5875 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint, 1), NULL);
5876 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint, 1), NULL);
5877 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint, 1), NULL);
5879 deprecate_cmd (c = add_com ("txbreak", class_breakpoint,
5880 tbreak_at_finish_command,
5881 "Set temporary breakpoint at procedure exit. Either there should\n\
5882 be no argument or the argument must be a depth.\n"), NULL);
5883 set_cmd_completer (c, location_completer);
5886 deprecate_cmd (add_com ("bx", class_breakpoint,
5887 break_at_finish_at_depth_command,
5888 "Set breakpoint at procedure exit. Either there should\n\
5889 be no argument or the argument must be a depth.\n"), NULL);