From 9d2d4de120ec8313fe0fbd6a9b4862b60dd1771b Mon Sep 17 00:00:00 2001
From: Jason Green <jason@jave01.(none)>
Date: Thu, 17 Jan 2008 17:29:34 -0500
Subject: [PATCH] Clarify some TRACEs, and detect 64-bit addresses when walking the stack
From: Eric van Beurden (ericvb@transgaming.com)
---
 dlls/dbghelp/stack.c |   76 +++++++++++++++++++++++++++++++++++++++----------
 1 files changed, 60 insertions(+), 16 deletions(-)

diff --git a/dlls/dbghelp/stack.c b/dlls/dbghelp/stack.c
index 9b70f09..a31bc84 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;
@@ -211,7 +225,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("Bad 16-bit stack frame 0x%08x\n", next_switch);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame32.frame16;
@@ -229,7 +243,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("Bad 32-bit stack frame 0x%08x\n", p);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame16.frame32;
@@ -243,7 +257,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
          */
@@ -255,14 +272,29 @@ static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame)
         if (frame->AddrFrame.Mode == AddrModeFlat)
         {
             assert(curr_mode == stm_32bit);
+            if (curr_mode != stm_32bit)
+                ERR("t 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("t 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 +303,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("Bad 32-bit stack frame 0x%08x\n", next_switch);
                     goto done_err;
                 }
 
@@ -295,7 +327,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("Bad 16-bit stack frame 0x%08x\n", p);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame16.frame32;
@@ -312,7 +344,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("Bad 16-bit stack frame 0x%08x\n", p);
                     goto done_err;
                 }
 
@@ -348,7 +380,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("Bad 32-bit stack frame 0x%08x\n", next_switch);
                     goto done_err;
                 }
                 curr_switch = (DWORD)frame32.frame16;
@@ -366,20 +398,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("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("could not read the EBP value from 0x%08x\n", frame->AddrFrame.Offset);
                     goto done_err;
+                }
             }
         }
     }
@@ -389,12 +429,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("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("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 +458,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
@@ -511,7 +555,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);
-- 
1.4.4.2