+2020-09-28  Tom Tromey  <tom@tromey.com>
+
+       * windows-tdep.c (tlb_make_value): Update.
+       * tui/tui-regs.c (tui_data_window::show_registers): Update.
+       * thread.c (scoped_restore_current_thread::restore)
+       (scoped_restore_current_thread::scoped_restore_current_thread)
+       (thread_command): Update.
+       * stack.c (backtrace_command_1, frame_apply_level_command)
+       (frame_apply_all_command, frame_apply_command): Update.
+       * infrun.c (siginfo_make_value, restore_infcall_control_state):
+       Update.
+       * gcore.c (derive_stack_segment): Update.
+       * frame.c (get_current_frame, has_stack_frames): Update.
+       * auxv.c (info_auxv_command): Update.
+       * ada-tasks.c (ada_build_task_list): Update.
+       * target.c (target_has_stack): Rename from target_has_stack_1.
+       * target.h (target_has_stack): Remove macro.
+       (target_has_stack): Rename from target_has_stack_1.
+
 2020-09-28  Tom Tromey  <tom@tromey.com>
 
        * target.c (target_has_memory): Rename from target_has_memory_1.
 
 {
   struct ada_tasks_inferior_data *data;
 
-  if (!target_has_stack)
+  if (!target_has_stack ())
     error (_("Cannot inspect Ada tasks when program is not running"));
 
   data = get_ada_tasks_inferior_data (current_inferior ());
 
 static void
 info_auxv_command (const char *cmd, int from_tty)
 {
-  if (! target_has_stack)
+  if (! target_has_stack ())
     error (_("The program has no auxiliary information now."));
   else
     {
 
      registers".  */
   if (!target_has_registers)
     error (_("No registers."));
-  if (!target_has_stack)
+  if (!target_has_stack ())
     error (_("No stack."));
   if (!target_has_memory ())
     error (_("No memory."));
 bool
 has_stack_frames ()
 {
-  if (!target_has_registers || !target_has_stack || !target_has_memory ())
+  if (!target_has_registers || !target_has_stack () || !target_has_memory ())
     return false;
 
   /* Traceframes are effectively a substitute for the live inferior.  */
 
   gdb_assert (top);
 
   /* Can't succeed without stack and registers.  */
-  if (!target_has_stack || !target_has_registers)
+  if (!target_has_stack () || !target_has_registers)
     return 0;
 
   /* Can't succeed without current frame.  */
 
 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var,
                    void *ignore)
 {
-  if (target_has_stack
+  if (target_has_stack ()
       && inferior_ptid != null_ptid
       && gdbarch_get_siginfo_type_p (gdbarch))
     {
   stop_stack_dummy = inf_status->stop_stack_dummy;
   stopped_by_random_signal = inf_status->stopped_by_random_signal;
 
-  if (target_has_stack)
+  if (target_has_stack ())
     {
       /* The point of the try/catch is that if the stack is clobbered,
          walking the stack might encounter a garbage pointer and
 
   int py_start = 0, py_end = 0;
   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
 
-  if (!target_has_stack)
+  if (!target_has_stack ())
     error (_("No stack."));
 
   if (count_exp)
 static void
 frame_apply_level_command (const char *cmd, int from_tty)
 {
-  if (!target_has_stack)
+  if (!target_has_stack ())
     error (_("No stack."));
 
   bool level_found = false;
 static void
 frame_apply_all_command (const char *cmd, int from_tty)
 {
-  if (!target_has_stack)
+  if (!target_has_stack ())
     error (_("No stack."));
 
   frame_apply_command_count ("frame apply all", cmd, from_tty,
   int count;
   struct frame_info *trailing;
 
-  if (!target_has_stack)
+  if (!target_has_stack ())
     error (_("No stack."));
 
   if (cmd == NULL)
 
 }
 
 int
-target_has_stack_1 (void)
+target_has_stack ()
 {
   for (target_ops *t = current_top_target (); t != NULL; t = t->beneath ())
     if (t->has_stack ())
 
 /* Does the target have a stack?  (Exec files don't, VxWorks doesn't, until
    we start a process.)  */
 
-extern int target_has_stack_1 (void);
-#define target_has_stack target_has_stack_1 ()
+extern int target_has_stack ();
 
 /* Does the target have registers?  (Exec files don't.)  */
 
 
       && m_was_stopped
       && m_thread->state == THREAD_STOPPED
       && target_has_registers
-      && target_has_stack
+      && target_has_stack ()
       && target_has_memory ())
     restore_selected_frame (m_selected_frame_id, m_selected_frame_level);
 }
       m_was_stopped = m_thread->state == THREAD_STOPPED;
       if (m_was_stopped
          && target_has_registers
-         && target_has_stack
+         && target_has_stack ()
          && target_has_memory ())
        {
          /* When processing internal events, there might not be a
       if (inferior_ptid == null_ptid)
        error (_("No thread selected"));
 
-      if (target_has_stack)
+      if (target_has_stack ())
        {
          struct thread_info *tp = inferior_thread ();
 
 
   if (group == 0)
     group = general_reggroup;
 
-  if (target_has_registers && target_has_stack && target_has_memory ())
+  if (target_has_registers && target_has_stack () && target_has_memory ())
     {
       show_register_group (group, get_selected_frame (NULL),
                           group == m_current_group);
 
 static struct value *
 tlb_make_value (struct gdbarch *gdbarch, struct internalvar *var, void *ignore)
 {
-  if (target_has_stack && inferior_ptid != null_ptid)
+  if (target_has_stack () && inferior_ptid != null_ptid)
     {
       struct type *type = windows_get_tlb_type (gdbarch);
       return allocate_computed_value (type, &tlb_value_funcs, NULL);