OpenCores
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 750

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.