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;
277 struct hppa_objfile_private
*
278 hppa_init_objfile_priv_data (struct objfile
*objfile
)
280 struct hppa_objfile_private
*priv
;
282 priv
= (struct hppa_objfile_private
*)
283 obstack_alloc (&objfile
->objfile_obstack
,
284 sizeof (struct hppa_objfile_private
));
285 set_objfile_data (objfile
, hppa_objfile_priv_data
, priv
);
286 memset (priv
, 0, sizeof (*priv
));
292 /* Compare the start address for two unwind entries returning 1 if
293 the first address is larger than the second, -1 if the second is
294 larger than the first, and zero if they are equal. */
297 compare_unwind_entries (const void *arg1
, const void *arg2
)
299 const struct unwind_table_entry
*a
= arg1
;
300 const struct unwind_table_entry
*b
= arg2
;
302 if (a
->region_start
> b
->region_start
)
304 else if (a
->region_start
< b
->region_start
)
311 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
313 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
314 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
316 bfd_vma value
= section
->vma
- section
->filepos
;
317 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
319 if (value
< *low_text_segment_address
)
320 *low_text_segment_address
= value
;
325 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
326 asection
*section
, unsigned int entries
, unsigned int size
,
327 CORE_ADDR text_offset
)
329 /* We will read the unwind entries into temporary memory, then
330 fill in the actual unwind table. */
336 char *buf
= alloca (size
);
337 CORE_ADDR low_text_segment_address
;
339 /* For ELF targets, then unwinds are supposed to
340 be segment relative offsets instead of absolute addresses.
342 Note that when loading a shared library (text_offset != 0) the
343 unwinds are already relative to the text_offset that will be
345 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
347 low_text_segment_address
= -1;
349 bfd_map_over_sections (objfile
->obfd
,
350 record_text_segment_lowaddr
,
351 &low_text_segment_address
);
353 text_offset
= low_text_segment_address
;
355 else if (gdbarch_tdep (current_gdbarch
)->solib_get_text_base
)
357 text_offset
= gdbarch_tdep (current_gdbarch
)->solib_get_text_base (objfile
);
360 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
362 /* Now internalize the information being careful to handle host/target
364 for (i
= 0; i
< entries
; i
++)
366 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
368 table
[i
].region_start
+= text_offset
;
370 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
371 table
[i
].region_end
+= text_offset
;
373 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
375 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
376 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
377 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
378 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
379 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
380 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
381 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
382 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
383 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
384 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
385 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
386 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
387 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
388 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
389 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
390 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
391 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
392 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
393 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
394 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
395 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
396 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
397 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
398 table
[i
].Cleanup_defined
= tmp
& 0x1;
399 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
401 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
402 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
403 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
404 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
405 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
406 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
408 /* Stub unwinds are handled elsewhere. */
409 table
[i
].stub_unwind
.stub_type
= 0;
410 table
[i
].stub_unwind
.padding
= 0;
415 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
416 the object file. This info is used mainly by find_unwind_entry() to find
417 out the stack frame size and frame pointer used by procedures. We put
418 everything on the psymbol obstack in the objfile so that it automatically
419 gets freed when the objfile is destroyed. */
422 read_unwind_info (struct objfile
*objfile
)
424 asection
*unwind_sec
, *stub_unwind_sec
;
425 unsigned unwind_size
, stub_unwind_size
, total_size
;
426 unsigned index
, unwind_entries
;
427 unsigned stub_entries
, total_entries
;
428 CORE_ADDR text_offset
;
429 struct hppa_unwind_info
*ui
;
430 struct hppa_objfile_private
*obj_private
;
432 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
433 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
434 sizeof (struct hppa_unwind_info
));
440 /* For reasons unknown the HP PA64 tools generate multiple unwinder
441 sections in a single executable. So we just iterate over every
442 section in the BFD looking for unwinder sections intead of trying
443 to do a lookup with bfd_get_section_by_name.
445 First determine the total size of the unwind tables so that we
446 can allocate memory in a nice big hunk. */
448 for (unwind_sec
= objfile
->obfd
->sections
;
450 unwind_sec
= unwind_sec
->next
)
452 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
453 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
455 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
456 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
458 total_entries
+= unwind_entries
;
462 /* Now compute the size of the stub unwinds. Note the ELF tools do not
463 use stub unwinds at the curren time. */
464 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
468 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
469 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
473 stub_unwind_size
= 0;
477 /* Compute total number of unwind entries and their total size. */
478 total_entries
+= stub_entries
;
479 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
481 /* Allocate memory for the unwind table. */
482 ui
->table
= (struct unwind_table_entry
*)
483 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
484 ui
->last
= total_entries
- 1;
486 /* Now read in each unwind section and internalize the standard unwind
489 for (unwind_sec
= objfile
->obfd
->sections
;
491 unwind_sec
= unwind_sec
->next
)
493 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
494 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
496 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
497 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
499 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
500 unwind_entries
, unwind_size
, text_offset
);
501 index
+= unwind_entries
;
505 /* Now read in and internalize the stub unwind entries. */
506 if (stub_unwind_size
> 0)
509 char *buf
= alloca (stub_unwind_size
);
511 /* Read in the stub unwind entries. */
512 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
513 0, stub_unwind_size
);
515 /* Now convert them into regular unwind entries. */
516 for (i
= 0; i
< stub_entries
; i
++, index
++)
518 /* Clear out the next unwind entry. */
519 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
521 /* Convert offset & size into region_start and region_end.
522 Stuff away the stub type into "reserved" fields. */
523 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
525 ui
->table
[index
].region_start
+= text_offset
;
527 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
530 ui
->table
[index
].region_end
531 = ui
->table
[index
].region_start
+ 4 *
532 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
538 /* Unwind table needs to be kept sorted. */
539 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
540 compare_unwind_entries
);
542 /* Keep a pointer to the unwind information. */
543 obj_private
= (struct hppa_objfile_private
*)
544 objfile_data (objfile
, hppa_objfile_priv_data
);
545 if (obj_private
== NULL
)
546 obj_private
= hppa_init_objfile_priv_data (objfile
);
548 obj_private
->unwind_info
= ui
;
551 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
552 of the objfiles seeking the unwind table entry for this PC. Each objfile
553 contains a sorted list of struct unwind_table_entry. Since we do a binary
554 search of the unwind tables, we depend upon them to be sorted. */
556 struct unwind_table_entry
*
557 find_unwind_entry (CORE_ADDR pc
)
559 int first
, middle
, last
;
560 struct objfile
*objfile
;
561 struct hppa_objfile_private
*priv
;
564 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
567 /* A function at address 0? Not in HP-UX! */
568 if (pc
== (CORE_ADDR
) 0)
571 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
575 ALL_OBJFILES (objfile
)
577 struct hppa_unwind_info
*ui
;
579 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
581 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
585 read_unwind_info (objfile
);
586 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
588 error ("Internal error reading unwind information.");
589 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
592 /* First, check the cache */
595 && pc
>= ui
->cache
->region_start
596 && pc
<= ui
->cache
->region_end
)
599 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
600 paddr_nz ((CORE_ADDR
) ui
->cache
));
604 /* Not in the cache, do a binary search */
609 while (first
<= last
)
611 middle
= (first
+ last
) / 2;
612 if (pc
>= ui
->table
[middle
].region_start
613 && pc
<= ui
->table
[middle
].region_end
)
615 ui
->cache
= &ui
->table
[middle
];
617 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
618 paddr_nz ((CORE_ADDR
) ui
->cache
));
619 return &ui
->table
[middle
];
622 if (pc
< ui
->table
[middle
].region_start
)
627 } /* ALL_OBJFILES() */
630 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
635 /* The epilogue is defined here as the area either on the `bv' instruction
636 itself or an instruction which destroys the function's stack frame.
638 We do not assume that the epilogue is at the end of a function as we can
639 also have return sequences in the middle of a function. */
641 hppa_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
643 unsigned long status
;
648 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
652 inst
= extract_unsigned_integer (buf
, 4);
654 /* The most common way to perform a stack adjustment ldo X(sp),sp
655 We are destroying a stack frame if the offset is negative. */
656 if ((inst
& 0xffffc000) == 0x37de0000
657 && hppa_extract_14 (inst
) < 0)
660 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
661 if (((inst
& 0x0fc010e0) == 0x0fc010e0
662 || (inst
& 0x0fc010e0) == 0x0fc010e0)
663 && hppa_extract_14 (inst
) < 0)
666 /* bv %r0(%rp) or bv,n %r0(%rp) */
667 if (inst
== 0xe840c000 || inst
== 0xe840c002)
673 static const unsigned char *
674 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
676 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
677 (*len
) = sizeof (breakpoint
);
681 /* Return the name of a register. */
684 hppa32_register_name (int i
)
686 static char *names
[] = {
687 "flags", "r1", "rp", "r3",
688 "r4", "r5", "r6", "r7",
689 "r8", "r9", "r10", "r11",
690 "r12", "r13", "r14", "r15",
691 "r16", "r17", "r18", "r19",
692 "r20", "r21", "r22", "r23",
693 "r24", "r25", "r26", "dp",
694 "ret0", "ret1", "sp", "r31",
695 "sar", "pcoqh", "pcsqh", "pcoqt",
696 "pcsqt", "eiem", "iir", "isr",
697 "ior", "ipsw", "goto", "sr4",
698 "sr0", "sr1", "sr2", "sr3",
699 "sr5", "sr6", "sr7", "cr0",
700 "cr8", "cr9", "ccr", "cr12",
701 "cr13", "cr24", "cr25", "cr26",
702 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
703 "fpsr", "fpe1", "fpe2", "fpe3",
704 "fpe4", "fpe5", "fpe6", "fpe7",
705 "fr4", "fr4R", "fr5", "fr5R",
706 "fr6", "fr6R", "fr7", "fr7R",
707 "fr8", "fr8R", "fr9", "fr9R",
708 "fr10", "fr10R", "fr11", "fr11R",
709 "fr12", "fr12R", "fr13", "fr13R",
710 "fr14", "fr14R", "fr15", "fr15R",
711 "fr16", "fr16R", "fr17", "fr17R",
712 "fr18", "fr18R", "fr19", "fr19R",
713 "fr20", "fr20R", "fr21", "fr21R",
714 "fr22", "fr22R", "fr23", "fr23R",
715 "fr24", "fr24R", "fr25", "fr25R",
716 "fr26", "fr26R", "fr27", "fr27R",
717 "fr28", "fr28R", "fr29", "fr29R",
718 "fr30", "fr30R", "fr31", "fr31R"
720 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
727 hppa64_register_name (int i
)
729 static char *names
[] = {
730 "flags", "r1", "rp", "r3",
731 "r4", "r5", "r6", "r7",
732 "r8", "r9", "r10", "r11",
733 "r12", "r13", "r14", "r15",
734 "r16", "r17", "r18", "r19",
735 "r20", "r21", "r22", "r23",
736 "r24", "r25", "r26", "dp",
737 "ret0", "ret1", "sp", "r31",
738 "sar", "pcoqh", "pcsqh", "pcoqt",
739 "pcsqt", "eiem", "iir", "isr",
740 "ior", "ipsw", "goto", "sr4",
741 "sr0", "sr1", "sr2", "sr3",
742 "sr5", "sr6", "sr7", "cr0",
743 "cr8", "cr9", "ccr", "cr12",
744 "cr13", "cr24", "cr25", "cr26",
745 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
746 "fpsr", "fpe1", "fpe2", "fpe3",
747 "fr4", "fr5", "fr6", "fr7",
748 "fr8", "fr9", "fr10", "fr11",
749 "fr12", "fr13", "fr14", "fr15",
750 "fr16", "fr17", "fr18", "fr19",
751 "fr20", "fr21", "fr22", "fr23",
752 "fr24", "fr25", "fr26", "fr27",
753 "fr28", "fr29", "fr30", "fr31"
755 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
761 /* This function pushes a stack frame with arguments as part of the
762 inferior function calling mechanism.
764 This is the version of the function for the 32-bit PA machines, in
765 which later arguments appear at lower addresses. (The stack always
766 grows towards higher addresses.)
768 We simply allocate the appropriate amount of stack space and put
769 arguments into their proper slots. */
772 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
773 struct regcache
*regcache
, CORE_ADDR bp_addr
,
774 int nargs
, struct value
**args
, CORE_ADDR sp
,
775 int struct_return
, CORE_ADDR struct_addr
)
777 /* Stack base address at which any pass-by-reference parameters are
779 CORE_ADDR struct_end
= 0;
780 /* Stack base address at which the first parameter is stored. */
781 CORE_ADDR param_end
= 0;
783 /* The inner most end of the stack after all the parameters have
785 CORE_ADDR new_sp
= 0;
787 /* Two passes. First pass computes the location of everything,
788 second pass writes the bytes out. */
791 /* Global pointer (r19) of the function we are trying to call. */
794 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
796 for (write_pass
= 0; write_pass
< 2; write_pass
++)
798 CORE_ADDR struct_ptr
= 0;
799 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
800 struct_ptr is adjusted for each argument below, so the first
801 argument will end up at sp-36. */
802 CORE_ADDR param_ptr
= 32;
804 int small_struct
= 0;
806 for (i
= 0; i
< nargs
; i
++)
808 struct value
*arg
= args
[i
];
809 struct type
*type
= check_typedef (value_type (arg
));
810 /* The corresponding parameter that is pushed onto the
811 stack, and [possibly] passed in a register. */
814 memset (param_val
, 0, sizeof param_val
);
815 if (TYPE_LENGTH (type
) > 8)
817 /* Large parameter, pass by reference. Store the value
818 in "struct" area and then pass its address. */
820 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
822 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
824 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
826 else if (TYPE_CODE (type
) == TYPE_CODE_INT
827 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
829 /* Integer value store, right aligned. "unpack_long"
830 takes care of any sign-extension problems. */
831 param_len
= align_up (TYPE_LENGTH (type
), 4);
832 store_unsigned_integer (param_val
, param_len
,
834 VALUE_CONTENTS (arg
)));
836 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
838 /* Floating point value store, right aligned. */
839 param_len
= align_up (TYPE_LENGTH (type
), 4);
840 memcpy (param_val
, VALUE_CONTENTS (arg
), param_len
);
844 param_len
= align_up (TYPE_LENGTH (type
), 4);
846 /* Small struct value are stored right-aligned. */
847 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
848 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
850 /* Structures of size 5, 6 and 7 bytes are special in that
851 the higher-ordered word is stored in the lower-ordered
852 argument, and even though it is a 8-byte quantity the
853 registers need not be 8-byte aligned. */
854 if (param_len
> 4 && param_len
< 8)
858 param_ptr
+= param_len
;
859 if (param_len
== 8 && !small_struct
)
860 param_ptr
= align_up (param_ptr
, 8);
862 /* First 4 non-FP arguments are passed in gr26-gr23.
863 First 4 32-bit FP arguments are passed in fr4L-fr7L.
864 First 2 64-bit FP arguments are passed in fr5 and fr7.
866 The rest go on the stack, starting at sp-36, towards lower
867 addresses. 8-byte arguments must be aligned to a 8-byte
871 write_memory (param_end
- param_ptr
, param_val
, param_len
);
873 /* There are some cases when we don't know the type
874 expected by the callee (e.g. for variadic functions), so
875 pass the parameters in both general and fp regs. */
878 int grreg
= 26 - (param_ptr
- 36) / 4;
879 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
880 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
882 regcache_cooked_write (regcache
, grreg
, param_val
);
883 regcache_cooked_write (regcache
, fpLreg
, param_val
);
887 regcache_cooked_write (regcache
, grreg
+ 1,
890 regcache_cooked_write (regcache
, fpreg
, param_val
);
891 regcache_cooked_write (regcache
, fpreg
+ 1,
898 /* Update the various stack pointers. */
901 struct_end
= sp
+ align_up (struct_ptr
, 64);
902 /* PARAM_PTR already accounts for all the arguments passed
903 by the user. However, the ABI mandates minimum stack
904 space allocations for outgoing arguments. The ABI also
905 mandates minimum stack alignments which we must
907 param_end
= struct_end
+ align_up (param_ptr
, 64);
911 /* If a structure has to be returned, set up register 28 to hold its
914 write_register (28, struct_addr
);
916 gp
= tdep
->find_global_pointer (function
);
919 write_register (19, gp
);
921 /* Set the return address. */
922 if (!gdbarch_push_dummy_code_p (gdbarch
))
923 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
925 /* Update the Stack Pointer. */
926 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
931 /* This function pushes a stack frame with arguments as part of the
932 inferior function calling mechanism.
934 This is the version for the PA64, in which later arguments appear
935 at higher addresses. (The stack always grows towards higher
938 We simply allocate the appropriate amount of stack space and put
939 arguments into their proper slots.
941 This ABI also requires that the caller provide an argument pointer
942 to the callee, so we do that too. */
945 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
946 struct regcache
*regcache
, CORE_ADDR bp_addr
,
947 int nargs
, struct value
**args
, CORE_ADDR sp
,
948 int struct_return
, CORE_ADDR struct_addr
)
950 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
951 reverse engineering testsuite failures. */
953 /* Stack base address at which any pass-by-reference parameters are
955 CORE_ADDR struct_end
= 0;
956 /* Stack base address at which the first parameter is stored. */
957 CORE_ADDR param_end
= 0;
959 /* The inner most end of the stack after all the parameters have
961 CORE_ADDR new_sp
= 0;
963 /* Global pointer (r27) of the function we are trying to call. */
965 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
967 /* Two passes. First pass computes the location of everything,
968 second pass writes the bytes out. */
970 for (write_pass
= 0; write_pass
< 2; write_pass
++)
972 CORE_ADDR struct_ptr
= 0;
973 CORE_ADDR param_ptr
= 0;
975 for (i
= 0; i
< nargs
; i
++)
977 struct value
*arg
= args
[i
];
978 struct type
*type
= check_typedef (value_type (arg
));
979 if ((TYPE_CODE (type
) == TYPE_CODE_INT
980 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
981 && TYPE_LENGTH (type
) <= 8)
983 /* Integer value store, right aligned. "unpack_long"
984 takes care of any sign-extension problems. */
988 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
989 int reg
= 27 - param_ptr
/ 8;
990 write_memory_unsigned_integer (param_end
- param_ptr
,
993 regcache_cooked_write_unsigned (regcache
, reg
, val
);
998 /* Small struct value, store left aligned? */
1000 if (TYPE_LENGTH (type
) > 8)
1002 param_ptr
= align_up (param_ptr
, 16);
1003 reg
= 26 - param_ptr
/ 8;
1004 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
1008 param_ptr
= align_up (param_ptr
, 8);
1009 reg
= 26 - param_ptr
/ 8;
1010 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
1015 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
1016 TYPE_LENGTH (type
));
1017 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
1021 int len
= min (8, TYPE_LENGTH (type
) - byte
);
1022 regcache_cooked_write_part (regcache
, reg
, 0, len
,
1023 VALUE_CONTENTS (arg
) + byte
);
1030 /* Update the various stack pointers. */
1033 struct_end
= sp
+ struct_ptr
;
1034 /* PARAM_PTR already accounts for all the arguments passed
1035 by the user. However, the ABI mandates minimum stack
1036 space allocations for outgoing arguments. The ABI also
1037 mandates minimum stack alignments which we must
1039 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
1043 /* If a structure has to be returned, set up register 28 to hold its
1046 write_register (28, struct_addr
);
1048 gp
= tdep
->find_global_pointer (function
);
1051 write_register (27, gp
);
1053 /* Set the return address. */
1054 if (!gdbarch_push_dummy_code_p (gdbarch
))
1055 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1057 /* Update the Stack Pointer. */
1058 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
+ 64);
1060 /* The stack will have 32 bytes of additional space for a frame marker. */
1061 return param_end
+ 64;
1065 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
1067 struct target_ops
*targ
)
1074 target_read_memory(plabel
, (char *)&addr
, 4);
1081 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1083 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1085 return align_up (addr
, 64);
1088 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1091 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1093 /* Just always 16-byte align. */
1094 return align_up (addr
, 16);
1098 hppa_read_pc (ptid_t ptid
)
1103 ipsw
= read_register_pid (HPPA_IPSW_REGNUM
, ptid
);
1104 pc
= read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
);
1106 /* If the current instruction is nullified, then we are effectively
1107 still executing the previous instruction. Pretend we are still
1108 there. This is needed when single stepping; if the nullified
1109 instruction is on a different line, we don't want GDB to think
1110 we've stepped onto that line. */
1111 if (ipsw
& 0x00200000)
1118 hppa_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1120 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, pc
, ptid
);
1121 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4, ptid
);
1124 /* return the alignment of a type in bytes. Structures have the maximum
1125 alignment required by their fields. */
1128 hppa_alignof (struct type
*type
)
1130 int max_align
, align
, i
;
1131 CHECK_TYPEDEF (type
);
1132 switch (TYPE_CODE (type
))
1137 return TYPE_LENGTH (type
);
1138 case TYPE_CODE_ARRAY
:
1139 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1140 case TYPE_CODE_STRUCT
:
1141 case TYPE_CODE_UNION
:
1143 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1145 /* Bit fields have no real alignment. */
1146 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1147 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1149 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1150 max_align
= max (max_align
, align
);
1159 /* For the given instruction (INST), return any adjustment it makes
1160 to the stack pointer or zero for no adjustment.
1162 This only handles instructions commonly found in prologues. */
1165 prologue_inst_adjust_sp (unsigned long inst
)
1167 /* This must persist across calls. */
1168 static int save_high21
;
1170 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1171 if ((inst
& 0xffffc000) == 0x37de0000)
1172 return hppa_extract_14 (inst
);
1175 if ((inst
& 0xffe00000) == 0x6fc00000)
1176 return hppa_extract_14 (inst
);
1178 /* std,ma X,D(sp) */
1179 if ((inst
& 0xffe00008) == 0x73c00008)
1180 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1182 /* addil high21,%r1; ldo low11,(%r1),%r30)
1183 save high bits in save_high21 for later use. */
1184 if ((inst
& 0xffe00000) == 0x28200000)
1186 save_high21
= hppa_extract_21 (inst
);
1190 if ((inst
& 0xffff0000) == 0x343e0000)
1191 return save_high21
+ hppa_extract_14 (inst
);
1193 /* fstws as used by the HP compilers. */
1194 if ((inst
& 0xffffffe0) == 0x2fd01220)
1195 return hppa_extract_5_load (inst
);
1197 /* No adjustment. */
1201 /* Return nonzero if INST is a branch of some kind, else return zero. */
1204 is_branch (unsigned long inst
)
1233 /* Return the register number for a GR which is saved by INST or
1234 zero it INST does not save a GR. */
1237 inst_saves_gr (unsigned long inst
)
1239 /* Does it look like a stw? */
1240 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1241 || (inst
>> 26) == 0x1f
1242 || ((inst
>> 26) == 0x1f
1243 && ((inst
>> 6) == 0xa)))
1244 return hppa_extract_5R_store (inst
);
1246 /* Does it look like a std? */
1247 if ((inst
>> 26) == 0x1c
1248 || ((inst
>> 26) == 0x03
1249 && ((inst
>> 6) & 0xf) == 0xb))
1250 return hppa_extract_5R_store (inst
);
1252 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1253 if ((inst
>> 26) == 0x1b)
1254 return hppa_extract_5R_store (inst
);
1256 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1258 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1259 || ((inst
>> 26) == 0x3
1260 && (((inst
>> 6) & 0xf) == 0x8
1261 || (inst
>> 6) & 0xf) == 0x9))
1262 return hppa_extract_5R_store (inst
);
1267 /* Return the register number for a FR which is saved by INST or
1268 zero it INST does not save a FR.
1270 Note we only care about full 64bit register stores (that's the only
1271 kind of stores the prologue will use).
1273 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1276 inst_saves_fr (unsigned long inst
)
1278 /* is this an FSTD ? */
1279 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1280 return hppa_extract_5r_store (inst
);
1281 if ((inst
& 0xfc000002) == 0x70000002)
1282 return hppa_extract_5R_store (inst
);
1283 /* is this an FSTW ? */
1284 if ((inst
& 0xfc00df80) == 0x24001200)
1285 return hppa_extract_5r_store (inst
);
1286 if ((inst
& 0xfc000002) == 0x7c000000)
1287 return hppa_extract_5R_store (inst
);
1291 /* Advance PC across any function entry prologue instructions
1292 to reach some "real" code.
1294 Use information in the unwind table to determine what exactly should
1295 be in the prologue. */
1299 skip_prologue_hard_way (CORE_ADDR pc
, int stop_before_branch
)
1302 CORE_ADDR orig_pc
= pc
;
1303 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1304 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1305 struct unwind_table_entry
*u
;
1306 int final_iteration
;
1312 u
= find_unwind_entry (pc
);
1316 /* If we are not at the beginning of a function, then return now. */
1317 if ((pc
& ~0x3) != u
->region_start
)
1320 /* This is how much of a frame adjustment we need to account for. */
1321 stack_remaining
= u
->Total_frame_size
<< 3;
1323 /* Magic register saves we want to know about. */
1324 save_rp
= u
->Save_RP
;
1325 save_sp
= u
->Save_SP
;
1327 /* An indication that args may be stored into the stack. Unfortunately
1328 the HPUX compilers tend to set this in cases where no args were
1332 /* Turn the Entry_GR field into a bitmask. */
1334 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1336 /* Frame pointer gets saved into a special location. */
1337 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1340 save_gr
|= (1 << i
);
1342 save_gr
&= ~restart_gr
;
1344 /* Turn the Entry_FR field into a bitmask too. */
1346 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1347 save_fr
|= (1 << i
);
1348 save_fr
&= ~restart_fr
;
1350 final_iteration
= 0;
1352 /* Loop until we find everything of interest or hit a branch.
1354 For unoptimized GCC code and for any HP CC code this will never ever
1355 examine any user instructions.
1357 For optimzied GCC code we're faced with problems. GCC will schedule
1358 its prologue and make prologue instructions available for delay slot
1359 filling. The end result is user code gets mixed in with the prologue
1360 and a prologue instruction may be in the delay slot of the first branch
1363 Some unexpected things are expected with debugging optimized code, so
1364 we allow this routine to walk past user instructions in optimized
1366 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1369 unsigned int reg_num
;
1370 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1371 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1373 /* Save copies of all the triggers so we can compare them later
1375 old_save_gr
= save_gr
;
1376 old_save_fr
= save_fr
;
1377 old_save_rp
= save_rp
;
1378 old_save_sp
= save_sp
;
1379 old_stack_remaining
= stack_remaining
;
1381 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1382 inst
= extract_unsigned_integer (buf
, 4);
1388 /* Note the interesting effects of this instruction. */
1389 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1391 /* There are limited ways to store the return pointer into the
1393 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1396 /* These are the only ways we save SP into the stack. At this time
1397 the HP compilers never bother to save SP into the stack. */
1398 if ((inst
& 0xffffc000) == 0x6fc10000
1399 || (inst
& 0xffffc00c) == 0x73c10008)
1402 /* Are we loading some register with an offset from the argument
1404 if ((inst
& 0xffe00000) == 0x37a00000
1405 || (inst
& 0xffffffe0) == 0x081d0240)
1411 /* Account for general and floating-point register saves. */
1412 reg_num
= inst_saves_gr (inst
);
1413 save_gr
&= ~(1 << reg_num
);
1415 /* Ugh. Also account for argument stores into the stack.
1416 Unfortunately args_stored only tells us that some arguments
1417 where stored into the stack. Not how many or what kind!
1419 This is a kludge as on the HP compiler sets this bit and it
1420 never does prologue scheduling. So once we see one, skip past
1421 all of them. We have similar code for the fp arg stores below.
1423 FIXME. Can still die if we have a mix of GR and FR argument
1425 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1427 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1430 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1431 inst
= extract_unsigned_integer (buf
, 4);
1434 reg_num
= inst_saves_gr (inst
);
1440 reg_num
= inst_saves_fr (inst
);
1441 save_fr
&= ~(1 << reg_num
);
1443 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1444 next_inst
= extract_unsigned_integer (buf
, 4);
1450 /* We've got to be read to handle the ldo before the fp register
1452 if ((inst
& 0xfc000000) == 0x34000000
1453 && inst_saves_fr (next_inst
) >= 4
1454 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1456 /* So we drop into the code below in a reasonable state. */
1457 reg_num
= inst_saves_fr (next_inst
);
1461 /* Ugh. Also account for argument stores into the stack.
1462 This is a kludge as on the HP compiler sets this bit and it
1463 never does prologue scheduling. So once we see one, skip past
1465 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1467 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1470 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1471 inst
= extract_unsigned_integer (buf
, 4);
1474 if ((inst
& 0xfc000000) != 0x34000000)
1476 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1477 next_inst
= extract_unsigned_integer (buf
, 4);
1480 reg_num
= inst_saves_fr (next_inst
);
1486 /* Quit if we hit any kind of branch. This can happen if a prologue
1487 instruction is in the delay slot of the first call/branch. */
1488 if (is_branch (inst
) && stop_before_branch
)
1491 /* What a crock. The HP compilers set args_stored even if no
1492 arguments were stored into the stack (boo hiss). This could
1493 cause this code to then skip a bunch of user insns (up to the
1496 To combat this we try to identify when args_stored was bogusly
1497 set and clear it. We only do this when args_stored is nonzero,
1498 all other resources are accounted for, and nothing changed on
1501 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1502 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1503 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1504 && old_stack_remaining
== stack_remaining
)
1510 /* !stop_before_branch, so also look at the insn in the delay slot
1512 if (final_iteration
)
1514 if (is_branch (inst
))
1515 final_iteration
= 1;
1518 /* We've got a tenative location for the end of the prologue. However
1519 because of limitations in the unwind descriptor mechanism we may
1520 have went too far into user code looking for the save of a register
1521 that does not exist. So, if there registers we expected to be saved
1522 but never were, mask them out and restart.
1524 This should only happen in optimized code, and should be very rare. */
1525 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1528 restart_gr
= save_gr
;
1529 restart_fr
= save_fr
;
1537 /* Return the address of the PC after the last prologue instruction if
1538 we can determine it from the debug symbols. Else return zero. */
1541 after_prologue (CORE_ADDR pc
)
1543 struct symtab_and_line sal
;
1544 CORE_ADDR func_addr
, func_end
;
1547 /* If we can not find the symbol in the partial symbol table, then
1548 there is no hope we can determine the function's start address
1550 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1553 /* Get the line associated with FUNC_ADDR. */
1554 sal
= find_pc_line (func_addr
, 0);
1556 /* There are only two cases to consider. First, the end of the source line
1557 is within the function bounds. In that case we return the end of the
1558 source line. Second is the end of the source line extends beyond the
1559 bounds of the current function. We need to use the slow code to
1560 examine instructions in that case.
1562 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1563 the wrong thing to do. In fact, it should be entirely possible for this
1564 function to always return zero since the slow instruction scanning code
1565 is supposed to *always* work. If it does not, then it is a bug. */
1566 if (sal
.end
< func_end
)
1572 /* To skip prologues, I use this predicate. Returns either PC itself
1573 if the code at PC does not look like a function prologue; otherwise
1574 returns an address that (if we're lucky) follows the prologue.
1576 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1577 It doesn't necessarily skips all the insns in the prologue. In fact
1578 we might not want to skip all the insns because a prologue insn may
1579 appear in the delay slot of the first branch, and we don't want to
1580 skip over the branch in that case. */
1583 hppa_skip_prologue (CORE_ADDR pc
)
1587 CORE_ADDR post_prologue_pc
;
1590 /* See if we can determine the end of the prologue via the symbol table.
1591 If so, then return either PC, or the PC after the prologue, whichever
1594 post_prologue_pc
= after_prologue (pc
);
1596 /* If after_prologue returned a useful address, then use it. Else
1597 fall back on the instruction skipping code.
1599 Some folks have claimed this causes problems because the breakpoint
1600 may be the first instruction of the prologue. If that happens, then
1601 the instruction skipping code has a bug that needs to be fixed. */
1602 if (post_prologue_pc
!= 0)
1603 return max (pc
, post_prologue_pc
);
1605 return (skip_prologue_hard_way (pc
, 1));
1608 struct hppa_frame_cache
1611 struct trad_frame_saved_reg
*saved_regs
;
1614 static struct hppa_frame_cache
*
1615 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1617 struct hppa_frame_cache
*cache
;
1622 struct unwind_table_entry
*u
;
1623 CORE_ADDR prologue_end
;
1628 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1629 frame_relative_level(next_frame
));
1631 if ((*this_cache
) != NULL
)
1634 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1635 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1636 return (*this_cache
);
1638 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1639 (*this_cache
) = cache
;
1640 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1643 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
1647 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1648 return (*this_cache
);
1651 /* Turn the Entry_GR field into a bitmask. */
1653 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1655 /* Frame pointer gets saved into a special location. */
1656 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1659 saved_gr_mask
|= (1 << i
);
1662 /* Turn the Entry_FR field into a bitmask too. */
1664 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1665 saved_fr_mask
|= (1 << i
);
1667 /* Loop until we find everything of interest or hit a branch.
1669 For unoptimized GCC code and for any HP CC code this will never ever
1670 examine any user instructions.
1672 For optimized GCC code we're faced with problems. GCC will schedule
1673 its prologue and make prologue instructions available for delay slot
1674 filling. The end result is user code gets mixed in with the prologue
1675 and a prologue instruction may be in the delay slot of the first branch
1678 Some unexpected things are expected with debugging optimized code, so
1679 we allow this routine to walk past user instructions in optimized
1682 int final_iteration
= 0;
1683 CORE_ADDR pc
, end_pc
;
1684 int looking_for_sp
= u
->Save_SP
;
1685 int looking_for_rp
= u
->Save_RP
;
1688 /* We have to use skip_prologue_hard_way instead of just
1689 skip_prologue_using_sal, in case we stepped into a function without
1690 symbol information. hppa_skip_prologue also bounds the returned
1691 pc by the passed in pc, so it will not return a pc in the next
1694 We used to call hppa_skip_prologue to find the end of the prologue,
1695 but if some non-prologue instructions get scheduled into the prologue,
1696 and the program is compiled with debug information, the "easy" way
1697 in hppa_skip_prologue will return a prologue end that is too early
1698 for us to notice any potential frame adjustments. */
1700 /* We used to use frame_func_unwind () to locate the beginning of the
1701 function to pass to skip_prologue (). However, when objects are
1702 compiled without debug symbols, frame_func_unwind can return the wrong
1703 function (or 0). We can do better than that by using unwind records. */
1705 prologue_end
= skip_prologue_hard_way (u
->region_start
, 0);
1706 end_pc
= frame_pc_unwind (next_frame
);
1708 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1709 end_pc
= prologue_end
;
1713 for (pc
= u
->region_start
;
1714 ((saved_gr_mask
|| saved_fr_mask
1715 || looking_for_sp
|| looking_for_rp
1716 || frame_size
< (u
->Total_frame_size
<< 3))
1724 if (!safe_frame_unwind_memory (next_frame
, pc
, buf4
,
1727 error ("Cannot read instruction at 0x%s\n", paddr_nz (pc
));
1728 return (*this_cache
);
1731 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1733 /* Note the interesting effects of this instruction. */
1734 frame_size
+= prologue_inst_adjust_sp (inst
);
1736 /* There are limited ways to store the return pointer into the
1738 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1741 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1743 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1746 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1748 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1751 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1754 /* Check to see if we saved SP into the stack. This also
1755 happens to indicate the location of the saved frame
1757 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1758 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1761 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1763 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1768 /* Account for general and floating-point register saves. */
1769 reg
= inst_saves_gr (inst
);
1770 if (reg
>= 3 && reg
<= 18
1771 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1773 saved_gr_mask
&= ~(1 << reg
);
1774 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1775 /* stwm with a positive displacement is a _post_
1777 cache
->saved_regs
[reg
].addr
= 0;
1778 else if ((inst
& 0xfc00000c) == 0x70000008)
1779 /* A std has explicit post_modify forms. */
1780 cache
->saved_regs
[reg
].addr
= 0;
1785 if ((inst
>> 26) == 0x1c)
1786 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1787 else if ((inst
>> 26) == 0x03)
1788 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1790 offset
= hppa_extract_14 (inst
);
1792 /* Handle code with and without frame pointers. */
1794 cache
->saved_regs
[reg
].addr
= offset
;
1796 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1800 /* GCC handles callee saved FP regs a little differently.
1802 It emits an instruction to put the value of the start of
1803 the FP store area into %r1. It then uses fstds,ma with a
1804 basereg of %r1 for the stores.
1806 HP CC emits them at the current stack pointer modifying the
1807 stack pointer as it stores each register. */
1809 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1810 if ((inst
& 0xffffc000) == 0x34610000
1811 || (inst
& 0xffffc000) == 0x37c10000)
1812 fp_loc
= hppa_extract_14 (inst
);
1814 reg
= inst_saves_fr (inst
);
1815 if (reg
>= 12 && reg
<= 21)
1817 /* Note +4 braindamage below is necessary because the FP
1818 status registers are internally 8 registers rather than
1819 the expected 4 registers. */
1820 saved_fr_mask
&= ~(1 << reg
);
1823 /* 1st HP CC FP register store. After this
1824 instruction we've set enough state that the GCC and
1825 HPCC code are both handled in the same manner. */
1826 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
1831 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1836 /* Quit if we hit any kind of branch the previous iteration. */
1837 if (final_iteration
)
1839 /* We want to look precisely one instruction beyond the branch
1840 if we have not found everything yet. */
1841 if (is_branch (inst
))
1842 final_iteration
= 1;
1847 /* The frame base always represents the value of %sp at entry to
1848 the current function (and is thus equivalent to the "saved"
1850 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1854 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1855 "prologue_end=0x%s) ",
1857 paddr_nz (frame_pc_unwind (next_frame
)),
1858 paddr_nz (prologue_end
));
1860 /* Check to see if a frame pointer is available, and use it for
1861 frame unwinding if it is.
1863 There are some situations where we need to rely on the frame
1864 pointer to do stack unwinding. For example, if a function calls
1865 alloca (), the stack pointer can get adjusted inside the body of
1866 the function. In this case, the ABI requires that the compiler
1867 maintain a frame pointer for the function.
1869 The unwind record has a flag (alloca_frame) that indicates that
1870 a function has a variable frame; unfortunately, gcc/binutils
1871 does not set this flag. Instead, whenever a frame pointer is used
1872 and saved on the stack, the Save_SP flag is set. We use this to
1873 decide whether to use the frame pointer for unwinding.
1875 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1876 instead of Save_SP. */
1878 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
1880 if (frame_pc_unwind (next_frame
) >= prologue_end
1881 && u
->Save_SP
&& fp
!= 0)
1886 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer] }",
1887 paddr_nz (cache
->base
));
1890 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1892 /* Both we're expecting the SP to be saved and the SP has been
1893 saved. The entry SP value is saved at this frame's SP
1895 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1898 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved] }",
1899 paddr_nz (cache
->base
));
1903 /* The prologue has been slowly allocating stack space. Adjust
1905 cache
->base
= this_sp
- frame_size
;
1907 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust] } ",
1908 paddr_nz (cache
->base
));
1911 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1914 /* The PC is found in the "return register", "Millicode" uses "r31"
1915 as the return register while normal code uses "rp". */
1918 if (trad_frame_addr_p (cache
->saved_regs
, 31))
1919 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1922 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
1923 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
1928 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1929 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1932 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1933 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1937 /* If Save_SP is set, then we expect the frame pointer to be saved in the
1938 frame. However, there is a one-insn window where we haven't saved it
1939 yet, but we've already clobbered it. Detect this case and fix it up.
1941 The prologue sequence for frame-pointer functions is:
1942 0: stw %rp, -20(%sp)
1945 c: stw,ma %r1, XX(%sp)
1947 So if we are at offset c, the r3 value that we want is not yet saved
1948 on the stack, but it's been overwritten. The prologue analyzer will
1949 set fp_in_r1 when it sees the copy insn so we know to get the value
1951 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
1954 ULONGEST r1
= frame_unwind_register_unsigned (next_frame
, 1);
1955 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
1959 /* Convert all the offsets into addresses. */
1961 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1963 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1964 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1969 struct gdbarch
*gdbarch
;
1970 struct gdbarch_tdep
*tdep
;
1972 gdbarch
= get_frame_arch (next_frame
);
1973 tdep
= gdbarch_tdep (gdbarch
);
1975 if (tdep
->unwind_adjust_stub
)
1977 tdep
->unwind_adjust_stub (next_frame
, cache
->base
, cache
->saved_regs
);
1982 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1983 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1984 return (*this_cache
);
1988 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1989 struct frame_id
*this_id
)
1991 struct hppa_frame_cache
*info
;
1992 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1993 struct unwind_table_entry
*u
;
1995 info
= hppa_frame_cache (next_frame
, this_cache
);
1996 u
= find_unwind_entry (pc
);
1998 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
2002 hppa_frame_prev_register (struct frame_info
*next_frame
,
2004 int regnum
, int *optimizedp
,
2005 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2006 int *realnump
, void *valuep
)
2008 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
2009 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2010 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2013 static const struct frame_unwind hppa_frame_unwind
=
2017 hppa_frame_prev_register
2020 static const struct frame_unwind
*
2021 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
2023 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2025 if (find_unwind_entry (pc
))
2026 return &hppa_frame_unwind
;
2031 /* This is a generic fallback frame unwinder that kicks in if we fail all
2032 the other ones. Normally we would expect the stub and regular unwinder
2033 to work, but in some cases we might hit a function that just doesn't
2034 have any unwind information available. In this case we try to do
2035 unwinding solely based on code reading. This is obviously going to be
2036 slow, so only use this as a last resort. Currently this will only
2037 identify the stack and pc for the frame. */
2039 static struct hppa_frame_cache
*
2040 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
2042 struct hppa_frame_cache
*cache
;
2043 unsigned int frame_size
;
2045 CORE_ADDR pc
, start_pc
, end_pc
, cur_pc
;
2048 fprintf_unfiltered (gdb_stdlog
, "{ hppa_fallback_frame_cache (frame=%d)-> ",
2049 frame_relative_level(next_frame
));
2051 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2052 (*this_cache
) = cache
;
2053 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2055 pc
= frame_func_unwind (next_frame
);
2056 cur_pc
= frame_pc_unwind (next_frame
);
2060 find_pc_partial_function (pc
, NULL
, &start_pc
, &end_pc
);
2062 if (start_pc
== 0 || end_pc
== 0)
2064 error ("Cannot find bounds of current function (@0x%s), unwinding will "
2065 "fail.", paddr_nz (pc
));
2069 if (end_pc
> cur_pc
)
2072 for (pc
= start_pc
; pc
< end_pc
; pc
+= 4)
2076 insn
= read_memory_unsigned_integer (pc
, 4);
2078 frame_size
+= prologue_inst_adjust_sp (insn
);
2080 /* There are limited ways to store the return pointer into the
2082 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2084 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2087 else if (insn
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
2089 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2095 fprintf_unfiltered (gdb_stdlog
, " frame_size = %d, found_rp = %d }\n",
2096 frame_size
, found_rp
);
2098 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
) - frame_size
;
2099 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2101 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2103 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2104 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
2108 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2109 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2116 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2117 struct frame_id
*this_id
)
2119 struct hppa_frame_cache
*info
=
2120 hppa_fallback_frame_cache (next_frame
, this_cache
);
2121 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2125 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
2127 int regnum
, int *optimizedp
,
2128 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2129 int *realnump
, void *valuep
)
2131 struct hppa_frame_cache
*info
=
2132 hppa_fallback_frame_cache (next_frame
, this_cache
);
2133 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2134 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2137 static const struct frame_unwind hppa_fallback_frame_unwind
=
2140 hppa_fallback_frame_this_id
,
2141 hppa_fallback_frame_prev_register
2144 static const struct frame_unwind
*
2145 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2147 return &hppa_fallback_frame_unwind
;
2150 /* Stub frames, used for all kinds of call stubs. */
2151 struct hppa_stub_unwind_cache
2154 struct trad_frame_saved_reg
*saved_regs
;
2157 static struct hppa_stub_unwind_cache
*
2158 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2161 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2162 struct hppa_stub_unwind_cache
*info
;
2163 struct unwind_table_entry
*u
;
2168 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2170 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2172 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2174 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2176 /* HPUX uses export stubs in function calls; the export stub clobbers
2177 the return value of the caller, and, later restores it from the
2179 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2181 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2183 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2189 /* By default we assume that stubs do not change the rp. */
2190 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2196 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2197 void **this_prologue_cache
,
2198 struct frame_id
*this_id
)
2200 struct hppa_stub_unwind_cache
*info
2201 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2204 *this_id
= frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2206 *this_id
= null_frame_id
;
2210 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2211 void **this_prologue_cache
,
2212 int regnum
, int *optimizedp
,
2213 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2214 int *realnump
, void *valuep
)
2216 struct hppa_stub_unwind_cache
*info
2217 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2220 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2221 optimizedp
, lvalp
, addrp
, realnump
,
2224 error ("Requesting registers from null frame.\n");
2227 static const struct frame_unwind hppa_stub_frame_unwind
= {
2229 hppa_stub_frame_this_id
,
2230 hppa_stub_frame_prev_register
2233 static const struct frame_unwind
*
2234 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2236 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2237 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2238 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2241 || (tdep
->in_solib_call_trampoline
!= NULL
2242 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2243 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2244 return &hppa_stub_frame_unwind
;
2248 static struct frame_id
2249 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2251 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2253 frame_pc_unwind (next_frame
));
2257 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2262 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2263 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2265 /* If the current instruction is nullified, then we are effectively
2266 still executing the previous instruction. Pretend we are still
2267 there. This is needed when single stepping; if the nullified
2268 instruction is on a different line, we don't want GDB to think
2269 we've stepped onto that line. */
2270 if (ipsw
& 0x00200000)
2276 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2277 Return NULL if no such symbol was found. */
2279 struct minimal_symbol
*
2280 hppa_lookup_stub_minimal_symbol (const char *name
,
2281 enum unwind_stub_types stub_type
)
2283 struct objfile
*objfile
;
2284 struct minimal_symbol
*msym
;
2286 ALL_MSYMBOLS (objfile
, msym
)
2288 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2290 struct unwind_table_entry
*u
;
2292 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2293 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2301 /* Instead of this nasty cast, add a method pvoid() that prints out a
2302 host VOID data type (remember %p isn't portable). */
2305 hppa_pointer_to_address_hack (void *ptr
)
2307 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2308 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2312 unwind_command (char *exp
, int from_tty
)
2315 struct unwind_table_entry
*u
;
2317 /* If we have an expression, evaluate it and use it as the address. */
2319 if (exp
!= 0 && *exp
!= 0)
2320 address
= parse_and_eval_address (exp
);
2324 u
= find_unwind_entry (address
);
2328 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2332 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2333 paddr_nz (hppa_pointer_to_address_hack (u
)));
2335 printf_unfiltered ("\tregion_start = ");
2336 print_address (u
->region_start
, gdb_stdout
);
2337 gdb_flush (gdb_stdout
);
2339 printf_unfiltered ("\n\tregion_end = ");
2340 print_address (u
->region_end
, gdb_stdout
);
2341 gdb_flush (gdb_stdout
);
2343 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2345 printf_unfiltered ("\n\tflags =");
2346 pif (Cannot_unwind
);
2348 pif (Millicode_save_sr0
);
2351 pif (Variable_Frame
);
2352 pif (Separate_Package_Body
);
2353 pif (Frame_Extension_Millicode
);
2354 pif (Stack_Overflow_Check
);
2355 pif (Two_Instruction_SP_Increment
);
2359 pif (Save_MRP_in_frame
);
2360 pif (extn_ptr_defined
);
2361 pif (Cleanup_defined
);
2362 pif (MPE_XL_interrupt_marker
);
2363 pif (HP_UX_interrupt_marker
);
2366 putchar_unfiltered ('\n');
2368 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2370 pin (Region_description
);
2373 pin (Total_frame_size
);
2375 if (u
->stub_unwind
.stub_type
)
2377 printf_unfiltered ("\tstub type = ");
2378 switch (u
->stub_unwind
.stub_type
)
2381 printf_unfiltered ("long branch\n");
2383 case PARAMETER_RELOCATION
:
2384 printf_unfiltered ("parameter relocation\n");
2387 printf_unfiltered ("export\n");
2390 printf_unfiltered ("import\n");
2393 printf_unfiltered ("import shlib\n");
2396 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2402 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2404 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2406 An example of this occurs when an a.out is linked against a foo.sl.
2407 The foo.sl defines a global bar(), and the a.out declares a signature
2408 for bar(). However, the a.out doesn't directly call bar(), but passes
2409 its address in another call.
2411 If you have this scenario and attempt to "break bar" before running,
2412 gdb will find a minimal symbol for bar() in the a.out. But that
2413 symbol's address will be negative. What this appears to denote is
2414 an index backwards from the base of the procedure linkage table (PLT)
2415 into the data linkage table (DLT), the end of which is contiguous
2416 with the start of the PLT. This is clearly not a valid address for
2417 us to set a breakpoint on.
2419 Note that one must be careful in how one checks for a negative address.
2420 0xc0000000 is a legitimate address of something in a shared text
2421 segment, for example. Since I don't know what the possible range
2422 is of these "really, truly negative" addresses that come from the
2423 minimal symbols, I'm resorting to the gross hack of checking the
2424 top byte of the address for all 1's. Sigh. */
2426 return (!target_has_stack
&& (pc
& 0xFF000000));
2429 /* Return the GDB type object for the "standard" data type of data
2432 static struct type
*
2433 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2435 if (reg_nr
< HPPA_FP4_REGNUM
)
2436 return builtin_type_uint32
;
2438 return builtin_type_ieee_single_big
;
2441 /* Return the GDB type object for the "standard" data type of data
2442 in register N. hppa64 version. */
2444 static struct type
*
2445 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2447 if (reg_nr
< HPPA_FP4_REGNUM
)
2448 return builtin_type_uint64
;
2450 return builtin_type_ieee_double_big
;
2453 /* Return True if REGNUM is not a register available to the user
2454 through ptrace(). */
2457 hppa_cannot_store_register (int regnum
)
2460 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2461 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2462 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2467 hppa_smash_text_address (CORE_ADDR addr
)
2469 /* The low two bits of the PC on the PA contain the privilege level.
2470 Some genius implementing a (non-GCC) compiler apparently decided
2471 this means that "addresses" in a text section therefore include a
2472 privilege level, and thus symbol tables should contain these bits.
2473 This seems like a bonehead thing to do--anyway, it seems to work
2474 for our purposes to just ignore those bits. */
2476 return (addr
&= ~0x3);
2479 /* Get the ith function argument for the current function. */
2481 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2485 get_frame_register (frame
, HPPA_R0_REGNUM
+ 26 - argi
, &addr
);
2490 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2491 int regnum
, void *buf
)
2495 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2496 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2498 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2502 hppa_find_global_pointer (struct value
*function
)
2508 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2509 struct trad_frame_saved_reg saved_regs
[],
2510 int regnum
, int *optimizedp
,
2511 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2512 int *realnump
, void *valuep
)
2514 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2520 trad_frame_get_prev_register (next_frame
, saved_regs
,
2521 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2522 lvalp
, addrp
, realnump
, valuep
);
2524 pc
= extract_unsigned_integer (valuep
, 4);
2525 store_unsigned_integer (valuep
, 4, pc
+ 4);
2528 /* It's a computed value. */
2536 /* Make sure the "flags" register is zero in all unwound frames.
2537 The "flags" registers is a HP-UX specific wart, and only the code
2538 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2539 with it here. This shouldn't affect other systems since those
2540 should provide zero for the "flags" register anyway. */
2541 if (regnum
== HPPA_FLAGS_REGNUM
)
2544 store_unsigned_integer (valuep
,
2545 register_size (get_frame_arch (next_frame
),
2549 /* It's a computed value. */
2557 trad_frame_get_prev_register (next_frame
, saved_regs
, regnum
,
2558 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2562 /* Here is a table of C type sizes on hppa with various compiles
2563 and options. I measured this on PA 9000/800 with HP-UX 11.11
2564 and these compilers:
2566 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2567 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2568 /opt/aCC/bin/aCC B3910B A.03.45
2569 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2571 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2572 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2573 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2574 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2575 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2576 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2577 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2578 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2582 compiler and options
2583 char, short, int, long, long long
2584 float, double, long double
2587 So all these compilers use either ILP32 or LP64 model.
2588 TODO: gcc has more options so it needs more investigation.
2590 For floating point types, see:
2592 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2593 HP-UX floating-point guide, hpux 11.00
2595 -- chastain 2003-12-18 */
2597 static struct gdbarch
*
2598 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2600 struct gdbarch_tdep
*tdep
;
2601 struct gdbarch
*gdbarch
;
2603 /* Try to determine the ABI of the object we are loading. */
2604 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2606 /* If it's a SOM file, assume it's HP/UX SOM. */
2607 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2608 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2611 /* find a candidate among the list of pre-declared architectures. */
2612 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2614 return (arches
->gdbarch
);
2616 /* If none found, then allocate and initialize one. */
2617 tdep
= XZALLOC (struct gdbarch_tdep
);
2618 gdbarch
= gdbarch_alloc (&info
, tdep
);
2620 /* Determine from the bfd_arch_info structure if we are dealing with
2621 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2622 then default to a 32bit machine. */
2623 if (info
.bfd_arch_info
!= NULL
)
2624 tdep
->bytes_per_address
=
2625 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2627 tdep
->bytes_per_address
= 4;
2629 tdep
->find_global_pointer
= hppa_find_global_pointer
;
2631 /* Some parts of the gdbarch vector depend on whether we are running
2632 on a 32 bits or 64 bits target. */
2633 switch (tdep
->bytes_per_address
)
2636 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2637 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2638 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2641 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2642 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2643 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2646 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2647 tdep
->bytes_per_address
);
2650 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2651 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2653 /* The following gdbarch vector elements are the same in both ILP32
2654 and LP64, but might show differences some day. */
2655 set_gdbarch_long_long_bit (gdbarch
, 64);
2656 set_gdbarch_long_double_bit (gdbarch
, 128);
2657 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2659 /* The following gdbarch vector elements do not depend on the address
2660 size, or in any other gdbarch element previously set. */
2661 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2662 set_gdbarch_in_function_epilogue_p (gdbarch
,
2663 hppa_in_function_epilogue_p
);
2664 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2665 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2666 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2667 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2668 set_gdbarch_cannot_fetch_register (gdbarch
, hppa_cannot_store_register
);
2669 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2670 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2671 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2672 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
2673 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
2675 /* Helper for function argument information. */
2676 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2678 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2680 /* When a hardware watchpoint triggers, we'll move the inferior past
2681 it by removing all eventpoints; stepping past the instruction
2682 that caused the trigger; reinserting eventpoints; and checking
2683 whether any watched location changed. */
2684 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2686 /* Inferior function call methods. */
2687 switch (tdep
->bytes_per_address
)
2690 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2691 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2692 set_gdbarch_convert_from_func_ptr_addr
2693 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
2696 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2697 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2700 internal_error (__FILE__
, __LINE__
, "bad switch");
2703 /* Struct return methods. */
2704 switch (tdep
->bytes_per_address
)
2707 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2710 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2713 internal_error (__FILE__
, __LINE__
, "bad switch");
2716 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2717 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2719 /* Frame unwind methods. */
2720 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2721 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2723 /* Hook in ABI-specific overrides, if they have been registered. */
2724 gdbarch_init_osabi (info
, gdbarch
);
2726 /* Hook in the default unwinders. */
2727 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2728 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2729 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
2735 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2737 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2739 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2740 tdep
->bytes_per_address
);
2741 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2745 _initialize_hppa_tdep (void)
2747 struct cmd_list_element
*c
;
2749 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2751 hppa_objfile_priv_data
= register_objfile_data ();
2753 add_cmd ("unwind", class_maintenance
, unwind_command
,
2754 "Print unwind table entry at given address.",
2755 &maintenanceprintlist
);
2757 /* Debug this files internals. */
2758 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, "\
2759 Set whether hppa target specific debugging information should be displayed.", "\
2760 Show whether hppa target specific debugging information is displayed.", "\
2761 This flag controls whether hppa target specific debugging information is\n\
2762 displayed. This information is particularly useful for debugging frame\n\
2763 unwinding problems.", "hppa debug flag is %s.",
2764 NULL
, NULL
, &setdebuglist
, &showdebuglist
);