X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fi386-tdep.c;h=a6994aaf1266ba4e47c06f694dad2d320c3c758f;hb=a616bb94509c22c96ae8bf1432ec28a7f3e31778;hp=1c8842c42c1ae1b2eed68ff63c8e2b0f3cf40a95;hpb=1528345d6c4a407e0b36b3474eb458cbd04146f7;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c index 1c8842c42c..a6994aaf12 100644 --- a/gdb/i386-tdep.c +++ b/gdb/i386-tdep.c @@ -1,6 +1,6 @@ /* Intel 386 target-dependent stuff. - Copyright (C) 1988-2015 Free Software Foundation, Inc. + Copyright (C) 1988-2018 Free Software Foundation, Inc. This file is part of GDB. @@ -23,7 +23,6 @@ #include "command.h" #include "dummy-frame.h" #include "dwarf2-frame.h" -#include "doublest.h" #include "frame.h" #include "frame-base.h" #include "frame-unwind.h" @@ -40,6 +39,7 @@ #include "symfile.h" #include "symtab.h" #include "target.h" +#include "target-float.h" #include "value.h" #include "dis-asm.h" #include "disasm.h" @@ -47,16 +47,12 @@ #include "i386-tdep.h" #include "i387-tdep.h" #include "x86-xstate.h" +#include "x86-tdep.h" #include "record.h" #include "record-full.h" -#include - -#include "features/i386/i386.c" -#include "features/i386/i386-avx.c" -#include "features/i386/i386-mpx.c" -#include "features/i386/i386-avx512.c" -#include "features/i386/i386-mmx.c" +#include "target-descriptions.h" +#include "arch/i386.h" #include "ax.h" #include "ax-gdb.h" @@ -67,6 +63,7 @@ #include "expression.h" #include "parser-defs.h" #include +#include /* Register names. */ @@ -120,6 +117,11 @@ static const char *i386_mpx_names[] = "bnd0raw", "bnd1raw", "bnd2raw", "bnd3raw", "bndcfgu", "bndstatus" }; +static const char* i386_pkeys_names[] = +{ + "pkru" +}; + /* Register names for MPX pseudo-registers. */ static const char *i386_bnd_names[] = @@ -414,6 +416,21 @@ i386_mpx_ctrl_regnum_p (struct gdbarch *gdbarch, int regnum) return regnum >= 0 && regnum < I387_NUM_MPX_CTRL_REGS; } +/* PKRU register? */ + +bool +i386_pkru_regnum_p (struct gdbarch *gdbarch, int regnum) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + int pkru_regnum = tdep->pkru_regnum; + + if (pkru_regnum < 0) + return false; + + regnum -= pkru_regnum; + return regnum >= 0 && regnum < I387_NUM_PKEYS_REGS; +} + /* Return the name of register REGNUM, or the empty string if it is an anonymous register. */ @@ -504,11 +521,11 @@ i386_dbx_reg_to_regnum (struct gdbarch *gdbarch, int reg) return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); } -/* Convert SVR4 register number REG to the appropriate register number +/* Convert SVR4 DWARF register number REG to the appropriate register number used by GDB. */ static int -i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg) +i386_svr4_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); @@ -546,8 +563,20 @@ i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg) case 45: return I386_GS_REGNUM; } - /* This will hopefully provoke a warning. */ - return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); + return -1; +} + +/* Wrapper on i386_svr4_dwarf_reg_to_regnum to return + num_regs + num_pseudo_regs for other debug formats. */ + +int +i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg) +{ + int regnum = i386_svr4_dwarf_reg_to_regnum (gdbarch, reg); + + if (regnum == -1) + return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); + return regnum; } @@ -576,14 +605,10 @@ static const char *disassembly_flavor = att_flavor; This function is 64-bit safe. */ -static const gdb_byte * -i386_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len) -{ - static gdb_byte break_insn[] = { 0xcc }; /* int 3 */ +constexpr gdb_byte i386_break_insn[] = { 0xcc }; /* int 3 */ + +typedef BP_MANIPULATION (i386_break_insn) i386_breakpoint; - *len = sizeof (break_insn); - return break_insn; -} /* Displaced instruction handling. */ @@ -770,8 +795,7 @@ i386_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr) return i386_jmp_p (insn); } -/* Some kernels may run one past a syscall insn, so we have to cope. - Otherwise this is just simple_displaced_step_copy_insn. */ +/* Some kernels may run one past a syscall insn, so we have to cope. */ struct displaced_step_closure * i386_displaced_step_copy_insn (struct gdbarch *gdbarch, @@ -779,7 +803,8 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch, struct regcache *regs) { size_t len = gdbarch_max_insn_length (gdbarch); - gdb_byte *buf = xmalloc (len); + i386_displaced_step_closure *closure = new i386_displaced_step_closure (len); + gdb_byte *buf = closure->buf.data (); read_memory (from, buf, len); @@ -804,7 +829,7 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch, displaced_step_dump_bytes (gdb_stdlog, buf, len); } - return (struct displaced_step_closure *) buf; + return closure; } /* Fix up the state of registers and memory after having single-stepped @@ -812,7 +837,7 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch, void i386_displaced_step_fixup (struct gdbarch *gdbarch, - struct displaced_step_closure *closure, + struct displaced_step_closure *closure_, CORE_ADDR from, CORE_ADDR to, struct regcache *regs) { @@ -824,9 +849,9 @@ i386_displaced_step_fixup (struct gdbarch *gdbarch, applying it. */ ULONGEST insn_offset = to - from; - /* Since we use simple_displaced_step_copy_insn, our closure is a - copy of the instruction. */ - gdb_byte *insn = (gdb_byte *) closure; + i386_displaced_step_closure *closure + = (i386_displaced_step_closure *) closure_; + gdb_byte *insn = closure->buf.data (); /* The start of the insn, needed in case we see some prefixes. */ gdb_byte *insn_start = insn; @@ -1354,7 +1379,7 @@ i386_analyze_stack_align (CORE_ADDR pc, CORE_ADDR current_pc, if (current_pc > pc + offset_and) cache->saved_sp_reg = regnums[reg]; - return min (pc + offset + 3, current_pc); + return std::min (pc + offset + 3, current_pc); } /* Maximum instruction length we need to handle. */ @@ -1824,9 +1849,8 @@ i386_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc) if (post_prologue_pc && (cust != NULL && COMPUNIT_PRODUCER (cust) != NULL - && strncmp (COMPUNIT_PRODUCER (cust), "clang ", - sizeof ("clang ") - 1) == 0)) - return max (start_pc, post_prologue_pc); + && startswith (COMPUNIT_PRODUCER (cust), "clang "))) + return std::max (start_pc, post_prologue_pc); } cache.locals = -1; @@ -2050,21 +2074,24 @@ i386_frame_cache_1 (struct frame_info *this_frame, static struct i386_frame_cache * i386_frame_cache (struct frame_info *this_frame, void **this_cache) { - volatile struct gdb_exception ex; struct i386_frame_cache *cache; if (*this_cache) - return *this_cache; + return (struct i386_frame_cache *) *this_cache; cache = i386_alloc_frame_cache (); *this_cache = cache; - TRY_CATCH (ex, RETURN_MASK_ERROR) + TRY { i386_frame_cache_1 (this_frame, cache); } - if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR) - throw_exception (ex); + CATCH (ex, RETURN_MASK_ERROR) + { + if (ex.error != NOT_AVAILABLE_ERROR) + throw_exception (ex); + } + END_CATCH return cache; } @@ -2176,12 +2203,14 @@ static const struct frame_unwind i386_frame_unwind = /* Normal frames, but in a function epilogue. */ -/* The epilogue is defined here as the 'ret' instruction, which will +/* Implement the stack_frame_destroyed_p gdbarch method. + + The epilogue is defined here as the 'ret' instruction, which will follow any instruction such as 'leave' or 'pop %ebp' that destroys the function's stack frame. */ static int -i386_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) +i386_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc) { gdb_byte insn; struct compunit_symtab *cust; @@ -2205,8 +2234,8 @@ i386_epilogue_frame_sniffer (const struct frame_unwind *self, void **this_prologue_cache) { if (frame_relative_level (this_frame) == 0) - return i386_in_function_epilogue_p (get_frame_arch (this_frame), - get_frame_pc (this_frame)); + return i386_stack_frame_destroyed_p (get_frame_arch (this_frame), + get_frame_pc (this_frame)); else return 0; } @@ -2214,17 +2243,16 @@ i386_epilogue_frame_sniffer (const struct frame_unwind *self, static struct i386_frame_cache * i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache) { - volatile struct gdb_exception ex; struct i386_frame_cache *cache; CORE_ADDR sp; if (*this_cache) - return *this_cache; + return (struct i386_frame_cache *) *this_cache; cache = i386_alloc_frame_cache (); *this_cache = cache; - TRY_CATCH (ex, RETURN_MASK_ERROR) + TRY { cache->pc = get_frame_func (this_frame); @@ -2238,8 +2266,12 @@ i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache) cache->base_p = 1; } - if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR) - throw_exception (ex); + CATCH (ex, RETURN_MASK_ERROR) + { + if (ex.error != NOT_AVAILABLE_ERROR) + throw_exception (ex); + } + END_CATCH return cache; } @@ -2397,17 +2429,16 @@ i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache) struct gdbarch *gdbarch = get_frame_arch (this_frame); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - volatile struct gdb_exception ex; struct i386_frame_cache *cache; CORE_ADDR addr; gdb_byte buf[4]; if (*this_cache) - return *this_cache; + return (struct i386_frame_cache *) *this_cache; cache = i386_alloc_frame_cache (); - TRY_CATCH (ex, RETURN_MASK_ERROR) + TRY { get_frame_register (this_frame, I386_ESP_REGNUM, buf); cache->base = extract_unsigned_integer (buf, 4, byte_order) - 4; @@ -2431,8 +2462,12 @@ i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache) cache->base_p = 1; } - if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR) - throw_exception (ex); + CATCH (ex, RETURN_MASK_ERROR) + { + if (ex.error != NOT_AVAILABLE_ERROR) + throw_exception (ex); + } + END_CATCH *this_cache = cache; return cache; @@ -2645,6 +2680,13 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function, int write_pass; int args_space = 0; + /* BND registers can be in arbitrary values at the moment of the + inferior call. This can cause boundary violations that are not + due to a real bug or even desired by the user. The best to be done + is set the BND registers to allow access to the whole memory, INIT + state, before pushing the inferior call. */ + i387_reset_bnd_regs (gdbarch, regcache); + /* Determine the total space required for arguments and struct return address in a first pass (allowing for 16-byte-aligned arguments), then push arguments in a second pass. */ @@ -2713,10 +2755,10 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function, /* Finally, update the stack pointer... */ store_unsigned_integer (buf, 4, byte_order, sp); - regcache_cooked_write (regcache, I386_ESP_REGNUM, buf); + regcache->cooked_write (I386_ESP_REGNUM, buf); /* ...and fake a frame pointer. */ - regcache_cooked_write (regcache, I386_EBP_REGNUM, buf); + regcache->cooked_write (I386_EBP_REGNUM, buf); /* MarkK wrote: This "+ 8" is all over the place: (i386_frame_this_id, i386_sigtramp_frame_this_id, @@ -2760,8 +2802,8 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type, its contents to the desired type. This is probably not exactly how it would happen on the target itself, but it is the best we can do. */ - regcache_raw_read (regcache, I386_ST0_REGNUM, buf); - convert_typed_floating (buf, i387_ext_type (gdbarch), valbuf, type); + regcache->raw_read (I386_ST0_REGNUM, buf); + target_float_convert (buf, i387_ext_type (gdbarch), valbuf, type); } else { @@ -2770,14 +2812,14 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type, if (len <= low_size) { - regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf); + regcache->raw_read (LOW_RETURN_REGNUM, buf); memcpy (valbuf, buf, len); } else if (len <= (low_size + high_size)) { - regcache_raw_read (regcache, LOW_RETURN_REGNUM, buf); + regcache->raw_read (LOW_RETURN_REGNUM, buf); memcpy (valbuf, buf, low_size); - regcache_raw_read (regcache, HIGH_RETURN_REGNUM, buf); + regcache->raw_read (HIGH_RETURN_REGNUM, buf); memcpy (valbuf + low_size, buf, len - low_size); } else @@ -2816,8 +2858,8 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type, floating-point format used by the FPU. This is probably not exactly how it would happen on the target itself, but it is the best we can do. */ - convert_typed_floating (valbuf, type, buf, i387_ext_type (gdbarch)); - regcache_raw_write (regcache, I386_ST0_REGNUM, buf); + target_float_convert (valbuf, type, buf, i387_ext_type (gdbarch)); + regcache->raw_write (I386_ST0_REGNUM, buf); /* Set the top of the floating-point register stack to 7. The actual value doesn't really matter, but 7 is what a normal @@ -2838,12 +2880,12 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type, int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM); if (len <= low_size) - regcache_raw_write_part (regcache, LOW_RETURN_REGNUM, 0, len, valbuf); + regcache->raw_write_part (LOW_RETURN_REGNUM, 0, len, valbuf); else if (len <= (low_size + high_size)) { - regcache_raw_write (regcache, LOW_RETURN_REGNUM, valbuf); - regcache_raw_write_part (regcache, HIGH_RETURN_REGNUM, 0, - len - low_size, valbuf + low_size); + regcache->raw_write (LOW_RETURN_REGNUM, valbuf); + regcache->raw_write_part (HIGH_RETURN_REGNUM, 0, len - low_size, + valbuf + low_size); } else internal_error (__FILE__, __LINE__, @@ -2998,7 +3040,7 @@ i386_bnd_type (struct gdbarch *gdbarch) if (!tdep->i386_bnd_type) { - struct type *t, *bound_t; + struct type *t; const struct builtin_type *bt = builtin_type (gdbarch); /* The type we're building is described bellow: */ @@ -3207,15 +3249,15 @@ i386_pseudo_register_type (struct gdbarch *gdbarch, int regnum) the MMX registers need to be mapped onto floating point registers. */ static int -i386_mmx_regnum_to_fp_regnum (struct regcache *regcache, int regnum) +i386_mmx_regnum_to_fp_regnum (readable_regcache *regcache, int regnum) { - struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ()); int mmxreg, fpreg; ULONGEST fstat; int tos; mmxreg = regnum - tdep->mm0_regnum; - regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat); + regcache->raw_read (I387_FSTAT_REGNUM (tdep), &fstat); tos = (fstat >> 11) & 0x7; fpreg = (mmxreg + tos) % 8; @@ -3228,11 +3270,11 @@ i386_mmx_regnum_to_fp_regnum (struct regcache *regcache, int regnum) void i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, - struct regcache *regcache, + readable_regcache *regcache, int regnum, struct value *result_value) { - gdb_byte raw_buf[MAX_REGISTER_SIZE]; + gdb_byte raw_buf[I386_MAX_REGISTER_SIZE]; enum register_status status; gdb_byte *buf = value_contents_raw (result_value); @@ -3241,7 +3283,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum); /* Extract (always little endian). */ - status = regcache_raw_read (regcache, fpnum, raw_buf); + status = regcache->raw_read (fpnum, raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, TYPE_LENGTH (value_type (result_value))); @@ -3256,9 +3298,8 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, regnum -= tdep->bnd0_regnum; /* Extract (always little endian). Read lower 128bits. */ - status = regcache_raw_read (regcache, - I387_BND0R_REGNUM (tdep) + regnum, - raw_buf); + status = regcache->raw_read (I387_BND0R_REGNUM (tdep) + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, 16); else @@ -3280,9 +3321,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, regnum -= tdep->k0_regnum; /* Extract (always little endian). */ - status = regcache_raw_read (regcache, - tdep->k0_regnum + regnum, - raw_buf); + status = regcache->raw_read (tdep->k0_regnum + regnum, raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, 8); else @@ -3295,18 +3334,16 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, if (regnum < num_lower_zmm_regs) { /* Extract (always little endian). Read lower 128bits. */ - status = regcache_raw_read (regcache, - I387_XMM0_REGNUM (tdep) + regnum, - raw_buf); + status = regcache->raw_read (I387_XMM0_REGNUM (tdep) + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, 16); else memcpy (buf, raw_buf, 16); /* Extract (always little endian). Read upper 128bits. */ - status = regcache_raw_read (regcache, - tdep->ymm0h_regnum + regnum, - raw_buf); + status = regcache->raw_read (tdep->ymm0h_regnum + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 16, 16); else @@ -3315,20 +3352,18 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, else { /* Extract (always little endian). Read lower 128bits. */ - status = regcache_raw_read (regcache, - I387_XMM16_REGNUM (tdep) + regnum - - num_lower_zmm_regs, - raw_buf); + status = regcache->raw_read (I387_XMM16_REGNUM (tdep) + regnum + - num_lower_zmm_regs, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, 16); else memcpy (buf, raw_buf, 16); /* Extract (always little endian). Read upper 128bits. */ - status = regcache_raw_read (regcache, - I387_YMM16H_REGNUM (tdep) + regnum - - num_lower_zmm_regs, - raw_buf); + status = regcache->raw_read (I387_YMM16H_REGNUM (tdep) + regnum + - num_lower_zmm_regs, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 16, 16); else @@ -3336,9 +3371,8 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, } /* Read upper 256bits. */ - status = regcache_raw_read (regcache, - tdep->zmm0h_regnum + regnum, - raw_buf); + status = regcache->raw_read (tdep->zmm0h_regnum + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 32, 32); else @@ -3349,17 +3383,15 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, regnum -= tdep->ymm0_regnum; /* Extract (always little endian). Read lower 128bits. */ - status = regcache_raw_read (regcache, - I387_XMM0_REGNUM (tdep) + regnum, - raw_buf); + status = regcache->raw_read (I387_XMM0_REGNUM (tdep) + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, 16); else memcpy (buf, raw_buf, 16); /* Read upper 128bits. */ - status = regcache_raw_read (regcache, - tdep->ymm0h_regnum + regnum, - raw_buf); + status = regcache->raw_read (tdep->ymm0h_regnum + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 16, 32); else @@ -3369,17 +3401,15 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, { regnum -= tdep->ymm16_regnum; /* Extract (always little endian). Read lower 128bits. */ - status = regcache_raw_read (regcache, - I387_XMM16_REGNUM (tdep) + regnum, - raw_buf); + status = regcache->raw_read (I387_XMM16_REGNUM (tdep) + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, 16); else memcpy (buf, raw_buf, 16); /* Read upper 128bits. */ - status = regcache_raw_read (regcache, - tdep->ymm16h_regnum + regnum, - raw_buf); + status = regcache->raw_read (tdep->ymm16h_regnum + regnum, + raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 16, 16); else @@ -3390,7 +3420,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, int gpnum = regnum - tdep->ax_regnum; /* Extract (always little endian). */ - status = regcache_raw_read (regcache, gpnum, raw_buf); + status = regcache->raw_read (gpnum, raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, TYPE_LENGTH (value_type (result_value))); @@ -3399,14 +3429,11 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, } else if (i386_byte_regnum_p (gdbarch, regnum)) { - /* Check byte pseudo registers last since this function will - be called from amd64_pseudo_register_read, which handles - byte pseudo registers differently. */ int gpnum = regnum - tdep->al_regnum; /* Extract (always little endian). We read both lower and upper registers. */ - status = regcache_raw_read (regcache, gpnum % 4, raw_buf); + status = regcache->raw_read (gpnum % 4, raw_buf); if (status != REG_VALID) mark_value_bytes_unavailable (result_value, 0, TYPE_LENGTH (value_type (result_value))); @@ -3422,7 +3449,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, static struct value * i386_pseudo_register_read_value (struct gdbarch *gdbarch, - struct regcache *regcache, + readable_regcache *regcache, int regnum) { struct value *result; @@ -3440,18 +3467,18 @@ void i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf) { - gdb_byte raw_buf[MAX_REGISTER_SIZE]; + gdb_byte raw_buf[I386_MAX_REGISTER_SIZE]; if (i386_mmx_regnum_p (gdbarch, regnum)) { int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum); /* Read ... */ - regcache_raw_read (regcache, fpnum, raw_buf); + regcache->raw_read (fpnum, raw_buf); /* ... Modify ... (always little endian). */ memcpy (raw_buf, buf, register_size (gdbarch, regnum)); /* ... Write. */ - regcache_raw_write (regcache, fpnum, raw_buf); + regcache->raw_write (fpnum, raw_buf); } else { @@ -3469,9 +3496,8 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, upper = extract_unsigned_integer (buf + size, size, byte_order); /* Fetching register buffer. */ - regcache_raw_read (regcache, - I387_BND0R_REGNUM (tdep) + regnum, - raw_buf); + regcache->raw_read (I387_BND0R_REGNUM (tdep) + regnum, + raw_buf); upper = ~upper; @@ -3479,18 +3505,13 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, memcpy (raw_buf, &lower, 8); memcpy (raw_buf + 8, &upper, 8); - - regcache_raw_write (regcache, - I387_BND0R_REGNUM (tdep) + regnum, - raw_buf); + regcache->raw_write (I387_BND0R_REGNUM (tdep) + regnum, raw_buf); } else if (i386_k_regnum_p (gdbarch, regnum)) { regnum -= tdep->k0_regnum; - regcache_raw_write (regcache, - tdep->k0_regnum + regnum, - buf); + regcache->raw_write (tdep->k0_regnum + regnum, buf); } else if (i386_zmm_regnum_p (gdbarch, regnum)) { @@ -3499,90 +3520,151 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, if (regnum < num_lower_zmm_regs) { /* Write lower 128bits. */ - regcache_raw_write (regcache, - I387_XMM0_REGNUM (tdep) + regnum, - buf); + regcache->raw_write (I387_XMM0_REGNUM (tdep) + regnum, buf); /* Write upper 128bits. */ - regcache_raw_write (regcache, - I387_YMM0_REGNUM (tdep) + regnum, - buf + 16); + regcache->raw_write (I387_YMM0_REGNUM (tdep) + regnum, buf + 16); } else { /* Write lower 128bits. */ - regcache_raw_write (regcache, - I387_XMM16_REGNUM (tdep) + regnum - - num_lower_zmm_regs, - buf); + regcache->raw_write (I387_XMM16_REGNUM (tdep) + regnum + - num_lower_zmm_regs, buf); /* Write upper 128bits. */ - regcache_raw_write (regcache, - I387_YMM16H_REGNUM (tdep) + regnum - - num_lower_zmm_regs, - buf + 16); + regcache->raw_write (I387_YMM16H_REGNUM (tdep) + regnum + - num_lower_zmm_regs, buf + 16); } /* Write upper 256bits. */ - regcache_raw_write (regcache, - tdep->zmm0h_regnum + regnum, - buf + 32); + regcache->raw_write (tdep->zmm0h_regnum + regnum, buf + 32); } else if (i386_ymm_regnum_p (gdbarch, regnum)) { regnum -= tdep->ymm0_regnum; /* ... Write lower 128bits. */ - regcache_raw_write (regcache, - I387_XMM0_REGNUM (tdep) + regnum, - buf); + regcache->raw_write (I387_XMM0_REGNUM (tdep) + regnum, buf); /* ... Write upper 128bits. */ - regcache_raw_write (regcache, - tdep->ymm0h_regnum + regnum, - buf + 16); + regcache->raw_write (tdep->ymm0h_regnum + regnum, buf + 16); } else if (i386_ymm_avx512_regnum_p (gdbarch, regnum)) { regnum -= tdep->ymm16_regnum; /* ... Write lower 128bits. */ - regcache_raw_write (regcache, - I387_XMM16_REGNUM (tdep) + regnum, - buf); + regcache->raw_write (I387_XMM16_REGNUM (tdep) + regnum, buf); /* ... Write upper 128bits. */ - regcache_raw_write (regcache, - tdep->ymm16h_regnum + regnum, - buf + 16); + regcache->raw_write (tdep->ymm16h_regnum + regnum, buf + 16); } else if (i386_word_regnum_p (gdbarch, regnum)) { int gpnum = regnum - tdep->ax_regnum; /* Read ... */ - regcache_raw_read (regcache, gpnum, raw_buf); + regcache->raw_read (gpnum, raw_buf); /* ... Modify ... (always little endian). */ memcpy (raw_buf, buf, 2); /* ... Write. */ - regcache_raw_write (regcache, gpnum, raw_buf); + regcache->raw_write (gpnum, raw_buf); } else if (i386_byte_regnum_p (gdbarch, regnum)) { - /* Check byte pseudo registers last since this function will - be called from amd64_pseudo_register_read, which handles - byte pseudo registers differently. */ int gpnum = regnum - tdep->al_regnum; /* Read ... We read both lower and upper registers. */ - regcache_raw_read (regcache, gpnum % 4, raw_buf); + regcache->raw_read (gpnum % 4, raw_buf); /* ... Modify ... (always little endian). */ if (gpnum >= 4) memcpy (raw_buf + 1, buf, 1); else memcpy (raw_buf, buf, 1); /* ... Write. */ - regcache_raw_write (regcache, gpnum % 4, raw_buf); + regcache->raw_write (gpnum % 4, raw_buf); } else internal_error (__FILE__, __LINE__, _("invalid regnum")); } } + +/* Implement the 'ax_pseudo_register_collect' gdbarch method. */ + +int +i386_ax_pseudo_register_collect (struct gdbarch *gdbarch, + struct agent_expr *ax, int regnum) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + if (i386_mmx_regnum_p (gdbarch, regnum)) + { + /* MMX to FPU register mapping depends on current TOS. Let's just + not care and collect everything... */ + int i; + + ax_reg_mask (ax, I387_FSTAT_REGNUM (tdep)); + for (i = 0; i < 8; i++) + ax_reg_mask (ax, I387_ST0_REGNUM (tdep) + i); + return 0; + } + else if (i386_bnd_regnum_p (gdbarch, regnum)) + { + regnum -= tdep->bnd0_regnum; + ax_reg_mask (ax, I387_BND0R_REGNUM (tdep) + regnum); + return 0; + } + else if (i386_k_regnum_p (gdbarch, regnum)) + { + regnum -= tdep->k0_regnum; + ax_reg_mask (ax, tdep->k0_regnum + regnum); + return 0; + } + else if (i386_zmm_regnum_p (gdbarch, regnum)) + { + regnum -= tdep->zmm0_regnum; + if (regnum < num_lower_zmm_regs) + { + ax_reg_mask (ax, I387_XMM0_REGNUM (tdep) + regnum); + ax_reg_mask (ax, tdep->ymm0h_regnum + regnum); + } + else + { + ax_reg_mask (ax, I387_XMM16_REGNUM (tdep) + regnum + - num_lower_zmm_regs); + ax_reg_mask (ax, I387_YMM16H_REGNUM (tdep) + regnum + - num_lower_zmm_regs); + } + ax_reg_mask (ax, tdep->zmm0h_regnum + regnum); + return 0; + } + else if (i386_ymm_regnum_p (gdbarch, regnum)) + { + regnum -= tdep->ymm0_regnum; + ax_reg_mask (ax, I387_XMM0_REGNUM (tdep) + regnum); + ax_reg_mask (ax, tdep->ymm0h_regnum + regnum); + return 0; + } + else if (i386_ymm_avx512_regnum_p (gdbarch, regnum)) + { + regnum -= tdep->ymm16_regnum; + ax_reg_mask (ax, I387_XMM16_REGNUM (tdep) + regnum); + ax_reg_mask (ax, tdep->ymm16h_regnum + regnum); + return 0; + } + else if (i386_word_regnum_p (gdbarch, regnum)) + { + int gpnum = regnum - tdep->ax_regnum; + + ax_reg_mask (ax, gpnum); + return 0; + } + else if (i386_byte_regnum_p (gdbarch, regnum)) + { + int gpnum = regnum - tdep->al_regnum; + + ax_reg_mask (ax, gpnum % 4); + return 0; + } + else + internal_error (__FILE__, __LINE__, _("invalid regnum")); + return 1; +} /* Return the register number of the register allocated by GCC after @@ -3722,9 +3804,9 @@ void i386_supply_gregset (const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - const gdb_byte *regs = gregs; + const gdb_byte *regs = (const gdb_byte *) gregs; int i; gdb_assert (len >= tdep->sizeof_gregset); @@ -3733,7 +3815,7 @@ i386_supply_gregset (const struct regset *regset, struct regcache *regcache, { if ((regnum == i || regnum == -1) && tdep->gregset_reg_offset[i] != -1) - regcache_raw_supply (regcache, i, regs + tdep->gregset_reg_offset[i]); + regcache->raw_supply (i, regs + tdep->gregset_reg_offset[i]); } } @@ -3747,9 +3829,9 @@ i386_collect_gregset (const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - gdb_byte *regs = gregs; + gdb_byte *regs = (gdb_byte *) gregs; int i; gdb_assert (len >= tdep->sizeof_gregset); @@ -3758,7 +3840,7 @@ i386_collect_gregset (const struct regset *regset, { if ((regnum == i || regnum == -1) && tdep->gregset_reg_offset[i] != -1) - regcache_raw_collect (regcache, i, regs + tdep->gregset_reg_offset[i]); + regcache->raw_collect (i, regs + tdep->gregset_reg_offset[i]); } } @@ -3770,7 +3852,7 @@ static void i386_supply_fpregset (const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (len == I387_SIZEOF_FXSAVE) @@ -3793,7 +3875,7 @@ i386_collect_fpregset (const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len) { - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); if (len == I387_SIZEOF_FXSAVE) @@ -3828,9 +3910,11 @@ i386_iterate_over_regset_sections (struct gdbarch *gdbarch, { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - cb (".reg", tdep->sizeof_gregset, &i386_gregset, NULL, cb_data); + cb (".reg", tdep->sizeof_gregset, tdep->sizeof_gregset, &i386_gregset, NULL, + cb_data); if (tdep->sizeof_fpregset) - cb (".reg2", tdep->sizeof_fpregset, tdep->fpregset, NULL, cb_data); + cb (".reg2", tdep->sizeof_fpregset, tdep->sizeof_fpregset, tdep->fpregset, + NULL, cb_data); } @@ -3854,8 +3938,8 @@ i386_pe_skip_trampoline_code (struct frame_info *frame, if (symname) { - if (strncmp (symname, "__imp_", 6) == 0 - || strncmp (symname, "_imp_", 5) == 0) + if (startswith (symname, "__imp_") + || startswith (symname, "_imp_")) return name ? 1 : read_memory_unsigned_integer (indirect, 4, byte_order); } @@ -3887,11 +3971,9 @@ i386_print_insn (bfd_vma pc, struct disassemble_info *info) gdb_assert (disassembly_flavor == att_flavor || disassembly_flavor == intel_flavor); - /* FIXME: kettenis/20020915: Until disassembler_options is properly - constified, cast to prevent a compiler warning. */ - info->disassembler_options = (char *) disassembly_flavor; + info->disassembler_options = disassembly_flavor; - return print_insn_i386 (pc, info); + return default_print_insn (pc, info); } @@ -4043,7 +4125,7 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, return 0; len = s - start - 1; - regname = alloca (len + 1); + regname = (char *) alloca (len + 1); strncpy (regname, start, len); regname[len] = '\0'; @@ -4153,7 +4235,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, return 0; len_base = s - start; - base = alloca (len_base + 1); + base = (char *) alloca (len_base + 1); strncpy (base, start, len_base); base[len_base] = '\0'; @@ -4168,7 +4250,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, ++s; len_index = s - start; - index = alloca (len_index + 1); + index = (char *) alloca (len_index + 1); strncpy (index, start, len_index); index[len_index] = '\0'; @@ -4270,7 +4352,8 @@ i386_stap_parse_special_token (struct gdbarch *gdbarch, TRIPLET, THREE_ARG_DISPLACEMENT, DONE - } current_state; + }; + int current_state; current_state = TRIPLET; @@ -4317,6 +4400,15 @@ i386_gnu_triplet_regexp (struct gdbarch *gdbarch) +/* Implement the "in_indirect_branch_thunk" gdbarch function. */ + +static bool +i386_in_indirect_branch_thunk (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + return x86_in_indirect_branch_thunk (pc, i386_register_names, + I386_EAX_REGNUM, I386_EIP_REGNUM); +} + /* Generic ELF. */ void @@ -4344,7 +4436,8 @@ i386_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) set_gdbarch_stap_parse_special_token (gdbarch, i386_stap_parse_special_token); - set_gdbarch_gnu_triplet_regexp (gdbarch, i386_gnu_triplet_regexp); + set_gdbarch_in_indirect_branch_thunk (gdbarch, + i386_in_indirect_branch_thunk); } /* System V Release 4 (SVR4). */ @@ -4368,33 +4461,6 @@ i386_svr4_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) tdep->jb_pc_offset = 20; } -/* DJGPP. */ - -static void -i386_go32_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) -{ - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - - /* DJGPP doesn't have any special frames for signal handlers. */ - tdep->sigtramp_p = NULL; - - tdep->jb_pc_offset = 36; - - /* DJGPP does not support the SSE registers. */ - if (! tdesc_has_registers (info.target_desc)) - tdep->tdesc = tdesc_i386_mmx; - - /* Native compiler is GCC, which uses the SVR4 register numbering - even in COFF and STABS. See the comment in i386_gdbarch_init, - before the calls to set_gdbarch_stab_reg_to_regnum and - set_gdbarch_sdb_reg_to_regnum. */ - set_gdbarch_stab_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum); - set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum); - - set_gdbarch_has_dos_based_file_system (gdbarch, 1); - - set_gdbarch_gnu_triplet_regexp (gdbarch, i386_gnu_triplet_regexp); -} /* i386 register groups. In addition to the normal groups, add "mmx" @@ -4431,9 +4497,9 @@ i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum, const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); int fp_regnum_p, mmx_regnum_p, xmm_regnum_p, mxcsr_regnum_p, ymm_regnum_p, ymmh_regnum_p, ymm_avx512_regnum_p, ymmh_avx512_regnum_p, - bndr_regnum_p, bnd_regnum_p, k_regnum_p, zmm_regnum_p, zmmh_regnum_p, - zmm_avx512_regnum_p, mpx_ctrl_regnum_p, xmm_avx512_regnum_p, - avx512_p, avx_p, sse_p; + bndr_regnum_p, bnd_regnum_p, zmm_regnum_p, zmmh_regnum_p, + mpx_ctrl_regnum_p, xmm_avx512_regnum_p, + avx512_p, avx_p, sse_p, pkru_regnum_p; /* Don't include pseudo registers, except for MMX, in any register groups. */ @@ -4450,6 +4516,7 @@ i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum, if (group == i386_mmx_reggroup) return mmx_regnum_p; + pkru_regnum_p = i386_pkru_regnum_p(gdbarch, regnum); xmm_regnum_p = i386_xmm_regnum_p (gdbarch, regnum); xmm_avx512_regnum_p = i386_xmm_avx512_regnum_p (gdbarch, regnum); mxcsr_regnum_p = i386_mxcsr_regnum_p (gdbarch, regnum); @@ -4460,11 +4527,11 @@ i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum, ymm_avx512_regnum_p = i386_ymm_avx512_regnum_p (gdbarch, regnum); zmm_regnum_p = i386_zmm_regnum_p (gdbarch, regnum); - avx512_p = ((tdep->xcr0 & X86_XSTATE_AVX512_MASK) - == X86_XSTATE_AVX512_MASK); - avx_p = ((tdep->xcr0 & X86_XSTATE_AVX512_MASK) + avx512_p = ((tdep->xcr0 & X86_XSTATE_AVX_AVX512_MASK) + == X86_XSTATE_AVX_AVX512_MASK); + avx_p = ((tdep->xcr0 & X86_XSTATE_AVX_AVX512_MASK) == X86_XSTATE_AVX_MASK) && !avx512_p; - sse_p = ((tdep->xcr0 & X86_XSTATE_AVX512_MASK) + sse_p = ((tdep->xcr0 & X86_XSTATE_AVX_AVX512_MASK) == X86_XSTATE_SSE_MASK) && !avx512_p && ! avx_p; if (group == vector_reggroup) @@ -4521,7 +4588,8 @@ i386_register_reggroup_p (struct gdbarch *gdbarch, int regnum, && !bnd_regnum_p && !mpx_ctrl_regnum_p && !zmm_regnum_p - && !zmmh_regnum_p); + && !zmmh_regnum_p + && !pkru_regnum_p); return default_register_reggroup_p (gdbarch, regnum, group); } @@ -4817,17 +4885,12 @@ i386_record_lea_modrm (struct i386_record_s *irp) { if (record_full_memory_query) { - int q; - - target_terminal_ours (); - q = yquery (_("\ + if (yquery (_("\ Process record ignores the memory change of instruction at address %s\n\ because it can't get the value of the segment register.\n\ Do you want to stop the program?"), - paddress (gdbarch, irp->orig_addr)); - target_terminal_inferior (); - if (q) - return -1; + paddress (gdbarch, irp->orig_addr))) + return -1; } return 0; @@ -4947,7 +5010,7 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache, uint32_t opcode; uint8_t opcode8; ULONGEST addr; - gdb_byte buf[MAX_REGISTER_SIZE]; + gdb_byte buf[I386_MAX_REGISTER_SIZE]; struct i386_record_s ir; struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); uint8_t rex_w = -1; @@ -5411,14 +5474,36 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache, I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM); break; - case 0x0fc7: /* cmpxchg8b */ + case 0x0fc7: /* cmpxchg8b / rdrand / rdseed */ if (i386_record_modrm (&ir)) return -1; if (ir.mod == 3) { - ir.addr -= 2; - opcode = opcode << 8 | ir.modrm; - goto no_support; + /* rdrand and rdseed use the 3 bits of the REG field of ModR/M as + an extended opcode. rdrand has bits 110 (/6) and rdseed + has bits 111 (/7). */ + if (ir.reg == 6 || ir.reg == 7) + { + /* The storage register is described by the 3 R/M bits, but the + REX.B prefix may be used to give access to registers + R8~R15. In this case ir.rex_b + R/M will give us the register + in the range R8~R15. + + REX.W may also be used to access 64-bit registers, but we + already record entire registers and not just partial bits + of them. */ + I386_RECORD_FULL_ARCH_LIST_ADD_REG (ir.rex_b + ir.rm); + /* These instructions also set conditional bits. */ + I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_EFLAGS_REGNUM); + break; + } + else + { + /* We don't handle this particular instruction yet. */ + ir.addr -= 2; + opcode = opcode << 8 | ir.modrm; + goto no_support; + } } I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REAX_REGNUM); I386_RECORD_FULL_ARCH_LIST_ADD_REG (X86_RECORD_REDX_REGNUM); @@ -5708,16 +5793,11 @@ i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache, { if (record_full_memory_query) { - int q; - - target_terminal_ours (); - q = yquery (_("\ + if (yquery (_("\ Process record ignores the memory change of instruction at address %s\n\ because it can't get the value of the segment register.\n\ Do you want to stop the program?"), - paddress (gdbarch, ir.orig_addr)); - target_terminal_inferior (); - if (q) + paddress (gdbarch, ir.orig_addr))) return -1; } } @@ -6382,16 +6462,11 @@ Do you want to stop the program?"), /* addr += ((uint32_t) read_register (I386_ES_REGNUM)) << 4; */ if (record_full_memory_query) { - int q; - - target_terminal_ours (); - q = yquery (_("\ + if (yquery (_("\ Process record ignores the memory change of instruction at address %s\n\ because it can't get the value of the segment register.\n\ Do you want to stop the program?"), - paddress (gdbarch, ir.orig_addr)); - target_terminal_inferior (); - if (q) + paddress (gdbarch, ir.orig_addr))) return -1; } } @@ -6937,17 +7012,12 @@ Do you want to stop the program?"), { if (record_full_memory_query) { - int q; - - target_terminal_ours (); - q = yquery (_("\ + if (yquery (_("\ Process record ignores the memory change of instruction at address %s\n\ because it can't get the value of the segment register.\n\ Do you want to stop the program?"), - paddress (gdbarch, ir.orig_addr)); - target_terminal_inferior (); - if (q) - return -1; + paddress (gdbarch, ir.orig_addr))) + return -1; } } else @@ -6994,16 +7064,11 @@ Do you want to stop the program?"), { if (record_full_memory_query) { - int q; - - target_terminal_ours (); - q = yquery (_("\ + if (yquery (_("\ Process record ignores the memory change of instruction at address %s\n\ because it can't get the value of the segment register.\n\ Do you want to stop the program?"), - paddress (gdbarch, ir.orig_addr)); - target_terminal_inferior (); - if (q) + paddress (gdbarch, ir.orig_addr))) return -1; } } @@ -7043,6 +7108,7 @@ Do you want to stop the program?"), else if (ir.rm == 1) break; } + /* Fall through. */ case 3: /* lidt */ if (ir.mod == 3) { @@ -8036,11 +8102,10 @@ static const int i386_record_regmap[] = string. */ static int -i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch, - CORE_ADDR addr, int *isize, char **msg) +i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, + std::string *msg) { int len, jumplen; - static struct ui_file *gdb_null = NULL; /* Ask the target for the minimum instruction length supported. */ jumplen = target_get_min_fast_tracepoint_insn_len (); @@ -8063,33 +8128,44 @@ i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch, jumplen = (register_size (gdbarch, 0) == 8) ? 5 : 4; } - /* Dummy file descriptor for the disassembler. */ - if (!gdb_null) - gdb_null = ui_file_new (); - /* Check for fit. */ - len = gdb_print_insn (gdbarch, addr, gdb_null, NULL); - if (isize) - *isize = len; + len = gdb_insn_length (gdbarch, addr); if (len < jumplen) { /* Return a bit of target-specific detail to add to the caller's generic failure message. */ if (msg) - *msg = xstrprintf (_("; instruction is only %d bytes long, " - "need at least %d bytes for the jump"), - len, jumplen); + *msg = string_printf (_("; instruction is only %d bytes long, " + "need at least %d bytes for the jump"), + len, jumplen); return 0; } else { if (msg) - *msg = NULL; + msg->clear (); return 1; } } +/* Return a floating-point format for a floating-point variable of + length LEN in bits. If non-NULL, NAME is the name of its type. + If no suitable type is found, return NULL. */ + +const struct floatformat ** +i386_floatformat_for_type (struct gdbarch *gdbarch, + const char *name, int len) +{ + if (len == 128 && name) + if (strcmp (name, "__float128") == 0 + || strcmp (name, "_Float128") == 0 + || strcmp (name, "complex _Float128") == 0) + return floatformats_ia64_quad; + + return default_floatformat_for_type (gdbarch, name, len); +} + static int i386_validate_tdesc_p (struct gdbarch_tdep *tdep, struct tdesc_arch_data *tdesc_data) @@ -8098,7 +8174,7 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep, const struct tdesc_feature *feature_core; const struct tdesc_feature *feature_sse, *feature_avx, *feature_mpx, - *feature_avx512; + *feature_avx512, *feature_pkeys; int i, num_regs, valid_p; if (! tdesc_has_registers (tdesc)) @@ -8121,6 +8197,9 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep, /* Try AVX512 registers. */ feature_avx512 = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx512"); + /* Try PKEYS */ + feature_pkeys = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.pkeys"); + valid_p = 1; /* The XCR0 bits. */ @@ -8130,7 +8209,7 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep, if (!feature_avx) return 0; - tdep->xcr0 = X86_XSTATE_MPX_AVX512_MASK; + tdep->xcr0 = X86_XSTATE_AVX_AVX512_MASK; /* It may have been set by OSABI initialization function. */ if (tdep->k0_regnum < 0) @@ -8227,10 +8306,53 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep, tdep->mpx_register_names[i]); } + if (feature_pkeys) + { + tdep->xcr0 |= X86_XSTATE_PKRU; + if (tdep->pkru_regnum < 0) + { + tdep->pkeys_register_names = i386_pkeys_names; + tdep->pkru_regnum = I386_PKRU_REGNUM; + tdep->num_pkeys_regs = 1; + } + + for (i = 0; i < I387_NUM_PKEYS_REGS; i++) + valid_p &= tdesc_numbered_register (feature_pkeys, tdesc_data, + I387_PKRU_REGNUM (tdep) + i, + tdep->pkeys_register_names[i]); + } + return valid_p; } + +/* Implement the type_align gdbarch function. */ + +static ULONGEST +i386_type_align (struct gdbarch *gdbarch, struct type *type) +{ + type = check_typedef (type); + + if (gdbarch_ptr_bit (gdbarch) == 32) + { + if ((TYPE_CODE (type) == TYPE_CODE_INT + || TYPE_CODE (type) == TYPE_CODE_FLT) + && TYPE_LENGTH (type) > 4) + return 4; + + /* Handle x86's funny long double. */ + if (TYPE_CODE (type) == TYPE_CODE_FLT + && gdbarch_long_double_bit (gdbarch) == TYPE_LENGTH (type) * 8) + return 4; + } + + return TYPE_LENGTH (type); +} + + +/* Note: This is called for both i386 and amd64. */ + static struct gdbarch * i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) { @@ -8242,15 +8364,13 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) int ymm0_regnum; int bnd0_regnum; int num_bnd_cooked; - int k0_regnum; - int zmm0_regnum; /* If there is already a candidate, use it. */ arches = gdbarch_list_lookup_by_info (arches, &info); if (arches != NULL) return arches->gdbarch; - /* Allocate space for the new architecture. */ + /* Allocate space for the new architecture. Assume i386 for now. */ tdep = XCNEW (struct gdbarch_tdep); gdbarch = gdbarch_alloc (&info, tdep); @@ -8288,7 +8408,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep->record_regmap = i386_record_regmap; - set_gdbarch_long_long_align_bit (gdbarch, 32); + set_gdbarch_type_align (gdbarch, i386_type_align); /* The format used for `long double' on almost all i386 targets is the i387 extended floating-point format. In fact, of all targets @@ -8301,6 +8421,9 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) alignment. */ set_gdbarch_long_double_bit (gdbarch, 96); + /* Support for floating-point data type variants. */ + set_gdbarch_floatformat_for_type (gdbarch, i386_floatformat_for_type); + /* Register numbers of various important registers. */ set_gdbarch_sp_regnum (gdbarch, I386_ESP_REGNUM); /* %esp */ set_gdbarch_pc_regnum (gdbarch, I386_EIP_REGNUM); /* %eip */ @@ -8342,7 +8465,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_sdb_reg_to_regnum (gdbarch, i386_dbx_reg_to_regnum); /* Use the SVR4 register numbering scheme for DWARF 2. */ - set_gdbarch_dwarf2_reg_to_regnum (gdbarch, i386_svr4_reg_to_regnum); + set_gdbarch_dwarf2_reg_to_regnum (gdbarch, i386_svr4_dwarf_reg_to_regnum); /* We don't set gdbarch_stab_reg_to_regnum, since ECOFF doesn't seem to be in use on any of the supported i386 targets. */ @@ -8368,7 +8491,9 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Stack grows downward. */ set_gdbarch_inner_than (gdbarch, core_addr_lessthan); - set_gdbarch_breakpoint_from_pc (gdbarch, i386_breakpoint_from_pc); + set_gdbarch_breakpoint_kind_from_pc (gdbarch, i386_breakpoint::kind_from_pc); + set_gdbarch_sw_breakpoint_from_kind (gdbarch, i386_breakpoint::bp_from_kind); + set_gdbarch_decr_pc_after_break (gdbarch, 1); set_gdbarch_max_insn_length (gdbarch, I386_MAX_INSN_LEN); @@ -8404,6 +8529,8 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_pseudo_register_read_value (gdbarch, i386_pseudo_register_read_value); set_gdbarch_pseudo_register_write (gdbarch, i386_pseudo_register_write); + set_gdbarch_ax_pseudo_register_collect (gdbarch, + i386_ax_pseudo_register_collect); set_tdesc_pseudo_register_type (gdbarch, i386_pseudo_register_type); set_tdesc_pseudo_register_name (gdbarch, i386_pseudo_register_name); @@ -8415,14 +8542,14 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* Even though the default ABI only includes general-purpose registers, floating-point registers and the SSE registers, we have to leave a gap for the upper AVX, MPX and AVX512 registers. */ - set_gdbarch_num_regs (gdbarch, I386_AVX512_NUM_REGS); + set_gdbarch_num_regs (gdbarch, I386_PKEYS_NUM_REGS); set_gdbarch_gnu_triplet_regexp (gdbarch, i386_gnu_triplet_regexp); /* Get the x86 target description from INFO. */ tdesc = info.target_desc; if (! tdesc_has_registers (tdesc)) - tdesc = tdesc_i386; + tdesc = i386_target_description (X86_XSTATE_SSE_MASK); tdep->tdesc = tdesc; tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS; @@ -8460,6 +8587,10 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep->num_ymm_avx512_regs = 0; tdep->num_xmm_avx512_regs = 0; + /* No PKEYS registers */ + tdep->pkru_regnum = -1; + tdep->num_pkeys_regs = 0; + tdesc_data = tdesc_data_alloc (); set_gdbarch_relocate_instruction (gdbarch, i386_relocate_instruction); @@ -8470,8 +8601,10 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) set_gdbarch_insn_is_ret (gdbarch, i386_insn_is_ret); set_gdbarch_insn_is_jump (gdbarch, i386_insn_is_jump); - /* Hook in ABI-specific overrides, if they have been registered. */ - info.tdep_info = (void *) tdesc_data; + /* Hook in ABI-specific overrides, if they have been registered. + Note: If INFO specifies a 64 bit arch, this is where we turn + a 32-bit i386 into a 64-bit amd64. */ + info.tdesc_data = tdesc_data; gdbarch_init_osabi (info, gdbarch); if (!i386_validate_tdesc_p (tdep, tdesc_data)) @@ -8578,19 +8711,283 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) return gdbarch; } -static enum gdb_osabi -i386_coff_osabi_sniffer (bfd *abfd) + + +/* Return the target description for a specified XSAVE feature mask. */ + +const struct target_desc * +i386_target_description (uint64_t xcr0) { - if (strcmp (bfd_get_target (abfd), "coff-go32-exe") == 0 - || strcmp (bfd_get_target (abfd), "coff-go32") == 0) - return GDB_OSABI_GO32; + static target_desc *i386_tdescs \ + [2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/] = {}; + target_desc **tdesc; + + tdesc = &i386_tdescs[(xcr0 & X86_XSTATE_SSE) ? 1 : 0] + [(xcr0 & X86_XSTATE_AVX) ? 1 : 0] + [(xcr0 & X86_XSTATE_MPX) ? 1 : 0] + [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0] + [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]; - return GDB_OSABI_UNKNOWN; + if (*tdesc == NULL) + *tdesc = i386_create_target_description (xcr0, false); + + return *tdesc; } - -/* Provide a prototype to silence -Wmissing-prototypes. */ -void _initialize_i386_tdep (void); +#define MPX_BASE_MASK (~(ULONGEST) 0xfff) + +/* Find the bound directory base address. */ + +static unsigned long +i386_mpx_bd_base (void) +{ + struct regcache *rcache; + struct gdbarch_tdep *tdep; + ULONGEST ret; + enum register_status regstatus; + + rcache = get_current_regcache (); + tdep = gdbarch_tdep (rcache->arch ()); + + regstatus = regcache_raw_read_unsigned (rcache, tdep->bndcfgu_regnum, &ret); + + if (regstatus != REG_VALID) + error (_("BNDCFGU register invalid, read status %d."), regstatus); + + return ret & MPX_BASE_MASK; +} + +int +i386_mpx_enabled (void) +{ + const struct gdbarch_tdep *tdep = gdbarch_tdep (get_current_arch ()); + const struct target_desc *tdesc = tdep->tdesc; + + return (tdesc_find_feature (tdesc, "org.gnu.gdb.i386.mpx") != NULL); +} + +#define MPX_BD_MASK 0xfffffff00000ULL /* select bits [47:20] */ +#define MPX_BT_MASK 0x0000000ffff8 /* select bits [19:3] */ +#define MPX_BD_MASK_32 0xfffff000 /* select bits [31:12] */ +#define MPX_BT_MASK_32 0x00000ffc /* select bits [11:2] */ + +/* Find the bound table entry given the pointer location and the base + address of the table. */ + +static CORE_ADDR +i386_mpx_get_bt_entry (CORE_ADDR ptr, CORE_ADDR bd_base) +{ + CORE_ADDR offset1; + CORE_ADDR offset2; + CORE_ADDR mpx_bd_mask, bd_ptr_r_shift, bd_ptr_l_shift; + CORE_ADDR bt_mask, bt_select_r_shift, bt_select_l_shift; + CORE_ADDR bd_entry_addr; + CORE_ADDR bt_addr; + CORE_ADDR bd_entry; + struct gdbarch *gdbarch = get_current_arch (); + struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr; + + + if (gdbarch_ptr_bit (gdbarch) == 64) + { + mpx_bd_mask = (CORE_ADDR) MPX_BD_MASK; + bd_ptr_r_shift = 20; + bd_ptr_l_shift = 3; + bt_select_r_shift = 3; + bt_select_l_shift = 5; + bt_mask = (CORE_ADDR) MPX_BT_MASK; + + if ( sizeof (CORE_ADDR) == 4) + error (_("bound table examination not supported\ + for 64-bit process with 32-bit GDB")); + } + else + { + mpx_bd_mask = MPX_BD_MASK_32; + bd_ptr_r_shift = 12; + bd_ptr_l_shift = 2; + bt_select_r_shift = 2; + bt_select_l_shift = 4; + bt_mask = MPX_BT_MASK_32; + } + + offset1 = ((ptr & mpx_bd_mask) >> bd_ptr_r_shift) << bd_ptr_l_shift; + bd_entry_addr = bd_base + offset1; + bd_entry = read_memory_typed_address (bd_entry_addr, data_ptr_type); + + if ((bd_entry & 0x1) == 0) + error (_("Invalid bounds directory entry at %s."), + paddress (get_current_arch (), bd_entry_addr)); + + /* Clearing status bit. */ + bd_entry--; + bt_addr = bd_entry & ~bt_select_r_shift; + offset2 = ((ptr & bt_mask) >> bt_select_r_shift) << bt_select_l_shift; + + return bt_addr + offset2; +} + +/* Print routine for the mpx bounds. */ + +static void +i386_mpx_print_bounds (const CORE_ADDR bt_entry[4]) +{ + struct ui_out *uiout = current_uiout; + LONGEST size; + struct gdbarch *gdbarch = get_current_arch (); + CORE_ADDR onecompl = ~((CORE_ADDR) 0); + int bounds_in_map = ((~bt_entry[1] == 0 && bt_entry[0] == onecompl) ? 1 : 0); + + if (bounds_in_map == 1) + { + uiout->text ("Null bounds on map:"); + uiout->text (" pointer value = "); + uiout->field_core_addr ("pointer-value", gdbarch, bt_entry[2]); + uiout->text ("."); + uiout->text ("\n"); + } + else + { + uiout->text ("{lbound = "); + uiout->field_core_addr ("lower-bound", gdbarch, bt_entry[0]); + uiout->text (", ubound = "); + + /* The upper bound is stored in 1's complement. */ + uiout->field_core_addr ("upper-bound", gdbarch, ~bt_entry[1]); + uiout->text ("}: pointer value = "); + uiout->field_core_addr ("pointer-value", gdbarch, bt_entry[2]); + + if (gdbarch_ptr_bit (gdbarch) == 64) + size = ( (~(int64_t) bt_entry[1]) - (int64_t) bt_entry[0]); + else + size = ( ~((int32_t) bt_entry[1]) - (int32_t) bt_entry[0]); + + /* In case the bounds are 0x0 and 0xffff... the difference will be -1. + -1 represents in this sense full memory access, and there is no need + one to the size. */ + + size = (size > -1 ? size + 1 : size); + uiout->text (", size = "); + uiout->field_fmt ("size", "%s", plongest (size)); + + uiout->text (", metadata = "); + uiout->field_core_addr ("metadata", gdbarch, bt_entry[3]); + uiout->text ("\n"); + } +} + +/* Implement the command "show mpx bound". */ + +static void +i386_mpx_info_bounds (const char *args, int from_tty) +{ + CORE_ADDR bd_base = 0; + CORE_ADDR addr; + CORE_ADDR bt_entry_addr = 0; + CORE_ADDR bt_entry[4]; + int i; + struct gdbarch *gdbarch = get_current_arch (); + struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr; + + if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_i386 + || !i386_mpx_enabled ()) + { + printf_unfiltered (_("Intel Memory Protection Extensions not " + "supported on this target.\n")); + return; + } + + if (args == NULL) + { + printf_unfiltered (_("Address of pointer variable expected.\n")); + return; + } + + addr = parse_and_eval_address (args); + + bd_base = i386_mpx_bd_base (); + bt_entry_addr = i386_mpx_get_bt_entry (addr, bd_base); + + memset (bt_entry, 0, sizeof (bt_entry)); + + for (i = 0; i < 4; i++) + bt_entry[i] = read_memory_typed_address (bt_entry_addr + + i * TYPE_LENGTH (data_ptr_type), + data_ptr_type); + + i386_mpx_print_bounds (bt_entry); +} + +/* Implement the command "set mpx bound". */ + +static void +i386_mpx_set_bounds (const char *args, int from_tty) +{ + CORE_ADDR bd_base = 0; + CORE_ADDR addr, lower, upper; + CORE_ADDR bt_entry_addr = 0; + CORE_ADDR bt_entry[2]; + const char *input = args; + int i; + struct gdbarch *gdbarch = get_current_arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr; + + if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_i386 + || !i386_mpx_enabled ()) + error (_("Intel Memory Protection Extensions not supported\ + on this target.")); + + if (args == NULL) + error (_("Pointer value expected.")); + + addr = value_as_address (parse_to_comma_and_eval (&input)); + + if (input[0] == ',') + ++input; + if (input[0] == '\0') + error (_("wrong number of arguments: missing lower and upper bound.")); + lower = value_as_address (parse_to_comma_and_eval (&input)); + + if (input[0] == ',') + ++input; + if (input[0] == '\0') + error (_("Wrong number of arguments; Missing upper bound.")); + upper = value_as_address (parse_to_comma_and_eval (&input)); + + bd_base = i386_mpx_bd_base (); + bt_entry_addr = i386_mpx_get_bt_entry (addr, bd_base); + for (i = 0; i < 2; i++) + bt_entry[i] = read_memory_typed_address (bt_entry_addr + + i * TYPE_LENGTH (data_ptr_type), + data_ptr_type); + bt_entry[0] = (uint64_t) lower; + bt_entry[1] = ~(uint64_t) upper; + + for (i = 0; i < 2; i++) + write_memory_unsigned_integer (bt_entry_addr + + i * TYPE_LENGTH (data_ptr_type), + TYPE_LENGTH (data_ptr_type), byte_order, + bt_entry[i]); +} + +static struct cmd_list_element *mpx_set_cmdlist, *mpx_show_cmdlist; + +/* Helper function for the CLI commands. */ + +static void +set_mpx_cmd (const char *args, int from_tty) +{ + help_list (mpx_set_cmdlist, "set mpx ", all_commands, gdb_stdout); +} + +/* Helper function for the CLI commands. */ + +static void +show_mpx_cmd (const char *args, int from_tty) +{ + cmd_show_list (mpx_show_cmdlist, from_tty, ""); +} void _initialize_i386_tdep (void) @@ -8619,24 +9016,64 @@ is \"default\"."), NULL, /* FIXME: i18n: */ &setlist, &showlist); - gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour, - i386_coff_osabi_sniffer); + /* Add "mpx" prefix for the set commands. */ + + add_prefix_cmd ("mpx", class_support, set_mpx_cmd, _("\ +Set Intel Memory Protection Extensions specific variables."), + &mpx_set_cmdlist, "set mpx ", + 0 /* allow-unknown */, &setlist); + + /* Add "mpx" prefix for the show commands. */ + + add_prefix_cmd ("mpx", class_support, show_mpx_cmd, _("\ +Show Intel Memory Protection Extensions specific variables."), + &mpx_show_cmdlist, "show mpx ", + 0 /* allow-unknown */, &showlist); + + /* Add "bound" command for the show mpx commands list. */ + + add_cmd ("bound", no_class, i386_mpx_info_bounds, + "Show the memory bounds for a given array/pointer storage\ + in the bound table.", + &mpx_show_cmdlist); + + /* Add "bound" command for the set mpx commands list. */ + + add_cmd ("bound", no_class, i386_mpx_set_bounds, + "Set the memory bounds for a given array/pointer storage\ + in the bound table.", + &mpx_set_cmdlist); gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_SVR4, i386_svr4_init_abi); - gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_GO32, - i386_go32_init_abi); /* Initialize the i386-specific register groups. */ i386_init_reggroups (); - /* Initialize the standard target descriptions. */ - initialize_tdesc_i386 (); - initialize_tdesc_i386_mmx (); - initialize_tdesc_i386_avx (); - initialize_tdesc_i386_mpx (); - initialize_tdesc_i386_avx512 (); - /* Tell remote stub that we support XML target description. */ register_remote_support_xml ("i386"); + +#if GDB_SELF_TEST + struct + { + const char *xml; + uint64_t mask; + } xml_masks[] = { + { "i386/i386.xml", X86_XSTATE_SSE_MASK }, + { "i386/i386-mmx.xml", X86_XSTATE_X87_MASK }, + { "i386/i386-avx.xml", X86_XSTATE_AVX_MASK }, + { "i386/i386-mpx.xml", X86_XSTATE_MPX_MASK }, + { "i386/i386-avx-mpx.xml", X86_XSTATE_AVX_MPX_MASK }, + { "i386/i386-avx-avx512.xml", X86_XSTATE_AVX_AVX512_MASK }, + { "i386/i386-avx-mpx-avx512-pku.xml", + X86_XSTATE_AVX_MPX_AVX512_PKU_MASK }, + }; + + for (auto &a : xml_masks) + { + auto tdesc = i386_target_description (a.mask); + + selftests::record_xml_tdesc (a.xml, tdesc); + } +#endif /* GDB_SELF_TEST */ }