~drizzle-trunk/drizzle/development

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
# 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 longlong2str function for Intel 80x86  (gcc/gas syntax) 
# Some set sequences are optimized for pentuimpro II 

	.file	"longlong2str-x86.s"
	.version "1.02"

.text
	.align 4

.globl	longlong2str_with_dig_vector
	.type	 longlong2str_with_dig_vector,@function
	
longlong2str_with_dig_vector:
	subl  $80,%esp          # Temporary buffer for up to 64 radix-2 digits
	pushl %ebp
	pushl %esi
	pushl %edi
	pushl %ebx
	movl 100(%esp),%esi	# esi = Lower part of val 
	movl 112(%esp),%ebx	# ebx = Radix 
	movl 104(%esp),%ebp	# ebp = Higher part of val 
	movl 108(%esp),%edi	# edi = dst

	testl %ebx,%ebx
	jge .L144		# Radix was positive
	negl %ebx		# Change radix to positive 
	testl %ebp,%ebp		# Test if given value is negative
	jge .L144
	movb $45,(%edi)		# Add sign 
	incl %edi		# Change sign of val 
	negl %esi
	adcl $0,%ebp
	negl %ebp
	
.L144:	# Test that radix is between 2 and 36
	movl %ebx, %eax
	addl $-2,%eax		# Test that radix is between 2 and 36
	cmpl $34,%eax
	ja .Lerror		# Radix was not in range

	leal 92(%esp),%ecx	# End of buffer 
	movl %edi, 108(%esp)    # Store possible modified dest
	movl 116(%esp), %edi    # dig_vec_upper
	testl %ebp,%ebp		# Test if value > 0xFFFFFFFF
	jne .Llongdiv
	cmpl %ebx, %esi		# Test if <= radix, for easy loop
	movl %esi, %eax		# Value in eax (for Llow)
	jae .Llow

	# Value is one digit (negative or positive)
	movb (%eax,%edi),%bl
	movl 108(%esp),%edi	# get dst
	movb %bl,(%edi)
	incl %edi		# End null here
	jmp .L10_end

.Llongdiv:
	# Value in ebp:esi. div the high part by the radix,
        # then div remainder + low part by the radix.
	movl %ebp,%eax		# edx=0,eax=high(from ebp)
	xorl %edx,%edx
	decl %ecx
	divl %ebx
	movl %eax,%ebp		# edx=result of last, eax=low(from esi)
	movl %esi,%eax
	divl %ebx
	movl %eax,%esi		# ebp:esi = quotient
	movb (%edx,%edi),%dl	# Store result number in temporary buffer
	testl %ebp,%ebp
	movb %dl,(%ecx)		# store value in buff 
	ja .Llongdiv		# (Higher part of val still > 0)
	
	.align 4
.Llow:				# Do rest with integer precision 
	# Value in 0:eax. div 0 + low part by the radix.
	xorl  %edx,%edx
	decl %ecx
	divl %ebx
	movb (%edx,%edi),%dl	# bh is always zero as ebx=radix < 36 
	testl %eax,%eax
	movb %dl,(%ecx)
	jne .Llow

.L160:
	movl 108(%esp),%edi	# get dst 

.Lcopy_end:	
	leal 92(%esp),%esi	# End of buffer 
.Lmov:				# mov temporary buffer to result (%ecx -> %edi)
	movb (%ecx), %al
	movb %al, (%edi)
	incl %ecx
	incl %edi
	cmpl  %ecx,%esi
	jne  .Lmov

.L10_end:
	movl %edi,%eax		# Pointer to end null 
	movb $0,(%edi)		# Store the end null 

.L165:
	popl %ebx
	popl %edi
	popl %esi
	popl %ebp
	addl $80,%esp
	ret

.Lerror:
	xorl %eax,%eax		# Wrong radix 
	jmp .L165

.Lfe3:
	.size	 longlong2str_with_dig_vector,.Lfe3-longlong2str_with_dig_vector

#
# This is almost equal to the above, except that we can do the final
# loop much more efficient	
#	

	.align 4
	
.globl	longlong10_to_str
	.type	 longlong10_to_str,@function
longlong10_to_str:
	subl $80,%esp
	pushl %ebp
	pushl %esi
	pushl %edi
	pushl %ebx
	movl 100(%esp),%esi	# Lower part of val 
	movl 104(%esp),%ebp	# Higher part of val 
	movl 108(%esp),%edi	# get dst 
	movl 112(%esp),%ebx	# Radix (10 or -10)
	testl %ebx,%ebx
	jge .L10_10		# Positive radix

	negl %ebx		# Change radix to positive (= 10)

	testl %ebp,%ebp		# Test if negative value
	jge .L10_10
	movb $45,(%edi)		# Add sign 
	incl %edi
	negl %esi		# Change sign of val (ebp:esi)
	adcl $0,%ebp
	negl %ebp

.L10_10:
	leal 92(%esp),%ecx	# End of buffer 
	testl %ebp,%ebp		# Test if value > 0xFFFFFFFF
	jne .L10_longdiv
	cmpl $10, %esi		# Test if <= radix, for easy loop
	movl %esi, %ebx		# Value in eax (for L10_low)
	jae .L10_low

	# Value is one digit (negative or positive)
	addb $48, %bl
	movb %bl,(%edi)
	incl %edi
	jmp .L10_end
	.align 4

.L10_longdiv:
	# val is stored in in ebp:esi 
	movl %ebp,%eax		# High part of value 
	xorl %edx,%edx
	divl %ebx		# Divide by 10
	movl %eax,%ebp
	movl %esi,%eax
	divl %ebx		# Divide by 10
	decl %ecx
	movl %eax,%esi		# quotent in ebp:esi 
	addl $48,%edx		# Convert to ascii
	movb %dl,(%ecx)		# store value in buff 

.L10_30:
	testl %ebp,%ebp
	ja .L10_longdiv
	movl %esi,%ebx		# Move val to %ebx

.L10_low:
	# The following code uses some tricks to change division by 10 to
	# multiplication and shifts
	movl $0xcccccccd,%esi
		
.L10_40:			# Divide %ebx with 10
        movl %ebx,%eax
        mull %esi
        decl %ecx
        shrl $3,%edx
        leal (%edx,%edx,4),%eax
        addl %eax,%eax
        subb %al,%bl		# %bl now contains val % 10
        addb $48,%bl
        movb %bl,(%ecx)
        movl %edx,%ebx
        testl %ebx,%ebx
	jne .L10_40
	jmp .Lcopy_end		# Shared end with longlong2str

.L10end:
	.size	 longlong10_to_str,.L10end-longlong10_to_str