URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [frv/] [lib1funcs.S] - Blame information for rev 734

Details | Compare with Previous | View Log


/* Library functions.
   Copyright (C) 2000, 2003, 2008, 2009 Free Software Foundation, Inc.
   Contributed by Red Hat, Inc.
 
   This file is part of GCC.
 
   GCC 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; either version 3, or (at your option)
   any later version.
 
   GCC 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.
 
   Under Section 7 of GPL version 3, you are granted additional
   permissions described in the GCC Runtime Library Exception, version
   3.1, as published by the Free Software Foundation.
 
   You should have received a copy of the GNU General Public License and
   a copy of the GCC Runtime Library Exception along with this program;
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
   .  */
 
#include 
 
 
#ifdef L_cmpll
/* icc0 = __cmpll (long long a, long long b)  */
 
        .globl  EXT(__cmpll)
        .type   EXT(__cmpll),@function
        .text
        .p2align 4
EXT(__cmpll):
        cmp     gr8, gr10, icc0
        ckeq    icc0, cc4
        P(ccmp) gr9, gr11, cc4, 1
        ret
.Lend:
        .size   EXT(__cmpll),.Lend-EXT(__cmpll)
#endif /* L_cmpll */
 
#ifdef L_cmpf
/* icc0 = __cmpf (float a, float b) */
/* Note, because this function returns the result in ICC0, it means it can't
   handle NaNs.  */
 
        .globl  EXT(__cmpf)
        .type   EXT(__cmpf),@function
        .text
        .p2align 4
EXT(__cmpf):
#ifdef __FRV_HARD_FLOAT__       /* floating point instructions available */
        movgf   gr8, fr0
        P(movgf) gr9, fr1
        setlos  #1, gr8
        fcmps   fr0, fr1, fcc0
        P(fcklt) fcc0, cc0
        fckeq   fcc0, cc1
        csub    gr0, gr8, gr8, cc0, 1
        cmov    gr0, gr8, cc1, 1
        cmpi    gr8, 0, icc0
        ret
#else                           /* no floating point instructions available */
        movsg   lr, gr4
        addi    sp, #-16, sp
        sti     gr4, @(sp, 8)
        st      fp, @(sp, gr0)
        mov     sp, fp
        call    EXT(__cmpsf2)
        cmpi    gr8, #0, icc0
        ldi     @(sp, 8), gr4
        movgs   gr4, lr
        ld      @(sp,gr0), fp
        addi    sp, #16, sp
        ret
#endif
.Lend:
        .size   EXT(__cmpf),.Lend-EXT(__cmpf)
#endif
 
#ifdef L_cmpd
/* icc0 = __cmpd (double a, double b) */
/* Note, because this function returns the result in ICC0, it means it can't
   handle NaNs.  */
 
        .globl  EXT(__cmpd)
        .type   EXT(__cmpd),@function
        .text
        .p2align 4
EXT(__cmpd):
        movsg   lr, gr4
        addi    sp, #-16, sp
        sti     gr4, @(sp, 8)
        st      fp, @(sp, gr0)
        mov     sp, fp
        call    EXT(__cmpdf2)
        cmpi    gr8, #0, icc0
        ldi     @(sp, 8), gr4
        movgs   gr4, lr
        ld      @(sp,gr0), fp
        addi    sp, #16, sp
        ret
.Lend:
        .size   EXT(__cmpd),.Lend-EXT(__cmpd)
#endif
 
#ifdef L_addll
/* gr8,gr9 = __addll (long long a, long long b) */
/* Note, gcc will never call this function, but it is present in case an
   ABI program calls it.  */
 
        .globl  EXT(__addll)
        .type   EXT(__addll),@function
        .text
        .p2align
EXT(__addll):
        addcc   gr9, gr11, gr9, icc0
        addx    gr8, gr10, gr8, icc0
        ret
.Lend:
        .size   EXT(__addll),.Lend-EXT(__addll)
#endif
 
#ifdef L_subll
/* gr8,gr9 = __subll (long long a, long long b) */
/* Note, gcc will never call this function, but it is present in case an
   ABI program calls it.  */
 
        .globl  EXT(__subll)
        .type   EXT(__subll),@function
        .text
        .p2align 4
EXT(__subll):
        subcc   gr9, gr11, gr9, icc0
        subx    gr8, gr10, gr8, icc0
        ret
.Lend:
        .size   EXT(__subll),.Lend-EXT(__subll)
#endif
 
#ifdef L_andll
/* gr8,gr9 = __andll (long long a, long long b) */
/* Note, gcc will never call this function, but it is present in case an
   ABI program calls it.  */
 
        .globl  EXT(__andll)
        .type   EXT(__andll),@function
        .text
        .p2align 4
EXT(__andll):
        P(and)  gr9, gr11, gr9
        P2(and) gr8, gr10, gr8
        ret
.Lend:
        .size   EXT(__andll),.Lend-EXT(__andll)
#endif
 
#ifdef L_orll
/* gr8,gr9 = __orll (long long a, long long b) */
/* Note, gcc will never call this function, but it is present in case an
   ABI program calls it.  */
 
        .globl  EXT(__orll)
        .type   EXT(__orll),@function
        .text
        .p2align 4
EXT(__orll):
        P(or)   gr9, gr11, gr9
        P2(or)  gr8, gr10, gr8
        ret
.Lend:
        .size   EXT(__orll),.Lend-EXT(__orll)
#endif
 
#ifdef L_xorll
/* gr8,gr9 = __xorll (long long a, long long b) */
/* Note, gcc will never call this function, but it is present in case an
   ABI program calls it.  */
 
        .globl  EXT(__xorll)
        .type   EXT(__xorll),@function
        .text
        .p2align 4
EXT(__xorll):
        P(xor)  gr9, gr11, gr9
        P2(xor) gr8, gr10, gr8
        ret
.Lend:
        .size   EXT(__xorll),.Lend-EXT(__xorll)
#endif
 
#ifdef L_notll
/* gr8,gr9 = __notll (long long a) */
/* Note, gcc will never call this function, but it is present in case an
   ABI program calls it.  */
 
        .globl  EXT(__notll)
        .type   EXT(__notll),@function
        .text
        .p2align 4
EXT(__notll):
        P(not)  gr9, gr9
        P2(not) gr8, gr8
        ret
.Lend:
        .size   EXT(__notll),.Lend-EXT(__notll)
#endif
 
#ifdef L_cmov
/* (void) __cmov (char *dest, const char *src, size_t len) */
/*
 * void __cmov (char *dest, const char *src, size_t len)
 * {
 *   size_t i;
 *
 *   if (dest < src || dest > src+len)
 *     {
 *       for (i = 0; i < len; i++)
 *       dest[i] = src[i];
 *     }
 *   else
 *     {
 *       while (len-- > 0)
 *       dest[len] = src[len];
 *     }
 * }
 */
 
        .globl  EXT(__cmov)
        .type   EXT(__cmov),@function
        .text
        .p2align 4
EXT(__cmov):
        P(cmp)  gr8, gr9, icc0
        add     gr9, gr10, gr4
        P(cmp)  gr8, gr4, icc1
        bc      icc0, 0, .Lfwd
        bls     icc1, 0, .Lback
.Lfwd:
        /* move bytes in a forward direction */
        P(setlos) #0, gr5
        cmp     gr0, gr10, icc0
        P(subi) gr9, #1, gr9
        P2(subi) gr8, #1, gr8
        bnc     icc0, 0, .Lret
.Lfloop:
        /* forward byte move loop */
        addi    gr5, #1, gr5
        P(ldsb) @(gr9, gr5), gr4
        cmp     gr5, gr10, icc0
        P(stb)  gr4, @(gr8, gr5)
        bc      icc0, 0, .Lfloop
        ret
.Lbloop:
        /* backward byte move loop body */
        ldsb    @(gr9,gr10),gr4
        stb     gr4,@(gr8,gr10)
.Lback:
        P(cmpi) gr10, #0, icc0
        addi    gr10, #-1, gr10
        bne     icc0, 0, .Lbloop
.Lret:
        ret
.Lend:
        .size    EXT(__cmov),.Lend-EXT(__cmov)
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [frv/] [lib1funcs.S] - Blame information for rev 734

Line No.	Rev	Author	Line
1	734	jeremybenn	`/* Library functions.`
2			`Copyright (C) 2000, 2003, 2008, 2009 Free Software Foundation, Inc.`
3			`Contributed by Red Hat, Inc.`
4
5			`This file is part of GCC.`
6
7			`GCC is free software ; you can redistribute it and/or modify`
8			`it under the terms of the GNU General Public License as published by`
9			`the Free Software Foundation; either version 3, or (at your option)`
10			`any later version.`
11
12			`GCC is distributed in the hope that it will be useful,`
13			`but WITHOUT ANY WARRANTY ; without even the implied warranty of`
14			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`GNU General Public License for more details.`
16
17			`Under Section 7 of GPL version 3, you are granted additional`
18			`permissions described in the GCC Runtime Library Exception, version`
19			`3.1, as published by the Free Software Foundation.`
20
21			`You should have received a copy of the GNU General Public License and`
22			`a copy of the GCC Runtime Library Exception along with this program;`
23			`see the files COPYING3 and COPYING.RUNTIME respectively. If not, see`
24			`. */`
25
26			`#include`
27
28
29			`#ifdef L_cmpll`
30			`/* icc0 = __cmpll (long long a, long long b) */`
31
32			`.globl EXT(__cmpll)`
33			`.type EXT(__cmpll),@function`
34			`.text`
35			`.p2align 4`
36			`EXT(__cmpll):`
37			`cmp gr8, gr10, icc0`
38			`ckeq icc0, cc4`
39			`P(ccmp) gr9, gr11, cc4, 1`
40			`ret`
41			`.Lend:`
42			`.size EXT(__cmpll),.Lend-EXT(__cmpll)`
43			`#endif /* L_cmpll */`
44
45			`#ifdef L_cmpf`
46			`/* icc0 = __cmpf (float a, float b) */`
47			`/* Note, because this function returns the result in ICC0, it means it can't`
48			`handle NaNs. */`
49
50			`.globl EXT(__cmpf)`
51			`.type EXT(__cmpf),@function`
52			`.text`
53			`.p2align 4`
54			`EXT(__cmpf):`
55			`#ifdef __FRV_HARD_FLOAT__ /* floating point instructions available */`
56			`movgf gr8, fr0`
57			`P(movgf) gr9, fr1`
58			`setlos #1, gr8`
59			`fcmps fr0, fr1, fcc0`
60			`P(fcklt) fcc0, cc0`
61			`fckeq fcc0, cc1`
62			`csub gr0, gr8, gr8, cc0, 1`
63			`cmov gr0, gr8, cc1, 1`
64			`cmpi gr8, 0, icc0`
65			`ret`
66			`#else /* no floating point instructions available */`
67			`movsg lr, gr4`
68			`addi sp, #-16, sp`
69			`sti gr4, @(sp, 8)`
70			`st fp, @(sp, gr0)`
71			`mov sp, fp`
72			`call EXT(__cmpsf2)`
73			`cmpi gr8, #0, icc0`
74			`ldi @(sp, 8), gr4`
75			`movgs gr4, lr`
76			`ld @(sp,gr0), fp`
77			`addi sp, #16, sp`
78			`ret`
79			`#endif`
80			`.Lend:`
81			`.size EXT(__cmpf),.Lend-EXT(__cmpf)`
82			`#endif`
83
84			`#ifdef L_cmpd`
85			`/* icc0 = __cmpd (double a, double b) */`
86			`/* Note, because this function returns the result in ICC0, it means it can't`
87			`handle NaNs. */`
88
89			`.globl EXT(__cmpd)`
90			`.type EXT(__cmpd),@function`
91			`.text`
92			`.p2align 4`
93			`EXT(__cmpd):`
94			`movsg lr, gr4`
95			`addi sp, #-16, sp`
96			`sti gr4, @(sp, 8)`
97			`st fp, @(sp, gr0)`
98			`mov sp, fp`
99			`call EXT(__cmpdf2)`
100			`cmpi gr8, #0, icc0`
101			`ldi @(sp, 8), gr4`
102			`movgs gr4, lr`
103			`ld @(sp,gr0), fp`
104			`addi sp, #16, sp`
105			`ret`
106			`.Lend:`
107			`.size EXT(__cmpd),.Lend-EXT(__cmpd)`
108			`#endif`
109
110			`#ifdef L_addll`
111			`/* gr8,gr9 = __addll (long long a, long long b) */`
112			`/* Note, gcc will never call this function, but it is present in case an`
113			`ABI program calls it. */`
114
115			`.globl EXT(__addll)`
116			`.type EXT(__addll),@function`
117			`.text`
118			`.p2align`
119			`EXT(__addll):`
120			`addcc gr9, gr11, gr9, icc0`
121			`addx gr8, gr10, gr8, icc0`
122			`ret`
123			`.Lend:`
124			`.size EXT(__addll),.Lend-EXT(__addll)`
125			`#endif`
126
127			`#ifdef L_subll`
128			`/* gr8,gr9 = __subll (long long a, long long b) */`
129			`/* Note, gcc will never call this function, but it is present in case an`
130			`ABI program calls it. */`
131
132			`.globl EXT(__subll)`
133			`.type EXT(__subll),@function`
134			`.text`
135			`.p2align 4`
136			`EXT(__subll):`
137			`subcc gr9, gr11, gr9, icc0`
138			`subx gr8, gr10, gr8, icc0`
139			`ret`
140			`.Lend:`
141			`.size EXT(__subll),.Lend-EXT(__subll)`
142			`#endif`
143
144			`#ifdef L_andll`
145			`/* gr8,gr9 = __andll (long long a, long long b) */`
146			`/* Note, gcc will never call this function, but it is present in case an`
147			`ABI program calls it. */`
148
149			`.globl EXT(__andll)`
150			`.type EXT(__andll),@function`
151			`.text`
152			`.p2align 4`
153			`EXT(__andll):`
154			`P(and) gr9, gr11, gr9`
155			`P2(and) gr8, gr10, gr8`
156			`ret`
157			`.Lend:`
158			`.size EXT(__andll),.Lend-EXT(__andll)`
159			`#endif`
160
161			`#ifdef L_orll`
162			`/* gr8,gr9 = __orll (long long a, long long b) */`
163			`/* Note, gcc will never call this function, but it is present in case an`
164			`ABI program calls it. */`
165
166			`.globl EXT(__orll)`
167			`.type EXT(__orll),@function`
168			`.text`
169			`.p2align 4`
170			`EXT(__orll):`
171			`P(or) gr9, gr11, gr9`
172			`P2(or) gr8, gr10, gr8`
173			`ret`
174			`.Lend:`
175			`.size EXT(__orll),.Lend-EXT(__orll)`
176			`#endif`
177
178			`#ifdef L_xorll`
179			`/* gr8,gr9 = __xorll (long long a, long long b) */`
180			`/* Note, gcc will never call this function, but it is present in case an`
181			`ABI program calls it. */`
182
183			`.globl EXT(__xorll)`
184			`.type EXT(__xorll),@function`
185			`.text`
186			`.p2align 4`
187			`EXT(__xorll):`
188			`P(xor) gr9, gr11, gr9`
189			`P2(xor) gr8, gr10, gr8`
190			`ret`
191			`.Lend:`
192			`.size EXT(__xorll),.Lend-EXT(__xorll)`
193			`#endif`
194
195			`#ifdef L_notll`
196			`/* gr8,gr9 = __notll (long long a) */`
197			`/* Note, gcc will never call this function, but it is present in case an`
198			`ABI program calls it. */`
199
200			`.globl EXT(__notll)`
201			`.type EXT(__notll),@function`
202			`.text`
203			`.p2align 4`
204			`EXT(__notll):`
205			`P(not) gr9, gr9`
206			`P2(not) gr8, gr8`
207			`ret`
208			`.Lend:`
209			`.size EXT(__notll),.Lend-EXT(__notll)`
210			`#endif`
211
212			`#ifdef L_cmov`
213			`/* (void) __cmov (char dest, const char src, size_t len) */`
214			`/*`
215			`* void __cmov (char dest, const char src, size_t len)`
216			`* {`
217			`* size_t i;`
218			`*`
219			`* if (dest < src \|\| dest > src+len)`
220			`* {`
221			`* for (i = 0; i < len; i++)`
222			`* dest[i] = src[i];`
223			`* }`
224			`* else`
225			`* {`
226			`* while (len-- > 0)`
227			`* dest[len] = src[len];`
228			`* }`
229			`* }`
230			`*/`
231
232			`.globl EXT(__cmov)`
233			`.type EXT(__cmov),@function`
234			`.text`
235			`.p2align 4`
236			`EXT(__cmov):`
237			`P(cmp) gr8, gr9, icc0`
238			`add gr9, gr10, gr4`
239			`P(cmp) gr8, gr4, icc1`
240			`bc icc0, 0, .Lfwd`
241			`bls icc1, 0, .Lback`
242			`.Lfwd:`
243			`/* move bytes in a forward direction */`
244			`P(setlos) #0, gr5`
245			`cmp gr0, gr10, icc0`
246			`P(subi) gr9, #1, gr9`
247			`P2(subi) gr8, #1, gr8`
248			`bnc icc0, 0, .Lret`
249			`.Lfloop:`
250			`/* forward byte move loop */`
251			`addi gr5, #1, gr5`
252			`P(ldsb) @(gr9, gr5), gr4`
253			`cmp gr5, gr10, icc0`
254			`P(stb) gr4, @(gr8, gr5)`
255			`bc icc0, 0, .Lfloop`
256			`ret`
257			`.Lbloop:`
258			`/* backward byte move loop body */`
259			`ldsb @(gr9,gr10),gr4`
260			`stb gr4,@(gr8,gr10)`
261			`.Lback:`
262			`P(cmpi) gr10, #0, icc0`
263			`addi gr10, #-1, gr10`
264			`bne icc0, 0, .Lbloop`
265			`.Lret:`
266			`ret`
267			`.Lend:`
268			`.size EXT(__cmov),.Lend-EXT(__cmov)`
269			`#endif`