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
);
75 /* Handle 32/64-bit struct return conventions. */
77 static enum return_value_convention
78 hppa32_return_value (struct gdbarch
*gdbarch
,
79 struct type
*type
, struct regcache
*regcache
,
80 void *readbuf
, const void *writebuf
)
82 if (TYPE_LENGTH (type
) <= 2 * 4)
84 /* The value always lives in the right hand end of the register
85 (or register pair)? */
87 int reg
= TYPE_CODE (type
) == TYPE_CODE_FLT
? HPPA_FP4_REGNUM
: 28;
88 int part
= TYPE_LENGTH (type
) % 4;
89 /* The left hand register contains only part of the value,
90 transfer that first so that the rest can be xfered as entire
95 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
98 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
102 /* Now transfer the remaining register values. */
103 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
106 regcache_cooked_read (regcache
, reg
, (char *) readbuf
+ b
);
107 if (writebuf
!= NULL
)
108 regcache_cooked_write (regcache
, reg
, (const char *) writebuf
+ b
);
111 return RETURN_VALUE_REGISTER_CONVENTION
;
114 return RETURN_VALUE_STRUCT_CONVENTION
;
117 static enum return_value_convention
118 hppa64_return_value (struct gdbarch
*gdbarch
,
119 struct type
*type
, struct regcache
*regcache
,
120 void *readbuf
, const void *writebuf
)
122 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
123 are in r28, padded on the left. Aggregates less that 65 bits are
124 in r28, right padded. Aggregates upto 128 bits are in r28 and
125 r29, right padded. */
126 if (TYPE_CODE (type
) == TYPE_CODE_FLT
127 && TYPE_LENGTH (type
) <= 8)
129 /* Floats are right aligned? */
130 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
132 regcache_cooked_read_part (regcache
, HPPA_FP4_REGNUM
, offset
,
133 TYPE_LENGTH (type
), readbuf
);
134 if (writebuf
!= NULL
)
135 regcache_cooked_write_part (regcache
, HPPA_FP4_REGNUM
, offset
,
136 TYPE_LENGTH (type
), writebuf
);
137 return RETURN_VALUE_REGISTER_CONVENTION
;
139 else if (TYPE_LENGTH (type
) <= 8 && is_integral_type (type
))
141 /* Integrals are right aligned. */
142 int offset
= register_size (gdbarch
, HPPA_FP4_REGNUM
) - TYPE_LENGTH (type
);
144 regcache_cooked_read_part (regcache
, 28, offset
,
145 TYPE_LENGTH (type
), readbuf
);
146 if (writebuf
!= NULL
)
147 regcache_cooked_write_part (regcache
, 28, offset
,
148 TYPE_LENGTH (type
), writebuf
);
149 return RETURN_VALUE_REGISTER_CONVENTION
;
151 else if (TYPE_LENGTH (type
) <= 2 * 8)
153 /* Composite values are left aligned. */
155 for (b
= 0; b
< TYPE_LENGTH (type
); b
+= 8)
157 int part
= min (8, TYPE_LENGTH (type
) - b
);
159 regcache_cooked_read_part (regcache
, 28 + b
/ 8, 0, part
,
160 (char *) readbuf
+ b
);
161 if (writebuf
!= NULL
)
162 regcache_cooked_write_part (regcache
, 28 + b
/ 8, 0, part
,
163 (const char *) writebuf
+ b
);
165 return RETURN_VALUE_REGISTER_CONVENTION
;
168 return RETURN_VALUE_STRUCT_CONVENTION
;
171 /* Routines to extract various sized constants out of hppa
174 /* This assumes that no garbage lies outside of the lower bits of
178 hppa_sign_extend (unsigned val
, unsigned bits
)
180 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
183 /* For many immediate values the sign bit is the low bit! */
186 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
188 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
191 /* Extract the bits at positions between FROM and TO, using HP's numbering
195 hppa_get_field (unsigned word
, int from
, int to
)
197 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
200 /* extract the immediate field from a ld{bhw}s instruction */
203 hppa_extract_5_load (unsigned word
)
205 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
208 /* extract the immediate field from a break instruction */
211 hppa_extract_5r_store (unsigned word
)
213 return (word
& MASK_5
);
216 /* extract the immediate field from a {sr}sm instruction */
219 hppa_extract_5R_store (unsigned word
)
221 return (word
>> 16 & MASK_5
);
224 /* extract a 14 bit immediate field */
227 hppa_extract_14 (unsigned word
)
229 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
232 /* extract a 21 bit constant */
235 hppa_extract_21 (unsigned word
)
241 val
= hppa_get_field (word
, 20, 20);
243 val
|= hppa_get_field (word
, 9, 19);
245 val
|= hppa_get_field (word
, 5, 6);
247 val
|= hppa_get_field (word
, 0, 4);
249 val
|= hppa_get_field (word
, 7, 8);
250 return hppa_sign_extend (val
, 21) << 11;
253 /* extract a 17 bit constant from branch instructions, returning the
254 19 bit signed value. */
257 hppa_extract_17 (unsigned word
)
259 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
260 hppa_get_field (word
, 29, 29) << 10 |
261 hppa_get_field (word
, 11, 15) << 11 |
262 (word
& 0x1) << 16, 17) << 2;
266 hppa_symbol_address(const char *sym
)
268 struct minimal_symbol
*minsym
;
270 minsym
= lookup_minimal_symbol (sym
, NULL
, NULL
);
272 return SYMBOL_VALUE_ADDRESS (minsym
);
274 return (CORE_ADDR
)-1;
278 /* Compare the start address for two unwind entries returning 1 if
279 the first address is larger than the second, -1 if the second is
280 larger than the first, and zero if they are equal. */
283 compare_unwind_entries (const void *arg1
, const void *arg2
)
285 const struct unwind_table_entry
*a
= arg1
;
286 const struct unwind_table_entry
*b
= arg2
;
288 if (a
->region_start
> b
->region_start
)
290 else if (a
->region_start
< b
->region_start
)
297 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
299 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
300 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
302 bfd_vma value
= section
->vma
- section
->filepos
;
303 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
305 if (value
< *low_text_segment_address
)
306 *low_text_segment_address
= value
;
311 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
312 asection
*section
, unsigned int entries
, unsigned int size
,
313 CORE_ADDR text_offset
)
315 /* We will read the unwind entries into temporary memory, then
316 fill in the actual unwind table. */
322 char *buf
= alloca (size
);
323 CORE_ADDR low_text_segment_address
;
325 /* For ELF targets, then unwinds are supposed to
326 be segment relative offsets instead of absolute addresses.
328 Note that when loading a shared library (text_offset != 0) the
329 unwinds are already relative to the text_offset that will be
331 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
333 low_text_segment_address
= -1;
335 bfd_map_over_sections (objfile
->obfd
,
336 record_text_segment_lowaddr
,
337 &low_text_segment_address
);
339 text_offset
= low_text_segment_address
;
342 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
344 /* Now internalize the information being careful to handle host/target
346 for (i
= 0; i
< entries
; i
++)
348 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
350 table
[i
].region_start
+= text_offset
;
352 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
353 table
[i
].region_end
+= text_offset
;
355 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
357 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
358 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
359 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
360 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
361 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
362 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
363 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
364 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
365 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
366 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
367 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
368 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
369 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
370 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
371 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
372 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
373 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
374 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
375 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
376 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
377 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
378 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
379 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
380 table
[i
].Cleanup_defined
= tmp
& 0x1;
381 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
383 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
384 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
385 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
386 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
387 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
388 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
390 /* Stub unwinds are handled elsewhere. */
391 table
[i
].stub_unwind
.stub_type
= 0;
392 table
[i
].stub_unwind
.padding
= 0;
397 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
398 the object file. This info is used mainly by find_unwind_entry() to find
399 out the stack frame size and frame pointer used by procedures. We put
400 everything on the psymbol obstack in the objfile so that it automatically
401 gets freed when the objfile is destroyed. */
404 read_unwind_info (struct objfile
*objfile
)
406 asection
*unwind_sec
, *stub_unwind_sec
;
407 unsigned unwind_size
, stub_unwind_size
, total_size
;
408 unsigned index
, unwind_entries
;
409 unsigned stub_entries
, total_entries
;
410 CORE_ADDR text_offset
;
411 struct hppa_unwind_info
*ui
;
412 struct hppa_objfile_private
*obj_private
;
414 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
415 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
416 sizeof (struct hppa_unwind_info
));
422 /* For reasons unknown the HP PA64 tools generate multiple unwinder
423 sections in a single executable. So we just iterate over every
424 section in the BFD looking for unwinder sections intead of trying
425 to do a lookup with bfd_get_section_by_name.
427 First determine the total size of the unwind tables so that we
428 can allocate memory in a nice big hunk. */
430 for (unwind_sec
= objfile
->obfd
->sections
;
432 unwind_sec
= unwind_sec
->next
)
434 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
435 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
437 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
438 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
440 total_entries
+= unwind_entries
;
444 /* Now compute the size of the stub unwinds. Note the ELF tools do not
445 use stub unwinds at the curren time. */
446 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
450 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
451 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
455 stub_unwind_size
= 0;
459 /* Compute total number of unwind entries and their total size. */
460 total_entries
+= stub_entries
;
461 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
463 /* Allocate memory for the unwind table. */
464 ui
->table
= (struct unwind_table_entry
*)
465 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
466 ui
->last
= total_entries
- 1;
468 /* Now read in each unwind section and internalize the standard unwind
471 for (unwind_sec
= objfile
->obfd
->sections
;
473 unwind_sec
= unwind_sec
->next
)
475 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
476 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
478 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
479 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
481 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
482 unwind_entries
, unwind_size
, text_offset
);
483 index
+= unwind_entries
;
487 /* Now read in and internalize the stub unwind entries. */
488 if (stub_unwind_size
> 0)
491 char *buf
= alloca (stub_unwind_size
);
493 /* Read in the stub unwind entries. */
494 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
495 0, stub_unwind_size
);
497 /* Now convert them into regular unwind entries. */
498 for (i
= 0; i
< stub_entries
; i
++, index
++)
500 /* Clear out the next unwind entry. */
501 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
503 /* Convert offset & size into region_start and region_end.
504 Stuff away the stub type into "reserved" fields. */
505 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
507 ui
->table
[index
].region_start
+= text_offset
;
509 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
512 ui
->table
[index
].region_end
513 = ui
->table
[index
].region_start
+ 4 *
514 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
520 /* Unwind table needs to be kept sorted. */
521 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
522 compare_unwind_entries
);
524 /* Keep a pointer to the unwind information. */
525 obj_private
= (struct hppa_objfile_private
*)
526 objfile_data (objfile
, hppa_objfile_priv_data
);
527 if (obj_private
== NULL
)
529 obj_private
= (struct hppa_objfile_private
*)
530 obstack_alloc (&objfile
->objfile_obstack
,
531 sizeof (struct hppa_objfile_private
));
532 set_objfile_data (objfile
, hppa_objfile_priv_data
, obj_private
);
533 obj_private
->unwind_info
= NULL
;
534 obj_private
->so_info
= NULL
;
537 obj_private
->unwind_info
= ui
;
540 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
541 of the objfiles seeking the unwind table entry for this PC. Each objfile
542 contains a sorted list of struct unwind_table_entry. Since we do a binary
543 search of the unwind tables, we depend upon them to be sorted. */
545 struct unwind_table_entry
*
546 find_unwind_entry (CORE_ADDR pc
)
548 int first
, middle
, last
;
549 struct objfile
*objfile
;
550 struct hppa_objfile_private
*priv
;
553 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
556 /* A function at address 0? Not in HP-UX! */
557 if (pc
== (CORE_ADDR
) 0)
560 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
564 ALL_OBJFILES (objfile
)
566 struct hppa_unwind_info
*ui
;
568 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
570 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
574 read_unwind_info (objfile
);
575 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
577 error ("Internal error reading unwind information.");
578 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
581 /* First, check the cache */
584 && pc
>= ui
->cache
->region_start
585 && pc
<= ui
->cache
->region_end
)
588 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
589 paddr_nz ((CORE_ADDR
) ui
->cache
));
593 /* Not in the cache, do a binary search */
598 while (first
<= last
)
600 middle
= (first
+ last
) / 2;
601 if (pc
>= ui
->table
[middle
].region_start
602 && pc
<= ui
->table
[middle
].region_end
)
604 ui
->cache
= &ui
->table
[middle
];
606 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
607 paddr_nz ((CORE_ADDR
) ui
->cache
));
608 return &ui
->table
[middle
];
611 if (pc
< ui
->table
[middle
].region_start
)
616 } /* ALL_OBJFILES() */
619 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
624 static const unsigned char *
625 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
627 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
628 (*len
) = sizeof (breakpoint
);
632 /* Return the name of a register. */
635 hppa32_register_name (int i
)
637 static char *names
[] = {
638 "flags", "r1", "rp", "r3",
639 "r4", "r5", "r6", "r7",
640 "r8", "r9", "r10", "r11",
641 "r12", "r13", "r14", "r15",
642 "r16", "r17", "r18", "r19",
643 "r20", "r21", "r22", "r23",
644 "r24", "r25", "r26", "dp",
645 "ret0", "ret1", "sp", "r31",
646 "sar", "pcoqh", "pcsqh", "pcoqt",
647 "pcsqt", "eiem", "iir", "isr",
648 "ior", "ipsw", "goto", "sr4",
649 "sr0", "sr1", "sr2", "sr3",
650 "sr5", "sr6", "sr7", "cr0",
651 "cr8", "cr9", "ccr", "cr12",
652 "cr13", "cr24", "cr25", "cr26",
653 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
654 "fpsr", "fpe1", "fpe2", "fpe3",
655 "fpe4", "fpe5", "fpe6", "fpe7",
656 "fr4", "fr4R", "fr5", "fr5R",
657 "fr6", "fr6R", "fr7", "fr7R",
658 "fr8", "fr8R", "fr9", "fr9R",
659 "fr10", "fr10R", "fr11", "fr11R",
660 "fr12", "fr12R", "fr13", "fr13R",
661 "fr14", "fr14R", "fr15", "fr15R",
662 "fr16", "fr16R", "fr17", "fr17R",
663 "fr18", "fr18R", "fr19", "fr19R",
664 "fr20", "fr20R", "fr21", "fr21R",
665 "fr22", "fr22R", "fr23", "fr23R",
666 "fr24", "fr24R", "fr25", "fr25R",
667 "fr26", "fr26R", "fr27", "fr27R",
668 "fr28", "fr28R", "fr29", "fr29R",
669 "fr30", "fr30R", "fr31", "fr31R"
671 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
678 hppa64_register_name (int i
)
680 static char *names
[] = {
681 "flags", "r1", "rp", "r3",
682 "r4", "r5", "r6", "r7",
683 "r8", "r9", "r10", "r11",
684 "r12", "r13", "r14", "r15",
685 "r16", "r17", "r18", "r19",
686 "r20", "r21", "r22", "r23",
687 "r24", "r25", "r26", "dp",
688 "ret0", "ret1", "sp", "r31",
689 "sar", "pcoqh", "pcsqh", "pcoqt",
690 "pcsqt", "eiem", "iir", "isr",
691 "ior", "ipsw", "goto", "sr4",
692 "sr0", "sr1", "sr2", "sr3",
693 "sr5", "sr6", "sr7", "cr0",
694 "cr8", "cr9", "ccr", "cr12",
695 "cr13", "cr24", "cr25", "cr26",
696 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
697 "fpsr", "fpe1", "fpe2", "fpe3",
698 "fr4", "fr5", "fr6", "fr7",
699 "fr8", "fr9", "fr10", "fr11",
700 "fr12", "fr13", "fr14", "fr15",
701 "fr16", "fr17", "fr18", "fr19",
702 "fr20", "fr21", "fr22", "fr23",
703 "fr24", "fr25", "fr26", "fr27",
704 "fr28", "fr29", "fr30", "fr31"
706 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
712 /* This function pushes a stack frame with arguments as part of the
713 inferior function calling mechanism.
715 This is the version of the function for the 32-bit PA machines, in
716 which later arguments appear at lower addresses. (The stack always
717 grows towards higher addresses.)
719 We simply allocate the appropriate amount of stack space and put
720 arguments into their proper slots. */
723 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
724 struct regcache
*regcache
, CORE_ADDR bp_addr
,
725 int nargs
, struct value
**args
, CORE_ADDR sp
,
726 int struct_return
, CORE_ADDR struct_addr
)
728 /* Stack base address at which any pass-by-reference parameters are
730 CORE_ADDR struct_end
= 0;
731 /* Stack base address at which the first parameter is stored. */
732 CORE_ADDR param_end
= 0;
734 /* The inner most end of the stack after all the parameters have
736 CORE_ADDR new_sp
= 0;
738 /* Two passes. First pass computes the location of everything,
739 second pass writes the bytes out. */
742 /* Global pointer (r19) of the function we are trying to call. */
745 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
747 for (write_pass
= 0; write_pass
< 2; write_pass
++)
749 CORE_ADDR struct_ptr
= 0;
750 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
751 struct_ptr is adjusted for each argument below, so the first
752 argument will end up at sp-36. */
753 CORE_ADDR param_ptr
= 32;
755 int small_struct
= 0;
757 for (i
= 0; i
< nargs
; i
++)
759 struct value
*arg
= args
[i
];
760 struct type
*type
= check_typedef (value_type (arg
));
761 /* The corresponding parameter that is pushed onto the
762 stack, and [possibly] passed in a register. */
765 memset (param_val
, 0, sizeof param_val
);
766 if (TYPE_LENGTH (type
) > 8)
768 /* Large parameter, pass by reference. Store the value
769 in "struct" area and then pass its address. */
771 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
773 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
775 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
777 else if (TYPE_CODE (type
) == TYPE_CODE_INT
778 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
780 /* Integer value store, right aligned. "unpack_long"
781 takes care of any sign-extension problems. */
782 param_len
= align_up (TYPE_LENGTH (type
), 4);
783 store_unsigned_integer (param_val
, param_len
,
785 VALUE_CONTENTS (arg
)));
787 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
789 /* Floating point value store, right aligned. */
790 param_len
= align_up (TYPE_LENGTH (type
), 4);
791 memcpy (param_val
, VALUE_CONTENTS (arg
), param_len
);
795 param_len
= align_up (TYPE_LENGTH (type
), 4);
797 /* Small struct value are stored right-aligned. */
798 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
799 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
801 /* Structures of size 5, 6 and 7 bytes are special in that
802 the higher-ordered word is stored in the lower-ordered
803 argument, and even though it is a 8-byte quantity the
804 registers need not be 8-byte aligned. */
805 if (param_len
> 4 && param_len
< 8)
809 param_ptr
+= param_len
;
810 if (param_len
== 8 && !small_struct
)
811 param_ptr
= align_up (param_ptr
, 8);
813 /* First 4 non-FP arguments are passed in gr26-gr23.
814 First 4 32-bit FP arguments are passed in fr4L-fr7L.
815 First 2 64-bit FP arguments are passed in fr5 and fr7.
817 The rest go on the stack, starting at sp-36, towards lower
818 addresses. 8-byte arguments must be aligned to a 8-byte
822 write_memory (param_end
- param_ptr
, param_val
, param_len
);
824 /* There are some cases when we don't know the type
825 expected by the callee (e.g. for variadic functions), so
826 pass the parameters in both general and fp regs. */
829 int grreg
= 26 - (param_ptr
- 36) / 4;
830 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
831 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
833 regcache_cooked_write (regcache
, grreg
, param_val
);
834 regcache_cooked_write (regcache
, fpLreg
, param_val
);
838 regcache_cooked_write (regcache
, grreg
+ 1,
841 regcache_cooked_write (regcache
, fpreg
, param_val
);
842 regcache_cooked_write (regcache
, fpreg
+ 1,
849 /* Update the various stack pointers. */
852 struct_end
= sp
+ align_up (struct_ptr
, 64);
853 /* PARAM_PTR already accounts for all the arguments passed
854 by the user. However, the ABI mandates minimum stack
855 space allocations for outgoing arguments. The ABI also
856 mandates minimum stack alignments which we must
858 param_end
= struct_end
+ align_up (param_ptr
, 64);
862 /* If a structure has to be returned, set up register 28 to hold its
865 write_register (28, struct_addr
);
867 gp
= tdep
->find_global_pointer (function
);
870 write_register (19, gp
);
872 /* Set the return address. */
873 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
875 /* Update the Stack Pointer. */
876 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
881 /* This function pushes a stack frame with arguments as part of the
882 inferior function calling mechanism.
884 This is the version for the PA64, in which later arguments appear
885 at higher addresses. (The stack always grows towards higher
888 We simply allocate the appropriate amount of stack space and put
889 arguments into their proper slots.
891 This ABI also requires that the caller provide an argument pointer
892 to the callee, so we do that too. */
895 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
896 struct regcache
*regcache
, CORE_ADDR bp_addr
,
897 int nargs
, struct value
**args
, CORE_ADDR sp
,
898 int struct_return
, CORE_ADDR struct_addr
)
900 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
901 reverse engineering testsuite failures. */
903 /* Stack base address at which any pass-by-reference parameters are
905 CORE_ADDR struct_end
= 0;
906 /* Stack base address at which the first parameter is stored. */
907 CORE_ADDR param_end
= 0;
909 /* The inner most end of the stack after all the parameters have
911 CORE_ADDR new_sp
= 0;
913 /* Two passes. First pass computes the location of everything,
914 second pass writes the bytes out. */
916 for (write_pass
= 0; write_pass
< 2; write_pass
++)
918 CORE_ADDR struct_ptr
= 0;
919 CORE_ADDR param_ptr
= 0;
921 for (i
= 0; i
< nargs
; i
++)
923 struct value
*arg
= args
[i
];
924 struct type
*type
= check_typedef (value_type (arg
));
925 if ((TYPE_CODE (type
) == TYPE_CODE_INT
926 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
927 && TYPE_LENGTH (type
) <= 8)
929 /* Integer value store, right aligned. "unpack_long"
930 takes care of any sign-extension problems. */
934 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
935 int reg
= 27 - param_ptr
/ 8;
936 write_memory_unsigned_integer (param_end
- param_ptr
,
939 regcache_cooked_write_unsigned (regcache
, reg
, val
);
944 /* Small struct value, store left aligned? */
946 if (TYPE_LENGTH (type
) > 8)
948 param_ptr
= align_up (param_ptr
, 16);
949 reg
= 26 - param_ptr
/ 8;
950 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
954 param_ptr
= align_up (param_ptr
, 8);
955 reg
= 26 - param_ptr
/ 8;
956 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
961 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
963 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
967 int len
= min (8, TYPE_LENGTH (type
) - byte
);
968 regcache_cooked_write_part (regcache
, reg
, 0, len
,
969 VALUE_CONTENTS (arg
) + byte
);
976 /* Update the various stack pointers. */
979 struct_end
= sp
+ struct_ptr
;
980 /* PARAM_PTR already accounts for all the arguments passed
981 by the user. However, the ABI mandates minimum stack
982 space allocations for outgoing arguments. The ABI also
983 mandates minimum stack alignments which we must
985 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
989 /* If a structure has to be returned, set up register 28 to hold its
992 write_register (28, struct_addr
);
994 /* Set the return address. */
995 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
997 /* Update the Stack Pointer. */
998 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
+ 64);
1000 /* The stack will have 32 bytes of additional space for a frame marker. */
1001 return param_end
+ 64;
1005 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
1007 struct target_ops
*targ
)
1014 target_read_memory(plabel
, (char *)&addr
, 4);
1021 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1023 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1025 return align_up (addr
, 64);
1028 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1031 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1033 /* Just always 16-byte align. */
1034 return align_up (addr
, 16);
1038 hppa_read_pc (ptid_t ptid
)
1043 ipsw
= read_register_pid (HPPA_IPSW_REGNUM
, ptid
);
1044 pc
= read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
);
1046 /* If the current instruction is nullified, then we are effectively
1047 still executing the previous instruction. Pretend we are still
1048 there. This is needed when single stepping; if the nullified
1049 instruction is on a different line, we don't want GDB to think
1050 we've stepped onto that line. */
1051 if (ipsw
& 0x00200000)
1058 hppa_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1060 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, pc
, ptid
);
1061 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, pc
+ 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
, int stop_before_branch
)
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
;
1246 int final_iteration
;
1252 u
= find_unwind_entry (pc
);
1256 /* If we are not at the beginning of a function, then return now. */
1257 if ((pc
& ~0x3) != u
->region_start
)
1260 /* This is how much of a frame adjustment we need to account for. */
1261 stack_remaining
= u
->Total_frame_size
<< 3;
1263 /* Magic register saves we want to know about. */
1264 save_rp
= u
->Save_RP
;
1265 save_sp
= u
->Save_SP
;
1267 /* An indication that args may be stored into the stack. Unfortunately
1268 the HPUX compilers tend to set this in cases where no args were
1272 /* Turn the Entry_GR field into a bitmask. */
1274 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1276 /* Frame pointer gets saved into a special location. */
1277 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1280 save_gr
|= (1 << i
);
1282 save_gr
&= ~restart_gr
;
1284 /* Turn the Entry_FR field into a bitmask too. */
1286 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1287 save_fr
|= (1 << i
);
1288 save_fr
&= ~restart_fr
;
1290 final_iteration
= 0;
1292 /* Loop until we find everything of interest or hit a branch.
1294 For unoptimized GCC code and for any HP CC code this will never ever
1295 examine any user instructions.
1297 For optimzied GCC code we're faced with problems. GCC will schedule
1298 its prologue and make prologue instructions available for delay slot
1299 filling. The end result is user code gets mixed in with the prologue
1300 and a prologue instruction may be in the delay slot of the first branch
1303 Some unexpected things are expected with debugging optimized code, so
1304 we allow this routine to walk past user instructions in optimized
1306 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1309 unsigned int reg_num
;
1310 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1311 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1313 /* Save copies of all the triggers so we can compare them later
1315 old_save_gr
= save_gr
;
1316 old_save_fr
= save_fr
;
1317 old_save_rp
= save_rp
;
1318 old_save_sp
= save_sp
;
1319 old_stack_remaining
= stack_remaining
;
1321 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1322 inst
= extract_unsigned_integer (buf
, 4);
1328 /* Note the interesting effects of this instruction. */
1329 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1331 /* There are limited ways to store the return pointer into the
1333 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1336 /* These are the only ways we save SP into the stack. At this time
1337 the HP compilers never bother to save SP into the stack. */
1338 if ((inst
& 0xffffc000) == 0x6fc10000
1339 || (inst
& 0xffffc00c) == 0x73c10008)
1342 /* Are we loading some register with an offset from the argument
1344 if ((inst
& 0xffe00000) == 0x37a00000
1345 || (inst
& 0xffffffe0) == 0x081d0240)
1351 /* Account for general and floating-point register saves. */
1352 reg_num
= inst_saves_gr (inst
);
1353 save_gr
&= ~(1 << reg_num
);
1355 /* Ugh. Also account for argument stores into the stack.
1356 Unfortunately args_stored only tells us that some arguments
1357 where stored into the stack. Not how many or what kind!
1359 This is a kludge as on the HP compiler sets this bit and it
1360 never does prologue scheduling. So once we see one, skip past
1361 all of them. We have similar code for the fp arg stores below.
1363 FIXME. Can still die if we have a mix of GR and FR argument
1365 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1367 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1370 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1371 inst
= extract_unsigned_integer (buf
, 4);
1374 reg_num
= inst_saves_gr (inst
);
1380 reg_num
= inst_saves_fr (inst
);
1381 save_fr
&= ~(1 << reg_num
);
1383 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1384 next_inst
= extract_unsigned_integer (buf
, 4);
1390 /* We've got to be read to handle the ldo before the fp register
1392 if ((inst
& 0xfc000000) == 0x34000000
1393 && inst_saves_fr (next_inst
) >= 4
1394 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1396 /* So we drop into the code below in a reasonable state. */
1397 reg_num
= inst_saves_fr (next_inst
);
1401 /* Ugh. Also account for argument stores into the stack.
1402 This is a kludge as on the HP compiler sets this bit and it
1403 never does prologue scheduling. So once we see one, skip past
1405 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1407 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1410 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1411 inst
= extract_unsigned_integer (buf
, 4);
1414 if ((inst
& 0xfc000000) != 0x34000000)
1416 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1417 next_inst
= extract_unsigned_integer (buf
, 4);
1420 reg_num
= inst_saves_fr (next_inst
);
1426 /* Quit if we hit any kind of branch. This can happen if a prologue
1427 instruction is in the delay slot of the first call/branch. */
1428 if (is_branch (inst
) && stop_before_branch
)
1431 /* What a crock. The HP compilers set args_stored even if no
1432 arguments were stored into the stack (boo hiss). This could
1433 cause this code to then skip a bunch of user insns (up to the
1436 To combat this we try to identify when args_stored was bogusly
1437 set and clear it. We only do this when args_stored is nonzero,
1438 all other resources are accounted for, and nothing changed on
1441 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1442 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1443 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1444 && old_stack_remaining
== stack_remaining
)
1450 /* !stop_before_branch, so also look at the insn in the delay slot
1452 if (final_iteration
)
1454 if (is_branch (inst
))
1455 final_iteration
= 1;
1458 /* We've got a tenative location for the end of the prologue. However
1459 because of limitations in the unwind descriptor mechanism we may
1460 have went too far into user code looking for the save of a register
1461 that does not exist. So, if there registers we expected to be saved
1462 but never were, mask them out and restart.
1464 This should only happen in optimized code, and should be very rare. */
1465 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1468 restart_gr
= save_gr
;
1469 restart_fr
= save_fr
;
1477 /* Return the address of the PC after the last prologue instruction if
1478 we can determine it from the debug symbols. Else return zero. */
1481 after_prologue (CORE_ADDR pc
)
1483 struct symtab_and_line sal
;
1484 CORE_ADDR func_addr
, func_end
;
1487 /* If we can not find the symbol in the partial symbol table, then
1488 there is no hope we can determine the function's start address
1490 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1493 /* Get the line associated with FUNC_ADDR. */
1494 sal
= find_pc_line (func_addr
, 0);
1496 /* There are only two cases to consider. First, the end of the source line
1497 is within the function bounds. In that case we return the end of the
1498 source line. Second is the end of the source line extends beyond the
1499 bounds of the current function. We need to use the slow code to
1500 examine instructions in that case.
1502 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1503 the wrong thing to do. In fact, it should be entirely possible for this
1504 function to always return zero since the slow instruction scanning code
1505 is supposed to *always* work. If it does not, then it is a bug. */
1506 if (sal
.end
< func_end
)
1512 /* To skip prologues, I use this predicate. Returns either PC itself
1513 if the code at PC does not look like a function prologue; otherwise
1514 returns an address that (if we're lucky) follows the prologue.
1516 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1517 It doesn't necessarily skips all the insns in the prologue. In fact
1518 we might not want to skip all the insns because a prologue insn may
1519 appear in the delay slot of the first branch, and we don't want to
1520 skip over the branch in that case. */
1523 hppa_skip_prologue (CORE_ADDR pc
)
1527 CORE_ADDR post_prologue_pc
;
1530 /* See if we can determine the end of the prologue via the symbol table.
1531 If so, then return either PC, or the PC after the prologue, whichever
1534 post_prologue_pc
= after_prologue (pc
);
1536 /* If after_prologue returned a useful address, then use it. Else
1537 fall back on the instruction skipping code.
1539 Some folks have claimed this causes problems because the breakpoint
1540 may be the first instruction of the prologue. If that happens, then
1541 the instruction skipping code has a bug that needs to be fixed. */
1542 if (post_prologue_pc
!= 0)
1543 return max (pc
, post_prologue_pc
);
1545 return (skip_prologue_hard_way (pc
, 1));
1548 struct hppa_frame_cache
1551 struct trad_frame_saved_reg
*saved_regs
;
1554 static struct hppa_frame_cache
*
1555 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1557 struct hppa_frame_cache
*cache
;
1562 struct unwind_table_entry
*u
;
1563 CORE_ADDR prologue_end
;
1568 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1569 frame_relative_level(next_frame
));
1571 if ((*this_cache
) != NULL
)
1574 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1575 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1576 return (*this_cache
);
1578 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1579 (*this_cache
) = cache
;
1580 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1583 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
1587 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1588 return (*this_cache
);
1591 /* Turn the Entry_GR field into a bitmask. */
1593 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1595 /* Frame pointer gets saved into a special location. */
1596 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1599 saved_gr_mask
|= (1 << i
);
1602 /* Turn the Entry_FR field into a bitmask too. */
1604 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1605 saved_fr_mask
|= (1 << i
);
1607 /* Loop until we find everything of interest or hit a branch.
1609 For unoptimized GCC code and for any HP CC code this will never ever
1610 examine any user instructions.
1612 For optimized GCC code we're faced with problems. GCC will schedule
1613 its prologue and make prologue instructions available for delay slot
1614 filling. The end result is user code gets mixed in with the prologue
1615 and a prologue instruction may be in the delay slot of the first branch
1618 Some unexpected things are expected with debugging optimized code, so
1619 we allow this routine to walk past user instructions in optimized
1622 int final_iteration
= 0;
1623 CORE_ADDR pc
, end_pc
;
1624 int looking_for_sp
= u
->Save_SP
;
1625 int looking_for_rp
= u
->Save_RP
;
1628 /* We have to use skip_prologue_hard_way instead of just
1629 skip_prologue_using_sal, in case we stepped into a function without
1630 symbol information. hppa_skip_prologue also bounds the returned
1631 pc by the passed in pc, so it will not return a pc in the next
1634 We used to call hppa_skip_prologue to find the end of the prologue,
1635 but if some non-prologue instructions get scheduled into the prologue,
1636 and the program is compiled with debug information, the "easy" way
1637 in hppa_skip_prologue will return a prologue end that is too early
1638 for us to notice any potential frame adjustments. */
1640 /* We used to use frame_func_unwind () to locate the beginning of the
1641 function to pass to skip_prologue (). However, when objects are
1642 compiled without debug symbols, frame_func_unwind can return the wrong
1643 function (or 0). We can do better than that by using unwind records. */
1645 prologue_end
= skip_prologue_hard_way (u
->region_start
, 0);
1646 end_pc
= frame_pc_unwind (next_frame
);
1648 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1649 end_pc
= prologue_end
;
1653 for (pc
= u
->region_start
;
1654 ((saved_gr_mask
|| saved_fr_mask
1655 || looking_for_sp
|| looking_for_rp
1656 || frame_size
< (u
->Total_frame_size
<< 3))
1664 if (!safe_frame_unwind_memory (next_frame
, pc
, buf4
,
1667 error ("Cannot read instruction at 0x%s\n", paddr_nz (pc
));
1668 return (*this_cache
);
1671 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1673 /* Note the interesting effects of this instruction. */
1674 frame_size
+= prologue_inst_adjust_sp (inst
);
1676 /* There are limited ways to store the return pointer into the
1678 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1681 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1683 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1686 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1688 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1691 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1694 /* Check to see if we saved SP into the stack. This also
1695 happens to indicate the location of the saved frame
1697 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1698 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1701 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1703 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1708 /* Account for general and floating-point register saves. */
1709 reg
= inst_saves_gr (inst
);
1710 if (reg
>= 3 && reg
<= 18
1711 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1713 saved_gr_mask
&= ~(1 << reg
);
1714 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1715 /* stwm with a positive displacement is a _post_
1717 cache
->saved_regs
[reg
].addr
= 0;
1718 else if ((inst
& 0xfc00000c) == 0x70000008)
1719 /* A std has explicit post_modify forms. */
1720 cache
->saved_regs
[reg
].addr
= 0;
1725 if ((inst
>> 26) == 0x1c)
1726 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1727 else if ((inst
>> 26) == 0x03)
1728 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1730 offset
= hppa_extract_14 (inst
);
1732 /* Handle code with and without frame pointers. */
1734 cache
->saved_regs
[reg
].addr
= offset
;
1736 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1740 /* GCC handles callee saved FP regs a little differently.
1742 It emits an instruction to put the value of the start of
1743 the FP store area into %r1. It then uses fstds,ma with a
1744 basereg of %r1 for the stores.
1746 HP CC emits them at the current stack pointer modifying the
1747 stack pointer as it stores each register. */
1749 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1750 if ((inst
& 0xffffc000) == 0x34610000
1751 || (inst
& 0xffffc000) == 0x37c10000)
1752 fp_loc
= hppa_extract_14 (inst
);
1754 reg
= inst_saves_fr (inst
);
1755 if (reg
>= 12 && reg
<= 21)
1757 /* Note +4 braindamage below is necessary because the FP
1758 status registers are internally 8 registers rather than
1759 the expected 4 registers. */
1760 saved_fr_mask
&= ~(1 << reg
);
1763 /* 1st HP CC FP register store. After this
1764 instruction we've set enough state that the GCC and
1765 HPCC code are both handled in the same manner. */
1766 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
1771 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1776 /* Quit if we hit any kind of branch the previous iteration. */
1777 if (final_iteration
)
1779 /* We want to look precisely one instruction beyond the branch
1780 if we have not found everything yet. */
1781 if (is_branch (inst
))
1782 final_iteration
= 1;
1787 /* The frame base always represents the value of %sp at entry to
1788 the current function (and is thus equivalent to the "saved"
1790 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1794 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1795 "prologue_end=0x%s) ",
1797 paddr_nz (frame_pc_unwind (next_frame
)),
1798 paddr_nz (prologue_end
));
1800 /* Check to see if a frame pointer is available, and use it for
1801 frame unwinding if it is.
1803 There are some situations where we need to rely on the frame
1804 pointer to do stack unwinding. For example, if a function calls
1805 alloca (), the stack pointer can get adjusted inside the body of
1806 the function. In this case, the ABI requires that the compiler
1807 maintain a frame pointer for the function.
1809 The unwind record has a flag (alloca_frame) that indicates that
1810 a function has a variable frame; unfortunately, gcc/binutils
1811 does not set this flag. Instead, whenever a frame pointer is used
1812 and saved on the stack, the Save_SP flag is set. We use this to
1813 decide whether to use the frame pointer for unwinding.
1815 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1816 instead of Save_SP. */
1818 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
1820 if (frame_pc_unwind (next_frame
) >= prologue_end
1821 && u
->Save_SP
&& fp
!= 0)
1826 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer] }",
1827 paddr_nz (cache
->base
));
1830 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1832 /* Both we're expecting the SP to be saved and the SP has been
1833 saved. The entry SP value is saved at this frame's SP
1835 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1838 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved] }",
1839 paddr_nz (cache
->base
));
1843 /* The prologue has been slowly allocating stack space. Adjust
1845 cache
->base
= this_sp
- frame_size
;
1847 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust] } ",
1848 paddr_nz (cache
->base
));
1851 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1854 /* The PC is found in the "return register", "Millicode" uses "r31"
1855 as the return register while normal code uses "rp". */
1858 if (trad_frame_addr_p (cache
->saved_regs
, 31))
1859 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1862 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
1863 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
1868 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1869 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1872 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1873 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1877 /* If Save_SP is set, then we expect the frame pointer to be saved in the
1878 frame. However, there is a one-insn window where we haven't saved it
1879 yet, but we've already clobbered it. Detect this case and fix it up.
1881 The prologue sequence for frame-pointer functions is:
1882 0: stw %rp, -20(%sp)
1885 c: stw,ma %r1, XX(%sp)
1887 So if we are at offset c, the r3 value that we want is not yet saved
1888 on the stack, but it's been overwritten. The prologue analyzer will
1889 set fp_in_r1 when it sees the copy insn so we know to get the value
1891 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
1894 ULONGEST r1
= frame_unwind_register_unsigned (next_frame
, 1);
1895 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
1899 /* Convert all the offsets into addresses. */
1901 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1903 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1904 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1909 struct gdbarch
*gdbarch
;
1910 struct gdbarch_tdep
*tdep
;
1912 gdbarch
= get_frame_arch (next_frame
);
1913 tdep
= gdbarch_tdep (gdbarch
);
1915 if (tdep
->unwind_adjust_stub
)
1917 tdep
->unwind_adjust_stub (next_frame
, cache
->base
, cache
->saved_regs
);
1922 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1923 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1924 return (*this_cache
);
1928 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1929 struct frame_id
*this_id
)
1931 struct hppa_frame_cache
*info
;
1932 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1933 struct unwind_table_entry
*u
;
1935 info
= hppa_frame_cache (next_frame
, this_cache
);
1936 u
= find_unwind_entry (pc
);
1938 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
1942 hppa_frame_prev_register (struct frame_info
*next_frame
,
1944 int regnum
, int *optimizedp
,
1945 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1946 int *realnump
, void *valuep
)
1948 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1949 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
1950 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1953 static const struct frame_unwind hppa_frame_unwind
=
1957 hppa_frame_prev_register
1960 static const struct frame_unwind
*
1961 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
1963 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1965 if (find_unwind_entry (pc
))
1966 return &hppa_frame_unwind
;
1971 /* This is a generic fallback frame unwinder that kicks in if we fail all
1972 the other ones. Normally we would expect the stub and regular unwinder
1973 to work, but in some cases we might hit a function that just doesn't
1974 have any unwind information available. In this case we try to do
1975 unwinding solely based on code reading. This is obviously going to be
1976 slow, so only use this as a last resort. Currently this will only
1977 identify the stack and pc for the frame. */
1979 static struct hppa_frame_cache
*
1980 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1982 struct hppa_frame_cache
*cache
;
1983 unsigned int frame_size
;
1985 CORE_ADDR pc
, start_pc
, end_pc
, cur_pc
;
1988 fprintf_unfiltered (gdb_stdlog
, "{ hppa_fallback_frame_cache (frame=%d)-> ",
1989 frame_relative_level(next_frame
));
1991 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1992 (*this_cache
) = cache
;
1993 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1995 pc
= frame_func_unwind (next_frame
);
1996 cur_pc
= frame_pc_unwind (next_frame
);
2000 find_pc_partial_function (pc
, NULL
, &start_pc
, &end_pc
);
2002 if (start_pc
== 0 || end_pc
== 0)
2004 error ("Cannot find bounds of current function (@0x%s), unwinding will "
2005 "fail.", paddr_nz (pc
));
2009 if (end_pc
> cur_pc
)
2012 for (pc
= start_pc
; pc
< end_pc
; pc
+= 4)
2016 insn
= read_memory_unsigned_integer (pc
, 4);
2018 frame_size
+= prologue_inst_adjust_sp (insn
);
2020 /* There are limited ways to store the return pointer into the
2022 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2024 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2027 else if (insn
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
2029 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2035 fprintf_unfiltered (gdb_stdlog
, " frame_size = %d, found_rp = %d }\n",
2036 frame_size
, found_rp
);
2038 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
) - frame_size
;
2039 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2041 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2043 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2044 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
2048 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2049 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2056 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2057 struct frame_id
*this_id
)
2059 struct hppa_frame_cache
*info
=
2060 hppa_fallback_frame_cache (next_frame
, this_cache
);
2061 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2065 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
2067 int regnum
, int *optimizedp
,
2068 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2069 int *realnump
, void *valuep
)
2071 struct hppa_frame_cache
*info
=
2072 hppa_fallback_frame_cache (next_frame
, this_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_fallback_frame_unwind
=
2080 hppa_fallback_frame_this_id
,
2081 hppa_fallback_frame_prev_register
2084 static const struct frame_unwind
*
2085 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2087 return &hppa_fallback_frame_unwind
;
2090 /* Stub frames, used for all kinds of call stubs. */
2091 struct hppa_stub_unwind_cache
2094 struct trad_frame_saved_reg
*saved_regs
;
2097 static struct hppa_stub_unwind_cache
*
2098 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2101 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2102 struct hppa_stub_unwind_cache
*info
;
2103 struct unwind_table_entry
*u
;
2108 if (frame_pc_unwind (next_frame
) == 0)
2111 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2113 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2115 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2117 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2119 /* HPUX uses export stubs in function calls; the export stub clobbers
2120 the return value of the caller, and, later restores it from the
2122 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2124 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2126 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2132 /* By default we assume that stubs do not change the rp. */
2133 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2139 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2140 void **this_prologue_cache
,
2141 struct frame_id
*this_id
)
2143 struct hppa_stub_unwind_cache
*info
2144 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2147 *this_id
= frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2149 *this_id
= null_frame_id
;
2153 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2154 void **this_prologue_cache
,
2155 int regnum
, int *optimizedp
,
2156 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2157 int *realnump
, void *valuep
)
2159 struct hppa_stub_unwind_cache
*info
2160 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2163 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2164 optimizedp
, lvalp
, addrp
, realnump
,
2167 error ("Requesting registers from null frame.\n");
2170 static const struct frame_unwind hppa_stub_frame_unwind
= {
2172 hppa_stub_frame_this_id
,
2173 hppa_stub_frame_prev_register
2176 static const struct frame_unwind
*
2177 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2179 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2180 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2181 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2184 || (tdep
->in_solib_call_trampoline
!= NULL
2185 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2186 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2187 return &hppa_stub_frame_unwind
;
2191 static struct frame_id
2192 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2194 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2196 frame_pc_unwind (next_frame
));
2200 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2205 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2206 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2208 /* If the current instruction is nullified, then we are effectively
2209 still executing the previous instruction. Pretend we are still
2210 there. This is needed when single stepping; if the nullified
2211 instruction is on a different line, we don't want GDB to think
2212 we've stepped onto that line. */
2213 if (ipsw
& 0x00200000)
2219 /* Instead of this nasty cast, add a method pvoid() that prints out a
2220 host VOID data type (remember %p isn't portable). */
2223 hppa_pointer_to_address_hack (void *ptr
)
2225 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2226 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2230 unwind_command (char *exp
, int from_tty
)
2233 struct unwind_table_entry
*u
;
2235 /* If we have an expression, evaluate it and use it as the address. */
2237 if (exp
!= 0 && *exp
!= 0)
2238 address
= parse_and_eval_address (exp
);
2242 u
= find_unwind_entry (address
);
2246 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2250 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2251 paddr_nz (hppa_pointer_to_address_hack (u
)));
2253 printf_unfiltered ("\tregion_start = ");
2254 print_address (u
->region_start
, gdb_stdout
);
2255 gdb_flush (gdb_stdout
);
2257 printf_unfiltered ("\n\tregion_end = ");
2258 print_address (u
->region_end
, gdb_stdout
);
2259 gdb_flush (gdb_stdout
);
2261 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2263 printf_unfiltered ("\n\tflags =");
2264 pif (Cannot_unwind
);
2266 pif (Millicode_save_sr0
);
2269 pif (Variable_Frame
);
2270 pif (Separate_Package_Body
);
2271 pif (Frame_Extension_Millicode
);
2272 pif (Stack_Overflow_Check
);
2273 pif (Two_Instruction_SP_Increment
);
2277 pif (Save_MRP_in_frame
);
2278 pif (extn_ptr_defined
);
2279 pif (Cleanup_defined
);
2280 pif (MPE_XL_interrupt_marker
);
2281 pif (HP_UX_interrupt_marker
);
2284 putchar_unfiltered ('\n');
2286 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2288 pin (Region_description
);
2291 pin (Total_frame_size
);
2293 if (u
->stub_unwind
.stub_type
)
2295 printf_unfiltered ("\tstub type = ");
2296 switch (u
->stub_unwind
.stub_type
)
2299 printf_unfiltered ("long branch\n");
2301 case PARAMETER_RELOCATION
:
2302 printf_unfiltered ("parameter relocation\n");
2305 printf_unfiltered ("export\n");
2308 printf_unfiltered ("import\n");
2311 printf_unfiltered ("import shlib\n");
2314 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2320 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2322 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2324 An example of this occurs when an a.out is linked against a foo.sl.
2325 The foo.sl defines a global bar(), and the a.out declares a signature
2326 for bar(). However, the a.out doesn't directly call bar(), but passes
2327 its address in another call.
2329 If you have this scenario and attempt to "break bar" before running,
2330 gdb will find a minimal symbol for bar() in the a.out. But that
2331 symbol's address will be negative. What this appears to denote is
2332 an index backwards from the base of the procedure linkage table (PLT)
2333 into the data linkage table (DLT), the end of which is contiguous
2334 with the start of the PLT. This is clearly not a valid address for
2335 us to set a breakpoint on.
2337 Note that one must be careful in how one checks for a negative address.
2338 0xc0000000 is a legitimate address of something in a shared text
2339 segment, for example. Since I don't know what the possible range
2340 is of these "really, truly negative" addresses that come from the
2341 minimal symbols, I'm resorting to the gross hack of checking the
2342 top byte of the address for all 1's. Sigh. */
2344 return (!target_has_stack
&& (pc
& 0xFF000000));
2347 /* Return the GDB type object for the "standard" data type of data
2350 static struct type
*
2351 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2353 if (reg_nr
< HPPA_FP4_REGNUM
)
2354 return builtin_type_uint32
;
2356 return builtin_type_ieee_single_big
;
2359 /* Return the GDB type object for the "standard" data type of data
2360 in register N. hppa64 version. */
2362 static struct type
*
2363 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2365 if (reg_nr
< HPPA_FP4_REGNUM
)
2366 return builtin_type_uint64
;
2368 return builtin_type_ieee_double_big
;
2371 /* Return True if REGNUM is not a register available to the user
2372 through ptrace(). */
2375 hppa_cannot_store_register (int regnum
)
2378 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2379 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2380 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2385 hppa_smash_text_address (CORE_ADDR addr
)
2387 /* The low two bits of the PC on the PA contain the privilege level.
2388 Some genius implementing a (non-GCC) compiler apparently decided
2389 this means that "addresses" in a text section therefore include a
2390 privilege level, and thus symbol tables should contain these bits.
2391 This seems like a bonehead thing to do--anyway, it seems to work
2392 for our purposes to just ignore those bits. */
2394 return (addr
&= ~0x3);
2397 /* Get the ith function argument for the current function. */
2399 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2403 get_frame_register (frame
, HPPA_R0_REGNUM
+ 26 - argi
, &addr
);
2408 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2409 int regnum
, void *buf
)
2413 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2414 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2416 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2420 hppa_find_global_pointer (struct value
*function
)
2426 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2427 struct trad_frame_saved_reg saved_regs
[],
2428 int regnum
, int *optimizedp
,
2429 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2430 int *realnump
, void *valuep
)
2432 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2438 trad_frame_get_prev_register (next_frame
, saved_regs
,
2439 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2440 lvalp
, addrp
, realnump
, valuep
);
2442 pc
= extract_unsigned_integer (valuep
, 4);
2443 store_unsigned_integer (valuep
, 4, pc
+ 4);
2446 /* It's a computed value. */
2454 /* Make sure the "flags" register is zero in all unwound frames.
2455 The "flags" registers is a HP-UX specific wart, and only the code
2456 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2457 with it here. This shouldn't affect other systems since those
2458 should provide zero for the "flags" register anyway. */
2459 if (regnum
== HPPA_FLAGS_REGNUM
)
2462 store_unsigned_integer (valuep
,
2463 register_size (get_frame_arch (next_frame
),
2467 /* It's a computed value. */
2475 trad_frame_get_prev_register (next_frame
, saved_regs
, regnum
,
2476 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2480 /* Here is a table of C type sizes on hppa with various compiles
2481 and options. I measured this on PA 9000/800 with HP-UX 11.11
2482 and these compilers:
2484 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2485 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2486 /opt/aCC/bin/aCC B3910B A.03.45
2487 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2489 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2490 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2491 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2492 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2493 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2494 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2495 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2496 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2500 compiler and options
2501 char, short, int, long, long long
2502 float, double, long double
2505 So all these compilers use either ILP32 or LP64 model.
2506 TODO: gcc has more options so it needs more investigation.
2508 For floating point types, see:
2510 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2511 HP-UX floating-point guide, hpux 11.00
2513 -- chastain 2003-12-18 */
2515 static struct gdbarch
*
2516 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2518 struct gdbarch_tdep
*tdep
;
2519 struct gdbarch
*gdbarch
;
2521 /* Try to determine the ABI of the object we are loading. */
2522 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2524 /* If it's a SOM file, assume it's HP/UX SOM. */
2525 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2526 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2529 /* find a candidate among the list of pre-declared architectures. */
2530 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2532 return (arches
->gdbarch
);
2534 /* If none found, then allocate and initialize one. */
2535 tdep
= XZALLOC (struct gdbarch_tdep
);
2536 gdbarch
= gdbarch_alloc (&info
, tdep
);
2538 /* Determine from the bfd_arch_info structure if we are dealing with
2539 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2540 then default to a 32bit machine. */
2541 if (info
.bfd_arch_info
!= NULL
)
2542 tdep
->bytes_per_address
=
2543 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2545 tdep
->bytes_per_address
= 4;
2547 tdep
->find_global_pointer
= hppa_find_global_pointer
;
2549 /* Some parts of the gdbarch vector depend on whether we are running
2550 on a 32 bits or 64 bits target. */
2551 switch (tdep
->bytes_per_address
)
2554 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2555 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2556 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2559 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2560 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2561 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2564 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2565 tdep
->bytes_per_address
);
2568 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2569 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2571 /* The following gdbarch vector elements are the same in both ILP32
2572 and LP64, but might show differences some day. */
2573 set_gdbarch_long_long_bit (gdbarch
, 64);
2574 set_gdbarch_long_double_bit (gdbarch
, 128);
2575 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2577 /* The following gdbarch vector elements do not depend on the address
2578 size, or in any other gdbarch element previously set. */
2579 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2580 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2581 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2582 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2583 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2584 set_gdbarch_cannot_fetch_register (gdbarch
, hppa_cannot_store_register
);
2585 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2586 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2587 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2588 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
2589 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
2591 /* Helper for function argument information. */
2592 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2594 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2596 /* When a hardware watchpoint triggers, we'll move the inferior past
2597 it by removing all eventpoints; stepping past the instruction
2598 that caused the trigger; reinserting eventpoints; and checking
2599 whether any watched location changed. */
2600 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2602 /* Inferior function call methods. */
2603 switch (tdep
->bytes_per_address
)
2606 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2607 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2608 set_gdbarch_convert_from_func_ptr_addr
2609 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
2612 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2613 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2616 internal_error (__FILE__
, __LINE__
, "bad switch");
2619 /* Struct return methods. */
2620 switch (tdep
->bytes_per_address
)
2623 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2626 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2629 internal_error (__FILE__
, __LINE__
, "bad switch");
2632 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2633 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2635 /* Frame unwind methods. */
2636 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2637 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2639 /* Hook in ABI-specific overrides, if they have been registered. */
2640 gdbarch_init_osabi (info
, gdbarch
);
2642 /* Hook in the default unwinders. */
2643 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2644 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2645 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
2651 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2653 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2655 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2656 tdep
->bytes_per_address
);
2657 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2661 _initialize_hppa_tdep (void)
2663 struct cmd_list_element
*c
;
2665 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2667 hppa_objfile_priv_data
= register_objfile_data ();
2669 add_cmd ("unwind", class_maintenance
, unwind_command
,
2670 "Print unwind table entry at given address.",
2671 &maintenanceprintlist
);
2673 /* Debug this files internals. */
2674 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, "\
2675 Set whether hppa target specific debugging information should be displayed.", "\
2676 Show whether hppa target specific debugging information is displayed.", "\
2677 This flag controls whether hppa target specific debugging information is\n\
2678 displayed. This information is particularly useful for debugging frame\n\
2679 unwinding problems.", "hppa debug flag is %s.",
2680 NULL
, NULL
, &setdebuglist
, &showdebuglist
);