Changeset 3593

Timestamp:

Sep 30, 2007, 11:41:15 PM (18 years ago)

Author:

bird

Message:

Fixed some unwinding stuff on msc+amd64.

Location:

trunk/kStuff/kProfiler2

Files:

• Makefile.kmk (modified) (1 diff)
• prfamd64msc.asm (modified) (2 diffs)
• prfcore.cpp.h (modified) (5 diffs)
• prfcore.h.h (modified) (2 diffs)
• tstlongjmp.c (added)

trunk/kStuff/kProfiler2/Makefile.kmk

@@ -142 +142 @@
         $(PATH_kPrf2)/kPrf2.lib
 
+PROGRAMS += tstlongjmp
+tstlongjmp_TEMPLATE = kStuffEXE
+tstlongjmp_CFLAGS.win = -GH -Gh -Zi
+tstlongjmp_SOURCES = tstlongjmp.c
+tstlongjmp_LIBS = \
+        $(PATH_kPrf2)/kPrf2.lib
+
 # Generate the rules
 include $(PATH_KBUILD)/subfooter.kmk

trunk/kStuff/kProfiler2/prfamd64msc.asm

@@ -91 +91 @@
         or      r8, rax                 ; param 3 - the timestamp
         mov     [rsp + 20h], r8         ; save the tsc for later use.
-        lea     rdx, [rsp + 8*8 + 28h]  ; Param 2 - frame pointer (pointer to the return address of the function calling us)
+        lea     rdx, [rsp + 8*8 + 28h]  ; Param 2 - default frame pointer
         mov     rcx, [rdx]              ; Param 1 - The function address
+
+        ; MSC seems to put the _penter both before and after the typical sub rsp, xxh
+        ; statement as if it cannot quite make up its mind. We'll try adjust for this
+        ; to make the unwinding a bit more accurate wrt to longjmp/throw. But since
+        ; there are also an uneven amount of push/pop around the _penter/_pexit we
+        ; can never really make a perfect job of it. sigh.
+        cmp     word [rcx - 5 - 4], 08348h  ; sub rsp, imm8
+        jne     .not_byte_sub
+        cmp     byte [rcx - 5 - 2], 0ech
+        jne     .not_byte_sub
+        movzx   eax, byte [rcx - 5 - 1]     ; imm8
+        add     rdx, rax
+        jmp     .call_prf_enter
+.not_byte_sub:
+        cmp     word [rcx - 5 - 7], 08148h  ; sub rsp, imm8
+        jne     .not_dword_sub
+        cmp     byte [rcx - 5 - 5], 0ech
+        jne     .not_dword_sub
+        mov     eax, [rcx - 5 - 4]          ; imm32
+        add     rdx, rax
+;        jmp     .call_prf_enter
+.not_dword_sub:
+.call_prf_enter:
         call    KPRF_ENTER
         jmp     common_return_path
@@ -135 +158 @@
         or      r8, rax                 ; param 3 - the timestamp
         mov     [rsp + 20h], r8         ; save the tsc for later use.
-        lea     rdx, [rsp + 8*8 + 28h]  ; Param 2 - frame pointer (pointer to the return address of the function calling us)
+        lea     rdx, [rsp + 8*8 + 28h]  ; Param 2 - frame pointer.
         mov     rcx, [rdx]              ; Param 1 - The function address
+
+        ; MSC some times put the _pexit before the add rsp, xxh. To try match up with
+        ; any adjustments made in _penter, we'll try detect this.
+        cmp     word [rcx], 08348h      ; add rsp, imm8
+        jne     .not_byte_sub
+        cmp     byte [rcx + 2], 0c4h
+        jne     .not_byte_sub
+        movzx   eax, byte [rcx + 3]     ; imm8
+        add     rdx, rax
+        jmp     .call_prf_leave
+.not_byte_sub:
+        cmp     word [rcx], 08148h      ; add rsp, imm32
+        jne     .not_dword_sub
+        cmp     byte [rcx + 2], 0c4h
+        jne     .not_dword_sub
+        mov     eax, [rcx + 3]          ; imm32
+        add     rdx, rax
+;        jmp     .call_prf_leave
+.not_dword_sub:
+.call_prf_leave:
         call    KPRF_LEAVE
         jmp common_return_path

trunk/kStuff/kProfiler2/prfcore.cpp.h

@@ -141 +141 @@
 /**
  * Unwinds the stack.
+ *
+ * On MSC+AMD64 we have to be very very careful here, because the uFramePtr cannot be trusted.
  */
 static KU64* KPRF_NAME(UnwindInt)(KPRF_TYPE(P,HDR) pHdr, KPRF_TYPE(P,STACK) pStack, KPRF_TYPE(,UPTR) uPC, KPRF_TYPE(,UPTR) uFramePtr, KU64 TS)
@@ -151 +153 @@
     KI32 iFrame = pStack->cFrames - 1;
     KPRF_TYPE(P,FRAME) pFrame = &pStack->aFrames[iFrame];
+
     /* the most frequent case first. */
+#if K_OS == K_OS_WINDOWS && K_ARCH == K_ARCH_AMD64
+    if (    uFramePtr == pFrame->uFramePtr
+        ||  (   pFrame->uFramePtr < uFramePtr
+             && iFrame > 0
+             && pFrame[-1].uFramePtr > uFramePtr))
+        return KPRF_NAME(UnwindOne)(pHdr, pStack, uPC, TS);
+#else
     if (uFramePtr == pFrame->uFramePtr)
         return KPRF_NAME(UnwindOne)(pHdr, pStack, uPC, TS);
+#endif
 
     /* none?  */
@@ -161 +172 @@
     /* one or more, possibly all */
     KU64 *pCurOverheadTicks = KPRF_NAME(UnwindOne)(pHdr, pStack, uPC, TS);
-    pFrame++;
+    pFrame--;
     if (    iFrame > 0
+#if K_OS == K_OS_WINDOWS && K_ARCH == K_ARCH_AMD64
+        &&  pFrame->uFramePtr <= uFramePtr
+        &&  pFrame[-1].uFramePtr > uFramePtr)
+#else
         &&  pFrame->uFramePtr <= uFramePtr)
+#endif
     {
         KPRF_TYPE(P,THREAD) pThread = KPRF_OFF2PTR(P,THREAD, pStack->offThread, pHdr);
@@ -170 +186 @@
         pCurOverheadTicks = KPRF_NAME(UnwindOne)(pHdr, pStack, uPC, TS);
         iFrame -= 2;
-        pFrame++;
+        pFrame--;
+#if K_OS == K_OS_WINDOWS && K_ARCH == K_ARCH_AMD64
+        while (     iFrame > 0
+               &&   pFrame->uFramePtr <= uFramePtr
+               &&   pFrame[-1].uFramePtr > uFramePtr)
+#else
         while (     iFrame >= 0
                &&   pFrame->uFramePtr <= uFramePtr)
+#endif
         {
             pCurOverheadTicks = KPRF_NAME(UnwindOne)(pHdr, pStack, uPC, TS);
             iFrame--;
-            pFrame++;
+            pFrame--;
         }
     }
@@ -255 +277 @@
     KPRF_TYPE(P,FRAME) pFrame = &pStack->aFrames[iFrame];
     if (    iFrame
+#if K_OS == K_OS_WINDOWS && K_ARCH == K_ARCH_AMD64
+        &&  0) /* don't bother her yet because of _penter/_pexit frame problems. */
+#else
         &&  pThread->uStackBasePtr >= uFramePtr                                     /* ASSUMES stack direction */
         &&  pFrame[-1].uFramePtr + (KPRF_BITS - 8) / 8 < uFramePtr)                 /* ASSUMES stack direction */
+#endif
     {
         KPRF_NAME(UnwindInt)(pHdr, pStack, uPC, uFramePtr, TS);

trunk/kStuff/kProfiler2/prfcore.h.h

@@ -270 +270 @@
     /** Stack address of this frame.
      * This is used to detect throw and longjmp, and is also used to deal with overflow. (relative address) */
-    KPRF_TYPE(,UPTR)       uFramePtr;
+    KPRF_TYPE(,UPTR)        uFramePtr;
     /** Offset (relative to the profiler header) to the function record.
      * This is 0 if we're out of function space. */
@@ -293 +293 @@
     /** The stack frames.
      * The actual size of this array is specified in the header. */
-    KPRF_TYPE(,FRAME)          aFrames[1];
+    KPRF_TYPE(,FRAME)           aFrames[1];
 } KPRF_TYPE(,STACK);
 /** Pointer to a stack. */