X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fi386-tdep.c;h=a19fc62e8d4ac3801c653bf810876184e2ca9a2d;hb=c17e02e1b55b5e9cbdc6581f05bfec96dc8436f4;hp=ec8b5d3b1bc5e3f5781eaaa6aa5c2e76251504a7;hpb=4a612d6f67d605f480ce7eec7fd9ca1cd1087b35;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c index ec8b5d3b1b..a19fc62e8d 100644 --- a/gdb/i386-tdep.c +++ b/gdb/i386-tdep.c @@ -1,6 +1,6 @@ /* Intel 386 target-dependent stuff. - Copyright (C) 1988-2017 Free Software Foundation, Inc. + Copyright (C) 1988-2020 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,23 +39,20 @@ #include "symfile.h" #include "symtab.h" #include "target.h" +#include "target-float.h" #include "value.h" #include "dis-asm.h" #include "disasm.h" #include "remote.h" #include "i386-tdep.h" #include "i387-tdep.h" -#include "x86-xstate.h" +#include "gdbsupport/x86-xstate.h" +#include "x86-tdep.h" #include "record.h" #include "record-full.h" -#include "features/i386/i386.c" -#include "features/i386/i386-avx.c" -#include "features/i386/i386-mpx.c" -#include "features/i386/i386-avx-mpx.c" -#include "features/i386/i386-avx-avx512.c" -#include "features/i386/i386-avx-mpx-avx512-pku.c" -#include "features/i386/i386-mmx.c" +#include "target-descriptions.h" +#include "arch/i386.h" #include "ax.h" #include "ax-gdb.h" @@ -68,6 +64,7 @@ #include "parser-defs.h" #include #include +#include /* Register names. */ @@ -522,7 +519,7 @@ i386_dbx_reg_to_regnum (struct gdbarch *gdbarch, int reg) } /* This will hopefully provoke a warning. */ - return gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); + return gdbarch_num_cooked_regs (gdbarch); } /* Convert SVR4 DWARF register number REG to the appropriate register number @@ -573,13 +570,13 @@ i386_svr4_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) /* Wrapper on i386_svr4_dwarf_reg_to_regnum to return num_regs + num_pseudo_regs for other debug formats. */ -static int +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 gdbarch_num_cooked_regs (gdbarch); return regnum; } @@ -799,8 +796,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, @@ -808,7 +804,8 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch, struct regcache *regs) { size_t len = gdbarch_max_insn_length (gdbarch); - gdb_byte *buf = (gdb_byte *) xmalloc (len); + i386_displaced_step_closure *closure = new i386_displaced_step_closure (len); + gdb_byte *buf = closure->buf.data (); read_memory (from, buf, len); @@ -833,7 +830,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 @@ -841,7 +838,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) { @@ -853,9 +850,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; @@ -1508,7 +1505,7 @@ struct i386_insn i386_frame_setup_skip_insns[] = /* Check for `mov imm32, r32'. Note that there is an alternative encoding for `mov m32, %eax'. - ??? Should we handle SIB adressing here? + ??? Should we handle SIB addressing here? ??? Should we handle 16-bit operand-sizes here? */ /* `movl m32, %eax' */ @@ -1625,7 +1622,7 @@ i386_analyze_frame_setup (struct gdbarch *gdbarch, /* Check for some special instructions that might be migrated by GCC into the prologue and skip them. At this point in the prologue, code should only touch the scratch registers %eax, - %ecx and %edx, so while the number of posibilities is sheer, + %ecx and %edx, so while the number of possibilities is sheer, it is limited. Make sure we only skip these instructions if we later see the @@ -1951,8 +1948,8 @@ i386_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc) call_dest = call_dest & 0xffffffffU; s = lookup_minimal_symbol_by_pc (call_dest); if (s.minsym != NULL - && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL - && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0) + && s.minsym->linkage_name () != NULL + && strcmp (s.minsym->linkage_name (), "__main") == 0) pc += 5; } } @@ -2086,16 +2083,15 @@ i386_frame_cache (struct frame_info *this_frame, void **this_cache) cache = i386_alloc_frame_cache (); *this_cache = cache; - TRY + try { i386_frame_cache_1 (this_frame, cache); } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { if (ex.error != NOT_AVAILABLE_ERROR) - throw_exception (ex); + throw; } - END_CATCH return cache; } @@ -2256,7 +2252,7 @@ i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache) cache = i386_alloc_frame_cache (); *this_cache = cache; - TRY + try { cache->pc = get_frame_func (this_frame); @@ -2270,12 +2266,11 @@ i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache) cache->base_p = 1; } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { if (ex.error != NOT_AVAILABLE_ERROR) - throw_exception (ex); + throw; } - END_CATCH return cache; } @@ -2442,7 +2437,7 @@ i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache) cache = i386_alloc_frame_cache (); - TRY + try { get_frame_register (this_frame, I386_ESP_REGNUM, buf); cache->base = extract_unsigned_integer (buf, 4, byte_order) - 4; @@ -2466,12 +2461,11 @@ i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache) cache->base_p = 1; } - CATCH (ex, RETURN_MASK_ERROR) + catch (const gdb_exception_error &ex) { if (ex.error != NOT_AVAILABLE_ERROR) - throw_exception (ex); + throw; } - END_CATCH *this_cache = cache; return cache; @@ -2675,7 +2669,8 @@ i386_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, 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, + struct value **args, CORE_ADDR sp, + function_call_return_method return_method, CORE_ADDR struct_addr) { enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); @@ -2699,7 +2694,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function, { int args_space_used = 0; - if (struct_return) + if (return_method == return_method_struct) { if (write_pass) { @@ -2759,10 +2754,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, @@ -2806,8 +2801,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 { @@ -2816,14 +2811,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 @@ -2862,8 +2857,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 @@ -2884,12 +2879,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__, @@ -2961,7 +2956,7 @@ i386_return_value (struct gdbarch *gdbarch, struct value *function, || code == TYPE_CODE_UNION || code == TYPE_CODE_ARRAY) && !i386_reg_struct_return_p (gdbarch, type)) - /* Complex double and long double uses the struct return covention. */ + /* Complex double and long double uses the struct return convention. */ || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 16) || (code == TYPE_CODE_COMPLEX && TYPE_LENGTH (type) == 24) /* 128-bit decimal float uses the struct return convention. */ @@ -3253,15 +3248,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; @@ -3274,7 +3269,7 @@ 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) { @@ -3287,7 +3282,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))); @@ -3302,9 +3297,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 @@ -3326,9 +3320,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 @@ -3341,18 +3333,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 @@ -3361,20 +3351,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 @@ -3382,9 +3370,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 @@ -3395,17 +3382,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 @@ -3415,17 +3400,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 @@ -3436,7 +3419,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))); @@ -3449,7 +3432,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch, /* 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))); @@ -3465,7 +3448,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; @@ -3490,11 +3473,11 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, 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 { @@ -3512,9 +3495,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; @@ -3522,18 +3504,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)) { @@ -3542,82 +3519,64 @@ 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)) { 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")); @@ -3844,7 +3803,7 @@ 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 = (const gdb_byte *) gregs; int i; @@ -3855,7 +3814,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]); } } @@ -3869,7 +3828,7 @@ 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 = (gdb_byte *) gregs; int i; @@ -3880,7 +3839,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]); } } @@ -3892,7 +3851,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) @@ -3915,7 +3874,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) @@ -3950,9 +3909,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); } @@ -3972,7 +3933,7 @@ i386_pe_skip_trampoline_code (struct frame_info *frame, read_memory_unsigned_integer (pc + 2, 4, byte_order); struct minimal_symbol *indsym = indirect ? lookup_minimal_symbol_by_pc (indirect).minsym : 0; - const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : 0; + const char *symname = indsym ? indsym->linkage_name () : 0; if (symname) { @@ -4009,11 +3970,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); } @@ -4075,10 +4034,10 @@ i386_stap_is_single_operand (struct gdbarch *gdbarch, const char *s) This function parses operands of the form `-8+3+1(%rbp)', which must be interpreted as `*(-8 + 3 - 1 + (void *) $eax)'. - Return 1 if the operand was parsed successfully, zero + Return true if the operand was parsed successfully, false otherwise. */ -static int +static bool i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, struct stap_parse_info *p) { @@ -4086,7 +4045,7 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, if (isdigit (*s) || *s == '-' || *s == '+') { - int got_minus[3]; + bool got_minus[3]; int i; long displacements[3]; const char *start; @@ -4095,17 +4054,17 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, struct stoken str; char *endp; - got_minus[0] = 0; + got_minus[0] = false; if (*s == '+') ++s; else if (*s == '-') { ++s; - got_minus[0] = 1; + got_minus[0] = true; } if (!isdigit ((unsigned char) *s)) - return 0; + return false; displacements[0] = strtol (s, &endp, 10); s = endp; @@ -4113,20 +4072,20 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, if (*s != '+' && *s != '-') { /* We are not dealing with a triplet. */ - return 0; + return false; } - got_minus[1] = 0; + got_minus[1] = false; if (*s == '+') ++s; else { ++s; - got_minus[1] = 1; + got_minus[1] = true; } if (!isdigit ((unsigned char) *s)) - return 0; + return false; displacements[1] = strtol (s, &endp, 10); s = endp; @@ -4134,26 +4093,26 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, if (*s != '+' && *s != '-') { /* We are not dealing with a triplet. */ - return 0; + return false; } - got_minus[2] = 0; + got_minus[2] = false; if (*s == '+') ++s; else { ++s; - got_minus[2] = 1; + got_minus[2] = true; } if (!isdigit ((unsigned char) *s)) - return 0; + return false; displacements[2] = strtol (s, &endp, 10); s = endp; if (*s != '(' || s[1] != '%') - return 0; + return false; s += 2; start = s; @@ -4162,7 +4121,7 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, ++s; if (*s++ != ')') - return 0; + return false; len = s - start - 1; regname = (char *) alloca (len + 1); @@ -4209,10 +4168,10 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, p->arg = s; - return 1; + return true; } - return 0; + return false; } /* Helper function for i386_stap_parse_special_token. @@ -4221,10 +4180,10 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch, (register index * size) + offset', as represented in `(%rcx,%rax,8)', or `[OFFSET](BASE_REG,INDEX_REG[,SIZE])'. - Return 1 if the operand was parsed successfully, zero + Return true if the operand was parsed successfully, false otherwise. */ -static int +static bool i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, struct stap_parse_info *p) { @@ -4232,9 +4191,9 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, if (isdigit (*s) || *s == '(' || *s == '-' || *s == '+') { - int offset_minus = 0; + bool offset_minus = false; long offset = 0; - int size_minus = 0; + bool size_minus = false; long size = 0; const char *start; char *base; @@ -4248,11 +4207,11 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, else if (*s == '-') { ++s; - offset_minus = 1; + offset_minus = true; } if (offset_minus && !isdigit (*s)) - return 0; + return false; if (isdigit (*s)) { @@ -4263,7 +4222,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, } if (*s != '(' || s[1] != '%') - return 0; + return false; s += 2; start = s; @@ -4272,7 +4231,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, ++s; if (*s != ',' || s[1] != '%') - return 0; + return false; len_base = s - start; base = (char *) alloca (len_base + 1); @@ -4299,7 +4258,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, index, p->saved_arg); if (*s != ',' && *s != ')') - return 0; + return false; if (*s == ',') { @@ -4311,14 +4270,14 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, else if (*s == '-') { ++s; - size_minus = 1; + size_minus = true; } size = strtol (s, &endp, 10); s = endp; if (*s != ')') - return 0; + return false; } ++s; @@ -4372,10 +4331,10 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch, p->arg = s; - return 1; + return true; } - return 0; + return false; } /* Implementation of `gdbarch_stap_parse_special_token', as defined in @@ -4427,6 +4386,29 @@ i386_stap_parse_special_token (struct gdbarch *gdbarch, return 0; } +/* Implementation of 'gdbarch_stap_adjust_register', as defined in + gdbarch.h. */ + +static std::string +i386_stap_adjust_register (struct gdbarch *gdbarch, struct stap_parse_info *p, + const std::string ®name, int regnum) +{ + static const std::unordered_set reg_assoc + = { "ax", "bx", "cx", "dx", + "si", "di", "bp", "sp" }; + + /* If we are dealing with a register whose size is less than the size + specified by the "[-]N@" prefix, and it is one of the registers that + we know has an extended variant available, then use the extended + version of the register instead. */ + if (register_size (gdbarch, regnum) < TYPE_LENGTH (p->arg_type) + && reg_assoc.find (regname) != reg_assoc.end ()) + return "e" + regname; + + /* Otherwise, just use the requested register. */ + return regname; +} + /* gdbarch gnu_triplet_regexp method. Both arches are acceptable as GDB always @@ -4440,6 +4422,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 @@ -4466,8 +4457,11 @@ i386_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) i386_stap_is_single_operand); set_gdbarch_stap_parse_special_token (gdbarch, i386_stap_parse_special_token); + set_gdbarch_stap_adjust_register (gdbarch, + i386_stap_adjust_register); - 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). */ @@ -4491,33 +4485,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" @@ -4554,8 +4521,8 @@ 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, + 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 @@ -7165,6 +7132,7 @@ Do you want to stop the program?"), else if (ir.rm == 1) break; } + /* Fall through. */ case 3: /* lidt */ if (ir.mod == 3) { @@ -8159,7 +8127,7 @@ static const int i386_record_regmap[] = static int i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, - char **msg) + std::string *msg) { int len, jumplen; @@ -8192,15 +8160,15 @@ i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, /* 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; } } @@ -8209,14 +8177,16 @@ i386_fast_tracepoint_valid_at (struct gdbarch *gdbarch, CORE_ADDR addr, 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 ** +static 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) + || strcmp (name, "complex _Float128") == 0 + || strcmp (name, "complex(kind=16)") == 0 + || strcmp (name, "real(kind=16)") == 0) return floatformats_ia64_quad; return default_floatformat_for_type (gdbarch, name, len); @@ -8230,7 +8200,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_pkeys; + *feature_avx512, *feature_pkeys, *feature_segments; int i, num_regs, valid_p; if (! tdesc_has_registers (tdesc)) @@ -8253,6 +8223,9 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep, /* Try AVX512 registers. */ feature_avx512 = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx512"); + /* Try segment base registers. */ + feature_segments = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.segments"); + /* Try PKEYS */ feature_pkeys = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.pkeys"); @@ -8362,6 +8335,16 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep, tdep->mpx_register_names[i]); } + if (feature_segments) + { + if (tdep->fsbase_regnum < 0) + tdep->fsbase_regnum = I386_FSBASE_REGNUM; + valid_p &= tdesc_numbered_register (feature_segments, tdesc_data, + tdep->fsbase_regnum, "fs_base"); + valid_p &= tdesc_numbered_register (feature_segments, tdesc_data, + tdep->fsbase_regnum + 1, "gs_base"); + } + if (feature_pkeys) { tdep->xcr0 |= X86_XSTATE_PKRU; @@ -8381,6 +8364,31 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep, 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 0; +} + /* Note: This is called for both i386 and amd64. */ @@ -8439,7 +8447,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 @@ -8573,14 +8581,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_PKEYS_NUM_REGS); + set_gdbarch_num_regs (gdbarch, I386_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, false); tdep->tdesc = tdesc; tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS; @@ -8622,6 +8630,9 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) tdep->pkru_regnum = -1; tdep->num_pkeys_regs = 0; + /* No segment base registers. */ + tdep->fsbase_regnum = -1; + tdesc_data = tdesc_data_alloc (); set_gdbarch_relocate_instruction (gdbarch, i386_relocate_instruction); @@ -8635,7 +8646,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* 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.tdep_info = tdesc_data; + info.tdesc_data = tdesc_data; gdbarch_init_osabi (info, gdbarch); if (!i386_validate_tdesc_p (tdep, tdesc_data)) @@ -8742,37 +8753,28 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) return gdbarch; } -static enum gdb_osabi -i386_coff_osabi_sniffer (bfd *abfd) -{ - if (strcmp (bfd_get_target (abfd), "coff-go32-exe") == 0 - || strcmp (bfd_get_target (abfd), "coff-go32") == 0) - return GDB_OSABI_GO32; - - return GDB_OSABI_UNKNOWN; -} /* Return the target description for a specified XSAVE feature mask. */ const struct target_desc * -i386_target_description (uint64_t xcr0) -{ - switch (xcr0 & X86_XSTATE_ALL_MASK) - { - case X86_XSTATE_AVX_MPX_AVX512_PKU_MASK: - return tdesc_i386_avx_mpx_avx512_pku; - case X86_XSTATE_AVX_AVX512_MASK: - return tdesc_i386_avx_avx512; - case X86_XSTATE_AVX_MPX_MASK: - return tdesc_i386_avx_mpx; - case X86_XSTATE_MPX_MASK: - return tdesc_i386_mpx; - case X86_XSTATE_AVX_MASK: - return tdesc_i386_avx; - default: - return tdesc_i386; - } +i386_target_description (uint64_t xcr0, bool segments) +{ + static target_desc *i386_tdescs \ + [2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/][2/*segments*/] = {}; + 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] + [segments ? 1 : 0]; + + if (*tdesc == NULL) + *tdesc = i386_create_target_description (xcr0, false, segments); + + return *tdesc; } #define MPX_BASE_MASK (~(ULONGEST) 0xfff) @@ -8788,7 +8790,7 @@ i386_mpx_bd_base (void) enum register_status regstatus; rcache = get_current_regcache (); - tdep = gdbarch_tdep (get_regcache_arch (rcache)); + tdep = gdbarch_tdep (rcache->arch ()); regstatus = regcache_raw_read_unsigned (rcache, tdep->bndcfgu_regnum, &ret); @@ -8909,7 +8911,7 @@ i386_mpx_print_bounds (const CORE_ADDR bt_entry[4]) size = (size > -1 ? size + 1 : size); uiout->text (", size = "); - uiout->field_fmt ("size", "%s", plongest (size)); + uiout->field_string ("size", plongest (size)); uiout->text (", metadata = "); uiout->field_core_addr ("metadata", gdbarch, bt_entry[3]); @@ -8920,7 +8922,7 @@ i386_mpx_print_bounds (const CORE_ADDR bt_entry[4]) /* Implement the command "show mpx bound". */ static void -i386_mpx_info_bounds (char *args, int from_tty) +i386_mpx_info_bounds (const char *args, int from_tty) { CORE_ADDR bd_base = 0; CORE_ADDR addr; @@ -8962,7 +8964,7 @@ i386_mpx_info_bounds (char *args, int from_tty) /* Implement the command "set mpx bound". */ static void -i386_mpx_set_bounds (char *args, int from_tty) +i386_mpx_set_bounds (const char *args, int from_tty) { CORE_ADDR bd_base = 0; CORE_ADDR addr, lower, upper; @@ -9017,7 +9019,7 @@ static struct cmd_list_element *mpx_set_cmdlist, *mpx_show_cmdlist; /* Helper function for the CLI commands. */ static void -set_mpx_cmd (char *args, int from_tty) +set_mpx_cmd (const char *args, int from_tty) { help_list (mpx_set_cmdlist, "set mpx ", all_commands, gdb_stdout); } @@ -9025,14 +9027,11 @@ set_mpx_cmd (char *args, int from_tty) /* Helper function for the CLI commands. */ static void -show_mpx_cmd (char *args, int from_tty) +show_mpx_cmd (const char *args, int from_tty) { cmd_show_list (mpx_show_cmdlist, from_tty, ""); } -/* Provide a prototype to silence -Wmissing-prototypes. */ -void _initialize_i386_tdep (void); - void _initialize_i386_tdep (void) { @@ -9088,26 +9087,12 @@ Show Intel Memory Protection Extensions specific variables."), in the bound table.", &mpx_set_cmdlist); - gdbarch_register_osabi_sniffer (bfd_arch_i386, bfd_target_coff_flavour, - i386_coff_osabi_sniffer); - 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_avx_mpx (); - initialize_tdesc_i386_avx_avx512 (); - initialize_tdesc_i386_avx_mpx_avx512_pku (); - /* Tell remote stub that we support XML target description. */ register_remote_support_xml ("i386"); }