94#define MASK_21 0x1fffff
97#define UNWIND_ENTRY_SIZE 16
98#define STUB_UNWIND_ENTRY_SIZE 8
109 return (
int) (val >> (
bits - 1) ? (-(1 <<
bits)) | val : val);
117 return (
int) ((val & 0x1 ? (-(1 << (
bits - 1))) : 0) | val >> 1);
126 return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1));
150 return (word >> 16 &
MASK_5);
191 (word & 0x1) << 16, 17) << 2;
203 return (CORE_ADDR)-1;
229 if ((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
230 == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
232 bfd_vma
value = section->vma - section->filepos;
233 CORE_ADDR *low_text_segment_address = (CORE_ADDR *)data;
235 if (
value < *low_text_segment_address)
236 *low_text_segment_address =
value;
242 asection *section,
unsigned int entries,
243 size_t size, CORE_ADDR text_offset)
254 char *buf = (
char *) alloca (
size);
255 CORE_ADDR low_text_segment_address;
263 if (tdep->
is_elf && text_offset == 0)
265 low_text_segment_address = -1;
269 &low_text_segment_address);
271 text_offset = low_text_segment_address;
278 bfd_get_section_contents (
objfile->
obfd.get (), section, buf, 0,
size);
282 for (i = 0; i < entries; i++)
291 tmp = bfd_get_32 (
objfile->
obfd, (bfd_byte *) buf);
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;
308 table[i].
cxx_info = (tmp >> 8) & 0x1;
312 table[i].
Save_SP = (tmp >> 4) & 0x1;
313 table[i].
Save_RP = (tmp >> 3) & 0x1;
315 table[i].
save_r19 = (tmp >> 1) & 0x1;
317 tmp = bfd_get_32 (
objfile->
obfd, (bfd_byte *) buf);
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;
368 unwind_sec = unwind_sec->next)
370 if (strcmp (unwind_sec->name,
"$UNWIND_START$") == 0
371 || strcmp (unwind_sec->name,
".PARISC.unwind") == 0)
373 unwind_size = bfd_section_size (unwind_sec);
376 total_entries += unwind_entries;
382 stub_unwind_sec = bfd_get_section_by_name (
objfile->
obfd.get (),
387 stub_unwind_size = bfd_section_size (stub_unwind_sec);
392 stub_unwind_size = 0;
397 total_entries += stub_entries;
403 ui->last = total_entries - 1;
410 unwind_sec = unwind_sec->next)
412 if (strcmp (unwind_sec->name,
"$UNWIND_START$") == 0
413 || strcmp (unwind_sec->name,
".PARISC.unwind") == 0)
415 unwind_size = bfd_section_size (unwind_sec);
419 unwind_entries, unwind_size, text_offset);
420 index += unwind_entries;
425 if (stub_unwind_size > 0)
428 char *buf = (
char *) alloca (stub_unwind_size);
431 bfd_get_section_contents (
objfile->
obfd.get (), stub_unwind_sec, buf,
432 0, stub_unwind_size);
435 for (i = 0; i < stub_entries; i++, index++)
444 ui->table[index].region_start += text_offset;
446 ui->table[index].stub_unwind.stub_type = bfd_get_8 (
objfile->
obfd,
449 ui->table[index].region_end
450 =
ui->table[index].region_start + 4 *
451 (bfd_get_16 (
objfile->
obfd, (bfd_byte *) buf) - 1);
463 if (obj_private == NULL)
477 int first, middle, last;
484 if (pc == (CORE_ADDR) 0)
504 error (_(
"Internal error reading unwind information."));
511 && pc >=
ui->cache->region_start
512 && pc <= ui->cache->region_end)
516 hex_string ((uintptr_t)
ui->cache));
525 while (first <= last)
527 middle = (first + last) / 2;
528 if (pc >=
ui->table[middle].region_start
529 && pc <= ui->table[middle].region_end)
531 ui->cache = &
ui->table[middle];
534 hex_string ((uintptr_t)
ui->cache));
535 return &
ui->table[middle];
538 if (pc < ui->table[middle].region_start)
575 if ((inst & 0xffffc000) == 0x37de0000
580 if (((inst & 0x0fc010e0) == 0x0fc010e0
581 || (inst & 0x0fc010e0) == 0x0fc010e0)
586 if (inst == 0xe840c000 || inst == 0xe840c002)
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"
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"
677 if (reg >= 0 && reg <= 32)
681 if (reg >= 72 && reg < 72 + 28 * 2 && !(reg & 1))
700 int nargs,
struct value **args, CORE_ADDR sp,
702 CORE_ADDR struct_addr)
708 CORE_ADDR struct_end = 0;
710 CORE_ADDR param_end = 0;
721 for (write_pass = 0; write_pass < 2; write_pass++)
723 CORE_ADDR struct_ptr = 0;
727 CORE_ADDR param_ptr = 32;
729 int small_struct = 0;
731 for (i = 0; i < nargs; i++)
733 struct value *arg = args[i];
737 gdb_byte param_val[8];
739 memset (param_val, 0,
sizeof param_val);
750 struct_end - struct_ptr);
752 else if (
type->
code () == TYPE_CODE_INT
759 (param_val, param_len, byte_order,
762 else if (
type->
code () == TYPE_CODE_FLT)
773 memcpy (param_val + param_len -
type->
length (),
780 if (param_len > 4 && param_len < 8)
784 param_ptr += param_len;
785 if (param_len == 8 && !small_struct)
786 param_ptr = align_up (param_ptr, 8);
797 write_memory (param_end - param_ptr, param_val, param_len);
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;
825 struct_end = sp + align_up (struct_ptr, 64);
831 param_end = struct_end + align_up (param_ptr, 64);
871 case TYPE_CODE_RANGE:
874 return (len == 1 || len == 2 || len == 4 || len == 8);
878 case TYPE_CODE_RVALUE_REF:
897 return (len == 4 || len == 8 || len == 16);
952 int nargs,
struct value **args, CORE_ADDR sp,
954 CORE_ADDR struct_addr)
963 sp = align_up (sp, 16);
965 for (i = 0; i < nargs; i++)
967 struct value *arg = args[i];
970 const bfd_byte *valbuf;
975 offset = align_up (offset, 8);
996 offset = align_up (offset, 16);
1043 offset = align_up (offset, 16);
1052 ULONGEST codeptr, fptr;
1073 offset += std::min (len, 8);
1074 valbuf += std::min (len, 8);
1075 len -= std::min (len, 8);
1087 sp += std::max (align_up (offset, 16), (ULONGEST) 64);
1122 gdb_byte *readbuf,
const gdb_byte *writebuf)
1136 if (readbuf != NULL)
1138 if (writebuf != NULL)
1145 if (readbuf != NULL)
1147 if (writebuf != NULL)
1160 gdb_byte *readbuf,
const gdb_byte *writebuf)
1228 readbuf += std::min (len, 8);
1229 len -= std::min (len, 8);
1240 writebuf += std::min (len, 8);
1241 len -= std::min (len, 8);
1257 CORE_ADDR plabel = addr & ~3;
1269 return align_up (addr, 64);
1278 return align_up (addr, 16);
1295 if (ipsw & 0x00200000)
1317 static int save_high21;
1320 if ((inst & 0xffffc000) == 0x37de0000)
1324 if ((inst & 0xffe00000) == 0x6fc00000)
1328 if ((inst & 0xffe00008) == 0x73c00008)
1329 return (inst & 0x1 ? -(1 << 13) : 0) | (((inst >> 4) & 0x3ff) << 3);
1333 if ((inst & 0xffe00000) == 0x2bc00000)
1339 if ((inst & 0xffff0000) == 0x343e0000)
1343 if ((inst & 0xffffffe0) == 0x2fd01220)
1455 switch ((inst >> 26) & 0x0f)
1458 switch ((inst >> 6) & 0x0f)
1497 if ((inst & 0xfc00dfc0) == 0x2c001200)
1499 if ((inst & 0xfc000002) == 0x70000002)
1502 if ((inst & 0xfc00df80) == 0x24001200)
1504 if ((inst & 0xfc000002) == 0x7c000000)
1518 int stop_before_branch)
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;
1526 int final_iteration;
1554 for (i = 3; i < u->
Entry_GR + 3; i++)
1560 save_gr |= (1 << i);
1562 save_gr &= ~restart_gr;
1566 for (i = 12; i < u->
Entry_FR + 12; i++)
1567 save_fr |= (1 << i);
1568 save_fr &= ~restart_fr;
1570 final_iteration = 0;
1586 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
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;
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;
1613 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1618 if ((inst & 0xffffc000) == 0x6fc10000
1619 || (inst & 0xffffc00c) == 0x73c10008)
1624 if ((inst & 0xffe00000) == 0x37a00000
1625 || (inst & 0xffffffe0) == 0x081d0240)
1633 save_gr &= ~(1 << reg_num);
1663 save_fr &= ~(1 << reg_num);
1674 if ((inst & 0xfc000000) == 0x34000000
1700 if ((inst & 0xfc000000) != 0x34000000)
1714 if (
is_branch (inst) && stop_before_branch)
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)
1738 if (final_iteration)
1741 final_iteration = 1;
1751 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1754 restart_gr = save_gr;
1755 restart_fr = save_fr;
1770 CORE_ADDR func_addr, func_end;
1791 if (sal.
end < func_end)
1810 CORE_ADDR post_prologue_pc;
1824 if (post_prologue_pc != 0)
1825 return std::max (
pc, post_prologue_pc);
1864 CORE_ADDR prologue_end;
1872 if ((*this_cache) != NULL)
1880 (*this_cache) = cache;
1894 for (i = 3; i < u->
Entry_GR + 3; i++)
1900 saved_gr_mask |= (1 << i);
1905 for (i = 12; i < u->
Entry_FR + 12; i++)
1906 saved_fr_mask |= (1 << i);
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;
1959 if (prologue_end != 0 && end_pc > prologue_end)
1960 end_pc = prologue_end;
1965 ((saved_gr_mask || saved_fr_mask
1966 || looking_for_sp || looking_for_rp
1977 error (_(
"Cannot read instruction at %s."),
1989 if (inst == 0x6bc23fd9)
1994 else if (inst == 0x6bc23fd1)
1999 else if (inst == 0x0fc212c1
2000 || inst == 0x73c23fe1)
2009 if ((inst & 0xffffc000) == 0x6fc10000
2010 || (inst & 0xffffc00c) == 0x73c10008)
2015 else if (inst == 0x08030241)
2022 if (reg >= 3 && reg <= 18
2025 saved_gr_mask &= ~(1 << reg);
2030 else if ((inst & 0xfc00000c) == 0x70000008)
2037 if ((inst >> 26) == 0x1c)
2038 offset = (inst & 0x1 ? -(1 << 13) : 0)
2039 | (((inst >> 4) & 0x3ff) << 3);
2040 else if ((inst >> 26) == 0x03)
2064 if ((inst & 0xffffc000) == 0x34610000
2065 || (inst & 0xffffc000) == 0x37c10000)
2069 if (reg >= 12 && reg <= 21)
2074 saved_fr_mask &= ~(1 << reg);
2091 if (final_iteration)
2096 final_iteration = 1;
2110 "prologue_end=%s) ",
2163 cache->
base = this_sp - frame_size;
2267static struct value *
2269 void **this_cache,
int regnum)
2274 info->saved_regs,
regnum);
2289 "hppa unwind table",
2312 unsigned int frame_size = 0;
2318 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2322 (*this_cache) = cache;
2331 for (pc = start_pc; pc < cur_pc; pc += 4)
2340 if (insn == 0x6bc23fd9)
2345 else if (insn == 0x0fc212c1
2346 || insn == 0x73c23fe1)
2356 frame_size, found_rp);
2359 cache->
base -= frame_size;
2389static struct value *
2391 void **this_cache,
int regnum)
2397 info->saved_regs,
regnum);
2441 void **this_prologue_cache,
2451static struct value *
2453 void **this_prologue_cache,
int regnum)
2459 error (_(
"Requesting registers from null frame."));
2462 info->saved_regs,
regnum);
2506 if (ipsw & 0x00200000)
2520 if (exp != 0 && *exp != 0)
2529 gdb_printf (
"Can't find unwind table entry for %s\n", exp);
2533 gdb_printf (
"unwind_table_entry (%s):\n", host_address_to_string (u));
2539#define pif(FLD) if (u->FLD) gdb_printf (" "#FLD);
2568#define pin(FLD) gdb_printf ("\t"#FLD" = 0x%x\n", u->FLD);
2673 return (addr &= ~0x3);
2685static enum register_status
2687 int regnum, gdb_byte *buf)
2691 enum register_status
status;
2721 struct value *pcoq_val =
2744 { 0x20200000, 0xffe00000 },
2746 { 0xe0202002, 0xffe02002 },
2752 { 0xe8200000, 0xffe00000 },
2754 { 0x28200000, 0xffe00000 },
2756 { 0xe0202002, 0xffe02002 },
2762 { 0x2b600000, 0xffe00000 },
2764 { 0x48350000, 0xffffb000 },
2766 { 0xeaa0c000, 0xffffffff },
2768 { 0x48330000, 0xffffb000 },
2774 { 0x2a600000, 0xffe00000 },
2776 { 0x48350000, 0xffffb000 },
2778 { 0xeaa0c000, 0xffffffff },
2780 { 0x48330000, 0xffffb000 },
2786 { 0xea9f1fdd, 0xffffffff },
2788 { 0xd6801c1e, 0xffffffff },
2793#define HPPA_MAX_INSN_PATTERN_LEN 4
2811 for (i = 0; pattern[i].
mask; i++)
2817 if ((insn[i] & pattern[i].
mask) == pattern[i].
data)
2834 int offset, len = 0;
2836 while (pattern[len].
mask)
2839 for (offset = 0; offset < len; offset++)
2933 warning (_(
"Cannot resolve PLT stub at %s."),
2990 return (
arches->gdbarch);
2999 if (
info.bfd_arch_info != NULL)
3001 info.bfd_arch_info->bits_per_address /
info.bfd_arch_info->bits_per_byte;
3031 internal_error (_(
"Unsupported address size: %d"),
3080 internal_error (_(
"bad switch"));
3093 internal_error (_(
"bad switch"));
3119 gdb_printf (file,
"bytes_per_address = %d\n",
3131 _(
"Print unwind table entry at given address."),
3136Set whether hppa target specific debugging information should be displayed."),
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."),
#define bits(obj, st, fn)
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
static std::vector< const char * > arches
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)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
enum register_status raw_read(int regnum, gdb_byte *buf)
enum register_status cooked_read_part(int regnum, int offset, int len, gdb_byte *buf)
enum register_status cooked_read(int regnum, gdb_byte *buf)
void cooked_write(int regnum, const gdb_byte *buf)
void cooked_write_part(int regnum, int offset, int len, const gdb_byte *buf)
struct cmd_list_element * maintenanceprintlist
struct cmd_list_element * showdebuglist
struct cmd_list_element * setdebuglist
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
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)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_REGISTER_CONVENTION
@ RETURN_VALUE_STRUCT_CONVENTION
CORE_ADDR parse_and_eval_address(const char *exp)
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)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
ULONGEST frame_unwind_register_unsigned(frame_info_ptr next_frame, int regnum)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
CORE_ADDR get_frame_address_in_block(frame_info_ptr this_frame)
bool safe_frame_unwind_memory(frame_info_ptr this_frame, CORE_ADDR addr, gdb::array_view< gdb_byte > buffer)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
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)
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)
void set_gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch, int have_nonsteppable_watchpoint)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
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)
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
bool gdbarch_push_dummy_code_p(struct gdbarch *gdbarch)
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)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
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)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
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)
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)
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)
function_call_return_method
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
struct type * check_typedef(struct type *type)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
static CORE_ADDR hppa_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
CORE_ADDR hppa_unwind_pc(struct gdbarch *gdbarch, frame_info_ptr next_frame)
static void hppa_fallback_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static struct insn_pattern hppa_import_stub[]
static int hppa_match_insns(struct gdbarch *gdbarch, CORE_ADDR pc, struct insn_pattern *pattern, unsigned int *insn)
static int hppa_stub_unwind_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_cache)
static struct type * hppa32_register_type(struct gdbarch *gdbarch, int regnum)
static struct insn_pattern hppa_long_branch_stub[]
static int hppa32_cannot_store_register(struct gdbarch *gdbarch, int regnum)
static CORE_ADDR after_prologue(CORE_ADDR pc)
static int compare_unwind_entries(const void *arg1, const void *arg2)
static struct value * hppa_fallback_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static CORE_ADDR hppa32_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
static int inst_saves_fr(unsigned long inst)
static int hppa64_integral_or_pointer_p(const struct type *type)
static const registry< objfile >::key< hppa_objfile_private > hppa_objfile_priv_data
static CORE_ADDR hppa64_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
static int hppa_frame_unwind_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_cache)
static void hppa_dump_tdep(struct gdbarch *gdbarch, struct ui_file *file)
CORE_ADDR hppa_skip_trampoline_code(frame_info_ptr frame, CORE_ADDR pc)
int hppa_extract_17(unsigned word)
static struct insn_pattern hppa_plt_stub[]
static int hppa_sign_extend(unsigned val, unsigned bits)
static struct unwind_table_entry * hppa_find_unwind_entry_in_block(frame_info_ptr this_frame)
#define HPPA_MAX_INSN_PATTERN_LEN
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)
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)
struct unwind_table_entry * find_unwind_entry(CORE_ADDR pc)
static void hppa_stub_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static CORE_ADDR hppa32_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
static int hppa64_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static int hppa_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
static int hppa_low_hppa_sign_extend(unsigned val, unsigned bits)
static int is_branch(unsigned long inst)
int hppa_extract_21(unsigned word)
static struct gdbarch * hppa_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
void _initialize_hppa_tdep()
static const int hppa32_num_regs
static void read_unwind_info(struct objfile *objfile)
static CORE_ADDR skip_prologue_hard_way(struct gdbarch *gdbarch, CORE_ADDR pc, int stop_before_branch)
static void hppa_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static const struct frame_unwind hppa_fallback_frame_unwind
static struct insn_pattern hppa_long_branch_pic_stub[]
static const char * hppa64_register_name(struct gdbarch *gdbarch, int i)
static int hppa64_floating_p(const struct type *type)
static struct insn_pattern hppa_import_pic_stub[]
static struct value * hppa_stub_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
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)
int hppa_get_field(unsigned word, int from, int to)
static enum register_status hppa_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf)
static int hppa64_cannot_fetch_register(struct gdbarch *gdbarch, int regnum)
static CORE_ADDR hppa64_convert_code_addr_to_fptr(struct gdbarch *gdbarch, CORE_ADDR code)
static const struct frame_unwind hppa_stub_frame_unwind
static int prologue_inst_adjust_sp(unsigned long inst)
int hppa_extract_14(unsigned word)
static const int hppa64_num_regs
static void internalize_unwinds(struct objfile *objfile, struct unwind_table_entry *table, asection *section, unsigned int entries, size_t size, CORE_ADDR text_offset)
#define STUB_UNWIND_ENTRY_SIZE
#define UNWIND_ENTRY_SIZE
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)
static const struct frame_unwind hppa_frame_unwind
static struct value * hppa_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
unsigned hppa_extract_5r_store(unsigned word)
unsigned hppa_extract_5R_store(unsigned word)
void hppa_write_pc(struct regcache *regcache, CORE_ADDR pc)
CORE_ADDR hppa_symbol_address(const char *sym)
static CORE_ADDR hppa_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static void unwind_command(const char *exp, int from_tty)
static int hppa_match_insns_relaxed(struct gdbarch *gdbarch, CORE_ADDR pc, struct insn_pattern *pattern, unsigned int *insn)
int hppa_in_solib_call_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc)
int hppa_extract_5_load(unsigned word)
static CORE_ADDR hppa_find_global_pointer(struct gdbarch *gdbarch, struct value *function)
static CORE_ADDR hppa_read_pc(readable_regcache *regcache)
static void record_text_segment_lowaddr(bfd *abfd, asection *section, void *data)
static struct hppa_stub_unwind_cache * hppa_stub_frame_unwind_cache(frame_info_ptr this_frame, void **this_cache)
static struct type * hppa64_register_type(struct gdbarch *gdbarch, int regnum)
static int hppa64_cannot_store_register(struct gdbarch *gdbarch, int regnum)
constexpr gdb_byte hppa_break_insn[]
static int hppa_in_dyncall(CORE_ADDR pc)
static int inst_saves_gr(unsigned long inst)
struct value * hppa_frame_prev_register_helper(frame_info_ptr this_frame, trad_frame_saved_reg saved_regs[], int regnum)
static int hppa32_cannot_fetch_register(struct gdbarch *gdbarch, int regnum)
static struct hppa_frame_cache * hppa_fallback_frame_cache(frame_info_ptr this_frame, void **this_cache)
static CORE_ADDR hppa_fetch_pointer_argument(frame_info_ptr frame, int argi, struct type *type)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
struct obj_section * find_pc_section(CORE_ADDR pc)
#define ALL_OBJFILE_OSECTIONS(objfile, osect)
static int in_plt_section(CORE_ADDR pc)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
struct program_space * current_program_space
int register_size(struct gdbarch *gdbarch, int regnum)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct minimal_symbol * minsym
struct type * builtin_double
struct type * builtin_func_ptr
struct type * builtin_uint32
struct type * builtin_uint64
struct type * builtin_float
trad_frame_saved_reg * saved_regs
CORE_ADDR(* find_global_pointer)(struct gdbarch *, struct value *)
CORE_ADDR(* solib_get_text_base)(struct objfile *objfile)
void(* unwind_adjust_stub)(frame_info_ptr this_frame, CORE_ADDR base, trad_frame_saved_reg *saved_regs)
int(* in_solib_call_trampoline)(struct gdbarch *gdbarch, CORE_ADDR pc)
struct hppa_unwind_info * unwind_info
int dummy_call_sequence_reg
CORE_ADDR dummy_call_sequence_addr
trad_frame_saved_reg * saved_regs
struct unwind_table_entry * table
struct unwind_table_entry * cache
CORE_ADDR value_address(objfile *objfile) const
CORE_ADDR endaddr() const
struct bfd_section * the_bfd_section
struct obj_section * sections_end
struct gdbarch * arch() const
CORE_ADDR text_section_offset() const
auto_obstack objfile_obstack
objfiles_range objfiles()
void set_addr(LONGEST addr)
void set_value(LONGEST val)
struct type * target_type() const
unsigned int Frame_Extension_Millicode
unsigned int Millicode_save_sr0
struct unwind_table_entry::@75 stub_unwind
unsigned int Save_MRP_in_frame
unsigned int Total_frame_size
unsigned int cxx_try_catch
unsigned int sched_entry_seq
unsigned int Separate_Package_Body
unsigned int HP_UX_interrupt_marker
unsigned int Stack_Overflow_Check
unsigned int alloca_frame
unsigned int Two_Instruction_SP_Increment
unsigned int Variable_Frame
unsigned int Region_description
unsigned int MPE_XL_interrupt_marker
unsigned int Cannot_unwind
unsigned int Cleanup_defined
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void gdb_printf(struct ui_file *stream, const char *format,...)
struct value * value_cast(struct type *type, struct value *arg2)
struct type * value_type(const struct value *value)
gdb::array_view< const gdb_byte > value_contents_all(struct value *value)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)