Match all of NitroSDK/math

lib/NitroSDK/asm/math/crc.s

@@ -1,243 +0,0 @@
-	.include "macros/function.inc"
-	.include "include/crc.inc"
-
-	
-
-	.text
-
-
-	arm_func_start MATHi_CRC8InitTable
-MATHi_CRC8InitTable: ; 0x020D30A8
-	stmfd sp!, {r3, lr}
-	mov ip, #0
-	mov r2, ip
-_020D30B4:
-	mov r3, ip
-	mov lr, r2
-_020D30BC:
-	tst r3, #0x80
-	eorne r3, r1, r3, lsl #1
-	add lr, lr, #1
-	moveq r3, r3, lsl #1
-	cmp lr, #8
-	blo _020D30BC
-	strb r3, [r0, ip]
-	add ip, ip, #1
-	cmp ip, #0x100
-	blo _020D30B4
-	ldmia sp!, {r3, pc}
-	arm_func_end MATHi_CRC8InitTable
-
-	arm_func_start MATHi_CRC8Update
-MATHi_CRC8Update: ; 0x020D30E8
-	stmfd sp!, {r4, lr}
-	cmp r3, #0
-	ldrb lr, [r1]
-	mov r4, #0
-	bls _020D3118
-_020D30FC:
-	ldrb ip, [r2], #1
-	add r4, r4, #1
-	cmp r4, r3
-	eor ip, lr, ip
-	and ip, ip, #0xff
-	ldrb lr, [r0, ip]
-	blo _020D30FC
-_020D3118:
-	strb lr, [r1]
-	ldmia sp!, {r4, pc}
-	arm_func_end MATHi_CRC8Update
-
-	arm_func_start MATHi_CRC16InitTable
-MATHi_CRC16InitTable: ; 0x020D3120
-	stmfd sp!, {r4, lr}
-	mov lr, #0
-	mov r4, lr
-	mov r3, lr
-_020D3130:
-	mov ip, r4
-	mov r2, r3
-_020D3138:
-	tst ip, #0x8000
-	eorne ip, r1, ip, lsl #1
-	add r2, r2, #1
-	moveq ip, ip, lsl #1
-	cmp r2, #8
-	blo _020D3138
-	mov r2, lr, lsl #1
-	add lr, lr, #1
-	strh ip, [r0, r2]
-	cmp lr, #0x100
-	add r4, r4, #0x100
-	blo _020D3130
-	ldmia sp!, {r4, pc}
-	arm_func_end MATHi_CRC16InitTable
-
-	arm_func_start MATHi_CRC16InitTableRev
-MATHi_CRC16InitTableRev: ; 0x020D316C
-	stmfd sp!, {r3, lr}
-	mov lr, #0
-	mov r3, lr
-_020D3178:
-	mov ip, lr
-	mov r2, r3
-_020D3180:
-	tst ip, #1
-	eorne ip, r1, ip, lsr #1
-	add r2, r2, #1
-	moveq ip, ip, lsr #1
-	cmp r2, #8
-	blo _020D3180
-	mov r2, lr, lsl #1
-	add lr, lr, #1
-	strh ip, [r0, r2]
-	cmp lr, #0x100
-	blo _020D3178
-	ldmia sp!, {r3, pc}
-	arm_func_end MATHi_CRC16InitTableRev
-
-	arm_func_start MATHi_CRC16Update
-MATHi_CRC16Update: ; 0x020D31B0
-	stmfd sp!, {r4, lr}
-	cmp r3, #0
-	ldrh lr, [r1]
-	mov r4, #0
-	bls _020D31E8
-_020D31C4:
-	ldrb ip, [r2], #1
-	add r4, r4, #1
-	cmp r4, r3
-	eor ip, ip, lr, lsr #8
-	mov ip, ip, lsl #0x18
-	mov ip, ip, lsr #0x17
-	ldrh ip, [r0, ip]
-	eor lr, ip, lr, lsl #8
-	blo _020D31C4
-_020D31E8:
-	strh lr, [r1]
-	ldmia sp!, {r4, pc}
-	arm_func_end MATHi_CRC16Update
-
-	arm_func_start MATHi_CRC16UpdateRev
-MATHi_CRC16UpdateRev: ; 0x020D31F0
-	stmfd sp!, {r4, lr}
-	cmp r3, #0
-	ldrh lr, [r1]
-	mov r4, #0
-	bls _020D3228
-_020D3204:
-	ldrb ip, [r2], #1
-	add r4, r4, #1
-	cmp r4, r3
-	eor ip, lr, ip
-	mov ip, ip, lsl #0x18
-	mov ip, ip, lsr #0x17
-	ldrh ip, [r0, ip]
-	eor lr, ip, lr, lsr #8
-	blo _020D3204
-_020D3228:
-	strh lr, [r1]
-	ldmia sp!, {r4, pc}
-	arm_func_end MATHi_CRC16UpdateRev
-
-	arm_func_start MATHi_CRC32InitTableRev
-MATHi_CRC32InitTableRev: ; 0x020D3230
-	stmfd sp!, {r3, lr}
-	mov ip, #0
-	mov r2, ip
-_020D323C:
-	mov r3, ip
-	mov lr, r2
-_020D3244:
-	tst r3, #1
-	eorne r3, r1, r3, lsr #1
-	add lr, lr, #1
-	moveq r3, r3, lsr #1
-	cmp lr, #8
-	blo _020D3244
-	str r3, [r0, ip, lsl #2]
-	add ip, ip, #1
-	cmp ip, #0x100
-	blo _020D323C
-	ldmia sp!, {r3, pc}
-	arm_func_end MATHi_CRC32InitTableRev
-
-	arm_func_start MATHi_CRC32UpdateRev
-MATHi_CRC32UpdateRev: ; 0x020D3270
-	stmfd sp!, {r4, lr}
-	cmp r3, #0
-	ldr lr, [r1]
-	mov r4, #0
-	bls _020D32A4
-_020D3284:
-	ldrb ip, [r2], #1
-	add r4, r4, #1
-	cmp r4, r3
-	eor ip, lr, ip
-	and ip, ip, #0xff
-	ldr ip, [r0, ip, lsl #2]
-	eor lr, ip, lr, lsr #8
-	blo _020D3284
-_020D32A4:
-	str lr, [r1]
-	ldmia sp!, {r4, pc}
-	arm_func_end MATHi_CRC32UpdateRev
-
-	arm_func_start MATH_CalcCRC8
-MATH_CalcCRC8: ; 0x020D32AC
-	stmfd sp!, {r3, lr}
-	mov lr, r1
-	mov ip, #0
-	mov r3, r2
-	add r1, sp, #0
-	mov r2, lr
-	strb ip, [sp]
-	bl MATHi_CRC8Update
-	ldrb r0, [sp]
-	ldmia sp!, {r3, pc}
-	arm_func_end MATH_CalcCRC8
-
-	arm_func_start MATH_CalcCRC16
-MATH_CalcCRC16: ; 0x020D32D4
-	stmfd sp!, {r3, lr}
-	mov lr, r1
-	mov ip, #0
-	mov r3, r2
-	add r1, sp, #0
-	mov r2, lr
-	strh ip, [sp]
-	bl MATHi_CRC16UpdateRev
-	ldrh r0, [sp]
-	ldmia sp!, {r3, pc}
-	arm_func_end MATH_CalcCRC16
-
-	arm_func_start MATH_CalcCRC16CCITT
-MATH_CalcCRC16CCITT: ; 0x020D32FC
-	stmfd sp!, {r3, lr}
-	ldr ip, _020D3324 ; =0x0000FFFF
-	mov lr, r1
-	mov r3, r2
-	add r1, sp, #0
-	mov r2, lr
-	strh ip, [sp]
-	bl MATHi_CRC16Update
-	ldrh r0, [sp]
-	ldmia sp!, {r3, pc}
-	; .align 2, 0
-_020D3324: .word 0x0000FFFF
-	arm_func_end MATH_CalcCRC16CCITT
-
-	arm_func_start MATH_CalcCRC32
-MATH_CalcCRC32: ; 0x020D3328
-	stmfd sp!, {r3, lr}
-	mov lr, r1
-	mvn ip, #0
-	mov r3, r2
-	add r1, sp, #0
-	mov r2, lr
-	str ip, [sp]
-	bl MATHi_CRC32UpdateRev
-	ldr r0, [sp]
-	mvn r0, r0
-	ldmia sp!, {r3, pc}
-	arm_func_end MATH_CalcCRC32

lib/NitroSDK/asm/math/dgt.s

@@ -1,47 +0,0 @@
-	.include "macros/function.inc"
-	.include "include/dgt.inc"
-
-	
-
-	.text
-
-
-	arm_func_start MATH_CalcMD5
-MATH_CalcMD5: ; 0x020D3028
-	stmfd sp!, {r4, r5, r6, lr}
-	sub sp, sp, #0x58
-	mov r6, r0
-	add r0, sp, #0
-	mov r5, r1
-	mov r4, r2
-	bl DGT_Hash1Reset
-	add r0, sp, #0
-	mov r1, r5
-	mov r2, r4
-	bl DGT_Hash1SetSource
-	add r1, sp, #0
-	mov r0, r6
-	bl DGT_Hash1GetDigest_R
-	add sp, sp, #0x58
-	ldmia sp!, {r4, r5, r6, pc}
-	arm_func_end MATH_CalcMD5
-
-	arm_func_start MATH_CalcSHA1
-MATH_CalcSHA1: ; 0x020D3068
-	stmfd sp!, {r4, r5, r6, lr}
-	sub sp, sp, #0x68
-	mov r6, r0
-	add r0, sp, #0
-	mov r5, r1
-	mov r4, r2
-	bl DGT_Hash2Reset
-	add r0, sp, #0
-	mov r1, r5
-	mov r2, r4
-	bl DGT_Hash2SetSource
-	add r0, sp, #0
-	mov r1, r6
-	bl DGT_Hash2GetDigest
-	add sp, sp, #0x68
-	ldmia sp!, {r4, r5, r6, pc}
-	arm_func_end MATH_CalcSHA1

lib/NitroSDK/asm/math/include/crc.inc

@@ -1,4 +0,0 @@
-.public MATHi_CRC8Update
-.public MATHi_CRC16Update
-.public MATHi_CRC16UpdateRev
-.public MATHi_CRC32UpdateRev

lib/NitroSDK/asm/math/include/dgt.inc

@@ -1,6 +0,0 @@
-.public DGT_Hash1Reset
-.public DGT_Hash1SetSource
-.public DGT_Hash1GetDigest_R
-.public DGT_Hash2Reset
-.public DGT_Hash2SetSource
-.public DGT_Hash2GetDigest

lib/NitroSDK/asm/math/math.s

@@ -1,28 +0,0 @@
-	.include "macros/function.inc"
-
-	
-
-	.text
-
-
-	arm_func_start MATH_CountPopulation
-MATH_CountPopulation: ; 0x020D2FE4
-	ldr r1, _020D301C ; =0x55555555
-	ldr r2, _020D3020 ; =0x33333333
-	and r1, r1, r0, lsr #1
-	sub r0, r0, r1
-	and r1, r0, r2
-	and r0, r2, r0, lsr #2
-	add r1, r1, r0
-	ldr r0, _020D3024 ; =0x0F0F0F0F
-	add r1, r1, r1, lsr #4
-	and r0, r1, r0
-	add r0, r0, r0, lsr #8
-	add r0, r0, r0, lsr #16
-	and r0, r0, #0xff
-	bx lr
-	; .align 2, 0
-_020D301C: .word 0x55555555
-_020D3020: .word 0x33333333
-_020D3024: .word 0x0F0F0F0F
-	arm_func_end MATH_CountPopulation

lib/NitroSDK/src/math/crc.c

@@ -0,0 +1,214 @@
+#include <nitro/math/crc.h>
+
+void MATHi_CRC8InitTable (MATHCRC8Table * table, u8 poly) {
+    u32 r;
+    u32 i, j;
+    u8 * t = table->table;
+
+    for (i = 0; i < 256; i++) {
+        r = i;
+        for (j = 0; j < 8; j++) {
+            if (r & 0x80) {
+                r = (r << 1) ^ poly;
+            } else {
+                r <<= 1;
+            }
+        }
+        t[i] = (u8)r;
+    }
+}
+
+void MATHi_CRC8InitTableRev (MATHCRC8Table * table, u8 poly) {
+    u32 r;
+    u32 i, j;
+    u8 * t = table->table;
+
+    for (i = 0; i < 256; i++) {
+        r = i;
+        for (j = 0; j < 8; j++) {
+            if (r & 1) {
+                r = (r >> 1) ^ poly;
+            } else {
+                r >>= 1;
+            }
+        }
+        t[i] = (u8)r;
+    }
+}
+
+void MATHi_CRC8Update (const MATHCRC8Table * table, MATHCRC8Context * context, const void * input, u32 length) {
+    u32 r;
+    u32 i;
+    const u8 * t = table->table;
+    u8 * data = (u8 *)input;
+
+    r = (u32) * context;
+    for (i = 0; i < length; i++) {
+        r = t[(r ^ *data) & 0xff];
+        data++;
+    }
+    *context = (MATHCRC8Context)r;
+}
+
+void MATHi_CRC16InitTable (MATHCRC16Table * table, u16 poly) {
+    u32 r;
+    u32 i, j;
+    u16 * t = table->table;
+
+    for (i = 0; i < 256; i++) {
+        r = i << 8;
+        for (j = 0; j < 8; j++) {
+            if (r & 0x8000) {
+                r = (r << 1) ^ poly;
+            } else {
+                r <<= 1;
+            }
+        }
+        t[i] = (u16)r;
+    }
+}
+
+void MATHi_CRC16InitTableRev (MATHCRC16Table * table, u16 poly) {
+    u32 r;
+    u32 i, j;
+    u16 * t = table->table;
+
+    for (i = 0; i < 256; i++) {
+        r = i;
+        for (j = 0; j < 8; j++) {
+            if (r & 1) {
+                r = (r >> 1) ^ poly;
+            } else {
+                r >>= 1;
+            }
+        }
+        t[i] = (u16)r;
+    }
+}
+
+void MATHi_CRC16Update (const MATHCRC16Table * table, MATHCRC16Context * context, const void * input, u32 length) {
+    u32 r;
+    u32 i;
+    const u16 * t = table->table;
+    u8 * data = (u8 *)input;
+
+    r = (u32) * context;
+    for (i = 0; i < length; i++) {
+        r = (r << 8) ^ t[((r >> 8) ^ *data) & 0xff];
+        data++;
+    }
+    *context = (MATHCRC16Context)r;
+}
+
+void MATHi_CRC16UpdateRev (const MATHCRC16Table * table, MATHCRC16Context * context, const void * input, u32 length) {
+    u32 r;
+    u32 i;
+    const u16 * t = table->table;
+    u8 * data = (u8 *)input;
+
+    r = (u32) * context;
+    for (i = 0; i < length; i++) {
+        r = (r >> 8) ^ t[(r ^ *data) & 0xff];
+        data++;
+    }
+    *context = (MATHCRC16Context)r;
+}
+
+void MATHi_CRC32InitTable (MATHCRC32Table * table, u32 poly) {
+    u32 r;
+    u32 i, j;
+    u32 * t = table->table;
+
+    for (i = 0; i < 256; i++) {
+        r = i << 24;
+        for (j = 0; j < 8; j++) {
+            if (r & 0x80000000U) {
+                r = (r << 1) ^ poly;
+            } else {
+                r <<= 1;
+            }
+        }
+        t[i] = r;
+    }
+}
+
+void MATHi_CRC32InitTableRev (MATHCRC32Table * table, u32 poly) {
+    u32 r;
+    u32 i, j;
+    u32 * t = table->table;
+
+    for (i = 0; i < 256; i++) {
+        r = i;
+        for (j = 0; j < 8; j++) {
+            if (r & 1) {
+                r = (r >> 1) ^ poly;
+            } else {
+                r >>= 1;
+            }
+        }
+        t[i] = r;
+    }
+}
+
+void MATHi_CRC32Update (const MATHCRC32Table * table, MATHCRC32Context * context, const void * input, u32 length) {
+    u32 r;
+    u32 i;
+    const u32 * t = table->table;
+    u8 * data = (u8 *)input;
+
+    r = (u32) * context;
+    for (i = 0; i < length; i++) {
+        r = (r << 8) ^ t[((r >> 24) ^ *data) & 0xff];
+        data++;
+    }
+    *context = (MATHCRC32Context)r;
+}
+
+void MATHi_CRC32UpdateRev (const MATHCRC32Table * table, MATHCRC32Context * context, const void * input, u32 length) {
+    u32 r;
+    u32 i;
+    const u32 * t = table->table;
+    u8 * data = (u8 *)input;
+
+    r = (u32) * context;
+    for (i = 0; i < length; i++) {
+        r = (r >> 8) ^ t[(r ^ *data) & 0xff];
+        data++;
+    }
+    *context = (MATHCRC32Context)r;
+}
+
+u8 MATH_CalcCRC8 (const MATHCRC8Table * table, const void * data, u32 dataLength) {
+    MATHCRC8Context context;
+    MATH_CRC8Init(&context);
+    MATH_CRC8Update(table, &context, data, dataLength);
+    return MATH_CRC8GetHash(&context);
+}
+
+u16 MATH_CalcCRC16 (const MATHCRC16Table * table, const void * data, u32 dataLength) {
+    MATHCRC16Context context;
+    MATH_CRC16Init(&context);
+    MATH_CRC16Update(table, &context, data, dataLength);
+    return MATH_CRC16GetHash(&context);
+}
+
+u16 MATH_CalcCRC16CCITT (const MATHCRC16Table * table, const void * data, u32 dataLength) {
+    MATHCRC16Context context;
+    MATH_CRC16CCITTInit(&context);
+    MATH_CRC16CCITTUpdate(table, &context, data, dataLength);
+    return MATH_CRC16CCITTGetHash(&context);
+}
+
+u32 MATH_CalcCRC32 (const MATHCRC32Table * table, const void * data, u32 dataLength) {
+    MATHCRC32Context context;
+    MATH_CRC32Init(&context);
+    MATH_CRC32Update(table, &context, data, dataLength);
+    return MATH_CRC32GetHash(&context);
+}
+
+u32 MATH_CalcCRC32POSIX (const MATHCRC32Table * table, const void * data, u32 dataLength) {
+    MATHCRC32Context context;
+    MATH_CRC32POSIXInit(&context);
+    MATH_CRC32POSIXUpdate(table, &context, data, dataLength);
+    return MATH_CRC32POSIXGetHash(&context);
+}

lib/NitroSDK/src/math/dgt.c

@@ -0,0 +1,15 @@
+#include <nitro/math/dgt.h>
+
+void MATH_CalcMD5 (void * digest, const void * data, u32 dataLength) {
+    MATHMD5Context context;
+    MATH_MD5Init(&context);
+    MATH_MD5Update(&context, data, dataLength);
+    MATH_MD5GetHash(&context, digest);
+}
+
+void MATH_CalcSHA1 (void * digest, const void * data, u32 dataLength) {
+    MATHSHA1Context context;
+    MATH_SHA1Init(&context);
+    MATH_SHA1Update(&context, data, dataLength);
+    MATH_SHA1GetHash(&context, digest);
+}

lib/NitroSDK/src/math/math.c

@@ -0,0 +1,67 @@
+#include <nitro/math.h>
+
+#if defined(SDK_ARM9) && (defined(SDK_CW) || defined(__MWERKS__))
+
+#pragma thumb off
+u32 MATH_CountLeadingZerosFunc (u32 x) {
+    asm
+    {
+        clz x, x
+    }
+    return x;
+}
+#pragma thumb reset
+
+#else
+
+u32 MATH_CountLeadingZerosFunc (u32 x) {
+    u32 y;
+    u32 n = 32;
+
+    y = x >> 16;
+    if (y != 0) {
+        n -= 16;
+        x = y;
+    }
+    y = x >> 8;
+    if (y != 0) {
+        n -= 8;
+        x = y;
+    }
+    y = x >> 4;
+    if (y != 0) {
+        n -= 4;
+        x = y;
+    }
+    y = x >> 2;
+    if (y != 0) {
+        n -= 2;
+        x = y;
+    }
+    y = x >> 1;
+    if (y != 0) {
+        n -= 2;
+    } else {
+        n -= x;
+    }
+
+    return n;
+}
+
+#endif
+
+u8 MATH_CountPopulation (u32 x) {
+    x -= ((x >> 1) & 0x55555555);
+
+    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+
+    x += (x >> 4);
+
+    x &= 0x0f0f0f0f;
+
+    x += (x >> 8);
+
+    x += (x >> 16);
+
+    return (u8)x;
+}

main.lsf

@@ -566,9 +566,9 @@ Static main
 	Object lib/NitroSDK/src/ctrdg/ctrdg_flash_MX29L010.o
 	Object lib/NitroSDK/src/ctrdg/ctrdg_flash_MX29L512.o
 	Object lib/NitroSDK/src/ctrdg/ctrdg_task.o
-	Object lib/NitroSDK/asm/math/math.o
-	Object lib/NitroSDK/asm/math/dgt.o
-	Object lib/NitroSDK/asm/math/crc.o
+	Object lib/NitroSDK/src/math/math.o
+	Object lib/NitroSDK/src/math/dgt.o
+	Object lib/NitroSDK/src/math/crc.o
 	Object lib/NitroSDK/asm/std/std_string.o
 	Object lib/NitroSDK/asm/std/std_sprintf.o
 	Object lib/msl/asm/abort_exit_arm.o