diff --git a/gdb/inferior.h b/gdb/inferior.h
index 33c2eac9d3c..1a3f579d8d2 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -503,6 +503,9 @@ public:
      this gdbarch.  */
   struct gdbarch *gdbarch = NULL;
 
+  /* Data related to displaced stepping.  */
+  displaced_step_inferior_state displaced_step_state;
+
   /* Per inferior data-pointers required by other GDB modules.  */
   REGISTRY_FIELDS;
 };
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 46a8985f860..63dd28237dd 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1476,53 +1476,12 @@ step_over_info_valid_p (void)
 
 displaced_step_closure::~displaced_step_closure () = default;
 
-/* Per-inferior displaced stepping state.  */
-struct displaced_step_inferior_state
-{
-  /* The process this displaced step state refers to.  */
-  inferior *inf;
-
-  /* True if preparing a displaced step ever failed.  If so, we won't
-     try displaced stepping for this inferior again.  */
-  int failed_before;
-
-  /* If this is not nullptr, this is the thread carrying out a
-     displaced single-step in process PID.  This thread's state will
-     require fixing up once it has completed its step.  */
-  thread_info *step_thread;
-
-  /* The architecture the thread had when we stepped it.  */
-  struct gdbarch *step_gdbarch;
-
-  /* The closure provided gdbarch_displaced_step_copy_insn, to be used
-     for post-step cleanup.  */
-  struct displaced_step_closure *step_closure;
-
-  /* The address of the original instruction, and the copy we
-     made.  */
-  CORE_ADDR step_original, step_copy;
-
-  /* Saved contents of copy area.  */
-  gdb_byte *step_saved_copy;
-};
-
-/* The list of states of processes involved in displaced stepping
-   presently.  */
-static std::forward_list<displaced_step_inferior_state *>
-  displaced_step_inferior_states;
-
 /* Get the displaced stepping state of process PID.  */
 
 static displaced_step_inferior_state *
 get_displaced_stepping_state (inferior *inf)
 {
-  for (auto *state : displaced_step_inferior_states)
-    {
-      if (state->inf == inf)
-	return state;
-    }
-
-  return nullptr;
+  return &inf->displaced_step_state;
 }
 
 /* Returns true if any inferior has a thread doing a displaced
@@ -1531,9 +1490,11 @@ get_displaced_stepping_state (inferior *inf)
 static bool
 displaced_step_in_progress_any_inferior ()
 {
-  for (auto *state : displaced_step_inferior_states)
+  inferior *i;
+
+  ALL_INFERIORS (i)
     {
-      if (state->step_thread != nullptr)
+      if (i->displaced_step_state.step_thread != nullptr)
 	return true;
     }
 
@@ -1546,13 +1507,9 @@ displaced_step_in_progress_any_inferior ()
 static int
 displaced_step_in_progress_thread (thread_info *thread)
 {
-  struct displaced_step_inferior_state *displaced;
-
   gdb_assert (thread != NULL);
 
-  displaced = get_displaced_stepping_state (thread->inf);
-
-  return (displaced != NULL && displaced->step_thread == thread);
+  return get_displaced_stepping_state (thread->inf)->step_thread == thread;
 }
 
 /* Return true if process PID has a thread doing a displaced step.  */
@@ -1560,34 +1517,7 @@ displaced_step_in_progress_thread (thread_info *thread)
 static int
 displaced_step_in_progress (inferior *inf)
 {
-  struct displaced_step_inferior_state *displaced;
-
-  displaced = get_displaced_stepping_state (inf);
-  if (displaced != NULL && displaced->step_thread != nullptr)
-    return 1;
-
-  return 0;
-}
-
-/* Add a new displaced stepping state for process PID to the displaced
-   stepping state list, or return a pointer to an already existing
-   entry, if it already exists.  Never returns NULL.  */
-
-static displaced_step_inferior_state *
-add_displaced_stepping_state (inferior *inf)
-{
-  displaced_step_inferior_state *state
-    = get_displaced_stepping_state (inf);
-
-  if (state != nullptr)
-    return state;
-
-  state = XCNEW (struct displaced_step_inferior_state);
-  state->inf = inf;
-
-  displaced_step_inferior_states.push_front (state);
-
-  return state;
+  return get_displaced_stepping_state (inf)->step_thread != nullptr;
 }
 
 /* If inferior is in displaced stepping, and ADDR equals to starting address
@@ -1597,42 +1527,21 @@ add_displaced_stepping_state (inferior *inf)
 struct displaced_step_closure*
 get_displaced_step_closure_by_addr (CORE_ADDR addr)
 {
-  struct displaced_step_inferior_state *displaced
+  displaced_step_inferior_state *displaced
     = get_displaced_stepping_state (current_inferior ());
 
   /* If checking the mode of displaced instruction in copy area.  */
-  if (displaced != NULL
-      && displaced->step_thread != nullptr
+  if (displaced->step_thread != nullptr
       && displaced->step_copy == addr)
     return displaced->step_closure;
 
   return NULL;
 }
 
-/* Remove the displaced stepping state of process PID.  */
-
-static void
-remove_displaced_stepping_state (inferior *inf)
-{
-  gdb_assert (inf != nullptr);
-
-  displaced_step_inferior_states.remove_if
-    ([inf] (displaced_step_inferior_state *state)
-      {
-	if (state->inf == inf)
-	  {
-	    xfree (state);
-	    return true;
-	  }
-	else
-	  return false;
-      });
-}
-
 static void
 infrun_inferior_exit (struct inferior *inf)
 {
-  remove_displaced_stepping_state (inf);
+  inf->displaced_step_state.reset ();
 }
 
 /* If ON, and the architecture supports it, GDB will use displaced
@@ -1669,17 +1578,15 @@ use_displaced_stepping (struct thread_info *tp)
 {
   struct regcache *regcache = get_thread_regcache (tp);
   struct gdbarch *gdbarch = regcache->arch ();
-  struct displaced_step_inferior_state *displaced_state;
-
-  displaced_state = get_displaced_stepping_state (tp->inf);
+  displaced_step_inferior_state *displaced_state
+    = get_displaced_stepping_state (tp->inf);
 
   return (((can_use_displaced_stepping == AUTO_BOOLEAN_AUTO
 	    && target_is_non_stop_p ())
 	   || can_use_displaced_stepping == AUTO_BOOLEAN_TRUE)
 	  && gdbarch_displaced_step_copy_insn_p (gdbarch)
 	  && find_record_target () == NULL
-	  && (displaced_state == NULL
-	      || !displaced_state->failed_before));
+	  && !displaced_state->failed_before);
 }
 
 /* Clean out any stray displaced stepping state.  */
@@ -1741,7 +1648,6 @@ displaced_step_prepare_throw (thread_info *tp)
   CORE_ADDR original, copy;
   ULONGEST len;
   struct displaced_step_closure *closure;
-  struct displaced_step_inferior_state *displaced;
   int status;
 
   /* We should never reach this function if the architecture does not
@@ -1760,7 +1666,8 @@ displaced_step_prepare_throw (thread_info *tp)
   /* We have to displaced step one thread at a time, as we only have
      access to a single scratch space per inferior.  */
 
-  displaced = add_displaced_stepping_state (tp->inf);
+  displaced_step_inferior_state *displaced
+    = get_displaced_stepping_state (tp->inf);
 
   if (displaced->step_thread != nullptr)
     {
@@ -1953,10 +1860,6 @@ displaced_step_fixup (thread_info *event_thread, enum gdb_signal signal)
     = get_displaced_stepping_state (event_thread->inf);
   int ret;
 
-  /* Was any thread of this process doing a displaced step?  */
-  if (displaced == NULL)
-    return 0;
-
   /* Was this event for the thread we displaced?  */
   if (displaced->step_thread != event_thread)
     return 0;
@@ -3577,7 +3480,7 @@ prepare_for_detach (void)
 
   /* Is any thread of this process displaced stepping?  If not,
      there's nothing else to do.  */
-  if (displaced == NULL || displaced->step_thread == nullptr)
+  if (displaced->step_thread == nullptr)
     return;
 
   if (debug_infrun)
diff --git a/gdb/infrun.h b/gdb/infrun.h
index a701f0ca47f..81b3c326163 100644
--- a/gdb/infrun.h
+++ b/gdb/infrun.h
@@ -258,4 +258,51 @@ struct buf_displaced_step_closure : displaced_step_closure
   gdb::byte_vector buf;
 };
 
+/* Per-inferior displaced stepping state.  */
+struct displaced_step_inferior_state
+{
+  /* Put this object back in its original state.  s*/
+  void reset ()
+  {
+    /* These should have been cleaned after the last displaced step
+       operation, so if there are still set, it's a bug.  */
+    gdb_assert (step_thread == nullptr);
+    gdb_assert (step_closure == nullptr);
+
+    failed_before = 0;
+    step_gdbarch = nullptr;
+    step_original = 0;
+    step_copy = 0;
+
+    if (step_saved_copy != nullptr)
+      {
+	xfree (step_saved_copy);
+	step_saved_copy = nullptr;
+      }
+  }
+
+  /* True if preparing a displaced step ever failed.  If so, we won't
+     try displaced stepping for this inferior again.  */
+  int failed_before = 0;
+
+  /* If this is not nullptr, this is the thread carrying out a
+     displaced single-step in process PID.  This thread's state will
+     require fixing up once it has completed its step.  */
+  thread_info *step_thread = nullptr;
+
+  /* The architecture the thread had when we stepped it.  */
+  gdbarch *step_gdbarch = nullptr;
+
+  /* The closure provided gdbarch_displaced_step_copy_insn, to be used
+     for post-step cleanup.  */
+  displaced_step_closure *step_closure = nullptr;
+
+  /* The address of the original instruction, and the copy we
+     made.  */
+  CORE_ADDR step_original = 0, step_copy = 0;
+
+  /* Saved contents of copy area.  */
+  gdb_byte *step_saved_copy = nullptr;
+};
+
 #endif /* INFRUN_H */
