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 static const unsigned char *
629 hppa_breakpoint_from_pc (CORE_ADDR *pc, int *len)
631 static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
632 (*len) = sizeof (breakpoint);
636 /* Return the name of a register. */
639 hppa32_register_name (int i)
641 static char *names[] = {
642 "flags", "r1", "rp", "r3",
643 "r4", "r5", "r6", "r7",
644 "r8", "r9", "r10", "r11",
645 "r12", "r13", "r14", "r15",
646 "r16", "r17", "r18", "r19",
647 "r20", "r21", "r22", "r23",
648 "r24", "r25", "r26", "dp",
649 "ret0", "ret1", "sp", "r31",
650 "sar", "pcoqh", "pcsqh", "pcoqt",
651 "pcsqt", "eiem", "iir", "isr",
652 "ior", "ipsw", "goto", "sr4",
653 "sr0", "sr1", "sr2", "sr3",
654 "sr5", "sr6", "sr7", "cr0",
655 "cr8", "cr9", "ccr", "cr12",
656 "cr13", "cr24", "cr25", "cr26",
657 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
658 "fpsr", "fpe1", "fpe2", "fpe3",
659 "fpe4", "fpe5", "fpe6", "fpe7",
660 "fr4", "fr4R", "fr5", "fr5R",
661 "fr6", "fr6R", "fr7", "fr7R",
662 "fr8", "fr8R", "fr9", "fr9R",
663 "fr10", "fr10R", "fr11", "fr11R",
664 "fr12", "fr12R", "fr13", "fr13R",
665 "fr14", "fr14R", "fr15", "fr15R",
666 "fr16", "fr16R", "fr17", "fr17R",
667 "fr18", "fr18R", "fr19", "fr19R",
668 "fr20", "fr20R", "fr21", "fr21R",
669 "fr22", "fr22R", "fr23", "fr23R",
670 "fr24", "fr24R", "fr25", "fr25R",
671 "fr26", "fr26R", "fr27", "fr27R",
672 "fr28", "fr28R", "fr29", "fr29R",
673 "fr30", "fr30R", "fr31", "fr31R"
675 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
682 hppa64_register_name (int i)
684 static char *names[] = {
685 "flags", "r1", "rp", "r3",
686 "r4", "r5", "r6", "r7",
687 "r8", "r9", "r10", "r11",
688 "r12", "r13", "r14", "r15",
689 "r16", "r17", "r18", "r19",
690 "r20", "r21", "r22", "r23",
691 "r24", "r25", "r26", "dp",
692 "ret0", "ret1", "sp", "r31",
693 "sar", "pcoqh", "pcsqh", "pcoqt",
694 "pcsqt", "eiem", "iir", "isr",
695 "ior", "ipsw", "goto", "sr4",
696 "sr0", "sr1", "sr2", "sr3",
697 "sr5", "sr6", "sr7", "cr0",
698 "cr8", "cr9", "ccr", "cr12",
699 "cr13", "cr24", "cr25", "cr26",
700 "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
701 "fpsr", "fpe1", "fpe2", "fpe3",
702 "fr4", "fr5", "fr6", "fr7",
703 "fr8", "fr9", "fr10", "fr11",
704 "fr12", "fr13", "fr14", "fr15",
705 "fr16", "fr17", "fr18", "fr19",
706 "fr20", "fr21", "fr22", "fr23",
707 "fr24", "fr25", "fr26", "fr27",
708 "fr28", "fr29", "fr30", "fr31"
710 if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
716 /* This function pushes a stack frame with arguments as part of the
717 inferior function calling mechanism.
719 This is the version of the function for the 32-bit PA machines, in
720 which later arguments appear at lower addresses. (The stack always
721 grows towards higher addresses.)
723 We simply allocate the appropriate amount of stack space and put
724 arguments into their proper slots. */
727 hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
728 struct regcache *regcache, CORE_ADDR bp_addr,
729 int nargs, struct value **args, CORE_ADDR sp,
730 int struct_return, CORE_ADDR struct_addr)
732 /* Stack base address at which any pass-by-reference parameters are
734 CORE_ADDR struct_end = 0;
735 /* Stack base address at which the first parameter is stored. */
736 CORE_ADDR param_end = 0;
738 /* The inner most end of the stack after all the parameters have
740 CORE_ADDR new_sp = 0;
742 /* Two passes. First pass computes the location of everything,
743 second pass writes the bytes out. */
746 /* Global pointer (r19) of the function we are trying to call. */
749 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
751 for (write_pass = 0; write_pass < 2; write_pass++)
753 CORE_ADDR struct_ptr = 0;
754 /* The first parameter goes into sp-36, each stack slot is 4-bytes.
755 struct_ptr is adjusted for each argument below, so the first
756 argument will end up at sp-36. */
757 CORE_ADDR param_ptr = 32;
759 int small_struct = 0;
761 for (i = 0; i < nargs; i++)
763 struct value *arg = args[i];
764 struct type *type = check_typedef (value_type (arg));
765 /* The corresponding parameter that is pushed onto the
766 stack, and [possibly] passed in a register. */
769 memset (param_val, 0, sizeof param_val);
770 if (TYPE_LENGTH (type) > 8)
772 /* Large parameter, pass by reference. Store the value
773 in "struct" area and then pass its address. */
775 struct_ptr += align_up (TYPE_LENGTH (type), 8);
777 write_memory (struct_end - struct_ptr, VALUE_CONTENTS (arg),
779 store_unsigned_integer (param_val, 4, struct_end - struct_ptr);
781 else if (TYPE_CODE (type) == TYPE_CODE_INT
782 || TYPE_CODE (type) == TYPE_CODE_ENUM)
784 /* Integer value store, right aligned. "unpack_long"
785 takes care of any sign-extension problems. */
786 param_len = align_up (TYPE_LENGTH (type), 4);
787 store_unsigned_integer (param_val, param_len,
789 VALUE_CONTENTS (arg)));
791 else if (TYPE_CODE (type) == TYPE_CODE_FLT)
793 /* Floating point value store, right aligned. */
794 param_len = align_up (TYPE_LENGTH (type), 4);
795 memcpy (param_val, VALUE_CONTENTS (arg), param_len);
799 param_len = align_up (TYPE_LENGTH (type), 4);
801 /* Small struct value are stored right-aligned. */
802 memcpy (param_val + param_len - TYPE_LENGTH (type),
803 VALUE_CONTENTS (arg), TYPE_LENGTH (type));
805 /* Structures of size 5, 6 and 7 bytes are special in that
806 the higher-ordered word is stored in the lower-ordered
807 argument, and even though it is a 8-byte quantity the
808 registers need not be 8-byte aligned. */
809 if (param_len > 4 && param_len < 8)
813 param_ptr += param_len;
814 if (param_len == 8 && !small_struct)
815 param_ptr = align_up (param_ptr, 8);
817 /* First 4 non-FP arguments are passed in gr26-gr23.
818 First 4 32-bit FP arguments are passed in fr4L-fr7L.
819 First 2 64-bit FP arguments are passed in fr5 and fr7.
821 The rest go on the stack, starting at sp-36, towards lower
822 addresses. 8-byte arguments must be aligned to a 8-byte
826 write_memory (param_end - param_ptr, param_val, param_len);
828 /* There are some cases when we don't know the type
829 expected by the callee (e.g. for variadic functions), so
830 pass the parameters in both general and fp regs. */
833 int grreg = 26 - (param_ptr - 36) / 4;
834 int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
835 int fpreg = 74 + (param_ptr - 32) / 8 * 4;
837 regcache_cooked_write (regcache, grreg, param_val);
838 regcache_cooked_write (regcache, fpLreg, param_val);
842 regcache_cooked_write (regcache, grreg + 1,
845 regcache_cooked_write (regcache, fpreg, param_val);
846 regcache_cooked_write (regcache, fpreg + 1,
853 /* Update the various stack pointers. */
856 struct_end = sp + align_up (struct_ptr, 64);
857 /* PARAM_PTR already accounts for all the arguments passed
858 by the user. However, the ABI mandates minimum stack
859 space allocations for outgoing arguments. The ABI also
860 mandates minimum stack alignments which we must
862 param_end = struct_end + align_up (param_ptr, 64);
866 /* If a structure has to be returned, set up register 28 to hold its
869 write_register (28, struct_addr);
871 gp = tdep->find_global_pointer (function);
874 write_register (19, gp);
876 /* Set the return address. */
877 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
879 /* Update the Stack Pointer. */
880 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
885 /* This function pushes a stack frame with arguments as part of the
886 inferior function calling mechanism.
888 This is the version for the PA64, in which later arguments appear
889 at higher addresses. (The stack always grows towards higher
892 We simply allocate the appropriate amount of stack space and put
893 arguments into their proper slots.
895 This ABI also requires that the caller provide an argument pointer
896 to the callee, so we do that too. */
899 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
900 struct regcache *regcache, CORE_ADDR bp_addr,
901 int nargs, struct value **args, CORE_ADDR sp,
902 int struct_return, CORE_ADDR struct_addr)
904 /* NOTE: cagney/2004-02-27: This is a guess - its implemented by
905 reverse engineering testsuite failures. */
907 /* Stack base address at which any pass-by-reference parameters are
909 CORE_ADDR struct_end = 0;
910 /* Stack base address at which the first parameter is stored. */
911 CORE_ADDR param_end = 0;
913 /* The inner most end of the stack after all the parameters have
915 CORE_ADDR new_sp = 0;
917 /* Two passes. First pass computes the location of everything,
918 second pass writes the bytes out. */
920 for (write_pass = 0; write_pass < 2; write_pass++)
922 CORE_ADDR struct_ptr = 0;
923 CORE_ADDR param_ptr = 0;
925 for (i = 0; i < nargs; i++)
927 struct value *arg = args[i];
928 struct type *type = check_typedef (value_type (arg));
929 if ((TYPE_CODE (type) == TYPE_CODE_INT
930 || TYPE_CODE (type) == TYPE_CODE_ENUM)
931 && TYPE_LENGTH (type) <= 8)
933 /* Integer value store, right aligned. "unpack_long"
934 takes care of any sign-extension problems. */
938 ULONGEST val = unpack_long (type, VALUE_CONTENTS (arg));
939 int reg = 27 - param_ptr / 8;
940 write_memory_unsigned_integer (param_end - param_ptr,
943 regcache_cooked_write_unsigned (regcache, reg, val);
948 /* Small struct value, store left aligned? */
950 if (TYPE_LENGTH (type) > 8)
952 param_ptr = align_up (param_ptr, 16);
953 reg = 26 - param_ptr / 8;
954 param_ptr += align_up (TYPE_LENGTH (type), 16);
958 param_ptr = align_up (param_ptr, 8);
959 reg = 26 - param_ptr / 8;
960 param_ptr += align_up (TYPE_LENGTH (type), 8);
965 write_memory (param_end - param_ptr, VALUE_CONTENTS (arg),
967 for (byte = 0; byte < TYPE_LENGTH (type); byte += 8)
971 int len = min (8, TYPE_LENGTH (type) - byte);
972 regcache_cooked_write_part (regcache, reg, 0, len,
973 VALUE_CONTENTS (arg) + byte);
980 /* Update the various stack pointers. */
983 struct_end = sp + struct_ptr;
984 /* PARAM_PTR already accounts for all the arguments passed
985 by the user. However, the ABI mandates minimum stack
986 space allocations for outgoing arguments. The ABI also
987 mandates minimum stack alignments which we must
989 param_end = struct_end + max (align_up (param_ptr, 16), 64);
993 /* If a structure has to be returned, set up register 28 to hold its
996 write_register (28, struct_addr);
998 /* Set the return address. */
999 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1001 /* Update the Stack Pointer. */
1002 regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end + 64);
1004 /* The stack will have 32 bytes of additional space for a frame marker. */
1005 return param_end + 64;
1009 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch,
1011 struct target_ops *targ)
1018 target_read_memory(plabel, (char *)&addr, 4);
1025 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1027 /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1029 return align_up (addr, 64);
1032 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1035 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1037 /* Just always 16-byte align. */
1038 return align_up (addr, 16);
1042 hppa_read_pc (ptid_t ptid)
1047 ipsw = read_register_pid (HPPA_IPSW_REGNUM, ptid);
1048 pc = read_register_pid (HPPA_PCOQ_HEAD_REGNUM, ptid);
1050 /* If the current instruction is nullified, then we are effectively
1051 still executing the previous instruction. Pretend we are still
1052 there. This is needed when single stepping; if the nullified
1053 instruction is on a different line, we don't want GDB to think
1054 we've stepped onto that line. */
1055 if (ipsw & 0x00200000)
1062 hppa_write_pc (CORE_ADDR pc, ptid_t ptid)
1064 write_register_pid (HPPA_PCOQ_HEAD_REGNUM, pc, ptid);
1065 write_register_pid (HPPA_PCOQ_TAIL_REGNUM, pc + 4, ptid);
1068 /* return the alignment of a type in bytes. Structures have the maximum
1069 alignment required by their fields. */
1072 hppa_alignof (struct type *type)
1074 int max_align, align, i;
1075 CHECK_TYPEDEF (type);
1076 switch (TYPE_CODE (type))
1081 return TYPE_LENGTH (type);
1082 case TYPE_CODE_ARRAY:
1083 return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
1084 case TYPE_CODE_STRUCT:
1085 case TYPE_CODE_UNION:
1087 for (i = 0; i < TYPE_NFIELDS (type); i++)
1089 /* Bit fields have no real alignment. */
1090 /* if (!TYPE_FIELD_BITPOS (type, i)) */
1091 if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
1093 align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
1094 max_align = max (max_align, align);
1103 /* For the given instruction (INST), return any adjustment it makes
1104 to the stack pointer or zero for no adjustment.
1106 This only handles instructions commonly found in prologues. */
1109 prologue_inst_adjust_sp (unsigned long inst)
1111 /* This must persist across calls. */
1112 static int save_high21;
1114 /* The most common way to perform a stack adjustment ldo X(sp),sp */
1115 if ((inst & 0xffffc000) == 0x37de0000)
1116 return hppa_extract_14 (inst);
1119 if ((inst & 0xffe00000) == 0x6fc00000)
1120 return hppa_extract_14 (inst);
1122 /* std,ma X,D(sp) */
1123 if ((inst & 0xffe00008) == 0x73c00008)
1124 return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1126 /* addil high21,%r1; ldo low11,(%r1),%r30)
1127 save high bits in save_high21 for later use. */
1128 if ((inst & 0xffe00000) == 0x28200000)
1130 save_high21 = hppa_extract_21 (inst);
1134 if ((inst & 0xffff0000) == 0x343e0000)
1135 return save_high21 + hppa_extract_14 (inst);
1137 /* fstws as used by the HP compilers. */
1138 if ((inst & 0xffffffe0) == 0x2fd01220)
1139 return hppa_extract_5_load (inst);
1141 /* No adjustment. */
1145 /* Return nonzero if INST is a branch of some kind, else return zero. */
1148 is_branch (unsigned long inst)
1177 /* Return the register number for a GR which is saved by INST or
1178 zero it INST does not save a GR. */
1181 inst_saves_gr (unsigned long inst)
1183 /* Does it look like a stw? */
1184 if ((inst >> 26) == 0x1a || (inst >> 26) == 0x1b
1185 || (inst >> 26) == 0x1f
1186 || ((inst >> 26) == 0x1f
1187 && ((inst >> 6) == 0xa)))
1188 return hppa_extract_5R_store (inst);
1190 /* Does it look like a std? */
1191 if ((inst >> 26) == 0x1c
1192 || ((inst >> 26) == 0x03
1193 && ((inst >> 6) & 0xf) == 0xb))
1194 return hppa_extract_5R_store (inst);
1196 /* Does it look like a stwm? GCC & HPC may use this in prologues. */
1197 if ((inst >> 26) == 0x1b)
1198 return hppa_extract_5R_store (inst);
1200 /* Does it look like sth or stb? HPC versions 9.0 and later use these
1202 if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18
1203 || ((inst >> 26) == 0x3
1204 && (((inst >> 6) & 0xf) == 0x8
1205 || (inst >> 6) & 0xf) == 0x9))
1206 return hppa_extract_5R_store (inst);
1211 /* Return the register number for a FR which is saved by INST or
1212 zero it INST does not save a FR.
1214 Note we only care about full 64bit register stores (that's the only
1215 kind of stores the prologue will use).
1217 FIXME: What about argument stores with the HP compiler in ANSI mode? */
1220 inst_saves_fr (unsigned long inst)
1222 /* is this an FSTD ? */
1223 if ((inst & 0xfc00dfc0) == 0x2c001200)
1224 return hppa_extract_5r_store (inst);
1225 if ((inst & 0xfc000002) == 0x70000002)
1226 return hppa_extract_5R_store (inst);
1227 /* is this an FSTW ? */
1228 if ((inst & 0xfc00df80) == 0x24001200)
1229 return hppa_extract_5r_store (inst);
1230 if ((inst & 0xfc000002) == 0x7c000000)
1231 return hppa_extract_5R_store (inst);
1235 /* Advance PC across any function entry prologue instructions
1236 to reach some "real" code.
1238 Use information in the unwind table to determine what exactly should
1239 be in the prologue. */
1243 skip_prologue_hard_way (CORE_ADDR pc, int stop_before_branch)
1246 CORE_ADDR orig_pc = pc;
1247 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1248 unsigned long args_stored, status, i, restart_gr, restart_fr;
1249 struct unwind_table_entry *u;
1250 int final_iteration;
1256 u = find_unwind_entry (pc);
1260 /* If we are not at the beginning of a function, then return now. */
1261 if ((pc & ~0x3) != u->region_start)
1264 /* This is how much of a frame adjustment we need to account for. */
1265 stack_remaining = u->Total_frame_size << 3;
1267 /* Magic register saves we want to know about. */
1268 save_rp = u->Save_RP;
1269 save_sp = u->Save_SP;
1271 /* An indication that args may be stored into the stack. Unfortunately
1272 the HPUX compilers tend to set this in cases where no args were
1276 /* Turn the Entry_GR field into a bitmask. */
1278 for (i = 3; i < u->Entry_GR + 3; i++)
1280 /* Frame pointer gets saved into a special location. */
1281 if (u->Save_SP && i == HPPA_FP_REGNUM)
1284 save_gr |= (1 << i);
1286 save_gr &= ~restart_gr;
1288 /* Turn the Entry_FR field into a bitmask too. */
1290 for (i = 12; i < u->Entry_FR + 12; i++)
1291 save_fr |= (1 << i);
1292 save_fr &= ~restart_fr;
1294 final_iteration = 0;
1296 /* Loop until we find everything of interest or hit a branch.
1298 For unoptimized GCC code and for any HP CC code this will never ever
1299 examine any user instructions.
1301 For optimzied GCC code we're faced with problems. GCC will schedule
1302 its prologue and make prologue instructions available for delay slot
1303 filling. The end result is user code gets mixed in with the prologue
1304 and a prologue instruction may be in the delay slot of the first branch
1307 Some unexpected things are expected with debugging optimized code, so
1308 we allow this routine to walk past user instructions in optimized
1310 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1313 unsigned int reg_num;
1314 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1315 unsigned long old_save_rp, old_save_sp, next_inst;
1317 /* Save copies of all the triggers so we can compare them later
1319 old_save_gr = save_gr;
1320 old_save_fr = save_fr;
1321 old_save_rp = save_rp;
1322 old_save_sp = save_sp;
1323 old_stack_remaining = stack_remaining;
1325 status = deprecated_read_memory_nobpt (pc, buf, 4);
1326 inst = extract_unsigned_integer (buf, 4);
1332 /* Note the interesting effects of this instruction. */
1333 stack_remaining -= prologue_inst_adjust_sp (inst);
1335 /* There are limited ways to store the return pointer into the
1337 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1)
1340 /* These are the only ways we save SP into the stack. At this time
1341 the HP compilers never bother to save SP into the stack. */
1342 if ((inst & 0xffffc000) == 0x6fc10000
1343 || (inst & 0xffffc00c) == 0x73c10008)
1346 /* Are we loading some register with an offset from the argument
1348 if ((inst & 0xffe00000) == 0x37a00000
1349 || (inst & 0xffffffe0) == 0x081d0240)
1355 /* Account for general and floating-point register saves. */
1356 reg_num = inst_saves_gr (inst);
1357 save_gr &= ~(1 << reg_num);
1359 /* Ugh. Also account for argument stores into the stack.
1360 Unfortunately args_stored only tells us that some arguments
1361 where stored into the stack. Not how many or what kind!
1363 This is a kludge as on the HP compiler sets this bit and it
1364 never does prologue scheduling. So once we see one, skip past
1365 all of them. We have similar code for the fp arg stores below.
1367 FIXME. Can still die if we have a mix of GR and FR argument
1369 if (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
1371 while (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
1374 status = deprecated_read_memory_nobpt (pc, buf, 4);
1375 inst = extract_unsigned_integer (buf, 4);
1378 reg_num = inst_saves_gr (inst);
1384 reg_num = inst_saves_fr (inst);
1385 save_fr &= ~(1 << reg_num);
1387 status = deprecated_read_memory_nobpt (pc + 4, buf, 4);
1388 next_inst = extract_unsigned_integer (buf, 4);
1394 /* We've got to be read to handle the ldo before the fp register
1396 if ((inst & 0xfc000000) == 0x34000000
1397 && inst_saves_fr (next_inst) >= 4
1398 && inst_saves_fr (next_inst) <= (TARGET_PTR_BIT == 64 ? 11 : 7))
1400 /* So we drop into the code below in a reasonable state. */
1401 reg_num = inst_saves_fr (next_inst);
1405 /* Ugh. Also account for argument stores into the stack.
1406 This is a kludge as on the HP compiler sets this bit and it
1407 never does prologue scheduling. So once we see one, skip past
1409 if (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
1411 while (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
1414 status = deprecated_read_memory_nobpt (pc, buf, 4);
1415 inst = extract_unsigned_integer (buf, 4);
1418 if ((inst & 0xfc000000) != 0x34000000)
1420 status = deprecated_read_memory_nobpt (pc + 4, buf, 4);
1421 next_inst = extract_unsigned_integer (buf, 4);
1424 reg_num = inst_saves_fr (next_inst);
1430 /* Quit if we hit any kind of branch. This can happen if a prologue
1431 instruction is in the delay slot of the first call/branch. */
1432 if (is_branch (inst) && stop_before_branch)
1435 /* What a crock. The HP compilers set args_stored even if no
1436 arguments were stored into the stack (boo hiss). This could
1437 cause this code to then skip a bunch of user insns (up to the
1440 To combat this we try to identify when args_stored was bogusly
1441 set and clear it. We only do this when args_stored is nonzero,
1442 all other resources are accounted for, and nothing changed on
1445 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1446 && old_save_gr == save_gr && old_save_fr == save_fr
1447 && old_save_rp == save_rp && old_save_sp == save_sp
1448 && old_stack_remaining == stack_remaining)
1454 /* !stop_before_branch, so also look at the insn in the delay slot
1456 if (final_iteration)
1458 if (is_branch (inst))
1459 final_iteration = 1;
1462 /* We've got a tenative location for the end of the prologue. However
1463 because of limitations in the unwind descriptor mechanism we may
1464 have went too far into user code looking for the save of a register
1465 that does not exist. So, if there registers we expected to be saved
1466 but never were, mask them out and restart.
1468 This should only happen in optimized code, and should be very rare. */
1469 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1472 restart_gr = save_gr;
1473 restart_fr = save_fr;
1481 /* Return the address of the PC after the last prologue instruction if
1482 we can determine it from the debug symbols. Else return zero. */
1485 after_prologue (CORE_ADDR pc)
1487 struct symtab_and_line sal;
1488 CORE_ADDR func_addr, func_end;
1491 /* If we can not find the symbol in the partial symbol table, then
1492 there is no hope we can determine the function's start address
1494 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1497 /* Get the line associated with FUNC_ADDR. */
1498 sal = find_pc_line (func_addr, 0);
1500 /* There are only two cases to consider. First, the end of the source line
1501 is within the function bounds. In that case we return the end of the
1502 source line. Second is the end of the source line extends beyond the
1503 bounds of the current function. We need to use the slow code to
1504 examine instructions in that case.
1506 Anything else is simply a bug elsewhere. Fixing it here is absolutely
1507 the wrong thing to do. In fact, it should be entirely possible for this
1508 function to always return zero since the slow instruction scanning code
1509 is supposed to *always* work. If it does not, then it is a bug. */
1510 if (sal.end < func_end)
1516 /* To skip prologues, I use this predicate. Returns either PC itself
1517 if the code at PC does not look like a function prologue; otherwise
1518 returns an address that (if we're lucky) follows the prologue.
1520 hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1521 It doesn't necessarily skips all the insns in the prologue. In fact
1522 we might not want to skip all the insns because a prologue insn may
1523 appear in the delay slot of the first branch, and we don't want to
1524 skip over the branch in that case. */
1527 hppa_skip_prologue (CORE_ADDR pc)
1531 CORE_ADDR post_prologue_pc;
1534 /* See if we can determine the end of the prologue via the symbol table.
1535 If so, then return either PC, or the PC after the prologue, whichever
1538 post_prologue_pc = after_prologue (pc);
1540 /* If after_prologue returned a useful address, then use it. Else
1541 fall back on the instruction skipping code.
1543 Some folks have claimed this causes problems because the breakpoint
1544 may be the first instruction of the prologue. If that happens, then
1545 the instruction skipping code has a bug that needs to be fixed. */
1546 if (post_prologue_pc != 0)
1547 return max (pc, post_prologue_pc);
1549 return (skip_prologue_hard_way (pc, 1));
1552 struct hppa_frame_cache
1555 struct trad_frame_saved_reg *saved_regs;
1558 static struct hppa_frame_cache *
1559 hppa_frame_cache (struct frame_info *next_frame, void **this_cache)
1561 struct hppa_frame_cache *cache;
1566 struct unwind_table_entry *u;
1567 CORE_ADDR prologue_end;
1572 fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1573 frame_relative_level(next_frame));
1575 if ((*this_cache) != NULL)
1578 fprintf_unfiltered (gdb_stdlog, "base=0x%s (cached) }",
1579 paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
1580 return (*this_cache);
1582 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1583 (*this_cache) = cache;
1584 cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1587 u = find_unwind_entry (frame_pc_unwind (next_frame));
1591 fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1592 return (*this_cache);
1595 /* Turn the Entry_GR field into a bitmask. */
1597 for (i = 3; i < u->Entry_GR + 3; i++)
1599 /* Frame pointer gets saved into a special location. */
1600 if (u->Save_SP && i == HPPA_FP_REGNUM)
1603 saved_gr_mask |= (1 << i);
1606 /* Turn the Entry_FR field into a bitmask too. */
1608 for (i = 12; i < u->Entry_FR + 12; i++)
1609 saved_fr_mask |= (1 << i);
1611 /* Loop until we find everything of interest or hit a branch.
1613 For unoptimized GCC code and for any HP CC code this will never ever
1614 examine any user instructions.
1616 For optimized GCC code we're faced with problems. GCC will schedule
1617 its prologue and make prologue instructions available for delay slot
1618 filling. The end result is user code gets mixed in with the prologue
1619 and a prologue instruction may be in the delay slot of the first branch
1622 Some unexpected things are expected with debugging optimized code, so
1623 we allow this routine to walk past user instructions in optimized
1626 int final_iteration = 0;
1627 CORE_ADDR pc, end_pc;
1628 int looking_for_sp = u->Save_SP;
1629 int looking_for_rp = u->Save_RP;
1632 /* We have to use skip_prologue_hard_way instead of just
1633 skip_prologue_using_sal, in case we stepped into a function without
1634 symbol information. hppa_skip_prologue also bounds the returned
1635 pc by the passed in pc, so it will not return a pc in the next
1638 We used to call hppa_skip_prologue to find the end of the prologue,
1639 but if some non-prologue instructions get scheduled into the prologue,
1640 and the program is compiled with debug information, the "easy" way
1641 in hppa_skip_prologue will return a prologue end that is too early
1642 for us to notice any potential frame adjustments. */
1644 /* We used to use frame_func_unwind () to locate the beginning of the
1645 function to pass to skip_prologue (). However, when objects are
1646 compiled without debug symbols, frame_func_unwind can return the wrong
1647 function (or 0). We can do better than that by using unwind records. */
1649 prologue_end = skip_prologue_hard_way (u->region_start, 0);
1650 end_pc = frame_pc_unwind (next_frame);
1652 if (prologue_end != 0 && end_pc > prologue_end)
1653 end_pc = prologue_end;
1657 for (pc = u->region_start;
1658 ((saved_gr_mask || saved_fr_mask
1659 || looking_for_sp || looking_for_rp
1660 || frame_size < (u->Total_frame_size << 3))
1668 if (!safe_frame_unwind_memory (next_frame, pc, buf4,
1671 error ("Cannot read instruction at 0x%s\n", paddr_nz (pc));
1672 return (*this_cache);
1675 inst = extract_unsigned_integer (buf4, sizeof buf4);
1677 /* Note the interesting effects of this instruction. */
1678 frame_size += prologue_inst_adjust_sp (inst);
1680 /* There are limited ways to store the return pointer into the
1682 if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
1685 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
1687 else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
1690 cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
1692 else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
1695 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
1698 /* Check to see if we saved SP into the stack. This also
1699 happens to indicate the location of the saved frame
1701 if ((inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
1702 || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
1705 cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
1707 else if (inst == 0x08030241) /* copy %r3, %r1 */
1712 /* Account for general and floating-point register saves. */
1713 reg = inst_saves_gr (inst);
1714 if (reg >= 3 && reg <= 18
1715 && (!u->Save_SP || reg != HPPA_FP_REGNUM))
1717 saved_gr_mask &= ~(1 << reg);
1718 if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
1719 /* stwm with a positive displacement is a _post_
1721 cache->saved_regs[reg].addr = 0;
1722 else if ((inst & 0xfc00000c) == 0x70000008)
1723 /* A std has explicit post_modify forms. */
1724 cache->saved_regs[reg].addr = 0;
1729 if ((inst >> 26) == 0x1c)
1730 offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1731 else if ((inst >> 26) == 0x03)
1732 offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
1734 offset = hppa_extract_14 (inst);
1736 /* Handle code with and without frame pointers. */
1738 cache->saved_regs[reg].addr = offset;
1740 cache->saved_regs[reg].addr = (u->Total_frame_size << 3) + offset;
1744 /* GCC handles callee saved FP regs a little differently.
1746 It emits an instruction to put the value of the start of
1747 the FP store area into %r1. It then uses fstds,ma with a
1748 basereg of %r1 for the stores.
1750 HP CC emits them at the current stack pointer modifying the
1751 stack pointer as it stores each register. */
1753 /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
1754 if ((inst & 0xffffc000) == 0x34610000
1755 || (inst & 0xffffc000) == 0x37c10000)
1756 fp_loc = hppa_extract_14 (inst);
1758 reg = inst_saves_fr (inst);
1759 if (reg >= 12 && reg <= 21)
1761 /* Note +4 braindamage below is necessary because the FP
1762 status registers are internally 8 registers rather than
1763 the expected 4 registers. */
1764 saved_fr_mask &= ~(1 << reg);
1767 /* 1st HP CC FP register store. After this
1768 instruction we've set enough state that the GCC and
1769 HPCC code are both handled in the same manner. */
1770 cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
1775 cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
1780 /* Quit if we hit any kind of branch the previous iteration. */
1781 if (final_iteration)
1783 /* We want to look precisely one instruction beyond the branch
1784 if we have not found everything yet. */
1785 if (is_branch (inst))
1786 final_iteration = 1;
1791 /* The frame base always represents the value of %sp at entry to
1792 the current function (and is thus equivalent to the "saved"
1794 CORE_ADDR this_sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
1798 fprintf_unfiltered (gdb_stdlog, " (this_sp=0x%s, pc=0x%s, "
1799 "prologue_end=0x%s) ",
1801 paddr_nz (frame_pc_unwind (next_frame)),
1802 paddr_nz (prologue_end));
1804 /* Check to see if a frame pointer is available, and use it for
1805 frame unwinding if it is.
1807 There are some situations where we need to rely on the frame
1808 pointer to do stack unwinding. For example, if a function calls
1809 alloca (), the stack pointer can get adjusted inside the body of
1810 the function. In this case, the ABI requires that the compiler
1811 maintain a frame pointer for the function.
1813 The unwind record has a flag (alloca_frame) that indicates that
1814 a function has a variable frame; unfortunately, gcc/binutils
1815 does not set this flag. Instead, whenever a frame pointer is used
1816 and saved on the stack, the Save_SP flag is set. We use this to
1817 decide whether to use the frame pointer for unwinding.
1819 TODO: For the HP compiler, maybe we should use the alloca_frame flag
1820 instead of Save_SP. */
1822 fp = frame_unwind_register_unsigned (next_frame, HPPA_FP_REGNUM);
1824 if (frame_pc_unwind (next_frame) >= prologue_end
1825 && u->Save_SP && fp != 0)
1830 fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [frame pointer] }",
1831 paddr_nz (cache->base));
1834 && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
1836 /* Both we're expecting the SP to be saved and the SP has been
1837 saved. The entry SP value is saved at this frame's SP
1839 cache->base = read_memory_integer (this_sp, TARGET_PTR_BIT / 8);
1842 fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [saved] }",
1843 paddr_nz (cache->base));
1847 /* The prologue has been slowly allocating stack space. Adjust
1849 cache->base = this_sp - frame_size;
1851 fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [unwind adjust] } ",
1852 paddr_nz (cache->base));
1855 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
1858 /* The PC is found in the "return register", "Millicode" uses "r31"
1859 as the return register while normal code uses "rp". */
1862 if (trad_frame_addr_p (cache->saved_regs, 31))
1863 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
1866 ULONGEST r31 = frame_unwind_register_unsigned (next_frame, 31);
1867 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
1872 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
1873 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[HPPA_RP_REGNUM];
1876 ULONGEST rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
1877 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
1881 /* If Save_SP is set, then we expect the frame pointer to be saved in the
1882 frame. However, there is a one-insn window where we haven't saved it
1883 yet, but we've already clobbered it. Detect this case and fix it up.
1885 The prologue sequence for frame-pointer functions is:
1886 0: stw %rp, -20(%sp)
1889 c: stw,ma %r1, XX(%sp)
1891 So if we are at offset c, the r3 value that we want is not yet saved
1892 on the stack, but it's been overwritten. The prologue analyzer will
1893 set fp_in_r1 when it sees the copy insn so we know to get the value
1895 if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
1898 ULONGEST r1 = frame_unwind_register_unsigned (next_frame, 1);
1899 trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
1903 /* Convert all the offsets into addresses. */
1905 for (reg = 0; reg < NUM_REGS; reg++)
1907 if (trad_frame_addr_p (cache->saved_regs, reg))
1908 cache->saved_regs[reg].addr += cache->base;
1913 struct gdbarch *gdbarch;
1914 struct gdbarch_tdep *tdep;
1916 gdbarch = get_frame_arch (next_frame);
1917 tdep = gdbarch_tdep (gdbarch);
1919 if (tdep->unwind_adjust_stub)
1921 tdep->unwind_adjust_stub (next_frame, cache->base, cache->saved_regs);
1926 fprintf_unfiltered (gdb_stdlog, "base=0x%s }",
1927 paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
1928 return (*this_cache);
1932 hppa_frame_this_id (struct frame_info *next_frame, void **this_cache,
1933 struct frame_id *this_id)
1935 struct hppa_frame_cache *info;
1936 CORE_ADDR pc = frame_pc_unwind (next_frame);
1937 struct unwind_table_entry *u;
1939 info = hppa_frame_cache (next_frame, this_cache);
1940 u = find_unwind_entry (pc);
1942 (*this_id) = frame_id_build (info->base, u->region_start);
1946 hppa_frame_prev_register (struct frame_info *next_frame,
1948 int regnum, int *optimizedp,
1949 enum lval_type *lvalp, CORE_ADDR *addrp,
1950 int *realnump, void *valuep)
1952 struct hppa_frame_cache *info = hppa_frame_cache (next_frame, this_cache);
1953 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
1954 optimizedp, lvalp, addrp, realnump, valuep);
1957 static const struct frame_unwind hppa_frame_unwind =
1961 hppa_frame_prev_register
1964 static const struct frame_unwind *
1965 hppa_frame_unwind_sniffer (struct frame_info *next_frame)
1967 CORE_ADDR pc = frame_pc_unwind (next_frame);
1969 if (find_unwind_entry (pc))
1970 return &hppa_frame_unwind;
1975 /* This is a generic fallback frame unwinder that kicks in if we fail all
1976 the other ones. Normally we would expect the stub and regular unwinder
1977 to work, but in some cases we might hit a function that just doesn't
1978 have any unwind information available. In this case we try to do
1979 unwinding solely based on code reading. This is obviously going to be
1980 slow, so only use this as a last resort. Currently this will only
1981 identify the stack and pc for the frame. */
1983 static struct hppa_frame_cache *
1984 hppa_fallback_frame_cache (struct frame_info *next_frame, void **this_cache)
1986 struct hppa_frame_cache *cache;
1987 unsigned int frame_size;
1989 CORE_ADDR pc, start_pc, end_pc, cur_pc;
1992 fprintf_unfiltered (gdb_stdlog, "{ hppa_fallback_frame_cache (frame=%d)-> ",
1993 frame_relative_level(next_frame));
1995 cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1996 (*this_cache) = cache;
1997 cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
1999 pc = frame_func_unwind (next_frame);
2000 cur_pc = frame_pc_unwind (next_frame);
2004 find_pc_partial_function (pc, NULL, &start_pc, &end_pc);
2006 if (start_pc == 0 || end_pc == 0)
2008 error ("Cannot find bounds of current function (@0x%s), unwinding will "
2009 "fail.", paddr_nz (pc));
2013 if (end_pc > cur_pc)
2016 for (pc = start_pc; pc < end_pc; pc += 4)
2020 insn = read_memory_unsigned_integer (pc, 4);
2022 frame_size += prologue_inst_adjust_sp (insn);
2024 /* There are limited ways to store the return pointer into the
2026 if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2028 cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2031 else if (insn == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
2033 cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2039 fprintf_unfiltered (gdb_stdlog, " frame_size = %d, found_rp = %d }\n",
2040 frame_size, found_rp);
2042 cache->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM) - frame_size;
2043 trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2045 if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2047 cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2048 cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[HPPA_RP_REGNUM];
2052 ULONGEST rp = frame_unwind_register_unsigned (next_frame, HPPA_RP_REGNUM);
2053 trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2060 hppa_fallback_frame_this_id (struct frame_info *next_frame, void **this_cache,
2061 struct frame_id *this_id)
2063 struct hppa_frame_cache *info =
2064 hppa_fallback_frame_cache (next_frame, this_cache);
2065 (*this_id) = frame_id_build (info->base, frame_func_unwind (next_frame));
2069 hppa_fallback_frame_prev_register (struct frame_info *next_frame,
2071 int regnum, int *optimizedp,
2072 enum lval_type *lvalp, CORE_ADDR *addrp,
2073 int *realnump, void *valuep)
2075 struct hppa_frame_cache *info =
2076 hppa_fallback_frame_cache (next_frame, this_cache);
2077 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2078 optimizedp, lvalp, addrp, realnump, valuep);
2081 static const struct frame_unwind hppa_fallback_frame_unwind =
2084 hppa_fallback_frame_this_id,
2085 hppa_fallback_frame_prev_register
2088 static const struct frame_unwind *
2089 hppa_fallback_unwind_sniffer (struct frame_info *next_frame)
2091 return &hppa_fallback_frame_unwind;
2094 /* Stub frames, used for all kinds of call stubs. */
2095 struct hppa_stub_unwind_cache
2098 struct trad_frame_saved_reg *saved_regs;
2101 static struct hppa_stub_unwind_cache *
2102 hppa_stub_frame_unwind_cache (struct frame_info *next_frame,
2105 struct gdbarch *gdbarch = get_frame_arch (next_frame);
2106 struct hppa_stub_unwind_cache *info;
2107 struct unwind_table_entry *u;
2112 info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
2114 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
2116 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
2118 if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2120 /* HPUX uses export stubs in function calls; the export stub clobbers
2121 the return value of the caller, and, later restores it from the
2123 u = find_unwind_entry (frame_pc_unwind (next_frame));
2125 if (u && u->stub_unwind.stub_type == EXPORT)
2127 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2133 /* By default we assume that stubs do not change the rp. */
2134 info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].realreg = HPPA_RP_REGNUM;
2140 hppa_stub_frame_this_id (struct frame_info *next_frame,
2141 void **this_prologue_cache,
2142 struct frame_id *this_id)
2144 struct hppa_stub_unwind_cache *info
2145 = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
2148 *this_id = frame_id_build (info->base, frame_func_unwind (next_frame));
2150 *this_id = null_frame_id;
2154 hppa_stub_frame_prev_register (struct frame_info *next_frame,
2155 void **this_prologue_cache,
2156 int regnum, int *optimizedp,
2157 enum lval_type *lvalp, CORE_ADDR *addrp,
2158 int *realnump, void *valuep)
2160 struct hppa_stub_unwind_cache *info
2161 = hppa_stub_frame_unwind_cache (next_frame, this_prologue_cache);
2164 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
2165 optimizedp, lvalp, addrp, realnump,
2168 error ("Requesting registers from null frame.\n");
2171 static const struct frame_unwind hppa_stub_frame_unwind = {
2173 hppa_stub_frame_this_id,
2174 hppa_stub_frame_prev_register
2177 static const struct frame_unwind *
2178 hppa_stub_unwind_sniffer (struct frame_info *next_frame)
2180 CORE_ADDR pc = frame_pc_unwind (next_frame);
2181 struct gdbarch *gdbarch = get_frame_arch (next_frame);
2182 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2185 || (tdep->in_solib_call_trampoline != NULL
2186 && tdep->in_solib_call_trampoline (pc, NULL))
2187 || IN_SOLIB_RETURN_TRAMPOLINE (pc, NULL))
2188 return &hppa_stub_frame_unwind;
2192 static struct frame_id
2193 hppa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
2195 return frame_id_build (frame_unwind_register_unsigned (next_frame,
2197 frame_pc_unwind (next_frame));
2201 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2206 ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2207 pc = frame_unwind_register_unsigned (next_frame, HPPA_PCOQ_HEAD_REGNUM);
2209 /* If the current instruction is nullified, then we are effectively
2210 still executing the previous instruction. Pretend we are still
2211 there. This is needed when single stepping; if the nullified
2212 instruction is on a different line, we don't want GDB to think
2213 we've stepped onto that line. */
2214 if (ipsw & 0x00200000)
2220 /* Instead of this nasty cast, add a method pvoid() that prints out a
2221 host VOID data type (remember %p isn't portable). */
2224 hppa_pointer_to_address_hack (void *ptr)
2226 gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr));
2227 return POINTER_TO_ADDRESS (builtin_type_void_data_ptr, &ptr);
2231 unwind_command (char *exp, int from_tty)
2234 struct unwind_table_entry *u;
2236 /* If we have an expression, evaluate it and use it as the address. */
2238 if (exp != 0 && *exp != 0)
2239 address = parse_and_eval_address (exp);
2243 u = find_unwind_entry (address);
2247 printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2251 printf_unfiltered ("unwind_table_entry (0x%s):\n",
2252 paddr_nz (hppa_pointer_to_address_hack (u)));
2254 printf_unfiltered ("\tregion_start = ");
2255 print_address (u->region_start, gdb_stdout);
2256 gdb_flush (gdb_stdout);
2258 printf_unfiltered ("\n\tregion_end = ");
2259 print_address (u->region_end, gdb_stdout);
2260 gdb_flush (gdb_stdout);
2262 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2264 printf_unfiltered ("\n\tflags =");
2265 pif (Cannot_unwind);
2267 pif (Millicode_save_sr0);
2270 pif (Variable_Frame);
2271 pif (Separate_Package_Body);
2272 pif (Frame_Extension_Millicode);
2273 pif (Stack_Overflow_Check);
2274 pif (Two_Instruction_SP_Increment);
2278 pif (Save_MRP_in_frame);
2279 pif (extn_ptr_defined);
2280 pif (Cleanup_defined);
2281 pif (MPE_XL_interrupt_marker);
2282 pif (HP_UX_interrupt_marker);
2285 putchar_unfiltered ('\n');
2287 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2289 pin (Region_description);
2292 pin (Total_frame_size);
2294 if (u->stub_unwind.stub_type)
2296 printf_unfiltered ("\tstub type = ");
2297 switch (u->stub_unwind.stub_type)
2300 printf_unfiltered ("long branch\n");
2302 case PARAMETER_RELOCATION:
2303 printf_unfiltered ("parameter relocation\n");
2306 printf_unfiltered ("export\n");
2309 printf_unfiltered ("import\n");
2312 printf_unfiltered ("import shlib\n");
2315 printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2321 hppa_pc_requires_run_before_use (CORE_ADDR pc)
2323 /* Sometimes we may pluck out a minimal symbol that has a negative address.
2325 An example of this occurs when an a.out is linked against a foo.sl.
2326 The foo.sl defines a global bar(), and the a.out declares a signature
2327 for bar(). However, the a.out doesn't directly call bar(), but passes
2328 its address in another call.
2330 If you have this scenario and attempt to "break bar" before running,
2331 gdb will find a minimal symbol for bar() in the a.out. But that
2332 symbol's address will be negative. What this appears to denote is
2333 an index backwards from the base of the procedure linkage table (PLT)
2334 into the data linkage table (DLT), the end of which is contiguous
2335 with the start of the PLT. This is clearly not a valid address for
2336 us to set a breakpoint on.
2338 Note that one must be careful in how one checks for a negative address.
2339 0xc0000000 is a legitimate address of something in a shared text
2340 segment, for example. Since I don't know what the possible range
2341 is of these "really, truly negative" addresses that come from the
2342 minimal symbols, I'm resorting to the gross hack of checking the
2343 top byte of the address for all 1's. Sigh. */
2345 return (!target_has_stack && (pc & 0xFF000000));
2348 /* Return the GDB type object for the "standard" data type of data
2351 static struct type *
2352 hppa32_register_type (struct gdbarch *gdbarch, int reg_nr)
2354 if (reg_nr < HPPA_FP4_REGNUM)
2355 return builtin_type_uint32;
2357 return builtin_type_ieee_single_big;
2360 /* Return the GDB type object for the "standard" data type of data
2361 in register N. hppa64 version. */
2363 static struct type *
2364 hppa64_register_type (struct gdbarch *gdbarch, int reg_nr)
2366 if (reg_nr < HPPA_FP4_REGNUM)
2367 return builtin_type_uint64;
2369 return builtin_type_ieee_double_big;
2372 /* Return True if REGNUM is not a register available to the user
2373 through ptrace(). */
2376 hppa_cannot_store_register (int regnum)
2379 || regnum == HPPA_PCSQ_HEAD_REGNUM
2380 || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2381 || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2386 hppa_smash_text_address (CORE_ADDR addr)
2388 /* The low two bits of the PC on the PA contain the privilege level.
2389 Some genius implementing a (non-GCC) compiler apparently decided
2390 this means that "addresses" in a text section therefore include a
2391 privilege level, and thus symbol tables should contain these bits.
2392 This seems like a bonehead thing to do--anyway, it seems to work
2393 for our purposes to just ignore those bits. */
2395 return (addr &= ~0x3);
2398 /* Get the ith function argument for the current function. */
2400 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2404 get_frame_register (frame, HPPA_R0_REGNUM + 26 - argi, &addr);
2409 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2410 int regnum, void *buf)
2414 regcache_raw_read_unsigned (regcache, regnum, &tmp);
2415 if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2417 store_unsigned_integer (buf, sizeof(tmp), tmp);
2421 hppa_find_global_pointer (struct value *function)
2427 hppa_frame_prev_register_helper (struct frame_info *next_frame,
2428 struct trad_frame_saved_reg saved_regs[],
2429 int regnum, int *optimizedp,
2430 enum lval_type *lvalp, CORE_ADDR *addrp,
2431 int *realnump, void *valuep)
2433 if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2439 trad_frame_get_prev_register (next_frame, saved_regs,
2440 HPPA_PCOQ_HEAD_REGNUM, optimizedp,
2441 lvalp, addrp, realnump, valuep);
2443 pc = extract_unsigned_integer (valuep, 4);
2444 store_unsigned_integer (valuep, 4, pc + 4);
2447 /* It's a computed value. */
2455 /* Make sure the "flags" register is zero in all unwound frames.
2456 The "flags" registers is a HP-UX specific wart, and only the code
2457 in hppa-hpux-tdep.c depends on it. However, it is easier to deal
2458 with it here. This shouldn't affect other systems since those
2459 should provide zero for the "flags" register anyway. */
2460 if (regnum == HPPA_FLAGS_REGNUM)
2463 store_unsigned_integer (valuep,
2464 register_size (get_frame_arch (next_frame),
2468 /* It's a computed value. */
2476 trad_frame_get_prev_register (next_frame, saved_regs, regnum,
2477 optimizedp, lvalp, addrp, realnump, valuep);
2481 /* Here is a table of C type sizes on hppa with various compiles
2482 and options. I measured this on PA 9000/800 with HP-UX 11.11
2483 and these compilers:
2485 /usr/ccs/bin/cc HP92453-01 A.11.01.21
2486 /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
2487 /opt/aCC/bin/aCC B3910B A.03.45
2488 gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
2490 cc : 1 2 4 4 8 : 4 8 -- : 4 4
2491 ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2492 ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2493 ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2494 acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
2495 acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
2496 acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
2497 gcc : 1 2 4 4 8 : 4 8 16 : 4 4
2501 compiler and options
2502 char, short, int, long, long long
2503 float, double, long double
2506 So all these compilers use either ILP32 or LP64 model.
2507 TODO: gcc has more options so it needs more investigation.
2509 For floating point types, see:
2511 http://docs.hp.com/hpux/pdf/B3906-90006.pdf
2512 HP-UX floating-point guide, hpux 11.00
2514 -- chastain 2003-12-18 */
2516 static struct gdbarch *
2517 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2519 struct gdbarch_tdep *tdep;
2520 struct gdbarch *gdbarch;
2522 /* Try to determine the ABI of the object we are loading. */
2523 if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
2525 /* If it's a SOM file, assume it's HP/UX SOM. */
2526 if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
2527 info.osabi = GDB_OSABI_HPUX_SOM;
2530 /* find a candidate among the list of pre-declared architectures. */
2531 arches = gdbarch_list_lookup_by_info (arches, &info);
2533 return (arches->gdbarch);
2535 /* If none found, then allocate and initialize one. */
2536 tdep = XZALLOC (struct gdbarch_tdep);
2537 gdbarch = gdbarch_alloc (&info, tdep);
2539 /* Determine from the bfd_arch_info structure if we are dealing with
2540 a 32 or 64 bits architecture. If the bfd_arch_info is not available,
2541 then default to a 32bit machine. */
2542 if (info.bfd_arch_info != NULL)
2543 tdep->bytes_per_address =
2544 info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
2546 tdep->bytes_per_address = 4;
2548 tdep->find_global_pointer = hppa_find_global_pointer;
2550 /* Some parts of the gdbarch vector depend on whether we are running
2551 on a 32 bits or 64 bits target. */
2552 switch (tdep->bytes_per_address)
2555 set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
2556 set_gdbarch_register_name (gdbarch, hppa32_register_name);
2557 set_gdbarch_register_type (gdbarch, hppa32_register_type);
2560 set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
2561 set_gdbarch_register_name (gdbarch, hppa64_register_name);
2562 set_gdbarch_register_type (gdbarch, hppa64_register_type);
2565 internal_error (__FILE__, __LINE__, "Unsupported address size: %d",
2566 tdep->bytes_per_address);
2569 set_gdbarch_long_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
2570 set_gdbarch_ptr_bit (gdbarch, tdep->bytes_per_address * TARGET_CHAR_BIT);
2572 /* The following gdbarch vector elements are the same in both ILP32
2573 and LP64, but might show differences some day. */
2574 set_gdbarch_long_long_bit (gdbarch, 64);
2575 set_gdbarch_long_double_bit (gdbarch, 128);
2576 set_gdbarch_long_double_format (gdbarch, &floatformat_ia64_quad_big);
2578 /* The following gdbarch vector elements do not depend on the address
2579 size, or in any other gdbarch element previously set. */
2580 set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue);
2581 set_gdbarch_inner_than (gdbarch, core_addr_greaterthan);
2582 set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM);
2583 set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM);
2584 set_gdbarch_cannot_store_register (gdbarch, hppa_cannot_store_register);
2585 set_gdbarch_cannot_fetch_register (gdbarch, hppa_cannot_store_register);
2586 set_gdbarch_addr_bits_remove (gdbarch, hppa_smash_text_address);
2587 set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
2588 set_gdbarch_believe_pcc_promotion (gdbarch, 1);
2589 set_gdbarch_read_pc (gdbarch, hppa_read_pc);
2590 set_gdbarch_write_pc (gdbarch, hppa_write_pc);
2592 /* Helper for function argument information. */
2593 set_gdbarch_fetch_pointer_argument (gdbarch, hppa_fetch_pointer_argument);
2595 set_gdbarch_print_insn (gdbarch, print_insn_hppa);
2597 /* When a hardware watchpoint triggers, we'll move the inferior past
2598 it by removing all eventpoints; stepping past the instruction
2599 that caused the trigger; reinserting eventpoints; and checking
2600 whether any watched location changed. */
2601 set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
2603 /* Inferior function call methods. */
2604 switch (tdep->bytes_per_address)
2607 set_gdbarch_push_dummy_call (gdbarch, hppa32_push_dummy_call);
2608 set_gdbarch_frame_align (gdbarch, hppa32_frame_align);
2609 set_gdbarch_convert_from_func_ptr_addr
2610 (gdbarch, hppa32_convert_from_func_ptr_addr);
2613 set_gdbarch_push_dummy_call (gdbarch, hppa64_push_dummy_call);
2614 set_gdbarch_frame_align (gdbarch, hppa64_frame_align);
2617 internal_error (__FILE__, __LINE__, "bad switch");
2620 /* Struct return methods. */
2621 switch (tdep->bytes_per_address)
2624 set_gdbarch_return_value (gdbarch, hppa32_return_value);
2627 set_gdbarch_return_value (gdbarch, hppa64_return_value);
2630 internal_error (__FILE__, __LINE__, "bad switch");
2633 set_gdbarch_breakpoint_from_pc (gdbarch, hppa_breakpoint_from_pc);
2634 set_gdbarch_pseudo_register_read (gdbarch, hppa_pseudo_register_read);
2636 /* Frame unwind methods. */
2637 set_gdbarch_unwind_dummy_id (gdbarch, hppa_unwind_dummy_id);
2638 set_gdbarch_unwind_pc (gdbarch, hppa_unwind_pc);
2640 /* Hook in ABI-specific overrides, if they have been registered. */
2641 gdbarch_init_osabi (info, gdbarch);
2643 /* Hook in the default unwinders. */
2644 frame_unwind_append_sniffer (gdbarch, hppa_stub_unwind_sniffer);
2645 frame_unwind_append_sniffer (gdbarch, hppa_frame_unwind_sniffer);
2646 frame_unwind_append_sniffer (gdbarch, hppa_fallback_unwind_sniffer);
2652 hppa_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
2654 struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
2656 fprintf_unfiltered (file, "bytes_per_address = %d\n",
2657 tdep->bytes_per_address);
2658 fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
2662 _initialize_hppa_tdep (void)
2664 struct cmd_list_element *c;
2666 gdbarch_register (bfd_arch_hppa, hppa_gdbarch_init, hppa_dump_tdep);
2668 hppa_objfile_priv_data = register_objfile_data ();
2670 add_cmd ("unwind", class_maintenance, unwind_command,
2671 "Print unwind table entry at given address.",
2672 &maintenanceprintlist);
2674 /* Debug this files internals. */
2675 add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, "\
2676 Set whether hppa target specific debugging information should be displayed.", "\
2677 Show whether hppa target specific debugging information is displayed.", "\
2678 This flag controls whether hppa target specific debugging information is\n\
2679 displayed. This information is particularly useful for debugging frame\n\
2680 unwinding problems.", "hppa debug flag is %s.",
2681 NULL, NULL, &setdebuglist, &showdebuglist);