[PATCH v2 1/7] winedbg: Remove outdated commented code.

[Rémi Bernon]

This doesn't compile anymore, let's get rid of it instead or pretending
it can still be useful.

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com>
---
 programs/winedbg/gdbproxy.c | 38 -------------------------------------
 1 file changed, 38 deletions(-)

diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index 02522ea31955..059564d8663c 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -850,14 +850,6 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
     }
 }
 
-#if 0
-static enum packet_return packet_extended(struct gdb_context* gdbctx)
-{
-    gdbctx->extended = 1;
-    return packet_ok;
-}
-#endif
-
 static enum packet_return packet_last_signal(struct gdb_context* gdbctx)
 {
     assert(gdbctx->in_packet_len == 0);
@@ -1150,10 +1142,6 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
 static enum packet_return packet_kill(struct gdb_context* gdbctx)
 {
     detach_debuggee(gdbctx, TRUE);
-#if 0
-    if (!gdbctx->extended)
-        /* dunno whether GDB cares or not */
-#endif
     return packet_ok | packet_last_f;
 }
 
@@ -1674,29 +1662,6 @@ static enum packet_return packet_step(struct gdb_context* gdbctx)
     return packet_reply_status(gdbctx);
 }
 
-#if 0
-static enum packet_return packet_step_signal(struct gdb_context* gdbctx)
-{
-    unsigned char sig;
-
-    /* FIXME: add support for address in packet */
-    assert(gdbctx->in_packet_len == 2);
-    if (dbg_curr_thread->tid != gdbctx->exec_thread && gdbctx->exec_thread)
-        if (gdbctx->trace & GDBPXY_TRC_COMMAND_ERROR)
-            fprintf(stderr, "NIY: step/sig on %u, while last thread is %u\n",
-                    gdbctx->exec_thread, DEBUG_CurrThread->tid);
-    hex_from(&sig, gdbctx->in_packet, 1);
-    /* cannot change signals on the fly */
-    if (gdbctx->trace & GDBPXY_TRC_COMMAND)
-        fprintf(stderr, "sigs: %u %u\n", sig, gdbctx->last_sig);
-    if (sig != gdbctx->last_sig)
-        return packet_error;
-    resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
-    wait_for_debuggee(gdbctx);
-    return packet_reply_status(gdbctx);
-}
-#endif
-
 static enum packet_return packet_thread_alive(struct gdb_context* gdbctx)
 {
     char*       end;
@@ -1723,7 +1688,6 @@ struct packet_entry
 
 static struct packet_entry packet_entries[] =
 {
-        /*{'!', packet_extended}, */
         {'?', packet_last_signal},
         {'c', packet_continue},
         {'C', packet_continue_signal},
@@ -1738,9 +1702,7 @@ static struct packet_entry packet_entries[] =
         {'P', packet_write_register},
         {'q', packet_query},
         {'Q', packet_set},
-        /* {'R', packet,restart}, only in extended mode ! */
         {'s', packet_step},        
-        /*{'S', packet_step_signal}, hard(er) to implement */
         {'T', packet_thread_alive},
         {'v', packet_verbose},
 };
-- 
2.26.0.rc2

[PATCH v2 2/7] winedbg: Simplify and fix register read/write handlers.

[Rémi Bernon]

This was using some conditional context read and dbg_curr_thread checks,
we can just read the context of the selected thread and write it back as
needed.

Also, packet_reply_register_hex_to was using gdbctx->context, which is
not always the context we want to read.

We still need to keep changes in sync with gdbctx->context as it may be
still be used for step / continue, but step / continue doesn't work well
and we will rewrite it later.

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com>
---

v2: Same as before, with better precondition checks.

 programs/winedbg/gdbproxy.c | 145 ++++++++++++++++++++----------------
 1 file changed, 81 insertions(+), 64 deletions(-)

diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index 059564d8663c..0c9872d93197 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -786,16 +786,16 @@ static enum packet_return packet_reply_error(struct gdb_context* gdbctx, int err
     return packet_done;
 }
 
-static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, unsigned idx)
+static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, dbg_ctx_t* ctx, unsigned idx)
 {
     const struct gdb_register *cpu_register_map = gdbctx->process->be_cpu->gdb_register_map;
 
     if (cpu_register_map[idx].gdb_length == cpu_register_map[idx].ctx_length)
-        packet_reply_hex_to(gdbctx, cpu_register_ptr(gdbctx, &gdbctx->context, idx),
+        packet_reply_hex_to(gdbctx, cpu_register_ptr(gdbctx, ctx, idx),
                             cpu_register_map[idx].gdb_length);
     else
     {
-        DWORD64     val = cpu_register(gdbctx, &gdbctx->context, idx);
+        DWORD64     val = cpu_register(gdbctx, ctx, idx);
         unsigned    i;
 
         for (i = 0; i < cpu_register_map[idx].gdb_length; i++)
@@ -829,12 +829,9 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
 
         for (i = 0; i < gdbctx->process->be_cpu->gdb_num_regs; i++)
         {
-            /* FIXME: this call will also grow the buffer...
-             * unneeded, but not harmful
-             */
             packet_reply_val(gdbctx, i, 1);
             packet_reply_add(gdbctx, ":");
-            packet_reply_register_hex_to(gdbctx, i);
+            packet_reply_register_hex_to(gdbctx, &gdbctx->context, i);
             packet_reply_add(gdbctx, ";");
         }
 
@@ -1090,20 +1087,24 @@ static enum packet_return packet_detach(struct gdb_context* gdbctx)
 
 static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
 {
-    int                 i;
+    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct backend_cpu *backend;
     dbg_ctx_t ctx;
+    size_t i;
 
     assert(gdbctx->in_trap);
 
-    if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
-    {
-        if (!fetch_context(gdbctx, gdbctx->other_thread->handle, &ctx))
-            return packet_error;
-    }
+    if (!thread) return packet_error;
+    if (!thread->process) return packet_error;
+    if (!(backend = thread->process->be_cpu)) return packet_error;
+
+    if (!backend->get_context(thread->handle, &ctx))
+        return packet_error;
+    if (thread == dbg_curr_thread) ctx = gdbctx->context;
 
     packet_reply_open(gdbctx);
-    for (i = 0; i < gdbctx->process->be_cpu->gdb_num_regs; i++)
-        packet_reply_register_hex_to(gdbctx, i);
+    for (i = 0; i < backend->gdb_num_regs; i++)
+        packet_reply_register_hex_to(gdbctx, &ctx, i);
 
     packet_reply_close(gdbctx);
     return packet_done;
@@ -1111,31 +1112,36 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
 
 static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
 {
-    const size_t cpu_num_regs = gdbctx->process->be_cpu->gdb_num_regs;
-    unsigned    i;
+    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct backend_cpu *backend;
     dbg_ctx_t ctx;
-    dbg_ctx_t *pctx = &gdbctx->context;
-    const char* ptr;
+    const char *ptr;
+    size_t i;
 
     assert(gdbctx->in_trap);
-    if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
-    {
-        if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
-            return packet_error;
-    }
-    if (gdbctx->in_packet_len < cpu_num_regs * 2) return packet_error;
+
+    if (!thread) return packet_error;
+    if (!thread->process) return packet_error;
+    if (!(backend = thread->process->be_cpu)) return packet_error;
+
+    if (!backend->get_context(thread->handle, &ctx))
+        return packet_error;
+    if (thread == dbg_curr_thread) ctx = gdbctx->context;
+
+    if (gdbctx->in_packet_len < backend->gdb_num_regs * 2)
+        return packet_error;
 
     ptr = gdbctx->in_packet;
-    for (i = 0; i < cpu_num_regs; i++)
-        cpu_register_hex_from(gdbctx, pctx, i, &ptr);
+    for (i = 0; i < backend->gdb_num_regs; i++)
+        cpu_register_hex_from(gdbctx, &ctx, i, &ptr);
 
-    if (pctx != &gdbctx->context &&
-        !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx))
+    if (!backend->set_context(thread->handle, &ctx))
     {
-        ERR("Failed to set context for tid %04x, error %u\n",
-            gdbctx->other_thread->tid, GetLastError());
+        ERR("Failed to set context for tid %04x, error %u\n", thread->tid, GetLastError());
         return packet_error;
     }
+
+    if (thread == dbg_curr_thread) gdbctx->context = ctx;
     return packet_ok;
 }
 
@@ -1249,69 +1255,80 @@ static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
 
 static enum packet_return packet_read_register(struct gdb_context* gdbctx)
 {
-    unsigned            reg;
+    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct backend_cpu *backend;
     dbg_ctx_t ctx;
-    dbg_ctx_t *pctx = &gdbctx->context;
+    size_t reg;
 
     assert(gdbctx->in_trap);
-    reg = hex_to_int(gdbctx->in_packet, gdbctx->in_packet_len);
-    if (reg >= gdbctx->process->be_cpu->gdb_num_regs)
-    {
-        WARN("Unhandled register %u\n", reg);
+
+    if (!thread) return packet_error;
+    if (!thread->process) return packet_error;
+    if (!(backend = thread->process->be_cpu)) return packet_error;
+
+    if (!backend->get_context(thread->handle, &ctx))
         return packet_error;
-    }
-    if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
+    if (thread == dbg_curr_thread) ctx = gdbctx->context;
+
+    if (sscanf(gdbctx->in_packet, "%zx", ®) != 1)
+        return packet_error;
+    if (reg >= backend->gdb_num_regs)
     {
-        if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
-            return packet_error;
+        WARN("Unhandled register %zu\n", reg);
+        return packet_error;
     }
 
-    TRACE("%u => %s\n", reg, wine_dbgstr_longlong(cpu_register(gdbctx, pctx, reg)));
+    TRACE("%zu => %s\n", reg, wine_dbgstr_longlong(cpu_register(gdbctx, &ctx, reg)));
 
     packet_reply_open(gdbctx);
-    packet_reply_register_hex_to(gdbctx, reg);
+    packet_reply_register_hex_to(gdbctx, &ctx, reg);
     packet_reply_close(gdbctx);
     return packet_done;
 }
 
 static enum packet_return packet_write_register(struct gdb_context* gdbctx)
 {
-    unsigned            reg;
-    char*               ptr;
+    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct backend_cpu *backend;
     dbg_ctx_t ctx;
-    dbg_ctx_t *pctx = &gdbctx->context;
+    size_t reg;
+    char *ptr;
 
     assert(gdbctx->in_trap);
 
-    reg = strtoul(gdbctx->in_packet, &ptr, 16);
-    if (ptr == NULL || reg >= gdbctx->process->be_cpu->gdb_num_regs || *ptr++ != '=')
+    if (!thread) return packet_error;
+    if (!thread->process) return packet_error;
+    if (!(backend = thread->process->be_cpu)) return packet_error;
+
+    if (!backend->get_context(thread->handle, &ctx))
+        return packet_error;
+    if (thread == dbg_curr_thread) ctx = gdbctx->context;
+
+    if (!(ptr = strchr(gdbctx->in_packet, '=')))
+        return packet_error;
+    *ptr++ = '\0';
+
+    if (sscanf(gdbctx->in_packet, "%zx", ®) != 1)
+        return packet_error;
+    if (reg >= backend->gdb_num_regs)
     {
-        WARN("Unhandled register %s\n",
-            debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len));
         /* FIXME: if just the reg is above cpu_num_regs, don't tell gdb
          *        it wouldn't matter too much, and it fakes our support for all regs
          */
-        return (ptr == NULL) ? packet_error : packet_ok;
+        WARN("Unhandled register %zu\n", reg);
+        return packet_ok;
     }
 
-    TRACE("%u <= %s\n", reg,
-        debugstr_an(ptr, (int)(gdbctx->in_packet_len - (ptr - gdbctx->in_packet))));
-
-    if (dbg_curr_thread != gdbctx->other_thread && gdbctx->other_thread)
-    {
-        if (!fetch_context(gdbctx, gdbctx->other_thread->handle, pctx = &ctx))
-            return packet_error;
-    }
+    TRACE("%zu <= %s\n", reg, debugstr_an(ptr, (int)(gdbctx->in_packet_len - (ptr - gdbctx->in_packet))));
 
-    cpu_register_hex_from(gdbctx, pctx, reg, (const char**)&ptr);
-    if (pctx != &gdbctx->context &&
-        !gdbctx->process->be_cpu->set_context(gdbctx->other_thread->handle, pctx))
+    cpu_register_hex_from(gdbctx, &ctx, reg, (const char**)&ptr);
+    if (!backend->set_context(thread->handle, &ctx))
     {
-        ERR("Failed to set context for tid %04x, error %u\n",
-            gdbctx->other_thread->tid, GetLastError());
+        ERR("Failed to set context for tid %04x, error %u\n", thread->tid, GetLastError());
         return packet_error;
     }
 
+    if (thread == dbg_curr_thread) gdbctx->context = ctx;
     return packet_ok;
 }
 
-- 
2.26.0.rc2

[PATCH v2 3/7] winedbg: Simplify individual thread single_step control.

[Rémi Bernon]

This is still some cleanup, and does not fix much wrt step / continue,
but it introduces dbg_thread_set_single_step that is going to be useful
for individual thread control and let us remove all remaining uses of
gdbctx->context.

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com>
---

v2: Same as before, with better precondition checks.

 programs/winedbg/gdbproxy.c | 71 +++++++++++++++++++------------------
 1 file changed, 36 insertions(+), 35 deletions(-)

diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index 0c9872d93197..f20c8d2ea9ae 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -89,7 +89,6 @@ struct gdb_context
     /* current Win32 trap env */
     unsigned                    last_sig;
     BOOL                        in_trap;
-    dbg_ctx_t                   context;
     /* Win32 information */
     struct dbg_process*         process;
     /* Unix environment */
@@ -271,14 +270,23 @@ static inline void cpu_register_hex_from(struct gdb_context *gdbctx,
  * =============================================== *
  */
 
-static BOOL fetch_context(struct gdb_context *gdbctx, HANDLE h, dbg_ctx_t *ctx)
+static void dbg_thread_set_single_step(struct dbg_thread *thread, BOOL enable)
 {
-    if (!gdbctx->process->be_cpu->get_context(h, ctx))
+    struct backend_cpu *backend;
+    dbg_ctx_t ctx;
+
+    if (!thread) return;
+    if (!thread->process) return;
+    if (!(backend = thread->process->be_cpu)) return;
+
+    if (!backend->get_context(thread->handle, &ctx))
     {
-        ERR("Failed to get context, error %u\n", GetLastError());
-        return FALSE;
+        ERR("get_context failed for thread %04x:%04x\n", thread->process->pid, thread->tid);
+        return;
     }
-    return TRUE;
+    backend->single_step(&ctx, enable);
+    if (!backend->set_context(thread->handle, &ctx))
+        ERR("set_context failed for thread %04x:%04x\n", thread->process->pid, thread->tid);
 }
 
 static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* exc)
@@ -438,10 +446,7 @@ static	void	handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
         TRACE("%08x:%08x: exception code=0x%08x\n", de->dwProcessId,
             de->dwThreadId, de->u.Exception.ExceptionRecord.ExceptionCode);
 
-        if (fetch_context(gdbctx, dbg_curr_thread->handle, &gdbctx->context))
-        {
-            gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception);
-        }
+        gdbctx->in_trap = handle_exception(gdbctx, &de->u.Exception);
         break;
 
     case CREATE_THREAD_DEBUG_EVENT:
@@ -499,9 +504,6 @@ static void resume_debuggee(struct gdb_context* gdbctx, DWORD cont)
 {
     if (dbg_curr_thread)
     {
-        if (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context))
-            ERR("Failed to set context for thread %04x, error %u\n",
-                dbg_curr_thread->tid, GetLastError());
         if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont))
             ERR("Failed to continue thread %04x, error %u\n",
                 dbg_curr_thread->tid, GetLastError());
@@ -518,9 +520,6 @@ static void resume_debuggee_thread(struct gdb_context* gdbctx, DWORD cont, unsig
     {
         if(dbg_curr_thread->tid  == threadid){
             /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */
-            if (!gdbctx->process->be_cpu->set_context(dbg_curr_thread->handle, &gdbctx->context))
-                ERR("Failed to set context for thread %04x, error %u\n",
-                    dbg_curr_thread->tid, GetLastError());
             if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont))
                 ERR("Failed to continue thread %04x, error %u\n",
                     dbg_curr_thread->tid, GetLastError());
@@ -594,7 +593,7 @@ static void    wait_for_debuggee(struct gdb_context* gdbctx)
 static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill)
 {
     assert(gdbctx->process->be_cpu);
-    gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE);
+    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE);
     resume_debuggee(gdbctx, DBG_CONTINUE);
     if (!kill)
         DebugActiveProcessStop(gdbctx->process->pid);
@@ -814,10 +813,19 @@ static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, dbg_
 
 static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
 {
-    if (gdbctx->process != NULL)
+    struct dbg_process *process = gdbctx->process;
+    struct backend_cpu *backend;
+    dbg_ctx_t ctx;
+    size_t i;
+
+    if (process != NULL)
     {
         unsigned char           sig;
-        unsigned                i;
+
+        if (!(backend = process->be_cpu)) return packet_error;
+
+        if (!backend->get_context(dbg_curr_thread->handle, &ctx))
+            return packet_error;
 
         packet_reply_open(gdbctx);
         packet_reply_add(gdbctx, "T");
@@ -827,11 +835,11 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
         packet_reply_val(gdbctx, dbg_curr_thread->tid, 4);
         packet_reply_add(gdbctx, ";");
 
-        for (i = 0; i < gdbctx->process->be_cpu->gdb_num_regs; i++)
+        for (i = 0; i < backend->gdb_num_regs; i++)
         {
             packet_reply_val(gdbctx, i, 1);
             packet_reply_add(gdbctx, ":");
-            packet_reply_register_hex_to(gdbctx, &gdbctx->context, i);
+            packet_reply_register_hex_to(gdbctx, &ctx, i);
             packet_reply_add(gdbctx, ";");
         }
 
@@ -978,13 +986,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
             switch (gdbctx->in_packet[actionIndex[i] + 1])
             {
             case 's': /* step */
-                gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE);
+                if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
                 /* fall through*/
             case 'c': /* continue */
                 resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
                 break;
             case 'S': /* step Sig, */
-                gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE);
+                if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
                 /* fall through */
             case 'C': /* continue sig */
                 hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1);
@@ -1020,13 +1028,13 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
                 switch (gdbctx->in_packet[actionIndex[defaultAction] + 1])
                 {
                 case 's': /* step */
-                    gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE);
+                    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
                     /* fall through */
                 case 'c': /* continue */
                     resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
                     break;
                 case 'S':
-                     gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE);
+                    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
                      /* fall through */
                 case 'C': /* continue sig */
                     hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1);
@@ -1042,8 +1050,7 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
     } /* if(defaultAction >=0) */
 
     wait_for_debuggee(gdbctx);
-    if (gdbctx->process)
-        gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE);
+    if (gdbctx->process && dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE);
     return packet_reply_status(gdbctx);
 }
 
@@ -1100,7 +1107,6 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
 
     if (!backend->get_context(thread->handle, &ctx))
         return packet_error;
-    if (thread == dbg_curr_thread) ctx = gdbctx->context;
 
     packet_reply_open(gdbctx);
     for (i = 0; i < backend->gdb_num_regs; i++)
@@ -1126,7 +1132,6 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
 
     if (!backend->get_context(thread->handle, &ctx))
         return packet_error;
-    if (thread == dbg_curr_thread) ctx = gdbctx->context;
 
     if (gdbctx->in_packet_len < backend->gdb_num_regs * 2)
         return packet_error;
@@ -1141,7 +1146,6 @@ static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
         return packet_error;
     }
 
-    if (thread == dbg_curr_thread) gdbctx->context = ctx;
     return packet_ok;
 }
 
@@ -1268,7 +1272,6 @@ static enum packet_return packet_read_register(struct gdb_context* gdbctx)
 
     if (!backend->get_context(thread->handle, &ctx))
         return packet_error;
-    if (thread == dbg_curr_thread) ctx = gdbctx->context;
 
     if (sscanf(gdbctx->in_packet, "%zx", ®) != 1)
         return packet_error;
@@ -1302,7 +1305,6 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx)
 
     if (!backend->get_context(thread->handle, &ctx))
         return packet_error;
-    if (thread == dbg_curr_thread) ctx = gdbctx->context;
 
     if (!(ptr = strchr(gdbctx->in_packet, '=')))
         return packet_error;
@@ -1328,7 +1330,6 @@ static enum packet_return packet_write_register(struct gdb_context* gdbctx)
         return packet_error;
     }
 
-    if (thread == dbg_curr_thread) gdbctx->context = ctx;
     return packet_ok;
 }
 
@@ -1672,10 +1673,10 @@ static enum packet_return packet_step(struct gdb_context* gdbctx)
     if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
         FIXME("Can't single-step thread %04x while on thread %04x\n",
             gdbctx->exec_thread->tid, dbg_curr_thread->tid);
-    gdbctx->process->be_cpu->single_step(&gdbctx->context, TRUE);
+    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
     resume_debuggee(gdbctx, DBG_CONTINUE);
     wait_for_debuggee(gdbctx);
-    gdbctx->process->be_cpu->single_step(&gdbctx->context, FALSE);
+    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE);
     return packet_reply_status(gdbctx);
 }
 
-- 
2.26.0.rc2

[PATCH v2 4/7] winedbg: Use tid for other/exec thread operations.

[Rémi Bernon]

Looking up the thread makes us loose track of any/all (0/-1) tids, we
need that for correct continue/step implementation.

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com>
---
 programs/winedbg/gdbproxy.c | 76 ++++++++++++++++++++-----------------
 1 file changed, 41 insertions(+), 35 deletions(-)

diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index f20c8d2ea9ae..a2a6df91f336 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -84,8 +84,8 @@ struct gdb_context
     int                         out_len;
     int                         out_curr_packet;
     /* generic GDB thread information */
-    struct dbg_thread*          exec_thread;    /* thread used in step & continue */
-    struct dbg_thread*          other_thread;   /* thread to be used in any other operation */
+    int                         exec_tid; /* tid used in step & continue */
+    int                         other_tid; /* tid to be used in any other operation */
     /* current Win32 trap env */
     unsigned                    last_sig;
     BOOL                        in_trap;
@@ -270,6 +270,23 @@ static inline void cpu_register_hex_from(struct gdb_context *gdbctx,
  * =============================================== *
  */
 
+static struct dbg_thread* dbg_thread_from_tid(struct gdb_context* gdbctx, int tid)
+{
+    struct dbg_process *process = gdbctx->process;
+    struct dbg_thread *thread;
+
+    if (!process) return NULL;
+
+    if (tid == 0) return dbg_curr_thread;
+    LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
+    {
+        if (tid > 0 && thread->tid != tid) continue;
+        return thread;
+    }
+
+    return dbg_curr_thread;
+}
+
 static void dbg_thread_set_single_step(struct dbg_thread *thread, BOOL enable)
 {
     struct backend_cpu *backend;
@@ -384,6 +401,8 @@ static	void	handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
     } u;
 
     dbg_curr_thread = dbg_get_thread(gdbctx->process, de->dwThreadId);
+    gdbctx->exec_tid = de->dwThreadId;
+    gdbctx->other_tid = de->dwThreadId;
 
     switch (de->dwDebugEventCode)
     {
@@ -464,8 +483,6 @@ static	void	handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
                 de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
 
         assert(dbg_curr_thread);
-        if (dbg_curr_thread == gdbctx->exec_thread) gdbctx->exec_thread = NULL;
-        if (dbg_curr_thread == gdbctx->other_thread) gdbctx->other_thread = NULL;
         dbg_del_thread(dbg_curr_thread);
         break;
 
@@ -865,9 +882,9 @@ static enum packet_return packet_continue(struct gdb_context* gdbctx)
 {
     /* FIXME: add support for address in packet */
     assert(gdbctx->in_packet_len == 0);
-    if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
+    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
         FIXME("Can't continue thread %04x while on thread %04x\n",
-            gdbctx->exec_thread->tid, dbg_curr_thread->tid);
+            gdbctx->exec_tid, dbg_curr_thread->tid);
     resume_debuggee(gdbctx, DBG_CONTINUE);
     wait_for_debuggee(gdbctx);
     return packet_reply_status(gdbctx);
@@ -962,9 +979,9 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
     /* Ok, now we have... actionIndex full of actions and we know what threads there are, so all
      * that remains is to apply the actions to the threads and the default action to any threads
      * left */
-    if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
+    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
         FIXME("Can't continue thread %04x while on thread %04x\n",
-            gdbctx->exec_thread->tid, dbg_curr_thread->tid);
+            gdbctx->exec_tid, dbg_curr_thread->tid);
 
     /* deal with the threaded stuff first */
     for (i = 0; i < actions ; i++)
@@ -1073,9 +1090,9 @@ static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
 
     /* FIXME: add support for address in packet */
     assert(gdbctx->in_packet_len == 2);
-    if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
+    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
         FIXME("Can't continue thread %04x while on thread %04x\n",
-            gdbctx->exec_thread->tid, dbg_curr_thread->tid);
+            gdbctx->exec_tid, dbg_curr_thread->tid);
     hex_from(&sig, gdbctx->in_packet, 1);
     /* cannot change signals on the fly */
     TRACE("sigs: %u %u\n", sig, gdbctx->last_sig);
@@ -1094,7 +1111,7 @@ static enum packet_return packet_detach(struct gdb_context* gdbctx)
 
 static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
 {
-    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
     struct backend_cpu *backend;
     dbg_ctx_t ctx;
     size_t i;
@@ -1118,7 +1135,7 @@ static enum packet_return packet_read_registers(struct gdb_context* gdbctx)
 
 static enum packet_return packet_write_registers(struct gdb_context* gdbctx)
 {
-    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
     struct backend_cpu *backend;
     dbg_ctx_t ctx;
     const char *ptr;
@@ -1157,28 +1174,16 @@ static enum packet_return packet_kill(struct gdb_context* gdbctx)
 
 static enum packet_return packet_thread(struct gdb_context* gdbctx)
 {
-    char* end;
-    unsigned thread;
-
     switch (gdbctx->in_packet[0])
     {
     case 'c':
+        if (sscanf(gdbctx->in_packet, "c%x", &gdbctx->exec_tid) == 1)
+            return packet_ok;
+        return packet_error;
     case 'g':
-        if (gdbctx->in_packet[1] == '-')
-            thread = -strtol(gdbctx->in_packet + 2, &end, 16);
-        else
-            thread = strtol(gdbctx->in_packet + 1, &end, 16);
-        if (end == NULL || end > gdbctx->in_packet + gdbctx->in_packet_len)
-        {
-            ERR("Failed to parse %s\n",
-                debugstr_an(gdbctx->in_packet, gdbctx->in_packet_len));
-            return packet_error;
-        }
-        if (gdbctx->in_packet[0] == 'c')
-            gdbctx->exec_thread = dbg_get_thread(gdbctx->process, thread);
-        else
-            gdbctx->other_thread = dbg_get_thread(gdbctx->process, thread);
-        return packet_ok;
+        if (sscanf(gdbctx->in_packet, "g%x", &gdbctx->other_tid) == 1)
+            return packet_ok;
+        return packet_error;
     default:
         FIXME("Unknown thread sub-command %c\n", gdbctx->in_packet[0]);
         return packet_error;
@@ -1259,7 +1264,7 @@ static enum packet_return packet_write_memory(struct gdb_context* gdbctx)
 
 static enum packet_return packet_read_register(struct gdb_context* gdbctx)
 {
-    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
     struct backend_cpu *backend;
     dbg_ctx_t ctx;
     size_t reg;
@@ -1291,7 +1296,7 @@ static enum packet_return packet_read_register(struct gdb_context* gdbctx)
 
 static enum packet_return packet_write_register(struct gdb_context* gdbctx)
 {
-    struct dbg_thread *thread = gdbctx->other_thread ? gdbctx->other_thread : dbg_curr_thread;
+    struct dbg_thread *thread = dbg_thread_from_tid(gdbctx, gdbctx->other_tid);
     struct backend_cpu *backend;
     dbg_ctx_t ctx;
     size_t reg;
@@ -1670,9 +1675,9 @@ static enum packet_return packet_step(struct gdb_context* gdbctx)
 {
     /* FIXME: add support for address in packet */
     assert(gdbctx->in_packet_len == 0);
-    if (dbg_curr_thread != gdbctx->exec_thread && gdbctx->exec_thread)
+    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
         FIXME("Can't single-step thread %04x while on thread %04x\n",
-            gdbctx->exec_thread->tid, dbg_curr_thread->tid);
+            gdbctx->exec_tid, dbg_curr_thread->tid);
     if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
     resume_debuggee(gdbctx, DBG_CONTINUE);
     wait_for_debuggee(gdbctx);
@@ -1976,7 +1981,8 @@ static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags, unsigne
     gdbctx->out_len = 0;
     gdbctx->out_curr_packet = -1;
 
-    gdbctx->exec_thread = gdbctx->other_thread = NULL;
+    gdbctx->exec_tid = -1;
+    gdbctx->other_tid = -1;
     gdbctx->last_sig = 0;
     gdbctx->in_trap = FALSE;
     gdbctx->process = NULL;
-- 
2.26.0.rc2

[PATCH v2 5/7] winedbg: Store the current debug event in gdbctx.

[Rémi Bernon]

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com>
---
 programs/winedbg/gdbproxy.c | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index a2a6df91f336..078a140a611d 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -87,6 +87,7 @@ struct gdb_context
     int                         exec_tid; /* tid used in step & continue */
     int                         other_tid; /* tid to be used in any other operation */
     /* current Win32 trap env */
+    DEBUG_EVENT                 de;
     unsigned                    last_sig;
     BOOL                        in_trap;
     /* Win32 information */
@@ -393,8 +394,10 @@ static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* e
     return ret;
 }
 
-static	void	handle_debug_event(struct gdb_context* gdbctx, DEBUG_EVENT* de)
+static void handle_debug_event(struct gdb_context* gdbctx)
 {
+    DEBUG_EVENT *de = &gdbctx->de;
+
     union {
         char                bufferA[256];
         WCHAR               buffer[256];
@@ -575,12 +578,10 @@ static BOOL	check_for_interrupt(struct gdb_context* gdbctx)
 
 static void    wait_for_debuggee(struct gdb_context* gdbctx)
 {
-    DEBUG_EVENT         de;
-
     gdbctx->in_trap = FALSE;
     for (;;)
     {
-		if (!WaitForDebugEvent(&de, 10))
+		if (!WaitForDebugEvent(&gdbctx->de, 10))
 		{
 			if (GetLastError() == ERROR_SEM_TIMEOUT)
 			{
@@ -589,7 +590,7 @@ static void    wait_for_debuggee(struct gdb_context* gdbctx)
 						ERR("Failed to break into debuggee\n");
 						break;
 					}
-					WaitForDebugEvent(&de, INFINITE);	
+					WaitForDebugEvent(&gdbctx->de, INFINITE);
 				} else {
 					continue;
 				} 
@@ -597,13 +598,13 @@ static void    wait_for_debuggee(struct gdb_context* gdbctx)
 				break;
 			} 
 		}
-        handle_debug_event(gdbctx, &de);
+        handle_debug_event(gdbctx);
         assert(!gdbctx->process ||
                gdbctx->process->pid == 0 ||
-               de.dwProcessId == gdbctx->process->pid);
-        assert(!dbg_curr_thread || de.dwThreadId == dbg_curr_thread->tid);
+               gdbctx->de.dwProcessId == gdbctx->process->pid);
+        assert(!dbg_curr_thread || gdbctx->de.dwThreadId == dbg_curr_thread->tid);
         if (gdbctx->in_trap) break;
-        ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
+        ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
     }
 }
 
@@ -1880,7 +1881,7 @@ static BOOL gdb_exec(const char* wine_path, unsigned port, unsigned flags)
     return TRUE;
 }
 
-static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned flags, unsigned port)
+static BOOL gdb_startup(struct gdb_context* gdbctx, unsigned flags, unsigned port)
 {
     int                 sock;
     struct sockaddr_in  s_addrs = {0};
@@ -1906,7 +1907,7 @@ static BOOL gdb_startup(struct gdb_context* gdbctx, DEBUG_EVENT* de, unsigned fl
         goto cleanup;
 
     /* step 2: do the process internal creation */
-    handle_debug_event(gdbctx, de);
+    handle_debug_event(gdbctx);
 
     /* step3: get the wine loader name */
     if (!dbg_get_debuggee_info(gdbctx->process->handle, &imh_mod))
@@ -1969,7 +1970,6 @@ cleanup:
 
 static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags, unsigned port)
 {
-    DEBUG_EVENT         de;
     int                 i;
 
     gdbctx->sock = -1;
@@ -1991,23 +1991,23 @@ static BOOL gdb_init_context(struct gdb_context* gdbctx, unsigned flags, unsigne
         gdbctx->wine_segs[i] = 0;
 
     /* wait for first trap */
-    while (WaitForDebugEvent(&de, INFINITE))
+    while (WaitForDebugEvent(&gdbctx->de, INFINITE))
     {
-        if (de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
+        if (gdbctx->de.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
         {
             /* this should be the first event we get,
              * and the only one of this type  */
-            assert(gdbctx->process == NULL && de.dwProcessId == dbg_curr_pid);
+            assert(gdbctx->process == NULL && gdbctx->de.dwProcessId == dbg_curr_pid);
             /* gdbctx->dwProcessId = pid; */
-            if (!gdb_startup(gdbctx, &de, flags, port)) return FALSE;
+            if (!gdb_startup(gdbctx, flags, port)) return FALSE;
             assert(!gdbctx->in_trap);
         }
         else
         {
-            handle_debug_event(gdbctx, &de);
+            handle_debug_event(gdbctx);
             if (gdbctx->in_trap) break;
         }
-        ContinueDebugEvent(de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
+        ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
     }
     return TRUE;
 }
-- 
2.26.0.rc2

[PATCH v2 6/7] winedbg: Rewrite and simplify step / continue handlers.

[Rémi Bernon]

The vCont handler used some overcomplicated logic, we only need to
iterate over the actions and apply them on the matching threads that
didn't match yet.

Thanks to DBG_REPLY_LATER we can now continue/step any thread regardless
of whether it is the one that raised the debug event. Just suspend all
active threads after debug event is raised and resume them one by one,
according to the gdb request. If the thread that raised the debug event
should not be resumed, reply with DBG_REPLY_LATER.

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com>
---
 programs/winedbg/debugger.h |   1 +
 programs/winedbg/gdbproxy.c | 289 ++++++++++--------------------------
 programs/winedbg/winedbg.c  |   1 +
 3 files changed, 80 insertions(+), 211 deletions(-)

diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h
index 40d93d669c82..ddac129bab53 100644
--- a/programs/winedbg/debugger.h
+++ b/programs/winedbg/debugger.h
@@ -207,6 +207,7 @@ struct dbg_thread
     }*                          frames;
     int                         num_frames;
     int                         curr_frame;
+    BOOL                        suspended;
 };
 
 struct dbg_delayed_bp
diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index 078a140a611d..0e60bbb6457f 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -88,6 +88,7 @@ struct gdb_context
     int                         other_tid; /* tid to be used in any other operation */
     /* current Win32 trap env */
     DEBUG_EVENT                 de;
+    DWORD                       de_reply;
     unsigned                    last_sig;
     BOOL                        in_trap;
     /* Win32 information */
@@ -137,17 +138,6 @@ static inline unsigned char hex_to0(int x)
     return "0123456789abcdef"[x];
 }
 
-static int hex_to_int(const char* src, size_t len)
-{
-    unsigned int returnval = 0;
-    while (len--)
-    {
-        returnval <<= 4;
-        returnval |= hex_from0(*src++);
-    }
-    return returnval;
-}
-
 static void hex_from(void* dst, const char* src, size_t len)
 {
     unsigned char *p = dst;
@@ -397,6 +387,7 @@ static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* e
 static void handle_debug_event(struct gdb_context* gdbctx)
 {
     DEBUG_EVENT *de = &gdbctx->de;
+    struct dbg_thread *thread;
 
     union {
         char                bufferA[256];
@@ -406,6 +397,7 @@ static void handle_debug_event(struct gdb_context* gdbctx)
     dbg_curr_thread = dbg_get_thread(gdbctx->process, de->dwThreadId);
     gdbctx->exec_tid = de->dwThreadId;
     gdbctx->other_tid = de->dwThreadId;
+    gdbctx->de_reply = DBG_REPLY_LATER;
 
     switch (de->dwDebugEventCode)
     {
@@ -518,35 +510,34 @@ static void handle_debug_event(struct gdb_context* gdbctx)
         FIXME("%08x:%08x: unknown event (%u)\n",
             de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
     }
-}
 
-static void resume_debuggee(struct gdb_context* gdbctx, DWORD cont)
-{
-    if (dbg_curr_thread)
+    if (!gdbctx->in_trap || !gdbctx->process) return;
+
+    LIST_FOR_EACH_ENTRY(thread, &gdbctx->process->threads, struct dbg_thread, entry)
     {
-        if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont))
-            ERR("Failed to continue thread %04x, error %u\n",
-                dbg_curr_thread->tid, GetLastError());
+        if (!thread->suspended) SuspendThread(thread->handle);
+        thread->suspended = TRUE;
     }
-    else
-        ERR("Cannot find last thread\n");
 }
 
-
-static void resume_debuggee_thread(struct gdb_context* gdbctx, DWORD cont, unsigned int threadid)
+static void handle_step_or_continue(struct gdb_context* gdbctx, int tid, BOOL step, int sig)
 {
+    struct dbg_process *process = gdbctx->process;
+    struct dbg_thread *thread;
 
-    if (dbg_curr_thread)
+    if (tid == 0) tid = dbg_curr_thread->tid;
+    LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
     {
-        if(dbg_curr_thread->tid  == threadid){
-            /* Windows debug and GDB don't seem to work well here, windows only likes ContinueDebugEvent being used on the reporter of the event */
-            if (!ContinueDebugEvent(gdbctx->process->pid, dbg_curr_thread->tid, cont))
-                ERR("Failed to continue thread %04x, error %u\n",
-                    dbg_curr_thread->tid, GetLastError());
-        }
+        if (tid != -1 && thread->tid != tid) continue;
+        if (!thread->suspended) continue;
+        thread->suspended = FALSE;
+
+        if (process->pid == gdbctx->de.dwProcessId && thread->tid == gdbctx->de.dwThreadId)
+            gdbctx->de_reply = (sig == -1 ? DBG_CONTINUE : DBG_EXCEPTION_NOT_HANDLED);
+
+        dbg_thread_set_single_step(thread, step);
+        ResumeThread(thread->handle);
     }
-    else
-        ERR("Cannot find last thread\n");
 }
 
 static BOOL	check_for_interrupt(struct gdb_context* gdbctx)
@@ -578,6 +569,9 @@ static BOOL	check_for_interrupt(struct gdb_context* gdbctx)
 
 static void    wait_for_debuggee(struct gdb_context* gdbctx)
 {
+    if (gdbctx->de.dwDebugEventCode)
+        ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, gdbctx->de_reply);
+
     gdbctx->in_trap = FALSE;
     for (;;)
     {
@@ -610,9 +604,11 @@ static void    wait_for_debuggee(struct gdb_context* gdbctx)
 
 static void detach_debuggee(struct gdb_context* gdbctx, BOOL kill)
 {
-    assert(gdbctx->process->be_cpu);
-    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE);
-    resume_debuggee(gdbctx, DBG_CONTINUE);
+    handle_step_or_continue(gdbctx, -1, FALSE, -1);
+
+    if (gdbctx->de.dwDebugEventCode)
+        ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
+
     if (!kill)
         DebugActiveProcessStop(gdbctx->process->pid);
     dbg_del_process(gdbctx->process);
@@ -881,51 +877,25 @@ static enum packet_return packet_last_signal(struct gdb_context* gdbctx)
 
 static enum packet_return packet_continue(struct gdb_context* gdbctx)
 {
-    /* FIXME: add support for address in packet */
-    assert(gdbctx->in_packet_len == 0);
-    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
-        FIXME("Can't continue thread %04x while on thread %04x\n",
-            gdbctx->exec_tid, dbg_curr_thread->tid);
-    resume_debuggee(gdbctx, DBG_CONTINUE);
+    void *addr;
+
+    if (sscanf(gdbctx->in_packet, "%p", &addr) == 1)
+        FIXME("Continue at address %p not supported\n", addr);
+
+    handle_step_or_continue(gdbctx, gdbctx->exec_tid, FALSE, -1);
+
     wait_for_debuggee(gdbctx);
     return packet_reply_status(gdbctx);
 }
 
 static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
 {
-    int i;
-    int defaultAction = -1; /* magic non action */
-    unsigned char sig;
-    int actions =0;
-    int actionIndex[20]; /* allow for up to 20 actions */
-    int threadIndex[20];
-    int threadCount = 0;
-    unsigned int threadIDs[100]; /* TODO: Should make this dynamic */
-    unsigned int threadID = 0;
-    struct dbg_thread*  thd;
-
-    /* OK we have vCont followed by..
-    * ? for query
-    * c for packet_continue
-    * Csig for packet_continue_signal
-    * s for step
-    * Ssig  for step signal
-    * and then an optional thread ID at the end..
-    * *******************************************/
+    char *buf = gdbctx->in_packet, *end = gdbctx->in_packet + gdbctx->in_packet_len;
 
-    /* Query */
     if (gdbctx->in_packet[4] == '?')
     {
-        /*
-          Reply:
-          `vCont[;action]...'
-          The vCont packet is supported. Each action is a supported command in the vCont packet.
-          `'
-          The vCont packet is not supported.  (this didn't seem to be obeyed!)
-        */
         packet_reply_open(gdbctx);
         packet_reply_add(gdbctx, "vCont");
-        /* add all the supported actions to the reply (all of them for now) */
         packet_reply_add(gdbctx, ";c");
         packet_reply_add(gdbctx, ";C");
         packet_reply_add(gdbctx, ";s");
@@ -934,141 +904,37 @@ static enum packet_return packet_verbose_cont(struct gdb_context* gdbctx)
         return packet_done;
     }
 
-    /* go through the packet and identify where all the actions start at */
-    for (i = 4; i < gdbctx->in_packet_len - 1; i++)
+    while (buf < end && (buf = memchr(buf + 1, ';', end - buf - 1)))
     {
-        if (gdbctx->in_packet[i] == ';')
-        {
-            threadIndex[actions] = 0;
-            actionIndex[actions++] = i;
-        }
-        else if (gdbctx->in_packet[i] == ':')
-        {
-            threadIndex[actions - 1] = i;
-        }
-    }
+        int tid = -1, sig = -1;
+        int action, n;
 
-    /* now look up the default action */
-    for (i = 0 ; i < actions; i++)
-    {
-        if (threadIndex[i] == 0)
+        switch ((action = buf[1]))
         {
-            if (defaultAction != -1)
-            {
-                fprintf(stderr,"Too many default actions specified\n");
+        default:
+            return packet_error;
+        case 'c':
+        case 's':
+            buf += 2;
+            break;
+        case 'C':
+        case 'S':
+            if (sscanf(buf, ";%*c%2x", &sig) <= 0 ||
+                sig != gdbctx->last_sig)
                 return packet_error;
-            }
-            defaultAction = i;
-        }
-    }
-
-    /* Now, I have this default action thing that needs to be applied to all non counted threads */
-
-    /* go through all the threads and stick their ids in the to be done list. */
-    LIST_FOR_EACH_ENTRY(thd, &gdbctx->process->threads, struct dbg_thread, entry)
-    {
-        threadIDs[threadCount++] = thd->tid;
-        /* check to see if we have more threads than I counted on, and tell the user what to do
-         * (they're running winedbg, so I'm sure they can fix the problem from the error message!) */
-        if (threadCount == 100)
-        {
-            fprintf(stderr, "Wow, that's a lot of threads, change threadIDs in wine/programs/winedbg/gdbproxy.c to be higher\n");
+            buf += 4;
             break;
         }
-    }
-
-    /* Ok, now we have... actionIndex full of actions and we know what threads there are, so all
-     * that remains is to apply the actions to the threads and the default action to any threads
-     * left */
-    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
-        FIXME("Can't continue thread %04x while on thread %04x\n",
-            gdbctx->exec_tid, dbg_curr_thread->tid);
-
-    /* deal with the threaded stuff first */
-    for (i = 0; i < actions ; i++)
-    {
-        if (threadIndex[i] != 0)
-        {
-            int j, idLength = 0;
-            if (i < actions - 1)
-            {
-                idLength = (actionIndex[i+1] - threadIndex[i]) - 1;
-            }
-            else
-            {
-                idLength = (gdbctx->in_packet_len - threadIndex[i]) - 1;
-            }
 
-            threadID = hex_to_int(gdbctx->in_packet + threadIndex[i] + 1 , idLength);
-            /* process the action */
-            switch (gdbctx->in_packet[actionIndex[i] + 1])
-            {
-            case 's': /* step */
-                if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
-                /* fall through*/
-            case 'c': /* continue */
-                resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
-                break;
-            case 'S': /* step Sig, */
-                if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
-                /* fall through */
-            case 'C': /* continue sig */
-                hex_from(&sig, gdbctx->in_packet + actionIndex[i] + 2, 1);
-                /* cannot change signals on the fly */
-                TRACE("sigs: %u %u\n", sig, gdbctx->last_sig);
-                if (sig != gdbctx->last_sig)
-                    return packet_error;
-                resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID);
-                break;
-            }
-            for (j = 0 ; j < threadCount; j++)
-            {
-                if (threadIDs[j] == threadID)
-                {
-                    threadIDs[j] = 0;
-                    break;
-                }
-            }
-        }
-    } /* for i=0 ; i< actions */
+        if (buf > end)
+            return packet_error;
+        if (buf < end && *buf == ':' && (n = sscanf(buf, ":%x", &tid)) <= 0)
+            return packet_error;
 
-    /* now we have manage the default action */
-    if (defaultAction >= 0)
-    {
-        for (i = 0 ; i< threadCount; i++)
-        {
-            /* check to see if we've already done something to the thread*/
-            if (threadIDs[i] != 0)
-            {
-                /* if not apply the default action*/
-                threadID = threadIDs[i];
-                /* process the action (yes this is almost identical to the one above!) */
-                switch (gdbctx->in_packet[actionIndex[defaultAction] + 1])
-                {
-                case 's': /* step */
-                    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
-                    /* fall through */
-                case 'c': /* continue */
-                    resume_debuggee_thread(gdbctx, DBG_CONTINUE, threadID);
-                    break;
-                case 'S':
-                    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
-                     /* fall through */
-                case 'C': /* continue sig */
-                    hex_from(&sig, gdbctx->in_packet + actionIndex[defaultAction] + 2, 1);
-                    /* cannot change signals on the fly */
-                    TRACE("sigs: %u %u\n", sig, gdbctx->last_sig);
-                    if (sig != gdbctx->last_sig)
-                        return packet_error;
-                    resume_debuggee_thread(gdbctx, DBG_EXCEPTION_NOT_HANDLED, threadID);
-                    break;
-                }
-            }
-        }
-    } /* if(defaultAction >=0) */
+        handle_step_or_continue(gdbctx, tid, action == 's' || action == 'S', sig);
+    }
 
     wait_for_debuggee(gdbctx);
-    if (gdbctx->process && dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE);
     return packet_reply_status(gdbctx);
 }
 
@@ -1087,19 +953,21 @@ static enum packet_return packet_verbose(struct gdb_context* gdbctx)
 
 static enum packet_return packet_continue_signal(struct gdb_context* gdbctx)
 {
-    unsigned char sig;
+    void *addr;
+    int sig, n;
+
+    if ((n = sscanf(gdbctx->in_packet, "%x;%p", &sig, &addr)) == 2)
+        FIXME("Continue at address %p not supported\n", addr);
+    if (n < 1) return packet_error;
 
-    /* FIXME: add support for address in packet */
-    assert(gdbctx->in_packet_len == 2);
-    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
-        FIXME("Can't continue thread %04x while on thread %04x\n",
-            gdbctx->exec_tid, dbg_curr_thread->tid);
-    hex_from(&sig, gdbctx->in_packet, 1);
-    /* cannot change signals on the fly */
-    TRACE("sigs: %u %u\n", sig, gdbctx->last_sig);
     if (sig != gdbctx->last_sig)
+    {
+        ERR("Changing signals is not supported.\n");
         return packet_error;
-    resume_debuggee(gdbctx, DBG_EXCEPTION_NOT_HANDLED);
+    }
+
+    handle_step_or_continue(gdbctx, gdbctx->exec_tid, FALSE, sig);
+
     wait_for_debuggee(gdbctx);
     return packet_reply_status(gdbctx);
 }
@@ -1674,15 +1542,14 @@ static enum packet_return packet_set(struct gdb_context* gdbctx)
 
 static enum packet_return packet_step(struct gdb_context* gdbctx)
 {
-    /* FIXME: add support for address in packet */
-    assert(gdbctx->in_packet_len == 0);
-    if (gdbctx->exec_tid > 0 && dbg_curr_thread->tid != gdbctx->exec_tid)
-        FIXME("Can't single-step thread %04x while on thread %04x\n",
-            gdbctx->exec_tid, dbg_curr_thread->tid);
-    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, TRUE);
-    resume_debuggee(gdbctx, DBG_CONTINUE);
+    void *addr;
+
+    if (sscanf(gdbctx->in_packet, "%p", &addr) == 1)
+        FIXME("Continue at address %p not supported\n", addr);
+
+    handle_step_or_continue(gdbctx, gdbctx->exec_tid, TRUE, -1);
+
     wait_for_debuggee(gdbctx);
-    if (dbg_curr_thread) dbg_thread_set_single_step(dbg_curr_thread, FALSE);
     return packet_reply_status(gdbctx);
 }
 
diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c
index 5dee3b7e5ab4..19f30f04e5dd 100644
--- a/programs/winedbg/winedbg.c
+++ b/programs/winedbg/winedbg.c
@@ -500,6 +500,7 @@ struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid,
     t->num_frames = 0;
     t->curr_frame = -1;
     t->addr_mode = AddrModeFlat;
+    t->suspended = FALSE;
 
     snprintf(t->name, sizeof(t->name), "%04x", tid);
 
-- 
2.26.0.rc2

[PATCH v2 7/7] winedbg: Remove uses of dbg_curr_thread from gdbproxy.

[Rémi Bernon]

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com>
---
 programs/winedbg/gdbproxy.c | 25 ++++++++++---------------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/programs/winedbg/gdbproxy.c b/programs/winedbg/gdbproxy.c
index 0e60bbb6457f..7c57caf9d1e8 100644
--- a/programs/winedbg/gdbproxy.c
+++ b/programs/winedbg/gdbproxy.c
@@ -268,14 +268,14 @@ static struct dbg_thread* dbg_thread_from_tid(struct gdb_context* gdbctx, int ti
 
     if (!process) return NULL;
 
-    if (tid == 0) return dbg_curr_thread;
+    if (tid == 0) tid = gdbctx->de.dwThreadId;
     LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
     {
         if (tid > 0 && thread->tid != tid) continue;
         return thread;
     }
 
-    return dbg_curr_thread;
+    return NULL;
 }
 
 static void dbg_thread_set_single_step(struct dbg_thread *thread, BOOL enable)
@@ -357,7 +357,7 @@ static BOOL handle_exception(struct gdb_context* gdbctx, EXCEPTION_DEBUG_INFO* e
         SIZE_T read;
 
         if (threadname->dwThreadID == -1)
-            thread = dbg_curr_thread;
+            thread = dbg_get_thread(gdbctx->process, gdbctx->de.dwThreadId);
         else
             thread = dbg_get_thread(gdbctx->process, threadname->dwThreadID);
         if (thread)
@@ -394,7 +394,6 @@ static void handle_debug_event(struct gdb_context* gdbctx)
         WCHAR               buffer[256];
     } u;
 
-    dbg_curr_thread = dbg_get_thread(gdbctx->process, de->dwThreadId);
     gdbctx->exec_tid = de->dwThreadId;
     gdbctx->other_tid = de->dwThreadId;
     gdbctx->de_reply = DBG_REPLY_LATER;
@@ -426,14 +425,12 @@ static void handle_debug_event(struct gdb_context* gdbctx)
         fprintf(stderr, "%04x:%04x: create thread I @%p\n", de->dwProcessId,
             de->dwThreadId, de->u.CreateProcessInfo.lpStartAddress);
 
-        assert(dbg_curr_thread == NULL); /* shouldn't be there */
         dbg_add_thread(gdbctx->process, de->dwThreadId,
                        de->u.CreateProcessInfo.hThread,
                        de->u.CreateProcessInfo.lpThreadLocalBase);
         break;
 
     case LOAD_DLL_DEBUG_EVENT:
-        assert(dbg_curr_thread);
         memory_get_string_indirect(gdbctx->process,
                                    de->u.LoadDll.lpImageName,
                                    de->u.LoadDll.fUnicode,
@@ -456,7 +453,6 @@ static void handle_debug_event(struct gdb_context* gdbctx)
         break;
 
     case EXCEPTION_DEBUG_EVENT:
-        assert(dbg_curr_thread);
         TRACE("%08x:%08x: exception code=0x%08x\n", de->dwProcessId,
             de->dwThreadId, de->u.Exception.ExceptionRecord.ExceptionCode);
 
@@ -476,9 +472,8 @@ static void handle_debug_event(struct gdb_context* gdbctx)
     case EXIT_THREAD_DEBUG_EVENT:
         fprintf(stderr, "%08x:%08x: exit thread (%u)\n",
                 de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);
-
-        assert(dbg_curr_thread);
-        dbg_del_thread(dbg_curr_thread);
+        if ((thread = dbg_get_thread(gdbctx->process, de->dwThreadId)))
+            dbg_del_thread(thread);
         break;
 
     case EXIT_PROCESS_DEBUG_EVENT:
@@ -493,7 +488,6 @@ static void handle_debug_event(struct gdb_context* gdbctx)
         break;
 
     case OUTPUT_DEBUG_STRING_EVENT:
-        assert(dbg_curr_thread);
         memory_get_string(gdbctx->process,
                           de->u.DebugString.lpDebugStringData, TRUE,
                           de->u.DebugString.fUnicode, u.bufferA, sizeof(u.bufferA));
@@ -525,7 +519,7 @@ static void handle_step_or_continue(struct gdb_context* gdbctx, int tid, BOOL st
     struct dbg_process *process = gdbctx->process;
     struct dbg_thread *thread;
 
-    if (tid == 0) tid = dbg_curr_thread->tid;
+    if (tid == 0) tid = gdbctx->de.dwThreadId;
     LIST_FOR_EACH_ENTRY(thread, &process->threads, struct dbg_thread, entry)
     {
         if (tid != -1 && thread->tid != tid) continue;
@@ -596,7 +590,6 @@ static void    wait_for_debuggee(struct gdb_context* gdbctx)
         assert(!gdbctx->process ||
                gdbctx->process->pid == 0 ||
                gdbctx->de.dwProcessId == gdbctx->process->pid);
-        assert(!dbg_curr_thread || gdbctx->de.dwThreadId == dbg_curr_thread->tid);
         if (gdbctx->in_trap) break;
         ContinueDebugEvent(gdbctx->de.dwProcessId, gdbctx->de.dwThreadId, DBG_CONTINUE);
     }
@@ -828,6 +821,7 @@ static inline void packet_reply_register_hex_to(struct gdb_context* gdbctx, dbg_
 static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
 {
     struct dbg_process *process = gdbctx->process;
+    struct dbg_thread *thread;
     struct backend_cpu *backend;
     dbg_ctx_t ctx;
     size_t i;
@@ -838,7 +832,8 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
 
         if (!(backend = process->be_cpu)) return packet_error;
 
-        if (!backend->get_context(dbg_curr_thread->handle, &ctx))
+        if (!(thread = dbg_get_thread(process, gdbctx->de.dwThreadId)) ||
+            !backend->get_context(thread->handle, &ctx))
             return packet_error;
 
         packet_reply_open(gdbctx);
@@ -846,7 +841,7 @@ static enum packet_return packet_reply_status(struct gdb_context* gdbctx)
         sig = gdbctx->last_sig;
         packet_reply_val(gdbctx, sig, 1);
         packet_reply_add(gdbctx, "thread:");
-        packet_reply_val(gdbctx, dbg_curr_thread->tid, 4);
+        packet_reply_val(gdbctx, gdbctx->de.dwThreadId, 4);
         packet_reply_add(gdbctx, ";");
 
         for (i = 0; i < backend->gdb_num_regs; i++)
-- 
2.26.0.rc2