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. */
31 #include "completer.h"
33 #include "gdb_assert.h"
34 #include "arch-utils.h"
35 /* For argument passing to the inferior */
38 #include "trad-frame.h"
39 #include "frame-unwind.h"
40 #include "frame-base.h"
45 #include "hppa-tdep.h"
47 static int hppa_debug
= 0;
49 /* Some local constants. */
50 static const int hppa32_num_regs
= 128;
51 static const int hppa64_num_regs
= 96;
53 /* hppa-specific object data -- unwind and solib info.
54 TODO/maybe: think about splitting this into two parts; the unwind data is
55 common to all hppa targets, but is only used in this file; we can register
56 that separately and make this static. The solib data is probably hpux-
57 specific, so we can create a separate extern objfile_data that is registered
58 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
59 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
61 /* Get at various relevent fields of an instruction word. */
64 #define MASK_14 0x3fff
65 #define MASK_21 0x1fffff
67 /* Define offsets into the call dummy for the _sr4export address.
68 See comments related to CALL_DUMMY for more info. */
69 #define SR4EXPORT_LDIL_OFFSET (HPPA_INSTRUCTION_SIZE * 12)
70 #define SR4EXPORT_LDO_OFFSET (HPPA_INSTRUCTION_SIZE * 13)
72 /* Sizes (in bytes) of the native unwind entries. */
73 #define UNWIND_ENTRY_SIZE 16
74 #define STUB_UNWIND_ENTRY_SIZE 8
76 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
77 following functions static, once we hppa is partially multiarched. */
78 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
79 int hppa_instruction_nullified (void);
81 /* Handle 32/64-bit struct return conventions. */
83 static enum return_value_convention
84 hppa32_return_value (struct gdbarch
*gdbarch
,
85 struct type
*type
, struct regcache
*regcache
,
86 void *readbuf
, const void *writebuf
)
88 if (TYPE_LENGTH (type
) <= 2 * 4)
90 /* The value always lives in the right hand end of the register
91 (or register pair)? */
93 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
94 int part
= TYPE_LENGTH (type
) % 4;
95 /* The left hand register contains only part of the value,
96 transfer that first so that the rest can be xfered as entire
101 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
103 if (writebuf
!= NULL
)
104 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
108 /* Now transfer the remaining register values. */
109 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
112 regcache_cooked_read (regcache
, reg
, (char *) readbuf
+ b
);
113 if (writebuf
!= NULL
)
114 regcache_cooked_write (regcache
, reg
, (const char *) writebuf
+ b
);
117 return RETURN_VALUE_REGISTER_CONVENTION
;
120 return RETURN_VALUE_STRUCT_CONVENTION
;
123 static enum return_value_convention
124 hppa64_return_value (struct gdbarch
*gdbarch
,
125 struct type
*type
, struct regcache
*regcache
,
126 void *readbuf
, const void *writebuf
)
128 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
129 are in r28, padded on the left. Aggregates less that 65 bits are
130 in r28, right padded. Aggregates upto 128 bits are in r28 and
131 r29, right padded. */
132 if (TYPE_CODE (type
) == TYPE_CODE_FLT
133 && TYPE_LENGTH (type
) <= 8)
135 /* Floats are right aligned? */
136 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
138 regcache_cooked_read_part (regcache
, HPPA_FP4_REGNUM
, offset
,
139 TYPE_LENGTH (type
), readbuf
);
140 if (writebuf
!= NULL
)
141 regcache_cooked_write_part (regcache
, HPPA_FP4_REGNUM
, offset
,
142 TYPE_LENGTH (type
), writebuf
);
143 return RETURN_VALUE_REGISTER_CONVENTION
;
145 else if (TYPE_LENGTH (type
) <= 8 && is_integral_type (type
))
147 /* Integrals are right aligned. */
148 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
150 regcache_cooked_read_part (regcache
, 28, offset
,
151 TYPE_LENGTH (type
), readbuf
);
152 if (writebuf
!= NULL
)
153 regcache_cooked_write_part (regcache
, 28, offset
,
154 TYPE_LENGTH (type
), writebuf
);
155 return RETURN_VALUE_REGISTER_CONVENTION
;
157 else if (TYPE_LENGTH (type
) <= 2 * 8)
159 /* Composite values are left aligned. */
161 for (b
= 0; b
< TYPE_LENGTH (type
); b
+= 8)
163 int part
= min (8, TYPE_LENGTH (type
) - b
);
165 regcache_cooked_read_part (regcache
, 28 + b
/ 8, 0, part
,
166 (char *) readbuf
+ b
);
167 if (writebuf
!= NULL
)
168 regcache_cooked_write_part (regcache
, 28 + b
/ 8, 0, part
,
169 (const char *) writebuf
+ b
);
171 return RETURN_VALUE_REGISTER_CONVENTION
;
174 return RETURN_VALUE_STRUCT_CONVENTION
;
177 /* Routines to extract various sized constants out of hppa
180 /* This assumes that no garbage lies outside of the lower bits of
184 hppa_sign_extend (unsigned val
, unsigned bits
)
186 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
189 /* For many immediate values the sign bit is the low bit! */
192 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
194 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
197 /* Extract the bits at positions between FROM and TO, using HP's numbering
201 hppa_get_field (unsigned word
, int from
, int to
)
203 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
206 /* extract the immediate field from a ld{bhw}s instruction */
209 hppa_extract_5_load (unsigned word
)
211 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
214 /* extract the immediate field from a break instruction */
217 hppa_extract_5r_store (unsigned word
)
219 return (word
& MASK_5
);
222 /* extract the immediate field from a {sr}sm instruction */
225 hppa_extract_5R_store (unsigned word
)
227 return (word
>> 16 & MASK_5
);
230 /* extract a 14 bit immediate field */
233 hppa_extract_14 (unsigned word
)
235 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
238 /* extract a 21 bit constant */
241 hppa_extract_21 (unsigned word
)
247 val
= hppa_get_field (word
, 20, 20);
249 val
|= hppa_get_field (word
, 9, 19);
251 val
|= hppa_get_field (word
, 5, 6);
253 val
|= hppa_get_field (word
, 0, 4);
255 val
|= hppa_get_field (word
, 7, 8);
256 return hppa_sign_extend (val
, 21) << 11;
259 /* extract a 17 bit constant from branch instructions, returning the
260 19 bit signed value. */
263 hppa_extract_17 (unsigned word
)
265 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
266 hppa_get_field (word
, 29, 29) << 10 |
267 hppa_get_field (word
, 11, 15) << 11 |
268 (word
& 0x1) << 16, 17) << 2;
272 /* Compare the start address for two unwind entries returning 1 if
273 the first address is larger than the second, -1 if the second is
274 larger than the first, and zero if they are equal. */
277 compare_unwind_entries (const void *arg1
, const void *arg2
)
279 const struct unwind_table_entry
*a
= arg1
;
280 const struct unwind_table_entry
*b
= arg2
;
282 if (a
->region_start
> b
->region_start
)
284 else if (a
->region_start
< b
->region_start
)
291 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
293 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
294 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
296 bfd_vma value
= section
->vma
- section
->filepos
;
297 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
299 if (value
< *low_text_segment_address
)
300 *low_text_segment_address
= value
;
305 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
306 asection
*section
, unsigned int entries
, unsigned int size
,
307 CORE_ADDR text_offset
)
309 /* We will read the unwind entries into temporary memory, then
310 fill in the actual unwind table. */
316 char *buf
= alloca (size
);
317 CORE_ADDR low_text_segment_address
;
319 /* For ELF targets, then unwinds are supposed to
320 be segment relative offsets instead of absolute addresses.
322 Note that when loading a shared library (text_offset != 0) the
323 unwinds are already relative to the text_offset that will be
325 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
327 low_text_segment_address
= -1;
329 bfd_map_over_sections (objfile
->obfd
,
330 record_text_segment_lowaddr
,
331 &low_text_segment_address
);
333 text_offset
= low_text_segment_address
;
336 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
338 /* Now internalize the information being careful to handle host/target
340 for (i
= 0; i
< entries
; i
++)
342 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
344 table
[i
].region_start
+= text_offset
;
346 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
347 table
[i
].region_end
+= text_offset
;
349 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
351 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
352 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
353 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
354 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
355 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
356 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
357 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
358 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
359 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
360 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
361 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
362 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
363 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
364 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
365 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
366 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
367 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
368 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
369 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
370 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
371 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
372 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
373 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
374 table
[i
].Cleanup_defined
= tmp
& 0x1;
375 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
377 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
378 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
379 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
380 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
381 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
382 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
384 /* Stub unwinds are handled elsewhere. */
385 table
[i
].stub_unwind
.stub_type
= 0;
386 table
[i
].stub_unwind
.padding
= 0;
391 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
392 the object file. This info is used mainly by find_unwind_entry() to find
393 out the stack frame size and frame pointer used by procedures. We put
394 everything on the psymbol obstack in the objfile so that it automatically
395 gets freed when the objfile is destroyed. */
398 read_unwind_info (struct objfile
*objfile
)
400 asection
*unwind_sec
, *stub_unwind_sec
;
401 unsigned unwind_size
, stub_unwind_size
, total_size
;
402 unsigned index
, unwind_entries
;
403 unsigned stub_entries
, total_entries
;
404 CORE_ADDR text_offset
;
405 struct hppa_unwind_info
*ui
;
406 struct hppa_objfile_private
*obj_private
;
408 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
409 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
410 sizeof (struct hppa_unwind_info
));
416 /* For reasons unknown the HP PA64 tools generate multiple unwinder
417 sections in a single executable. So we just iterate over every
418 section in the BFD looking for unwinder sections intead of trying
419 to do a lookup with bfd_get_section_by_name.
421 First determine the total size of the unwind tables so that we
422 can allocate memory in a nice big hunk. */
424 for (unwind_sec
= objfile
->obfd
->sections
;
426 unwind_sec
= unwind_sec
->next
)
428 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
429 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
431 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
432 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
434 total_entries
+= unwind_entries
;
438 /* Now compute the size of the stub unwinds. Note the ELF tools do not
439 use stub unwinds at the curren time. */
440 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
444 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
445 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
449 stub_unwind_size
= 0;
453 /* Compute total number of unwind entries and their total size. */
454 total_entries
+= stub_entries
;
455 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
457 /* Allocate memory for the unwind table. */
458 ui
->table
= (struct unwind_table_entry
*)
459 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
460 ui
->last
= total_entries
- 1;
462 /* Now read in each unwind section and internalize the standard unwind
465 for (unwind_sec
= objfile
->obfd
->sections
;
467 unwind_sec
= unwind_sec
->next
)
469 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
470 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
472 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
473 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
475 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
476 unwind_entries
, unwind_size
, text_offset
);
477 index
+= unwind_entries
;
481 /* Now read in and internalize the stub unwind entries. */
482 if (stub_unwind_size
> 0)
485 char *buf
= alloca (stub_unwind_size
);
487 /* Read in the stub unwind entries. */
488 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
489 0, stub_unwind_size
);
491 /* Now convert them into regular unwind entries. */
492 for (i
= 0; i
< stub_entries
; i
++, index
++)
494 /* Clear out the next unwind entry. */
495 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
497 /* Convert offset & size into region_start and region_end.
498 Stuff away the stub type into "reserved" fields. */
499 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
501 ui
->table
[index
].region_start
+= text_offset
;
503 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
506 ui
->table
[index
].region_end
507 = ui
->table
[index
].region_start
+ 4 *
508 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
514 /* Unwind table needs to be kept sorted. */
515 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
516 compare_unwind_entries
);
518 /* Keep a pointer to the unwind information. */
519 obj_private
= (struct hppa_objfile_private
*)
520 objfile_data (objfile
, hppa_objfile_priv_data
);
521 if (obj_private
== NULL
)
523 obj_private
= (struct hppa_objfile_private
*)
524 obstack_alloc (&objfile
->objfile_obstack
,
525 sizeof (struct hppa_objfile_private
));
526 set_objfile_data (objfile
, hppa_objfile_priv_data
, obj_private
);
527 obj_private
->unwind_info
= NULL
;
528 obj_private
->so_info
= NULL
;
531 obj_private
->unwind_info
= ui
;
534 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
535 of the objfiles seeking the unwind table entry for this PC. Each objfile
536 contains a sorted list of struct unwind_table_entry. Since we do a binary
537 search of the unwind tables, we depend upon them to be sorted. */
539 struct unwind_table_entry
*
540 find_unwind_entry (CORE_ADDR pc
)
542 int first
, middle
, last
;
543 struct objfile
*objfile
;
544 struct hppa_objfile_private
*priv
;
547 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
550 /* A function at address 0? Not in HP-UX! */
551 if (pc
== (CORE_ADDR
) 0)
554 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
558 ALL_OBJFILES (objfile
)
560 struct hppa_unwind_info
*ui
;
562 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
564 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
568 read_unwind_info (objfile
);
569 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
571 error ("Internal error reading unwind information.");
572 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
575 /* First, check the cache */
578 && pc
>= ui
->cache
->region_start
579 && pc
<= ui
->cache
->region_end
)
582 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
583 paddr_nz ((CORE_ADDR
) ui
->cache
));
587 /* Not in the cache, do a binary search */
592 while (first
<= last
)
594 middle
= (first
+ last
) / 2;
595 if (pc
>= ui
->table
[middle
].region_start
596 && pc
<= ui
->table
[middle
].region_end
)
598 ui
->cache
= &ui
->table
[middle
];
600 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
601 paddr_nz ((CORE_ADDR
) ui
->cache
));
602 return &ui
->table
[middle
];
605 if (pc
< ui
->table
[middle
].region_start
)
610 } /* ALL_OBJFILES() */
613 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
618 static const unsigned char *
619 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
621 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
622 (*len
) = sizeof (breakpoint
);
626 /* Return the name of a register. */
629 hppa32_register_name (int i
)
631 static char *names
[] = {
632 "flags", "r1", "rp", "r3",
633 "r4", "r5", "r6", "r7",
634 "r8", "r9", "r10", "r11",
635 "r12", "r13", "r14", "r15",
636 "r16", "r17", "r18", "r19",
637 "r20", "r21", "r22", "r23",
638 "r24", "r25", "r26", "dp",
639 "ret0", "ret1", "sp", "r31",
640 "sar", "pcoqh", "pcsqh", "pcoqt",
641 "pcsqt", "eiem", "iir", "isr",
642 "ior", "ipsw", "goto", "sr4",
643 "sr0", "sr1", "sr2", "sr3",
644 "sr5", "sr6", "sr7", "cr0",
645 "cr8", "cr9", "ccr", "cr12",
646 "cr13", "cr24", "cr25", "cr26",
647 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
648 "fpsr", "fpe1", "fpe2", "fpe3",
649 "fpe4", "fpe5", "fpe6", "fpe7",
650 "fr4", "fr4R", "fr5", "fr5R",
651 "fr6", "fr6R", "fr7", "fr7R",
652 "fr8", "fr8R", "fr9", "fr9R",
653 "fr10", "fr10R", "fr11", "fr11R",
654 "fr12", "fr12R", "fr13", "fr13R",
655 "fr14", "fr14R", "fr15", "fr15R",
656 "fr16", "fr16R", "fr17", "fr17R",
657 "fr18", "fr18R", "fr19", "fr19R",
658 "fr20", "fr20R", "fr21", "fr21R",
659 "fr22", "fr22R", "fr23", "fr23R",
660 "fr24", "fr24R", "fr25", "fr25R",
661 "fr26", "fr26R", "fr27", "fr27R",
662 "fr28", "fr28R", "fr29", "fr29R",
663 "fr30", "fr30R", "fr31", "fr31R"
665 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
672 hppa64_register_name (int i
)
674 static char *names
[] = {
675 "flags", "r1", "rp", "r3",
676 "r4", "r5", "r6", "r7",
677 "r8", "r9", "r10", "r11",
678 "r12", "r13", "r14", "r15",
679 "r16", "r17", "r18", "r19",
680 "r20", "r21", "r22", "r23",
681 "r24", "r25", "r26", "dp",
682 "ret0", "ret1", "sp", "r31",
683 "sar", "pcoqh", "pcsqh", "pcoqt",
684 "pcsqt", "eiem", "iir", "isr",
685 "ior", "ipsw", "goto", "sr4",
686 "sr0", "sr1", "sr2", "sr3",
687 "sr5", "sr6", "sr7", "cr0",
688 "cr8", "cr9", "ccr", "cr12",
689 "cr13", "cr24", "cr25", "cr26",
690 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
691 "fpsr", "fpe1", "fpe2", "fpe3",
692 "fr4", "fr5", "fr6", "fr7",
693 "fr8", "fr9", "fr10", "fr11",
694 "fr12", "fr13", "fr14", "fr15",
695 "fr16", "fr17", "fr18", "fr19",
696 "fr20", "fr21", "fr22", "fr23",
697 "fr24", "fr25", "fr26", "fr27",
698 "fr28", "fr29", "fr30", "fr31"
700 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
706 /* This function pushes a stack frame with arguments as part of the
707 inferior function calling mechanism.
709 This is the version of the function for the 32-bit PA machines, in
710 which later arguments appear at lower addresses. (The stack always
711 grows towards higher addresses.)
713 We simply allocate the appropriate amount of stack space and put
714 arguments into their proper slots. */
717 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
718 struct regcache
*regcache
, CORE_ADDR bp_addr
,
719 int nargs
, struct value
**args
, CORE_ADDR sp
,
720 int struct_return
, CORE_ADDR struct_addr
)
722 /* Stack base address at which any pass-by-reference parameters are
724 CORE_ADDR struct_end
= 0;
725 /* Stack base address at which the first parameter is stored. */
726 CORE_ADDR param_end
= 0;
728 /* The inner most end of the stack after all the parameters have
730 CORE_ADDR new_sp
= 0;
732 /* Two passes. First pass computes the location of everything,
733 second pass writes the bytes out. */
735 for (write_pass
= 0; write_pass
< 2; write_pass
++)
737 CORE_ADDR struct_ptr
= 0;
738 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
739 struct_ptr is adjusted for each argument below, so the first
740 argument will end up at sp-36. */
741 CORE_ADDR param_ptr
= 32;
743 int small_struct
= 0;
745 for (i
= 0; i
< nargs
; i
++)
747 struct value
*arg
= args
[i
];
748 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
749 /* The corresponding parameter that is pushed onto the
750 stack, and [possibly] passed in a register. */
753 memset (param_val
, 0, sizeof param_val
);
754 if (TYPE_LENGTH (type
) > 8)
756 /* Large parameter, pass by reference. Store the value
757 in "struct" area and then pass its address. */
759 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
761 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
763 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
765 else if (TYPE_CODE (type
) == TYPE_CODE_INT
766 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
768 /* Integer value store, right aligned. "unpack_long"
769 takes care of any sign-extension problems. */
770 param_len
= align_up (TYPE_LENGTH (type
), 4);
771 store_unsigned_integer (param_val
, param_len
,
773 VALUE_CONTENTS (arg
)));
775 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
777 /* Floating point value store, right aligned. */
778 param_len
= align_up (TYPE_LENGTH (type
), 4);
779 memcpy (param_val
, VALUE_CONTENTS (arg
), param_len
);
783 param_len
= align_up (TYPE_LENGTH (type
), 4);
785 /* Small struct value are stored right-aligned. */
786 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
787 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
789 /* Structures of size 5, 6 and 7 bytes are special in that
790 the higher-ordered word is stored in the lower-ordered
791 argument, and even though it is a 8-byte quantity the
792 registers need not be 8-byte aligned. */
793 if (param_len
> 4 && param_len
< 8)
797 param_ptr
+= param_len
;
798 if (param_len
== 8 && !small_struct
)
799 param_ptr
= align_up (param_ptr
, 8);
801 /* First 4 non-FP arguments are passed in gr26-gr23.
802 First 4 32-bit FP arguments are passed in fr4L-fr7L.
803 First 2 64-bit FP arguments are passed in fr5 and fr7.
805 The rest go on the stack, starting at sp-36, towards lower
806 addresses. 8-byte arguments must be aligned to a 8-byte
810 write_memory (param_end
- param_ptr
, param_val
, param_len
);
812 /* There are some cases when we don't know the type
813 expected by the callee (e.g. for variadic functions), so
814 pass the parameters in both general and fp regs. */
817 int grreg
= 26 - (param_ptr
- 36) / 4;
818 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
819 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
821 regcache_cooked_write (regcache
, grreg
, param_val
);
822 regcache_cooked_write (regcache
, fpLreg
, param_val
);
826 regcache_cooked_write (regcache
, grreg
+ 1,
829 regcache_cooked_write (regcache
, fpreg
, param_val
);
830 regcache_cooked_write (regcache
, fpreg
+ 1,
837 /* Update the various stack pointers. */
840 struct_end
= sp
+ align_up (struct_ptr
, 64);
841 /* PARAM_PTR already accounts for all the arguments passed
842 by the user. However, the ABI mandates minimum stack
843 space allocations for outgoing arguments. The ABI also
844 mandates minimum stack alignments which we must
846 param_end
= struct_end
+ align_up (param_ptr
, 64);
850 /* If a structure has to be returned, set up register 28 to hold its
853 write_register (28, struct_addr
);
855 /* Set the return address. */
856 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
858 /* Update the Stack Pointer. */
859 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
864 /* This function pushes a stack frame with arguments as part of the
865 inferior function calling mechanism.
867 This is the version for the PA64, in which later arguments appear
868 at higher addresses. (The stack always grows towards higher
871 We simply allocate the appropriate amount of stack space and put
872 arguments into their proper slots.
874 This ABI also requires that the caller provide an argument pointer
875 to the callee, so we do that too. */
878 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
879 struct regcache
*regcache
, CORE_ADDR bp_addr
,
880 int nargs
, struct value
**args
, CORE_ADDR sp
,
881 int struct_return
, CORE_ADDR struct_addr
)
883 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
884 reverse engineering testsuite failures. */
886 /* Stack base address at which any pass-by-reference parameters are
888 CORE_ADDR struct_end
= 0;
889 /* Stack base address at which the first parameter is stored. */
890 CORE_ADDR param_end
= 0;
892 /* The inner most end of the stack after all the parameters have
894 CORE_ADDR new_sp
= 0;
896 /* Two passes. First pass computes the location of everything,
897 second pass writes the bytes out. */
899 for (write_pass
= 0; write_pass
< 2; write_pass
++)
901 CORE_ADDR struct_ptr
= 0;
902 CORE_ADDR param_ptr
= 0;
904 for (i
= 0; i
< nargs
; i
++)
906 struct value
*arg
= args
[i
];
907 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
908 if ((TYPE_CODE (type
) == TYPE_CODE_INT
909 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
910 && TYPE_LENGTH (type
) <= 8)
912 /* Integer value store, right aligned. "unpack_long"
913 takes care of any sign-extension problems. */
917 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
918 int reg
= 27 - param_ptr
/ 8;
919 write_memory_unsigned_integer (param_end
- param_ptr
,
922 regcache_cooked_write_unsigned (regcache
, reg
, val
);
927 /* Small struct value, store left aligned? */
929 if (TYPE_LENGTH (type
) > 8)
931 param_ptr
= align_up (param_ptr
, 16);
932 reg
= 26 - param_ptr
/ 8;
933 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
937 param_ptr
= align_up (param_ptr
, 8);
938 reg
= 26 - param_ptr
/ 8;
939 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
944 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
946 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
950 int len
= min (8, TYPE_LENGTH (type
) - byte
);
951 regcache_cooked_write_part (regcache
, reg
, 0, len
,
952 VALUE_CONTENTS (arg
) + byte
);
959 /* Update the various stack pointers. */
962 struct_end
= sp
+ struct_ptr
;
963 /* PARAM_PTR already accounts for all the arguments passed
964 by the user. However, the ABI mandates minimum stack
965 space allocations for outgoing arguments. The ABI also
966 mandates minimum stack alignments which we must
968 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
972 /* If a structure has to be returned, set up register 28 to hold its
975 write_register (28, struct_addr
);
977 /* Set the return address. */
978 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
980 /* Update the Stack Pointer. */
981 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
+ 64);
983 /* The stack will have 32 bytes of additional space for a frame marker. */
984 return param_end
+ 64;
988 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
990 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
992 return align_up (addr
, 64);
995 /* Force all frames to 16-byte alignment. Better safe than sorry. */
998 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1000 /* Just always 16-byte align. */
1001 return align_up (addr
, 16);
1005 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1009 hppa_target_read_pc (ptid_t ptid
)
1011 int flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1013 /* The following test does not belong here. It is OS-specific, and belongs
1015 /* Test SS_INSYSCALL */
1017 return read_register_pid (31, ptid
) & ~0x3;
1019 return read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
) & ~0x3;
1022 /* Write out the PC. If currently in a syscall, then also write the new
1023 PC value into %r31. */
1026 hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
1028 int flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1030 /* The following test does not belong here. It is OS-specific, and belongs
1032 /* If in a syscall, then set %r31. Also make sure to get the
1033 privilege bits set correctly. */
1034 /* Test SS_INSYSCALL */
1036 write_register_pid (31, v
| 0x3, ptid
);
1038 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, v
, ptid
);
1039 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, v
+ 4, ptid
);
1042 /* return the alignment of a type in bytes. Structures have the maximum
1043 alignment required by their fields. */
1046 hppa_alignof (struct type
*type
)
1048 int max_align
, align
, i
;
1049 CHECK_TYPEDEF (type
);
1050 switch (TYPE_CODE (type
))
1055 return TYPE_LENGTH (type
);
1056 case TYPE_CODE_ARRAY
:
1057 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1058 case TYPE_CODE_STRUCT
:
1059 case TYPE_CODE_UNION
:
1061 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1063 /* Bit fields have no real alignment. */
1064 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1065 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1067 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1068 max_align
= max (max_align
, align
);
1077 /* For the given instruction (INST), return any adjustment it makes
1078 to the stack pointer or zero for no adjustment.
1080 This only handles instructions commonly found in prologues. */
1083 prologue_inst_adjust_sp (unsigned long inst
)
1085 /* This must persist across calls. */
1086 static int save_high21
;
1088 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1089 if ((inst
& 0xffffc000) == 0x37de0000)
1090 return hppa_extract_14 (inst
);
1093 if ((inst
& 0xffe00000) == 0x6fc00000)
1094 return hppa_extract_14 (inst
);
1096 /* std,ma X,D(sp) */
1097 if ((inst
& 0xffe00008) == 0x73c00008)
1098 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1100 /* addil high21,%r1; ldo low11,(%r1),%r30)
1101 save high bits in save_high21 for later use. */
1102 if ((inst
& 0xffe00000) == 0x28200000)
1104 save_high21
= hppa_extract_21 (inst
);
1108 if ((inst
& 0xffff0000) == 0x343e0000)
1109 return save_high21
+ hppa_extract_14 (inst
);
1111 /* fstws as used by the HP compilers. */
1112 if ((inst
& 0xffffffe0) == 0x2fd01220)
1113 return hppa_extract_5_load (inst
);
1115 /* No adjustment. */
1119 /* Return nonzero if INST is a branch of some kind, else return zero. */
1122 is_branch (unsigned long inst
)
1151 /* Return the register number for a GR which is saved by INST or
1152 zero it INST does not save a GR. */
1155 inst_saves_gr (unsigned long inst
)
1157 /* Does it look like a stw? */
1158 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1159 || (inst
>> 26) == 0x1f
1160 || ((inst
>> 26) == 0x1f
1161 && ((inst
>> 6) == 0xa)))
1162 return hppa_extract_5R_store (inst
);
1164 /* Does it look like a std? */
1165 if ((inst
>> 26) == 0x1c
1166 || ((inst
>> 26) == 0x03
1167 && ((inst
>> 6) & 0xf) == 0xb))
1168 return hppa_extract_5R_store (inst
);
1170 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1171 if ((inst
>> 26) == 0x1b)
1172 return hppa_extract_5R_store (inst
);
1174 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1176 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1177 || ((inst
>> 26) == 0x3
1178 && (((inst
>> 6) & 0xf) == 0x8
1179 || (inst
>> 6) & 0xf) == 0x9))
1180 return hppa_extract_5R_store (inst
);
1185 /* Return the register number for a FR which is saved by INST or
1186 zero it INST does not save a FR.
1188 Note we only care about full 64bit register stores (that's the only
1189 kind of stores the prologue will use).
1191 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1194 inst_saves_fr (unsigned long inst
)
1196 /* is this an FSTD ? */
1197 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1198 return hppa_extract_5r_store (inst
);
1199 if ((inst
& 0xfc000002) == 0x70000002)
1200 return hppa_extract_5R_store (inst
);
1201 /* is this an FSTW ? */
1202 if ((inst
& 0xfc00df80) == 0x24001200)
1203 return hppa_extract_5r_store (inst
);
1204 if ((inst
& 0xfc000002) == 0x7c000000)
1205 return hppa_extract_5R_store (inst
);
1209 /* Advance PC across any function entry prologue instructions
1210 to reach some "real" code.
1212 Use information in the unwind table to determine what exactly should
1213 be in the prologue. */
1217 skip_prologue_hard_way (CORE_ADDR pc
)
1220 CORE_ADDR orig_pc
= pc
;
1221 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1222 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1223 struct unwind_table_entry
*u
;
1229 u
= find_unwind_entry (pc
);
1233 /* If we are not at the beginning of a function, then return now. */
1234 if ((pc
& ~0x3) != u
->region_start
)
1237 /* This is how much of a frame adjustment we need to account for. */
1238 stack_remaining
= u
->Total_frame_size
<< 3;
1240 /* Magic register saves we want to know about. */
1241 save_rp
= u
->Save_RP
;
1242 save_sp
= u
->Save_SP
;
1244 /* An indication that args may be stored into the stack. Unfortunately
1245 the HPUX compilers tend to set this in cases where no args were
1249 /* Turn the Entry_GR field into a bitmask. */
1251 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1253 /* Frame pointer gets saved into a special location. */
1254 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1257 save_gr
|= (1 << i
);
1259 save_gr
&= ~restart_gr
;
1261 /* Turn the Entry_FR field into a bitmask too. */
1263 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1264 save_fr
|= (1 << i
);
1265 save_fr
&= ~restart_fr
;
1267 /* Loop until we find everything of interest or hit a branch.
1269 For unoptimized GCC code and for any HP CC code this will never ever
1270 examine any user instructions.
1272 For optimzied GCC code we're faced with problems. GCC will schedule
1273 its prologue and make prologue instructions available for delay slot
1274 filling. The end result is user code gets mixed in with the prologue
1275 and a prologue instruction may be in the delay slot of the first branch
1278 Some unexpected things are expected with debugging optimized code, so
1279 we allow this routine to walk past user instructions in optimized
1281 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1284 unsigned int reg_num
;
1285 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1286 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1288 /* Save copies of all the triggers so we can compare them later
1290 old_save_gr
= save_gr
;
1291 old_save_fr
= save_fr
;
1292 old_save_rp
= save_rp
;
1293 old_save_sp
= save_sp
;
1294 old_stack_remaining
= stack_remaining
;
1296 status
= read_memory_nobpt (pc
, buf
, 4);
1297 inst
= extract_unsigned_integer (buf
, 4);
1303 /* Note the interesting effects of this instruction. */
1304 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1306 /* There are limited ways to store the return pointer into the
1308 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1311 /* These are the only ways we save SP into the stack. At this time
1312 the HP compilers never bother to save SP into the stack. */
1313 if ((inst
& 0xffffc000) == 0x6fc10000
1314 || (inst
& 0xffffc00c) == 0x73c10008)
1317 /* Are we loading some register with an offset from the argument
1319 if ((inst
& 0xffe00000) == 0x37a00000
1320 || (inst
& 0xffffffe0) == 0x081d0240)
1326 /* Account for general and floating-point register saves. */
1327 reg_num
= inst_saves_gr (inst
);
1328 save_gr
&= ~(1 << reg_num
);
1330 /* Ugh. Also account for argument stores into the stack.
1331 Unfortunately args_stored only tells us that some arguments
1332 where stored into the stack. Not how many or what kind!
1334 This is a kludge as on the HP compiler sets this bit and it
1335 never does prologue scheduling. So once we see one, skip past
1336 all of them. We have similar code for the fp arg stores below.
1338 FIXME. Can still die if we have a mix of GR and FR argument
1340 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1342 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1345 status
= read_memory_nobpt (pc
, buf
, 4);
1346 inst
= extract_unsigned_integer (buf
, 4);
1349 reg_num
= inst_saves_gr (inst
);
1355 reg_num
= inst_saves_fr (inst
);
1356 save_fr
&= ~(1 << reg_num
);
1358 status
= read_memory_nobpt (pc
+ 4, buf
, 4);
1359 next_inst
= extract_unsigned_integer (buf
, 4);
1365 /* We've got to be read to handle the ldo before the fp register
1367 if ((inst
& 0xfc000000) == 0x34000000
1368 && inst_saves_fr (next_inst
) >= 4
1369 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1371 /* So we drop into the code below in a reasonable state. */
1372 reg_num
= inst_saves_fr (next_inst
);
1376 /* Ugh. Also account for argument stores into the stack.
1377 This is a kludge as on the HP compiler sets this bit and it
1378 never does prologue scheduling. So once we see one, skip past
1380 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1382 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1385 status
= read_memory_nobpt (pc
, buf
, 4);
1386 inst
= extract_unsigned_integer (buf
, 4);
1389 if ((inst
& 0xfc000000) != 0x34000000)
1391 status
= read_memory_nobpt (pc
+ 4, buf
, 4);
1392 next_inst
= extract_unsigned_integer (buf
, 4);
1395 reg_num
= inst_saves_fr (next_inst
);
1401 /* Quit if we hit any kind of branch. This can happen if a prologue
1402 instruction is in the delay slot of the first call/branch. */
1403 if (is_branch (inst
))
1406 /* What a crock. The HP compilers set args_stored even if no
1407 arguments were stored into the stack (boo hiss). This could
1408 cause this code to then skip a bunch of user insns (up to the
1411 To combat this we try to identify when args_stored was bogusly
1412 set and clear it. We only do this when args_stored is nonzero,
1413 all other resources are accounted for, and nothing changed on
1416 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1417 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1418 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1419 && old_stack_remaining
== stack_remaining
)
1426 /* We've got a tenative location for the end of the prologue. However
1427 because of limitations in the unwind descriptor mechanism we may
1428 have went too far into user code looking for the save of a register
1429 that does not exist. So, if there registers we expected to be saved
1430 but never were, mask them out and restart.
1432 This should only happen in optimized code, and should be very rare. */
1433 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1436 restart_gr
= save_gr
;
1437 restart_fr
= save_fr
;
1445 /* Return the address of the PC after the last prologue instruction if
1446 we can determine it from the debug symbols. Else return zero. */
1449 after_prologue (CORE_ADDR pc
)
1451 struct symtab_and_line sal
;
1452 CORE_ADDR func_addr
, func_end
;
1455 /* If we can not find the symbol in the partial symbol table, then
1456 there is no hope we can determine the function's start address
1458 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1461 /* Get the line associated with FUNC_ADDR. */
1462 sal
= find_pc_line (func_addr
, 0);
1464 /* There are only two cases to consider. First, the end of the source line
1465 is within the function bounds. In that case we return the end of the
1466 source line. Second is the end of the source line extends beyond the
1467 bounds of the current function. We need to use the slow code to
1468 examine instructions in that case.
1470 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1471 the wrong thing to do. In fact, it should be entirely possible for this
1472 function to always return zero since the slow instruction scanning code
1473 is supposed to *always* work. If it does not, then it is a bug. */
1474 if (sal
.end
< func_end
)
1480 /* To skip prologues, I use this predicate. Returns either PC itself
1481 if the code at PC does not look like a function prologue; otherwise
1482 returns an address that (if we're lucky) follows the prologue. If
1483 LENIENT, then we must skip everything which is involved in setting
1484 up the frame (it's OK to skip more, just so long as we don't skip
1485 anything which might clobber the registers which are being saved.
1486 Currently we must not skip more on the alpha, but we might the lenient
1490 hppa_skip_prologue (CORE_ADDR pc
)
1494 CORE_ADDR post_prologue_pc
;
1497 /* See if we can determine the end of the prologue via the symbol table.
1498 If so, then return either PC, or the PC after the prologue, whichever
1501 post_prologue_pc
= after_prologue (pc
);
1503 /* If after_prologue returned a useful address, then use it. Else
1504 fall back on the instruction skipping code.
1506 Some folks have claimed this causes problems because the breakpoint
1507 may be the first instruction of the prologue. If that happens, then
1508 the instruction skipping code has a bug that needs to be fixed. */
1509 if (post_prologue_pc
!= 0)
1510 return max (pc
, post_prologue_pc
);
1512 return (skip_prologue_hard_way (pc
));
1515 struct hppa_frame_cache
1518 struct trad_frame_saved_reg
*saved_regs
;
1521 static struct hppa_frame_cache
*
1522 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1524 struct hppa_frame_cache
*cache
;
1529 struct unwind_table_entry
*u
;
1530 CORE_ADDR prologue_end
;
1534 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1535 frame_relative_level(next_frame
));
1537 if ((*this_cache
) != NULL
)
1540 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1541 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1542 return (*this_cache
);
1544 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1545 (*this_cache
) = cache
;
1546 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1549 u
= find_unwind_entry (frame_func_unwind (next_frame
));
1553 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1554 return (*this_cache
);
1557 /* Turn the Entry_GR field into a bitmask. */
1559 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1561 /* Frame pointer gets saved into a special location. */
1562 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1565 saved_gr_mask
|= (1 << i
);
1568 /* Turn the Entry_FR field into a bitmask too. */
1570 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1571 saved_fr_mask
|= (1 << i
);
1573 /* Loop until we find everything of interest or hit a branch.
1575 For unoptimized GCC code and for any HP CC code this will never ever
1576 examine any user instructions.
1578 For optimized GCC code we're faced with problems. GCC will schedule
1579 its prologue and make prologue instructions available for delay slot
1580 filling. The end result is user code gets mixed in with the prologue
1581 and a prologue instruction may be in the delay slot of the first branch
1584 Some unexpected things are expected with debugging optimized code, so
1585 we allow this routine to walk past user instructions in optimized
1588 int final_iteration
= 0;
1589 CORE_ADDR pc
, end_pc
;
1590 int looking_for_sp
= u
->Save_SP
;
1591 int looking_for_rp
= u
->Save_RP
;
1594 /* We have to use hppa_skip_prologue instead of just
1595 skip_prologue_using_sal, in case we stepped into a function without
1596 symbol information. hppa_skip_prologue also bounds the returned
1597 pc by the passed in pc, so it will not return a pc in the next
1599 prologue_end
= hppa_skip_prologue (frame_func_unwind (next_frame
));
1600 end_pc
= frame_pc_unwind (next_frame
);
1602 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1603 end_pc
= prologue_end
;
1607 for (pc
= frame_func_unwind (next_frame
);
1608 ((saved_gr_mask
|| saved_fr_mask
1609 || looking_for_sp
|| looking_for_rp
1610 || frame_size
< (u
->Total_frame_size
<< 3))
1616 long status
= read_memory_nobpt (pc
, buf4
, sizeof buf4
);
1617 long inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1619 /* Note the interesting effects of this instruction. */
1620 frame_size
+= prologue_inst_adjust_sp (inst
);
1622 /* There are limited ways to store the return pointer into the
1624 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1627 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1629 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1632 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1635 /* Check to see if we saved SP into the stack. This also
1636 happens to indicate the location of the saved frame
1638 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1639 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1642 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1645 /* Account for general and floating-point register saves. */
1646 reg
= inst_saves_gr (inst
);
1647 if (reg
>= 3 && reg
<= 18
1648 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1650 saved_gr_mask
&= ~(1 << reg
);
1651 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1652 /* stwm with a positive displacement is a _post_
1654 cache
->saved_regs
[reg
].addr
= 0;
1655 else if ((inst
& 0xfc00000c) == 0x70000008)
1656 /* A std has explicit post_modify forms. */
1657 cache
->saved_regs
[reg
].addr
= 0;
1662 if ((inst
>> 26) == 0x1c)
1663 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1664 else if ((inst
>> 26) == 0x03)
1665 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1667 offset
= hppa_extract_14 (inst
);
1669 /* Handle code with and without frame pointers. */
1671 cache
->saved_regs
[reg
].addr
= offset
;
1673 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1677 /* GCC handles callee saved FP regs a little differently.
1679 It emits an instruction to put the value of the start of
1680 the FP store area into %r1. It then uses fstds,ma with a
1681 basereg of %r1 for the stores.
1683 HP CC emits them at the current stack pointer modifying the
1684 stack pointer as it stores each register. */
1686 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1687 if ((inst
& 0xffffc000) == 0x34610000
1688 || (inst
& 0xffffc000) == 0x37c10000)
1689 fp_loc
= hppa_extract_14 (inst
);
1691 reg
= inst_saves_fr (inst
);
1692 if (reg
>= 12 && reg
<= 21)
1694 /* Note +4 braindamage below is necessary because the FP
1695 status registers are internally 8 registers rather than
1696 the expected 4 registers. */
1697 saved_fr_mask
&= ~(1 << reg
);
1700 /* 1st HP CC FP register store. After this
1701 instruction we've set enough state that the GCC and
1702 HPCC code are both handled in the same manner. */
1703 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
1708 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1713 /* Quit if we hit any kind of branch the previous iteration. */
1714 if (final_iteration
)
1716 /* We want to look precisely one instruction beyond the branch
1717 if we have not found everything yet. */
1718 if (is_branch (inst
))
1719 final_iteration
= 1;
1724 /* The frame base always represents the value of %sp at entry to
1725 the current function (and is thus equivalent to the "saved"
1727 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1731 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1732 "prologue_end=0x%s) ",
1734 paddr_nz (frame_pc_unwind (next_frame
)),
1735 paddr_nz (prologue_end
));
1737 /* Check to see if a frame pointer is available, and use it for
1738 frame unwinding if it is.
1740 There are some situations where we need to rely on the frame
1741 pointer to do stack unwinding. For example, if a function calls
1742 alloca (), the stack pointer can get adjusted inside the body of
1743 the function. In this case, the ABI requires that the compiler
1744 maintain a frame pointer for the function.
1746 The unwind record has a flag (alloca_frame) that indicates that
1747 a function has a variable frame; unfortunately, gcc/binutils
1748 does not set this flag. Instead, whenever a frame pointer is used
1749 and saved on the stack, the Save_SP flag is set. We use this to
1750 decide whether to use the frame pointer for unwinding.
1752 fp should never be zero here; checking just in case.
1754 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1755 instead of Save_SP. */
1757 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
1759 if (frame_pc_unwind (next_frame
) >= prologue_end
1760 && u
->Save_SP
&& fp
!= 0)
1765 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer] }",
1766 paddr_nz (cache
->base
));
1768 else if (frame_pc_unwind (next_frame
) >= prologue_end
)
1770 if (u
->Save_SP
&& trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1772 /* Both we're expecting the SP to be saved and the SP has been
1773 saved. The entry SP value is saved at this frame's SP
1775 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1778 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved] }",
1779 paddr_nz (cache
->base
));
1783 /* The prologue has been slowly allocating stack space. Adjust
1785 cache
->base
= this_sp
- frame_size
;
1787 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust] } ",
1788 paddr_nz (cache
->base
));
1794 /* This frame has not yet been created. */
1795 cache
->base
= this_sp
;
1798 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [before prologue] } ",
1799 paddr_nz (cache
->base
));
1803 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1806 /* The PC is found in the "return register", "Millicode" uses "r31"
1807 as the return register while normal code uses "rp". */
1810 if (trad_frame_addr_p (cache
->saved_regs
, 31))
1811 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1814 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
1815 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
1820 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1821 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1824 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1825 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1830 /* Convert all the offsets into addresses. */
1832 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1834 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1835 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1840 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1841 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1842 return (*this_cache
);
1846 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1847 struct frame_id
*this_id
)
1849 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1850 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
1854 hppa_frame_prev_register (struct frame_info
*next_frame
,
1856 int regnum
, int *optimizedp
,
1857 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1858 int *realnump
, void *valuep
)
1860 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1861 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
1862 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1865 static const struct frame_unwind hppa_frame_unwind
=
1869 hppa_frame_prev_register
1872 static const struct frame_unwind
*
1873 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
1875 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1877 if (find_unwind_entry (pc
))
1878 return &hppa_frame_unwind
;
1883 /* This is a generic fallback frame unwinder that kicks in if we fail all
1884 the other ones. Normally we would expect the stub and regular unwinder
1885 to work, but in some cases we might hit a function that just doesn't
1886 have any unwind information available. In this case we try to do
1887 unwinding solely based on code reading. This is obviously going to be
1888 slow, so only use this as a last resort. Currently this will only
1889 identify the stack and pc for the frame. */
1891 static struct hppa_frame_cache
*
1892 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1894 struct hppa_frame_cache
*cache
;
1895 CORE_ADDR pc
, start_pc
, end_pc
, cur_pc
;
1897 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1898 (*this_cache
) = cache
;
1899 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1901 pc
= frame_func_unwind (next_frame
);
1902 cur_pc
= frame_pc_unwind (next_frame
);
1904 find_pc_partial_function (pc
, NULL
, &start_pc
, &end_pc
);
1906 if (start_pc
== 0 || end_pc
== 0)
1908 error ("Cannot find bounds of current function (@0x%s), unwinding will "
1909 "fail.", paddr_nz (pc
));
1913 if (end_pc
> cur_pc
)
1916 for (pc
= start_pc
; pc
< end_pc
; pc
+= 4)
1920 insn
= read_memory_unsigned_integer (pc
, 4);
1922 /* There are limited ways to store the return pointer into the
1924 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1926 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1929 else if (insn
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1931 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1936 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1938 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1940 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
1941 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1945 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1946 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1953 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1954 struct frame_id
*this_id
)
1956 struct hppa_frame_cache
*info
=
1957 hppa_fallback_frame_cache (next_frame
, this_cache
);
1958 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
1962 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
1964 int regnum
, int *optimizedp
,
1965 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1966 int *realnump
, void *valuep
)
1968 struct hppa_frame_cache
*info
=
1969 hppa_fallback_frame_cache (next_frame
, this_cache
);
1970 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
1971 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1974 static const struct frame_unwind hppa_fallback_frame_unwind
=
1977 hppa_fallback_frame_this_id
,
1978 hppa_fallback_frame_prev_register
1981 static const struct frame_unwind
*
1982 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
1984 return &hppa_fallback_frame_unwind
;
1988 hppa_frame_base_address (struct frame_info
*next_frame
,
1991 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
,
1996 static const struct frame_base hppa_frame_base
= {
1998 hppa_frame_base_address
,
1999 hppa_frame_base_address
,
2000 hppa_frame_base_address
2003 static const struct frame_base
*
2004 hppa_frame_base_sniffer (struct frame_info
*next_frame
)
2006 return &hppa_frame_base
;
2009 /* Stub frames, used for all kinds of call stubs. */
2010 struct hppa_stub_unwind_cache
2013 struct trad_frame_saved_reg
*saved_regs
;
2016 static struct hppa_stub_unwind_cache
*
2017 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2020 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2021 struct hppa_stub_unwind_cache
*info
;
2022 struct unwind_table_entry
*u
;
2027 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2029 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2031 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2033 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2035 /* HPUX uses export stubs in function calls; the export stub clobbers
2036 the return value of the caller, and, later restores it from the
2038 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2040 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2042 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2048 /* By default we assume that stubs do not change the rp. */
2049 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2055 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2056 void **this_prologue_cache
,
2057 struct frame_id
*this_id
)
2059 struct hppa_stub_unwind_cache
*info
2060 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2061 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
2065 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2066 void **this_prologue_cache
,
2067 int regnum
, int *optimizedp
,
2068 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2069 int *realnump
, void *valuep
)
2071 struct hppa_stub_unwind_cache
*info
2072 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2073 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2074 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2077 static const struct frame_unwind hppa_stub_frame_unwind
= {
2079 hppa_stub_frame_this_id
,
2080 hppa_stub_frame_prev_register
2083 static const struct frame_unwind
*
2084 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2086 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2088 if (IN_SOLIB_CALL_TRAMPOLINE (pc
, NULL
)
2089 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2090 return &hppa_stub_frame_unwind
;
2094 static struct frame_id
2095 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2097 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2099 frame_pc_unwind (next_frame
));
2103 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2105 return frame_unwind_register_signed (next_frame
, HPPA_PCOQ_HEAD_REGNUM
) & ~3;
2108 /* Instead of this nasty cast, add a method pvoid() that prints out a
2109 host VOID data type (remember %p isn't portable). */
2112 hppa_pointer_to_address_hack (void *ptr
)
2114 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2115 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2119 unwind_command (char *exp
, int from_tty
)
2122 struct unwind_table_entry
*u
;
2124 /* If we have an expression, evaluate it and use it as the address. */
2126 if (exp
!= 0 && *exp
!= 0)
2127 address
= parse_and_eval_address (exp
);
2131 u
= find_unwind_entry (address
);
2135 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2139 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2140 paddr_nz (hppa_pointer_to_address_hack (u
)));
2142 printf_unfiltered ("\tregion_start = ");
2143 print_address (u
->region_start
, gdb_stdout
);
2145 printf_unfiltered ("\n\tregion_end = ");
2146 print_address (u
->region_end
, gdb_stdout
);
2148 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2150 printf_unfiltered ("\n\tflags =");
2151 pif (Cannot_unwind
);
2153 pif (Millicode_save_sr0
);
2156 pif (Variable_Frame
);
2157 pif (Separate_Package_Body
);
2158 pif (Frame_Extension_Millicode
);
2159 pif (Stack_Overflow_Check
);
2160 pif (Two_Instruction_SP_Increment
);
2164 pif (Save_MRP_in_frame
);
2165 pif (extn_ptr_defined
);
2166 pif (Cleanup_defined
);
2167 pif (MPE_XL_interrupt_marker
);
2168 pif (HP_UX_interrupt_marker
);
2171 putchar_unfiltered ('\n');
2173 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2175 pin (Region_description
);
2178 pin (Total_frame_size
);
2182 hppa_skip_permanent_breakpoint (void)
2184 /* To step over a breakpoint instruction on the PA takes some
2185 fiddling with the instruction address queue.
2187 When we stop at a breakpoint, the IA queue front (the instruction
2188 we're executing now) points at the breakpoint instruction, and
2189 the IA queue back (the next instruction to execute) points to
2190 whatever instruction we would execute after the breakpoint, if it
2191 were an ordinary instruction. This is the case even if the
2192 breakpoint is in the delay slot of a branch instruction.
2194 Clearly, to step past the breakpoint, we need to set the queue
2195 front to the back. But what do we put in the back? What
2196 instruction comes after that one? Because of the branch delay
2197 slot, the next insn is always at the back + 4. */
2198 write_register (HPPA_PCOQ_HEAD_REGNUM
, read_register (HPPA_PCOQ_TAIL_REGNUM
));
2199 write_register (HPPA_PCSQ_HEAD_REGNUM
, read_register (HPPA_PCSQ_TAIL_REGNUM
));
2201 write_register (HPPA_PCOQ_TAIL_REGNUM
, read_register (HPPA_PCOQ_TAIL_REGNUM
) + 4);
2202 /* We can leave the tail's space the same, since there's no jump. */
2206 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2208 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2210 An example of this occurs when an a.out is linked against a foo.sl.
2211 The foo.sl defines a global bar(), and the a.out declares a signature
2212 for bar(). However, the a.out doesn't directly call bar(), but passes
2213 its address in another call.
2215 If you have this scenario and attempt to "break bar" before running,
2216 gdb will find a minimal symbol for bar() in the a.out. But that
2217 symbol's address will be negative. What this appears to denote is
2218 an index backwards from the base of the procedure linkage table (PLT)
2219 into the data linkage table (DLT), the end of which is contiguous
2220 with the start of the PLT. This is clearly not a valid address for
2221 us to set a breakpoint on.
2223 Note that one must be careful in how one checks for a negative address.
2224 0xc0000000 is a legitimate address of something in a shared text
2225 segment, for example. Since I don't know what the possible range
2226 is of these "really, truly negative" addresses that come from the
2227 minimal symbols, I'm resorting to the gross hack of checking the
2228 top byte of the address for all 1's. Sigh. */
2230 return (!target_has_stack
&& (pc
& 0xFF000000));
2234 hppa_instruction_nullified (void)
2236 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
2237 avoid the type cast. I'm leaving it as is for now as I'm doing
2238 semi-mechanical multiarching-related changes. */
2239 const int ipsw
= (int) read_register (HPPA_IPSW_REGNUM
);
2240 const int flags
= (int) read_register (HPPA_FLAGS_REGNUM
);
2242 return ((ipsw
& 0x00200000) && !(flags
& 0x2));
2245 /* Return the GDB type object for the "standard" data type of data
2248 static struct type
*
2249 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2251 if (reg_nr
< HPPA_FP4_REGNUM
)
2252 return builtin_type_uint32
;
2254 return builtin_type_ieee_single_big
;
2257 /* Return the GDB type object for the "standard" data type of data
2258 in register N. hppa64 version. */
2260 static struct type
*
2261 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2263 if (reg_nr
< HPPA_FP4_REGNUM
)
2264 return builtin_type_uint64
;
2266 return builtin_type_ieee_double_big
;
2269 /* Return True if REGNUM is not a register available to the user
2270 through ptrace(). */
2273 hppa_cannot_store_register (int regnum
)
2276 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2277 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2278 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2283 hppa_smash_text_address (CORE_ADDR addr
)
2285 /* The low two bits of the PC on the PA contain the privilege level.
2286 Some genius implementing a (non-GCC) compiler apparently decided
2287 this means that "addresses" in a text section therefore include a
2288 privilege level, and thus symbol tables should contain these bits.
2289 This seems like a bonehead thing to do--anyway, it seems to work
2290 for our purposes to just ignore those bits. */
2292 return (addr
&= ~0x3);
2295 /* Get the ith function argument for the current function. */
2297 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2301 get_frame_register (frame
, HPPA_R0_REGNUM
+ 26 - argi
, &addr
);
2306 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2307 int regnum
, void *buf
)
2311 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2312 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2314 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2318 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2319 struct trad_frame_saved_reg saved_regs
[],
2320 int regnum
, int *optimizedp
,
2321 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2322 int *realnump
, void *valuep
)
2324 int pcoqt
= (regnum
== HPPA_PCOQ_TAIL_REGNUM
);
2325 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2326 int regsize
= register_size (gdbarch
, HPPA_PCOQ_HEAD_REGNUM
);
2329 regnum
= HPPA_PCOQ_HEAD_REGNUM
;
2331 trad_frame_prev_register (next_frame
, saved_regs
, regnum
,
2332 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2335 store_unsigned_integer (valuep
, regsize
,
2336 extract_unsigned_integer (valuep
, regsize
) + 4);
2339 /* Here is a table of C type sizes on hppa with various compiles
2340 and options. I measured this on PA 9000/800 with HP-UX 11.11
2341 and these compilers:
2343 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2344 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2345 /opt/aCC/bin/aCC B3910B A.03.45
2346 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2348 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2349 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2350 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2351 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2352 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2353 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2354 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2355 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2359 compiler and options
2360 char, short, int, long, long long
2361 float, double, long double
2364 So all these compilers use either ILP32 or LP64 model.
2365 TODO: gcc has more options so it needs more investigation.
2367 For floating point types, see:
2369 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2370 HP-UX floating-point guide, hpux 11.00
2372 -- chastain 2003-12-18 */
2374 static struct gdbarch
*
2375 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2377 struct gdbarch_tdep
*tdep
;
2378 struct gdbarch
*gdbarch
;
2380 /* Try to determine the ABI of the object we are loading. */
2381 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2383 /* If it's a SOM file, assume it's HP/UX SOM. */
2384 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2385 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2388 /* find a candidate among the list of pre-declared architectures. */
2389 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2391 return (arches
->gdbarch
);
2393 /* If none found, then allocate and initialize one. */
2394 tdep
= XZALLOC (struct gdbarch_tdep
);
2395 gdbarch
= gdbarch_alloc (&info
, tdep
);
2397 /* Determine from the bfd_arch_info structure if we are dealing with
2398 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2399 then default to a 32bit machine. */
2400 if (info
.bfd_arch_info
!= NULL
)
2401 tdep
->bytes_per_address
=
2402 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2404 tdep
->bytes_per_address
= 4;
2406 /* Some parts of the gdbarch vector depend on whether we are running
2407 on a 32 bits or 64 bits target. */
2408 switch (tdep
->bytes_per_address
)
2411 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2412 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2413 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2416 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2417 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2418 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2421 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2422 tdep
->bytes_per_address
);
2425 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2426 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2428 /* The following gdbarch vector elements are the same in both ILP32
2429 and LP64, but might show differences some day. */
2430 set_gdbarch_long_long_bit (gdbarch
, 64);
2431 set_gdbarch_long_double_bit (gdbarch
, 128);
2432 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2434 /* The following gdbarch vector elements do not depend on the address
2435 size, or in any other gdbarch element previously set. */
2436 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2437 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2438 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2439 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2440 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2441 set_gdbarch_cannot_fetch_register (gdbarch
, hppa_cannot_store_register
);
2442 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2443 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2444 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2445 set_gdbarch_read_pc (gdbarch
, hppa_target_read_pc
);
2446 set_gdbarch_write_pc (gdbarch
, hppa_target_write_pc
);
2448 /* Helper for function argument information. */
2449 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2451 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2453 /* When a hardware watchpoint triggers, we'll move the inferior past
2454 it by removing all eventpoints; stepping past the instruction
2455 that caused the trigger; reinserting eventpoints; and checking
2456 whether any watched location changed. */
2457 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2459 /* Inferior function call methods. */
2460 switch (tdep
->bytes_per_address
)
2463 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2464 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2467 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2468 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2471 internal_error (__FILE__
, __LINE__
, "bad switch");
2474 /* Struct return methods. */
2475 switch (tdep
->bytes_per_address
)
2478 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2481 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2484 internal_error (__FILE__
, __LINE__
, "bad switch");
2487 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2488 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2490 /* Frame unwind methods. */
2491 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2492 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2494 /* Hook in ABI-specific overrides, if they have been registered. */
2495 gdbarch_init_osabi (info
, gdbarch
);
2497 /* Hook in the default unwinders. */
2498 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2499 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2500 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
2501 frame_base_append_sniffer (gdbarch
, hppa_frame_base_sniffer
);
2507 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2509 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2511 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2512 tdep
->bytes_per_address
);
2513 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2517 _initialize_hppa_tdep (void)
2519 struct cmd_list_element
*c
;
2520 void break_at_finish_command (char *arg
, int from_tty
);
2521 void tbreak_at_finish_command (char *arg
, int from_tty
);
2522 void break_at_finish_at_depth_command (char *arg
, int from_tty
);
2524 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2526 hppa_objfile_priv_data
= register_objfile_data ();
2528 add_cmd ("unwind", class_maintenance
, unwind_command
,
2529 "Print unwind table entry at given address.",
2530 &maintenanceprintlist
);
2532 deprecate_cmd (add_com ("xbreak", class_breakpoint
,
2533 break_at_finish_command
,
2534 concat ("Set breakpoint at procedure exit. \n\
2535 Argument may be function name, or \"*\" and an address.\n\
2536 If function is specified, break at end of code for that function.\n\
2537 If an address is specified, break at the end of the function that contains \n\
2538 that exact address.\n",
2539 "With no arg, uses current execution address of selected stack frame.\n\
2540 This is useful for breaking on return to a stack frame.\n\
2542 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2544 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
)), NULL
);
2545 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint
, 1), NULL
);
2546 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint
, 1), NULL
);
2547 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint
, 1), NULL
);
2548 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1), NULL
);
2550 deprecate_cmd (c
= add_com ("txbreak", class_breakpoint
,
2551 tbreak_at_finish_command
,
2552 "Set temporary breakpoint at procedure exit. Either there should\n\
2553 be no argument or the argument must be a depth.\n"), NULL
);
2554 set_cmd_completer (c
, location_completer
);
2557 deprecate_cmd (add_com ("bx", class_breakpoint
,
2558 break_at_finish_at_depth_command
,
2559 "Set breakpoint at procedure exit. Either there should\n\
2560 be no argument or the argument must be a depth.\n"), NULL
);
2562 /* Debug this files internals. */
2563 add_show_from_set (add_set_cmd ("hppa", class_maintenance
, var_zinteger
,
2564 &hppa_debug
, "Set hppa debugging.\n\
2565 When non-zero, hppa specific debugging is enabled.", &setdebuglist
), &showdebuglist
);