Sam's asm and ammx optims

3rdParty/PKWare/explode.cpp

@@ -28,6 +28,11 @@ static char CopyrightPkware[] = "PKWARE Data Compression Library for Win32\r\n"
                                 "PKWARE Data Compression Library Reg. U.S. Pat. and Tm. Off.\r\n"
                                 "Version 1.11\r\n";
 
+#ifdef __AMIGA__
+// pass values in d0/d1 regs for speedup
+#define static static __attribute__ ((regparam(2)))
+#endif
+
 //-----------------------------------------------------------------------------
 // Tables
 
@@ -227,9 +232,43 @@ static void PKWAREAPI GenAscTabs(TDcmpStruct * pWork)
 // Returns: PKDCL_OK:         Operation was successful
 //          PKDCL_STREAM_END: There are no more bits in the input buffer
 
-static int PKWAREAPI WasteBits(TDcmpStruct * pWork, unsigned int nBits)
+static int PKWAREAPI WasteBits(TDcmpStruct * const pWork, unsigned int const nBits)
 {
+#ifdef __mc68000__
+	unsigned int m; int t = pWork->extra_bits;
+
     // If number of bits required is less than number of (bits in the buffer) ?
+    if((t -= nBits)<0) {
+		const TDcmpStruct *zero = 0; 
+		m = 1; // should be 0 but causes a gcc bug
+	    pWork->extra_bits = (t+=8); t += nBits;
+
+		// Load input buffer if necessary
+		if(pWork->in_pos == pWork->in_bytes)
+		{
+			pWork->in_pos = sizeof(pWork->in_buff);
+			if((pWork->in_bytes = pWork->read_buf(pWork->in_buff, &pWork->in_pos, pWork->param)) == 0)
+				return PKDCL_STREAM_END;
+			pWork->in_pos = 0;
+		} 
+		// Update bit buffer
+		__asm__ __volatile__ (
+		"	move.b	(%5,%4,%1.l),%0	\n"
+		"   addq.l	#1,%1			\n"
+		"	lsl.l	%2,%0			\n"
+		"	or.l	%3,%0			\n"
+		: "+d" (m), "+r" (pWork->in_pos)
+		: "d" (t), "m" (pWork->bit_buff), 
+		  "a" (pWork), "m" (zero->in_buff) );
+	} else {
+		pWork->extra_bits = t;
+		m = pWork->bit_buff;
+	}
+end:
+	pWork->bit_buff = m >> nBits;
+    return PKDCL_OK;
+#else
+	// If number of bits required is less than number of (bits in the buffer) ?
     if(nBits <= pWork->extra_bits)
     {
         pWork->extra_bits -= nBits;
@@ -252,6 +291,7 @@ static int PKWAREAPI WasteBits(TDcmpStruct * pWork, unsigned int nBits)
     pWork->bit_buff >>= (nBits - pWork->extra_bits);
     pWork->extra_bits = (pWork->extra_bits - nBits) + 8;
     return PKDCL_OK;
+#endif
 }
 
 //-----------------------------------------------------------------------------

3rdParty/Storm/Source/storm.h

@@ -66,6 +66,7 @@ struct CCritSect {
 	{
 		DeleteCriticalSection(&m_critsect);
 	}
+
 	void Enter()
 	{
 		EnterCriticalSection(&m_critsect);

3rdParty/StormLib/src/SBaseCommon.cpp

@@ -313,6 +313,14 @@ DWORD HashStringLower(const char * szFileName, DWORD dwHashType)
 // If the value is already a power of two, returns the same value
 DWORD GetNearestPowerOfTwo(DWORD dwFileCount)
 {
+#ifdef __mc68000__
+	DWORD ret = 1;
+	__asm__ __volatile__(
+	"	bfffo	%1{0:31},%1	\n"
+	"	bfins	%0,%0{0:%1}	\n"
+	: "+d" (ret), "+d" (dwFileCount) : );
+	return ret;
+#else
     dwFileCount --;
 
     dwFileCount |= dwFileCount >> 1;
@@ -322,6 +330,7 @@ DWORD GetNearestPowerOfTwo(DWORD dwFileCount)
     dwFileCount |= dwFileCount >> 16;
 
     return dwFileCount + 1;
+#endif
 }
 /*
 DWORD GetNearestPowerOfTwo(DWORD dwFileCount)
@@ -416,6 +425,56 @@ void EncryptMpqBlock(void * pvDataBlock, DWORD dwLength, DWORD dwKey1)
 
 void DecryptMpqBlock(void * pvDataBlock, DWORD dwLength, DWORD dwKey1)
 {
+#ifdef __mc68000__
+
+#define _DataBlock  	"a0"
+#define	_StormBuffer	"a1"
+#define _dwLength		"d0"
+#define _dwKey1			"d1"
+#define _dwKey2			"d2"
+#define _dwValue32		"d3"
+#define	_dwTmp			"d4"
+
+	register DWORD   dwLength_		asm(_dwLength);
+
+    if(dwLength_ = dwLength>>2) {
+		register LPDWORD DataBlock 		asm(_DataBlock) = (LPDWORD)pvDataBlock;
+		register LPDWORD StormBuffer_	asm(_StormBuffer) = &StormBuffer[MPQ_HASH_KEY2_MIX];
+		register DWORD   dwKey1_  		asm(_dwKey1) = dwKey1;
+		register DWORD   dwKey2   		asm(_dwKey2) = 0xEEEEEEEE;
+		register DWORD   dwValue32		asm(_dwValue32);
+		register DWORD   dwTmp			asm(_dwTmp);
+		__asm__ __volatile__ (
+		"\n"
+		".loop%=:\n"
+		"	move.l	("_DataBlock"),"_dwTmp"								\n"
+		"	moveq	#0,"_dwValue32"										\n"
+		"	move.b	"_dwKey1","_dwValue32"								\n"
+		"	add.l	("_StormBuffer","_dwValue32".l*4),"_dwKey2"			\n"
+		"	move.l	"_dwKey1","_dwValue32"								\n"
+		"	add.l	"_dwKey2","_dwValue32"								\n"
+		"	eor.l	"_dwTmp","_dwValue32"								\n"
+		"	move.l	"_dwValue32",("_DataBlock")+						\n"
+		"	add.l	"_dwKey2","_dwValue32"								\n"
+		"	lsl.l	#5,"_dwKey2"										\n"
+		"	addq.l	#3,"_dwValue32"										\n"
+		"	add.l	"_dwValue32","_dwKey2"								\n"
+		"	moveq	#0x15,"_dwValue32"									\n"
+		"	rol.l	"_dwValue32","_dwKey1"								\n"
+		"	move.l	"_dwKey1","_dwValue32"								\n"
+		"	not.l	"_dwKey1"											\n"
+		"	and.l	#-1<<0x15,"_dwKey1"									\n"
+		"	and.l	#~(-1<<0x15),"_dwValue32"							\n"
+		"	add.l	#0x11111111,"_dwKey1"								\n"
+		"	or.l	"_dwValue32","_dwKey1"								\n"
+		"	subq.l	#1,"_dwLength"										\n"
+		"	bne.b	.loop%=												\n"
+		: "+r" (dwKey1_), "+r" (dwKey2), "=r" (dwValue32), "+r" (dwLength_), "+r" (DataBlock), "=r" (dwTmp)
+		: "r" (StormBuffer_)
+		: "cc", "memory"
+		);
+	}
+#else
     LPDWORD DataBlock = (LPDWORD)pvDataBlock;
     DWORD dwValue32;
     DWORD dwKey2 = 0xEEEEEEEE;
@@ -435,6 +494,7 @@ void DecryptMpqBlock(void * pvDataBlock, DWORD dwLength, DWORD dwKey1)
         dwKey1 = ((~dwKey1 << 0x15) + 0x11111111) | (dwKey1 >> 0x0B);
         dwKey2 = dwValue32 + dwKey2 + (dwKey2 << 5) + 3;
     }
+#endif
 }
 
 /**
@@ -1813,42 +1873,69 @@ uint64_t SwapUInt64( uint64_t val )
 }
 #endif
 
+#ifdef __AMIGA__
+extern "C" {
+	extern char ac68080_ammx;
+	extern void ConvertUInt16BufferAMMX(void * ptr, size_t length);
+	extern void ConvertUInt32BufferAMMX(void * ptr, size_t length);
+	extern void ConvertUInt64BufferAMMX(void * ptr, size_t length);
+};
+#endif
+
 // Swaps array of unsigned 16-bit integers
 void ConvertUInt16Buffer(void * ptr, size_t length)
 {
-    uint16_t * buffer = (uint16_t *)ptr;
-    uint32_t nElements = (uint32_t)(length / sizeof(uint16_t));
-
-    while(nElements-- > 0)
+#ifdef __AMIGA__
+	if(ac68080_ammx) ConvertUInt16BufferAMMX(ptr, length);
+	else
+#endif
 	{
-		*buffer = SwapUInt16(*buffer);
-		buffer++;
+		uint16_t * buffer = (uint16_t *)ptr;
+		uint32_t nElements = (uint32_t)(length / sizeof(uint16_t));
+
+		while(nElements-- > 0)
+		{
+			*buffer = SwapUInt16(*buffer);
+			buffer++;
+		}
 	}
 }
 
 // Swaps array of unsigned 32-bit integers
 void ConvertUInt32Buffer(void * ptr, size_t length)
 {
-    uint32_t * buffer = (uint32_t *)ptr;
-    uint32_t nElements = (uint32_t)(length / sizeof(uint32_t));
-
-	while(nElements-- > 0)
+#ifdef __AMIGA__
+	if(ac68080_ammx) ConvertUInt32BufferAMMX(ptr, length);
+	else
+#endif
 	{
-		*buffer = SwapUInt32(*buffer);
-		buffer++;
+		uint32_t * buffer = (uint32_t *)ptr;
+		uint32_t nElements = (uint32_t)(length / sizeof(uint32_t));
+
+		while(nElements-- > 0)
+		{
+			*buffer = SwapUInt32(*buffer);
+			buffer++;
+		}
 	}
 }
 
 // Swaps array of unsigned 64-bit integers
 void ConvertUInt64Buffer(void * ptr, size_t length)
 {
-    uint64_t * buffer = (uint64_t *)ptr;
-    uint32_t nElements = (uint32_t)(length / sizeof(uint64_t));
-
-	while(nElements-- > 0)
+#ifdef __AMIGA__
+	if(ac68080_ammx) ConvertUInt64BufferAMMX(ptr, length);
+	else
+#endif
 	{
-		*buffer = SwapUInt64(*buffer);
-		buffer++;
+		uint64_t * buffer = (uint64_t *)ptr;
+		uint32_t nElements = (uint32_t)(length / sizeof(uint64_t));
+
+		while(nElements-- > 0)
+		{
+			*buffer = SwapUInt64(*buffer);
+			buffer++;
+		}
 	}
 }
 

3rdParty/StormLib/src/StormCommon.h

@@ -114,6 +114,17 @@ typedef struct _MPQ_SIGNATURE_INFO
 //#define STORM_FREE(ptr)                  HeapFree(GetProcessHeap(), 0, ptr)
 //
 //#else
+
+#ifdef __AMIGA__
+#define	malloc	dlmalloc
+#define	realloc	dlrealloc
+#define	free	dlfree
+extern "C" {
+void *malloc(size_t len);
+void *realloc(void *ptr, size_t len);
+void  free(void *ptr);
+}
+#endif
 
 #define STORM_ALLOC(type, nitems)        (type *)malloc((nitems) * sizeof(type))
 #define STORM_REALLOC(type, ptr, nitems) (type *)realloc(ptr, ((nitems) * sizeof(type)))