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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [config/] [arm/] [fpa.md] - Blame information for rev 709

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 709 jeremybenn
;;- Machine description for FPA co-processor for ARM cpus.
2
;;  Copyright 1991, 1993, 1994, 1995, 1996, 1996, 1997, 1998, 1999, 2000,
3
;;  2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4
;;  Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl)
5
;;  and Martin Simmons (@harleqn.co.uk).
6
;;  More major hacks by Richard Earnshaw (rearnsha@arm.com).
7
 
8
;; This file is part of GCC.
9
 
10
;; GCC is free software; you can redistribute it and/or modify it
11
;; under the terms of the GNU General Public License as published
12
;; by the Free Software Foundation; either version 3, or (at your
13
;; option) any later version.
14
 
15
;; GCC is distributed in the hope that it will be useful, but WITHOUT
16
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17
;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
18
;; License for more details.
19
 
20
;; You should have received a copy of the GNU General Public License
21
;; along with GCC; see the file COPYING3.  If not see
22
;; .
23
 
24
;; Some FPA mnemonics are ambiguous between conditional infixes and
25
;; conditional suffixes.  All instructions use a conditional infix,
26
;; even in unified assembly mode.
27
 
28
;; FPA automaton.
29
(define_automaton "armfp")
30
 
31
;; Floating point unit (FPA)
32
(define_cpu_unit "fpa" "armfp")
33
 
34
; The fpa10 doesn't really have a memory read unit, but it can start
35
; to speculatively execute the instruction in the pipeline, provided
36
; the data is already loaded, so pretend reads have a delay of 2 (and
37
; that the pipeline is infinite).
38
(define_cpu_unit "fpa_mem" "arm")
39
 
40
(define_insn_reservation "fdivx" 71
41
  (and (eq_attr "fpu" "fpa")
42
       (eq_attr "type" "fdivx"))
43
  "core+fpa*69")
44
 
45
(define_insn_reservation "fdivd" 59
46
  (and (eq_attr "fpu" "fpa")
47
       (eq_attr "type" "fdivd"))
48
  "core+fpa*57")
49
 
50
(define_insn_reservation "fdivs" 31
51
  (and (eq_attr "fpu" "fpa")
52
       (eq_attr "type" "fdivs"))
53
  "core+fpa*29")
54
 
55
(define_insn_reservation "fmul" 9
56
  (and (eq_attr "fpu" "fpa")
57
       (eq_attr "type" "fmul"))
58
  "core+fpa*7")
59
 
60
(define_insn_reservation "ffmul" 6
61
  (and (eq_attr "fpu" "fpa")
62
       (eq_attr "type" "ffmul"))
63
  "core+fpa*4")
64
 
65
(define_insn_reservation "farith" 4
66
  (and (eq_attr "fpu" "fpa")
67
       (eq_attr "type" "farith"))
68
  "core+fpa*2")
69
 
70
(define_insn_reservation "ffarith" 2
71
  (and (eq_attr "fpu" "fpa")
72
       (eq_attr "type" "ffarith"))
73
  "core+fpa*2")
74
 
75
(define_insn_reservation "r_2_f" 5
76
  (and (eq_attr "fpu" "fpa")
77
       (eq_attr "type" "r_2_f"))
78
  "core+fpa*3")
79
 
80
(define_insn_reservation "f_2_r" 1
81
  (and (eq_attr "fpu" "fpa")
82
       (eq_attr "type" "f_2_r"))
83
  "core+fpa*2")
84
 
85
(define_insn_reservation "f_load" 3
86
  (and (eq_attr "fpu" "fpa") (eq_attr "type" "f_fpa_load"))
87
  "fpa_mem+core*3")
88
 
89
(define_insn_reservation "f_store" 4
90
  (and (eq_attr "fpu" "fpa") (eq_attr "type" "f_fpa_store"))
91
  "core*4")
92
 
93
(define_insn_reservation "r_mem_f" 6
94
  (and (eq_attr "model_wbuf" "no")
95
    (and (eq_attr "fpu" "fpa") (eq_attr "type" "r_mem_f")))
96
  "core*6")
97
 
98
(define_insn_reservation "f_mem_r" 7
99
  (and (eq_attr "fpu" "fpa") (eq_attr "type" "f_mem_r"))
100
  "core*7")
101
 
102
 
103
(define_insn "*addsf3_fpa"
104
  [(set (match_operand:SF          0 "s_register_operand" "=f,f")
105
        (plus:SF (match_operand:SF 1 "s_register_operand" "%f,f")
106
                 (match_operand:SF 2 "arm_float_add_operand"    "fG,H")))]
107
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
108
  "@
109
   adf%?s\\t%0, %1, %2
110
   suf%?s\\t%0, %1, #%N2"
111
  [(set_attr "type" "farith")
112
   (set_attr "predicable" "yes")]
113
)
114
 
115
(define_insn "*adddf3_fpa"
116
  [(set (match_operand:DF          0 "s_register_operand" "=f,f")
117
        (plus:DF (match_operand:DF 1 "s_register_operand" "%f,f")
118
                 (match_operand:DF 2 "arm_float_add_operand"    "fG,H")))]
119
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
120
  "@
121
   adf%?d\\t%0, %1, %2
122
   suf%?d\\t%0, %1, #%N2"
123
  [(set_attr "type" "farith")
124
   (set_attr "predicable" "yes")]
125
)
126
 
127
(define_insn "*adddf_esfdf_df_fpa"
128
  [(set (match_operand:DF           0 "s_register_operand" "=f,f")
129
        (plus:DF (float_extend:DF
130
                  (match_operand:SF 1 "s_register_operand"  "f,f"))
131
                 (match_operand:DF  2 "arm_float_add_operand"    "fG,H")))]
132
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
133
  "@
134
   adf%?d\\t%0, %1, %2
135
   suf%?d\\t%0, %1, #%N2"
136
  [(set_attr "type" "farith")
137
   (set_attr "predicable" "yes")]
138
)
139
 
140
(define_insn "*adddf_df_esfdf_fpa"
141
  [(set (match_operand:DF           0 "s_register_operand" "=f")
142
        (plus:DF (match_operand:DF  1 "s_register_operand"  "f")
143
                 (float_extend:DF
144
                  (match_operand:SF 2 "s_register_operand"  "f"))))]
145
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
146
  "adf%?d\\t%0, %1, %2"
147
  [(set_attr "type" "farith")
148
   (set_attr "predicable" "yes")]
149
)
150
 
151
(define_insn "*adddf_esfdf_esfdf_fpa"
152
  [(set (match_operand:DF           0 "s_register_operand" "=f")
153
        (plus:DF (float_extend:DF
154
                  (match_operand:SF 1 "s_register_operand" "f"))
155
                 (float_extend:DF
156
                  (match_operand:SF 2 "s_register_operand" "f"))))]
157
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
158
  "adf%?d\\t%0, %1, %2"
159
  [(set_attr "type" "farith")
160
   (set_attr "predicable" "yes")]
161
)
162
 
163
(define_insn "*subsf3_fpa"
164
  [(set (match_operand:SF 0 "s_register_operand" "=f,f")
165
        (minus:SF (match_operand:SF 1 "arm_float_rhs_operand" "f,G")
166
                  (match_operand:SF 2 "arm_float_rhs_operand" "fG,f")))]
167
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
168
  "@
169
   suf%?s\\t%0, %1, %2
170
   rsf%?s\\t%0, %2, %1"
171
  [(set_attr "type" "farith")]
172
)
173
 
174
(define_insn "*subdf3_fpa"
175
  [(set (match_operand:DF           0 "s_register_operand" "=f,f")
176
        (minus:DF (match_operand:DF 1 "arm_float_rhs_operand"     "f,G")
177
                  (match_operand:DF 2 "arm_float_rhs_operand"    "fG,f")))]
178
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
179
  "@
180
   suf%?d\\t%0, %1, %2
181
   rsf%?d\\t%0, %2, %1"
182
  [(set_attr "type" "farith")
183
   (set_attr "predicable" "yes")]
184
)
185
 
186
(define_insn "*subdf_esfdf_df_fpa"
187
  [(set (match_operand:DF            0 "s_register_operand" "=f")
188
        (minus:DF (float_extend:DF
189
                   (match_operand:SF 1 "s_register_operand"  "f"))
190
                  (match_operand:DF  2 "arm_float_rhs_operand"    "fG")))]
191
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
192
  "suf%?d\\t%0, %1, %2"
193
  [(set_attr "type" "farith")
194
   (set_attr "predicable" "yes")]
195
)
196
 
197
(define_insn "*subdf_df_esfdf_fpa"
198
  [(set (match_operand:DF 0 "s_register_operand" "=f,f")
199
        (minus:DF (match_operand:DF 1 "arm_float_rhs_operand" "f,G")
200
                  (float_extend:DF
201
                   (match_operand:SF 2 "s_register_operand" "f,f"))))]
202
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
203
  "@
204
   suf%?d\\t%0, %1, %2
205
   rsf%?d\\t%0, %2, %1"
206
  [(set_attr "type" "farith")
207
   (set_attr "predicable" "yes")]
208
)
209
 
210
(define_insn "*subdf_esfdf_esfdf_fpa"
211
  [(set (match_operand:DF 0 "s_register_operand" "=f")
212
        (minus:DF (float_extend:DF
213
                   (match_operand:SF 1 "s_register_operand" "f"))
214
                  (float_extend:DF
215
                   (match_operand:SF 2 "s_register_operand" "f"))))]
216
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
217
  "suf%?d\\t%0, %1, %2"
218
  [(set_attr "type" "farith")
219
   (set_attr "predicable" "yes")]
220
)
221
 
222
(define_insn "*mulsf3_fpa"
223
  [(set (match_operand:SF 0 "s_register_operand" "=f")
224
        (mult:SF (match_operand:SF 1 "s_register_operand" "f")
225
                 (match_operand:SF 2 "arm_float_rhs_operand" "fG")))]
226
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
227
  "fml%?s\\t%0, %1, %2"
228
  [(set_attr "type" "ffmul")
229
   (set_attr "predicable" "yes")]
230
)
231
 
232
(define_insn "*muldf3_fpa"
233
  [(set (match_operand:DF 0 "s_register_operand" "=f")
234
        (mult:DF (match_operand:DF 1 "s_register_operand" "f")
235
                 (match_operand:DF 2 "arm_float_rhs_operand" "fG")))]
236
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
237
  "muf%?d\\t%0, %1, %2"
238
  [(set_attr "type" "fmul")
239
   (set_attr "predicable" "yes")]
240
)
241
 
242
(define_insn "*muldf_esfdf_df_fpa"
243
  [(set (match_operand:DF 0 "s_register_operand" "=f")
244
        (mult:DF (float_extend:DF
245
                  (match_operand:SF 1 "s_register_operand" "f"))
246
                 (match_operand:DF 2 "arm_float_rhs_operand" "fG")))]
247
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
248
  "muf%?d\\t%0, %1, %2"
249
  [(set_attr "type" "fmul")
250
   (set_attr "predicable" "yes")]
251
)
252
 
253
(define_insn "*muldf_df_esfdf_fpa"
254
  [(set (match_operand:DF 0 "s_register_operand" "=f")
255
        (mult:DF (match_operand:DF 1 "s_register_operand" "f")
256
                 (float_extend:DF
257
                  (match_operand:SF 2 "s_register_operand" "f"))))]
258
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
259
  "muf%?d\\t%0, %1, %2"
260
  [(set_attr "type" "fmul")
261
   (set_attr "predicable" "yes")]
262
)
263
 
264
(define_insn "*muldf_esfdf_esfdf_fpa"
265
  [(set (match_operand:DF 0 "s_register_operand" "=f")
266
        (mult:DF
267
         (float_extend:DF (match_operand:SF 1 "s_register_operand" "f"))
268
         (float_extend:DF (match_operand:SF 2 "s_register_operand" "f"))))]
269
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
270
  "muf%?d\\t%0, %1, %2"
271
  [(set_attr "type" "fmul")
272
   (set_attr "predicable" "yes")]
273
)
274
 
275
;; Division insns
276
 
277
(define_insn "*divsf3_fpa"
278
  [(set (match_operand:SF 0 "s_register_operand" "=f,f")
279
        (div:SF (match_operand:SF 1 "arm_float_rhs_operand" "f,G")
280
                (match_operand:SF 2 "arm_float_rhs_operand" "fG,f")))]
281
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
282
  "@
283
   fdv%?s\\t%0, %1, %2
284
   frd%?s\\t%0, %2, %1"
285
  [(set_attr "type" "fdivs")
286
   (set_attr "predicable" "yes")]
287
)
288
 
289
(define_insn "*divdf3_fpa"
290
  [(set (match_operand:DF 0 "s_register_operand" "=f,f")
291
        (div:DF (match_operand:DF 1 "arm_float_rhs_operand" "f,G")
292
                (match_operand:DF 2 "arm_float_rhs_operand" "fG,f")))]
293
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
294
  "@
295
   dvf%?d\\t%0, %1, %2
296
   rdf%?d\\t%0, %2, %1"
297
  [(set_attr "type" "fdivd")
298
   (set_attr "predicable" "yes")]
299
)
300
 
301
(define_insn "*divdf_esfdf_df_fpa"
302
  [(set (match_operand:DF 0 "s_register_operand" "=f")
303
        (div:DF (float_extend:DF
304
                 (match_operand:SF 1 "s_register_operand" "f"))
305
                (match_operand:DF 2 "arm_float_rhs_operand" "fG")))]
306
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
307
  "dvf%?d\\t%0, %1, %2"
308
  [(set_attr "type" "fdivd")
309
   (set_attr "predicable" "yes")]
310
)
311
 
312
(define_insn "*divdf_df_esfdf_fpa"
313
  [(set (match_operand:DF 0 "s_register_operand" "=f")
314
        (div:DF (match_operand:DF 1 "arm_float_rhs_operand" "fG")
315
                (float_extend:DF
316
                 (match_operand:SF 2 "s_register_operand" "f"))))]
317
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
318
  "rdf%?d\\t%0, %2, %1"
319
  [(set_attr "type" "fdivd")
320
   (set_attr "predicable" "yes")]
321
)
322
 
323
(define_insn "*divdf_esfdf_esfdf_fpa"
324
  [(set (match_operand:DF 0 "s_register_operand" "=f")
325
        (div:DF (float_extend:DF
326
                 (match_operand:SF 1 "s_register_operand" "f"))
327
                (float_extend:DF
328
                 (match_operand:SF 2 "s_register_operand" "f"))))]
329
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
330
  "dvf%?d\\t%0, %1, %2"
331
  [(set_attr "type" "fdivd")
332
   (set_attr "predicable" "yes")]
333
)
334
 
335
(define_insn "*modsf3_fpa"
336
  [(set (match_operand:SF 0 "s_register_operand" "=f")
337
        (mod:SF (match_operand:SF 1 "s_register_operand" "f")
338
                (match_operand:SF 2 "arm_float_rhs_operand" "fG")))]
339
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
340
  "rmf%?s\\t%0, %1, %2"
341
  [(set_attr "type" "fdivs")
342
   (set_attr "predicable" "yes")]
343
)
344
 
345
(define_insn "*moddf3_fpa"
346
  [(set (match_operand:DF 0 "s_register_operand" "=f")
347
        (mod:DF (match_operand:DF 1 "s_register_operand" "f")
348
                (match_operand:DF 2 "arm_float_rhs_operand" "fG")))]
349
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
350
  "rmf%?d\\t%0, %1, %2"
351
  [(set_attr "type" "fdivd")
352
   (set_attr "predicable" "yes")]
353
)
354
 
355
(define_insn "*moddf_esfdf_df_fpa"
356
  [(set (match_operand:DF 0 "s_register_operand" "=f")
357
        (mod:DF (float_extend:DF
358
                 (match_operand:SF 1 "s_register_operand" "f"))
359
                (match_operand:DF 2 "arm_float_rhs_operand" "fG")))]
360
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
361
  "rmf%?d\\t%0, %1, %2"
362
  [(set_attr "type" "fdivd")
363
   (set_attr "predicable" "yes")]
364
)
365
 
366
(define_insn "*moddf_df_esfdf_fpa"
367
  [(set (match_operand:DF 0 "s_register_operand" "=f")
368
        (mod:DF (match_operand:DF 1 "s_register_operand" "f")
369
                (float_extend:DF
370
                 (match_operand:SF 2 "s_register_operand" "f"))))]
371
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
372
  "rmf%?d\\t%0, %1, %2"
373
  [(set_attr "type" "fdivd")
374
   (set_attr "predicable" "yes")]
375
)
376
 
377
(define_insn "*moddf_esfdf_esfdf_fpa"
378
  [(set (match_operand:DF 0 "s_register_operand" "=f")
379
        (mod:DF (float_extend:DF
380
                 (match_operand:SF 1 "s_register_operand" "f"))
381
                (float_extend:DF
382
                 (match_operand:SF 2 "s_register_operand" "f"))))]
383
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
384
  "rmf%?d\\t%0, %1, %2"
385
  [(set_attr "type" "fdivd")
386
   (set_attr "predicable" "yes")]
387
)
388
 
389
(define_insn "*negsf2_fpa"
390
  [(set (match_operand:SF         0 "s_register_operand" "=f")
391
        (neg:SF (match_operand:SF 1 "s_register_operand" "f")))]
392
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
393
  "mnf%?s\\t%0, %1"
394
  [(set_attr "type" "ffarith")
395
   (set_attr "predicable" "yes")]
396
)
397
 
398
(define_insn "*negdf2_fpa"
399
  [(set (match_operand:DF         0 "s_register_operand" "=f")
400
        (neg:DF (match_operand:DF 1 "s_register_operand" "f")))]
401
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
402
  "mnf%?d\\t%0, %1"
403
  [(set_attr "type" "ffarith")
404
   (set_attr "predicable" "yes")]
405
)
406
 
407
(define_insn "*negdf_esfdf_fpa"
408
  [(set (match_operand:DF 0 "s_register_operand" "=f")
409
        (neg:DF (float_extend:DF
410
                 (match_operand:SF 1 "s_register_operand" "f"))))]
411
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
412
  "mnf%?d\\t%0, %1"
413
  [(set_attr "type" "ffarith")
414
   (set_attr "predicable" "yes")]
415
)
416
 
417
(define_insn "*abssf2_fpa"
418
  [(set (match_operand:SF          0 "s_register_operand" "=f")
419
         (abs:SF (match_operand:SF 1 "s_register_operand" "f")))]
420
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
421
  "abs%?s\\t%0, %1"
422
  [(set_attr "type" "ffarith")
423
   (set_attr "predicable" "yes")]
424
)
425
 
426
(define_insn "*absdf2_fpa"
427
  [(set (match_operand:DF         0 "s_register_operand" "=f")
428
        (abs:DF (match_operand:DF 1 "s_register_operand" "f")))]
429
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
430
  "abs%?d\\t%0, %1"
431
  [(set_attr "type" "ffarith")
432
   (set_attr "predicable" "yes")]
433
)
434
 
435
(define_insn "*absdf_esfdf_fpa"
436
  [(set (match_operand:DF 0 "s_register_operand" "=f")
437
        (abs:DF (float_extend:DF
438
                 (match_operand:SF 1 "s_register_operand" "f"))))]
439
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
440
  "abs%?d\\t%0, %1"
441
  [(set_attr "type" "ffarith")
442
   (set_attr "predicable" "yes")]
443
)
444
 
445
(define_insn "*sqrtsf2_fpa"
446
  [(set (match_operand:SF 0 "s_register_operand" "=f")
447
        (sqrt:SF (match_operand:SF 1 "s_register_operand" "f")))]
448
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
449
  "sqt%?s\\t%0, %1"
450
  [(set_attr "type" "float_em")
451
   (set_attr "predicable" "yes")]
452
)
453
 
454
(define_insn "*sqrtdf2_fpa"
455
  [(set (match_operand:DF 0 "s_register_operand" "=f")
456
        (sqrt:DF (match_operand:DF 1 "s_register_operand" "f")))]
457
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
458
  "sqt%?d\\t%0, %1"
459
  [(set_attr "type" "float_em")
460
   (set_attr "predicable" "yes")]
461
)
462
 
463
(define_insn "*sqrtdf_esfdf_fpa"
464
  [(set (match_operand:DF 0 "s_register_operand" "=f")
465
        (sqrt:DF (float_extend:DF
466
                  (match_operand:SF 1 "s_register_operand" "f"))))]
467
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
468
  "sqt%?d\\t%0, %1"
469
  [(set_attr "type" "float_em")
470
   (set_attr "predicable" "yes")]
471
)
472
 
473
(define_insn "*floatsisf2_fpa"
474
  [(set (match_operand:SF           0 "s_register_operand" "=f")
475
        (float:SF (match_operand:SI 1 "s_register_operand" "r")))]
476
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
477
  "flt%?s\\t%0, %1"
478
  [(set_attr "type" "r_2_f")
479
   (set_attr "predicable" "yes")]
480
)
481
 
482
(define_insn "*floatsidf2_fpa"
483
  [(set (match_operand:DF           0 "s_register_operand" "=f")
484
        (float:DF (match_operand:SI 1 "s_register_operand" "r")))]
485
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
486
  "flt%?d\\t%0, %1"
487
  [(set_attr "type" "r_2_f")
488
   (set_attr "predicable" "yes")]
489
)
490
 
491
(define_insn "*fix_truncsfsi2_fpa"
492
  [(set (match_operand:SI         0 "s_register_operand" "=r")
493
        (fix:SI (fix:SF (match_operand:SF 1 "s_register_operand" "f"))))]
494
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
495
  "fix%?z\\t%0, %1"
496
  [(set_attr "type" "f_2_r")
497
   (set_attr "predicable" "yes")]
498
)
499
 
500
(define_insn "*fix_truncdfsi2_fpa"
501
  [(set (match_operand:SI         0 "s_register_operand" "=r")
502
        (fix:SI (fix:DF (match_operand:DF 1 "s_register_operand" "f"))))]
503
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
504
  "fix%?z\\t%0, %1"
505
  [(set_attr "type" "f_2_r")
506
   (set_attr "predicable" "yes")]
507
)
508
 
509
(define_insn "*truncdfsf2_fpa"
510
  [(set (match_operand:SF 0 "s_register_operand" "=f")
511
        (float_truncate:SF
512
         (match_operand:DF 1 "s_register_operand" "f")))]
513
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
514
  "mvf%?s\\t%0, %1"
515
  [(set_attr "type" "ffarith")
516
   (set_attr "predicable" "yes")]
517
)
518
 
519
(define_insn "*extendsfdf2_fpa"
520
  [(set (match_operand:DF                  0 "s_register_operand" "=f")
521
        (float_extend:DF (match_operand:SF 1 "s_register_operand"  "f")))]
522
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
523
  "mvf%?d\\t%0, %1"
524
  [(set_attr "type" "ffarith")
525
   (set_attr "predicable" "yes")]
526
)
527
 
528
(define_insn "*movsf_fpa"
529
  [(set (match_operand:SF 0 "nonimmediate_operand" "=f,f,f, m,f,r,r,r, m")
530
        (match_operand:SF 1 "general_operand"      "fG,H,mE,f,r,f,r,mE,r"))]
531
  "TARGET_ARM
532
   && TARGET_HARD_FLOAT && TARGET_FPA
533
   && (GET_CODE (operands[0]) != MEM
534
       || register_operand (operands[1], SFmode))"
535
  "@
536
   mvf%?s\\t%0, %1
537
   mnf%?s\\t%0, #%N1
538
   ldf%?s\\t%0, %1
539
   stf%?s\\t%1, %0
540
   str%?\\t%1, [%|sp, #-4]!\;ldf%?s\\t%0, [%|sp], #4
541
   stf%?s\\t%1, [%|sp, #-4]!\;ldr%?\\t%0, [%|sp], #4
542
   mov%?\\t%0, %1
543
   ldr%?\\t%0, %1\\t%@ float
544
   str%?\\t%1, %0\\t%@ float"
545
  [(set_attr "length" "4,4,4,4,8,8,4,4,4")
546
   (set_attr "predicable" "yes")
547
   (set_attr "type"
548
         "ffarith,ffarith,f_fpa_load,f_fpa_store,r_mem_f,f_mem_r,*,load1,store1")
549
   (set_attr "pool_range" "*,*,1024,*,*,*,*,4096,*")
550
   (set_attr "neg_pool_range" "*,*,1012,*,*,*,*,4084,*")]
551
)
552
 
553
(define_insn "*movdf_fpa"
554
  [(set (match_operand:DF 0 "nonimmediate_operand"
555
                                                "=r,Q,r,m,r, f, f,f, m,!f,!r")
556
        (match_operand:DF 1 "general_operand"
557
                                                "Q, r,r,r,mF,fG,H,mF,f,r, f"))]
558
  "TARGET_ARM
559
   && TARGET_HARD_FLOAT && TARGET_FPA
560
   && (GET_CODE (operands[0]) != MEM
561
       || register_operand (operands[1], DFmode))"
562
  "*
563
  {
564
  switch (which_alternative)
565
    {
566
    default:
567
    case 0: return \"ldm%(ia%)\\t%m1, %M0\\t%@ double\";
568
    case 1: return \"stm%(ia%)\\t%m0, %M1\\t%@ double\";
569
    case 2: return \"#\";
570
    case 3: case 4: return output_move_double (operands, true, NULL);
571
    case 5: return \"mvf%?d\\t%0, %1\";
572
    case 6: return \"mnf%?d\\t%0, #%N1\";
573
    case 7: return \"ldf%?d\\t%0, %1\";
574
    case 8: return \"stf%?d\\t%1, %0\";
575
    case 9: return output_mov_double_fpa_from_arm (operands);
576
    case 10: return output_mov_double_arm_from_fpa (operands);
577
    }
578
  }
579
  "
580
  [(set_attr "length" "4,4,8,8,8,4,4,4,4,8,8")
581
   (set_attr "predicable" "yes")
582
   (set_attr "type"
583
    "load1,store2,*,store2,load1,ffarith,ffarith,f_fpa_load,f_fpa_store,r_mem_f,f_mem_r")
584
   (set_attr "pool_range" "*,*,*,*,1020,*,*,1024,*,*,*")
585
   (set_attr "neg_pool_range" "*,*,*,*,1008,*,*,1008,*,*,*")]
586
)
587
 
588
;; We treat XFmode as meaning 'internal format'.  It's the right size and we
589
;; don't use it for anything else.  We only support moving between FPA
590
;; registers and moving an FPA register to/from memory.
591
(define_insn "*movxf_fpa"
592
  [(set (match_operand:XF 0 "nonimmediate_operand" "=f,f,m")
593
        (match_operand:XF 1 "general_operand" "f,m,f"))]
594
  "TARGET_ARM && TARGET_HARD_FLOAT && TARGET_FPA
595
   && (register_operand (operands[0], XFmode)
596
       || register_operand (operands[1], XFmode))"
597
  "*
598
  switch (which_alternative)
599
    {
600
    default:
601
    case 0: return \"mvf%?e\\t%0, %1\";
602
    case 1: if (TARGET_FPA_EMU2)
603
              return \"ldf%?e\\t%0, %1\";
604
            return \"lfm%?\\t%0, 1, %1\";
605
    case 2: if (TARGET_FPA_EMU2)
606
              return \"stf%?e\\t%1, %0\";
607
            return \"sfm%?\\t%1, 1, %0\";
608
    }
609
  "
610
  [(set_attr "length" "4,4,4")
611
   (set_attr "predicable" "yes")
612
   (set_attr "type" "ffarith,f_fpa_load,f_fpa_store")]
613
)
614
 
615
;; stfs/ldfs always use a conditional infix.  This works around the
616
;; ambiguity between "stf pl s" and "sftp ls".
617
(define_insn "*thumb2_movsf_fpa"
618
  [(set (match_operand:SF 0 "nonimmediate_operand" "=f,f,f, m,f,r,r,r, m")
619
        (match_operand:SF 1 "general_operand"      "fG,H,mE,f,r,f,r,mE,r"))]
620
  "TARGET_THUMB2
621
   && TARGET_HARD_FLOAT && TARGET_FPA
622
   && (GET_CODE (operands[0]) != MEM
623
       || register_operand (operands[1], SFmode))"
624
  "@
625
   mvf%?s\\t%0, %1
626
   mnf%?s\\t%0, #%N1
627
   ldf%?s\\t%0, %1
628
   stf%?s\\t%1, %0
629
   str%?\\t%1, [%|sp, #-4]!\;ldf%?s\\t%0, [%|sp], #4
630
   stf%?s\\t%1, [%|sp, #-4]!\;ldr%?\\t%0, [%|sp], #4
631
   mov%?\\t%0, %1 @bar
632
   ldr%?\\t%0, %1\\t%@ float
633
   str%?\\t%1, %0\\t%@ float"
634
  [(set_attr "length" "4,4,4,4,8,8,4,4,4")
635
   (set_attr "ce_count" "1,1,1,1,2,2,1,1,1")
636
   (set_attr "predicable" "yes")
637
   (set_attr "type"
638
         "ffarith,ffarith,f_fpa_load,f_fpa_store,r_mem_f,f_mem_r,*,load1,store1")
639
   (set_attr "pool_range" "*,*,1024,*,*,*,*,4096,*")
640
   (set_attr "neg_pool_range" "*,*,1012,*,*,*,*,0,*")]
641
)
642
 
643
;; Not predicable because we don't know the number of instructions.
644
(define_insn "*thumb2_movdf_fpa"
645
  [(set (match_operand:DF 0 "nonimmediate_operand"
646
                                                "=r,Q,r,m,r, f, f,f, m,!f,!r")
647
        (match_operand:DF 1 "general_operand"
648
                                                "Q, r,r,r,mF,fG,H,mF,f,r, f"))]
649
  "TARGET_THUMB2
650
   && TARGET_HARD_FLOAT && TARGET_FPA
651
   && (GET_CODE (operands[0]) != MEM
652
       || register_operand (operands[1], DFmode))"
653
  "*
654
  {
655
  switch (which_alternative)
656
    {
657
    default:
658
    case 0: return \"ldm%(ia%)\\t%m1, %M0\\t%@ double\";
659
    case 1: return \"stm%(ia%)\\t%m0, %M1\\t%@ double\";
660
    case 2: case 3: case 4: return output_move_double (operands, true, NULL);
661
    case 5: return \"mvf%?d\\t%0, %1\";
662
    case 6: return \"mnf%?d\\t%0, #%N1\";
663
    case 7: return \"ldf%?d\\t%0, %1\";
664
    case 8: return \"stf%?d\\t%1, %0\";
665
    case 9: return output_mov_double_fpa_from_arm (operands);
666
    case 10: return output_mov_double_arm_from_fpa (operands);
667
    }
668
  }
669
  "
670
  [(set_attr "length" "4,4,8,8,8,4,4,4,4,8,8")
671
   (set_attr "type"
672
    "load1,store2,*,store2,load1,ffarith,ffarith,f_fpa_load,f_fpa_store,r_mem_f,f_mem_r")
673
   (set_attr "pool_range" "*,*,*,*,4092,*,*,1024,*,*,*")
674
   (set_attr "neg_pool_range" "*,*,*,*,0,*,*,1008,*,*,*")]
675
)
676
 
677
;; Saving and restoring the floating point registers in the prologue should
678
;; be done in XFmode, even though we don't support that for anything else
679
;; (Well, strictly it's 'internal representation', but that's effectively
680
;; XFmode).
681
;; Not predicable because we don't know the number of instructions.
682
 
683
(define_insn "*thumb2_movxf_fpa"
684
  [(set (match_operand:XF 0 "nonimmediate_operand" "=f,f,f,m,f,r,r")
685
        (match_operand:XF 1 "general_operand" "fG,H,m,f,r,f,r"))]
686
  "TARGET_THUMB2 && TARGET_HARD_FLOAT && TARGET_FPA && reload_completed"
687
  "*
688
  switch (which_alternative)
689
    {
690
    default:
691
    case 0: return \"mvf%?e\\t%0, %1\";
692
    case 1: return \"mnf%?e\\t%0, #%N1\";
693
    case 2: return \"ldf%?e\\t%0, %1\";
694
    case 3: return \"stf%?e\\t%1, %0\";
695
    case 4: return output_mov_long_double_fpa_from_arm (operands);
696
    case 5: return output_mov_long_double_arm_from_fpa (operands);
697
    case 6: return output_mov_long_double_arm_from_arm (operands);
698
    }
699
  "
700
  [(set_attr "length" "4,4,4,4,8,8,12")
701
   (set_attr "type" "ffarith,ffarith,f_fpa_load,f_fpa_store,r_mem_f,f_mem_r,*")
702
   (set_attr "pool_range" "*,*,1024,*,*,*,*")
703
   (set_attr "neg_pool_range" "*,*,1004,*,*,*,*")]
704
)
705
 
706
(define_insn "*cmpsf_fpa"
707
  [(set (reg:CCFP CC_REGNUM)
708
        (compare:CCFP (match_operand:SF 0 "s_register_operand" "f,f")
709
                      (match_operand:SF 1 "arm_float_add_operand" "fG,H")))]
710
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
711
  "@
712
   cmf%?\\t%0, %1
713
   cnf%?\\t%0, #%N1"
714
  [(set_attr "conds" "set")
715
   (set_attr "type" "f_2_r")]
716
)
717
 
718
(define_insn "*cmpdf_fpa"
719
  [(set (reg:CCFP CC_REGNUM)
720
        (compare:CCFP (match_operand:DF 0 "s_register_operand" "f,f")
721
                      (match_operand:DF 1 "arm_float_add_operand" "fG,H")))]
722
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
723
  "@
724
   cmf%?\\t%0, %1
725
   cnf%?\\t%0, #%N1"
726
  [(set_attr "conds" "set")
727
   (set_attr "type" "f_2_r")]
728
)
729
 
730
(define_insn "*cmpesfdf_df_fpa"
731
  [(set (reg:CCFP CC_REGNUM)
732
        (compare:CCFP (float_extend:DF
733
                       (match_operand:SF 0 "s_register_operand" "f,f"))
734
                      (match_operand:DF 1 "arm_float_add_operand" "fG,H")))]
735
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
736
  "@
737
   cmf%?\\t%0, %1
738
   cnf%?\\t%0, #%N1"
739
  [(set_attr "conds" "set")
740
   (set_attr "type" "f_2_r")]
741
)
742
 
743
(define_insn "*cmpdf_esfdf_fpa"
744
  [(set (reg:CCFP CC_REGNUM)
745
        (compare:CCFP (match_operand:DF 0 "s_register_operand" "f")
746
                      (float_extend:DF
747
                       (match_operand:SF 1 "s_register_operand" "f"))))]
748
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
749
  "cmf%?\\t%0, %1"
750
  [(set_attr "conds" "set")
751
   (set_attr "type" "f_2_r")]
752
)
753
 
754
(define_insn "*cmpsf_trap_fpa"
755
  [(set (reg:CCFPE CC_REGNUM)
756
        (compare:CCFPE (match_operand:SF 0 "s_register_operand" "f,f")
757
                       (match_operand:SF 1 "arm_float_add_operand" "fG,H")))]
758
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
759
  "@
760
   cmf%?e\\t%0, %1
761
   cnf%?e\\t%0, #%N1"
762
  [(set_attr "conds" "set")
763
   (set_attr "type" "f_2_r")]
764
)
765
 
766
(define_insn "*cmpdf_trap_fpa"
767
  [(set (reg:CCFPE CC_REGNUM)
768
        (compare:CCFPE (match_operand:DF 0 "s_register_operand" "f,f")
769
                       (match_operand:DF 1 "arm_float_add_operand" "fG,H")))]
770
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
771
  "@
772
   cmf%?e\\t%0, %1
773
   cnf%?e\\t%0, #%N1"
774
  [(set_attr "conds" "set")
775
   (set_attr "type" "f_2_r")]
776
)
777
 
778
(define_insn "*cmp_esfdf_df_trap_fpa"
779
  [(set (reg:CCFPE CC_REGNUM)
780
        (compare:CCFPE (float_extend:DF
781
                        (match_operand:SF 0 "s_register_operand" "f,f"))
782
                       (match_operand:DF 1 "arm_float_add_operand" "fG,H")))]
783
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
784
  "@
785
   cmf%?e\\t%0, %1
786
   cnf%?e\\t%0, #%N1"
787
  [(set_attr "conds" "set")
788
   (set_attr "type" "f_2_r")]
789
)
790
 
791
(define_insn "*cmp_df_esfdf_trap_fpa"
792
  [(set (reg:CCFPE CC_REGNUM)
793
        (compare:CCFPE (match_operand:DF 0 "s_register_operand" "f")
794
                       (float_extend:DF
795
                        (match_operand:SF 1 "s_register_operand" "f"))))]
796
  "TARGET_32BIT && TARGET_HARD_FLOAT && TARGET_FPA"
797
  "cmf%?e\\t%0, %1"
798
  [(set_attr "conds" "set")
799
   (set_attr "type" "f_2_r")]
800
)
801
 
802
(define_insn "*movsfcc_fpa"
803
  [(set (match_operand:SF 0 "s_register_operand" "=f,f,f,f,f,f,f,f")
804
        (if_then_else:SF
805
         (match_operator 3 "arm_comparison_operator"
806
          [(match_operand 4 "cc_register" "") (const_int 0)])
807
         (match_operand:SF 1 "arm_float_add_operand" "0,0,fG,H,fG,fG,H,H")
808
         (match_operand:SF 2 "arm_float_add_operand" "fG,H,0,0,fG,H,fG,H")))]
809
  "TARGET_ARM && TARGET_HARD_FLOAT && TARGET_FPA"
810
  "@
811
   mvf%D3s\\t%0, %2
812
   mnf%D3s\\t%0, #%N2
813
   mvf%d3s\\t%0, %1
814
   mnf%d3s\\t%0, #%N1
815
   mvf%d3s\\t%0, %1\;mvf%D3s\\t%0, %2
816
   mvf%d3s\\t%0, %1\;mnf%D3s\\t%0, #%N2
817
   mnf%d3s\\t%0, #%N1\;mvf%D3s\\t%0, %2
818
   mnf%d3s\\t%0, #%N1\;mnf%D3s\\t%0, #%N2"
819
  [(set_attr "length" "4,4,4,4,8,8,8,8")
820
   (set_attr "type" "ffarith")
821
   (set_attr "conds" "use")]
822
)
823
 
824
(define_insn "*movdfcc_fpa"
825
  [(set (match_operand:DF 0 "s_register_operand" "=f,f,f,f,f,f,f,f")
826
        (if_then_else:DF
827
         (match_operator 3 "arm_comparison_operator"
828
          [(match_operand 4 "cc_register" "") (const_int 0)])
829
         (match_operand:DF 1 "arm_float_add_operand" "0,0,fG,H,fG,fG,H,H")
830
         (match_operand:DF 2 "arm_float_add_operand" "fG,H,0,0,fG,H,fG,H")))]
831
  "TARGET_ARM && TARGET_HARD_FLOAT && TARGET_FPA"
832
  "@
833
   mvf%D3d\\t%0, %2
834
   mnf%D3d\\t%0, #%N2
835
   mvf%d3d\\t%0, %1
836
   mnf%d3d\\t%0, #%N1
837
   mvf%d3d\\t%0, %1\;mvf%D3d\\t%0, %2
838
   mvf%d3d\\t%0, %1\;mnf%D3d\\t%0, #%N2
839
   mnf%d3d\\t%0, #%N1\;mvf%D3d\\t%0, %2
840
   mnf%d3d\\t%0, #%N1\;mnf%D3d\\t%0, #%N2"
841
  [(set_attr "length" "4,4,4,4,8,8,8,8")
842
   (set_attr "type" "ffarith")
843
   (set_attr "conds" "use")]
844
)
845
 
846
(define_insn "*thumb2_movsfcc_fpa"
847
  [(set (match_operand:SF 0 "s_register_operand" "=f,f,f,f,f,f,f,f")
848
        (if_then_else:SF
849
         (match_operator 3 "arm_comparison_operator"
850
          [(match_operand 4 "cc_register" "") (const_int 0)])
851
         (match_operand:SF 1 "arm_float_add_operand" "0,0,fG,H,fG,fG,H,H")
852
         (match_operand:SF 2 "arm_float_add_operand" "fG,H,0,0,fG,H,fG,H")))]
853
  "TARGET_THUMB2 && TARGET_HARD_FLOAT && TARGET_FPA"
854
  "@
855
   it\\t%D3\;mvf%D3s\\t%0, %2
856
   it\\t%D3\;mnf%D3s\\t%0, #%N2
857
   it\\t%d3\;mvf%d3s\\t%0, %1
858
   it\\t%d3\;mnf%d3s\\t%0, #%N1
859
   ite\\t%d3\;mvf%d3s\\t%0, %1\;mvf%D3s\\t%0, %2
860
   ite\\t%d3\;mvf%d3s\\t%0, %1\;mnf%D3s\\t%0, #%N2
861
   ite\\t%d3\;mnf%d3s\\t%0, #%N1\;mvf%D3s\\t%0, %2
862
   ite\\t%d3\;mnf%d3s\\t%0, #%N1\;mnf%D3s\\t%0, #%N2"
863
  [(set_attr "length" "6,6,6,6,10,10,10,10")
864
   (set_attr "type" "ffarith")
865
   (set_attr "conds" "use")]
866
)
867
 
868
(define_insn "*thumb2_movdfcc_fpa"
869
  [(set (match_operand:DF 0 "s_register_operand" "=f,f,f,f,f,f,f,f")
870
        (if_then_else:DF
871
         (match_operator 3 "arm_comparison_operator"
872
          [(match_operand 4 "cc_register" "") (const_int 0)])
873
         (match_operand:DF 1 "arm_float_add_operand" "0,0,fG,H,fG,fG,H,H")
874
         (match_operand:DF 2 "arm_float_add_operand" "fG,H,0,0,fG,H,fG,H")))]
875
  "TARGET_THUMB2 && TARGET_HARD_FLOAT && TARGET_FPA"
876
  "@
877
   it\\t%D3\;mvf%D3d\\t%0, %2
878
   it\\t%D3\;mnf%D3d\\t%0, #%N2
879
   it\\t%d3\;mvf%d3d\\t%0, %1
880
   it\\t%d3\;mnf%d3d\\t%0, #%N1
881
   ite\\t%d3\;mvf%d3d\\t%0, %1\;mvf%D3d\\t%0, %2
882
   ite\\t%d3\;mvf%d3d\\t%0, %1\;mnf%D3d\\t%0, #%N2
883
   ite\\t%d3\;mnf%d3d\\t%0, #%N1\;mvf%D3d\\t%0, %2
884
   ite\\t%d3\;mnf%d3d\\t%0, #%N1\;mnf%D3d\\t%0, #%N2"
885
  [(set_attr "length" "6,6,6,6,10,10,10,10")
886
   (set_attr "type" "ffarith")
887
   (set_attr "conds" "use")]
888
)
889
 

powered by: WebSVN 2.1.0

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