23#include "opcode/i386.h"
42#include "gdbsupport/x86-xstate.h"
49#include "gdbsupport/byte-vector.h"
65 "rax",
"rbx",
"rcx",
"rdx",
"rsi",
"rdi",
"rbp",
"rsp",
68 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
69 "rip",
"eflags",
"cs",
"ss",
"ds",
"es",
"fs",
"gs",
72 "st0",
"st1",
"st2",
"st3",
"st4",
"st5",
"st6",
"st7",
73 "fctrl",
"fstat",
"ftag",
"fiseg",
"fioff",
"foseg",
"fooff",
"fop",
76 "xmm0",
"xmm1",
"xmm2",
"xmm3",
"xmm4",
"xmm5",
"xmm6",
"xmm7",
77 "xmm8",
"xmm9",
"xmm10",
"xmm11",
"xmm12",
"xmm13",
"xmm14",
"xmm15",
83 "ymm0",
"ymm1",
"ymm2",
"ymm3",
84 "ymm4",
"ymm5",
"ymm6",
"ymm7",
85 "ymm8",
"ymm9",
"ymm10",
"ymm11",
86 "ymm12",
"ymm13",
"ymm14",
"ymm15"
91 "ymm16",
"ymm17",
"ymm18",
"ymm19",
92 "ymm20",
"ymm21",
"ymm22",
"ymm23",
93 "ymm24",
"ymm25",
"ymm26",
"ymm27",
94 "ymm28",
"ymm29",
"ymm30",
"ymm31"
99 "ymm0h",
"ymm1h",
"ymm2h",
"ymm3h",
100 "ymm4h",
"ymm5h",
"ymm6h",
"ymm7h",
101 "ymm8h",
"ymm9h",
"ymm10h",
"ymm11h",
102 "ymm12h",
"ymm13h",
"ymm14h",
"ymm15h"
107 "ymm16h",
"ymm17h",
"ymm18h",
"ymm19h",
108 "ymm20h",
"ymm21h",
"ymm22h",
"ymm23h",
109 "ymm24h",
"ymm25h",
"ymm26h",
"ymm27h",
110 "ymm28h",
"ymm29h",
"ymm30h",
"ymm31h"
115 "bnd0raw",
"bnd1raw",
"bnd2raw",
"bnd3raw",
"bndcfgu",
"bndstatus"
120 "k0",
"k1",
"k2",
"k3",
121 "k4",
"k5",
"k6",
"k7"
126 "zmm0h",
"zmm1h",
"zmm2h",
"zmm3h",
127 "zmm4h",
"zmm5h",
"zmm6h",
"zmm7h",
128 "zmm8h",
"zmm9h",
"zmm10h",
"zmm11h",
129 "zmm12h",
"zmm13h",
"zmm14h",
"zmm15h",
130 "zmm16h",
"zmm17h",
"zmm18h",
"zmm19h",
131 "zmm20h",
"zmm21h",
"zmm22h",
"zmm23h",
132 "zmm24h",
"zmm25h",
"zmm26h",
"zmm27h",
133 "zmm28h",
"zmm29h",
"zmm30h",
"zmm31h"
138 "zmm0",
"zmm1",
"zmm2",
"zmm3",
139 "zmm4",
"zmm5",
"zmm6",
"zmm7",
140 "zmm8",
"zmm9",
"zmm10",
"zmm11",
141 "zmm12",
"zmm13",
"zmm14",
"zmm15",
142 "zmm16",
"zmm17",
"zmm18",
"zmm19",
143 "zmm20",
"zmm21",
"zmm22",
"zmm23",
144 "zmm24",
"zmm25",
"zmm26",
"zmm27",
145 "zmm28",
"zmm29",
"zmm30",
"zmm31"
149 "xmm16",
"xmm17",
"xmm18",
"xmm19",
150 "xmm20",
"xmm21",
"xmm22",
"xmm23",
151 "xmm24",
"xmm25",
"xmm26",
"xmm27",
152 "xmm28",
"xmm29",
"xmm30",
"xmm31"
210 -1, -1, -1, -1, -1, -1, -1, -1,
304 "al",
"bl",
"cl",
"dl",
"sil",
"dil",
"bpl",
"spl",
305 "r8l",
"r9l",
"r10l",
"r11l",
"r12l",
"r13l",
"r14l",
"r15l",
306 "ah",
"bh",
"ch",
"dh"
310#define AMD64_NUM_LOWER_BYTE_REGS 16
316 "ax",
"bx",
"cx",
"dx",
"si",
"di",
"bp",
"",
317 "r8w",
"r9w",
"r10w",
"r11w",
"r12w",
"r13w",
"r14w",
"r15w"
324 "eax",
"ebx",
"ecx",
"edx",
"esi",
"edi",
"ebp",
"esp",
325 "r8d",
"r9d",
"r10d",
"r11d",
"r12d",
"r13d",
"r14d",
"r15d",
376 memcpy (buf, raw_buf + 1, 1);
386 memcpy (buf, raw_buf, 1);
399 memcpy (buf, raw_buf, 4);
414 int regnum,
const gdb_byte *buf)
430 memcpy (raw_buf + 1, buf, 1);
441 memcpy (raw_buf, buf, 1);
454 memcpy (raw_buf, buf, 4);
514 if (class1 == class2)
550 if (
type->
code () == TYPE_CODE_STRUCT
551 ||
type->
code () == TYPE_CODE_UNION)
562 && subtype->
length () == 0)
573 error (_(
"could not determine alignment of type"));
575 int bytepos = bitpos / 8;
576 if (bytepos % align != 0)
593 unsigned int bitoffset)
600 bitsize = subtype->
length () * 8;
608 int pos = bitpos / 64;
609 int endpos = (bitpos + bitsize - 1) / 64;
611 if (subtype->
code () == TYPE_CODE_STRUCT
612 || subtype->
code () == TYPE_CODE_UNION)
621 gdb_assert (pos == 0 || pos == 1);
625 if (bitsize <= 64 && pos == 0 && endpos == 1)
685 if (
type->
code () == TYPE_CODE_ARRAY)
692 theclass[1] = theclass[0];
699 gdb_assert (
type->
code () == TYPE_CODE_STRUCT
700 ||
type->
code () == TYPE_CODE_UNION);
735 if ((
code == TYPE_CODE_INT ||
code == TYPE_CODE_ENUM
736 ||
code == TYPE_CODE_BOOL ||
code == TYPE_CODE_RANGE
737 ||
code == TYPE_CODE_CHAR
739 && (len == 1 || len == 2 || len == 4 || len == 8))
744 else if ((
code == TYPE_CODE_FLT ||
code == TYPE_CODE_DECFLOAT)
745 && (len == 2 || len == 4 || len == 8))
752 else if (
code == TYPE_CODE_DECFLOAT && len == 16)
759 else if (
code == TYPE_CODE_FLT && len == 16)
772 else if (
code == TYPE_CODE_COMPLEX && (len == 8 || len == 4))
774 else if (
code == TYPE_CODE_COMPLEX && len == 16)
779 else if (
code == TYPE_CODE_COMPLEX && len == 32)
783 else if (
code == TYPE_CODE_ARRAY ||
code == TYPE_CODE_STRUCT
784 ||
code == TYPE_CODE_UNION)
791 gdb_byte *readbuf,
const gdb_byte *writebuf)
801 gdb_assert (!(readbuf && writebuf));
855 gdb_assert (len <= 16);
857 for (i = 0; len > 0; i++, len -= 8)
867 regnum = integer_regnum[integer_reg++];
873 regnum = sse_regnum[sse_reg++];
879 gdb_assert (sse_reg > 0);
880 regnum = sse_regnum[sse_reg - 1];
895 gdb_assert (i > 0 && theclass[0] ==
AMD64_X87);
905 gdb_assert (!
"Unexpected register class.");
908 gdb_assert (
regnum != -1);
926 static int integer_regnum[] =
935 static int sse_regnum[] =
943 struct value **stack_args = XALLOCAVEC (
struct value *, nargs);
944 int num_stack_args = 0;
945 int num_elements = 0;
955 for (i = 0; i < nargs; i++)
960 int needed_integer_regs = 0;
961 int needed_sse_regs = 0;
969 for (j = 0; j < 2; j++)
972 needed_integer_regs++;
979 if (integer_reg + needed_integer_regs > ARRAY_SIZE (integer_regnum)
980 || sse_reg + needed_sse_regs > ARRAY_SIZE (sse_regnum)
981 || (needed_integer_regs == 0 && needed_sse_regs == 0))
984 num_elements += ((len + 7) / 8);
985 stack_args[num_stack_args++] = args[i];
993 gdb_assert (len <= 16);
995 for (j = 0; len > 0; j++, len -= 8)
1000 switch (theclass[j])
1003 regnum = integer_regnum[integer_reg++];
1007 regnum = sse_regnum[sse_reg++];
1011 gdb_assert (sse_reg > 0);
1012 regnum = sse_regnum[sse_reg - 1];
1020 gdb_assert (!
"Unexpected register class.");
1023 gdb_assert (
regnum != -1);
1024 memset (buf, 0,
sizeof buf);
1025 memcpy (buf, valbuf + j * 8, std::min (len, 8));
1032 sp -= num_elements * 8;
1039 for (i = 0; i < num_stack_args; i++)
1046 element += ((len + 7) / 8);
1060 int nargs,
struct value **args, CORE_ADDR sp,
1062 CORE_ADDR struct_addr)
1146 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1147 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1148 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1149 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1150 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1151 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1152 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0,
1153 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1154 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1155 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1156 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1157 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1158 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,
1159 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,
1160 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1161 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1
1169 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1,
1170 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1171 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,
1172 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,
1173 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1174 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1175 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1176 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,
1177 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1178 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1179 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1,
1180 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,
1181 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
1182 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1183 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1184 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
1194 return REX_PREFIX_P (pfx);
1224 case DATA_PREFIX_OPCODE:
1225 case ADDR_PREFIX_OPCODE:
1226 case CS_PREFIX_OPCODE:
1227 case DS_PREFIX_OPCODE:
1228 case ES_PREFIX_OPCODE:
1229 case FS_PREFIX_OPCODE:
1230 case GS_PREFIX_OPCODE:
1231 case SS_PREFIX_OPCODE:
1232 case LOCK_PREFIX_OPCODE:
1233 case REPE_PREFIX_OPCODE:
1234 case REPNE_PREFIX_OPCODE:
1257 int used_regs_mask = 0;
1266 used_regs_mask |= 1 << EAX_REG_NUM;
1268 used_regs_mask |= 1 << EDX_REG_NUM;
1270 used_regs_mask |= 1 << ESP_REG_NUM;
1281 int mod = MODRM_MOD_FIELD (modrm);
1282 int reg = MODRM_REG_FIELD (modrm);
1283 int rm = MODRM_RM_FIELD (modrm);
1284 int have_sib = mod != 3 && rm == 4;
1287 used_regs_mask |= 1 << reg;
1293 used_regs_mask |= 1 << base;
1294 used_regs_mask |= 1 << idx;
1298 used_regs_mask |= 1 << rm;
1302 gdb_assert (used_regs_mask < 256);
1303 gdb_assert (used_regs_mask != 255);
1309 for (i = 0; i < 8; ++i)
1311 if (! (used_regs_mask & (1 << i)))
1316 internal_error (_(
"unable to find free reg"));
1325 gdb_byte *start = insn;
1358 if (*insn == TWO_BYTE_OPCODE_ESCAPE)
1406 CORE_ADDR from, CORE_ADDR to,
struct regcache *regs)
1412 int arch_tmp_regno, tmp_regno;
1413 ULONGEST orig_value;
1418 rip_base = from + insn_length;
1427 static constexpr gdb_byte VEX3_NOT_B = 0x20;
1438 pfx[1] |= VEX3_NOT_B;
1440 gdb_assert_not_reached (
"unhandled prefix");
1463 CORE_ADDR from, CORE_ADDR to,
struct regcache *regs)
1471 if ((modrm & 0xc7) == 0x05)
1482 CORE_ADDR from, CORE_ADDR to,
1488 int fixup_sentinel_space = len;
1489 std::unique_ptr<amd64_displaced_step_copy_insn_closure> dsc
1491 gdb_byte *buf = &dsc->insn_buf[0];
1492 struct amd64_insn *details = &dsc->insn_details;
1499 memset (buf + len, 0, fixup_sentinel_space);
1532 if (insn[0] == 0xff)
1535 if ((insn[1] & 0x38) == 0x20)
1539 if ((insn[1] & 0x38) == 0x28)
1554 if (insn[0] == 0xeb)
1558 if (insn[0] == 0xe9)
1569 if (insn[0] == 0xff)
1572 if ((insn[1] & 0x38) == 0x10)
1576 if ((insn[1] & 0x38) == 0x18)
1612 if (insn[0] == 0xe8)
1626 if (insn[0] == 0x0f && insn[1] == 0x05)
1644 int len, classification;
1647 buf = (gdb_byte *) alloca (len);
1652 classification = pred (&details);
1654 return classification;
1687 CORE_ADDR from, CORE_ADDR to,
1694 ULONGEST insn_offset = to - from;
1695 gdb_byte *insn = dsc->
insn_buf.data ();
1747 && orig_rip != to + insn_len
1751 && orig_rip != to + insn_len + 1)
1755 ULONGEST rip = orig_rip - insn_offset;
1781 const ULONGEST retaddr_len = 8;
1785 retaddr = (retaddr - insn_offset) & 0xffffffffffffffffULL;
1806 if ((modrm & 0xc7) == 0x05)
1825 CORE_ADDR *to, CORE_ADDR oldloc)
1830 int fixup_sentinel_space = len;
1831 gdb_byte *buf = (gdb_byte *)
xmalloc (len + fixup_sentinel_space);
1834 LONGEST rel32, newrel;
1843 memset (buf + len, 0, fixup_sentinel_space);
1856 if (insn[0] == 0xe8)
1858 gdb_byte push_buf[32];
1863 ret_addr = oldloc + insn_length;
1868 if (ret_addr <= 0x7fffffff)
1876 push_buf[i++] = 0x48;
1877 push_buf[i++] = 0x83;
1878 push_buf[i++] = 0xec;
1879 push_buf[i++] = 0x08;
1881 push_buf[i++] = 0xc7;
1882 push_buf[i++] = 0x04;
1883 push_buf[i++] = 0x24;
1885 ret_addr & 0xffffffff);
1888 push_buf[i++] = 0xc7;
1889 push_buf[i++] = 0x44;
1890 push_buf[i++] = 0x24;
1891 push_buf[i++] = 0x04;
1896 gdb_assert (i <=
sizeof (push_buf));
1905 newrel = (oldloc - *to) + rel32;
1922 if (insn[0] == 0xe9)
1925 else if (insn[0] == 0x0f && (insn[1] & 0xf0) == 0x80)
1932 newrel = (oldloc - *to) + rel32;
1945#define AMD64_NUM_SAVED_REGS AMD64_NUM_GREGS
2037 int offset, offset_and;
2044 if ((buf[0] & 0xfb) == 0x48
2050 if ((buf[2] & 0xc7) != 0x44)
2054 reg = (buf[2] >> 3) & 7;
2067 if ((buf[0] & 0xf8) == 0x50)
2069 else if ((buf[0] & 0xf6) == 0x40
2070 && (buf[1] & 0xf8) == 0x50)
2073 if ((buf[0] & 1) != 0)
2082 reg += buf[offset] & 0x7;
2087 if ((buf[offset] & 0xfb) != 0x48
2088 || buf[offset + 1] != 0x8d
2089 || buf[offset + 3] != 0x24
2090 || buf[offset + 4] != 0x10)
2094 if ((buf[offset + 2] & 0xc7) != 0x44)
2098 r = (buf[offset + 2] >> 3) & 7;
2101 if (buf[offset] == 0x4c)
2112 if (reg == 4 || reg == 5)
2116 if (buf[offset] != 0x48
2117 || buf[offset + 2] != 0xe4
2118 || (buf[offset + 1] != 0x81 && buf[offset + 1] != 0x83))
2121 offset_and = offset;
2122 offset += buf[offset + 1] == 0x81 ? 7 : 4;
2126 if (buf[offset] == 0xff)
2128 else if ((buf[offset] & 0xf6) == 0x40
2129 && buf[offset + 1] == 0xff)
2132 if ((buf[offset] & 0x1) != 0)
2141 if (buf[offset + 1] != 0xf8
2142 || (buf[offset] & 0xf8) != 0x70)
2146 r += buf[offset] & 7;
2152 if (current_pc >
pc + offset_and)
2155 return std::min (
pc + offset + 2, current_pc);
2206 int offset, offset_and;
2212 offset = buf[0] == 0x67 ? 1 : 0;
2216 if (((buf[offset] & 0xfb) == 0x48 || (buf[offset] & 0xfb) == 0x40)
2217 && buf[offset + 1] == 0x8d
2218 && buf[offset + 3] == 0x24
2219 && buf[offset + 4] == 0x8)
2222 if ((buf[offset + 2] & 0xc7) != 0x44)
2226 reg = (buf[offset + 2] >> 3) & 7;
2229 if ((buf[offset] & 0x4) != 0)
2239 if ((buf[offset] & 0xf6) == 0x40
2240 && (buf[offset + 1] & 0xf8) == 0x50)
2243 if ((buf[offset] & 1) != 0)
2248 else if ((buf[offset] & 0xf8) != 0x50)
2252 reg += buf[offset] & 0x7;
2257 if (buf[offset] == 0x67)
2262 if (((buf[offset] & 0xfb) != 0x48 && (buf[offset] & 0xfb) != 0x40)
2263 || buf[offset + 1] != 0x8d
2264 || buf[offset + 3] != 0x24
2265 || buf[offset + 4] != 0x10)
2269 if ((buf[offset + 2] & 0xc7) != 0x44)
2273 r = (buf[offset + 2] >> 3) & 7;
2276 if ((buf[offset] & 0x4) != 0)
2287 if (reg == 4 || reg == 5)
2292 if (buf[offset] != 0x48)
2295 if (buf[offset + 2] != 0xe4
2296 || (buf[offset + 1] != 0x81 && buf[offset + 1] != 0x83))
2299 offset_and = offset;
2300 offset += buf[offset + 1] == 0x81 ? 7 : 4;
2303 if (buf[offset] == 0x67)
2308 if (buf[offset] == 0xff)
2310 else if ((buf[offset] & 0xf6) == 0x40
2311 && buf[offset + 1] == 0xff)
2314 if ((buf[offset] & 0x1) != 0)
2323 if (buf[offset + 1] != 0xf8
2324 || (buf[offset] & 0xf8) != 0x70)
2328 r += buf[offset] & 7;
2334 if (current_pc >
pc + offset_and)
2337 return std::min (
pc + offset + 2, current_pc);
2363 CORE_ADDR
pc, CORE_ADDR current_pc,
2368 static const gdb_byte endbr64[4] = { 0xf3, 0x0f, 0x1e, 0xfa };
2370 static const gdb_byte mov_rsp_rbp_1[3] = { 0x48, 0x89, 0xe5 };
2371 static const gdb_byte mov_rsp_rbp_2[3] = { 0x48, 0x8b, 0xec };
2373 static const gdb_byte mov_esp_ebp_1[2] = { 0x89, 0xe5 };
2374 static const gdb_byte mov_esp_ebp_2[2] = { 0x8b, 0xec };
2379 if (current_pc <=
pc)
2390 if (op == endbr64[0])
2394 if (memcmp (buf, &endbr64[1], 3) == 0)
2400 if (current_pc <=
pc)
2411 if (current_pc <=
pc + 1)
2417 if (memcmp (buf, mov_rsp_rbp_1, 3) == 0
2418 || memcmp (buf, mov_rsp_rbp_2, 3) == 0)
2428 if (memcmp (buf, mov_esp_ebp_1, 2) == 0
2429 || memcmp (buf, mov_esp_ebp_2, 2) == 0)
2465 gdb_byte buf[4 + 8 * 7];
2472 if (start_pc_sal.
symtab == NULL
2475 || start_pc_sal.
pc != start_pc ||
pc >= start_pc_sal.
end)
2479 if (next_sal.
line != start_pc_sal.
line)
2487 if (buf[0] != 0x84 || buf[1] != 0xc0)
2494 for (xmmreg = 0; xmmreg < 8; xmmreg++)
2497 if (buf[offset] != 0x0f || buf[offset + 1] != 0x29
2498 || (buf[offset + 2] & 0x3f) != (xmmreg << 3 | 0x5))
2502 if ((buf[offset + 2] & 0xc0) == 0x40)
2508 else if ((buf[offset + 2] & 0xc0) == 0x80)
2518 if (offset - 4 != buf[3])
2521 return next_sal.
end;
2531 CORE_ADDR func_addr;
2535 CORE_ADDR post_prologue_pc
2542 if (post_prologue_pc
2547 return std::max (start_pc, post_prologue_pc);
2592 cache->
base = ((cache->
saved_sp - 8) & 0xfffffffffffffff0LL) - 8;
2640 *this_cache = cache;
2646 catch (
const gdb_exception_error &ex)
2648 if (ex.error != NOT_AVAILABLE_ERROR)
2663 return UNWIND_UNAVAILABLE;
2666 if (cache->
base == 0)
2667 return UNWIND_OUTERMOST;
2669 return UNWIND_NO_REASON;
2681 else if (cache->
base == 0)
2690static struct value *
2698 gdb_assert (
regnum >= 0);
2774 catch (
const gdb_exception_error &ex)
2776 if (ex.error != NOT_AVAILABLE_ERROR)
2780 *this_cache = cache;
2792 return UNWIND_UNAVAILABLE;
2794 return UNWIND_NO_REASON;
2799 void **this_cache,
struct frame_id *this_id)
2806 else if (cache->
base == 0)
2815static struct value *
2817 void **this_cache,
int regnum)
2915 void **this_prologue_cache)
2936 *this_cache = cache;
2956 catch (
const gdb_exception_error &ex)
2958 if (ex.error != NOT_AVAILABLE_ERROR)
2973 return UNWIND_UNAVAILABLE;
2975 return UNWIND_NO_REASON;
3018 return sp & -(CORE_ADDR)16;
3028 int regnum,
const void *fpregs,
size_t len)
3045 int regnum,
void *fpregs,
size_t len)
3078 if (jb_pc_offset == -1)
3117 const struct target_desc *tdesc = info.target_desc;
3118 static const char *
const stap_integer_prefixes[] = {
"$", NULL };
3119 static const char *
const stap_register_prefixes[] = {
"%", NULL };
3120 static const char *
const stap_register_indirection_prefixes[] = {
"(",
3122 static const char *
const stap_register_indirection_suffixes[] = {
")",
3131 tdesc = default_tdesc;
3132 tdep->
tdesc = tdesc;
3266 stap_register_indirection_prefixes);
3268 stap_register_indirection_suffixes);
3339 [2][2][2][2][2] = {};
3342 tdesc = &amd64_tdescs[(xcr0 & X86_XSTATE_AVX) ? 1 : 0]
3343 [(xcr0 & X86_XSTATE_MPX) ? 1 : 0]
3344 [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0]
3345 [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]
3390 const gdb_byte *regs = (
const gdb_byte *) fxsave;
3413 const gdb_byte *regs = (
const gdb_byte *) xsave;
3421 if (!(clear_bv & X86_XSTATE_X87))
3442 gdb_byte *regs = (gdb_byte *) fxsave;
3459 void *xsave,
int gcore)
3463 gdb_byte *regs = (gdb_byte *) xsave;
void register_amd64_ravenscar_ops(struct gdbarch *gdbarch)
static int amd64_insn_is_jump(struct gdbarch *gdbarch, CORE_ADDR addr)
static int amd64_ret_p(const struct amd64_insn *details)
static void amd64_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
static void append_insns(CORE_ADDR *to, ULONGEST len, const gdb_byte *buf)
#define AMD64_NUM_SAVED_REGS
static void amd64_none_init_abi(gdbarch_info info, gdbarch *arch)
static enum amd64_reg_class amd64_merge_classes(enum amd64_reg_class class1, enum amd64_reg_class class2)
static int rex_prefix_p(gdb_byte pfx)
static enum unwind_stop_reason amd64_epilogue_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
static const int amd64_arch_regmap_len
void amd64_collect_xsave(const struct regcache *regcache, int regnum, void *xsave, int gcore)
static const char *const amd64_xmm_avx512_names[]
static struct value * amd64_sigtramp_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static int amd64_jmp_p(const struct amd64_insn *details)
static CORE_ADDR amd64_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct amd64_frame_cache *cache)
static void amd64_classify_aggregate(struct type *type, enum amd64_reg_class theclass[2])
static bool vex2_prefix_p(gdb_byte pfx)
void amd64_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_copy_insn_closure *dsc_, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static int amd64_arch_reg_to_regnum(int reg)
static int amd64_absolute_jmp_p(const struct amd64_insn *details)
static int amd64_ax_pseudo_register_collect(struct gdbarch *gdbarch, struct agent_expr *ax, int regnum)
const struct target_desc * amd64_target_description(uint64_t xcr0, bool segments)
#define AMD64_NUM_LOWER_BYTE_REGS
static struct value * amd64_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static const unsigned char twobyte_has_modrm[256]
static void fixup_displaced_copy(struct gdbarch *gdbarch, amd64_displaced_step_copy_insn_closure *dsc, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static void amd64_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
static struct amd64_frame_cache * amd64_alloc_frame_cache(void)
displaced_step_copy_insn_closure_up amd64_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static gdb_byte * amd64_skip_prefixes(gdb_byte *insn)
static const char *const amd64_pkeys_names[]
static struct amd64_frame_cache * amd64_epilogue_frame_cache(frame_info_ptr this_frame, void **this_cache)
static const char *const amd64_zmm_names[]
static CORE_ADDR amd64_x32_analyze_stack_align(CORE_ADDR pc, CORE_ADDR current_pc, struct amd64_frame_cache *cache)
static bool amd64_has_unaligned_fields(struct type *type)
static CORE_ADDR amd64_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
static bool vex3_prefix_p(gdb_byte pfx)
void amd64_x32_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, const target_desc *default_tdesc)
void amd64_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch, const target_desc *default_tdesc)
static const char *const amd64_ymmh_names[]
static const char *const amd64_mpx_names[]
static enum unwind_stop_reason amd64_sigtramp_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
static void amd64_epilogue_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static struct amd64_frame_cache * amd64_sigtramp_frame_cache(frame_info_ptr this_frame, void **this_cache)
static int amd64_sigtramp_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_cache)
static const struct frame_base amd64_frame_base
static const char *const amd64_register_names[]
static const char *const amd64_zmmh_names[]
static CORE_ADDR amd64_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc)
static void amd64_classify_aggregate_field(struct type *type, int i, enum amd64_reg_class theclass[2], unsigned int bitoffset)
static CORE_ADDR amd64_push_arguments(struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method)
static struct value * amd64_pseudo_register_read_value(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum)
static const char * amd64_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
static const char *const amd64_ymmh_avx512_names[]
static const int amd64_record_regmap[]
static int amd64_absolute_call_p(const struct amd64_insn *details)
static int amd64_syscall_p(const struct amd64_insn *insn, int *lengthp)
static void amd64_x32_none_init_abi(gdbarch_info info, gdbarch *arch)
static void amd64_collect_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
void amd64_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
static const char *const amd64_k_names[]
static const struct frame_unwind amd64_frame_unwind
static int amd64_epilogue_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
void _initialize_amd64_tdep()
static int amd64_insn_is_call(struct gdbarch *gdbarch, CORE_ADDR addr)
static CORE_ADDR amd64_analyze_stack_align(CORE_ADDR pc, CORE_ADDR current_pc, struct amd64_frame_cache *cache)
static enum unwind_stop_reason amd64_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
static const struct frame_unwind amd64_sigtramp_frame_unwind
static struct frame_id amd64_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
static void amd64_gen_return_address(struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
static int rip_relative_offset(struct amd64_insn *insn)
static void fixup_riprel(struct gdbarch *gdbarch, amd64_displaced_step_copy_insn_closure *dsc, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
static const char *const amd64_byte_names[]
static void amd64_get_insn_details(gdb_byte *insn, struct amd64_insn *details)
static bool amd64_in_indirect_branch_thunk(struct gdbarch *gdbarch, CORE_ADDR pc)
static const int amd64_dwarf_regmap_len
static int amd64_dwarf_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static const int amd64_arch_regmap[16]
static const struct frame_unwind amd64_epilogue_frame_unwind
static CORE_ADDR amd64_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 int amd64_dwarf_regmap[]
static const char *const amd64_ymm_names[]
void amd64_supply_xsave(struct regcache *regcache, int regnum, const void *xsave)
static struct type * amd64_x32_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
static CORE_ADDR amd64_skip_xmm_prologue(CORE_ADDR pc, CORE_ADDR start_pc)
static int amd64_classify_insn_at(struct gdbarch *gdbarch, CORE_ADDR addr, int(*pred)(const struct amd64_insn *))
static void amd64_frame_cache_1(frame_info_ptr this_frame, struct amd64_frame_cache *cache)
static void amd64_sigtramp_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static int amd64_insn_is_ret(struct gdbarch *gdbarch, CORE_ADDR addr)
static enum return_value_convention amd64_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static const char *const amd64_word_names[]
static const char *const amd64_ymm_avx512_names[]
static void amd64_init_frame_cache(struct amd64_frame_cache *cache)
static void amd64_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static const char *const amd64_dword_names[]
static int amd64_get_longjmp_target(frame_info_ptr frame, CORE_ADDR *pc)
const struct regset amd64_fpregset
static CORE_ADDR amd64_frame_base_address(frame_info_ptr this_frame, void **this_cache)
void amd64_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
static void amd64_relocate_instruction(struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR oldloc)
static int amd64_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
static void amd64_classify(struct type *type, enum amd64_reg_class theclass[2])
static const unsigned char onebyte_has_modrm[256]
static int amd64_call_p(const struct amd64_insn *details)
static int amd64_get_unused_input_int_reg(const struct amd64_insn *details)
target_desc * amd64_create_target_description(uint64_t xcr0, bool is_x32, bool is_linux, bool segments)
void ax_reg_mask(struct agent_expr *ax, int reg)
void ax_simple(struct agent_expr *x, enum agent_op op)
void ax_const_l(struct agent_expr *x, LONGEST l)
void ax_reg(struct agent_expr *x, int reg)
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 raw_read_part(int regnum, int offset, int len, gdb_byte *buf)
void raw_collect(int regnum, void *buf) const override
void raw_supply(int regnum, const void *buf) override
void cooked_write(int regnum, const gdb_byte *buf)
void raw_write_part(int regnum, int offset, int len, const gdb_byte *buf)
void raw_write(int regnum, const gdb_byte *buf)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
ULONGEST read_code_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_ABI_RETURNS_ADDRESS
@ RETURN_VALUE_REGISTER_CONVENTION
int gdb_buffered_insn_length(struct gdbarch *gdbarch, const gdb_byte *insn, int max_len, CORE_ADDR addr)
#define displaced_debug_printf(fmt,...)
std::unique_ptr< displaced_step_copy_insn_closure > displaced_step_copy_insn_closure_up
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
void frame_unwind_prepend_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
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)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
void get_frame_register(frame_info_ptr frame, int regnum, gdb_byte *buf)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum)
void set_gdbarch_insn_is_jump(struct gdbarch *gdbarch, gdbarch_insn_is_jump_ftype *insn_is_jump)
void set_gdbarch_ps_regnum(struct gdbarch *gdbarch, int ps_regnum)
void set_gdbarch_register_to_value(struct gdbarch *gdbarch, gdbarch_register_to_value_ftype *register_to_value)
void set_gdbarch_gen_return_address(struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype *gen_return_address)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void set_gdbarch_value_to_register(struct gdbarch *gdbarch, gdbarch_value_to_register_ftype *value_to_register)
void set_gdbarch_stap_parse_special_token(struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype *stap_parse_special_token)
void set_gdbarch_stap_integer_prefixes(struct gdbarch *gdbarch, const char *const *stap_integer_prefixes)
void set_gdbarch_pseudo_register_read_value(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype *pseudo_register_read_value)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype *stap_is_single_operand)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void set_gdbarch_ax_pseudo_register_collect(struct gdbarch *gdbarch, gdbarch_ax_pseudo_register_collect_ftype *ax_pseudo_register_collect)
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_frame_red_zone_size(struct gdbarch *gdbarch, int frame_red_zone_size)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write)
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)
void set_gdbarch_insn_is_ret(struct gdbarch *gdbarch, gdbarch_insn_is_ret_ftype *insn_is_ret)
void set_gdbarch_convert_register_p(struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype *convert_register_p)
void set_gdbarch_insn_is_call(struct gdbarch *gdbarch, gdbarch_insn_is_call_ftype *insn_is_call)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void set_gdbarch_stap_register_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_prefixes)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_relocate_instruction(struct gdbarch *gdbarch, gdbarch_relocate_instruction_ftype *relocate_instruction)
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
void set_gdbarch_in_indirect_branch_thunk(struct gdbarch *gdbarch, gdbarch_in_indirect_branch_thunk_ftype *in_indirect_branch_thunk)
function_call_return_method
int field_is_static(struct field *f)
unsigned type_align(struct type *type)
struct type * check_typedef(struct type *type)
#define TYPE_IS_REFERENCE(t)
#define TYPE_FIELD_BITSIZE(thistype, n)
#define TYPE_FIELD_PACKED(thistype, n)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
int i386_zmm_regnum_p(struct gdbarch *gdbarch, int regnum)
const char * i386_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
int i386_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
int i386_dword_regnum_p(struct gdbarch *gdbarch, int regnum)
int i386_ymm_avx512_regnum_p(struct gdbarch *gdbarch, int regnum)
void i386_pseudo_register_read_into_value(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, struct value *result_value)
int i386_ymm_regnum_p(struct gdbarch *gdbarch, int regnum)
void i386_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
int i386_byte_regnum_p(struct gdbarch *gdbarch, int regnum)
int i386_xmm_regnum_p(struct gdbarch *gdbarch, int regnum)
int i386_ax_pseudo_register_collect(struct gdbarch *gdbarch, struct agent_expr *ax, int regnum)
expr::operation_up i386_stap_parse_special_token(struct gdbarch *gdbarch, struct stap_parse_info *p)
int i386_word_regnum_p(struct gdbarch *gdbarch, int regnum)
struct type * i386_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
void i387_value_to_register(frame_info_ptr frame, int regnum, struct type *type, const gdb_byte *from)
ULONGEST i387_xsave_get_clear_bv(struct gdbarch *gdbarch, const void *xsave)
void i387_supply_xsave(struct regcache *regcache, int regnum, const void *xsave)
void i387_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
void i387_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
void i387_collect_xsave(const struct regcache *regcache, int regnum, void *xsave, int gcore)
void i387_reset_bnd_regs(struct gdbarch *gdbarch, struct regcache *regcache)
int i387_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
void i387_return_value(struct gdbarch *gdbarch, struct regcache *regcache)
int i387_register_to_value(frame_info_ptr frame, int regnum, struct type *type, gdb_byte *to, int *optimizedp, int *unavailablep)
#define I387_XMM0_REGNUM(tdep)
#define I387_SIZEOF_FXSAVE
#define I387_FOSEG_REGNUM(tdep)
#define I387_FISEG_REGNUM(tdep)
std::string displaced_step_dump_bytes(const gdb_byte *buf, size_t len)
struct language_pass_by_ref_info language_pass_by_reference(struct type *type)
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
int producer_is_gcc_ge_4(const char *producer)
bool producer_is_llvm(const char *producer)
bool producer_is_icc_ge_19(const char *producer)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
int register_size(struct gdbarch *gdbarch, int regnum)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
struct amd64_insn insn_details
gdb::byte_vector insn_buf
amd64_displaced_step_copy_insn_closure(int insn_buf_len)
CORE_ADDR saved_regs[AMD64_NUM_SAVED_REGS]
struct type * builtin_func_ptr
struct type * builtin_data_ptr
bool epilogue_unwind_valid() const
const char * producer() const
LONGEST loc_bitpos() const
struct type * type() const
const char *const * mpx_register_names
const struct regset * fpregset
const char *const * zmmh_register_names
const char *const * k_register_names
const char *const * register_names
int(* sigtramp_p)(frame_info_ptr)
const char *const * xmm_avx512_register_names
CORE_ADDR(* sigcontext_addr)(frame_info_ptr)
const char *const * pkeys_register_names
const char *const * ymmh_register_names
const struct target_desc * tdesc
const int * record_regmap
const char *const * ymm16h_register_names
struct compunit_symtab * compunit() const
const struct bfd_arch_info * arch
struct type * target_type() const
struct field & field(int idx) const
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
struct symtab_and_line find_pc_sect_line(CORE_ADDR pc, struct obj_section *section, int notcurrent)
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
void set_tdesc_pseudo_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *pseudo_name)
int tdesc_has_registers(const struct target_desc *target_desc)
void set_tdesc_pseudo_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *pseudo_type)
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
struct type * value_type(const struct value *value)
struct value * allocate_value(struct type *type)
void mark_value_bytes_unavailable(struct value *value, LONGEST offset, LONGEST length)
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
#define VALUE_REGNUM(val)
bool x86_in_indirect_branch_thunk(CORE_ADDR pc, const char *const *register_names, int lo, int hi)