From 6e1cac01e1c91f267f027775b3ad86500931f950 Mon Sep 17 00:00:00 2001
From: Jason Green <jason@jave01.(none)>
Date: Tue, 20 Nov 2007 16:10:15 -0500
Subject: [PATCH] Improve TRACEs, and detect 64-bit addresses when walking the stack

---
 dlls/dbghelp/stack.c |  100 +++++++++++++++++++++++++++++++++++++++-----------
 1 files changed, 78 insertions(+), 22 deletions(-)

diff --git a/dlls/dbghelp/stack.c b/dlls/dbghelp/stack.c
index 1eefbb8..d798f12 100644
--- a/dlls/dbghelp/stack.c
+++ b/dlls/dbghelp/stack.c
@@ -116,6 +116,20 @@ static inline void addr_32to64(const ADDRESS* addr32, ADDRESS64* addr64)
 
 static inline void addr_64to32(const ADDRESS64* addr64, ADDRESS* addr32)
 {
+    if (addr64->Offset >> 32){
+        const char *mode = "";
+
+
+        switch (addr64->Mode){
+            case AddrMode1616: mode = "1616"; break;
+            case AddrMode1632: mode = "1632"; break;
+            case AddrModeReal: mode = "Real"; break;
+            case AddrModeFlat: mode = "Flat"; break;
+        }
+
+        ERR("detected a 64-bit address! {addr64 = <mode = %s, segment = 0x%04x, offset = 0x%016llx>}\n", mode, addr64->Segment, addr64->Offset);
+    }
+
     addr32->Offset = (ULONG)addr64->Offset;
     addr32->Segment = addr64->Segment;
     addr32->Mode = addr64->Mode;
@@ -172,7 +186,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
     /* sanity check */
     if (curr_mode >= stm_done) return FALSE;
 
-    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08x nSwitch=%08x\n",
+    TRACE("Enter: PC = %s Frame = %s Return = %s Stack = %s Mode = %s cSwitch = 0x%08x nSwitch = 0x%08x\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
@@ -184,10 +198,11 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
     {
         THREAD_BASIC_INFORMATION info;
 
+
         if ((frame->AddrPC.Mode == AddrModeFlat) &&
             (frame->AddrFrame.Mode != AddrModeFlat))
         {
-            WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n");
+            WARN("[start] Bad AddrPC.Mode / AddrFrame.Mode combination\n");
             goto done_err;
         }
 
@@ -202,16 +217,17 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
                                      sizeof(info), NULL) == STATUS_SUCCESS)
         {
             curr_switch = (unsigned long)info.TebBaseAddress + FIELD_OFFSET(TEB, WOW32Reserved);
+
             if (!sw_read_mem(cb, curr_switch, &next_switch, sizeof(next_switch)))
             {
-                WARN("Can't read TEB:WOW32Reserved\n");
+                WARN("[start] Can't read TEB:WOW32Reserved\n");
                 goto done_err;
             }
             if (curr_mode == stm_16bit)
             {
                 if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32)))
                 {
-                    WARN("Bad stack frame 0x%08x\n", next_switch);
+                    WARN("[start] Bad 16-bit stack frame 0x%08x\n", next_switch);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame32.frame16;
@@ -229,7 +245,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
                 p = sw_xlat_addr(cb, &tmp);
                 if (!sw_read_mem(cb, p, &frame16, sizeof(frame16)))
                 {
-                    WARN("Bad stack frame 0x%08x\n", p);
+                    WARN("[start] Bad 32-bit stack frame 0x%08x\n", p);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame16.frame32;
@@ -243,7 +259,10 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
              * but the 16 <=> 32 switch facility won't be available.
              */
             curr_switch = 0;
-        frame->AddrReturn.Mode = frame->AddrStack.Mode = (curr_mode == stm_16bit) ? AddrMode1616 : AddrModeFlat;
+
+
+        /* NOTE: native doesn't set frame->AddrStack.Mode until the second frame (when its offset is set) */
+        frame->AddrReturn.Mode /*= frame->AddrStack.Mode*/ = (curr_mode == stm_16bit) ? AddrMode1616 : AddrModeFlat;
         /* don't set up AddrStack on first call. Either the caller has set it up, or
          * we will get it in the next frame
          */
@@ -251,18 +270,37 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
     }
     else
     {
-        if (frame->AddrFrame.Offset == 0) goto done_err;
+        if (frame->AddrFrame.Offset == 0){
+            TRACE("[continue] null frame offset!\n");
+            goto done_err;
+        }
+
         if (frame->AddrFrame.Mode == AddrModeFlat)
         {
             assert(curr_mode == stm_32bit);
+            if (curr_mode != stm_32bit)
+                ERR("[continue] not in 32-bit stack mode!\n");
+
             do_switch = curr_switch && frame->AddrFrame.Offset >= curr_switch;
+            TRACE("do_switch = %s {curr_switch = 0x%08x, frame->AddrFrame.Offset = 0x%08x}\n", 
+                        do_switch ? "TRUE" : "FALSE", 
+                        curr_switch,
+                        frame->AddrFrame.Offset);
         }
         else
         {
             assert(curr_mode == stm_16bit);
+            if (curr_mode != stm_16bit)
+                ERR("[continue] not in 16-bit stack mode!\n");
+
             do_switch = curr_switch && 
                 frame->AddrFrame.Segment == SELECTOROF(curr_switch) &&
                 frame->AddrFrame.Offset >= OFFSETOF(curr_switch);
+            TRACE("do_switch = %s {curr_switch = 0x%08x, frame->AddrFrame.Offset = 0x%08x, frame->AddrFrame.Segment = 0x%08x}\n", 
+                        do_switch ? "TRUE" : "FALSE", 
+                        curr_switch,
+                        frame->AddrFrame.Offset,
+                        frame->AddrFrame.Segment);
         }
 	   
         if (do_switch)
@@ -271,7 +309,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
             {
                 if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32)))
                 {
-                    WARN("Bad stack frame 0x%08x\n", next_switch);
+                    WARN("[continue16] Bad 32-bit stack frame 0x%08x\n", next_switch);
                     goto done_err;
                 }
 
@@ -295,7 +333,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
 
                 if (!sw_read_mem(cb, p, &frame16, sizeof(frame16)))
                 {
-                    WARN("Bad stack frame 0x%08x\n", p);
+                    WARN("[continue16] Bad 16-bit stack frame 0x%08x\n", p);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame16.frame32;
@@ -312,7 +350,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
 
                 if (!sw_read_mem(cb, p, &frame16, sizeof(frame16)))
                 {
-                    WARN("Bad stack frame 0x%08x\n", p);
+                    WARN("[continue32] Bad 16-bit stack frame 0x%08x\n", p);
                     goto done_err;
                 }
 
@@ -348,7 +386,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
                 next_switch = curr_switch;
                 if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32)))
                 {
-                    WARN("Bad stack frame 0x%08x\n", next_switch);
+                    WARN("[continue32] Bad 32-bit stack frame 0x%08x\n", next_switch);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame32.frame16;
@@ -366,20 +404,28 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
             frame->AddrPC = frame->AddrReturn;
             if (curr_mode == stm_16bit)
             {
+                DWORD addr;
+
+
                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(WORD);
+                addr = sw_xlat_addr(cb, &frame->AddrFrame);
+
                 /* "pop up" previous BP value */
-                if (!sw_read_mem(cb, sw_xlat_addr(cb, &frame->AddrFrame),
-                                 &val, sizeof(WORD)))
+                if (!sw_read_mem(cb, addr, &val, sizeof(WORD))){
+                    ERR("[continue16] could not read the BP value from 0x%08x\n", addr);
                     goto done_err;
+                }
+
                 frame->AddrFrame.Offset = val;
             }
             else
             {
                 frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(DWORD);
                 /* "pop up" previous EBP value */
-                if (!sw_read_mem(cb, frame->AddrFrame.Offset, 
-                                 &frame->AddrFrame.Offset, sizeof(DWORD)))
+                if (!sw_read_mem(cb, frame->AddrFrame.Offset, &frame->AddrFrame.Offset, sizeof(DWORD))){
+                    ERR("[continue32] could not read the EBP value from 0x%08x\n", frame->AddrFrame.Offset);
                     goto done_err;
+                }
             }
         }
     }
@@ -389,12 +435,16 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
         int     i;
 
         p = sw_xlat_addr(cb, &frame->AddrFrame);
-        if (!sw_read_mem(cb, p + sizeof(WORD), &val, sizeof(WORD)))
+        if (!sw_read_mem(cb, p + sizeof(WORD), &val, sizeof(WORD))){
+            ERR("[next16] could not read 16-bit return address\n");
             goto done_err;
+        }
         frame->AddrReturn.Offset = val;
         /* get potential cs if a far call was used */
-        if (!sw_read_mem(cb, p + 2 * sizeof(WORD), &val, sizeof(WORD)))
+        if (!sw_read_mem(cb, p + 2 * sizeof(WORD), &val, sizeof(WORD))){
+            ERR("[next16] could not read 16-bit return address segment\n");
             goto done_err;
+        }
         if (frame->AddrFrame.Offset & 1)
             frame->AddrReturn.Segment = val; /* far call assumed */
         else
@@ -414,8 +464,8 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
                      */
                     frame->AddrReturn.Segment = val;
                 }
-	    }
-	}
+            }
+        }
         frame->AddrFrame.Offset &= ~1;
         /* we "pop" parameters as 16 bit entities... of course, this won't
          * work if the parameter is in fact bigger than 16bit, but
@@ -432,7 +482,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
         if (!sw_read_mem(cb, frame->AddrFrame.Offset + sizeof(DWORD),
                          &frame->AddrReturn.Offset, sizeof(DWORD)))
         {
-            WARN("Cannot read new frame offset %08x\n", frame->AddrFrame.Offset + (int)sizeof(DWORD));
+            WARN("[next32] Cannot read new frame offset %08x\n", frame->AddrFrame.Offset + (int)sizeof(DWORD));
             goto done_err;
         }
         sw_read_mem(cb, frame->AddrFrame.Offset + 2 * sizeof(DWORD),
@@ -447,7 +497,7 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
     else
         frame->FuncTableEntry = NULL;
 
-    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08x nSwitch=%08x FuncTable=%p\n",
+    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=0x%08x nSwitch=0x%08x FuncTable=%p\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
@@ -511,7 +561,7 @@ BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
     STACKFRAME                  frame32;
     BOOL                        ret;
 
-    TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n",
+    TRACE("(MachineType = %d, hProcess = %p, hThread = %p, frame64 = %p, ctx = %p, f_read_mem = %p, FunctionTableAccessRoutine = %p, GetModuleBaseRoutine = %p, f_xlat_adr = %p)\n",
           MachineType, hProcess, hThread, frame64, ctx,
           f_read_mem, FunctionTableAccessRoutine,
           GetModuleBaseRoutine, f_xlat_adr);
@@ -522,6 +572,8 @@ BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
         return FALSE;
     }
 
+
+    TRACE("copying stack frame info to a 32-bit frame\n");
     addr_64to32(&frame64->AddrPC,     &frame32.AddrPC);
     addr_64to32(&frame64->AddrReturn, &frame32.AddrReturn);
     addr_64to32(&frame64->AddrFrame,  &frame32.AddrFrame);
@@ -535,6 +587,7 @@ BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
     frame32.Reserved[2] = (ULONG)frame64->Reserved[2];
     /* we don't handle KdHelp */
 
+    TRACE("setting up callback frame\n");
     swcb.hProcess = hProcess;
     swcb.hThread = hThread;
     swcb.is32 = FALSE;
@@ -544,7 +597,9 @@ BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
     swcb.u.s64.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess64;
     swcb.u.s64.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase64;
 
+    TRACE("performing 32-bit stack walk\n");
     ret = stack_walk(&swcb, &frame32);
+    TRACE("done stack walk.  Converting back...\n");
 
     addr_32to64(&frame32.AddrPC,     &frame64->AddrPC);
     addr_32to64(&frame32.AddrReturn, &frame64->AddrReturn);
@@ -572,6 +627,7 @@ BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread,
     frame64->KdHelp.SystemRangeStart = 0xC0000000;
     frame64->KdHelp.Reserved[0] /* KiUserExceptionDispatcher */ = 0xE0005000;
 
+    TRACE("done filling in stack frame\n");
     return ret;
 }
 
-- 
1.4.4.2