OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [ia64/] [lib1funcs.asm] - Blame information for rev 328

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

Line No. Rev Author Line
1 282 jeremybenn
/* Copyright (C) 2000, 2001, 2003, 2005, 2009 Free Software Foundation, Inc.
2
   Contributed by James E. Wilson .
3
 
4
   This file is part of GCC.
5
 
6
   GCC is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3, or (at your option)
9
   any later version.
10
 
11
   GCC is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   Under Section 7 of GPL version 3, you are granted additional
17
   permissions described in the GCC Runtime Library Exception, version
18
   3.1, as published by the Free Software Foundation.
19
 
20
   You should have received a copy of the GNU General Public License and
21
   a copy of the GCC Runtime Library Exception along with this program;
22
   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23
   .  */
24
 
25
#ifdef L__divxf3
26
// Compute a 80-bit IEEE double-extended quotient.
27
//
28
// From the Intel IA-64 Optimization Guide, choose the minimum latency
29
// alternative.
30
//
31
// farg0 holds the dividend.  farg1 holds the divisor.
32
//
33
// __divtf3 is an alternate symbol name for backward compatibility.
34
 
35
        .text
36
        .align 16
37
        .global __divxf3
38
        .proc __divxf3
39
__divxf3:
40
#ifdef SHARED
41
        .global __divtf3
42
__divtf3:
43
#endif
44
        cmp.eq p7, p0 = r0, r0
45
        frcpa.s0 f10, p6 = farg0, farg1
46
        ;;
47
(p6)    cmp.ne p7, p0 = r0, r0
48
        .pred.rel.mutex p6, p7
49
(p6)    fnma.s1 f11 = farg1, f10, f1
50
(p6)    fma.s1 f12 = farg0, f10, f0
51
        ;;
52
(p6)    fma.s1 f13 = f11, f11, f0
53
(p6)    fma.s1 f14 = f11, f11, f11
54
        ;;
55
(p6)    fma.s1 f11 = f13, f13, f11
56
(p6)    fma.s1 f13 = f14, f10, f10
57
        ;;
58
(p6)    fma.s1 f10 = f13, f11, f10
59
(p6)    fnma.s1 f11 = farg1, f12, farg0
60
        ;;
61
(p6)    fma.s1 f11 = f11, f10, f12
62
(p6)    fnma.s1 f12 = farg1, f10, f1
63
        ;;
64
(p6)    fma.s1 f10 = f12, f10, f10
65
(p6)    fnma.s1 f12 = farg1, f11, farg0
66
        ;;
67
(p6)    fma.s0 fret0 = f12, f10, f11
68
(p7)    mov fret0 = f10
69
        br.ret.sptk rp
70
        .endp __divxf3
71
#endif
72
 
73
#ifdef L__divdf3
74
// Compute a 64-bit IEEE double quotient.
75
//
76
// From the Intel IA-64 Optimization Guide, choose the minimum latency
77
// alternative.
78
//
79
// farg0 holds the dividend.  farg1 holds the divisor.
80
 
81
        .text
82
        .align 16
83
        .global __divdf3
84
        .proc __divdf3
85
__divdf3:
86
        cmp.eq p7, p0 = r0, r0
87
        frcpa.s0 f10, p6 = farg0, farg1
88
        ;;
89
(p6)    cmp.ne p7, p0 = r0, r0
90
        .pred.rel.mutex p6, p7
91
(p6)    fmpy.s1 f11 = farg0, f10
92
(p6)    fnma.s1 f12 = farg1, f10, f1
93
        ;;
94
(p6)    fma.s1 f11 = f12, f11, f11
95
(p6)    fmpy.s1 f13 = f12, f12
96
        ;;
97
(p6)    fma.s1 f10 = f12, f10, f10
98
(p6)    fma.s1 f11 = f13, f11, f11
99
        ;;
100
(p6)    fmpy.s1 f12 = f13, f13
101
(p6)    fma.s1 f10 = f13, f10, f10
102
        ;;
103
(p6)    fma.d.s1 f11 = f12, f11, f11
104
(p6)    fma.s1 f10 = f12, f10, f10
105
        ;;
106
(p6)    fnma.d.s1 f8 = farg1, f11, farg0
107
        ;;
108
(p6)    fma.d fret0 = f8, f10, f11
109
(p7)    mov fret0 = f10
110
        br.ret.sptk rp
111
        ;;
112
        .endp __divdf3
113
#endif
114
 
115
#ifdef L__divsf3
116
// Compute a 32-bit IEEE float quotient.
117
//
118
// From the Intel IA-64 Optimization Guide, choose the minimum latency
119
// alternative.
120
//
121
// farg0 holds the dividend.  farg1 holds the divisor.
122
 
123
        .text
124
        .align 16
125
        .global __divsf3
126
        .proc __divsf3
127
__divsf3:
128
        cmp.eq p7, p0 = r0, r0
129
        frcpa.s0 f10, p6 = farg0, farg1
130
        ;;
131
(p6)    cmp.ne p7, p0 = r0, r0
132
        .pred.rel.mutex p6, p7
133
(p6)    fmpy.s1 f8 = farg0, f10
134
(p6)    fnma.s1 f9 = farg1, f10, f1
135
        ;;
136
(p6)    fma.s1 f8 = f9, f8, f8
137
(p6)    fmpy.s1 f9 = f9, f9
138
        ;;
139
(p6)    fma.s1 f8 = f9, f8, f8
140
(p6)    fmpy.s1 f9 = f9, f9
141
        ;;
142
(p6)    fma.d.s1 f10 = f9, f8, f8
143
        ;;
144
(p6)    fnorm.s.s0 fret0 = f10
145
(p7)    mov fret0 = f10
146
        br.ret.sptk rp
147
        ;;
148
        .endp __divsf3
149
#endif
150
 
151
#ifdef L__divdi3
152
// Compute a 64-bit integer quotient.
153
//
154
// From the Intel IA-64 Optimization Guide, choose the minimum latency
155
// alternative.
156
//
157
// in0 holds the dividend.  in1 holds the divisor.
158
 
159
        .text
160
        .align 16
161
        .global __divdi3
162
        .proc __divdi3
163
__divdi3:
164
        .regstk 2,0,0,0
165
        // Transfer inputs to FP registers.
166
        setf.sig f8 = in0
167
        setf.sig f9 = in1
168
        // Check divide by zero.
169
        cmp.ne.unc p0,p7=0,in1
170
        ;;
171
        // Convert the inputs to FP, so that they won't be treated as unsigned.
172
        fcvt.xf f8 = f8
173
        fcvt.xf f9 = f9
174
(p7)    break 1
175
        ;;
176
        // Compute the reciprocal approximation.
177
        frcpa.s1 f10, p6 = f8, f9
178
        ;;
179
        // 3 Newton-Raphson iterations.
180
(p6)    fnma.s1 f11 = f9, f10, f1
181
(p6)    fmpy.s1 f12 = f8, f10
182
        ;;
183
(p6)    fmpy.s1 f13 = f11, f11
184
(p6)    fma.s1 f12 = f11, f12, f12
185
        ;;
186
(p6)    fma.s1 f10 = f11, f10, f10
187
(p6)    fma.s1 f11 = f13, f12, f12
188
        ;;
189
(p6)    fma.s1 f10 = f13, f10, f10
190
(p6)    fnma.s1 f12 = f9, f11, f8
191
        ;;
192
(p6)    fma.s1 f10 = f12, f10, f11
193
        ;;
194
        // Round quotient to an integer.
195
        fcvt.fx.trunc.s1 f10 = f10
196
        ;;
197
        // Transfer result to GP registers.
198
        getf.sig ret0 = f10
199
        br.ret.sptk rp
200
        ;;
201
        .endp __divdi3
202
#endif
203
 
204
#ifdef L__moddi3
205
// Compute a 64-bit integer modulus.
206
//
207
// From the Intel IA-64 Optimization Guide, choose the minimum latency
208
// alternative.
209
//
210
// in0 holds the dividend (a).  in1 holds the divisor (b).
211
 
212
        .text
213
        .align 16
214
        .global __moddi3
215
        .proc __moddi3
216
__moddi3:
217
        .regstk 2,0,0,0
218
        // Transfer inputs to FP registers.
219
        setf.sig f14 = in0
220
        setf.sig f9 = in1
221
        // Check divide by zero.
222
        cmp.ne.unc p0,p7=0,in1
223
        ;;
224
        // Convert the inputs to FP, so that they won't be treated as unsigned.
225
        fcvt.xf f8 = f14
226
        fcvt.xf f9 = f9
227
(p7)    break 1
228
        ;;
229
        // Compute the reciprocal approximation.
230
        frcpa.s1 f10, p6 = f8, f9
231
        ;;
232
        // 3 Newton-Raphson iterations.
233
(p6)    fmpy.s1 f12 = f8, f10
234
(p6)    fnma.s1 f11 = f9, f10, f1
235
        ;;
236
(p6)    fma.s1 f12 = f11, f12, f12
237
(p6)    fmpy.s1 f13 = f11, f11
238
        ;;
239
(p6)    fma.s1 f10 = f11, f10, f10
240
(p6)    fma.s1 f11 = f13, f12, f12
241
        ;;
242
        sub in1 = r0, in1
243
(p6)    fma.s1 f10 = f13, f10, f10
244
(p6)    fnma.s1 f12 = f9, f11, f8
245
        ;;
246
        setf.sig f9 = in1
247
(p6)    fma.s1 f10 = f12, f10, f11
248
        ;;
249
        fcvt.fx.trunc.s1 f10 = f10
250
        ;;
251
        // r = q * (-b) + a
252
        xma.l f10 = f10, f9, f14
253
        ;;
254
        // Transfer result to GP registers.
255
        getf.sig ret0 = f10
256
        br.ret.sptk rp
257
        ;;
258
        .endp __moddi3
259
#endif
260
 
261
#ifdef L__udivdi3
262
// Compute a 64-bit unsigned integer quotient.
263
//
264
// From the Intel IA-64 Optimization Guide, choose the minimum latency
265
// alternative.
266
//
267
// in0 holds the dividend.  in1 holds the divisor.
268
 
269
        .text
270
        .align 16
271
        .global __udivdi3
272
        .proc __udivdi3
273
__udivdi3:
274
        .regstk 2,0,0,0
275
        // Transfer inputs to FP registers.
276
        setf.sig f8 = in0
277
        setf.sig f9 = in1
278
        // Check divide by zero.
279
        cmp.ne.unc p0,p7=0,in1
280
        ;;
281
        // Convert the inputs to FP, to avoid FP software-assist faults.
282
        fcvt.xuf.s1 f8 = f8
283
        fcvt.xuf.s1 f9 = f9
284
(p7)    break 1
285
        ;;
286
        // Compute the reciprocal approximation.
287
        frcpa.s1 f10, p6 = f8, f9
288
        ;;
289
        // 3 Newton-Raphson iterations.
290
(p6)    fnma.s1 f11 = f9, f10, f1
291
(p6)    fmpy.s1 f12 = f8, f10
292
        ;;
293
(p6)    fmpy.s1 f13 = f11, f11
294
(p6)    fma.s1 f12 = f11, f12, f12
295
        ;;
296
(p6)    fma.s1 f10 = f11, f10, f10
297
(p6)    fma.s1 f11 = f13, f12, f12
298
        ;;
299
(p6)    fma.s1 f10 = f13, f10, f10
300
(p6)    fnma.s1 f12 = f9, f11, f8
301
        ;;
302
(p6)    fma.s1 f10 = f12, f10, f11
303
        ;;
304
        // Round quotient to an unsigned integer.
305
        fcvt.fxu.trunc.s1 f10 = f10
306
        ;;
307
        // Transfer result to GP registers.
308
        getf.sig ret0 = f10
309
        br.ret.sptk rp
310
        ;;
311
        .endp __udivdi3
312
#endif
313
 
314
#ifdef L__umoddi3
315
// Compute a 64-bit unsigned integer modulus.
316
//
317
// From the Intel IA-64 Optimization Guide, choose the minimum latency
318
// alternative.
319
//
320
// in0 holds the dividend (a).  in1 holds the divisor (b).
321
 
322
        .text
323
        .align 16
324
        .global __umoddi3
325
        .proc __umoddi3
326
__umoddi3:
327
        .regstk 2,0,0,0
328
        // Transfer inputs to FP registers.
329
        setf.sig f14 = in0
330
        setf.sig f9 = in1
331
        // Check divide by zero.
332
        cmp.ne.unc p0,p7=0,in1
333
        ;;
334
        // Convert the inputs to FP, to avoid FP software assist faults.
335
        fcvt.xuf.s1 f8 = f14
336
        fcvt.xuf.s1 f9 = f9
337
(p7)    break 1;
338
        ;;
339
        // Compute the reciprocal approximation.
340
        frcpa.s1 f10, p6 = f8, f9
341
        ;;
342
        // 3 Newton-Raphson iterations.
343
(p6)    fmpy.s1 f12 = f8, f10
344
(p6)    fnma.s1 f11 = f9, f10, f1
345
        ;;
346
(p6)    fma.s1 f12 = f11, f12, f12
347
(p6)    fmpy.s1 f13 = f11, f11
348
        ;;
349
(p6)    fma.s1 f10 = f11, f10, f10
350
(p6)    fma.s1 f11 = f13, f12, f12
351
        ;;
352
        sub in1 = r0, in1
353
(p6)    fma.s1 f10 = f13, f10, f10
354
(p6)    fnma.s1 f12 = f9, f11, f8
355
        ;;
356
        setf.sig f9 = in1
357
(p6)    fma.s1 f10 = f12, f10, f11
358
        ;;
359
        // Round quotient to an unsigned integer.
360
        fcvt.fxu.trunc.s1 f10 = f10
361
        ;;
362
        // r = q * (-b) + a
363
        xma.l f10 = f10, f9, f14
364
        ;;
365
        // Transfer result to GP registers.
366
        getf.sig ret0 = f10
367
        br.ret.sptk rp
368
        ;;
369
        .endp __umoddi3
370
#endif
371
 
372
#ifdef L__divsi3
373
// Compute a 32-bit integer quotient.
374
//
375
// From the Intel IA-64 Optimization Guide, choose the minimum latency
376
// alternative.
377
//
378
// in0 holds the dividend.  in1 holds the divisor.
379
 
380
        .text
381
        .align 16
382
        .global __divsi3
383
        .proc __divsi3
384
__divsi3:
385
        .regstk 2,0,0,0
386
        // Check divide by zero.
387
        cmp.ne.unc p0,p7=0,in1
388
        sxt4 in0 = in0
389
        sxt4 in1 = in1
390
        ;;
391
        setf.sig f8 = in0
392
        setf.sig f9 = in1
393
(p7)    break 1
394
        ;;
395
        mov r2 = 0x0ffdd
396
        fcvt.xf f8 = f8
397
        fcvt.xf f9 = f9
398
        ;;
399
        setf.exp f11 = r2
400
        frcpa.s1 f10, p6 = f8, f9
401
        ;;
402
(p6)    fmpy.s1 f8 = f8, f10
403
(p6)    fnma.s1 f9 = f9, f10, f1
404
        ;;
405
(p6)    fma.s1 f8 = f9, f8, f8
406
(p6)    fma.s1 f9 = f9, f9, f11
407
        ;;
408
(p6)    fma.s1 f10 = f9, f8, f8
409
        ;;
410
        fcvt.fx.trunc.s1 f10 = f10
411
        ;;
412
        getf.sig ret0 = f10
413
        br.ret.sptk rp
414
        ;;
415
        .endp __divsi3
416
#endif
417
 
418
#ifdef L__modsi3
419
// Compute a 32-bit integer modulus.
420
//
421
// From the Intel IA-64 Optimization Guide, choose the minimum latency
422
// alternative.
423
//
424
// in0 holds the dividend.  in1 holds the divisor.
425
 
426
        .text
427
        .align 16
428
        .global __modsi3
429
        .proc __modsi3
430
__modsi3:
431
        .regstk 2,0,0,0
432
        mov r2 = 0x0ffdd
433
        sxt4 in0 = in0
434
        sxt4 in1 = in1
435
        ;;
436
        setf.sig f13 = r32
437
        setf.sig f9 = r33
438
        // Check divide by zero.
439
        cmp.ne.unc p0,p7=0,in1
440
        ;;
441
        sub in1 = r0, in1
442
        fcvt.xf f8 = f13
443
        fcvt.xf f9 = f9
444
        ;;
445
        setf.exp f11 = r2
446
        frcpa.s1 f10, p6 = f8, f9
447
(p7)    break 1
448
        ;;
449
(p6)    fmpy.s1 f12 = f8, f10
450
(p6)    fnma.s1 f10 = f9, f10, f1
451
        ;;
452
        setf.sig f9 = in1
453
(p6)    fma.s1 f12 = f10, f12, f12
454
(p6)    fma.s1 f10 = f10, f10, f11
455
        ;;
456
(p6)    fma.s1 f10 = f10, f12, f12
457
        ;;
458
        fcvt.fx.trunc.s1 f10 = f10
459
        ;;
460
        xma.l f10 = f10, f9, f13
461
        ;;
462
        getf.sig ret0 = f10
463
        br.ret.sptk rp
464
        ;;
465
        .endp __modsi3
466
#endif
467
 
468
#ifdef L__udivsi3
469
// Compute a 32-bit unsigned integer quotient.
470
//
471
// From the Intel IA-64 Optimization Guide, choose the minimum latency
472
// alternative.
473
//
474
// in0 holds the dividend.  in1 holds the divisor.
475
 
476
        .text
477
        .align 16
478
        .global __udivsi3
479
        .proc __udivsi3
480
__udivsi3:
481
        .regstk 2,0,0,0
482
        mov r2 = 0x0ffdd
483
        zxt4 in0 = in0
484
        zxt4 in1 = in1
485
        ;;
486
        setf.sig f8 = in0
487
        setf.sig f9 = in1
488
        // Check divide by zero.
489
        cmp.ne.unc p0,p7=0,in1
490
        ;;
491
        fcvt.xf f8 = f8
492
        fcvt.xf f9 = f9
493
(p7)    break 1
494
        ;;
495
        setf.exp f11 = r2
496
        frcpa.s1 f10, p6 = f8, f9
497
        ;;
498
(p6)    fmpy.s1 f8 = f8, f10
499
(p6)    fnma.s1 f9 = f9, f10, f1
500
        ;;
501
(p6)    fma.s1 f8 = f9, f8, f8
502
(p6)    fma.s1 f9 = f9, f9, f11
503
        ;;
504
(p6)    fma.s1 f10 = f9, f8, f8
505
        ;;
506
        fcvt.fxu.trunc.s1 f10 = f10
507
        ;;
508
        getf.sig ret0 = f10
509
        br.ret.sptk rp
510
        ;;
511
        .endp __udivsi3
512
#endif
513
 
514
#ifdef L__umodsi3
515
// Compute a 32-bit unsigned integer modulus.
516
//
517
// From the Intel IA-64 Optimization Guide, choose the minimum latency
518
// alternative.
519
//
520
// in0 holds the dividend.  in1 holds the divisor.
521
 
522
        .text
523
        .align 16
524
        .global __umodsi3
525
        .proc __umodsi3
526
__umodsi3:
527
        .regstk 2,0,0,0
528
        mov r2 = 0x0ffdd
529
        zxt4 in0 = in0
530
        zxt4 in1 = in1
531
        ;;
532
        setf.sig f13 = in0
533
        setf.sig f9 = in1
534
        // Check divide by zero.
535
        cmp.ne.unc p0,p7=0,in1
536
        ;;
537
        sub in1 = r0, in1
538
        fcvt.xf f8 = f13
539
        fcvt.xf f9 = f9
540
        ;;
541
        setf.exp f11 = r2
542
        frcpa.s1 f10, p6 = f8, f9
543
(p7)    break 1;
544
        ;;
545
(p6)    fmpy.s1 f12 = f8, f10
546
(p6)    fnma.s1 f10 = f9, f10, f1
547
        ;;
548
        setf.sig f9 = in1
549
(p6)    fma.s1 f12 = f10, f12, f12
550
(p6)    fma.s1 f10 = f10, f10, f11
551
        ;;
552
(p6)    fma.s1 f10 = f10, f12, f12
553
        ;;
554
        fcvt.fxu.trunc.s1 f10 = f10
555
        ;;
556
        xma.l f10 = f10, f9, f13
557
        ;;
558
        getf.sig ret0 = f10
559
        br.ret.sptk rp
560
        ;;
561
        .endp __umodsi3
562
#endif
563
 
564
#ifdef L__save_stack_nonlocal
565
// Notes on save/restore stack nonlocal: We read ar.bsp but write
566
// ar.bspstore.  This is because ar.bsp can be read at all times
567
// (independent of the RSE mode) but since it's read-only we need to
568
// restore the value via ar.bspstore.  This is OK because
569
// ar.bsp==ar.bspstore after executing "flushrs".
570
 
571
// void __ia64_save_stack_nonlocal(void *save_area, void *stack_pointer)
572
 
573
        .text
574
        .align 16
575
        .global __ia64_save_stack_nonlocal
576
        .proc __ia64_save_stack_nonlocal
577
__ia64_save_stack_nonlocal:
578
        { .mmf
579
          alloc r18 = ar.pfs, 2, 0, 0, 0
580
          mov r19 = ar.rsc
581
          ;;
582
        }
583
        { .mmi
584
          flushrs
585
          st8 [in0] = in1, 24
586
          and r19 = 0x1c, r19
587
          ;;
588
        }
589
        { .mmi
590
          st8 [in0] = r18, -16
591
          mov ar.rsc = r19
592
          or r19 = 0x3, r19
593
          ;;
594
        }
595
        { .mmi
596
          mov r16 = ar.bsp
597
          mov r17 = ar.rnat
598
          adds r2 = 8, in0
599
          ;;
600
        }
601
        { .mmi
602
          st8 [in0] = r16
603
          st8 [r2] = r17
604
        }
605
        { .mib
606
          mov ar.rsc = r19
607
          br.ret.sptk.few rp
608
          ;;
609
        }
610
        .endp __ia64_save_stack_nonlocal
611
#endif
612
 
613
#ifdef L__nonlocal_goto
614
// void __ia64_nonlocal_goto(void *target_label, void *save_area,
615
//                           void *static_chain);
616
 
617
        .text
618
        .align 16
619
        .global __ia64_nonlocal_goto
620
        .proc __ia64_nonlocal_goto
621
__ia64_nonlocal_goto:
622
        { .mmi
623
          alloc r20 = ar.pfs, 3, 0, 0, 0
624
          ld8 r12 = [in1], 8
625
          mov.ret.sptk rp = in0, .L0
626
          ;;
627
        }
628
        { .mmf
629
          ld8 r16 = [in1], 8
630
          mov r19 = ar.rsc
631
          ;;
632
        }
633
        { .mmi
634
          flushrs
635
          ld8 r17 = [in1], 8
636
          and r19 = 0x1c, r19
637
          ;;
638
        }
639
        { .mmi
640
          ld8 r18 = [in1]
641
          mov ar.rsc = r19
642
          or r19 = 0x3, r19
643
          ;;
644
        }
645
        { .mmi
646
          mov ar.bspstore = r16
647
          ;;
648
          mov ar.rnat = r17
649
          ;;
650
        }
651
        { .mmi
652
          loadrs
653
          invala
654
          mov r15 = in2
655
          ;;
656
        }
657
.L0:    { .mib
658
          mov ar.rsc = r19
659
          mov ar.pfs = r18
660
          br.ret.sptk.few rp
661
          ;;
662
        }
663
        .endp __ia64_nonlocal_goto
664
#endif
665
 
666
#ifdef L__restore_stack_nonlocal
667
// This is mostly the same as nonlocal_goto above.
668
// ??? This has not been tested yet.
669
 
670
// void __ia64_restore_stack_nonlocal(void *save_area)
671
 
672
        .text
673
        .align 16
674
        .global __ia64_restore_stack_nonlocal
675
        .proc __ia64_restore_stack_nonlocal
676
__ia64_restore_stack_nonlocal:
677
        { .mmf
678
          alloc r20 = ar.pfs, 4, 0, 0, 0
679
          ld8 r12 = [in0], 8
680
          ;;
681
        }
682
        { .mmb
683
          ld8 r16=[in0], 8
684
          mov r19 = ar.rsc
685
          ;;
686
        }
687
        { .mmi
688
          flushrs
689
          ld8 r17 = [in0], 8
690
          and r19 = 0x1c, r19
691
          ;;
692
        }
693
        { .mmf
694
          ld8 r18 = [in0]
695
          mov ar.rsc = r19
696
          ;;
697
        }
698
        { .mmi
699
          mov ar.bspstore = r16
700
          ;;
701
          mov ar.rnat = r17
702
          or r19 = 0x3, r19
703
          ;;
704
        }
705
        { .mmf
706
          loadrs
707
          invala
708
          ;;
709
        }
710
.L0:    { .mib
711
          mov ar.rsc = r19
712
          mov ar.pfs = r18
713
          br.ret.sptk.few rp
714
          ;;
715
        }
716
        .endp __ia64_restore_stack_nonlocal
717
#endif
718
 
719
#ifdef L__trampoline
720
// Implement the nested function trampoline.  This is out of line
721
// so that we don't have to bother with flushing the icache, as
722
// well as making the on-stack trampoline smaller.
723
//
724
// The trampoline has the following form:
725
//
726
//              +-------------------+ >
727
//      TRAMP:  | __ia64_trampoline | |
728
//              +-------------------+  > fake function descriptor
729
//              | TRAMP+16          | |
730
//              +-------------------+ >
731
//              | target descriptor |
732
//              +-------------------+
733
//              | static link       |
734
//              +-------------------+
735
 
736
        .text
737
        .align 16
738
        .global __ia64_trampoline
739
        .proc __ia64_trampoline
740
__ia64_trampoline:
741
        { .mmi
742
          ld8 r2 = [r1], 8
743
          ;;
744
          ld8 r15 = [r1]
745
        }
746
        { .mmi
747
          ld8 r3 = [r2], 8
748
          ;;
749
          ld8 r1 = [r2]
750
          mov b6 = r3
751
        }
752
        { .bbb
753
          br.sptk.many b6
754
          ;;
755
        }
756
        .endp __ia64_trampoline
757
#endif
758
 
759
#ifdef SHARED
760
// Thunks for backward compatibility.
761
#ifdef L_fixtfdi
762
        .text
763
        .align 16
764
        .global __fixtfti
765
        .proc __fixtfti
766
__fixtfti:
767
        { .bbb
768
          br.sptk.many __fixxfti
769
          ;;
770
        }
771
        .endp __fixtfti
772
#endif
773
#ifdef L_fixunstfdi
774
        .align 16
775
        .global __fixunstfti
776
        .proc __fixunstfti
777
__fixunstfti:
778
        { .bbb
779
          br.sptk.many __fixunsxfti
780
          ;;
781
        }
782
        .endp __fixunstfti
783
#endif
784
#ifdef L_floatditf
785
        .align 16
786
        .global __floattitf
787
        .proc __floattitf
788
__floattitf:
789
        { .bbb
790
          br.sptk.many __floattixf
791
          ;;
792
        }
793
        .endp __floattitf
794
#endif
795
#endif

powered by: WebSVN 2.1.0

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