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"
55 #include "hppa-tdep.h"
57 static int hppa_debug
= 0;
59 /* Some local constants. */
60 static const int hppa32_num_regs
= 128;
61 static const int hppa64_num_regs
= 96;
63 /* hppa-specific object data -- unwind and solib info.
64 TODO/maybe: think about splitting this into two parts; the unwind data is
65 common to all hppa targets, but is only used in this file; we can register
66 that separately and make this static. The solib data is probably hpux-
67 specific, so we can create a separate extern objfile_data that is registered
68 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
69 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
71 /* Get at various relevent fields of an instruction word. */
74 #define MASK_14 0x3fff
75 #define MASK_21 0x1fffff
77 /* Define offsets into the call dummy for the _sr4export address.
78 See comments related to CALL_DUMMY for more info. */
79 #define SR4EXPORT_LDIL_OFFSET (HPPA_INSTRUCTION_SIZE * 12)
80 #define SR4EXPORT_LDO_OFFSET (HPPA_INSTRUCTION_SIZE * 13)
82 /* To support detection of the pseudo-initial frame
84 #define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
85 #define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
87 /* Sizes (in bytes) of the native unwind entries. */
88 #define UNWIND_ENTRY_SIZE 16
89 #define STUB_UNWIND_ENTRY_SIZE 8
91 static void unwind_command (char *, int);
93 static int hppa_alignof (struct type
*);
95 static int prologue_inst_adjust_sp (unsigned long);
97 static int is_branch (unsigned long);
99 static int inst_saves_gr (unsigned long);
101 static int inst_saves_fr (unsigned long);
103 static int compare_unwind_entries (const void *, const void *);
105 static void read_unwind_info (struct objfile
*);
107 static void internalize_unwinds (struct objfile
*,
108 struct unwind_table_entry
*,
109 asection
*, unsigned int,
110 unsigned int, CORE_ADDR
);
111 static void record_text_segment_lowaddr (bfd
*, asection
*, void *);
112 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
113 following functions static, once we hppa is partially multiarched. */
114 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
115 int hppa_instruction_nullified (void);
117 /* Handle 32/64-bit struct return conventions. */
119 static enum return_value_convention
120 hppa32_return_value (struct gdbarch
*gdbarch
,
121 struct type
*type
, struct regcache
*regcache
,
122 void *readbuf
, const void *writebuf
)
124 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
127 regcache_cooked_read_part (regcache
, FP4_REGNUM
, 0,
128 TYPE_LENGTH (type
), readbuf
);
129 if (writebuf
!= NULL
)
130 regcache_cooked_write_part (regcache
, FP4_REGNUM
, 0,
131 TYPE_LENGTH (type
), writebuf
);
132 return RETURN_VALUE_REGISTER_CONVENTION
;
134 if (TYPE_LENGTH (type
) <= 2 * 4)
136 /* The value always lives in the right hand end of the register
137 (or register pair)? */
140 int part
= TYPE_LENGTH (type
) % 4;
141 /* The left hand register contains only part of the value,
142 transfer that first so that the rest can be xfered as entire
147 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
149 if (writebuf
!= NULL
)
150 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
154 /* Now transfer the remaining register values. */
155 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
158 regcache_cooked_read (regcache
, reg
, (char *) readbuf
+ b
);
159 if (writebuf
!= NULL
)
160 regcache_cooked_write (regcache
, reg
, (const char *) writebuf
+ b
);
163 return RETURN_VALUE_REGISTER_CONVENTION
;
166 return RETURN_VALUE_STRUCT_CONVENTION
;
169 static enum return_value_convention
170 hppa64_return_value (struct gdbarch
*gdbarch
,
171 struct type
*type
, struct regcache
*regcache
,
172 void *readbuf
, const void *writebuf
)
174 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
175 are in r28, padded on the left. Aggregates less that 65 bits are
176 in r28, right padded. Aggregates upto 128 bits are in r28 and
177 r29, right padded. */
178 if (TYPE_CODE (type
) == TYPE_CODE_FLT
179 && TYPE_LENGTH (type
) <= 8)
181 /* Floats are right aligned? */
182 int offset
= register_size (gdbarch
, FP4_REGNUM
) - TYPE_LENGTH (type
);
184 regcache_cooked_read_part (regcache
, FP4_REGNUM
, offset
,
185 TYPE_LENGTH (type
), readbuf
);
186 if (writebuf
!= NULL
)
187 regcache_cooked_write_part (regcache
, FP4_REGNUM
, offset
,
188 TYPE_LENGTH (type
), writebuf
);
189 return RETURN_VALUE_REGISTER_CONVENTION
;
191 else if (TYPE_LENGTH (type
) <= 8 && is_integral_type (type
))
193 /* Integrals are right aligned. */
194 int offset
= register_size (gdbarch
, FP4_REGNUM
) - TYPE_LENGTH (type
);
196 regcache_cooked_read_part (regcache
, 28, offset
,
197 TYPE_LENGTH (type
), readbuf
);
198 if (writebuf
!= NULL
)
199 regcache_cooked_write_part (regcache
, 28, offset
,
200 TYPE_LENGTH (type
), writebuf
);
201 return RETURN_VALUE_REGISTER_CONVENTION
;
203 else if (TYPE_LENGTH (type
) <= 2 * 8)
205 /* Composite values are left aligned. */
207 for (b
= 0; b
< TYPE_LENGTH (type
); b
+= 8)
209 int part
= min (8, TYPE_LENGTH (type
) - b
);
211 regcache_cooked_read_part (regcache
, 28 + b
/ 8, 0, part
,
212 (char *) readbuf
+ b
);
213 if (writebuf
!= NULL
)
214 regcache_cooked_write_part (regcache
, 28 + b
/ 8, 0, part
,
215 (const char *) writebuf
+ b
);
217 return RETURN_VALUE_REGISTER_CONVENTION
;
220 return RETURN_VALUE_STRUCT_CONVENTION
;
223 /* Routines to extract various sized constants out of hppa
226 /* This assumes that no garbage lies outside of the lower bits of
230 hppa_sign_extend (unsigned val
, unsigned bits
)
232 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
235 /* For many immediate values the sign bit is the low bit! */
238 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
240 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
243 /* Extract the bits at positions between FROM and TO, using HP's numbering
247 hppa_get_field (unsigned word
, int from
, int to
)
249 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
252 /* extract the immediate field from a ld{bhw}s instruction */
255 hppa_extract_5_load (unsigned word
)
257 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
260 /* extract the immediate field from a break instruction */
263 hppa_extract_5r_store (unsigned word
)
265 return (word
& MASK_5
);
268 /* extract the immediate field from a {sr}sm instruction */
271 hppa_extract_5R_store (unsigned word
)
273 return (word
>> 16 & MASK_5
);
276 /* extract a 14 bit immediate field */
279 hppa_extract_14 (unsigned word
)
281 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
284 /* extract a 21 bit constant */
287 hppa_extract_21 (unsigned word
)
293 val
= hppa_get_field (word
, 20, 20);
295 val
|= hppa_get_field (word
, 9, 19);
297 val
|= hppa_get_field (word
, 5, 6);
299 val
|= hppa_get_field (word
, 0, 4);
301 val
|= hppa_get_field (word
, 7, 8);
302 return hppa_sign_extend (val
, 21) << 11;
305 /* extract a 17 bit constant from branch instructions, returning the
306 19 bit signed value. */
309 hppa_extract_17 (unsigned word
)
311 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
312 hppa_get_field (word
, 29, 29) << 10 |
313 hppa_get_field (word
, 11, 15) << 11 |
314 (word
& 0x1) << 16, 17) << 2;
318 /* Compare the start address for two unwind entries returning 1 if
319 the first address is larger than the second, -1 if the second is
320 larger than the first, and zero if they are equal. */
323 compare_unwind_entries (const void *arg1
, const void *arg2
)
325 const struct unwind_table_entry
*a
= arg1
;
326 const struct unwind_table_entry
*b
= arg2
;
328 if (a
->region_start
> b
->region_start
)
330 else if (a
->region_start
< b
->region_start
)
337 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
339 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
340 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
342 bfd_vma value
= section
->vma
- section
->filepos
;
343 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
345 if (value
< *low_text_segment_address
)
346 *low_text_segment_address
= value
;
351 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
352 asection
*section
, unsigned int entries
, unsigned int size
,
353 CORE_ADDR text_offset
)
355 /* We will read the unwind entries into temporary memory, then
356 fill in the actual unwind table. */
362 char *buf
= alloca (size
);
363 CORE_ADDR low_text_segment_address
;
365 /* For ELF targets, then unwinds are supposed to
366 be segment relative offsets instead of absolute addresses.
368 Note that when loading a shared library (text_offset != 0) the
369 unwinds are already relative to the text_offset that will be
371 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
373 low_text_segment_address
= -1;
375 bfd_map_over_sections (objfile
->obfd
,
376 record_text_segment_lowaddr
,
377 &low_text_segment_address
);
379 text_offset
= low_text_segment_address
;
382 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
384 /* Now internalize the information being careful to handle host/target
386 for (i
= 0; i
< entries
; i
++)
388 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
390 table
[i
].region_start
+= text_offset
;
392 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
393 table
[i
].region_end
+= text_offset
;
395 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
397 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
398 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
399 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
400 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
401 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
402 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
403 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
404 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
405 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
406 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
407 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
408 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
409 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
410 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
411 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
412 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
413 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
414 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
415 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
416 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
417 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
418 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
419 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
420 table
[i
].Cleanup_defined
= tmp
& 0x1;
421 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
423 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
424 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
425 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
426 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
427 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
428 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
430 /* Stub unwinds are handled elsewhere. */
431 table
[i
].stub_unwind
.stub_type
= 0;
432 table
[i
].stub_unwind
.padding
= 0;
437 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
438 the object file. This info is used mainly by find_unwind_entry() to find
439 out the stack frame size and frame pointer used by procedures. We put
440 everything on the psymbol obstack in the objfile so that it automatically
441 gets freed when the objfile is destroyed. */
444 read_unwind_info (struct objfile
*objfile
)
446 asection
*unwind_sec
, *stub_unwind_sec
;
447 unsigned unwind_size
, stub_unwind_size
, total_size
;
448 unsigned index
, unwind_entries
;
449 unsigned stub_entries
, total_entries
;
450 CORE_ADDR text_offset
;
451 struct hppa_unwind_info
*ui
;
452 struct hppa_objfile_private
*obj_private
;
454 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
455 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
456 sizeof (struct hppa_unwind_info
));
462 /* For reasons unknown the HP PA64 tools generate multiple unwinder
463 sections in a single executable. So we just iterate over every
464 section in the BFD looking for unwinder sections intead of trying
465 to do a lookup with bfd_get_section_by_name.
467 First determine the total size of the unwind tables so that we
468 can allocate memory in a nice big hunk. */
470 for (unwind_sec
= objfile
->obfd
->sections
;
472 unwind_sec
= unwind_sec
->next
)
474 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
475 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
477 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
478 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
480 total_entries
+= unwind_entries
;
484 /* Now compute the size of the stub unwinds. Note the ELF tools do not
485 use stub unwinds at the curren time. */
486 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
490 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
491 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
495 stub_unwind_size
= 0;
499 /* Compute total number of unwind entries and their total size. */
500 total_entries
+= stub_entries
;
501 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
503 /* Allocate memory for the unwind table. */
504 ui
->table
= (struct unwind_table_entry
*)
505 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
506 ui
->last
= total_entries
- 1;
508 /* Now read in each unwind section and internalize the standard unwind
511 for (unwind_sec
= objfile
->obfd
->sections
;
513 unwind_sec
= unwind_sec
->next
)
515 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
516 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
518 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
519 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
521 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
522 unwind_entries
, unwind_size
, text_offset
);
523 index
+= unwind_entries
;
527 /* Now read in and internalize the stub unwind entries. */
528 if (stub_unwind_size
> 0)
531 char *buf
= alloca (stub_unwind_size
);
533 /* Read in the stub unwind entries. */
534 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
535 0, stub_unwind_size
);
537 /* Now convert them into regular unwind entries. */
538 for (i
= 0; i
< stub_entries
; i
++, index
++)
540 /* Clear out the next unwind entry. */
541 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
543 /* Convert offset & size into region_start and region_end.
544 Stuff away the stub type into "reserved" fields. */
545 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
547 ui
->table
[index
].region_start
+= text_offset
;
549 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
552 ui
->table
[index
].region_end
553 = ui
->table
[index
].region_start
+ 4 *
554 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
560 /* Unwind table needs to be kept sorted. */
561 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
562 compare_unwind_entries
);
564 /* Keep a pointer to the unwind information. */
565 obj_private
= (struct hppa_objfile_private
*)
566 objfile_data (objfile
, hppa_objfile_priv_data
);
567 if (obj_private
== NULL
)
569 obj_private
= (struct hppa_objfile_private
*)
570 obstack_alloc (&objfile
->objfile_obstack
,
571 sizeof (struct hppa_objfile_private
));
572 set_objfile_data (objfile
, hppa_objfile_priv_data
, obj_private
);
573 obj_private
->unwind_info
= NULL
;
574 obj_private
->so_info
= NULL
;
577 obj_private
->unwind_info
= ui
;
580 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
581 of the objfiles seeking the unwind table entry for this PC. Each objfile
582 contains a sorted list of struct unwind_table_entry. Since we do a binary
583 search of the unwind tables, we depend upon them to be sorted. */
585 struct unwind_table_entry
*
586 find_unwind_entry (CORE_ADDR pc
)
588 int first
, middle
, last
;
589 struct objfile
*objfile
;
590 struct hppa_objfile_private
*priv
;
593 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
596 /* A function at address 0? Not in HP-UX! */
597 if (pc
== (CORE_ADDR
) 0)
600 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
604 ALL_OBJFILES (objfile
)
606 struct hppa_unwind_info
*ui
;
608 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
610 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
614 read_unwind_info (objfile
);
615 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
617 error ("Internal error reading unwind information.");
618 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
621 /* First, check the cache */
624 && pc
>= ui
->cache
->region_start
625 && pc
<= ui
->cache
->region_end
)
628 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
629 paddr_nz ((CORE_ADDR
) ui
->cache
));
633 /* Not in the cache, do a binary search */
638 while (first
<= last
)
640 middle
= (first
+ last
) / 2;
641 if (pc
>= ui
->table
[middle
].region_start
642 && pc
<= ui
->table
[middle
].region_end
)
644 ui
->cache
= &ui
->table
[middle
];
646 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
647 paddr_nz ((CORE_ADDR
) ui
->cache
));
648 return &ui
->table
[middle
];
651 if (pc
< ui
->table
[middle
].region_start
)
656 } /* ALL_OBJFILES() */
659 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
664 static const unsigned char *
665 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
667 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
668 (*len
) = sizeof (breakpoint
);
672 /* Return the name of a register. */
675 hppa32_register_name (int i
)
677 static char *names
[] = {
678 "flags", "r1", "rp", "r3",
679 "r4", "r5", "r6", "r7",
680 "r8", "r9", "r10", "r11",
681 "r12", "r13", "r14", "r15",
682 "r16", "r17", "r18", "r19",
683 "r20", "r21", "r22", "r23",
684 "r24", "r25", "r26", "dp",
685 "ret0", "ret1", "sp", "r31",
686 "sar", "pcoqh", "pcsqh", "pcoqt",
687 "pcsqt", "eiem", "iir", "isr",
688 "ior", "ipsw", "goto", "sr4",
689 "sr0", "sr1", "sr2", "sr3",
690 "sr5", "sr6", "sr7", "cr0",
691 "cr8", "cr9", "ccr", "cr12",
692 "cr13", "cr24", "cr25", "cr26",
693 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
694 "fpsr", "fpe1", "fpe2", "fpe3",
695 "fpe4", "fpe5", "fpe6", "fpe7",
696 "fr4", "fr4R", "fr5", "fr5R",
697 "fr6", "fr6R", "fr7", "fr7R",
698 "fr8", "fr8R", "fr9", "fr9R",
699 "fr10", "fr10R", "fr11", "fr11R",
700 "fr12", "fr12R", "fr13", "fr13R",
701 "fr14", "fr14R", "fr15", "fr15R",
702 "fr16", "fr16R", "fr17", "fr17R",
703 "fr18", "fr18R", "fr19", "fr19R",
704 "fr20", "fr20R", "fr21", "fr21R",
705 "fr22", "fr22R", "fr23", "fr23R",
706 "fr24", "fr24R", "fr25", "fr25R",
707 "fr26", "fr26R", "fr27", "fr27R",
708 "fr28", "fr28R", "fr29", "fr29R",
709 "fr30", "fr30R", "fr31", "fr31R"
711 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
718 hppa64_register_name (int i
)
720 static char *names
[] = {
721 "flags", "r1", "rp", "r3",
722 "r4", "r5", "r6", "r7",
723 "r8", "r9", "r10", "r11",
724 "r12", "r13", "r14", "r15",
725 "r16", "r17", "r18", "r19",
726 "r20", "r21", "r22", "r23",
727 "r24", "r25", "r26", "dp",
728 "ret0", "ret1", "sp", "r31",
729 "sar", "pcoqh", "pcsqh", "pcoqt",
730 "pcsqt", "eiem", "iir", "isr",
731 "ior", "ipsw", "goto", "sr4",
732 "sr0", "sr1", "sr2", "sr3",
733 "sr5", "sr6", "sr7", "cr0",
734 "cr8", "cr9", "ccr", "cr12",
735 "cr13", "cr24", "cr25", "cr26",
736 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
737 "fpsr", "fpe1", "fpe2", "fpe3",
738 "fr4", "fr5", "fr6", "fr7",
739 "fr8", "fr9", "fr10", "fr11",
740 "fr12", "fr13", "fr14", "fr15",
741 "fr16", "fr17", "fr18", "fr19",
742 "fr20", "fr21", "fr22", "fr23",
743 "fr24", "fr25", "fr26", "fr27",
744 "fr28", "fr29", "fr30", "fr31"
746 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
752 /* This function pushes a stack frame with arguments as part of the
753 inferior function calling mechanism.
755 This is the version of the function for the 32-bit PA machines, in
756 which later arguments appear at lower addresses. (The stack always
757 grows towards higher addresses.)
759 We simply allocate the appropriate amount of stack space and put
760 arguments into their proper slots. */
763 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
764 struct regcache
*regcache
, CORE_ADDR bp_addr
,
765 int nargs
, struct value
**args
, CORE_ADDR sp
,
766 int struct_return
, CORE_ADDR struct_addr
)
768 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
769 reverse engineering testsuite failures. */
771 /* Stack base address at which any pass-by-reference parameters are
773 CORE_ADDR struct_end
= 0;
774 /* Stack base address at which the first parameter is stored. */
775 CORE_ADDR param_end
= 0;
777 /* The inner most end of the stack after all the parameters have
779 CORE_ADDR new_sp
= 0;
781 /* Two passes. First pass computes the location of everything,
782 second pass writes the bytes out. */
784 for (write_pass
= 0; write_pass
< 2; write_pass
++)
786 CORE_ADDR struct_ptr
= 0;
787 CORE_ADDR param_ptr
= 0;
788 int reg
= 27; /* NOTE: Registers go down. */
790 for (i
= 0; i
< nargs
; i
++)
792 struct value
*arg
= args
[i
];
793 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
794 /* The corresponding parameter that is pushed onto the
795 stack, and [possibly] passed in a register. */
798 memset (param_val
, 0, sizeof param_val
);
799 if (TYPE_LENGTH (type
) > 8)
801 /* Large parameter, pass by reference. Store the value
802 in "struct" area and then pass its address. */
804 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
806 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
808 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
810 else if (TYPE_CODE (type
) == TYPE_CODE_INT
811 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
813 /* Integer value store, right aligned. "unpack_long"
814 takes care of any sign-extension problems. */
815 param_len
= align_up (TYPE_LENGTH (type
), 4);
816 store_unsigned_integer (param_val
, param_len
,
818 VALUE_CONTENTS (arg
)));
822 /* Small struct value, store right aligned? */
823 param_len
= align_up (TYPE_LENGTH (type
), 4);
824 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
825 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
827 param_ptr
+= param_len
;
828 reg
-= param_len
/ 4;
831 write_memory (param_end
- param_ptr
, param_val
, param_len
);
834 regcache_cooked_write (regcache
, reg
, param_val
);
836 regcache_cooked_write (regcache
, reg
+ 1, param_val
+ 4);
841 /* Update the various stack pointers. */
844 struct_end
= sp
+ struct_ptr
;
845 /* PARAM_PTR already accounts for all the arguments passed
846 by the user. However, the ABI mandates minimum stack
847 space allocations for outgoing arguments. The ABI also
848 mandates minimum stack alignments which we must
850 param_end
= struct_end
+ max (align_up (param_ptr
, 8), 16);
854 /* If a structure has to be returned, set up register 28 to hold its
857 write_register (28, struct_addr
);
859 /* Set the return address. */
860 regcache_cooked_write_unsigned (regcache
, RP_REGNUM
, bp_addr
);
862 /* Update the Stack Pointer. */
863 regcache_cooked_write_unsigned (regcache
, SP_REGNUM
, param_end
+ 32);
865 /* The stack will have 32 bytes of additional space for a frame marker. */
866 return param_end
+ 32;
869 /* This function pushes a stack frame with arguments as part of the
870 inferior function calling mechanism.
872 This is the version for the PA64, in which later arguments appear
873 at higher addresses. (The stack always grows towards higher
876 We simply allocate the appropriate amount of stack space and put
877 arguments into their proper slots.
879 This ABI also requires that the caller provide an argument pointer
880 to the callee, so we do that too. */
883 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
884 struct regcache
*regcache
, CORE_ADDR bp_addr
,
885 int nargs
, struct value
**args
, CORE_ADDR sp
,
886 int struct_return
, CORE_ADDR struct_addr
)
888 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
889 reverse engineering testsuite failures. */
891 /* Stack base address at which any pass-by-reference parameters are
893 CORE_ADDR struct_end
= 0;
894 /* Stack base address at which the first parameter is stored. */
895 CORE_ADDR param_end
= 0;
897 /* The inner most end of the stack after all the parameters have
899 CORE_ADDR new_sp
= 0;
901 /* Two passes. First pass computes the location of everything,
902 second pass writes the bytes out. */
904 for (write_pass
= 0; write_pass
< 2; write_pass
++)
906 CORE_ADDR struct_ptr
= 0;
907 CORE_ADDR param_ptr
= 0;
909 for (i
= 0; i
< nargs
; i
++)
911 struct value
*arg
= args
[i
];
912 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
913 if ((TYPE_CODE (type
) == TYPE_CODE_INT
914 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
915 && TYPE_LENGTH (type
) <= 8)
917 /* Integer value store, right aligned. "unpack_long"
918 takes care of any sign-extension problems. */
922 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
923 int reg
= 27 - param_ptr
/ 8;
924 write_memory_unsigned_integer (param_end
- param_ptr
,
927 regcache_cooked_write_unsigned (regcache
, reg
, val
);
932 /* Small struct value, store left aligned? */
934 if (TYPE_LENGTH (type
) > 8)
936 param_ptr
= align_up (param_ptr
, 16);
937 reg
= 26 - param_ptr
/ 8;
938 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
942 param_ptr
= align_up (param_ptr
, 8);
943 reg
= 26 - param_ptr
/ 8;
944 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
949 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
951 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
955 int len
= min (8, TYPE_LENGTH (type
) - byte
);
956 regcache_cooked_write_part (regcache
, reg
, 0, len
,
957 VALUE_CONTENTS (arg
) + byte
);
964 /* Update the various stack pointers. */
967 struct_end
= sp
+ struct_ptr
;
968 /* PARAM_PTR already accounts for all the arguments passed
969 by the user. However, the ABI mandates minimum stack
970 space allocations for outgoing arguments. The ABI also
971 mandates minimum stack alignments which we must
973 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
977 /* If a structure has to be returned, set up register 28 to hold its
980 write_register (28, struct_addr
);
982 /* Set the return address. */
983 regcache_cooked_write_unsigned (regcache
, RP_REGNUM
, bp_addr
);
985 /* Update the Stack Pointer. */
986 regcache_cooked_write_unsigned (regcache
, SP_REGNUM
, param_end
+ 64);
988 /* The stack will have 32 bytes of additional space for a frame marker. */
989 return param_end
+ 64;
993 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
995 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
997 return align_up (addr
, 64);
1000 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1003 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1005 /* Just always 16-byte align. */
1006 return align_up (addr
, 16);
1010 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1014 hppa_target_read_pc (ptid_t ptid
)
1016 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
1018 /* The following test does not belong here. It is OS-specific, and belongs
1020 /* Test SS_INSYSCALL */
1022 return read_register_pid (31, ptid
) & ~0x3;
1024 return read_register_pid (PCOQ_HEAD_REGNUM
, ptid
) & ~0x3;
1027 /* Write out the PC. If currently in a syscall, then also write the new
1028 PC value into %r31. */
1031 hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
1033 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
1035 /* The following test does not belong here. It is OS-specific, and belongs
1037 /* If in a syscall, then set %r31. Also make sure to get the
1038 privilege bits set correctly. */
1039 /* Test SS_INSYSCALL */
1041 write_register_pid (31, v
| 0x3, ptid
);
1043 write_register_pid (PCOQ_HEAD_REGNUM
, v
, ptid
);
1044 write_register_pid (PCOQ_TAIL_REGNUM
, v
+ 4, ptid
);
1047 /* return the alignment of a type in bytes. Structures have the maximum
1048 alignment required by their fields. */
1051 hppa_alignof (struct type
*type
)
1053 int max_align
, align
, i
;
1054 CHECK_TYPEDEF (type
);
1055 switch (TYPE_CODE (type
))
1060 return TYPE_LENGTH (type
);
1061 case TYPE_CODE_ARRAY
:
1062 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1063 case TYPE_CODE_STRUCT
:
1064 case TYPE_CODE_UNION
:
1066 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1068 /* Bit fields have no real alignment. */
1069 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1070 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1072 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1073 max_align
= max (max_align
, align
);
1082 /* For the given instruction (INST), return any adjustment it makes
1083 to the stack pointer or zero for no adjustment.
1085 This only handles instructions commonly found in prologues. */
1088 prologue_inst_adjust_sp (unsigned long inst
)
1090 /* This must persist across calls. */
1091 static int save_high21
;
1093 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1094 if ((inst
& 0xffffc000) == 0x37de0000)
1095 return hppa_extract_14 (inst
);
1098 if ((inst
& 0xffe00000) == 0x6fc00000)
1099 return hppa_extract_14 (inst
);
1101 /* std,ma X,D(sp) */
1102 if ((inst
& 0xffe00008) == 0x73c00008)
1103 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1105 /* addil high21,%r1; ldo low11,(%r1),%r30)
1106 save high bits in save_high21 for later use. */
1107 if ((inst
& 0xffe00000) == 0x28200000)
1109 save_high21
= hppa_extract_21 (inst
);
1113 if ((inst
& 0xffff0000) == 0x343e0000)
1114 return save_high21
+ hppa_extract_14 (inst
);
1116 /* fstws as used by the HP compilers. */
1117 if ((inst
& 0xffffffe0) == 0x2fd01220)
1118 return hppa_extract_5_load (inst
);
1120 /* No adjustment. */
1124 /* Return nonzero if INST is a branch of some kind, else return zero. */
1127 is_branch (unsigned long inst
)
1156 /* Return the register number for a GR which is saved by INST or
1157 zero it INST does not save a GR. */
1160 inst_saves_gr (unsigned long inst
)
1162 /* Does it look like a stw? */
1163 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1164 || (inst
>> 26) == 0x1f
1165 || ((inst
>> 26) == 0x1f
1166 && ((inst
>> 6) == 0xa)))
1167 return hppa_extract_5R_store (inst
);
1169 /* Does it look like a std? */
1170 if ((inst
>> 26) == 0x1c
1171 || ((inst
>> 26) == 0x03
1172 && ((inst
>> 6) & 0xf) == 0xb))
1173 return hppa_extract_5R_store (inst
);
1175 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1176 if ((inst
>> 26) == 0x1b)
1177 return hppa_extract_5R_store (inst
);
1179 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1181 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1182 || ((inst
>> 26) == 0x3
1183 && (((inst
>> 6) & 0xf) == 0x8
1184 || (inst
>> 6) & 0xf) == 0x9))
1185 return hppa_extract_5R_store (inst
);
1190 /* Return the register number for a FR which is saved by INST or
1191 zero it INST does not save a FR.
1193 Note we only care about full 64bit register stores (that's the only
1194 kind of stores the prologue will use).
1196 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1199 inst_saves_fr (unsigned long inst
)
1201 /* is this an FSTD ? */
1202 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1203 return hppa_extract_5r_store (inst
);
1204 if ((inst
& 0xfc000002) == 0x70000002)
1205 return hppa_extract_5R_store (inst
);
1206 /* is this an FSTW ? */
1207 if ((inst
& 0xfc00df80) == 0x24001200)
1208 return hppa_extract_5r_store (inst
);
1209 if ((inst
& 0xfc000002) == 0x7c000000)
1210 return hppa_extract_5R_store (inst
);
1214 /* Advance PC across any function entry prologue instructions
1215 to reach some "real" code.
1217 Use information in the unwind table to determine what exactly should
1218 be in the prologue. */
1222 skip_prologue_hard_way (CORE_ADDR pc
)
1225 CORE_ADDR orig_pc
= pc
;
1226 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1227 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1228 struct unwind_table_entry
*u
;
1234 u
= find_unwind_entry (pc
);
1238 /* If we are not at the beginning of a function, then return now. */
1239 if ((pc
& ~0x3) != u
->region_start
)
1242 /* This is how much of a frame adjustment we need to account for. */
1243 stack_remaining
= u
->Total_frame_size
<< 3;
1245 /* Magic register saves we want to know about. */
1246 save_rp
= u
->Save_RP
;
1247 save_sp
= u
->Save_SP
;
1249 /* An indication that args may be stored into the stack. Unfortunately
1250 the HPUX compilers tend to set this in cases where no args were
1254 /* Turn the Entry_GR field into a bitmask. */
1256 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1258 /* Frame pointer gets saved into a special location. */
1259 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1262 save_gr
|= (1 << i
);
1264 save_gr
&= ~restart_gr
;
1266 /* Turn the Entry_FR field into a bitmask too. */
1268 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1269 save_fr
|= (1 << i
);
1270 save_fr
&= ~restart_fr
;
1272 /* Loop until we find everything of interest or hit a branch.
1274 For unoptimized GCC code and for any HP CC code this will never ever
1275 examine any user instructions.
1277 For optimzied GCC code we're faced with problems. GCC will schedule
1278 its prologue and make prologue instructions available for delay slot
1279 filling. The end result is user code gets mixed in with the prologue
1280 and a prologue instruction may be in the delay slot of the first branch
1283 Some unexpected things are expected with debugging optimized code, so
1284 we allow this routine to walk past user instructions in optimized
1286 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1289 unsigned int reg_num
;
1290 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1291 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1293 /* Save copies of all the triggers so we can compare them later
1295 old_save_gr
= save_gr
;
1296 old_save_fr
= save_fr
;
1297 old_save_rp
= save_rp
;
1298 old_save_sp
= save_sp
;
1299 old_stack_remaining
= stack_remaining
;
1301 status
= target_read_memory (pc
, buf
, 4);
1302 inst
= extract_unsigned_integer (buf
, 4);
1308 /* Note the interesting effects of this instruction. */
1309 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1311 /* There are limited ways to store the return pointer into the
1313 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1316 /* These are the only ways we save SP into the stack. At this time
1317 the HP compilers never bother to save SP into the stack. */
1318 if ((inst
& 0xffffc000) == 0x6fc10000
1319 || (inst
& 0xffffc00c) == 0x73c10008)
1322 /* Are we loading some register with an offset from the argument
1324 if ((inst
& 0xffe00000) == 0x37a00000
1325 || (inst
& 0xffffffe0) == 0x081d0240)
1331 /* Account for general and floating-point register saves. */
1332 reg_num
= inst_saves_gr (inst
);
1333 save_gr
&= ~(1 << reg_num
);
1335 /* Ugh. Also account for argument stores into the stack.
1336 Unfortunately args_stored only tells us that some arguments
1337 where stored into the stack. Not how many or what kind!
1339 This is a kludge as on the HP compiler sets this bit and it
1340 never does prologue scheduling. So once we see one, skip past
1341 all of them. We have similar code for the fp arg stores below.
1343 FIXME. Can still die if we have a mix of GR and FR argument
1345 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1347 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1350 status
= target_read_memory (pc
, buf
, 4);
1351 inst
= extract_unsigned_integer (buf
, 4);
1354 reg_num
= inst_saves_gr (inst
);
1360 reg_num
= inst_saves_fr (inst
);
1361 save_fr
&= ~(1 << reg_num
);
1363 status
= target_read_memory (pc
+ 4, buf
, 4);
1364 next_inst
= extract_unsigned_integer (buf
, 4);
1370 /* We've got to be read to handle the ldo before the fp register
1372 if ((inst
& 0xfc000000) == 0x34000000
1373 && inst_saves_fr (next_inst
) >= 4
1374 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1376 /* So we drop into the code below in a reasonable state. */
1377 reg_num
= inst_saves_fr (next_inst
);
1381 /* Ugh. Also account for argument stores into the stack.
1382 This is a kludge as on the HP compiler sets this bit and it
1383 never does prologue scheduling. So once we see one, skip past
1385 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1387 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1390 status
= target_read_memory (pc
, buf
, 4);
1391 inst
= extract_unsigned_integer (buf
, 4);
1394 if ((inst
& 0xfc000000) != 0x34000000)
1396 status
= target_read_memory (pc
+ 4, buf
, 4);
1397 next_inst
= extract_unsigned_integer (buf
, 4);
1400 reg_num
= inst_saves_fr (next_inst
);
1406 /* Quit if we hit any kind of branch. This can happen if a prologue
1407 instruction is in the delay slot of the first call/branch. */
1408 if (is_branch (inst
))
1411 /* What a crock. The HP compilers set args_stored even if no
1412 arguments were stored into the stack (boo hiss). This could
1413 cause this code to then skip a bunch of user insns (up to the
1416 To combat this we try to identify when args_stored was bogusly
1417 set and clear it. We only do this when args_stored is nonzero,
1418 all other resources are accounted for, and nothing changed on
1421 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1422 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1423 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1424 && old_stack_remaining
== stack_remaining
)
1431 /* We've got a tenative location for the end of the prologue. However
1432 because of limitations in the unwind descriptor mechanism we may
1433 have went too far into user code looking for the save of a register
1434 that does not exist. So, if there registers we expected to be saved
1435 but never were, mask them out and restart.
1437 This should only happen in optimized code, and should be very rare. */
1438 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1441 restart_gr
= save_gr
;
1442 restart_fr
= save_fr
;
1450 /* Return the address of the PC after the last prologue instruction if
1451 we can determine it from the debug symbols. Else return zero. */
1454 after_prologue (CORE_ADDR pc
)
1456 struct symtab_and_line sal
;
1457 CORE_ADDR func_addr
, func_end
;
1460 /* If we can not find the symbol in the partial symbol table, then
1461 there is no hope we can determine the function's start address
1463 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1466 /* Get the line associated with FUNC_ADDR. */
1467 sal
= find_pc_line (func_addr
, 0);
1469 /* There are only two cases to consider. First, the end of the source line
1470 is within the function bounds. In that case we return the end of the
1471 source line. Second is the end of the source line extends beyond the
1472 bounds of the current function. We need to use the slow code to
1473 examine instructions in that case.
1475 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1476 the wrong thing to do. In fact, it should be entirely possible for this
1477 function to always return zero since the slow instruction scanning code
1478 is supposed to *always* work. If it does not, then it is a bug. */
1479 if (sal
.end
< func_end
)
1485 /* To skip prologues, I use this predicate. Returns either PC itself
1486 if the code at PC does not look like a function prologue; otherwise
1487 returns an address that (if we're lucky) follows the prologue. If
1488 LENIENT, then we must skip everything which is involved in setting
1489 up the frame (it's OK to skip more, just so long as we don't skip
1490 anything which might clobber the registers which are being saved.
1491 Currently we must not skip more on the alpha, but we might the lenient
1495 hppa_skip_prologue (CORE_ADDR pc
)
1499 CORE_ADDR post_prologue_pc
;
1502 /* See if we can determine the end of the prologue via the symbol table.
1503 If so, then return either PC, or the PC after the prologue, whichever
1506 post_prologue_pc
= after_prologue (pc
);
1508 /* If after_prologue returned a useful address, then use it. Else
1509 fall back on the instruction skipping code.
1511 Some folks have claimed this causes problems because the breakpoint
1512 may be the first instruction of the prologue. If that happens, then
1513 the instruction skipping code has a bug that needs to be fixed. */
1514 if (post_prologue_pc
!= 0)
1515 return max (pc
, post_prologue_pc
);
1517 return (skip_prologue_hard_way (pc
));
1520 struct hppa_frame_cache
1523 struct trad_frame_saved_reg
*saved_regs
;
1526 static struct hppa_frame_cache
*
1527 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1529 struct hppa_frame_cache
*cache
;
1534 struct unwind_table_entry
*u
;
1538 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1539 frame_relative_level(next_frame
));
1541 if ((*this_cache
) != NULL
)
1544 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1545 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1546 return (*this_cache
);
1548 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1549 (*this_cache
) = cache
;
1550 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1553 u
= find_unwind_entry (frame_func_unwind (next_frame
));
1557 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1558 return (*this_cache
);
1561 /* Turn the Entry_GR field into a bitmask. */
1563 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1565 /* Frame pointer gets saved into a special location. */
1566 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1569 saved_gr_mask
|= (1 << i
);
1572 /* Turn the Entry_FR field into a bitmask too. */
1574 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1575 saved_fr_mask
|= (1 << i
);
1577 /* Loop until we find everything of interest or hit a branch.
1579 For unoptimized GCC code and for any HP CC code this will never ever
1580 examine any user instructions.
1582 For optimized GCC code we're faced with problems. GCC will schedule
1583 its prologue and make prologue instructions available for delay slot
1584 filling. The end result is user code gets mixed in with the prologue
1585 and a prologue instruction may be in the delay slot of the first branch
1588 Some unexpected things are expected with debugging optimized code, so
1589 we allow this routine to walk past user instructions in optimized
1592 int final_iteration
= 0;
1595 int looking_for_sp
= u
->Save_SP
;
1596 int looking_for_rp
= u
->Save_RP
;
1598 end_pc
= skip_prologue_using_sal (frame_func_unwind (next_frame
));
1600 end_pc
= frame_pc_unwind (next_frame
);
1602 for (pc
= frame_func_unwind (next_frame
);
1603 ((saved_gr_mask
|| saved_fr_mask
1604 || looking_for_sp
|| looking_for_rp
1605 || frame_size
< (u
->Total_frame_size
<< 3))
1611 long status
= target_read_memory (pc
, buf4
, sizeof buf4
);
1612 long inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1614 /* Note the interesting effects of this instruction. */
1615 frame_size
+= prologue_inst_adjust_sp (inst
);
1617 /* There are limited ways to store the return pointer into the
1619 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1622 cache
->saved_regs
[RP_REGNUM
].addr
= -20;
1624 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1627 cache
->saved_regs
[RP_REGNUM
].addr
= -16;
1630 /* Check to see if we saved SP into the stack. This also
1631 happens to indicate the location of the saved frame
1633 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1634 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1637 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1640 /* Account for general and floating-point register saves. */
1641 reg
= inst_saves_gr (inst
);
1642 if (reg
>= 3 && reg
<= 18
1643 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1645 saved_gr_mask
&= ~(1 << reg
);
1646 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1647 /* stwm with a positive displacement is a _post_
1649 cache
->saved_regs
[reg
].addr
= 0;
1650 else if ((inst
& 0xfc00000c) == 0x70000008)
1651 /* A std has explicit post_modify forms. */
1652 cache
->saved_regs
[reg
].addr
= 0;
1657 if ((inst
>> 26) == 0x1c)
1658 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1659 else if ((inst
>> 26) == 0x03)
1660 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1662 offset
= hppa_extract_14 (inst
);
1664 /* Handle code with and without frame pointers. */
1666 cache
->saved_regs
[reg
].addr
= offset
;
1668 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1672 /* GCC handles callee saved FP regs a little differently.
1674 It emits an instruction to put the value of the start of
1675 the FP store area into %r1. It then uses fstds,ma with a
1676 basereg of %r1 for the stores.
1678 HP CC emits them at the current stack pointer modifying the
1679 stack pointer as it stores each register. */
1681 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1682 if ((inst
& 0xffffc000) == 0x34610000
1683 || (inst
& 0xffffc000) == 0x37c10000)
1684 fp_loc
= hppa_extract_14 (inst
);
1686 reg
= inst_saves_fr (inst
);
1687 if (reg
>= 12 && reg
<= 21)
1689 /* Note +4 braindamage below is necessary because the FP
1690 status registers are internally 8 registers rather than
1691 the expected 4 registers. */
1692 saved_fr_mask
&= ~(1 << reg
);
1695 /* 1st HP CC FP register store. After this
1696 instruction we've set enough state that the GCC and
1697 HPCC code are both handled in the same manner. */
1698 cache
->saved_regs
[reg
+ FP4_REGNUM
+ 4].addr
= 0;
1703 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1708 /* Quit if we hit any kind of branch the previous iteration. */
1709 if (final_iteration
)
1711 /* We want to look precisely one instruction beyond the branch
1712 if we have not found everything yet. */
1713 if (is_branch (inst
))
1714 final_iteration
= 1;
1719 /* The frame base always represents the value of %sp at entry to
1720 the current function (and is thus equivalent to the "saved"
1722 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1723 /* FIXME: cagney/2004-02-22: This assumes that the frame has been
1724 created. If it hasn't everything will be out-of-wack. */
1725 if (u
->Save_SP
&& trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1726 /* Both we're expecting the SP to be saved and the SP has been
1727 saved. The entry SP value is saved at this frame's SP
1729 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1731 /* The prologue has been slowly allocating stack space. Adjust
1733 cache
->base
= this_sp
- frame_size
;
1734 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1737 /* The PC is found in the "return register", "Millicode" uses "r31"
1738 as the return register while normal code uses "rp". */
1740 cache
->saved_regs
[PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1742 cache
->saved_regs
[PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[RP_REGNUM
];
1745 /* Convert all the offsets into addresses. */
1747 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1749 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1750 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1755 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1756 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1757 return (*this_cache
);
1761 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1762 struct frame_id
*this_id
)
1764 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1765 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
1769 hppa_frame_prev_register (struct frame_info
*next_frame
,
1771 int regnum
, int *optimizedp
,
1772 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1773 int *realnump
, void *valuep
)
1775 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1776 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1777 if (regnum
== PCOQ_TAIL_REGNUM
)
1779 /* The PCOQ TAIL, or NPC, needs to be computed from the unwound
1787 int regsize
= register_size (gdbarch
, PCOQ_HEAD_REGNUM
);
1790 enum lval_type lval
;
1793 bfd_byte value
[MAX_REGISTER_SIZE
];
1794 trad_frame_prev_register (next_frame
, info
->saved_regs
,
1795 PCOQ_HEAD_REGNUM
, &optimized
, &lval
, &addr
,
1797 pc
= extract_unsigned_integer (&value
, regsize
);
1798 store_unsigned_integer (valuep
, regsize
, pc
+ 4);
1803 trad_frame_prev_register (next_frame
, info
->saved_regs
, regnum
,
1804 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1808 static const struct frame_unwind hppa_frame_unwind
=
1812 hppa_frame_prev_register
1815 static const struct frame_unwind
*
1816 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
1818 return &hppa_frame_unwind
;
1822 hppa_frame_base_address (struct frame_info
*next_frame
,
1825 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
,
1830 static const struct frame_base hppa_frame_base
= {
1832 hppa_frame_base_address
,
1833 hppa_frame_base_address
,
1834 hppa_frame_base_address
1837 static const struct frame_base
*
1838 hppa_frame_base_sniffer (struct frame_info
*next_frame
)
1840 return &hppa_frame_base
;
1843 static struct frame_id
1844 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1846 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
1848 frame_pc_unwind (next_frame
));
1852 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1854 return frame_unwind_register_signed (next_frame
, PCOQ_HEAD_REGNUM
) & ~3;
1857 /* Instead of this nasty cast, add a method pvoid() that prints out a
1858 host VOID data type (remember %p isn't portable). */
1861 hppa_pointer_to_address_hack (void *ptr
)
1863 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
1864 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
1868 unwind_command (char *exp
, int from_tty
)
1871 struct unwind_table_entry
*u
;
1873 /* If we have an expression, evaluate it and use it as the address. */
1875 if (exp
!= 0 && *exp
!= 0)
1876 address
= parse_and_eval_address (exp
);
1880 u
= find_unwind_entry (address
);
1884 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
1888 printf_unfiltered ("unwind_table_entry (0x%s):\n",
1889 paddr_nz (hppa_pointer_to_address_hack (u
)));
1891 printf_unfiltered ("\tregion_start = ");
1892 print_address (u
->region_start
, gdb_stdout
);
1894 printf_unfiltered ("\n\tregion_end = ");
1895 print_address (u
->region_end
, gdb_stdout
);
1897 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
1899 printf_unfiltered ("\n\tflags =");
1900 pif (Cannot_unwind
);
1902 pif (Millicode_save_sr0
);
1905 pif (Variable_Frame
);
1906 pif (Separate_Package_Body
);
1907 pif (Frame_Extension_Millicode
);
1908 pif (Stack_Overflow_Check
);
1909 pif (Two_Instruction_SP_Increment
);
1913 pif (Save_MRP_in_frame
);
1914 pif (extn_ptr_defined
);
1915 pif (Cleanup_defined
);
1916 pif (MPE_XL_interrupt_marker
);
1917 pif (HP_UX_interrupt_marker
);
1920 putchar_unfiltered ('\n');
1922 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
1924 pin (Region_description
);
1927 pin (Total_frame_size
);
1931 hppa_skip_permanent_breakpoint (void)
1933 /* To step over a breakpoint instruction on the PA takes some
1934 fiddling with the instruction address queue.
1936 When we stop at a breakpoint, the IA queue front (the instruction
1937 we're executing now) points at the breakpoint instruction, and
1938 the IA queue back (the next instruction to execute) points to
1939 whatever instruction we would execute after the breakpoint, if it
1940 were an ordinary instruction. This is the case even if the
1941 breakpoint is in the delay slot of a branch instruction.
1943 Clearly, to step past the breakpoint, we need to set the queue
1944 front to the back. But what do we put in the back? What
1945 instruction comes after that one? Because of the branch delay
1946 slot, the next insn is always at the back + 4. */
1947 write_register (PCOQ_HEAD_REGNUM
, read_register (PCOQ_TAIL_REGNUM
));
1948 write_register (PCSQ_HEAD_REGNUM
, read_register (PCSQ_TAIL_REGNUM
));
1950 write_register (PCOQ_TAIL_REGNUM
, read_register (PCOQ_TAIL_REGNUM
) + 4);
1951 /* We can leave the tail's space the same, since there's no jump. */
1955 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
1957 /* Sometimes we may pluck out a minimal symbol that has a negative address.
1959 An example of this occurs when an a.out is linked against a foo.sl.
1960 The foo.sl defines a global bar(), and the a.out declares a signature
1961 for bar(). However, the a.out doesn't directly call bar(), but passes
1962 its address in another call.
1964 If you have this scenario and attempt to "break bar" before running,
1965 gdb will find a minimal symbol for bar() in the a.out. But that
1966 symbol's address will be negative. What this appears to denote is
1967 an index backwards from the base of the procedure linkage table (PLT)
1968 into the data linkage table (DLT), the end of which is contiguous
1969 with the start of the PLT. This is clearly not a valid address for
1970 us to set a breakpoint on.
1972 Note that one must be careful in how one checks for a negative address.
1973 0xc0000000 is a legitimate address of something in a shared text
1974 segment, for example. Since I don't know what the possible range
1975 is of these "really, truly negative" addresses that come from the
1976 minimal symbols, I'm resorting to the gross hack of checking the
1977 top byte of the address for all 1's. Sigh. */
1979 return (!target_has_stack
&& (pc
& 0xFF000000));
1983 hppa_instruction_nullified (void)
1985 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
1986 avoid the type cast. I'm leaving it as is for now as I'm doing
1987 semi-mechanical multiarching-related changes. */
1988 const int ipsw
= (int) read_register (IPSW_REGNUM
);
1989 const int flags
= (int) read_register (FLAGS_REGNUM
);
1991 return ((ipsw
& 0x00200000) && !(flags
& 0x2));
1994 /* Return the GDB type object for the "standard" data type of data
1997 static struct type
*
1998 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2000 if (reg_nr
< FP4_REGNUM
)
2001 return builtin_type_uint32
;
2003 return builtin_type_ieee_single_big
;
2006 /* Return the GDB type object for the "standard" data type of data
2007 in register N. hppa64 version. */
2009 static struct type
*
2010 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2012 if (reg_nr
< FP4_REGNUM
)
2013 return builtin_type_uint64
;
2015 return builtin_type_ieee_double_big
;
2018 /* Return True if REGNUM is not a register available to the user
2019 through ptrace(). */
2022 hppa_cannot_store_register (int regnum
)
2025 || regnum
== PCSQ_HEAD_REGNUM
2026 || (regnum
>= PCSQ_TAIL_REGNUM
&& regnum
< IPSW_REGNUM
)
2027 || (regnum
> IPSW_REGNUM
&& regnum
< FP4_REGNUM
));
2032 hppa_smash_text_address (CORE_ADDR addr
)
2034 /* The low two bits of the PC on the PA contain the privilege level.
2035 Some genius implementing a (non-GCC) compiler apparently decided
2036 this means that "addresses" in a text section therefore include a
2037 privilege level, and thus symbol tables should contain these bits.
2038 This seems like a bonehead thing to do--anyway, it seems to work
2039 for our purposes to just ignore those bits. */
2041 return (addr
&= ~0x3);
2044 /* Get the ith function argument for the current function. */
2046 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2050 get_frame_register (frame
, R0_REGNUM
+ 26 - argi
, &addr
);
2055 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2056 int regnum
, void *buf
)
2060 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2061 if (regnum
== PCOQ_HEAD_REGNUM
|| regnum
== PCOQ_TAIL_REGNUM
)
2063 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2066 /* Here is a table of C type sizes on hppa with various compiles
2067 and options. I measured this on PA 9000/800 with HP-UX 11.11
2068 and these compilers:
2070 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2071 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2072 /opt/aCC/bin/aCC B3910B A.03.45
2073 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2075 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2076 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2077 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2078 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2079 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2080 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2081 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2082 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2086 compiler and options
2087 char, short, int, long, long long
2088 float, double, long double
2091 So all these compilers use either ILP32 or LP64 model.
2092 TODO: gcc has more options so it needs more investigation.
2094 For floating point types, see:
2096 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2097 HP-UX floating-point guide, hpux 11.00
2099 -- chastain 2003-12-18 */
2101 static struct gdbarch
*
2102 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2104 struct gdbarch_tdep
*tdep
;
2105 struct gdbarch
*gdbarch
;
2107 /* Try to determine the ABI of the object we are loading. */
2108 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2110 /* If it's a SOM file, assume it's HP/UX SOM. */
2111 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2112 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2115 /* find a candidate among the list of pre-declared architectures. */
2116 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2118 return (arches
->gdbarch
);
2120 /* If none found, then allocate and initialize one. */
2121 tdep
= XZALLOC (struct gdbarch_tdep
);
2122 gdbarch
= gdbarch_alloc (&info
, tdep
);
2124 /* Determine from the bfd_arch_info structure if we are dealing with
2125 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2126 then default to a 32bit machine. */
2127 if (info
.bfd_arch_info
!= NULL
)
2128 tdep
->bytes_per_address
=
2129 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2131 tdep
->bytes_per_address
= 4;
2133 /* Some parts of the gdbarch vector depend on whether we are running
2134 on a 32 bits or 64 bits target. */
2135 switch (tdep
->bytes_per_address
)
2138 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2139 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2140 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2143 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2144 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2145 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2148 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2149 tdep
->bytes_per_address
);
2152 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2153 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2155 /* The following gdbarch vector elements are the same in both ILP32
2156 and LP64, but might show differences some day. */
2157 set_gdbarch_long_long_bit (gdbarch
, 64);
2158 set_gdbarch_long_double_bit (gdbarch
, 128);
2159 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2161 /* The following gdbarch vector elements do not depend on the address
2162 size, or in any other gdbarch element previously set. */
2163 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2164 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2165 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2166 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2167 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2168 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2169 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2170 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2171 set_gdbarch_read_pc (gdbarch
, hppa_target_read_pc
);
2172 set_gdbarch_write_pc (gdbarch
, hppa_target_write_pc
);
2174 /* Helper for function argument information. */
2175 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2177 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2179 /* When a hardware watchpoint triggers, we'll move the inferior past
2180 it by removing all eventpoints; stepping past the instruction
2181 that caused the trigger; reinserting eventpoints; and checking
2182 whether any watched location changed. */
2183 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2185 /* Inferior function call methods. */
2186 switch (tdep
->bytes_per_address
)
2189 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2190 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2193 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2194 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2197 internal_error (__FILE__
, __LINE__
, "bad switch");
2200 /* Struct return methods. */
2201 switch (tdep
->bytes_per_address
)
2204 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2207 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2210 internal_error (__FILE__
, __LINE__
, "bad switch");
2213 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2215 /* Frame unwind methods. */
2216 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2217 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2218 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2219 frame_base_append_sniffer (gdbarch
, hppa_frame_base_sniffer
);
2221 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2223 /* Hook in ABI-specific overrides, if they have been registered. */
2224 gdbarch_init_osabi (info
, gdbarch
);
2230 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2232 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2234 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2235 tdep
->bytes_per_address
);
2236 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2240 _initialize_hppa_tdep (void)
2242 struct cmd_list_element
*c
;
2243 void break_at_finish_command (char *arg
, int from_tty
);
2244 void tbreak_at_finish_command (char *arg
, int from_tty
);
2245 void break_at_finish_at_depth_command (char *arg
, int from_tty
);
2247 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2249 hppa_objfile_priv_data
= register_objfile_data ();
2251 add_cmd ("unwind", class_maintenance
, unwind_command
,
2252 "Print unwind table entry at given address.",
2253 &maintenanceprintlist
);
2255 deprecate_cmd (add_com ("xbreak", class_breakpoint
,
2256 break_at_finish_command
,
2257 concat ("Set breakpoint at procedure exit. \n\
2258 Argument may be function name, or \"*\" and an address.\n\
2259 If function is specified, break at end of code for that function.\n\
2260 If an address is specified, break at the end of the function that contains \n\
2261 that exact address.\n",
2262 "With no arg, uses current execution address of selected stack frame.\n\
2263 This is useful for breaking on return to a stack frame.\n\
2265 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2267 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
)), NULL
);
2268 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint
, 1), NULL
);
2269 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint
, 1), NULL
);
2270 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint
, 1), NULL
);
2271 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1), NULL
);
2273 deprecate_cmd (c
= add_com ("txbreak", class_breakpoint
,
2274 tbreak_at_finish_command
,
2275 "Set temporary breakpoint at procedure exit. Either there should\n\
2276 be no argument or the argument must be a depth.\n"), NULL
);
2277 set_cmd_completer (c
, location_completer
);
2280 deprecate_cmd (add_com ("bx", class_breakpoint
,
2281 break_at_finish_at_depth_command
,
2282 "Set breakpoint at procedure exit. Either there should\n\
2283 be no argument or the argument must be a depth.\n"), NULL
);
2285 /* Debug this files internals. */
2286 add_show_from_set (add_set_cmd ("hppa", class_maintenance
, var_zinteger
,
2287 &hppa_debug
, "Set hppa debugging.\n\
2288 When non-zero, hppa specific debugging is enabled.", &setdebuglist
), &showdebuglist
);