|
0
|
1 ;; libgcc routines for the Renesas H8/300 CPU.
|
|
|
2 ;; Contributed by Steve Chamberlain <sac@cygnus.com>
|
|
|
3 ;; Optimizations by Toshiyasu Morita <toshiyasu.morita@renesas.com>
|
|
|
4
|
|
|
5 /* Copyright (C) 1994, 2000, 2001, 2002, 2003, 2004, 2009
|
|
|
6 Free Software Foundation, Inc.
|
|
|
7
|
|
|
8 This file is free software; you can redistribute it and/or modify it
|
|
|
9 under the terms of the GNU General Public License as published by the
|
|
|
10 Free Software Foundation; either version 3, or (at your option) any
|
|
|
11 later version.
|
|
|
12
|
|
|
13 This file is distributed in the hope that it will be useful, but
|
|
|
14 WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
16 General Public License for more details.
|
|
|
17
|
|
|
18 Under Section 7 of GPL version 3, you are granted additional
|
|
|
19 permissions described in the GCC Runtime Library Exception, version
|
|
|
20 3.1, as published by the Free Software Foundation.
|
|
|
21
|
|
|
22 You should have received a copy of the GNU General Public License and
|
|
|
23 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
24 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
25 <http://www.gnu.org/licenses/>. */
|
|
|
26
|
|
|
27 /* Assembler register definitions. */
|
|
|
28
|
|
|
29 #define A0 r0
|
|
|
30 #define A0L r0l
|
|
|
31 #define A0H r0h
|
|
|
32
|
|
|
33 #define A1 r1
|
|
|
34 #define A1L r1l
|
|
|
35 #define A1H r1h
|
|
|
36
|
|
|
37 #define A2 r2
|
|
|
38 #define A2L r2l
|
|
|
39 #define A2H r2h
|
|
|
40
|
|
|
41 #define A3 r3
|
|
|
42 #define A3L r3l
|
|
|
43 #define A3H r3h
|
|
|
44
|
|
|
45 #define S0 r4
|
|
|
46 #define S0L r4l
|
|
|
47 #define S0H r4h
|
|
|
48
|
|
|
49 #define S1 r5
|
|
|
50 #define S1L r5l
|
|
|
51 #define S1H r5h
|
|
|
52
|
|
|
53 #define S2 r6
|
|
|
54 #define S2L r6l
|
|
|
55 #define S2H r6h
|
|
|
56
|
|
|
57 #ifdef __H8300__
|
|
|
58 #define PUSHP push
|
|
|
59 #define POPP pop
|
|
|
60
|
|
|
61 #define A0P r0
|
|
|
62 #define A1P r1
|
|
|
63 #define A2P r2
|
|
|
64 #define A3P r3
|
|
|
65 #define S0P r4
|
|
|
66 #define S1P r5
|
|
|
67 #define S2P r6
|
|
|
68 #endif
|
|
|
69
|
|
|
70 #if defined (__H8300H__) || defined (__H8300S__) || defined (__H8300SX__)
|
|
|
71 #define PUSHP push.l
|
|
|
72 #define POPP pop.l
|
|
|
73
|
|
|
74 #define A0P er0
|
|
|
75 #define A1P er1
|
|
|
76 #define A2P er2
|
|
|
77 #define A3P er3
|
|
|
78 #define S0P er4
|
|
|
79 #define S1P er5
|
|
|
80 #define S2P er6
|
|
|
81
|
|
|
82 #define A0E e0
|
|
|
83 #define A1E e1
|
|
|
84 #define A2E e2
|
|
|
85 #define A3E e3
|
|
|
86 #endif
|
|
|
87
|
|
|
88 #ifdef __H8300H__
|
|
|
89 #ifdef __NORMAL_MODE__
|
|
|
90 .h8300hn
|
|
|
91 #else
|
|
|
92 .h8300h
|
|
|
93 #endif
|
|
|
94 #endif
|
|
|
95
|
|
|
96 #ifdef __H8300S__
|
|
|
97 #ifdef __NORMAL_MODE__
|
|
|
98 .h8300sn
|
|
|
99 #else
|
|
|
100 .h8300s
|
|
|
101 #endif
|
|
|
102 #endif
|
|
|
103 #ifdef __H8300SX__
|
|
|
104 #ifdef __NORMAL_MODE__
|
|
|
105 .h8300sxn
|
|
|
106 #else
|
|
|
107 .h8300sx
|
|
|
108 #endif
|
|
|
109 #endif
|
|
|
110
|
|
|
111 #ifdef L_cmpsi2
|
|
|
112 #ifdef __H8300__
|
|
|
113 .section .text
|
|
|
114 .align 2
|
|
|
115 .global ___cmpsi2
|
|
|
116 ___cmpsi2:
|
|
|
117 cmp.w A0,A2
|
|
|
118 bne .L2
|
|
|
119 cmp.w A1,A3
|
|
|
120 bne .L4
|
|
|
121 mov.w #1,A0
|
|
|
122 rts
|
|
|
123 .L2:
|
|
|
124 bgt .L5
|
|
|
125 .L3:
|
|
|
126 mov.w #2,A0
|
|
|
127 rts
|
|
|
128 .L4:
|
|
|
129 bls .L3
|
|
|
130 .L5:
|
|
|
131 sub.w A0,A0
|
|
|
132 rts
|
|
|
133 .end
|
|
|
134 #endif
|
|
|
135 #endif /* L_cmpsi2 */
|
|
|
136
|
|
|
137 #ifdef L_ucmpsi2
|
|
|
138 #ifdef __H8300__
|
|
|
139 .section .text
|
|
|
140 .align 2
|
|
|
141 .global ___ucmpsi2
|
|
|
142 ___ucmpsi2:
|
|
|
143 cmp.w A0,A2
|
|
|
144 bne .L2
|
|
|
145 cmp.w A1,A3
|
|
|
146 bne .L4
|
|
|
147 mov.w #1,A0
|
|
|
148 rts
|
|
|
149 .L2:
|
|
|
150 bhi .L5
|
|
|
151 .L3:
|
|
|
152 mov.w #2,A0
|
|
|
153 rts
|
|
|
154 .L4:
|
|
|
155 bls .L3
|
|
|
156 .L5:
|
|
|
157 sub.w A0,A0
|
|
|
158 rts
|
|
|
159 .end
|
|
|
160 #endif
|
|
|
161 #endif /* L_ucmpsi2 */
|
|
|
162
|
|
|
163 #ifdef L_divhi3
|
|
|
164
|
|
|
165 ;; HImode divides for the H8/300.
|
|
|
166 ;; We bunch all of this into one object file since there are several
|
|
|
167 ;; "supporting routines".
|
|
|
168
|
|
|
169 ; general purpose normalize routine
|
|
|
170 ;
|
|
|
171 ; divisor in A0
|
|
|
172 ; dividend in A1
|
|
|
173 ; turns both into +ve numbers, and leaves what the answer sign
|
|
|
174 ; should be in A2L
|
|
|
175
|
|
|
176 #ifdef __H8300__
|
|
|
177 .section .text
|
|
|
178 .align 2
|
|
|
179 divnorm:
|
|
|
180 or A0H,A0H ; is divisor > 0
|
|
|
181 stc ccr,A2L
|
|
|
182 bge _lab1
|
|
|
183 not A0H ; no - then make it +ve
|
|
|
184 not A0L
|
|
|
185 adds #1,A0
|
|
|
186 _lab1: or A1H,A1H ; look at dividend
|
|
|
187 bge _lab2
|
|
|
188 not A1H ; it is -ve, make it positive
|
|
|
189 not A1L
|
|
|
190 adds #1,A1
|
|
|
191 xor #0x8,A2L; and toggle sign of result
|
|
|
192 _lab2: rts
|
|
|
193 ;; Basically the same, except that the sign of the divisor determines
|
|
|
194 ;; the sign.
|
|
|
195 modnorm:
|
|
|
196 or A0H,A0H ; is divisor > 0
|
|
|
197 stc ccr,A2L
|
|
|
198 bge _lab7
|
|
|
199 not A0H ; no - then make it +ve
|
|
|
200 not A0L
|
|
|
201 adds #1,A0
|
|
|
202 _lab7: or A1H,A1H ; look at dividend
|
|
|
203 bge _lab8
|
|
|
204 not A1H ; it is -ve, make it positive
|
|
|
205 not A1L
|
|
|
206 adds #1,A1
|
|
|
207 _lab8: rts
|
|
|
208
|
|
|
209 ; A0=A0/A1 signed
|
|
|
210
|
|
|
211 .global ___divhi3
|
|
|
212 ___divhi3:
|
|
|
213 bsr divnorm
|
|
|
214 bsr ___udivhi3
|
|
|
215 negans: btst #3,A2L ; should answer be negative ?
|
|
|
216 beq _lab4
|
|
|
217 not A0H ; yes, so make it so
|
|
|
218 not A0L
|
|
|
219 adds #1,A0
|
|
|
220 _lab4: rts
|
|
|
221
|
|
|
222 ; A0=A0%A1 signed
|
|
|
223
|
|
|
224 .global ___modhi3
|
|
|
225 ___modhi3:
|
|
|
226 bsr modnorm
|
|
|
227 bsr ___udivhi3
|
|
|
228 mov A3,A0
|
|
|
229 bra negans
|
|
|
230
|
|
|
231 ; A0=A0%A1 unsigned
|
|
|
232
|
|
|
233 .global ___umodhi3
|
|
|
234 ___umodhi3:
|
|
|
235 bsr ___udivhi3
|
|
|
236 mov A3,A0
|
|
|
237 rts
|
|
|
238
|
|
|
239 ; A0=A0/A1 unsigned
|
|
|
240 ; A3=A0%A1 unsigned
|
|
|
241 ; A2H trashed
|
|
|
242 ; D high 8 bits of denom
|
|
|
243 ; d low 8 bits of denom
|
|
|
244 ; N high 8 bits of num
|
|
|
245 ; n low 8 bits of num
|
|
|
246 ; M high 8 bits of mod
|
|
|
247 ; m low 8 bits of mod
|
|
|
248 ; Q high 8 bits of quot
|
|
|
249 ; q low 8 bits of quot
|
|
|
250 ; P preserve
|
|
|
251
|
|
|
252 ; The H8/300 only has a 16/8 bit divide, so we look at the incoming and
|
|
|
253 ; see how to partition up the expression.
|
|
|
254
|
|
|
255 .global ___udivhi3
|
|
|
256 ___udivhi3:
|
|
|
257 ; A0 A1 A2 A3
|
|
|
258 ; Nn Dd P
|
|
|
259 sub.w A3,A3 ; Nn Dd xP 00
|
|
|
260 or A1H,A1H
|
|
|
261 bne divlongway
|
|
|
262 or A0H,A0H
|
|
|
263 beq _lab6
|
|
|
264
|
|
|
265 ; we know that D == 0 and N is != 0
|
|
|
266 mov.b A0H,A3L ; Nn Dd xP 0N
|
|
|
267 divxu A1L,A3 ; MQ
|
|
|
268 mov.b A3L,A0H ; Q
|
|
|
269 ; dealt with N, do n
|
|
|
270 _lab6: mov.b A0L,A3L ; n
|
|
|
271 divxu A1L,A3 ; mq
|
|
|
272 mov.b A3L,A0L ; Qq
|
|
|
273 mov.b A3H,A3L ; m
|
|
|
274 mov.b #0x0,A3H ; Qq 0m
|
|
|
275 rts
|
|
|
276
|
|
|
277 ; D != 0 - which means the denominator is
|
|
|
278 ; loop around to get the result.
|
|
|
279
|
|
|
280 divlongway:
|
|
|
281 mov.b A0H,A3L ; Nn Dd xP 0N
|
|
|
282 mov.b #0x0,A0H ; high byte of answer has to be zero
|
|
|
283 mov.b #0x8,A2H ; 8
|
|
|
284 div8: add.b A0L,A0L ; n*=2
|
|
|
285 rotxl A3L ; Make remainder bigger
|
|
|
286 rotxl A3H
|
|
|
287 sub.w A1,A3 ; Q-=N
|
|
|
288 bhs setbit ; set a bit ?
|
|
|
289 add.w A1,A3 ; no : too far , Q+=N
|
|
|
290
|
|
|
291 dec A2H
|
|
|
292 bne div8 ; next bit
|
|
|
293 rts
|
|
|
294
|
|
|
295 setbit: inc A0L ; do insert bit
|
|
|
296 dec A2H
|
|
|
297 bne div8 ; next bit
|
|
|
298 rts
|
|
|
299
|
|
|
300 #endif /* __H8300__ */
|
|
|
301 #endif /* L_divhi3 */
|
|
|
302
|
|
|
303 #ifdef L_divsi3
|
|
|
304
|
|
|
305 ;; 4 byte integer divides for the H8/300.
|
|
|
306 ;;
|
|
|
307 ;; We have one routine which does all the work and lots of
|
|
|
308 ;; little ones which prepare the args and massage the sign.
|
|
|
309 ;; We bunch all of this into one object file since there are several
|
|
|
310 ;; "supporting routines".
|
|
|
311
|
|
|
312 .section .text
|
|
|
313 .align 2
|
|
|
314
|
|
|
315 ; Put abs SIs into r0/r1 and r2/r3, and leave a 1 in r6l with sign of rest.
|
|
|
316 ; This function is here to keep branch displacements small.
|
|
|
317
|
|
|
318 #ifdef __H8300__
|
|
|
319
|
|
|
320 divnorm:
|
|
|
321 mov.b A0H,A0H ; is the numerator -ve
|
|
|
322 stc ccr,S2L ; keep the sign in bit 3 of S2L
|
|
|
323 bge postive
|
|
|
324
|
|
|
325 ; negate arg
|
|
|
326 not A0H
|
|
|
327 not A1H
|
|
|
328 not A0L
|
|
|
329 not A1L
|
|
|
330
|
|
|
331 add #1,A1L
|
|
|
332 addx #0,A1H
|
|
|
333 addx #0,A0L
|
|
|
334 addx #0,A0H
|
|
|
335 postive:
|
|
|
336 mov.b A2H,A2H ; is the denominator -ve
|
|
|
337 bge postive2
|
|
|
338 not A2L
|
|
|
339 not A2H
|
|
|
340 not A3L
|
|
|
341 not A3H
|
|
|
342 add.b #1,A3L
|
|
|
343 addx #0,A3H
|
|
|
344 addx #0,A2L
|
|
|
345 addx #0,A2H
|
|
|
346 xor.b #0x08,S2L ; toggle the result sign
|
|
|
347 postive2:
|
|
|
348 rts
|
|
|
349
|
|
|
350 ;; Basically the same, except that the sign of the divisor determines
|
|
|
351 ;; the sign.
|
|
|
352 modnorm:
|
|
|
353 mov.b A0H,A0H ; is the numerator -ve
|
|
|
354 stc ccr,S2L ; keep the sign in bit 3 of S2L
|
|
|
355 bge mpostive
|
|
|
356
|
|
|
357 ; negate arg
|
|
|
358 not A0H
|
|
|
359 not A1H
|
|
|
360 not A0L
|
|
|
361 not A1L
|
|
|
362
|
|
|
363 add #1,A1L
|
|
|
364 addx #0,A1H
|
|
|
365 addx #0,A0L
|
|
|
366 addx #0,A0H
|
|
|
367 mpostive:
|
|
|
368 mov.b A2H,A2H ; is the denominator -ve
|
|
|
369 bge mpostive2
|
|
|
370 not A2L
|
|
|
371 not A2H
|
|
|
372 not A3L
|
|
|
373 not A3H
|
|
|
374 add.b #1,A3L
|
|
|
375 addx #0,A3H
|
|
|
376 addx #0,A2L
|
|
|
377 addx #0,A2H
|
|
|
378 mpostive2:
|
|
|
379 rts
|
|
|
380
|
|
|
381 #else /* __H8300H__ */
|
|
|
382
|
|
|
383 divnorm:
|
|
|
384 mov.l A0P,A0P ; is the numerator -ve
|
|
|
385 stc ccr,S2L ; keep the sign in bit 3 of S2L
|
|
|
386 bge postive
|
|
|
387
|
|
|
388 neg.l A0P ; negate arg
|
|
|
389
|
|
|
390 postive:
|
|
|
391 mov.l A1P,A1P ; is the denominator -ve
|
|
|
392 bge postive2
|
|
|
393
|
|
|
394 neg.l A1P ; negate arg
|
|
|
395 xor.b #0x08,S2L ; toggle the result sign
|
|
|
396
|
|
|
397 postive2:
|
|
|
398 rts
|
|
|
399
|
|
|
400 ;; Basically the same, except that the sign of the divisor determines
|
|
|
401 ;; the sign.
|
|
|
402 modnorm:
|
|
|
403 mov.l A0P,A0P ; is the numerator -ve
|
|
|
404 stc ccr,S2L ; keep the sign in bit 3 of S2L
|
|
|
405 bge mpostive
|
|
|
406
|
|
|
407 neg.l A0P ; negate arg
|
|
|
408
|
|
|
409 mpostive:
|
|
|
410 mov.l A1P,A1P ; is the denominator -ve
|
|
|
411 bge mpostive2
|
|
|
412
|
|
|
413 neg.l A1P ; negate arg
|
|
|
414
|
|
|
415 mpostive2:
|
|
|
416 rts
|
|
|
417
|
|
|
418 #endif
|
|
|
419
|
|
|
420 ; numerator in A0/A1
|
|
|
421 ; denominator in A2/A3
|
|
|
422 .global ___modsi3
|
|
|
423 ___modsi3:
|
|
|
424 #ifdef __H8300__
|
|
|
425 PUSHP S2P
|
|
|
426 PUSHP S0P
|
|
|
427 PUSHP S1P
|
|
|
428 bsr modnorm
|
|
|
429 bsr divmodsi4
|
|
|
430 mov S0,A0
|
|
|
431 mov S1,A1
|
|
|
432 bra exitdiv
|
|
|
433 #else
|
|
|
434 PUSHP S2P
|
|
|
435 bsr modnorm
|
|
|
436 bsr ___udivsi3
|
|
|
437 mov.l er3,er0
|
|
|
438 bra exitdiv
|
|
|
439 #endif
|
|
|
440
|
|
|
441 ;; H8/300H and H8S version of ___udivsi3 is defined later in
|
|
|
442 ;; the file.
|
|
|
443 #ifdef __H8300__
|
|
|
444 .global ___udivsi3
|
|
|
445 ___udivsi3:
|
|
|
446 PUSHP S2P
|
|
|
447 PUSHP S0P
|
|
|
448 PUSHP S1P
|
|
|
449 bsr divmodsi4
|
|
|
450 bra reti
|
|
|
451 #endif
|
|
|
452
|
|
|
453 .global ___umodsi3
|
|
|
454 ___umodsi3:
|
|
|
455 #ifdef __H8300__
|
|
|
456 PUSHP S2P
|
|
|
457 PUSHP S0P
|
|
|
458 PUSHP S1P
|
|
|
459 bsr divmodsi4
|
|
|
460 mov S0,A0
|
|
|
461 mov S1,A1
|
|
|
462 bra reti
|
|
|
463 #else
|
|
|
464 bsr ___udivsi3
|
|
|
465 mov.l er3,er0
|
|
|
466 rts
|
|
|
467 #endif
|
|
|
468
|
|
|
469 .global ___divsi3
|
|
|
470 ___divsi3:
|
|
|
471 #ifdef __H8300__
|
|
|
472 PUSHP S2P
|
|
|
473 PUSHP S0P
|
|
|
474 PUSHP S1P
|
|
|
475 jsr divnorm
|
|
|
476 jsr divmodsi4
|
|
|
477 #else
|
|
|
478 PUSHP S2P
|
|
|
479 jsr divnorm
|
|
|
480 bsr ___udivsi3
|
|
|
481 #endif
|
|
|
482
|
|
|
483 ; examine what the sign should be
|
|
|
484 exitdiv:
|
|
|
485 btst #3,S2L
|
|
|
486 beq reti
|
|
|
487
|
|
|
488 ; should be -ve
|
|
|
489 #ifdef __H8300__
|
|
|
490 not A0H
|
|
|
491 not A1H
|
|
|
492 not A0L
|
|
|
493 not A1L
|
|
|
494
|
|
|
495 add #1,A1L
|
|
|
496 addx #0,A1H
|
|
|
497 addx #0,A0L
|
|
|
498 addx #0,A0H
|
|
|
499 #else /* __H8300H__ */
|
|
|
500 neg.l A0P
|
|
|
501 #endif
|
|
|
502
|
|
|
503 reti:
|
|
|
504 #ifdef __H8300__
|
|
|
505 POPP S1P
|
|
|
506 POPP S0P
|
|
|
507 #endif
|
|
|
508 POPP S2P
|
|
|
509 rts
|
|
|
510
|
|
|
511 ; takes A0/A1 numerator (A0P for H8/300H)
|
|
|
512 ; A2/A3 denominator (A1P for H8/300H)
|
|
|
513 ; returns A0/A1 quotient (A0P for H8/300H)
|
|
|
514 ; S0/S1 remainder (S0P for H8/300H)
|
|
|
515 ; trashes S2H
|
|
|
516
|
|
|
517 #ifdef __H8300__
|
|
|
518
|
|
|
519 divmodsi4:
|
|
|
520 sub.w S0,S0 ; zero play area
|
|
|
521 mov.w S0,S1
|
|
|
522 mov.b A2H,S2H
|
|
|
523 or A2L,S2H
|
|
|
524 or A3H,S2H
|
|
|
525 bne DenHighNonZero
|
|
|
526 mov.b A0H,A0H
|
|
|
527 bne NumByte0Zero
|
|
|
528 mov.b A0L,A0L
|
|
|
529 bne NumByte1Zero
|
|
|
530 mov.b A1H,A1H
|
|
|
531 bne NumByte2Zero
|
|
|
532 bra NumByte3Zero
|
|
|
533 NumByte0Zero:
|
|
|
534 mov.b A0H,S1L
|
|
|
535 divxu A3L,S1
|
|
|
536 mov.b S1L,A0H
|
|
|
537 NumByte1Zero:
|
|
|
538 mov.b A0L,S1L
|
|
|
539 divxu A3L,S1
|
|
|
540 mov.b S1L,A0L
|
|
|
541 NumByte2Zero:
|
|
|
542 mov.b A1H,S1L
|
|
|
543 divxu A3L,S1
|
|
|
544 mov.b S1L,A1H
|
|
|
545 NumByte3Zero:
|
|
|
546 mov.b A1L,S1L
|
|
|
547 divxu A3L,S1
|
|
|
548 mov.b S1L,A1L
|
|
|
549
|
|
|
550 mov.b S1H,S1L
|
|
|
551 mov.b #0x0,S1H
|
|
|
552 rts
|
|
|
553
|
|
|
554 ; have to do the divide by shift and test
|
|
|
555 DenHighNonZero:
|
|
|
556 mov.b A0H,S1L
|
|
|
557 mov.b A0L,A0H
|
|
|
558 mov.b A1H,A0L
|
|
|
559 mov.b A1L,A1H
|
|
|
560
|
|
|
561 mov.b #0,A1L
|
|
|
562 mov.b #24,S2H ; only do 24 iterations
|
|
|
563
|
|
|
564 nextbit:
|
|
|
565 add.w A1,A1 ; double the answer guess
|
|
|
566 rotxl A0L
|
|
|
567 rotxl A0H
|
|
|
568
|
|
|
569 rotxl S1L ; double remainder
|
|
|
570 rotxl S1H
|
|
|
571 rotxl S0L
|
|
|
572 rotxl S0H
|
|
|
573 sub.w A3,S1 ; does it all fit
|
|
|
574 subx A2L,S0L
|
|
|
575 subx A2H,S0H
|
|
|
576 bhs setone
|
|
|
577
|
|
|
578 add.w A3,S1 ; no, restore mistake
|
|
|
579 addx A2L,S0L
|
|
|
580 addx A2H,S0H
|
|
|
581
|
|
|
582 dec S2H
|
|
|
583 bne nextbit
|
|
|
584 rts
|
|
|
585
|
|
|
586 setone:
|
|
|
587 inc A1L
|
|
|
588 dec S2H
|
|
|
589 bne nextbit
|
|
|
590 rts
|
|
|
591
|
|
|
592 #else /* __H8300H__ */
|
|
|
593
|
|
|
594 ;; This function also computes the remainder and stores it in er3.
|
|
|
595 .global ___udivsi3
|
|
|
596 ___udivsi3:
|
|
|
597 mov.w A1E,A1E ; denominator top word 0?
|
|
|
598 bne DenHighNonZero
|
|
|
599
|
|
|
600 ; do it the easy way, see page 107 in manual
|
|
|
601 mov.w A0E,A2
|
|
|
602 extu.l A2P
|
|
|
603 divxu.w A1,A2P
|
|
|
604 mov.w A2E,A0E
|
|
|
605 divxu.w A1,A0P
|
|
|
606 mov.w A0E,A3
|
|
|
607 mov.w A2,A0E
|
|
|
608 extu.l A3P
|
|
|
609 rts
|
|
|
610
|
|
|
611 ; er0 = er0 / er1
|
|
|
612 ; er3 = er0 % er1
|
|
|
613 ; trashes er1 er2
|
|
|
614 ; expects er1 >= 2^16
|
|
|
615 DenHighNonZero:
|
|
|
616 mov.l er0,er3
|
|
|
617 mov.l er1,er2
|
|
|
618 #ifdef __H8300H__
|
|
|
619 divmod_L21:
|
|
|
620 shlr.l er0
|
|
|
621 shlr.l er2 ; make divisor < 2^16
|
|
|
622 mov.w e2,e2
|
|
|
623 bne divmod_L21
|
|
|
624 #else
|
|
|
625 shlr.l #2,er2 ; make divisor < 2^16
|
|
|
626 mov.w e2,e2
|
|
|
627 beq divmod_L22A
|
|
|
628 divmod_L21:
|
|
|
629 shlr.l #2,er0
|
|
|
630 divmod_L22:
|
|
|
631 shlr.l #2,er2 ; make divisor < 2^16
|
|
|
632 mov.w e2,e2
|
|
|
633 bne divmod_L21
|
|
|
634 divmod_L22A:
|
|
|
635 rotxl.w r2
|
|
|
636 bcs divmod_L23
|
|
|
637 shlr.l er0
|
|
|
638 bra divmod_L24
|
|
|
639 divmod_L23:
|
|
|
640 rotxr.w r2
|
|
|
641 shlr.l #2,er0
|
|
|
642 divmod_L24:
|
|
|
643 #endif
|
|
|
644 ;; At this point,
|
|
|
645 ;; er0 contains shifted dividend
|
|
|
646 ;; er1 contains divisor
|
|
|
647 ;; er2 contains shifted divisor
|
|
|
648 ;; er3 contains dividend, later remainder
|
|
|
649 divxu.w r2,er0 ; r0 now contains the approximate quotient (AQ)
|
|
|
650 extu.l er0
|
|
|
651 beq divmod_L25
|
|
|
652 subs #1,er0 ; er0 = AQ - 1
|
|
|
653 mov.w e1,r2
|
|
|
654 mulxu.w r0,er2 ; er2 = upper (AQ - 1) * divisor
|
|
|
655 sub.w r2,e3 ; dividend - 65536 * er2
|
|
|
656 mov.w r1,r2
|
|
|
657 mulxu.w r0,er2 ; compute er3 = remainder (tentative)
|
|
|
658 sub.l er2,er3 ; er3 = dividend - (AQ - 1) * divisor
|
|
|
659 divmod_L25:
|
|
|
660 cmp.l er1,er3 ; is divisor < remainder?
|
|
|
661 blo divmod_L26
|
|
|
662 adds #1,er0
|
|
|
663 sub.l er1,er3 ; correct the remainder
|
|
|
664 divmod_L26:
|
|
|
665 rts
|
|
|
666
|
|
|
667 #endif
|
|
|
668 #endif /* L_divsi3 */
|
|
|
669
|
|
|
670 #ifdef L_mulhi3
|
|
|
671
|
|
|
672 ;; HImode multiply.
|
|
|
673 ; The H8/300 only has an 8*8->16 multiply.
|
|
|
674 ; The answer is the same as:
|
|
|
675 ;
|
|
|
676 ; product = (srca.l * srcb.l) + ((srca.h * srcb.l) + (srcb.h * srca.l)) * 256
|
|
|
677 ; (we can ignore A1.h * A0.h cause that will all off the top)
|
|
|
678 ; A0 in
|
|
|
679 ; A1 in
|
|
|
680 ; A0 answer
|
|
|
681
|
|
|
682 #ifdef __H8300__
|
|
|
683 .section .text
|
|
|
684 .align 2
|
|
|
685 .global ___mulhi3
|
|
|
686 ___mulhi3:
|
|
|
687 mov.b A1L,A2L ; A2l gets srcb.l
|
|
|
688 mulxu A0L,A2 ; A2 gets first sub product
|
|
|
689
|
|
|
690 mov.b A0H,A3L ; prepare for
|
|
|
691 mulxu A1L,A3 ; second sub product
|
|
|
692
|
|
|
693 add.b A3L,A2H ; sum first two terms
|
|
|
694
|
|
|
695 mov.b A1H,A3L ; third sub product
|
|
|
696 mulxu A0L,A3
|
|
|
697
|
|
|
698 add.b A3L,A2H ; almost there
|
|
|
699 mov.w A2,A0 ; that is
|
|
|
700 rts
|
|
|
701
|
|
|
702 #endif
|
|
|
703 #endif /* L_mulhi3 */
|
|
|
704
|
|
|
705 #ifdef L_mulsi3
|
|
|
706
|
|
|
707 ;; SImode multiply.
|
|
|
708 ;;
|
|
|
709 ;; I think that shift and add may be sufficient for this. Using the
|
|
|
710 ;; supplied 8x8->16 would need 10 ops of 14 cycles each + overhead. This way
|
|
|
711 ;; the inner loop uses maybe 20 cycles + overhead, but terminates
|
|
|
712 ;; quickly on small args.
|
|
|
713 ;;
|
|
|
714 ;; A0/A1 src_a
|
|
|
715 ;; A2/A3 src_b
|
|
|
716 ;;
|
|
|
717 ;; while (a)
|
|
|
718 ;; {
|
|
|
719 ;; if (a & 1)
|
|
|
720 ;; r += b;
|
|
|
721 ;; a >>= 1;
|
|
|
722 ;; b <<= 1;
|
|
|
723 ;; }
|
|
|
724
|
|
|
725 .section .text
|
|
|
726 .align 2
|
|
|
727
|
|
|
728 #ifdef __H8300__
|
|
|
729
|
|
|
730 .global ___mulsi3
|
|
|
731 ___mulsi3:
|
|
|
732 PUSHP S0P
|
|
|
733 PUSHP S1P
|
|
|
734
|
|
|
735 sub.w S0,S0
|
|
|
736 sub.w S1,S1
|
|
|
737
|
|
|
738 ; while (a)
|
|
|
739 _top: mov.w A0,A0
|
|
|
740 bne _more
|
|
|
741 mov.w A1,A1
|
|
|
742 beq _done
|
|
|
743 _more: ; if (a & 1)
|
|
|
744 bld #0,A1L
|
|
|
745 bcc _nobit
|
|
|
746 ; r += b
|
|
|
747 add.w A3,S1
|
|
|
748 addx A2L,S0L
|
|
|
749 addx A2H,S0H
|
|
|
750 _nobit:
|
|
|
751 ; a >>= 1
|
|
|
752 shlr A0H
|
|
|
753 rotxr A0L
|
|
|
754 rotxr A1H
|
|
|
755 rotxr A1L
|
|
|
756
|
|
|
757 ; b <<= 1
|
|
|
758 add.w A3,A3
|
|
|
759 addx A2L,A2L
|
|
|
760 addx A2H,A2H
|
|
|
761 bra _top
|
|
|
762
|
|
|
763 _done:
|
|
|
764 mov.w S0,A0
|
|
|
765 mov.w S1,A1
|
|
|
766 POPP S1P
|
|
|
767 POPP S0P
|
|
|
768 rts
|
|
|
769
|
|
|
770 #else /* __H8300H__ */
|
|
|
771
|
|
|
772 ;
|
|
|
773 ; mulsi3 for H8/300H - based on Renesas SH implementation
|
|
|
774 ;
|
|
|
775 ; by Toshiyasu Morita
|
|
|
776 ;
|
|
|
777 ; Old code:
|
|
|
778 ;
|
|
|
779 ; 16b * 16b = 372 states (worst case)
|
|
|
780 ; 32b * 32b = 724 states (worst case)
|
|
|
781 ;
|
|
|
782 ; New code:
|
|
|
783 ;
|
|
|
784 ; 16b * 16b = 48 states
|
|
|
785 ; 16b * 32b = 72 states
|
|
|
786 ; 32b * 32b = 92 states
|
|
|
787 ;
|
|
|
788
|
|
|
789 .global ___mulsi3
|
|
|
790 ___mulsi3:
|
|
|
791 mov.w r1,r2 ; ( 2 states) b * d
|
|
|
792 mulxu r0,er2 ; (22 states)
|
|
|
793
|
|
|
794 mov.w e0,r3 ; ( 2 states) a * d
|
|
|
795 beq L_skip1 ; ( 4 states)
|
|
|
796 mulxu r1,er3 ; (22 states)
|
|
|
797 add.w r3,e2 ; ( 2 states)
|
|
|
798
|
|
|
799 L_skip1:
|
|
|
800 mov.w e1,r3 ; ( 2 states) c * b
|
|
|
801 beq L_skip2 ; ( 4 states)
|
|
|
802 mulxu r0,er3 ; (22 states)
|
|
|
803 add.w r3,e2 ; ( 2 states)
|
|
|
804
|
|
|
805 L_skip2:
|
|
|
806 mov.l er2,er0 ; ( 2 states)
|
|
|
807 rts ; (10 states)
|
|
|
808
|
|
|
809 #endif
|
|
|
810 #endif /* L_mulsi3 */
|
|
|
811 #ifdef L_fixunssfsi_asm
|
|
|
812 /* For the h8300 we use asm to save some bytes, to
|
|
|
813 allow more programs to fit into the tiny address
|
|
|
814 space. For the H8/300H and H8S, the C version is good enough. */
|
|
|
815 #ifdef __H8300__
|
|
|
816 /* We still treat NANs different than libgcc2.c, but then, the
|
|
|
817 behavior is undefined anyways. */
|
|
|
818 .global ___fixunssfsi
|
|
|
819 ___fixunssfsi:
|
|
|
820 cmp.b #0x4f,r0h
|
|
|
821 bge Large_num
|
|
|
822 jmp @___fixsfsi
|
|
|
823 Large_num:
|
|
|
824 bhi L_huge_num
|
|
|
825 xor.b #0x80,A0L
|
|
|
826 bmi L_shift8
|
|
|
827 L_huge_num:
|
|
|
828 mov.w #65535,A0
|
|
|
829 mov.w A0,A1
|
|
|
830 rts
|
|
|
831 L_shift8:
|
|
|
832 mov.b A0L,A0H
|
|
|
833 mov.b A1H,A0L
|
|
|
834 mov.b A1L,A1H
|
|
|
835 mov.b #0,A1L
|
|
|
836 rts
|
|
|
837 #endif
|
|
|
838 #endif /* L_fixunssfsi_asm */
|
