GDB (xrefs)
/tmp/gdb-7.10/gdb/hppa-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for the HP PA-RISC architecture.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  Contributed by the Center for Software Science at the
6  University of Utah (pa-gdb-bugs@cs.utah.edu).
7 
8  This file is part of GDB.
9 
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 3 of the License, or
13  (at your option) any later version.
14 
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  GNU General Public License for more details.
19 
20  You should have received a copy of the GNU General Public License
21  along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 
23 #include "defs.h"
24 #include "bfd.h"
25 #include "inferior.h"
26 #include "regcache.h"
27 #include "completer.h"
28 #include "osabi.h"
29 #include "arch-utils.h"
30 /* For argument passing to the inferior. */
31 #include "symtab.h"
32 #include "dis-asm.h"
33 #include "trad-frame.h"
34 #include "frame-unwind.h"
35 #include "frame-base.h"
36 
37 #include "gdbcore.h"
38 #include "gdbcmd.h"
39 #include "gdbtypes.h"
40 #include "objfiles.h"
41 #include "hppa-tdep.h"
42 
43 static int hppa_debug = 0;
44 
45 /* Some local constants. */
46 static const int hppa32_num_regs = 128;
47 static const int hppa64_num_regs = 96;
48 
49 /* We use the objfile->obj_private pointer for two things:
50  * 1. An unwind table;
51  *
52  * 2. A pointer to any associated shared library object.
53  *
54  * #defines are used to help refer to these objects.
55  */
56 
57 /* Info about the unwind table associated with an object file.
58  * This is hung off of the "objfile->obj_private" pointer, and
59  * is allocated in the objfile's psymbol obstack. This allows
60  * us to have unique unwind info for each executable and shared
61  * library that we are debugging.
62  */
64  {
65  struct unwind_table_entry *table; /* Pointer to unwind info */
66  struct unwind_table_entry *cache; /* Pointer to last entry we found */
67  int last; /* Index of last entry */
68  };
69 
71  {
72  struct hppa_unwind_info *unwind_info; /* a pointer */
73  struct so_list *so_info; /* a pointer */
75 
78  };
79 
80 /* hppa-specific object data -- unwind and solib info.
81  TODO/maybe: think about splitting this into two parts; the unwind data is
82  common to all hppa targets, but is only used in this file; we can register
83  that separately and make this static. The solib data is probably hpux-
84  specific, so we can create a separate extern objfile_data that is registered
85  by hppa-hpux-tdep.c and shared with pa64solib.c and somsolib.c. */
86 static const struct objfile_data *hppa_objfile_priv_data = NULL;
87 
88 /* Get at various relevent fields of an instruction word. */
89 #define MASK_5 0x1f
90 #define MASK_11 0x7ff
91 #define MASK_14 0x3fff
92 #define MASK_21 0x1fffff
93 
94 /* Sizes (in bytes) of the native unwind entries. */
95 #define UNWIND_ENTRY_SIZE 16
96 #define STUB_UNWIND_ENTRY_SIZE 8
97 
98 /* Routines to extract various sized constants out of hppa
99  instructions. */
100 
101 /* This assumes that no garbage lies outside of the lower bits of
102  value. */
103 
104 static int
105 hppa_sign_extend (unsigned val, unsigned bits)
106 {
107  return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
108 }
109 
110 /* For many immediate values the sign bit is the low bit! */
111 
112 static int
113 hppa_low_hppa_sign_extend (unsigned val, unsigned bits)
114 {
115  return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
116 }
117 
118 /* Extract the bits at positions between FROM and TO, using HP's numbering
119  (MSB = 0). */
120 
121 int
122 hppa_get_field (unsigned word, int from, int to)
123 {
124  return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
125 }
126 
127 /* Extract the immediate field from a ld{bhw}s instruction. */
128 
129 int
131 {
132  return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5);
133 }
134 
135 /* Extract the immediate field from a break instruction. */
136 
137 unsigned
139 {
140  return (word & MASK_5);
141 }
142 
143 /* Extract the immediate field from a {sr}sm instruction. */
144 
145 unsigned
147 {
148  return (word >> 16 & MASK_5);
149 }
150 
151 /* Extract a 14 bit immediate field. */
152 
153 int
155 {
156  return hppa_low_hppa_sign_extend (word & MASK_14, 14);
157 }
158 
159 /* Extract a 21 bit constant. */
160 
161 int
163 {
164  int val;
165 
166  word &= MASK_21;
167  word <<= 11;
168  val = hppa_get_field (word, 20, 20);
169  val <<= 11;
170  val |= hppa_get_field (word, 9, 19);
171  val <<= 2;
172  val |= hppa_get_field (word, 5, 6);
173  val <<= 5;
174  val |= hppa_get_field (word, 0, 4);
175  val <<= 2;
176  val |= hppa_get_field (word, 7, 8);
177  return hppa_sign_extend (val, 21) << 11;
178 }
179 
180 /* extract a 17 bit constant from branch instructions, returning the
181  19 bit signed value. */
182 
183 int
185 {
186  return hppa_sign_extend (hppa_get_field (word, 19, 28) |
187  hppa_get_field (word, 29, 29) << 10 |
188  hppa_get_field (word, 11, 15) << 11 |
189  (word & 0x1) << 16, 17) << 2;
190 }
191 
192 CORE_ADDR
193 hppa_symbol_address(const char *sym)
194 {
195  struct bound_minimal_symbol minsym;
196 
197  minsym = lookup_minimal_symbol (sym, NULL, NULL);
198  if (minsym.minsym)
199  return BMSYMBOL_VALUE_ADDRESS (minsym);
200  else
201  return (CORE_ADDR)-1;
202 }
203 
204 static struct hppa_objfile_private *
206 {
207  struct hppa_objfile_private *priv;
208 
209  priv = (struct hppa_objfile_private *)
210  obstack_alloc (&objfile->objfile_obstack,
211  sizeof (struct hppa_objfile_private));
212  set_objfile_data (objfile, hppa_objfile_priv_data, priv);
213  memset (priv, 0, sizeof (*priv));
214 
215  return priv;
216 }
217 
218 
219 /* Compare the start address for two unwind entries returning 1 if
220  the first address is larger than the second, -1 if the second is
221  larger than the first, and zero if they are equal. */
222 
223 static int
224 compare_unwind_entries (const void *arg1, const void *arg2)
225 {
226  const struct unwind_table_entry *a = arg1;
227  const struct unwind_table_entry *b = arg2;
228 
229  if (a->region_start > b->region_start)
230  return 1;
231  else if (a->region_start < b->region_start)
232  return -1;
233  else
234  return 0;
235 }
236 
237 static void
238 record_text_segment_lowaddr (bfd *abfd, asection *section, void *data)
239 {
240  if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
241  == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
242  {
243  bfd_vma value = section->vma - section->filepos;
244  CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
245 
246  if (value < *low_text_segment_address)
247  *low_text_segment_address = value;
248  }
249 }
250 
251 static void
253  asection *section, unsigned int entries,
254  size_t size, CORE_ADDR text_offset)
255 {
256  /* We will read the unwind entries into temporary memory, then
257  fill in the actual unwind table. */
258 
259  if (size > 0)
260  {
261  struct gdbarch *gdbarch = get_objfile_arch (objfile);
262  unsigned long tmp;
263  unsigned i;
264  char *buf = alloca (size);
265  CORE_ADDR low_text_segment_address;
266 
267  /* For ELF targets, then unwinds are supposed to
268  be segment relative offsets instead of absolute addresses.
269 
270  Note that when loading a shared library (text_offset != 0) the
271  unwinds are already relative to the text_offset that will be
272  passed in. */
273  if (gdbarch_tdep (gdbarch)->is_elf && text_offset == 0)
274  {
275  low_text_segment_address = -1;
276 
277  bfd_map_over_sections (objfile->obfd,
279  &low_text_segment_address);
280 
281  text_offset = low_text_segment_address;
282  }
283  else if (gdbarch_tdep (gdbarch)->solib_get_text_base)
284  {
285  text_offset = gdbarch_tdep (gdbarch)->solib_get_text_base (objfile);
286  }
287 
288  bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
289 
290  /* Now internalize the information being careful to handle host/target
291  endian issues. */
292  for (i = 0; i < entries; i++)
293  {
294  table[i].region_start = bfd_get_32 (objfile->obfd,
295  (bfd_byte *) buf);
296  table[i].region_start += text_offset;
297  buf += 4;
298  table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
299  table[i].region_end += text_offset;
300  buf += 4;
301  tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
302  buf += 4;
303  table[i].Cannot_unwind = (tmp >> 31) & 0x1;
304  table[i].Millicode = (tmp >> 30) & 0x1;
305  table[i].Millicode_save_sr0 = (tmp >> 29) & 0x1;
306  table[i].Region_description = (tmp >> 27) & 0x3;
307  table[i].reserved = (tmp >> 26) & 0x1;
308  table[i].Entry_SR = (tmp >> 25) & 0x1;
309  table[i].Entry_FR = (tmp >> 21) & 0xf;
310  table[i].Entry_GR = (tmp >> 16) & 0x1f;
311  table[i].Args_stored = (tmp >> 15) & 0x1;
312  table[i].Variable_Frame = (tmp >> 14) & 0x1;
313  table[i].Separate_Package_Body = (tmp >> 13) & 0x1;
314  table[i].Frame_Extension_Millicode = (tmp >> 12) & 0x1;
315  table[i].Stack_Overflow_Check = (tmp >> 11) & 0x1;
316  table[i].Two_Instruction_SP_Increment = (tmp >> 10) & 0x1;
317  table[i].sr4export = (tmp >> 9) & 0x1;
318  table[i].cxx_info = (tmp >> 8) & 0x1;
319  table[i].cxx_try_catch = (tmp >> 7) & 0x1;
320  table[i].sched_entry_seq = (tmp >> 6) & 0x1;
321  table[i].reserved1 = (tmp >> 5) & 0x1;
322  table[i].Save_SP = (tmp >> 4) & 0x1;
323  table[i].Save_RP = (tmp >> 3) & 0x1;
324  table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
325  table[i].save_r19 = (tmp >> 1) & 0x1;
326  table[i].Cleanup_defined = tmp & 0x1;
327  tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
328  buf += 4;
329  table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
330  table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
331  table[i].Large_frame = (tmp >> 29) & 0x1;
332  table[i].alloca_frame = (tmp >> 28) & 0x1;
333  table[i].reserved2 = (tmp >> 27) & 0x1;
334  table[i].Total_frame_size = tmp & 0x7ffffff;
335 
336  /* Stub unwinds are handled elsewhere. */
337  table[i].stub_unwind.stub_type = 0;
338  table[i].stub_unwind.padding = 0;
339  }
340  }
341 }
342 
343 /* Read in the backtrace information stored in the `$UNWIND_START$' section of
344  the object file. This info is used mainly by find_unwind_entry() to find
345  out the stack frame size and frame pointer used by procedures. We put
346  everything on the psymbol obstack in the objfile so that it automatically
347  gets freed when the objfile is destroyed. */
348 
349 static void
351 {
352  asection *unwind_sec, *stub_unwind_sec;
353  size_t unwind_size, stub_unwind_size, total_size;
354  unsigned index, unwind_entries;
355  unsigned stub_entries, total_entries;
356  CORE_ADDR text_offset;
357  struct hppa_unwind_info *ui;
358  struct hppa_objfile_private *obj_private;
359 
360  text_offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
361  ui = (struct hppa_unwind_info *) obstack_alloc (&objfile->objfile_obstack,
362  sizeof (struct hppa_unwind_info));
363 
364  ui->table = NULL;
365  ui->cache = NULL;
366  ui->last = -1;
367 
368  /* For reasons unknown the HP PA64 tools generate multiple unwinder
369  sections in a single executable. So we just iterate over every
370  section in the BFD looking for unwinder sections intead of trying
371  to do a lookup with bfd_get_section_by_name.
372 
373  First determine the total size of the unwind tables so that we
374  can allocate memory in a nice big hunk. */
375  total_entries = 0;
376  for (unwind_sec = objfile->obfd->sections;
377  unwind_sec;
378  unwind_sec = unwind_sec->next)
379  {
380  if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
381  || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
382  {
383  unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
384  unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
385 
386  total_entries += unwind_entries;
387  }
388  }
389 
390  /* Now compute the size of the stub unwinds. Note the ELF tools do not
391  use stub unwinds at the current time. */
392  stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
393 
394  if (stub_unwind_sec)
395  {
396  stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
397  stub_entries = stub_unwind_size / STUB_UNWIND_ENTRY_SIZE;
398  }
399  else
400  {
401  stub_unwind_size = 0;
402  stub_entries = 0;
403  }
404 
405  /* Compute total number of unwind entries and their total size. */
406  total_entries += stub_entries;
407  total_size = total_entries * sizeof (struct unwind_table_entry);
408 
409  /* Allocate memory for the unwind table. */
410  ui->table = (struct unwind_table_entry *)
411  obstack_alloc (&objfile->objfile_obstack, total_size);
412  ui->last = total_entries - 1;
413 
414  /* Now read in each unwind section and internalize the standard unwind
415  entries. */
416  index = 0;
417  for (unwind_sec = objfile->obfd->sections;
418  unwind_sec;
419  unwind_sec = unwind_sec->next)
420  {
421  if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
422  || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
423  {
424  unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
425  unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
426 
427  internalize_unwinds (objfile, &ui->table[index], unwind_sec,
428  unwind_entries, unwind_size, text_offset);
429  index += unwind_entries;
430  }
431  }
432 
433  /* Now read in and internalize the stub unwind entries. */
434  if (stub_unwind_size > 0)
435  {
436  unsigned int i;
437  char *buf = alloca (stub_unwind_size);
438 
439  /* Read in the stub unwind entries. */
440  bfd_get_section_contents (objfile->obfd, stub_unwind_sec, buf,
441  0, stub_unwind_size);
442 
443  /* Now convert them into regular unwind entries. */
444  for (i = 0; i < stub_entries; i++, index++)
445  {
446  /* Clear out the next unwind entry. */
447  memset (&ui->table[index], 0, sizeof (struct unwind_table_entry));
448 
449  /* Convert offset & size into region_start and region_end.
450  Stuff away the stub type into "reserved" fields. */
451  ui->table[index].region_start = bfd_get_32 (objfile->obfd,
452  (bfd_byte *) buf);
453  ui->table[index].region_start += text_offset;
454  buf += 4;
455  ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
456  (bfd_byte *) buf);
457  buf += 2;
458  ui->table[index].region_end
459  = ui->table[index].region_start + 4 *
460  (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
461  buf += 2;
462  }
463 
464  }
465 
466  /* Unwind table needs to be kept sorted. */
467  qsort (ui->table, total_entries, sizeof (struct unwind_table_entry),
469 
470  /* Keep a pointer to the unwind information. */
471  obj_private = (struct hppa_objfile_private *)
472  objfile_data (objfile, hppa_objfile_priv_data);
473  if (obj_private == NULL)
474  obj_private = hppa_init_objfile_priv_data (objfile);
475 
476  obj_private->unwind_info = ui;
477 }
478 
479 /* Lookup the unwind (stack backtrace) info for the given PC. We search all
480  of the objfiles seeking the unwind table entry for this PC. Each objfile
481  contains a sorted list of struct unwind_table_entry. Since we do a binary
482  search of the unwind tables, we depend upon them to be sorted. */
483 
484 struct unwind_table_entry *
486 {
487  int first, middle, last;
488  struct objfile *objfile;
489  struct hppa_objfile_private *priv;
490 
491  if (hppa_debug)
492  fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry %s -> ",
493  hex_string (pc));
494 
495  /* A function at address 0? Not in HP-UX! */
496  if (pc == (CORE_ADDR) 0)
497  {
498  if (hppa_debug)
499  fprintf_unfiltered (gdb_stdlog, "NULL }\n");
500  return NULL;
501  }
502 
503  ALL_OBJFILES (objfile)
504  {
505  struct hppa_unwind_info *ui;
506  ui = NULL;
507  priv = objfile_data (objfile, hppa_objfile_priv_data);
508  if (priv)
509  ui = ((struct hppa_objfile_private *) priv)->unwind_info;
510 
511  if (!ui)
512  {
513  read_unwind_info (objfile);
514  priv = objfile_data (objfile, hppa_objfile_priv_data);
515  if (priv == NULL)
516  error (_("Internal error reading unwind information."));
517  ui = ((struct hppa_objfile_private *) priv)->unwind_info;
518  }
519 
520  /* First, check the cache. */
521 
522  if (ui->cache
523  && pc >= ui->cache->region_start
524  && pc <= ui->cache->region_end)
525  {
526  if (hppa_debug)
527  fprintf_unfiltered (gdb_stdlog, "%s (cached) }\n",
528  hex_string ((uintptr_t) ui->cache));
529  return ui->cache;
530  }
531 
532  /* Not in the cache, do a binary search. */
533 
534  first = 0;
535  last = ui->last;
536 
537  while (first <= last)
538  {
539  middle = (first + last) / 2;
540  if (pc >= ui->table[middle].region_start
541  && pc <= ui->table[middle].region_end)
542  {
543  ui->cache = &ui->table[middle];
544  if (hppa_debug)
545  fprintf_unfiltered (gdb_stdlog, "%s }\n",
546  hex_string ((uintptr_t) ui->cache));
547  return &ui->table[middle];
548  }
549 
550  if (pc < ui->table[middle].region_start)
551  last = middle - 1;
552  else
553  first = middle + 1;
554  }
555  } /* ALL_OBJFILES() */
556 
557  if (hppa_debug)
558  fprintf_unfiltered (gdb_stdlog, "NULL (not found) }\n");
559 
560  return NULL;
561 }
562 
563 /* Implement the stack_frame_destroyed_p gdbarch method.
564 
565  The epilogue is defined here as the area either on the `bv' instruction
566  itself or an instruction which destroys the function's stack frame.
567 
568  We do not assume that the epilogue is at the end of a function as we can
569  also have return sequences in the middle of a function. */
570 
571 static int
572 hppa_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
573 {
574  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
575  unsigned long status;
576  unsigned int inst;
577  gdb_byte buf[4];
578 
579  status = target_read_memory (pc, buf, 4);
580  if (status != 0)
581  return 0;
582 
583  inst = extract_unsigned_integer (buf, 4, byte_order);
584 
585  /* The most common way to perform a stack adjustment ldo X(sp),sp
586  We are destroying a stack frame if the offset is negative. */
587  if ((inst & 0xffffc000) == 0x37de0000
588  && hppa_extract_14 (inst) < 0)
589  return 1;
590 
591  /* ldw,mb D(sp),X or ldd,mb D(sp),X */
592  if (((inst & 0x0fc010e0) == 0x0fc010e0
593  || (inst & 0x0fc010e0) == 0x0fc010e0)
594  && hppa_extract_14 (inst) < 0)
595  return 1;
596 
597  /* bv %r0(%rp) or bv,n %r0(%rp) */
598  if (inst == 0xe840c000 || inst == 0xe840c002)
599  return 1;
600 
601  return 0;
602 }
603 
604 static const unsigned char *
605 hppa_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
606 {
607  static const unsigned char breakpoint[] = {0x00, 0x01, 0x00, 0x04};
608  (*len) = sizeof (breakpoint);
609  return breakpoint;
610 }
611 
612 /* Return the name of a register. */
613 
614 static const char *
615 hppa32_register_name (struct gdbarch *gdbarch, int i)
616 {
617  static char *names[] = {
618  "flags", "r1", "rp", "r3",
619  "r4", "r5", "r6", "r7",
620  "r8", "r9", "r10", "r11",
621  "r12", "r13", "r14", "r15",
622  "r16", "r17", "r18", "r19",
623  "r20", "r21", "r22", "r23",
624  "r24", "r25", "r26", "dp",
625  "ret0", "ret1", "sp", "r31",
626  "sar", "pcoqh", "pcsqh", "pcoqt",
627  "pcsqt", "eiem", "iir", "isr",
628  "ior", "ipsw", "goto", "sr4",
629  "sr0", "sr1", "sr2", "sr3",
630  "sr5", "sr6", "sr7", "cr0",
631  "cr8", "cr9", "ccr", "cr12",
632  "cr13", "cr24", "cr25", "cr26",
633  "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
634  "fpsr", "fpe1", "fpe2", "fpe3",
635  "fpe4", "fpe5", "fpe6", "fpe7",
636  "fr4", "fr4R", "fr5", "fr5R",
637  "fr6", "fr6R", "fr7", "fr7R",
638  "fr8", "fr8R", "fr9", "fr9R",
639  "fr10", "fr10R", "fr11", "fr11R",
640  "fr12", "fr12R", "fr13", "fr13R",
641  "fr14", "fr14R", "fr15", "fr15R",
642  "fr16", "fr16R", "fr17", "fr17R",
643  "fr18", "fr18R", "fr19", "fr19R",
644  "fr20", "fr20R", "fr21", "fr21R",
645  "fr22", "fr22R", "fr23", "fr23R",
646  "fr24", "fr24R", "fr25", "fr25R",
647  "fr26", "fr26R", "fr27", "fr27R",
648  "fr28", "fr28R", "fr29", "fr29R",
649  "fr30", "fr30R", "fr31", "fr31R"
650  };
651  if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
652  return NULL;
653  else
654  return names[i];
655 }
656 
657 static const char *
658 hppa64_register_name (struct gdbarch *gdbarch, int i)
659 {
660  static char *names[] = {
661  "flags", "r1", "rp", "r3",
662  "r4", "r5", "r6", "r7",
663  "r8", "r9", "r10", "r11",
664  "r12", "r13", "r14", "r15",
665  "r16", "r17", "r18", "r19",
666  "r20", "r21", "r22", "r23",
667  "r24", "r25", "r26", "dp",
668  "ret0", "ret1", "sp", "r31",
669  "sar", "pcoqh", "pcsqh", "pcoqt",
670  "pcsqt", "eiem", "iir", "isr",
671  "ior", "ipsw", "goto", "sr4",
672  "sr0", "sr1", "sr2", "sr3",
673  "sr5", "sr6", "sr7", "cr0",
674  "cr8", "cr9", "ccr", "cr12",
675  "cr13", "cr24", "cr25", "cr26",
676  "mpsfu_high","mpsfu_low","mpsfu_ovflo","pad",
677  "fpsr", "fpe1", "fpe2", "fpe3",
678  "fr4", "fr5", "fr6", "fr7",
679  "fr8", "fr9", "fr10", "fr11",
680  "fr12", "fr13", "fr14", "fr15",
681  "fr16", "fr17", "fr18", "fr19",
682  "fr20", "fr21", "fr22", "fr23",
683  "fr24", "fr25", "fr26", "fr27",
684  "fr28", "fr29", "fr30", "fr31"
685  };
686  if (i < 0 || i >= (sizeof (names) / sizeof (*names)))
687  return NULL;
688  else
689  return names[i];
690 }
691 
692 /* Map dwarf DBX register numbers to GDB register numbers. */
693 static int
694 hppa64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
695 {
696  /* The general registers and the sar are the same in both sets. */
697  if (reg <= 32)
698  return reg;
699 
700  /* fr4-fr31 are mapped from 72 in steps of 2. */
701  if (reg >= 72 && reg < 72 + 28 * 2 && !(reg & 1))
702  return HPPA64_FP4_REGNUM + (reg - 72) / 2;
703 
704  warning (_("Unmapped DWARF DBX Register #%d encountered."), reg);
705  return -1;
706 }
707 
708 /* This function pushes a stack frame with arguments as part of the
709  inferior function calling mechanism.
710 
711  This is the version of the function for the 32-bit PA machines, in
712  which later arguments appear at lower addresses. (The stack always
713  grows towards higher addresses.)
714 
715  We simply allocate the appropriate amount of stack space and put
716  arguments into their proper slots. */
717 
718 static CORE_ADDR
719 hppa32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
720  struct regcache *regcache, CORE_ADDR bp_addr,
721  int nargs, struct value **args, CORE_ADDR sp,
722  int struct_return, CORE_ADDR struct_addr)
723 {
724  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
725 
726  /* Stack base address at which any pass-by-reference parameters are
727  stored. */
728  CORE_ADDR struct_end = 0;
729  /* Stack base address at which the first parameter is stored. */
730  CORE_ADDR param_end = 0;
731 
732  /* The inner most end of the stack after all the parameters have
733  been pushed. */
734  CORE_ADDR new_sp = 0;
735 
736  /* Two passes. First pass computes the location of everything,
737  second pass writes the bytes out. */
738  int write_pass;
739 
740  /* Global pointer (r19) of the function we are trying to call. */
741  CORE_ADDR gp;
742 
743  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
744 
745  for (write_pass = 0; write_pass < 2; write_pass++)
746  {
747  CORE_ADDR struct_ptr = 0;
748  /* The first parameter goes into sp-36, each stack slot is 4-bytes.
749  struct_ptr is adjusted for each argument below, so the first
750  argument will end up at sp-36. */
751  CORE_ADDR param_ptr = 32;
752  int i;
753  int small_struct = 0;
754 
755  for (i = 0; i < nargs; i++)
756  {
757  struct value *arg = args[i];
758  struct type *type = check_typedef (value_type (arg));
759  /* The corresponding parameter that is pushed onto the
760  stack, and [possibly] passed in a register. */
761  gdb_byte param_val[8];
762  int param_len;
763  memset (param_val, 0, sizeof param_val);
764  if (TYPE_LENGTH (type) > 8)
765  {
766  /* Large parameter, pass by reference. Store the value
767  in "struct" area and then pass its address. */
768  param_len = 4;
769  struct_ptr += align_up (TYPE_LENGTH (type), 8);
770  if (write_pass)
771  write_memory (struct_end - struct_ptr, value_contents (arg),
772  TYPE_LENGTH (type));
773  store_unsigned_integer (param_val, 4, byte_order,
774  struct_end - struct_ptr);
775  }
776  else if (TYPE_CODE (type) == TYPE_CODE_INT
777  || TYPE_CODE (type) == TYPE_CODE_ENUM)
778  {
779  /* Integer value store, right aligned. "unpack_long"
780  takes care of any sign-extension problems. */
781  param_len = align_up (TYPE_LENGTH (type), 4);
782  store_unsigned_integer (param_val, param_len, byte_order,
783  unpack_long (type,
784  value_contents (arg)));
785  }
786  else if (TYPE_CODE (type) == TYPE_CODE_FLT)
787  {
788  /* Floating point value store, right aligned. */
789  param_len = align_up (TYPE_LENGTH (type), 4);
790  memcpy (param_val, value_contents (arg), param_len);
791  }
792  else
793  {
794  param_len = align_up (TYPE_LENGTH (type), 4);
795 
796  /* Small struct value are stored right-aligned. */
797  memcpy (param_val + param_len - TYPE_LENGTH (type),
798  value_contents (arg), TYPE_LENGTH (type));
799 
800  /* Structures of size 5, 6 and 7 bytes are special in that
801  the higher-ordered word is stored in the lower-ordered
802  argument, and even though it is a 8-byte quantity the
803  registers need not be 8-byte aligned. */
804  if (param_len > 4 && param_len < 8)
805  small_struct = 1;
806  }
807 
808  param_ptr += param_len;
809  if (param_len == 8 && !small_struct)
810  param_ptr = align_up (param_ptr, 8);
811 
812  /* First 4 non-FP arguments are passed in gr26-gr23.
813  First 4 32-bit FP arguments are passed in fr4L-fr7L.
814  First 2 64-bit FP arguments are passed in fr5 and fr7.
815 
816  The rest go on the stack, starting at sp-36, towards lower
817  addresses. 8-byte arguments must be aligned to a 8-byte
818  stack boundary. */
819  if (write_pass)
820  {
821  write_memory (param_end - param_ptr, param_val, param_len);
822 
823  /* There are some cases when we don't know the type
824  expected by the callee (e.g. for variadic functions), so
825  pass the parameters in both general and fp regs. */
826  if (param_ptr <= 48)
827  {
828  int grreg = 26 - (param_ptr - 36) / 4;
829  int fpLreg = 72 + (param_ptr - 36) / 4 * 2;
830  int fpreg = 74 + (param_ptr - 32) / 8 * 4;
831 
832  regcache_cooked_write (regcache, grreg, param_val);
833  regcache_cooked_write (regcache, fpLreg, param_val);
834 
835  if (param_len > 4)
836  {
837  regcache_cooked_write (regcache, grreg + 1,
838  param_val + 4);
839 
840  regcache_cooked_write (regcache, fpreg, param_val);
841  regcache_cooked_write (regcache, fpreg + 1,
842  param_val + 4);
843  }
844  }
845  }
846  }
847 
848  /* Update the various stack pointers. */
849  if (!write_pass)
850  {
851  struct_end = sp + align_up (struct_ptr, 64);
852  /* PARAM_PTR already accounts for all the arguments passed
853  by the user. However, the ABI mandates minimum stack
854  space allocations for outgoing arguments. The ABI also
855  mandates minimum stack alignments which we must
856  preserve. */
857  param_end = struct_end + align_up (param_ptr, 64);
858  }
859  }
860 
861  /* If a structure has to be returned, set up register 28 to hold its
862  address. */
863  if (struct_return)
864  regcache_cooked_write_unsigned (regcache, 28, struct_addr);
865 
866  gp = tdep->find_global_pointer (gdbarch, function);
867 
868  if (gp != 0)
869  regcache_cooked_write_unsigned (regcache, 19, gp);
870 
871  /* Set the return address. */
872  if (!gdbarch_push_dummy_code_p (gdbarch))
873  regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
874 
875  /* Update the Stack Pointer. */
876  regcache_cooked_write_unsigned (regcache, HPPA_SP_REGNUM, param_end);
877 
878  return param_end;
879 }
880 
881 /* The 64-bit PA-RISC calling conventions are documented in "64-Bit
882  Runtime Architecture for PA-RISC 2.0", which is distributed as part
883  as of the HP-UX Software Transition Kit (STK). This implementation
884  is based on version 3.3, dated October 6, 1997. */
885 
886 /* Check whether TYPE is an "Integral or Pointer Scalar Type". */
887 
888 static int
890 {
891  switch (TYPE_CODE (type))
892  {
893  case TYPE_CODE_INT:
894  case TYPE_CODE_BOOL:
895  case TYPE_CODE_CHAR:
896  case TYPE_CODE_ENUM:
897  case TYPE_CODE_RANGE:
898  {
899  int len = TYPE_LENGTH (type);
900  return (len == 1 || len == 2 || len == 4 || len == 8);
901  }
902  case TYPE_CODE_PTR:
903  case TYPE_CODE_REF:
904  return (TYPE_LENGTH (type) == 8);
905  default:
906  break;
907  }
908 
909  return 0;
910 }
911 
912 /* Check whether TYPE is a "Floating Scalar Type". */
913 
914 static int
915 hppa64_floating_p (const struct type *type)
916 {
917  switch (TYPE_CODE (type))
918  {
919  case TYPE_CODE_FLT:
920  {
921  int len = TYPE_LENGTH (type);
922  return (len == 4 || len == 8 || len == 16);
923  }
924  default:
925  break;
926  }
927 
928  return 0;
929 }
930 
931 /* If CODE points to a function entry address, try to look up the corresponding
932  function descriptor and return its address instead. If CODE is not a
933  function entry address, then just return it unchanged. */
934 static CORE_ADDR
936 {
937  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
938  struct obj_section *sec, *opd;
939 
940  sec = find_pc_section (code);
941 
942  if (!sec)
943  return code;
944 
945  /* If CODE is in a data section, assume it's already a fptr. */
946  if (!(sec->the_bfd_section->flags & SEC_CODE))
947  return code;
948 
949  ALL_OBJFILE_OSECTIONS (sec->objfile, opd)
950  {
951  if (strcmp (opd->the_bfd_section->name, ".opd") == 0)
952  break;
953  }
954 
955  if (opd < sec->objfile->sections_end)
956  {
957  CORE_ADDR addr;
958 
959  for (addr = obj_section_addr (opd);
960  addr < obj_section_endaddr (opd);
961  addr += 2 * 8)
962  {
963  ULONGEST opdaddr;
964  gdb_byte tmp[8];
965 
966  if (target_read_memory (addr, tmp, sizeof (tmp)))
967  break;
968  opdaddr = extract_unsigned_integer (tmp, sizeof (tmp), byte_order);
969 
970  if (opdaddr == code)
971  return addr - 16;
972  }
973  }
974 
975  return code;
976 }
977 
978 static CORE_ADDR
979 hppa64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
980  struct regcache *regcache, CORE_ADDR bp_addr,
981  int nargs, struct value **args, CORE_ADDR sp,
982  int struct_return, CORE_ADDR struct_addr)
983 {
984  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
985  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
986  int i, offset = 0;
987  CORE_ADDR gp;
988 
989  /* "The outgoing parameter area [...] must be aligned at a 16-byte
990  boundary." */
991  sp = align_up (sp, 16);
992 
993  for (i = 0; i < nargs; i++)
994  {
995  struct value *arg = args[i];
996  struct type *type = value_type (arg);
997  int len = TYPE_LENGTH (type);
998  const bfd_byte *valbuf;
999  bfd_byte fptrbuf[8];
1000  int regnum;
1001 
1002  /* "Each parameter begins on a 64-bit (8-byte) boundary." */
1003  offset = align_up (offset, 8);
1004 
1005  if (hppa64_integral_or_pointer_p (type))
1006  {
1007  /* "Integral scalar parameters smaller than 64 bits are
1008  padded on the left (i.e., the value is in the
1009  least-significant bits of the 64-bit storage unit, and
1010  the high-order bits are undefined)." Therefore we can
1011  safely sign-extend them. */
1012  if (len < 8)
1013  {
1014  arg = value_cast (builtin_type (gdbarch)->builtin_int64, arg);
1015  len = 8;
1016  }
1017  }
1018  else if (hppa64_floating_p (type))
1019  {
1020  if (len > 8)
1021  {
1022  /* "Quad-precision (128-bit) floating-point scalar
1023  parameters are aligned on a 16-byte boundary." */
1024  offset = align_up (offset, 16);
1025 
1026  /* "Double-extended- and quad-precision floating-point
1027  parameters within the first 64 bytes of the parameter
1028  list are always passed in general registers." */
1029  }
1030  else
1031  {
1032  if (len == 4)
1033  {
1034  /* "Single-precision (32-bit) floating-point scalar
1035  parameters are padded on the left with 32 bits of
1036  garbage (i.e., the floating-point value is in the
1037  least-significant 32 bits of a 64-bit storage
1038  unit)." */
1039  offset += 4;
1040  }
1041 
1042  /* "Single- and double-precision floating-point
1043  parameters in this area are passed according to the
1044  available formal parameter information in a function
1045  prototype. [...] If no prototype is in scope,
1046  floating-point parameters must be passed both in the
1047  corresponding general registers and in the
1048  corresponding floating-point registers." */
1049  regnum = HPPA64_FP4_REGNUM + offset / 8;
1050 
1051  if (regnum < HPPA64_FP4_REGNUM + 8)
1052  {
1053  /* "Single-precision floating-point parameters, when
1054  passed in floating-point registers, are passed in
1055  the right halves of the floating point registers;
1056  the left halves are unused." */
1057  regcache_cooked_write_part (regcache, regnum, offset % 8,
1058  len, value_contents (arg));
1059  }
1060  }
1061  }
1062  else
1063  {
1064  if (len > 8)
1065  {
1066  /* "Aggregates larger than 8 bytes are aligned on a
1067  16-byte boundary, possibly leaving an unused argument
1068  slot, which is filled with garbage. If necessary,
1069  they are padded on the right (with garbage), to a
1070  multiple of 8 bytes." */
1071  offset = align_up (offset, 16);
1072  }
1073  }
1074 
1075  /* If we are passing a function pointer, make sure we pass a function
1076  descriptor instead of the function entry address. */
1077  if (TYPE_CODE (type) == TYPE_CODE_PTR
1078  && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC)
1079  {
1080  ULONGEST codeptr, fptr;
1081 
1082  codeptr = unpack_long (type, value_contents (arg));
1083  fptr = hppa64_convert_code_addr_to_fptr (gdbarch, codeptr);
1084  store_unsigned_integer (fptrbuf, TYPE_LENGTH (type), byte_order,
1085  fptr);
1086  valbuf = fptrbuf;
1087  }
1088  else
1089  {
1090  valbuf = value_contents (arg);
1091  }
1092 
1093  /* Always store the argument in memory. */
1094  write_memory (sp + offset, valbuf, len);
1095 
1096  regnum = HPPA_ARG0_REGNUM - offset / 8;
1097  while (regnum > HPPA_ARG0_REGNUM - 8 && len > 0)
1098  {
1099  regcache_cooked_write_part (regcache, regnum,
1100  offset % 8, min (len, 8), valbuf);
1101  offset += min (len, 8);
1102  valbuf += min (len, 8);
1103  len -= min (len, 8);
1104  regnum--;
1105  }
1106 
1107  offset += len;
1108  }
1109 
1110  /* Set up GR29 (%ret1) to hold the argument pointer (ap). */
1111  regcache_cooked_write_unsigned (regcache, HPPA_RET1_REGNUM, sp + 64);
1112 
1113  /* Allocate the outgoing parameter area. Make sure the outgoing
1114  parameter area is multiple of 16 bytes in length. */
1115  sp += max (align_up (offset, 16), 64);
1116 
1117  /* Allocate 32-bytes of scratch space. The documentation doesn't
1118  mention this, but it seems to be needed. */
1119  sp += 32;
1120 
1121  /* Allocate the frame marker area. */
1122  sp += 16;
1123 
1124  /* If a structure has to be returned, set up GR 28 (%ret0) to hold
1125  its address. */
1126  if (struct_return)
1127  regcache_cooked_write_unsigned (regcache, HPPA_RET0_REGNUM, struct_addr);
1128 
1129  /* Set up GR27 (%dp) to hold the global pointer (gp). */
1130  gp = tdep->find_global_pointer (gdbarch, function);
1131  if (gp != 0)
1133 
1134  /* Set up GR2 (%rp) to hold the return pointer (rp). */
1135  if (!gdbarch_push_dummy_code_p (gdbarch))
1136  regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, bp_addr);
1137 
1138  /* Set up GR30 to hold the stack pointer (sp). */
1140 
1141  return sp;
1142 }
1143 
1144 
1145 /* Handle 32/64-bit struct return conventions. */
1146 
1147 static enum return_value_convention
1148 hppa32_return_value (struct gdbarch *gdbarch, struct value *function,
1149  struct type *type, struct regcache *regcache,
1150  gdb_byte *readbuf, const gdb_byte *writebuf)
1151 {
1152  if (TYPE_LENGTH (type) <= 2 * 4)
1153  {
1154  /* The value always lives in the right hand end of the register
1155  (or register pair)? */
1156  int b;
1157  int reg = TYPE_CODE (type) == TYPE_CODE_FLT ? HPPA_FP4_REGNUM : 28;
1158  int part = TYPE_LENGTH (type) % 4;
1159  /* The left hand register contains only part of the value,
1160  transfer that first so that the rest can be xfered as entire
1161  4-byte registers. */
1162  if (part > 0)
1163  {
1164  if (readbuf != NULL)
1165  regcache_cooked_read_part (regcache, reg, 4 - part,
1166  part, readbuf);
1167  if (writebuf != NULL)
1168  regcache_cooked_write_part (regcache, reg, 4 - part,
1169  part, writebuf);
1170  reg++;
1171  }
1172  /* Now transfer the remaining register values. */
1173  for (b = part; b < TYPE_LENGTH (type); b += 4)
1174  {
1175  if (readbuf != NULL)
1176  regcache_cooked_read (regcache, reg, readbuf + b);
1177  if (writebuf != NULL)
1178  regcache_cooked_write (regcache, reg, writebuf + b);
1179  reg++;
1180  }
1182  }
1183  else
1185 }
1186 
1187 static enum return_value_convention
1188 hppa64_return_value (struct gdbarch *gdbarch, struct value *function,
1189  struct type *type, struct regcache *regcache,
1190  gdb_byte *readbuf, const gdb_byte *writebuf)
1191 {
1192  int len = TYPE_LENGTH (type);
1193  int regnum, offset;
1194 
1195  if (len > 16)
1196  {
1197  /* All return values larget than 128 bits must be aggregate
1198  return values. */
1200  gdb_assert (!hppa64_floating_p (type));
1201 
1202  /* "Aggregate return values larger than 128 bits are returned in
1203  a buffer allocated by the caller. The address of the buffer
1204  must be passed in GR 28." */
1206  }
1207 
1208  if (hppa64_integral_or_pointer_p (type))
1209  {
1210  /* "Integral return values are returned in GR 28. Values
1211  smaller than 64 bits are padded on the left (with garbage)." */
1212  regnum = HPPA_RET0_REGNUM;
1213  offset = 8 - len;
1214  }
1215  else if (hppa64_floating_p (type))
1216  {
1217  if (len > 8)
1218  {
1219  /* "Double-extended- and quad-precision floating-point
1220  values are returned in GRs 28 and 29. The sign,
1221  exponent, and most-significant bits of the mantissa are
1222  returned in GR 28; the least-significant bits of the
1223  mantissa are passed in GR 29. For double-extended
1224  precision values, GR 29 is padded on the right with 48
1225  bits of garbage." */
1226  regnum = HPPA_RET0_REGNUM;
1227  offset = 0;
1228  }
1229  else
1230  {
1231  /* "Single-precision and double-precision floating-point
1232  return values are returned in FR 4R (single precision) or
1233  FR 4 (double-precision)." */
1234  regnum = HPPA64_FP4_REGNUM;
1235  offset = 8 - len;
1236  }
1237  }
1238  else
1239  {
1240  /* "Aggregate return values up to 64 bits in size are returned
1241  in GR 28. Aggregates smaller than 64 bits are left aligned
1242  in the register; the pad bits on the right are undefined."
1243 
1244  "Aggregate return values between 65 and 128 bits are returned
1245  in GRs 28 and 29. The first 64 bits are placed in GR 28, and
1246  the remaining bits are placed, left aligned, in GR 29. The
1247  pad bits on the right of GR 29 (if any) are undefined." */
1248  regnum = HPPA_RET0_REGNUM;
1249  offset = 0;
1250  }
1251 
1252  if (readbuf)
1253  {
1254  while (len > 0)
1255  {
1256  regcache_cooked_read_part (regcache, regnum, offset,
1257  min (len, 8), readbuf);
1258  readbuf += min (len, 8);
1259  len -= min (len, 8);
1260  regnum++;
1261  }
1262  }
1263 
1264  if (writebuf)
1265  {
1266  while (len > 0)
1267  {
1268  regcache_cooked_write_part (regcache, regnum, offset,
1269  min (len, 8), writebuf);
1270  writebuf += min (len, 8);
1271  len -= min (len, 8);
1272  regnum++;
1273  }
1274  }
1275 
1277 }
1278 
1279 
1280 static CORE_ADDR
1281 hppa32_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
1282  struct target_ops *targ)
1283 {
1284  if (addr & 2)
1285  {
1286  struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1287  CORE_ADDR plabel = addr & ~3;
1288  return read_memory_typed_address (plabel, func_ptr_type);
1289  }
1290 
1291  return addr;
1292 }
1293 
1294 static CORE_ADDR
1295 hppa32_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1296 {
1297  /* HP frames are 64-byte (or cache line) aligned (yes that's _byte_
1298  and not _bit_)! */
1299  return align_up (addr, 64);
1300 }
1301 
1302 /* Force all frames to 16-byte alignment. Better safe than sorry. */
1303 
1304 static CORE_ADDR
1305 hppa64_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1306 {
1307  /* Just always 16-byte align. */
1308  return align_up (addr, 16);
1309 }
1310 
1311 CORE_ADDR
1313 {
1314  ULONGEST ipsw;
1315  ULONGEST pc;
1316 
1319 
1320  /* If the current instruction is nullified, then we are effectively
1321  still executing the previous instruction. Pretend we are still
1322  there. This is needed when single stepping; if the nullified
1323  instruction is on a different line, we don't want GDB to think
1324  we've stepped onto that line. */
1325  if (ipsw & 0x00200000)
1326  pc -= 4;
1327 
1328  return pc & ~0x3;
1329 }
1330 
1331 void
1333 {
1336 }
1337 
1338 /* For the given instruction (INST), return any adjustment it makes
1339  to the stack pointer or zero for no adjustment.
1340 
1341  This only handles instructions commonly found in prologues. */
1342 
1343 static int
1344 prologue_inst_adjust_sp (unsigned long inst)
1345 {
1346  /* This must persist across calls. */
1347  static int save_high21;
1348 
1349  /* The most common way to perform a stack adjustment ldo X(sp),sp */
1350  if ((inst & 0xffffc000) == 0x37de0000)
1351  return hppa_extract_14 (inst);
1352 
1353  /* stwm X,D(sp) */
1354  if ((inst & 0xffe00000) == 0x6fc00000)
1355  return hppa_extract_14 (inst);
1356 
1357  /* std,ma X,D(sp) */
1358  if ((inst & 0xffe00008) == 0x73c00008)
1359  return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
1360 
1361  /* addil high21,%r30; ldo low11,(%r1),%r30)
1362  save high bits in save_high21 for later use. */
1363  if ((inst & 0xffe00000) == 0x2bc00000)
1364  {
1365  save_high21 = hppa_extract_21 (inst);
1366  return 0;
1367  }
1368 
1369  if ((inst & 0xffff0000) == 0x343e0000)
1370  return save_high21 + hppa_extract_14 (inst);
1371 
1372  /* fstws as used by the HP compilers. */
1373  if ((inst & 0xffffffe0) == 0x2fd01220)
1374  return hppa_extract_5_load (inst);
1375 
1376  /* No adjustment. */
1377  return 0;
1378 }
1379 
1380 /* Return nonzero if INST is a branch of some kind, else return zero. */
1381 
1382 static int
1383 is_branch (unsigned long inst)
1384 {
1385  switch (inst >> 26)
1386  {
1387  case 0x20:
1388  case 0x21:
1389  case 0x22:
1390  case 0x23:
1391  case 0x27:
1392  case 0x28:
1393  case 0x29:
1394  case 0x2a:
1395  case 0x2b:
1396  case 0x2f:
1397  case 0x30:
1398  case 0x31:
1399  case 0x32:
1400  case 0x33:
1401  case 0x38:
1402  case 0x39:
1403  case 0x3a:
1404  case 0x3b:
1405  return 1;
1406 
1407  default:
1408  return 0;
1409  }
1410 }
1411 
1412 /* Return the register number for a GR which is saved by INST or
1413  zero if INST does not save a GR.
1414 
1415  Referenced from:
1416 
1417  parisc 1.1:
1418  https://parisc.wiki.kernel.org/images-parisc/6/68/Pa11_acd.pdf
1419 
1420  parisc 2.0:
1421  https://parisc.wiki.kernel.org/images-parisc/7/73/Parisc2.0.pdf
1422 
1423  According to Table 6-5 of Chapter 6 (Memory Reference Instructions)
1424  on page 106 in parisc 2.0, all instructions for storing values from
1425  the general registers are:
1426 
1427  Store: stb, sth, stw, std (according to Chapter 7, they
1428  are only in both "inst >> 26" and "inst >> 6".
1429  Store Absolute: stwa, stda (according to Chapter 7, they are only
1430  in "inst >> 6".
1431  Store Bytes: stby, stdby (according to Chapter 7, they are
1432  only in "inst >> 6").
1433 
1434  For (inst >> 26), according to Chapter 7:
1435 
1436  The effective memory reference address is formed by the addition
1437  of an immediate displacement to a base value.
1438 
1439  - stb: 0x18, store a byte from a general register.
1440 
1441  - sth: 0x19, store a halfword from a general register.
1442 
1443  - stw: 0x1a, store a word from a general register.
1444 
1445  - stwm: 0x1b, store a word from a general register and perform base
1446  register modification (2.0 will still treate it as stw).
1447 
1448  - std: 0x1c, store a doubleword from a general register (2.0 only).
1449 
1450  - stw: 0x1f, store a word from a general register (2.0 only).
1451 
1452  For (inst >> 6) when ((inst >> 26) == 0x03), according to Chapter 7:
1453 
1454  The effective memory reference address is formed by the addition
1455  of an index value to a base value specified in the instruction.
1456 
1457  - stb: 0x08, store a byte from a general register (1.1 calls stbs).
1458 
1459  - sth: 0x09, store a halfword from a general register (1.1 calls
1460  sths).
1461 
1462  - stw: 0x0a, store a word from a general register (1.1 calls stws).
1463 
1464  - std: 0x0b: store a doubleword from a general register (2.0 only)
1465 
1466  Implement fast byte moves (stores) to unaligned word or doubleword
1467  destination.
1468 
1469  - stby: 0x0c, for unaligned word (1.1 calls stbys).
1470 
1471  - stdby: 0x0d for unaligned doubleword (2.0 only).
1472 
1473  Store a word or doubleword using an absolute memory address formed
1474  using short or long displacement or indexed
1475 
1476  - stwa: 0x0e, store a word from a general register to an absolute
1477  address (1.0 calls stwas).
1478 
1479  - stda: 0x0f, store a doubleword from a general register to an
1480  absolute address (2.0 only). */
1481 
1482 static int
1483 inst_saves_gr (unsigned long inst)
1484 {
1485  switch ((inst >> 26) & 0x0f)
1486  {
1487  case 0x03:
1488  switch ((inst >> 6) & 0x0f)
1489  {
1490  case 0x08:
1491  case 0x09:
1492  case 0x0a:
1493  case 0x0b:
1494  case 0x0c:
1495  case 0x0d:
1496  case 0x0e:
1497  case 0x0f:
1498  return hppa_extract_5R_store (inst);
1499  default:
1500  return 0;
1501  }
1502  case 0x18:
1503  case 0x19:
1504  case 0x1a:
1505  case 0x1b:
1506  case 0x1c:
1507  /* no 0x1d or 0x1e -- according to parisc 2.0 document */
1508  case 0x1f:
1509  return hppa_extract_5R_store (inst);
1510  default:
1511  return 0;
1512  }
1513 }
1514 
1515 /* Return the register number for a FR which is saved by INST or
1516  zero it INST does not save a FR.
1517 
1518  Note we only care about full 64bit register stores (that's the only
1519  kind of stores the prologue will use).
1520 
1521  FIXME: What about argument stores with the HP compiler in ANSI mode? */
1522 
1523 static int
1524 inst_saves_fr (unsigned long inst)
1525 {
1526  /* Is this an FSTD? */
1527  if ((inst & 0xfc00dfc0) == 0x2c001200)
1528  return hppa_extract_5r_store (inst);
1529  if ((inst & 0xfc000002) == 0x70000002)
1530  return hppa_extract_5R_store (inst);
1531  /* Is this an FSTW? */
1532  if ((inst & 0xfc00df80) == 0x24001200)
1533  return hppa_extract_5r_store (inst);
1534  if ((inst & 0xfc000002) == 0x7c000000)
1535  return hppa_extract_5R_store (inst);
1536  return 0;
1537 }
1538 
1539 /* Advance PC across any function entry prologue instructions
1540  to reach some "real" code.
1541 
1542  Use information in the unwind table to determine what exactly should
1543  be in the prologue. */
1544 
1545 
1546 static CORE_ADDR
1547 skip_prologue_hard_way (struct gdbarch *gdbarch, CORE_ADDR pc,
1548  int stop_before_branch)
1549 {
1550  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1551  gdb_byte buf[4];
1552  CORE_ADDR orig_pc = pc;
1553  unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1554  unsigned long args_stored, status, i, restart_gr, restart_fr;
1555  struct unwind_table_entry *u;
1556  int final_iteration;
1557 
1558  restart_gr = 0;
1559  restart_fr = 0;
1560 
1561 restart:
1562  u = find_unwind_entry (pc);
1563  if (!u)
1564  return pc;
1565 
1566  /* If we are not at the beginning of a function, then return now. */
1567  if ((pc & ~0x3) != u->region_start)
1568  return pc;
1569 
1570  /* This is how much of a frame adjustment we need to account for. */
1571  stack_remaining = u->Total_frame_size << 3;
1572 
1573  /* Magic register saves we want to know about. */
1574  save_rp = u->Save_RP;
1575  save_sp = u->Save_SP;
1576 
1577  /* An indication that args may be stored into the stack. Unfortunately
1578  the HPUX compilers tend to set this in cases where no args were
1579  stored too!. */
1580  args_stored = 1;
1581 
1582  /* Turn the Entry_GR field into a bitmask. */
1583  save_gr = 0;
1584  for (i = 3; i < u->Entry_GR + 3; i++)
1585  {
1586  /* Frame pointer gets saved into a special location. */
1587  if (u->Save_SP && i == HPPA_FP_REGNUM)
1588  continue;
1589 
1590  save_gr |= (1 << i);
1591  }
1592  save_gr &= ~restart_gr;
1593 
1594  /* Turn the Entry_FR field into a bitmask too. */
1595  save_fr = 0;
1596  for (i = 12; i < u->Entry_FR + 12; i++)
1597  save_fr |= (1 << i);
1598  save_fr &= ~restart_fr;
1599 
1600  final_iteration = 0;
1601 
1602  /* Loop until we find everything of interest or hit a branch.
1603 
1604  For unoptimized GCC code and for any HP CC code this will never ever
1605  examine any user instructions.
1606 
1607  For optimzied GCC code we're faced with problems. GCC will schedule
1608  its prologue and make prologue instructions available for delay slot
1609  filling. The end result is user code gets mixed in with the prologue
1610  and a prologue instruction may be in the delay slot of the first branch
1611  or call.
1612 
1613  Some unexpected things are expected with debugging optimized code, so
1614  we allow this routine to walk past user instructions in optimized
1615  GCC code. */
1616  while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1617  || args_stored)
1618  {
1619  unsigned int reg_num;
1620  unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1621  unsigned long old_save_rp, old_save_sp, next_inst;
1622 
1623  /* Save copies of all the triggers so we can compare them later
1624  (only for HPC). */
1625  old_save_gr = save_gr;
1626  old_save_fr = save_fr;
1627  old_save_rp = save_rp;
1628  old_save_sp = save_sp;
1629  old_stack_remaining = stack_remaining;
1630 
1631  status = target_read_memory (pc, buf, 4);
1632  inst = extract_unsigned_integer (buf, 4, byte_order);
1633 
1634  /* Yow! */
1635  if (status != 0)
1636  return pc;
1637 
1638  /* Note the interesting effects of this instruction. */
1639  stack_remaining -= prologue_inst_adjust_sp (inst);
1640 
1641  /* There are limited ways to store the return pointer into the
1642  stack. */
1643  if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1644  save_rp = 0;
1645 
1646  /* These are the only ways we save SP into the stack. At this time
1647  the HP compilers never bother to save SP into the stack. */
1648  if ((inst & 0xffffc000) == 0x6fc10000
1649  || (inst & 0xffffc00c) == 0x73c10008)
1650  save_sp = 0;
1651 
1652  /* Are we loading some register with an offset from the argument
1653  pointer? */
1654  if ((inst & 0xffe00000) == 0x37a00000
1655  || (inst & 0xffffffe0) == 0x081d0240)
1656  {
1657  pc += 4;
1658  continue;
1659  }
1660 
1661  /* Account for general and floating-point register saves. */
1662  reg_num = inst_saves_gr (inst);
1663  save_gr &= ~(1 << reg_num);
1664 
1665  /* Ugh. Also account for argument stores into the stack.
1666  Unfortunately args_stored only tells us that some arguments
1667  where stored into the stack. Not how many or what kind!
1668 
1669  This is a kludge as on the HP compiler sets this bit and it
1670  never does prologue scheduling. So once we see one, skip past
1671  all of them. We have similar code for the fp arg stores below.
1672 
1673  FIXME. Can still die if we have a mix of GR and FR argument
1674  stores! */
1675  if (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1676  && reg_num <= 26)
1677  {
1678  while (reg_num >= (gdbarch_ptr_bit (gdbarch) == 64 ? 19 : 23)
1679  && reg_num <= 26)
1680  {
1681  pc += 4;
1682  status = target_read_memory (pc, buf, 4);
1683  inst = extract_unsigned_integer (buf, 4, byte_order);
1684  if (status != 0)
1685  return pc;
1686  reg_num = inst_saves_gr (inst);
1687  }
1688  args_stored = 0;
1689  continue;
1690  }
1691 
1692  reg_num = inst_saves_fr (inst);
1693  save_fr &= ~(1 << reg_num);
1694 
1695  status = target_read_memory (pc + 4, buf, 4);
1696  next_inst = extract_unsigned_integer (buf, 4, byte_order);
1697 
1698  /* Yow! */
1699  if (status != 0)
1700  return pc;
1701 
1702  /* We've got to be read to handle the ldo before the fp register
1703  save. */
1704  if ((inst & 0xfc000000) == 0x34000000
1705  && inst_saves_fr (next_inst) >= 4
1706  && inst_saves_fr (next_inst)
1707  <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1708  {
1709  /* So we drop into the code below in a reasonable state. */
1710  reg_num = inst_saves_fr (next_inst);
1711  pc -= 4;
1712  }
1713 
1714  /* Ugh. Also account for argument stores into the stack.
1715  This is a kludge as on the HP compiler sets this bit and it
1716  never does prologue scheduling. So once we see one, skip past
1717  all of them. */
1718  if (reg_num >= 4
1719  && reg_num <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1720  {
1721  while (reg_num >= 4
1722  && reg_num
1723  <= (gdbarch_ptr_bit (gdbarch) == 64 ? 11 : 7))
1724  {
1725  pc += 8;
1726  status = target_read_memory (pc, buf, 4);
1727  inst = extract_unsigned_integer (buf, 4, byte_order);
1728  if (status != 0)
1729  return pc;
1730  if ((inst & 0xfc000000) != 0x34000000)
1731  break;
1732  status = target_read_memory (pc + 4, buf, 4);
1733  next_inst = extract_unsigned_integer (buf, 4, byte_order);
1734  if (status != 0)
1735  return pc;
1736  reg_num = inst_saves_fr (next_inst);
1737  }
1738  args_stored = 0;
1739  continue;
1740  }
1741 
1742  /* Quit if we hit any kind of branch. This can happen if a prologue
1743  instruction is in the delay slot of the first call/branch. */
1744  if (is_branch (inst) && stop_before_branch)
1745  break;
1746 
1747  /* What a crock. The HP compilers set args_stored even if no
1748  arguments were stored into the stack (boo hiss). This could
1749  cause this code to then skip a bunch of user insns (up to the
1750  first branch).
1751 
1752  To combat this we try to identify when args_stored was bogusly
1753  set and clear it. We only do this when args_stored is nonzero,
1754  all other resources are accounted for, and nothing changed on
1755  this pass. */
1756  if (args_stored
1757  && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1758  && old_save_gr == save_gr && old_save_fr == save_fr
1759  && old_save_rp == save_rp && old_save_sp == save_sp
1760  && old_stack_remaining == stack_remaining)
1761  break;
1762 
1763  /* Bump the PC. */
1764  pc += 4;
1765 
1766  /* !stop_before_branch, so also look at the insn in the delay slot
1767  of the branch. */
1768  if (final_iteration)
1769  break;
1770  if (is_branch (inst))
1771  final_iteration = 1;
1772  }
1773 
1774  /* We've got a tenative location for the end of the prologue. However
1775  because of limitations in the unwind descriptor mechanism we may
1776  have went too far into user code looking for the save of a register
1777  that does not exist. So, if there registers we expected to be saved
1778  but never were, mask them out and restart.
1779 
1780  This should only happen in optimized code, and should be very rare. */
1781  if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1782  {
1783  pc = orig_pc;
1784  restart_gr = save_gr;
1785  restart_fr = save_fr;
1786  goto restart;
1787  }
1788 
1789  return pc;
1790 }
1791 
1792 
1793 /* Return the address of the PC after the last prologue instruction if
1794  we can determine it from the debug symbols. Else return zero. */
1795 
1796 static CORE_ADDR
1798 {
1799  struct symtab_and_line sal;
1800  CORE_ADDR func_addr, func_end;
1801 
1802  /* If we can not find the symbol in the partial symbol table, then
1803  there is no hope we can determine the function's start address
1804  with this code. */
1805  if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1806  return 0;
1807 
1808  /* Get the line associated with FUNC_ADDR. */
1809  sal = find_pc_line (func_addr, 0);
1810 
1811  /* There are only two cases to consider. First, the end of the source line
1812  is within the function bounds. In that case we return the end of the
1813  source line. Second is the end of the source line extends beyond the
1814  bounds of the current function. We need to use the slow code to
1815  examine instructions in that case.
1816 
1817  Anything else is simply a bug elsewhere. Fixing it here is absolutely
1818  the wrong thing to do. In fact, it should be entirely possible for this
1819  function to always return zero since the slow instruction scanning code
1820  is supposed to *always* work. If it does not, then it is a bug. */
1821  if (sal.end < func_end)
1822  return sal.end;
1823  else
1824  return 0;
1825 }
1826 
1827 /* To skip prologues, I use this predicate. Returns either PC itself
1828  if the code at PC does not look like a function prologue; otherwise
1829  returns an address that (if we're lucky) follows the prologue.
1830 
1831  hppa_skip_prologue is called by gdb to place a breakpoint in a function.
1832  It doesn't necessarily skips all the insns in the prologue. In fact
1833  we might not want to skip all the insns because a prologue insn may
1834  appear in the delay slot of the first branch, and we don't want to
1835  skip over the branch in that case. */
1836 
1837 static CORE_ADDR
1838 hppa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1839 {
1840  CORE_ADDR post_prologue_pc;
1841 
1842  /* See if we can determine the end of the prologue via the symbol table.
1843  If so, then return either PC, or the PC after the prologue, whichever
1844  is greater. */
1845 
1846  post_prologue_pc = after_prologue (pc);
1847 
1848  /* If after_prologue returned a useful address, then use it. Else
1849  fall back on the instruction skipping code.
1850 
1851  Some folks have claimed this causes problems because the breakpoint
1852  may be the first instruction of the prologue. If that happens, then
1853  the instruction skipping code has a bug that needs to be fixed. */
1854  if (post_prologue_pc != 0)
1855  return max (pc, post_prologue_pc);
1856  else
1857  return (skip_prologue_hard_way (gdbarch, pc, 1));
1858 }
1859 
1860 /* Return an unwind entry that falls within the frame's code block. */
1861 
1862 static struct unwind_table_entry *
1864 {
1865  CORE_ADDR pc = get_frame_address_in_block (this_frame);
1866 
1867  /* FIXME drow/20070101: Calling gdbarch_addr_bits_remove on the
1868  result of get_frame_address_in_block implies a problem.
1869  The bits should have been removed earlier, before the return
1870  value of gdbarch_unwind_pc. That might be happening already;
1871  if it isn't, it should be fixed. Then this call can be
1872  removed. */
1873  pc = gdbarch_addr_bits_remove (get_frame_arch (this_frame), pc);
1874  return find_unwind_entry (pc);
1875 }
1876 
1878 {
1881 };
1882 
1883 static struct hppa_frame_cache *
1884 hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
1885 {
1886  struct gdbarch *gdbarch = get_frame_arch (this_frame);
1887  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1888  int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1889  struct hppa_frame_cache *cache;
1890  long saved_gr_mask;
1891  long saved_fr_mask;
1892  long frame_size;
1893  struct unwind_table_entry *u;
1894  CORE_ADDR prologue_end;
1895  int fp_in_r1 = 0;
1896  int i;
1897 
1898  if (hppa_debug)
1899  fprintf_unfiltered (gdb_stdlog, "{ hppa_frame_cache (frame=%d) -> ",
1900  frame_relative_level(this_frame));
1901 
1902  if ((*this_cache) != NULL)
1903  {
1904  if (hppa_debug)
1905  fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
1906  paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
1907  return (*this_cache);
1908  }
1909  cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
1910  (*this_cache) = cache;
1911  cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1912 
1913  /* Yow! */
1914  u = hppa_find_unwind_entry_in_block (this_frame);
1915  if (!u)
1916  {
1917  if (hppa_debug)
1918  fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
1919  return (*this_cache);
1920  }
1921 
1922  /* Turn the Entry_GR field into a bitmask. */
1923  saved_gr_mask = 0;
1924  for (i = 3; i < u->Entry_GR + 3; i++)
1925  {
1926  /* Frame pointer gets saved into a special location. */
1927  if (u->Save_SP && i == HPPA_FP_REGNUM)
1928  continue;
1929 
1930  saved_gr_mask |= (1 << i);
1931  }
1932 
1933  /* Turn the Entry_FR field into a bitmask too. */
1934  saved_fr_mask = 0;
1935  for (i = 12; i < u->Entry_FR + 12; i++)
1936  saved_fr_mask |= (1 << i);
1937 
1938  /* Loop until we find everything of interest or hit a branch.
1939 
1940  For unoptimized GCC code and for any HP CC code this will never ever
1941  examine any user instructions.
1942 
1943  For optimized GCC code we're faced with problems. GCC will schedule
1944  its prologue and make prologue instructions available for delay slot
1945  filling. The end result is user code gets mixed in with the prologue
1946  and a prologue instruction may be in the delay slot of the first branch
1947  or call.
1948 
1949  Some unexpected things are expected with debugging optimized code, so
1950  we allow this routine to walk past user instructions in optimized
1951  GCC code. */
1952  {
1953  int final_iteration = 0;
1954  CORE_ADDR pc, start_pc, end_pc;
1955  int looking_for_sp = u->Save_SP;
1956  int looking_for_rp = u->Save_RP;
1957  int fp_loc = -1;
1958 
1959  /* We have to use skip_prologue_hard_way instead of just
1960  skip_prologue_using_sal, in case we stepped into a function without
1961  symbol information. hppa_skip_prologue also bounds the returned
1962  pc by the passed in pc, so it will not return a pc in the next
1963  function.
1964 
1965  We used to call hppa_skip_prologue to find the end of the prologue,
1966  but if some non-prologue instructions get scheduled into the prologue,
1967  and the program is compiled with debug information, the "easy" way
1968  in hppa_skip_prologue will return a prologue end that is too early
1969  for us to notice any potential frame adjustments. */
1970 
1971  /* We used to use get_frame_func to locate the beginning of the
1972  function to pass to skip_prologue. However, when objects are
1973  compiled without debug symbols, get_frame_func can return the wrong
1974  function (or 0). We can do better than that by using unwind records.
1975  This only works if the Region_description of the unwind record
1976  indicates that it includes the entry point of the function.
1977  HP compilers sometimes generate unwind records for regions that
1978  do not include the entry or exit point of a function. GNU tools
1979  do not do this. */
1980 
1981  if ((u->Region_description & 0x2) == 0)
1982  start_pc = u->region_start;
1983  else
1984  start_pc = get_frame_func (this_frame);
1985 
1986  prologue_end = skip_prologue_hard_way (gdbarch, start_pc, 0);
1987  end_pc = get_frame_pc (this_frame);
1988 
1989  if (prologue_end != 0 && end_pc > prologue_end)
1990  end_pc = prologue_end;
1991 
1992  frame_size = 0;
1993 
1994  for (pc = start_pc;
1995  ((saved_gr_mask || saved_fr_mask
1996  || looking_for_sp || looking_for_rp
1997  || frame_size < (u->Total_frame_size << 3))
1998  && pc < end_pc);
1999  pc += 4)
2000  {
2001  int reg;
2002  gdb_byte buf4[4];
2003  long inst;
2004 
2005  if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4))
2006  {
2007  error (_("Cannot read instruction at %s."),
2008  paddress (gdbarch, pc));
2009  return (*this_cache);
2010  }
2011 
2012  inst = extract_unsigned_integer (buf4, sizeof buf4, byte_order);
2013 
2014  /* Note the interesting effects of this instruction. */
2015  frame_size += prologue_inst_adjust_sp (inst);
2016 
2017  /* There are limited ways to store the return pointer into the
2018  stack. */
2019  if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2020  {
2021  looking_for_rp = 0;
2022  cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2023  }
2024  else if (inst == 0x6bc23fd1) /* stw rp,-0x18(sr0,sp) */
2025  {
2026  looking_for_rp = 0;
2027  cache->saved_regs[HPPA_RP_REGNUM].addr = -24;
2028  }
2029  else if (inst == 0x0fc212c1
2030  || inst == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2031  {
2032  looking_for_rp = 0;
2033  cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2034  }
2035 
2036  /* Check to see if we saved SP into the stack. This also
2037  happens to indicate the location of the saved frame
2038  pointer. */
2039  if ((inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
2040  || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
2041  {
2042  looking_for_sp = 0;
2043  cache->saved_regs[HPPA_FP_REGNUM].addr = 0;
2044  }
2045  else if (inst == 0x08030241) /* copy %r3, %r1 */
2046  {
2047  fp_in_r1 = 1;
2048  }
2049 
2050  /* Account for general and floating-point register saves. */
2051  reg = inst_saves_gr (inst);
2052  if (reg >= 3 && reg <= 18
2053  && (!u->Save_SP || reg != HPPA_FP_REGNUM))
2054  {
2055  saved_gr_mask &= ~(1 << reg);
2056  if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0)
2057  /* stwm with a positive displacement is a _post_
2058  _modify_. */
2059  cache->saved_regs[reg].addr = 0;
2060  else if ((inst & 0xfc00000c) == 0x70000008)
2061  /* A std has explicit post_modify forms. */
2062  cache->saved_regs[reg].addr = 0;
2063  else
2064  {
2065  CORE_ADDR offset;
2066 
2067  if ((inst >> 26) == 0x1c)
2068  offset = (inst & 0x1 ? -1 << 13 : 0)
2069  | (((inst >> 4) & 0x3ff) << 3);
2070  else if ((inst >> 26) == 0x03)
2071  offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5);
2072  else
2073  offset = hppa_extract_14 (inst);
2074 
2075  /* Handle code with and without frame pointers. */
2076  if (u->Save_SP)
2077  cache->saved_regs[reg].addr = offset;
2078  else
2079  cache->saved_regs[reg].addr
2080  = (u->Total_frame_size << 3) + offset;
2081  }
2082  }
2083 
2084  /* GCC handles callee saved FP regs a little differently.
2085 
2086  It emits an instruction to put the value of the start of
2087  the FP store area into %r1. It then uses fstds,ma with a
2088  basereg of %r1 for the stores.
2089 
2090  HP CC emits them at the current stack pointer modifying the
2091  stack pointer as it stores each register. */
2092 
2093  /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
2094  if ((inst & 0xffffc000) == 0x34610000
2095  || (inst & 0xffffc000) == 0x37c10000)
2096  fp_loc = hppa_extract_14 (inst);
2097 
2098  reg = inst_saves_fr (inst);
2099  if (reg >= 12 && reg <= 21)
2100  {
2101  /* Note +4 braindamage below is necessary because the FP
2102  status registers are internally 8 registers rather than
2103  the expected 4 registers. */
2104  saved_fr_mask &= ~(1 << reg);
2105  if (fp_loc == -1)
2106  {
2107  /* 1st HP CC FP register store. After this
2108  instruction we've set enough state that the GCC and
2109  HPCC code are both handled in the same manner. */
2110  cache->saved_regs[reg + HPPA_FP4_REGNUM + 4].addr = 0;
2111  fp_loc = 8;
2112  }
2113  else
2114  {
2115  cache->saved_regs[reg + HPPA_FP0_REGNUM + 4].addr = fp_loc;
2116  fp_loc += 8;
2117  }
2118  }
2119 
2120  /* Quit if we hit any kind of branch the previous iteration. */
2121  if (final_iteration)
2122  break;
2123  /* We want to look precisely one instruction beyond the branch
2124  if we have not found everything yet. */
2125  if (is_branch (inst))
2126  final_iteration = 1;
2127  }
2128  }
2129 
2130  {
2131  /* The frame base always represents the value of %sp at entry to
2132  the current function (and is thus equivalent to the "saved"
2133  stack pointer. */
2134  CORE_ADDR this_sp = get_frame_register_unsigned (this_frame,
2135  HPPA_SP_REGNUM);
2136  CORE_ADDR fp;
2137 
2138  if (hppa_debug)
2139  fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
2140  "prologue_end=%s) ",
2141  paddress (gdbarch, this_sp),
2142  paddress (gdbarch, get_frame_pc (this_frame)),
2143  paddress (gdbarch, prologue_end));
2144 
2145  /* Check to see if a frame pointer is available, and use it for
2146  frame unwinding if it is.
2147 
2148  There are some situations where we need to rely on the frame
2149  pointer to do stack unwinding. For example, if a function calls
2150  alloca (), the stack pointer can get adjusted inside the body of
2151  the function. In this case, the ABI requires that the compiler
2152  maintain a frame pointer for the function.
2153 
2154  The unwind record has a flag (alloca_frame) that indicates that
2155  a function has a variable frame; unfortunately, gcc/binutils
2156  does not set this flag. Instead, whenever a frame pointer is used
2157  and saved on the stack, the Save_SP flag is set. We use this to
2158  decide whether to use the frame pointer for unwinding.
2159 
2160  TODO: For the HP compiler, maybe we should use the alloca_frame flag
2161  instead of Save_SP. */
2162 
2163  fp = get_frame_register_unsigned (this_frame, HPPA_FP_REGNUM);
2164 
2165  if (u->alloca_frame)
2166  fp -= u->Total_frame_size << 3;
2167 
2168  if (get_frame_pc (this_frame) >= prologue_end
2169  && (u->Save_SP || u->alloca_frame) && fp != 0)
2170  {
2171  cache->base = fp;
2172 
2173  if (hppa_debug)
2174  fprintf_unfiltered (gdb_stdlog, " (base=%s) [frame pointer]",
2175  paddress (gdbarch, cache->base));
2176  }
2177  else if (u->Save_SP
2178  && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
2179  {
2180  /* Both we're expecting the SP to be saved and the SP has been
2181  saved. The entry SP value is saved at this frame's SP
2182  address. */
2183  cache->base = read_memory_integer (this_sp, word_size, byte_order);
2184 
2185  if (hppa_debug)
2186  fprintf_unfiltered (gdb_stdlog, " (base=%s) [saved]",
2187  paddress (gdbarch, cache->base));
2188  }
2189  else
2190  {
2191  /* The prologue has been slowly allocating stack space. Adjust
2192  the SP back. */
2193  cache->base = this_sp - frame_size;
2194  if (hppa_debug)
2195  fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
2196  paddress (gdbarch, cache->base));
2197 
2198  }
2199  trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
2200  }
2201 
2202  /* The PC is found in the "return register", "Millicode" uses "r31"
2203  as the return register while normal code uses "rp". */
2204  if (u->Millicode)
2205  {
2206  if (trad_frame_addr_p (cache->saved_regs, 31))
2207  {
2208  cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] = cache->saved_regs[31];
2209  if (hppa_debug)
2210  fprintf_unfiltered (gdb_stdlog, " (pc=r31) [stack] } ");
2211  }
2212  else
2213  {
2214  ULONGEST r31 = get_frame_register_unsigned (this_frame, 31);
2215  trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, r31);
2216  if (hppa_debug)
2217  fprintf_unfiltered (gdb_stdlog, " (pc=r31) [frame] } ");
2218  }
2219  }
2220  else
2221  {
2222  if (trad_frame_addr_p (cache->saved_regs, HPPA_RP_REGNUM))
2223  {
2224  cache->saved_regs[HPPA_PCOQ_HEAD_REGNUM] =
2225  cache->saved_regs[HPPA_RP_REGNUM];
2226  if (hppa_debug)
2227  fprintf_unfiltered (gdb_stdlog, " (pc=rp) [stack] } ");
2228  }
2229  else
2230  {
2231  ULONGEST rp = get_frame_register_unsigned (this_frame,
2232  HPPA_RP_REGNUM);
2233  trad_frame_set_value (cache->saved_regs, HPPA_PCOQ_HEAD_REGNUM, rp);
2234  if (hppa_debug)
2235  fprintf_unfiltered (gdb_stdlog, " (pc=rp) [frame] } ");
2236  }
2237  }
2238 
2239  /* If Save_SP is set, then we expect the frame pointer to be saved in the
2240  frame. However, there is a one-insn window where we haven't saved it
2241  yet, but we've already clobbered it. Detect this case and fix it up.
2242 
2243  The prologue sequence for frame-pointer functions is:
2244  0: stw %rp, -20(%sp)
2245  4: copy %r3, %r1
2246  8: copy %sp, %r3
2247  c: stw,ma %r1, XX(%sp)
2248 
2249  So if we are at offset c, the r3 value that we want is not yet saved
2250  on the stack, but it's been overwritten. The prologue analyzer will
2251  set fp_in_r1 when it sees the copy insn so we know to get the value
2252  from r1 instead. */
2253  if (u->Save_SP && !trad_frame_addr_p (cache->saved_regs, HPPA_FP_REGNUM)
2254  && fp_in_r1)
2255  {
2256  ULONGEST r1 = get_frame_register_unsigned (this_frame, 1);
2257  trad_frame_set_value (cache->saved_regs, HPPA_FP_REGNUM, r1);
2258  }
2259 
2260  {
2261  /* Convert all the offsets into addresses. */
2262  int reg;
2263  for (reg = 0; reg < gdbarch_num_regs (gdbarch); reg++)
2264  {
2265  if (trad_frame_addr_p (cache->saved_regs, reg))
2266  cache->saved_regs[reg].addr += cache->base;
2267  }
2268  }
2269 
2270  {
2271  struct gdbarch_tdep *tdep;
2272 
2273  tdep = gdbarch_tdep (gdbarch);
2274 
2275  if (tdep->unwind_adjust_stub)
2276  tdep->unwind_adjust_stub (this_frame, cache->base, cache->saved_regs);
2277  }
2278 
2279  if (hppa_debug)
2280  fprintf_unfiltered (gdb_stdlog, "base=%s }",
2281  paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
2282  return (*this_cache);
2283 }
2284 
2285 static void
2286 hppa_frame_this_id (struct frame_info *this_frame, void **this_cache,
2287  struct frame_id *this_id)
2288 {
2289  struct hppa_frame_cache *info;
2290  CORE_ADDR pc = get_frame_pc (this_frame);
2291  struct unwind_table_entry *u;
2292 
2293  info = hppa_frame_cache (this_frame, this_cache);
2294  u = hppa_find_unwind_entry_in_block (this_frame);
2295 
2296  (*this_id) = frame_id_build (info->base, u->region_start);
2297 }
2298 
2299 static struct value *
2301  void **this_cache, int regnum)
2302 {
2303  struct hppa_frame_cache *info = hppa_frame_cache (this_frame, this_cache);
2304 
2305  return hppa_frame_prev_register_helper (this_frame,
2306  info->saved_regs, regnum);
2307 }
2308 
2309 static int
2311  struct frame_info *this_frame, void **this_cache)
2312 {
2313  if (hppa_find_unwind_entry_in_block (this_frame))
2314  return 1;
2315 
2316  return 0;
2317 }
2318 
2319 static const struct frame_unwind hppa_frame_unwind =
2320 {
2321  NORMAL_FRAME,
2325  NULL,
2327 };
2328 
2329 /* This is a generic fallback frame unwinder that kicks in if we fail all
2330  the other ones. Normally we would expect the stub and regular unwinder
2331  to work, but in some cases we might hit a function that just doesn't
2332  have any unwind information available. In this case we try to do
2333  unwinding solely based on code reading. This is obviously going to be
2334  slow, so only use this as a last resort. Currently this will only
2335  identify the stack and pc for the frame. */
2336 
2337 static struct hppa_frame_cache *
2338 hppa_fallback_frame_cache (struct frame_info *this_frame, void **this_cache)
2339 {
2340  struct gdbarch *gdbarch = get_frame_arch (this_frame);
2341  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2342  struct hppa_frame_cache *cache;
2343  unsigned int frame_size = 0;
2344  int found_rp = 0;
2345  CORE_ADDR start_pc;
2346 
2347  if (hppa_debug)
2349  "{ hppa_fallback_frame_cache (frame=%d) -> ",
2350  frame_relative_level (this_frame));
2351 
2352  cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
2353  (*this_cache) = cache;
2354  cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2355 
2356  start_pc = get_frame_func (this_frame);
2357  if (start_pc)
2358  {
2359  CORE_ADDR cur_pc = get_frame_pc (this_frame);
2360  CORE_ADDR pc;
2361 
2362  for (pc = start_pc; pc < cur_pc; pc += 4)
2363  {
2364  unsigned int insn;
2365 
2366  insn = read_memory_unsigned_integer (pc, 4, byte_order);
2367  frame_size += prologue_inst_adjust_sp (insn);
2368 
2369  /* There are limited ways to store the return pointer into the
2370  stack. */
2371  if (insn == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
2372  {
2373  cache->saved_regs[HPPA_RP_REGNUM].addr = -20;
2374  found_rp = 1;
2375  }
2376  else if (insn == 0x0fc212c1
2377  || insn == 0x73c23fe1) /* std rp,-0x10(sr0,sp) */
2378  {
2379  cache->saved_regs[HPPA_RP_REGNUM].addr = -16;
2380  found_rp = 1;
2381  }
2382  }
2383  }
2384 
2385  if (hppa_debug)
2386  fprintf_unfiltered (gdb_stdlog, " frame_size=%d, found_rp=%d }\n",
2387  frame_size, found_rp);
2388 
2389  cache->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2390  cache->base -= frame_size;
2392 
2394  {
2395  cache->saved_regs[HPPA_RP_REGNUM].addr += cache->base;
2397  cache->saved_regs[HPPA_RP_REGNUM];
2398  }
2399  else
2400  {
2401  ULONGEST rp;
2402  rp = get_frame_register_unsigned (this_frame, HPPA_RP_REGNUM);
2404  }
2405 
2406  return cache;
2407 }
2408 
2409 static void
2410 hppa_fallback_frame_this_id (struct frame_info *this_frame, void **this_cache,
2411  struct frame_id *this_id)
2412 {
2413  struct hppa_frame_cache *info =
2414  hppa_fallback_frame_cache (this_frame, this_cache);
2415 
2416  (*this_id) = frame_id_build (info->base, get_frame_func (this_frame));
2417 }
2418 
2419 static struct value *
2421  void **this_cache, int regnum)
2422 {
2423  struct hppa_frame_cache *info
2424  = hppa_fallback_frame_cache (this_frame, this_cache);
2425 
2426  return hppa_frame_prev_register_helper (this_frame,
2427  info->saved_regs, regnum);
2428 }
2429 
2430 static const struct frame_unwind hppa_fallback_frame_unwind =
2431 {
2432  NORMAL_FRAME,
2436  NULL,
2438 };
2439 
2440 /* Stub frames, used for all kinds of call stubs. */
2442 {
2445 };
2446 
2447 static struct hppa_stub_unwind_cache *
2449  void **this_cache)
2450 {
2451  struct gdbarch *gdbarch = get_frame_arch (this_frame);
2452  struct hppa_stub_unwind_cache *info;
2453  struct unwind_table_entry *u;
2454 
2455  if (*this_cache)
2456  return *this_cache;
2457 
2459  *this_cache = info;
2460  info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2461 
2462  info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
2463 
2464  if (gdbarch_osabi (gdbarch) == GDB_OSABI_HPUX_SOM)
2465  {
2466  /* HPUX uses export stubs in function calls; the export stub clobbers
2467  the return value of the caller, and, later restores it from the
2468  stack. */
2469  u = find_unwind_entry (get_frame_pc (this_frame));
2470 
2471  if (u && u->stub_unwind.stub_type == EXPORT)
2472  {
2473  info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = info->base - 24;
2474 
2475  return info;
2476  }
2477  }
2478 
2479  /* By default we assume that stubs do not change the rp. */
2481 
2482  return info;
2483 }
2484 
2485 static void
2487  void **this_prologue_cache,
2488  struct frame_id *this_id)
2489 {
2490  struct hppa_stub_unwind_cache *info
2491  = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2492 
2493  if (info)
2494  *this_id = frame_id_build (info->base, get_frame_func (this_frame));
2495 }
2496 
2497 static struct value *
2499  void **this_prologue_cache, int regnum)
2500 {
2501  struct hppa_stub_unwind_cache *info
2502  = hppa_stub_frame_unwind_cache (this_frame, this_prologue_cache);
2503 
2504  if (info == NULL)
2505  error (_("Requesting registers from null frame."));
2506 
2507  return hppa_frame_prev_register_helper (this_frame,
2508  info->saved_regs, regnum);
2509 }
2510 
2511 static int
2513  struct frame_info *this_frame,
2514  void **this_cache)
2515 {
2516  CORE_ADDR pc = get_frame_address_in_block (this_frame);
2517  struct gdbarch *gdbarch = get_frame_arch (this_frame);
2518  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2519 
2520  if (pc == 0
2521  || (tdep->in_solib_call_trampoline != NULL
2522  && tdep->in_solib_call_trampoline (gdbarch, pc))
2523  || gdbarch_in_solib_return_trampoline (gdbarch, pc, NULL))
2524  return 1;
2525  return 0;
2526 }
2527 
2528 static const struct frame_unwind hppa_stub_frame_unwind = {
2529  NORMAL_FRAME,
2533  NULL,
2535 };
2536 
2537 static struct frame_id
2538 hppa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
2539 {
2540  return frame_id_build (get_frame_register_unsigned (this_frame,
2541  HPPA_SP_REGNUM),
2542  get_frame_pc (this_frame));
2543 }
2544 
2545 CORE_ADDR
2546 hppa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
2547 {
2548  ULONGEST ipsw;
2549  CORE_ADDR pc;
2550 
2551  ipsw = frame_unwind_register_unsigned (next_frame, HPPA_IPSW_REGNUM);
2553 
2554  /* If the current instruction is nullified, then we are effectively
2555  still executing the previous instruction. Pretend we are still
2556  there. This is needed when single stepping; if the nullified
2557  instruction is on a different line, we don't want GDB to think
2558  we've stepped onto that line. */
2559  if (ipsw & 0x00200000)
2560  pc -= 4;
2561 
2562  return pc & ~0x3;
2563 }
2564 
2565 /* Return the minimal symbol whose name is NAME and stub type is STUB_TYPE.
2566  Return NULL if no such symbol was found. */
2567 
2568 struct bound_minimal_symbol
2570  enum unwind_stub_types stub_type)
2571 {
2572  struct objfile *objfile;
2573  struct minimal_symbol *msym;
2574  struct bound_minimal_symbol result = { NULL, NULL };
2575 
2576  ALL_MSYMBOLS (objfile, msym)
2577  {
2578  if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
2579  {
2580  struct unwind_table_entry *u;
2581 
2582  u = find_unwind_entry (MSYMBOL_VALUE (msym));
2583  if (u != NULL && u->stub_unwind.stub_type == stub_type)
2584  {
2585  result.objfile = objfile;
2586  result.minsym = msym;
2587  return result;
2588  }
2589  }
2590  }
2591 
2592  return result;
2593 }
2594 
2595 static void
2596 unwind_command (char *exp, int from_tty)
2597 {
2598  CORE_ADDR address;
2599  struct unwind_table_entry *u;
2600 
2601  /* If we have an expression, evaluate it and use it as the address. */
2602 
2603  if (exp != 0 && *exp != 0)
2604  address = parse_and_eval_address (exp);
2605  else
2606  return;
2607 
2608  u = find_unwind_entry (address);
2609 
2610  if (!u)
2611  {
2612  printf_unfiltered ("Can't find unwind table entry for %s\n", exp);
2613  return;
2614  }
2615 
2616  printf_unfiltered ("unwind_table_entry (%s):\n", host_address_to_string (u));
2617 
2618  printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
2620 
2621  printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
2623 
2624 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
2625 
2626  printf_unfiltered ("\n\tflags =");
2627  pif (Cannot_unwind);
2628  pif (Millicode);
2630  pif (Entry_SR);
2631  pif (Args_stored);
2632  pif (Variable_Frame);
2637  pif (sr4export);
2638  pif (cxx_info);
2639  pif (cxx_try_catch);
2640  pif (sched_entry_seq);
2641  pif (Save_SP);
2642  pif (Save_RP);
2644  pif (save_r19);
2645  pif (Cleanup_defined);
2648  pif (Large_frame);
2649  pif (alloca_frame);
2650 
2651  putchar_unfiltered ('\n');
2652 
2653 #define pin(FLD) printf_unfiltered ("\t"#FLD" = 0x%x\n", u->FLD);
2654 
2656  pin (Entry_FR);
2657  pin (Entry_GR);
2659 
2660  if (u->stub_unwind.stub_type)
2661  {
2662  printf_unfiltered ("\tstub type = ");
2663  switch (u->stub_unwind.stub_type)
2664  {
2665  case LONG_BRANCH:
2666  printf_unfiltered ("long branch\n");
2667  break;
2668  case PARAMETER_RELOCATION:
2669  printf_unfiltered ("parameter relocation\n");
2670  break;
2671  case EXPORT:
2672  printf_unfiltered ("export\n");
2673  break;
2674  case IMPORT:
2675  printf_unfiltered ("import\n");
2676  break;
2677  case IMPORT_SHLIB:
2678  printf_unfiltered ("import shlib\n");
2679  break;
2680  default:
2681  printf_unfiltered ("unknown (%d)\n", u->stub_unwind.stub_type);
2682  }
2683  }
2684 }
2685 
2686 /* Return the GDB type object for the "standard" data type of data in
2687  register REGNUM. */
2688 
2689 static struct type *
2690 hppa32_register_type (struct gdbarch *gdbarch, int regnum)
2691 {
2692  if (regnum < HPPA_FP4_REGNUM)
2693  return builtin_type (gdbarch)->builtin_uint32;
2694  else
2695  return builtin_type (gdbarch)->builtin_float;
2696 }
2697 
2698 static struct type *
2699 hppa64_register_type (struct gdbarch *gdbarch, int regnum)
2700 {
2701  if (regnum < HPPA64_FP4_REGNUM)
2702  return builtin_type (gdbarch)->builtin_uint64;
2703  else
2704  return builtin_type (gdbarch)->builtin_double;
2705 }
2706 
2707 /* Return non-zero if REGNUM is not a register available to the user
2708  through ptrace/ttrace. */
2709 
2710 static int
2711 hppa32_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2712 {
2713  return (regnum == 0
2714  || regnum == HPPA_PCSQ_HEAD_REGNUM
2715  || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2716  || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA_FP4_REGNUM));
2717 }
2718 
2719 static int
2720 hppa32_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2721 {
2722  /* cr26 and cr27 are readable (but not writable) from userspace. */
2723  if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2724  return 0;
2725  else
2726  return hppa32_cannot_store_register (gdbarch, regnum);
2727 }
2728 
2729 static int
2730 hppa64_cannot_store_register (struct gdbarch *gdbarch, int regnum)
2731 {
2732  return (regnum == 0
2733  || regnum == HPPA_PCSQ_HEAD_REGNUM
2734  || (regnum >= HPPA_PCSQ_TAIL_REGNUM && regnum < HPPA_IPSW_REGNUM)
2735  || (regnum > HPPA_IPSW_REGNUM && regnum < HPPA64_FP4_REGNUM));
2736 }
2737 
2738 static int
2739 hppa64_cannot_fetch_register (struct gdbarch *gdbarch, int regnum)
2740 {
2741  /* cr26 and cr27 are readable (but not writable) from userspace. */
2742  if (regnum == HPPA_CR26_REGNUM || regnum == HPPA_CR27_REGNUM)
2743  return 0;
2744  else
2745  return hppa64_cannot_store_register (gdbarch, regnum);
2746 }
2747 
2748 static CORE_ADDR
2749 hppa_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
2750 {
2751  /* The low two bits of the PC on the PA contain the privilege level.
2752  Some genius implementing a (non-GCC) compiler apparently decided
2753  this means that "addresses" in a text section therefore include a
2754  privilege level, and thus symbol tables should contain these bits.
2755  This seems like a bonehead thing to do--anyway, it seems to work
2756  for our purposes to just ignore those bits. */
2757 
2758  return (addr &= ~0x3);
2759 }
2760 
2761 /* Get the ARGIth function argument for the current function. */
2762 
2763 static CORE_ADDR
2764 hppa_fetch_pointer_argument (struct frame_info *frame, int argi,
2765  struct type *type)
2766 {
2767  return get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 26 - argi);
2768 }
2769 
2770 static enum register_status
2771 hppa_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
2772  int regnum, gdb_byte *buf)
2773 {
2774  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2775  ULONGEST tmp;
2776  enum register_status status;
2777 
2778  status = regcache_raw_read_unsigned (regcache, regnum, &tmp);
2779  if (status == REG_VALID)
2780  {
2781  if (regnum == HPPA_PCOQ_HEAD_REGNUM || regnum == HPPA_PCOQ_TAIL_REGNUM)
2782  tmp &= ~0x3;
2783  store_unsigned_integer (buf, sizeof tmp, byte_order, tmp);
2784  }
2785  return status;
2786 }
2787 
2788 static CORE_ADDR
2789 hppa_find_global_pointer (struct gdbarch *gdbarch, struct value *function)
2790 {
2791  return 0;
2792 }
2793 
2794 struct value *
2796  struct trad_frame_saved_reg saved_regs[],
2797  int regnum)
2798 {
2799  struct gdbarch *arch = get_frame_arch (this_frame);
2800  enum bfd_endian byte_order = gdbarch_byte_order (arch);
2801 
2802  if (regnum == HPPA_PCOQ_TAIL_REGNUM)
2803  {
2805  CORE_ADDR pc;
2806  struct value *pcoq_val =
2807  trad_frame_get_prev_register (this_frame, saved_regs,
2809 
2811  size, byte_order);
2812  return frame_unwind_got_constant (this_frame, regnum, pc + 4);
2813  }
2814 
2815  return trad_frame_get_prev_register (this_frame, saved_regs, regnum);
2816 }
2817 
2818 
2819 /* An instruction to match. */
2820 struct insn_pattern
2821 {
2822  unsigned int data; /* See if it matches this.... */
2823  unsigned int mask; /* ... with this mask. */
2824 };
2825 
2826 /* See bfd/elf32-hppa.c */
2827 static struct insn_pattern hppa_long_branch_stub[] = {
2828  /* ldil LR'xxx,%r1 */
2829  { 0x20200000, 0xffe00000 },
2830  /* be,n RR'xxx(%sr4,%r1) */
2831  { 0xe0202002, 0xffe02002 },
2832  { 0, 0 }
2833 };
2834 
2835 static struct insn_pattern hppa_long_branch_pic_stub[] = {
2836  /* b,l .+8, %r1 */
2837  { 0xe8200000, 0xffe00000 },
2838  /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */
2839  { 0x28200000, 0xffe00000 },
2840  /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */
2841  { 0xe0202002, 0xffe02002 },
2842  { 0, 0 }
2843 };
2844 
2845 static struct insn_pattern hppa_import_stub[] = {
2846  /* addil LR'xxx, %dp */
2847  { 0x2b600000, 0xffe00000 },
2848  /* ldw RR'xxx(%r1), %r21 */
2849  { 0x48350000, 0xffffb000 },
2850  /* bv %r0(%r21) */
2851  { 0xeaa0c000, 0xffffffff },
2852  /* ldw RR'xxx+4(%r1), %r19 */
2853  { 0x48330000, 0xffffb000 },
2854  { 0, 0 }
2855 };
2856 
2857 static struct insn_pattern hppa_import_pic_stub[] = {
2858  /* addil LR'xxx,%r19 */
2859  { 0x2a600000, 0xffe00000 },
2860  /* ldw RR'xxx(%r1),%r21 */
2861  { 0x48350000, 0xffffb000 },
2862  /* bv %r0(%r21) */
2863  { 0xeaa0c000, 0xffffffff },
2864  /* ldw RR'xxx+4(%r1),%r19 */
2865  { 0x48330000, 0xffffb000 },
2866  { 0, 0 },
2867 };
2868 
2869 static struct insn_pattern hppa_plt_stub[] = {
2870  /* b,l 1b, %r20 - 1b is 3 insns before here */
2871  { 0xea9f1fdd, 0xffffffff },
2872  /* depi 0,31,2,%r20 */
2873  { 0xd6801c1e, 0xffffffff },
2874  { 0, 0 }
2875 };
2876 
2877 /* Maximum number of instructions on the patterns above. */
2878 #define HPPA_MAX_INSN_PATTERN_LEN 4
2879 
2880 /* Return non-zero if the instructions at PC match the series
2881  described in PATTERN, or zero otherwise. PATTERN is an array of
2882  'struct insn_pattern' objects, terminated by an entry whose mask is
2883  zero.
2884 
2885  When the match is successful, fill INSN[i] with what PATTERN[i]
2886  matched. */
2887 
2888 static int
2889 hppa_match_insns (struct gdbarch *gdbarch, CORE_ADDR pc,
2890  struct insn_pattern *pattern, unsigned int *insn)
2891 {
2892  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2893  CORE_ADDR npc = pc;
2894  int i;
2895 
2896  for (i = 0; pattern[i].mask; i++)
2897  {
2898  gdb_byte buf[HPPA_INSN_SIZE];
2899 
2900  target_read_memory (npc, buf, HPPA_INSN_SIZE);
2901  insn[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
2902  if ((insn[i] & pattern[i].mask) == pattern[i].data)
2903  npc += 4;
2904  else
2905  return 0;
2906  }
2907 
2908  return 1;
2909 }
2910 
2911 /* This relaxed version of the insstruction matcher allows us to match
2912  from somewhere inside the pattern, by looking backwards in the
2913  instruction scheme. */
2914 
2915 static int
2916 hppa_match_insns_relaxed (struct gdbarch *gdbarch, CORE_ADDR pc,
2917  struct insn_pattern *pattern, unsigned int *insn)
2918 {
2919  int offset, len = 0;
2920 
2921  while (pattern[len].mask)
2922  len++;
2923 
2924  for (offset = 0; offset < len; offset++)
2925  if (hppa_match_insns (gdbarch, pc - offset * HPPA_INSN_SIZE,
2926  pattern, insn))
2927  return 1;
2928 
2929  return 0;
2930 }
2931 
2932 static int
2934 {
2935  struct unwind_table_entry *u;
2936 
2937  u = find_unwind_entry (hppa_symbol_address ("$$dyncall"));
2938  if (!u)
2939  return 0;
2940 
2941  return (pc >= u->region_start && pc <= u->region_end);
2942 }
2943 
2944 int
2945 hppa_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
2946 {
2947  unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2948  struct unwind_table_entry *u;
2949 
2950  if (in_plt_section (pc) || hppa_in_dyncall (pc))
2951  return 1;
2952 
2953  /* The GNU toolchain produces linker stubs without unwind
2954  information. Since the pattern matching for linker stubs can be
2955  quite slow, so bail out if we do have an unwind entry. */
2956 
2957  u = find_unwind_entry (pc);
2958  if (u != NULL)
2959  return 0;
2960 
2961  return
2962  (hppa_match_insns_relaxed (gdbarch, pc, hppa_import_stub, insn)
2963  || hppa_match_insns_relaxed (gdbarch, pc, hppa_import_pic_stub, insn)
2964  || hppa_match_insns_relaxed (gdbarch, pc, hppa_long_branch_stub, insn)
2965  || hppa_match_insns_relaxed (gdbarch, pc,
2966  hppa_long_branch_pic_stub, insn));
2967 }
2968 
2969 /* This code skips several kind of "trampolines" used on PA-RISC
2970  systems: $$dyncall, import stubs and PLT stubs. */
2971 
2972 CORE_ADDR
2974 {
2975  struct gdbarch *gdbarch = get_frame_arch (frame);
2976  struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
2977 
2978  unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN];
2979  int dp_rel;
2980 
2981  /* $$dyncall handles both PLABELs and direct addresses. */
2982  if (hppa_in_dyncall (pc))
2983  {
2984  pc = get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 22);
2985 
2986  /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it. */
2987  if (pc & 0x2)
2988  pc = read_memory_typed_address (pc & ~0x3, func_ptr_type);
2989 
2990  return pc;
2991  }
2992 
2993  dp_rel = hppa_match_insns (gdbarch, pc, hppa_import_stub, insn);
2994  if (dp_rel || hppa_match_insns (gdbarch, pc, hppa_import_pic_stub, insn))
2995  {
2996  /* Extract the target address from the addil/ldw sequence. */
2997  pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]);
2998 
2999  if (dp_rel)
3001  else
3002  pc += get_frame_register_unsigned (frame, HPPA_R0_REGNUM + 19);
3003 
3004  /* fallthrough */
3005  }
3006 
3007  if (in_plt_section (pc))
3008  {
3009  pc = read_memory_typed_address (pc, func_ptr_type);
3010 
3011  /* If the PLT slot has not yet been resolved, the target will be
3012  the PLT stub. */
3013  if (in_plt_section (pc))
3014  {
3015  /* Sanity check: are we pointing to the PLT stub? */
3016  if (!hppa_match_insns (gdbarch, pc, hppa_plt_stub, insn))
3017  {
3018  warning (_("Cannot resolve PLT stub at %s."),
3019  paddress (gdbarch, pc));
3020  return 0;
3021  }
3022 
3023  /* This should point to the fixup routine. */
3024  pc = read_memory_typed_address (pc + 8, func_ptr_type);
3025  }
3026  }
3027 
3028  return pc;
3029 }
3030 
3031 
3032 /* Here is a table of C type sizes on hppa with various compiles
3033  and options. I measured this on PA 9000/800 with HP-UX 11.11
3034  and these compilers:
3035 
3036  /usr/ccs/bin/cc HP92453-01 A.11.01.21
3037  /opt/ansic/bin/cc HP92453-01 B.11.11.28706.GP
3038  /opt/aCC/bin/aCC B3910B A.03.45
3039  gcc gcc 3.3.2 native hppa2.0w-hp-hpux11.11
3040 
3041  cc : 1 2 4 4 8 : 4 8 -- : 4 4
3042  ansic +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3043  ansic +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3044  ansic +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3045  acc +DA1.1 : 1 2 4 4 8 : 4 8 16 : 4 4
3046  acc +DA2.0 : 1 2 4 4 8 : 4 8 16 : 4 4
3047  acc +DA2.0W : 1 2 4 8 8 : 4 8 16 : 8 8
3048  gcc : 1 2 4 4 8 : 4 8 16 : 4 4
3049 
3050  Each line is:
3051 
3052  compiler and options
3053  char, short, int, long, long long
3054  float, double, long double
3055  char *, void (*)()
3056 
3057  So all these compilers use either ILP32 or LP64 model.
3058  TODO: gcc has more options so it needs more investigation.
3059 
3060  For floating point types, see:
3061 
3062  http://docs.hp.com/hpux/pdf/B3906-90006.pdf
3063  HP-UX floating-point guide, hpux 11.00
3064 
3065  -- chastain 2003-12-18 */
3066 
3067 static struct gdbarch *
3068 hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3069 {
3070  struct gdbarch_tdep *tdep;
3071  struct gdbarch *gdbarch;
3072 
3073  /* Try to determine the ABI of the object we are loading. */
3074  if (info.abfd != NULL && info.osabi == GDB_OSABI_UNKNOWN)
3075  {
3076  /* If it's a SOM file, assume it's HP/UX SOM. */
3077  if (bfd_get_flavour (info.abfd) == bfd_target_som_flavour)
3078  info.osabi = GDB_OSABI_HPUX_SOM;
3079  }
3080 
3081  /* find a candidate among the list of pre-declared architectures. */
3082  arches = gdbarch_list_lookup_by_info (arches, &info);
3083  if (arches != NULL)
3084  return (arches->gdbarch);
3085 
3086  /* If none found, then allocate and initialize one. */
3087  tdep = XCNEW (struct gdbarch_tdep);
3088  gdbarch = gdbarch_alloc (&info, tdep);
3089 
3090  /* Determine from the bfd_arch_info structure if we are dealing with
3091  a 32 or 64 bits architecture. If the bfd_arch_info is not available,
3092  then default to a 32bit machine. */
3093  if (info.bfd_arch_info != NULL)
3094  tdep->bytes_per_address =
3095  info.bfd_arch_info->bits_per_address / info.bfd_arch_info->bits_per_byte;
3096  else
3097  tdep->bytes_per_address = 4;
3098 
3100 
3101  /* Some parts of the gdbarch vector depend on whether we are running
3102  on a 32 bits or 64 bits target. */
3103  switch (tdep->bytes_per_address)
3104  {
3105  case 4:
3106  set_gdbarch_num_regs (gdbarch, hppa32_num_regs);
3113  break;
3114  case 8:
3115  set_gdbarch_num_regs (gdbarch, hppa64_num_regs);
3123  break;
3124  default:
3125  internal_error (__FILE__, __LINE__, _("Unsupported address size: %d"),
3126  tdep->bytes_per_address);
3127  }
3128 
3131 
3132  /* The following gdbarch vector elements are the same in both ILP32
3133  and LP64, but might show differences some day. */
3134  set_gdbarch_long_long_bit (gdbarch, 64);
3135  set_gdbarch_long_double_bit (gdbarch, 128);
3137 
3138  /* The following gdbarch vector elements do not depend on the address
3139  size, or in any other gdbarch element previously set. */
3147  set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3148  set_gdbarch_read_pc (gdbarch, hppa_read_pc);
3150 
3151  /* Helper for function argument information. */
3153 
3154  set_gdbarch_print_insn (gdbarch, print_insn_hppa);
3155 
3156  /* When a hardware watchpoint triggers, we'll move the inferior past
3157  it by removing all eventpoints; stepping past the instruction
3158  that caused the trigger; reinserting eventpoints; and checking
3159  whether any watched location changed. */
3161 
3162  /* Inferior function call methods. */
3163  switch (tdep->bytes_per_address)
3164  {
3165  case 4:
3170  break;
3171  case 8:
3174  break;
3175  default:
3176  internal_error (__FILE__, __LINE__, _("bad switch"));
3177  }
3178 
3179  /* Struct return methods. */
3180  switch (tdep->bytes_per_address)
3181  {
3182  case 4:
3184  break;
3185  case 8:
3187  break;
3188  default:
3189  internal_error (__FILE__, __LINE__, _("bad switch"));
3190  }
3191 
3194 
3195  /* Frame unwind methods. */
3198 
3199  /* Hook in ABI-specific overrides, if they have been registered. */
3200  gdbarch_init_osabi (info, gdbarch);
3201 
3202  /* Hook in the default unwinders. */
3203  frame_unwind_append_unwinder (gdbarch, &hppa_stub_frame_unwind);
3204  frame_unwind_append_unwinder (gdbarch, &hppa_frame_unwind);
3205  frame_unwind_append_unwinder (gdbarch, &hppa_fallback_frame_unwind);
3206 
3207  return gdbarch;
3208 }
3209 
3210 static void
3211 hppa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3212 {
3213  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3214 
3215  fprintf_unfiltered (file, "bytes_per_address = %d\n",
3216  tdep->bytes_per_address);
3217  fprintf_unfiltered (file, "elf = %s\n", tdep->is_elf ? "yes" : "no");
3218 }
3219 
3220 /* Provide a prototype to silence -Wmissing-prototypes. */
3222 
3223 void
3225 {
3226  struct cmd_list_element *c;
3227 
3229 
3230  hppa_objfile_priv_data = register_objfile_data ();
3231 
3233  _("Print unwind table entry at given address."),
3235 
3236  /* Debug this files internals. */
3237  add_setshow_boolean_cmd ("hppa", class_maintenance, &hppa_debug, _("\
3238 Set whether hppa target specific debugging information should be displayed."),
3239  _("\
3240 Show whether hppa target specific debugging information is displayed."), _("\
3241 This flag controls whether hppa target specific debugging information is\n\
3242 displayed. This information is particularly useful for debugging frame\n\
3243 unwinding problems."),
3244  NULL,
3245  NULL, /* FIXME: i18n: hppa debug flag is %s. */
3247 }
CORE_ADDR(* find_global_pointer)(struct gdbarch *, struct value *)
Definition: hppa-tdep.h:97
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:1909
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
Definition: gdbarch.c:2935
void set_gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch, int have_nonsteppable_watchpoint)
Definition: gdbarch.c:3261
void set_gdbarch_cannot_fetch_register(struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype cannot_fetch_register)
Definition: gdbarch.c:2349
unsigned int padding
Definition: hppa-tdep.h:168
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
static void internalize_unwinds(struct objfile *objfile, struct unwind_table_entry *table, asection *section, unsigned int entries, size_t size, CORE_ADDR text_offset)
Definition: hppa-tdep.c:252
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
unsigned int sr4export
Definition: hppa-tdep.h:143
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2248
int hppa_extract_5_load(unsigned word)
Definition: hppa-tdep.c:130
int putchar_unfiltered(int c)
Definition: utils.c:2151
CORE_ADDR hppa_read_pc(struct regcache *regcache)
Definition: hppa-tdep.c:1312
static int hppa64_cannot_fetch_register(struct gdbarch *gdbarch, int regnum)
Definition: hppa-tdep.c:2739
unsigned int reserved
Definition: hppa-tdep.h:133
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
bfd * obfd
Definition: objfiles.h:313
static int hppa_frame_unwind_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
Definition: hppa-tdep.c:2310
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
unsigned int Entry_SR
Definition: hppa-tdep.h:134
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
static CORE_ADDR hppa_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: hppa-tdep.c:2749
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
Definition: gdbarch.c:2042
unsigned int Save_MRP_in_frame
Definition: hppa-tdep.h:150
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
bfd_vma CORE_ADDR
Definition: common-types.h:41
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: osabi.c:341
#define MASK_21
Definition: hppa-tdep.c:92
static void hppa_dump_tdep(struct gdbarch *gdbarch, struct ui_file *file)
Definition: hppa-tdep.c:3211
static int hppa_stub_unwind_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
Definition: hppa-tdep.c:2512
static int inst_saves_fr(unsigned long inst)
Definition: hppa-tdep.c:1524
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:135
static struct hppa_frame_cache * hppa_fallback_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: hppa-tdep.c:2338
unsigned int Large_frame
Definition: hppa-tdep.h:156
unsigned int Variable_Frame
Definition: hppa-tdep.h:138
int gdbarch_push_dummy_code_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:2240
unsigned int reserved1
Definition: hppa-tdep.h:147
int trad_frame_addr_p(struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:77
unsigned int Two_Instruction_SP_Increment
Definition: hppa-tdep.h:142
unsigned int Cannot_unwind
Definition: hppa-tdep.h:129
if(!(yy_init))
Definition: ada-lex.c:1072
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
CORE_ADDR hppa_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)
Definition: hppa-tdep.c:2973
void warning(const char *fmt,...)
Definition: errors.c:26
initialize_file_ftype _initialize_hppa_tdep
int(* in_solib_call_trampoline)(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: hppa-tdep.h:102
CORE_ADDR end
Definition: symtab.h:1377
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
Definition: trad-frame.c:92
struct type ** const(pascal_builtin_types[])
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype write_pc)
Definition: gdbarch.c:1802
void set_gdbarch_addr_bits_remove(struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype addr_bits_remove)
Definition: gdbarch.c:3002
unsigned int data
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
unsigned int save_r19
Definition: hppa-tdep.h:151
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1182
static const char * hppa32_register_name(struct gdbarch *gdbarch, int i)
Definition: hppa-tdep.c:615
unsigned int Total_frame_size
Definition: hppa-tdep.h:159
struct ui_file * gdb_stdout
Definition: main.c:71
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
CORE_ADDR hppa_symbol_address(const char *sym)
Definition: hppa-tdep.c:193
#define obj_section_endaddr(s)
Definition: objfiles.h:141
return_value_convention
Definition: defs.h:206
static CORE_ADDR after_prologue(CORE_ADDR pc)
Definition: hppa-tdep.c:1797
static CORE_ADDR hppa64_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: hppa-tdep.c:979
#define pin(FLD)
static struct value * hppa_stub_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
Definition: hppa-tdep.c:2498
void regcache_cooked_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:1028
static CORE_ADDR hppa64_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: hppa-tdep.c:1305
const struct floatformat * floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:98
Definition: solist.h:30
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
Definition: objfiles.h:627
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:4985
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
struct so_list * so_info
Definition: hppa-tdep.c:73
struct bound_minimal_symbol hppa_lookup_stub_minimal_symbol(const char *name, enum unwind_stub_types stub_type)
Definition: hppa-tdep.c:2569
#define _(String)
Definition: gdb_locale.h:40
const struct bfd_arch_info * bfd_arch_info
Definition: gdbarch.h:1549
struct trad_frame_saved_reg * saved_regs
Definition: hppa-tdep.c:2444
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
Definition: gdbarch.c:2110
void(* unwind_adjust_stub)(struct frame_info *this_frame, CORE_ADDR base, struct trad_frame_saved_reg *saved_regs)
Definition: hppa-tdep.h:109
static void read_unwind_info(struct objfile *objfile)
Definition: hppa-tdep.c:350
static const struct objfile_data * hppa_objfile_priv_data
Definition: hppa-tdep.c:86
#define bits(obj, st, fn)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
unsigned int stub_type
Definition: hppa-tdep.h:167
unsigned int Save_SP
Definition: hppa-tdep.h:148
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:78
enum gdb_osabi gdbarch_osabi(struct gdbarch *gdbarch)
Definition: gdbarch.c:1438
#define MSYMBOL_VALUE(symbol)
Definition: symtab.h:384
struct value * hppa_frame_prev_register_helper(struct frame_info *this_frame, struct trad_frame_saved_reg saved_regs[], int regnum)
Definition: hppa-tdep.c:2795
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
static struct hppa_frame_cache * hppa_frame_cache(struct frame_info *this_frame, void **this_cache)
Definition: hppa-tdep.c:1884
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
unsigned int cxx_try_catch
Definition: hppa-tdep.h:145
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
Definition: frame-unwind.c:241
static int hppa_in_dyncall(CORE_ADDR pc)
Definition: hppa-tdep.c:2933
static CORE_ADDR hppa_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: hppa-tdep.c:1838
int hppa_in_solib_call_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: hppa-tdep.c:2945
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
Definition: gdbarch.c:4933
#define obj_section_addr(s)
Definition: objfiles.h:135
#define pif(FLD)
struct obstack objfile_obstack
Definition: objfiles.h:328
static struct gdbarch * hppa_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: hppa-tdep.c:3068
CORE_ADDR dummy_call_sequence_addr
Definition: hppa-tdep.c:77
const char *const name
Definition: aarch64-tdep.c:68
static CORE_ADDR skip_prologue_hard_way(struct gdbarch *gdbarch, CORE_ADDR pc, int stop_before_branch)
Definition: hppa-tdep.c:1547
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
int * from
Definition: varobj.h:282
static struct unwind_table_entry * hppa_find_unwind_entry_in_block(struct frame_info *this_frame)
Definition: hppa-tdep.c:1863
static CORE_ADDR hppa_fetch_pointer_argument(struct frame_info *frame, int argi, struct type *type)
Definition: hppa-tdep.c:2764
unsigned int Cleanup_defined
Definition: hppa-tdep.h:152
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2151
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:311
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
static struct value * hppa_fallback_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: hppa-tdep.c:2420
CORE_ADDR region_end
Definition: hppa-tdep.h:127
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
void initialize_file_ftype(void)
Definition: defs.h:281
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
unsigned hppa_extract_5r_store(unsigned word)
Definition: hppa-tdep.c:138
register_status
Definition: regcache.h:50
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype stack_frame_destroyed_p)
Definition: gdbarch.c:3135
static const char * hppa64_register_name(struct gdbarch *gdbarch, int i)
Definition: hppa-tdep.c:658
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
int safe_frame_unwind_memory(struct frame_info *this_frame, CORE_ADDR addr, gdb_byte *buf, int len)
Definition: frame.c:2525
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:1991
int hppa_extract_14(unsigned word)
Definition: hppa-tdep.c:154
bfd * abfd
Definition: gdbarch.h:1557
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2175
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
struct_return
Definition: arm-tdep.h:148
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
Definition: gdbarch.c:2406
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1188
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
static int hppa64_cannot_store_register(struct gdbarch *gdbarch, int regnum)
Definition: hppa-tdep.c:2730
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
static int is_branch(unsigned long inst)
Definition: hppa-tdep.c:1383
unsigned int MPE_XL_interrupt_marker
Definition: hppa-tdep.h:154
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
void set_gdbarch_cannot_store_register(struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype cannot_store_register)
Definition: gdbarch.c:2366
static int hppa_low_hppa_sign_extend(unsigned val, unsigned bits)
Definition: hppa-tdep.c:113
enum gdb_osabi osabi
Definition: gdbarch.h:1563
Definition: gdbtypes.h:749
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
const char * word
Definition: symtab.h:1448
unsigned int mask
static int inst_saves_gr(unsigned long inst)
Definition: hppa-tdep.c:1483
unsigned int Save_RP
Definition: hppa-tdep.h:149
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
Definition: gdbarch.c:2863
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
Definition: gdbarch.c:2672
struct type * builtin_uint32
Definition: gdbtypes.h:1519
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:170
static struct frame_id hppa_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: hppa-tdep.c:2538
#define gdb_assert(expr)
Definition: gdb_assert.h:33
unsigned int alloca_frame
Definition: hppa-tdep.h:157
unsigned int sched_entry_seq
Definition: hppa-tdep.h:146
#define min(a, b)
Definition: defs.h:106
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:690
void set_gdbarch_read_pc(struct gdbarch *gdbarch, gdbarch_read_pc_ftype read_pc)
Definition: gdbarch.c:1778
static struct value * hppa_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
Definition: hppa-tdep.c:2300
static int hppa32_cannot_fetch_register(struct gdbarch *gdbarch, int regnum)
Definition: hppa-tdep.c:2720
static enum return_value_convention hppa64_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: hppa-tdep.c:1188
struct gdbarch * gdbarch
Definition: gdbarch.h:1542
void set_gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype convert_from_func_ptr_addr)
Definition: gdbarch.c:2985
struct trad_frame_saved_reg * saved_regs
Definition: hppa-tdep.c:1880
int regnum
Definition: aarch64-tdep.c:69
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
static struct type * hppa64_register_type(struct gdbarch *gdbarch, int regnum)
Definition: hppa-tdep.c:2699
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
int gdbarch_in_solib_return_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
Definition: gdbarch.c:3108
CORE_ADDR region_start
Definition: hppa-tdep.h:126
struct ui_file * gdb_stdlog
Definition: main.c:73
struct cmd_list_element * maintenanceprintlist
Definition: cli-cmds.c:167
unsigned int Separate_Package_Body
Definition: hppa-tdep.h:139
unsigned int Millicode_save_sr0
Definition: hppa-tdep.h:131
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition: gdbarch.c:1534
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2797
#define STUB_UNWIND_ENTRY_SIZE
Definition: hppa-tdep.c:96
int hppa_extract_17(unsigned word)
Definition: hppa-tdep.c:184
void hppa_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: hppa-tdep.c:1332
static int hppa64_floating_p(const struct type *type)
Definition: hppa-tdep.c:915
unsigned int reserved2
Definition: hppa-tdep.h:158
static CORE_ADDR hppa32_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: hppa-tdep.c:719
Definition: value.c:172
struct hppa_unwind_info * unwind_info
Definition: hppa-tdep.c:72
CORE_ADDR hppa_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: hppa-tdep.c:2546
#define HPPA_MAX_INSN_PATTERN_LEN
Definition: hppa-tdep.c:2878
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
Definition: trad-frame.c:52
bfd_byte gdb_byte
Definition: common-types.h:38
unsigned int HP_UX_interrupt_marker
Definition: hppa-tdep.h:155
struct unwind_table_entry::@86 stub_unwind
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
Definition: gdbarch.c:1843
ULONGEST align_up(ULONGEST v, int n)
Definition: utils.c:2963
#define ALL_MSYMBOLS(objfile, m)
Definition: objfiles.h:623
unsigned int Entry_FR
Definition: hppa-tdep.h:135
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
struct type * builtin_double
Definition: gdbtypes.h:1491
#define max(a, b)
Definition: defs.h:109
static enum return_value_convention hppa32_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: hppa-tdep.c:1148
int frame_relative_level(struct frame_info *fi)
Definition: frame.c:2454
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:96
#define MASK_5
Definition: hppa-tdep.c:89
#define UNWIND_ENTRY_SIZE
Definition: hppa-tdep.c:95
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
static CORE_ADDR hppa64_convert_code_addr_to_fptr(struct gdbarch *gdbarch, CORE_ADDR code)
Definition: hppa-tdep.c:935
static struct hppa_stub_unwind_cache * hppa_stub_frame_unwind_cache(struct frame_info *this_frame, void **this_cache)
Definition: hppa-tdep.c:2448
static int hppa64_integral_or_pointer_p(const struct type *type)
Definition: hppa-tdep.c:889
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct obj_section * sections_end
Definition: objfiles.h:386
static int in_plt_section(CORE_ADDR pc)
Definition: objfiles.h:539
static int prologue_inst_adjust_sp(unsigned long inst)
Definition: hppa-tdep.c:1344
struct minimal_symbol * minsym
Definition: minsyms.h:32
unsigned int Millicode
Definition: hppa-tdep.h:130
int offset
Definition: agent.c:65
int code
Definition: ser-unix.c:684
struct objfile * objfile
Definition: objfiles.h:124
static CORE_ADDR hppa32_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
Definition: hppa-tdep.c:1281
static void hppa_fallback_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: hppa-tdep.c:2410
#define qsort
Definition: ada-exp.c:2747
static struct type * hppa32_register_type(struct gdbarch *gdbarch, int regnum)
Definition: hppa-tdep.c:2690
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
void set_gdbarch_fetch_pointer_argument(struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
Definition: gdbarch.c:3374
CORE_ADDR pc
Definition: symtab.h:1376
int hppa_get_field(unsigned word, int from, int to)
Definition: hppa-tdep.c:122
static int compare_unwind_entries(const void *arg1, const void *arg2)
Definition: hppa-tdep.c:224
static void hppa_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
Definition: hppa-tdep.c:2286
CORE_ADDR(* solib_get_text_base)(struct objfile *objfile)
Definition: hppa-tdep.h:117
static int hppa32_cannot_store_register(struct gdbarch *gdbarch, int regnum)
Definition: hppa-tdep.c:2711
static int hppa_sign_extend(unsigned val, unsigned bits)
Definition: hppa-tdep.c:105
CORE_ADDR base
Definition: hppa-tdep.c:1879
unsigned int Frame_Extension_Millicode
Definition: hppa-tdep.h:140
static int hppa_match_insns_relaxed(struct gdbarch *gdbarch, CORE_ADDR pc, struct insn_pattern *pattern, unsigned int *insn)
Definition: hppa-tdep.c:2916
static const int hppa64_num_regs
Definition: hppa-tdep.c:47
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
int bytes_per_address
Definition: hppa-tdep.h:89
static struct hppa_objfile_private * hppa_init_objfile_priv_data(struct objfile *objfile)
Definition: hppa-tdep.c:205
struct unwind_table_entry * cache
Definition: hppa-tdep.c:66
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1667
struct type * value_type(const struct value *value)
Definition: value.c:1021
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1517
enum register_status regcache_cooked_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
Definition: regcache.c:1017
static const unsigned char * hppa_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
Definition: hppa-tdep.c:605
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2556
static int hppa_debug
Definition: hppa-tdep.c:43
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
static void unwind_command(char *exp, int from_tty)
Definition: hppa-tdep.c:2596
static int hppa_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: hppa-tdep.c:572
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition: gdbarch.c:1683
static int hppa64_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
Definition: hppa-tdep.c:694
static CORE_ADDR hppa32_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: hppa-tdep.c:1295
static void hppa_stub_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition: hppa-tdep.c:2486
int core_addr_greaterthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:144
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int int * to
Definition: varobj.h:282
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition: gdbarch.c:1700
struct objfile * objfile
Definition: minsyms.h:37
unsigned int cxx_info
Definition: hppa-tdep.h:144
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2216
static void record_text_segment_lowaddr(bfd *abfd, asection *section, void *data)
Definition: hppa-tdep.c:238
struct unwind_table_entry * find_unwind_entry(CORE_ADDR pc)
Definition: hppa-tdep.c:485
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
struct section_offsets * section_offsets
Definition: objfiles.h:362
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
struct type * builtin_uint64
Definition: gdbtypes.h:1521
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
Definition: corefile.c:378
static CORE_ADDR hppa_find_global_pointer(struct gdbarch *gdbarch, struct value *function)
Definition: hppa-tdep.c:2789
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2590
unsigned hppa_extract_5R_store(unsigned word)
Definition: hppa-tdep.c:146
static const int hppa32_num_regs
Definition: hppa-tdep.c:46
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
static int hppa_match_insns(struct gdbarch *gdbarch, CORE_ADDR pc, struct insn_pattern *pattern, unsigned int *insn)
Definition: hppa-tdep.c:2889
unsigned int Entry_GR
Definition: hppa-tdep.h:136
enum bfd_endian byte_order
Definition: gdbarch.c:128
struct unwind_table_entry * table
Definition: hppa-tdep.c:65
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
Definition: gdbarch.c:2127
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
#define MASK_14
Definition: hppa-tdep.c:91
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
Definition: gdbarch.c:339
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
Definition: gdbarch.c:2655
Definition: hppa-tdep.h:124
unsigned int Stack_Overflow_Check
Definition: hppa-tdep.h:141
static enum register_status hppa_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: hppa-tdep.c:2771
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
unwind_stub_types
Definition: hppa-tdep.h:180
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:930
#define HPPA_INSN_SIZE
Definition: hppa-tdep.h:82
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
Definition: gdbarch.c:3067
int hppa_extract_21(unsigned word)
Definition: hppa-tdep.c:162
unsigned int Region_description
Definition: hppa-tdep.h:132
struct type * builtin_float
Definition: gdbtypes.h:1490
unsigned int Args_stored
Definition: hppa-tdep.h:137
const ULONGEST const LONGEST len
Definition: target.h:309