Changeset 3565 for trunk/kStuff/kProfile/kProfileR3.cpp

Timestamp:

Aug 27, 2007, 6:06:17 AM (18 years ago)

Author:

bird

Message:

Use kStuff.

File:

• trunk/kStuff/kProfile/kProfileR3.cpp (modified) (34 diffs)

trunk/kStuff/kProfile/kProfileR3.cpp

@@ +1 @@
+/* $Id: $ */
+/** @file
+ * kProfiler Mark 2 - The Ring-3 Implementation.
+ */
+
+/*
+ * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
+ *
+ * This file is part of kProfiler.
+ *
+ * kProfiler is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * kProfiler is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with kProfiler; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
 
 
@@ -8 +33 @@
 # include <psapi.h>
 # include <malloc.h>
-typedef unsigned char uint8_t;
-typedef signed char int8_t;
-typedef unsigned short uint16_t;
-typedef signed short int16_t;
-typedef unsigned int uint32_t;
-typedef signed int int32_t;
-typedef unsigned _int64 uint64_t;
-typedef signed _int64 int64_t;
-typedef size_t uintptr_t;
 # if _MSC_VER >= 1400
 #  include <intrin.h>
@@ -45 +61 @@
 #endif
 
+#include <k/kDefs.h>
+#include <k/kTypes.h>
 
 /*
@@ -100 +118 @@
 /** Update the state. */
 #define KPRF_RWLOCK_SETSTATE(pRWLock, enmNewState) \
-    kPrfAtomicSet32((volatile uint32_t *)&(pRWLock)->enmState, (uint32_t)(enmNewState))
+    kPrfAtomicSet32((volatile KU32 *)&(pRWLock)->enmState, (KU32)(enmNewState))
 
 /** Read/Write lock type. */
@@ -109 +127 @@
     KPRF_TYPE(,MUTEX)       Mutex;
     /** The current number of readers. */
-    uint32_t                cReaders;
+    KU32                    cReaders;
     /** The number of readers waiting. */
-    uint32_t                cReadersWaiting;
+    KU32                    cReadersWaiting;
     /** The current number of waiting writers. */
-    uint32_t                cWritersWaiting;
+    KU32                    cWritersWaiting;
 # if defined(KPRF_OS_WINDOWS)
     /** The handle of the event object on which the waiting readers block. (manual reset). */
@@ -218 +236 @@
  * @returns The thread id.
  */
-static inline uintptr_t kPrfGetThreadId(void)
+static inline KUPTR kPrfGetThreadId(void)
 {
 /* Win32/64 */
 #if defined(KPRF_OS_WINDOWS)
-    uintptr_t ThreadId = (uintptr_t)GetCurrentThreadId();
+    KUPTR ThreadId = (KUPTR)GetCurrentThreadId();
 
 /* Posix Threads */
 #elif defined(KPRF_USE_PTHREAD)
-    uintptr_t ThreadId = (uintptr_t)pthread_self();
+    KUPTR ThreadId = (KUPTR)pthread_self();
 
 #elif defined(KPRF_OS_OS2)
@@ -248 +266 @@
  * @returns The process id.
  */
-static inline uintptr_t kPrfGetProcessId(void)
+static inline KUPTR kPrfGetProcessId(void)
 {
 /* Win32/64 */
 #if defined(KPRF_OS_WINDOWS)
-    uintptr_t ThreadId = (uintptr_t)GetProcessId(GetCurrentProcess());
+    KUPTR ThreadId = (KUPTR)GetProcessId(GetCurrentProcess());
 
 #elif defined(KPRF_OS_OS2)
@@ -261 +279 @@
 
 #else
-    uintptr_t ThreadId = (uintptr_t)getpid();
+    KUPTR ThreadId = (KUPTR)getpid();
 #endif
 
@@ -302 +320 @@
  * This must correspond to what the assembly code are doing.
  */
-static inline uint64_t kPrfNow(void)
+static inline KU64 kPrfNow(void)
 {
 #if defined(HAVE_INTRIN)
@@ -309 +327 @@
     union
     {
-        uint64_t u64;
+        KU64 u64;
         struct
         {
-            uint32_t u32Lo;
-            uint32_t u32Hi;
+            KU32 u32Lo;
+            KU32 u32Hi;
         } s;
     } u;
@@ -336 +354 @@
  * Atomically set a 32-bit value.
  */
-static inline void kPrfAtomicSet32(volatile uint32_t *pu32, const uint32_t u32)
+static inline void kPrfAtomicSet32(volatile KU32 *pu32, const KU32 u32)
 {
 #if defined(HAVE_INTRIN)
@@ -365 +383 @@
  * Atomically set a 64-bit value.
  */
-static inline void kPrfAtomicSet64(volatile uint64_t *pu64, uint64_t u64)
+static inline void kPrfAtomicSet64(volatile KU64 *pu64, KU64 u64)
 {
 #if defined(HAVE_INTRIN) && KPRF_BITS == 64
-    _InterlockedExchange64((int64_t *)pu64, (const int64_t)u64);
+    _InterlockedExchange64((KI64 *)pu64, (const KI64)u64);
 
 #elif defined(__GNUC__) && KPRF_BITS == 64
@@ -382 +400 @@
                            "=m" (*pu64)
                          : "0" (*pu64),
-                           "b" ( (uint32_t)u64 ),
-                           "c" ( (uint32_t)(u64 >> 32) ));
+                           "b" ( (KU32)u64 ),
+                           "c" ( (KU32)(u64 >> 32) ));
 
 #elif _MSC_VER
@@ -407 +425 @@
  * Atomically add a 32-bit integer to another.
  */
-static inline void kPrfAtomicAdd32(volatile uint32_t *pu32, const uint32_t u32)
+static inline void kPrfAtomicAdd32(volatile KU32 *pu32, const KU32 u32)
 {
 #if defined(HAVE_INTRIN)
@@ -431 +449 @@
 #define KPRF_ATOMIC_ADD32(a,b)          kPrfAtomicAdd32(a, b)
 #define KPRF_ATOMIC_INC32(a)            kPrfAtomicAdd32(a, 1);
-#define KPRF_ATOMIC_DEC32(a)            kPrfAtomicAdd32(a, (uint32_t)-1);
+#define KPRF_ATOMIC_DEC32(a)            kPrfAtomicAdd32(a, (KU32)-1);
 
 
@@ -438 +456 @@
  * Atomically isn't quite required, just a non-corruptive manner, assuming all updates are adds.
  */
-static inline void kPrfAtomicAdd64(volatile uint64_t *pu64, const uint64_t u64)
+static inline void kPrfAtomicAdd64(volatile KU64 *pu64, const KU64 u64)
 {
 #if defined(HAVE_INTRIN) && KPRF_BITS == 64
-    _InterlockedExchangeAdd64((volatile int64_t *)pu64, (const int64_t)u64);
+    _InterlockedExchangeAdd64((volatile KI64 *)pu64, (const KI64)u64);
 
 #elif defined(__GNUC__) && KPRF_BITS == 64
@@ -451 +469 @@
     __asm__ __volatile__("lock; addl %0, %2\n\t"
                          "lock; adcl %1, %3\n\t"
-                         : "=m" (*(volatile uint32_t *)pu64),
-                           "=m" (*((volatile uint32_t *)pu64 + 1))
-                         : "r" ((uint32_t)u64),
-                           "r" ((uint32_t)(u64 >> 32)));
+                         : "=m" (*(volatile KU32 *)pu64),
+                           "=m" (*((volatile KU32 *)pu64 + 1))
+                         : "r" ((KU32)u64),
+                           "r" ((KU32)(u64 >> 32)));
 
 #elif _MSC_VER
@@ -922 +940 @@
  *
  */
-static int kPrfGetModSeg(KPRF_TYPE(,UPTR) uAddress, char *pszPath, uint32_t cchPath, uint32_t *piSegment,
+static int kPrfGetModSeg(KPRF_TYPE(,UPTR) uAddress, char *pszPath, KU32 cchPath, KU32 *piSegment,
                          KPRF_TYPE(P,UPTR) puBasePtr, KPRF_TYPE(P,UPTR) pcbSegmentMinusOne)
 {
@@ -945 +963 @@
             __try
             {
-                const uintptr_t uImageBase = (uintptr_t)pahModules[i];
+                const KUPTR uImageBase = (KUPTR)pahModules[i];
                 union
                 {
-                    uint8_t            *pu8;
+                    KU8                *pu8;
                     PIMAGE_DOS_HEADER   pDos;
                     PIMAGE_NT_HEADERS   pNt;
                     PIMAGE_NT_HEADERS32 pNt32;
                     PIMAGE_NT_HEADERS64 pNt64;
-                    uintptr_t           u;
+                    KUPTR               u;
                 } u;
                 u.u = uImageBase;
@@ -970 +988 @@
 
                 /* Extract necessary info from the optional header (comes in 32-bit and 64-bit variations, we simplify a bit). */
-                uint32_t                cbImage;
+                KU32                    cbImage;
                 PIMAGE_SECTION_HEADER   paSHs;
                 if (u.pNt->FileHeader.SizeOfOptionalHeader == sizeof(IMAGE_OPTIONAL_HEADER32))
@@ -986 +1004 @@
 
                 /* Is our address within the image size */
-                uintptr_t uRVA = uAddress - (uintptr_t)pahModules[i];
+                KUPTR uRVA = uAddress - (KUPTR)pahModules[i];
                 if (uRVA >= cbImage)
                     continue;
@@ -994 +1012 @@
                  * (segment == section + 1)
                  */
-                const uint32_t  cSHs = u.pNt->FileHeader.NumberOfSections;
+                const KU32 cSHs = u.pNt->FileHeader.NumberOfSections;
                 if (uRVA < paSHs[0].VirtualAddress)
                 {
@@ -1004 +1022 @@
                 else
                 {
-                    uint32_t iSH = 0;
+                    KU32 iSH = 0;
                     for (;;)
                     {
@@ -1063 +1081 @@
         ULONG cb     = ~0UL;
         ULONG fFlags = ~0UL;
-        uAddress &= ~(uintptr_t)0xfff;
+        uAddress &= ~(KUPTR)0xfff;
         rc = DosQueryMem((PVOID)(uAddress, &cb, &fFlags);
         if (!rc)
         {
-            *pcbSegmentMinusOne = (offObj & ~(uintptr_t)0xfff) + KPRF_ALIGN(cb, 0x1000) - 1;
+            *pcbSegmentMinusOne = (offObj & ~(KUPTR)0xfff) + KPRF_ALIGN(cb, 0x1000) - 1;
             if ((fFlags & PAG_BASE) && cb <= 0x1000) /* don't quite remember if PAG_BASE returns one page or not */
             {
@@ -1118 +1136 @@
 static KPRF_TYPE(P,THREAD) kPrfGetThreadAutoReg(void)
 {
-    uintptr_t uStackBasePtr;
+    KUPTR uStackBasePtr;
 
 #if 0
@@ -1129 +1147 @@
     DosGetInfoBlocks(&pTib, &pPib); /* never fails except if you give it bad input, thus 'Get' not 'Query'. */
     /* I never recall which of these is the right one... */
-    uStackBasePtr = (uintptr_t)pTib->tib_pstack < (uintptr_t)pTib->tib_pstack_limit
-        ? (uintptr_t)pTib->tib_pstack
-        : (uintptr_t)pTib->tib_pstack_limit;
+    uStackBasePtr = (KUPTR)pTib->tib_pstack < (KUPTR)pTib->tib_pstack_limit
+        ? (KUPTR)pTib->tib_pstack
+        : (KUPTR)pTib->tib_pstack_limit;
 
 #else
     /* the default is top of the current stack page (assuming a page to be 4KB) */
-    uStackBasePtr = (uintptr_t)&uStackBasePtr;
-    uStackBasePtr = (uStackBasePtr + 0xfff) & ~(uintptr_t)0xfff;
+    uStackBasePtr = (KUPTR)&uStackBasePtr;
+    uStackBasePtr = (uStackBasePtr + 0xfff) & ~(KUPTR)0xfff;
 #endif
 
@@ -1152 +1170 @@
  * @param   pszDefault  The default value.
  */
-static char *kPrfGetEnvString(const char *pszVar, char *pszValue, uint32_t cchValue, const char *pszDefault)
+static char *kPrfGetEnvString(const char *pszVar, char *pszValue, KU32 cchValue, const char *pszDefault)
 {
 #if defined(KPRF_OS_WINDOWS)
@@ -1191 +1209 @@
  * @param   uDefault    The default value.
  */
-static uint32_t kPrfGetEnvValue(const char *pszVar, uint32_t uDefault)
+static KU32 kPrfGetEnvValue(const char *pszVar, KU32 uDefault)
 {
 #if defined(KPRF_OS_WINDOWS)
@@ -1223 +1241 @@
      */
     unsigned    uBase = 10;
-    uint32_t    uValue = 0;
+    KU32        uValue = 0;
     const char *psz = pszValue;
 
@@ -1279 +1297 @@
  * @param   cb      The amount of memory (in bytes) to allocate.
  */
-static void *kPrfAllocMem(uint32_t cb)
+static void *kPrfAllocMem(KU32 cb)
 {
 #if defined(KPRF_OS_WINDOWS)
@@ -1342 +1360 @@
  * @param   cbData      The amount of data to write.
  */
-static int kPrfWriteFile(const char *pszName, const void *pvData, uint32_t cbData)
+static int kPrfWriteFile(const char *pszName, const void *pvData, KU32 cbData)
 {
 #if defined(KPRF_OS_WINDOWS)
@@ -1412 +1430 @@
      * Initial suggestions.
      */
-    uint32_t    cbModSegs  = kPrfGetEnvValue("KPRF2_CBMODSEGS",  128*1024);
-    uint32_t    cFunctions = kPrfGetEnvValue("KPRF2_CFUNCTIONS", 8192);
-    uint32_t    cThreads   = kPrfGetEnvValue("KPRF2_CTHREADS",   256);
-    uint32_t    cStacks    = kPrfGetEnvValue("KPRF2_CSTACKS",    48);
-    uint32_t    cFrames    = kPrfGetEnvValue("KPRF2_CFRAMES",    448);
-
-    uint32_t cb = KPRF_NAME(CalcSize)(cFunctions, cbModSegs, cThreads, cStacks, cFrames);
+    KU32    cbModSegs  = kPrfGetEnvValue("KPRF2_CBMODSEGS",  128*1024);
+    KU32    cFunctions = kPrfGetEnvValue("KPRF2_CFUNCTIONS", 8192);
+    KU32    cThreads   = kPrfGetEnvValue("KPRF2_CTHREADS",   256);
+    KU32    cStacks    = kPrfGetEnvValue("KPRF2_CSTACKS",    48);
+    KU32    cFrames    = kPrfGetEnvValue("KPRF2_CFRAMES",    448);
+
+    KU32    cb = KPRF_NAME(CalcSize)(cFunctions, cbModSegs, cThreads, cStacks, cFrames);
 
     /*
@@ -1548 +1566 @@
 
     /* append the process id */
-    uintptr_t pid = kPrfGetProcessId();
+    KUPTR pid = kPrfGetProcessId();
     char *psz = szName;
     while (*psz)
@@ -1554 +1572 @@
 
     static char s_szDigits[0x11] = "0123456789abcdef";
-    uint32_t uShift = KPRF_BITS - 4;
+    KU32 uShift = KPRF_BITS - 4;
     while (     uShift > 0
            &&   !(pid & (0xf << uShift)))