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