https://git.reactos.org/?p=reactos.git;a=commitdiff;h=94eb475177571d1fc6177c...
commit 94eb475177571d1fc6177cb7310d4532e632d811 Author: Timo Kreuzer timo.kreuzer@reactos.org AuthorDate: Mon Oct 21 19:43:26 2024 +0300 Commit: Timo Kreuzer timo.kreuzer@reactos.org CommitDate: Wed Jan 22 18:56:08 2025 +0200
[UCRT][ASM] Make asm code GCC compatible --- sdk/include/asm/asm.inc | 8 +- sdk/lib/ucrt/string/amd64/strcat.s | 27 ++++--- sdk/lib/ucrt/string/amd64/strcmp.s | 45 ++++++----- sdk/lib/ucrt/string/amd64/strlen.s | 15 ++-- sdk/lib/ucrt/string/amd64/strncat.s | 23 +++--- sdk/lib/ucrt/string/amd64/strncmp.s | 29 ++++--- sdk/lib/ucrt/string/amd64/strncpy.s | 27 ++++--- sdk/lib/ucrt/string/i386/_memicmp.s | 83 +++++++++++-------- sdk/lib/ucrt/string/i386/_strnicm.s | 88 +++++++++++--------- sdk/lib/ucrt/string/i386/memccpy.s | 95 +++++++++++----------- sdk/lib/ucrt/string/i386/strcat.s | 112 ++++++++++++------------- sdk/lib/ucrt/string/i386/strcmp.s | 29 ++++--- sdk/lib/ucrt/string/i386/strcspn.s | 5 ++ sdk/lib/ucrt/string/i386/strlen.s | 49 +++++------ sdk/lib/ucrt/string/i386/strncat.s | 129 ++++++++++++++--------------- sdk/lib/ucrt/string/i386/strncmp.s | 61 +++++++------- sdk/lib/ucrt/string/i386/strncpy.s | 157 ++++++++++++++++++------------------ sdk/lib/ucrt/string/i386/strnset.s | 57 +++++++------ sdk/lib/ucrt/string/i386/strpbrk.s | 5 ++ sdk/lib/ucrt/string/i386/strrev.s | 65 ++++++++------- sdk/lib/ucrt/string/i386/strset.s | 46 ++++++----- sdk/lib/ucrt/string/i386/strspn.s | 104 ++++++++++++++---------- 22 files changed, 701 insertions(+), 558 deletions(-)
diff --git a/sdk/include/asm/asm.inc b/sdk/include/asm/asm.inc index 51ec68d03c7..9af3d164ac9 100644 --- a/sdk/include/asm/asm.inc +++ b/sdk/include/asm/asm.inc @@ -316,8 +316,10 @@ ENDM .endm
/* MASM compatible ALIGN */ -#define ALIGN .align -#define align .align +.macro align x + .align x +.endm +#define ALIGN align
/* MASM compatible REPEAT, additional ENDR */ #define REPEAT .rept @@ -352,6 +354,7 @@ ENDM
/* MASM needs an END tag */ #define END +#define end
.macro .MODEL model .endm @@ -359,6 +362,7 @@ ENDM .macro .code .text .endm +#define CODESEG .code
.macro .const .section .rdata diff --git a/sdk/lib/ucrt/string/amd64/strcat.s b/sdk/lib/ucrt/string/amd64/strcat.s index 63724bedf5f..9723e778dbf 100644 --- a/sdk/lib/ucrt/string/amd64/strcat.s +++ b/sdk/lib/ucrt/string/amd64/strcat.s @@ -1,3 +1,7 @@ +#include <asm.inc> +#include <ksamd64.inc> +.code64 +#if 0 title strcat - concatenate (append) one string to another ;*** ;strcat.asm - contains strcat() and strcpy() routines @@ -73,11 +77,12 @@ include ksamd64.inc ; ;Exceptions: ;******************************************************************************* +#endif
public ___entry_from_strcat_in_strcpy -LEAF_ENTRY_ARG2 strcat, _TEXT, dst:ptr byte, src:ptr byte +LEAF_ENTRY_ARG2 strcat, _TEXT, dst_ptr_byte, src_ptr_byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
mov r11, rcx test cl, 7 @@ -94,12 +99,12 @@ strcat_copy_head_loop_begin: strcat_loop_begin: mov rax, [rcx] mov r10, rax - mov r9, 7efefefefefefeffh + mov r9, HEX(7efefefefefefeff) add r9, r10 xor r10, -1 xor r10, r9 add rcx, 8 - mov r9, 8101010101010100h + mov r9, HEX(8101010101010100) test r10, r9 je strcat_loop_begin sub rcx, 8 @@ -136,16 +141,16 @@ strcat_loop_end:
LEAF_END strcat, _TEXT
-LEAF_ENTRY_ARG2 strcpy, _TEXT, dst:ptr byte, src:ptr byte +LEAF_ENTRY_ARG2 strcpy, _TEXT, dst_ptr_byte, src_ptr byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
mov r11, rcx strcat_copy: ___entry_from_strcat_in_strcpy=strcat_copy - ; align the SOURCE so we never page fault - ; dest pointer alignment not important - sub rcx, rdx ; combine pointers + // align the SOURCE so we never page fault + // dest pointer alignment not important + sub rcx, rdx // combine pointers test dl, 7 jz qword_loop_entrance
@@ -168,12 +173,12 @@ qword_loop_begin: add rdx, 8 qword_loop_entrance: mov rax, [rdx] - mov r9, 7efefefefefefeffh + mov r9, HEX(7efefefefefefeff) add r9, rax mov r10, rax xor r10, -1 xor r10, r9 - mov r9, 8101010101010100h + mov r9, HEX(8101010101010100) test r10, r9 jz qword_loop_begin
diff --git a/sdk/lib/ucrt/string/amd64/strcmp.s b/sdk/lib/ucrt/string/amd64/strcmp.s index 91ae47fd591..8a3e32d0e5e 100644 --- a/sdk/lib/ucrt/string/amd64/strcmp.s +++ b/sdk/lib/ucrt/string/amd64/strcmp.s @@ -1,3 +1,7 @@ +#include <asm.inc> +#include <ksamd64.inc> +.code64 +#if 0 page ,132 title strcmp.asm - compare two strings ;*** @@ -54,25 +58,26 @@ include ksamd64.inc ;Exceptions: ; ;******************************************************************************* +#endif
-CHAR_TYPE EQU BYTE -CHAR_PTR EQU BYTE PTR -CHAR_SIZE = sizeof CHAR_TYPE +#define CHAR_TYPE BYTE +#define CHAR_PTR BYTE PTR +#define CHAR_SIZE 1 /* = sizeof CHAR_TYPE */
-BLK_TYPE EQU QWORD -BLK_PTR EQU QWORD PTR -BLK_SIZE = sizeof BLK_TYPE +#define BLK_TYPE QWORD +#define BLK_PTR QWORD PTR +#define BLK_SIZE 8 /* = sizeof BLK_TYPE */
-;PAGE_SIZE = 1000h -PAGE_MASK = PAGE_SIZE - 1 ; mask for offset in MM page -PAGE_SAFE_BLK = PAGE_SIZE - BLK_SIZE ; maximum offset for safe block compare +//PAGE_SIZE = 1000h +PAGE_MASK = PAGE_SIZE - 1 // mask for offset in MM page +PAGE_SAFE_BLK = PAGE_SIZE - BLK_SIZE // maximum offset for safe block compare
-LEAF_ENTRY_ARG2 strcmp, _TEXT, str1:ptr byte, str2:ptr byte +LEAF_ENTRY_ARG2 strcmp, _TEXT, str1_ptr_byte, str2_ptr_byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
-; rcx = src -; rdx = dst +// rcx = src +// rdx = dst
sub rdx, rcx test cl, (BLK_SIZE - 1) @@ -93,8 +98,8 @@ comp_head_loop_begin:
qword_loop_enter:
- mov r11, 8080808080808080h - mov r10, 0fefefefefefefeffh + mov r11, HEX(8080808080808080) + mov r10, HEX(0fefefefefefefeff)
qword_loop_begin: lea eax, [edx+ecx] @@ -105,24 +110,24 @@ qword_loop_begin: mov rax, BLK_PTR[rcx] cmp rax, BLK_PTR[rdx+rcx]
-; mismatched string (or maybe null + garbage after) +// mismatched string (or maybe null + garbage after) jne comp_head_loop_begin
-; look for null terminator +// look for null terminator lea r9, [rax + r10] not rax add rcx, BLK_SIZE and rax, r9
- test rax, r11 ; r11=8080808080808080h + test rax, r11 // r11=8080808080808080h jz qword_loop_begin
return_equal: - xor eax, eax ; gets all 64 bits + xor eax, eax // gets all 64 bits ret
return_not_equal: - sbb rax, rax ; AX=-1, CY=1 AX=0, CY=0 + sbb rax, rax // AX=-1, CY=1 AX=0, CY=0 or rax, 1 ret
diff --git a/sdk/lib/ucrt/string/amd64/strlen.s b/sdk/lib/ucrt/string/amd64/strlen.s index 3ca728ee6ad..0157d58a244 100644 --- a/sdk/lib/ucrt/string/amd64/strlen.s +++ b/sdk/lib/ucrt/string/amd64/strlen.s @@ -1,3 +1,7 @@ +#include <asm.inc> +#include <ksamd64.inc> +.code64 +#if 0 page ,132 title strlen - return the length of a null-terminated string ;*** @@ -42,17 +46,18 @@ include ksamd64.inc ;Exceptions: ; ;******************************************************************************* +#endif
LEAF_ENTRY_ARG1 strlen, _TEXT, buf:ptr byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
mov rax, rcx - neg rcx ; for later + neg rcx // for later test rax, 7 jz main_loop_entry
-byte 066h, 090h +.byte HEX(66), HEX(90)
byte_loop_begin: mov dl, [rax] @@ -63,8 +68,8 @@ byte_loop_begin: jnz byte_loop_begin
main_loop_entry: - mov r8, 7efefefefefefeffh - mov r11, 8101010101010100h + mov r8, HEX(7efefefefefefeff) + mov r11, HEX(8101010101010100)
main_loop_begin: mov rdx, [rax] diff --git a/sdk/lib/ucrt/string/amd64/strncat.s b/sdk/lib/ucrt/string/amd64/strncat.s index f2a60f5355d..8b506c2bfe8 100644 --- a/sdk/lib/ucrt/string/amd64/strncat.s +++ b/sdk/lib/ucrt/string/amd64/strncat.s @@ -1,3 +1,7 @@ +#include <asm.inc> +#include <ksamd64.inc> +.code64 +#if 0 page ,132 title strncat - append n chars of string1 to string2 ;*** @@ -53,8 +57,9 @@ include ksamd64.inc ;Exceptions: ; ;******************************************************************************* -LEAF_ENTRY_ARG3 strncat, _TEXT, front:ptr byte, back:ptr byte, count:dword - OPTION PROLOGUE:NONE, EPILOGUE:NONE +#endif +LEAF_ENTRY_ARG3 strncat, _TEXT, front_ptr_byte, back_ptr_byte, count_dword + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
mov r11, rcx or r8, r8 @@ -75,12 +80,12 @@ strncat_copy_head_loop_begin: strncat_loop_begin: mov rax, [rcx] mov r10, rax - mov r9, 7efefefefefefeffh + mov r9, HEX(7efefefefefefeff) add r9, r10 xor r10, -1 xor r10, r9 add rcx, 8 - mov r9, 8101010101010100h + mov r9, HEX(8101010101010100) test r10, r9 je strncat_loop_begin sub rcx, 8 @@ -116,9 +121,9 @@ strncat_loop_end: jmp strncat_loop_begin
strncat_copy: -; align the SOURCE so we never page fault -; dest pointer alignment not important - sub rcx, rdx ; combine pointers +// align the SOURCE so we never page fault +// dest pointer alignment not important + sub rcx, rdx // combine pointers test dl, 7 jz qword_loop_entrance
@@ -150,12 +155,12 @@ qword_loop_entrance: mov rax, [rdx] sub r8, 8 jbe qword_loop_end - mov r9, 7efefefefefefeffh + mov r9, HEX(7efefefefefefeff) add r9, rax mov r10, rax xor r10, -1 xor r10, r9 - mov r9, 8101010101010100h + mov r9, HEX(8101010101010100) test r10, r9 jz qword_loop_begin
diff --git a/sdk/lib/ucrt/string/amd64/strncmp.s b/sdk/lib/ucrt/string/amd64/strncmp.s index 52b31f5f61b..f16fc43cd13 100644 --- a/sdk/lib/ucrt/string/amd64/strncmp.s +++ b/sdk/lib/ucrt/string/amd64/strncmp.s @@ -1,3 +1,7 @@ +#include <asm.inc> +#include <ksamd64.inc> +.code64 +#if 0 page ,132 title strncmp - compare first n chars of two strings ;*** @@ -51,14 +55,15 @@ include ksamd64.inc ;Exceptions: ; ;******************************************************************************* +#endif
-LEAF_ENTRY_ARG3 strncmp, _TEXT, str1:ptr byte, str2:ptr byte, count:dword +LEAF_ENTRY_ARG3 strncmp, _TEXT, str1_ptr_byte, str2_ptr_byte, count_dword
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
-; rcx = first -; rdx = last -; r8 = count +// rcx = first +// rdx = last +// r8 = count
sub rdx, rcx
@@ -85,13 +90,13 @@ comp_head_loop_begin: jnz comp_head_loop_begin
qword_loop_enter: - mov r11, 08080808080808080h - mov r10, 0fefefefefefefeffh + mov r11, HEX(08080808080808080) + mov r10, HEX(0fefefefefefefeff)
qword_loop_begin: lea eax, [rdx+rcx] - and eax, 0fffh - cmp eax, 0ff8h + and eax, HEX(0fff) + cmp eax, HEX(0ff8) ja comp_head_loop_begin
mov rax, qword ptr[rcx] @@ -106,7 +111,7 @@ qword_loop_begin: lea r9, [r10+rax] not rax and rax, r9 - test rax, r11 ; 8080808080808080h + test rax, r11 // 8080808080808080h
jz qword_loop_begin
@@ -114,10 +119,10 @@ return_equal: xor eax, eax ret
-; align 16 +// align 16
return_not_equal: - sbb rax, rax ; AX=-1, CY=1 AX=0, CY=0 + sbb rax, rax // AX=-1, CY=1 AX=0, CY=0 or rax, 1 ret
diff --git a/sdk/lib/ucrt/string/amd64/strncpy.s b/sdk/lib/ucrt/string/amd64/strncpy.s index c92ed90346e..27d1349dc0c 100644 --- a/sdk/lib/ucrt/string/amd64/strncpy.s +++ b/sdk/lib/ucrt/string/amd64/strncpy.s @@ -1,3 +1,7 @@ +#include <asm.inc> +#include <ksamd64.inc> +.code64 +#if 0 page ,132 title strncpy - copy at most n characters of string ;*** @@ -12,17 +16,18 @@ ; Look at strncat.asm for this file include ksamd64.inc subttl "strncpy" +#endif
-LEAF_ENTRY_ARG3 strncpy, _TEXT, dst:ptr byte, src:ptr byte, count:dword -OPTION PROLOGUE:NONE, EPILOGUE:NONE +LEAF_ENTRY_ARG3 strncpy, _TEXT, dst_ptr_byte, src_ptr_byte, count_dword +//OPTION PROLOGUE:NONE, EPILOGUE:NONE
-; align the SOURCE so we never page fault -; dest pointer alignment not important +// align the SOURCE so we never page fault +// dest pointer alignment not important
mov r11, rcx or r8, r8 jz strncpy_exit - sub rcx, rdx ; combine pointers + sub rcx, rdx // combine pointers test dl, 7 jz qword_loop_entrance
@@ -49,12 +54,12 @@ qword_loop_entrance: mov rax, [rdx] sub r8, 8 jbe qword_loop_end - mov r9, 7efefefefefefeffh + mov r9, HEX(7efefefefefefeff) add r9, rax mov r10, rax xor r10, -1 xor r10, r9 - mov r9, 8101010101010100h + mov r9, HEX(8101010101010100) test r10, r9 jz qword_loop_begin
@@ -118,12 +123,12 @@ strncpy_exit_2: mov rax, r11 ret
-;this is really just memset +//this is really just memset filler: add rcx, rdx xor rdx, rdx cmp r8, 16 - jb tail ; a quickie + jb tail // a quickie aligner1: test cl, 7 jz aligned @@ -144,7 +149,7 @@ loop32: jae loop32
tail_8_enter: - add r8, 32 ; get back the value + add r8, 32 // get back the value tail_8_begin: sub r8, 8 jb tail_enter @@ -153,7 +158,7 @@ tail_8_begin: jmp tail_8_begin
tail_enter: - add r8, 8 ; get back the value + add r8, 8 // get back the value tail: sub r8, 1 jb tail_finish diff --git a/sdk/lib/ucrt/string/i386/_memicmp.s b/sdk/lib/ucrt/string/i386/_memicmp.s index 3d08e70f38a..3f12973fc80 100644 --- a/sdk/lib/ucrt/string/i386/_memicmp.s +++ b/sdk/lib/ucrt/string/i386/_memicmp.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title memicmp - compare blocks of memory, ignore case ;*** @@ -54,77 +56,90 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public __ascii_memicmp -__ascii_memicmp proc \ - uses edi esi ebx, \ - first:ptr byte, \ - last:ptr byte, \ - count:IWORD + public ___ascii_memicmp +.PROC ___ascii_memicmp
- mov ecx,[count] ; cx = count +// Prolog. Original sources used ML's extended PROC feature to autogenerate this. + push ebp + mov ebp, esp + push edi + push esi + push ebx +#define first ebp + 8 +#define last ebp + 12 +#define count ebp + 16 + + mov ecx,[count] // cx = count or ecx,ecx - jz short toend ; if count=0, nothing to do + jz short toend // if count=0, nothing to do
- mov esi,[first] ; si = first - mov edi,[last] ; di = last + mov esi,[first] // si = first + mov edi,[last] // di = last
- ; C locale + // C locale
mov bh,'A' mov bl,'Z' - mov dh,'a'-'A' ; add to cap to make lower + mov dh,'a'-'A' // add to cap to make lower
align 4
lupe: - mov ah,[esi] ; ah = *first - add esi,1 ; first++ - mov al,[edi] ; al = *last - add edi,1 ; last++ + mov ah,[esi] // ah = *first + add esi,1 // first++ + mov al,[edi] // al = *last + add edi,1 // last++
- cmp ah,al ; test for equality BEFORE converting case + cmp ah,al // test for equality BEFORE converting case je short dolupe
- cmp ah,bh ; ah < 'A' ?? + cmp ah,bh // ah < 'A' ?? jb short skip1
- cmp ah,bl ; ah > 'Z' ?? + cmp ah,bl // ah > 'Z' ?? ja short skip1
- add ah,dh ; make lower case + add ah,dh // make lower case
skip1: - cmp al,bh ; al < 'A' ?? + cmp al,bh // al < 'A' ?? jb short skip2
- cmp al,bl ; al > 'Z' ?? + cmp al,bl // al > 'Z' ?? ja short skip2
- add al,dh ; make lower case + add al,dh // make lower case
skip2: - cmp ah,al ; *first == *last ?? - jne short differ ; nope, found mismatched chars + cmp ah,al // *first == *last ?? + jne short differ // nope, found mismatched chars
dolupe: sub ecx,1 jnz short lupe
- jmp short toend ; cx = 0, return 0 + jmp short toend // cx = 0, return 0
differ: - mov ecx,-1 ; assume last is bigger - ; *** can't use "or ecx,-1" due to flags *** - jb short toend ; last is, in fact, bigger (return -1) - neg ecx ; first is bigger (return 1) + mov ecx,-1 // assume last is bigger + // *** can't use "or ecx,-1" due to flags *** + jb short toend // last is, in fact, bigger (return -1) + neg ecx // first is bigger (return 1)
toend: - mov eax,ecx ; move return value to ax + mov eax,ecx // move return value to ax + +// Epilog. Original sources used ML's extended PROC feature to autogenerate this. + pop ebx + pop esi + pop edi + pop ebp
- ret ; _cdecl return + ret // _cdecl return
-__ascii_memicmp endp +.ENDP // ___ascii_memicmp end diff --git a/sdk/lib/ucrt/string/i386/_strnicm.s b/sdk/lib/ucrt/string/i386/_strnicm.s index dc3dcb4d074..f3a983a46a8 100644 --- a/sdk/lib/ucrt/string/i386/_strnicm.s +++ b/sdk/lib/ucrt/string/i386/_strnicm.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strnicmp - compare n chars of strings, ignore case ;*** @@ -62,63 +64,69 @@ page ;Exceptions: ; ;******************************************************************************* - - CODESEG - - public __ascii_strnicmp -__ascii_strnicmp proc \ - uses edi esi ebx, \ - first:ptr byte, \ - last:ptr byte, \ - count:IWORD - - mov ecx,[count] ; cx = byte count +#endif + + .code + + public ___ascii_strnicmp +.PROC ___ascii_strnicmp +// Prolog. Original sources used ML's extended PROC feature to autogenerate this. + push ebp + mov ebp, esp + push edi // uses edi esi ebx + push esi + push ebx +#define first ebp + 8 // first:ptr byte +#define last ebp + 12 // last:ptr byte +#define count ebp + 16 // count:IWORD + + mov ecx,[count] // cx = byte count or ecx,ecx - jz toend ; if count = 0, we are done + jz toend // if count = 0, we are done
- mov esi,[first] ; si = first string - mov edi,[last] ; di = last string + mov esi,[first] // si = first string + mov edi,[last] // di = last string
mov bh,'A' mov bl,'Z' - mov dh,'a'-'A' ; add to cap to make lower + mov dh,'a'-'A' // add to cap to make lower
align 4
lupe: - mov ah,[esi] ; *first + mov ah,[esi] // *first
- or ah,ah ; see if *first is null + or ah,ah // see if *first is null
- mov al,[edi] ; *last + mov al,[edi] // *last
- jz short eject ; jump if *first is null + jz short eject // jump if *first is null
- or al,al ; see if *last is null - jz short eject ; jump if so + or al,al // see if *last is null + jz short eject // jump if so
- add esi,1 ; first++ - add edi,1 ; last++ + add esi,1 // first++ + add edi,1 // last++
- cmp ah,bh ; 'A' + cmp ah,bh // 'A' jb short skip1
- cmp ah,bl ; 'Z' + cmp ah,bl // 'Z' ja short skip1
- add ah,dh ; make lower case + add ah,dh // make lower case
skip1: - cmp al,bh ; 'A' + cmp al,bh // 'A' jb short skip2
- cmp al,bl ; 'Z' + cmp al,bl // 'Z' ja short skip2
- add al,dh ; make lower case + add al,dh // make lower case
skip2: - cmp ah,al ; *first == *last ?? + cmp ah,al // *first == *last ?? jne short differ
sub ecx,1 @@ -126,18 +134,24 @@ skip2:
eject: xor ecx,ecx - cmp ah,al ; compare the (possibly) differing bytes - je short toend ; both zero; return 0 + cmp ah,al // compare the (possibly) differing bytes + je short toend // both zero; return 0
differ: - mov ecx,-1 ; assume last is bigger (* can't use 'or' *) - jb short toend ; last is, in fact, bigger (return -1) - neg ecx ; first is bigger (return 1) + mov ecx,-1 // assume last is bigger (* can't use 'or' *) + jb short toend // last is, in fact, bigger (return -1) + neg ecx // first is bigger (return 1)
toend: mov eax,ecx
- ret ; _cdecl return +// Epilog. Original sources used ML's extended PROC feature to autogenerate this. + pop ebx + pop esi + pop edi + pop ebp + + ret // _cdecl return
-__ascii_strnicmp endp +.ENDP // ___ascii_strnicmp end diff --git a/sdk/lib/ucrt/string/i386/memccpy.s b/sdk/lib/ucrt/string/i386/memccpy.s index 96b5e2086ba..d40b38362d9 100644 --- a/sdk/lib/ucrt/string/i386/memccpy.s +++ b/sdk/lib/ucrt/string/i386/memccpy.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title memccpy - copy bytes until character found ;*** @@ -51,85 +53,86 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public _memccpy -_memccpy proc \ - dest:ptr byte, \ - src:ptr byte, \ - _c:byte, \ - count:DWORD + public __memccpy +.PROC __memccpy + // dest:ptr byte, \ + // src:ptr byte, \ + // _c:byte, \ + // count:DWORD
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
- .FPO ( 0, 4, 0, 0, 0, 0 ) + FPO 0, 4, 0, 0, 0, 0
- mov ecx,[esp + 10h] ; ecx = max byte count - push ebx ; save ebx + mov ecx,[esp + HEX(10)] // ecx = max byte count + push ebx // save ebx
- test ecx,ecx ; if it's nothing to move - jz ret_zero_len ; restore ebx, and return NULL + test ecx,ecx // if it's nothing to move + jz ret_zero_len // restore ebx, and return NULL
- mov bh,[esp + 10h] ; bh = byte to look for - push esi ; save esi + mov bh,[esp + HEX(10)] // bh = byte to look for + push esi // save esi
- test ecx,1 ; test if counter is odd or even + test ecx,1 // test if counter is odd or even
- mov eax,[esp + 0ch] ; eax = dest , don't affect flags - mov esi,[esp + 10h] ; esi = source , don't affect flags + mov eax,[esp + HEX(0c)] // eax = dest , don't affect flags + mov esi,[esp + HEX(10)] // esi = source , don't affect flags
-; nop - jz lupe2 ; if counter is even, do double loop - ; else do one iteration, and drop into double loop - mov bl,[esi] ; get first byte into bl - add esi,1 ; kick src (esi points to src) +// nop + jz lupe2 // if counter is even, do double loop + // else do one iteration, and drop into double loop + mov bl,[esi] // get first byte into bl + add esi,1 // kick src (esi points to src)
- mov [eax],bl ; store it in dest - add eax,1 ; kick dest + mov [eax],bl // store it in dest + add eax,1 // kick dest
- cmp bl,bh ; see if we just moved the byte + cmp bl,bh // see if we just moved the byte je short toend
- sub ecx,1 ; decrement counter - jz retnull ; drop into double loop if nonzero + sub ecx,1 // decrement counter + jz retnull // drop into double loop if nonzero
lupe2: - mov bl,[esi] ; get first byte into bl - add esi,2 ; kick esi (src) + mov bl,[esi] // get first byte into bl + add esi,2 // kick esi (src)
- cmp bl,bh ; check if we just moved the byte (from bl) - je toend_mov_inc ; store bl & exit + cmp bl,bh // check if we just moved the byte (from bl) + je toend_mov_inc // store bl & exit
- mov [eax],bl ; store first byte from bl - mov bl,[esi - 1] ; get second byte into bl + mov [eax],bl // store first byte from bl + mov bl,[esi - 1] // get second byte into bl
- mov [eax + 1],bl ; store second byte from bl - add eax,2 ; kick eax (dest) + mov [eax + 1],bl // store second byte from bl + add eax,2 // kick eax (dest)
- cmp bl,bh ; see if we just moved the byte - je short toend ; end of string + cmp bl,bh // see if we just moved the byte + je short toend // end of string
- sub ecx,2 ; modify counter, and if nonzero continue - jnz lupe2 ; else drop out & return NULL + sub ecx,2 // modify counter, and if nonzero continue + jnz lupe2 // else drop out & return NULL
retnull: pop esi ret_zero_len: - xor eax,eax ; null pointer + xor eax,eax // null pointer pop ebx
- ret ; _cdecl return + ret // _cdecl return
toend_mov_inc: - mov [eax],bl ; store first byte from bl - add eax,1 ; eax points right after the value + mov [eax],bl // store first byte from bl + add eax,1 // eax points right after the value
toend: pop esi pop ebx
- ret ; _cdecl return + ret // _cdecl return
-_memccpy endp +.ENDP // __memccpy
end diff --git a/sdk/lib/ucrt/string/i386/strcat.s b/sdk/lib/ucrt/string/i386/strcat.s index b7df345894c..62851822664 100644 --- a/sdk/lib/ucrt/string/i386/strcat.s +++ b/sdk/lib/ucrt/string/i386/strcat.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strcat - concatenate (append) one string to another ;*** @@ -80,39 +82,41 @@ page ; ;Exceptions: ;******************************************************************************* +#endif
- CODESEG + .code
-% public strcat, strcpy ; make both functions available -strcpy proc \ - dst:ptr byte, \ - src:ptr byte + public _strcat + public _strcpy // make both functions available +.PROC _strcpy + // dst:ptr byte, \ + // src:ptr byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
- push edi ; preserve edi - mov edi,[esp+8] ; edi points to dest string + push edi // preserve edi + mov edi,[esp+8] // edi points to dest string jmp short copy_start
-strcpy endp +.ENDP // _strcpy
align 16
-strcat proc \ - dst:ptr byte, \ - src:ptr byte +.PROC _strcat + // dst:ptr byte, \ + // src:ptr byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
- .FPO ( 0, 2, 0, 0, 0, 0 ) + FPO 0, 2, 0, 0, 0, 0
- mov ecx,[esp+4] ; ecx -> dest string - push edi ; preserve edi - test ecx,3 ; test if string is aligned on 32 bits + mov ecx,[esp+4] // ecx -> dest string + push edi // preserve edi + test ecx,3 // test if string is aligned on 32 bits je short find_end_of_dest_string_loop
-dest_misaligned: ; simple byte loop until string is aligned +dest_misaligned: // simple byte loop until string is aligned mov al,byte ptr [ecx] add ecx,1 test al,al @@ -123,27 +127,27 @@ dest_misaligned: ; simple byte loop until string is aligned align 4
find_end_of_dest_string_loop: - mov eax,dword ptr [ecx] ; read 4 bytes - mov edx,7efefeffh + mov eax,dword ptr [ecx] // read 4 bytes + mov edx,HEX(7efefeff) add edx,eax xor eax,-1 xor eax,edx add ecx,4 - test eax,81010100h + test eax,HEX(81010100) je short find_end_of_dest_string_loop - ; found zero byte in the loop + // found zero byte in the loop mov eax,[ecx - 4] - test al,al ; is it byte 0 + test al,al // is it byte 0 je short start_byte_0 - test ah,ah ; is it byte 1 + test ah,ah // is it byte 1 je short start_byte_1 - test eax,00ff0000h ; is it byte 2 + test eax,HEX(00ff0000) // is it byte 2 je short start_byte_2 - test eax,0ff000000h ; is it byte 3 + test eax,HEX(0ff000000) // is it byte 3 je short start_byte_3 jmp short find_end_of_dest_string_loop - ; taken if bits 24-30 are clear and bit - ; 31 is set + // taken if bits 24-30 are clear and bit + // 31 is set start_byte_3: lea edi,[ecx - 1] jmp short copy_start @@ -155,15 +159,15 @@ start_byte_1: jmp short copy_start start_byte_0: lea edi,[ecx - 4] -; jmp short copy_start +// jmp short copy_start
-; edi points to the end of dest string. -copy_start:: - mov ecx,[esp+0ch] ; ecx -> sorc string - test ecx,3 ; test if string is aligned on 32 bits +// edi points to the end of dest string. +GLOBAL_LABEL copy_start + mov ecx,[esp+HEX(0c)] // ecx -> sorc string + test ecx,3 // test if string is aligned on 32 bits je short main_loop_entrance
-src_misaligned: ; simple byte loop until string is aligned +src_misaligned: // simple byte loop until string is aligned mov dl,byte ptr [ecx] add ecx,1 test dl,dl @@ -174,58 +178,58 @@ src_misaligned: ; simple byte loop until string is aligned jne short src_misaligned jmp short main_loop_entrance
-main_loop: ; edx contains first dword of sorc string - mov [edi],edx ; store one more dword - add edi,4 ; kick dest pointer +main_loop: // edx contains first dword of sorc string + mov [edi],edx // store one more dword + add edi,4 // kick dest pointer main_loop_entrance: - mov edx,7efefeffh - mov eax,dword ptr [ecx] ; read 4 bytes + mov edx,HEX(7efefeff) + mov eax,dword ptr [ecx] // read 4 bytes
add edx,eax xor eax,-1
xor eax,edx - mov edx,[ecx] ; it's in cache now + mov edx,[ecx] // it's in cache now
- add ecx,4 ; kick dest pointer - test eax,81010100h + add ecx,4 // kick dest pointer + test eax,HEX(81010100)
je short main_loop - ; found zero byte in the loop + // found zero byte in the loop ; main_loop_end: - test dl,dl ; is it byte 0 + test dl,dl // is it byte 0 je short byte_0 - test dh,dh ; is it byte 1 + test dh,dh // is it byte 1 je short byte_1 - test edx,00ff0000h ; is it byte 2 + test edx,HEX(00ff0000) // is it byte 2 je short byte_2 - test edx,0ff000000h ; is it byte 3 + test edx,HEX(0ff000000) // is it byte 3 je short byte_3 - jmp short main_loop ; taken if bits 24-30 are clear and bit - ; 31 is set + jmp short main_loop // taken if bits 24-30 are clear and bit + // 31 is set byte_3: mov [edi],edx - mov eax,[esp+8] ; return in eax pointer to dest string + mov eax,[esp+8] // return in eax pointer to dest string pop edi ret byte_2: mov [edi],dx - mov eax,[esp+8] ; return in eax pointer to dest string + mov eax,[esp+8] // return in eax pointer to dest string mov byte ptr [edi+2],0 pop edi ret byte_1: mov [edi],dx - mov eax,[esp+8] ; return in eax pointer to dest string + mov eax,[esp+8] // return in eax pointer to dest string pop edi ret byte_0: mov [edi],dl - mov eax,[esp+8] ; return in eax pointer to dest string + mov eax,[esp+8] // return in eax pointer to dest string pop edi ret
-strcat endp +.ENDP // _strcat
end
diff --git a/sdk/lib/ucrt/string/i386/strcmp.s b/sdk/lib/ucrt/string/i386/strcmp.s index f22bc9a56af..6ff11c95a3a 100644 --- a/sdk/lib/ucrt/string/i386/strcmp.s +++ b/sdk/lib/ucrt/string/i386/strcmp.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strcmp.asm - compare two strings ;*** @@ -58,21 +60,22 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public strcmp -strcmp proc \ - str1:ptr byte, \ - str2:ptr byte + public _strcmp +.PROC _strcmp + // str1:ptr byte, \ + // str2:ptr byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
-; .FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame) - .FPO ( 0, 2, 0, 0, 0, 0 ) +// .FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame) + FPO 0, 2, 0, 0, 0, 0
- mov edx,[esp + 4] ; edx = src - mov ecx,[esp + 8] ; ecx = dst + mov edx,[esp + 4] // edx = src + mov ecx,[esp + 8] // ecx = dst
test edx,3 jnz short dopartial @@ -110,8 +113,8 @@ doneeq:
align 8 donene: - ; The instructions below should place -1 in eax if src < dst, - ; and 1 in eax if src > dst. + // The instructions below should place -1 in eax if src < dst, + // and 1 in eax if src > dst.
sbb eax,eax or eax,1 @@ -149,6 +152,6 @@ doword: add ecx,2 jmp short dodwords
-strcmp endp +.ENDP // _strcmp
end diff --git a/sdk/lib/ucrt/string/i386/strcspn.s b/sdk/lib/ucrt/string/i386/strcspn.s index 1a227b7664b..01d551c3069 100644 --- a/sdk/lib/ucrt/string/i386/strcspn.s +++ b/sdk/lib/ucrt/string/i386/strcspn.s @@ -1,3 +1,4 @@ +#if 0 ;*** ;strcspn.asm - ; @@ -14,3 +15,7 @@
SSTRCSPN EQU 1 INCLUDE STRSPN.ASM +#else +#define SSTRCSPN 1 +#include "strspn.s" +#endif diff --git a/sdk/lib/ucrt/string/i386/strlen.s b/sdk/lib/ucrt/string/i386/strlen.s index 00f13e60dc4..0097d5ff325 100644 --- a/sdk/lib/ucrt/string/i386/strlen.s +++ b/sdk/lib/ucrt/string/i386/strlen.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strlen - return the length of a null-terminated string ;*** @@ -46,26 +48,27 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public strlen + public _strlen
-strlen proc \ - buf:ptr byte +.PROC _strlen + // buf:ptr byte
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
- .FPO ( 0, 1, 0, 0, 0, 0 ) + FPO 0, 1, 0, 0, 0, 0
-string equ [esp + 4] +#define string [esp + 4]
- mov ecx,string ; ecx -> string - test ecx,3 ; test if string is aligned on 32 bits + mov ecx,string // ecx -> string + test ecx,3 // test if string is aligned on 32 bits je short main_loop
str_misaligned: - ; simple byte loop until string is aligned + // simple byte loop until string is aligned mov al,byte ptr [ecx] add ecx,1 test al,al @@ -73,31 +76,31 @@ str_misaligned: test ecx,3 jne short str_misaligned
- add eax,dword ptr 0 ; 5 byte nop to align label below + add eax,dword ptr 0 // 5 byte nop to align label below
- align 16 ; should be redundant + align 16 // should be redundant
main_loop: - mov eax,dword ptr [ecx] ; read 4 bytes - mov edx,7efefeffh + mov eax,dword ptr [ecx] // read 4 bytes + mov edx,HEX(7efefeff) add edx,eax xor eax,-1 xor eax,edx add ecx,4 - test eax,81010100h + test eax,HEX(81010100) je short main_loop - ; found zero byte in the loop + // found zero byte in the loop mov eax,[ecx - 4] - test al,al ; is it byte 0 + test al,al // is it byte 0 je short byte_0 - test ah,ah ; is it byte 1 + test ah,ah // is it byte 1 je short byte_1 - test eax,00ff0000h ; is it byte 2 + test eax,HEX(00ff0000) // is it byte 2 je short byte_2 - test eax,0ff000000h ; is it byte 3 + test eax,HEX(0ff000000) // is it byte 3 je short byte_3 - jmp short main_loop ; taken if bits 24-30 are clear and bit - ; 31 is set + jmp short main_loop // taken if bits 24-30 are clear and bit + // 31 is set
byte_3: lea eax,[ecx - 1] @@ -120,6 +123,6 @@ byte_0: sub eax,ecx ret
-strlen endp +.ENDP // _strlen
end diff --git a/sdk/lib/ucrt/string/i386/strncat.s b/sdk/lib/ucrt/string/i386/strncat.s index 4ec292c0e8f..0fd2d6508b2 100644 --- a/sdk/lib/ucrt/string/i386/strncat.s +++ b/sdk/lib/ucrt/string/i386/strncat.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strncat - append n chars of string1 to string2 ;*** @@ -57,29 +59,30 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public strncat -strncat proc -; front:ptr byte, -; back:ptr byte, -; count:IWORD + public _strncat +.PROC _strncat + // front:ptr byte, + // back:ptr byte, + // count:IWORD
- .FPO ( 0, 3, 0, 0, 0, 0 ) + FPO 0, 3, 0, 0, 0, 0
- mov ecx,[esp + 0ch] ; ecx = count - push edi ; preserve edi + mov ecx,[esp + HEX(0c)] // ecx = count + push edi // preserve edi test ecx,ecx - jz finish ; leave if count is zero + jz finish // leave if count is zero
- mov edi,[esp + 8] ; edi -> front string - push esi ; preserve esi - test edi,3 ; is string aligned on dword (4 bytes) - push ebx ; preserve ebx + mov edi,[esp + 8] // edi -> front string + push esi // preserve esi + test edi,3 // is string aligned on dword (4 bytes) + push ebx // preserve ebx je short find_end_of_front_string_loop
- ; simple byte loop until string is aligned + // simple byte loop until string is aligned
front_misaligned: mov al,byte ptr [edi] @@ -90,27 +93,27 @@ front_misaligned: jne short front_misaligned
find_end_of_front_string_loop: - mov eax,dword ptr [edi] ; read dword (4 bytes) - mov edx,7efefeffh + mov eax,dword ptr [edi] // read dword (4 bytes) + mov edx,HEX(7efefeff) add edx,eax xor eax,-1 xor eax,edx add edi,4 - test eax,81010100h + test eax,HEX(81010100) je short find_end_of_front_string_loop
-; found zero byte in the loop +// found zero byte in the loop mov eax,[edi - 4] - test al,al ; is it byte 0 + test al,al // is it byte 0 je short start_byte_0 - test ah,ah ; is it byte 1 + test ah,ah // is it byte 1 je short start_byte_1 - test eax,00ff0000h ; is it byte 2 + test eax,HEX(00ff0000) // is it byte 2 je short start_byte_2 - test eax,0ff000000h ; is it byte 3 + test eax,HEX(0ff000000) // is it byte 3 jne short find_end_of_front_string_loop - ; taken if bits 24-30 are clear and bit - ; 31 is set + // taken if bits 24-30 are clear and bit + // 31 is set start_byte_3: sub edi,1 jmp short copy_start @@ -123,20 +126,20 @@ start_byte_1: start_byte_0: sub edi,4
-; edi now points to the end of front string. +// edi now points to the end of front string.
copy_start: - mov esi,[esp + 14h] ; esi -> back string - test esi,3 ; is back string is dword aligned? + mov esi,[esp + HEX(14)] // esi -> back string + test esi,3 // is back string is dword aligned? jnz back_misaligned
- mov ebx,ecx ; store count for tail loop + mov ebx,ecx // store count for tail loop
shr ecx,2 jnz short main_loop_entrance - jmp short tail_loop_start ; 0 < counter < 4 + jmp short tail_loop_start // 0 < counter < 4
-; simple byte loop until back string is aligned +// simple byte loop until back string is aligned
back_misaligned: mov dl,byte ptr [esi] @@ -149,14 +152,14 @@ back_misaligned: jz empty_counter test esi,3 jne short back_misaligned - mov ebx,ecx ; store count for tail loop - shr ecx,2 ; convert ecx to dword count + mov ebx,ecx // store count for tail loop + shr ecx,2 // convert ecx to dword count jnz short main_loop_entrance
tail_loop_start: mov ecx,ebx - and ecx,3 ; ecx = count of leftover bytes after the - ; dwords have been concatenated + and ecx,3 // ecx = count of leftover bytes after the + // dwords have been concatenated jz empty_counter
tail_loop: @@ -165,88 +168,88 @@ tail_loop: mov [edi],dl add edi,1 test dl,dl - je short finish1 ; '\0' was already copied + je short finish1 // '\0' was already copied sub ecx,1 jnz tail_loop
empty_counter: - mov [edi],cl ; cl=0; + mov [edi],cl // cl=0; finish1: pop ebx pop esi finish: - mov eax,[esp + 8] ; return in eax pointer to front string + mov eax,[esp + 8] // return in eax pointer to front string pop edi - ret ; _cdecl return + ret // _cdecl return
byte_0: mov [edi],dl - mov eax,[esp + 10h] ; return in eax pointer to front string + mov eax,[esp + HEX(10)] // return in eax pointer to front string pop ebx pop esi pop edi - ret ; _cdecl return + ret // _cdecl return
-main_loop: ; edx contains first dword of back string - mov [edi],edx ; store one more dword - add edi,4 ; kick pointer to front string +main_loop: // edx contains first dword of back string + mov [edi],edx // store one more dword + add edi,4 // kick pointer to front string
sub ecx,1 jz tail_loop_start main_loop_entrance: - mov edx,7efefeffh - mov eax,dword ptr [esi] ; read 4 bytes + mov edx,HEX(7efefeff) + mov eax,dword ptr [esi] // read 4 bytes
add edx,eax xor eax,-1
xor eax,edx - mov edx,[esi] ; it's in cache now + mov edx,[esi] // it's in cache now
- add esi,4 ; kick pointer to back string - test eax,81010100h + add esi,4 // kick pointer to back string + test eax,HEX(81010100)
je short main_loop
-; may be found zero byte in the loop - test dl,dl ; is it byte 0 +// may be found zero byte in the loop + test dl,dl // is it byte 0 je short byte_0 - test dh,dh ; is it byte 1 + test dh,dh // is it byte 1 je short byte_1 - test edx,00ff0000h ; is it byte 2 + test edx,HEX(00ff0000) // is it byte 2 je short byte_2 - test edx,0ff000000h ; is it byte 3 - jne short main_loop ; taken if bits 24-30 are clear and bit - ; 31 is set + test edx,HEX(0ff000000) // is it byte 3 + jne short main_loop // taken if bits 24-30 are clear and bit + // 31 is set byte_3: mov [edi],edx - mov eax,[esp + 10h] ; return in eax pointer to front string + mov eax,[esp + HEX(10)] // return in eax pointer to front string pop ebx pop esi pop edi - ret ; _cdecl return + ret // _cdecl return
byte_2: mov [edi],dx xor edx,edx - mov eax,[esp + 10h] ; return in eax pointer to front string + mov eax,[esp + HEX(10)] // return in eax pointer to front string mov [edi + 2],dl pop ebx pop esi pop edi - ret ; _cdecl return + ret // _cdecl return
byte_1: mov [edi],dx - mov eax,[esp + 10h] ; return in eax pointer to front string + mov eax,[esp + HEX(10)] // return in eax pointer to front string pop ebx pop esi pop edi - ret ; _cdecl return + ret // _cdecl return
-strncat endp +.ENDP // _strncat
end
diff --git a/sdk/lib/ucrt/string/i386/strncmp.s b/sdk/lib/ucrt/string/i386/strncmp.s index 1f0faa27a16..8086c5da06a 100644 --- a/sdk/lib/ucrt/string/i386/strncmp.s +++ b/sdk/lib/ucrt/string/i386/strncmp.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strncmp.asm - compare two strings ;*** @@ -73,43 +75,44 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
-CHAR_TYPE EQU BYTE -CHAR_PTR EQU BYTE PTR -CHAR_SIZE = sizeof CHAR_TYPE +#define CHAR_TYPE BYTE +#define CHAR_PTR BYTE PTR +#define CHAR_SIZE 1 // = sizeof CHAR_TYPE
-BLK_TYPE EQU DWORD -BLK_PTR EQU DWORD PTR -BLK_SIZE = sizeof BLK_TYPE -BLK_CHARS = BLK_SIZE / CHAR_SIZE +#define BLK_TYPE DWORD +#define BLK_PTR DWORD PTR +#define BLK_SIZE 4 // = sizeof BLK_TYPE +#define BLK_CHARS 4 // = BLK_SIZE / CHAR_SIZE
-PAGE_SIZE = 1000h -PAGE_MASK = PAGE_SIZE - 1 ; mask for offset in MM page -PAGE_SAFE_BLK = PAGE_SIZE - BLK_SIZE ; maximum offset for safe block compare +PAGE_SIZE = HEX(1000) +PAGE_MASK = PAGE_SIZE - 1 // mask for offset in MM page +PAGE_SAFE_BLK = PAGE_SIZE - BLK_SIZE // maximum offset for safe block compare
- public strncmp -strncmp proc \ - uses ebx esi, \ - str1:ptr byte, \ - str2:ptr byte, \ - count:IWORD + public _strncmp +.PROC _strncmp + // uses ebx esi, \ + // str1:ptr byte, \ + // str2:ptr byte, \ + // count:IWORD
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
push ebx push esi
-; .FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame) - .FPO ( 0, 3, $ - strncmp, 2, 0, 0 ) +// .FPO (cdwLocals, cdwParams, cbProlog, cbRegs, fUseBP, cbFrame) + FPO 0, 3, ($ - _strncmp), 2, 0, 0
- mov ecx,[esp + 12] ; ecx = str1 - mov edx,[esp + 16] ; edx = str2 - mov ebx,[esp + 20] ; ebx = count + mov ecx,[esp + 12] // ecx = str1 + mov edx,[esp + 16] // edx = str2 + mov ebx,[esp + 20] // ebx = count
-; Check for a limit of zero characters. - test ebx, 0FFFFFFFFh +// Check for a limit of zero characters. + test ebx, HEX(0FFFFFFFF) jz return_equal
sub ecx, edx @@ -146,11 +149,11 @@ dword_loop_begin: sub ebx, BLK_CHARS jbe return_equal
- lea esi, [eax+0fefefeffh] + lea esi, [eax+HEX(0fefefeff)] add edx, BLK_SIZE not eax and eax, esi - test eax, 80808080h + test eax, HEX(80808080) jz dword_loop_begin
return_equal: @@ -162,12 +165,12 @@ return_equal: align 16
return_not_equal: - sbb eax, eax ; AX=-1, CY=1 AX=0, CY=0 + sbb eax, eax // AX=-1, CY=1 AX=0, CY=0 or eax, 1 pop esi pop ebx ret
-strncmp endp +.ENDP // _strncmp
end diff --git a/sdk/lib/ucrt/string/i386/strncpy.s b/sdk/lib/ucrt/string/i386/strncpy.s index 000991703b5..30c8801ec84 100644 --- a/sdk/lib/ucrt/string/i386/strncpy.s +++ b/sdk/lib/ucrt/string/i386/strncpy.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strncpy - copy at most n characters of string ;*** @@ -55,95 +57,96 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public strncpy -strncpy proc \ - dest:ptr byte, \ - source:ptr byte, \ - count:dword + public _strncpy +.PROC _strncpy + // dest:ptr byte, \ + // source:ptr byte, \ + // count:dword
- OPTION PROLOGUE:NONE, EPILOGUE:NONE + //OPTION PROLOGUE:NONE, EPILOGUE:NONE
- .FPO ( 0, 3, 0, 0, 0, 0 ) + FPO 0, 3, 0, 0, 0, 0
- mov ecx,[esp + 0ch] ; ecx = count - push edi ; preserve edi + mov ecx,[esp + HEX(0c)] // ecx = count + push edi // preserve edi test ecx,ecx - jz finish ; leave if count is zero + jz finish // leave if count is zero
- push esi ; preserve edi - push ebx ; preserve ebx - mov ebx,ecx ; store count for tail loop - mov esi,[esp + 14h] ; esi -> source string - test esi,3 ; test if source string is aligned on 32 bits - mov edi,[esp + 10h] ; edi -> dest string - jnz short src_misaligned ; (almost always source is aligned) + push esi // preserve edi + push ebx // preserve ebx + mov ebx,ecx // store count for tail loop + mov esi,[esp + HEX(14)] // esi -> source string + test esi,3 // test if source string is aligned on 32 bits + mov edi,[esp + HEX(10)] // edi -> dest string + jnz short src_misaligned // (almost always source is aligned)
- shr ecx,2 ; convert ecx to dword count + shr ecx,2 // convert ecx to dword count jnz main_loop_entrance - jmp short copy_tail_loop ; 0 < count < 4 + jmp short copy_tail_loop // 0 < count < 4
-; simple byte loop until string is aligned +// simple byte loop until string is aligned
src_misaligned: - mov al,byte ptr [esi] ; copy a byte from source to dest + mov al,byte ptr [esi] // copy a byte from source to dest add esi,1 mov [edi],al add edi,1 sub ecx,1 - jz fill_tail_end1 ; if count == 0, leave - test al,al ; was last copied byte zero? - jz short align_dest ; if so, go align dest and pad it out - ; with zeros - test esi,3 ; esi already aligned ? + jz fill_tail_end1 // if count == 0, leave + test al,al // was last copied byte zero? + jz short align_dest // if so, go align dest and pad it out + // with zeros + test esi,3 // esi already aligned ? jne short src_misaligned - mov ebx,ecx ; store count for tail loop + mov ebx,ecx // store count for tail loop shr ecx,2 jnz short main_loop_entrance
tail_loop_start: - and ebx,3 ; ebx = count_before_main_loop%4 - jz short fill_tail_end1 ; if ebx == 0 then leave without - ; appending a null byte + and ebx,3 // ebx = count_before_main_loop%4 + jz short fill_tail_end1 // if ebx == 0 then leave without + // appending a null byte
-; while ( EOS (end-of-string) not found and count > 0 ) copy bytes +// while ( EOS (end-of-string) not found and count > 0 ) copy bytes
copy_tail_loop: - mov al,byte ptr [esi] ; load byte from source + mov al,byte ptr [esi] // load byte from source add esi,1 - mov [edi],al ; store byte to dest + mov [edi],al // store byte to dest add edi,1 - test al,al ; EOS found? - je short fill_tail_zero_bytes ; '\0' was already copied + test al,al // EOS found? + je short fill_tail_zero_bytes // '\0' was already copied sub ebx,1 jnz copy_tail_loop fill_tail_end1: - mov eax,[esp + 10h] ; prepare return value + mov eax,[esp + HEX(10)] // prepare return value pop ebx pop esi pop edi ret
-; EOS found. Pad with null characters to length count +// EOS found. Pad with null characters to length count
align_dest: - test edi,3 ; dest string aligned? + test edi,3 // dest string aligned? jz dest_align_loop_end dest_align_loop: mov [edi],al add edi,1 - sub ecx,1 ; count == 0? - jz fill_tail_end ; if so, finished - test edi,3 ; is edi aligned ? + sub ecx,1 // count == 0? + jz fill_tail_end // if so, finished + test edi,3 // is edi aligned ? jnz dest_align_loop dest_align_loop_end: - mov ebx,ecx ; ebx > 0 - shr ecx,2 ; convert ecx to count of dwords + mov ebx,ecx // ebx > 0 + shr ecx,2 // convert ecx to count of dwords jnz fill_dwords_with_EOS - ; pad tail bytes -finish_loop: ; 0 < ebx < 4 + // pad tail bytes +finish_loop: // 0 < ebx < 4 mov [edi],al add edi,1 fill_tail_zero_bytes: @@ -152,68 +155,68 @@ fill_tail_zero_bytes: pop ebx pop esi finish: - mov eax,[esp + 8] ; return in eax pointer to dest string + mov eax,[esp + 8] // return in eax pointer to dest string pop edi ret
-; copy (source) string to (dest). Also look for end of (source) string +// copy (source) string to (dest). Also look for end of (source) string
-main_loop: ; edx contains first dword of source string - mov [edi],edx ; store one more dword - add edi,4 ; kick dest pointer +main_loop: // edx contains first dword of source string + mov [edi],edx // store one more dword + add edi,4 // kick dest pointer sub ecx,1 jz tail_loop_start
main_loop_entrance: - mov edx,7efefeffh - mov eax,dword ptr [esi] ; read 4 bytes (dword) + mov edx,HEX(7efefeff) + mov eax,dword ptr [esi] // read 4 bytes (dword) add edx,eax xor eax,-1 xor eax,edx - mov edx,[esi] ; it's in cache now - add esi,4 ; kick dest pointer - test eax,81010100h + mov edx,[esi] // it's in cache now + add esi,4 // kick dest pointer + test eax,HEX(81010100) je short main_loop
- ; may have found zero byte in the dword + // may have found zero byte in the dword
- test dl,dl ; is it byte 0 + test dl,dl // is it byte 0 je short byte_0 - test dh,dh ; is it byte 1 + test dh,dh // is it byte 1 je short byte_1 - test edx,00ff0000h ; is it byte 2 + test edx,HEX(00ff0000) // is it byte 2 je short byte_2 - test edx,0ff000000h ; is it byte 3 - jne short main_loop ; taken if bits 24-30 are clear and bit - ; 31 is set + test edx,HEX(0ff000000) // is it byte 3 + jne short main_loop // taken if bits 24-30 are clear and bit + // 31 is set
-; a null character was found, so dest needs to be padded out with null chars -; to count length. +// a null character was found, so dest needs to be padded out with null chars +// to count length.
mov [edi],edx jmp short fill_with_EOS_dwords
byte_2: - and edx,0ffffh ; fill high 2 bytes with 0 + and edx,HEX(0ffff) // fill high 2 bytes with 0 mov [edi],edx jmp short fill_with_EOS_dwords
byte_1: - and edx,0ffh ; fill high 3 bytes with 0 + and edx,HEX(0ff) // fill high 3 bytes with 0 mov [edi],edx jmp short fill_with_EOS_dwords
byte_0: - xor edx,edx ; fill whole dword with 0 + xor edx,edx // fill whole dword with 0 mov [edi],edx
-; End of string was found. Pad out dest string with dwords of 0 +// End of string was found. Pad out dest string with dwords of 0
-fill_with_EOS_dwords: ; ecx > 0 (ecx is dword counter) +fill_with_EOS_dwords: // ecx > 0 (ecx is dword counter) add edi,4 - xor eax,eax ; it is instead of ??????????????????? + xor eax,eax // it is instead of ??????????????????? sub ecx,1 - jz fill_tail ; we filled all dwords + jz fill_tail // we filled all dwords
fill_dwords_with_EOS: xor eax,eax @@ -222,17 +225,17 @@ fill_with_EOS_loop: add edi,4 sub ecx,1 jnz short fill_with_EOS_loop -fill_tail: ; let's pad tail bytes with zero - and ebx,3 ; ebx = ebx % 4 - jnz finish_loop ; taken, when there are some tail bytes +fill_tail: // let's pad tail bytes with zero + and ebx,3 // ebx = ebx % 4 + jnz finish_loop // taken, when there are some tail bytes fill_tail_end: - mov eax,[esp + 10h] + mov eax,[esp + HEX(10)] pop ebx pop esi pop edi ret
-strncpy endp +.ENDP // _strncpy end
diff --git a/sdk/lib/ucrt/string/i386/strnset.s b/sdk/lib/ucrt/string/i386/strnset.s index 8e999122f35..f2caef4a36e 100644 --- a/sdk/lib/ucrt/string/i386/strnset.s +++ b/sdk/lib/ucrt/string/i386/strnset.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strnset - set first n characters to one char. ;*** @@ -50,40 +52,49 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public _strnset -_strnset proc \ - uses edi ebx, \ - string:ptr byte, \ - val:byte, \ - count:IWORD + public __strnset +.PROC __strnset +// Prolog. Original sources used ML's extended PROC feature to autogenerate this. + push ebp + mov ebp, esp + push edi // uses edi ebx + push ebx + #define string ebp + 8 // string:ptr byte + #define val ebp + 12 // val:byte + #define count ebp + 16 // count:IWORD
- mov edi,[string] ; di = string - mov edx,edi ; dx=string addr; save return value - mov ebx,[count] ; cx = max chars to set - xor eax,eax ; null byte + mov edi,[string] // di = string + mov edx,edi // dx=string addr; save return value + mov ebx,[count] // cx = max chars to set + xor eax,eax // null byte mov ecx,ebx - jecxz short done ; zero length specified + jecxz short done // zero length specified
-repne scasb ; find null byte & count bytes in cx - jne short nonull ; null not found - add ecx,1 ; don't want the null +repne scasb // find null byte & count bytes in cx + jne short nonull // null not found + add ecx,1 // don't want the null
nonull: - sub ebx,ecx ; bx=strlen (not null) - mov ecx,ebx ; cx=strlen (not null) + sub ebx,ecx // bx=strlen (not null) + mov ecx,ebx // cx=strlen (not null)
- mov edi,edx ; restore string pointer - mov al,val ; byte value -rep stosb ; fill 'er up + mov edi,edx // restore string pointer + mov al,[val] // byte value +rep stosb // fill 'er up
done: - mov eax,edx ; return value: string addr + mov eax,edx // return value: string addr
- ret ; _cdecl return +// Epilog. Original sources used ML's extended PROC feature to autogenerate this. + pop ebx + pop edi + pop ebp + ret // _cdecl return
-_strnset endp +.ENDP // __strnset end diff --git a/sdk/lib/ucrt/string/i386/strpbrk.s b/sdk/lib/ucrt/string/i386/strpbrk.s index 7bf1693bec8..9fa023abc53 100644 --- a/sdk/lib/ucrt/string/i386/strpbrk.s +++ b/sdk/lib/ucrt/string/i386/strpbrk.s @@ -1,3 +1,4 @@ +#if 0 ;*** ;strpbrk.asm - ; @@ -14,3 +15,7 @@
SSTRPBRK EQU 1 INCLUDE STRSPN.ASM +#else +#define SSTRPBRK 1 +#include "strspn.s" +#endif diff --git a/sdk/lib/ucrt/string/i386/strrev.s b/sdk/lib/ucrt/string/i386/strrev.s index 538fb257bd4..b96dc900a2b 100644 --- a/sdk/lib/ucrt/string/i386/strrev.s +++ b/sdk/lib/ucrt/string/i386/strrev.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strrev - reverse a string in place ;*** @@ -63,43 +65,52 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public _strrev -_strrev proc \ - uses edi esi, \ - string:ptr byte + public __strrev +.PROC __strrev +// Prolog. Original sources used ML's extended PROC feature to autogenerate this. + push ebp + mov ebp, esp + push edi // uses edi esi + push esi +#define string ebp + 8 // string:ptr byte
- mov edi,[string] ; di = string - mov edx,edi ; dx=pointer to string; save return value + mov edi,[string] // di = string + mov edx,edi // dx=pointer to string; save return value
- mov esi,edi ; si=pointer to string - xor eax,eax ; search value (null) - or ecx,-1 ; cx = -1 -repne scasb ; find null - cmp ecx,-2 ; is string empty? (if offset value is 0, the - je short done ; cmp below will not catch it and we'll hang). + mov esi,edi // si=pointer to string + xor eax,eax // search value (null) + or ecx,-1 // cx = -1 +repne scasb // find null + cmp ecx,-2 // is string empty? (if offset value is 0, the + je short done // cmp below will not catch it and we'll hang).
- sub edi,2 ; string is not empty, move di pointer back - ; di points to last non-null byte + sub edi,2 // string is not empty, move di pointer back + // di points to last non-null byte
lupe: - cmp esi,edi ; see if pointers have crossed yet - jae short done ; exit when pointers meet (or cross) + cmp esi,edi // see if pointers have crossed yet + jae short done // exit when pointers meet (or cross)
- mov ah,[esi] ; get front byte... - mov al,[edi] ; and end byte - mov [esi],al ; put end byte in front... - mov [edi],ah ; and front byte at end - add esi,1 ; front moves up... - sub edi,1 ; and end moves down - jmp short lupe ; keep switching bytes + mov ah,[esi] // get front byte... + mov al,[edi] // and end byte + mov [esi],al // put end byte in front... + mov [edi],ah // and front byte at end + add esi,1 // front moves up... + sub edi,1 // and end moves down + jmp short lupe // keep switching bytes
done: - mov eax,edx ; return value: string addr + mov eax,edx // return value: string addr
- ret ; _cdecl return +// Epilog. Original sources used ML's extended PROC feature to autogenerate this. + pop esi + pop edi + pop ebp + ret // _cdecl return
-_strrev endp +.ENDP // __strrev end diff --git a/sdk/lib/ucrt/string/i386/strset.s b/sdk/lib/ucrt/string/i386/strset.s index 9f674bf0330..72d2e345f8e 100644 --- a/sdk/lib/ucrt/string/i386/strset.s +++ b/sdk/lib/ucrt/string/i386/strset.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strset - set all characters of string to character ;*** @@ -48,31 +50,39 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
- CODESEG + .code
- public _strset -_strset proc \ - uses edi, \ - string:ptr byte, \ - val:byte + public __strset +.PROC __strset +// Prolog. Original sources used ML's extended PROC feature to autogenerate this. + push ebp + mov ebp, esp + push edi // uses edi +#define string ebp + 8 // string:ptr byte +#define val ebp + 12 // val:byte
- mov edi,[string] ; di = string - mov edx,edi ; dx=string addr; save return value + mov edi,[string] // di = string + mov edx,edi // dx=string addr; save return value
- xor eax,eax ; ax = 0 - or ecx,-1 ; cx = -1 -repne scasb ; scan string & count bytes - add ecx,2 ; cx=-strlen - neg ecx ; cx=strlen - mov al,[val] ; al = byte value to store - mov edi,edx ; di=string addr + xor eax,eax // ax = 0 + or ecx,-1 // cx = -1 +repne scasb // scan string & count bytes + add ecx,2 // cx=-strlen + neg ecx // cx=strlen + mov al,[val] // al = byte value to store + mov edi,edx // di=string addr rep stosb
- mov eax,edx ; return value: string addr + mov eax,edx // return value: string addr
- ret ; _cdecl return +// Epilog. Original sources used ML's extended PROC feature to autogenerate this. + pop edi + pop ebp
-_strset endp + ret // _cdecl return + +.ENDP // __strset end diff --git a/sdk/lib/ucrt/string/i386/strspn.s b/sdk/lib/ucrt/string/i386/strspn.s index 3f89a15ce75..384325092e4 100644 --- a/sdk/lib/ucrt/string/i386/strspn.s +++ b/sdk/lib/ucrt/string/i386/strspn.s @@ -1,3 +1,5 @@ +#include <asm.inc> +#if 0 page ,132 title strspn - search for init substring of chars from control str ;*** @@ -165,54 +167,58 @@ page ;Exceptions: ; ;******************************************************************************* +#endif
-ifdef SSTRCSPN +#ifdef SSTRCSPN
- _STRSPN_ equ <strcspn> + #define _STRSPN_ _strcspn
-elseifdef SSTRPBRK +#elif defined(SSTRPBRK)
- _STRSPN_ equ <strpbrk> + #define _STRSPN_ _strpbrk
-else ; SSTRCSPN +#else // SSTRCSPN
-; Default is to build strspn() +// Default is to build strspn()
- SSTRSPN equ 1 - _STRSPN_ equ <strspn> + #define SSTRSPN 1 + #define _STRSPN_ _strspn
-endif ; SSTRCSPN +#endif // SSTRCSPN
-% public _STRSPN_ +public _STRSPN_
- CODESEG + .code
-_STRSPN_ proc \ - uses esi, \ - string:ptr byte, \ - control:ptr byte +.PROC _STRSPN_ +// Prolog. Original sources used ML's extended PROC feature to autogenerate this. + push ebp + mov ebp, esp + push esi // uses esi +#define string ebp + 8 // string:ptr byte +#define control ebp + 12 // control:ptr byte
-; create and zero out char bit map +// create and zero out char bit map
xor eax,eax - push eax ; 32 + push eax // 32 push eax push eax - push eax ; 128 + push eax // 128 push eax push eax push eax - push eax ; 256 + push eax // 256
-map equ [esp] +#define map [esp]
-; Set control char bits in map +// Set control char bits in map
- mov edx,control ; si = control string + mov edx,[control] // si = control string
- align @WordSize -lab listnext ; init char bit map + align 4 // @WordSize +listnext: // init char bit map mov al,[edx] or al,al jz short listdone @@ -220,18 +226,22 @@ lab listnext ; init char bit map bts map,eax jmp short listnext
-lab listdone +listdone:
-; Loop through comparing source string with control bits +// Loop through comparing source string with control bits
- mov esi,string ; si = string + mov esi,[string] // si = string
-_ifnd SSTRPBRK, <or ecx,-1> ; set ecx to -1 +#ifndef SSTRPBRK + or ecx,-1 // set ecx to -1 +#endif
- align @WordSize -lab dstnext + align 4 // @WordSize +dstnext:
-_ifnd SSTRPBRK, <add ecx,1> +#ifndef SSTRPBRK + add ecx,1 +#endif
mov al,[esi] or al,al @@ -239,24 +249,30 @@ _ifnd SSTRPBRK, <add ecx,1> add esi,1 bt map, eax
-ifdef SSTRSPN - jc short dstnext ; strspn: found char, continue -elseifdef SSTRCSPN - jnc short dstnext ; strcspn: did not find char, continue -elseifdef SSTRPBRK - jnc short dstnext ; strpbrk: did not find char, continue - lea eax,[esi - 1] ; found char, return address of it -endif ; SSTRSPN +#ifdef SSTRSPN + jc short dstnext // strspn: found char, continue +#elif defined SSTRCSPN + jnc short dstnext // strcspn: did not find char, continue +#elif defined SSTRPBRK + jnc short dstnext // strpbrk: did not find char, continue + lea eax,[esi - 1] // found char, return address of it +#endif // SSTRSPN
-; Return code +// Return code
-lab dstdone +dstdone:
-_ifnd SSTRPBRK, <mov eax,ecx> ; strspn/strcspn: return index +#ifndef SSTRPBRK + mov eax,ecx // strspn/strcspn: return index +#endif
add esp,32
- ret ; _cdecl return +// Epilog. Original sources used ML's extended PROC feature to autogenerate this. + pop esi + pop ebp
-_STRSPN_ endp + ret // _cdecl return + +.ENDP // _STRSPN_ end
-
Timo Kreuzer