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. */
33 #include "completer.h"
36 #include "gdb_assert.h"
37 #include "infttrace.h"
38 #include "arch-utils.h"
39 /* For argument passing to the inferior */
43 #include "trad-frame.h"
44 #include "frame-unwind.h"
45 #include "frame-base.h"
55 #include "hppa-tdep.h"
57 static int hppa_debug
= 0;
59 /* Some local constants. */
60 static const int hppa32_num_regs
= 128;
61 static const int hppa64_num_regs
= 96;
63 /* hppa-specific object data -- unwind and solib info.
64 TODO/maybe: think about splitting this into two parts; the unwind data is
65 common to all hppa targets, but is only used in this file; we can register
66 that separately and make this static. The solib data is probably hpux-
67 specific, so we can create a separate extern objfile_data that is registered
68 by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
69 const struct objfile_data
*hppa_objfile_priv_data
= NULL
;
71 /* Get at various relevent fields of an instruction word. */
74 #define MASK_14 0x3fff
75 #define MASK_21 0x1fffff
77 /* Define offsets into the call dummy for the _sr4export address.
78 See comments related to CALL_DUMMY for more info. */
79 #define SR4EXPORT_LDIL_OFFSET (HPPA_INSTRUCTION_SIZE * 12)
80 #define SR4EXPORT_LDO_OFFSET (HPPA_INSTRUCTION_SIZE * 13)
82 /* To support detection of the pseudo-initial frame
84 #define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
85 #define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
87 /* Sizes (in bytes) of the native unwind entries. */
88 #define UNWIND_ENTRY_SIZE 16
89 #define STUB_UNWIND_ENTRY_SIZE 8
91 static void unwind_command (char *, int);
93 static int hppa_alignof (struct type
*);
95 static int prologue_inst_adjust_sp (unsigned long);
97 static int is_branch (unsigned long);
99 static int inst_saves_gr (unsigned long);
101 static int inst_saves_fr (unsigned long);
103 static int compare_unwind_entries (const void *, const void *);
105 static void read_unwind_info (struct objfile
*);
107 static void internalize_unwinds (struct objfile
*,
108 struct unwind_table_entry
*,
109 asection
*, unsigned int,
110 unsigned int, CORE_ADDR
);
111 static void record_text_segment_lowaddr (bfd
*, asection
*, void *);
112 /* FIXME: brobecker 2002-11-07: We will likely be able to make the
113 following functions static, once we hppa is partially multiarched. */
114 int hppa_pc_requires_run_before_use (CORE_ADDR pc
);
115 int hppa_instruction_nullified (void);
117 /* Handle 32/64-bit struct return conventions. */
119 static enum return_value_convention
120 hppa32_return_value (struct gdbarch
*gdbarch
,
121 struct type
*type
, struct regcache
*regcache
,
122 void *readbuf
, const void *writebuf
)
124 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
127 regcache_cooked_read_part (regcache
, FP4_REGNUM
, 0,
128 TYPE_LENGTH (type
), readbuf
);
129 if (writebuf
!= NULL
)
130 regcache_cooked_write_part (regcache
, FP4_REGNUM
, 0,
131 TYPE_LENGTH (type
), writebuf
);
132 return RETURN_VALUE_REGISTER_CONVENTION
;
134 if (TYPE_LENGTH (type
) <= 2 * 4)
136 /* The value always lives in the right hand end of the register
137 (or register pair)? */
140 int part
= TYPE_LENGTH (type
) % 4;
141 /* The left hand register contains only part of the value,
142 transfer that first so that the rest can be xfered as entire
147 regcache_cooked_read_part (regcache
, reg
, 4 - part
,
149 if (writebuf
!= NULL
)
150 regcache_cooked_write_part (regcache
, reg
, 4 - part
,
154 /* Now transfer the remaining register values. */
155 for (b
= part
; b
< TYPE_LENGTH (type
); b
+= 4)
158 regcache_cooked_read (regcache
, reg
, (char *) readbuf
+ b
);
159 if (writebuf
!= NULL
)
160 regcache_cooked_write (regcache
, reg
, (const char *) writebuf
+ b
);
163 return RETURN_VALUE_REGISTER_CONVENTION
;
166 return RETURN_VALUE_STRUCT_CONVENTION
;
169 static enum return_value_convention
170 hppa64_return_value (struct gdbarch
*gdbarch
,
171 struct type
*type
, struct regcache
*regcache
,
172 void *readbuf
, const void *writebuf
)
174 /* RM: Floats are returned in FR4R, doubles in FR4. Integral values
175 are in r28, padded on the left. Aggregates less that 65 bits are
176 in r28, right padded. Aggregates upto 128 bits are in r28 and
177 r29, right padded. */
178 if (TYPE_CODE (type
) == TYPE_CODE_FLT
179 && TYPE_LENGTH (type
) <= 8)
181 /* Floats are right aligned? */
182 int offset
= register_size (gdbarch
, FP4_REGNUM
) - TYPE_LENGTH (type
);
184 regcache_cooked_read_part (regcache
, FP4_REGNUM
, offset
,
185 TYPE_LENGTH (type
), readbuf
);
186 if (writebuf
!= NULL
)
187 regcache_cooked_write_part (regcache
, FP4_REGNUM
, offset
,
188 TYPE_LENGTH (type
), writebuf
);
189 return RETURN_VALUE_REGISTER_CONVENTION
;
191 else if (TYPE_LENGTH (type
) <= 8 && is_integral_type (type
))
193 /* Integrals are right aligned. */
194 int offset
= register_size (gdbarch
, FP4_REGNUM
) - TYPE_LENGTH (type
);
196 regcache_cooked_read_part (regcache
, 28, offset
,
197 TYPE_LENGTH (type
), readbuf
);
198 if (writebuf
!= NULL
)
199 regcache_cooked_write_part (regcache
, 28, offset
,
200 TYPE_LENGTH (type
), writebuf
);
201 return RETURN_VALUE_REGISTER_CONVENTION
;
203 else if (TYPE_LENGTH (type
) <= 2 * 8)
205 /* Composite values are left aligned. */
207 for (b
= 0; b
< TYPE_LENGTH (type
); b
+= 8)
209 int part
= min (8, TYPE_LENGTH (type
) - b
);
211 regcache_cooked_read_part (regcache
, 28 + b
/ 8, 0, part
,
212 (char *) readbuf
+ b
);
213 if (writebuf
!= NULL
)
214 regcache_cooked_write_part (regcache
, 28 + b
/ 8, 0, part
,
215 (const char *) writebuf
+ b
);
217 return RETURN_VALUE_REGISTER_CONVENTION
;
220 return RETURN_VALUE_STRUCT_CONVENTION
;
223 /* Routines to extract various sized constants out of hppa
226 /* This assumes that no garbage lies outside of the lower bits of
230 hppa_sign_extend (unsigned val
, unsigned bits
)
232 return (int) (val
>> (bits
- 1) ? (-1 << bits
) | val
: val
);
235 /* For many immediate values the sign bit is the low bit! */
238 hppa_low_hppa_sign_extend (unsigned val
, unsigned bits
)
240 return (int) ((val
& 0x1 ? (-1 << (bits
- 1)) : 0) | val
>> 1);
243 /* Extract the bits at positions between FROM and TO, using HP's numbering
247 hppa_get_field (unsigned word
, int from
, int to
)
249 return ((word
) >> (31 - (to
)) & ((1 << ((to
) - (from
) + 1)) - 1));
252 /* extract the immediate field from a ld{bhw}s instruction */
255 hppa_extract_5_load (unsigned word
)
257 return hppa_low_hppa_sign_extend (word
>> 16 & MASK_5
, 5);
260 /* extract the immediate field from a break instruction */
263 hppa_extract_5r_store (unsigned word
)
265 return (word
& MASK_5
);
268 /* extract the immediate field from a {sr}sm instruction */
271 hppa_extract_5R_store (unsigned word
)
273 return (word
>> 16 & MASK_5
);
276 /* extract a 14 bit immediate field */
279 hppa_extract_14 (unsigned word
)
281 return hppa_low_hppa_sign_extend (word
& MASK_14
, 14);
284 /* extract a 21 bit constant */
287 hppa_extract_21 (unsigned word
)
293 val
= hppa_get_field (word
, 20, 20);
295 val
|= hppa_get_field (word
, 9, 19);
297 val
|= hppa_get_field (word
, 5, 6);
299 val
|= hppa_get_field (word
, 0, 4);
301 val
|= hppa_get_field (word
, 7, 8);
302 return hppa_sign_extend (val
, 21) << 11;
305 /* extract a 17 bit constant from branch instructions, returning the
306 19 bit signed value. */
309 hppa_extract_17 (unsigned word
)
311 return hppa_sign_extend (hppa_get_field (word
, 19, 28) |
312 hppa_get_field (word
, 29, 29) << 10 |
313 hppa_get_field (word
, 11, 15) << 11 |
314 (word
& 0x1) << 16, 17) << 2;
318 /* Compare the start address for two unwind entries returning 1 if
319 the first address is larger than the second, -1 if the second is
320 larger than the first, and zero if they are equal. */
323 compare_unwind_entries (const void *arg1
, const void *arg2
)
325 const struct unwind_table_entry
*a
= arg1
;
326 const struct unwind_table_entry
*b
= arg2
;
328 if (a
->region_start
> b
->region_start
)
330 else if (a
->region_start
< b
->region_start
)
337 record_text_segment_lowaddr (bfd
*abfd
, asection
*section
, void *data
)
339 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
340 == (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
))
342 bfd_vma value
= section
->vma
- section
->filepos
;
343 CORE_ADDR
*low_text_segment_address
= (CORE_ADDR
*)data
;
345 if (value
< *low_text_segment_address
)
346 *low_text_segment_address
= value
;
351 internalize_unwinds (struct objfile
*objfile
, struct unwind_table_entry
*table
,
352 asection
*section
, unsigned int entries
, unsigned int size
,
353 CORE_ADDR text_offset
)
355 /* We will read the unwind entries into temporary memory, then
356 fill in the actual unwind table. */
362 char *buf
= alloca (size
);
363 CORE_ADDR low_text_segment_address
;
365 /* For ELF targets, then unwinds are supposed to
366 be segment relative offsets instead of absolute addresses.
368 Note that when loading a shared library (text_offset != 0) the
369 unwinds are already relative to the text_offset that will be
371 if (gdbarch_tdep (current_gdbarch
)->is_elf
&& text_offset
== 0)
373 low_text_segment_address
= -1;
375 bfd_map_over_sections (objfile
->obfd
,
376 record_text_segment_lowaddr
,
377 &low_text_segment_address
);
379 text_offset
= low_text_segment_address
;
382 bfd_get_section_contents (objfile
->obfd
, section
, buf
, 0, size
);
384 /* Now internalize the information being careful to handle host/target
386 for (i
= 0; i
< entries
; i
++)
388 table
[i
].region_start
= bfd_get_32 (objfile
->obfd
,
390 table
[i
].region_start
+= text_offset
;
392 table
[i
].region_end
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
393 table
[i
].region_end
+= text_offset
;
395 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
397 table
[i
].Cannot_unwind
= (tmp
>> 31) & 0x1;
398 table
[i
].Millicode
= (tmp
>> 30) & 0x1;
399 table
[i
].Millicode_save_sr0
= (tmp
>> 29) & 0x1;
400 table
[i
].Region_description
= (tmp
>> 27) & 0x3;
401 table
[i
].reserved1
= (tmp
>> 26) & 0x1;
402 table
[i
].Entry_SR
= (tmp
>> 25) & 0x1;
403 table
[i
].Entry_FR
= (tmp
>> 21) & 0xf;
404 table
[i
].Entry_GR
= (tmp
>> 16) & 0x1f;
405 table
[i
].Args_stored
= (tmp
>> 15) & 0x1;
406 table
[i
].Variable_Frame
= (tmp
>> 14) & 0x1;
407 table
[i
].Separate_Package_Body
= (tmp
>> 13) & 0x1;
408 table
[i
].Frame_Extension_Millicode
= (tmp
>> 12) & 0x1;
409 table
[i
].Stack_Overflow_Check
= (tmp
>> 11) & 0x1;
410 table
[i
].Two_Instruction_SP_Increment
= (tmp
>> 10) & 0x1;
411 table
[i
].Ada_Region
= (tmp
>> 9) & 0x1;
412 table
[i
].cxx_info
= (tmp
>> 8) & 0x1;
413 table
[i
].cxx_try_catch
= (tmp
>> 7) & 0x1;
414 table
[i
].sched_entry_seq
= (tmp
>> 6) & 0x1;
415 table
[i
].reserved2
= (tmp
>> 5) & 0x1;
416 table
[i
].Save_SP
= (tmp
>> 4) & 0x1;
417 table
[i
].Save_RP
= (tmp
>> 3) & 0x1;
418 table
[i
].Save_MRP_in_frame
= (tmp
>> 2) & 0x1;
419 table
[i
].extn_ptr_defined
= (tmp
>> 1) & 0x1;
420 table
[i
].Cleanup_defined
= tmp
& 0x1;
421 tmp
= bfd_get_32 (objfile
->obfd
, (bfd_byte
*) buf
);
423 table
[i
].MPE_XL_interrupt_marker
= (tmp
>> 31) & 0x1;
424 table
[i
].HP_UX_interrupt_marker
= (tmp
>> 30) & 0x1;
425 table
[i
].Large_frame
= (tmp
>> 29) & 0x1;
426 table
[i
].Pseudo_SP_Set
= (tmp
>> 28) & 0x1;
427 table
[i
].reserved4
= (tmp
>> 27) & 0x1;
428 table
[i
].Total_frame_size
= tmp
& 0x7ffffff;
430 /* Stub unwinds are handled elsewhere. */
431 table
[i
].stub_unwind
.stub_type
= 0;
432 table
[i
].stub_unwind
.padding
= 0;
437 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
438 the object file. This info is used mainly by find_unwind_entry() to find
439 out the stack frame size and frame pointer used by procedures. We put
440 everything on the psymbol obstack in the objfile so that it automatically
441 gets freed when the objfile is destroyed. */
444 read_unwind_info (struct objfile
*objfile
)
446 asection
*unwind_sec
, *stub_unwind_sec
;
447 unsigned unwind_size
, stub_unwind_size
, total_size
;
448 unsigned index
, unwind_entries
;
449 unsigned stub_entries
, total_entries
;
450 CORE_ADDR text_offset
;
451 struct hppa_unwind_info
*ui
;
452 struct hppa_objfile_private
*obj_private
;
454 text_offset
= ANOFFSET (objfile
->section_offsets
, 0);
455 ui
= (struct hppa_unwind_info
*) obstack_alloc (&objfile
->objfile_obstack
,
456 sizeof (struct hppa_unwind_info
));
462 /* For reasons unknown the HP PA64 tools generate multiple unwinder
463 sections in a single executable. So we just iterate over every
464 section in the BFD looking for unwinder sections intead of trying
465 to do a lookup with bfd_get_section_by_name.
467 First determine the total size of the unwind tables so that we
468 can allocate memory in a nice big hunk. */
470 for (unwind_sec
= objfile
->obfd
->sections
;
472 unwind_sec
= unwind_sec
->next
)
474 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
475 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
477 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
478 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
480 total_entries
+= unwind_entries
;
484 /* Now compute the size of the stub unwinds. Note the ELF tools do not
485 use stub unwinds at the curren time. */
486 stub_unwind_sec
= bfd_get_section_by_name (objfile
->obfd
, "$UNWIND_END$");
490 stub_unwind_size
= bfd_section_size (objfile
->obfd
, stub_unwind_sec
);
491 stub_entries
= stub_unwind_size
/ STUB_UNWIND_ENTRY_SIZE
;
495 stub_unwind_size
= 0;
499 /* Compute total number of unwind entries and their total size. */
500 total_entries
+= stub_entries
;
501 total_size
= total_entries
* sizeof (struct unwind_table_entry
);
503 /* Allocate memory for the unwind table. */
504 ui
->table
= (struct unwind_table_entry
*)
505 obstack_alloc (&objfile
->objfile_obstack
, total_size
);
506 ui
->last
= total_entries
- 1;
508 /* Now read in each unwind section and internalize the standard unwind
511 for (unwind_sec
= objfile
->obfd
->sections
;
513 unwind_sec
= unwind_sec
->next
)
515 if (strcmp (unwind_sec
->name
, "$UNWIND_START$") == 0
516 || strcmp (unwind_sec
->name
, ".PARISC.unwind") == 0)
518 unwind_size
= bfd_section_size (objfile
->obfd
, unwind_sec
);
519 unwind_entries
= unwind_size
/ UNWIND_ENTRY_SIZE
;
521 internalize_unwinds (objfile
, &ui
->table
[index
], unwind_sec
,
522 unwind_entries
, unwind_size
, text_offset
);
523 index
+= unwind_entries
;
527 /* Now read in and internalize the stub unwind entries. */
528 if (stub_unwind_size
> 0)
531 char *buf
= alloca (stub_unwind_size
);
533 /* Read in the stub unwind entries. */
534 bfd_get_section_contents (objfile
->obfd
, stub_unwind_sec
, buf
,
535 0, stub_unwind_size
);
537 /* Now convert them into regular unwind entries. */
538 for (i
= 0; i
< stub_entries
; i
++, index
++)
540 /* Clear out the next unwind entry. */
541 memset (&ui
->table
[index
], 0, sizeof (struct unwind_table_entry
));
543 /* Convert offset & size into region_start and region_end.
544 Stuff away the stub type into "reserved" fields. */
545 ui
->table
[index
].region_start
= bfd_get_32 (objfile
->obfd
,
547 ui
->table
[index
].region_start
+= text_offset
;
549 ui
->table
[index
].stub_unwind
.stub_type
= bfd_get_8 (objfile
->obfd
,
552 ui
->table
[index
].region_end
553 = ui
->table
[index
].region_start
+ 4 *
554 (bfd_get_16 (objfile
->obfd
, (bfd_byte
*) buf
) - 1);
560 /* Unwind table needs to be kept sorted. */
561 qsort (ui
->table
, total_entries
, sizeof (struct unwind_table_entry
),
562 compare_unwind_entries
);
564 /* Keep a pointer to the unwind information. */
565 obj_private
= (struct hppa_objfile_private
*)
566 objfile_data (objfile
, hppa_objfile_priv_data
);
567 if (obj_private
== NULL
)
569 obj_private
= (struct hppa_objfile_private
*)
570 obstack_alloc (&objfile
->objfile_obstack
,
571 sizeof (struct hppa_objfile_private
));
572 set_objfile_data (objfile
, hppa_objfile_priv_data
, obj_private
);
573 obj_private
->unwind_info
= NULL
;
574 obj_private
->so_info
= NULL
;
577 obj_private
->unwind_info
= ui
;
580 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
581 of the objfiles seeking the unwind table entry for this PC. Each objfile
582 contains a sorted list of struct unwind_table_entry. Since we do a binary
583 search of the unwind tables, we depend upon them to be sorted. */
585 struct unwind_table_entry
*
586 find_unwind_entry (CORE_ADDR pc
)
588 int first
, middle
, last
;
589 struct objfile
*objfile
;
590 struct hppa_objfile_private
*priv
;
593 fprintf_unfiltered (gdb_stdlog
, "{ find_unwind_entry 0x%s -> ",
596 /* A function at address 0? Not in HP-UX! */
597 if (pc
== (CORE_ADDR
) 0)
600 fprintf_unfiltered (gdb_stdlog
, "NULL }\n");
604 ALL_OBJFILES (objfile
)
606 struct hppa_unwind_info
*ui
;
608 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
610 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
614 read_unwind_info (objfile
);
615 priv
= objfile_data (objfile
, hppa_objfile_priv_data
);
617 error ("Internal error reading unwind information.");
618 ui
= ((struct hppa_objfile_private
*) priv
)->unwind_info
;
621 /* First, check the cache */
624 && pc
>= ui
->cache
->region_start
625 && pc
<= ui
->cache
->region_end
)
628 fprintf_unfiltered (gdb_stdlog
, "0x%s (cached) }\n",
629 paddr_nz ((CORE_ADDR
) ui
->cache
));
633 /* Not in the cache, do a binary search */
638 while (first
<= last
)
640 middle
= (first
+ last
) / 2;
641 if (pc
>= ui
->table
[middle
].region_start
642 && pc
<= ui
->table
[middle
].region_end
)
644 ui
->cache
= &ui
->table
[middle
];
646 fprintf_unfiltered (gdb_stdlog
, "0x%s }\n",
647 paddr_nz ((CORE_ADDR
) ui
->cache
));
648 return &ui
->table
[middle
];
651 if (pc
< ui
->table
[middle
].region_start
)
656 } /* ALL_OBJFILES() */
659 fprintf_unfiltered (gdb_stdlog
, "NULL (not found) }\n");
664 static const unsigned char *
665 hppa_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
667 static const unsigned char breakpoint
[] = {0x00, 0x01, 0x00, 0x04};
668 (*len
) = sizeof (breakpoint
);
672 /* Return the name of a register. */
675 hppa32_register_name (int i
)
677 static char *names
[] = {
678 "flags", "r1", "rp", "r3",
679 "r4", "r5", "r6", "r7",
680 "r8", "r9", "r10", "r11",
681 "r12", "r13", "r14", "r15",
682 "r16", "r17", "r18", "r19",
683 "r20", "r21", "r22", "r23",
684 "r24", "r25", "r26", "dp",
685 "ret0", "ret1", "sp", "r31",
686 "sar", "pcoqh", "pcsqh", "pcoqt",
687 "pcsqt", "eiem", "iir", "isr",
688 "ior", "ipsw", "goto", "sr4",
689 "sr0", "sr1", "sr2", "sr3",
690 "sr5", "sr6", "sr7", "cr0",
691 "cr8", "cr9", "ccr", "cr12",
692 "cr13", "cr24", "cr25", "cr26",
693 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
694 "fpsr", "fpe1", "fpe2", "fpe3",
695 "fpe4", "fpe5", "fpe6", "fpe7",
696 "fr4", "fr4R", "fr5", "fr5R",
697 "fr6", "fr6R", "fr7", "fr7R",
698 "fr8", "fr8R", "fr9", "fr9R",
699 "fr10", "fr10R", "fr11", "fr11R",
700 "fr12", "fr12R", "fr13", "fr13R",
701 "fr14", "fr14R", "fr15", "fr15R",
702 "fr16", "fr16R", "fr17", "fr17R",
703 "fr18", "fr18R", "fr19", "fr19R",
704 "fr20", "fr20R", "fr21", "fr21R",
705 "fr22", "fr22R", "fr23", "fr23R",
706 "fr24", "fr24R", "fr25", "fr25R",
707 "fr26", "fr26R", "fr27", "fr27R",
708 "fr28", "fr28R", "fr29", "fr29R",
709 "fr30", "fr30R", "fr31", "fr31R"
711 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
718 hppa64_register_name (int i
)
720 static char *names
[] = {
721 "flags", "r1", "rp", "r3",
722 "r4", "r5", "r6", "r7",
723 "r8", "r9", "r10", "r11",
724 "r12", "r13", "r14", "r15",
725 "r16", "r17", "r18", "r19",
726 "r20", "r21", "r22", "r23",
727 "r24", "r25", "r26", "dp",
728 "ret0", "ret1", "sp", "r31",
729 "sar", "pcoqh", "pcsqh", "pcoqt",
730 "pcsqt", "eiem", "iir", "isr",
731 "ior", "ipsw", "goto", "sr4",
732 "sr0", "sr1", "sr2", "sr3",
733 "sr5", "sr6", "sr7", "cr0",
734 "cr8", "cr9", "ccr", "cr12",
735 "cr13", "cr24", "cr25", "cr26",
736 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
737 "fpsr", "fpe1", "fpe2", "fpe3",
738 "fr4", "fr5", "fr6", "fr7",
739 "fr8", "fr9", "fr10", "fr11",
740 "fr12", "fr13", "fr14", "fr15",
741 "fr16", "fr17", "fr18", "fr19",
742 "fr20", "fr21", "fr22", "fr23",
743 "fr24", "fr25", "fr26", "fr27",
744 "fr28", "fr29", "fr30", "fr31"
746 if (i
< 0 || i
>= (sizeof (names
) / sizeof (*names
)))
752 /* This function pushes a stack frame with arguments as part of the
753 inferior function calling mechanism.
755 This is the version of the function for the 32-bit PA machines, in
756 which later arguments appear at lower addresses. (The stack always
757 grows towards higher addresses.)
759 We simply allocate the appropriate amount of stack space and put
760 arguments into their proper slots. */
763 hppa32_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
764 struct regcache
*regcache
, CORE_ADDR bp_addr
,
765 int nargs
, struct value
**args
, CORE_ADDR sp
,
766 int struct_return
, CORE_ADDR struct_addr
)
768 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
769 reverse engineering testsuite failures. */
771 /* Stack base address at which any pass-by-reference parameters are
773 CORE_ADDR struct_end
= 0;
774 /* Stack base address at which the first parameter is stored. */
775 CORE_ADDR param_end
= 0;
777 /* The inner most end of the stack after all the parameters have
779 CORE_ADDR new_sp
= 0;
781 /* Two passes. First pass computes the location of everything,
782 second pass writes the bytes out. */
784 for (write_pass
= 0; write_pass
< 2; write_pass
++)
786 CORE_ADDR struct_ptr
= 0;
787 CORE_ADDR param_ptr
= 0;
788 int reg
= 27; /* NOTE: Registers go down. */
790 for (i
= 0; i
< nargs
; i
++)
792 struct value
*arg
= args
[i
];
793 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
794 /* The corresponding parameter that is pushed onto the
795 stack, and [possibly] passed in a register. */
798 memset (param_val
, 0, sizeof param_val
);
799 if (TYPE_LENGTH (type
) > 8)
801 /* Large parameter, pass by reference. Store the value
802 in "struct" area and then pass its address. */
804 struct_ptr
+= align_up (TYPE_LENGTH (type
), 8);
806 write_memory (struct_end
- struct_ptr
, VALUE_CONTENTS (arg
),
808 store_unsigned_integer (param_val
, 4, struct_end
- struct_ptr
);
810 else if (TYPE_CODE (type
) == TYPE_CODE_INT
811 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
813 /* Integer value store, right aligned. "unpack_long"
814 takes care of any sign-extension problems. */
815 param_len
= align_up (TYPE_LENGTH (type
), 4);
816 store_unsigned_integer (param_val
, param_len
,
818 VALUE_CONTENTS (arg
)));
822 /* Small struct value, store right aligned? */
823 param_len
= align_up (TYPE_LENGTH (type
), 4);
824 memcpy (param_val
+ param_len
- TYPE_LENGTH (type
),
825 VALUE_CONTENTS (arg
), TYPE_LENGTH (type
));
827 param_ptr
+= param_len
;
828 reg
-= param_len
/ 4;
831 write_memory (param_end
- param_ptr
, param_val
, param_len
);
834 regcache_cooked_write (regcache
, reg
, param_val
);
836 regcache_cooked_write (regcache
, reg
+ 1, param_val
+ 4);
841 /* Update the various stack pointers. */
844 struct_end
= sp
+ struct_ptr
;
845 /* PARAM_PTR already accounts for all the arguments passed
846 by the user. However, the ABI mandates minimum stack
847 space allocations for outgoing arguments. The ABI also
848 mandates minimum stack alignments which we must
850 param_end
= struct_end
+ max (align_up (param_ptr
, 8), 16);
854 /* If a structure has to be returned, set up register 28 to hold its
857 write_register (28, struct_addr
);
859 /* Set the return address. */
860 regcache_cooked_write_unsigned (regcache
, RP_REGNUM
, bp_addr
);
862 /* Update the Stack Pointer. */
863 regcache_cooked_write_unsigned (regcache
, SP_REGNUM
, param_end
+ 32);
865 /* The stack will have 32 bytes of additional space for a frame marker. */
866 return param_end
+ 32;
869 /* This function pushes a stack frame with arguments as part of the
870 inferior function calling mechanism.
872 This is the version for the PA64, in which later arguments appear
873 at higher addresses. (The stack always grows towards higher
876 We simply allocate the appropriate amount of stack space and put
877 arguments into their proper slots.
879 This ABI also requires that the caller provide an argument pointer
880 to the callee, so we do that too. */
883 hppa64_push_dummy_call (struct gdbarch
*gdbarch
, CORE_ADDR func_addr
,
884 struct regcache
*regcache
, CORE_ADDR bp_addr
,
885 int nargs
, struct value
**args
, CORE_ADDR sp
,
886 int struct_return
, CORE_ADDR struct_addr
)
888 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
889 reverse engineering testsuite failures. */
891 /* Stack base address at which any pass-by-reference parameters are
893 CORE_ADDR struct_end
= 0;
894 /* Stack base address at which the first parameter is stored. */
895 CORE_ADDR param_end
= 0;
897 /* The inner most end of the stack after all the parameters have
899 CORE_ADDR new_sp
= 0;
901 /* Two passes. First pass computes the location of everything,
902 second pass writes the bytes out. */
904 for (write_pass
= 0; write_pass
< 2; write_pass
++)
906 CORE_ADDR struct_ptr
= 0;
907 CORE_ADDR param_ptr
= 0;
909 for (i
= 0; i
< nargs
; i
++)
911 struct value
*arg
= args
[i
];
912 struct type
*type
= check_typedef (VALUE_TYPE (arg
));
913 if ((TYPE_CODE (type
) == TYPE_CODE_INT
914 || TYPE_CODE (type
) == TYPE_CODE_ENUM
)
915 && TYPE_LENGTH (type
) <= 8)
917 /* Integer value store, right aligned. "unpack_long"
918 takes care of any sign-extension problems. */
922 ULONGEST val
= unpack_long (type
, VALUE_CONTENTS (arg
));
923 int reg
= 27 - param_ptr
/ 8;
924 write_memory_unsigned_integer (param_end
- param_ptr
,
927 regcache_cooked_write_unsigned (regcache
, reg
, val
);
932 /* Small struct value, store left aligned? */
934 if (TYPE_LENGTH (type
) > 8)
936 param_ptr
= align_up (param_ptr
, 16);
937 reg
= 26 - param_ptr
/ 8;
938 param_ptr
+= align_up (TYPE_LENGTH (type
), 16);
942 param_ptr
= align_up (param_ptr
, 8);
943 reg
= 26 - param_ptr
/ 8;
944 param_ptr
+= align_up (TYPE_LENGTH (type
), 8);
949 write_memory (param_end
- param_ptr
, VALUE_CONTENTS (arg
),
951 for (byte
= 0; byte
< TYPE_LENGTH (type
); byte
+= 8)
955 int len
= min (8, TYPE_LENGTH (type
) - byte
);
956 regcache_cooked_write_part (regcache
, reg
, 0, len
,
957 VALUE_CONTENTS (arg
) + byte
);
964 /* Update the various stack pointers. */
967 struct_end
= sp
+ struct_ptr
;
968 /* PARAM_PTR already accounts for all the arguments passed
969 by the user. However, the ABI mandates minimum stack
970 space allocations for outgoing arguments. The ABI also
971 mandates minimum stack alignments which we must
973 param_end
= struct_end
+ max (align_up (param_ptr
, 16), 64);
977 /* If a structure has to be returned, set up register 28 to hold its
980 write_register (28, struct_addr
);
982 /* Set the return address. */
983 regcache_cooked_write_unsigned (regcache
, RP_REGNUM
, bp_addr
);
985 /* Update the Stack Pointer. */
986 regcache_cooked_write_unsigned (regcache
, SP_REGNUM
, param_end
+ 64);
988 /* The stack will have 32 bytes of additional space for a frame marker. */
989 return param_end
+ 64;
993 hppa32_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
995 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
997 return align_up (addr
, 64);
1000 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1003 hppa64_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1005 /* Just always 16-byte align. */
1006 return align_up (addr
, 16);
1010 /* Get the PC from %r31 if currently in a syscall. Also mask out privilege
1014 hppa_target_read_pc (ptid_t ptid
)
1016 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
1018 /* The following test does not belong here. It is OS-specific, and belongs
1020 /* Test SS_INSYSCALL */
1022 return read_register_pid (31, ptid
) & ~0x3;
1024 return read_register_pid (PCOQ_HEAD_REGNUM
, ptid
) & ~0x3;
1027 /* Write out the PC. If currently in a syscall, then also write the new
1028 PC value into %r31. */
1031 hppa_target_write_pc (CORE_ADDR v
, ptid_t ptid
)
1033 int flags
= read_register_pid (FLAGS_REGNUM
, ptid
);
1035 /* The following test does not belong here. It is OS-specific, and belongs
1037 /* If in a syscall, then set %r31. Also make sure to get the
1038 privilege bits set correctly. */
1039 /* Test SS_INSYSCALL */
1041 write_register_pid (31, v
| 0x3, ptid
);
1043 write_register_pid (PCOQ_HEAD_REGNUM
, v
, ptid
);
1044 write_register_pid (PCOQ_TAIL_REGNUM
, v
+ 4, ptid
);
1047 /* return the alignment of a type in bytes. Structures have the maximum
1048 alignment required by their fields. */
1051 hppa_alignof (struct type
*type
)
1053 int max_align
, align
, i
;
1054 CHECK_TYPEDEF (type
);
1055 switch (TYPE_CODE (type
))
1060 return TYPE_LENGTH (type
);
1061 case TYPE_CODE_ARRAY
:
1062 return hppa_alignof (TYPE_FIELD_TYPE (type
, 0));
1063 case TYPE_CODE_STRUCT
:
1064 case TYPE_CODE_UNION
:
1066 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
1068 /* Bit fields have no real alignment. */
1069 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1070 if (!TYPE_FIELD_BITSIZE (type
, i
)) /* elz: this should be bitsize */
1072 align
= hppa_alignof (TYPE_FIELD_TYPE (type
, i
));
1073 max_align
= max (max_align
, align
);
1082 /* For the given instruction (INST), return any adjustment it makes
1083 to the stack pointer or zero for no adjustment.
1085 This only handles instructions commonly found in prologues. */
1088 prologue_inst_adjust_sp (unsigned long inst
)
1090 /* This must persist across calls. */
1091 static int save_high21
;
1093 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1094 if ((inst
& 0xffffc000) == 0x37de0000)
1095 return hppa_extract_14 (inst
);
1098 if ((inst
& 0xffe00000) == 0x6fc00000)
1099 return hppa_extract_14 (inst
);
1101 /* std,ma X,D(sp) */
1102 if ((inst
& 0xffe00008) == 0x73c00008)
1103 return (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1105 /* addil high21,%r1; ldo low11,(%r1),%r30)
1106 save high bits in save_high21 for later use. */
1107 if ((inst
& 0xffe00000) == 0x28200000)
1109 save_high21
= hppa_extract_21 (inst
);
1113 if ((inst
& 0xffff0000) == 0x343e0000)
1114 return save_high21
+ hppa_extract_14 (inst
);
1116 /* fstws as used by the HP compilers. */
1117 if ((inst
& 0xffffffe0) == 0x2fd01220)
1118 return hppa_extract_5_load (inst
);
1120 /* No adjustment. */
1124 /* Return nonzero if INST is a branch of some kind, else return zero. */
1127 is_branch (unsigned long inst
)
1156 /* Return the register number for a GR which is saved by INST or
1157 zero it INST does not save a GR. */
1160 inst_saves_gr (unsigned long inst
)
1162 /* Does it look like a stw? */
1163 if ((inst
>> 26) == 0x1a || (inst
>> 26) == 0x1b
1164 || (inst
>> 26) == 0x1f
1165 || ((inst
>> 26) == 0x1f
1166 && ((inst
>> 6) == 0xa)))
1167 return hppa_extract_5R_store (inst
);
1169 /* Does it look like a std? */
1170 if ((inst
>> 26) == 0x1c
1171 || ((inst
>> 26) == 0x03
1172 && ((inst
>> 6) & 0xf) == 0xb))
1173 return hppa_extract_5R_store (inst
);
1175 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1176 if ((inst
>> 26) == 0x1b)
1177 return hppa_extract_5R_store (inst
);
1179 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1181 if ((inst
>> 26) == 0x19 || (inst
>> 26) == 0x18
1182 || ((inst
>> 26) == 0x3
1183 && (((inst
>> 6) & 0xf) == 0x8
1184 || (inst
>> 6) & 0xf) == 0x9))
1185 return hppa_extract_5R_store (inst
);
1190 /* Return the register number for a FR which is saved by INST or
1191 zero it INST does not save a FR.
1193 Note we only care about full 64bit register stores (that's the only
1194 kind of stores the prologue will use).
1196 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1199 inst_saves_fr (unsigned long inst
)
1201 /* is this an FSTD ? */
1202 if ((inst
& 0xfc00dfc0) == 0x2c001200)
1203 return hppa_extract_5r_store (inst
);
1204 if ((inst
& 0xfc000002) == 0x70000002)
1205 return hppa_extract_5R_store (inst
);
1206 /* is this an FSTW ? */
1207 if ((inst
& 0xfc00df80) == 0x24001200)
1208 return hppa_extract_5r_store (inst
);
1209 if ((inst
& 0xfc000002) == 0x7c000000)
1210 return hppa_extract_5R_store (inst
);
1214 /* Advance PC across any function entry prologue instructions
1215 to reach some "real" code.
1217 Use information in the unwind table to determine what exactly should
1218 be in the prologue. */
1222 skip_prologue_hard_way (CORE_ADDR pc
)
1225 CORE_ADDR orig_pc
= pc
;
1226 unsigned long inst
, stack_remaining
, save_gr
, save_fr
, save_rp
, save_sp
;
1227 unsigned long args_stored
, status
, i
, restart_gr
, restart_fr
;
1228 struct unwind_table_entry
*u
;
1234 u
= find_unwind_entry (pc
);
1238 /* If we are not at the beginning of a function, then return now. */
1239 if ((pc
& ~0x3) != u
->region_start
)
1242 /* This is how much of a frame adjustment we need to account for. */
1243 stack_remaining
= u
->Total_frame_size
<< 3;
1245 /* Magic register saves we want to know about. */
1246 save_rp
= u
->Save_RP
;
1247 save_sp
= u
->Save_SP
;
1249 /* An indication that args may be stored into the stack. Unfortunately
1250 the HPUX compilers tend to set this in cases where no args were
1254 /* Turn the Entry_GR field into a bitmask. */
1256 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1258 /* Frame pointer gets saved into a special location. */
1259 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1262 save_gr
|= (1 << i
);
1264 save_gr
&= ~restart_gr
;
1266 /* Turn the Entry_FR field into a bitmask too. */
1268 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1269 save_fr
|= (1 << i
);
1270 save_fr
&= ~restart_fr
;
1272 /* Loop until we find everything of interest or hit a branch.
1274 For unoptimized GCC code and for any HP CC code this will never ever
1275 examine any user instructions.
1277 For optimzied GCC code we're faced with problems. GCC will schedule
1278 its prologue and make prologue instructions available for delay slot
1279 filling. The end result is user code gets mixed in with the prologue
1280 and a prologue instruction may be in the delay slot of the first branch
1283 Some unexpected things are expected with debugging optimized code, so
1284 we allow this routine to walk past user instructions in optimized
1286 while (save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0
1289 unsigned int reg_num
;
1290 unsigned long old_stack_remaining
, old_save_gr
, old_save_fr
;
1291 unsigned long old_save_rp
, old_save_sp
, next_inst
;
1293 /* Save copies of all the triggers so we can compare them later
1295 old_save_gr
= save_gr
;
1296 old_save_fr
= save_fr
;
1297 old_save_rp
= save_rp
;
1298 old_save_sp
= save_sp
;
1299 old_stack_remaining
= stack_remaining
;
1301 status
= target_read_memory (pc
, buf
, 4);
1302 inst
= extract_unsigned_integer (buf
, 4);
1308 /* Note the interesting effects of this instruction. */
1309 stack_remaining
-= prologue_inst_adjust_sp (inst
);
1311 /* There are limited ways to store the return pointer into the
1313 if (inst
== 0x6bc23fd9 || inst
== 0x0fc212c1)
1316 /* These are the only ways we save SP into the stack. At this time
1317 the HP compilers never bother to save SP into the stack. */
1318 if ((inst
& 0xffffc000) == 0x6fc10000
1319 || (inst
& 0xffffc00c) == 0x73c10008)
1322 /* Are we loading some register with an offset from the argument
1324 if ((inst
& 0xffe00000) == 0x37a00000
1325 || (inst
& 0xffffffe0) == 0x081d0240)
1331 /* Account for general and floating-point register saves. */
1332 reg_num
= inst_saves_gr (inst
);
1333 save_gr
&= ~(1 << reg_num
);
1335 /* Ugh. Also account for argument stores into the stack.
1336 Unfortunately args_stored only tells us that some arguments
1337 where stored into the stack. Not how many or what kind!
1339 This is a kludge as on the HP compiler sets this bit and it
1340 never does prologue scheduling. So once we see one, skip past
1341 all of them. We have similar code for the fp arg stores below.
1343 FIXME. Can still die if we have a mix of GR and FR argument
1345 if (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1347 while (reg_num
>= (TARGET_PTR_BIT
== 64 ? 19 : 23) && reg_num
<= 26)
1350 status
= target_read_memory (pc
, buf
, 4);
1351 inst
= extract_unsigned_integer (buf
, 4);
1354 reg_num
= inst_saves_gr (inst
);
1360 reg_num
= inst_saves_fr (inst
);
1361 save_fr
&= ~(1 << reg_num
);
1363 status
= target_read_memory (pc
+ 4, buf
, 4);
1364 next_inst
= extract_unsigned_integer (buf
, 4);
1370 /* We've got to be read to handle the ldo before the fp register
1372 if ((inst
& 0xfc000000) == 0x34000000
1373 && inst_saves_fr (next_inst
) >= 4
1374 && inst_saves_fr (next_inst
) <= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1376 /* So we drop into the code below in a reasonable state. */
1377 reg_num
= inst_saves_fr (next_inst
);
1381 /* Ugh. Also account for argument stores into the stack.
1382 This is a kludge as on the HP compiler sets this bit and it
1383 never does prologue scheduling. So once we see one, skip past
1385 if (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1387 while (reg_num
>= 4 && reg_num
<= (TARGET_PTR_BIT
== 64 ? 11 : 7))
1390 status
= target_read_memory (pc
, buf
, 4);
1391 inst
= extract_unsigned_integer (buf
, 4);
1394 if ((inst
& 0xfc000000) != 0x34000000)
1396 status
= target_read_memory (pc
+ 4, buf
, 4);
1397 next_inst
= extract_unsigned_integer (buf
, 4);
1400 reg_num
= inst_saves_fr (next_inst
);
1406 /* Quit if we hit any kind of branch. This can happen if a prologue
1407 instruction is in the delay slot of the first call/branch. */
1408 if (is_branch (inst
))
1411 /* What a crock. The HP compilers set args_stored even if no
1412 arguments were stored into the stack (boo hiss). This could
1413 cause this code to then skip a bunch of user insns (up to the
1416 To combat this we try to identify when args_stored was bogusly
1417 set and clear it. We only do this when args_stored is nonzero,
1418 all other resources are accounted for, and nothing changed on
1421 && !(save_gr
|| save_fr
|| save_rp
|| save_sp
|| stack_remaining
> 0)
1422 && old_save_gr
== save_gr
&& old_save_fr
== save_fr
1423 && old_save_rp
== save_rp
&& old_save_sp
== save_sp
1424 && old_stack_remaining
== stack_remaining
)
1431 /* We've got a tenative location for the end of the prologue. However
1432 because of limitations in the unwind descriptor mechanism we may
1433 have went too far into user code looking for the save of a register
1434 that does not exist. So, if there registers we expected to be saved
1435 but never were, mask them out and restart.
1437 This should only happen in optimized code, and should be very rare. */
1438 if (save_gr
|| (save_fr
&& !(restart_fr
|| restart_gr
)))
1441 restart_gr
= save_gr
;
1442 restart_fr
= save_fr
;
1450 /* Return the address of the PC after the last prologue instruction if
1451 we can determine it from the debug symbols. Else return zero. */
1454 after_prologue (CORE_ADDR pc
)
1456 struct symtab_and_line sal
;
1457 CORE_ADDR func_addr
, func_end
;
1460 /* If we can not find the symbol in the partial symbol table, then
1461 there is no hope we can determine the function's start address
1463 if (!find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
1466 /* Get the line associated with FUNC_ADDR. */
1467 sal
= find_pc_line (func_addr
, 0);
1469 /* There are only two cases to consider. First, the end of the source line
1470 is within the function bounds. In that case we return the end of the
1471 source line. Second is the end of the source line extends beyond the
1472 bounds of the current function. We need to use the slow code to
1473 examine instructions in that case.
1475 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1476 the wrong thing to do. In fact, it should be entirely possible for this
1477 function to always return zero since the slow instruction scanning code
1478 is supposed to *always* work. If it does not, then it is a bug. */
1479 if (sal
.end
< func_end
)
1485 /* To skip prologues, I use this predicate. Returns either PC itself
1486 if the code at PC does not look like a function prologue; otherwise
1487 returns an address that (if we're lucky) follows the prologue. If
1488 LENIENT, then we must skip everything which is involved in setting
1489 up the frame (it's OK to skip more, just so long as we don't skip
1490 anything which might clobber the registers which are being saved.
1491 Currently we must not skip more on the alpha, but we might the lenient
1495 hppa_skip_prologue (CORE_ADDR pc
)
1499 CORE_ADDR post_prologue_pc
;
1502 /* See if we can determine the end of the prologue via the symbol table.
1503 If so, then return either PC, or the PC after the prologue, whichever
1506 post_prologue_pc
= after_prologue (pc
);
1508 /* If after_prologue returned a useful address, then use it. Else
1509 fall back on the instruction skipping code.
1511 Some folks have claimed this causes problems because the breakpoint
1512 may be the first instruction of the prologue. If that happens, then
1513 the instruction skipping code has a bug that needs to be fixed. */
1514 if (post_prologue_pc
!= 0)
1515 return max (pc
, post_prologue_pc
);
1517 return (skip_prologue_hard_way (pc
));
1520 struct hppa_frame_cache
1523 struct trad_frame_saved_reg
*saved_regs
;
1526 static struct hppa_frame_cache
*
1527 hppa_frame_cache (struct frame_info
*next_frame
, void **this_cache
)
1529 struct hppa_frame_cache
*cache
;
1534 struct unwind_table_entry
*u
;
1535 CORE_ADDR prologue_end
;
1539 fprintf_unfiltered (gdb_stdlog
, "{ hppa_frame_cache (frame=%d) -> ",
1540 frame_relative_level(next_frame
));
1542 if ((*this_cache
) != NULL
)
1545 fprintf_unfiltered (gdb_stdlog
, "base=0x%s (cached) }",
1546 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1547 return (*this_cache
);
1549 cache
= FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache
);
1550 (*this_cache
) = cache
;
1551 cache
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1554 u
= find_unwind_entry (frame_func_unwind (next_frame
));
1558 fprintf_unfiltered (gdb_stdlog
, "base=NULL (no unwind entry) }");
1559 return (*this_cache
);
1562 /* Turn the Entry_GR field into a bitmask. */
1564 for (i
= 3; i
< u
->Entry_GR
+ 3; i
++)
1566 /* Frame pointer gets saved into a special location. */
1567 if (u
->Save_SP
&& i
== HPPA_FP_REGNUM
)
1570 saved_gr_mask
|= (1 << i
);
1573 /* Turn the Entry_FR field into a bitmask too. */
1575 for (i
= 12; i
< u
->Entry_FR
+ 12; i
++)
1576 saved_fr_mask
|= (1 << i
);
1578 /* Loop until we find everything of interest or hit a branch.
1580 For unoptimized GCC code and for any HP CC code this will never ever
1581 examine any user instructions.
1583 For optimized GCC code we're faced with problems. GCC will schedule
1584 its prologue and make prologue instructions available for delay slot
1585 filling. The end result is user code gets mixed in with the prologue
1586 and a prologue instruction may be in the delay slot of the first branch
1589 Some unexpected things are expected with debugging optimized code, so
1590 we allow this routine to walk past user instructions in optimized
1593 int final_iteration
= 0;
1594 CORE_ADDR pc
, end_pc
;
1595 int looking_for_sp
= u
->Save_SP
;
1596 int looking_for_rp
= u
->Save_RP
;
1599 /* We have to use hppa_skip_prologue instead of just
1600 skip_prologue_using_sal, in case we stepped into a function without
1601 symbol information. hppa_skip_prologue also bounds the returned
1602 pc by the passed in pc, so it will not return a pc in the next
1604 prologue_end
= hppa_skip_prologue (frame_func_unwind (next_frame
));
1605 end_pc
= frame_pc_unwind (next_frame
);
1607 if (prologue_end
!= 0 && end_pc
> prologue_end
)
1608 end_pc
= prologue_end
;
1612 for (pc
= frame_func_unwind (next_frame
);
1613 ((saved_gr_mask
|| saved_fr_mask
1614 || looking_for_sp
|| looking_for_rp
1615 || frame_size
< (u
->Total_frame_size
<< 3))
1621 long status
= target_read_memory (pc
, buf4
, sizeof buf4
);
1622 long inst
= extract_unsigned_integer (buf4
, sizeof buf4
);
1624 /* Note the interesting effects of this instruction. */
1625 frame_size
+= prologue_inst_adjust_sp (inst
);
1627 /* There are limited ways to store the return pointer into the
1629 if (inst
== 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1632 cache
->saved_regs
[RP_REGNUM
].addr
= -20;
1634 else if (inst
== 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1637 cache
->saved_regs
[RP_REGNUM
].addr
= -16;
1640 /* Check to see if we saved SP into the stack. This also
1641 happens to indicate the location of the saved frame
1643 if ((inst
& 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1644 || (inst
& 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1647 cache
->saved_regs
[HPPA_FP_REGNUM
].addr
= 0;
1650 /* Account for general and floating-point register saves. */
1651 reg
= inst_saves_gr (inst
);
1652 if (reg
>= 3 && reg
<= 18
1653 && (!u
->Save_SP
|| reg
!= HPPA_FP_REGNUM
))
1655 saved_gr_mask
&= ~(1 << reg
);
1656 if ((inst
>> 26) == 0x1b && hppa_extract_14 (inst
) >= 0)
1657 /* stwm with a positive displacement is a _post_
1659 cache
->saved_regs
[reg
].addr
= 0;
1660 else if ((inst
& 0xfc00000c) == 0x70000008)
1661 /* A std has explicit post_modify forms. */
1662 cache
->saved_regs
[reg
].addr
= 0;
1667 if ((inst
>> 26) == 0x1c)
1668 offset
= (inst
& 0x1 ? -1 << 13 : 0) | (((inst
>> 4) & 0x3ff) << 3);
1669 else if ((inst
>> 26) == 0x03)
1670 offset
= hppa_low_hppa_sign_extend (inst
& 0x1f, 5);
1672 offset
= hppa_extract_14 (inst
);
1674 /* Handle code with and without frame pointers. */
1676 cache
->saved_regs
[reg
].addr
= offset
;
1678 cache
->saved_regs
[reg
].addr
= (u
->Total_frame_size
<< 3) + offset
;
1682 /* GCC handles callee saved FP regs a little differently.
1684 It emits an instruction to put the value of the start of
1685 the FP store area into %r1. It then uses fstds,ma with a
1686 basereg of %r1 for the stores.
1688 HP CC emits them at the current stack pointer modifying the
1689 stack pointer as it stores each register. */
1691 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1692 if ((inst
& 0xffffc000) == 0x34610000
1693 || (inst
& 0xffffc000) == 0x37c10000)
1694 fp_loc
= hppa_extract_14 (inst
);
1696 reg
= inst_saves_fr (inst
);
1697 if (reg
>= 12 && reg
<= 21)
1699 /* Note +4 braindamage below is necessary because the FP
1700 status registers are internally 8 registers rather than
1701 the expected 4 registers. */
1702 saved_fr_mask
&= ~(1 << reg
);
1705 /* 1st HP CC FP register store. After this
1706 instruction we've set enough state that the GCC and
1707 HPCC code are both handled in the same manner. */
1708 cache
->saved_regs
[reg
+ FP4_REGNUM
+ 4].addr
= 0;
1713 cache
->saved_regs
[reg
+ HPPA_FP0_REGNUM
+ 4].addr
= fp_loc
;
1718 /* Quit if we hit any kind of branch the previous iteration. */
1719 if (final_iteration
)
1721 /* We want to look precisely one instruction beyond the branch
1722 if we have not found everything yet. */
1723 if (is_branch (inst
))
1724 final_iteration
= 1;
1729 /* The frame base always represents the value of %sp at entry to
1730 the current function (and is thus equivalent to the "saved"
1732 CORE_ADDR this_sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1735 fprintf_unfiltered (gdb_stdlog
, " (this_sp=0x%s, pc=0x%s, "
1736 "prologue_end=0x%s) ",
1738 paddr_nz (frame_pc_unwind (next_frame
)),
1739 paddr_nz (prologue_end
));
1741 if (frame_pc_unwind (next_frame
) >= prologue_end
)
1743 if (u
->Save_SP
&& trad_frame_addr_p (cache
->saved_regs
, HPPA_SP_REGNUM
))
1745 /* Both we're expecting the SP to be saved and the SP has been
1746 saved. The entry SP value is saved at this frame's SP
1748 cache
->base
= read_memory_integer (this_sp
, TARGET_PTR_BIT
/ 8);
1751 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [saved] }",
1752 paddr_nz (cache
->base
));
1756 /* The prologue has been slowly allocating stack space. Adjust
1758 cache
->base
= this_sp
- frame_size
;
1760 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [unwind adjust] } ",
1761 paddr_nz (cache
->base
));
1767 /* This frame has not yet been created. */
1768 cache
->base
= this_sp
;
1771 fprintf_unfiltered (gdb_stdlog
, " (base=0x%s) [before prologue] } ",
1772 paddr_nz (cache
->base
));
1776 trad_frame_set_value (cache
->saved_regs
, HPPA_SP_REGNUM
, cache
->base
);
1779 /* The PC is found in the "return register", "Millicode" uses "r31"
1780 as the return register while normal code uses "rp". */
1783 if (trad_frame_addr_p (cache
->saved_regs
, RP_REGNUM
))
1784 cache
->saved_regs
[PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[31];
1787 ULONGEST r31
= frame_unwind_register_unsigned (next_frame
, 31);
1788 trad_frame_set_value (cache
->saved_regs
, PCOQ_HEAD_REGNUM
, r31
);
1793 if (trad_frame_addr_p (cache
->saved_regs
, RP_REGNUM
))
1794 cache
->saved_regs
[PCOQ_HEAD_REGNUM
] = cache
->saved_regs
[RP_REGNUM
];
1797 ULONGEST rp
= frame_unwind_register_unsigned (next_frame
, RP_REGNUM
);
1798 trad_frame_set_value (cache
->saved_regs
, PCOQ_HEAD_REGNUM
, rp
);
1803 /* Convert all the offsets into addresses. */
1805 for (reg
= 0; reg
< NUM_REGS
; reg
++)
1807 if (trad_frame_addr_p (cache
->saved_regs
, reg
))
1808 cache
->saved_regs
[reg
].addr
+= cache
->base
;
1813 fprintf_unfiltered (gdb_stdlog
, "base=0x%s }",
1814 paddr_nz (((struct hppa_frame_cache
*)*this_cache
)->base
));
1815 return (*this_cache
);
1819 hppa_frame_this_id (struct frame_info
*next_frame
, void **this_cache
,
1820 struct frame_id
*this_id
)
1822 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1823 (*this_id
) = frame_id_build (info
->base
, frame_func_unwind (next_frame
));
1827 hppa_frame_prev_register (struct frame_info
*next_frame
,
1829 int regnum
, int *optimizedp
,
1830 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1831 int *realnump
, void *valuep
)
1833 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
, this_cache
);
1834 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1835 if (regnum
== PCOQ_TAIL_REGNUM
)
1837 /* The PCOQ TAIL, or NPC, needs to be computed from the unwound
1845 int regsize
= register_size (gdbarch
, PCOQ_HEAD_REGNUM
);
1848 enum lval_type lval
;
1851 bfd_byte value
[MAX_REGISTER_SIZE
];
1852 trad_frame_prev_register (next_frame
, info
->saved_regs
,
1853 PCOQ_HEAD_REGNUM
, &optimized
, &lval
, &addr
,
1855 pc
= extract_unsigned_integer (&value
, regsize
);
1856 store_unsigned_integer (valuep
, regsize
, pc
+ 4);
1861 trad_frame_prev_register (next_frame
, info
->saved_regs
, regnum
,
1862 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
1866 static const struct frame_unwind hppa_frame_unwind
=
1870 hppa_frame_prev_register
1873 static const struct frame_unwind
*
1874 hppa_frame_unwind_sniffer (struct frame_info
*next_frame
)
1876 return &hppa_frame_unwind
;
1880 hppa_frame_base_address (struct frame_info
*next_frame
,
1883 struct hppa_frame_cache
*info
= hppa_frame_cache (next_frame
,
1888 static const struct frame_base hppa_frame_base
= {
1890 hppa_frame_base_address
,
1891 hppa_frame_base_address
,
1892 hppa_frame_base_address
1895 static const struct frame_base
*
1896 hppa_frame_base_sniffer (struct frame_info
*next_frame
)
1898 return &hppa_frame_base
;
1901 /* Stub frames, used for all kinds of call stubs. */
1902 struct hppa_stub_unwind_cache
1905 struct trad_frame_saved_reg
*saved_regs
;
1908 static struct hppa_stub_unwind_cache
*
1909 hppa_stub_frame_unwind_cache (struct frame_info
*next_frame
,
1912 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1913 struct hppa_stub_unwind_cache
*info
;
1918 info
= FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache
);
1920 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
1922 info
->saved_regs
[PCOQ_HEAD_REGNUM
].realreg
= RP_REGNUM
;
1923 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
1929 hppa_stub_frame_this_id (struct frame_info
*next_frame
,
1930 void **this_prologue_cache
,
1931 struct frame_id
*this_id
)
1933 struct hppa_stub_unwind_cache
*info
1934 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
1935 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
1939 hppa_stub_frame_prev_register (struct frame_info
*next_frame
,
1940 void **this_prologue_cache
,
1941 int regnum
, int *optimizedp
,
1942 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1943 int *realnump
, void *bufferp
)
1945 struct hppa_stub_unwind_cache
*info
1946 = hppa_stub_frame_unwind_cache (next_frame
, this_prologue_cache
);
1947 int pcoqt
= (regnum
== PCOQ_TAIL_REGNUM
);
1948 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1949 int regsize
= register_size (gdbarch
, PCOQ_HEAD_REGNUM
);
1952 regnum
= PCOQ_HEAD_REGNUM
;
1954 trad_frame_prev_register (next_frame
, info
->saved_regs
, regnum
,
1955 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
1958 store_unsigned_integer (bufferp
, regsize
,
1959 extract_unsigned_integer (bufferp
, regsize
) + 4);
1962 static const struct frame_unwind hppa_stub_frame_unwind
= {
1964 hppa_stub_frame_this_id
,
1965 hppa_stub_frame_prev_register
1968 static const struct frame_unwind
*
1969 hppa_stub_unwind_sniffer (struct frame_info
*next_frame
)
1971 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1973 if (IN_SOLIB_CALL_TRAMPOLINE (pc
, NULL
)
1974 || IN_SOLIB_RETURN_TRAMPOLINE (pc
, NULL
))
1975 return &hppa_stub_frame_unwind
;
1979 static struct frame_id
1980 hppa_unwind_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1982 return frame_id_build (frame_unwind_register_unsigned (next_frame
,
1984 frame_pc_unwind (next_frame
));
1988 hppa_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1990 return frame_unwind_register_signed (next_frame
, PCOQ_HEAD_REGNUM
) & ~3;
1993 /* Instead of this nasty cast, add a method pvoid() that prints out a
1994 host VOID data type (remember %p isn't portable). */
1997 hppa_pointer_to_address_hack (void *ptr
)
1999 gdb_assert (sizeof (ptr
) == TYPE_LENGTH (builtin_type_void_data_ptr
));
2000 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr
, &ptr
);
2004 unwind_command (char *exp
, int from_tty
)
2007 struct unwind_table_entry
*u
;
2009 /* If we have an expression, evaluate it and use it as the address. */
2011 if (exp
!= 0 && *exp
!= 0)
2012 address
= parse_and_eval_address (exp
);
2016 u
= find_unwind_entry (address
);
2020 printf_unfiltered ("Can't find unwind table entry for %s\n", exp
);
2024 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2025 paddr_nz (hppa_pointer_to_address_hack (u
)));
2027 printf_unfiltered ("\tregion_start = ");
2028 print_address (u
->region_start
, gdb_stdout
);
2030 printf_unfiltered ("\n\tregion_end = ");
2031 print_address (u
->region_end
, gdb_stdout
);
2033 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2035 printf_unfiltered ("\n\tflags =");
2036 pif (Cannot_unwind
);
2038 pif (Millicode_save_sr0
);
2041 pif (Variable_Frame
);
2042 pif (Separate_Package_Body
);
2043 pif (Frame_Extension_Millicode
);
2044 pif (Stack_Overflow_Check
);
2045 pif (Two_Instruction_SP_Increment
);
2049 pif (Save_MRP_in_frame
);
2050 pif (extn_ptr_defined
);
2051 pif (Cleanup_defined
);
2052 pif (MPE_XL_interrupt_marker
);
2053 pif (HP_UX_interrupt_marker
);
2056 putchar_unfiltered ('\n');
2058 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2060 pin (Region_description
);
2063 pin (Total_frame_size
);
2067 hppa_skip_permanent_breakpoint (void)
2069 /* To step over a breakpoint instruction on the PA takes some
2070 fiddling with the instruction address queue.
2072 When we stop at a breakpoint, the IA queue front (the instruction
2073 we're executing now) points at the breakpoint instruction, and
2074 the IA queue back (the next instruction to execute) points to
2075 whatever instruction we would execute after the breakpoint, if it
2076 were an ordinary instruction. This is the case even if the
2077 breakpoint is in the delay slot of a branch instruction.
2079 Clearly, to step past the breakpoint, we need to set the queue
2080 front to the back. But what do we put in the back? What
2081 instruction comes after that one? Because of the branch delay
2082 slot, the next insn is always at the back + 4. */
2083 write_register (PCOQ_HEAD_REGNUM
, read_register (PCOQ_TAIL_REGNUM
));
2084 write_register (PCSQ_HEAD_REGNUM
, read_register (PCSQ_TAIL_REGNUM
));
2086 write_register (PCOQ_TAIL_REGNUM
, read_register (PCOQ_TAIL_REGNUM
) + 4);
2087 /* We can leave the tail's space the same, since there's no jump. */
2091 hppa_pc_requires_run_before_use (CORE_ADDR pc
)
2093 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2095 An example of this occurs when an a.out is linked against a foo.sl.
2096 The foo.sl defines a global bar(), and the a.out declares a signature
2097 for bar(). However, the a.out doesn't directly call bar(), but passes
2098 its address in another call.
2100 If you have this scenario and attempt to "break bar" before running,
2101 gdb will find a minimal symbol for bar() in the a.out. But that
2102 symbol's address will be negative. What this appears to denote is
2103 an index backwards from the base of the procedure linkage table (PLT)
2104 into the data linkage table (DLT), the end of which is contiguous
2105 with the start of the PLT. This is clearly not a valid address for
2106 us to set a breakpoint on.
2108 Note that one must be careful in how one checks for a negative address.
2109 0xc0000000 is a legitimate address of something in a shared text
2110 segment, for example. Since I don't know what the possible range
2111 is of these "really, truly negative" addresses that come from the
2112 minimal symbols, I'm resorting to the gross hack of checking the
2113 top byte of the address for all 1's. Sigh. */
2115 return (!target_has_stack
&& (pc
& 0xFF000000));
2119 hppa_instruction_nullified (void)
2121 /* brobecker 2002/11/07: Couldn't we use a ULONGEST here? It would
2122 avoid the type cast. I'm leaving it as is for now as I'm doing
2123 semi-mechanical multiarching-related changes. */
2124 const int ipsw
= (int) read_register (IPSW_REGNUM
);
2125 const int flags
= (int) read_register (FLAGS_REGNUM
);
2127 return ((ipsw
& 0x00200000) && !(flags
& 0x2));
2130 /* Return the GDB type object for the "standard" data type of data
2133 static struct type
*
2134 hppa32_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2136 if (reg_nr
< FP4_REGNUM
)
2137 return builtin_type_uint32
;
2139 return builtin_type_ieee_single_big
;
2142 /* Return the GDB type object for the "standard" data type of data
2143 in register N. hppa64 version. */
2145 static struct type
*
2146 hppa64_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
2148 if (reg_nr
< FP4_REGNUM
)
2149 return builtin_type_uint64
;
2151 return builtin_type_ieee_double_big
;
2154 /* Return True if REGNUM is not a register available to the user
2155 through ptrace(). */
2158 hppa_cannot_store_register (int regnum
)
2161 || regnum
== PCSQ_HEAD_REGNUM
2162 || (regnum
>= PCSQ_TAIL_REGNUM
&& regnum
< IPSW_REGNUM
)
2163 || (regnum
> IPSW_REGNUM
&& regnum
< FP4_REGNUM
));
2168 hppa_smash_text_address (CORE_ADDR addr
)
2170 /* The low two bits of the PC on the PA contain the privilege level.
2171 Some genius implementing a (non-GCC) compiler apparently decided
2172 this means that "addresses" in a text section therefore include a
2173 privilege level, and thus symbol tables should contain these bits.
2174 This seems like a bonehead thing to do--anyway, it seems to work
2175 for our purposes to just ignore those bits. */
2177 return (addr
&= ~0x3);
2180 /* Get the ith function argument for the current function. */
2182 hppa_fetch_pointer_argument (struct frame_info
*frame
, int argi
,
2186 get_frame_register (frame
, R0_REGNUM
+ 26 - argi
, &addr
);
2191 hppa_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
2192 int regnum
, void *buf
)
2196 regcache_raw_read_unsigned (regcache
, regnum
, &tmp
);
2197 if (regnum
== PCOQ_HEAD_REGNUM
|| regnum
== PCOQ_TAIL_REGNUM
)
2199 store_unsigned_integer (buf
, sizeof(tmp
), tmp
);
2202 /* Here is a table of C type sizes on hppa with various compiles
2203 and options. I measured this on PA 9000/800 with HP-UX 11.11
2204 and these compilers:
2206 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2207 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2208 /opt/aCC/bin/aCC B3910B A.03.45
2209 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2211 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2212 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2213 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2214 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2215 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2216 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2217 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2218 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2222 compiler and options
2223 char, short, int, long, long long
2224 float, double, long double
2227 So all these compilers use either ILP32 or LP64 model.
2228 TODO: gcc has more options so it needs more investigation.
2230 For floating point types, see:
2232 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2233 HP-UX floating-point guide, hpux 11.00
2235 -- chastain 2003-12-18 */
2237 static struct gdbarch
*
2238 hppa_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
2240 struct gdbarch_tdep
*tdep
;
2241 struct gdbarch
*gdbarch
;
2243 /* Try to determine the ABI of the object we are loading. */
2244 if (info
.abfd
!= NULL
&& info
.osabi
== GDB_OSABI_UNKNOWN
)
2246 /* If it's a SOM file, assume it's HP/UX SOM. */
2247 if (bfd_get_flavour (info
.abfd
) == bfd_target_som_flavour
)
2248 info
.osabi
= GDB_OSABI_HPUX_SOM
;
2251 /* find a candidate among the list of pre-declared architectures. */
2252 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
2254 return (arches
->gdbarch
);
2256 /* If none found, then allocate and initialize one. */
2257 tdep
= XZALLOC (struct gdbarch_tdep
);
2258 gdbarch
= gdbarch_alloc (&info
, tdep
);
2260 /* Determine from the bfd_arch_info structure if we are dealing with
2261 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2262 then default to a 32bit machine. */
2263 if (info
.bfd_arch_info
!= NULL
)
2264 tdep
->bytes_per_address
=
2265 info
.bfd_arch_info
->bits_per_address
/ info
.bfd_arch_info
->bits_per_byte
;
2267 tdep
->bytes_per_address
= 4;
2269 /* Some parts of the gdbarch vector depend on whether we are running
2270 on a 32 bits or 64 bits target. */
2271 switch (tdep
->bytes_per_address
)
2274 set_gdbarch_num_regs (gdbarch
, hppa32_num_regs
);
2275 set_gdbarch_register_name (gdbarch
, hppa32_register_name
);
2276 set_gdbarch_register_type (gdbarch
, hppa32_register_type
);
2279 set_gdbarch_num_regs (gdbarch
, hppa64_num_regs
);
2280 set_gdbarch_register_name (gdbarch
, hppa64_register_name
);
2281 set_gdbarch_register_type (gdbarch
, hppa64_register_type
);
2284 internal_error (__FILE__
, __LINE__
, "Unsupported address size: %d",
2285 tdep
->bytes_per_address
);
2288 set_gdbarch_long_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2289 set_gdbarch_ptr_bit (gdbarch
, tdep
->bytes_per_address
* TARGET_CHAR_BIT
);
2291 /* The following gdbarch vector elements are the same in both ILP32
2292 and LP64, but might show differences some day. */
2293 set_gdbarch_long_long_bit (gdbarch
, 64);
2294 set_gdbarch_long_double_bit (gdbarch
, 128);
2295 set_gdbarch_long_double_format (gdbarch
, &floatformat_ia64_quad_big
);
2297 /* The following gdbarch vector elements do not depend on the address
2298 size, or in any other gdbarch element previously set. */
2299 set_gdbarch_skip_prologue (gdbarch
, hppa_skip_prologue
);
2300 set_gdbarch_inner_than (gdbarch
, core_addr_greaterthan
);
2301 set_gdbarch_sp_regnum (gdbarch
, HPPA_SP_REGNUM
);
2302 set_gdbarch_fp0_regnum (gdbarch
, HPPA_FP0_REGNUM
);
2303 set_gdbarch_cannot_store_register (gdbarch
, hppa_cannot_store_register
);
2304 set_gdbarch_addr_bits_remove (gdbarch
, hppa_smash_text_address
);
2305 set_gdbarch_smash_text_address (gdbarch
, hppa_smash_text_address
);
2306 set_gdbarch_believe_pcc_promotion (gdbarch
, 1);
2307 set_gdbarch_read_pc (gdbarch
, hppa_target_read_pc
);
2308 set_gdbarch_write_pc (gdbarch
, hppa_target_write_pc
);
2310 /* Helper for function argument information. */
2311 set_gdbarch_fetch_pointer_argument (gdbarch
, hppa_fetch_pointer_argument
);
2313 set_gdbarch_print_insn (gdbarch
, print_insn_hppa
);
2315 /* When a hardware watchpoint triggers, we'll move the inferior past
2316 it by removing all eventpoints; stepping past the instruction
2317 that caused the trigger; reinserting eventpoints; and checking
2318 whether any watched location changed. */
2319 set_gdbarch_have_nonsteppable_watchpoint (gdbarch
, 1);
2321 /* Inferior function call methods. */
2322 switch (tdep
->bytes_per_address
)
2325 set_gdbarch_push_dummy_call (gdbarch
, hppa32_push_dummy_call
);
2326 set_gdbarch_frame_align (gdbarch
, hppa32_frame_align
);
2329 set_gdbarch_push_dummy_call (gdbarch
, hppa64_push_dummy_call
);
2330 set_gdbarch_frame_align (gdbarch
, hppa64_frame_align
);
2333 internal_error (__FILE__
, __LINE__
, "bad switch");
2336 /* Struct return methods. */
2337 switch (tdep
->bytes_per_address
)
2340 set_gdbarch_return_value (gdbarch
, hppa32_return_value
);
2343 set_gdbarch_return_value (gdbarch
, hppa64_return_value
);
2346 internal_error (__FILE__
, __LINE__
, "bad switch");
2349 set_gdbarch_breakpoint_from_pc (gdbarch
, hppa_breakpoint_from_pc
);
2350 set_gdbarch_pseudo_register_read (gdbarch
, hppa_pseudo_register_read
);
2352 /* Frame unwind methods. */
2353 set_gdbarch_unwind_dummy_id (gdbarch
, hppa_unwind_dummy_id
);
2354 set_gdbarch_unwind_pc (gdbarch
, hppa_unwind_pc
);
2356 /* Hook in the default unwinders. */
2357 frame_unwind_append_sniffer (gdbarch
, hppa_stub_unwind_sniffer
);
2358 frame_unwind_append_sniffer (gdbarch
, hppa_frame_unwind_sniffer
);
2359 frame_base_append_sniffer (gdbarch
, hppa_frame_base_sniffer
);
2361 /* Hook in ABI-specific overrides, if they have been registered. */
2362 gdbarch_init_osabi (info
, gdbarch
);
2368 hppa_dump_tdep (struct gdbarch
*current_gdbarch
, struct ui_file
*file
)
2370 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
2372 fprintf_unfiltered (file
, "bytes_per_address = %d\n",
2373 tdep
->bytes_per_address
);
2374 fprintf_unfiltered (file
, "elf = %s\n", tdep
->is_elf
? "yes" : "no");
2378 _initialize_hppa_tdep (void)
2380 struct cmd_list_element
*c
;
2381 void break_at_finish_command (char *arg
, int from_tty
);
2382 void tbreak_at_finish_command (char *arg
, int from_tty
);
2383 void break_at_finish_at_depth_command (char *arg
, int from_tty
);
2385 gdbarch_register (bfd_arch_hppa
, hppa_gdbarch_init
, hppa_dump_tdep
);
2387 hppa_objfile_priv_data
= register_objfile_data ();
2389 add_cmd ("unwind", class_maintenance
, unwind_command
,
2390 "Print unwind table entry at given address.",
2391 &maintenanceprintlist
);
2393 deprecate_cmd (add_com ("xbreak", class_breakpoint
,
2394 break_at_finish_command
,
2395 concat ("Set breakpoint at procedure exit. \n\
2396 Argument may be function name, or \"*\" and an address.\n\
2397 If function is specified, break at end of code for that function.\n\
2398 If an address is specified, break at the end of the function that contains \n\
2399 that exact address.\n",
2400 "With no arg, uses current execution address of selected stack frame.\n\
2401 This is useful for breaking on return to a stack frame.\n\
2403 Multiple breakpoints at one place are permitted, and useful if conditional.\n\
2405 Do \"help breakpoints\" for info on other commands dealing with breakpoints.", NULL
)), NULL
);
2406 deprecate_cmd (add_com_alias ("xb", "xbreak", class_breakpoint
, 1), NULL
);
2407 deprecate_cmd (add_com_alias ("xbr", "xbreak", class_breakpoint
, 1), NULL
);
2408 deprecate_cmd (add_com_alias ("xbre", "xbreak", class_breakpoint
, 1), NULL
);
2409 deprecate_cmd (add_com_alias ("xbrea", "xbreak", class_breakpoint
, 1), NULL
);
2411 deprecate_cmd (c
= add_com ("txbreak", class_breakpoint
,
2412 tbreak_at_finish_command
,
2413 "Set temporary breakpoint at procedure exit. Either there should\n\
2414 be no argument or the argument must be a depth.\n"), NULL
);
2415 set_cmd_completer (c
, location_completer
);
2418 deprecate_cmd (add_com ("bx", class_breakpoint
,
2419 break_at_finish_at_depth_command
,
2420 "Set breakpoint at procedure exit. Either there should\n\
2421 be no argument or the argument must be a depth.\n"), NULL
);
2423 /* Debug this files internals. */
2424 add_show_from_set (add_set_cmd ("hppa", class_maintenance
, var_zinteger
,
2425 &hppa_debug
, "Set hppa debugging.\n\
2426 When non-zero, hppa specific debugging is enabled.", &setdebuglist
), &showdebuglist
);