summaryrefslogtreecommitdiffstatshomepage
path: root/src/osd/windows/osinline.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/osd/windows/osinline.h')
-rw-r--r--src/osd/windows/osinline.h552
1 files changed, 21 insertions, 531 deletions
diff --git a/src/osd/windows/osinline.h b/src/osd/windows/osinline.h
index e6131724886..6839638a7a9 100644
--- a/src/osd/windows/osinline.h
+++ b/src/osd/windows/osinline.h
@@ -2,7 +2,7 @@
//
// osinline.h
//
-// x86 inline implementations for MSVC compiler.
+// Inline implementations for non-GCC Win32 compilers
//
// Copyright (c) 1996-2007, Nicola Salmoria and the MAME Team.
// Visit http://mamedev.org for licensing and usage restrictions.
@@ -12,551 +12,41 @@
#ifndef __OSINLINE__
#define __OSINLINE__
-#ifdef PTR64
-#include <intrin.h>
-#pragma intrinsic(_BitScanReverse)
-#else
-#pragma intrinsic(_InterlockedCompareExchange)
-#pragma intrinsic(_InterlockedExchange)
-#pragma intrinsic(_InterlockedExchangeAdd)
-#endif
-
-
-/***************************************************************************
- INLINE MATH FUNCTIONS
-***************************************************************************/
-
-/*-------------------------------------------------
- mul_32x32 - perform a signed 32 bit x 32 bit
- multiply and return the full 64 bit result
--------------------------------------------------*/
-
-#ifndef PTR64
-#define mul_32x32 _mul_32x32
-INLINE INT64 _mul_32x32(INT32 a, INT32 b)
-{
- // in theory this should work, but it is untested
- __asm
- {
- mov eax,a
- imul b
- // leave results in edx:eax
- }
-}
-#endif
-
-
-/*-------------------------------------------------
- mulu_32x32 - perform an unsigned 32 bit x
- 32 bit multiply and return the full 64 bit
- result
--------------------------------------------------*/
-
-#ifndef PTR64
-#define mulu_32x32 _mulu_32x32
-INLINE UINT64 _mulu_32x32(UINT32 a, UINT32 b)
-{
- // in theory this should work, but it is untested
- __asm
- {
- mov eax,a
- mul b
- // leave results in edx:eax
- }
-}
-#endif
-
-
-/*-------------------------------------------------
- mul_32x32_hi - perform a signed 32 bit x 32 bit
- multiply and return the upper 32 bits of the
- result
--------------------------------------------------*/
-
-#ifndef PTR64
-#define mul_32x32_hi _mul_32x32_hi
-INLINE INT32 _mul_32x32_hi(INT32 a, INT32 b)
-{
- INT32 result;
-
- __asm
- {
- mov eax,a
- imul b
- mov result,edx
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- mulu_32x32_hi - perform an unsigned 32 bit x
- 32 bit multiply and return the upper 32 bits
- of the result
--------------------------------------------------*/
-
-#ifndef PTR64
-#define mulu_32x32_hi _mulu_32x32_hi
-INLINE UINT32 _mulu_32x32_hi(UINT32 a, UINT32 b)
-{
- INT32 result;
-
- __asm
- {
- mov eax,a
- mul b
- mov result,edx
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- mul_32x32_shift - perform a signed 32 bit x
- 32 bit multiply and shift the result by the
- given number of bits before truncating the
- result to 32 bits
--------------------------------------------------*/
-
-#ifndef PTR64
-#define mul_32x32_shift _mul_32x32_shift
-INLINE INT32 _mul_32x32_shift(INT32 a, INT32 b, UINT8 shift)
-{
- INT32 result;
-
- __asm
- {
- mov eax,a
- imul b
- mov cl,shift
- shrd eax,edx,cl
- mov result,eax
- }
-
- return result;
-}
+#if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
+#include "eivcx86.h"
#endif
-
-/*-------------------------------------------------
- mulu_32x32_shift - perform an unsigned 32 bit x
- 32 bit multiply and shift the result by the
- given number of bits before truncating the
- result to 32 bits
--------------------------------------------------*/
-
-#ifndef PTR64
-#define mulu_32x32_shift _mulu_32x32_shift
-INLINE UINT32 _mulu_32x32_shift(UINT32 a, UINT32 b, UINT8 shift)
-{
- INT32 result;
-
- __asm
- {
- mov eax,a
- mul b
- mov cl,shift
- shrd eax,edx,cl
- mov result,eax
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- div_64x32 - perform a signed 64 bit x 32 bit
- divide and return the 32 bit quotient
--------------------------------------------------*/
-
-#ifndef PTR64
-#define div_64x32 _div_64x32
-INLINE INT32 _div_64x32(INT64 a, INT32 b)
-{
- INT32 result;
- INT32 alow = a;
- INT32 ahigh = a >> 32;
-
- __asm
- {
- mov eax,alow
- mov edx,ahigh
- idiv b
- mov result,eax
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- divu_64x32 - perform an unsigned 64 bit x 32 bit
- divide and return the 32 bit quotient
--------------------------------------------------*/
-
-#ifndef PTR64
-#define divu_64x32 _divu_64x32
-INLINE UINT32 _divu_64x32(UINT64 a, UINT32 b)
-{
- UINT32 result;
- UINT32 alow = a;
- UINT32 ahigh = a >> 32;
-
- __asm
- {
- mov eax,alow
- mov edx,ahigh
- div b
- mov result,eax
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- div_64x32_rem - perform a signed 64 bit x 32
- bit divide and return the 32 bit quotient and
- 32 bit remainder
--------------------------------------------------*/
-
-#ifndef PTR64
-#define div_64x32_rem _div_64x32_rem
-INLINE INT32 _div_64x32_rem(INT64 a, INT32 b, INT32 *remainder)
-{
- INT32 result;
- INT32 alow = a;
- INT32 ahigh = a >> 32;
- INT32 rem;
-
- __asm
- {
- mov eax,alow
- mov edx,ahigh
- idiv b
- mov result,eax
- mov rem,edx
- }
-
- *remainder = rem;
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- divu_64x32_rem - perform an unsigned 64 bit x
- 32 bit divide and return the 32 bit quotient
- and 32 bit remainder
--------------------------------------------------*/
-
-#ifndef PTR64
-#define divu_64x32_rem _divu_64x32_rem
-INLINE UINT32 _divu_64x32_rem(UINT64 a, UINT32 b, UINT32 *remainder)
-{
- UINT32 result;
- UINT32 alow = a;
- UINT32 ahigh = a >> 32;
- UINT32 rem;
-
- __asm
- {
- mov eax,alow
- mov edx,ahigh
- div b
- mov result,eax
- mov rem,edx
- }
-
- *remainder = rem;
- return result;
-}
+#if defined(_MSC_VER)
+#include "eivc.h"
#endif
-
-/*-------------------------------------------------
- div_32x32_shift - perform a signed divide of
- two 32 bit values, shifting the first before
- division, and returning the 32 bit quotient
--------------------------------------------------*/
-
-#ifndef PTR64
-#define div_32x32_shift _div_32x32_shift
-INLINE INT32 _div_32x32_shift(INT32 a, INT32 b, UINT8 shift)
-{
- INT32 result;
-
- __asm
- {
- mov eax,a
- cdq
- mov cl,shift
- shld edx,eax,cl
- shl eax,cl
- idiv b
- mov result,eax
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- divu_32x32_shift - perform an unsigned divide of
- two 32 bit values, shifting the first before
- division, and returning the 32 bit quotient
--------------------------------------------------*/
-
-#ifndef PTR64
-#define divu_32x32_shift _divu_32x32_shift
-INLINE UINT32 _divu_32x32_shift(UINT32 a, UINT32 b, UINT8 shift)
-{
- UINT32 result;
-
- __asm
- {
- mov eax,a
- xor edx,edx
- mov cl,shift
- shld edx,eax,cl
- shl eax,cl
- div b
- mov result,eax
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- mod_64x32 - perform a signed 64 bit x 32 bit
- divide and return the 32 bit remainder
--------------------------------------------------*/
-
-#ifndef PTR64
-#define mod_64x32 _mod_64x32
-INLINE INT32 _mod_64x32(INT64 a, INT32 b)
-{
- INT32 result;
- INT32 alow = a;
- INT32 ahigh = a >> 32;
-
- __asm
- {
- mov eax,alow
- mov edx,ahigh
- idiv b
- mov result,edx
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- modu_64x32 - perform an unsigned 64 bit x 32 bit
- divide and return the 32 bit remainder
--------------------------------------------------*/
-
-#ifndef PTR64
-#define modu_64x32 _modu_64x32
-INLINE UINT32 _modu_64x32(UINT64 a, UINT32 b)
-{
- UINT32 result;
- UINT32 alow = a;
- UINT32 ahigh = a >> 32;
-
- __asm
- {
- mov eax,alow
- mov edx,ahigh
- div b
- mov result,edx
- }
-
- return result;
-}
-#endif
-
-
-/*-------------------------------------------------
- recip_approx - compute an approximate floating
- point reciprocal
--------------------------------------------------*/
+INT32 win_compare_exchange32(INT32 volatile *ptr, INT32 compare, INT32 exchange);
+INT32 win_atomic_exchange32(INT32 volatile *ptr, INT32 exchange);
+INT32 win_atomic_add32(INT32 volatile *ptr, INT32 delta);
#ifdef PTR64
-#define recip_approx _recip_approx
-INLINE float _recip_approx(float z)
-{
- __m128 mz = _mm_set_ss(z);
- __m128 mooz = _mm_rcp_ss(mz);
- float ooz;
- _mm_store_ss(&ooz, mooz);
- return ooz;
-}
+INT64 win_compare_exchange64(INT64 volatile *ptr, INT64 compare, INT64 exchange);
#endif
+#ifndef compare_exchange32
+#define compare_exchange32 win_compare_exchange32
+#endif /* compare_exchange32 */
-/***************************************************************************
- INLINE BIT MANIPULATION FUNCTIONS
-***************************************************************************/
-
-/*-------------------------------------------------
- count_leading_zeros - return the number of
- leading zero bits in a 32-bit value
--------------------------------------------------*/
-
-#define count_leading_zeros _count_leading_zeros
-INLINE UINT8 _count_leading_zeros(UINT32 value)
-{
#ifdef PTR64
- UINT32 index;
- return _BitScanReverse(&index, value) ? (index ^ 31) : 32;
-#else
- INT32 result;
-
- __asm
- {
- bsr eax,value
- jnz skip
- mov eax,63
- skip:
- xor eax,31
- mov result,eax
- }
-
- return result;
-#endif
-}
-
-
-/*-------------------------------------------------
- count_leading_ones - return the number of
- leading one bits in a 32-bit value
--------------------------------------------------*/
-
-#define count_leading_ones _count_leading_ones
-INLINE UINT8 _count_leading_ones(UINT32 value)
-{
-#ifdef PTR64
- UINT32 index;
- return _BitScanReverse(&index, ~value) ? (index ^ 31) : 32;
-#else
- INT32 result;
-
- __asm
- {
- mov eax,value
- not eax
- bsr eax,eax
- jnz skip
- mov eax,63
- skip:
- xor eax,31
- mov result,eax
- }
-
- return result;
+#ifndef compare_exchange64
+#define compare_exchange64 win_compare_exchange64
+#endif /* compare_exchange64 */
#endif
-}
-
-
-
-/***************************************************************************
- INLINE SYNCHRONIZATION FUNCTIONS
-***************************************************************************/
-
-/*-------------------------------------------------
- compare_exchange32 - compare the 'compare'
- value against the memory at 'ptr'; if equal,
- swap in the 'exchange' value. Regardless,
- return the previous value at 'ptr'.
--------------------------------------------------*/
-
-#define compare_exchange32 _compare_exchange32
-INLINE INT32 _compare_exchange32(INT32 volatile *ptr, INT32 compare, INT32 exchange)
-{
- return _InterlockedCompareExchange(ptr, exchange, compare);
-}
-
-
-/*-------------------------------------------------
- compare_exchange64 - compare the 'compare'
- value against the memory at 'ptr'; if equal,
- swap in the 'exchange' value. Regardless,
- return the previous value at 'ptr'.
--------------------------------------------------*/
-
-#ifdef PTR64
-#define compare_exchange64 _compare_exchange64
-INLINE INT64 _compare_exchange64(INT64 volatile *ptr, INT64 compare, INT64 exchange)
-{
- return _InterlockedCompareExchange64(ptr, exchange, compare);
-}
-#endif
-
-
-/*-------------------------------------------------
- atomic_exchange32 - atomically exchange the
- exchange value with the memory at 'ptr',
- returning the original value.
--------------------------------------------------*/
-
-#define atomic_exchange32 _atomic_exchange32
-INLINE INT32 _atomic_exchange32(INT32 volatile *ptr, INT32 exchange)
-{
- return _InterlockedExchange(ptr, exchange);
-}
-
-
-/*-------------------------------------------------
- atomic_add32 - atomically add the delta value
- to the memory at 'ptr', returning the final
- result.
--------------------------------------------------*/
-
-#define atomic_add32 _atomic_add32
-INLINE INT32 _atomic_add32(INT32 volatile *ptr, INT32 delta)
-{
- return _InterlockedExchangeAdd(ptr, delta) + delta;
-}
-
-
-/*-------------------------------------------------
- atomic_increment32 - atomically increment the
- 32-bit value in memory at 'ptr', returning the
- final result.
--------------------------------------------------*/
-
-#define atomic_increment32 _atomic_increment32
-INLINE INT32 _atomic_increment32(INT32 volatile *ptr)
-{
- return _InterlockedIncrement(ptr);
-}
+#ifndef atomic_exchange32
+#define atomic_exchange32 win_atomic_exchange32
+#endif /* atomic_exchange32 */
-/*-------------------------------------------------
- atomic_decrement32 - atomically decrement the
- 32-bit value in memory at 'ptr', returning the
- final result.
--------------------------------------------------*/
-#define atomic_decrement32 _atomic_decrement32
-INLINE INT32 _atomic_decrement32(INT32 volatile *ptr)
-{
- return _InterlockedDecrement(ptr);
-}
+#ifndef atomic_add32
+#define atomic_add32 win_atomic_add32
+#endif /* atomic_add32 */
#endif /* __OSINLINE__ */