Changeset 21535 in vbox for trunk/include

Timestamp:

Jul 13, 2009 2:44:54 PM (16 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

50008

Message:

iprt/asm.h: Added ASMIntAreEnabled and ASMNopPause. Fixed a bunch of ANSI C warnings.

File:

• trunk/include/iprt/asm.h (modified) (9 diffs)

trunk/include/iprt/asm.h

@@ -1501 +1501 @@
 
 /**
+ * Are interrupts enabled?
+ *
+ * @returns true / false.
+ */
+#if RT_INLINE_ASM_EXTERNAL
+DECLASM(RTCCUINTREG) ASMIntAreEnabled(void);
+#else
+DECLINLINE(RTCCUINTREG) ASMIntAreEnabled(void)
+{
+    RTCCUINTREG uFlags = ASMGetFlags();
+    return uFlags & 0x200 /* X86_EFL_IF */ ? true : false;
+}
+#endif
+
+
+/**
  * Halts the CPU until interrupted.
  */
@@ -1513 +1529 @@
     __asm {
         hlt
+    }
+# endif
+}
+#endif
+
+
+/**
+ * The PAUSE variant of NOP for helping hyperthreaded CPUs detecing spin locks.
+ */
+#if RT_INLINE_ASM_EXTERNAL
+DECLASM(void) ASMNopPause(void);
+#else
+DECLINLINE(void) ASMNopPause(void)
+{
+# if RT_INLINE_ASM_GNU_STYLE
+    __asm__ __volatile__(".byte 0xf3,0x90\n\t");
+# else
+    __asm {
+        _emit 0f3h
+        _emit 090h
     }
 # endif
@@ -2914 +2950 @@
 # define ASMAtomicXchgHandle(ph, hNew, phRes) \
    do { \
-       *(uint32_t *)(phRes) = ASMAtomicXchgU32((uint32_t volatile *)(ph), (const uint32_t)(hNew)); \
        AssertCompile(sizeof(*(ph))    == sizeof(uint32_t)); \
        AssertCompile(sizeof(*(phRes)) == sizeof(uint32_t)); \
+       *(uint32_t *)(phRes) = ASMAtomicXchgU32((uint32_t volatile *)(ph), (const uint32_t)(hNew)); \
    } while (0)
 #elif HC_ARCH_BITS == 64
 # define ASMAtomicXchgHandle(ph, hNew, phRes) \
    do { \
-       *(uint64_t *)(phRes) = ASMAtomicXchgU64((uint64_t volatile *)(ph), (const uint64_t)(hNew)); \
        AssertCompile(sizeof(*(ph))    == sizeof(uint64_t)); \
        AssertCompile(sizeof(*(phRes)) == sizeof(uint64_t)); \
+       *(uint64_t *)(phRes) = ASMAtomicXchgU64((uint64_t volatile *)(ph), (const uint64_t)(hNew)); \
    } while (0)
 #else
@@ -3191 +3227 @@
 # define ASMAtomicCmpXchgHandle(ph, hNew, hOld, fRc) \
    do { \
+       AssertCompile(sizeof(*(ph)) == sizeof(uint32_t)); \
        (fRc) = ASMAtomicCmpXchgU32((uint32_t volatile *)(ph), (const uint32_t)(hNew), (const uint32_t)(hOld)); \
-       AssertCompile(sizeof(*(ph)) == sizeof(uint32_t)); \
    } while (0)
 #elif HC_ARCH_BITS == 64
 # define ASMAtomicCmpXchgHandle(ph, hNew, hOld, fRc) \
    do { \
+       AssertCompile(sizeof(*(ph)) == sizeof(uint64_t)); \
        (fRc) = ASMAtomicCmpXchgU64((uint64_t volatile *)(ph), (const uint64_t)(hNew), (const uint64_t)(hOld)); \
-       AssertCompile(sizeof(*(ph)) == sizeof(uint64_t)); \
    } while (0)
 #else
@@ -3439 +3475 @@
 # define ASMAtomicCmpXchgExHandle(ph, hNew, hOld, fRc, phOldVal) \
     do { \
-        (fRc) = ASMAtomicCmpXchgExU32((volatile uint32_t *)(pu), (uint32_t)(uNew), (uint32_t)(uOld), (uint32_t *)(puOldVal)); \
         AssertCompile(sizeof(*ph)       == sizeof(uint32_t)); \
         AssertCompile(sizeof(*phOldVal) == sizeof(uint32_t)); \
+        (fRc) = ASMAtomicCmpXchgExU32((volatile uint32_t *)(pu), (uint32_t)(uNew), (uint32_t)(uOld), (uint32_t *)(puOldVal)); \
     } while (0)
 #elif HC_ARCH_BITS == 64
 # define ASMAtomicCmpXchgExHandle(ph, hNew, hOld, fRc, phOldVal) \
     do { \
-        (fRc) = ASMAtomicCmpXchgExU64((volatile uint64_t *)(pu), (uint64_t)(uNew), (uint64_t)(uOld), (uint64_t *)(puOldVal)); \
         AssertCompile(sizeof(*(ph))       == sizeof(uint64_t)); \
         AssertCompile(sizeof(*(phOldVal)) == sizeof(uint64_t)); \
+        (fRc) = ASMAtomicCmpXchgExU64((volatile uint64_t *)(pu), (uint64_t)(uNew), (uint64_t)(uOld), (uint64_t *)(puOldVal)); \
     } while (0)
 #else
@@ -4348 +4384 @@
 # define ASMAtomicReadHandle(ph, phRes) \
     do { \
-        *(uint32_t *)(phRes) = ASMAtomicReadU32((uint32_t volatile *)(ph)); \
         AssertCompile(sizeof(*(ph))    == sizeof(uint32_t)); \
         AssertCompile(sizeof(*(phRes)) == sizeof(uint32_t)); \
+        *(uint32_t *)(phRes) = ASMAtomicReadU32((uint32_t volatile *)(ph)); \
     } while (0)
 #elif HC_ARCH_BITS == 64
 # define ASMAtomicReadHandle(ph, phRes) \
     do { \
-        *(uint64_t *)(phRes) = ASMAtomicReadU64((uint64_t volatile *)(ph)); \
         AssertCompile(sizeof(*(ph))    == sizeof(uint64_t)); \
         AssertCompile(sizeof(*(phRes)) == sizeof(uint64_t)); \
+        *(uint64_t *)(phRes) = ASMAtomicReadU64((uint64_t volatile *)(ph)); \
     } while (0)
 #else
@@ -4375 +4411 @@
 # define ASMAtomicUoReadHandle(ph, phRes) \
     do { \
-        *(uint32_t *)(phRes) = ASMAtomicUoReadU32((uint32_t volatile *)(ph)); \
         AssertCompile(sizeof(*(ph))    == sizeof(uint32_t)); \
         AssertCompile(sizeof(*(phRes)) == sizeof(uint32_t)); \
+        *(uint32_t *)(phRes) = ASMAtomicUoReadU32((uint32_t volatile *)(ph)); \
     } while (0)
 #elif HC_ARCH_BITS == 64
 # define ASMAtomicUoReadHandle(ph, phRes) \
     do { \
-        *(uint64_t *)(phRes) = ASMAtomicUoReadU64((uint64_t volatile *)(ph)); \
         AssertCompile(sizeof(*(ph))    == sizeof(uint64_t)); \
         AssertCompile(sizeof(*(phRes)) == sizeof(uint64_t)); \
+        *(uint64_t *)(phRes) = ASMAtomicUoReadU64((uint64_t volatile *)(ph)); \
     } while (0)
 #else
@@ -4708 +4744 @@
 # define ASMAtomicWriteHandle(ph, hNew) \
     do { \
+        AssertCompile(sizeof(*(ph)) == sizeof(uint32_t)); \
         ASMAtomicWriteU32((uint32_t volatile *)(ph), (const uint32_t)(hNew)); \
-        AssertCompile(sizeof(*(ph)) == sizeof(uint32_t)); \
     } while (0)
 #elif HC_ARCH_BITS == 64
 # define ASMAtomicWriteHandle(ph, hNew) \
     do { \
+        AssertCompile(sizeof(*(ph)) == sizeof(uint64_t)); \
         ASMAtomicWriteU64((uint64_t volatile *)(ph), (const uint64_t)(hNew)); \
-        AssertCompile(sizeof(*(ph)) == sizeof(uint64_t)); \
     } while (0)
 #else
@@ -4733 +4769 @@
 # define ASMAtomicUoWriteHandle(ph, hNew) \
     do { \
+        AssertCompile(sizeof(*(ph)) == sizeof(uint32_t)); \
         ASMAtomicUoWriteU32((uint32_t volatile *)(ph), (const uint32_t)hNew); \
-        AssertCompile(sizeof(*(ph)) == sizeof(uint32_t)); \
     } while (0)
 #elif HC_ARCH_BITS == 64
 # define ASMAtomicUoWriteHandle(ph, hNew) \
     do { \
+        AssertCompile(sizeof(*(ph)) == sizeof(uint64_t)); \
         ASMAtomicUoWriteU64((uint64_t volatile *)(ph), (const uint64_t)hNew); \
-        AssertCompile(sizeof(*(ph)) == sizeof(uint64_t)); \
     } while (0)
 #else