24#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)
686 if (
type->
code () == TYPE_CODE_ARRAY)
693 theclass[1] = theclass[0];
700 gdb_assert (
type->
code () == TYPE_CODE_STRUCT
701 ||
type->
code () == TYPE_CODE_UNION);
736 if ((
code == TYPE_CODE_INT ||
code == TYPE_CODE_ENUM
737 ||
code == TYPE_CODE_BOOL ||
code == TYPE_CODE_RANGE
738 ||
code == TYPE_CODE_CHAR
740 && (len == 1 || len == 2 || len == 4 || len == 8))
745 else if ((
code == TYPE_CODE_FLT ||
code == TYPE_CODE_DECFLOAT)
746 && (len == 2 || len == 4 || len == 8))
753 else if (
code == TYPE_CODE_DECFLOAT && len == 16)
760 else if (
code == TYPE_CODE_FLT && len == 16)
773 else if (
code == TYPE_CODE_COMPLEX && (len == 8 || len == 4))
775 else if (
code == TYPE_CODE_COMPLEX && len == 16)
780 else if (
code == TYPE_CODE_COMPLEX && len == 32)
784 else if (
code == TYPE_CODE_ARRAY ||
code == TYPE_CODE_STRUCT
785 ||
code == TYPE_CODE_UNION)
792 struct value **read_value,
const gdb_byte *writebuf)
802 gdb_assert (!(read_value && writebuf));
820 if (read_value !=
nullptr)
831 gdb_byte *readbuf =
nullptr;
832 if (read_value !=
nullptr)
835 readbuf = (*read_value)->contents_raw ().data ();
863 gdb_assert (len <= 16);
865 for (i = 0; len > 0; i++, len -= 8)
875 regnum = integer_regnum[integer_reg++];
881 regnum = sse_regnum[sse_reg++];
887 gdb_assert (sse_reg > 0);
888 regnum = sse_regnum[sse_reg - 1];
903 gdb_assert (i > 0 && theclass[0] ==
AMD64_X87);
913 gdb_assert (!
"Unexpected register class.");
916 gdb_assert (
regnum != -1);
934 static int integer_regnum[] =
943 static int sse_regnum[] =
951 struct value **stack_args = XALLOCAVEC (
struct value *, nargs);
952 int num_stack_args = 0;
953 int num_elements = 0;
963 for (i = 0; i < nargs; i++)
965 struct type *
type = args[i]->type ();
968 int needed_integer_regs = 0;
969 int needed_sse_regs = 0;
977 for (j = 0; j < 2; j++)
980 needed_integer_regs++;
987 if (integer_reg + needed_integer_regs > ARRAY_SIZE (integer_regnum)
988 || sse_reg + needed_sse_regs > ARRAY_SIZE (sse_regnum)
989 || (needed_integer_regs == 0 && needed_sse_regs == 0))
992 num_elements += ((len + 7) / 8);
993 stack_args[num_stack_args++] = args[i];
998 const gdb_byte *valbuf = args[i]->contents ().data ();
1001 gdb_assert (len <= 16);
1003 for (j = 0; len > 0; j++, len -= 8)
1008 switch (theclass[j])
1011 regnum = integer_regnum[integer_reg++];
1015 regnum = sse_regnum[sse_reg++];
1019 gdb_assert (sse_reg > 0);
1020 regnum = sse_regnum[sse_reg - 1];
1028 gdb_assert (!
"Unexpected register class.");
1031 gdb_assert (
regnum != -1);
1032 memset (buf, 0,
sizeof buf);
1033 memcpy (buf, valbuf + j * 8, std::min (len, 8));
1040 sp -= num_elements * 8;
1047 for (i = 0; i < num_stack_args; i++)
1050 const gdb_byte *valbuf = stack_args[i]->
contents ().data ();
1054 element += ((len + 7) / 8);
1068 int nargs,
struct value **args, CORE_ADDR sp,
1070 CORE_ADDR struct_addr)
1154 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1155 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1156 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1157 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,
1158 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1159 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1160 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0,
1161 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1162 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1163 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1164 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1165 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1166 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,
1167 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,
1168 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1169 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1
1177 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1,
1178 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1179 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,
1180 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,
1181 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
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,0,1,1,1,1,1,1,1,1,
1185 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1186 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1187 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1,
1188 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,
1189 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,
1190 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1191 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1192 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
1202 return REX_PREFIX_P (pfx);
1232 case DATA_PREFIX_OPCODE:
1233 case ADDR_PREFIX_OPCODE:
1234 case CS_PREFIX_OPCODE:
1235 case DS_PREFIX_OPCODE:
1236 case ES_PREFIX_OPCODE:
1237 case FS_PREFIX_OPCODE:
1238 case GS_PREFIX_OPCODE:
1239 case SS_PREFIX_OPCODE:
1240 case LOCK_PREFIX_OPCODE:
1241 case REPE_PREFIX_OPCODE:
1242 case REPNE_PREFIX_OPCODE:
1265 int used_regs_mask = 0;
1274 used_regs_mask |= 1 << EAX_REG_NUM;
1276 used_regs_mask |= 1 << EDX_REG_NUM;
1278 used_regs_mask |= 1 << ESP_REG_NUM;
1289 int mod = MODRM_MOD_FIELD (modrm);
1290 int reg = MODRM_REG_FIELD (modrm);
1291 int rm = MODRM_RM_FIELD (modrm);
1292 int have_sib = mod != 3 && rm == 4;
1295 used_regs_mask |= 1 << reg;
1301 used_regs_mask |= 1 << base;
1302 used_regs_mask |= 1 << idx;
1306 used_regs_mask |= 1 << rm;
1310 gdb_assert (used_regs_mask < 256);
1311 gdb_assert (used_regs_mask != 255);
1317 for (i = 0; i < 8; ++i)
1319 if (! (used_regs_mask & (1 << i)))
1324 internal_error (_(
"unable to find free reg"));
1333 gdb_byte *start = insn;
1366 if (*insn == TWO_BYTE_OPCODE_ESCAPE)
1414 CORE_ADDR from, CORE_ADDR to,
struct regcache *regs)
1420 int arch_tmp_regno, tmp_regno;
1421 ULONGEST orig_value;
1426 rip_base = from + insn_length;
1435 static constexpr gdb_byte VEX3_NOT_B = 0x20;
1446 pfx[1] |= VEX3_NOT_B;
1448 gdb_assert_not_reached (
"unhandled prefix");
1471 CORE_ADDR from, CORE_ADDR to,
struct regcache *regs)
1479 if ((modrm & 0xc7) == 0x05)
1490 CORE_ADDR from, CORE_ADDR to,
1496 int fixup_sentinel_space = len;
1497 std::unique_ptr<amd64_displaced_step_copy_insn_closure> dsc
1499 gdb_byte *buf = &dsc->insn_buf[0];
1500 struct amd64_insn *details = &dsc->insn_details;
1507 memset (buf + len, 0, fixup_sentinel_space);
1529 bytes_to_string (buf, len).c_str ());
1540 if (insn[0] == 0xff)
1543 if ((insn[1] & 0x38) == 0x20)
1547 if ((insn[1] & 0x38) == 0x28)
1562 if (insn[0] == 0xeb)
1566 if (insn[0] == 0xe9)
1577 if (insn[0] == 0xff)
1580 if ((insn[1] & 0x38) == 0x10)
1584 if ((insn[1] & 0x38) == 0x18)
1620 if (insn[0] == 0xe8)
1634 if (insn[0] == 0x0f && insn[1] == 0x05)
1654 read_code (addr, buf.data (), buf.size ());
1657 int classification = pred (&details);
1659 return classification;
1692 CORE_ADDR from, CORE_ADDR to,
1693 struct regcache *regs,
bool completed_p)
1699 ULONGEST insn_offset = to - from;
1700 gdb_byte *insn = dsc->
insn_buf.data ();
1755 && (pc < to || pc > (to + insn_len + 1)))
1759 CORE_ADDR rip = pc - insn_offset;
1785 const ULONGEST retaddr_len = 8;
1789 retaddr = (retaddr - insn_offset) & 0xffffffffffffffffULL;
1810 if ((modrm & 0xc7) == 0x05)
1829 CORE_ADDR *to, CORE_ADDR oldloc)
1834 int fixup_sentinel_space = len;
1835 gdb::byte_vector buf (len + fixup_sentinel_space);
1838 LONGEST rel32, newrel;
1847 memset (buf.data () + len, 0, fixup_sentinel_space);
1860 if (insn[0] == 0xe8)
1862 gdb_byte push_buf[32];
1867 ret_addr = oldloc + insn_length;
1872 if (ret_addr <= 0x7fffffff)
1880 push_buf[i++] = 0x48;
1881 push_buf[i++] = 0x83;
1882 push_buf[i++] = 0xec;
1883 push_buf[i++] = 0x08;
1885 push_buf[i++] = 0xc7;
1886 push_buf[i++] = 0x04;
1887 push_buf[i++] = 0x24;
1889 ret_addr & 0xffffffff);
1892 push_buf[i++] = 0xc7;
1893 push_buf[i++] = 0x44;
1894 push_buf[i++] = 0x24;
1895 push_buf[i++] = 0x04;
1900 gdb_assert (i <=
sizeof (push_buf));
1909 newrel = (oldloc - *to) + rel32;
1926 if (insn[0] == 0xe9)
1929 else if (insn[0] == 0x0f && (insn[1] & 0xf0) == 0x80)
1936 newrel = (oldloc - *to) + rel32;
1949#define AMD64_NUM_SAVED_REGS AMD64_NUM_GREGS
2041 int offset, offset_and;
2048 if ((buf[0] & 0xfb) == 0x48
2054 if ((buf[2] & 0xc7) != 0x44)
2058 reg = (buf[2] >> 3) & 7;
2071 if ((buf[0] & 0xf8) == 0x50)
2073 else if ((buf[0] & 0xf6) == 0x40
2074 && (buf[1] & 0xf8) == 0x50)
2077 if ((buf[0] & 1) != 0)
2086 reg += buf[offset] & 0x7;
2091 if ((buf[offset] & 0xfb) != 0x48
2092 || buf[offset + 1] != 0x8d
2093 || buf[offset + 3] != 0x24
2094 || buf[offset + 4] != 0x10)
2098 if ((buf[offset + 2] & 0xc7) != 0x44)
2102 r = (buf[offset + 2] >> 3) & 7;
2105 if (buf[offset] == 0x4c)
2116 if (reg == 4 || reg == 5)
2120 if (buf[offset] != 0x48
2121 || buf[offset + 2] != 0xe4
2122 || (buf[offset + 1] != 0x81 && buf[offset + 1] != 0x83))
2125 offset_and = offset;
2126 offset += buf[offset + 1] == 0x81 ? 7 : 4;
2130 if (buf[offset] == 0xff)
2132 else if ((buf[offset] & 0xf6) == 0x40
2133 && buf[offset + 1] == 0xff)
2136 if ((buf[offset] & 0x1) != 0)
2145 if (buf[offset + 1] != 0xf8
2146 || (buf[offset] & 0xf8) != 0x70)
2150 r += buf[offset] & 7;
2156 if (current_pc >
pc + offset_and)
2159 return std::min (
pc + offset + 2, current_pc);
2210 int offset, offset_and;
2216 offset = buf[0] == 0x67 ? 1 : 0;
2220 if (((buf[offset] & 0xfb) == 0x48 || (buf[offset] & 0xfb) == 0x40)
2221 && buf[offset + 1] == 0x8d
2222 && buf[offset + 3] == 0x24
2223 && buf[offset + 4] == 0x8)
2226 if ((buf[offset + 2] & 0xc7) != 0x44)
2230 reg = (buf[offset + 2] >> 3) & 7;
2233 if ((buf[offset] & 0x4) != 0)
2243 if ((buf[offset] & 0xf6) == 0x40
2244 && (buf[offset + 1] & 0xf8) == 0x50)
2247 if ((buf[offset] & 1) != 0)
2252 else if ((buf[offset] & 0xf8) != 0x50)
2256 reg += buf[offset] & 0x7;
2261 if (buf[offset] == 0x67)
2266 if (((buf[offset] & 0xfb) != 0x48 && (buf[offset] & 0xfb) != 0x40)
2267 || buf[offset + 1] != 0x8d
2268 || buf[offset + 3] != 0x24
2269 || buf[offset + 4] != 0x10)
2273 if ((buf[offset + 2] & 0xc7) != 0x44)
2277 r = (buf[offset + 2] >> 3) & 7;
2280 if ((buf[offset] & 0x4) != 0)
2291 if (reg == 4 || reg == 5)
2296 if (buf[offset] != 0x48)
2299 if (buf[offset + 2] != 0xe4
2300 || (buf[offset + 1] != 0x81 && buf[offset + 1] != 0x83))
2303 offset_and = offset;
2304 offset += buf[offset + 1] == 0x81 ? 7 : 4;
2307 if (buf[offset] == 0x67)
2312 if (buf[offset] == 0xff)
2314 else if ((buf[offset] & 0xf6) == 0x40
2315 && buf[offset + 1] == 0xff)
2318 if ((buf[offset] & 0x1) != 0)
2327 if (buf[offset + 1] != 0xf8
2328 || (buf[offset] & 0xf8) != 0x70)
2332 r += buf[offset] & 7;
2338 if (current_pc >
pc + offset_and)
2341 return std::min (
pc + offset + 2, current_pc);
2367 CORE_ADDR
pc, CORE_ADDR current_pc,
2372 static const gdb_byte endbr64[4] = { 0xf3, 0x0f, 0x1e, 0xfa };
2374 static const gdb_byte mov_rsp_rbp_1[3] = { 0x48, 0x89, 0xe5 };
2375 static const gdb_byte mov_rsp_rbp_2[3] = { 0x48, 0x8b, 0xec };
2377 static const gdb_byte mov_esp_ebp_1[2] = { 0x89, 0xe5 };
2378 static const gdb_byte mov_esp_ebp_2[2] = { 0x8b, 0xec };
2383 if (current_pc <=
pc)
2394 if (op == endbr64[0])
2398 if (memcmp (buf, &endbr64[1], 3) == 0)
2404 if (current_pc <=
pc)
2415 if (current_pc <=
pc + 1)
2421 if (memcmp (buf, mov_rsp_rbp_1, 3) == 0
2422 || memcmp (buf, mov_rsp_rbp_2, 3) == 0)
2432 if (memcmp (buf, mov_esp_ebp_1, 2) == 0
2433 || memcmp (buf, mov_esp_ebp_2, 2) == 0)
2469 gdb_byte buf[4 + 8 * 7];
2476 if (start_pc_sal.
symtab == NULL
2479 || start_pc_sal.
pc != start_pc ||
pc >= start_pc_sal.
end)
2483 if (next_sal.
line != start_pc_sal.
line)
2491 if (buf[0] != 0x84 || buf[1] != 0xc0)
2498 for (xmmreg = 0; xmmreg < 8; xmmreg++)
2501 if (buf[offset] != 0x0f || buf[offset + 1] != 0x29
2502 || (buf[offset + 2] & 0x3f) != (xmmreg << 3 | 0x5))
2506 if ((buf[offset + 2] & 0xc0) == 0x40)
2512 else if ((buf[offset + 2] & 0xc0) == 0x80)
2522 if (offset - 4 != buf[3])
2525 return next_sal.
end;
2535 CORE_ADDR func_addr;
2539 CORE_ADDR post_prologue_pc
2546 if (post_prologue_pc
2551 return std::max (start_pc, post_prologue_pc);
2596 cache->
base = ((cache->
saved_sp - 8) & 0xfffffffffffffff0LL) - 8;
2644 *this_cache = cache;
2650 catch (
const gdb_exception_error &ex)
2652 if (ex.error != NOT_AVAILABLE_ERROR)
2667 return UNWIND_UNAVAILABLE;
2670 if (cache->
base == 0)
2671 return UNWIND_OUTERMOST;
2673 return UNWIND_NO_REASON;
2685 else if (cache->
base == 0)
2694static struct value *
2702 gdb_assert (
regnum >= 0);
2778 catch (
const gdb_exception_error &ex)
2780 if (ex.error != NOT_AVAILABLE_ERROR)
2784 *this_cache = cache;
2796 return UNWIND_UNAVAILABLE;
2798 return UNWIND_NO_REASON;
2803 void **this_cache,
struct frame_id *this_id)
2810 else if (cache->
base == 0)
2819static struct value *
2821 void **this_cache,
int regnum)
2914 void **this_prologue_cache,
bool override_p)
2934 if (!unwind_valid_p)
2947 void **this_prologue_cache)
2956 void **this_prologue_cache)
2974 *this_cache = cache;
2994 catch (
const gdb_exception_error &ex)
2996 if (ex.error != NOT_AVAILABLE_ERROR)
3011 return UNWIND_UNAVAILABLE;
3013 return UNWIND_NO_REASON;
3032 "amd64 epilogue override",
3067 return sp & -(CORE_ADDR)16;
3077 int regnum,
const void *fpregs,
size_t len)
3094 int regnum,
void *fpregs,
size_t len)
3127 if (jb_pc_offset == -1)
3166 const struct target_desc *tdesc = info.target_desc;
3167 static const char *
const stap_integer_prefixes[] = {
"$", NULL };
3168 static const char *
const stap_register_prefixes[] = {
"%", NULL };
3180 tdesc = default_tdesc;
3181 tdep->
tdesc = tdesc;
3390 [2][2][2][2][2] = {};
3393 tdesc = &amd64_tdescs[(xcr0 & X86_XSTATE_AVX) ? 1 : 0]
3394 [(xcr0 & X86_XSTATE_MPX) ? 1 : 0]
3395 [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0]
3396 [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]
3441 const gdb_byte *regs = (
const gdb_byte *) fxsave;
3464 const gdb_byte *regs = (
const gdb_byte *) xsave;
3472 if (!(clear_bv & X86_XSTATE_X87))
3493 gdb_byte *regs = (gdb_byte *) fxsave;
3510 void *xsave,
int gcore)
3514 gdb_byte *regs = (gdb_byte *) xsave;
void register_amd64_ravenscar_ops(struct gdbarch *gdbarch)
static int amd64_epilogue_frame_sniffer_1(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache, bool override_p)
static int amd64_insn_is_jump(struct gdbarch *gdbarch, CORE_ADDR addr)
static int amd64_ret_p(const struct amd64_insn *details)
static int amd64_epilogue_override_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
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)
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 struct frame_unwind amd64_epilogue_override_frame_unwind
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 enum return_value_convention amd64_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, struct value **read_value, const gdb_byte *writebuf)
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 struct amd64_frame_cache * amd64_frame_cache(frame_info_ptr this_frame, void **this_cache)
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)
void amd64_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_copy_insn_closure *dsc_, CORE_ADDR from, CORE_ADDR to, struct regcache *regs, bool completed_p)
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 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_return_value_as_value(struct gdbarch *gdbarch, gdbarch_return_value_as_value_ftype *return_value_as_value)
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_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
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
unsigned type_align(struct type *type)
struct type * check_typedef(struct type *type)
#define TYPE_IS_REFERENCE(t)
#define TYPE_HAS_DYNAMIC_LENGTH(t)
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)
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)
CORE_ADDR regcache_read_pc(struct regcache *regcache)
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_write_pc(struct regcache *regcache, CORE_ADDR pc)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
static const char *const stap_register_indirection_prefixes[]
static const char *const stap_register_indirection_suffixes[]
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
const char * producer() const
LONGEST loc_bitpos() const
unsigned int bitsize() 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
unsigned int num_fields() const
struct gdbarch * arch() const
static struct value * allocate(struct type *type)
void set_lval(lval_type val)
void mark_bytes_unavailable(LONGEST offset, ULONGEST length)
gdb::array_view< const gdb_byte > contents()
gdb::array_view< gdb_byte > contents_raw()
struct type * type() 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)
static bool compunit_epilogue_unwind_valid(struct compunit_symtab *cust)
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 value * value_at_non_lval(struct type *type, CORE_ADDR addr)
#define VALUE_REGNUM(val)
bool x86_in_indirect_branch_thunk(CORE_ADDR pc, const char *const *register_names, int lo, int hi)