gdb: add target_ops::supports_displaced_step

[deliverable/binutils-gdb.git] / gdb / i386-tdep.c

diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index b359254c75f092931e297c9613c8a8f50dd76fff..1f2acae4e5c6f67a31f166eb1e0b6c92967f825e 100644 (file)
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -1,6 +1,6 @@
 /* Intel 386 target-dependent stuff.
 
 /* Intel 386 target-dependent stuff.
 

-   Copyright (C) 1988-2018 Free Software Foundation, Inc.
+   Copyright (C) 1988-2020 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -22,7 +22,7 @@
 #include "arch-utils.h"
 #include "command.h"
 #include "dummy-frame.h"
 #include "arch-utils.h"
 #include "command.h"
 #include "dummy-frame.h"

-#include "dwarf2-frame.h"
+#include "dwarf2/frame.h"

 #include "frame.h"
 #include "frame-base.h"
 #include "frame-unwind.h"
 #include "frame.h"
 #include "frame-base.h"
 #include "frame-unwind.h"


@@ -46,7 +46,7 @@
 #include "remote.h"
 #include "i386-tdep.h"
 #include "i387-tdep.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 "x86-tdep.h"
 
 #include "record.h"


@@ -64,6 +64,7 @@
 #include "parser-defs.h"
 #include <ctype.h>
 #include <algorithm>
 #include "parser-defs.h"
 #include <ctype.h>
 #include <algorithm>

+#include <unordered_set>

 
 /* Register names.  */
 
 
 /* Register names.  */
 


@@ -518,7 +519,7 @@ i386_dbx_reg_to_regnum (struct gdbarch *gdbarch, int reg)
     }
 
   /* This will hopefully provoke a warning.  */
     }
 
   /* 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
 }
 
 /* Convert SVR4 DWARF register number REG to the appropriate register number


@@ -575,7 +576,7 @@ i386_svr4_reg_to_regnum (struct gdbarch *gdbarch, int reg)
   int regnum = i386_svr4_dwarf_reg_to_regnum (gdbarch, reg);
 
   if (regnum == -1)
   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;
 }
 
   return regnum;
 }
 


@@ -797,13 +798,14 @@ i386_insn_is_jump (struct gdbarch *gdbarch, CORE_ADDR addr)
 
 /* Some kernels may run one past a syscall insn, so we have to cope.  */
 
 
 /* Some kernels may run one past a syscall insn, so we have to cope.  */
 

-struct displaced_step_closure *
+displaced_step_copy_insn_closure_up

 i386_displaced_step_copy_insn (struct gdbarch *gdbarch,
                               CORE_ADDR from, CORE_ADDR to,
                               struct regcache *regs)
 {
   size_t len = gdbarch_max_insn_length (gdbarch);
 i386_displaced_step_copy_insn (struct gdbarch *gdbarch,
                               CORE_ADDR from, CORE_ADDR to,
                               struct regcache *regs)
 {
   size_t len = gdbarch_max_insn_length (gdbarch);

-  i386_displaced_step_closure *closure = new i386_displaced_step_closure (len);
+  std::unique_ptr<i386_displaced_step_copy_insn_closure> closure
+    (new i386_displaced_step_copy_insn_closure (len));

   gdb_byte *buf = closure->buf.data ();
 
   read_memory (from, buf, len);
   gdb_byte *buf = closure->buf.data ();
 
   read_memory (from, buf, len);


@@ -829,7 +831,8 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch,
       displaced_step_dump_bytes (gdb_stdlog, buf, len);
     }
 
       displaced_step_dump_bytes (gdb_stdlog, buf, len);
     }
 

-  return closure;
+  /* This is a work around for a problem with g++ 4.8.  */
+  return displaced_step_copy_insn_closure_up (closure.release ());

 }
 
 /* Fix up the state of registers and memory after having single-stepped
 }
 
 /* Fix up the state of registers and memory after having single-stepped


@@ -837,7 +840,7 @@ i386_displaced_step_copy_insn (struct gdbarch *gdbarch,
 
 void
 i386_displaced_step_fixup (struct gdbarch *gdbarch,
 
 void
 i386_displaced_step_fixup (struct gdbarch *gdbarch,

-                           struct displaced_step_closure *closure_,
+                           struct displaced_step_copy_insn_closure *closure_,

                            CORE_ADDR from, CORE_ADDR to,
                            struct regcache *regs)
 {
                            CORE_ADDR from, CORE_ADDR to,
                            struct regcache *regs)
 {


@@ -849,8 +852,8 @@ i386_displaced_step_fixup (struct gdbarch *gdbarch,
      applying it.  */
   ULONGEST insn_offset = to - from;
 
      applying it.  */
   ULONGEST insn_offset = to - from;
 

-  i386_displaced_step_closure *closure
-    = (i386_displaced_step_closure *) closure_;
+  i386_displaced_step_copy_insn_closure *closure
+    = (i386_displaced_step_copy_insn_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;
   gdb_byte *insn = closure->buf.data ();
   /* The start of the insn, needed in case we see some prefixes.  */
   gdb_byte *insn_start = insn;


@@ -1504,7 +1507,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'.
 
   /* 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' */
      ??? Should we handle 16-bit operand-sizes here?  */
 
   /* `movl m32, %eax' */


@@ -1621,7 +1624,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,
       /* 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
         it is limited.
 
         Make sure we only skip these instructions if we later see the


@@ -1947,8 +1950,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
          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;
        }
     }
            pc += 5;
        }
     }


@@ -2082,16 +2085,15 @@ i386_frame_cache (struct frame_info *this_frame, void **this_cache)
   cache = i386_alloc_frame_cache ();
   *this_cache = cache;
 
   cache = i386_alloc_frame_cache ();
   *this_cache = cache;
 

-  TRY
+  try

     {
       i386_frame_cache_1 (this_frame, cache);
     }
     {
       i386_frame_cache_1 (this_frame, cache);
     }

-  CATCH (ex, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &ex)

     {
       if (ex.error != NOT_AVAILABLE_ERROR)
     {
       if (ex.error != NOT_AVAILABLE_ERROR)

-       throw_exception (ex);
+       throw;

     }
     }

-  END_CATCH

 
   return cache;
 }
 
   return cache;
 }


@@ -2252,7 +2254,7 @@ i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
   cache = i386_alloc_frame_cache ();
   *this_cache = cache;
 
   cache = i386_alloc_frame_cache ();
   *this_cache = cache;
 

-  TRY
+  try

     {
       cache->pc = get_frame_func (this_frame);
 
     {
       cache->pc = get_frame_func (this_frame);
 


@@ -2266,12 +2268,11 @@ i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_cache)
 
       cache->base_p = 1;
     }
 
       cache->base_p = 1;
     }

-  CATCH (ex, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &ex)

     {
       if (ex.error != NOT_AVAILABLE_ERROR)
     {
       if (ex.error != NOT_AVAILABLE_ERROR)

-       throw_exception (ex);
+       throw;

     }
     }

-  END_CATCH

 
   return cache;
 }
 
   return cache;
 }


@@ -2438,7 +2439,7 @@ i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
 
   cache = i386_alloc_frame_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;
     {
       get_frame_register (this_frame, I386_ESP_REGNUM, buf);
       cache->base = extract_unsigned_integer (buf, 4, byte_order) - 4;


@@ -2462,12 +2463,11 @@ i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
 
       cache->base_p = 1;
     }
 
       cache->base_p = 1;
     }

-  CATCH (ex, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &ex)

     {
       if (ex.error != NOT_AVAILABLE_ERROR)
     {
       if (ex.error != NOT_AVAILABLE_ERROR)

-       throw_exception (ex);
+       throw;

     }
     }

-  END_CATCH

 
   *this_cache = cache;
   return cache;
 
   *this_cache = cache;
   return cache;


@@ -2633,17 +2633,17 @@ static int
 i386_16_byte_align_p (struct type *type)
 {
   type = check_typedef (type);
 i386_16_byte_align_p (struct type *type)
 {
   type = check_typedef (type);

-  if ((TYPE_CODE (type) == TYPE_CODE_DECFLOAT
-       || (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)))
+  if ((type->code () == TYPE_CODE_DECFLOAT
+       || (type->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type)))

       && TYPE_LENGTH (type) == 16)
     return 1;
       && TYPE_LENGTH (type) == 16)
     return 1;

-  if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+  if (type->code () == TYPE_CODE_ARRAY)

     return i386_16_byte_align_p (TYPE_TARGET_TYPE (type));
     return i386_16_byte_align_p (TYPE_TARGET_TYPE (type));

-  if (TYPE_CODE (type) == TYPE_CODE_STRUCT
-      || TYPE_CODE (type) == TYPE_CODE_UNION)
+  if (type->code () == TYPE_CODE_STRUCT
+      || type->code () == TYPE_CODE_UNION)

     {
       int i;
     {
       int i;

-      for (i = 0; i < TYPE_NFIELDS (type); i++)
+      for (i = 0; i < type->num_fields (); i++)

        {
          if (i386_16_byte_align_p (TYPE_FIELD_TYPE (type, i)))
            return 1;
        {
          if (i386_16_byte_align_p (TYPE_FIELD_TYPE (type, i)))
            return 1;


@@ -2668,11 +2668,15 @@ i386_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr,
   return sp - 16;
 }
 
   return sp - 16;
 }
 

-static CORE_ADDR
-i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
-                     struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
-                     struct value **args, CORE_ADDR sp, int struct_return,
-                     CORE_ADDR struct_addr)
+/* The "push_dummy_call" gdbarch method, optionally with the thiscall
+   calling convention.  */
+
+CORE_ADDR
+i386_thiscall_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
+                              struct regcache *regcache, CORE_ADDR bp_addr,
+                              int nargs, struct value **args, CORE_ADDR sp,
+                              function_call_return_method return_method,
+                              CORE_ADDR struct_addr, bool thiscall)

 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   gdb_byte buf[4];
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   gdb_byte buf[4];


@@ -2695,7 +2699,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     {
       int args_space_used = 0;
 
     {
       int args_space_used = 0;
 

-      if (struct_return)
+      if (return_method == return_method_struct)

        {
          if (write_pass)
            {
        {
          if (write_pass)
            {


@@ -2708,7 +2712,7 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
            args_space += 4;
        }
 
            args_space += 4;
        }
 

-      for (i = 0; i < nargs; i++)
+      for (i = thiscall ? 1 : 0; i < nargs; i++)

        {
          int len = TYPE_LENGTH (value_enclosing_type (args[i]));
 
        {
          int len = TYPE_LENGTH (value_enclosing_type (args[i]));
 


@@ -2755,10 +2759,14 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 
   /* Finally, update the stack pointer...  */
   store_unsigned_integer (buf, 4, byte_order, sp);
 
   /* 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.  */
 
   /* ...and fake a frame pointer.  */

-  regcache_cooked_write (regcache, I386_EBP_REGNUM, buf);
+  regcache->cooked_write (I386_EBP_REGNUM, buf);
+
+  /* The 'this' pointer needs to be in ECX.  */
+  if (thiscall)
+    regcache->cooked_write (I386_ECX_REGNUM, value_contents_all (args[0]));

 
   /* MarkK wrote: This "+ 8" is all over the place:
      (i386_frame_this_id, i386_sigtramp_frame_this_id,
 
   /* MarkK wrote: This "+ 8" is all over the place:
      (i386_frame_this_id, i386_sigtramp_frame_this_id,


@@ -2772,6 +2780,20 @@ i386_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   return sp + 8;
 }
 
   return sp + 8;
 }
 

+/* Implement the "push_dummy_call" gdbarch method.  */
+
+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,
+                     function_call_return_method return_method,
+                     CORE_ADDR struct_addr)
+{
+  return i386_thiscall_push_dummy_call (gdbarch, function, regcache, bp_addr,
+                                       nargs, args, sp, return_method,
+                                       struct_addr, false);
+}
+

 /* These registers are used for returning integers (and on some
    targets also for returning `struct' and `union' values when their
    size and alignment match an integer type).  */
 /* These registers are used for returning integers (and on some
    targets also for returning `struct' and `union' values when their
    size and alignment match an integer type).  */


@@ -2789,7 +2811,7 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
   int len = TYPE_LENGTH (type);
   gdb_byte buf[I386_MAX_REGISTER_SIZE];
 
   int len = TYPE_LENGTH (type);
   gdb_byte buf[I386_MAX_REGISTER_SIZE];
 

-  if (TYPE_CODE (type) == TYPE_CODE_FLT)
+  if (type->code () == TYPE_CODE_FLT)

     {
       if (tdep->st0_regnum < 0)
        {
     {
       if (tdep->st0_regnum < 0)
        {


@@ -2802,7 +2824,7 @@ 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.  */
         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);
+      regcache->raw_read (I386_ST0_REGNUM, buf);

       target_float_convert (buf, i387_ext_type (gdbarch), valbuf, type);
     }
   else
       target_float_convert (buf, i387_ext_type (gdbarch), valbuf, type);
     }
   else


@@ -2812,14 +2834,14 @@ i386_extract_return_value (struct gdbarch *gdbarch, struct type *type,
 
       if (len <= low_size)
        {
 
       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))
        {
          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);
          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
          memcpy (valbuf + low_size, buf, len - low_size);
        }
       else


@@ -2839,7 +2861,7 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   int len = TYPE_LENGTH (type);
 
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   int len = TYPE_LENGTH (type);
 

-  if (TYPE_CODE (type) == TYPE_CODE_FLT)
+  if (type->code () == TYPE_CODE_FLT)

     {
       ULONGEST fstat;
       gdb_byte buf[I386_MAX_REGISTER_SIZE];
     {
       ULONGEST fstat;
       gdb_byte buf[I386_MAX_REGISTER_SIZE];


@@ -2859,7 +2881,7 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
         not exactly how it would happen on the target itself, but
         it is the best we can do.  */
       target_float_convert (valbuf, type, buf, i387_ext_type (gdbarch));
         not exactly how it would happen on the target itself, but
         it is the best we can do.  */
       target_float_convert (valbuf, type, buf, i387_ext_type (gdbarch));

-      regcache_raw_write (regcache, I386_ST0_REGNUM, buf);
+      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
 
       /* Set the top of the floating-point register stack to 7.  The
          actual value doesn't really matter, but 7 is what a normal


@@ -2880,12 +2902,12 @@ i386_store_return_value (struct gdbarch *gdbarch, struct type *type,
       int high_size = register_size (gdbarch, HIGH_RETURN_REGNUM);
 
       if (len <= low_size)
       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))
        {
       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__,
        }
       else
        internal_error (__FILE__, __LINE__,


@@ -2916,7 +2938,7 @@ static int
 i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

-  enum type_code code = TYPE_CODE (type);
+  enum type_code code = type->code ();

   int len = TYPE_LENGTH (type);
 
   gdb_assert (code == TYPE_CODE_STRUCT
   int len = TYPE_LENGTH (type);
 
   gdb_assert (code == TYPE_CODE_STRUCT


@@ -2930,10 +2952,10 @@ i386_reg_struct_return_p (struct gdbarch *gdbarch, struct type *type)
 
   /* Structures consisting of a single `float', `double' or 'long
      double' member are returned in %st(0).  */
 
   /* Structures consisting of a single `float', `double' or 'long
      double' member are returned in %st(0).  */

-  if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
+  if (code == TYPE_CODE_STRUCT && type->num_fields () == 1)

     {
       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
     {
       type = check_typedef (TYPE_FIELD_TYPE (type, 0));

-      if (TYPE_CODE (type) == TYPE_CODE_FLT)
+      if (type->code () == TYPE_CODE_FLT)

        return (len == 4 || len == 8 || len == 12);
     }
 
        return (len == 4 || len == 8 || len == 12);
     }
 


@@ -2951,13 +2973,13 @@ i386_return_value (struct gdbarch *gdbarch, struct value *function,
                   struct type *type, struct regcache *regcache,
                   gdb_byte *readbuf, const gdb_byte *writebuf)
 {
                   struct type *type, struct regcache *regcache,
                   gdb_byte *readbuf, const gdb_byte *writebuf)
 {

-  enum type_code code = TYPE_CODE (type);
+  enum type_code code = type->code ();

 
   if (((code == TYPE_CODE_STRUCT
        || code == TYPE_CODE_UNION
        || code == TYPE_CODE_ARRAY)
        && !i386_reg_struct_return_p (gdbarch, type))
 
   if (((code == TYPE_CODE_STRUCT
        || 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.  */
       || (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.  */


@@ -2998,7 +3020,7 @@ i386_return_value (struct gdbarch *gdbarch, struct value *function,
      the structure.  Since that should work for all structures that
      have only one member, we don't bother to check the member's type
      here.  */
      the structure.  Since that should work for all structures that
      have only one member, we don't bother to check the member's type
      here.  */

-  if (code == TYPE_CODE_STRUCT && TYPE_NFIELDS (type) == 1)
+  if (code == TYPE_CODE_STRUCT && type->num_fields () == 1)

     {
       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
       return i386_return_value (gdbarch, function, type, regcache,
     {
       type = check_typedef (TYPE_FIELD_TYPE (type, 0));
       return i386_return_value (gdbarch, function, type, regcache,


@@ -3058,7 +3080,7 @@ i386_bnd_type (struct gdbarch *gdbarch)
       append_composite_type_field (t, "lbound", bt->builtin_data_ptr);
       append_composite_type_field (t, "ubound", bt->builtin_data_ptr);
 
       append_composite_type_field (t, "lbound", bt->builtin_data_ptr);
       append_composite_type_field (t, "ubound", bt->builtin_data_ptr);
 

-      TYPE_NAME (t) = "builtin_type_bound128";
+      t->set_name ("builtin_type_bound128");

       tdep->i386_bnd_type = t;
     }
 
       tdep->i386_bnd_type = t;
     }
 


@@ -3111,7 +3133,7 @@ i386_zmm_type (struct gdbarch *gdbarch)
                                   init_vector_type (bt->builtin_int128, 4));
 
       TYPE_VECTOR (t) = 1;
                                   init_vector_type (bt->builtin_int128, 4));
 
       TYPE_VECTOR (t) = 1;

-      TYPE_NAME (t) = "builtin_type_vec512i";
+      t->set_name ("builtin_type_vec512i");

       tdep->i386_zmm_type = t;
     }
 
       tdep->i386_zmm_type = t;
     }
 


@@ -3164,7 +3186,7 @@ i386_ymm_type (struct gdbarch *gdbarch)
                                   init_vector_type (bt->builtin_int128, 2));
 
       TYPE_VECTOR (t) = 1;
                                   init_vector_type (bt->builtin_int128, 2));
 
       TYPE_VECTOR (t) = 1;

-      TYPE_NAME (t) = "builtin_type_vec256i";
+      t->set_name ("builtin_type_vec256i");

       tdep->i386_ymm_type = t;
     }
 
       tdep->i386_ymm_type = t;
     }
 


@@ -3206,7 +3228,7 @@ i386_mmx_type (struct gdbarch *gdbarch)
                                   init_vector_type (bt->builtin_int8, 8));
 
       TYPE_VECTOR (t) = 1;
                                   init_vector_type (bt->builtin_int8, 8));
 
       TYPE_VECTOR (t) = 1;

-      TYPE_NAME (t) = "builtin_type_vec64i";
+      t->set_name ("builtin_type_vec64i");

       tdep->i386_mmx_type = t;
     }
 
       tdep->i386_mmx_type = t;
     }
 


@@ -3474,11 +3496,11 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
       int fpnum = i386_mmx_regnum_to_fp_regnum (regcache, regnum);
 
       /* Read ...  */
       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.  */
       /* ... 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
     {
     }
   else
     {


@@ -3496,9 +3518,8 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
          upper = extract_unsigned_integer (buf + size, size, byte_order);
 
          /* Fetching register buffer.  */
          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;
 
 
          upper = ~upper;
 


@@ -3506,18 +3527,13 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
          memcpy (raw_buf, &lower, 8);
          memcpy (raw_buf + 8, &upper, 8);
 
          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;
 
        }
       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))
        {
        }
       else if (i386_zmm_regnum_p (gdbarch, regnum))
        {


@@ -3526,82 +3542,64 @@ i386_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
          if (regnum < num_lower_zmm_regs)
            {
              /* Write lower 128bits.  */
          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.  */
              /* 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.  */
            }
          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.  */
              /* 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.  */
            }
          /* 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.  */
        }
       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.  */
          /* ... 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.  */
        }
       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.  */
          /* ... 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 ...  */
        }
       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.  */
          /* ... 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.  */
        }
       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.  */
          /* ... 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"));
        }
       else
        internal_error (__FILE__, __LINE__, _("invalid regnum"));


@@ -3839,7 +3837,7 @@ i386_supply_gregset (const struct regset *regset, struct regcache *regcache,
     {
       if ((regnum == i || regnum == -1)
          && tdep->gregset_reg_offset[i] != -1)
     {
       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]);

     }
 }
 
     }
 }
 


@@ -3864,7 +3862,7 @@ i386_collect_gregset (const struct regset *regset,
     {
       if ((regnum == i || regnum == -1)
          && tdep->gregset_reg_offset[i] != -1)
     {
       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]);

     }
 }
 
     }
 }
 


@@ -3934,9 +3932,11 @@ i386_iterate_over_regset_sections (struct gdbarch *gdbarch,
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (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)
   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);

 }
 \f
 
 }
 \f
 


@@ -3956,7 +3956,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;
        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)
        {
 
       if (symname)
        {


@@ -4057,10 +4057,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)'.
 
    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.  */
 
    otherwise.  */
 

-static int
+static bool

 i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
                                       struct stap_parse_info *p)
 {
 i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
                                       struct stap_parse_info *p)
 {


@@ -4068,7 +4068,7 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
 
   if (isdigit (*s) || *s == '-' || *s == '+')
     {
 
   if (isdigit (*s) || *s == '-' || *s == '+')
     {

-      int got_minus[3];
+      bool got_minus[3];

       int i;
       long displacements[3];
       const char *start;
       int i;
       long displacements[3];
       const char *start;


@@ -4077,17 +4077,17 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
       struct stoken str;
       char *endp;
 
       struct stoken str;
       char *endp;
 

-      got_minus[0] = 0;
+      got_minus[0] = false;

       if (*s == '+')
        ++s;
       else if (*s == '-')
        {
          ++s;
       if (*s == '+')
        ++s;
       else if (*s == '-')
        {
          ++s;

-         got_minus[0] = 1;
+         got_minus[0] = true;

        }
 
       if (!isdigit ((unsigned char) *s))
        }
 
       if (!isdigit ((unsigned char) *s))

-       return 0;
+       return false;

 
       displacements[0] = strtol (s, &endp, 10);
       s = endp;
 
       displacements[0] = strtol (s, &endp, 10);
       s = endp;


@@ -4095,20 +4095,20 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
       if (*s != '+' && *s != '-')
        {
          /* We are not dealing with a triplet.  */
       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;
       if (*s == '+')
        ++s;
       else
        {
          ++s;

-         got_minus[1] = 1;
+         got_minus[1] = true;

        }
 
       if (!isdigit ((unsigned char) *s))
        }
 
       if (!isdigit ((unsigned char) *s))

-       return 0;
+       return false;

 
       displacements[1] = strtol (s, &endp, 10);
       s = endp;
 
       displacements[1] = strtol (s, &endp, 10);
       s = endp;


@@ -4116,26 +4116,26 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
       if (*s != '+' && *s != '-')
        {
          /* We are not dealing with a triplet.  */
       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;
       if (*s == '+')
        ++s;
       else
        {
          ++s;

-         got_minus[2] = 1;
+         got_minus[2] = true;

        }
 
       if (!isdigit ((unsigned char) *s))
        }
 
       if (!isdigit ((unsigned char) *s))

-       return 0;
+       return false;

 
       displacements[2] = strtol (s, &endp, 10);
       s = endp;
 
       if (*s != '(' || s[1] != '%')
 
       displacements[2] = strtol (s, &endp, 10);
       s = endp;
 
       if (*s != '(' || s[1] != '%')

-       return 0;
+       return false;

 
       s += 2;
       start = s;
 
       s += 2;
       start = s;


@@ -4144,7 +4144,7 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
        ++s;
 
       if (*s++ != ')')
        ++s;
 
       if (*s++ != ')')

-       return 0;
+       return false;

 
       len = s - start - 1;
       regname = (char *) alloca (len + 1);
 
       len = s - start - 1;
       regname = (char *) alloca (len + 1);


@@ -4191,10 +4191,10 @@ i386_stap_parse_special_token_triplet (struct gdbarch *gdbarch,
 
       p->arg = s;
 
 
       p->arg = s;
 

-      return 1;
+      return true;

     }
 
     }
 

-  return 0;
+  return false;

 }
 
 /* Helper function for i386_stap_parse_special_token.
 }
 
 /* Helper function for i386_stap_parse_special_token.


@@ -4203,10 +4203,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])'.
 
    (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.  */
 
    otherwise.  */
 

-static int
+static bool

 i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
                                              struct stap_parse_info *p)
 {
 i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
                                              struct stap_parse_info *p)
 {


@@ -4214,9 +4214,9 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
 
   if (isdigit (*s) || *s == '(' || *s == '-' || *s == '+')
     {
 
   if (isdigit (*s) || *s == '(' || *s == '-' || *s == '+')
     {

-      int offset_minus = 0;
+      bool offset_minus = false;

       long offset = 0;
       long offset = 0;

-      int size_minus = 0;
+      bool size_minus = false;

       long size = 0;
       const char *start;
       char *base;
       long size = 0;
       const char *start;
       char *base;


@@ -4230,11 +4230,11 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
       else if (*s == '-')
        {
          ++s;
       else if (*s == '-')
        {
          ++s;

-         offset_minus = 1;
+         offset_minus = true;

        }
 
       if (offset_minus && !isdigit (*s))
        }
 
       if (offset_minus && !isdigit (*s))

-       return 0;
+       return false;

 
       if (isdigit (*s))
        {
 
       if (isdigit (*s))
        {


@@ -4245,7 +4245,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
        }
 
       if (*s != '(' || s[1] != '%')
        }
 
       if (*s != '(' || s[1] != '%')

-       return 0;
+       return false;

 
       s += 2;
       start = s;
 
       s += 2;
       start = s;


@@ -4254,7 +4254,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
        ++s;
 
       if (*s != ',' || s[1] != '%')
        ++s;
 
       if (*s != ',' || s[1] != '%')

-       return 0;
+       return false;

 
       len_base = s - start;
       base = (char *) alloca (len_base + 1);
 
       len_base = s - start;
       base = (char *) alloca (len_base + 1);


@@ -4281,7 +4281,7 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
               index, p->saved_arg);
 
       if (*s != ',' && *s != ')')
               index, p->saved_arg);
 
       if (*s != ',' && *s != ')')

-       return 0;
+       return false;

 
       if (*s == ',')
        {
 
       if (*s == ',')
        {


@@ -4293,14 +4293,14 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
          else if (*s == '-')
            {
              ++s;
          else if (*s == '-')
            {
              ++s;

-             size_minus = 1;
+             size_minus = true;

            }
 
          size = strtol (s, &endp, 10);
          s = endp;
 
          if (*s != ')')
            }
 
          size = strtol (s, &endp, 10);
          s = endp;
 
          if (*s != ')')

-           return 0;
+           return false;

        }
 
       ++s;
        }
 
       ++s;


@@ -4354,10 +4354,10 @@ i386_stap_parse_special_token_three_arg_disp (struct gdbarch *gdbarch,
 
       p->arg = s;
 
 
       p->arg = s;
 

-      return 1;
+      return true;

     }
 
     }
 

-  return 0;
+  return false;

 }
 
 /* Implementation of `gdbarch_stap_parse_special_token', as defined in
 }
 
 /* Implementation of `gdbarch_stap_parse_special_token', as defined in


@@ -4409,6 +4409,29 @@ i386_stap_parse_special_token (struct gdbarch *gdbarch,
   return 0;
 }
 
   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 &regname, int regnum)
+{
+  static const std::unordered_set<std::string> 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;
+}
+

 \f
 
 /* gdbarch gnu_triplet_regexp method.  Both arches are acceptable as GDB always
 \f
 
 /* gdbarch gnu_triplet_regexp method.  Both arches are acceptable as GDB always


@@ -4457,6 +4480,8 @@ 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);
                                      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_in_indirect_branch_thunk (gdbarch,
                                        i386_in_indirect_branch_thunk);
 
   set_gdbarch_in_indirect_branch_thunk (gdbarch,
                                        i386_in_indirect_branch_thunk);


@@ -7130,6 +7155,7 @@ Do you want to stop the program?"),
              else if (ir.rm == 1)
                break;
            }
              else if (ir.rm == 1)
                break;
            }

+         /* Fall through.  */

        case 3:  /* lidt */
          if (ir.mod == 3)
            {
        case 3:  /* lidt */
          if (ir.mod == 3)
            {


@@ -8174,14 +8200,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.  */
 
    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
 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);
       return floatformats_ia64_quad;
 
   return default_floatformat_for_type (gdbarch, name, len);


@@ -8195,7 +8223,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,
   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))
   int i, num_regs, valid_p;
 
   if (! tdesc_has_registers (tdesc))


@@ -8218,6 +8246,9 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
   /* Try AVX512 registers.  */
   feature_avx512 = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.avx512");
 
   /* 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");
 
   /* Try PKEYS  */
   feature_pkeys = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.pkeys");
 


@@ -8327,6 +8358,16 @@ i386_validate_tdesc_p (struct gdbarch_tdep *tdep,
            tdep->mpx_register_names[i]);
     }
 
            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;
   if (feature_pkeys)
     {
       tdep->xcr0 |= X86_XSTATE_PKRU;


@@ -8357,18 +8398,18 @@ i386_type_align (struct gdbarch *gdbarch, struct type *type)
 
   if (gdbarch_ptr_bit (gdbarch) == 32)
     {
 
   if (gdbarch_ptr_bit (gdbarch) == 32)
     {

-      if ((TYPE_CODE (type) == TYPE_CODE_INT
-          || TYPE_CODE (type) == TYPE_CODE_FLT)
+      if ((type->code () == TYPE_CODE_INT
+          || type->code () == TYPE_CODE_FLT)

          && TYPE_LENGTH (type) > 4)
        return 4;
 
       /* Handle x86's funny long double.  */
          && TYPE_LENGTH (type) > 4)
        return 4;
 
       /* Handle x86's funny long double.  */

-      if (TYPE_CODE (type) == TYPE_CODE_FLT
+      if (type->code () == TYPE_CODE_FLT

          && gdbarch_long_double_bit (gdbarch) == TYPE_LENGTH (type) * 8)
        return 4;
     }
 
          && gdbarch_long_double_bit (gdbarch) == TYPE_LENGTH (type) * 8)
        return 4;
     }
 

-  return TYPE_LENGTH (type);
+  return 0;

 }
 
 \f
 }
 
 \f


@@ -8563,14 +8604,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.  */
   /* 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))
 
   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 = i386_target_description (X86_XSTATE_SSE_MASK);
+    tdesc = i386_target_description (X86_XSTATE_SSE_MASK, false);

   tdep->tdesc = tdesc;
 
   tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS;
   tdep->tdesc = tdesc;
 
   tdep->num_core_regs = I386_NUM_GREGS + I387_NUM_REGS;


@@ -8612,6 +8653,9 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   tdep->pkru_regnum = -1;
   tdep->num_pkeys_regs = 0;
 
   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);
   tdesc_data = tdesc_data_alloc ();
 
   set_gdbarch_relocate_instruction (gdbarch, i386_relocate_instruction);


@@ -8737,20 +8781,21 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 /* Return the target description for a specified XSAVE feature mask.  */
 
 const struct target_desc *
 /* Return the target description for a specified XSAVE feature mask.  */
 
 const struct target_desc *

-i386_target_description (uint64_t xcr0)
+i386_target_description (uint64_t xcr0, bool segments)

 {
   static target_desc *i386_tdescs \
 {
   static target_desc *i386_tdescs \

-    [2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/] = {};
+    [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]
   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];
+    [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0]
+    [segments ? 1 : 0];

 
   if (*tdesc == NULL)
 
   if (*tdesc == NULL)

-    *tdesc = i386_create_target_description (xcr0, false);
+    *tdesc = i386_create_target_description (xcr0, false, segments);

 
   return *tdesc;
 }
 
   return *tdesc;
 }


@@ -8889,7 +8934,7 @@ i386_mpx_print_bounds (const CORE_ADDR bt_entry[4])
 
       size = (size > -1 ? size + 1 : size);
       uiout->text (", size = ");
 
       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]);
 
       uiout->text (", metadata = ");
       uiout->field_core_addr ("metadata", gdbarch, bt_entry[3]);


@@ -8994,24 +9039,9 @@ i386_mpx_set_bounds (const char *args, int from_tty)
 
 static struct cmd_list_element *mpx_set_cmdlist, *mpx_show_cmdlist;
 
 
 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
 void

-_initialize_i386_tdep (void)
+_initialize_i386_tdep ()

 {
   register_gdbarch_init (bfd_arch_i386, i386_gdbarch_init);
 
 {
   register_gdbarch_init (bfd_arch_i386, i386_gdbarch_init);
 


@@ -9039,17 +9069,17 @@ is \"default\"."),
 
   /* Add "mpx" prefix for the set commands.  */
 
 
   /* Add "mpx" prefix for the set commands.  */
 

-  add_prefix_cmd ("mpx", class_support, set_mpx_cmd, _("\
+  add_basic_prefix_cmd ("mpx", class_support, _("\

 Set Intel Memory Protection Extensions specific variables."),
 Set Intel Memory Protection Extensions specific variables."),

-                 &mpx_set_cmdlist, "set mpx ",
-                 0 /* allow-unknown */, &setlist);
+                       &mpx_set_cmdlist, "set mpx ",
+                       0 /* allow-unknown */, &setlist);

 
   /* Add "mpx" prefix for the show commands.  */
 
 
   /* Add "mpx" prefix for the show commands.  */
 

-  add_prefix_cmd ("mpx", class_support, show_mpx_cmd, _("\
+  add_show_prefix_cmd ("mpx", class_support, _("\

 Show Intel Memory Protection Extensions specific variables."),
 Show Intel Memory Protection Extensions specific variables."),

-                 &mpx_show_cmdlist, "show mpx ",
-                 0 /* allow-unknown */, &showlist);
+                      &mpx_show_cmdlist, "show mpx ",
+                      0 /* allow-unknown */, &showlist);

 
   /* Add "bound" command for the show mpx commands list.  */
 
 
   /* Add "bound" command for the show mpx commands list.  */
 


@@ -9073,28 +9103,4 @@ Show Intel Memory Protection Extensions specific variables."),
 
   /* Tell remote stub that we support XML target description.  */
   register_remote_support_xml ("i386");
 
   /* 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 */

 }
 }