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
;
341 else if (gdbarch_tdep (current_gdbarch
)->solib_get_text_base
)
343 text_offset
= gdbarch_tdep (current_gdbarch
)->solib_get_text_base (objfile
);
346 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
348 /* Now internalize the information being careful to handle host/target
350 for (i
= 0; i
< entries
; i
++)
352 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
354 table
[i
].region_start
+= text_offset
;
356 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
357 table
[i
].region_end
+= text_offset
;
359 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
361 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
362 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
363 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
364 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
365 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
366 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
367 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
368 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
369 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
370 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
371 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
372 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
373 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
374 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
375 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
376 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
377 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
378 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
379 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
380 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
381 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
382 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
383 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
384 table
[i
].Cleanup_defined
= tmp
& 0x1;
385 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
387 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
388 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
389 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
390 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
391 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
392 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
394 /* Stub unwinds are handled elsewhere. */
395 table
[i
].stub_unwind
.stub_type
= 0;
396 table
[i
].stub_unwind
.padding
= 0;
401 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
402 the object file. This info is used mainly by find_unwind_entry() to find
403 out the stack frame size and frame pointer used by procedures. We put
404 everything on the psymbol obstack in the objfile so that it automatically
405 gets freed when the objfile is destroyed. */
408 read_unwind_info (struct objfile
*objfile
)
410 asection
*unwind_sec
, *stub_unwind_sec
;
411 unsigned unwind_size
, stub_unwind_size
, total_size
;
412 unsigned index
, unwind_entries
;
413 unsigned stub_entries
, total_entries
;
414 CORE_ADDR text_offset
;
415 struct hppa_unwind_info
*ui
;
416 struct hppa_objfile_private
*obj_private
;
418 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
419 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
420 sizeof (struct hppa_unwind_info
));
426 /* For reasons unknown the HP PA64 tools generate multiple unwinder
427 sections in a single executable. So we just iterate over every
428 section in the BFD looking for unwinder sections intead of trying
429 to do a lookup with bfd_get_section_by_name.
431 First determine the total size of the unwind tables so that we
432 can allocate memory in a nice big hunk. */
434 for (unwind_sec
= objfile
->obfd
->sections
;
436 unwind_sec
= unwind_sec
->next
)
438 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
439 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
441 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
442 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
444 total_entries
+= unwind_entries
;
448 /* Now compute the size of the stub unwinds. Note the ELF tools do not
449 use stub unwinds at the curren time. */
450 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
454 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
455 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
459 stub_unwind_size
= 0;
463 /* Compute total number of unwind entries and their total size. */
464 total_entries
+= stub_entries
;
465 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
467 /* Allocate memory for the unwind table. */
468 ui
->table
= (struct unwind_table_entry
*)
469 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
470 ui
->last
= total_entries
- 1;
472 /* Now read in each unwind section and internalize the standard unwind
475 for (unwind_sec
= objfile
->obfd
->sections
;
477 unwind_sec
= unwind_sec
->next
)
479 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
480 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
482 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
483 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
485 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
486 unwind_entries
, unwind_size
, text_offset
);
487 index
+= unwind_entries
;
491 /* Now read in and internalize the stub unwind entries. */
492 if (stub_unwind_size
> 0)
495 char *buf
= alloca (stub_unwind_size
);
497 /* Read in the stub unwind entries. */
498 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
499 0, stub_unwind_size
);
501 /* Now convert them into regular unwind entries. */
502 for (i
= 0; i
< stub_entries
; i
++, index
++)
504 /* Clear out the next unwind entry. */
505 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
507 /* Convert offset & size into region_start and region_end.
508 Stuff away the stub type into "reserved" fields. */
509 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
511 ui
->table
[index
].region_start
+= text_offset
;
513 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
516 ui
->table
[index
].region_end
517 = ui
->table
[index
].region_start
+ 4 *
518 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
524 /* Unwind table needs to be kept sorted. */
525 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
526 compare_unwind_entries
);
528 /* Keep a pointer to the unwind information. */
529 obj_private
= (struct hppa_objfile_private
*)
530 objfile_data (objfile
, hppa_objfile_priv_data
);
531 if (obj_private
== NULL
)
533 obj_private
= (struct hppa_objfile_private
*)
534 obstack_alloc (&objfile
->objfile_obstack
,
535 sizeof (struct hppa_objfile_private
));
536 set_objfile_data (objfile
, hppa_objfile_priv_data
, obj_private
);
537 obj_private
->unwind_info
= NULL
;
538 obj_private
->so_info
= NULL
;
541 obj_private
->unwind_info
= ui
;
544 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
545 of the objfiles seeking the unwind table entry for this PC. Each objfile
546 contains a sorted list of struct unwind_table_entry. Since we do a binary
547 search of the unwind tables, we depend upon them to be sorted. */
549 struct unwind_table_entry
*
550 find_unwind_entry (CORE_ADDR pc
)
552 int first
, middle
, last
;
553 struct objfile
*objfile
;
554 struct hppa_objfile_private
*priv
;
557 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
560 /* A function at address 0? Not in HP-UX! */
561 if (pc
== (CORE_ADDR
) 0)
564 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
568 ALL_OBJFILES (objfile
)
570 struct hppa_unwind_info
*ui
;
572 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
574 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
578 read_unwind_info (objfile
);
579 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
581 error ("Internal error reading unwind information.");
582 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
585 /* First, check the cache */
588 && pc
>= ui
->cache
->region_start
589 && pc
<= ui
->cache
->region_end
)
592 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
593 paddr_nz ((CORE_ADDR
) ui
->cache
));
597 /* Not in the cache, do a binary search */
602 while (first
<= last
)
604 middle
= (first
+ last
) / 2;
605 if (pc
>= ui
->table
[middle
].region_start
606 && pc
<= ui
->table
[middle
].region_end
)
608 ui
->cache
= &ui
->table
[middle
];
610 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
611 paddr_nz ((CORE_ADDR
) ui
->cache
));
612 return &ui
->table
[middle
];
615 if (pc
< ui
->table
[middle
].region_start
)
620 } /* ALL_OBJFILES() */
623 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
628 /* The epilogue is defined here as the area either on the `bv' instruction
629 itself or an instruction which destroys the function's stack frame.
631 We do not assume that the epilogue is at the end of a function as we can
632 also have return sequences in the middle of a function. */
634 hppa_in_function_epilogue_p (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
636 unsigned long status
;
641 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
645 inst
= extract_unsigned_integer (buf
, 4);
647 /* The most common way to perform a stack adjustment ldo X(sp),sp
648 We are destroying a stack frame if the offset is negative. */
649 if ((inst
& 0xffffc000) == 0x37de0000
650 && hppa_extract_14 (inst
) < 0)
653 /* ldw,mb D(sp),X or ldd,mb D(sp),X */
654 if (((inst
& 0x0fc010e0) == 0x0fc010e0
655 || (inst
& 0x0fc010e0) == 0x0fc010e0)
656 && hppa_extract_14 (inst
) < 0)
659 /* bv %r0(%rp) or bv,n %r0(%rp) */
660 if (inst
== 0xe840c000 || inst
== 0xe840c002)
666 static const unsigned char *
667 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
669 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
670 (*len
) = sizeof (breakpoint
);
674 /* Return the name of a register. */
677 hppa32_register_name (int i
)
679 static char *names
[] = {
680 "flags", "r1", "rp", "r3",
681 "r4", "r5", "r6", "r7",
682 "r8", "r9", "r10", "r11",
683 "r12", "r13", "r14", "r15",
684 "r16", "r17", "r18", "r19",
685 "r20", "r21", "r22", "r23",
686 "r24", "r25", "r26", "dp",
687 "ret0", "ret1", "sp", "r31",
688 "sar", "pcoqh", "pcsqh", "pcoqt",
689 "pcsqt", "eiem", "iir", "isr",
690 "ior", "ipsw", "goto", "sr4",
691 "sr0", "sr1", "sr2", "sr3",
692 "sr5", "sr6", "sr7", "cr0",
693 "cr8", "cr9", "ccr", "cr12",
694 "cr13", "cr24", "cr25", "cr26",
695 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
696 "fpsr", "fpe1", "fpe2", "fpe3",
697 "fpe4", "fpe5", "fpe6", "fpe7",
698 "fr4", "fr4R", "fr5", "fr5R",
699 "fr6", "fr6R", "fr7", "fr7R",
700 "fr8", "fr8R", "fr9", "fr9R",
701 "fr10", "fr10R", "fr11", "fr11R",
702 "fr12", "fr12R", "fr13", "fr13R",
703 "fr14", "fr14R", "fr15", "fr15R",
704 "fr16", "fr16R", "fr17", "fr17R",
705 "fr18", "fr18R", "fr19", "fr19R",
706 "fr20", "fr20R", "fr21", "fr21R",
707 "fr22", "fr22R", "fr23", "fr23R",
708 "fr24", "fr24R", "fr25", "fr25R",
709 "fr26", "fr26R", "fr27", "fr27R",
710 "fr28", "fr28R", "fr29", "fr29R",
711 "fr30", "fr30R", "fr31", "fr31R"
713 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
720 hppa64_register_name (int i
)
722 static char *names
[] = {
723 "flags", "r1", "rp", "r3",
724 "r4", "r5", "r6", "r7",
725 "r8", "r9", "r10", "r11",
726 "r12", "r13", "r14", "r15",
727 "r16", "r17", "r18", "r19",
728 "r20", "r21", "r22", "r23",
729 "r24", "r25", "r26", "dp",
730 "ret0", "ret1", "sp", "r31",
731 "sar", "pcoqh", "pcsqh", "pcoqt",
732 "pcsqt", "eiem", "iir", "isr",
733 "ior", "ipsw", "goto", "sr4",
734 "sr0", "sr1", "sr2", "sr3",
735 "sr5", "sr6", "sr7", "cr0",
736 "cr8", "cr9", "ccr", "cr12",
737 "cr13", "cr24", "cr25", "cr26",
738 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
739 "fpsr", "fpe1", "fpe2", "fpe3",
740 "fr4", "fr5", "fr6", "fr7",
741 "fr8", "fr9", "fr10", "fr11",
742 "fr12", "fr13", "fr14", "fr15",
743 "fr16", "fr17", "fr18", "fr19",
744 "fr20", "fr21", "fr22", "fr23",
745 "fr24", "fr25", "fr26", "fr27",
746 "fr28", "fr29", "fr30", "fr31"
748 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
754 /* This function pushes a stack frame with arguments as part of the
755 inferior function calling mechanism.
757 This is the version of the function for the 32-bit PA machines, in
758 which later arguments appear at lower addresses. (The stack always
759 grows towards higher addresses.)
761 We simply allocate the appropriate amount of stack space and put
762 arguments into their proper slots. */
765 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
766 struct regcache
*regcache
, CORE_ADDR bp_addr
,
767 int nargs
, struct value
**args
, CORE_ADDR sp
,
768 int struct_return
, CORE_ADDR struct_addr
)
770 /* Stack base address at which any pass-by-reference parameters are
772 CORE_ADDR struct_end
= 0;
773 /* Stack base address at which the first parameter is stored. */
774 CORE_ADDR param_end
= 0;
776 /* The inner most end of the stack after all the parameters have
778 CORE_ADDR new_sp
= 0;
780 /* Two passes. First pass computes the location of everything,
781 second pass writes the bytes out. */
784 /* Global pointer (r19) of the function we are trying to call. */
787 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
789 for (write_pass
= 0; write_pass
< 2; write_pass
++)
791 CORE_ADDR struct_ptr
= 0;
792 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
793 struct_ptr is adjusted for each argument below, so the first
794 argument will end up at sp-36. */
795 CORE_ADDR param_ptr
= 32;
797 int small_struct
= 0;
799 for (i
= 0; i
< nargs
; i
++)
801 struct value
*arg
= args
[i
];
802 struct type
*type
= check_typedef (value_type (arg
));
803 /* The corresponding parameter that is pushed onto the
804 stack, and [possibly] passed in a register. */
807 memset (param_val
, 0, sizeof param_val
);
808 if (TYPE_LENGTH (type
) > 8)
810 /* Large parameter, pass by reference. Store the value
811 in "struct" area and then pass its address. */
813 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
815 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
817 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
819 else if (TYPE_CODE (type
) == TYPE_CODE_INT
820 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
822 /* Integer value store, right aligned. "unpack_long"
823 takes care of any sign-extension problems. */
824 param_len
= align_up (TYPE_LENGTH (type
), 4);
825 store_unsigned_integer (param_val
, param_len
,
827 VALUE_CONTENTS (arg
)));
829 else if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
831 /* Floating point value store, right aligned. */
832 param_len
= align_up (TYPE_LENGTH (type
), 4);
833 memcpy (param_val
, VALUE_CONTENTS (arg
), param_len
);
837 param_len
= align_up (TYPE_LENGTH (type
), 4);
839 /* Small struct value are stored right-aligned. */
840 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
841 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
843 /* Structures of size 5, 6 and 7 bytes are special in that
844 the higher-ordered word is stored in the lower-ordered
845 argument, and even though it is a 8-byte quantity the
846 registers need not be 8-byte aligned. */
847 if (param_len
> 4 && param_len
< 8)
851 param_ptr
+= param_len
;
852 if (param_len
== 8 && !small_struct
)
853 param_ptr
= align_up (param_ptr
, 8);
855 /* First 4 non-FP arguments are passed in gr26-gr23.
856 First 4 32-bit FP arguments are passed in fr4L-fr7L.
857 First 2 64-bit FP arguments are passed in fr5 and fr7.
859 The rest go on the stack, starting at sp-36, towards lower
860 addresses. 8-byte arguments must be aligned to a 8-byte
864 write_memory (param_end
- param_ptr
, param_val
, param_len
);
866 /* There are some cases when we don't know the type
867 expected by the callee (e.g. for variadic functions), so
868 pass the parameters in both general and fp regs. */
871 int grreg
= 26 - (param_ptr
- 36) / 4;
872 int fpLreg
= 72 + (param_ptr
- 36) / 4 * 2;
873 int fpreg
= 74 + (param_ptr
- 32) / 8 * 4;
875 regcache_cooked_write (regcache
, grreg
, param_val
);
876 regcache_cooked_write (regcache
, fpLreg
, param_val
);
880 regcache_cooked_write (regcache
, grreg
+ 1,
883 regcache_cooked_write (regcache
, fpreg
, param_val
);
884 regcache_cooked_write (regcache
, fpreg
+ 1,
891 /* Update the various stack pointers. */
894 struct_end
= sp
+ align_up (struct_ptr
, 64);
895 /* PARAM_PTR already accounts for all the arguments passed
896 by the user. However, the ABI mandates minimum stack
897 space allocations for outgoing arguments. The ABI also
898 mandates minimum stack alignments which we must
900 param_end
= struct_end
+ align_up (param_ptr
, 64);
904 /* If a structure has to be returned, set up register 28 to hold its
907 write_register (28, struct_addr
);
909 gp
= tdep
->find_global_pointer (function
);
912 write_register (19, gp
);
914 /* Set the return address. */
915 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
917 /* Update the Stack Pointer. */
918 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
);
923 /* This function pushes a stack frame with arguments as part of the
924 inferior function calling mechanism.
926 This is the version for the PA64, in which later arguments appear
927 at higher addresses. (The stack always grows towards higher
930 We simply allocate the appropriate amount of stack space and put
931 arguments into their proper slots.
933 This ABI also requires that the caller provide an argument pointer
934 to the callee, so we do that too. */
937 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
938 struct regcache
*regcache
, CORE_ADDR bp_addr
,
939 int nargs
, struct value
**args
, CORE_ADDR sp
,
940 int struct_return
, CORE_ADDR struct_addr
)
942 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
943 reverse engineering testsuite failures. */
945 /* Stack base address at which any pass-by-reference parameters are
947 CORE_ADDR struct_end
= 0;
948 /* Stack base address at which the first parameter is stored. */
949 CORE_ADDR param_end
= 0;
951 /* The inner most end of the stack after all the parameters have
953 CORE_ADDR new_sp
= 0;
955 /* Two passes. First pass computes the location of everything,
956 second pass writes the bytes out. */
958 for (write_pass
= 0; write_pass
< 2; write_pass
++)
960 CORE_ADDR struct_ptr
= 0;
961 CORE_ADDR param_ptr
= 0;
963 for (i
= 0; i
< nargs
; i
++)
965 struct value
*arg
= args
[i
];
966 struct type
*type
= check_typedef (value_type (arg
));
967 if ((TYPE_CODE (type
) == TYPE_CODE_INT
968 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
969 && TYPE_LENGTH (type
) <= 8)
971 /* Integer value store, right aligned. "unpack_long"
972 takes care of any sign-extension problems. */
976 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
977 int reg
= 27 - param_ptr
/ 8;
978 write_memory_unsigned_integer (param_end
- param_ptr
,
981 regcache_cooked_write_unsigned (regcache
, reg
, val
);
986 /* Small struct value, store left aligned? */
988 if (TYPE_LENGTH (type
) > 8)
990 param_ptr
= align_up (param_ptr
, 16);
991 reg
= 26 - param_ptr
/ 8;
992 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
996 param_ptr
= align_up (param_ptr
, 8);
997 reg
= 26 - param_ptr
/ 8;
998 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
1003 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
1004 TYPE_LENGTH (type
));
1005 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
1009 int len
= min (8, TYPE_LENGTH (type
) - byte
);
1010 regcache_cooked_write_part (regcache
, reg
, 0, len
,
1011 VALUE_CONTENTS (arg
) + byte
);
1018 /* Update the various stack pointers. */
1021 struct_end
= sp
+ struct_ptr
;
1022 /* PARAM_PTR already accounts for all the arguments passed
1023 by the user. However, the ABI mandates minimum stack
1024 space allocations for outgoing arguments. The ABI also
1025 mandates minimum stack alignments which we must
1027 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
1031 /* If a structure has to be returned, set up register 28 to hold its
1034 write_register (28, struct_addr
);
1036 /* Set the return address. */
1037 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, bp_addr
);
1039 /* Update the Stack Pointer. */
1040 regcache_cooked_write_unsigned (regcache
, HPPA_SP_REGNUM
, param_end
+ 64);
1042 /* The stack will have 32 bytes of additional space for a frame marker. */
1043 return param_end
+ 64;
1047 hppa32_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
1049 struct target_ops
*targ
)
1056 target_read_memory(plabel
, (char *)&addr
, 4);
1063 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1065 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1067 return align_up (addr
, 64);
1070 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1073 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1075 /* Just always 16-byte align. */
1076 return align_up (addr
, 16);
1080 hppa_read_pc (ptid_t ptid
)
1085 ipsw
= read_register_pid (HPPA_IPSW_REGNUM
, ptid
);
1086 pc
= read_register_pid (HPPA_PCOQ_HEAD_REGNUM
, ptid
);
1088 /* If the current instruction is nullified, then we are effectively
1089 still executing the previous instruction. Pretend we are still
1090 there. This is needed when single stepping; if the nullified
1091 instruction is on a different line, we don't want GDB to think
1092 we've stepped onto that line. */
1093 if (ipsw
& 0x00200000)
1100 hppa_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1102 write_register_pid (HPPA_PCOQ_HEAD_REGNUM
, pc
, ptid
);
1103 write_register_pid (HPPA_PCOQ_TAIL_REGNUM
, pc
+ 4, ptid
);
1106 /* return the alignment of a type in bytes. Structures have the maximum
1107 alignment required by their fields. */
1110 hppa_alignof (struct type
*type
)
1112 int max_align
, align
, i
;
1113 CHECK_TYPEDEF (type
);
1114 switch (TYPE_CODE (type
))
1119 return TYPE_LENGTH (type
);
1120 case TYPE_CODE_ARRAY
:
1121 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1122 case TYPE_CODE_STRUCT
:
1123 case TYPE_CODE_UNION
:
1125 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1127 /* Bit fields have no real alignment. */
1128 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1129 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1131 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1132 max_align
= max (max_align
, align
);
1141 /* For the given instruction (INST), return any adjustment it makes
1142 to the stack pointer or zero for no adjustment.
1144 This only handles instructions commonly found in prologues. */
1147 prologue_inst_adjust_sp (unsigned long inst
)
1149 /* This must persist across calls. */
1150 static int save_high21
;
1152 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1153 if ((inst
& 0xffffc000) == 0x37de0000)
1154 return hppa_extract_14 (inst
);
1157 if ((inst
& 0xffe00000) == 0x6fc00000)
1158 return hppa_extract_14 (inst
);
1160 /* std,ma X,D(sp) */
1161 if ((inst
& 0xffe00008) == 0x73c00008)
1162 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1164 /* addil high21,%r1; ldo low11,(%r1),%r30)
1165 save high bits in save_high21 for later use. */
1166 if ((inst
& 0xffe00000) == 0x28200000)
1168 save_high21
= hppa_extract_21 (inst
);
1172 if ((inst
& 0xffff0000) == 0x343e0000)
1173 return save_high21
+ hppa_extract_14 (inst
);
1175 /* fstws as used by the HP compilers. */
1176 if ((inst
& 0xffffffe0) == 0x2fd01220)
1177 return hppa_extract_5_load (inst
);
1179 /* No adjustment. */
1183 /* Return nonzero if INST is a branch of some kind, else return zero. */
1186 is_branch (unsigned long inst
)
1215 /* Return the register number for a GR which is saved by INST or
1216 zero it INST does not save a GR. */
1219 inst_saves_gr (unsigned long inst
)
1221 /* Does it look like a stw? */
1222 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1223 || (inst
>> 26) == 0x1f
1224 || ((inst
>> 26) == 0x1f
1225 && ((inst
>> 6) == 0xa)))
1226 return hppa_extract_5R_store (inst
);
1228 /* Does it look like a std? */
1229 if ((inst
>> 26) == 0x1c
1230 || ((inst
>> 26) == 0x03
1231 && ((inst
>> 6) & 0xf) == 0xb))
1232 return hppa_extract_5R_store (inst
);
1234 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1235 if ((inst
>> 26) == 0x1b)
1236 return hppa_extract_5R_store (inst
);
1238 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1240 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1241 || ((inst
>> 26) == 0x3
1242 && (((inst
>> 6) & 0xf) == 0x8
1243 || (inst
>> 6) & 0xf) == 0x9))
1244 return hppa_extract_5R_store (inst
);
1249 /* Return the register number for a FR which is saved by INST or
1250 zero it INST does not save a FR.
1252 Note we only care about full 64bit register stores (that's the only
1253 kind of stores the prologue will use).
1255 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1258 inst_saves_fr (unsigned long inst
)
1260 /* is this an FSTD ? */
1261 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1262 return hppa_extract_5r_store (inst
);
1263 if ((inst
& 0xfc000002) == 0x70000002)
1264 return hppa_extract_5R_store (inst
);
1265 /* is this an FSTW ? */
1266 if ((inst
& 0xfc00df80) == 0x24001200)
1267 return hppa_extract_5r_store (inst
);
1268 if ((inst
& 0xfc000002) == 0x7c000000)
1269 return hppa_extract_5R_store (inst
);
1273 /* Advance PC across any function entry prologue instructions
1274 to reach some "real" code.
1276 Use information in the unwind table to determine what exactly should
1277 be in the prologue. */
1281 skip_prologue_hard_way (CORE_ADDR pc
, int stop_before_branch
)
1284 CORE_ADDR orig_pc
= pc
;
1285 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1286 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1287 struct unwind_table_entry
*u
;
1288 int final_iteration
;
1294 u
= find_unwind_entry (pc
);
1298 /* If we are not at the beginning of a function, then return now. */
1299 if ((pc
& ~0x3) != u
->region_start
)
1302 /* This is how much of a frame adjustment we need to account for. */
1303 stack_remaining
= u
->Total_frame_size
<< 3;
1305 /* Magic register saves we want to know about. */
1306 save_rp
= u
->Save_RP
;
1307 save_sp
= u
->Save_SP
;
1309 /* An indication that args may be stored into the stack. Unfortunately
1310 the HPUX compilers tend to set this in cases where no args were
1314 /* Turn the Entry_GR field into a bitmask. */
1316 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1318 /* Frame pointer gets saved into a special location. */
1319 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1322 save_gr
|= (1 << i
);
1324 save_gr
&= ~restart_gr
;
1326 /* Turn the Entry_FR field into a bitmask too. */
1328 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1329 save_fr
|= (1 << i
);
1330 save_fr
&= ~restart_fr
;
1332 final_iteration
= 0;
1334 /* Loop until we find everything of interest or hit a branch.
1336 For unoptimized GCC code and for any HP CC code this will never ever
1337 examine any user instructions.
1339 For optimzied GCC code we're faced with problems. GCC will schedule
1340 its prologue and make prologue instructions available for delay slot
1341 filling. The end result is user code gets mixed in with the prologue
1342 and a prologue instruction may be in the delay slot of the first branch
1345 Some unexpected things are expected with debugging optimized code, so
1346 we allow this routine to walk past user instructions in optimized
1348 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1351 unsigned int reg_num
;
1352 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1353 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1355 /* Save copies of all the triggers so we can compare them later
1357 old_save_gr
= save_gr
;
1358 old_save_fr
= save_fr
;
1359 old_save_rp
= save_rp
;
1360 old_save_sp
= save_sp
;
1361 old_stack_remaining
= stack_remaining
;
1363 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1364 inst
= extract_unsigned_integer (buf
, 4);
1370 /* Note the interesting effects of this instruction. */
1371 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1373 /* There are limited ways to store the return pointer into the
1375 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1378 /* These are the only ways we save SP into the stack. At this time
1379 the HP compilers never bother to save SP into the stack. */
1380 if ((inst
& 0xffffc000) == 0x6fc10000
1381 || (inst
& 0xffffc00c) == 0x73c10008)
1384 /* Are we loading some register with an offset from the argument
1386 if ((inst
& 0xffe00000) == 0x37a00000
1387 || (inst
& 0xffffffe0) == 0x081d0240)
1393 /* Account for general and floating-point register saves. */
1394 reg_num
= inst_saves_gr (inst
);
1395 save_gr
&= ~(1 << reg_num
);
1397 /* Ugh. Also account for argument stores into the stack.
1398 Unfortunately args_stored only tells us that some arguments
1399 where stored into the stack. Not how many or what kind!
1401 This is a kludge as on the HP compiler sets this bit and it
1402 never does prologue scheduling. So once we see one, skip past
1403 all of them. We have similar code for the fp arg stores below.
1405 FIXME. Can still die if we have a mix of GR and FR argument
1407 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1409 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1412 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1413 inst
= extract_unsigned_integer (buf
, 4);
1416 reg_num
= inst_saves_gr (inst
);
1422 reg_num
= inst_saves_fr (inst
);
1423 save_fr
&= ~(1 << reg_num
);
1425 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1426 next_inst
= extract_unsigned_integer (buf
, 4);
1432 /* We've got to be read to handle the ldo before the fp register
1434 if ((inst
& 0xfc000000) == 0x34000000
1435 && inst_saves_fr (next_inst
) >= 4
1436 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1438 /* So we drop into the code below in a reasonable state. */
1439 reg_num
= inst_saves_fr (next_inst
);
1443 /* Ugh. Also account for argument stores into the stack.
1444 This is a kludge as on the HP compiler sets this bit and it
1445 never does prologue scheduling. So once we see one, skip past
1447 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1449 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1452 status
= deprecated_read_memory_nobpt (pc
, buf
, 4);
1453 inst
= extract_unsigned_integer (buf
, 4);
1456 if ((inst
& 0xfc000000) != 0x34000000)
1458 status
= deprecated_read_memory_nobpt (pc
+ 4, buf
, 4);
1459 next_inst
= extract_unsigned_integer (buf
, 4);
1462 reg_num
= inst_saves_fr (next_inst
);
1468 /* Quit if we hit any kind of branch. This can happen if a prologue
1469 instruction is in the delay slot of the first call/branch. */
1470 if (is_branch (inst
) && stop_before_branch
)
1473 /* What a crock. The HP compilers set args_stored even if no
1474 arguments were stored into the stack (boo hiss). This could
1475 cause this code to then skip a bunch of user insns (up to the
1478 To combat this we try to identify when args_stored was bogusly
1479 set and clear it. We only do this when args_stored is nonzero,
1480 all other resources are accounted for, and nothing changed on
1483 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1484 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1485 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1486 && old_stack_remaining
== stack_remaining
)
1492 /* !stop_before_branch, so also look at the insn in the delay slot
1494 if (final_iteration
)
1496 if (is_branch (inst
))
1497 final_iteration
= 1;
1500 /* We've got a tenative location for the end of the prologue. However
1501 because of limitations in the unwind descriptor mechanism we may
1502 have went too far into user code looking for the save of a register
1503 that does not exist. So, if there registers we expected to be saved
1504 but never were, mask them out and restart.
1506 This should only happen in optimized code, and should be very rare. */
1507 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1510 restart_gr
= save_gr
;
1511 restart_fr
= save_fr
;
1519 /* Return the address of the PC after the last prologue instruction if
1520 we can determine it from the debug symbols. Else return zero. */
1523 after_prologue (CORE_ADDR pc
)
1525 struct symtab_and_line sal
;
1526 CORE_ADDR func_addr
, func_end
;
1529 /* If we can not find the symbol in the partial symbol table, then
1530 there is no hope we can determine the function's start address
1532 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1535 /* Get the line associated with FUNC_ADDR. */
1536 sal
= find_pc_line (func_addr
, 0);
1538 /* There are only two cases to consider. First, the end of the source line
1539 is within the function bounds. In that case we return the end of the
1540 source line. Second is the end of the source line extends beyond the
1541 bounds of the current function. We need to use the slow code to
1542 examine instructions in that case.
1544 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1545 the wrong thing to do. In fact, it should be entirely possible for this
1546 function to always return zero since the slow instruction scanning code
1547 is supposed to *always* work. If it does not, then it is a bug. */
1548 if (sal
.end
< func_end
)
1554 /* To skip prologues, I use this predicate. Returns either PC itself
1555 if the code at PC does not look like a function prologue; otherwise
1556 returns an address that (if we're lucky) follows the prologue.
1558 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1559 It doesn't necessarily skips all the insns in the prologue. In fact
1560 we might not want to skip all the insns because a prologue insn may
1561 appear in the delay slot of the first branch, and we don't want to
1562 skip over the branch in that case. */
1565 hppa_skip_prologue (CORE_ADDR pc
)
1569 CORE_ADDR post_prologue_pc
;
1572 /* See if we can determine the end of the prologue via the symbol table.
1573 If so, then return either PC, or the PC after the prologue, whichever
1576 post_prologue_pc
= after_prologue (pc
);
1578 /* If after_prologue returned a useful address, then use it. Else
1579 fall back on the instruction skipping code.
1581 Some folks have claimed this causes problems because the breakpoint
1582 may be the first instruction of the prologue. If that happens, then
1583 the instruction skipping code has a bug that needs to be fixed. */
1584 if (post_prologue_pc
!= 0)
1585 return max (pc
, post_prologue_pc
);
1587 return (skip_prologue_hard_way (pc
, 1));
1590 struct hppa_frame_cache
1593 struct trad_frame_saved_reg
*saved_regs
;
1596 static struct hppa_frame_cache
*
1597 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1599 struct hppa_frame_cache
*cache
;
1604 struct unwind_table_entry
*u
;
1605 CORE_ADDR prologue_end
;
1610 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1611 frame_relative_level(next_frame
));
1613 if ((*this_cache
) != NULL
)
1616 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1617 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1618 return (*this_cache
);
1620 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1621 (*this_cache
) = cache
;
1622 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1625 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
1629 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1630 return (*this_cache
);
1633 /* Turn the Entry_GR field into a bitmask. */
1635 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1637 /* Frame pointer gets saved into a special location. */
1638 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1641 saved_gr_mask
|= (1 << i
);
1644 /* Turn the Entry_FR field into a bitmask too. */
1646 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1647 saved_fr_mask
|= (1 << i
);
1649 /* Loop until we find everything of interest or hit a branch.
1651 For unoptimized GCC code and for any HP CC code this will never ever
1652 examine any user instructions.
1654 For optimized GCC code we're faced with problems. GCC will schedule
1655 its prologue and make prologue instructions available for delay slot
1656 filling. The end result is user code gets mixed in with the prologue
1657 and a prologue instruction may be in the delay slot of the first branch
1660 Some unexpected things are expected with debugging optimized code, so
1661 we allow this routine to walk past user instructions in optimized
1664 int final_iteration
= 0;
1665 CORE_ADDR pc
, end_pc
;
1666 int looking_for_sp
= u
->Save_SP
;
1667 int looking_for_rp
= u
->Save_RP
;
1670 /* We have to use skip_prologue_hard_way instead of just
1671 skip_prologue_using_sal, in case we stepped into a function without
1672 symbol information. hppa_skip_prologue also bounds the returned
1673 pc by the passed in pc, so it will not return a pc in the next
1676 We used to call hppa_skip_prologue to find the end of the prologue,
1677 but if some non-prologue instructions get scheduled into the prologue,
1678 and the program is compiled with debug information, the "easy" way
1679 in hppa_skip_prologue will return a prologue end that is too early
1680 for us to notice any potential frame adjustments. */
1682 /* We used to use frame_func_unwind () to locate the beginning of the
1683 function to pass to skip_prologue (). However, when objects are
1684 compiled without debug symbols, frame_func_unwind can return the wrong
1685 function (or 0). We can do better than that by using unwind records. */
1687 prologue_end
= skip_prologue_hard_way (u
->region_start
, 0);
1688 end_pc
= frame_pc_unwind (next_frame
);
1690 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1691 end_pc
= prologue_end
;
1695 for (pc
= u
->region_start
;
1696 ((saved_gr_mask
|| saved_fr_mask
1697 || looking_for_sp
|| looking_for_rp
1698 || frame_size
< (u
->Total_frame_size
<< 3))
1706 if (!safe_frame_unwind_memory (next_frame
, pc
, buf4
,
1709 error ("Cannot read instruction at 0x%s\n", paddr_nz (pc
));
1710 return (*this_cache
);
1713 inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1715 /* Note the interesting effects of this instruction. */
1716 frame_size
+= prologue_inst_adjust_sp (inst
);
1718 /* There are limited ways to store the return pointer into the
1720 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1723 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
1725 else if (inst
== 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1728 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -24;
1730 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1733 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
1736 /* Check to see if we saved SP into the stack. This also
1737 happens to indicate the location of the saved frame
1739 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1740 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1743 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1745 else if (inst
== 0x08030241) /* copy %r3, %r1 */
1750 /* Account for general and floating-point register saves. */
1751 reg
= inst_saves_gr (inst
);
1752 if (reg
>= 3 && reg
<= 18
1753 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1755 saved_gr_mask
&= ~(1 << reg
);
1756 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1757 /* stwm with a positive displacement is a _post_
1759 cache
->saved_regs
[reg
].addr
= 0;
1760 else if ((inst
& 0xfc00000c) == 0x70000008)
1761 /* A std has explicit post_modify forms. */
1762 cache
->saved_regs
[reg
].addr
= 0;
1767 if ((inst
>> 26) == 0x1c)
1768 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1769 else if ((inst
>> 26) == 0x03)
1770 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1772 offset
= hppa_extract_14 (inst
);
1774 /* Handle code with and without frame pointers. */
1776 cache
->saved_regs
[reg
].addr
= offset
;
1778 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1782 /* GCC handles callee saved FP regs a little differently.
1784 It emits an instruction to put the value of the start of
1785 the FP store area into %r1. It then uses fstds,ma with a
1786 basereg of %r1 for the stores.
1788 HP CC emits them at the current stack pointer modifying the
1789 stack pointer as it stores each register. */
1791 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1792 if ((inst
& 0xffffc000) == 0x34610000
1793 || (inst
& 0xffffc000) == 0x37c10000)
1794 fp_loc
= hppa_extract_14 (inst
);
1796 reg
= inst_saves_fr (inst
);
1797 if (reg
>= 12 && reg
<= 21)
1799 /* Note +4 braindamage below is necessary because the FP
1800 status registers are internally 8 registers rather than
1801 the expected 4 registers. */
1802 saved_fr_mask
&= ~(1 << reg
);
1805 /* 1st HP CC FP register store. After this
1806 instruction we've set enough state that the GCC and
1807 HPCC code are both handled in the same manner. */
1808 cache
->saved_regs
[reg
+ HPPA_FP4_REGNUM
+ 4].addr
= 0;
1813 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1818 /* Quit if we hit any kind of branch the previous iteration. */
1819 if (final_iteration
)
1821 /* We want to look precisely one instruction beyond the branch
1822 if we have not found everything yet. */
1823 if (is_branch (inst
))
1824 final_iteration
= 1;
1829 /* The frame base always represents the value of %sp at entry to
1830 the current function (and is thus equivalent to the "saved"
1832 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1836 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1837 "prologue_end=0x%s) ",
1839 paddr_nz (frame_pc_unwind (next_frame
)),
1840 paddr_nz (prologue_end
));
1842 /* Check to see if a frame pointer is available, and use it for
1843 frame unwinding if it is.
1845 There are some situations where we need to rely on the frame
1846 pointer to do stack unwinding. For example, if a function calls
1847 alloca (), the stack pointer can get adjusted inside the body of
1848 the function. In this case, the ABI requires that the compiler
1849 maintain a frame pointer for the function.
1851 The unwind record has a flag (alloca_frame) that indicates that
1852 a function has a variable frame; unfortunately, gcc/binutils
1853 does not set this flag. Instead, whenever a frame pointer is used
1854 and saved on the stack, the Save_SP flag is set. We use this to
1855 decide whether to use the frame pointer for unwinding.
1857 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1858 instead of Save_SP. */
1860 fp
= frame_unwind_register_unsigned (next_frame
, HPPA_FP_REGNUM
);
1862 if (frame_pc_unwind (next_frame
) >= prologue_end
1863 && u
->Save_SP
&& fp
!= 0)
1868 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [frame pointer] }",
1869 paddr_nz (cache
->base
));
1872 && trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1874 /* Both we're expecting the SP to be saved and the SP has been
1875 saved. The entry SP value is saved at this frame's SP
1877 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1880 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved] }",
1881 paddr_nz (cache
->base
));
1885 /* The prologue has been slowly allocating stack space. Adjust
1887 cache
->base
= this_sp
- frame_size
;
1889 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust] } ",
1890 paddr_nz (cache
->base
));
1893 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1896 /* The PC is found in the "return register", "Millicode" uses "r31"
1897 as the return register while normal code uses "rp". */
1900 if (trad_frame_addr_p (cache
->saved_regs
, 31))
1901 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1904 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
1905 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, r31
);
1910 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
1911 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
1914 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
1915 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
1919 /* If Save_SP is set, then we expect the frame pointer to be saved in the
1920 frame. However, there is a one-insn window where we haven't saved it
1921 yet, but we've already clobbered it. Detect this case and fix it up.
1923 The prologue sequence for frame-pointer functions is:
1924 0: stw %rp, -20(%sp)
1927 c: stw,ma %r1, XX(%sp)
1929 So if we are at offset c, the r3 value that we want is not yet saved
1930 on the stack, but it's been overwritten. The prologue analyzer will
1931 set fp_in_r1 when it sees the copy insn so we know to get the value
1933 if (u
->Save_SP
&& !trad_frame_addr_p (cache
->saved_regs
, HPPA_FP_REGNUM
)
1936 ULONGEST r1
= frame_unwind_register_unsigned (next_frame
, 1);
1937 trad_frame_set_value (cache
->saved_regs
, HPPA_FP_REGNUM
, r1
);
1941 /* Convert all the offsets into addresses. */
1943 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1945 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1946 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1951 struct gdbarch
*gdbarch
;
1952 struct gdbarch_tdep
*tdep
;
1954 gdbarch
= get_frame_arch (next_frame
);
1955 tdep
= gdbarch_tdep (gdbarch
);
1957 if (tdep
->unwind_adjust_stub
)
1959 tdep
->unwind_adjust_stub (next_frame
, cache
->base
, cache
->saved_regs
);
1964 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1965 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1966 return (*this_cache
);
1970 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1971 struct frame_id
*this_id
)
1973 struct hppa_frame_cache
*info
;
1974 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1975 struct unwind_table_entry
*u
;
1977 info
= hppa_frame_cache (next_frame
, this_cache
);
1978 u
= find_unwind_entry (pc
);
1980 (*this_id
) = frame_id_build (info
->base
, u
->region_start
);
1984 hppa_frame_prev_register (struct frame_info
*next_frame
,
1986 int regnum
, int *optimizedp
,
1987 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1988 int *realnump
, void *valuep
)
1990 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1991 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
1992 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1995 static const struct frame_unwind hppa_frame_unwind
=
1999 hppa_frame_prev_register
2002 static const struct frame_unwind
*
2003 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
2005 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2007 if (find_unwind_entry (pc
))
2008 return &hppa_frame_unwind
;
2013 /* This is a generic fallback frame unwinder that kicks in if we fail all
2014 the other ones. Normally we would expect the stub and regular unwinder
2015 to work, but in some cases we might hit a function that just doesn't
2016 have any unwind information available. In this case we try to do
2017 unwinding solely based on code reading. This is obviously going to be
2018 slow, so only use this as a last resort. Currently this will only
2019 identify the stack and pc for the frame. */
2021 static struct hppa_frame_cache
*
2022 hppa_fallback_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
2024 struct hppa_frame_cache
*cache
;
2025 unsigned int frame_size
;
2027 CORE_ADDR pc
, start_pc
, end_pc
, cur_pc
;
2030 fprintf_unfiltered (gdb_stdlog
, "{ hppa_fallback_frame_cache (frame=%d)-> ",
2031 frame_relative_level(next_frame
));
2033 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
2034 (*this_cache
) = cache
;
2035 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2037 pc
= frame_func_unwind (next_frame
);
2038 cur_pc
= frame_pc_unwind (next_frame
);
2042 find_pc_partial_function (pc
, NULL
, &start_pc
, &end_pc
);
2044 if (start_pc
== 0 || end_pc
== 0)
2046 error ("Cannot find bounds of current function (@0x%s), unwinding will "
2047 "fail.", paddr_nz (pc
));
2051 if (end_pc
> cur_pc
)
2054 for (pc
= start_pc
; pc
< end_pc
; pc
+= 4)
2058 insn
= read_memory_unsigned_integer (pc
, 4);
2060 frame_size
+= prologue_inst_adjust_sp (insn
);
2062 /* There are limited ways to store the return pointer into the
2064 if (insn
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2066 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -20;
2069 else if (insn
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
2071 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
= -16;
2077 fprintf_unfiltered (gdb_stdlog
, " frame_size = %d, found_rp = %d }\n",
2078 frame_size
, found_rp
);
2080 cache
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
) - frame_size
;
2081 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
2083 if (trad_frame_addr_p (cache
->saved_regs
, HPPA_RP_REGNUM
))
2085 cache
->saved_regs
[HPPA_RP_REGNUM
].addr
+= cache
->base
;
2086 cache
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[HPPA_RP_REGNUM
];
2090 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, HPPA_RP_REGNUM
);
2091 trad_frame_set_value (cache
->saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, rp
);
2098 hppa_fallback_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
2099 struct frame_id
*this_id
)
2101 struct hppa_frame_cache
*info
=
2102 hppa_fallback_frame_cache (next_frame
, this_cache
);
2103 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2107 hppa_fallback_frame_prev_register (struct frame_info
*next_frame
,
2109 int regnum
, int *optimizedp
,
2110 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2111 int *realnump
, void *valuep
)
2113 struct hppa_frame_cache
*info
=
2114 hppa_fallback_frame_cache (next_frame
, this_cache
);
2115 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2116 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2119 static const struct frame_unwind hppa_fallback_frame_unwind
=
2122 hppa_fallback_frame_this_id
,
2123 hppa_fallback_frame_prev_register
2126 static const struct frame_unwind
*
2127 hppa_fallback_unwind_sniffer (struct frame_info
*next_frame
)
2129 return &hppa_fallback_frame_unwind
;
2132 /* Stub frames, used for all kinds of call stubs. */
2133 struct hppa_stub_unwind_cache
2136 struct trad_frame_saved_reg
*saved_regs
;
2139 static struct hppa_stub_unwind_cache
*
2140 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
2143 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2144 struct hppa_stub_unwind_cache
*info
;
2145 struct unwind_table_entry
*u
;
2150 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
2152 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
2154 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
2156 if (gdbarch_osabi (gdbarch
) == GDB_OSABI_HPUX_SOM
)
2158 /* HPUX uses export stubs in function calls; the export stub clobbers
2159 the return value of the caller, and, later restores it from the
2161 u
= find_unwind_entry (frame_pc_unwind (next_frame
));
2163 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
2165 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].addr
= info
->base
- 24;
2171 /* By default we assume that stubs do not change the rp. */
2172 info
->saved_regs
[HPPA_PCOQ_HEAD_REGNUM
].realreg
= HPPA_RP_REGNUM
;
2178 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
2179 void **this_prologue_cache
,
2180 struct frame_id
*this_id
)
2182 struct hppa_stub_unwind_cache
*info
2183 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2186 *this_id
= frame_id_build (info
->base
, frame_func_unwind (next_frame
));
2188 *this_id
= null_frame_id
;
2192 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
2193 void **this_prologue_cache
,
2194 int regnum
, int *optimizedp
,
2195 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2196 int *realnump
, void *valuep
)
2198 struct hppa_stub_unwind_cache
*info
2199 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
2202 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
2203 optimizedp
, lvalp
, addrp
, realnump
,
2206 error ("Requesting registers from null frame.\n");
2209 static const struct frame_unwind hppa_stub_frame_unwind
= {
2211 hppa_stub_frame_this_id
,
2212 hppa_stub_frame_prev_register
2215 static const struct frame_unwind
*
2216 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
2218 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2219 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
2220 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
2223 || (tdep
->in_solib_call_trampoline
!= NULL
2224 && tdep
->in_solib_call_trampoline (pc
, NULL
))
2225 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
2226 return &hppa_stub_frame_unwind
;
2230 static struct frame_id
2231 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2233 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
2235 frame_pc_unwind (next_frame
));
2239 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
2244 ipsw
= frame_unwind_register_unsigned (next_frame
, HPPA_IPSW_REGNUM
);
2245 pc
= frame_unwind_register_unsigned (next_frame
, HPPA_PCOQ_HEAD_REGNUM
);
2247 /* If the current instruction is nullified, then we are effectively
2248 still executing the previous instruction. Pretend we are still
2249 there. This is needed when single stepping; if the nullified
2250 instruction is on a different line, we don't want GDB to think
2251 we've stepped onto that line. */
2252 if (ipsw
& 0x00200000)
2258 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2259 Return NULL if no such symbol was found. */
2261 struct minimal_symbol
*
2262 hppa_lookup_stub_minimal_symbol (const char *name
,
2263 enum unwind_stub_types stub_type
)
2265 struct objfile
*objfile
;
2266 struct minimal_symbol
*msym
;
2268 ALL_MSYMBOLS (objfile
, msym
)
2270 if (strcmp (SYMBOL_LINKAGE_NAME (msym
), name
) == 0)
2272 struct unwind_table_entry
*u
;
2274 u
= find_unwind_entry (SYMBOL_VALUE (msym
));
2275 if (u
!= NULL
&& u
->stub_unwind
.stub_type
== stub_type
)
2283 /* Instead of this nasty cast, add a method pvoid() that prints out a
2284 host VOID data type (remember %p isn't portable). */
2287 hppa_pointer_to_address_hack (void *ptr
)
2289 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2290 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2294 unwind_command (char *exp
, int from_tty
)
2297 struct unwind_table_entry
*u
;
2299 /* If we have an expression, evaluate it and use it as the address. */
2301 if (exp
!= 0 && *exp
!= 0)
2302 address
= parse_and_eval_address (exp
);
2306 u
= find_unwind_entry (address
);
2310 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2314 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2315 paddr_nz (hppa_pointer_to_address_hack (u
)));
2317 printf_unfiltered ("\tregion_start = ");
2318 print_address (u
->region_start
, gdb_stdout
);
2319 gdb_flush (gdb_stdout
);
2321 printf_unfiltered ("\n\tregion_end = ");
2322 print_address (u
->region_end
, gdb_stdout
);
2323 gdb_flush (gdb_stdout
);
2325 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2327 printf_unfiltered ("\n\tflags =");
2328 pif (Cannot_unwind
);
2330 pif (Millicode_save_sr0
);
2333 pif (Variable_Frame
);
2334 pif (Separate_Package_Body
);
2335 pif (Frame_Extension_Millicode
);
2336 pif (Stack_Overflow_Check
);
2337 pif (Two_Instruction_SP_Increment
);
2341 pif (Save_MRP_in_frame
);
2342 pif (extn_ptr_defined
);
2343 pif (Cleanup_defined
);
2344 pif (MPE_XL_interrupt_marker
);
2345 pif (HP_UX_interrupt_marker
);
2348 putchar_unfiltered ('\n');
2350 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2352 pin (Region_description
);
2355 pin (Total_frame_size
);
2357 if (u
->stub_unwind
.stub_type
)
2359 printf_unfiltered ("\tstub type = ");
2360 switch (u
->stub_unwind
.stub_type
)
2363 printf_unfiltered ("long branch\n");
2365 case PARAMETER_RELOCATION
:
2366 printf_unfiltered ("parameter relocation\n");
2369 printf_unfiltered ("export\n");
2372 printf_unfiltered ("import\n");
2375 printf_unfiltered ("import shlib\n");
2378 printf_unfiltered ("unknown (%d)\n", u
->stub_unwind
.stub_type
);
2384 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2386 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2388 An example of this occurs when an a.out is linked against a foo.sl.
2389 The foo.sl defines a global bar(), and the a.out declares a signature
2390 for bar(). However, the a.out doesn't directly call bar(), but passes
2391 its address in another call.
2393 If you have this scenario and attempt to "break bar" before running,
2394 gdb will find a minimal symbol for bar() in the a.out. But that
2395 symbol's address will be negative. What this appears to denote is
2396 an index backwards from the base of the procedure linkage table (PLT)
2397 into the data linkage table (DLT), the end of which is contiguous
2398 with the start of the PLT. This is clearly not a valid address for
2399 us to set a breakpoint on.
2401 Note that one must be careful in how one checks for a negative address.
2402 0xc0000000 is a legitimate address of something in a shared text
2403 segment, for example. Since I don't know what the possible range
2404 is of these "really, truly negative" addresses that come from the
2405 minimal symbols, I'm resorting to the gross hack of checking the
2406 top byte of the address for all 1's. Sigh. */
2408 return (!target_has_stack
&& (pc
& 0xFF000000));
2411 /* Return the GDB type object for the "standard" data type of data
2414 static struct type
*
2415 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2417 if (reg_nr
< HPPA_FP4_REGNUM
)
2418 return builtin_type_uint32
;
2420 return builtin_type_ieee_single_big
;
2423 /* Return the GDB type object for the "standard" data type of data
2424 in register N. hppa64 version. */
2426 static struct type
*
2427 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2429 if (reg_nr
< HPPA_FP4_REGNUM
)
2430 return builtin_type_uint64
;
2432 return builtin_type_ieee_double_big
;
2435 /* Return True if REGNUM is not a register available to the user
2436 through ptrace(). */
2439 hppa_cannot_store_register (int regnum
)
2442 || regnum
== HPPA_PCSQ_HEAD_REGNUM
2443 || (regnum
>= HPPA_PCSQ_TAIL_REGNUM
&& regnum
< HPPA_IPSW_REGNUM
)
2444 || (regnum
> HPPA_IPSW_REGNUM
&& regnum
< HPPA_FP4_REGNUM
));
2449 hppa_smash_text_address (CORE_ADDR addr
)
2451 /* The low two bits of the PC on the PA contain the privilege level.
2452 Some genius implementing a (non-GCC) compiler apparently decided
2453 this means that "addresses" in a text section therefore include a
2454 privilege level, and thus symbol tables should contain these bits.
2455 This seems like a bonehead thing to do--anyway, it seems to work
2456 for our purposes to just ignore those bits. */
2458 return (addr
&= ~0x3);
2461 /* Get the ith function argument for the current function. */
2463 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2467 get_frame_register (frame
, HPPA_R0_REGNUM
+ 26 - argi
, &addr
);
2472 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2473 int regnum
, void *buf
)
2477 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2478 if (regnum
== HPPA_PCOQ_HEAD_REGNUM
|| regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2480 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2484 hppa_find_global_pointer (struct value
*function
)
2490 hppa_frame_prev_register_helper (struct frame_info
*next_frame
,
2491 struct trad_frame_saved_reg saved_regs
[],
2492 int regnum
, int *optimizedp
,
2493 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
2494 int *realnump
, void *valuep
)
2496 if (regnum
== HPPA_PCOQ_TAIL_REGNUM
)
2502 trad_frame_get_prev_register (next_frame
, saved_regs
,
2503 HPPA_PCOQ_HEAD_REGNUM
, optimizedp
,
2504 lvalp
, addrp
, realnump
, valuep
);
2506 pc
= extract_unsigned_integer (valuep
, 4);
2507 store_unsigned_integer (valuep
, 4, pc
+ 4);
2510 /* It's a computed value. */
2518 /* Make sure the "flags" register is zero in all unwound frames.
2519 The "flags" registers is a HP-UX specific wart, and only the code
2520 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2521 with it here. This shouldn't affect other systems since those
2522 should provide zero for the "flags" register anyway. */
2523 if (regnum
== HPPA_FLAGS_REGNUM
)
2526 store_unsigned_integer (valuep
,
2527 register_size (get_frame_arch (next_frame
),
2531 /* It's a computed value. */
2539 trad_frame_get_prev_register (next_frame
, saved_regs
, regnum
,
2540 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
2544 /* Here is a table of C type sizes on hppa with various compiles
2545 and options. I measured this on PA 9000/800 with HP-UX 11.11
2546 and these compilers:
2548 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2549 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2550 /opt/aCC/bin/aCC B3910B A.03.45
2551 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2553 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2554 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2555 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2556 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2557 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2558 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2559 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2560 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2564 compiler and options
2565 char, short, int, long, long long
2566 float, double, long double
2569 So all these compilers use either ILP32 or LP64 model.
2570 TODO: gcc has more options so it needs more investigation.
2572 For floating point types, see:
2574 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2575 HP-UX floating-point guide, hpux 11.00
2577 -- chastain 2003-12-18 */
2579 static struct gdbarch
*
2580 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2582 struct gdbarch_tdep
*tdep
;
2583 struct gdbarch
*gdbarch
;
2585 /* Try to determine the ABI of the object we are loading. */
2586 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2588 /* If it's a SOM file, assume it's HP/UX SOM. */
2589 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2590 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2593 /* find a candidate among the list of pre-declared architectures. */
2594 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2596 return (arches
->gdbarch
);
2598 /* If none found, then allocate and initialize one. */
2599 tdep
= XZALLOC (struct gdbarch_tdep
);
2600 gdbarch
= gdbarch_alloc (&info
, tdep
);
2602 /* Determine from the bfd_arch_info structure if we are dealing with
2603 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2604 then default to a 32bit machine. */
2605 if (info
.bfd_arch_info
!= NULL
)
2606 tdep
->bytes_per_address
=
2607 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2609 tdep
->bytes_per_address
= 4;
2611 tdep
->find_global_pointer
= hppa_find_global_pointer
;
2613 /* Some parts of the gdbarch vector depend on whether we are running
2614 on a 32 bits or 64 bits target. */
2615 switch (tdep
->bytes_per_address
)
2618 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2619 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2620 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2623 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2624 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2625 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2628 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2629 tdep
->bytes_per_address
);
2632 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2633 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2635 /* The following gdbarch vector elements are the same in both ILP32
2636 and LP64, but might show differences some day. */
2637 set_gdbarch_long_long_bit (gdbarch
, 64);
2638 set_gdbarch_long_double_bit (gdbarch
, 128);
2639 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2641 /* The following gdbarch vector elements do not depend on the address
2642 size, or in any other gdbarch element previously set. */
2643 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2644 set_gdbarch_in_function_epilogue_p (gdbarch
,
2645 hppa_in_function_epilogue_p
);
2646 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2647 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2648 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2649 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2650 set_gdbarch_cannot_fetch_register (gdbarch
, hppa_cannot_store_register
);
2651 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2652 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2653 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2654 set_gdbarch_read_pc (gdbarch
, hppa_read_pc
);
2655 set_gdbarch_write_pc (gdbarch
, hppa_write_pc
);
2657 /* Helper for function argument information. */
2658 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2660 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2662 /* When a hardware watchpoint triggers, we'll move the inferior past
2663 it by removing all eventpoints; stepping past the instruction
2664 that caused the trigger; reinserting eventpoints; and checking
2665 whether any watched location changed. */
2666 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2668 /* Inferior function call methods. */
2669 switch (tdep
->bytes_per_address
)
2672 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2673 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2674 set_gdbarch_convert_from_func_ptr_addr
2675 (gdbarch
, hppa32_convert_from_func_ptr_addr
);
2678 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2679 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2682 internal_error (__FILE__
, __LINE__
, "bad switch");
2685 /* Struct return methods. */
2686 switch (tdep
->bytes_per_address
)
2689 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2692 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2695 internal_error (__FILE__
, __LINE__
, "bad switch");
2698 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2699 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2701 /* Frame unwind methods. */
2702 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2703 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2705 /* Hook in ABI-specific overrides, if they have been registered. */
2706 gdbarch_init_osabi (info
, gdbarch
);
2708 /* Hook in the default unwinders. */
2709 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2710 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2711 frame_unwind_append_sniffer (gdbarch
, hppa_fallback_unwind_sniffer
);
2717 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2719 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2721 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2722 tdep
->bytes_per_address
);
2723 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2727 _initialize_hppa_tdep (void)
2729 struct cmd_list_element
*c
;
2731 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2733 hppa_objfile_priv_data
= register_objfile_data ();
2735 add_cmd ("unwind", class_maintenance
, unwind_command
,
2736 "Print unwind table entry at given address.",
2737 &maintenanceprintlist
);
2739 /* Debug this files internals. */
2740 add_setshow_boolean_cmd ("hppa", class_maintenance
, &hppa_debug
, "\
2741 Set whether hppa target specific debugging information should be displayed.", "\
2742 Show whether hppa target specific debugging information is displayed.", "\
2743 This flag controls whether hppa target specific debugging information is\n\
2744 displayed. This information is particularly useful for debugging frame\n\
2745 unwinding problems.", "hppa debug flag is %s.",
2746 NULL
, NULL
, &setdebuglist
, &showdebuglist
);