38 #include "gdb/sim-ppc.h"
47 #include "coff/internal.h"
49 #include "coff/xcoff.h"
54 #include "elf/ppc64.h"
87 #define IS_SPE_PSEUDOREG(tdep, regnum) ((tdep)->ppc_ev0_regnum >= 0 \
88 && (regnum) >= (tdep)->ppc_ev0_regnum \
89 && (regnum) < (tdep)->ppc_ev0_regnum + 32)
92 #define IS_DFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_dl0_regnum >= 0 \
93 && (regnum) >= (tdep)->ppc_dl0_regnum \
94 && (regnum) < (tdep)->ppc_dl0_regnum + 16)
97 #define IS_VSX_PSEUDOREG(tdep, regnum) ((tdep)->ppc_vsr0_regnum >= 0 \
98 && (regnum) >= (tdep)->ppc_vsr0_regnum \
99 && (regnum) < (tdep)->ppc_vsr0_regnum + ppc_num_vsrs)
102 #define IS_EFP_PSEUDOREG(tdep, regnum) ((tdep)->ppc_efpr0_regnum >= 0 \
103 && (regnum) >= (tdep)->ppc_efpr0_regnum \
104 && (regnum) < (tdep)->ppc_efpr0_regnum + ppc_num_efprs)
268 static const char *
const segment_regs[] = {
269 "sr0",
"sr1",
"sr2",
"sr3",
"sr4",
"sr5",
"sr6",
"sr7",
270 "sr8",
"sr9",
"sr10",
"sr11",
"sr12",
"sr13",
"sr14",
"sr15"
275 for (i = 0; i < total_regs; i++)
287 sim_ppc_f0_regnum + i);
302 set_sim_regno (sim_regno, gdb_regno, sim_ppc_sr0_regnum + i);
311 sim_ppc_vr0_regnum + i);
317 sim_ppc_vscr_regnum);
326 sim_ppc_rh0_regnum + i);
335 for (i = 0; i < sim_ppc_num_sprs; i++)
337 const char *spr_name = sim_spr_register_name (i);
340 if (spr_name != NULL)
344 set_sim_regno (sim_regno, gdb_regno, sim_ppc_spr0_regnum + i);
386 if (regnum != -1 && offset != -1)
392 if (gdb_regsize < regsize
394 offset += regsize - gdb_regsize;
407 if (regnum != -1 && offset != -1)
413 if (gdb_regsize < regsize)
417 memset (regs + offset, 0, regsize - gdb_regsize);
418 offset += regsize - gdb_regsize;
421 memset (regs + offset + regsize - gdb_regsize, 0,
422 regsize - gdb_regsize);
506 int regnum,
const void *gregs,
size_t len)
521 i++, offset += gpr_size)
551 int regnum,
const void *fpregs,
size_t len)
588 int regnum,
const void *vsxregs,
size_t len)
619 int regnum,
const void *vrregs,
size_t len)
680 i++, offset += gpr_size)
827 int opcode = (insn >> 26) & 0x03f;
828 int sd = (insn >> 21) & 0x01f;
829 int a = (insn >> 16) & 0x01f;
830 int subcode = (insn >> 1) & 0x3ff;
838 if (opcode == 31 && subcode == 444 && a == 1)
840 if (opcode == 14 && sd == 1)
842 if (opcode == 58 && sd == 1)
851 if (opcode == 19 && subcode == 16)
853 if (opcode == 19 && subcode == 528)
883 CORE_ADDR scan_pc, func_start, func_end, epilogue_start, epilogue_end;
892 if (epilogue_start < func_start) epilogue_start = func_start;
895 if (epilogue_end > func_end) epilogue_end = func_end;
899 for (scan_pc = pc; scan_pc < epilogue_end; scan_pc +=
PPC_INSN_SIZE)
904 if (insn == 0x4e800020)
908 if (insn == 0x4e800420)
912 if (ctr > func_start && ctr < func_end)
923 for (scan_pc = pc - PPC_INSN_SIZE;
924 scan_pc >= epilogue_start;
956 static const unsigned char *
960 static unsigned char big_breakpoint[] = { 0x7d, 0x82, 0x10, 0x08 };
961 static unsigned char little_breakpoint[] = { 0x08, 0x10, 0x82, 0x7d };
964 return big_breakpoint;
966 return little_breakpoint;
970 #define BRANCH_MASK 0xfc000000
971 #define BP_MASK 0xFC0007FE
972 #define B_INSN 0x48000000
973 #define BC_INSN 0x40000000
974 #define BXL_INSN 0x4c000000
975 #define BP_INSN 0x7C000008
998 "displaced: (ppc) fixup (%s, %s)\n",
1012 offset = current_pc -
to;
1024 "displaced: (ppc) branch instruction: %s\n"
1025 "displaced: (ppc) adjusted PC from %s to %s\n",
1027 paddress (gdbarch, from + offset));
1056 "displaced: (ppc) adjusted LR to %s\n",
1081 #define LWARX_MASK 0xfc0007fe
1082 #define LWARX_INSTRUCTION 0x7c000028
1083 #define LDARX_INSTRUCTION 0x7c0000A8
1084 #define STWCX_MASK 0xfc0007ff
1085 #define STWCX_INSTRUCTION 0x7c00012d
1086 #define STDCX_INSTRUCTION 0x7c0001ad
1106 int last_breakpoint = 0;
1107 const int atomic_sequence_length = 16;
1109 int bc_insn_count = 0;
1118 for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
1128 int immediate = ((insn & 0xfffc) ^ 0x8000) - 0x8000;
1129 int absolute = insn & 2;
1131 if (bc_insn_count >= 1)
1136 breaks[1] = immediate;
1138 breaks[1] = loc + immediate;
1164 && (breaks[1] == breaks[0]
1165 || (breaks[1] >= pc && breaks[1] <= closing_insn)))
1166 last_breakpoint = 0;
1169 for (index = 0; index <= last_breakpoint; index++)
1176 #define SIGNED_SHORT(x) \
1177 ((sizeof (short) == 2) \
1178 ? ((int)(short)(x)) \
1179 : ((int)((((x) & 0xffff) ^ 0x8000) - 0x8000)))
1181 #define GET_SRC_REG(x) (((x) >> 21) & 0x1f)
1196 if ((op & 0xfc0007fe) == 0x7c000378)
1199 const int rx_regno = (op >> 16) & 31;
1203 if (rx_regno == 0 && ry_regno >= 3 && ry_regno <= 10)
1205 *r0_contains_arg = 1;
1214 if ((op & 0xfc1f0003) == 0xf8010000 ||
1215 (op & 0xfc1f0000) == 0xd8010000)
1220 return (rx_regno >= 3 && rx_regno <= 10);
1226 ((op & 0xfc1f0000) == 0x901f0000 ||
1227 (op & 0xfc1f0000) == 0x981f0000 ||
1228 (op & 0xfc1f0000) == 0xd81f0000))
1234 return ((rx_regno >= 3 && rx_regno <= 10)
1235 || (rx_regno == 0 && *r0_contains_arg));
1238 if ((op & 0xfc1f0000) == 0xfc010000)
1243 return (src_regno >= 2 && src_regno <= 8);
1246 if (framep && ((op & 0xfc1f0000) == 0xfc1f0000))
1251 return (src_regno >= 2 && src_regno <= 8);
1273 absolute = (
int) ((insn >> 1) & 1);
1274 immediate = ((insn & ~3) << 6) >> 6;
1278 dest = pc + immediate;
1281 if ((dest_insn & 0xfc00ffff) == 0x4c000021)
1297 #define BL_MASK 0xfc000001
1298 #define BL_INSTRUCTION 0x48000001
1299 #define BL_DISPLACEMENT_MASK 0x03fffffc
1301 static unsigned long
1331 if ((op & 0xffff0000) == 0x90010000)
1333 while ((op & 0xffff0000) == 0x90010000)
1356 if ((op & 0xffff0000) != 0x39810000)
1362 if ((op & 0xffff0000) != 0x3c000000)
1368 if ((op & 0xffff0000) == 0x60000000)
1374 if (op != 0x7c0c0214)
1380 if (op != 0x7c0c0000)
1386 if ((op & 0xff9f0001) != 0x41820000)
1392 if ((op & 0xffff0000) != 0x398c0000)
1398 if (op != 0x900c0000)
1404 if ((op & 0xfc000001) != 0x48000000)
1410 if ((op & 0xffff0000) == 0x900c0000)
1439 if ((op & 0xffff0000) != 0x38010000)
1445 if ((op & 0xffff0000) != 0x3c010000)
1451 if ((op & 0xffff0000) != 0x30000000)
1458 if ((op & 0xffff0000) != 0x3d800000)
1464 if ((op & 0xffff0000) != 0x818c0000)
1470 if ((op & 0xfffffffe) != 0x7c406008)
1513 long vr_saved_offset = 0;
1519 int vrsave_reg = -1;
1522 int minimal_toc_loaded = 0;
1523 int prev_insn_was_prologue_insn = 1;
1524 int num_skip_non_prologue_insns = 0;
1525 int r0_contains_arg = 0;
1550 if (prev_insn_was_prologue_insn)
1551 last_prologue_pc =
pc;
1557 prev_insn_was_prologue_insn = 1;
1564 if ((op & 0xfc1fffff) == 0x7c0802a6)
1584 lr_reg = (op & 0x03e00000) >> 21;
1586 r0_contains_arg = 0;
1589 else if ((op & 0xfc1fffff) == 0x7c000026)
1591 cr_reg = (op & 0x03e00000);
1593 r0_contains_arg = 0;
1597 else if ((op & 0xfc1f0000) == 0xd8010000)
1608 else if (((op & 0xfc1f0000) == 0xbc010000) ||
1609 (((op & 0xfc1f0000) == 0x90010000 ||
1610 (op & 0xfc1f0003) == 0xf8010000) &&
1611 (op & 0x03e00000) >= 0x01a00000))
1615 if ((op & 0xfc1f0000) == 0xbc010000)
1616 fdata->
gpr_mask |= ~((1U << reg) - 1);
1622 if ((op & 0xfc1f0003) == 0xf8010000)
1629 else if ((op & 0xffff0000) == 0x3c4c0000
1630 || (op & 0xffff0000) == 0x3c400000
1631 || (op & 0xffff0000) == 0x38420000)
1641 else if (op == 0x60000000)
1647 prev_insn_was_prologue_insn = 0;
1651 else if ((op & 0xffff0000) == 0x3c000000)
1653 fdata->
offset = (op & 0x0000ffff) << 16;
1655 r0_contains_arg = 0;
1659 else if ((op & 0xffff0000) == 0x60000000)
1661 fdata->
offset |= (op & 0x0000ffff);
1663 r0_contains_arg = 0;
1667 else if (lr_reg >= 0 &&
1669 (((op & 0xffff0000) == (lr_reg | 0xf8010000)) ||
1671 ((op & 0xffff0000) == (lr_reg | 0x90010000)) ||
1673 ((op & 0xffff0000) == (lr_reg | 0x94010000))))
1680 if ((op & 0xfc000003) == 0xf8000000 ||
1681 (op & 0xfc000000) == 0x90000000)
1689 else if (cr_reg >= 0 &&
1691 (((op & 0xffff0000) == (cr_reg | 0xf8010000)) ||
1693 ((op & 0xffff0000) == (cr_reg | 0x90010000)) ||
1695 ((op & 0xffff0000) == (cr_reg | 0x94010000))))
1701 if ((op & 0xfc000003) == 0xf8000000 ||
1702 (op & 0xfc000000) == 0x90000000)
1710 else if ((op & 0xfe80ffff) == 0x42800005 && lr_reg != -1)
1717 else if (op == 0x48000005)
1724 else if (op == 0x48000004)
1729 else if ((op & 0xffff0000) == 0x3fc00000 ||
1731 (op & 0xffff0000) == 0x3bde0000)
1736 else if ((op & 0xfc000001) == 0x48000001)
1755 if ((pc - orig_pc) > 8)
1760 if ((prologue_sal.
line == 0)
1761 || (prologue_sal.
line != this_sal.
line))
1772 if (op == 0x4def7b82 || op == 0)
1780 else if ((op & 0xfc1f0000) == 0x94010000)
1787 else if ((op & 0xfc1f016a) == 0x7c01016e)
1794 else if ((op & 0xfc1f0003) == 0xf8010001)
1801 else if ((op & 0xfc1f016a) == 0x7c01016a)
1808 else if ((op & 0xffff0000) == 0x38210000)
1817 else if (((op >> 22) == 0x20f ||
1818 (op >> 22) == 0x3af)
1820 && !minimal_toc_loaded)
1822 minimal_toc_loaded = 1;
1828 else if ((op & 0xfc0007fe) == 0x7c000378 &&
1829 (((op >> 21) & 31) >= 3) &&
1830 (((op >> 21) & 31) <= 10) &&
1831 ((
long) ((op >> 16) & 31)
1845 else if (op == 0x603d0000)
1854 else if (op == 0x603f0000
1855 || op == 0x7c3f0b78)
1864 else if ((op & 0xfc1fffff) == 0x38010000)
1869 + ((op & ~0x38010000) >> 21));
1880 else if ((op & 0xfc1fffff) == 0x7c0042a6)
1885 else if ((op & 0xfc1fffff) == 0x7c0043a6)
1893 else if ((op & 0xfc1f0000) == 0x90010000)
1904 else if (((op & 0xfc000000) == 0x64000000)
1905 || ((op & 0xfc000000) == 0x60000000))
1914 else if ((op & 0xffff0000) == 0x38000000
1915 || (op & 0xffff0000) == 0x39c00000)
1917 if ((op & 0xffff0000) == 0x38000000)
1918 r0_contains_arg = 0;
1925 prev_insn_was_prologue_insn = 0;
1929 else if ((op & 0xfc1fffff) == 0x7c1f01ce)
1931 if (pc == (li_found_pc + 4))
1942 vr_saved_offset = -1;
1953 else if (arch_info->mach == bfd_mach_ppc_e500
1954 && (op & 0xfc1f07ff) == 0x101f0321)
1956 if ((op & 0x03e00000) >= 0x01a00000)
1960 imm = (op >> 11) & 0x1f;
1961 ev_offset = imm * 8;
1975 else if (arch_info->mach == bfd_mach_ppc_e500
1976 && (op & 0xffe007ff) == 0x13e00320)
1978 if (pc == (li_found_pc + 4))
1990 vr_saved_offset = -1;
1998 else if (arch_info->mach == bfd_mach_ppc_e500
1999 && (op & 0xffe007ff) == 0x13e00321)
2004 ev_offset = ((op >> 11) & 0x1f) * 8;
2019 else if (arch_info->mach == bfd_mach_ppc_e500
2020 && (op & 0xfc1fffff) == 0x101f0320)
2022 if (pc == (li_found_pc + 4))
2024 if ((op & 0x03e00000) >= 0x01a00000)
2039 vr_saved_offset = -1;
2048 unsigned int all_mask = ~((1U << fdata->
saved_gpr) - 1);
2056 && (fdata->
gpr_mask & all_mask) == all_mask)
2059 if (op == 0x4e800020
2060 || op == 0x4e800420)
2064 if ((op & 0xf4000000) == 0x40000000)
2074 prev_insn_was_prologue_insn = 0;
2091 if ((op & 0xfc000001) == 0x48000001)
2095 if (op == 0x4def7b82)
2101 tmp = find_pc_misc_function (pc);
2103 && strcmp (misc_function_vector[tmp].
name,
main_name ()) == 0)
2109 if (pc == lim_pc && lr_reg >= 0)
2113 return last_prologue_pc;
2120 CORE_ADDR limit_pc, func_addr, func_end_addr = 0;
2129 if (post_prologue_pc != 0)
2130 return max (pc, post_prologue_pc);
2141 limit_pc = pc + 100;
2145 if (func_end_addr && limit_pc > func_end_addr)
2146 limit_pc = func_end_addr;
2193 return (addr & -16);
2246 unsigned int ii, op;
2251 static unsigned trampoline_code[] =
2271 if ((op & 0xfc000003) == 0x48000000)
2275 rel = ((
int)(op << 6) >> 6);
2276 return pc + 8 + rel;
2282 if (solib_target_pc)
2283 return solib_target_pc;
2285 for (ii = 0; trampoline_code[ii]; ++ii)
2288 if (op != trampoline_code[ii])
2299 static struct type *
2310 union __gdb_builtin_type_vec64
2314 int32_t v2_int32[2];
2315 int16_t v4_int16[4];
2335 TYPE_NAME (t) =
"ppc_builtin_type_vec64";
2344 static struct type *
2382 TYPE_NAME (t) =
"ppc_builtin_type_vec128";
2414 static const char *
const spe_regnames[] = {
2415 "ev0",
"ev1",
"ev2",
"ev3",
"ev4",
"ev5",
"ev6",
"ev7",
2416 "ev8",
"ev9",
"ev10",
"ev11",
"ev12",
"ev13",
"ev14",
"ev15",
2417 "ev16",
"ev17",
"ev18",
"ev19",
"ev20",
"ev21",
"ev22",
"ev23",
2418 "ev24",
"ev25",
"ev26",
"ev27",
"ev28",
"ev29",
"ev30",
"ev31",
2426 static const char *
const dfp128_regnames[] = {
2427 "dl0",
"dl1",
"dl2",
"dl3",
2428 "dl4",
"dl5",
"dl6",
"dl7",
2429 "dl8",
"dl9",
"dl10",
"dl11",
2430 "dl12",
"dl13",
"dl14",
"dl15"
2438 static const char *
const vsx_regnames[] = {
2439 "vs0",
"vs1",
"vs2",
"vs3",
"vs4",
"vs5",
"vs6",
"vs7",
2440 "vs8",
"vs9",
"vs10",
"vs11",
"vs12",
"vs13",
"vs14",
2441 "vs15",
"vs16",
"vs17",
"vs18",
"vs19",
"vs20",
"vs21",
2442 "vs22",
"vs23",
"vs24",
"vs25",
"vs26",
"vs27",
"vs28",
2443 "vs29",
"vs30",
"vs31",
"vs32",
"vs33",
"vs34",
"vs35",
2444 "vs36",
"vs37",
"vs38",
"vs39",
"vs40",
"vs41",
"vs42",
2445 "vs43",
"vs44",
"vs45",
"vs46",
"vs47",
"vs48",
"vs49",
2446 "vs50",
"vs51",
"vs52",
"vs53",
"vs54",
"vs55",
"vs56",
2447 "vs57",
"vs58",
"vs59",
"vs60",
"vs61",
"vs62",
"vs63"
2455 static const char *
const efpr_regnames[] = {
2456 "f32",
"f33",
"f34",
"f35",
"f36",
"f37",
"f38",
2457 "f39",
"f40",
"f41",
"f42",
"f43",
"f44",
"f45",
2458 "f46",
"f47",
"f48",
"f49",
"f50",
"f51",
2459 "f52",
"f53",
"f54",
"f55",
"f56",
"f57",
2460 "f58",
"f59",
"f60",
"f61",
"f62",
"f63"
2471 static struct type *
2539 int *optimizedp,
int *unavailablep)
2548 from, optimizedp, unavailablep))
2553 *optimizedp = *unavailablep = 0;
2626 status = move (regcache, tdep->
ppc_gp0_regnum + reg_index, byte_buffer);
2661 reg_nr, (
void *) buffer);
2677 2 * reg_index, buffer);
2680 2 * reg_index + 1, buffer + 8);
2685 2 * reg_index + 1, buffer);
2688 2 * reg_index, buffer + 8);
2707 2 * reg_index, buffer);
2709 2 * reg_index + 1, buffer + 8);
2714 2 * reg_index + 1, buffer);
2716 2 * reg_index, buffer + 8);
2732 reg_index - 32, buffer);
2741 reg_index, buffer + 8);
2746 reg_index, buffer + 8);
2766 reg_index - 32, buffer);
2774 reg_index, buffer + 8);
2779 reg_index, buffer + 8);
2835 _(
"rs6000_pseudo_register_read: "
2836 "called on unexpected register '%s' (%d)"),
2860 _(
"rs6000_pseudo_register_write: "
2861 "called on unexpected register '%s' (%d)"),
2871 if (0 <= num && num <= 31)
2873 else if (32 <= num && num <= 63)
2878 else if (77 <= num && num <= 108)
2880 else if (1200 <= num && num < 1200 + 32)
2913 if (0 <= num && num <= 31)
2915 else if (32 <= num && num <= 63)
2920 else if (1124 <= num && num < 1124 + 32)
2922 else if (1200 <= num && num < 1200 + 32)
2984 if (0 <= num && num <= 63)
2986 else if (68 <= num && num <= 75)
2987 return num - 68 + 86;
2988 else if (77 <= num && num <= 108)
2989 return num - 77 + 1124;
3039 {
"powerpc",
"PowerPC user-level", bfd_arch_powerpc,
3041 {
"power",
"POWER user-level", bfd_arch_rs6000,
3043 {
"403",
"IBM PowerPC 403", bfd_arch_powerpc,
3045 {
"405",
"IBM PowerPC 405", bfd_arch_powerpc,
3047 {
"601",
"Motorola PowerPC 601", bfd_arch_powerpc,
3049 {
"602",
"Motorola PowerPC 602", bfd_arch_powerpc,
3051 {
"603",
"Motorola/IBM PowerPC 603 or 603e", bfd_arch_powerpc,
3053 {
"604",
"Motorola PowerPC 604 or 604e", bfd_arch_powerpc,
3055 {
"403GC",
"IBM PowerPC 403GC", bfd_arch_powerpc,
3057 {
"505",
"Motorola PowerPC 505", bfd_arch_powerpc,
3059 {
"860",
"Motorola PowerPC 860 or 850", bfd_arch_powerpc,
3061 {
"750",
"Motorola/IBM PowerPC 750 or 740", bfd_arch_powerpc,
3063 {
"7400",
"Motorola/IBM PowerPC 7400 (G4)", bfd_arch_powerpc,
3065 {
"e500",
"Motorola PowerPC e500", bfd_arch_powerpc,
3069 {
"powerpc64",
"PowerPC 64-bit user-level", bfd_arch_powerpc,
3071 {
"620",
"Motorola PowerPC 620", bfd_arch_powerpc,
3073 {
"630",
"Motorola PowerPC 630", bfd_arch_powerpc,
3075 {
"a35",
"PowerPC A35", bfd_arch_powerpc,
3077 {
"rs64ii",
"PowerPC rs64ii", bfd_arch_powerpc,
3079 {
"rs64iii",
"PowerPC rs64iii", bfd_arch_powerpc,
3083 {
"rs1",
"IBM POWER RS1", bfd_arch_rs6000,
3085 {
"rsc",
"IBM POWER RSC", bfd_arch_rs6000,
3087 {
"rs2",
"IBM POWER RS2", bfd_arch_rs6000,
3101 for (v = variants; v->
name; v++)
3102 if (arch == v->
arch && mach == v->
mach)
3111 if (info->endian == BFD_ENDIAN_BIG)
3112 return print_insn_big_powerpc (memaddr, info);
3114 return print_insn_little_powerpc (memaddr, info);
3150 if ((*this_cache) != NULL)
3151 return (*this_cache);
3153 (*this_cache) = cache;
3185 if (func == 0 && saved_lr == pc)
3190 if (func == saved_func)
3207 byte_order, &backchain))
3258 for (i = fdata.
saved_vr; i < 32; i++)
3274 CORE_ADDR off = (byte_order == BFD_ENDIAN_BIG ? 4 : 0);
3327 if (info->
base == 0)
3333 static struct value *
3335 void **this_cache,
int regnum)
3366 (*this_cache) = cache;
3399 void **this_cache,
struct frame_id *this_id)
3406 if (info->
base == 0)
3415 static struct value *
3417 void **this_cache,
int regnum)
3430 void **this_prologue_cache)
3465 rs6000_frame_base_address
3559 vector_abi = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_GNU,
3560 Tag_GNU_Power_ABI_Vector);
3561 if (vector_abi == 3)
3565 sect = bfd_get_section_by_name (abfd,
".PPC.EMB.apuinfo");
3569 size = bfd_get_section_size (sect);
3571 if (!bfd_get_section_contents (abfd, sect, contents, 0, size))
3598 unsigned int name_len;
3599 unsigned int data_len;
3606 name_len = bfd_get_32 (abfd, ptr);
3607 name_len = (name_len + 3) & ~3U;
3608 data_len = bfd_get_32 (abfd, ptr + 4);
3609 type = bfd_get_32 (abfd, ptr + 8);
3614 && strcmp ((
const char *) ptr,
"APUinfo") != 0)
3633 unsigned int apuinfo = bfd_get_32 (abfd, ptr);
3634 unsigned int apu = apuinfo >> 16;
3640 if (apu == 0x100 || apu == 0x101)
3657 #define PPC_FIELD(value, from, len) \
3658 (((value) >> (32 - (from) - (len))) & ((1 << (len)) - 1))
3659 #define PPC_SEXT(v, bs) \
3660 ((((CORE_ADDR) (v) & (((CORE_ADDR) 1 << (bs)) - 1)) \
3661 ^ ((CORE_ADDR) 1 << ((bs) - 1))) \
3662 - ((CORE_ADDR) 1 << ((bs) - 1)))
3663 #define PPC_OP6(insn) PPC_FIELD (insn, 0, 6)
3664 #define PPC_EXTOP(insn) PPC_FIELD (insn, 21, 10)
3665 #define PPC_RT(insn) PPC_FIELD (insn, 6, 5)
3666 #define PPC_RS(insn) PPC_FIELD (insn, 6, 5)
3667 #define PPC_RA(insn) PPC_FIELD (insn, 11, 5)
3668 #define PPC_RB(insn) PPC_FIELD (insn, 16, 5)
3669 #define PPC_NB(insn) PPC_FIELD (insn, 16, 5)
3670 #define PPC_VRT(insn) PPC_FIELD (insn, 6, 5)
3671 #define PPC_FRT(insn) PPC_FIELD (insn, 6, 5)
3672 #define PPC_SPR(insn) (PPC_FIELD (insn, 11, 5) \
3673 | (PPC_FIELD (insn, 16, 5) << 5))
3674 #define PPC_BO(insn) PPC_FIELD (insn, 6, 5)
3675 #define PPC_T(insn) PPC_FIELD (insn, 6, 5)
3676 #define PPC_D(insn) PPC_SEXT (PPC_FIELD (insn, 16, 16), 16)
3677 #define PPC_DS(insn) PPC_SEXT (PPC_FIELD (insn, 16, 14), 14)
3678 #define PPC_BIT(insn,n) ((insn & (1 << (31 - (n)))) ? 1 : 0)
3679 #define PPC_OE(insn) PPC_BIT (insn, 21)
3680 #define PPC_RC(insn) PPC_BIT (insn, 31)
3681 #define PPC_Rc(insn) PPC_BIT (insn, 21)
3682 #define PPC_LK(insn) PPC_BIT (insn, 31)
3683 #define PPC_TX(insn) PPC_BIT (insn, 31)
3684 #define PPC_LEV(insn) PPC_FIELD (insn, 20, 7)
3686 #define PPC_XT(insn) ((PPC_TX (insn) << 5) | PPC_T (insn))
3687 #define PPC_XER_NB(xer) (xer & 0x7f)
3696 if (vsr < 0 || vsr >= 64)
3754 switch ((ext & 0x1ff))
3771 switch (ext & 0x3ff)
3981 "at %s, 4-%d.\n", insn,
paddress (gdbarch, addr), ext);
4011 if ((
PPC_BO (insn) & 0x4) == 0)
4025 "at %s, 19-%d.\n", insn,
paddress (gdbarch, addr), ext);
4044 switch (ext & 0x1ff)
4092 if ((ext & 0x1f) == 15)
4202 for (i = 0; i < nr; i++)
4205 + ((
PPC_RT (insn) + i) & 0x1f));
4319 if (ext == 694 || ext == 726 || ext == 150 || ext == 214 || ext == 182)
4382 addr = addr & ~0x1ULL;
4386 addr = addr & ~0x3ULL;
4391 addr = addr & ~0xfULL;
4483 "%08x at %s, 31-%d.\n",
4484 insn,
paddress (gdbarch, addr), ext);
4497 ea = (ra + rb) & ~((
ULONGEST) (at_dcsz - 1));
4504 "at %s, 31-%d.\n", insn,
paddress (gdbarch, addr), ext);
4597 "at %s, 59-%d.\n", insn,
paddress (gdbarch, addr), ext);
4705 switch ((ext >> 2) & 0x7f)
4873 if (((ext >> 3) & 0x3) == 3)
4880 "at %s, 60-%d.\n", insn,
paddress (gdbarch, addr), ext);
5047 "at %s, 59-%d.\n", insn,
paddress (gdbarch, addr), ext);
5124 if ((
PPC_BO (insn) & 0x4) == 0)
5185 for (i =
PPC_RT (insn); i < 32; i++)
5215 addr +=
PPC_D (insn);
5241 addr +=
PPC_D (insn);
5243 if (op6 == 36 || op6 == 37 || op6 == 52 || op6 == 53)
5245 else if (op6 == 54 || op6 == 55)
5247 else if (op6 == 44 || op6 == 45)
5249 else if (op6 == 38 || op6 == 39)
5298 if ((op6 == 61 && sub2 != 0) || (op6 == 62 && sub2 > 2))
5306 size = ((op6 == 61) || sub2 == 2) ? 16 : 8;
5308 addr +=
PPC_DS (insn) << 2;
5311 if (op6 == 62 && sub2 == 1)
5327 "at %s, %d.\n", insn,
paddress (gdbarch, addr), op6);
5345 static struct gdbarch *
5348 struct gdbarch *gdbarch;
5350 int wordsize, from_xcoff_exec, from_elf_exec;
5351 enum bfd_architecture arch;
5358 int have_fpu = 1, have_spe = 0, have_mq = 0, have_altivec = 0, have_dfp = 0,
5360 int tdesc_wordsize = -1;
5363 int num_pseudoregs = 0;
5372 && bfd_get_arch (info.
abfd) != bfd_arch_powerpc
5373 && bfd_get_arch (info.
abfd) != bfd_arch_rs6000)
5376 from_xcoff_exec = info.
abfd && info.
abfd->format == bfd_object &&
5377 bfd_get_flavour (info.
abfd) == bfd_target_xcoff_flavour;
5379 from_elf_exec = info.
abfd && info.
abfd->format == bfd_object &&
5380 bfd_get_flavour (info.
abfd) == bfd_target_elf_flavour;
5384 if (from_xcoff_exec)
5386 if (bfd_xcoff_is_xcoff64 (info.
abfd))
5391 else if (from_elf_exec)
5393 if (elf_elfheader (info.
abfd)->e_ident[EI_CLASS] == ELFCLASS64)
5424 mach = bfd_mach_ppc_e500;
5425 bfd_default_set_arch_mach (&abfd, arch, mach);
5448 static const char *
const gprs[] = {
5449 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
5450 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
5451 "r16",
"r17",
"r18",
"r19",
"r20",
"r21",
"r22",
"r23",
5452 "r24",
"r25",
"r26",
"r27",
"r28",
"r29",
"r30",
"r31"
5456 static const char *
const msr_names[] = {
"msr",
"ps" };
5457 static const char *
const cr_names[] = {
"cr",
"cnd" };
5458 static const char *
const ctr_names[] = {
"ctr",
"cnt" };
5461 "org.gnu.gdb.power.core");
5462 if (feature == NULL)
5497 wordsize = tdesc_wordsize;
5500 "org.gnu.gdb.power.fpu");
5501 if (feature != NULL)
5503 static const char *
const fprs[] = {
5504 "f0",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"f7",
5505 "f8",
"f9",
"f10",
"f11",
"f12",
"f13",
"f14",
"f15",
5506 "f16",
"f17",
"f18",
"f19",
"f20",
"f21",
"f22",
"f23",
5507 "f24",
"f25",
"f26",
"f27",
"f28",
"f29",
"f30",
"f31"
5528 have_dfp = have_fpu;
5531 "org.gnu.gdb.power.altivec");
5532 if (feature != NULL)
5534 static const char *
const vector_regs[] = {
5535 "vr0",
"vr1",
"vr2",
"vr3",
"vr4",
"vr5",
"vr6",
"vr7",
5536 "vr8",
"vr9",
"vr10",
"vr11",
"vr12",
"vr13",
"vr14",
"vr15",
5537 "vr16",
"vr17",
"vr18",
"vr19",
"vr20",
"vr21",
"vr22",
"vr23",
5538 "vr24",
"vr25",
"vr26",
"vr27",
"vr28",
"vr29",
"vr30",
"vr31"
5551 if (have_spe || !valid_p)
5563 "org.gnu.gdb.power.vsx");
5565 if (feature != NULL)
5567 static const char *
const vsx_regs[] = {
5568 "vs0h",
"vs1h",
"vs2h",
"vs3h",
"vs4h",
"vs5h",
5569 "vs6h",
"vs7h",
"vs8h",
"vs9h",
"vs10h",
"vs11h",
5570 "vs12h",
"vs13h",
"vs14h",
"vs15h",
"vs16h",
"vs17h",
5571 "vs18h",
"vs19h",
"vs20h",
"vs21h",
"vs22h",
"vs23h",
5572 "vs24h",
"vs25h",
"vs26h",
"vs27h",
"vs28h",
"vs29h",
5607 "org.gnu.gdb.power.spe");
5608 if (feature != NULL)
5610 static const char *
const upper_spe[] = {
5611 "ev0h",
"ev1h",
"ev2h",
"ev3h",
5612 "ev4h",
"ev5h",
"ev6h",
"ev7h",
5613 "ev8h",
"ev9h",
"ev10h",
"ev11h",
5614 "ev12h",
"ev13h",
"ev14h",
"ev15h",
5615 "ev16h",
"ev17h",
"ev18h",
"ev19h",
5616 "ev20h",
"ev21h",
"ev22h",
"ev23h",
5617 "ev24h",
"ev25h",
"ev26h",
"ev27h",
5618 "ev28h",
"ev29h",
"ev30h",
"ev31h"
5631 if (have_mq || have_fpu || !valid_p)
5653 if (tdesc_wordsize != -1 && tdesc_wordsize != wordsize)
5662 switch (elf_elfheader (info.
abfd)->e_flags & EF_PPC64_ABI)
5677 switch (bfd_elf_get_obj_attr_int (info.
abfd, OBJ_ATTR_GNU,
5678 Tag_GNU_Power_ABI_FP))
5693 switch (bfd_elf_get_obj_attr_int (info.
abfd, OBJ_ATTR_GNU,
5694 Tag_GNU_Power_ABI_Vector))
5720 if (wordsize == 8 && info.
byte_order == BFD_ENDIAN_LITTLE)
5731 soft_float = !have_fpu;
5736 if (!soft_float && !have_fpu)
5768 if (tdep && tdep->
elf_abi != elf_abi)
5774 if (tdep && tdep->
wordsize == wordsize)
5776 if (tdesc_data != NULL)
5838 if (have_spe || have_dfp || have_vsx)
5848 if (arch == bfd_arch_rs6000)
5856 num_pseudoregs += 32;
5858 num_pseudoregs += 16;
5861 num_pseudoregs += 96;
5889 else if (wordsize == 8)
6003 if (mach == bfd_mach_ppc_e500)
6028 \"set powerpc\" must be followed by an appropriate subcommand.\n"));
6047 internal_error (__FILE__, __LINE__,
_(
"could not update architecture"));
6068 internal_error (__FILE__, __LINE__,
_(
"Invalid vector ABI accepted: %s."),
6074 internal_error (__FILE__, __LINE__,
_(
"could not update architecture"));
6114 unsigned int *insns)
6119 for (i = 0, insn = 0; pattern[i].
mask; i++)
6124 if ((insn & pattern[i].mask) == pattern[i].
data)
6130 else if (!pattern[i].optional)
6143 return ((((
CORE_ADDR) insn & 0xffff) ^ 0x8000) - 0x8000);
6153 return ((((
CORE_ADDR) insn & 0xfffc) ^ 0x8000) - 0x8000);
6191 _(
"Various PowerPC-specific commands."),
6192 &setpowerpccmdlist,
"set powerpc ", 0, &
setlist);
6195 _(
"Various PowerPC-specific commands."),
6196 &showpowerpccmdlist,
"show powerpc ", 0, &
showlist);
6201 _(
"Set whether to use a soft-float ABI."),
6202 _(
"Show whether to use a soft-float ABI."),
6205 &setpowerpccmdlist, &showpowerpccmdlist);
6209 _(
"Set the vector ABI."),
6210 _(
"Show the vector ABI."),
6212 &setpowerpccmdlist, &showpowerpccmdlist);
6217 Set whether to use just one debug register for watchpoints on scalars."),
6219 Show whether to use just one debug register for watchpoints on scalars."),
6221 If true, GDB will use only one debug register when watching a variable of\n\
6222 scalar type, thus assuming that the variable is accessed through the address\n\
6223 of its first byte."),
6225 &setpowerpccmdlist, &showpowerpccmdlist);
static void initialize_tdesc_powerpc_602(void)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
struct target_desc * tdesc_powerpc_603
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
void set_gdbarch_have_nonsteppable_watchpoint(struct gdbarch *gdbarch, int have_nonsteppable_watchpoint)
void set_gdbarch_value_to_register(struct gdbarch *gdbarch, gdbarch_value_to_register_ftype value_to_register)
void ppc_collect_vsxregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *vsxregs, size_t len)
static void show_powerpc_exact_watchpoints(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
static const struct variant * find_variant_by_arch(enum bfd_architecture arch, unsigned long mach)
struct type * builtin_declong
void set_gdbarch_skip_main_prologue(struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype skip_main_prologue)
void set_gdbarch_ps_regnum(struct gdbarch *gdbarch, int ps_regnum)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
void ppc_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
static void rs6000_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
static void initialize_tdesc_powerpc_403gc(void)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
void set_gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
static int store_param_on_stack_p(unsigned long op, int framep, int *r0_contains_arg)
CORE_ADDR get_frame_pc(struct frame_info *frame)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
#define MSYMBOL_LINKAGE_NAME(symbol)
static const char * powerpc_vector_abi_string
struct frame_info * get_current_frame(void)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
enum register_status(* move_ev_register_func)(struct regcache *, int, void *)
static void ppc_dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, struct frame_info *this_frame)
static int rs6000_in_solib_return_trampoline(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
void ppc_supply_vrregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *vrregs, size_t len)
static int ppc_vrreg_offset(struct gdbarch_tdep *tdep, const struct ppc_reg_offsets *offsets, int regnum)
static const struct frame_base rs6000_frame_base
static void set_sim_regno(int *table, int gdb_regno, int sim_regno)
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
#define BL_DISPLACEMENT_MASK
static CORE_ADDR rs6000_skip_stack_check(struct gdbarch *gdbarch, const CORE_ADDR start_pc)
static void initialize_tdesc_powerpc_750(void)
#define GDBARCH_OBSTACK_CALLOC(GDBARCH, NR, TYPE)
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
void add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void set_tdesc_pseudo_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *pseudo_type)
static int ppc_fpreg_offset(struct gdbarch_tdep *tdep, const struct ppc_reg_offsets *offsets, int regnum)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
static int rs6000_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int num)
struct gdbarch_tdep * tdep
static void initialize_tdesc_powerpc_altivec32(void)
static enum register_status vsx_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, gdb_byte *buffer)
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
#define TYPE_NAME(thistype)
struct target_desc * tdesc_powerpc_altivec32
void set_gdbarch_displaced_step_location(struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype displaced_step_location)
static void initialize_tdesc_powerpc_405(void)
static CORE_ADDR skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR lim_pc, struct rs6000_framedata *fdata)
static struct type * rs6000_builtin_type_vec64(struct gdbarch *gdbarch)
static int ppc_record_vsr(struct regcache *regcache, struct gdbarch_tdep *tdep, int vsr)
void convert_typed_floating(const void *from, const struct type *from_type, void *to, const struct type *to_type)
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
struct ui_file * gdb_stdout
static int max_skip_non_prologue_insns
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
static int ppc_process_record_op60(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, uint32_t insn)
static int rs6000_stab_reg_to_regnum(struct gdbarch *gdbarch, int num)
void set_gdbarch_frame_red_zone_size(struct gdbarch *gdbarch, int frame_red_zone_size)
void internal_error(const char *file, int line, const char *fmt,...)
int gdbarch_update_p(struct gdbarch_info info)
const char * tdesc_register_name(struct gdbarch *gdbarch, int regno)
static unsigned int read_insn(struct frame_info *frame, CORE_ADDR pc)
static void initialize_tdesc_powerpc_603(void)
int tdesc_register_size(const struct tdesc_feature *feature, const char *name)
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
struct displaced_step_closure * simple_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static enum register_status do_regcache_raw_write(struct regcache *regcache, int regnum, void *buffer)
#define PPC_MAX_EPILOGUE_INSTRUCTIONS
struct type * arch_composite_type(struct gdbarch *gdbarch, char *name, enum type_code code)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
void set_gdbarch_deprecated_fp_regnum(struct gdbarch *gdbarch, int deprecated_fp_regnum)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
struct gdbarch_list * next
int vsx_register_p(struct gdbarch *gdbarch, int regno)
struct address_space * get_frame_address_space(struct frame_info *frame)
int gdbarch_num_regs(struct gdbarch *gdbarch)
struct reggroup *const all_reggroup
const struct bfd_arch_info * bfd_arch_info
struct target_desc * tdesc_rs6000
int ppc_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr)
static struct value * rs6000_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
void set_gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype dwarf2_reg_to_regnum)
struct gdbarch_tdep_info * tdep_info
int ppc_deal_with_atomic_sequence(struct frame_info *frame)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
static int rs6000_in_function_epilogue_frame_p(struct frame_info *curfrm, struct gdbarch *gdbarch, CORE_ADDR pc)
void tdesc_data_cleanup(void *data_untyped)
void set_gdbarch_displaced_step_hw_singlestep(struct gdbarch *gdbarch, gdbarch_displaced_step_hw_singlestep_ftype displaced_step_hw_singlestep)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
static int rs6000_pseudo_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
static const struct frame_unwind rs6000_frame_unwind
struct target_desc * tdesc_powerpc_604
static CORE_ADDR rs6000_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
struct type * builtin_int32
static const unsigned char * rs6000_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *bp_addr, int *bp_size)
struct target_desc * tdesc_powerpc_7400
#define FRAME_OBSTACK_ZALLOC(TYPE)
static void ppc_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
enum powerpc_vector_abi vector_abi
static const char * rs6000_register_name(struct gdbarch *gdbarch, int regno)
struct target_desc * tdesc_powerpc_403gc
int ppc_altivec_support_p(struct gdbarch *gdbarch)
static void dfp_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer)
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
void ppc_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
#define STDCX_INSTRUCTION
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
struct reggroup *const float_reggroup
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
struct cmd_list_element * setlist
void add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
static void init_sim_regno_table(struct gdbarch *arch)
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
#define CATCH(EXCEPTION, MASK)
static CORE_ADDR rs6000_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
static void rs6000_value_to_register(struct frame_info *frame, int regnum, struct type *type, const gdb_byte *from)
int tdesc_numbered_register_choices(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *const names[])
int ppc_vsr0_upper_regnum
enum register_status regcache_raw_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
struct target_desc * tdesc_powerpc_602
static CORE_ADDR rs6000_frame_align(struct gdbarch *gdbarch, CORE_ADDR addr)
static enum auto_boolean powerpc_soft_float_global
static int rs6000_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
CORE_ADDR ppc64_sysv_abi_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
void dwarf2_frame_set_init_reg(struct gdbarch *gdbarch, void(*init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, struct frame_info *))
struct target_ops current_target
void initialize_file_ftype(void)
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
static const char *const powerpc_vector_strings[]
static struct rs6000_frame_cache * rs6000_epilogue_frame_cache(struct frame_info *this_frame, void **this_cache)
static int ppc_process_record_op59(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, uint32_t insn)
void fprintf_filtered(struct ui_file *stream, const char *format,...)
static void initialize_tdesc_powerpc_e500(void)
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
static struct type * rs6000_builtin_type_vec128(struct gdbarch *gdbarch)
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype stack_frame_destroyed_p)
static int rs6000_adjust_frame_regnum(struct gdbarch *gdbarch, int num, int eh_frame_p)
struct target_desc * tdesc_powerpc_403
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
int safe_frame_unwind_memory(struct frame_info *this_frame, CORE_ADDR addr, gdb_byte *buf, int len)
#define PPC_FIELD(value, from, len)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void register_e500_ravenscar_ops(struct gdbarch *gdbarch)
struct target_desc * tdesc_powerpc_405
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
static int bfd_uses_spe_extensions(bfd *abfd)
void set_gdbarch_in_solib_return_trampoline(struct gdbarch *gdbarch, gdbarch_in_solib_return_trampoline_ftype in_solib_return_trampoline)
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
struct cmd_list_element * showlist
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
static const struct frame_base * rs6000_frame_base_sniffer(struct frame_info *this_frame)
static void initialize_tdesc_rs6000(void)
void insert_single_step_breakpoint(struct gdbarch *gdbarch, struct address_space *aspace, CORE_ADDR next_pc)
static CORE_ADDR rs6000_fetch_pointer_argument(struct frame_info *frame, int argi, struct type *type)
struct type * builtin_int16
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void set_gdbarch_register_sim_regno(struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype register_sim_regno)
static int ppc_greg_offset(struct gdbarch *gdbarch, struct gdbarch_tdep *tdep, const struct ppc_reg_offsets *offsets, int regnum, int *regsize)
static void initialize_tdesc_powerpc_601(void)
static int bl_to_blrl_insn_p(CORE_ADDR pc, int insn, enum bfd_endian byte_order)
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
struct type * init_vector_type(struct type *elt_type, int n)
void set_gdbarch_register_to_value(struct gdbarch *gdbarch, gdbarch_register_to_value_ftype register_to_value)
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
void set_gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_from_pc_ftype breakpoint_from_pc)
static CORE_ADDR rs6000_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
static void powerpc_set_soft_float(char *args, int from_tty, struct cmd_list_element *c)
int(* ppc_syscall_record)(struct regcache *regcache)
static void set_powerpc_command(char *args, int from_tty)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
static int startswith(const char *string, const char *pattern)
static void initialize_tdesc_powerpc_64(void)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
static struct frame_id rs6000_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
void ppc_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
int altivec_register_p(struct gdbarch *gdbarch, int regno)
int target_exact_watchpoints
void printf_unfiltered(const char *format,...)
static void initialize_tdesc_powerpc_vsx32(void)
static struct type * rs6000_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
struct reggroup *const vector_reggroup
CORE_ADDR displaced_step_at_entry_point(struct gdbarch *gdbarch)
CORE_ADDR ppc_sysv_abi_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
static struct rs6000_frame_cache * rs6000_frame_cache(struct frame_info *this_frame, void **this_cache)
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
static int ppc_displaced_step_hw_singlestep(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
struct ui_file * gdb_stdlog
void set_gdbarch_sofun_address_maybe_missing(struct gdbarch *gdbarch, int sofun_address_maybe_missing)
static int insn_changes_sp_or_jumps(unsigned long insn)
struct type * builtin_uint128
static int ppc_process_record_op31(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, uint32_t insn)
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
struct target_desc * tdesc_powerpc_64
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
static void rs6000_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer)
void ppc_collect_reg(const struct regcache *regcache, int regnum, gdb_byte *regs, size_t offset, int regsize)
void put_frame_register(struct frame_info *frame, int regnum, const gdb_byte *buf)
int ppc_floating_point_unit_p(struct gdbarch *gdbarch)
int record_full_arch_list_add_mem(CORE_ADDR addr, int len)
const struct target_desc * target_desc
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype software_single_step)
static void show_powerpc_command(char *args, int from_tty)
static enum register_status e500_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, gdb_byte *buffer)
CORE_ADDR ppc_insn_d_field(unsigned int insn)
static void initialize_tdesc_powerpc_altivec64(void)
#define LDARX_INSTRUCTION
static void initialize_tdesc_powerpc_505(void)
struct type * ppc_builtin_type_vec128
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
static int ppc_process_record_op63(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, uint32_t insn)
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct frame_info *this_frame)
void throw_exception(struct gdb_exception exception)
void tdesc_use_registers(struct gdbarch *gdbarch, const struct target_desc *target_desc, struct tdesc_arch_data *early_data)
const char const char int
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
struct target_desc * tdesc_powerpc_e500
void append_composite_type_field(struct type *t, char *name, struct type *field)
static void initialize_tdesc_powerpc_vsx64(void)
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
static void initialize_tdesc_powerpc_32(void)
struct target_desc * tdesc_powerpc_altivec64
struct target_desc * tdesc_powerpc_505
void set_gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
void set_gdbarch_char_signed(struct gdbarch *gdbarch, int char_signed)
static CORE_ADDR rs6000_frame_base_address(struct frame_info *this_frame, void **this_cache)
static void efpr_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer)
struct type * builtin_double
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
void set_gdbarch_convert_register_p(struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype convert_register_p)
void ppc_collect_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
static int rs6000_register_to_value(struct frame_info *frame, int regnum, struct type *type, gdb_byte *to, int *optimizedp, int *unavailablep)
static void e500_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer)
static struct value * rs6000_epilogue_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
int frame_relative_level(struct frame_info *fi)
initialize_file_ftype _initialize_rs6000_tdep
#define TYPE_CODE(thistype)
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
#define IS_EFP_PSEUDOREG(tdep, regnum)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void gdbarch_info_init(struct gdbarch_info *info)
static void initialize_tdesc_powerpc_860(void)
#define IS_VSX_PSEUDOREG(tdep, regnum)
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
static enum register_status e500_move_ev_register(move_ev_register_func move, struct regcache *regcache, int ev_reg, void *buffer)
struct minimal_symbol * minsym
enum bfd_architecture arch
static CORE_ADDR rs6000_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
static void rs6000_dump_tdep(struct gdbarch *gdbarch, struct ui_file *file)
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
void set_gdbarch_fetch_pointer_argument(struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
enum return_value_convention ppc64_sysv_abi_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
struct type * ppc_builtin_type_vec64
struct target_desc * tdesc_powerpc_860
CORE_ADDR ppc_insn_ds_field(unsigned int insn)
struct m32c_reg regs[M32C_MAX_NUM_REGS]
static int gdb_print_insn_powerpc(bfd_vma memaddr, disassemble_info *info)
#define STWCX_INSTRUCTION
struct tdesc_arch_data * tdesc_data_alloc(void)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
void frame_base_append_sniffer(struct gdbarch *gdbarch, frame_base_sniffer_ftype *sniffer)
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
static enum register_status efpr_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, gdb_byte *buffer)
unsigned long long ULONGEST
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
static unsigned long rs6000_fetch_instruction(struct gdbarch *gdbarch, const CORE_ADDR pc)
static int ppc_process_record_op4(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, uint32_t insn)
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
int register_size(struct gdbarch *gdbarch, int regnum)
int spe_register_p(struct gdbarch *gdbarch, int regno)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
void register_ppc_ravenscar_ops(struct gdbarch *gdbarch)
struct type * builtin_int64
static int rs6000_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
static struct gdbarch * rs6000_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
void ppc_supply_reg(struct regcache *regcache, int regnum, const gdb_byte *regs, size_t offset, int regsize)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
static void initialize_tdesc_powerpc_403(void)
void set_gdbarch_displaced_step_free_closure(struct gdbarch *gdbarch, gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure)
#define LWARX_INSTRUCTION
void ppc_collect_vrregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *vrregs, size_t len)
void set_tdesc_pseudo_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *pseudo_reggroup_p)
struct target_desc * tdesc_powerpc_601
int ppc_insns_match_pattern(struct frame_info *frame, CORE_ADDR pc, struct ppc_insn_pattern *pattern, unsigned int *insns)
static void vsx_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer)
static int ppc_process_record_op19(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, uint32_t insn)
#define TYPE_LENGTH(thistype)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
enum powerpc_elf_abi elf_abi
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
struct trad_frame_saved_reg * saved_regs
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
struct type * builtin_int8
static void initialize_tdesc_powerpc_604(void)
static struct gdbarch_data * tdesc_data
enum bfd_endian byte_order
static void powerpc_set_vector_abi(char *args, int from_tty, struct cmd_list_element *c)
enum bfd_endian byte_order
static enum register_status do_regcache_raw_read(struct regcache *regcache, int regnum, void *buffer)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_max_insn_length(struct gdbarch *gdbarch, ULONGEST max_insn_length)
void ppc_supply_vsxregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *vsxregs, size_t len)
int record_full_arch_list_add_end(void)
int tdesc_has_registers(const struct target_desc *target_desc)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
struct target_desc ** tdesc
static void initialize_tdesc_powerpc_7400(void)
static enum powerpc_vector_abi powerpc_vector_abi_global
enum return_value_convention ppc_sysv_abi_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
enum dwarf2_frame_reg_rule how
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
static enum register_status rs6000_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, gdb_byte *buffer)
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct target_desc * tdesc_powerpc_750
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
static int ppc_vsx_support_p(struct gdbarch *gdbarch)
#define IS_SPE_PSEUDOREG(tdep, regnum)
struct type * builtin_float
void dwarf2_frame_set_adjust_regnum(struct gdbarch *gdbarch, int(*adjust_regnum)(struct gdbarch *, int, int))
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
const ULONGEST const LONGEST len
void simple_displaced_step_free_closure(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
static enum register_status dfp_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, gdb_byte *buffer)
#define IS_DFP_PSEUDOREG(tdep, regnum)
static int rs6000_register_sim_regno(struct gdbarch *gdbarch, int reg)
static int rs6000_epilogue_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
static void rs6000_epilogue_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)