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 /* Sizes (in bytes) of the native unwind entries. */
68 #define UNWIND_ENTRY_SIZE 16
69 #define STUB_UNWIND_ENTRY_SIZE 8
71 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
72 following functions static, once we hppa is partially multiarched. */
73 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
74 int hppa_instruction_nullified (void);
76 /* Handle 32/64-bit struct return conventions. */
78 static enum return_value_convention
79 hppa32_return_value (struct gdbarch
*gdbarch
,
80 struct type
*type
, struct regcache
*regcache
,
81 void *readbuf
, const void *writebuf
)
83 if (TYPE_LENGTH (type
) <= 2 * 4)
85 /* The value always lives in the right hand end of the register
86 (or register pair)? */
88 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
89 int part
= TYPE_LENGTH (type
) % 4;
90 /* The left hand register contains only part of the value,
91 transfer that first so that the rest can be xfered as entire
96 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
99 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
103 /* Now transfer the remaining register values. */
104 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
107 regcache_cooked_read (regcache
, reg
, (char *) readbuf
+ b
);
108 if (writebuf
!= NULL
)
109 regcache_cooked_write (regcache
, reg
, (const char *) writebuf
+ b
);
112 return RETURN_VALUE_REGISTER_CONVENTION
;
115 return RETURN_VALUE_STRUCT_CONVENTION
;
118 static enum return_value_convention
119 hppa64_return_value (struct gdbarch
*gdbarch
,
120 struct type
*type
, struct regcache
*regcache
,
121 void *readbuf
, const void *writebuf
)
123 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
124 are in r28, padded on the left. Aggregates less that 65 bits are
125 in r28, right padded. Aggregates upto 128 bits are in r28 and
126 r29, right padded. */
127 if (TYPE_CODE (type
) == TYPE_CODE_FLT
128 && TYPE_LENGTH (type
) <= 8)
130 /* Floats are right aligned? */
131 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
133 regcache_cooked_read_part (regcache
, HPPA_FP4_REGNUM
, offset
,
134 TYPE_LENGTH (type
), readbuf
);
135 if (writebuf
!= NULL
)
136 regcache_cooked_write_part (regcache
, HPPA_FP4_REGNUM
, offset
,
137 TYPE_LENGTH (type
), writebuf
);
138 return RETURN_VALUE_REGISTER_CONVENTION
;
140 else if (TYPE_LENGTH (type
) <= 8 && is_integral_type (type
))
142 /* Integrals are right aligned. */
143 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
145 regcache_cooked_read_part (regcache
, 28, offset
,
146 TYPE_LENGTH (type
), readbuf
);
147 if (writebuf
!= NULL
)
148 regcache_cooked_write_part (regcache
, 28, offset
,
149 TYPE_LENGTH (type
), writebuf
);
150 return RETURN_VALUE_REGISTER_CONVENTION
;
152 else if (TYPE_LENGTH (type
) <= 2 * 8)
154 /* Composite values are left aligned. */
156 for (b
= 0; b
< TYPE_LENGTH (type
); b
+= 8)
158 int part
= min (8, TYPE_LENGTH (type
) - b
);
160 regcache_cooked_read_part (regcache
, 28 + b
/ 8, 0, part
,
161 (char *) readbuf
+ b
);
162 if (writebuf
!= NULL
)
163 regcache_cooked_write_part (regcache
, 28 + b
/ 8, 0, part
,
164 (const char *) writebuf
+ b
);
166 return RETURN_VALUE_REGISTER_CONVENTION
;
169 return RETURN_VALUE_STRUCT_CONVENTION
;
172 /* Routines to extract various sized constants out of hppa
175 /* This assumes that no garbage lies outside of the lower bits of
179 hppa_sign_extend (unsigned val
, unsigned bits
)
181 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
184 /* For many immediate values the sign bit is the low bit! */
187 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
189 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
192 /* Extract the bits at positions between FROM and TO, using HP's numbering
196 hppa_get_field (unsigned word
, int from
, int to
)
198 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
201 /* extract the immediate field from a ld{bhw}s instruction */
204 hppa_extract_5_load (unsigned word
)
206 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
209 /* extract the immediate field from a break instruction */
212 hppa_extract_5r_store (unsigned word
)
214 return (word
& MASK_5
);
217 /* extract the immediate field from a {sr}sm instruction */
220 hppa_extract_5R_store (unsigned word
)
222 return (word
>> 16 & MASK_5
);
225 /* extract a 14 bit immediate field */
228 hppa_extract_14 (unsigned word
)
230 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
233 /* extract a 21 bit constant */
236 hppa_extract_21 (unsigned word
)
242 val
= hppa_get_field (word
, 20, 20);
244 val
|= hppa_get_field (word
, 9, 19);
246 val
|= hppa_get_field (word
, 5, 6);
248 val
|= hppa_get_field (word
, 0, 4);
250 val
|= hppa_get_field (word
, 7, 8);
251 return hppa_sign_extend (val
, 21) << 11;
254 /* extract a 17 bit constant from branch instructions, returning the
255 19 bit signed value. */
258 hppa_extract_17 (unsigned word
)
260 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
261 hppa_get_field (word
, 29, 29) << 10 |
262 hppa_get_field (word
, 11, 15) << 11 |
263 (word
& 0x1) << 16, 17) << 2;
267 /* Compare the start address for two unwind entries returning 1 if
268 the first address is larger than the second, -1 if the second is
269 larger than the first, and zero if they are equal. */
272 compare_unwind_entries (const void *arg1
, const void *arg2
)
274 const struct unwind_table_entry
*a
= arg1
;
275 const struct unwind_table_entry
*b
= arg2
;
277 if (a
->region_start
> b
->region_start
)
279 else if (a
->region_start
< b
->region_start
)
286 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
288 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
289 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
291 bfd_vma value
= section
->vma
- section
->filepos
;
292 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
294 if (value
< *low_text_segment_address
)
295 *low_text_segment_address
= value
;
300 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
301 asection
*section
, unsigned int entries
, unsigned int size
,
302 CORE_ADDR text_offset
)
304 /* We will read the unwind entries into temporary memory, then
305 fill in the actual unwind table. */
311 char *buf
= alloca (size
);
312 CORE_ADDR low_text_segment_address
;
314 /* For ELF targets, then unwinds are supposed to
315 be segment relative offsets instead of absolute addresses.
317 Note that when loading a shared library (text_offset != 0) the
318 unwinds are already relative to the text_offset that will be
320 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
322 low_text_segment_address
= -1;
324 bfd_map_over_sections (objfile
->obfd
,
325 record_text_segment_lowaddr
,
326 &low_text_segment_address
);
328 text_offset
= low_text_segment_address
;
331 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
333 /* Now internalize the information being careful to handle host/target
335 for (i
= 0; i
< entries
; i
++)
337 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
339 table
[i
].region_start
+= text_offset
;
341 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
342 table
[i
].region_end
+= text_offset
;
344 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
346 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
347 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
348 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
349 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
350 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
351 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
352 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
353 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
354 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
355 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
356 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
357 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
358 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
359 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
360 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
361 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
362 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
363 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
364 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
365 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
366 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
367 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
368 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
369 table
[i
].Cleanup_defined
= tmp
& 0x1;
370 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
372 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
373 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
374 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
375 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
376 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
377 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
379 /* Stub unwinds are handled elsewhere. */
380 table
[i
].stub_unwind
.stub_type
= 0;
381 table
[i
].stub_unwind
.padding
= 0;
386 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
387 the object file. This info is used mainly by find_unwind_entry() to find
388 out the stack frame size and frame pointer used by procedures. We put
389 everything on the psymbol obstack in the objfile so that it automatically
390 gets freed when the objfile is destroyed. */
393 read_unwind_info (struct objfile
*objfile
)
395 asection
*unwind_sec
, *stub_unwind_sec
;
396 unsigned unwind_size
, stub_unwind_size
, total_size
;
397 unsigned index
, unwind_entries
;
398 unsigned stub_entries
, total_entries
;
399 CORE_ADDR text_offset
;
400 struct hppa_unwind_info
*ui
;
401 struct hppa_objfile_private
*obj_private
;
403 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
404 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
405 sizeof (struct hppa_unwind_info
));
411 /* For reasons unknown the HP PA64 tools generate multiple unwinder
412 sections in a single executable. So we just iterate over every
413 section in the BFD looking for unwinder sections intead of trying
414 to do a lookup with bfd_get_section_by_name.
416 First determine the total size of the unwind tables so that we
417 can allocate memory in a nice big hunk. */
419 for (unwind_sec
= objfile
->obfd
->sections
;
421 unwind_sec
= unwind_sec
->next
)
423 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
424 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
426 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
427 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
429 total_entries
+= unwind_entries
;
433 /* Now compute the size of the stub unwinds. Note the ELF tools do not
434 use stub unwinds at the curren time. */
435 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
439 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
440 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
444 stub_unwind_size
= 0;
448 /* Compute total number of unwind entries and their total size. */
449 total_entries
+= stub_entries
;
450 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
452 /* Allocate memory for the unwind table. */
453 ui
->table
= (struct unwind_table_entry
*)
454 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
455 ui
->last
= total_entries
- 1;
457 /* Now read in each unwind section and internalize the standard unwind
460 for (unwind_sec
= objfile
->obfd
->sections
;
462 unwind_sec
= unwind_sec
->next
)
464 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
465 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
467 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
468 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
470 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
471 unwind_entries
, unwind_size
, text_offset
);
472 index
+= unwind_entries
;
476 /* Now read in and internalize the stub unwind entries. */
477 if (stub_unwind_size
> 0)
480 char *buf
= alloca (stub_unwind_size
);
482 /* Read in the stub unwind entries. */
483 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
484 0, stub_unwind_size
);
486 /* Now convert them into regular unwind entries. */
487 for (i
= 0; i
< stub_entries
; i
++, index
++)
489 /* Clear out the next unwind entry. */
490 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
492 /* Convert offset & size into region_start and region_end.
493 Stuff away the stub type into "reserved" fields. */
494 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
496 ui
->table
[index
].region_start
+= text_offset
;
498 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
501 ui
->table
[index
].region_end
502 = ui
->table
[index
].region_start
+ 4 *
503 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
509 /* Unwind table needs to be kept sorted. */
510 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
511 compare_unwind_entries
);
513 /* Keep a pointer to the unwind information. */
514 obj_private
= (struct hppa_objfile_private
*)
515 objfile_data (objfile
, hppa_objfile_priv_data
);
516 if (obj_private
== NULL
)
518 obj_private
= (struct hppa_objfile_private
*)
519 obstack_alloc (&objfile
->objfile_obstack
,
520 sizeof (struct hppa_objfile_private
));
521 set_objfile_data (objfile
, hppa_objfile_priv_data
, obj_private
);
522 obj_private
->unwind_info
= NULL
;
523 obj_private
->so_info
= NULL
;
526 obj_private
->unwind_info
= ui
;
529 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
530 of the objfiles seeking the unwind table entry for this PC. Each objfile
531 contains a sorted list of struct unwind_table_entry. Since we do a binary
532 search of the unwind tables, we depend upon them to be sorted. */
534 struct unwind_table_entry
*
535 find_unwind_entry (CORE_ADDR pc
)
537 int first
, middle
, last
;
538 struct objfile
*objfile
;
539 struct hppa_objfile_private
*priv
;
542 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
545 /* A function at address 0? Not in HP-UX! */
546 if (pc
== (CORE_ADDR
) 0)
549 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
553 ALL_OBJFILES (objfile
)
555 struct hppa_unwind_info
*ui
;
557 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
559 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
563 read_unwind_info (objfile
);
564 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
566 error ("Internal error reading unwind information.");
567 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
570 /* First, check the cache */
573 && pc
>= ui
->cache
->region_start
574 && pc
<= ui
->cache
->region_end
)
577 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
578 paddr_nz ((CORE_ADDR
) ui
->cache
));
582 /* Not in the cache, do a binary search */
587 while (first
<= last
)
589 middle
= (first
+ last
) / 2;
590 if (pc
>= ui
->table
[middle
].region_start
591 && pc
<= ui
->table
[middle
].region_end
)
593 ui
->cache
= &ui
->table
[middle
];
595 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
596 paddr_nz ((CORE_ADDR
) ui
->cache
));
597 return &ui
->table
[middle
];
600 if (pc
< ui
->table
[middle
].region_start
)
605 } /* ALL_OBJFILES() */
608 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
613 static const unsigned char *
614 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
616 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
617 (*len
) = sizeof (breakpoint
);
621 /* Return the name of a register. */
624 hppa32_register_name (int i
)
626 static char *names
[] = {
627 "flags", "r1", "rp", "r3",
628 "r4", "r5", "r6", "r7",
629 "r8", "r9", "r10", "r11",
630 "r12", "r13", "r14", "r15",
631 "r16", "r17", "r18", "r19",
632 "r20", "r21", "r22", "r23",
633 "r24", "r25", "r26", "dp",
634 "ret0", "ret1", "sp", "r31",
635 "sar", "pcoqh", "pcsqh", "pcoqt",
636 "pcsqt", "eiem", "iir", "isr",
637 "ior", "ipsw", "goto", "sr4",
638 "sr0", "sr1", "sr2", "sr3",
639 "sr5", "sr6", "sr7", "cr0",
640 "cr8", "cr9", "ccr", "cr12",
641 "cr13", "cr24", "cr25", "cr26",
642 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
643 "fpsr", "fpe1", "fpe2", "fpe3",
644 "fpe4", "fpe5", "fpe6", "fpe7",
645 "fr4", "fr4R", "fr5", "fr5R",
646 "fr6", "fr6R", "fr7", "fr7R",
647 "fr8", "fr8R", "fr9", "fr9R",
648 "fr10", "fr10R", "fr11", "fr11R",
649 "fr12", "fr12R", "fr13", "fr13R",
650 "fr14", "fr14R", "fr15", "fr15R",
651 "fr16", "fr16R", "fr17", "fr17R",
652 "fr18", "fr18R", "fr19", "fr19R",
653 "fr20", "fr20R", "fr21", "fr21R",
654 "fr22", "fr22R", "fr23", "fr23R",
655 "fr24", "fr24R", "fr25", "fr25R",
656 "fr26", "fr26R", "fr27", "fr27R",
657 "fr28", "fr28R", "fr29", "fr29R",
658 "fr30", "fr30R", "fr31", "fr31R"
660 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
667 hppa64_register_name (int i
)
669 static char *names
[] = {
670 "flags", "r1", "rp", "r3",
671 "r4", "r5", "r6", "r7",
672 "r8", "r9", "r10", "r11",
673 "r12", "r13", "r14", "r15",
674 "r16", "r17", "r18", "r19",
675 "r20", "r21", "r22", "r23",
676 "r24", "r25", "r26", "dp",
677 "ret0", "ret1", "sp", "r31",
678 "sar", "pcoqh", "pcsqh", "pcoqt",
679 "pcsqt", "eiem", "iir", "isr",
680 "ior", "ipsw", "goto", "sr4",
681 "sr0", "sr1", "sr2", "sr3",
682 "sr5", "sr6", "sr7", "cr0",
683 "cr8", "cr9", "ccr", "cr12",
684 "cr13", "cr24", "cr25", "cr26",
685 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
686 "fpsr", "fpe1", "fpe2", "fpe3",
687 "fr4", "fr5", "fr6", "fr7",
688 "fr8", "fr9", "fr10", "fr11",
689 "fr12", "fr13", "fr14", "fr15",
690 "fr16", "fr17", "fr18", "fr19",
691 "fr20", "fr21", "fr22", "fr23",
692 "fr24", "fr25", "fr26", "fr27",
693 "fr28", "fr29", "fr30", "fr31"
695 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
701 /* This function pushes a stack frame with arguments as part of the
702 inferior function calling mechanism.
704 This is the version of the function for the 32-bit PA machines, in
705 which later arguments appear at lower addresses. (The stack always
706 grows towards higher addresses.)
708 We simply allocate the appropriate amount of stack space and put
709 arguments into their proper slots. */
712 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
713 struct regcache
*regcache
, CORE_ADDR bp_addr
,
714 int nargs
, struct value
**args
, CORE_ADDR sp
,
715 int struct_return
, CORE_ADDR struct_addr
)
717 /* Stack base address at which any pass-by-reference parameters are
719 CORE_ADDR struct_end
= 0;
720 /* Stack base address at which the first parameter is stored. */
721 CORE_ADDR param_end
= 0;
723 /* The inner most end of the stack after all the parameters have
725 CORE_ADDR new_sp
= 0;
727 /* Two passes. First pass computes the location of everything,
728 second pass writes the bytes out. */
731 /* Global pointer (r19) of the function we are trying to call. */
734 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
736 for (write_pass
= 0; write_pass
< 2; write_pass
++)
738 CORE_ADDR struct_ptr
= 0;
739 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
740 struct_ptr is adjusted for each argument below, so the first
741 argument will end up at sp-36. */
742 CORE_ADDR param_ptr
= 32;
744 int small_struct
= 0;
746 for (i
= 0; i
< nargs
; i
++)
748 struct value
*arg
= args
[i
];
749 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
750 /* The corresponding parameter that is pushed onto the
751 stack, and [possibly] passed in a register. */
754 memset (param_val
, 0, sizeof param_val
);
755 if (TYPE_LENGTH (type
) > 8)
757 /* Large parameter, pass by reference. Store the value
758 in "struct" area and then pass its address. */
760 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
762 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
764 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
766 else if (TYPE_CODE (type
) == TYPE_CODE_INT
767 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
769 /* Integer value store, right aligned. "unpack_long"
770 takes care of any sign-extension problems. */
771 param_len
= align_up (TYPE_LENGTH (type
), 4);
772 store_unsigned_integer (param_val
, param_len
,
774 VALUE_CONTENTS (arg
)));
776 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
778 /* Floating point value store, right aligned. */
779 param_len
= align_up (TYPE_LENGTH (type
), 4);
780 memcpy (param_val
, VALUE_CONTENTS (arg
), param_len
);
784 param_len
= align_up (TYPE_LENGTH (type
), 4);
786 /* Small struct value are stored right-aligned. */
787 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
788 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
790 /* Structures of size 5, 6 and 7 bytes are special in that
791 the higher-ordered word is stored in the lower-ordered
792 argument, and even though it is a 8-byte quantity the
793 registers need not be 8-byte aligned. */
794 if (param_len
> 4 && param_len
< 8)
798 param_ptr
+= param_len
;
799 if (param_len
== 8 && !small_struct
)
800 param_ptr
= align_up (param_ptr
, 8);
802 /* First 4 non-FP arguments are passed in gr26-gr23.
803 First 4 32-bit FP arguments are passed in fr4L-fr7L.
804 First 2 64-bit FP arguments are passed in fr5 and fr7.
806 The rest go on the stack, starting at sp-36, towards lower
807 addresses. 8-byte arguments must be aligned to a 8-byte
811 write_memory (param_end
- param_ptr
, param_val
, param_len
);
813 /* There are some cases when we don't know the type
814 expected by the callee (e.g. for variadic functions), so
815 pass the parameters in both general and fp regs. */
818 int grreg
= 26 - (param_ptr
- 36) / 4;
819 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
820 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
822 regcache_cooked_write (regcache
, grreg
, param_val
);
823 regcache_cooked_write (regcache
, fpLreg
, param_val
);
827 regcache_cooked_write (regcache
, grreg
+ 1,
830 regcache_cooked_write (regcache
, fpreg
, param_val
);
831 regcache_cooked_write (regcache
, fpreg
+ 1,
838 /* Update the various stack pointers. */
841 struct_end
= sp
+ align_up (struct_ptr
, 64);
842 /* PARAM_PTR already accounts for all the arguments passed
843 by the user. However, the ABI mandates minimum stack
844 space allocations for outgoing arguments. The ABI also
845 mandates minimum stack alignments which we must
847 param_end
= struct_end
+ align_up (param_ptr
, 64);
851 /* If a structure has to be returned, set up register 28 to hold its
854 write_register (28, struct_addr
);
856 gp
= tdep
->find_global_pointer (function
);
859 write_register (19, gp
);
861 /* Set the return address. */
862 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
864 /* Update the Stack Pointer. */
865 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
870 /* This function pushes a stack frame with arguments as part of the
871 inferior function calling mechanism.
873 This is the version for the PA64, in which later arguments appear
874 at higher addresses. (The stack always grows towards higher
877 We simply allocate the appropriate amount of stack space and put
878 arguments into their proper slots.
880 This ABI also requires that the caller provide an argument pointer
881 to the callee, so we do that too. */
884 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
885 struct regcache
*regcache
, CORE_ADDR bp_addr
,
886 int nargs
, struct value
**args
, CORE_ADDR sp
,
887 int struct_return
, CORE_ADDR struct_addr
)
889 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
890 reverse engineering testsuite failures. */
892 /* Stack base address at which any pass-by-reference parameters are
894 CORE_ADDR struct_end
= 0;
895 /* Stack base address at which the first parameter is stored. */
896 CORE_ADDR param_end
= 0;
898 /* The inner most end of the stack after all the parameters have
900 CORE_ADDR new_sp
= 0;
902 /* Two passes. First pass computes the location of everything,
903 second pass writes the bytes out. */
905 for (write_pass
= 0; write_pass
< 2; write_pass
++)
907 CORE_ADDR struct_ptr
= 0;
908 CORE_ADDR param_ptr
= 0;
910 for (i
= 0; i
< nargs
; i
++)
912 struct value
*arg
= args
[i
];
913 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
914 if ((TYPE_CODE (type
) == TYPE_CODE_INT
915 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
916 && TYPE_LENGTH (type
) <= 8)
918 /* Integer value store, right aligned. "unpack_long"
919 takes care of any sign-extension problems. */
923 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
924 int reg
= 27 - param_ptr
/ 8;
925 write_memory_unsigned_integer (param_end
- param_ptr
,
928 regcache_cooked_write_unsigned (regcache
, reg
, val
);
933 /* Small struct value, store left aligned? */
935 if (TYPE_LENGTH (type
) > 8)
937 param_ptr
= align_up (param_ptr
, 16);
938 reg
= 26 - param_ptr
/ 8;
939 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
943 param_ptr
= align_up (param_ptr
, 8);
944 reg
= 26 - param_ptr
/ 8;
945 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
950 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
952 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
956 int len
= min (8, TYPE_LENGTH (type
) - byte
);
957 regcache_cooked_write_part (regcache
, reg
, 0, len
,
958 VALUE_CONTENTS (arg
) + byte
);
965 /* Update the various stack pointers. */
968 struct_end
= sp
+ struct_ptr
;
969 /* PARAM_PTR already accounts for all the arguments passed
970 by the user. However, the ABI mandates minimum stack
971 space allocations for outgoing arguments. The ABI also
972 mandates minimum stack alignments which we must
974 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
978 /* If a structure has to be returned, set up register 28 to hold its
981 write_register (28, struct_addr
);
983 /* Set the return address. */
984 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
986 /* Update the Stack Pointer. */
987 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
+ 64);
989 /* The stack will have 32 bytes of additional space for a frame marker. */
990 return param_end
+ 64;
994 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
996 struct target_ops
*targ
)
1003 target_read_memory(plabel
, (char *)&addr
, 4);
1010 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1012 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1014 return align_up (addr
, 64);
1017 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1020 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1022 /* Just always 16-byte align. */
1023 return align_up (addr
, 16);
1027 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1031 hppa_target_read_pc (ptid_t ptid
)
1033 int flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1035 /* The following test does not belong here. It is OS-specific, and belongs
1037 /* Test SS_INSYSCALL */
1039 return read_register_pid (31, ptid
) & ~0x3;
1041 return read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
) & ~0x3;
1044 /* Write out the PC. If currently in a syscall, then also write the new
1045 PC value into %r31. */
1048 hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
1050 int flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1052 /* The following test does not belong here. It is OS-specific, and belongs
1054 /* If in a syscall, then set %r31. Also make sure to get the
1055 privilege bits set correctly. */
1056 /* Test SS_INSYSCALL */
1058 write_register_pid (31, v
| 0x3, ptid
);
1060 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, v
, ptid
);
1061 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, v
+ 4, ptid
);
1064 /* return the alignment of a type in bytes. Structures have the maximum
1065 alignment required by their fields. */
1068 hppa_alignof (struct type
*type
)
1070 int max_align
, align
, i
;
1071 CHECK_TYPEDEF (type
);
1072 switch (TYPE_CODE (type
))
1077 return TYPE_LENGTH (type
);
1078 case TYPE_CODE_ARRAY
:
1079 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1080 case TYPE_CODE_STRUCT
:
1081 case TYPE_CODE_UNION
:
1083 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1085 /* Bit fields have no real alignment. */
1086 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1087 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1089 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1090 max_align
= max (max_align
, align
);
1099 /* For the given instruction (INST), return any adjustment it makes
1100 to the stack pointer or zero for no adjustment.
1102 This only handles instructions commonly found in prologues. */
1105 prologue_inst_adjust_sp (unsigned long inst
)
1107 /* This must persist across calls. */
1108 static int save_high21
;
1110 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1111 if ((inst
& 0xffffc000) == 0x37de0000)
1112 return hppa_extract_14 (inst
);
1115 if ((inst
& 0xffe00000) == 0x6fc00000)
1116 return hppa_extract_14 (inst
);
1118 /* std,ma X,D(sp) */
1119 if ((inst
& 0xffe00008) == 0x73c00008)
1120 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1122 /* addil high21,%r1; ldo low11,(%r1),%r30)
1123 save high bits in save_high21 for later use. */
1124 if ((inst
& 0xffe00000) == 0x28200000)
1126 save_high21
= hppa_extract_21 (inst
);
1130 if ((inst
& 0xffff0000) == 0x343e0000)
1131 return save_high21
+ hppa_extract_14 (inst
);
1133 /* fstws as used by the HP compilers. */
1134 if ((inst
& 0xffffffe0) == 0x2fd01220)
1135 return hppa_extract_5_load (inst
);
1137 /* No adjustment. */
1141 /* Return nonzero if INST is a branch of some kind, else return zero. */
1144 is_branch (unsigned long inst
)
1173 /* Return the register number for a GR which is saved by INST or
1174 zero it INST does not save a GR. */
1177 inst_saves_gr (unsigned long inst
)
1179 /* Does it look like a stw? */
1180 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1181 || (inst
>> 26) == 0x1f
1182 || ((inst
>> 26) == 0x1f
1183 && ((inst
>> 6) == 0xa)))
1184 return hppa_extract_5R_store (inst
);
1186 /* Does it look like a std? */
1187 if ((inst
>> 26) == 0x1c
1188 || ((inst
>> 26) == 0x03
1189 && ((inst
>> 6) & 0xf) == 0xb))
1190 return hppa_extract_5R_store (inst
);
1192 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1193 if ((inst
>> 26) == 0x1b)
1194 return hppa_extract_5R_store (inst
);
1196 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1198 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1199 || ((inst
>> 26) == 0x3
1200 && (((inst
>> 6) & 0xf) == 0x8
1201 || (inst
>> 6) & 0xf) == 0x9))
1202 return hppa_extract_5R_store (inst
);
1207 /* Return the register number for a FR which is saved by INST or
1208 zero it INST does not save a FR.
1210 Note we only care about full 64bit register stores (that's the only
1211 kind of stores the prologue will use).
1213 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1216 inst_saves_fr (unsigned long inst
)
1218 /* is this an FSTD ? */
1219 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1220 return hppa_extract_5r_store (inst
);
1221 if ((inst
& 0xfc000002) == 0x70000002)
1222 return hppa_extract_5R_store (inst
);
1223 /* is this an FSTW ? */
1224 if ((inst
& 0xfc00df80) == 0x24001200)
1225 return hppa_extract_5r_store (inst
);
1226 if ((inst
& 0xfc000002) == 0x7c000000)
1227 return hppa_extract_5R_store (inst
);
1231 /* Advance PC across any function entry prologue instructions
1232 to reach some "real" code.
1234 Use information in the unwind table to determine what exactly should
1235 be in the prologue. */
1239 skip_prologue_hard_way (CORE_ADDR pc
)
1242 CORE_ADDR orig_pc
= pc
;
1243 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1244 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1245 struct unwind_table_entry
*u
;
1251 u
= find_unwind_entry (pc
);
1255 /* If we are not at the beginning of a function, then return now. */
1256 if ((pc
& ~0x3) != u
->region_start
)
1259 /* This is how much of a frame adjustment we need to account for. */
1260 stack_remaining
= u
->Total_frame_size
<< 3;
1262 /* Magic register saves we want to know about. */
1263 save_rp
= u
->Save_RP
;
1264 save_sp
= u
->Save_SP
;
1266 /* An indication that args may be stored into the stack. Unfortunately
1267 the HPUX compilers tend to set this in cases where no args were
1271 /* Turn the Entry_GR field into a bitmask. */
1273 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1275 /* Frame pointer gets saved into a special location. */
1276 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1279 save_gr
|= (1 << i
);
1281 save_gr
&= ~restart_gr
;
1283 /* Turn the Entry_FR field into a bitmask too. */
1285 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1286 save_fr
|= (1 << i
);
1287 save_fr
&= ~restart_fr
;
1289 /* Loop until we find everything of interest or hit a branch.
1291 For unoptimized GCC code and for any HP CC code this will never ever
1292 examine any user instructions.
1294 For optimzied GCC code we're faced with problems. GCC will schedule
1295 its prologue and make prologue instructions available for delay slot
1296 filling. The end result is user code gets mixed in with the prologue
1297 and a prologue instruction may be in the delay slot of the first branch
1300 Some unexpected things are expected with debugging optimized code, so
1301 we allow this routine to walk past user instructions in optimized
1303 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1306 unsigned int reg_num
;
1307 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1308 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1310 /* Save copies of all the triggers so we can compare them later
1312 old_save_gr
= save_gr
;
1313 old_save_fr
= save_fr
;
1314 old_save_rp
= save_rp
;
1315 old_save_sp
= save_sp
;
1316 old_stack_remaining
= stack_remaining
;
1318 status
= read_memory_nobpt (pc
, buf
, 4);
1319 inst
= extract_unsigned_integer (buf
, 4);
1325 /* Note the interesting effects of this instruction. */
1326 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1328 /* There are limited ways to store the return pointer into the
1330 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1333 /* These are the only ways we save SP into the stack. At this time
1334 the HP compilers never bother to save SP into the stack. */
1335 if ((inst
& 0xffffc000) == 0x6fc10000
1336 || (inst
& 0xffffc00c) == 0x73c10008)
1339 /* Are we loading some register with an offset from the argument
1341 if ((inst
& 0xffe00000) == 0x37a00000
1342 || (inst
& 0xffffffe0) == 0x081d0240)
1348 /* Account for general and floating-point register saves. */
1349 reg_num
= inst_saves_gr (inst
);
1350 save_gr
&= ~(1 << reg_num
);
1352 /* Ugh. Also account for argument stores into the stack.
1353 Unfortunately args_stored only tells us that some arguments
1354 where stored into the stack. Not how many or what kind!
1356 This is a kludge as on the HP compiler sets this bit and it
1357 never does prologue scheduling. So once we see one, skip past
1358 all of them. We have similar code for the fp arg stores below.
1360 FIXME. Can still die if we have a mix of GR and FR argument
1362 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1364 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1367 status
= read_memory_nobpt (pc
, buf
, 4);
1368 inst
= extract_unsigned_integer (buf
, 4);
1371 reg_num
= inst_saves_gr (inst
);
1377 reg_num
= inst_saves_fr (inst
);
1378 save_fr
&= ~(1 << reg_num
);
1380 status
= read_memory_nobpt (pc
+ 4, buf
, 4);
1381 next_inst
= extract_unsigned_integer (buf
, 4);
1387 /* We've got to be read to handle the ldo before the fp register
1389 if ((inst
& 0xfc000000) == 0x34000000
1390 && inst_saves_fr (next_inst
) >= 4
1391 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1393 /* So we drop into the code below in a reasonable state. */
1394 reg_num
= inst_saves_fr (next_inst
);
1398 /* Ugh. Also account for argument stores into the stack.
1399 This is a kludge as on the HP compiler sets this bit and it
1400 never does prologue scheduling. So once we see one, skip past
1402 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1404 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1407 status
= read_memory_nobpt (pc
, buf
, 4);
1408 inst
= extract_unsigned_integer (buf
, 4);
1411 if ((inst
& 0xfc000000) != 0x34000000)
1413 status
= read_memory_nobpt (pc
+ 4, buf
, 4);
1414 next_inst
= extract_unsigned_integer (buf
, 4);
1417 reg_num
= inst_saves_fr (next_inst
);
1423 /* Quit if we hit any kind of branch. This can happen if a prologue
1424 instruction is in the delay slot of the first call/branch. */
1425 if (is_branch (inst
))
1428 /* What a crock. The HP compilers set args_stored even if no
1429 arguments were stored into the stack (boo hiss). This could
1430 cause this code to then skip a bunch of user insns (up to the
1433 To combat this we try to identify when args_stored was bogusly
1434 set and clear it. We only do this when args_stored is nonzero,
1435 all other resources are accounted for, and nothing changed on
1438 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1439 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1440 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1441 && old_stack_remaining
== stack_remaining
)
1448 /* We've got a tenative location for the end of the prologue. However
1449 because of limitations in the unwind descriptor mechanism we may
1450 have went too far into user code looking for the save of a register
1451 that does not exist. So, if there registers we expected to be saved
1452 but never were, mask them out and restart.
1454 This should only happen in optimized code, and should be very rare. */
1455 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1458 restart_gr
= save_gr
;
1459 restart_fr
= save_fr
;
1467 /* Return the address of the PC after the last prologue instruction if
1468 we can determine it from the debug symbols. Else return zero. */
1471 after_prologue (CORE_ADDR pc
)
1473 struct symtab_and_line sal
;
1474 CORE_ADDR func_addr
, func_end
;
1477 /* If we can not find the symbol in the partial symbol table, then
1478 there is no hope we can determine the function's start address
1480 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1483 /* Get the line associated with FUNC_ADDR. */
1484 sal
= find_pc_line (func_addr
, 0);
1486 /* There are only two cases to consider. First, the end of the source line
1487 is within the function bounds. In that case we return the end of the
1488 source line. Second is the end of the source line extends beyond the
1489 bounds of the current function. We need to use the slow code to
1490 examine instructions in that case.
1492 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1493 the wrong thing to do. In fact, it should be entirely possible for this
1494 function to always return zero since the slow instruction scanning code
1495 is supposed to *always* work. If it does not, then it is a bug. */
1496 if (sal
.end
< func_end
)
1502 /* To skip prologues, I use this predicate. Returns either PC itself
1503 if the code at PC does not look like a function prologue; otherwise
1504 returns an address that (if we're lucky) follows the prologue. If
1505 LENIENT, then we must skip everything which is involved in setting
1506 up the frame (it's OK to skip more, just so long as we don't skip
1507 anything which might clobber the registers which are being saved.
1508 Currently we must not skip more on the alpha, but we might the lenient
1512 hppa_skip_prologue (CORE_ADDR pc
)
1516 CORE_ADDR post_prologue_pc
;
1519 /* See if we can determine the end of the prologue via the symbol table.
1520 If so, then return either PC, or the PC after the prologue, whichever
1523 post_prologue_pc
= after_prologue (pc
);
1525 /* If after_prologue returned a useful address, then use it. Else
1526 fall back on the instruction skipping code.
1528 Some folks have claimed this causes problems because the breakpoint
1529 may be the first instruction of the prologue. If that happens, then
1530 the instruction skipping code has a bug that needs to be fixed. */
1531 if (post_prologue_pc
!= 0)
1532 return max (pc
, post_prologue_pc
);
1534 return (skip_prologue_hard_way (pc
));
1537 struct hppa_frame_cache
1540 struct trad_frame_saved_reg
*saved_regs
;
1543 static struct hppa_frame_cache
*
1544 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1546 struct hppa_frame_cache
*cache
;
1551 struct unwind_table_entry
*u
;
1552 CORE_ADDR prologue_end
;
1556 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1557 frame_relative_level(next_frame
));
1559 if ((*this_cache
) != NULL
)
1562 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1563 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1564 return (*this_cache
);
1566 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1567 (*this_cache
) = cache
;
1568 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1571 u
= find_unwind_entry (frame_func_unwind (next_frame
));
1575 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1576 return (*this_cache
);
1579 /* Turn the Entry_GR field into a bitmask. */
1581 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1583 /* Frame pointer gets saved into a special location. */
1584 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1587 saved_gr_mask
|= (1 << i
);
1590 /* Turn the Entry_FR field into a bitmask too. */
1592 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1593 saved_fr_mask
|= (1 << i
);
1595 /* Loop until we find everything of interest or hit a branch.
1597 For unoptimized GCC code and for any HP CC code this will never ever
1598 examine any user instructions.
1600 For optimized GCC code we're faced with problems. GCC will schedule
1601 its prologue and make prologue instructions available for delay slot
1602 filling. The end result is user code gets mixed in with the prologue
1603 and a prologue instruction may be in the delay slot of the first branch
1606 Some unexpected things are expected with debugging optimized code, so
1607 we allow this routine to walk past user instructions in optimized
1610 int final_iteration
= 0;
1611 CORE_ADDR pc
, end_pc
;
1612 int looking_for_sp
= u
->Save_SP
;
1613 int looking_for_rp
= u
->Save_RP
;
1616 /* We have to use hppa_skip_prologue instead of just
1617 skip_prologue_using_sal, in case we stepped into a function without
1618 symbol information. hppa_skip_prologue also bounds the returned
1619 pc by the passed in pc, so it will not return a pc in the next
1621 prologue_end
= hppa_skip_prologue (frame_func_unwind (next_frame
));
1622 end_pc
= frame_pc_unwind (next_frame
);
1624 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1625 end_pc
= prologue_end
;
1629 for (pc
= frame_func_unwind (next_frame
);
1630 ((saved_gr_mask
|| saved_fr_mask
1631 || looking_for_sp
|| looking_for_rp
1632 || frame_size
< (u
->Total_frame_size
<< 3))
1638 long status
= read_memory_nobpt (pc
, buf4
, sizeof buf4
);
1639 long inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1641 /* Note the interesting effects of this instruction. */
1642 frame_size
+= prologue_inst_adjust_sp (inst
);
1644 /* There are limited ways to store the return pointer into the
1646 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1649 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1651 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1654 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1657 /* Check to see if we saved SP into the stack. This also
1658 happens to indicate the location of the saved frame
1660 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1661 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1664 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1667 /* Account for general and floating-point register saves. */
1668 reg
= inst_saves_gr (inst
);
1669 if (reg
>= 3 && reg
<= 18
1670 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1672 saved_gr_mask
&= ~(1 << reg
);
1673 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1674 /* stwm with a positive displacement is a _post_
1676 cache
->saved_regs
[reg
].addr
= 0;
1677 else if ((inst
& 0xfc00000c) == 0x70000008)
1678 /* A std has explicit post_modify forms. */
1679 cache
->saved_regs
[reg
].addr
= 0;
1684 if ((inst
>> 26) == 0x1c)
1685 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1686 else if ((inst
>> 26) == 0x03)
1687 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1689 offset
= hppa_extract_14 (inst
);
1691 /* Handle code with and without frame pointers. */
1693 cache
->saved_regs
[reg
].addr
= offset
;
1695 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1699 /* GCC handles callee saved FP regs a little differently.
1701 It emits an instruction to put the value of the start of
1702 the FP store area into %r1. It then uses fstds,ma with a
1703 basereg of %r1 for the stores.
1705 HP CC emits them at the current stack pointer modifying the
1706 stack pointer as it stores each register. */
1708 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1709 if ((inst
& 0xffffc000) == 0x34610000
1710 || (inst
& 0xffffc000) == 0x37c10000)
1711 fp_loc
= hppa_extract_14 (inst
);
1713 reg
= inst_saves_fr (inst
);
1714 if (reg
>= 12 && reg
<= 21)
1716 /* Note +4 braindamage below is necessary because the FP
1717 status registers are internally 8 registers rather than
1718 the expected 4 registers. */
1719 saved_fr_mask
&= ~(1 << reg
);
1722 /* 1st HP CC FP register store. After this
1723 instruction we've set enough state that the GCC and
1724 HPCC code are both handled in the same manner. */
1725 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
1730 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1735 /* Quit if we hit any kind of branch the previous iteration. */
1736 if (final_iteration
)
1738 /* We want to look precisely one instruction beyond the branch
1739 if we have not found everything yet. */
1740 if (is_branch (inst
))
1741 final_iteration
= 1;
1746 /* The frame base always represents the value of %sp at entry to
1747 the current function (and is thus equivalent to the "saved"
1749 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1753 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1754 "prologue_end=0x%s) ",
1756 paddr_nz (frame_pc_unwind (next_frame
)),
1757 paddr_nz (prologue_end
));
1759 /* Check to see if a frame pointer is available, and use it for
1760 frame unwinding if it is.
1762 There are some situations where we need to rely on the frame
1763 pointer to do stack unwinding. For example, if a function calls
1764 alloca (), the stack pointer can get adjusted inside the body of
1765 the function. In this case, the ABI requires that the compiler
1766 maintain a frame pointer for the function.
1768 The unwind record has a flag (alloca_frame) that indicates that
1769 a function has a variable frame; unfortunately, gcc/binutils
1770 does not set this flag. Instead, whenever a frame pointer is used
1771 and saved on the stack, the Save_SP flag is set. We use this to
1772 decide whether to use the frame pointer for unwinding.
1774 fp should never be zero here; checking just in case.
1776 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1777 instead of Save_SP. */
1779 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
1781 if (frame_pc_unwind (next_frame
) >= prologue_end
1782 && u
->Save_SP
&& fp
!= 0)
1787 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer] }",
1788 paddr_nz (cache
->base
));
1790 else if (frame_pc_unwind (next_frame
) >= prologue_end
)
1792 if (u
->Save_SP
&& trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1794 /* Both we're expecting the SP to be saved and the SP has been
1795 saved. The entry SP value is saved at this frame's SP
1797 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1800 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved] }",
1801 paddr_nz (cache
->base
));
1805 /* The prologue has been slowly allocating stack space. Adjust
1807 cache
->base
= this_sp
- frame_size
;
1809 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust] } ",
1810 paddr_nz (cache
->base
));
1816 /* This frame has not yet been created. */
1817 cache
->base
= this_sp
;
1820 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [before prologue] } ",
1821 paddr_nz (cache
->base
));
1825 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1828 /* The PC is found in the "return register", "Millicode" uses "r31"
1829 as the return register while normal code uses "rp". */
1832 if (trad_frame_addr_p (cache
->saved_regs
, 31))
1833 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1836 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
1837 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
1842 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1843 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1846 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1847 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1852 /* Convert all the offsets into addresses. */
1854 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1856 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1857 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1862 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1863 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1864 return (*this_cache
);
1868 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1869 struct frame_id
*this_id
)
1871 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1872 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
1876 hppa_frame_prev_register (struct frame_info
*next_frame
,
1878 int regnum
, int *optimizedp
,
1879 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1880 int *realnump
, void *valuep
)
1882 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1883 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
1884 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1887 static const struct frame_unwind hppa_frame_unwind
=
1891 hppa_frame_prev_register
1894 static const struct frame_unwind
*
1895 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
1897 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1899 if (find_unwind_entry (pc
))
1900 return &hppa_frame_unwind
;
1905 /* This is a generic fallback frame unwinder that kicks in if we fail all
1906 the other ones. Normally we would expect the stub and regular unwinder
1907 to work, but in some cases we might hit a function that just doesn't
1908 have any unwind information available. In this case we try to do
1909 unwinding solely based on code reading. This is obviously going to be
1910 slow, so only use this as a last resort. Currently this will only
1911 identify the stack and pc for the frame. */
1913 static struct hppa_frame_cache
*
1914 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1916 struct hppa_frame_cache
*cache
;
1917 unsigned int frame_size
;
1918 CORE_ADDR pc
, start_pc
, end_pc
, cur_pc
;
1920 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1921 (*this_cache
) = cache
;
1922 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1924 pc
= frame_func_unwind (next_frame
);
1925 cur_pc
= frame_pc_unwind (next_frame
);
1928 find_pc_partial_function (pc
, NULL
, &start_pc
, &end_pc
);
1930 if (start_pc
== 0 || end_pc
== 0)
1932 error ("Cannot find bounds of current function (@0x%s), unwinding will "
1933 "fail.", paddr_nz (pc
));
1937 if (end_pc
> cur_pc
)
1940 for (pc
= start_pc
; pc
< end_pc
; pc
+= 4)
1944 insn
= read_memory_unsigned_integer (pc
, 4);
1946 frame_size
+= prologue_inst_adjust_sp (insn
);
1948 /* There are limited ways to store the return pointer into the
1950 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1951 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1952 else if (insn
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1953 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1956 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
) - frame_size
;
1957 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1959 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1961 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
1962 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1966 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1967 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1974 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1975 struct frame_id
*this_id
)
1977 struct hppa_frame_cache
*info
=
1978 hppa_fallback_frame_cache (next_frame
, this_cache
);
1979 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
1983 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
1985 int regnum
, int *optimizedp
,
1986 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1987 int *realnump
, void *valuep
)
1989 struct hppa_frame_cache
*info
=
1990 hppa_fallback_frame_cache (next_frame
, this_cache
);
1991 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
1992 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1995 static const struct frame_unwind hppa_fallback_frame_unwind
=
1998 hppa_fallback_frame_this_id
,
1999 hppa_fallback_frame_prev_register
2002 static const struct frame_unwind
*
2003 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2005 return &hppa_fallback_frame_unwind
;
2009 hppa_frame_base_address (struct frame_info
*next_frame
,
2012 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
,
2017 static const struct frame_base hppa_frame_base
= {
2019 hppa_frame_base_address
,
2020 hppa_frame_base_address
,
2021 hppa_frame_base_address
2024 static const struct frame_base
*
2025 hppa_frame_base_sniffer (struct frame_info
*next_frame
)
2027 return &hppa_frame_base
;
2030 /* Stub frames, used for all kinds of call stubs. */
2031 struct hppa_stub_unwind_cache
2034 struct trad_frame_saved_reg
*saved_regs
;
2037 static struct hppa_stub_unwind_cache
*
2038 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2041 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2042 struct hppa_stub_unwind_cache
*info
;
2043 struct unwind_table_entry
*u
;
2048 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2050 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2052 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2054 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2056 /* HPUX uses export stubs in function calls; the export stub clobbers
2057 the return value of the caller, and, later restores it from the
2059 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2061 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2063 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2069 /* By default we assume that stubs do not change the rp. */
2070 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2076 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2077 void **this_prologue_cache
,
2078 struct frame_id
*this_id
)
2080 struct hppa_stub_unwind_cache
*info
2081 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2082 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
2086 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2087 void **this_prologue_cache
,
2088 int regnum
, int *optimizedp
,
2089 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2090 int *realnump
, void *valuep
)
2092 struct hppa_stub_unwind_cache
*info
2093 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2094 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2095 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2098 static const struct frame_unwind hppa_stub_frame_unwind
= {
2100 hppa_stub_frame_this_id
,
2101 hppa_stub_frame_prev_register
2104 static const struct frame_unwind
*
2105 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2107 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2110 || IN_SOLIB_CALL_TRAMPOLINE (pc
, NULL
)
2111 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2112 return &hppa_stub_frame_unwind
;
2116 static struct frame_id
2117 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2119 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2121 frame_pc_unwind (next_frame
));
2125 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2127 return frame_unwind_register_signed (next_frame
, HPPA_PCOQ_HEAD_REGNUM
) & ~3;
2130 /* Instead of this nasty cast, add a method pvoid() that prints out a
2131 host VOID data type (remember %p isn't portable). */
2134 hppa_pointer_to_address_hack (void *ptr
)
2136 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2137 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2141 unwind_command (char *exp
, int from_tty
)
2144 struct unwind_table_entry
*u
;
2146 /* If we have an expression, evaluate it and use it as the address. */
2148 if (exp
!= 0 && *exp
!= 0)
2149 address
= parse_and_eval_address (exp
);
2153 u
= find_unwind_entry (address
);
2157 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2161 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2162 paddr_nz (hppa_pointer_to_address_hack (u
)));
2164 printf_unfiltered ("\tregion_start = ");
2165 print_address (u
->region_start
, gdb_stdout
);
2167 printf_unfiltered ("\n\tregion_end = ");
2168 print_address (u
->region_end
, gdb_stdout
);
2170 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2172 printf_unfiltered ("\n\tflags =");
2173 pif (Cannot_unwind
);
2175 pif (Millicode_save_sr0
);
2178 pif (Variable_Frame
);
2179 pif (Separate_Package_Body
);
2180 pif (Frame_Extension_Millicode
);
2181 pif (Stack_Overflow_Check
);
2182 pif (Two_Instruction_SP_Increment
);
2186 pif (Save_MRP_in_frame
);
2187 pif (extn_ptr_defined
);
2188 pif (Cleanup_defined
);
2189 pif (MPE_XL_interrupt_marker
);
2190 pif (HP_UX_interrupt_marker
);
2193 putchar_unfiltered ('\n');
2195 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2197 pin (Region_description
);
2200 pin (Total_frame_size
);
2204 hppa_skip_permanent_breakpoint (void)
2206 /* To step over a breakpoint instruction on the PA takes some
2207 fiddling with the instruction address queue.
2209 When we stop at a breakpoint, the IA queue front (the instruction
2210 we're executing now) points at the breakpoint instruction, and
2211 the IA queue back (the next instruction to execute) points to
2212 whatever instruction we would execute after the breakpoint, if it
2213 were an ordinary instruction. This is the case even if the
2214 breakpoint is in the delay slot of a branch instruction.
2216 Clearly, to step past the breakpoint, we need to set the queue
2217 front to the back. But what do we put in the back? What
2218 instruction comes after that one? Because of the branch delay
2219 slot, the next insn is always at the back + 4. */
2220 write_register (HPPA_PCOQ_HEAD_REGNUM
, read_register (HPPA_PCOQ_TAIL_REGNUM
));
2221 write_register (HPPA_PCSQ_HEAD_REGNUM
, read_register (HPPA_PCSQ_TAIL_REGNUM
));
2223 write_register (HPPA_PCOQ_TAIL_REGNUM
, read_register (HPPA_PCOQ_TAIL_REGNUM
) + 4);
2224 /* We can leave the tail's space the same, since there's no jump. */
2228 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2230 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2232 An example of this occurs when an a.out is linked against a foo.sl.
2233 The foo.sl defines a global bar(), and the a.out declares a signature
2234 for bar(). However, the a.out doesn't directly call bar(), but passes
2235 its address in another call.
2237 If you have this scenario and attempt to "break bar" before running,
2238 gdb will find a minimal symbol for bar() in the a.out. But that
2239 symbol's address will be negative. What this appears to denote is
2240 an index backwards from the base of the procedure linkage table (PLT)
2241 into the data linkage table (DLT), the end of which is contiguous
2242 with the start of the PLT. This is clearly not a valid address for
2243 us to set a breakpoint on.
2245 Note that one must be careful in how one checks for a negative address.
2246 0xc0000000 is a legitimate address of something in a shared text
2247 segment, for example. Since I don't know what the possible range
2248 is of these "really, truly negative" addresses that come from the
2249 minimal symbols, I'm resorting to the gross hack of checking the
2250 top byte of the address for all 1's. Sigh. */
2252 return (!target_has_stack
&& (pc
& 0xFF000000));
2256 hppa_instruction_nullified (void)
2258 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
2259 avoid the type cast. I'm leaving it as is for now as I'm doing
2260 semi-mechanical multiarching-related changes. */
2261 const int ipsw
= (int) read_register (HPPA_IPSW_REGNUM
);
2262 const int flags
= (int) read_register (HPPA_FLAGS_REGNUM
);
2264 return ((ipsw
& 0x00200000) && !(flags
& 0x2));
2267 /* Return the GDB type object for the "standard" data type of data
2270 static struct type
*
2271 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2273 if (reg_nr
< HPPA_FP4_REGNUM
)
2274 return builtin_type_uint32
;
2276 return builtin_type_ieee_single_big
;
2279 /* Return the GDB type object for the "standard" data type of data
2280 in register N. hppa64 version. */
2282 static struct type
*
2283 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2285 if (reg_nr
< HPPA_FP4_REGNUM
)
2286 return builtin_type_uint64
;
2288 return builtin_type_ieee_double_big
;
2291 /* Return True if REGNUM is not a register available to the user
2292 through ptrace(). */
2295 hppa_cannot_store_register (int regnum
)
2298 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2299 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2300 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2305 hppa_smash_text_address (CORE_ADDR addr
)
2307 /* The low two bits of the PC on the PA contain the privilege level.
2308 Some genius implementing a (non-GCC) compiler apparently decided
2309 this means that "addresses" in a text section therefore include a
2310 privilege level, and thus symbol tables should contain these bits.
2311 This seems like a bonehead thing to do--anyway, it seems to work
2312 for our purposes to just ignore those bits. */
2314 return (addr
&= ~0x3);
2317 /* Get the ith function argument for the current function. */
2319 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2323 get_frame_register (frame
, HPPA_R0_REGNUM
+ 26 - argi
, &addr
);
2328 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2329 int regnum
, void *buf
)
2333 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2334 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2336 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2340 hppa_find_global_pointer (struct value
*function
)
2346 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2347 struct trad_frame_saved_reg saved_regs
[],
2348 int regnum
, int *optimizedp
,
2349 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2350 int *realnump
, void *valuep
)
2352 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2358 trad_frame_prev_register (next_frame
, saved_regs
,
2359 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2360 lvalp
, addrp
, realnump
, valuep
);
2362 pc
= extract_unsigned_integer (valuep
, 4);
2363 store_unsigned_integer (valuep
, 4, pc
+ 4);
2366 /* It's a computed value. */
2374 trad_frame_prev_register (next_frame
, saved_regs
, regnum
,
2375 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2379 /* Here is a table of C type sizes on hppa with various compiles
2380 and options. I measured this on PA 9000/800 with HP-UX 11.11
2381 and these compilers:
2383 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2384 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2385 /opt/aCC/bin/aCC B3910B A.03.45
2386 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2388 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2389 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2390 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2391 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2392 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2393 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2394 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2395 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2399 compiler and options
2400 char, short, int, long, long long
2401 float, double, long double
2404 So all these compilers use either ILP32 or LP64 model.
2405 TODO: gcc has more options so it needs more investigation.
2407 For floating point types, see:
2409 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2410 HP-UX floating-point guide, hpux 11.00
2412 -- chastain 2003-12-18 */
2414 static struct gdbarch
*
2415 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2417 struct gdbarch_tdep
*tdep
;
2418 struct gdbarch
*gdbarch
;
2420 /* Try to determine the ABI of the object we are loading. */
2421 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2423 /* If it's a SOM file, assume it's HP/UX SOM. */
2424 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2425 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2428 /* find a candidate among the list of pre-declared architectures. */
2429 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2431 return (arches
->gdbarch
);
2433 /* If none found, then allocate and initialize one. */
2434 tdep
= XZALLOC (struct gdbarch_tdep
);
2435 gdbarch
= gdbarch_alloc (&info
, tdep
);
2437 /* Determine from the bfd_arch_info structure if we are dealing with
2438 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2439 then default to a 32bit machine. */
2440 if (info
.bfd_arch_info
!= NULL
)
2441 tdep
->bytes_per_address
=
2442 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2444 tdep
->bytes_per_address
= 4;
2446 tdep
->find_global_pointer
= hppa_find_global_pointer
;
2448 /* Some parts of the gdbarch vector depend on whether we are running
2449 on a 32 bits or 64 bits target. */
2450 switch (tdep
->bytes_per_address
)
2453 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2454 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2455 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2458 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2459 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2460 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2463 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2464 tdep
->bytes_per_address
);
2467 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2468 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2470 /* The following gdbarch vector elements are the same in both ILP32
2471 and LP64, but might show differences some day. */
2472 set_gdbarch_long_long_bit (gdbarch
, 64);
2473 set_gdbarch_long_double_bit (gdbarch
, 128);
2474 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2476 /* The following gdbarch vector elements do not depend on the address
2477 size, or in any other gdbarch element previously set. */
2478 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2479 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2480 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2481 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2482 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2483 set_gdbarch_cannot_fetch_register (gdbarch
, hppa_cannot_store_register
);
2484 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2485 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2486 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2487 set_gdbarch_read_pc (gdbarch
, hppa_target_read_pc
);
2488 set_gdbarch_write_pc (gdbarch
, hppa_target_write_pc
);
2490 /* Helper for function argument information. */
2491 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2493 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2495 /* When a hardware watchpoint triggers, we'll move the inferior past
2496 it by removing all eventpoints; stepping past the instruction
2497 that caused the trigger; reinserting eventpoints; and checking
2498 whether any watched location changed. */
2499 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2501 /* Inferior function call methods. */
2502 switch (tdep
->bytes_per_address
)
2505 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2506 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2507 set_gdbarch_convert_from_func_ptr_addr
2508 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
2511 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2512 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2515 internal_error (__FILE__
, __LINE__
, "bad switch");
2518 /* Struct return methods. */
2519 switch (tdep
->bytes_per_address
)
2522 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2525 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2528 internal_error (__FILE__
, __LINE__
, "bad switch");
2531 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2532 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2534 /* Frame unwind methods. */
2535 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2536 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2538 /* Hook in ABI-specific overrides, if they have been registered. */
2539 gdbarch_init_osabi (info
, gdbarch
);
2541 /* Hook in the default unwinders. */
2542 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2543 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2544 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
2545 frame_base_append_sniffer (gdbarch
, hppa_frame_base_sniffer
);
2551 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2553 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2555 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2556 tdep
->bytes_per_address
);
2557 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2561 _initialize_hppa_tdep (void)
2563 struct cmd_list_element
*c
;
2564 void break_at_finish_command (char *arg
, int from_tty
);
2565 void tbreak_at_finish_command (char *arg
, int from_tty
);
2566 void break_at_finish_at_depth_command (char *arg
, int from_tty
);
2568 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2570 hppa_objfile_priv_data
= register_objfile_data ();
2572 add_cmd ("unwind", class_maintenance
, unwind_command
,
2573 "Print unwind table entry at given address.",
2574 &maintenanceprintlist
);
2576 deprecate_cmd (add_com ("xbreak", class_breakpoint
,
2577 break_at_finish_command
,
2578 concat ("Set breakpoint at procedure exit. \n\
2579 Argument may be function name, or \"*\" and an address.\n\
2580 If function is specified, break at end of code for that function.\n\
2581 If an address is specified, break at the end of the function that contains \n\
2582 that exact address.\n",
2583 "With no arg, uses current execution address of selected stack frame.\n\
2584 This is useful for breaking on return to a stack frame.\n\
2586 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2588 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
)), NULL
);
2589 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint
, 1), NULL
);
2590 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint
, 1), NULL
);
2591 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint
, 1), NULL
);
2592 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1), NULL
);
2594 deprecate_cmd (c
= add_com ("txbreak", class_breakpoint
,
2595 tbreak_at_finish_command
,
2596 "Set temporary breakpoint at procedure exit. Either there should\n\
2597 be no argument or the argument must be a depth.\n"), NULL
);
2598 set_cmd_completer (c
, location_completer
);
2601 deprecate_cmd (add_com ("bx", class_breakpoint
,
2602 break_at_finish_at_depth_command
,
2603 "Set breakpoint at procedure exit. Either there should\n\
2604 be no argument or the argument must be a depth.\n"), NULL
);
2606 /* Debug this files internals. */
2607 add_show_from_set (add_set_cmd ("hppa", class_maintenance
, var_zinteger
,
2608 &hppa_debug
, "Set hppa debugging.\n\
2609 When non-zero, hppa specific debugging is enabled.", &setdebuglist
), &showdebuglist
);