mirror of
https://github.com/MariaDB/server.git
synced 2025-10-30 04:26:45 +03:00
417 lines
8.9 KiB
ArmAsm
417 lines
8.9 KiB
ArmAsm
# Copyright (C) 2000 MySQL AB
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; version 2 of the License.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
# Optimized string functions Intel 80x86 (gcc/gas syntax)
|
|
|
|
.file "strings.s"
|
|
.version "1.00"
|
|
|
|
.text
|
|
|
|
# Move a alligned, not overlapped, by (long) divided memory area
|
|
# Args: to,from,length
|
|
|
|
.globl bmove_align
|
|
.type bmove_align,@function
|
|
bmove_align:
|
|
movl %edi,%edx
|
|
push %esi
|
|
movl 4(%esp),%edi # to
|
|
movl 8(%esp),%esi # from
|
|
movl 12(%esp),%ecx # length
|
|
addw $3,%cx # fix if not divisible with long
|
|
shrw $2,%cx
|
|
jz .ba_20
|
|
.p2align 4,,7
|
|
.ba_10:
|
|
movl -4(%esi,%ecx),%eax
|
|
movl %eax,-4(%edi,%ecx)
|
|
decl %ecx
|
|
jnz .ba_10
|
|
.ba_20: pop %esi
|
|
movl %edx,%edi
|
|
ret
|
|
|
|
.bmove_align_end:
|
|
.size bmove_align,.bmove_align_end-bmove_align
|
|
|
|
# Move a string from higher to lower
|
|
# Arg from_end+1,to_end+1,length
|
|
|
|
.globl bmove_upp
|
|
.type bmove_upp,@function
|
|
bmove_upp:
|
|
movl %edi,%edx # Remember %edi
|
|
push %esi
|
|
movl 8(%esp),%edi # dst
|
|
movl 16(%esp),%ecx # length
|
|
movl 12(%esp),%esi # source
|
|
test %ecx,%ecx
|
|
jz .bu_20
|
|
subl %ecx,%esi # To start of strings
|
|
subl %ecx,%edi
|
|
|
|
.p2align 4,,7
|
|
.bu_10: movb -1(%esi,%ecx),%al
|
|
movb %al,-1(%edi,%ecx)
|
|
decl %ecx
|
|
jnz .bu_10
|
|
.bu_20: pop %esi
|
|
movl %edx,%edi
|
|
ret
|
|
|
|
.bmove_upp_end:
|
|
.size bmove_upp,.bmove_upp_end-bmove_upp
|
|
|
|
# Append fillchars to string
|
|
# Args: dest,len,fill
|
|
|
|
.globl strappend
|
|
.type strappend,@function
|
|
strappend:
|
|
pushl %edi
|
|
movl 8(%esp),%edi # Memory pointer
|
|
movl 12(%esp),%ecx # Length
|
|
clrl %eax # Find end of string
|
|
repne
|
|
scasb
|
|
jnz sa_99 # String to long, shorten it
|
|
movzb 16(%esp),%eax # Fillchar
|
|
decl %edi # Point at end null
|
|
incl %ecx # rep made one dec for null-char
|
|
|
|
movb %al,%ah # (2) Set up a 32 bit pattern.
|
|
movw %ax,%dx # (2)
|
|
shll $16,%eax # (3)
|
|
movw %dx,%ax # (2) %eax has the 32 bit pattern.
|
|
|
|
movl %ecx,%edx # (2) Save the count of bytes.
|
|
shrl $2,%ecx # (2) Number of dwords.
|
|
rep
|
|
stosl # (5 + 5n)
|
|
movb $3,%cl # (2)
|
|
and %edx,%ecx # (2) Fill in the odd bytes
|
|
rep
|
|
stosb # Move last bytes if any
|
|
|
|
sa_99: movb $0,(%edi) # End of string
|
|
popl %edi
|
|
ret
|
|
.strappend_end:
|
|
.size strappend,.strappend_end-strappend
|
|
|
|
# Find if string contains any char in another string
|
|
# Arg: str,set
|
|
# Ret: Pointer to first found char in str
|
|
|
|
.globl strcont
|
|
.type strcont,@function
|
|
strcont:
|
|
movl %edi,%edx
|
|
pushl %esi
|
|
movl 8(%esp),%esi # str
|
|
movl 12(%esp),%ecx # set
|
|
clrb %ah # For endtest
|
|
jmp sc_60
|
|
|
|
sc_10: scasb
|
|
jz sc_fo # Found char
|
|
sc_20: cmp (%edi),%ah # Test if null
|
|
jnz sc_10 # Not end of set yet
|
|
incl %esi # Next char in str
|
|
sc_60: movl %ecx,%edi # %edi = Set
|
|
movb (%esi),%al # Test if this char exist
|
|
andb %al,%al
|
|
jnz sc_20 # Not end of string
|
|
clrl %esi # Return Null
|
|
sc_fo: movl %esi,%eax # Char found here
|
|
movl %edx,%edi # Restore
|
|
popl %esi
|
|
ret
|
|
.strcont_end:
|
|
.size strcont,.strcont_end-strcont
|
|
|
|
# Find end of string
|
|
# Arg: str
|
|
# ret: Pointer to end null
|
|
|
|
.globl strend
|
|
.type strend,@function
|
|
strend:
|
|
movl %edi,%edx # Save
|
|
movl 4(%esp),%edi # str
|
|
clrl %eax # Find end of string
|
|
movl %eax,%ecx
|
|
decl %ecx # ECX = -1
|
|
repne
|
|
scasb
|
|
movl %edi,%eax
|
|
decl %eax # End of string
|
|
movl %edx,%edi # Restore
|
|
ret
|
|
.strend_end:
|
|
.size strend,.strend_end-strend
|
|
|
|
# Make a string with len fill-chars and endnull
|
|
# Args: dest,len,fill
|
|
# Ret: dest+len
|
|
|
|
.globl strfill
|
|
.type strfill,@function
|
|
strfill:
|
|
pushl %edi
|
|
movl 8(%esp),%edi # Memory pointer
|
|
movl 12(%esp),%ecx # Length
|
|
movzb 16(%esp),%eax # Fill
|
|
|
|
movb %al,%ah # (2) Set up a 32 bit pattern
|
|
movw %ax,%dx # (2)
|
|
shll $16,%eax # (3)
|
|
movw %dx,%ax # (2) %eax has the 32 bit pattern.
|
|
|
|
movl %ecx,%edx # (2) Save the count of bytes.
|
|
shrl $2,%ecx # (2) Number of dwords.
|
|
rep
|
|
stosl # (5 + 5n)
|
|
movb $3,%cl # (2)
|
|
and %edx,%ecx # (2) Fill in the odd bytes
|
|
rep
|
|
stosb # Move last bytes if any
|
|
|
|
movb %cl,(%edi) # End NULL
|
|
movl %edi,%eax # End i %eax
|
|
popl %edi
|
|
ret
|
|
.strfill_end:
|
|
.size strfill,.strfill_end-strfill
|
|
|
|
|
|
# Find a char in or end of a string
|
|
# Arg: str,char
|
|
# Ret: pointer to found char or NullS
|
|
|
|
.globl strcend
|
|
.type strcend,@function
|
|
strcend:
|
|
movl %edi,%edx
|
|
movl 4(%esp),%edi # str
|
|
movb 8(%esp),%ah # search
|
|
clrb %al # for scasb to find end
|
|
|
|
se_10: cmpb (%edi),%ah
|
|
jz se_20 # Found char
|
|
scasb
|
|
jnz se_10 # Not end
|
|
dec %edi # Not found, point at end of string
|
|
se_20: movl %edi,%eax
|
|
movl %edx,%edi # Restore
|
|
ret
|
|
.strcend_end:
|
|
.size strcend,.strcend_end-strcend
|
|
|
|
# Test if string has a given suffix
|
|
|
|
.globl is_prefix
|
|
.type is_prefix,@function
|
|
is_prefix:
|
|
movl %edi,%edx # Save %edi
|
|
pushl %esi # and %esi
|
|
movl 12(%esp),%esi # get suffix
|
|
movl 8(%esp),%edi # s1
|
|
movl $1,%eax # Ok and zero-test
|
|
ip_10: cmpb (%esi),%ah
|
|
jz suf_ok # End of string/ found suffix
|
|
cmpsb # Compare strings
|
|
jz ip_10 # Same, possible prefix
|
|
xor %eax,%eax # Not suffix
|
|
suf_ok: popl %esi
|
|
movl %edx,%edi
|
|
ret
|
|
.is_prefix_end:
|
|
.size is_prefix,.is_prefix_end-is_prefix
|
|
|
|
# Find a substring in string
|
|
# Arg: str,search
|
|
|
|
.globl strstr
|
|
.type strstr,@function
|
|
|
|
strstr:
|
|
pushl %edi
|
|
pushl %esi
|
|
movl 12(%esp),%esi # str
|
|
movl 16(%esp),%edi # search
|
|
movl %edi,%ecx
|
|
incl %ecx # %ecx = search+1
|
|
movb (%edi),%ah # %ah = First char in search
|
|
jmp sf_10
|
|
|
|
sf_00: movl %edx,%esi # si = Current str-pos
|
|
sf_10: movb (%esi),%al # Test if this char exist
|
|
andb %al,%al
|
|
jz sf_90 # End of string, didn't find search
|
|
incl %esi
|
|
cmpb %al,%ah
|
|
jnz sf_10 # Didn't find first char, continue
|
|
movl %esi,%edx # Save str-pos in %edx
|
|
movl %ecx,%edi
|
|
sf_20: cmpb $0,(%edi)
|
|
jz sf_fo # Found substring
|
|
cmpsb
|
|
jz sf_20 # Char ok
|
|
jmp sf_00 # Next str-pos
|
|
|
|
sf_90: movl $1,%edx # Return Null
|
|
sf_fo: movl %edx,%eax # Char found here
|
|
decl %eax # Pointed one after
|
|
popl %esi
|
|
popl %edi
|
|
ret
|
|
.strstr_end:
|
|
.size strstr,.strstr_end-strstr
|
|
|
|
|
|
# Find a substring in string, return index
|
|
# Arg: str,search
|
|
|
|
.globl strinstr
|
|
.type strinstr,@function
|
|
|
|
strinstr:
|
|
pushl %ebp
|
|
movl %esp,%ebp
|
|
pushl 12(%ebp) # search
|
|
pushl 8(%ebp) # str
|
|
call strstr
|
|
add $8,%esp
|
|
or %eax,%eax
|
|
jz si_99 # Not found, return NULL
|
|
sub 8(%ebp),%eax # Pos from start
|
|
inc %eax # And first pos = 1
|
|
si_99: popl %ebp
|
|
ret
|
|
.strinstr_end:
|
|
.size strinstr,.strinstr_end-strinstr
|
|
|
|
# Make a string of len length from another string
|
|
# Arg: dst,src,length
|
|
# ret: end of dst
|
|
|
|
.globl strmake
|
|
.type strmake,@function
|
|
|
|
strmake:
|
|
pushl %edi
|
|
pushl %esi
|
|
mov 12(%esp),%edi # dst
|
|
movl $0,%edx
|
|
movl 20(%esp),%ecx # length
|
|
movl 16(%esp),%esi # src
|
|
cmpl %edx,%ecx
|
|
jz sm_90
|
|
sm_00: movb (%esi,%edx),%al
|
|
cmpb $0,%al
|
|
jz sm_90
|
|
movb %al,(%edi,%edx)
|
|
incl %edx
|
|
cmpl %edx,%ecx
|
|
jnz sm_00
|
|
sm_90: movb $0,(%edi,%edx)
|
|
sm_99: lea (%edi,%edx),%eax # Return pointer to end null
|
|
pop %esi
|
|
pop %edi
|
|
ret
|
|
.strmake_end:
|
|
.size strmake,.strmake_end-strmake
|
|
|
|
# Move a string with max len chars
|
|
# arg: dst,src,len
|
|
# ret: pos to first null or dst+len
|
|
|
|
.globl strnmov
|
|
.type strnmov,@function
|
|
strnmov:
|
|
pushl %edi
|
|
pushl %esi
|
|
movl 12(%esp),%edi # dst
|
|
movl 16(%esp),%esi # src
|
|
movl 20(%esp),%ecx # Length of memory-area
|
|
jecxz snm_99 # Nothing to do
|
|
clrb %al # For test of end-null
|
|
|
|
snm_10: cmpb (%esi),%al # Next char to move
|
|
movsb # move arg
|
|
jz snm_20 # last char, fill with null
|
|
loop snm_10 # Continue moving
|
|
incl %edi # Point two after last
|
|
snm_20: decl %edi # Point at first null (or last+1)
|
|
snm_99: movl %edi,%eax # Pointer at last char
|
|
popl %esi
|
|
popl %edi
|
|
ret
|
|
.strnmov_end:
|
|
.size strnmov,.strnmov_end-strnmov
|
|
|
|
|
|
.globl strmov
|
|
.type strmov,@function
|
|
strmov:
|
|
movl %esi,%ecx # Save old %esi and %edi
|
|
movl %edi,%edx
|
|
movl 8(%esp),%esi # get source pointer (s2)
|
|
movl 4(%esp),%edi # %edi -> s1
|
|
smo_10: movb (%esi),%al
|
|
movsb # move arg
|
|
andb %al,%al
|
|
jnz smo_10 # Not last
|
|
movl %edi,%eax
|
|
dec %eax
|
|
movl %ecx,%esi # Restore
|
|
movl %edx,%edi
|
|
ret
|
|
.strmov_end:
|
|
.size strmov,.strmov_end-strmov
|
|
|
|
.globl strxmov
|
|
.type strxmov,@function
|
|
strxmov:
|
|
movl %ebx,%edx # Save %ebx, %esi and %edi
|
|
mov %esi,%ecx
|
|
push %edi
|
|
leal 8(%esp),%ebx # Get destination
|
|
movl (%ebx),%edi
|
|
xorb %al,%al
|
|
jmp next_str # Handle source ebx+4
|
|
|
|
start_str:
|
|
movsb
|
|
cmpb -1(%edi),%al
|
|
jne start_str
|
|
decl %edi # Don't copy last null
|
|
|
|
next_str:
|
|
addl $4,%ebx
|
|
movl (%ebx),%esi
|
|
orl %esi,%esi
|
|
jne start_str
|
|
movb %al,0(%edi) # Force last to ASCII 0
|
|
|
|
movl %edi,%eax # Return ptr to ASCII 0
|
|
pop %edi # Restore registers
|
|
movl %ecx,%esi
|
|
movl %edx,%ebx
|
|
ret
|
|
.strxmov_end:
|
|
.size strxmov,.strxmov_end-strxmov
|