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)
766 memcpy (param_val, arg->
contents ().data (), param_len);
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);
926 if (strcmp (opd->the_bfd_section->name,
".opd") == 0)
928 for (CORE_ADDR
addr = opd->addr ();
929 addr < opd->endaddr ();
951 int nargs,
struct value **args, CORE_ADDR sp,
953 CORE_ADDR struct_addr)
962 sp = align_up (sp, 16);
964 for (i = 0; i < nargs; i++)
966 struct value *arg = args[i];
969 const bfd_byte *valbuf;
974 offset = align_up (offset, 8);
995 offset = align_up (offset, 16);
1042 offset = align_up (offset, 16);
1051 ULONGEST codeptr, fptr;
1072 offset += std::min (len, 8);
1073 valbuf += std::min (len, 8);
1074 len -= std::min (len, 8);
1086 sp += std::max (align_up (offset, 16), (ULONGEST) 64);
1121 gdb_byte *readbuf,
const gdb_byte *writebuf)
1135 if (readbuf != NULL)
1137 if (writebuf != NULL)
1144 if (readbuf != NULL)
1146 if (writebuf != NULL)
1159 gdb_byte *readbuf,
const gdb_byte *writebuf)
1227 readbuf += std::min (len, 8);
1228 len -= std::min (len, 8);
1239 writebuf += std::min (len, 8);
1240 len -= std::min (len, 8);
1256 CORE_ADDR plabel = addr & ~3;
1268 return align_up (addr, 64);
1277 return align_up (addr, 16);
1294 if (ipsw & 0x00200000)
1316 static int save_high21;
1319 if ((inst & 0xffffc000) == 0x37de0000)
1323 if ((inst & 0xffe00000) == 0x6fc00000)
1327 if ((inst & 0xffe00008) == 0x73c00008)
1328 return (inst & 0x1 ? -(1 << 13) : 0) | (((inst >> 4) & 0x3ff) << 3);
1332 if ((inst & 0xffe00000) == 0x2bc00000)
1338 if ((inst & 0xffff0000) == 0x343e0000)
1342 if ((inst & 0xffffffe0) == 0x2fd01220)
1454 switch ((inst >> 26) & 0x0f)
1457 switch ((inst >> 6) & 0x0f)
1496 if ((inst & 0xfc00dfc0) == 0x2c001200)
1498 if ((inst & 0xfc000002) == 0x70000002)
1501 if ((inst & 0xfc00df80) == 0x24001200)
1503 if ((inst & 0xfc000002) == 0x7c000000)
1517 int stop_before_branch)
1521 CORE_ADDR orig_pc = pc;
1522 unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
1523 unsigned long args_stored,
status, i, restart_gr, restart_fr;
1525 int final_iteration;
1553 for (i = 3; i < u->
Entry_GR + 3; i++)
1559 save_gr |= (1 << i);
1561 save_gr &= ~restart_gr;
1565 for (i = 12; i < u->
Entry_FR + 12; i++)
1566 save_fr |= (1 << i);
1567 save_fr &= ~restart_fr;
1569 final_iteration = 0;
1585 while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0
1588 unsigned int reg_num;
1589 unsigned long old_stack_remaining, old_save_gr, old_save_fr;
1590 unsigned long old_save_rp, old_save_sp, next_inst;
1594 old_save_gr = save_gr;
1595 old_save_fr = save_fr;
1596 old_save_rp = save_rp;
1597 old_save_sp = save_sp;
1598 old_stack_remaining = stack_remaining;
1612 if (inst == 0x6bc23fd9 || inst == 0x0fc212c1 || inst == 0x73c23fe1)
1617 if ((inst & 0xffffc000) == 0x6fc10000
1618 || (inst & 0xffffc00c) == 0x73c10008)
1623 if ((inst & 0xffe00000) == 0x37a00000
1624 || (inst & 0xffffffe0) == 0x081d0240)
1632 save_gr &= ~(1 << reg_num);
1662 save_fr &= ~(1 << reg_num);
1673 if ((inst & 0xfc000000) == 0x34000000
1699 if ((inst & 0xfc000000) != 0x34000000)
1713 if (
is_branch (inst) && stop_before_branch)
1726 && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
1727 && old_save_gr == save_gr && old_save_fr == save_fr
1728 && old_save_rp == save_rp && old_save_sp == save_sp
1729 && old_stack_remaining == stack_remaining)
1737 if (final_iteration)
1740 final_iteration = 1;
1750 if (save_gr || (save_fr && !(restart_fr || restart_gr)))
1753 restart_gr = save_gr;
1754 restart_fr = save_fr;
1769 CORE_ADDR func_addr, func_end;
1790 if (sal.
end < func_end)
1809 CORE_ADDR post_prologue_pc;
1823 if (post_prologue_pc != 0)
1824 return std::max (
pc, post_prologue_pc);
1863 CORE_ADDR prologue_end;
1871 if ((*this_cache) != NULL)
1879 (*this_cache) = cache;
1893 for (i = 3; i < u->
Entry_GR + 3; i++)
1899 saved_gr_mask |= (1 << i);
1904 for (i = 12; i < u->
Entry_FR + 12; i++)
1905 saved_fr_mask |= (1 << i);
1922 int final_iteration = 0;
1923 CORE_ADDR pc, start_pc, end_pc;
1924 int looking_for_sp = u->
Save_SP;
1925 int looking_for_rp = u->
Save_RP;
1958 if (prologue_end != 0 && end_pc > prologue_end)
1959 end_pc = prologue_end;
1964 ((saved_gr_mask || saved_fr_mask
1965 || looking_for_sp || looking_for_rp
1976 error (_(
"Cannot read instruction at %s."),
1988 if (inst == 0x6bc23fd9)
1993 else if (inst == 0x6bc23fd1)
1998 else if (inst == 0x0fc212c1
1999 || inst == 0x73c23fe1)
2008 if ((inst & 0xffffc000) == 0x6fc10000
2009 || (inst & 0xffffc00c) == 0x73c10008)
2014 else if (inst == 0x08030241)
2021 if (reg >= 3 && reg <= 18
2024 saved_gr_mask &= ~(1 << reg);
2029 else if ((inst & 0xfc00000c) == 0x70000008)
2036 if ((inst >> 26) == 0x1c)
2037 offset = (inst & 0x1 ? -(1 << 13) : 0)
2038 | (((inst >> 4) & 0x3ff) << 3);
2039 else if ((inst >> 26) == 0x03)
2063 if ((inst & 0xffffc000) == 0x34610000
2064 || (inst & 0xffffc000) == 0x37c10000)
2068 if (reg >= 12 && reg <= 21)
2073 saved_fr_mask &= ~(1 << reg);
2090 if (final_iteration)
2095 final_iteration = 1;
2109 "prologue_end=%s) ",
2162 cache->
base = this_sp - frame_size;
2266static struct value *
2268 void **this_cache,
int regnum)
2273 info->saved_regs,
regnum);
2288 "hppa unwind table",
2311 unsigned int frame_size = 0;
2317 "{ hppa_fallback_frame_cache (frame=%d) -> ",
2321 (*this_cache) = cache;
2330 for (pc = start_pc; pc < cur_pc; pc += 4)
2339 if (insn == 0x6bc23fd9)
2344 else if (insn == 0x0fc212c1
2345 || insn == 0x73c23fe1)
2355 frame_size, found_rp);
2358 cache->
base -= frame_size;
2388static struct value *
2390 void **this_cache,
int regnum)
2396 info->saved_regs,
regnum);
2440 void **this_prologue_cache,
2450static struct value *
2452 void **this_prologue_cache,
int regnum)
2458 error (_(
"Requesting registers from null frame."));
2461 info->saved_regs,
regnum);
2505 if (ipsw & 0x00200000)
2519 if (exp != 0 && *exp != 0)
2528 gdb_printf (
"Can't find unwind table entry for %s\n", exp);
2532 gdb_printf (
"unwind_table_entry (%s):\n", host_address_to_string (u));
2538#define pif(FLD) if (u->FLD) gdb_printf (" "#FLD);
2567#define pin(FLD) gdb_printf ("\t"#FLD" = 0x%x\n", u->FLD);
2672 return (addr &= ~0x3);
2684static enum register_status
2686 int regnum, gdb_byte *buf)
2690 enum register_status
status;
2720 struct value *pcoq_val =
2743 { 0x20200000, 0xffe00000 },
2745 { 0xe0202002, 0xffe02002 },
2751 { 0xe8200000, 0xffe00000 },
2753 { 0x28200000, 0xffe00000 },
2755 { 0xe0202002, 0xffe02002 },
2761 { 0x2b600000, 0xffe00000 },
2763 { 0x48350000, 0xffffb000 },
2765 { 0xeaa0c000, 0xffffffff },
2767 { 0x48330000, 0xffffb000 },
2773 { 0x2a600000, 0xffe00000 },
2775 { 0x48350000, 0xffffb000 },
2777 { 0xeaa0c000, 0xffffffff },
2779 { 0x48330000, 0xffffb000 },
2785 { 0xea9f1fdd, 0xffffffff },
2787 { 0xd6801c1e, 0xffffffff },
2792#define HPPA_MAX_INSN_PATTERN_LEN 4
2810 for (i = 0; pattern[i].
mask; i++)
2816 if ((insn[i] & pattern[i].
mask) == pattern[i].
data)
2833 int offset, len = 0;
2835 while (pattern[len].
mask)
2838 for (offset = 0; offset < len; offset++)
2932 warning (_(
"Cannot resolve PLT stub at %s."),
2987 return (
arches->gdbarch);
2997 if (
info.bfd_arch_info != NULL)
2999 info.bfd_arch_info->bits_per_address /
info.bfd_arch_info->bits_per_byte;
3029 internal_error (_(
"Unsupported address size: %d"),
3078 internal_error (_(
"bad switch"));
3091 internal_error (_(
"bad switch"));
3117 gdb_printf (file,
"bytes_per_address = %d\n",
3129 _(
"Print unwind table entry at given address."),
3134Set whether hppa target specific debugging information should be displayed."),
3136Show whether hppa target specific debugging information is displayed."), _(
"\
3137This flag controls whether hppa target specific debugging information is\n\
3138displayed. This information is particularly useful for debugging frame\n\
3139unwinding problems."),
#define bits(obj, st, fn)
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
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, gdbarch_tdep_up tdep)
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
function_call_return_method
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
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 hppa_frame_cache * hppa_frame_cache(frame_info_ptr this_frame, void **this_cache)
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)
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
struct bfd_section * the_bfd_section
iterator_range< section_iterator > sections()
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
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
struct unwind_table_entry::@79 stub_unwind
unsigned int Region_description
unsigned int MPE_XL_interrupt_marker
unsigned int Cannot_unwind
unsigned int Cleanup_defined
gdb::array_view< const gdb_byte > contents_all()
gdb::array_view< const gdb_byte > contents()
struct type * type() const
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)
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)