Specialised unsafe.asm to unsafe_mem.asm, and renamed unsafe.memcmp to unsafe.compare

unsafe_mem.asm

@@ -1,4 +1,4 @@
-; int memcmp(uint8_t* a, uint8_t* b, size_t count);
+; int compare(uint8_t* a, uint8_t* b, size_t count);
 ;   Compares two memory segment of equal length lexicographically.
 ;   Temporarily modifies the byte at address `a + count`.
 ;
@@ -11,7 +11,7 @@
 ;   -  `0` if both segments are equal.
 ;   - `<0` if the first segment is less than the second segment.
 ;   - `>0` if the first segment is greater than the second segment.
-pub fn_memcmp:
+pub compare:
     ; Exclusive end point of the second segment.
     add r4, r3, r2
     ; Exclusive end point of the first segment.
@@ -20,13 +20,13 @@ pub fn_memcmp:
     load_8 flags, [r4]
     ; Check if the first bytes behind the sequences are equal.
     cmp flags, r6
-    jne _memcmp__loop
+    jne _compare__loop
     ; Change the byte directly behind the first segment.
     xor r4, r6, 1
-    ; This would be problematic if someone calls memcmp with a first segment
+    ; This would be problematic if someone calls compare with a first segment
     ; whose end point overlaps the program memory of this function.
     store_8 [r3], r4
-_memcmp__loop:
+_compare__loop:
     load_32 r4, [r1]
     add r1, r1, 4
     load_32 r5, [r2]
@@ -34,7 +34,7 @@ _memcmp__loop:
     ; Comparing two sequences of 4 bytes lexicographically is equivalent to
     ; comparing the corresponding big endian 32 bit words.
     cmp r4, r5
-    je _memcmp__loop
+    je _compare__loop
     ; We overshot in the loop; decrement r1 again. (Only by 2, we backtrack the rest if necessary later)
     sub r1, r1, 2
     ; Restore the byte we changed.
@@ -45,24 +45,24 @@ _memcmp__loop:
     mov r5, flags
     ; Check if at least one of the two most significant bytes is not 0.
     cmp r4, 0xffff
-    jbe _memcmp__low2
+    jbe _compare__low2
     ; If it is, backtrack the remaining 2 indices.
     ; Shift the most significant bytes to the least significant ones.
     sub r1, r1, 2
     lsr r4, r4, 16
-_memcmp__low2:
+_compare__low2:
     ; r1 now points to a non-zero 16 bit value.
     ; If the 16 bit value at r1-2 is in-bounds, then it is 0.
     ; Check if the most significant byte of the 16 bit value is 0.
     cmp r4, 0xff
-    ja _memcmp__low1
+    ja _compare__low1
     ; If it is, our target is the least significant byte.
     add r1, r1, 1
-_memcmp__low1:
+_compare__low1:
     ; Otherwise, the target is that non-zero byte.
     ; Check if the target is out of bounds, i.e. the loop terminated through the "bounds check".
     cmp r1, r3
-    jae _memcmp__oob
+    jae _compare__oob
     ; r5 is the comparison result in the format of `cmp`. Convert it to the desired format.
     ; 00 => 0x40000000 > 0
     ; 01 => 0x00000000 = 0
@@ -70,6 +70,6 @@ _memcmp__low1:
     xor r1, r5, 1
     lsl r1, r1, 30
     jmp r13
-_memcmp__oob:
+_compare__oob:
     mov r1, 0
     jmp r13