← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/m68k/math-emu/fp_entry.S

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/m68k/math-emu/fp_entry.S
 
1
/*
 
2
 * fp_emu.S
 
3
 *
 
4
 * Copyright Roman Zippel, 1997.  All rights reserved.
 
5
 *
 
6
 * Redistribution and use in source and binary forms, with or without
 
7
 * modification, are permitted provided that the following conditions
 
8
 * are met:
 
9
 * 1. Redistributions of source code must retain the above copyright
 
10
 *    notice, and the entire permission notice in its entirety,
 
11
 *    including the disclaimer of warranties.
 
12
 * 2. Redistributions in binary form must reproduce the above copyright
 
13
 *    notice, this list of conditions and the following disclaimer in the
 
14
 *    documentation and/or other materials provided with the distribution.
 
15
 * 3. The name of the author may not be used to endorse or promote
 
16
 *    products derived from this software without specific prior
 
17
 *    written permission.
 
18
 *
 
19
 * ALTERNATIVELY, this product may be distributed under the terms of
 
20
 * the GNU General Public License, in which case the provisions of the GPL are
 
21
 * required INSTEAD OF the above restrictions.  (This clause is
 
22
 * necessary due to a potential bad interaction between the GPL and
 
23
 * the restrictions contained in a BSD-style copyright.)
 
24
 *
 
25
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 
26
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
27
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
28
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 
29
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
30
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
31
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
32
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 
33
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
34
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 
35
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 
36
 */
 
37
 
 
38
#include <linux/linkage.h>
 
39
#include <asm/entry.h>
 
40
 
 
41
#include "fp_emu.h"
 
42
 
 
43
        .globl  fpu_emu
 
44
        .globl  fp_debugprint
 
45
        .globl  fp_err_ua1,fp_err_ua2
 
46
 
 
47
        .text
 
48
fpu_emu:
 
49
        SAVE_ALL_INT
 
50
        GET_CURRENT(%d0)
 
51
 
 
52
#if defined(CPU_M68020_OR_M68030) && defined(CPU_M68040_OR_M68060)
 
53
        tst.l   m68k_is040or060
 
54
        jeq     1f
 
55
#endif
 
56
#if defined(CPU_M68040_OR_M68060)
 
57
        move.l  (FPS_PC2,%sp),(FPS_PC,%sp)
 
58
#endif
 
59
1:
 
60
        | emulate the instruction
 
61
        jsr     fp_scan
 
62
 
 
63
#if defined(CONFIG_M68060)
 
64
#if !defined(CPU_M68060_ONLY)
 
65
        btst    #3,m68k_cputype+3
 
66
        jeq     1f
 
67
#endif
 
68
        btst    #7,(FPS_SR,%sp)
 
69
        jne     fp_sendtrace060
 
70
#endif
 
71
1:
 
72
        | emulation successful?
 
73
        tst.l   %d0
 
74
        jeq     ret_from_exception
 
75
 
 
76
        | send some signal to program here
 
77
 
 
78
        jra     ret_from_exception
 
79
 
 
80
        | we jump here after an access error while trying to access
 
81
        | user space, we correct stackpointer and send a SIGSEGV to
 
82
        | the user process
 
83
fp_err_ua2:
 
84
        addq.l  #4,%sp
 
85
fp_err_ua1:
 
86
        addq.l  #4,%sp
 
87
        move.l  %a0,-(%sp)
 
88
        pea     LSEGV_MAPERR
 
89
        pea     LSIGSEGV
 
90
        jsr     fpemu_signal
 
91
        add.w   #12,%sp
 
92
        jra     ret_from_exception
 
93
 
 
94
#if defined(CONFIG_M68060)
 
95
        | send a trace signal if we are debugged
 
96
        | it does not really belong here, but...
 
97
fp_sendtrace060:
 
98
        move.l  (FPS_PC,%sp),-(%sp)
 
99
        pea     LTRAP_TRACE
 
100
        pea     LSIGTRAP
 
101
        jsr     fpemu_signal
 
102
        add.w   #12,%sp
 
103
        jra     ret_from_exception
 
104
#endif
 
105
 
 
106
        .globl  fp_get_data_reg, fp_put_data_reg
 
107
        .globl  fp_get_addr_reg, fp_put_addr_reg
 
108
 
 
109
        | Entry points to get/put a register. Some of them can be get/put
 
110
        | directly, others are on the stack, as we read/write the stack
 
111
        | directly here, these function may only be called from within
 
112
        | instruction decoding, otherwise the stack pointer is incorrect
 
113
        | and the stack gets corrupted.
 
114
fp_get_data_reg:
 
115
        jmp     ([0f:w,%pc,%d0.w*4])
 
116
 
 
117
        .align  4
 
118
0:
 
119
        .long   fp_get_d0, fp_get_d1
 
120
        .long   fp_get_d2, fp_get_d3
 
121
        .long   fp_get_d4, fp_get_d5
 
122
        .long   fp_get_d6, fp_get_d7
 
123
 
 
124
fp_get_d0:
 
125
        move.l  (PT_OFF_D0+8,%sp),%d0
 
126
        printf  PREGISTER,"{d0->%08x}",1,%d0
 
127
        rts
 
128
 
 
129
fp_get_d1:
 
130
        move.l  (PT_OFF_D1+8,%sp),%d0
 
131
        printf  PREGISTER,"{d1->%08x}",1,%d0
 
132
        rts
 
133
 
 
134
fp_get_d2:
 
135
        move.l  (PT_OFF_D2+8,%sp),%d0
 
136
        printf  PREGISTER,"{d2->%08x}",1,%d0
 
137
        rts
 
138
 
 
139
fp_get_d3:
 
140
        move.l  %d3,%d0
 
141
        printf  PREGISTER,"{d3->%08x}",1,%d0
 
142
        rts
 
143
 
 
144
fp_get_d4:
 
145
        move.l  %d4,%d0
 
146
        printf  PREGISTER,"{d4->%08x}",1,%d0
 
147
        rts
 
148
 
 
149
fp_get_d5:
 
150
        move.l  %d5,%d0
 
151
        printf  PREGISTER,"{d5->%08x}",1,%d0
 
152
        rts
 
153
 
 
154
fp_get_d6:
 
155
        move.l  %d6,%d0
 
156
        printf  PREGISTER,"{d6->%08x}",1,%d0
 
157
        rts
 
158
 
 
159
fp_get_d7:
 
160
        move.l  %d7,%d0
 
161
        printf  PREGISTER,"{d7->%08x}",1,%d0
 
162
        rts
 
163
 
 
164
fp_put_data_reg:
 
165
        jmp     ([0f:w,%pc,%d1.w*4])
 
166
 
 
167
        .align  4
 
168
0:
 
169
        .long   fp_put_d0, fp_put_d1
 
170
        .long   fp_put_d2, fp_put_d3
 
171
        .long   fp_put_d4, fp_put_d5
 
172
        .long   fp_put_d6, fp_put_d7
 
173
 
 
174
fp_put_d0:
 
175
        printf  PREGISTER,"{d0<-%08x}",1,%d0
 
176
        move.l  %d0,(PT_OFF_D0+8,%sp)
 
177
        rts
 
178
 
 
179
fp_put_d1:
 
180
        printf  PREGISTER,"{d1<-%08x}",1,%d0
 
181
        move.l  %d0,(PT_OFF_D1+8,%sp)
 
182
        rts
 
183
 
 
184
fp_put_d2:
 
185
        printf  PREGISTER,"{d2<-%08x}",1,%d0
 
186
        move.l  %d0,(PT_OFF_D2+8,%sp)
 
187
        rts
 
188
 
 
189
fp_put_d3:
 
190
        printf  PREGISTER,"{d3<-%08x}",1,%d0
 
191
|       move.l  %d0,%d3
 
192
        move.l  %d0,(PT_OFF_D3+8,%sp)
 
193
        rts
 
194
 
 
195
fp_put_d4:
 
196
        printf  PREGISTER,"{d4<-%08x}",1,%d0
 
197
|       move.l  %d0,%d4
 
198
        move.l  %d0,(PT_OFF_D4+8,%sp)
 
199
        rts
 
200
 
 
201
fp_put_d5:
 
202
        printf  PREGISTER,"{d5<-%08x}",1,%d0
 
203
|       move.l  %d0,%d5
 
204
        move.l  %d0,(PT_OFF_D5+8,%sp)
 
205
        rts
 
206
 
 
207
fp_put_d6:
 
208
        printf  PREGISTER,"{d6<-%08x}",1,%d0
 
209
        move.l  %d0,%d6
 
210
        rts
 
211
 
 
212
fp_put_d7:
 
213
        printf  PREGISTER,"{d7<-%08x}",1,%d0
 
214
        move.l  %d0,%d7
 
215
        rts
 
216
 
 
217
fp_get_addr_reg:
 
218
        jmp     ([0f:w,%pc,%d0.w*4])
 
219
 
 
220
        .align  4
 
221
0:
 
222
        .long   fp_get_a0, fp_get_a1
 
223
        .long   fp_get_a2, fp_get_a3
 
224
        .long   fp_get_a4, fp_get_a5
 
225
        .long   fp_get_a6, fp_get_a7
 
226
 
 
227
fp_get_a0:
 
228
        move.l  (PT_OFF_A0+8,%sp),%a0
 
229
        printf  PREGISTER,"{a0->%08x}",1,%a0
 
230
        rts
 
231
 
 
232
fp_get_a1:
 
233
        move.l  (PT_OFF_A1+8,%sp),%a0
 
234
        printf  PREGISTER,"{a1->%08x}",1,%a0
 
235
        rts
 
236
 
 
237
fp_get_a2:
 
238
        move.l  (PT_OFF_A2+8,%sp),%a0
 
239
        printf  PREGISTER,"{a2->%08x}",1,%a0
 
240
        rts
 
241
 
 
242
fp_get_a3:
 
243
        move.l  %a3,%a0
 
244
        printf  PREGISTER,"{a3->%08x}",1,%a0
 
245
        rts
 
246
 
 
247
fp_get_a4:
 
248
        move.l  %a4,%a0
 
249
        printf  PREGISTER,"{a4->%08x}",1,%a0
 
250
        rts
 
251
 
 
252
fp_get_a5:
 
253
        move.l  %a5,%a0
 
254
        printf  PREGISTER,"{a5->%08x}",1,%a0
 
255
        rts
 
256
 
 
257
fp_get_a6:
 
258
        move.l  %a6,%a0
 
259
        printf  PREGISTER,"{a6->%08x}",1,%a0
 
260
        rts
 
261
 
 
262
fp_get_a7:
 
263
        move.l  %usp,%a0
 
264
        printf  PREGISTER,"{a7->%08x}",1,%a0
 
265
        rts
 
266
 
 
267
fp_put_addr_reg:
 
268
        jmp     ([0f:w,%pc,%d0.w*4])
 
269
 
 
270
        .align  4
 
271
0:
 
272
        .long   fp_put_a0, fp_put_a1
 
273
        .long   fp_put_a2, fp_put_a3
 
274
        .long   fp_put_a4, fp_put_a5
 
275
        .long   fp_put_a6, fp_put_a7
 
276
 
 
277
fp_put_a0:
 
278
        printf  PREGISTER,"{a0<-%08x}",1,%a0
 
279
        move.l  %a0,(PT_OFF_A0+8,%sp)
 
280
        rts
 
281
 
 
282
fp_put_a1:
 
283
        printf  PREGISTER,"{a1<-%08x}",1,%a0
 
284
        move.l  %a0,(PT_OFF_A1+8,%sp)
 
285
        rts
 
286
 
 
287
fp_put_a2:
 
288
        printf  PREGISTER,"{a2<-%08x}",1,%a0
 
289
        move.l  %a0,(PT_OFF_A2+8,%sp)
 
290
        rts
 
291
 
 
292
fp_put_a3:
 
293
        printf  PREGISTER,"{a3<-%08x}",1,%a0
 
294
        move.l  %a0,%a3
 
295
        rts
 
296
 
 
297
fp_put_a4:
 
298
        printf  PREGISTER,"{a4<-%08x}",1,%a0
 
299
        move.l  %a0,%a4
 
300
        rts
 
301
 
 
302
fp_put_a5:
 
303
        printf  PREGISTER,"{a5<-%08x}",1,%a0
 
304
        move.l  %a0,%a5
 
305
        rts
 
306
 
 
307
fp_put_a6:
 
308
        printf  PREGISTER,"{a6<-%08x}",1,%a0
 
309
        move.l  %a0,%a6
 
310
        rts
 
311
 
 
312
fp_put_a7:
 
313
        printf  PREGISTER,"{a7<-%08x}",1,%a0
 
314
        move.l  %a0,%usp
 
315
        rts
 
316
 
 
317
        .data
 
318
        .align  4
 
319
 
 
320
fp_debugprint:
 
321
|       .long   PMDECODE
 
322
        .long   PMINSTR+PMDECODE+PMCONV+PMNORM
 
323
|       .long   PMCONV+PMNORM+PMINSTR
 
324
|       .long   0