21 #include "opcode/i386.h"
73 "eax",
"ecx",
"edx",
"ebx",
74 "esp",
"ebp",
"esi",
"edi",
75 "eip",
"eflags",
"cs",
"ss",
76 "ds",
"es",
"fs",
"gs",
77 "st0",
"st1",
"st2",
"st3",
78 "st4",
"st5",
"st6",
"st7",
79 "fctrl",
"fstat",
"ftag",
"fiseg",
80 "fioff",
"foseg",
"fooff",
"fop",
81 "xmm0",
"xmm1",
"xmm2",
"xmm3",
82 "xmm4",
"xmm5",
"xmm6",
"xmm7",
88 "zmm0",
"zmm1",
"zmm2",
"zmm3",
89 "zmm4",
"zmm5",
"zmm6",
"zmm7"
94 "zmm0h",
"zmm1h",
"zmm2h",
"zmm3h",
95 "zmm4h",
"zmm5h",
"zmm6h",
"zmm7h"
100 "k0",
"k1",
"k2",
"k3",
101 "k4",
"k5",
"k6",
"k7"
106 "ymm0",
"ymm1",
"ymm2",
"ymm3",
107 "ymm4",
"ymm5",
"ymm6",
"ymm7",
112 "ymm0h",
"ymm1h",
"ymm2h",
"ymm3h",
113 "ymm4h",
"ymm5h",
"ymm6h",
"ymm7h",
118 "bnd0raw",
"bnd1raw",
"bnd2raw",
"bnd3raw",
"bndcfgu",
"bndstatus"
125 "bnd0",
"bnd1",
"bnd2",
"bnd3"
132 "mm0",
"mm1",
"mm2",
"mm3",
133 "mm4",
"mm5",
"mm6",
"mm7"
140 "al",
"cl",
"dl",
"bl",
141 "ah",
"ch",
"dh",
"bh"
148 "ax",
"cx",
"dx",
"bx",
218 if (zmm0h_regnum < 0)
257 if (ymm0h_regnum < 0)
285 if (ymm16h_regnum < 0)
298 if (ymm16_regnum < 0)
328 if (num_xmm_regs == 0)
343 if (num_xmm_avx512_regs == 0)
469 if (reg >= 0 && reg <= 7)
479 else if (reg >= 12 && reg <= 19)
484 else if (reg >= 21 && reg <= 28)
495 else if (reg >= 29 && reg <= 36)
518 if (reg >= 0 && reg <= 9)
523 else if (reg >= 11 && reg <= 18)
528 else if (reg >= 21 && reg <= 36)
580 static gdb_byte break_insn[] = { 0xcc };
582 *len =
sizeof (break_insn);
603 case DATA_PREFIX_OPCODE:
604 case ADDR_PREFIX_OPCODE:
605 case CS_PREFIX_OPCODE:
606 case DS_PREFIX_OPCODE:
607 case ES_PREFIX_OPCODE:
608 case FS_PREFIX_OPCODE:
609 case GS_PREFIX_OPCODE:
610 case SS_PREFIX_OPCODE:
611 case LOCK_PREFIX_OPCODE:
612 case REPE_PREFIX_OPCODE:
613 case REPNE_PREFIX_OPCODE:
634 if ((insn[1] & 0x38) == 0x20)
638 if ((insn[1] & 0x38) == 0x28)
671 if ((insn[1] & 0x38) == 0x10)
675 if ((insn[1] & 0x38) == 0x18)
719 if ((insn[0] == 0xcd && insn[1] == 0x80)
721 || (insn[0] == 0x0f && insn[1] == 0x34)
723 || (insn[0] == 0x0f && insn[1] == 0x05))
793 insn[syscall_length] = NOP_OPCODE;
833 "displaced: fixup (%s, %s), "
834 "insn = 0x%02x 0x%02x ...\n",
885 && orig_eip != to + (insn - insn_start) + insn_len
890 && orig_eip != to + (insn - insn_start) + insn_len + 1)
894 "displaced: syscall changed %%eip; "
899 ULONGEST eip = (orig_eip - insn_offset) & 0xffffffffUL;
910 "relocated %%eip from %s to %s\n",
932 retaddr = (retaddr - insn_offset) & 0xffffffffUL;
937 "displaced: relocated return addr at %s to %s\n",
956 int offset = 0, rel32, newrel;
974 unsigned int ret_addr;
977 ret_addr = oldloc + insn_length;
988 newrel = (oldloc - *
to) + rel32;
993 "Adjusted insn rel32=%s at %s to"
1005 if (insn[0] == 0xe9)
1008 else if (insn[0] == 0x0f && (insn[1] & 0xf0) == 0x80)
1014 newrel = (oldloc - *
to) + rel32;
1018 "Adjusted insn rel32=%s at %s to"
1019 " rel32=%s at %s\n",
1030 #ifdef I386_REGNO_TO_SYMMETRY
1031 #error "The Sequent Symmetry is no longer supported."
1040 #define I386_NUM_SAVED_REGS I386_NUM_GREGS
1135 delta += data16 + 2;
1162 static gdb_byte proto1[3] = { 0x87, 0x04, 0x24 };
1163 static gdb_byte proto2[4] = { 0x87, 0x44, 0x24, 0x00 };
1167 if (current_pc <= pc)
1179 if (memcmp (buf, proto1, 3) != 0 && memcmp (buf, proto2, 4) != 0)
1182 if (current_pc == pc)
1188 if (current_pc == pc + 1)
1194 if (buf[1] == proto1[1])
1220 if (op == 0x68 || op == 0x6a)
1234 if (buf[0] == 0xe8 && buf[6] == 0xc4 && buf[7] == 0x4)
1235 pc += delta +
sizeof (buf);
1276 static int regnums[8] = {
1292 if (buf[0] == 0x8d && buf[2] == 0x24 && buf[3] == 0x4)
1295 if ((buf[1] & 0xc7) != 0x44)
1299 reg = (buf[1] >> 3) & 7;
1306 if ((buf[0] & 0xf8) != 0x50)
1313 if (buf[1] != 0x8d || buf[3] != 0x24 || buf[4] != 0x8)
1317 if ((buf[2] & 0xc7) != 0x44)
1322 if (reg != ((buf[2] >> 3) & 7))
1329 if (reg == 4 || reg == 5)
1333 if (buf[offset + 1] != 0xe4
1334 || (buf[offset] != 0x81 && buf[offset] != 0x83))
1338 offset += buf[
offset] == 0x81 ? 6 : 3;
1342 if (buf[offset] != 0xff
1343 || buf[offset + 2] != 0xfc
1344 || (buf[offset + 1] & 0xf8) != 0x70)
1349 if (reg != (buf[offset + 1] & 7))
1352 if (current_pc > pc + offset_and)
1355 return min (pc + offset + 3, current_pc);
1359 #define I386_MAX_MATCHED_INSN_LEN 6
1379 if ((op & pattern.
mask[0]) == pattern.
insn[0])
1382 int insn_matched = 1;
1391 for (i = 1; i < pattern.
len; i++)
1393 if ((buf[i - 1] & pattern.
mask[i]) != pattern.
insn[i])
1396 return insn_matched;
1410 for (pattern = insn_patterns; pattern->
len > 0; pattern++)
1434 ix = insn - insn_patterns;
1435 for (i = ix - 1; i >= 0; i--)
1437 current_pc -= insn_patterns[i].
len;
1443 current_pc = pc + insn->
len;
1444 for (insn = insn_patterns + ix + 1; insn->
len > 0; insn++)
1449 current_pc += insn->
len;
1469 { 2, { 0xb0, 0x00 }, { 0xfa, 0x00 } },
1471 { 2, { 0xb2, 0x00 }, { 0xfb, 0x00 } },
1473 { 5, { 0xb8 }, { 0xfe } },
1475 { 5, { 0xba }, { 0xff } },
1484 { 5, { 0xa1 }, { 0xff } },
1486 { 6, { 0x89, 0x05 }, {0xff, 0xf7 } },
1488 { 6, { 0x89, 0x15 }, {0xff, 0xff } },
1496 { 2, { 0x29, 0xc0 }, { 0xfd, 0xff } },
1498 { 2, { 0x29, 0xc9 }, { 0xfd, 0xff } },
1500 { 2, { 0x29, 0xd2 }, { 0xfd, 0xff } },
1502 { 2, { 0x31, 0xc0 }, { 0xfd, 0xff } },
1504 { 2, { 0x31, 0xc9 }, { 0xfd, 0xff } },
1506 { 2, { 0x31, 0xd2 }, { 0xfd, 0xff } },
1543 else if (op == 0x8b)
1602 while (pc + skip < limit)
1612 if (limit <= pc + skip)
1689 else if (op == 0x81)
1700 else if (op == 0x8d)
1715 else if (op == 0xc8)
1739 for (i = 0; i < 8 && pc < current_pc; i++)
1743 if (op < 0x50 || op > 0x57)
1822 if (post_prologue_pc
1826 return max (start_pc, post_prologue_pc);
1849 for (i = 0; i < 6; i++)
1854 if (pic_pat[i] != op)
1870 else if (op == 0x9d)
1880 if (delta > 0 && op == 0x81
1920 call_dest = call_dest & 0xffffffffU;
1968 if (cache->
base == 0)
1998 cache->
base = ((cache->
saved_sp - 4) & 0xfffffff0) - 4;
2004 else if (cache->
pc != 0
2056 *this_cache = cache;
2080 else if (cache->
base == 0)
2098 return UNWIND_UNAVAILABLE;
2101 if (cache->
base == 0)
2102 return UNWIND_OUTERMOST;
2104 return UNWIND_NO_REASON;
2107 static struct value *
2160 if (regnum < I386_NUM_SAVED_REGS && cache->
saved_regs[regnum] != -1)
2207 void **this_prologue_cache)
2226 *this_cache = cache;
2260 return UNWIND_UNAVAILABLE;
2262 return UNWIND_NO_REASON;
2279 static struct value *
2281 void **this_cache,
int regnum)
2312 { 5, { 0xb8 }, { 0xfe } },
2315 { 5, { 0xe9 }, { 0xff } },
2325 { 5, { 0x68 }, { 0xff } },
2328 { 5, { 0xe9 }, { 0xff } },
2445 *this_cache = cache;
2457 return UNWIND_UNAVAILABLE;
2459 return UNWIND_NO_REASON;
2478 static struct value *
2480 void **this_cache,
int regnum)
2491 void **this_prologue_cache)
2542 i386_frame_base_address
2583 if (jb_pc_offset == -1)
2660 for (write_pass = 0; write_pass < 2; write_pass++)
2662 int args_space_used = 0;
2671 args_space_used += 4;
2677 for (i = 0; i < nargs; i++)
2684 args_space_used =
align_up (args_space_used, 16);
2695 args_space_used +=
align_up (len, 4);
2700 args_space =
align_up (args_space, 16);
2744 #define LOW_RETURN_REGNUM I386_EAX_REGNUM
2745 #define HIGH_RETURN_REGNUM I386_EDX_REGNUM
2762 warning (
_(
"Cannot find floating-point return value."));
2763 memset (valbuf, 0, len);
2779 if (len <= low_size)
2782 memcpy (valbuf, buf, len);
2784 else if (len <= (low_size + high_size))
2787 memcpy (valbuf, buf, low_size);
2789 memcpy (valbuf + low_size, buf, len - low_size);
2793 _(
"Cannot extract return value of %d bytes long."),
2815 warning (
_(
"Cannot set floating-point return value."));
2848 if (len <= low_size)
2850 else if (len <= (low_size + high_size))
2854 len - low_size, valbuf + low_size);
2858 _(
"Cannot store return value of %d bytes long."), len);
2903 return (len == 4 || len == 8 || len == 12);
2906 return (len == 1 || len == 2 || len == 4 || len == 8);
3001 static struct type *
3009 struct type *t, *bound_t;
3027 TYPE_NAME (t) =
"builtin_type_bound128";
3037 static struct type *
3048 union __gdb_builtin_type_vec512i
3050 int128_t uint128[4];
3051 int64_t v4_int64[8];
3052 int32_t v8_int32[16];
3053 int16_t v16_int16[32];
3054 int8_t v32_int8[64];
3055 double v4_double[8];
3090 static struct type *
3101 union __gdb_builtin_type_vec256i
3103 int128_t uint128[2];
3104 int64_t v2_int64[4];
3105 int32_t v4_int32[8];
3106 int16_t v8_int16[16];
3107 int8_t v16_int8[32];
3108 double v2_double[4];
3141 static struct type *
3152 union __gdb_builtin_type_vec64i
3155 int32_t v2_int32[2];
3156 int16_t v4_int16[4];
3227 tos = (fstat >> 11) & 0x7;
3228 fpreg = (mmxreg + tos) % 8;
3241 struct value *result_value)
3282 memcpy (buf, &lower, size);
3283 memcpy (buf + size, &upper, size);
3297 memcpy (buf, raw_buf, 8);
3312 memcpy (buf, raw_buf, 16);
3321 memcpy (buf + 16, raw_buf, 16);
3333 memcpy (buf, raw_buf, 16);
3343 memcpy (buf + 16, raw_buf, 16);
3353 memcpy (buf + 32, raw_buf, 32);
3366 memcpy (buf, raw_buf, 16);
3374 memcpy (buf + 16, raw_buf, 16);
3386 memcpy (buf, raw_buf, 16);
3394 memcpy (buf + 16, raw_buf, 16);
3406 memcpy (buf, raw_buf, 2);
3421 else if (gpnum >= 4)
3422 memcpy (buf, raw_buf + 1, 1);
3424 memcpy (buf, raw_buf, 1);
3431 static struct value *
3436 struct value *result;
3487 memcpy (raw_buf, &lower, 8);
3488 memcpy (raw_buf + 8, &upper, 8);
3569 memcpy (raw_buf, buf, 2);
3584 memcpy (raw_buf + 1, buf, 1);
3586 memcpy (raw_buf, buf, 1);
3608 static int next_regnum[] =
3619 if (regnum >= 0 && regnum <
sizeof (next_regnum) /
sizeof (next_regnum[0]))
3620 return next_regnum[
regnum];
3639 if (len > 4 && len % 4 == 0)
3641 int last_regnum =
regnum;
3649 if (last_regnum != -1)
3662 int *optimizedp,
int *unavailablep)
3669 optimizedp, unavailablep);
3682 to, optimizedp, unavailablep))
3690 *optimizedp = *unavailablep = 0;
3731 int regnum,
const void *gregs,
size_t len)
3742 if ((regnum == i || regnum == -1)
3767 if ((regnum == i || regnum == -1)
3779 int regnum,
const void *fpregs,
size_t len)
3857 unsigned long indirect =
3885 return (name && strcmp (
"_sigtramp", name) == 0);
3902 return print_insn_i386 (pc, info);
3924 return (name && (strcmp (
"_sigreturn", name) == 0
3925 || strcmp (
"sigvechandler", name) == 0));
3954 || (isdigit (*s) && s[1] ==
'(' && s[2] ==
'%')
3955 || (*s ==
'(' && s[1] ==
'%')
3956 || (*s ==
'%' && isalpha (s[1])));
3971 const char *s = p->
arg;
3973 if (isdigit (*s) || *s ==
'-' || *s ==
'+')
3977 long displacements[3];
3993 if (!isdigit ((
unsigned char) *s))
3996 displacements[0] = strtol (s, &endp, 10);
3999 if (*s !=
'+' && *s !=
'-')
4014 if (!isdigit ((
unsigned char) *s))
4017 displacements[1] = strtol (s, &endp, 10);
4020 if (*s !=
'+' && *s !=
'-')
4035 if (!isdigit ((
unsigned char) *s))
4038 displacements[2] = strtol (s, &endp, 10);
4041 if (*s !=
'(' || s[1] !=
'%')
4047 while (isalnum (*s))
4053 len = s - start - 1;
4054 regname = alloca (len + 1);
4056 strncpy (regname, start, len);
4057 regname[
len] =
'\0';
4060 error (
_(
"Invalid register name `%s' on expression `%s'."),
4063 for (i = 0; i < 3; i++)
4117 const char *s = p->
arg;
4119 if (isdigit (*s) || *s ==
'(' || *s ==
'-' || *s ==
'+')
4121 int offset_minus = 0;
4130 struct stoken base_token, index_token;
4140 if (offset_minus && !isdigit (*s))
4147 offset = strtol (s, &endp, 10);
4151 if (*s !=
'(' || s[1] !=
'%')
4157 while (isalnum (*s))
4160 if (*s !=
',' || s[1] !=
'%')
4163 len_base = s - start;
4164 base = alloca (len_base + 1);
4165 strncpy (base, start, len_base);
4166 base[len_base] =
'\0';
4169 error (
_(
"Invalid register name `%s' on expression `%s'."),
4175 while (isalnum (*s))
4178 len_index = s - start;
4179 index = alloca (len_index + 1);
4180 strncpy (index, start, len_index);
4181 index[len_index] =
'\0';
4184 error (
_(
"Invalid register name `%s' on expression `%s'."),
4187 if (*s !=
',' && *s !=
')')
4203 size = strtol (s, &endp, 10);
4224 base_token.
ptr = base;
4225 base_token.
length = len_base;
4233 index_token.
ptr = index;
4234 index_token.
length = len_index;
4279 THREE_ARG_DISPLACEMENT,
4284 current_state = TRIPLET;
4294 while (current_state != DONE)
4296 switch (current_state)
4303 case THREE_ARG_DISPLACEMENT:
4324 return "(x86_64|i.86)";
4334 static const char *
const stap_integer_prefixes[] = {
"$", NULL };
4335 static const char *
const stap_register_prefixes[] = {
"%", NULL };
4336 static const char *
const stap_register_indirection_prefixes[] = {
"(",
4338 static const char *
const stap_register_indirection_suffixes[] = {
")",
4348 stap_register_indirection_prefixes);
4350 stap_register_indirection_suffixes);
4441 int fp_regnum_p, mmx_regnum_p, xmm_regnum_p, mxcsr_regnum_p,
4442 ymm_regnum_p, ymmh_regnum_p, ymm_avx512_regnum_p, ymmh_avx512_regnum_p,
4443 bndr_regnum_p, bnd_regnum_p, k_regnum_p, zmm_regnum_p, zmmh_regnum_p,
4444 zmm_avx512_regnum_p, mpx_ctrl_regnum_p, xmm_avx512_regnum_p,
4445 avx512_p, avx_p, sse_p;
4459 if (group == i386_mmx_reggroup)
4460 return mmx_regnum_p;
4465 if (group == i386_sse_reggroup)
4466 return xmm_regnum_p || xmm_avx512_regnum_p || mxcsr_regnum_p;
4480 return (mmx_regnum_p
4481 || (zmm_regnum_p && avx512_p)
4482 || ((ymm_regnum_p || ymm_avx512_regnum_p) && avx_p)
4483 || ((xmm_regnum_p || xmm_avx512_regnum_p) && sse_p)
4497 && (((xmm_regnum_p || xmm_avx512_regnum_p) && !sse_p)
4498 || ((ymm_regnum_p || ymm_avx512_regnum_p) && !avx_p)
4500 || ymmh_avx512_regnum_p
4507 return bnd_regnum_p;
4517 return mpx_ctrl_regnum_p;
4520 return (!fp_regnum_p
4524 && !xmm_avx512_regnum_p
4527 && !ymm_avx512_regnum_p
4528 && !ymmh_avx512_regnum_p
4531 && !mpx_ctrl_regnum_p
4551 #define PREFIX_REPZ 0x01
4552 #define PREFIX_REPNZ 0x02
4553 #define PREFIX_LOCK 0x04
4554 #define PREFIX_DATA 0x08
4555 #define PREFIX_ADDR 0x10
4605 struct gdbarch *gdbarch = irp->
gdbarch;
4624 struct gdbarch *gdbarch = irp->
gdbarch;
4637 uint8_t base = irp->
rm;
4645 scale = (byte >> 6) & 3;
4646 index = ((byte >> 3) & 7) | irp->
rex_x;
4654 if ((base & 7) == 5)
4669 *addr = (int8_t) buf[0];
4687 if (irp->
aflag == 2)
4692 *addr = (uint32_t) (offset64 + *addr);
4694 if (havesib && (index != 4 || scale != 0))
4698 if (irp->
aflag == 2)
4699 *addr += offset64 << scale;
4701 *addr = (uint32_t) (*addr + (offset64 << scale));
4708 *addr = (uint32_t) *addr;
4731 *addr = (int8_t) buf[0];
4747 *addr = (uint32_t) (*addr + offset64);
4751 *addr = (uint32_t) (*addr + offset64);
4757 *addr = (uint32_t) (*addr + offset64);
4761 *addr = (uint32_t) (*addr + offset64);
4767 *addr = (uint32_t) (*addr + offset64);
4771 *addr = (uint32_t) (*addr + offset64);
4777 *addr = (uint32_t) (*addr + offset64);
4781 *addr = (uint32_t) (*addr + offset64);
4787 *addr = (uint32_t) (*addr + offset64);
4793 *addr = (uint32_t) (*addr + offset64);
4799 *addr = (uint32_t) (*addr + offset64);
4805 *addr = (uint32_t) (*addr + offset64);
4822 struct gdbarch *gdbarch = irp->
gdbarch;
4833 Process record ignores the memory change of instruction at address %s\n\
4834 because it can't get the value of the segment register.\n\
4835 Do you want to stop the program?"),
4876 #define I386_SAVE_FPU_REGS 0xfffd
4877 #define I386_SAVE_FPU_ENV 0xfffe
4878 #define I386_SAVE_FPU_ENV_REG_STACK 0xffff
4946 #define I386_RECORD_FULL_ARCH_LIST_ADD_REG(regnum) \
4947 record_full_arch_list_add_reg (ir.regcache, ir.regmap[(regnum)])
4967 ir.
addr = input_addr;
4989 case REPE_PREFIX_OPCODE:
4992 case REPNE_PREFIX_OPCODE:
4995 case LOCK_PREFIX_OPCODE:
4998 case CS_PREFIX_OPCODE:
5001 case SS_PREFIX_OPCODE:
5004 case DS_PREFIX_OPCODE:
5007 case ES_PREFIX_OPCODE:
5010 case FS_PREFIX_OPCODE:
5013 case GS_PREFIX_OPCODE:
5016 case DATA_PREFIX_OPCODE:
5019 case ADDR_PREFIX_OPCODE:
5041 rex_w = (opcode8 >> 3) & 1;
5042 rex_r = (opcode8 & 0x4) << 1;
5043 ir.
rex_x = (opcode8 & 0x2) << 2;
5044 ir.
rex_b = (opcode8 & 0x1) << 3;
5070 opcode = (uint32_t) opcode8;
5078 opcode = (uint32_t) opcode8 | 0x0f00;
5130 if (((opcode >> 3) & 7) !=
OP_CMPL)
5132 if ((opcode & 1) == 0)
5137 switch ((opcode >> 1) & 3)
5180 if ((opcode & 1) == 0)
5224 if ((opcode & 1) == 0)
5231 if (ir.
mod != 3 && ir.
reg == 0)
5267 opcode = opcode << 8 | ir.
modrm;
5277 if (ir.
reg >= 2 && opcode == 0xfe)
5280 opcode = opcode << 8 | ir.
modrm;
5287 if ((opcode & 1) == 0)
5330 opcode = opcode << 8 | ir.
modrm;
5360 else if (opcode == 0x6b)
5371 if ((opcode & 1) == 0)
5400 if ((opcode & 1) == 0)
5429 opcode = opcode << 8 | ir.
modrm;
5593 if ((opcode & 1) == 0)
5603 if (opcode == 0xc6 || opcode == 0xc7)
5610 if (opcode == 0xc6 || opcode == 0xc7)
5620 if ((opcode & 1) == 0)
5638 opcode = opcode << 8 | ir.
modrm;
5674 opcode = opcode << 8 | ir.
modrm;
5697 opcode = opcode << 8 | ir.
modrm;
5724 Process record ignores the memory change of instruction at address %s\n\
5725 because it can't get the value of the segment register.\n\
5726 Do you want to stop the program?"),
5735 if ((opcode & 1) == 0)
5774 ? ((opcode & 0x7) | ir.
rex_b)
5775 : ((opcode & 0x7) & 0x3));
5802 if ((opcode & 1) == 0)
5845 opcode = opcode << 8 | ir.
modrm;
5877 if ((opcode & 1) == 0)
5883 if (ir.
mod != 3 && (opcode == 0xd2 || opcode == 0xd3))
5926 ir.
reg |= ((opcode & 7) << 3);
6006 switch (ir.
reg >> 4)
6025 switch (ir.
reg >> 4)
6030 if (3 == (ir.
reg & 7))
6041 if ((3 == (ir.
reg & 7))
6042 || (5 == (ir.
reg & 7))
6043 || (7 == (ir.
reg & 7)))
6054 if (3 == (ir.
reg & 7))
6063 if ((3 <= (ir.
reg & 7)) && (6 <= (ir.
reg & 7)))
6150 opcode = opcode << 8 | ir.
modrm;
6165 if (0x0c == (ir.
modrm >> 4))
6167 if ((ir.
modrm & 0x0f) <= 7)
6180 if ((ir.
modrm & 0x0f) - 0x08)
6184 ((ir.
modrm & 0x0f) - 0x08)))
6237 if (0xe9 == ir.
modrm)
6242 else if ((0x0c == ir.
modrm >> 4) || (0x0d == ir.
modrm >> 4))
6247 if (((ir.
modrm & 0x0f) > 0) && ((ir.
modrm & 0x0f) <= 7))
6254 else if ((ir.
modrm & 0x0f) - 0x08)
6258 ((ir.
modrm & 0x0f) - 0x08)))
6264 if (0xe3 == ir.
modrm)
6269 else if ((0x0c == ir.
modrm >> 4) || (0x0d == ir.
modrm >> 4))
6274 if (((ir.
modrm & 0x0f) > 0) && ((ir.
modrm & 0x0f) <= 7))
6281 else if ((ir.
modrm & 0x0f) - 0x08)
6285 ((ir.
modrm & 0x0f) - 0x08)))
6291 if ((0x0c == ir.
modrm >> 4)
6292 || (0x0d == ir.
modrm >> 4)
6293 || (0x0f == ir.
modrm >> 4))
6295 if ((ir.
modrm & 0x0f) <= 7)
6306 ((ir.
modrm & 0x0f) - 0x08)))
6312 if (0x0c == ir.
modrm >> 4)
6318 else if ((0x0d == ir.
modrm >> 4) || (0x0e == ir.
modrm >> 4))
6320 if ((ir.
modrm & 0x0f) <= 7)
6336 if ((0x0c == ir.
modrm >> 4)
6337 || (0x0e == ir.
modrm >> 4)
6338 || (0x0f == ir.
modrm >> 4)
6339 || (0xd9 == ir.
modrm))
6346 if (0xe0 == ir.
modrm)
6352 else if ((0x0f == ir.
modrm >> 4) || (0x0e == ir.
modrm >> 4))
6375 if ((opcode & 1) == 0)
6389 if (ir.
aflag && (es != ds))
6398 Process record ignores the memory change of instruction at address %s\n\
6399 because it can't get the value of the segment register.\n\
6400 Do you want to stop the program?"),
6415 if (opcode == 0xa4 || opcode == 0xa5)
6641 opcode = opcode << 8 | ir.
modrm;
6680 addr64 += ((int16_t) addr >> 4) << 4;
6683 addr64 += ((int32_t) addr >> 5) << 5;
6686 addr64 += ((int64_t) addr >> 6) << 6;
6731 opcode = (uint32_t) opcode8;
6752 if (interrupt != 0x80
6756 "instruction int 0x%02x.\n"),
6770 "instruction into.\n"));
6781 "instruction bound.\n"));
6817 "instruction wrmsr.\n"));
6824 "instruction rdmsr.\n"));
6845 "instruction sysenter.\n"));
6857 "instruction sysexit.\n"));
6868 "instruction syscall.\n"));
6880 "instruction sysret.\n"));
6894 "instruction hlt.\n"));
6924 opcode = opcode << 8 | ir.
modrm;
6942 opcode = opcode << 8 | ir.
modrm;
6953 Process record ignores the memory change of instruction at address %s\n\
6954 because it can't get the value of the segment register.\n\
6955 Do you want to stop the program?"),
6994 opcode = opcode << 8 | ir.
modrm;
7010 Process record ignores the memory change of instruction at address %s\n\
7011 because it can't get the value of the segment register.\n\
7012 Do you want to stop the program?"),
7052 else if (ir.
rm == 1)
7059 opcode = opcode << 8 | ir.
modrm;
7088 opcode = opcode << 8 | ir.
modrm;
7097 opcode = opcode << 8 | ir.
modrm;
7113 ? (ir.
reg | rex_r) : ir.
rm);
7136 if (ir.
mod == 3 && ir.
reg == 3)
7139 opcode = opcode << 8 | ir.
modrm;
7158 if ((ir.
modrm & 0xc0) != 0xc0)
7161 opcode = opcode << 8 | ir.
modrm;
7178 opcode = opcode << 8 | ir.
modrm;
7188 if ((ir.
modrm & 0xc0) != 0xc0 || ir.
reg == 4
7189 || ir.
reg == 5 || ir.
reg >= 8)
7192 opcode = opcode << 8 | ir.
modrm;
7250 goto no_support_3dnow_data;
7255 no_support_3dnow_data:
7256 opcode = (opcode << 8) | opcode8;
7337 opcode = (opcode << 8) | ir.
modrm;
7470 switch ((prefixes & ~PREFIX_ADDR))
7482 reswitch_prefix_add:
7493 opcode = (uint32_t) opcode8 | opcode << 8;
7494 goto reswitch_prefix_add;
7703 if ((opcode & 0xfffffffc) == 0x660f3a60)
7727 if (opcode == 0x0f13 || opcode == 0x660f13
7728 || opcode == 0x0f17 || opcode == 0x660f17)
7768 if (opcode == 0x0fe7)
8022 "at address %s.\n"),
8023 (
unsigned int) (opcode),
8032 0, 0, 0, 0, 0, 0, 0, 0,
8052 static struct ui_file *gdb_null = NULL;
8064 else if (jumplen == 0)
8089 *msg =
xstrprintf (
_(
"; instruction is only %d bytes long, "
8090 "need at least %d bytes for the jump"),
8109 const struct tdesc_feature *feature_sse, *feature_avx, *feature_mpx,
8111 int i, num_regs, valid_p;
8118 if (feature_core == NULL)
8184 if (!feature_avx512)
8200 else if (feature_sse)
8209 for (i = 0; i < num_regs; i++)
8217 for (; i < num_regs; i++)
8243 static struct gdbarch *
8247 struct gdbarch *gdbarch;
8435 tdep->
tdesc = tdesc;
8508 tdesc = tdep->
tdesc;
8529 mm0_regnum = ymm0_regnum;
8557 bnd0_regnum = mm0_regnum;
8570 tdep-> bnd0_regnum = -1;
8593 if (strcmp (bfd_get_target (abfd),
"coff-go32-exe") == 0
8594 || strcmp (bfd_get_target (abfd),
"coff-go32") == 0)
8620 #define MPX_BASE_MASK (~(ULONGEST) 0xfff)
8624 static unsigned long
8639 error (
_(
"BNDCFGU register invalid, read status %d."), regstatus);
8655 #define MPX_BD_MASK 0xfffffff00000ULL
8656 #define MPX_BT_MASK 0x0000000ffff8
8657 #define MPX_BD_MASK_32 0xfffff000
8658 #define MPX_BT_MASK_32 0x00000ffc
8668 CORE_ADDR mpx_bd_mask, bd_ptr_r_shift, bd_ptr_l_shift;
8669 CORE_ADDR bt_mask, bt_select_r_shift, bt_select_l_shift;
8680 bd_ptr_r_shift = 20;
8682 bt_select_r_shift = 3;
8683 bt_select_l_shift = 5;
8687 error (
_(
"operation not supported"));
8692 bd_ptr_r_shift = 12;
8694 bt_select_r_shift = 2;
8695 bt_select_l_shift = 4;
8699 offset1 = ((ptr & mpx_bd_mask) >> bd_ptr_r_shift) << bd_ptr_l_shift;
8700 bd_entry_addr = bd_base +
offset1;
8703 if ((bd_entry & 0x1) == 0)
8704 error (
_(
"Invalid bounds directory entry at %s."),
8709 bt_addr = bd_entry & ~bt_select_r_shift;
8710 offset2 = ((ptr & bt_mask) >> bt_select_r_shift) << bt_select_l_shift;
8712 return bt_addr + offset2;
8724 int bounds_in_map = ((~bt_entry[1] == 0 && bt_entry[0] == onecompl) ? 1 : 0);
8726 if (bounds_in_map == 1)
8746 size = ( (~(int64_t) bt_entry[1]) - (int64_t) bt_entry[0]);
8748 size = ( ~((int32_t) bt_entry[1]) - (int32_t) bt_entry[0]);
8754 size = (size > -1 ? size + 1 :
size);
8780 "supported on this target.\n"));
8795 memset (bt_entry, 0,
sizeof (bt_entry));
8797 for (i = 0; i < 4; i++)
8799 + i * data_ptr_type->
length,
8814 const char *input = args;
8821 error (
_(
"Intel(R) Memory Protection Extensions not supported\
8825 error (
_(
"Pointer value expected."));
8829 if (input[0] ==
',')
8831 if (input[0] ==
'\0')
8832 error (
_(
"wrong number of arguments: missing lower and upper bound."));
8835 if (input[0] ==
',')
8837 if (input[0] ==
'\0')
8838 error (
_(
"Wrong number of arguments; Missing upper bound."));
8843 for (i = 0; i < 2; i++)
8845 + i * data_ptr_type->
length,
8847 bt_entry[0] = (uint64_t) lower;
8848 bt_entry[1] = ~(uint64_t) upper;
8850 for (i = 0; i < 2; i++)
8852 data_ptr_type->
length, byte_order,
8885 Set the disassembly flavor."),
_(
"\
8886 Show the disassembly flavor."),
_(
"\
8887 The valid values are \"att\" and \"intel\", and the default value is \"att\"."),
8896 Set the convention for returning small structs."),
_(
"\
8897 Show the convention for returning small structs."),
_(
"\
8898 Valid values are \"default\", \"pcc\" and \"reg\", and the default value\n\
8907 Set Intel(R) Memory Protection Extensions specific variables."),
8908 &mpx_set_cmdlist,
"set mpx ",
8914 Show Intel(R) Memory Protection Extensions specific variables."),
8915 &mpx_show_cmdlist,
"show mpx ",
8921 "Show the memory bounds for a given array/pointer storage\
8922 in the bound table.",
8928 "Set the memory bounds for a given array/pointer storage\
8929 in the bound table.",
int i386_zmm_regnum_p(struct gdbarch *gdbarch, int regnum)
void reggroup_add(struct gdbarch *gdbarch, struct reggroup *group)
int i386_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
struct gdbarch * target_gdbarch(void)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
#define X86_XSTATE_AVX_MASK
void i387_collect_fsave(const struct regcache *regcache, int regnum, void *fsave)
void set_gdbarch_value_to_register(struct gdbarch *gdbarch, gdbarch_value_to_register_ftype value_to_register)
static int i386_record_lea_modrm(struct i386_record_s *irp)
void target_terminal_ours(void)
void i386_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
static CORE_ADDR i386_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
static void initialize_tdesc_i386_mmx(void)
char * hex_string(LONGEST num)
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 void i386_store_return_value(struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static void i386_go32_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
void set_gdbarch_ps_regnum(struct gdbarch *gdbarch, int ps_regnum)
static int i386_svr4_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static struct i386_frame_cache * i386_frame_cache(struct frame_info *this_frame, void **this_cache)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
#define I387_FOP_REGNUM(tdep)
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype get_longjmp_target)
static struct i386_insn * i386_match_insn(CORE_ADDR pc, struct i386_insn *insn_patterns)
struct type * i386_bnd_type
#define target_get_min_fast_tracepoint_insn_len()
void set_tdesc_pseudo_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *pseudo_name)
static int i386_ymmh_regnum_p(struct gdbarch *gdbarch, int regnum)
CORE_ADDR get_frame_pc(struct frame_info *frame)
#define I387_NUM_MPX_CTRL_REGS
CORE_ADDR saved_regs[I386_NUM_SAVED_REGS]
static const char *const valid_conventions[]
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
#define MSYMBOL_LINKAGE_NAME(symbol)
#define X86_XSTATE_SSE_MASK
int i386_k_regnum_p(struct gdbarch *gdbarch, int regnum)
const char ** mpx_register_names
static int i386_stap_parse_special_token_three_arg_disp(struct gdbarch *gdbarch, struct stap_parse_info *p)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
void displaced_step_dump_bytes(struct ui_file *file, const gdb_byte *buf, size_t len)
#define I386_NUM_SAVED_REGS
static const char att_flavor[]
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
struct reggroup * reggroup_new(const char *name, enum reggroup_type type)
int i386_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR input_addr)
struct type * i386_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
static struct i386_frame_cache * i386_alloc_frame_cache(void)
#define I387_BND0R_REGNUM(tdep)
void set_gdbarch_stap_parse_special_token(struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype stap_parse_special_token)
static int i386_syscall_p(const gdb_byte *insn, int *lengthp)
int i386_dword_regnum_p(struct gdbarch *gdbarch, int regnum)
static const char default_struct_convention[]
const char ** ymm16h_register_names
int(* i386_intx80_record)(struct regcache *regcache)
static int i386_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
int i386_zmmh_regnum_p(struct gdbarch *gdbarch, int regnum)
void store_signed_integer(gdb_byte *, int, enum bfd_endian, LONGEST)
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
#define X86_XSTATE_MPX_MASK
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
struct value * frame_unwind_got_memory(struct frame_info *frame, int regnum, CORE_ADDR addr)
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
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)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
static int i386_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
void set_gdbarch_relocate_instruction(struct gdbarch *gdbarch, gdbarch_relocate_instruction_ftype relocate_instruction)
void warning(const char *fmt,...)
static const char * i386_zmmh_names[]
void set_gdbarch_gen_return_address(struct gdbarch *gdbarch, gdbarch_gen_return_address_ftype gen_return_address)
gdb_byte mask[I386_MAX_MATCHED_INSN_LEN]
void i387_supply_fxsave(struct regcache *regcache, int regnum, const void *fxsave)
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype stab_reg_to_regnum)
#define TYPE_NAME(thistype)
static void i386_extract_return_value(struct gdbarch *gdbarch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static const char * i386_zmm_names[]
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void set_gdbarch_sdb_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_sdb_reg_to_regnum_ftype sdb_reg_to_regnum)
char * plongest(LONGEST l)
void convert_typed_floating(const void *from, const struct type *from_type, void *to, const struct type *to_type)
void set_gdbarch_stap_register_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_prefixes)
void register_remote_support_xml(const char *xml)
static const char * i386_word_names[]
static int i386_svr4_sigtramp_p(struct frame_info *this_frame)
struct target_desc * tdesc_i386_mmx
struct ui_file * gdb_stdout
static unsigned long i386_mpx_bd_base(void)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
const struct regset i386_fpregset
struct frame_id frame_id_build_unavailable_stack(CORE_ADDR code_addr)
int(* i386_syscall_record)(struct regcache *regcache)
void internal_error(const char *file, int line, const char *fmt,...)
void frame_unwind_register(struct frame_info *frame, int regnum, gdb_byte *buf)
struct displaced_step_closure * i386_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
const char * tdesc_register_name(struct gdbarch *gdbarch, int regno)
unsigned int record_debug
static struct reggroup * i386_sse_reggroup
int i386_sigtramp_p(struct frame_info *this_frame)
#define I387_NUM_MPX_REGS
static CORE_ADDR i386_skip_noop(CORE_ADDR pc)
int i386_stap_parse_special_token(struct gdbarch *gdbarch, struct stap_parse_info *p)
void gdbarch_register_osabi_sniffer(enum bfd_architecture arch, enum bfd_flavour flavour, enum gdb_osabi(*sniffer_fn)(bfd *))
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype register_reggroup_p)
int i386_xmm_avx512_regnum_p(struct gdbarch *gdbarch, int regnum)
static int i386_print_insn(bfd_vma pc, struct disassemble_info *info)
#define I387_NUM_XMM_REGS(tdep)
#define I387_NUM_BND_REGS
#define I386_MAX_MATCHED_INSN_LEN
CORE_ADDR(* sigcontext_addr)(struct frame_info *)
static void initialize_tdesc_i386(void)
static const char pcc_struct_convention[]
static struct type * i386_ymm_type(struct gdbarch *gdbarch)
#define I386_AVX512_NUM_REGS
int i386_fp_regnum_p(struct gdbarch *gdbarch, int regnum)
int yquery(const char *ctlstr,...)
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 mark_value_bytes_unavailable(struct value *value, int offset, int length)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
static struct value * i386_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
struct reggroup *const restore_reggroup
void i387_supply_fsave(struct regcache *regcache, int regnum, const void *fsave)
void ax_reg(struct agent_expr *x, int reg)
int gdbarch_num_regs(struct gdbarch *gdbarch)
static void i386_value_to_register(struct frame_info *frame, int regnum, struct type *type, const gdb_byte *from)
#define I387_ST0_REGNUM(tdep)
struct reggroup *const all_reggroup
static struct i386_frame_cache * i386_epilogue_frame_cache(struct frame_info *this_frame, void **this_cache)
static int i386_mpx_ctrl_regnum_p(struct gdbarch *gdbarch, int regnum)
void gdbarch_free(struct gdbarch *arch)
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
void i386_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_closure *closure, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
void set_gdbarch_long_long_align_bit(struct gdbarch *gdbarch, int long_long_align_bit)
static void i386_add_reggroups(struct gdbarch *gdbarch)
void set_gdbarch_gnu_triplet_regexp(struct gdbarch *gdbarch, gdbarch_gnu_triplet_regexp_ftype gnu_triplet_regexp)
static int i386_fast_tracepoint_valid_at(struct gdbarch *gdbarch, CORE_ADDR addr, int *isize, char **msg)
static void initialize_tdesc_i386_avx512(void)
static int i386_ret_p(const gdb_byte *insn)
void tdesc_data_cleanup(void *data_untyped)
static void i386_init_reggroups(void)
#define TYPE_FIELD_TYPE(thistype, n)
void ui_out_field_fmt(struct ui_out *uiout, const char *fldname, const char *format,...)
struct value * allocate_value(struct type *type)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
struct regcache * get_current_regcache(void)
struct type * builtin_int32
void ui_out_text(struct ui_out *uiout, const char *string)
int i386_fpc_regnum_p(struct gdbarch *gdbarch, int regnum)
static const char * i386_k_names[]
#define I386_MAX_INSN_LEN
static enum unwind_stop_reason i386_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
static void i386_relocate_instruction(struct gdbarch *gdbarch, CORE_ADDR *to, CORE_ADDR oldloc)
#define FRAME_OBSTACK_ZALLOC(TYPE)
static int i386_mmx_regnum_p(struct gdbarch *gdbarch, int regnum)
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
static CORE_ADDR i386_analyze_struct_return(CORE_ADDR pc, CORE_ADDR current_pc, struct i386_frame_cache *cache)
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
struct value * frame_unwind_got_constant(struct frame_info *frame, int regnum, ULONGEST val)
int i386_xmm_regnum_p(struct gdbarch *gdbarch, int regnum)
void i387_value_to_register(struct frame_info *frame, int regnum, struct type *type, const gdb_byte *from)
ULONGEST read_code_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
static struct i386_frame_cache * i386_sigtramp_frame_cache(struct frame_info *this_frame, void **this_cache)
struct compunit_symtab * find_pc_compunit_symtab(CORE_ADDR pc)
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static int i386_match_pattern(CORE_ADDR pc, struct i386_insn pattern)
int i386_byte_regnum_p(struct gdbarch *gdbarch, int regnum)
int i386_ymm_regnum_p(struct gdbarch *gdbarch, int regnum)
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
void set_gdbarch_stap_integer_prefixes(struct gdbarch *gdbarch, const char *const *stap_integer_prefixes)
struct type * i386_zmm_type
int(* i386_sysenter_record)(struct regcache *regcache)
static int i386_absolute_call_p(const gdb_byte *insn)
struct parser_state pstate
struct reggroup *const float_reggroup
static const char * disassembly_flavor
static const char * i386_ymmh_names[]
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
static int i386_16_byte_align_p(struct type *type)
static const char * i386_mmx_names[]
struct cmd_list_element * setlist
static const char *const valid_flavors[]
static const char * i386_register_name(struct gdbarch *gdbarch, int regnum)
struct type * builtin_int128
void write_exp_elt_longcst(struct parser_state *ps, LONGEST expelt)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
void set_gdbarch_pseudo_register_read_value(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_value_ftype pseudo_register_read_value)
struct type * check_typedef(struct type *type)
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
ULONGEST gdbarch_max_insn_length(struct gdbarch *gdbarch)
int gdbarch_iterate_over_regset_sections_p(struct gdbarch *gdbarch)
static CORE_ADDR i386_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc)
#define CATCH(EXCEPTION, MASK)
struct reggroup *const general_reggroup
void i387_collect_fxsave(const struct regcache *regcache, int regnum, void *fxsave)
#define I387_FSTAT_REGNUM(tdep)
static int i386_jmp_p(const gdb_byte *insn)
void i386_svr4_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static int i386_bndr_regnum_p(struct gdbarch *gdbarch, int regnum)
static int i386_insn_is_jump(struct gdbarch *gdbarch, CORE_ADDR addr)
static const char reg_struct_convention[]
enum struct_return struct_return
static void initialize_tdesc_i386_avx(void)
int record_read_memory(struct gdbarch *gdbarch, CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void set_gdbarch_insn_is_ret(struct gdbarch *gdbarch, gdbarch_insn_is_ret_ftype insn_is_ret)
CORE_ADDR i386_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static int i386_epilogue_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
static CORE_ADDR i386_push_dummy_code(struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
static struct cmd_list_element * mpx_set_cmdlist
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
const char ** ymmh_register_names
struct reggroup *const system_reggroup
struct target_desc * tdesc_i386_avx
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
struct ui_file * ui_file_new(void)
struct target_desc * tdesc_i386_avx512
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
static CORE_ADDR i386_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)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
struct type * i387_ext_type
void target_terminal_inferior(void)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
#define I387_XMM0_REGNUM(tdep)
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
int gdb_print_insn(struct gdbarch *gdbarch, CORE_ADDR memaddr, struct ui_file *stream, int *branch_delay_insns)
struct cmd_list_element * showlist
const gdb_byte * value_contents_all(struct value *value)
struct type * builtin_int16
struct type * i387_ext_type(struct gdbarch *gdbarch)
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
struct target_desc * tdesc_i386
struct type * value_enclosing_type(struct value *value)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
#define I386_SAVE_FPU_ENV_REG_STACK
static const char * i386_gnu_triplet_regexp(struct gdbarch *gdbarch)
static CORE_ADDR i386_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct i386_frame_cache *cache)
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
static int i386_record_modrm(struct i386_record_s *irp)
static void i386_mpx_print_bounds(const CORE_ADDR bt_entry[4])
static struct type * i386_bnd_type(struct gdbarch *gdbarch)
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
#define VALUE_REGNUM(val)
struct type * init_vector_type(struct type *elt_type, int n)
static void i386_sigtramp_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
static int i386_dbx_reg_to_regnum(struct gdbarch *gdbarch, int reg)
static const char * i386_bnd_names[]
static int i386_absolute_jmp_p(const gdb_byte *insn)
static CORE_ADDR i386_follow_jump(struct gdbarch *gdbarch, CORE_ADDR pc)
void set_gdbarch_register_to_value(struct gdbarch *gdbarch, gdbarch_register_to_value_ftype register_to_value)
static struct reggroup * i386_mmx_reggroup
void read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
#define I387_FTAG_REGNUM(tdep)
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)
const void * register_reggroup_p
struct gdbarch * get_current_arch(void)
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
#define COMPUNIT_PRODUCER(cust)
struct type * tdesc_find_type(struct gdbarch *gdbarch, const char *id)
#define I387_YMM0_REGNUM(tdep)
static void show_mpx_cmd(char *args, int from_tty)
#define X86_XSTATE_MPX_AVX512_MASK
static const char * i386_register_names[]
void ax_simple(struct agent_expr *x, enum agent_op op)
#define HIGH_RETURN_REGNUM
static int startswith(const char *string, const char *pattern)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
void _initialize_i386_tdep(void)
const char ** zmmh_register_names
#define LOW_RETURN_REGNUM
static const char * struct_convention
static int i386_sigtramp_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
static void i386_mpx_info_bounds(char *args, int from_tty)
static int i386_mpx_enabled(void)
char * xstrprintf(const char *format,...)
#define I387_YMM16H_REGNUM(tdep)
static int i386_stack_tramp_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_cache)
#define I387_XMM16_REGNUM(tdep)
void printf_unfiltered(const char *format,...)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static enum unwind_stop_reason i386_sigtramp_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
void( iterate_over_regset_sections_cb)(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
void set_gdbarch_insn_is_jump(struct gdbarch *gdbarch, gdbarch_insn_is_jump_ftype insn_is_jump)
int i386_word_regnum_p(struct gdbarch *gdbarch, int regnum)
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
static int i386_call_p(const gdb_byte *insn)
struct reggroup *const vector_reggroup
static const char * i386_ymm_names[]
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
static int i386_stap_parse_special_token_triplet(struct gdbarch *gdbarch, struct stap_parse_info *p)
int i387_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
struct ui_file * gdb_stdlog
int record_full_memory_query
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
const char ** xmm_avx512_register_names
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
static int i386_get_longjmp_target(struct frame_info *frame, CORE_ADDR *pc)
LONGEST read_code_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
static void i386_epilogue_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
void put_frame_register(struct frame_info *frame, int regnum, const gdb_byte *buf)
int record_full_arch_list_add_mem(CORE_ADDR addr, int len)
static const struct frame_unwind i386_frame_unwind
const struct target_desc * target_desc
static gdb_byte * i386_skip_prefixes(gdb_byte *insn, size_t max_len)
struct value * parse_to_comma_and_eval(const char **expp)
#define I387_SIZEOF_FXSAVE
static CORE_ADDR i386_svr4_sigcontext_addr(struct frame_info *this_frame)
void set_gdbarch_push_dummy_code(struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype push_dummy_code)
#define I387_MM0_REGNUM(tdep)
static struct value * i386_pseudo_register_read_value(struct gdbarch *gdbarch, struct regcache *regcache, int regnum)
void write_exp_elt_opcode(struct parser_state *ps, enum exp_opcode expelt)
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
#define X86_XSTATE_X87_MASK
static void i386_frame_this_id(struct frame_info *this_frame, void **this_cache, struct frame_id *this_id)
const char * i386_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
static int i386_reg_struct_return_p(struct gdbarch *gdbarch, struct type *type)
static void append_insns(CORE_ADDR *to, ULONGEST len, const gdb_byte *buf)
struct regcache * regcache
static int i386_ymmh_avx512_regnum_p(struct gdbarch *gdbarch, int regnum)
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)
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
#define I386_SAVE_FPU_REGS
static int i386_mmx_regnum_to_fp_regnum(struct regcache *regcache, int regnum)
static enum gdb_osabi i386_coff_osabi_sniffer(bfd *abfd)
static struct type * i386_zmm_type(struct gdbarch *gdbarch)
void append_composite_type_field(struct type *t, char *name, struct type *field)
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
const struct floatformat * floatformats_i387_ext[BFD_ENDIAN_UNKNOWN]
int(* sigtramp_p)(struct frame_info *)
ULONGEST align_up(ULONGEST v, int n)
gdb_byte insn[I386_MAX_MATCHED_INSN_LEN]
#define X86_XSTATE_AVX512_MASK
#define TYPE_TARGET_TYPE(thistype)
struct type * i386_ymm_type
struct type * builtin_double
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
static void i386_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
void set_gdbarch_convert_register_p(struct gdbarch *gdbarch, gdbarch_convert_register_p_ftype convert_register_p)
static void set_mpx_cmd(char *args, int from_tty)
int deprecated_frame_register_read(struct frame_info *frame, int regnum, gdb_byte *myaddr)
static struct value * i386_sigtramp_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
int frame_relative_level(struct frame_info *fi)
static void check(BOOL ok, const char *file, int line)
CORE_ADDR parse_and_eval_address(const char *exp)
#define TYPE_CODE(thistype)
static void i386_collect_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
struct type * i386_mmx_type
const int * record_regmap
struct value * frame_unwind_got_register(struct frame_info *frame, int regnum, int new_regnum)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
static CORE_ADDR i386_mpx_get_bt_entry(CORE_ADDR ptr, CORE_ADDR bd_base)
void set_gdbarch_fast_tracepoint_valid_at(struct gdbarch *gdbarch, gdbarch_fast_tracepoint_valid_at_ftype fast_tracepoint_valid_at)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static struct cmd_list_element * mpx_show_cmdlist
static int i386_insn_is_ret(struct gdbarch *gdbarch, CORE_ADDR addr)
struct type * builtin_data_ptr
struct minimal_symbol * minsym
int i386_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype stap_is_single_operand)
static CORE_ADDR i386_analyze_frame_setup(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR limit, struct i386_frame_cache *cache)
static void i386_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
static int i386_validate_tdesc_p(struct gdbarch_tdep *tdep, struct tdesc_arch_data *tdesc_data)
void i386_elf_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static int i386_match_insn_block(CORE_ADDR pc, struct i386_insn *insn_patterns)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
#define I387_BNDCFGU_REGNUM(tdep)
void set_gdbarch_print_float_info(struct gdbarch *gdbarch, gdbarch_print_float_info_ftype print_float_info)
static const char * i386_mpx_names[]
void get_frame_register(struct frame_info *frame, int regnum, gdb_byte *buf)
#define TYPE_NFIELDS(thistype)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
static int i386_next_regnum(int regnum)
#define I386_SAVE_FPU_ENV
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
static struct frame_id i386_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
void set_gdbarch_fetch_pointer_argument(struct gdbarch *gdbarch, gdbarch_fetch_pointer_argument_ftype fetch_pointer_argument)
#define I387_SIZEOF_FSAVE
struct m32c_reg regs[M32C_MAX_NUM_REGS]
static CORE_ADDR i386_frame_base_address(struct frame_info *this_frame, void **this_cache)
#define I387_MXCSR_REGNUM(tdep)
static const gdb_byte * i386_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
#define I386_MAX_REGISTER_SIZE
static enum return_value_convention i386_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
const struct target_desc * tdesc
int i386_ymm_avx512_regnum_p(struct gdbarch *gdbarch, int regnum)
void ax_const_l(struct agent_expr *x, LONGEST l)
const struct regset * fpregset
struct tdesc_arch_data * tdesc_data_alloc(void)
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
static struct value * i386_epilogue_frame_prev_register(struct frame_info *this_frame, void **this_cache, int regnum)
void set_gdbarch_call_dummy_location(struct gdbarch *gdbarch, int call_dummy_location)
void i387_print_float_info(struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args)
static CORE_ADDR i386_fetch_pointer_argument(struct frame_info *frame, int argi, struct type *type)
void ui_out_field_core_addr(struct ui_out *uiout, const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
unsigned long long ULONGEST
static CORE_ADDR i386_analyze_register_saves(CORE_ADDR pc, CORE_ADDR current_pc, struct i386_frame_cache *cache)
int i387_register_to_value(struct frame_info *frame, int regnum, struct type *type, gdb_byte *to, int *optimizedp, int *unavailablep)
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
int register_size(struct gdbarch *gdbarch, int regnum)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
static void i386_frame_cache_1(struct frame_info *this_frame, struct i386_frame_cache *cache)
struct type * value_type(const struct value *value)
struct type * builtin_int64
static int i386_register_to_value(struct frame_info *frame, int regnum, struct type *type, gdb_byte *to, int *optimizedp, int *unavailablep)
#define I387_NUM_XMM_AVX512_REGS(tdep)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
CORE_ADDR value_as_address(struct value *val)
static int i386_record_floats(struct gdbarch *gdbarch, struct i386_record_s *ir, uint32_t iregnum)
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
gdb_byte * value_contents_raw(struct value *value)
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
struct reggroup *const save_reggroup
#define I387_FCTRL_REGNUM(tdep)
static void i386_gen_return_address(struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value, CORE_ADDR scope)
#define TYPE_LENGTH(thistype)
static int i386_insn_is_call(struct gdbarch *gdbarch, CORE_ADDR addr)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
static int i386_in_stack_tramp_p(CORE_ADDR pc)
#define COMPUNIT_EPILOGUE_UNWIND_VALID(cust)
struct target_desc * tdesc_i386_mpx
static struct gdbarch * i386_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void set_gdbarch_insn_is_call(struct gdbarch *gdbarch, gdbarch_insn_is_call_ftype insn_is_call)
struct ui_out * current_uiout
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
static int i386_mxcsr_regnum_p(struct gdbarch *gdbarch, int regnum)
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
static CORE_ADDR i386_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
const char ** k_register_names
struct type * builtin_int8
void i386_pseudo_register_read_into_value(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, struct value *result_value)
void set_gdbarch_has_dos_based_file_system(struct gdbarch *gdbarch, int has_dos_based_file_system)
static struct gdbarch_data * tdesc_data
static void initialize_tdesc_i386_mpx(void)
const int num_lower_zmm_regs
enum axs_lvalue_kind kind
enum bfd_endian byte_order
void i386_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
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 write_exp_string(struct parser_state *ps, struct stoken str)
static const char * i386_byte_names[]
int record_full_arch_list_add_end(void)
int tdesc_has_registers(const struct target_desc *target_desc)
static enum unwind_stop_reason i386_epilogue_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
void write_exp_elt_type(struct parser_state *ps, struct type *expelt)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
CORE_ADDR get_frame_func(struct frame_info *this_frame)
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
static CORE_ADDR i386_skip_probe(CORE_ADDR pc)
void error(const char *fmt,...)
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)
struct type * lookup_pointer_type(struct type *type)
int i386_bnd_regnum_p(struct gdbarch *gdbarch, int regnum)
CORE_ADDR i386_pe_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc, char *name)
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
static void i386_mpx_set_bounds(char *args, int from_tty)
const struct target_desc * i386_target_description(uint64_t xcr0)
int gdb_buffered_insn_length(struct gdbarch *gdbarch, const gdb_byte *insn, int max_len, CORE_ADDR addr)
static int i386_record_lea_modrm_addr(struct i386_record_s *irp, uint64_t *addr)
#define I386_RECORD_FULL_ARCH_LIST_ADD_REG(regnum)
static const char intel_flavor[]
void i386_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
void set_gdbarch_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype print_insn)
static int i386_record_push(struct i386_record_s *irp, int size)
static CORE_ADDR i386_analyze_stack_align(CORE_ADDR pc, CORE_ADDR current_pc, struct i386_frame_cache *cache)
struct type * builtin_float
static struct type * i386_mmx_type(struct gdbarch *gdbarch)
static const int i386_record_regmap[]
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
const ULONGEST const LONGEST len
#define X86_XSTATE_ALL_MASK