OSDN Git Service

e44b919ccb9eb17f1d7983865ff712ceac6b5dd1
[pf3gnuchains/gcc-fork.git] / gcc / config / mips / mips.md
1 ;;  Mips.md          Machine Description for MIPS based processors
2 ;;  Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 ;;  1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 ;;  Contributed by   A. Lichnewsky, lich@inria.inria.fr
5 ;;  Changes by       Michael Meissner, meissner@osf.org
6 ;;  64-bit r4000 support by Ian Lance Taylor, ian@cygnus.com, and
7 ;;  Brendan Eich, brendan@microunity.com.
8
9 ;; This file is part of GCC.
10
11 ;; GCC is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; any later version.
15
16 ;; GCC is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 ;; GNU General Public License for more details.
20
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GCC; see the file COPYING.  If not, write to
23 ;; the Free Software Foundation, 51 Franklin Street, Fifth Floor,
24 ;; Boston, MA 02110-1301, USA.
25
26 (define_constants
27   [(UNSPEC_LOAD_DF_LOW           0)
28    (UNSPEC_LOAD_DF_HIGH          1)
29    (UNSPEC_STORE_DF_HIGH         2)
30    (UNSPEC_GET_FNADDR            3)
31    (UNSPEC_BLOCKAGE              4)
32    (UNSPEC_CPRESTORE             5)
33    (UNSPEC_EH_RECEIVER           6)
34    (UNSPEC_EH_RETURN             7)
35    (UNSPEC_CONSTTABLE_INT        8)
36    (UNSPEC_CONSTTABLE_FLOAT      9)
37    (UNSPEC_ALIGN                14)
38    (UNSPEC_HIGH                 17)
39    (UNSPEC_LOAD_LEFT            18)
40    (UNSPEC_LOAD_RIGHT           19)
41    (UNSPEC_STORE_LEFT           20)
42    (UNSPEC_STORE_RIGHT          21)
43    (UNSPEC_LOADGP               22)
44    (UNSPEC_LOAD_CALL            23)
45    (UNSPEC_LOAD_GOT             24)
46    (UNSPEC_GP                   25)
47    (UNSPEC_MFHILO               26)
48    (UNSPEC_TLS_LDM              27)
49    (UNSPEC_TLS_GET_TP           28)
50    (UNSPEC_MFHC1                31)
51    (UNSPEC_MTHC1                32)
52
53    (UNSPEC_ADDRESS_FIRST        100)
54
55    (FAKE_CALL_REGNO             79)
56
57    ;; For MIPS Paired-Singled Floating Point Instructions.
58
59    (UNSPEC_MOVE_TF_PS           200)
60    (UNSPEC_C                    201)
61
62    ;; MIPS64/MIPS32R2 alnv.ps
63    (UNSPEC_ALNV_PS              202)
64
65    ;; MIPS-3D instructions
66    (UNSPEC_CABS                 203)
67
68    (UNSPEC_ADDR_PS              204)
69    (UNSPEC_CVT_PW_PS            205)
70    (UNSPEC_CVT_PS_PW            206)
71    (UNSPEC_MULR_PS              207)
72    (UNSPEC_ABS_PS               208)
73
74    (UNSPEC_RSQRT1               209)
75    (UNSPEC_RSQRT2               210)
76    (UNSPEC_RECIP1               211)
77    (UNSPEC_RECIP2               212)
78    (UNSPEC_SINGLE_CC            213)
79    (UNSPEC_SCC                  214)
80
81    ;; MIPS DSP ASE Revision 0.98 3/24/2005
82    (UNSPEC_ADDQ                 300)
83    (UNSPEC_ADDQ_S               301)
84    (UNSPEC_SUBQ                 302)
85    (UNSPEC_SUBQ_S               303)
86    (UNSPEC_ADDSC                304)
87    (UNSPEC_ADDWC                305)
88    (UNSPEC_MODSUB               306)
89    (UNSPEC_RADDU_W_QB           307)
90    (UNSPEC_ABSQ_S               308)
91    (UNSPEC_PRECRQ_QB_PH         309)
92    (UNSPEC_PRECRQ_PH_W          310)
93    (UNSPEC_PRECRQ_RS_PH_W       311)
94    (UNSPEC_PRECRQU_S_QB_PH      312)
95    (UNSPEC_PRECEQ_W_PHL         313)
96    (UNSPEC_PRECEQ_W_PHR         314)
97    (UNSPEC_PRECEQU_PH_QBL       315)
98    (UNSPEC_PRECEQU_PH_QBR       316)
99    (UNSPEC_PRECEQU_PH_QBLA      317)
100    (UNSPEC_PRECEQU_PH_QBRA      318)
101    (UNSPEC_PRECEU_PH_QBL        319)
102    (UNSPEC_PRECEU_PH_QBR        320)
103    (UNSPEC_PRECEU_PH_QBLA       321)
104    (UNSPEC_PRECEU_PH_QBRA       322)
105    (UNSPEC_SHLL                 323)
106    (UNSPEC_SHLL_S               324)
107    (UNSPEC_SHRL_QB              325)
108    (UNSPEC_SHRA_PH              326)
109    (UNSPEC_SHRA_R               327)
110    (UNSPEC_MULEU_S_PH_QBL       328)
111    (UNSPEC_MULEU_S_PH_QBR       329)
112    (UNSPEC_MULQ_RS_PH           330)
113    (UNSPEC_MULEQ_S_W_PHL        331)
114    (UNSPEC_MULEQ_S_W_PHR        332)
115    (UNSPEC_DPAU_H_QBL           333)
116    (UNSPEC_DPAU_H_QBR           334)
117    (UNSPEC_DPSU_H_QBL           335)
118    (UNSPEC_DPSU_H_QBR           336)
119    (UNSPEC_DPAQ_S_W_PH          337)
120    (UNSPEC_DPSQ_S_W_PH          338)
121    (UNSPEC_MULSAQ_S_W_PH        339)
122    (UNSPEC_DPAQ_SA_L_W          340)
123    (UNSPEC_DPSQ_SA_L_W          341)
124    (UNSPEC_MAQ_S_W_PHL          342)
125    (UNSPEC_MAQ_S_W_PHR          343)
126    (UNSPEC_MAQ_SA_W_PHL         344)
127    (UNSPEC_MAQ_SA_W_PHR         345)
128    (UNSPEC_BITREV               346)
129    (UNSPEC_INSV                 347)
130    (UNSPEC_REPL_QB              348)
131    (UNSPEC_REPL_PH              349)
132    (UNSPEC_CMP_EQ               350)
133    (UNSPEC_CMP_LT               351)
134    (UNSPEC_CMP_LE               352)
135    (UNSPEC_CMPGU_EQ_QB          353)
136    (UNSPEC_CMPGU_LT_QB          354)
137    (UNSPEC_CMPGU_LE_QB          355)
138    (UNSPEC_PICK                 356)
139    (UNSPEC_PACKRL_PH            357)
140    (UNSPEC_EXTR_W               358)
141    (UNSPEC_EXTR_R_W             359)
142    (UNSPEC_EXTR_RS_W            360)
143    (UNSPEC_EXTR_S_H             361)
144    (UNSPEC_EXTP                 362)
145    (UNSPEC_EXTPDP               363)
146    (UNSPEC_SHILO                364)
147    (UNSPEC_MTHLIP               365)
148    (UNSPEC_WRDSP                366)
149    (UNSPEC_RDDSP                367)
150
151    ;; MIPS DSP ASE REV 2 Revision 0.02 11/24/2006
152    (UNSPEC_ABSQ_S_QB            400)
153    (UNSPEC_ADDU_PH              401)
154    (UNSPEC_ADDU_S_PH            402)
155    (UNSPEC_ADDUH_QB             403)
156    (UNSPEC_ADDUH_R_QB           404)
157    (UNSPEC_APPEND               405)
158    (UNSPEC_BALIGN               406)
159    (UNSPEC_CMPGDU_EQ_QB         407)
160    (UNSPEC_CMPGDU_LT_QB         408)
161    (UNSPEC_CMPGDU_LE_QB         409)
162    (UNSPEC_DPA_W_PH             410)
163    (UNSPEC_DPS_W_PH             411)
164    (UNSPEC_MADD                 412)
165    (UNSPEC_MADDU                413)
166    (UNSPEC_MSUB                 414)
167    (UNSPEC_MSUBU                415)
168    (UNSPEC_MUL_PH               416)
169    (UNSPEC_MUL_S_PH             417)
170    (UNSPEC_MULQ_RS_W            418)
171    (UNSPEC_MULQ_S_PH            419)
172    (UNSPEC_MULQ_S_W             420)
173    (UNSPEC_MULSA_W_PH           421)
174    (UNSPEC_MULT                 422)
175    (UNSPEC_MULTU                423)
176    (UNSPEC_PRECR_QB_PH          424)
177    (UNSPEC_PRECR_SRA_PH_W       425)
178    (UNSPEC_PRECR_SRA_R_PH_W     426)
179    (UNSPEC_PREPEND              427)
180    (UNSPEC_SHRA_QB              428)
181    (UNSPEC_SHRA_R_QB            429)
182    (UNSPEC_SHRL_PH              430)
183    (UNSPEC_SUBU_PH              431)
184    (UNSPEC_SUBU_S_PH            432)
185    (UNSPEC_SUBUH_QB             433)
186    (UNSPEC_SUBUH_R_QB           434)
187    (UNSPEC_ADDQH_PH             435)
188    (UNSPEC_ADDQH_R_PH           436)
189    (UNSPEC_ADDQH_W              437)
190    (UNSPEC_ADDQH_R_W            438)
191    (UNSPEC_SUBQH_PH             439)
192    (UNSPEC_SUBQH_R_PH           440)
193    (UNSPEC_SUBQH_W              441)
194    (UNSPEC_SUBQH_R_W            442)
195    (UNSPEC_DPAX_W_PH            443)
196    (UNSPEC_DPSX_W_PH            444)
197    (UNSPEC_DPAQX_S_W_PH         445)
198    (UNSPEC_DPAQX_SA_W_PH        446)
199    (UNSPEC_DPSQX_S_W_PH         447)
200    (UNSPEC_DPSQX_SA_W_PH        448)
201   ]
202 )
203
204 (include "predicates.md")
205 (include "constraints.md")
206 \f
207 ;; ....................
208 ;;
209 ;;      Attributes
210 ;;
211 ;; ....................
212
213 (define_attr "got" "unset,xgot_high,load"
214   (const_string "unset"))
215
216 ;; For jal instructions, this attribute is DIRECT when the target address
217 ;; is symbolic and INDIRECT when it is a register.
218 (define_attr "jal" "unset,direct,indirect"
219   (const_string "unset"))
220
221 ;; This attribute is YES if the instruction is a jal macro (not a
222 ;; real jal instruction).
223 ;;
224 ;; jal is always a macro for TARGET_CALL_CLOBBERED_GP because it includes
225 ;; an instruction to restore $gp.  Direct jals are also macros for
226 ;; flag_pic && !TARGET_ABSOLUTE_ABICALLS because they first load
227 ;; the target address into a register.
228 (define_attr "jal_macro" "no,yes"
229   (cond [(eq_attr "jal" "direct")
230          (symbol_ref "TARGET_CALL_CLOBBERED_GP
231                       || (flag_pic && !TARGET_ABSOLUTE_ABICALLS)")
232          (eq_attr "jal" "indirect")
233          (symbol_ref "TARGET_CALL_CLOBBERED_GP")]
234         (const_string "no")))
235
236 ;; Classification of each insn.
237 ;; branch       conditional branch
238 ;; jump         unconditional jump
239 ;; call         unconditional call
240 ;; load         load instruction(s)
241 ;; fpload       floating point load
242 ;; fpidxload    floating point indexed load
243 ;; store        store instruction(s)
244 ;; fpstore      floating point store
245 ;; fpidxstore   floating point indexed store
246 ;; prefetch     memory prefetch (register + offset)
247 ;; prefetchx    memory indexed prefetch (register + register)
248 ;; condmove     conditional moves
249 ;; mfc          transfer from coprocessor
250 ;; mtc          transfer to coprocessor
251 ;; mthilo       transfer to hi/lo registers
252 ;; mfhilo       transfer from hi/lo registers
253 ;; const        load constant
254 ;; arith        integer arithmetic and logical instructions
255 ;; shift        integer shift instructions
256 ;; slt          set less than instructions
257 ;; clz          the clz and clo instructions
258 ;; trap         trap if instructions
259 ;; imul         integer multiply 2 operands
260 ;; imul3        integer multiply 3 operands
261 ;; imadd        integer multiply-add
262 ;; idiv         integer divide
263 ;; fmove        floating point register move
264 ;; fadd         floating point add/subtract
265 ;; fmul         floating point multiply
266 ;; fmadd        floating point multiply-add
267 ;; fdiv         floating point divide
268 ;; frdiv        floating point reciprocal divide
269 ;; frdiv1       floating point reciprocal divide step 1
270 ;; frdiv2       floating point reciprocal divide step 2
271 ;; fabs         floating point absolute value
272 ;; fneg         floating point negation
273 ;; fcmp         floating point compare
274 ;; fcvt         floating point convert
275 ;; fsqrt        floating point square root
276 ;; frsqrt       floating point reciprocal square root
277 ;; frsqrt1      floating point reciprocal square root step1
278 ;; frsqrt2      floating point reciprocal square root step2
279 ;; multi        multiword sequence (or user asm statements)
280 ;; nop          no operation
281 (define_attr "type"
282   "unknown,branch,jump,call,load,fpload,fpidxload,store,fpstore,fpidxstore,prefetch,prefetchx,condmove,mfc,mtc,mthilo,mfhilo,const,arith,shift,slt,clz,trap,imul,imul3,imadd,idiv,fmove,fadd,fmul,fmadd,fdiv,frdiv,frdiv1,frdiv2,fabs,fneg,fcmp,fcvt,fsqrt,frsqrt,frsqrt1,frsqrt2,multi,nop"
283   (cond [(eq_attr "jal" "!unset") (const_string "call")
284          (eq_attr "got" "load") (const_string "load")]
285         (const_string "unknown")))
286
287 ;; Main data type used by the insn
288 (define_attr "mode" "unknown,none,QI,HI,SI,DI,SF,DF,FPSW"
289   (const_string "unknown"))
290
291 ;; Mode for conversion types (fcvt)
292 ;; I2S          integer to float single (SI/DI to SF)
293 ;; I2D          integer to float double (SI/DI to DF)
294 ;; S2I          float to integer (SF to SI/DI)
295 ;; D2I          float to integer (DF to SI/DI)
296 ;; D2S          double to float single
297 ;; S2D          float single to double
298
299 (define_attr "cnv_mode" "unknown,I2S,I2D,S2I,D2I,D2S,S2D" 
300   (const_string "unknown"))
301
302 ;; Is this an extended instruction in mips16 mode?
303 (define_attr "extended_mips16" "no,yes"
304   (const_string "no"))
305
306 ;; Length of instruction in bytes.
307 (define_attr "length" ""
308    (cond [;; Direct branch instructions have a range of [-0x40000,0x3fffc].
309           ;; If a branch is outside this range, we have a choice of two
310           ;; sequences.  For PIC, an out-of-range branch like:
311           ;;
312           ;;    bne     r1,r2,target
313           ;;    dslot
314           ;;
315           ;; becomes the equivalent of:
316           ;;
317           ;;    beq     r1,r2,1f
318           ;;    dslot
319           ;;    la      $at,target
320           ;;    jr      $at
321           ;;    nop
322           ;; 1:
323           ;;
324           ;; where the load address can be up to three instructions long
325           ;; (lw, nop, addiu).
326           ;;
327           ;; The non-PIC case is similar except that we use a direct
328           ;; jump instead of an la/jr pair.  Since the target of this
329           ;; jump is an absolute 28-bit bit address (the other bits
330           ;; coming from the address of the delay slot) this form cannot
331           ;; cross a 256MB boundary.  We could provide the option of
332           ;; using la/jr in this case too, but we do not do so at
333           ;; present.
334           ;;
335           ;; Note that this value does not account for the delay slot
336           ;; instruction, whose length is added separately.  If the RTL
337           ;; pattern has no explicit delay slot, mips_adjust_insn_length
338           ;; will add the length of the implicit nop.  The values for
339           ;; forward and backward branches will be different as well.
340           (eq_attr "type" "branch")
341           (cond [(and (le (minus (match_dup 1) (pc)) (const_int 131064))
342                       (le (minus (pc) (match_dup 1)) (const_int 131068)))
343                   (const_int 4)
344                  (ne (symbol_ref "flag_pic") (const_int 0))
345                  (const_int 24)
346                  ] (const_int 12))
347
348           (eq_attr "got" "load")
349           (const_int 4)
350           (eq_attr "got" "xgot_high")
351           (const_int 8)
352
353           (eq_attr "type" "const")
354           (symbol_ref "mips_const_insns (operands[1]) * 4")
355           (eq_attr "type" "load,fpload")
356           (symbol_ref "mips_fetch_insns (operands[1]) * 4")
357           (eq_attr "type" "store,fpstore")
358           (symbol_ref "mips_fetch_insns (operands[0]) * 4")
359
360           ;; In the worst case, a call macro will take 8 instructions:
361           ;;
362           ;;     lui $25,%call_hi(FOO)
363           ;;     addu $25,$25,$28
364           ;;     lw $25,%call_lo(FOO)($25)
365           ;;     nop
366           ;;     jalr $25
367           ;;     nop
368           ;;     lw $gp,X($sp)
369           ;;     nop
370           (eq_attr "jal_macro" "yes")
371           (const_int 32)
372
373           (and (eq_attr "extended_mips16" "yes")
374                (ne (symbol_ref "TARGET_MIPS16") (const_int 0)))
375           (const_int 8)
376
377           ;; Various VR4120 errata require a nop to be inserted after a macc
378           ;; instruction.  The assembler does this for us, so account for
379           ;; the worst-case length here.
380           (and (eq_attr "type" "imadd")
381                (ne (symbol_ref "TARGET_FIX_VR4120") (const_int 0)))
382           (const_int 8)
383
384           ;; VR4120 errata MD(4): if there are consecutive dmult instructions,
385           ;; the result of the second one is missed.  The assembler should work
386           ;; around this by inserting a nop after the first dmult.
387           (and (eq_attr "type" "imul,imul3")
388                (and (eq_attr "mode" "DI")
389                     (ne (symbol_ref "TARGET_FIX_VR4120") (const_int 0))))
390           (const_int 8)
391
392           (eq_attr "type" "idiv")
393           (symbol_ref "mips_idiv_insns () * 4")
394           ] (const_int 4)))
395
396 ;; Attribute describing the processor.  This attribute must match exactly
397 ;; with the processor_type enumeration in mips.h.
398 (define_attr "cpu"
399   "r3000,4kc,4kp,5kc,5kf,20kc,24kc,24kf,24kx,74kc,74kf,74kx,m4k,r3900,r6000,r4000,r4100,r4111,r4120,r4130,r4300,r4600,r4650,r5000,r5400,r5500,r7000,r8000,r9000,sb1,sb1a,sr71000"
400   (const (symbol_ref "mips_tune")))
401
402 ;; The type of hardware hazard associated with this instruction.
403 ;; DELAY means that the next instruction cannot read the result
404 ;; of this one.  HILO means that the next two instructions cannot
405 ;; write to HI or LO.
406 (define_attr "hazard" "none,delay,hilo"
407   (cond [(and (eq_attr "type" "load,fpload,fpidxload")
408               (ne (symbol_ref "ISA_HAS_LOAD_DELAY") (const_int 0)))
409          (const_string "delay")
410
411          (and (eq_attr "type" "mfc,mtc")
412               (ne (symbol_ref "ISA_HAS_XFER_DELAY") (const_int 0)))
413          (const_string "delay")
414
415          (and (eq_attr "type" "fcmp")
416               (ne (symbol_ref "ISA_HAS_FCMP_DELAY") (const_int 0)))
417          (const_string "delay")
418
419          ;; The r4000 multiplication patterns include an mflo instruction.
420          (and (eq_attr "type" "imul")
421               (ne (symbol_ref "TARGET_FIX_R4000") (const_int 0)))
422          (const_string "hilo")
423
424          (and (eq_attr "type" "mfhilo")
425               (eq (symbol_ref "ISA_HAS_HILO_INTERLOCKS") (const_int 0)))
426          (const_string "hilo")]
427         (const_string "none")))
428
429 ;; Is it a single instruction?
430 (define_attr "single_insn" "no,yes"
431   (symbol_ref "get_attr_length (insn) == (TARGET_MIPS16 ? 2 : 4)"))
432
433 ;; Can the instruction be put into a delay slot?
434 (define_attr "can_delay" "no,yes"
435   (if_then_else (and (eq_attr "type" "!branch,call,jump")
436                      (and (eq_attr "hazard" "none")
437                           (eq_attr "single_insn" "yes")))
438                 (const_string "yes")
439                 (const_string "no")))
440
441 ;; Attribute defining whether or not we can use the branch-likely instructions
442 (define_attr "branch_likely" "no,yes"
443   (const
444    (if_then_else (ne (symbol_ref "GENERATE_BRANCHLIKELY") (const_int 0))
445                  (const_string "yes")
446                  (const_string "no"))))
447
448 ;; True if an instruction might assign to hi or lo when reloaded.
449 ;; This is used by the TUNE_MACC_CHAINS code.
450 (define_attr "may_clobber_hilo" "no,yes"
451   (if_then_else (eq_attr "type" "imul,imul3,imadd,idiv,mthilo")
452                 (const_string "yes")
453                 (const_string "no")))
454
455 ;; Describe a user's asm statement.
456 (define_asm_attributes
457   [(set_attr "type" "multi")
458    (set_attr "can_delay" "no")])
459 \f
460 ;; This mode macro allows 32-bit and 64-bit GPR patterns to be generated
461 ;; from the same template.
462 (define_mode_macro GPR [SI (DI "TARGET_64BIT")])
463
464 ;; This mode macro allows :P to be used for patterns that operate on
465 ;; pointer-sized quantities.  Exactly one of the two alternatives will match.
466 (define_mode_macro P [(SI "Pmode == SImode") (DI "Pmode == DImode")])
467
468 ;; This mode macro allows :MOVECC to be used anywhere that a
469 ;; conditional-move-type condition is needed.
470 (define_mode_macro MOVECC [SI (DI "TARGET_64BIT") (CC "TARGET_HARD_FLOAT")])
471
472 ;; This mode macro allows the QI and HI extension patterns to be defined from
473 ;; the same template.
474 (define_mode_macro SHORT [QI HI])
475
476 ;; This mode macro allows :ANYF to be used wherever a scalar or vector
477 ;; floating-point mode is allowed.
478 (define_mode_macro ANYF [(SF "TARGET_HARD_FLOAT")
479                          (DF "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT")
480                          (V2SF "TARGET_PAIRED_SINGLE_FLOAT")])
481
482 ;; Like ANYF, but only applies to scalar modes.
483 (define_mode_macro SCALARF [(SF "TARGET_HARD_FLOAT")
484                             (DF "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT")])
485
486 ;; In GPR templates, a string like "<d>subu" will expand to "subu" in the
487 ;; 32-bit version and "dsubu" in the 64-bit version.
488 (define_mode_attr d [(SI "") (DI "d")])
489
490 ;; This attribute gives the length suffix for a sign- or zero-extension
491 ;; instruction.
492 (define_mode_attr size [(QI "b") (HI "h")])
493
494 ;; This attributes gives the mode mask of a SHORT.
495 (define_mode_attr mask [(QI "0x00ff") (HI "0xffff")])
496
497 ;; Mode attributes for GPR loads and stores.
498 (define_mode_attr load [(SI "lw") (DI "ld")])
499 (define_mode_attr store [(SI "sw") (DI "sd")])
500
501 ;; Similarly for MIPS IV indexed FPR loads and stores.
502 (define_mode_attr loadx [(SF "lwxc1") (DF "ldxc1") (V2SF "ldxc1")])
503 (define_mode_attr storex [(SF "swxc1") (DF "sdxc1") (V2SF "sdxc1")])
504
505 ;; The unextended ranges of the MIPS16 addiu and daddiu instructions
506 ;; are different.  Some forms of unextended addiu have an 8-bit immediate
507 ;; field but the equivalent daddiu has only a 5-bit field.
508 (define_mode_attr si8_di5 [(SI "8") (DI "5")])
509
510 ;; This attribute gives the best constraint to use for registers of
511 ;; a given mode.
512 (define_mode_attr reg [(SI "d") (DI "d") (CC "z")])
513
514 ;; This attribute gives the format suffix for floating-point operations.
515 (define_mode_attr fmt [(SF "s") (DF "d") (V2SF "ps")])
516
517 ;; This attribute gives the upper-case mode name for one unit of a
518 ;; floating-point mode.
519 (define_mode_attr UNITMODE [(SF "SF") (DF "DF") (V2SF "SF")])
520
521 ;; This attribute works around the early SB-1 rev2 core "F2" erratum:
522 ;;
523 ;; In certain cases, div.s and div.ps may have a rounding error
524 ;; and/or wrong inexact flag.
525 ;;
526 ;; Therefore, we only allow div.s if not working around SB-1 rev2
527 ;; errata or if a slight loss of precision is OK.
528 (define_mode_attr divide_condition
529   [DF (SF "!TARGET_FIX_SB1 || flag_unsafe_math_optimizations")
530    (V2SF "TARGET_SB1 && (!TARGET_FIX_SB1 || flag_unsafe_math_optimizations)")])
531
532 ; This attribute gives the condition for which sqrt instructions exist.
533 (define_mode_attr sqrt_condition
534   [(SF "!ISA_MIPS1") (DF "!ISA_MIPS1") (V2SF "TARGET_SB1")])
535
536 ; This attribute gives the condition for which recip and rsqrt instructions
537 ; exist.
538 (define_mode_attr recip_condition
539   [(SF "ISA_HAS_FP4") (DF "ISA_HAS_FP4") (V2SF "TARGET_SB1")])
540
541 ;; This code macro allows all branch instructions to be generated from
542 ;; a single define_expand template.
543 (define_code_macro any_cond [unordered ordered unlt unge uneq ltgt unle ungt
544                              eq ne gt ge lt le gtu geu ltu leu])
545
546 ;; This code macro allows signed and unsigned widening multiplications
547 ;; to use the same template.
548 (define_code_macro any_extend [sign_extend zero_extend])
549
550 ;; This code macro allows the three shift instructions to be generated
551 ;; from the same template.
552 (define_code_macro any_shift [ashift ashiftrt lshiftrt])
553
554 ;; This code macro allows all native floating-point comparisons to be
555 ;; generated from the same template.
556 (define_code_macro fcond [unordered uneq unlt unle eq lt le])
557
558 ;; This code macro is used for comparisons that can be implemented
559 ;; by swapping the operands.
560 (define_code_macro swapped_fcond [ge gt unge ungt])
561
562 ;; <u> expands to an empty string when doing a signed operation and
563 ;; "u" when doing an unsigned operation.
564 (define_code_attr u [(sign_extend "") (zero_extend "u")])
565
566 ;; <su> is like <u>, but the signed form expands to "s" rather than "".
567 (define_code_attr su [(sign_extend "s") (zero_extend "u")])
568
569 ;; <optab> expands to the name of the optab for a particular code.
570 (define_code_attr optab [(ashift "ashl")
571                          (ashiftrt "ashr")
572                          (lshiftrt "lshr")])
573
574 ;; <insn> expands to the name of the insn that implements a particular code.
575 (define_code_attr insn [(ashift "sll")
576                         (ashiftrt "sra")
577                         (lshiftrt "srl")])
578
579 ;; <fcond> is the c.cond.fmt condition associated with a particular code.
580 (define_code_attr fcond [(unordered "un")
581                          (uneq "ueq")
582                          (unlt "ult")
583                          (unle "ule")
584                          (eq "eq")
585                          (lt "lt")
586                          (le "le")])
587
588 ;; Similar, but for swapped conditions.
589 (define_code_attr swapped_fcond [(ge "le")
590                                  (gt "lt")
591                                  (unge "ule")
592                                  (ungt "ult")])
593 \f
594 ;; .........................
595 ;;
596 ;;      Branch, call and jump delay slots
597 ;;
598 ;; .........................
599
600 (define_delay (and (eq_attr "type" "branch")
601                    (eq (symbol_ref "TARGET_MIPS16") (const_int 0)))
602   [(eq_attr "can_delay" "yes")
603    (nil)
604    (and (eq_attr "branch_likely" "yes")
605         (eq_attr "can_delay" "yes"))])
606
607 (define_delay (eq_attr "type" "jump")
608   [(eq_attr "can_delay" "yes")
609    (nil)
610    (nil)])
611
612 (define_delay (and (eq_attr "type" "call")
613                    (eq_attr "jal_macro" "no"))
614   [(eq_attr "can_delay" "yes")
615    (nil)
616    (nil)])
617 \f
618 ;; Pipeline descriptions.
619 ;;
620 ;; generic.md provides a fallback for processors without a specific
621 ;; pipeline description.  It is derived from the old define_function_unit
622 ;; version and uses the "alu" and "imuldiv" units declared below.
623 ;;
624 ;; Some of the processor-specific files are also derived from old
625 ;; define_function_unit descriptions and simply override the parts of
626 ;; generic.md that don't apply.  The other processor-specific files
627 ;; are self-contained.
628 (define_automaton "alu,imuldiv")
629
630 (define_cpu_unit "alu" "alu")
631 (define_cpu_unit "imuldiv" "imuldiv")
632
633 (include "4k.md")
634 (include "5k.md")
635 (include "24k.md")
636 (include "74k.md")
637 (include "3000.md")
638 (include "4000.md")
639 (include "4100.md")
640 (include "4130.md")
641 (include "4300.md")
642 (include "4600.md")
643 (include "5000.md")
644 (include "5400.md")
645 (include "5500.md")
646 (include "6000.md")
647 (include "7000.md")
648 (include "9000.md")
649 (include "sb1.md")
650 (include "sr71k.md")
651 (include "generic.md")
652 \f
653 ;;
654 ;;  ....................
655 ;;
656 ;;      CONDITIONAL TRAPS
657 ;;
658 ;;  ....................
659 ;;
660
661 (define_insn "trap"
662   [(trap_if (const_int 1) (const_int 0))]
663   ""
664 {
665   if (ISA_HAS_COND_TRAP)
666     return "teq\t$0,$0";
667   else if (TARGET_MIPS16)
668     return "break 0";
669   else
670     return "break";
671 }
672   [(set_attr "type" "trap")])
673
674 (define_expand "conditional_trap"
675   [(trap_if (match_operator 0 "comparison_operator"
676                             [(match_dup 2) (match_dup 3)])
677             (match_operand 1 "const_int_operand"))]
678   "ISA_HAS_COND_TRAP"
679 {
680   if (GET_MODE_CLASS (GET_MODE (cmp_operands[0])) == MODE_INT
681       && operands[1] == const0_rtx)
682     {
683       mips_gen_conditional_trap (operands);
684       DONE;
685     }
686   else
687     FAIL;
688 })
689
690 (define_insn "*conditional_trap<mode>"
691   [(trap_if (match_operator:GPR 0 "trap_comparison_operator"
692                                 [(match_operand:GPR 1 "reg_or_0_operand" "dJ")
693                                  (match_operand:GPR 2 "arith_operand" "dI")])
694             (const_int 0))]
695   "ISA_HAS_COND_TRAP"
696   "t%C0\t%z1,%2"
697   [(set_attr "type" "trap")])
698 \f
699 ;;
700 ;;  ....................
701 ;;
702 ;;      ADDITION
703 ;;
704 ;;  ....................
705 ;;
706
707 (define_insn "add<mode>3"
708   [(set (match_operand:ANYF 0 "register_operand" "=f")
709         (plus:ANYF (match_operand:ANYF 1 "register_operand" "f")
710                    (match_operand:ANYF 2 "register_operand" "f")))]
711   ""
712   "add.<fmt>\t%0,%1,%2"
713   [(set_attr "type" "fadd")
714    (set_attr "mode" "<UNITMODE>")])
715
716 (define_expand "add<mode>3"
717   [(set (match_operand:GPR 0 "register_operand")
718         (plus:GPR (match_operand:GPR 1 "register_operand")
719                   (match_operand:GPR 2 "arith_operand")))]
720   "")
721
722 (define_insn "*add<mode>3"
723   [(set (match_operand:GPR 0 "register_operand" "=d,d")
724         (plus:GPR (match_operand:GPR 1 "register_operand" "d,d")
725                   (match_operand:GPR 2 "arith_operand" "d,Q")))]
726   "!TARGET_MIPS16"
727   "@
728     <d>addu\t%0,%1,%2
729     <d>addiu\t%0,%1,%2"
730   [(set_attr "type" "arith")
731    (set_attr "mode" "<MODE>")])
732
733 ;; We need to recognize MIPS16 stack pointer additions explicitly, since
734 ;; we don't have a constraint for $sp.  These insns will be generated by
735 ;; the save_restore_insns functions.
736
737 (define_insn "*add<mode>3_sp1"
738   [(set (reg:GPR 29)
739         (plus:GPR (reg:GPR 29)
740                   (match_operand:GPR 0 "const_arith_operand" "")))]
741   "TARGET_MIPS16"
742   "<d>addiu\t%$,%$,%0"
743   [(set_attr "type" "arith")
744    (set_attr "mode" "<MODE>")
745    (set (attr "length") (if_then_else (match_operand 0 "m16_simm8_8")
746                                       (const_int 4)
747                                       (const_int 8)))])
748
749 (define_insn "*add<mode>3_sp2"
750   [(set (match_operand:GPR 0 "register_operand" "=d")
751         (plus:GPR (reg:GPR 29)
752                   (match_operand:GPR 1 "const_arith_operand" "")))]
753   "TARGET_MIPS16"
754   "<d>addiu\t%0,%$,%1"
755   [(set_attr "type" "arith")
756    (set_attr "mode" "<MODE>")
757    (set (attr "length") (if_then_else (match_operand 1 "m16_uimm<si8_di5>_4")
758                                       (const_int 4)
759                                       (const_int 8)))])
760
761 (define_insn "*add<mode>3_mips16"
762   [(set (match_operand:GPR 0 "register_operand" "=d,d,d")
763         (plus:GPR (match_operand:GPR 1 "register_operand" "0,d,d")
764                   (match_operand:GPR 2 "arith_operand" "Q,O,d")))]
765   "TARGET_MIPS16"
766   "@
767     <d>addiu\t%0,%2
768     <d>addiu\t%0,%1,%2
769     <d>addu\t%0,%1,%2"
770   [(set_attr "type" "arith")
771    (set_attr "mode" "<MODE>")
772    (set_attr_alternative "length"
773                 [(if_then_else (match_operand 2 "m16_simm<si8_di5>_1")
774                                (const_int 4)
775                                (const_int 8))
776                  (if_then_else (match_operand 2 "m16_simm4_1")
777                                (const_int 4)
778                                (const_int 8))
779                  (const_int 4)])])
780
781
782 ;; On the mips16, we can sometimes split an add of a constant which is
783 ;; a 4 byte instruction into two adds which are both 2 byte
784 ;; instructions.  There are two cases: one where we are adding a
785 ;; constant plus a register to another register, and one where we are
786 ;; simply adding a constant to a register.
787
788 (define_split
789   [(set (match_operand:SI 0 "register_operand")
790         (plus:SI (match_dup 0)
791                  (match_operand:SI 1 "const_int_operand")))]
792   "TARGET_MIPS16 && reload_completed && !TARGET_DEBUG_D_MODE
793    && REG_P (operands[0])
794    && M16_REG_P (REGNO (operands[0]))
795    && GET_CODE (operands[1]) == CONST_INT
796    && ((INTVAL (operands[1]) > 0x7f
797         && INTVAL (operands[1]) <= 0x7f + 0x7f)
798        || (INTVAL (operands[1]) < - 0x80
799            && INTVAL (operands[1]) >= - 0x80 - 0x80))"
800   [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 1)))
801    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))]
802 {
803   HOST_WIDE_INT val = INTVAL (operands[1]);
804
805   if (val >= 0)
806     {
807       operands[1] = GEN_INT (0x7f);
808       operands[2] = GEN_INT (val - 0x7f);
809     }
810   else
811     {
812       operands[1] = GEN_INT (- 0x80);
813       operands[2] = GEN_INT (val + 0x80);
814     }
815 })
816
817 (define_split
818   [(set (match_operand:SI 0 "register_operand")
819         (plus:SI (match_operand:SI 1 "register_operand")
820                  (match_operand:SI 2 "const_int_operand")))]
821   "TARGET_MIPS16 && reload_completed && !TARGET_DEBUG_D_MODE
822    && REG_P (operands[0])
823    && M16_REG_P (REGNO (operands[0]))
824    && REG_P (operands[1])
825    && M16_REG_P (REGNO (operands[1]))
826    && REGNO (operands[0]) != REGNO (operands[1])
827    && GET_CODE (operands[2]) == CONST_INT
828    && ((INTVAL (operands[2]) > 0x7
829         && INTVAL (operands[2]) <= 0x7 + 0x7f)
830        || (INTVAL (operands[2]) < - 0x8
831            && INTVAL (operands[2]) >= - 0x8 - 0x80))"
832   [(set (match_dup 0) (plus:SI (match_dup 1) (match_dup 2)))
833    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 3)))]
834 {
835   HOST_WIDE_INT val = INTVAL (operands[2]);
836
837   if (val >= 0)
838     {
839       operands[2] = GEN_INT (0x7);
840       operands[3] = GEN_INT (val - 0x7);
841     }
842   else
843     {
844       operands[2] = GEN_INT (- 0x8);
845       operands[3] = GEN_INT (val + 0x8);
846     }
847 })
848
849 (define_split
850   [(set (match_operand:DI 0 "register_operand")
851         (plus:DI (match_dup 0)
852                  (match_operand:DI 1 "const_int_operand")))]
853   "TARGET_MIPS16 && TARGET_64BIT && reload_completed && !TARGET_DEBUG_D_MODE
854    && REG_P (operands[0])
855    && M16_REG_P (REGNO (operands[0]))
856    && GET_CODE (operands[1]) == CONST_INT
857    && ((INTVAL (operands[1]) > 0xf
858         && INTVAL (operands[1]) <= 0xf + 0xf)
859        || (INTVAL (operands[1]) < - 0x10
860            && INTVAL (operands[1]) >= - 0x10 - 0x10))"
861   [(set (match_dup 0) (plus:DI (match_dup 0) (match_dup 1)))
862    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 2)))]
863 {
864   HOST_WIDE_INT val = INTVAL (operands[1]);
865
866   if (val >= 0)
867     {
868       operands[1] = GEN_INT (0xf);
869       operands[2] = GEN_INT (val - 0xf);
870     }
871   else
872     {
873       operands[1] = GEN_INT (- 0x10);
874       operands[2] = GEN_INT (val + 0x10);
875     }
876 })
877
878 (define_split
879   [(set (match_operand:DI 0 "register_operand")
880         (plus:DI (match_operand:DI 1 "register_operand")
881                  (match_operand:DI 2 "const_int_operand")))]
882   "TARGET_MIPS16 && TARGET_64BIT && reload_completed && !TARGET_DEBUG_D_MODE
883    && REG_P (operands[0])
884    && M16_REG_P (REGNO (operands[0]))
885    && REG_P (operands[1])
886    && M16_REG_P (REGNO (operands[1]))
887    && REGNO (operands[0]) != REGNO (operands[1])
888    && GET_CODE (operands[2]) == CONST_INT
889    && ((INTVAL (operands[2]) > 0x7
890         && INTVAL (operands[2]) <= 0x7 + 0xf)
891        || (INTVAL (operands[2]) < - 0x8
892            && INTVAL (operands[2]) >= - 0x8 - 0x10))"
893   [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))
894    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
895 {
896   HOST_WIDE_INT val = INTVAL (operands[2]);
897
898   if (val >= 0)
899     {
900       operands[2] = GEN_INT (0x7);
901       operands[3] = GEN_INT (val - 0x7);
902     }
903   else
904     {
905       operands[2] = GEN_INT (- 0x8);
906       operands[3] = GEN_INT (val + 0x8);
907     }
908 })
909
910 (define_insn "*addsi3_extended"
911   [(set (match_operand:DI 0 "register_operand" "=d,d")
912         (sign_extend:DI
913              (plus:SI (match_operand:SI 1 "register_operand" "d,d")
914                       (match_operand:SI 2 "arith_operand" "d,Q"))))]
915   "TARGET_64BIT && !TARGET_MIPS16"
916   "@
917     addu\t%0,%1,%2
918     addiu\t%0,%1,%2"
919   [(set_attr "type" "arith")
920    (set_attr "mode" "SI")])
921
922 ;; Split this insn so that the addiu splitters can have a crack at it.
923 ;; Use a conservative length estimate until the split.
924 (define_insn_and_split "*addsi3_extended_mips16"
925   [(set (match_operand:DI 0 "register_operand" "=d,d,d")
926         (sign_extend:DI
927              (plus:SI (match_operand:SI 1 "register_operand" "0,d,d")
928                       (match_operand:SI 2 "arith_operand" "Q,O,d"))))]
929   "TARGET_64BIT && TARGET_MIPS16"
930   "#"
931   "&& reload_completed"
932   [(set (match_dup 3) (plus:SI (match_dup 1) (match_dup 2)))]
933   { operands[3] = gen_lowpart (SImode, operands[0]); }
934   [(set_attr "type" "arith")
935    (set_attr "mode" "SI")
936    (set_attr "extended_mips16" "yes")])
937 \f
938 ;;
939 ;;  ....................
940 ;;
941 ;;      SUBTRACTION
942 ;;
943 ;;  ....................
944 ;;
945
946 (define_insn "sub<mode>3"
947   [(set (match_operand:ANYF 0 "register_operand" "=f")
948         (minus:ANYF (match_operand:ANYF 1 "register_operand" "f")
949                     (match_operand:ANYF 2 "register_operand" "f")))]
950   ""
951   "sub.<fmt>\t%0,%1,%2"
952   [(set_attr "type" "fadd")
953    (set_attr "mode" "<UNITMODE>")])
954
955 (define_insn "sub<mode>3"
956   [(set (match_operand:GPR 0 "register_operand" "=d")
957         (minus:GPR (match_operand:GPR 1 "register_operand" "d")
958                    (match_operand:GPR 2 "register_operand" "d")))]
959   ""
960   "<d>subu\t%0,%1,%2"
961   [(set_attr "type" "arith")
962    (set_attr "mode" "<MODE>")])
963
964 (define_insn "*subsi3_extended"
965   [(set (match_operand:DI 0 "register_operand" "=d")
966         (sign_extend:DI
967             (minus:SI (match_operand:SI 1 "register_operand" "d")
968                       (match_operand:SI 2 "register_operand" "d"))))]
969   "TARGET_64BIT"
970   "subu\t%0,%1,%2"
971   [(set_attr "type" "arith")
972    (set_attr "mode" "DI")])
973 \f
974 ;;
975 ;;  ....................
976 ;;
977 ;;      MULTIPLICATION
978 ;;
979 ;;  ....................
980 ;;
981
982 (define_expand "mul<mode>3"
983   [(set (match_operand:SCALARF 0 "register_operand")
984         (mult:SCALARF (match_operand:SCALARF 1 "register_operand")
985                       (match_operand:SCALARF 2 "register_operand")))]
986   ""
987   "")
988
989 (define_insn "*mul<mode>3"
990   [(set (match_operand:SCALARF 0 "register_operand" "=f")
991         (mult:SCALARF (match_operand:SCALARF 1 "register_operand" "f")
992                       (match_operand:SCALARF 2 "register_operand" "f")))]
993   "!TARGET_4300_MUL_FIX"
994   "mul.<fmt>\t%0,%1,%2"
995   [(set_attr "type" "fmul")
996    (set_attr "mode" "<MODE>")])
997
998 ;; Early VR4300 silicon has a CPU bug where multiplies with certain
999 ;; operands may corrupt immediately following multiplies. This is a
1000 ;; simple fix to insert NOPs.
1001
1002 (define_insn "*mul<mode>3_r4300"
1003   [(set (match_operand:SCALARF 0 "register_operand" "=f")
1004         (mult:SCALARF (match_operand:SCALARF 1 "register_operand" "f")
1005                       (match_operand:SCALARF 2 "register_operand" "f")))]
1006   "TARGET_4300_MUL_FIX"
1007   "mul.<fmt>\t%0,%1,%2\;nop"
1008   [(set_attr "type" "fmul")
1009    (set_attr "mode" "<MODE>")
1010    (set_attr "length" "8")])
1011
1012 (define_insn "mulv2sf3"
1013   [(set (match_operand:V2SF 0 "register_operand" "=f")
1014         (mult:V2SF (match_operand:V2SF 1 "register_operand" "f")
1015                    (match_operand:V2SF 2 "register_operand" "f")))]
1016   "TARGET_PAIRED_SINGLE_FLOAT"
1017   "mul.ps\t%0,%1,%2"
1018   [(set_attr "type" "fmul")
1019    (set_attr "mode" "SF")])
1020
1021 ;; The original R4000 has a cpu bug.  If a double-word or a variable
1022 ;; shift executes while an integer multiplication is in progress, the
1023 ;; shift may give an incorrect result.  Avoid this by keeping the mflo
1024 ;; with the mult on the R4000.
1025 ;;
1026 ;; From "MIPS R4000PC/SC Errata, Processor Revision 2.2 and 3.0"
1027 ;; (also valid for MIPS R4000MC processors):
1028 ;;
1029 ;; "16. R4000PC, R4000SC: Please refer to errata 28 for an update to
1030 ;;      this errata description.
1031 ;;      The following code sequence causes the R4000 to incorrectly
1032 ;;      execute the Double Shift Right Arithmetic 32 (dsra32)
1033 ;;      instruction.  If the dsra32 instruction is executed during an
1034 ;;      integer multiply, the dsra32 will only shift by the amount in
1035 ;;      specified in the instruction rather than the amount plus 32
1036 ;;      bits.
1037 ;;      instruction 1:          mult    rs,rt           integer multiply
1038 ;;      instruction 2-12:       dsra32  rd,rt,rs        doubleword shift
1039 ;;                                                      right arithmetic + 32
1040 ;;      Workaround: A dsra32 instruction placed after an integer
1041 ;;      multiply should not be one of the 11 instructions after the
1042 ;;      multiply instruction."
1043 ;;
1044 ;; and:
1045 ;;
1046 ;; "28. R4000PC, R4000SC: The text from errata 16 should be replaced by
1047 ;;      the following description.
1048 ;;      All extended shifts (shift by n+32) and variable shifts (32 and
1049 ;;      64-bit versions) may produce incorrect results under the
1050 ;;      following conditions:
1051 ;;      1) An integer multiply is currently executing
1052 ;;      2) These types of shift instructions are executed immediately
1053 ;;         following an integer divide instruction.
1054 ;;      Workaround:
1055 ;;      1) Make sure no integer multiply is running wihen these
1056 ;;         instruction are executed.  If this cannot be predicted at
1057 ;;         compile time, then insert a "mfhi" to R0 instruction
1058 ;;         immediately after the integer multiply instruction.  This
1059 ;;         will cause the integer multiply to complete before the shift
1060 ;;         is executed.
1061 ;;      2) Separate integer divide and these two classes of shift
1062 ;;         instructions by another instruction or a noop."
1063 ;;
1064 ;; These processors have PRId values of 0x00004220 and 0x00004300,
1065 ;; respectively.
1066
1067 (define_expand "mulsi3"
1068   [(set (match_operand:SI 0 "register_operand")
1069         (mult:SI (match_operand:SI 1 "register_operand")
1070                  (match_operand:SI 2 "register_operand")))]
1071   ""
1072 {
1073   if (ISA_HAS_MUL3)
1074     emit_insn (gen_mulsi3_mult3 (operands[0], operands[1], operands[2]));
1075   else if (TARGET_FIX_R4000)
1076     emit_insn (gen_mulsi3_r4000 (operands[0], operands[1], operands[2]));
1077   else
1078     emit_insn (gen_mulsi3_internal (operands[0], operands[1], operands[2]));
1079   DONE;
1080 })
1081
1082 (define_expand "muldi3"
1083   [(set (match_operand:DI 0 "register_operand")
1084         (mult:DI (match_operand:DI 1 "register_operand")
1085                  (match_operand:DI 2 "register_operand")))]
1086   "TARGET_64BIT"
1087 {
1088   if (TARGET_FIX_R4000)
1089     emit_insn (gen_muldi3_r4000 (operands[0], operands[1], operands[2]));
1090   else
1091     emit_insn (gen_muldi3_internal (operands[0], operands[1], operands[2]));
1092   DONE;
1093 })
1094
1095 (define_insn "mulsi3_mult3"
1096   [(set (match_operand:SI 0 "register_operand" "=d,l")
1097         (mult:SI (match_operand:SI 1 "register_operand" "d,d")
1098                  (match_operand:SI 2 "register_operand" "d,d")))
1099    (clobber (match_scratch:SI 3 "=h,h"))
1100    (clobber (match_scratch:SI 4 "=l,X"))]
1101   "ISA_HAS_MUL3"
1102 {
1103   if (which_alternative == 1)
1104     return "mult\t%1,%2";
1105   if (TARGET_MIPS3900)
1106     return "mult\t%0,%1,%2";
1107   return "mul\t%0,%1,%2";
1108 }
1109   [(set_attr "type" "imul3,imul")
1110    (set_attr "mode" "SI")])
1111
1112 ;; If a register gets allocated to LO, and we spill to memory, the reload
1113 ;; will include a move from LO to a GPR.  Merge it into the multiplication
1114 ;; if it can set the GPR directly.
1115 ;;
1116 ;; Operand 0: LO
1117 ;; Operand 1: GPR (1st multiplication operand)
1118 ;; Operand 2: GPR (2nd multiplication operand)
1119 ;; Operand 3: HI
1120 ;; Operand 4: GPR (destination)
1121 (define_peephole2
1122   [(parallel
1123        [(set (match_operand:SI 0 "register_operand")
1124              (mult:SI (match_operand:SI 1 "register_operand")
1125                       (match_operand:SI 2 "register_operand")))
1126         (clobber (match_operand:SI 3 "register_operand"))
1127         (clobber (scratch:SI))])
1128    (set (match_operand:SI 4 "register_operand")
1129         (unspec [(match_dup 0) (match_dup 3)] UNSPEC_MFHILO))]
1130   "ISA_HAS_MUL3 && peep2_reg_dead_p (2, operands[0])"
1131   [(parallel
1132        [(set (match_dup 4)
1133              (mult:SI (match_dup 1)
1134                       (match_dup 2)))
1135         (clobber (match_dup 3))
1136         (clobber (match_dup 0))])])
1137
1138 (define_insn "mul<mode>3_internal"
1139   [(set (match_operand:GPR 0 "register_operand" "=l")
1140         (mult:GPR (match_operand:GPR 1 "register_operand" "d")
1141                   (match_operand:GPR 2 "register_operand" "d")))
1142    (clobber (match_scratch:GPR 3 "=h"))]
1143   "!TARGET_FIX_R4000"
1144   "<d>mult\t%1,%2"
1145   [(set_attr "type" "imul")
1146    (set_attr "mode" "<MODE>")])
1147
1148 (define_insn "mul<mode>3_r4000"
1149   [(set (match_operand:GPR 0 "register_operand" "=d")
1150         (mult:GPR (match_operand:GPR 1 "register_operand" "d")
1151                   (match_operand:GPR 2 "register_operand" "d")))
1152    (clobber (match_scratch:GPR 3 "=h"))
1153    (clobber (match_scratch:GPR 4 "=l"))]
1154   "TARGET_FIX_R4000"
1155   "<d>mult\t%1,%2\;mflo\t%0"
1156   [(set_attr "type" "imul")
1157    (set_attr "mode" "<MODE>")
1158    (set_attr "length" "8")])
1159
1160 ;; On the VR4120 and VR4130, it is better to use "mtlo $0; macc" instead
1161 ;; of "mult; mflo".  They have the same latency, but the first form gives
1162 ;; us an extra cycle to compute the operands.
1163
1164 ;; Operand 0: LO
1165 ;; Operand 1: GPR (1st multiplication operand)
1166 ;; Operand 2: GPR (2nd multiplication operand)
1167 ;; Operand 3: HI
1168 ;; Operand 4: GPR (destination)
1169 (define_peephole2
1170   [(parallel
1171        [(set (match_operand:SI 0 "register_operand")
1172              (mult:SI (match_operand:SI 1 "register_operand")
1173                       (match_operand:SI 2 "register_operand")))
1174         (clobber (match_operand:SI 3 "register_operand"))])
1175    (set (match_operand:SI 4 "register_operand")
1176         (unspec:SI [(match_dup 0) (match_dup 3)] UNSPEC_MFHILO))]
1177   "ISA_HAS_MACC && !ISA_HAS_MUL3"
1178   [(set (match_dup 0)
1179         (const_int 0))
1180    (parallel
1181        [(set (match_dup 0)
1182              (plus:SI (mult:SI (match_dup 1)
1183                                (match_dup 2))
1184                       (match_dup 0)))
1185         (set (match_dup 4)
1186              (plus:SI (mult:SI (match_dup 1)
1187                                (match_dup 2))
1188                       (match_dup 0)))
1189         (clobber (match_dup 3))])])
1190
1191 ;; Multiply-accumulate patterns
1192
1193 ;; For processors that can copy the output to a general register:
1194 ;;
1195 ;; The all-d alternative is needed because the combiner will find this
1196 ;; pattern and then register alloc/reload will move registers around to
1197 ;; make them fit, and we don't want to trigger unnecessary loads to LO.
1198 ;;
1199 ;; The last alternative should be made slightly less desirable, but adding
1200 ;; "?" to the constraint is too strong, and causes values to be loaded into
1201 ;; LO even when that's more costly.  For now, using "*d" mostly does the
1202 ;; trick.
1203 (define_insn "*mul_acc_si"
1204   [(set (match_operand:SI 0 "register_operand" "=l,*d,*d")
1205         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "d,d,d")
1206                           (match_operand:SI 2 "register_operand" "d,d,d"))
1207                  (match_operand:SI 3 "register_operand" "0,l,*d")))
1208    (clobber (match_scratch:SI 4 "=h,h,h"))
1209    (clobber (match_scratch:SI 5 "=X,3,l"))
1210    (clobber (match_scratch:SI 6 "=X,X,&d"))]
1211   "(TARGET_MIPS3900
1212    || GENERATE_MADD_MSUB)
1213    && !TARGET_MIPS16"
1214 {
1215   static const char *const madd[] = { "madd\t%1,%2", "madd\t%0,%1,%2" };
1216   if (which_alternative == 2)
1217     return "#";
1218   if (GENERATE_MADD_MSUB && which_alternative != 0)
1219     return "#";
1220   return madd[which_alternative];
1221 }
1222   [(set_attr "type"     "imadd,imadd,multi")
1223    (set_attr "mode"     "SI")
1224    (set_attr "length"   "4,4,8")])
1225
1226 ;; Split the above insn if we failed to get LO allocated.
1227 (define_split
1228   [(set (match_operand:SI 0 "register_operand")
1229         (plus:SI (mult:SI (match_operand:SI 1 "register_operand")
1230                           (match_operand:SI 2 "register_operand"))
1231                  (match_operand:SI 3 "register_operand")))
1232    (clobber (match_scratch:SI 4))
1233    (clobber (match_scratch:SI 5))
1234    (clobber (match_scratch:SI 6))]
1235   "reload_completed && !TARGET_DEBUG_D_MODE
1236    && GP_REG_P (true_regnum (operands[0]))
1237    && GP_REG_P (true_regnum (operands[3]))"
1238   [(parallel [(set (match_dup 6)
1239                    (mult:SI (match_dup 1) (match_dup 2)))
1240               (clobber (match_dup 4))
1241               (clobber (match_dup 5))])
1242    (set (match_dup 0) (plus:SI (match_dup 6) (match_dup 3)))]
1243   "")
1244
1245 ;; Splitter to copy result of MADD to a general register
1246 (define_split
1247   [(set (match_operand:SI                   0 "register_operand")
1248         (plus:SI (mult:SI (match_operand:SI 1 "register_operand")
1249                           (match_operand:SI 2 "register_operand"))
1250                  (match_operand:SI          3 "register_operand")))
1251    (clobber (match_scratch:SI               4))
1252    (clobber (match_scratch:SI               5))
1253    (clobber (match_scratch:SI               6))]
1254   "reload_completed && !TARGET_DEBUG_D_MODE
1255    && GP_REG_P (true_regnum (operands[0]))
1256    && true_regnum (operands[3]) == LO_REGNUM"
1257   [(parallel [(set (match_dup 3)
1258                    (plus:SI (mult:SI (match_dup 1) (match_dup 2))
1259                             (match_dup 3)))
1260               (clobber (match_dup 4))
1261               (clobber (match_dup 5))
1262               (clobber (match_dup 6))])
1263    (set (match_dup 0) (unspec:SI [(match_dup 5) (match_dup 4)] UNSPEC_MFHILO))]
1264   "")
1265
1266 (define_insn "*macc"
1267   [(set (match_operand:SI 0 "register_operand" "=l,d")
1268         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "d,d")
1269                           (match_operand:SI 2 "register_operand" "d,d"))
1270                  (match_operand:SI 3 "register_operand" "0,l")))
1271    (clobber (match_scratch:SI 4 "=h,h"))
1272    (clobber (match_scratch:SI 5 "=X,3"))]
1273   "ISA_HAS_MACC"
1274 {
1275   if (which_alternative == 1)
1276     return "macc\t%0,%1,%2";
1277   else if (TARGET_MIPS5500)
1278     return "madd\t%1,%2";
1279   else
1280     /* The VR4130 assumes that there is a two-cycle latency between a macc
1281        that "writes" to $0 and an instruction that reads from it.  We avoid
1282        this by assigning to $1 instead.  */
1283     return "%[macc\t%@,%1,%2%]";
1284 }
1285   [(set_attr "type" "imadd")
1286    (set_attr "mode" "SI")])
1287
1288 (define_insn "*msac"
1289   [(set (match_operand:SI 0 "register_operand" "=l,d")
1290         (minus:SI (match_operand:SI 1 "register_operand" "0,l")
1291                   (mult:SI (match_operand:SI 2 "register_operand" "d,d")
1292                            (match_operand:SI 3 "register_operand" "d,d"))))
1293    (clobber (match_scratch:SI 4 "=h,h"))
1294    (clobber (match_scratch:SI 5 "=X,1"))]
1295   "ISA_HAS_MSAC"
1296 {
1297   if (which_alternative == 1)
1298     return "msac\t%0,%2,%3";
1299   else if (TARGET_MIPS5500)
1300     return "msub\t%2,%3";
1301   else
1302     return "msac\t$0,%2,%3";
1303 }
1304   [(set_attr "type"     "imadd")
1305    (set_attr "mode"     "SI")])
1306
1307 ;; An msac-like instruction implemented using negation and a macc.
1308 (define_insn_and_split "*msac_using_macc"
1309   [(set (match_operand:SI 0 "register_operand" "=l,d")
1310         (minus:SI (match_operand:SI 1 "register_operand" "0,l")
1311                   (mult:SI (match_operand:SI 2 "register_operand" "d,d")
1312                            (match_operand:SI 3 "register_operand" "d,d"))))
1313    (clobber (match_scratch:SI 4 "=h,h"))
1314    (clobber (match_scratch:SI 5 "=X,1"))
1315    (clobber (match_scratch:SI 6 "=d,d"))]
1316   "ISA_HAS_MACC && !ISA_HAS_MSAC"
1317   "#"
1318   "&& reload_completed"
1319   [(set (match_dup 6)
1320         (neg:SI (match_dup 3)))
1321    (parallel
1322        [(set (match_dup 0)
1323              (plus:SI (mult:SI (match_dup 2)
1324                                (match_dup 6))
1325                       (match_dup 1)))
1326         (clobber (match_dup 4))
1327         (clobber (match_dup 5))])]
1328   ""
1329   [(set_attr "type"     "imadd")
1330    (set_attr "length"   "8")])
1331
1332 ;; Patterns generated by the define_peephole2 below.
1333
1334 (define_insn "*macc2"
1335   [(set (match_operand:SI 0 "register_operand" "=l")
1336         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "d")
1337                           (match_operand:SI 2 "register_operand" "d"))
1338                  (match_dup 0)))
1339    (set (match_operand:SI 3 "register_operand" "=d")
1340         (plus:SI (mult:SI (match_dup 1)
1341                           (match_dup 2))
1342                  (match_dup 0)))
1343    (clobber (match_scratch:SI 4 "=h"))]
1344   "ISA_HAS_MACC && reload_completed"
1345   "macc\t%3,%1,%2"
1346   [(set_attr "type"     "imadd")
1347    (set_attr "mode"     "SI")])
1348
1349 (define_insn "*msac2"
1350   [(set (match_operand:SI 0 "register_operand" "=l")
1351         (minus:SI (match_dup 0)
1352                   (mult:SI (match_operand:SI 1 "register_operand" "d")
1353                            (match_operand:SI 2 "register_operand" "d"))))
1354    (set (match_operand:SI 3 "register_operand" "=d")
1355         (minus:SI (match_dup 0)
1356                   (mult:SI (match_dup 1)
1357                            (match_dup 2))))
1358    (clobber (match_scratch:SI 4 "=h"))]
1359   "ISA_HAS_MSAC && reload_completed"
1360   "msac\t%3,%1,%2"
1361   [(set_attr "type"     "imadd")
1362    (set_attr "mode"     "SI")])
1363
1364 ;; Convert macc $0,<r1>,<r2> & mflo <r3> into macc <r3>,<r1>,<r2>
1365 ;; Similarly msac.
1366 ;;
1367 ;; Operand 0: LO
1368 ;; Operand 1: macc/msac
1369 ;; Operand 2: HI
1370 ;; Operand 3: GPR (destination)
1371 (define_peephole2
1372   [(parallel
1373        [(set (match_operand:SI 0 "register_operand")
1374              (match_operand:SI 1 "macc_msac_operand"))
1375         (clobber (match_operand:SI 2 "register_operand"))
1376         (clobber (scratch:SI))])
1377    (set (match_operand:SI 3 "register_operand")
1378         (unspec:SI [(match_dup 0) (match_dup 2)] UNSPEC_MFHILO))]
1379   ""
1380   [(parallel [(set (match_dup 0)
1381                    (match_dup 1))
1382               (set (match_dup 3)
1383                    (match_dup 1))
1384               (clobber (match_dup 2))])]
1385   "")
1386
1387 ;; When we have a three-address multiplication instruction, it should
1388 ;; be faster to do a separate multiply and add, rather than moving
1389 ;; something into LO in order to use a macc instruction.
1390 ;;
1391 ;; This peephole needs a scratch register to cater for the case when one
1392 ;; of the multiplication operands is the same as the destination.
1393 ;;
1394 ;; Operand 0: GPR (scratch)
1395 ;; Operand 1: LO
1396 ;; Operand 2: GPR (addend)
1397 ;; Operand 3: GPR (destination)
1398 ;; Operand 4: macc/msac
1399 ;; Operand 5: HI
1400 ;; Operand 6: new multiplication
1401 ;; Operand 7: new addition/subtraction
1402 (define_peephole2
1403   [(match_scratch:SI 0 "d")
1404    (set (match_operand:SI 1 "register_operand")
1405         (match_operand:SI 2 "register_operand"))
1406    (match_dup 0)
1407    (parallel
1408        [(set (match_operand:SI 3 "register_operand")
1409              (match_operand:SI 4 "macc_msac_operand"))
1410         (clobber (match_operand:SI 5 "register_operand"))
1411         (clobber (match_dup 1))])]
1412   "ISA_HAS_MUL3
1413    && true_regnum (operands[1]) == LO_REGNUM
1414    && peep2_reg_dead_p (2, operands[1])
1415    && GP_REG_P (true_regnum (operands[3]))"
1416   [(parallel [(set (match_dup 0)
1417                    (match_dup 6))
1418               (clobber (match_dup 5))
1419               (clobber (match_dup 1))])
1420    (set (match_dup 3)
1421         (match_dup 7))]
1422 {
1423   operands[6] = XEXP (operands[4], GET_CODE (operands[4]) == PLUS ? 0 : 1);
1424   operands[7] = gen_rtx_fmt_ee (GET_CODE (operands[4]), SImode,
1425                                 operands[2], operands[0]);
1426 })
1427
1428 ;; Same as above, except LO is the initial target of the macc.
1429 ;;
1430 ;; Operand 0: GPR (scratch)
1431 ;; Operand 1: LO
1432 ;; Operand 2: GPR (addend)
1433 ;; Operand 3: macc/msac
1434 ;; Operand 4: HI
1435 ;; Operand 5: GPR (destination)
1436 ;; Operand 6: new multiplication
1437 ;; Operand 7: new addition/subtraction
1438 (define_peephole2
1439   [(match_scratch:SI 0 "d")
1440    (set (match_operand:SI 1 "register_operand")
1441         (match_operand:SI 2 "register_operand"))
1442    (match_dup 0)
1443    (parallel
1444        [(set (match_dup 1)
1445              (match_operand:SI 3 "macc_msac_operand"))
1446         (clobber (match_operand:SI 4 "register_operand"))
1447         (clobber (scratch:SI))])
1448    (match_dup 0)
1449    (set (match_operand:SI 5 "register_operand")
1450         (unspec:SI [(match_dup 1) (match_dup 4)] UNSPEC_MFHILO))]
1451   "ISA_HAS_MUL3 && peep2_reg_dead_p (3, operands[1])"
1452   [(parallel [(set (match_dup 0)
1453                    (match_dup 6))
1454               (clobber (match_dup 4))
1455               (clobber (match_dup 1))])
1456    (set (match_dup 5)
1457         (match_dup 7))]
1458 {
1459   operands[6] = XEXP (operands[4], GET_CODE (operands[4]) == PLUS ? 0 : 1);
1460   operands[7] = gen_rtx_fmt_ee (GET_CODE (operands[4]), SImode,
1461                                 operands[2], operands[0]);
1462 })
1463
1464 (define_insn "*mul_sub_si"
1465   [(set (match_operand:SI 0 "register_operand" "=l,*d,*d")
1466         (minus:SI (match_operand:SI 1 "register_operand" "0,l,*d")
1467                   (mult:SI (match_operand:SI 2 "register_operand" "d,d,d")
1468                            (match_operand:SI 3 "register_operand" "d,d,d"))))
1469    (clobber (match_scratch:SI 4 "=h,h,h"))
1470    (clobber (match_scratch:SI 5 "=X,1,l"))
1471    (clobber (match_scratch:SI 6 "=X,X,&d"))]
1472   "GENERATE_MADD_MSUB"
1473   "@
1474    msub\t%2,%3
1475    #
1476    #"
1477   [(set_attr "type"     "imadd,multi,multi")
1478    (set_attr "mode"     "SI")
1479    (set_attr "length"   "4,8,8")])
1480
1481 ;; Split the above insn if we failed to get LO allocated.
1482 (define_split
1483   [(set (match_operand:SI 0 "register_operand")
1484         (minus:SI (match_operand:SI 1 "register_operand")
1485                   (mult:SI (match_operand:SI 2 "register_operand")
1486                            (match_operand:SI 3 "register_operand"))))
1487    (clobber (match_scratch:SI 4))
1488    (clobber (match_scratch:SI 5))
1489    (clobber (match_scratch:SI 6))]
1490   "reload_completed && !TARGET_DEBUG_D_MODE
1491    && GP_REG_P (true_regnum (operands[0]))
1492    && GP_REG_P (true_regnum (operands[1]))"
1493   [(parallel [(set (match_dup 6)
1494                    (mult:SI (match_dup 2) (match_dup 3)))
1495               (clobber (match_dup 4))
1496               (clobber (match_dup 5))])
1497    (set (match_dup 0) (minus:SI (match_dup 1) (match_dup 6)))]
1498   "")
1499
1500 ;; Splitter to copy result of MSUB to a general register
1501 (define_split
1502   [(set (match_operand:SI 0 "register_operand")
1503         (minus:SI (match_operand:SI 1 "register_operand")
1504                   (mult:SI (match_operand:SI 2 "register_operand")
1505                            (match_operand:SI 3 "register_operand"))))
1506    (clobber (match_scratch:SI 4))
1507    (clobber (match_scratch:SI 5))
1508    (clobber (match_scratch:SI 6))]
1509   "reload_completed && !TARGET_DEBUG_D_MODE
1510    && GP_REG_P (true_regnum (operands[0]))
1511    && true_regnum (operands[1]) == LO_REGNUM"
1512   [(parallel [(set (match_dup 1)
1513                    (minus:SI (match_dup 1)
1514                              (mult:SI (match_dup 2) (match_dup 3))))
1515               (clobber (match_dup 4))
1516               (clobber (match_dup 5))
1517               (clobber (match_dup 6))])
1518    (set (match_dup 0) (unspec:SI [(match_dup 5) (match_dup 4)] UNSPEC_MFHILO))]
1519   "")
1520
1521 (define_insn "*muls"
1522   [(set (match_operand:SI                  0 "register_operand" "=l,d")
1523         (neg:SI (mult:SI (match_operand:SI 1 "register_operand" "d,d")
1524                          (match_operand:SI 2 "register_operand" "d,d"))))
1525    (clobber (match_scratch:SI              3                    "=h,h"))
1526    (clobber (match_scratch:SI              4                    "=X,l"))]
1527   "ISA_HAS_MULS"
1528   "@
1529    muls\t$0,%1,%2
1530    muls\t%0,%1,%2"
1531   [(set_attr "type"     "imul,imul3")
1532    (set_attr "mode"     "SI")])
1533
1534 ;; ??? We could define a mulditi3 pattern when TARGET_64BIT.
1535
1536 (define_expand "<u>mulsidi3"
1537   [(parallel
1538       [(set (match_operand:DI 0 "register_operand")
1539             (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand"))
1540                      (any_extend:DI (match_operand:SI 2 "register_operand"))))
1541        (clobber (scratch:DI))
1542        (clobber (scratch:DI))
1543        (clobber (scratch:DI))])]
1544   "!TARGET_64BIT || !TARGET_FIX_R4000"
1545 {
1546   if (!TARGET_64BIT)
1547     {
1548       if (!TARGET_FIX_R4000)
1549         emit_insn (gen_<u>mulsidi3_32bit_internal (operands[0], operands[1],
1550                                                    operands[2]));
1551       else
1552         emit_insn (gen_<u>mulsidi3_32bit_r4000 (operands[0], operands[1],
1553                                                 operands[2]));
1554       DONE;
1555     }
1556 })
1557
1558 (define_insn "<u>mulsidi3_32bit_internal"
1559   [(set (match_operand:DI 0 "register_operand" "=x")
1560         (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand" "d"))
1561                  (any_extend:DI (match_operand:SI 2 "register_operand" "d"))))]
1562   "!TARGET_64BIT && !TARGET_FIX_R4000 && !TARGET_DSPR2"
1563   "mult<u>\t%1,%2"
1564   [(set_attr "type" "imul")
1565    (set_attr "mode" "SI")])
1566
1567 (define_insn "<u>mulsidi3_32bit_r4000"
1568   [(set (match_operand:DI 0 "register_operand" "=d")
1569         (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand" "d"))
1570                  (any_extend:DI (match_operand:SI 2 "register_operand" "d"))))
1571    (clobber (match_scratch:DI 3 "=x"))]
1572   "!TARGET_64BIT && TARGET_FIX_R4000"
1573   "mult<u>\t%1,%2\;mflo\t%L0;mfhi\t%M0"
1574   [(set_attr "type" "imul")
1575    (set_attr "mode" "SI")
1576    (set_attr "length" "12")])
1577
1578 (define_insn_and_split "*<u>mulsidi3_64bit"
1579   [(set (match_operand:DI 0 "register_operand" "=d")
1580         (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand" "d"))
1581                  (any_extend:DI (match_operand:SI 2 "register_operand" "d"))))
1582    (clobber (match_scratch:DI 3 "=l"))
1583    (clobber (match_scratch:DI 4 "=h"))
1584    (clobber (match_scratch:DI 5 "=d"))]
1585   "TARGET_64BIT && !TARGET_FIX_R4000"
1586   "#"
1587   "&& reload_completed"
1588   [(parallel
1589        [(set (match_dup 3)
1590              (sign_extend:DI
1591                 (mult:SI (match_dup 1)
1592                          (match_dup 2))))
1593         (set (match_dup 4)
1594              (ashiftrt:DI
1595                 (mult:DI (any_extend:DI (match_dup 1))
1596                          (any_extend:DI (match_dup 2)))
1597                 (const_int 32)))])
1598
1599    ;; OP5 <- LO, OP0 <- HI
1600    (set (match_dup 5) (unspec:DI [(match_dup 3) (match_dup 4)] UNSPEC_MFHILO))
1601    (set (match_dup 0) (unspec:DI [(match_dup 4) (match_dup 3)] UNSPEC_MFHILO))
1602
1603    ;; Zero-extend OP5.
1604    (set (match_dup 5)
1605         (ashift:DI (match_dup 5)
1606                    (const_int 32)))
1607    (set (match_dup 5)
1608         (lshiftrt:DI (match_dup 5)
1609                      (const_int 32)))
1610
1611    ;; Shift OP0 into place.
1612    (set (match_dup 0)
1613         (ashift:DI (match_dup 0)
1614                    (const_int 32)))
1615
1616    ;; OR the two halves together
1617    (set (match_dup 0)
1618         (ior:DI (match_dup 0)
1619                 (match_dup 5)))]
1620   ""
1621   [(set_attr "type" "imul")
1622    (set_attr "mode" "SI")
1623    (set_attr "length" "24")])
1624
1625 (define_insn "*<u>mulsidi3_64bit_parts"
1626   [(set (match_operand:DI 0 "register_operand" "=l")
1627         (sign_extend:DI
1628            (mult:SI (match_operand:SI 2 "register_operand" "d")
1629                     (match_operand:SI 3 "register_operand" "d"))))
1630    (set (match_operand:DI 1 "register_operand" "=h")
1631         (ashiftrt:DI
1632            (mult:DI (any_extend:DI (match_dup 2))
1633                     (any_extend:DI (match_dup 3)))
1634            (const_int 32)))]
1635   "TARGET_64BIT && !TARGET_FIX_R4000"
1636   "mult<u>\t%2,%3"
1637   [(set_attr "type" "imul")
1638    (set_attr "mode" "SI")])
1639
1640 ;; Widening multiply with negation.
1641 (define_insn "*muls<u>_di"
1642   [(set (match_operand:DI 0 "register_operand" "=x")
1643         (neg:DI
1644          (mult:DI
1645           (any_extend:DI (match_operand:SI 1 "register_operand" "d"))
1646           (any_extend:DI (match_operand:SI 2 "register_operand" "d")))))]
1647   "!TARGET_64BIT && ISA_HAS_MULS"
1648   "muls<u>\t$0,%1,%2"
1649   [(set_attr "type" "imul")
1650    (set_attr "mode" "SI")])
1651
1652 (define_insn "*msac<u>_di"
1653   [(set (match_operand:DI 0 "register_operand" "=x")
1654         (minus:DI
1655            (match_operand:DI 3 "register_operand" "0")
1656            (mult:DI
1657               (any_extend:DI (match_operand:SI 1 "register_operand" "d"))
1658               (any_extend:DI (match_operand:SI 2 "register_operand" "d")))))]
1659   "!TARGET_64BIT && ISA_HAS_MSAC"
1660 {
1661   if (TARGET_MIPS5500)
1662     return "msub<u>\t%1,%2";
1663   else
1664     return "msac<u>\t$0,%1,%2";
1665 }
1666   [(set_attr "type" "imadd")
1667    (set_attr "mode" "SI")])
1668
1669 ;; _highpart patterns
1670
1671 (define_expand "<su>mulsi3_highpart"
1672   [(set (match_operand:SI 0 "register_operand")
1673         (truncate:SI
1674          (lshiftrt:DI
1675           (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand"))
1676                    (any_extend:DI (match_operand:SI 2 "register_operand")))
1677           (const_int 32))))]
1678   "ISA_HAS_MULHI || !TARGET_FIX_R4000"
1679 {
1680   if (ISA_HAS_MULHI)
1681     emit_insn (gen_<su>mulsi3_highpart_mulhi_internal (operands[0],
1682                                                        operands[1],
1683                                                        operands[2]));
1684   else
1685     emit_insn (gen_<su>mulsi3_highpart_internal (operands[0], operands[1],
1686                                                  operands[2]));
1687   DONE;
1688 })
1689
1690 (define_insn "<su>mulsi3_highpart_internal"
1691   [(set (match_operand:SI 0 "register_operand" "=h")
1692         (truncate:SI
1693          (lshiftrt:DI
1694           (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand" "d"))
1695                    (any_extend:DI (match_operand:SI 2 "register_operand" "d")))
1696           (const_int 32))))
1697    (clobber (match_scratch:SI 3 "=l"))]
1698   "!ISA_HAS_MULHI && !TARGET_FIX_R4000"
1699   "mult<u>\t%1,%2"
1700   [(set_attr "type" "imul")
1701    (set_attr "mode" "SI")])
1702
1703 (define_insn "<su>mulsi3_highpart_mulhi_internal"
1704   [(set (match_operand:SI 0 "register_operand" "=h,d")
1705         (truncate:SI
1706          (lshiftrt:DI
1707           (mult:DI
1708            (any_extend:DI (match_operand:SI 1 "register_operand" "d,d"))
1709            (any_extend:DI (match_operand:SI 2 "register_operand" "d,d")))
1710           (const_int 32))))
1711    (clobber (match_scratch:SI 3 "=l,l"))
1712    (clobber (match_scratch:SI 4 "=X,h"))]
1713   "ISA_HAS_MULHI"
1714   "@
1715    mult<u>\t%1,%2
1716    mulhi<u>\t%0,%1,%2"
1717   [(set_attr "type" "imul,imul3")
1718    (set_attr "mode" "SI")])
1719
1720 (define_insn "*<su>mulsi3_highpart_neg_mulhi_internal"
1721   [(set (match_operand:SI 0 "register_operand" "=h,d")
1722         (truncate:SI
1723          (lshiftrt:DI
1724           (neg:DI
1725            (mult:DI
1726             (any_extend:DI (match_operand:SI 1 "register_operand" "d,d"))
1727             (any_extend:DI (match_operand:SI 2 "register_operand" "d,d"))))
1728           (const_int 32))))
1729    (clobber (match_scratch:SI 3 "=l,l"))
1730    (clobber (match_scratch:SI 4 "=X,h"))]
1731   "ISA_HAS_MULHI"
1732   "@
1733    mulshi<u>\t%.,%1,%2
1734    mulshi<u>\t%0,%1,%2"
1735   [(set_attr "type" "imul,imul3")
1736    (set_attr "mode" "SI")])
1737
1738 ;; Disable unsigned multiplication for -mfix-vr4120.  This is for VR4120
1739 ;; errata MD(0), which says that dmultu does not always produce the
1740 ;; correct result.
1741 (define_insn "<su>muldi3_highpart"
1742   [(set (match_operand:DI 0 "register_operand" "=h")
1743         (truncate:DI
1744          (lshiftrt:TI
1745           (mult:TI
1746            (any_extend:TI (match_operand:DI 1 "register_operand" "d"))
1747            (any_extend:TI (match_operand:DI 2 "register_operand" "d")))
1748           (const_int 64))))
1749    (clobber (match_scratch:DI 3 "=l"))]
1750   "TARGET_64BIT && !TARGET_FIX_R4000
1751    && !(<CODE> == ZERO_EXTEND && TARGET_FIX_VR4120)"
1752   "dmult<u>\t%1,%2"
1753   [(set_attr "type" "imul")
1754    (set_attr "mode" "DI")])
1755
1756 ;; The R4650 supports a 32-bit multiply/ 64-bit accumulate
1757 ;; instruction.  The HI/LO registers are used as a 64-bit accumulator.
1758
1759 (define_insn "madsi"
1760   [(set (match_operand:SI 0 "register_operand" "+l")
1761         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "d")
1762                           (match_operand:SI 2 "register_operand" "d"))
1763                  (match_dup 0)))
1764    (clobber (match_scratch:SI 3 "=h"))]
1765   "TARGET_MAD"
1766   "mad\t%1,%2"
1767   [(set_attr "type"     "imadd")
1768    (set_attr "mode"     "SI")])
1769
1770 (define_insn "<u>maddsidi4"
1771   [(set (match_operand:DI 0 "register_operand" "=ka")
1772         (plus:DI
1773          (mult:DI (any_extend:DI (match_operand:SI 1 "register_operand" "d"))
1774                   (any_extend:DI (match_operand:SI 2 "register_operand" "d")))
1775          (match_operand:DI 3 "register_operand" "0")))]
1776   "(TARGET_MAD || ISA_HAS_MACC || GENERATE_MADD_MSUB || TARGET_DSPR2)
1777    && !TARGET_64BIT"
1778 {
1779   if (TARGET_MAD)
1780     return "mad<u>\t%1,%2";
1781   else if (TARGET_DSPR2)
1782     return "madd<u>\t%q0,%1,%2";
1783   else if (GENERATE_MADD_MSUB || TARGET_MIPS5500)
1784     return "madd<u>\t%1,%2";
1785   else
1786     /* See comment in *macc.  */
1787     return "%[macc<u>\t%@,%1,%2%]";
1788 }
1789   [(set_attr "type" "imadd")
1790    (set_attr "mode" "SI")])
1791
1792 ;; Floating point multiply accumulate instructions.
1793
1794 (define_insn "*madd<mode>"
1795   [(set (match_operand:ANYF 0 "register_operand" "=f")
1796         (plus:ANYF (mult:ANYF (match_operand:ANYF 1 "register_operand" "f")
1797                               (match_operand:ANYF 2 "register_operand" "f"))
1798                    (match_operand:ANYF 3 "register_operand" "f")))]
1799   "ISA_HAS_FP4 && TARGET_FUSED_MADD"
1800   "madd.<fmt>\t%0,%3,%1,%2"
1801   [(set_attr "type" "fmadd")
1802    (set_attr "mode" "<UNITMODE>")])
1803
1804 (define_insn "*msub<mode>"
1805   [(set (match_operand:ANYF 0 "register_operand" "=f")
1806         (minus:ANYF (mult:ANYF (match_operand:ANYF 1 "register_operand" "f")
1807                                (match_operand:ANYF 2 "register_operand" "f"))
1808                     (match_operand:ANYF 3 "register_operand" "f")))]
1809   "ISA_HAS_FP4 && TARGET_FUSED_MADD"
1810   "msub.<fmt>\t%0,%3,%1,%2"
1811   [(set_attr "type" "fmadd")
1812    (set_attr "mode" "<UNITMODE>")])
1813
1814 (define_insn "*nmadd<mode>"
1815   [(set (match_operand:ANYF 0 "register_operand" "=f")
1816         (neg:ANYF (plus:ANYF
1817                    (mult:ANYF (match_operand:ANYF 1 "register_operand" "f")
1818                               (match_operand:ANYF 2 "register_operand" "f"))
1819                    (match_operand:ANYF 3 "register_operand" "f"))))]
1820   "ISA_HAS_NMADD_NMSUB && TARGET_FUSED_MADD
1821    && HONOR_SIGNED_ZEROS (<MODE>mode)
1822    && !HONOR_NANS (<MODE>mode)"
1823   "nmadd.<fmt>\t%0,%3,%1,%2"
1824   [(set_attr "type" "fmadd")
1825    (set_attr "mode" "<UNITMODE>")])
1826
1827 (define_insn "*nmadd<mode>_fastmath"
1828   [(set (match_operand:ANYF 0 "register_operand" "=f")
1829         (minus:ANYF
1830          (mult:ANYF (neg:ANYF (match_operand:ANYF 1 "register_operand" "f"))
1831                     (match_operand:ANYF 2 "register_operand" "f"))
1832          (match_operand:ANYF 3 "register_operand" "f")))]
1833   "ISA_HAS_NMADD_NMSUB && TARGET_FUSED_MADD
1834    && !HONOR_SIGNED_ZEROS (<MODE>mode)
1835    && !HONOR_NANS (<MODE>mode)"
1836   "nmadd.<fmt>\t%0,%3,%1,%2"
1837   [(set_attr "type" "fmadd")
1838    (set_attr "mode" "<UNITMODE>")])
1839
1840 (define_insn "*nmsub<mode>"
1841   [(set (match_operand:ANYF 0 "register_operand" "=f")
1842         (neg:ANYF (minus:ANYF
1843                    (mult:ANYF (match_operand:ANYF 2 "register_operand" "f")
1844                               (match_operand:ANYF 3 "register_operand" "f"))
1845                    (match_operand:ANYF 1 "register_operand" "f"))))]
1846   "ISA_HAS_NMADD_NMSUB && TARGET_FUSED_MADD
1847    && HONOR_SIGNED_ZEROS (<MODE>mode)
1848    && !HONOR_NANS (<MODE>mode)"
1849   "nmsub.<fmt>\t%0,%1,%2,%3"
1850   [(set_attr "type" "fmadd")
1851    (set_attr "mode" "<UNITMODE>")])
1852
1853 (define_insn "*nmsub<mode>_fastmath"
1854   [(set (match_operand:ANYF 0 "register_operand" "=f")
1855         (minus:ANYF
1856          (match_operand:ANYF 1 "register_operand" "f")
1857          (mult:ANYF (match_operand:ANYF 2 "register_operand" "f")
1858                     (match_operand:ANYF 3 "register_operand" "f"))))]
1859   "ISA_HAS_NMADD_NMSUB && TARGET_FUSED_MADD
1860    && !HONOR_SIGNED_ZEROS (<MODE>mode)
1861    && !HONOR_NANS (<MODE>mode)"
1862   "nmsub.<fmt>\t%0,%1,%2,%3"
1863   [(set_attr "type" "fmadd")
1864    (set_attr "mode" "<UNITMODE>")])
1865 \f
1866 ;;
1867 ;;  ....................
1868 ;;
1869 ;;      DIVISION and REMAINDER
1870 ;;
1871 ;;  ....................
1872 ;;
1873
1874 (define_expand "div<mode>3"
1875   [(set (match_operand:ANYF 0 "register_operand")
1876         (div:ANYF (match_operand:ANYF 1 "reg_or_1_operand")
1877                   (match_operand:ANYF 2 "register_operand")))]
1878   "<divide_condition>"
1879 {
1880   if (const_1_operand (operands[1], <MODE>mode))
1881     if (!(ISA_HAS_FP4 && flag_unsafe_math_optimizations))
1882       operands[1] = force_reg (<MODE>mode, operands[1]);
1883 })
1884
1885 ;; These patterns work around the early SB-1 rev2 core "F1" erratum:
1886 ;;
1887 ;; If an mfc1 or dmfc1 happens to access the floating point register
1888 ;; file at the same time a long latency operation (div, sqrt, recip,
1889 ;; sqrt) iterates an intermediate result back through the floating
1890 ;; point register file bypass, then instead returning the correct
1891 ;; register value the mfc1 or dmfc1 operation returns the intermediate
1892 ;; result of the long latency operation.
1893 ;;
1894 ;; The workaround is to insert an unconditional 'mov' from/to the
1895 ;; long latency op destination register.
1896
1897 (define_insn "*div<mode>3"
1898   [(set (match_operand:ANYF 0 "register_operand" "=f")
1899         (div:ANYF (match_operand:ANYF 1 "register_operand" "f")
1900                   (match_operand:ANYF 2 "register_operand" "f")))]
1901   "<divide_condition>"
1902 {
1903   if (TARGET_FIX_SB1)
1904     return "div.<fmt>\t%0,%1,%2\;mov.<fmt>\t%0,%0";
1905   else
1906     return "div.<fmt>\t%0,%1,%2";
1907 }
1908   [(set_attr "type" "fdiv")
1909    (set_attr "mode" "<UNITMODE>")
1910    (set (attr "length")
1911         (if_then_else (ne (symbol_ref "TARGET_FIX_SB1") (const_int 0))
1912                       (const_int 8)
1913                       (const_int 4)))])
1914
1915 (define_insn "*recip<mode>3"
1916   [(set (match_operand:ANYF 0 "register_operand" "=f")
1917         (div:ANYF (match_operand:ANYF 1 "const_1_operand" "")
1918                   (match_operand:ANYF 2 "register_operand" "f")))]
1919   "<recip_condition> && flag_unsafe_math_optimizations"
1920 {
1921   if (TARGET_FIX_SB1)
1922     return "recip.<fmt>\t%0,%2\;mov.<fmt>\t%0,%0";
1923   else
1924     return "recip.<fmt>\t%0,%2";
1925 }
1926   [(set_attr "type" "frdiv")
1927    (set_attr "mode" "<UNITMODE>")
1928    (set (attr "length")
1929         (if_then_else (ne (symbol_ref "TARGET_FIX_SB1") (const_int 0))
1930                       (const_int 8)
1931                       (const_int 4)))])
1932
1933 ;; VR4120 errata MD(A1): signed division instructions do not work correctly
1934 ;; with negative operands.  We use special libgcc functions instead.
1935 (define_insn "divmod<mode>4"
1936   [(set (match_operand:GPR 0 "register_operand" "=l")
1937         (div:GPR (match_operand:GPR 1 "register_operand" "d")
1938                  (match_operand:GPR 2 "register_operand" "d")))
1939    (set (match_operand:GPR 3 "register_operand" "=h")
1940         (mod:GPR (match_dup 1)
1941                  (match_dup 2)))]
1942   "!TARGET_FIX_VR4120"
1943   { return mips_output_division ("<d>div\t$0,%1,%2", operands); }
1944   [(set_attr "type" "idiv")
1945    (set_attr "mode" "<MODE>")])
1946
1947 (define_insn "udivmod<mode>4"
1948   [(set (match_operand:GPR 0 "register_operand" "=l")
1949         (udiv:GPR (match_operand:GPR 1 "register_operand" "d")
1950                   (match_operand:GPR 2 "register_operand" "d")))
1951    (set (match_operand:GPR 3 "register_operand" "=h")
1952         (umod:GPR (match_dup 1)
1953                   (match_dup 2)))]
1954   ""
1955   { return mips_output_division ("<d>divu\t$0,%1,%2", operands); }
1956   [(set_attr "type" "idiv")
1957    (set_attr "mode" "<MODE>")])
1958 \f
1959 ;;
1960 ;;  ....................
1961 ;;
1962 ;;      SQUARE ROOT
1963 ;;
1964 ;;  ....................
1965
1966 ;; These patterns work around the early SB-1 rev2 core "F1" erratum (see
1967 ;; "*div[sd]f3" comment for details).
1968
1969 (define_insn "sqrt<mode>2"
1970   [(set (match_operand:ANYF 0 "register_operand" "=f")
1971         (sqrt:ANYF (match_operand:ANYF 1 "register_operand" "f")))]
1972   "<sqrt_condition>"
1973 {
1974   if (TARGET_FIX_SB1)
1975     return "sqrt.<fmt>\t%0,%1\;mov.<fmt>\t%0,%0";
1976   else
1977     return "sqrt.<fmt>\t%0,%1";
1978 }
1979   [(set_attr "type" "fsqrt")
1980    (set_attr "mode" "<UNITMODE>")
1981    (set (attr "length")
1982         (if_then_else (ne (symbol_ref "TARGET_FIX_SB1") (const_int 0))
1983                       (const_int 8)
1984                       (const_int 4)))])
1985
1986 (define_insn "*rsqrt<mode>a"
1987   [(set (match_operand:ANYF 0 "register_operand" "=f")
1988         (div:ANYF (match_operand:ANYF 1 "const_1_operand" "")
1989                   (sqrt:ANYF (match_operand:ANYF 2 "register_operand" "f"))))]
1990   "<recip_condition> && flag_unsafe_math_optimizations"
1991 {
1992   if (TARGET_FIX_SB1)
1993     return "rsqrt.<fmt>\t%0,%2\;mov.<fmt>\t%0,%0";
1994   else
1995     return "rsqrt.<fmt>\t%0,%2";
1996 }
1997   [(set_attr "type" "frsqrt")
1998    (set_attr "mode" "<UNITMODE>")
1999    (set (attr "length")
2000         (if_then_else (ne (symbol_ref "TARGET_FIX_SB1") (const_int 0))
2001                       (const_int 8)
2002                       (const_int 4)))])
2003
2004 (define_insn "*rsqrt<mode>b"
2005   [(set (match_operand:ANYF 0 "register_operand" "=f")
2006         (sqrt:ANYF (div:ANYF (match_operand:ANYF 1 "const_1_operand" "")
2007                              (match_operand:ANYF 2 "register_operand" "f"))))]
2008   "<recip_condition> && flag_unsafe_math_optimizations"
2009 {
2010   if (TARGET_FIX_SB1)
2011     return "rsqrt.<fmt>\t%0,%2\;mov.<fmt>\t%0,%0";
2012   else
2013     return "rsqrt.<fmt>\t%0,%2";
2014 }
2015   [(set_attr "type" "frsqrt")
2016    (set_attr "mode" "<UNITMODE>")
2017    (set (attr "length")
2018         (if_then_else (ne (symbol_ref "TARGET_FIX_SB1") (const_int 0))
2019                       (const_int 8)
2020                       (const_int 4)))])
2021 \f
2022 ;;
2023 ;;  ....................
2024 ;;
2025 ;;      ABSOLUTE VALUE
2026 ;;
2027 ;;  ....................
2028
2029 ;; Do not use the integer abs macro instruction, since that signals an
2030 ;; exception on -2147483648 (sigh).
2031
2032 ;; abs.fmt is an arithmetic instruction and treats all NaN inputs as
2033 ;; invalid; it does not clear their sign bits.  We therefore can't use
2034 ;; abs.fmt if the signs of NaNs matter.
2035
2036 (define_insn "abs<mode>2"
2037   [(set (match_operand:ANYF 0 "register_operand" "=f")
2038         (abs:ANYF (match_operand:ANYF 1 "register_operand" "f")))]
2039   "!HONOR_NANS (<MODE>mode)"
2040   "abs.<fmt>\t%0,%1"
2041   [(set_attr "type" "fabs")
2042    (set_attr "mode" "<UNITMODE>")])
2043 \f
2044 ;;
2045 ;;  ...................
2046 ;;
2047 ;;  Count leading zeroes.
2048 ;;
2049 ;;  ...................
2050 ;;
2051
2052 (define_insn "clz<mode>2"
2053   [(set (match_operand:GPR 0 "register_operand" "=d")
2054         (clz:GPR (match_operand:GPR 1 "register_operand" "d")))]
2055   "ISA_HAS_CLZ_CLO"
2056   "<d>clz\t%0,%1"
2057   [(set_attr "type" "clz")
2058    (set_attr "mode" "<MODE>")])
2059 \f
2060 ;;
2061 ;;  ....................
2062 ;;
2063 ;;      NEGATION and ONE'S COMPLEMENT
2064 ;;
2065 ;;  ....................
2066
2067 (define_insn "negsi2"
2068   [(set (match_operand:SI 0 "register_operand" "=d")
2069         (neg:SI (match_operand:SI 1 "register_operand" "d")))]
2070   ""
2071 {
2072   if (TARGET_MIPS16)
2073     return "neg\t%0,%1";
2074   else
2075     return "subu\t%0,%.,%1";
2076 }
2077   [(set_attr "type"     "arith")
2078    (set_attr "mode"     "SI")])
2079
2080 (define_insn "negdi2"
2081   [(set (match_operand:DI 0 "register_operand" "=d")
2082         (neg:DI (match_operand:DI 1 "register_operand" "d")))]
2083   "TARGET_64BIT && !TARGET_MIPS16"
2084   "dsubu\t%0,%.,%1"
2085   [(set_attr "type"     "arith")
2086    (set_attr "mode"     "DI")])
2087
2088 ;; neg.fmt is an arithmetic instruction and treats all NaN inputs as
2089 ;; invalid; it does not flip their sign bit.  We therefore can't use
2090 ;; neg.fmt if the signs of NaNs matter.
2091
2092 (define_insn "neg<mode>2"
2093   [(set (match_operand:ANYF 0 "register_operand" "=f")
2094         (neg:ANYF (match_operand:ANYF 1 "register_operand" "f")))]
2095   "!HONOR_NANS (<MODE>mode)"
2096   "neg.<fmt>\t%0,%1"
2097   [(set_attr "type" "fneg")
2098    (set_attr "mode" "<UNITMODE>")])
2099
2100 (define_insn "one_cmpl<mode>2"
2101   [(set (match_operand:GPR 0 "register_operand" "=d")
2102         (not:GPR (match_operand:GPR 1 "register_operand" "d")))]
2103   ""
2104 {
2105   if (TARGET_MIPS16)
2106     return "not\t%0,%1";
2107   else
2108     return "nor\t%0,%.,%1";
2109 }
2110   [(set_attr "type" "arith")
2111    (set_attr "mode" "<MODE>")])
2112 \f
2113 ;;
2114 ;;  ....................
2115 ;;
2116 ;;      LOGICAL
2117 ;;
2118 ;;  ....................
2119 ;;
2120
2121 ;; Many of these instructions use trivial define_expands, because we
2122 ;; want to use a different set of constraints when TARGET_MIPS16.
2123
2124 (define_expand "and<mode>3"
2125   [(set (match_operand:GPR 0 "register_operand")
2126         (and:GPR (match_operand:GPR 1 "register_operand")
2127                  (match_operand:GPR 2 "uns_arith_operand")))]
2128   ""
2129 {
2130   if (TARGET_MIPS16)
2131     operands[2] = force_reg (<MODE>mode, operands[2]);
2132 })
2133
2134 (define_insn "*and<mode>3"
2135   [(set (match_operand:GPR 0 "register_operand" "=d,d")
2136         (and:GPR (match_operand:GPR 1 "register_operand" "%d,d")
2137                  (match_operand:GPR 2 "uns_arith_operand" "d,K")))]
2138   "!TARGET_MIPS16"
2139   "@
2140    and\t%0,%1,%2
2141    andi\t%0,%1,%x2"
2142   [(set_attr "type" "arith")
2143    (set_attr "mode" "<MODE>")])
2144
2145 (define_insn "*and<mode>3_mips16"
2146   [(set (match_operand:GPR 0 "register_operand" "=d")
2147         (and:GPR (match_operand:GPR 1 "register_operand" "%0")
2148                  (match_operand:GPR 2 "register_operand" "d")))]
2149   "TARGET_MIPS16"
2150   "and\t%0,%2"
2151   [(set_attr "type" "arith")
2152    (set_attr "mode" "<MODE>")])
2153
2154 (define_expand "ior<mode>3"
2155   [(set (match_operand:GPR 0 "register_operand")
2156         (ior:GPR (match_operand:GPR 1 "register_operand")
2157                  (match_operand:GPR 2 "uns_arith_operand")))]
2158   ""
2159 {
2160   if (TARGET_MIPS16)
2161     operands[2] = force_reg (<MODE>mode, operands[2]);
2162 })
2163
2164 (define_insn "*ior<mode>3"
2165   [(set (match_operand:GPR 0 "register_operand" "=d,d")
2166         (ior:GPR (match_operand:GPR 1 "register_operand" "%d,d")
2167                  (match_operand:GPR 2 "uns_arith_operand" "d,K")))]
2168   "!TARGET_MIPS16"
2169   "@
2170    or\t%0,%1,%2
2171    ori\t%0,%1,%x2"
2172   [(set_attr "type" "arith")
2173    (set_attr "mode" "<MODE>")])
2174
2175 (define_insn "*ior<mode>3_mips16"
2176   [(set (match_operand:GPR 0 "register_operand" "=d")
2177         (ior:GPR (match_operand:GPR 1 "register_operand" "%0")
2178                  (match_operand:GPR 2 "register_operand" "d")))]
2179   "TARGET_MIPS16"
2180   "or\t%0,%2"
2181   [(set_attr "type" "arith")
2182    (set_attr "mode" "<MODE>")])
2183
2184 (define_expand "xor<mode>3"
2185   [(set (match_operand:GPR 0 "register_operand")
2186         (xor:GPR (match_operand:GPR 1 "register_operand")
2187                  (match_operand:GPR 2 "uns_arith_operand")))]
2188   ""
2189   "")
2190
2191 (define_insn ""
2192   [(set (match_operand:GPR 0 "register_operand" "=d,d")
2193         (xor:GPR (match_operand:GPR 1 "register_operand" "%d,d")
2194                  (match_operand:GPR 2 "uns_arith_operand" "d,K")))]
2195   "!TARGET_MIPS16"
2196   "@
2197    xor\t%0,%1,%2
2198    xori\t%0,%1,%x2"
2199   [(set_attr "type" "arith")
2200    (set_attr "mode" "<MODE>")])
2201
2202 (define_insn ""
2203   [(set (match_operand:GPR 0 "register_operand" "=d,t,t")
2204         (xor:GPR (match_operand:GPR 1 "register_operand" "%0,d,d")
2205                  (match_operand:GPR 2 "uns_arith_operand" "d,K,d")))]
2206   "TARGET_MIPS16"
2207   "@
2208    xor\t%0,%2
2209    cmpi\t%1,%2
2210    cmp\t%1,%2"
2211   [(set_attr "type" "arith")
2212    (set_attr "mode" "<MODE>")
2213    (set_attr_alternative "length"
2214                 [(const_int 4)
2215                  (if_then_else (match_operand:VOID 2 "m16_uimm8_1")
2216                                (const_int 4)
2217                                (const_int 8))
2218                  (const_int 4)])])
2219
2220 (define_insn "*nor<mode>3"
2221   [(set (match_operand:GPR 0 "register_operand" "=d")
2222         (and:GPR (not:GPR (match_operand:GPR 1 "register_operand" "d"))
2223                  (not:GPR (match_operand:GPR 2 "register_operand" "d"))))]
2224   "!TARGET_MIPS16"
2225   "nor\t%0,%1,%2"
2226   [(set_attr "type" "arith")
2227    (set_attr "mode" "<MODE>")])
2228 \f
2229 ;;
2230 ;;  ....................
2231 ;;
2232 ;;      TRUNCATION
2233 ;;
2234 ;;  ....................
2235
2236
2237
2238 (define_insn "truncdfsf2"
2239   [(set (match_operand:SF 0 "register_operand" "=f")
2240         (float_truncate:SF (match_operand:DF 1 "register_operand" "f")))]
2241   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT"
2242   "cvt.s.d\t%0,%1"
2243   [(set_attr "type"     "fcvt")
2244    (set_attr "cnv_mode" "D2S")   
2245    (set_attr "mode"     "SF")])
2246
2247 ;; Integer truncation patterns.  Truncating SImode values to smaller
2248 ;; modes is a no-op, as it is for most other GCC ports.  Truncating
2249 ;; DImode values to SImode is not a no-op for TARGET_64BIT since we
2250 ;; need to make sure that the lower 32 bits are properly sign-extended
2251 ;; (see TRULY_NOOP_TRUNCATION).  Truncating DImode values into modes
2252 ;; smaller than SImode is equivalent to two separate truncations:
2253 ;;
2254 ;;                        A       B
2255 ;;    DI ---> HI  ==  DI ---> SI ---> HI
2256 ;;    DI ---> QI  ==  DI ---> SI ---> QI
2257 ;;
2258 ;; Step A needs a real instruction but step B does not.
2259
2260 (define_insn "truncdisi2"
2261   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,m")
2262         (truncate:SI (match_operand:DI 1 "register_operand" "d,d")))]
2263   "TARGET_64BIT"
2264   "@
2265     sll\t%0,%1,0
2266     sw\t%1,%0"
2267   [(set_attr "type" "shift,store")
2268    (set_attr "mode" "SI")
2269    (set_attr "extended_mips16" "yes,*")])
2270
2271 (define_insn "truncdihi2"
2272   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,m")
2273         (truncate:HI (match_operand:DI 1 "register_operand" "d,d")))]
2274   "TARGET_64BIT"
2275   "@
2276     sll\t%0,%1,0
2277     sh\t%1,%0"
2278   [(set_attr "type" "shift,store")
2279    (set_attr "mode" "SI")
2280    (set_attr "extended_mips16" "yes,*")])
2281
2282 (define_insn "truncdiqi2"
2283   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,m")
2284         (truncate:QI (match_operand:DI 1 "register_operand" "d,d")))]
2285   "TARGET_64BIT"
2286   "@
2287     sll\t%0,%1,0
2288     sb\t%1,%0"
2289   [(set_attr "type" "shift,store")
2290    (set_attr "mode" "SI")
2291    (set_attr "extended_mips16" "yes,*")])
2292
2293 ;; Combiner patterns to optimize shift/truncate combinations.
2294
2295 (define_insn ""
2296   [(set (match_operand:SI 0 "register_operand" "=d")
2297         (truncate:SI
2298           (ashiftrt:DI (match_operand:DI 1 "register_operand" "d")
2299                        (match_operand:DI 2 "const_arith_operand" ""))))]
2300   "TARGET_64BIT && !TARGET_MIPS16 && INTVAL (operands[2]) >= 32"
2301   "dsra\t%0,%1,%2"
2302   [(set_attr "type" "shift")
2303    (set_attr "mode" "SI")])
2304
2305 (define_insn ""
2306   [(set (match_operand:SI 0 "register_operand" "=d")
2307         (truncate:SI (lshiftrt:DI (match_operand:DI 1 "register_operand" "d")
2308                                   (const_int 32))))]
2309   "TARGET_64BIT && !TARGET_MIPS16"
2310   "dsra\t%0,%1,32"
2311   [(set_attr "type" "shift")
2312    (set_attr "mode" "SI")])
2313
2314
2315 ;; Combiner patterns for truncate/sign_extend combinations.  They use
2316 ;; the shift/truncate patterns above.
2317
2318 (define_insn_and_split ""
2319   [(set (match_operand:SI 0 "register_operand" "=d")
2320         (sign_extend:SI
2321             (truncate:HI (match_operand:DI 1 "register_operand" "d"))))]
2322   "TARGET_64BIT && !TARGET_MIPS16"
2323   "#"
2324   "&& reload_completed"
2325   [(set (match_dup 2)
2326         (ashift:DI (match_dup 1)
2327                    (const_int 48)))
2328    (set (match_dup 0)
2329         (truncate:SI (ashiftrt:DI (match_dup 2)
2330                                   (const_int 48))))]
2331   { operands[2] = gen_lowpart (DImode, operands[0]); })
2332
2333 (define_insn_and_split ""
2334   [(set (match_operand:SI 0 "register_operand" "=d")
2335         (sign_extend:SI
2336             (truncate:QI (match_operand:DI 1 "register_operand" "d"))))]
2337   "TARGET_64BIT && !TARGET_MIPS16"
2338   "#"
2339   "&& reload_completed"
2340   [(set (match_dup 2)
2341         (ashift:DI (match_dup 1)
2342                    (const_int 56)))
2343    (set (match_dup 0)
2344         (truncate:SI (ashiftrt:DI (match_dup 2)
2345                                   (const_int 56))))]
2346   { operands[2] = gen_lowpart (DImode, operands[0]); })
2347
2348
2349 ;; Combiner patterns to optimize truncate/zero_extend combinations.
2350
2351 (define_insn ""
2352   [(set (match_operand:SI 0 "register_operand" "=d")
2353         (zero_extend:SI (truncate:HI
2354                          (match_operand:DI 1 "register_operand" "d"))))]
2355   "TARGET_64BIT && !TARGET_MIPS16"
2356   "andi\t%0,%1,0xffff"
2357   [(set_attr "type"     "arith")
2358    (set_attr "mode"     "SI")])
2359
2360 (define_insn ""
2361   [(set (match_operand:SI 0 "register_operand" "=d")
2362         (zero_extend:SI (truncate:QI
2363                          (match_operand:DI 1 "register_operand" "d"))))]
2364   "TARGET_64BIT && !TARGET_MIPS16"
2365   "andi\t%0,%1,0xff"
2366   [(set_attr "type"     "arith")
2367    (set_attr "mode"     "SI")])
2368
2369 (define_insn ""
2370   [(set (match_operand:HI 0 "register_operand" "=d")
2371         (zero_extend:HI (truncate:QI
2372                          (match_operand:DI 1 "register_operand" "d"))))]
2373   "TARGET_64BIT && !TARGET_MIPS16"
2374   "andi\t%0,%1,0xff"
2375   [(set_attr "type"     "arith")
2376    (set_attr "mode"     "HI")])
2377 \f
2378 ;;
2379 ;;  ....................
2380 ;;
2381 ;;      ZERO EXTENSION
2382 ;;
2383 ;;  ....................
2384
2385 ;; Extension insns.
2386
2387 (define_insn_and_split "zero_extendsidi2"
2388   [(set (match_operand:DI 0 "register_operand" "=d,d")
2389         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "d,W")))]
2390   "TARGET_64BIT"
2391   "@
2392    #
2393    lwu\t%0,%1"
2394   "&& reload_completed && REG_P (operands[1])"
2395   [(set (match_dup 0)
2396         (ashift:DI (match_dup 1) (const_int 32)))
2397    (set (match_dup 0)
2398         (lshiftrt:DI (match_dup 0) (const_int 32)))]
2399   { operands[1] = gen_lowpart (DImode, operands[1]); }
2400   [(set_attr "type" "multi,load")
2401    (set_attr "mode" "DI")
2402    (set_attr "length" "8,*")])
2403
2404 ;; Combine is not allowed to convert this insn into a zero_extendsidi2
2405 ;; because of TRULY_NOOP_TRUNCATION.
2406
2407 (define_insn_and_split "*clear_upper32"
2408   [(set (match_operand:DI 0 "register_operand" "=d,d")
2409         (and:DI (match_operand:DI 1 "nonimmediate_operand" "d,o")
2410                 (const_int 4294967295)))]
2411   "TARGET_64BIT"
2412 {
2413   if (which_alternative == 0)
2414     return "#";
2415
2416   operands[1] = gen_lowpart (SImode, operands[1]);
2417   return "lwu\t%0,%1";
2418 }
2419   "&& reload_completed && REG_P (operands[1])"
2420   [(set (match_dup 0)
2421         (ashift:DI (match_dup 1) (const_int 32)))
2422    (set (match_dup 0)
2423         (lshiftrt:DI (match_dup 0) (const_int 32)))]
2424   ""
2425   [(set_attr "type" "multi,load")
2426    (set_attr "mode" "DI")
2427    (set_attr "length" "8,*")])
2428
2429 (define_expand "zero_extend<SHORT:mode><GPR:mode>2"
2430   [(set (match_operand:GPR 0 "register_operand")
2431         (zero_extend:GPR (match_operand:SHORT 1 "nonimmediate_operand")))]
2432   ""
2433 {
2434   if (TARGET_MIPS16 && !GENERATE_MIPS16E
2435       && !memory_operand (operands[1], <SHORT:MODE>mode))
2436     {
2437       emit_insn (gen_and<GPR:mode>3 (operands[0],
2438                                      gen_lowpart (<GPR:MODE>mode, operands[1]),
2439                                      force_reg (<GPR:MODE>mode,
2440                                                 GEN_INT (<SHORT:mask>))));
2441       DONE;
2442     }
2443 })
2444
2445 (define_insn "*zero_extend<SHORT:mode><GPR:mode>2"
2446   [(set (match_operand:GPR 0 "register_operand" "=d,d")
2447         (zero_extend:GPR
2448              (match_operand:SHORT 1 "nonimmediate_operand" "d,m")))]
2449   "!TARGET_MIPS16"
2450   "@
2451    andi\t%0,%1,<SHORT:mask>
2452    l<SHORT:size>u\t%0,%1"
2453   [(set_attr "type" "arith,load")
2454    (set_attr "mode" "<GPR:MODE>")])
2455
2456 (define_insn "*zero_extend<SHORT:mode><GPR:mode>2_mips16e"
2457   [(set (match_operand:GPR 0 "register_operand" "=d")
2458         (zero_extend:GPR (match_operand:SHORT 1 "register_operand" "0")))]
2459   "GENERATE_MIPS16E"
2460   "ze<SHORT:size>\t%0"
2461   [(set_attr "type" "arith")
2462    (set_attr "mode" "<GPR:MODE>")])
2463
2464 (define_insn "*zero_extend<SHORT:mode><GPR:mode>2_mips16"
2465   [(set (match_operand:GPR 0 "register_operand" "=d")
2466         (zero_extend:GPR (match_operand:SHORT 1 "memory_operand" "m")))]
2467   "TARGET_MIPS16"
2468   "l<SHORT:size>u\t%0,%1"
2469   [(set_attr "type" "load")
2470    (set_attr "mode" "<GPR:MODE>")])
2471
2472 (define_expand "zero_extendqihi2"
2473   [(set (match_operand:HI 0 "register_operand")
2474         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand")))]
2475   ""
2476 {
2477   if (TARGET_MIPS16 && !memory_operand (operands[1], QImode))
2478     {
2479       emit_insn (gen_zero_extendqisi2 (gen_lowpart (SImode, operands[0]),
2480                                        operands[1]));
2481       DONE;
2482     }
2483 })
2484
2485 (define_insn "*zero_extendqihi2"
2486   [(set (match_operand:HI 0 "register_operand" "=d,d")
2487         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "d,m")))]
2488   "!TARGET_MIPS16"
2489   "@
2490    andi\t%0,%1,0x00ff
2491    lbu\t%0,%1"
2492   [(set_attr "type" "arith,load")
2493    (set_attr "mode" "HI")])
2494
2495 (define_insn "*zero_extendqihi2_mips16"
2496   [(set (match_operand:HI 0 "register_operand" "=d")
2497         (zero_extend:HI (match_operand:QI 1 "memory_operand" "m")))]
2498   "TARGET_MIPS16"
2499   "lbu\t%0,%1"
2500   [(set_attr "type" "load")
2501    (set_attr "mode" "HI")])
2502 \f
2503 ;;
2504 ;;  ....................
2505 ;;
2506 ;;      SIGN EXTENSION
2507 ;;
2508 ;;  ....................
2509
2510 ;; Extension insns.
2511 ;; Those for integer source operand are ordered widest source type first.
2512
2513 ;; When TARGET_64BIT, all SImode integer registers should already be in
2514 ;; sign-extended form (see TRULY_NOOP_TRUNCATION and truncdisi2).  We can
2515 ;; therefore get rid of register->register instructions if we constrain
2516 ;; the source to be in the same register as the destination.
2517 ;;
2518 ;; The register alternative has type "arith" so that the pre-reload
2519 ;; scheduler will treat it as a move.  This reflects what happens if
2520 ;; the register alternative needs a reload.
2521 (define_insn_and_split "extendsidi2"
2522   [(set (match_operand:DI 0 "register_operand" "=d,d")
2523         (sign_extend:DI (match_operand:SI 1 "nonimmediate_operand" "0,m")))]
2524   "TARGET_64BIT"
2525   "@
2526    #
2527    lw\t%0,%1"
2528   "&& reload_completed && register_operand (operands[1], VOIDmode)"
2529   [(const_int 0)]
2530 {
2531   emit_note (NOTE_INSN_DELETED);
2532   DONE;
2533 }
2534   [(set_attr "type" "arith,load")
2535    (set_attr "mode" "DI")])
2536
2537 (define_expand "extend<SHORT:mode><GPR:mode>2"
2538   [(set (match_operand:GPR 0 "register_operand")
2539         (sign_extend:GPR (match_operand:SHORT 1 "nonimmediate_operand")))]
2540   "")
2541
2542 (define_insn "*extend<SHORT:mode><GPR:mode>2_mips16e"
2543   [(set (match_operand:GPR 0 "register_operand" "=d,d")
2544         (sign_extend:GPR (match_operand:SHORT 1 "nonimmediate_operand" "0,m")))]
2545   "GENERATE_MIPS16E"
2546   "@
2547    se<SHORT:size>\t%0
2548    l<SHORT:size>\t%0,%1"
2549   [(set_attr "type" "arith,load")
2550    (set_attr "mode" "<GPR:MODE>")])
2551
2552 (define_insn_and_split "*extend<SHORT:mode><GPR:mode>2"
2553   [(set (match_operand:GPR 0 "register_operand" "=d,d")
2554         (sign_extend:GPR
2555              (match_operand:SHORT 1 "nonimmediate_operand" "d,m")))]
2556   "!ISA_HAS_SEB_SEH && !GENERATE_MIPS16E"
2557   "@
2558    #
2559    l<SHORT:size>\t%0,%1"
2560   "&& reload_completed && REG_P (operands[1])"
2561   [(set (match_dup 0) (ashift:GPR (match_dup 1) (match_dup 2)))
2562    (set (match_dup 0) (ashiftrt:GPR (match_dup 0) (match_dup 2)))]
2563 {
2564   operands[1] = gen_lowpart (<GPR:MODE>mode, operands[1]);
2565   operands[2] = GEN_INT (GET_MODE_BITSIZE (<GPR:MODE>mode)
2566                          - GET_MODE_BITSIZE (<SHORT:MODE>mode));
2567 }
2568   [(set_attr "type" "arith,load")
2569    (set_attr "mode" "<GPR:MODE>")
2570    (set_attr "length" "8,*")])
2571
2572 (define_insn "*extend<SHORT:mode><GPR:mode>2_se<SHORT:size>"
2573   [(set (match_operand:GPR 0 "register_operand" "=d,d")
2574         (sign_extend:GPR
2575              (match_operand:SHORT 1 "nonimmediate_operand" "d,m")))]
2576   "ISA_HAS_SEB_SEH"
2577   "@
2578    se<SHORT:size>\t%0,%1
2579    l<SHORT:size>\t%0,%1"
2580   [(set_attr "type" "arith,load")
2581    (set_attr "mode" "<GPR:MODE>")])
2582
2583 ;; This pattern generates the same code as extendqisi2; split it into
2584 ;; that form after reload.
2585 (define_insn_and_split "extendqihi2"
2586   [(set (match_operand:HI 0 "register_operand" "=d,d")
2587         (sign_extend:HI (match_operand:QI 1 "nonimmediate_operand" "d,m")))]
2588   ""
2589   "#"
2590   "reload_completed"
2591   [(set (match_dup 0) (sign_extend:SI (match_dup 1)))]
2592   { operands[0] = gen_lowpart (SImode, operands[0]); }
2593   [(set_attr "type" "arith,load")
2594    (set_attr "mode" "SI")
2595    (set_attr "length" "8,*")])
2596
2597 (define_insn "extendsfdf2"
2598   [(set (match_operand:DF 0 "register_operand" "=f")
2599         (float_extend:DF (match_operand:SF 1 "register_operand" "f")))]
2600   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT"
2601   "cvt.d.s\t%0,%1"
2602   [(set_attr "type"     "fcvt")
2603    (set_attr "cnv_mode" "S2D")   
2604    (set_attr "mode"     "DF")])
2605 \f
2606 ;;
2607 ;;  ....................
2608 ;;
2609 ;;      CONVERSIONS
2610 ;;
2611 ;;  ....................
2612
2613 (define_expand "fix_truncdfsi2"
2614   [(set (match_operand:SI 0 "register_operand")
2615         (fix:SI (match_operand:DF 1 "register_operand")))]
2616   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT"
2617 {
2618   if (!ISA_HAS_TRUNC_W)
2619     {
2620       emit_insn (gen_fix_truncdfsi2_macro (operands[0], operands[1]));
2621       DONE;
2622     }
2623 })
2624
2625 (define_insn "fix_truncdfsi2_insn"
2626   [(set (match_operand:SI 0 "register_operand" "=f")
2627         (fix:SI (match_operand:DF 1 "register_operand" "f")))]
2628   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && ISA_HAS_TRUNC_W"
2629   "trunc.w.d %0,%1"
2630   [(set_attr "type"     "fcvt")
2631    (set_attr "mode"     "DF")
2632    (set_attr "cnv_mode" "D2I")
2633    (set_attr "length"   "4")])
2634
2635 (define_insn "fix_truncdfsi2_macro"
2636   [(set (match_operand:SI 0 "register_operand" "=f")
2637         (fix:SI (match_operand:DF 1 "register_operand" "f")))
2638    (clobber (match_scratch:DF 2 "=d"))]
2639   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && !ISA_HAS_TRUNC_W"
2640 {
2641   if (set_nomacro)
2642     return ".set\tmacro\;trunc.w.d %0,%1,%2\;.set\tnomacro";
2643   else
2644     return "trunc.w.d %0,%1,%2";
2645 }
2646   [(set_attr "type"     "fcvt")
2647    (set_attr "mode"     "DF")
2648    (set_attr "cnv_mode" "D2I")
2649    (set_attr "length"   "36")])
2650
2651 (define_expand "fix_truncsfsi2"
2652   [(set (match_operand:SI 0 "register_operand")
2653         (fix:SI (match_operand:SF 1 "register_operand")))]
2654   "TARGET_HARD_FLOAT"
2655 {
2656   if (!ISA_HAS_TRUNC_W)
2657     {
2658       emit_insn (gen_fix_truncsfsi2_macro (operands[0], operands[1]));
2659       DONE;
2660     }
2661 })
2662
2663 (define_insn "fix_truncsfsi2_insn"
2664   [(set (match_operand:SI 0 "register_operand" "=f")
2665         (fix:SI (match_operand:SF 1 "register_operand" "f")))]
2666   "TARGET_HARD_FLOAT && ISA_HAS_TRUNC_W"
2667   "trunc.w.s %0,%1"
2668   [(set_attr "type"     "fcvt")
2669    (set_attr "mode"     "SF")
2670    (set_attr "cnv_mode" "S2I")
2671    (set_attr "length"   "4")])
2672
2673 (define_insn "fix_truncsfsi2_macro"
2674   [(set (match_operand:SI 0 "register_operand" "=f")
2675         (fix:SI (match_operand:SF 1 "register_operand" "f")))
2676    (clobber (match_scratch:SF 2 "=d"))]
2677   "TARGET_HARD_FLOAT && !ISA_HAS_TRUNC_W"
2678 {
2679   if (set_nomacro)
2680     return ".set\tmacro\;trunc.w.s %0,%1,%2\;.set\tnomacro";
2681   else
2682     return "trunc.w.s %0,%1,%2";
2683 }
2684   [(set_attr "type"     "fcvt")
2685    (set_attr "mode"     "SF")
2686    (set_attr "cnv_mode" "S2I")
2687    (set_attr "length"   "36")])
2688
2689
2690 (define_insn "fix_truncdfdi2"
2691   [(set (match_operand:DI 0 "register_operand" "=f")
2692         (fix:DI (match_operand:DF 1 "register_operand" "f")))]
2693   "TARGET_HARD_FLOAT && TARGET_FLOAT64 && TARGET_DOUBLE_FLOAT"
2694   "trunc.l.d %0,%1"
2695   [(set_attr "type"     "fcvt")
2696    (set_attr "mode"     "DF")
2697    (set_attr "cnv_mode" "D2I")
2698    (set_attr "length"   "4")])
2699
2700
2701 (define_insn "fix_truncsfdi2"
2702   [(set (match_operand:DI 0 "register_operand" "=f")
2703         (fix:DI (match_operand:SF 1 "register_operand" "f")))]
2704   "TARGET_HARD_FLOAT && TARGET_FLOAT64 && TARGET_DOUBLE_FLOAT"
2705   "trunc.l.s %0,%1"
2706   [(set_attr "type"     "fcvt")
2707    (set_attr "mode"     "SF")
2708    (set_attr "cnv_mode" "S2I")
2709    (set_attr "length"   "4")])
2710
2711
2712 (define_insn "floatsidf2"
2713   [(set (match_operand:DF 0 "register_operand" "=f")
2714         (float:DF (match_operand:SI 1 "register_operand" "f")))]
2715   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT"
2716   "cvt.d.w\t%0,%1"
2717   [(set_attr "type"     "fcvt")
2718    (set_attr "mode"     "DF")
2719    (set_attr "cnv_mode" "I2D")   
2720    (set_attr "length"   "4")])
2721
2722
2723 (define_insn "floatdidf2"
2724   [(set (match_operand:DF 0 "register_operand" "=f")
2725         (float:DF (match_operand:DI 1 "register_operand" "f")))]
2726   "TARGET_HARD_FLOAT && TARGET_FLOAT64 && TARGET_DOUBLE_FLOAT"
2727   "cvt.d.l\t%0,%1"
2728   [(set_attr "type"     "fcvt")
2729    (set_attr "mode"     "DF")
2730    (set_attr "cnv_mode" "I2D")   
2731    (set_attr "length"   "4")])
2732
2733
2734 (define_insn "floatsisf2"
2735   [(set (match_operand:SF 0 "register_operand" "=f")
2736         (float:SF (match_operand:SI 1 "register_operand" "f")))]
2737   "TARGET_HARD_FLOAT"
2738   "cvt.s.w\t%0,%1"
2739   [(set_attr "type"     "fcvt")
2740    (set_attr "mode"     "SF")
2741    (set_attr "cnv_mode" "I2S")   
2742    (set_attr "length"   "4")])
2743
2744
2745 (define_insn "floatdisf2"
2746   [(set (match_operand:SF 0 "register_operand" "=f")
2747         (float:SF (match_operand:DI 1 "register_operand" "f")))]
2748   "TARGET_HARD_FLOAT && TARGET_FLOAT64 && TARGET_DOUBLE_FLOAT"
2749   "cvt.s.l\t%0,%1"
2750   [(set_attr "type"     "fcvt")
2751    (set_attr "mode"     "SF")
2752    (set_attr "cnv_mode" "I2S")   
2753    (set_attr "length"   "4")])
2754
2755
2756 (define_expand "fixuns_truncdfsi2"
2757   [(set (match_operand:SI 0 "register_operand")
2758         (unsigned_fix:SI (match_operand:DF 1 "register_operand")))]
2759   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT"
2760 {
2761   rtx reg1 = gen_reg_rtx (DFmode);
2762   rtx reg2 = gen_reg_rtx (DFmode);
2763   rtx reg3 = gen_reg_rtx (SImode);
2764   rtx label1 = gen_label_rtx ();
2765   rtx label2 = gen_label_rtx ();
2766   REAL_VALUE_TYPE offset;
2767
2768   real_2expN (&offset, 31);
2769
2770   if (reg1)                     /* Turn off complaints about unreached code.  */
2771     {
2772       emit_move_insn (reg1, CONST_DOUBLE_FROM_REAL_VALUE (offset, DFmode));
2773       do_pending_stack_adjust ();
2774
2775       emit_insn (gen_cmpdf (operands[1], reg1));
2776       emit_jump_insn (gen_bge (label1));
2777
2778       emit_insn (gen_fix_truncdfsi2 (operands[0], operands[1]));
2779       emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
2780                                    gen_rtx_LABEL_REF (VOIDmode, label2)));
2781       emit_barrier ();
2782
2783       emit_label (label1);
2784       emit_move_insn (reg2, gen_rtx_MINUS (DFmode, operands[1], reg1));
2785       emit_move_insn (reg3, GEN_INT (trunc_int_for_mode
2786                                      (BITMASK_HIGH, SImode)));
2787
2788       emit_insn (gen_fix_truncdfsi2 (operands[0], reg2));
2789       emit_insn (gen_iorsi3 (operands[0], operands[0], reg3));
2790
2791       emit_label (label2);
2792
2793       /* Allow REG_NOTES to be set on last insn (labels don't have enough
2794          fields, and can't be used for REG_NOTES anyway).  */
2795       emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
2796       DONE;
2797     }
2798 })
2799
2800
2801 (define_expand "fixuns_truncdfdi2"
2802   [(set (match_operand:DI 0 "register_operand")
2803         (unsigned_fix:DI (match_operand:DF 1 "register_operand")))]
2804   "TARGET_HARD_FLOAT && TARGET_64BIT && TARGET_DOUBLE_FLOAT"
2805 {
2806   rtx reg1 = gen_reg_rtx (DFmode);
2807   rtx reg2 = gen_reg_rtx (DFmode);
2808   rtx reg3 = gen_reg_rtx (DImode);
2809   rtx label1 = gen_label_rtx ();
2810   rtx label2 = gen_label_rtx ();
2811   REAL_VALUE_TYPE offset;
2812
2813   real_2expN (&offset, 63);
2814
2815   emit_move_insn (reg1, CONST_DOUBLE_FROM_REAL_VALUE (offset, DFmode));
2816   do_pending_stack_adjust ();
2817
2818   emit_insn (gen_cmpdf (operands[1], reg1));
2819   emit_jump_insn (gen_bge (label1));
2820
2821   emit_insn (gen_fix_truncdfdi2 (operands[0], operands[1]));
2822   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
2823                                gen_rtx_LABEL_REF (VOIDmode, label2)));
2824   emit_barrier ();
2825
2826   emit_label (label1);
2827   emit_move_insn (reg2, gen_rtx_MINUS (DFmode, operands[1], reg1));
2828   emit_move_insn (reg3, GEN_INT (BITMASK_HIGH));
2829   emit_insn (gen_ashldi3 (reg3, reg3, GEN_INT (32)));
2830
2831   emit_insn (gen_fix_truncdfdi2 (operands[0], reg2));
2832   emit_insn (gen_iordi3 (operands[0], operands[0], reg3));
2833
2834   emit_label (label2);
2835
2836   /* Allow REG_NOTES to be set on last insn (labels don't have enough
2837      fields, and can't be used for REG_NOTES anyway).  */
2838   emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
2839   DONE;
2840 })
2841
2842
2843 (define_expand "fixuns_truncsfsi2"
2844   [(set (match_operand:SI 0 "register_operand")
2845         (unsigned_fix:SI (match_operand:SF 1 "register_operand")))]
2846   "TARGET_HARD_FLOAT"
2847 {
2848   rtx reg1 = gen_reg_rtx (SFmode);
2849   rtx reg2 = gen_reg_rtx (SFmode);
2850   rtx reg3 = gen_reg_rtx (SImode);
2851   rtx label1 = gen_label_rtx ();
2852   rtx label2 = gen_label_rtx ();
2853   REAL_VALUE_TYPE offset;
2854
2855   real_2expN (&offset, 31);
2856
2857   emit_move_insn (reg1, CONST_DOUBLE_FROM_REAL_VALUE (offset, SFmode));
2858   do_pending_stack_adjust ();
2859
2860   emit_insn (gen_cmpsf (operands[1], reg1));
2861   emit_jump_insn (gen_bge (label1));
2862
2863   emit_insn (gen_fix_truncsfsi2 (operands[0], operands[1]));
2864   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
2865                                gen_rtx_LABEL_REF (VOIDmode, label2)));
2866   emit_barrier ();
2867
2868   emit_label (label1);
2869   emit_move_insn (reg2, gen_rtx_MINUS (SFmode, operands[1], reg1));
2870   emit_move_insn (reg3, GEN_INT (trunc_int_for_mode
2871                                  (BITMASK_HIGH, SImode)));
2872
2873   emit_insn (gen_fix_truncsfsi2 (operands[0], reg2));
2874   emit_insn (gen_iorsi3 (operands[0], operands[0], reg3));
2875
2876   emit_label (label2);
2877
2878   /* Allow REG_NOTES to be set on last insn (labels don't have enough
2879      fields, and can't be used for REG_NOTES anyway).  */
2880   emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
2881   DONE;
2882 })
2883
2884
2885 (define_expand "fixuns_truncsfdi2"
2886   [(set (match_operand:DI 0 "register_operand")
2887         (unsigned_fix:DI (match_operand:SF 1 "register_operand")))]
2888   "TARGET_HARD_FLOAT && TARGET_64BIT && TARGET_DOUBLE_FLOAT"
2889 {
2890   rtx reg1 = gen_reg_rtx (SFmode);
2891   rtx reg2 = gen_reg_rtx (SFmode);
2892   rtx reg3 = gen_reg_rtx (DImode);
2893   rtx label1 = gen_label_rtx ();
2894   rtx label2 = gen_label_rtx ();
2895   REAL_VALUE_TYPE offset;
2896
2897   real_2expN (&offset, 63);
2898
2899   emit_move_insn (reg1, CONST_DOUBLE_FROM_REAL_VALUE (offset, SFmode));
2900   do_pending_stack_adjust ();
2901
2902   emit_insn (gen_cmpsf (operands[1], reg1));
2903   emit_jump_insn (gen_bge (label1));
2904
2905   emit_insn (gen_fix_truncsfdi2 (operands[0], operands[1]));
2906   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
2907                                gen_rtx_LABEL_REF (VOIDmode, label2)));
2908   emit_barrier ();
2909
2910   emit_label (label1);
2911   emit_move_insn (reg2, gen_rtx_MINUS (SFmode, operands[1], reg1));
2912   emit_move_insn (reg3, GEN_INT (BITMASK_HIGH));
2913   emit_insn (gen_ashldi3 (reg3, reg3, GEN_INT (32)));
2914
2915   emit_insn (gen_fix_truncsfdi2 (operands[0], reg2));
2916   emit_insn (gen_iordi3 (operands[0], operands[0], reg3));
2917
2918   emit_label (label2);
2919
2920   /* Allow REG_NOTES to be set on last insn (labels don't have enough
2921      fields, and can't be used for REG_NOTES anyway).  */
2922   emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
2923   DONE;
2924 })
2925 \f
2926 ;;
2927 ;;  ....................
2928 ;;
2929 ;;      DATA MOVEMENT
2930 ;;
2931 ;;  ....................
2932
2933 ;; Bit field extract patterns which use lwl/lwr or ldl/ldr.
2934
2935 (define_expand "extv"
2936   [(set (match_operand 0 "register_operand")
2937         (sign_extract (match_operand:QI 1 "memory_operand")
2938                       (match_operand 2 "immediate_operand")
2939                       (match_operand 3 "immediate_operand")))]
2940   "!TARGET_MIPS16"
2941 {
2942   if (mips_expand_unaligned_load (operands[0], operands[1],
2943                                   INTVAL (operands[2]),
2944                                   INTVAL (operands[3])))
2945     DONE;
2946   else
2947     FAIL;
2948 })
2949
2950 (define_expand "extzv"
2951   [(set (match_operand 0 "register_operand")
2952         (zero_extract (match_operand 1 "nonimmediate_operand")
2953                       (match_operand 2 "immediate_operand")
2954                       (match_operand 3 "immediate_operand")))]
2955   "!TARGET_MIPS16"
2956 {
2957   if (mips_expand_unaligned_load (operands[0], operands[1],
2958                                   INTVAL (operands[2]),
2959                                   INTVAL (operands[3])))
2960     DONE;
2961   else if (mips_use_ins_ext_p (operands[1], operands[2], operands[3]))
2962     {
2963       if (GET_MODE (operands[0]) == DImode)
2964         emit_insn (gen_extzvdi (operands[0], operands[1], operands[2],
2965                                 operands[3]));
2966       else
2967         emit_insn (gen_extzvsi (operands[0], operands[1], operands[2],
2968                                 operands[3]));
2969       DONE;
2970     }
2971   else
2972     FAIL;
2973 })
2974
2975 (define_insn "extzv<mode>"
2976   [(set (match_operand:GPR 0 "register_operand" "=d")
2977         (zero_extract:GPR (match_operand:GPR 1 "register_operand" "d")
2978                           (match_operand:SI 2 "immediate_operand" "I")
2979                           (match_operand:SI 3 "immediate_operand" "I")))]
2980   "mips_use_ins_ext_p (operands[1], operands[2], operands[3])"
2981   "<d>ext\t%0,%1,%3,%2"
2982   [(set_attr "type"     "arith")
2983    (set_attr "mode"     "<MODE>")])
2984
2985
2986 (define_expand "insv"
2987   [(set (zero_extract (match_operand 0 "nonimmediate_operand")
2988                       (match_operand 1 "immediate_operand")
2989                       (match_operand 2 "immediate_operand"))
2990         (match_operand 3 "reg_or_0_operand"))]
2991   "!TARGET_MIPS16"
2992 {
2993   if (mips_expand_unaligned_store (operands[0], operands[3],
2994                                    INTVAL (operands[1]),
2995                                    INTVAL (operands[2])))
2996     DONE;
2997   else if (mips_use_ins_ext_p (operands[0], operands[1], operands[2]))
2998     {
2999       if (GET_MODE (operands[0]) == DImode)
3000         emit_insn (gen_insvdi (operands[0], operands[1], operands[2],
3001                                operands[3]));
3002       else
3003         emit_insn (gen_insvsi (operands[0], operands[1], operands[2],
3004                                operands[3]));
3005       DONE;
3006    }
3007    else
3008      FAIL;
3009 })
3010
3011 (define_insn "insv<mode>"
3012   [(set (zero_extract:GPR (match_operand:GPR 0 "register_operand" "+d")
3013                           (match_operand:SI 1 "immediate_operand" "I")
3014                           (match_operand:SI 2 "immediate_operand" "I"))
3015         (match_operand:GPR 3 "reg_or_0_operand" "dJ"))]
3016   "mips_use_ins_ext_p (operands[0], operands[1], operands[2])"
3017   "<d>ins\t%0,%z3,%2,%1"
3018   [(set_attr "type"     "arith")
3019    (set_attr "mode"     "<MODE>")])
3020
3021 ;; Unaligned word moves generated by the bit field patterns.
3022 ;;
3023 ;; As far as the rtl is concerned, both the left-part and right-part
3024 ;; instructions can access the whole field.  However, the real operand
3025 ;; refers to just the first or the last byte (depending on endianness).
3026 ;; We therefore use two memory operands to each instruction, one to
3027 ;; describe the rtl effect and one to use in the assembly output.
3028 ;;
3029 ;; Operands 0 and 1 are the rtl-level target and source respectively.
3030 ;; This allows us to use the standard length calculations for the "load"
3031 ;; and "store" type attributes.
3032
3033 (define_insn "mov_<load>l"
3034   [(set (match_operand:GPR 0 "register_operand" "=d")
3035         (unspec:GPR [(match_operand:BLK 1 "memory_operand" "m")
3036                      (match_operand:QI 2 "memory_operand" "m")]
3037                     UNSPEC_LOAD_LEFT))]
3038   "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[1])"
3039   "<load>l\t%0,%2"
3040   [(set_attr "type" "load")
3041    (set_attr "mode" "<MODE>")])
3042
3043 (define_insn "mov_<load>r"
3044   [(set (match_operand:GPR 0 "register_operand" "=d")
3045         (unspec:GPR [(match_operand:BLK 1 "memory_operand" "m")
3046                      (match_operand:QI 2 "memory_operand" "m")
3047                      (match_operand:GPR 3 "register_operand" "0")]
3048                     UNSPEC_LOAD_RIGHT))]
3049   "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[1])"
3050   "<load>r\t%0,%2"
3051   [(set_attr "type" "load")
3052    (set_attr "mode" "<MODE>")])
3053
3054 (define_insn "mov_<store>l"
3055   [(set (match_operand:BLK 0 "memory_operand" "=m")
3056         (unspec:BLK [(match_operand:GPR 1 "reg_or_0_operand" "dJ")
3057                      (match_operand:QI 2 "memory_operand" "m")]
3058                     UNSPEC_STORE_LEFT))]
3059   "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[0])"
3060   "<store>l\t%z1,%2"
3061   [(set_attr "type" "store")
3062    (set_attr "mode" "<MODE>")])
3063
3064 (define_insn "mov_<store>r"
3065   [(set (match_operand:BLK 0 "memory_operand" "+m")
3066         (unspec:BLK [(match_operand:GPR 1 "reg_or_0_operand" "dJ")
3067                      (match_operand:QI 2 "memory_operand" "m")
3068                      (match_dup 0)]
3069                     UNSPEC_STORE_RIGHT))]
3070   "!TARGET_MIPS16 && mips_mem_fits_mode_p (<MODE>mode, operands[0])"
3071   "<store>r\t%z1,%2"
3072   [(set_attr "type" "store")
3073    (set_attr "mode" "<MODE>")])
3074
3075 ;; An instruction to calculate the high part of a 64-bit SYMBOL_GENERAL.
3076 ;; The required value is:
3077 ;;
3078 ;;      (%highest(op1) << 48) + (%higher(op1) << 32) + (%hi(op1) << 16)
3079 ;;
3080 ;; which translates to:
3081 ;;
3082 ;;      lui     op0,%highest(op1)
3083 ;;      daddiu  op0,op0,%higher(op1)
3084 ;;      dsll    op0,op0,16
3085 ;;      daddiu  op0,op0,%hi(op1)
3086 ;;      dsll    op0,op0,16
3087 ;;
3088 ;; The split is deferred until after flow2 to allow the peephole2 below
3089 ;; to take effect.
3090 (define_insn_and_split "*lea_high64"
3091   [(set (match_operand:DI 0 "register_operand" "=d")
3092         (high:DI (match_operand:DI 1 "general_symbolic_operand" "")))]
3093   "TARGET_EXPLICIT_RELOCS && ABI_HAS_64BIT_SYMBOLS"
3094   "#"
3095   "&& flow2_completed"
3096   [(set (match_dup 0) (high:DI (match_dup 2)))
3097    (set (match_dup 0) (lo_sum:DI (match_dup 0) (match_dup 2)))
3098    (set (match_dup 0) (ashift:DI (match_dup 0) (const_int 16)))
3099    (set (match_dup 0) (lo_sum:DI (match_dup 0) (match_dup 3)))
3100    (set (match_dup 0) (ashift:DI (match_dup 0) (const_int 16)))]
3101 {
3102   operands[2] = mips_unspec_address (operands[1], SYMBOL_64_HIGH);
3103   operands[3] = mips_unspec_address (operands[1], SYMBOL_64_MID);
3104 }
3105   [(set_attr "length" "20")])
3106
3107 ;; Use a scratch register to reduce the latency of the above pattern
3108 ;; on superscalar machines.  The optimized sequence is:
3109 ;;
3110 ;;      lui     op1,%highest(op2)
3111 ;;      lui     op0,%hi(op2)
3112 ;;      daddiu  op1,op1,%higher(op2)
3113 ;;      dsll32  op1,op1,0
3114 ;;      daddu   op1,op1,op0
3115 (define_peephole2
3116   [(set (match_operand:DI 1 "register_operand")
3117         (high:DI (match_operand:DI 2 "general_symbolic_operand")))
3118    (match_scratch:DI 0 "d")]
3119   "TARGET_EXPLICIT_RELOCS && ABI_HAS_64BIT_SYMBOLS"
3120   [(set (match_dup 1) (high:DI (match_dup 3)))
3121    (set (match_dup 0) (high:DI (match_dup 4)))
3122    (set (match_dup 1) (lo_sum:DI (match_dup 1) (match_dup 3)))
3123    (set (match_dup 1) (ashift:DI (match_dup 1) (const_int 32)))
3124    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 0)))]
3125 {
3126   operands[3] = mips_unspec_address (operands[2], SYMBOL_64_HIGH);
3127   operands[4] = mips_unspec_address (operands[2], SYMBOL_64_LOW);
3128 })
3129
3130 ;; On most targets, the expansion of (lo_sum (high X) X) for a 64-bit
3131 ;; SYMBOL_GENERAL X will take 6 cycles.  This next pattern allows combine
3132 ;; to merge the HIGH and LO_SUM parts of a move if the HIGH part is only
3133 ;; used once.  We can then use the sequence:
3134 ;;
3135 ;;      lui     op0,%highest(op1)
3136 ;;      lui     op2,%hi(op1)
3137 ;;      daddiu  op0,op0,%higher(op1)
3138 ;;      daddiu  op2,op2,%lo(op1)
3139 ;;      dsll32  op0,op0,0
3140 ;;      daddu   op0,op0,op2
3141 ;;
3142 ;; which takes 4 cycles on most superscalar targets.
3143 (define_insn_and_split "*lea64"
3144   [(set (match_operand:DI 0 "register_operand" "=d")
3145         (match_operand:DI 1 "general_symbolic_operand" ""))
3146    (clobber (match_scratch:DI 2 "=&d"))]
3147   "TARGET_EXPLICIT_RELOCS && ABI_HAS_64BIT_SYMBOLS && cse_not_expected"
3148   "#"
3149   "&& reload_completed"
3150   [(set (match_dup 0) (high:DI (match_dup 3)))
3151    (set (match_dup 2) (high:DI (match_dup 4)))
3152    (set (match_dup 0) (lo_sum:DI (match_dup 0) (match_dup 3)))
3153    (set (match_dup 2) (lo_sum:DI (match_dup 2) (match_dup 4)))
3154    (set (match_dup 0) (ashift:DI (match_dup 0) (const_int 32)))
3155    (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 2)))]
3156 {
3157   operands[3] = mips_unspec_address (operands[1], SYMBOL_64_HIGH);
3158   operands[4] = mips_unspec_address (operands[1], SYMBOL_64_LOW);
3159 }
3160   [(set_attr "length" "24")])
3161
3162 ;; Insns to fetch a symbol from a big GOT.
3163
3164 (define_insn_and_split "*xgot_hi<mode>"
3165   [(set (match_operand:P 0 "register_operand" "=d")
3166         (high:P (match_operand:P 1 "got_disp_operand" "")))]
3167   "TARGET_EXPLICIT_RELOCS && TARGET_XGOT"
3168   "#"
3169   "&& reload_completed"
3170   [(set (match_dup 0) (high:P (match_dup 2)))
3171    (set (match_dup 0) (plus:P (match_dup 0) (match_dup 3)))]
3172 {
3173   operands[2] = mips_unspec_address (operands[1], SYMBOL_GOTOFF_DISP);
3174   operands[3] = pic_offset_table_rtx;
3175 }
3176   [(set_attr "got" "xgot_high")
3177    (set_attr "mode" "<MODE>")])
3178
3179 (define_insn_and_split "*xgot_lo<mode>"
3180   [(set (match_operand:P 0 "register_operand" "=d")
3181         (lo_sum:P (match_operand:P 1 "register_operand" "d")
3182                   (match_operand:P 2 "got_disp_operand" "")))]
3183   "TARGET_EXPLICIT_RELOCS && TARGET_XGOT"
3184   "#"
3185   "&& reload_completed"
3186   [(set (match_dup 0)
3187         (unspec:P [(match_dup 1) (match_dup 3)] UNSPEC_LOAD_GOT))]
3188   { operands[3] = mips_unspec_address (operands[2], SYMBOL_GOTOFF_DISP); }
3189   [(set_attr "got" "load")
3190    (set_attr "mode" "<MODE>")])
3191
3192 ;; Insns to fetch a symbol from a normal GOT.
3193
3194 (define_insn_and_split "*got_disp<mode>"
3195   [(set (match_operand:P 0 "register_operand" "=d")
3196         (match_operand:P 1 "got_disp_operand" ""))]
3197   "TARGET_EXPLICIT_RELOCS && !TARGET_XGOT"
3198   "#"
3199   "&& reload_completed"
3200   [(set (match_dup 0)
3201         (unspec:P [(match_dup 2) (match_dup 3)] UNSPEC_LOAD_GOT))]
3202 {
3203   operands[2] = pic_offset_table_rtx;
3204   operands[3] = mips_unspec_address (operands[1], SYMBOL_GOTOFF_DISP);
3205 }
3206   [(set_attr "got" "load")
3207    (set_attr "mode" "<MODE>")])
3208
3209 ;; Insns for loading the "page" part of a page/ofst address from the GOT.
3210
3211 (define_insn_and_split "*got_page<mode>"
3212   [(set (match_operand:P 0 "register_operand" "=d")
3213         (high:P (match_operand:P 1 "got_page_ofst_operand" "")))]
3214   "TARGET_EXPLICIT_RELOCS"
3215   "#"
3216   "&& reload_completed"
3217   [(set (match_dup 0)
3218         (unspec:P [(match_dup 2) (match_dup 3)] UNSPEC_LOAD_GOT))]
3219 {
3220   operands[2] = pic_offset_table_rtx;
3221   operands[3] = mips_unspec_address (operands[1], SYMBOL_GOTOFF_PAGE);
3222 }
3223   [(set_attr "got" "load")
3224    (set_attr "mode" "<MODE>")])
3225
3226 ;; Lower-level instructions for loading an address from the GOT.
3227 ;; We could use MEMs, but an unspec gives more optimization
3228 ;; opportunities.
3229
3230 (define_insn "load_got<mode>"
3231   [(set (match_operand:P 0 "register_operand" "=d")
3232         (unspec:P [(match_operand:P 1 "register_operand" "d")
3233                    (match_operand:P 2 "immediate_operand" "")]
3234                   UNSPEC_LOAD_GOT))]
3235   ""
3236   "<load>\t%0,%R2(%1)"
3237   [(set_attr "type" "load")
3238    (set_attr "mode" "<MODE>")
3239    (set_attr "length" "4")])
3240
3241 ;; Instructions for adding the low 16 bits of an address to a register.
3242 ;; Operand 2 is the address: print_operand works out which relocation
3243 ;; should be applied.
3244
3245 (define_insn "*low<mode>"
3246   [(set (match_operand:P 0 "register_operand" "=d")
3247         (lo_sum:P (match_operand:P 1 "register_operand" "d")
3248                   (match_operand:P 2 "immediate_operand" "")))]
3249   "!TARGET_MIPS16"
3250   "<d>addiu\t%0,%1,%R2"
3251   [(set_attr "type" "arith")
3252    (set_attr "mode" "<MODE>")])
3253
3254 (define_insn "*low<mode>_mips16"
3255   [(set (match_operand:P 0 "register_operand" "=d")
3256         (lo_sum:P (match_operand:P 1 "register_operand" "0")
3257                   (match_operand:P 2 "immediate_operand" "")))]
3258   "TARGET_MIPS16"
3259   "<d>addiu\t%0,%R2"
3260   [(set_attr "type" "arith")
3261    (set_attr "mode" "<MODE>")
3262    (set_attr "length" "8")])
3263
3264 ;; Allow combine to split complex const_int load sequences, using operand 2
3265 ;; to store the intermediate results.  See move_operand for details.
3266 (define_split
3267   [(set (match_operand:GPR 0 "register_operand")
3268         (match_operand:GPR 1 "splittable_const_int_operand"))
3269    (clobber (match_operand:GPR 2 "register_operand"))]
3270   ""
3271   [(const_int 0)]
3272 {
3273   mips_move_integer (operands[0], operands[2], INTVAL (operands[1]));
3274   DONE;
3275 })
3276
3277 ;; Likewise, for symbolic operands.
3278 (define_split
3279   [(set (match_operand:P 0 "register_operand")
3280         (match_operand:P 1 "splittable_symbolic_operand"))
3281    (clobber (match_operand:P 2 "register_operand"))]
3282   ""
3283   [(set (match_dup 0) (match_dup 1))]
3284   { operands[1] = mips_split_symbol (operands[2], operands[1]); })
3285
3286 ;; 64-bit integer moves
3287
3288 ;; Unlike most other insns, the move insns can't be split with
3289 ;; different predicates, because register spilling and other parts of
3290 ;; the compiler, have memoized the insn number already.
3291
3292 (define_expand "movdi"
3293   [(set (match_operand:DI 0 "")
3294         (match_operand:DI 1 ""))]
3295   ""
3296 {
3297   if (mips_legitimize_move (DImode, operands[0], operands[1]))
3298     DONE;
3299 })
3300
3301 ;; For mips16, we need a special case to handle storing $31 into
3302 ;; memory, since we don't have a constraint to match $31.  This
3303 ;; instruction can be generated by save_restore_insns.
3304
3305 (define_insn "*mov<mode>_ra"
3306   [(set (match_operand:GPR 0 "stack_operand" "=m")
3307         (reg:GPR 31))]
3308   "TARGET_MIPS16"
3309   "<store>\t$31,%0"
3310   [(set_attr "type" "store")
3311    (set_attr "mode" "<MODE>")])
3312
3313 (define_insn "*movdi_32bit"
3314   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,d,m,*a,*d,*B*C*D,*B*C*D,*d,*m")
3315         (match_operand:DI 1 "move_operand" "d,i,m,d,*J*d,*a,*d,*m,*B*C*D,*B*C*D"))]
3316   "!TARGET_64BIT && !TARGET_FLOAT64 && !TARGET_MIPS16
3317    && (register_operand (operands[0], DImode)
3318        || reg_or_0_operand (operands[1], DImode))"
3319   { return mips_output_move (operands[0], operands[1]); }
3320   [(set_attr "type"     "arith,arith,load,store,mthilo,mfhilo,mtc,load,mfc,store")
3321    (set_attr "mode"     "DI")
3322    (set_attr "length"   "8,16,*,*,8,8,8,*,8,*")])
3323
3324 (define_insn "*movdi_gp32_fp64"
3325   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,d,m,*a,*d,*f,*f,*f,*d,*m")
3326         (match_operand:DI 1 "move_operand" "d,i,m,d,*J*d,*a,*f,*J*d,*m,*f,*f"))]
3327   "!TARGET_64BIT && TARGET_FLOAT64 && !TARGET_MIPS16
3328    && (register_operand (operands[0], DImode)
3329        || reg_or_0_operand (operands[1], DImode))"
3330   { return mips_output_move (operands[0], operands[1]); }
3331   [(set_attr "type"     "arith,arith,load,store,mthilo,mfhilo,fmove,mtc,fpload,mfc,fpstore")
3332    (set_attr "mode"     "DI")
3333    (set_attr "length"   "8,16,*,*,8,8,4,8,*,8,*")])
3334
3335 (define_insn "*movdi_32bit_mips16"
3336   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,y,d,d,d,d,m,*d")
3337         (match_operand:DI 1 "move_operand" "d,d,y,K,N,m,d,*x"))]
3338   "!TARGET_64BIT && TARGET_MIPS16
3339    && (register_operand (operands[0], DImode)
3340        || register_operand (operands[1], DImode))"
3341   { return mips_output_move (operands[0], operands[1]); }
3342   [(set_attr "type"     "arith,arith,arith,arith,arith,load,store,mfhilo")
3343    (set_attr "mode"     "DI")
3344    (set_attr "length"   "8,8,8,8,12,*,*,8")])
3345
3346 (define_insn "*movdi_64bit"
3347   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,d,e,d,m,*f,*f,*f,*d,*m,*x,*B*C*D,*B*C*D,*d,*m")
3348         (match_operand:DI 1 "move_operand" "d,U,T,m,dJ,*f,*d*J,*m,*f,*f,*J*d,*d,*m,*B*C*D,*B*C*D"))]
3349   "TARGET_64BIT && !TARGET_MIPS16
3350    && (register_operand (operands[0], DImode)
3351        || reg_or_0_operand (operands[1], DImode))"
3352   { return mips_output_move (operands[0], operands[1]); }
3353   [(set_attr "type"     "arith,const,const,load,store,fmove,mtc,fpload,mfc,fpstore,mthilo,mtc,load,mfc,store")
3354    (set_attr "mode"     "DI")
3355    (set_attr "length"   "4,*,*,*,*,4,4,*,4,*,4,8,*,8,*")])
3356
3357 (define_insn "*movdi_64bit_mips16"
3358   [(set (match_operand:DI 0 "nonimmediate_operand" "=d,y,d,d,d,d,d,m")
3359         (match_operand:DI 1 "move_operand" "d,d,y,K,N,U,m,d"))]
3360   "TARGET_64BIT && TARGET_MIPS16
3361    && (register_operand (operands[0], DImode)
3362        || register_operand (operands[1], DImode))"
3363   { return mips_output_move (operands[0], operands[1]); }
3364   [(set_attr "type"     "arith,arith,arith,arith,arith,const,load,store")
3365    (set_attr "mode"     "DI")
3366    (set_attr_alternative "length"
3367                 [(const_int 4)
3368                  (const_int 4)
3369                  (const_int 4)
3370                  (if_then_else (match_operand:VOID 1 "m16_uimm8_1")
3371                                (const_int 4)
3372                                (const_int 8))
3373                  (if_then_else (match_operand:VOID 1 "m16_nuimm8_1")
3374                                (const_int 8)
3375                                (const_int 12))
3376                  (const_string "*")
3377                  (const_string "*")
3378                  (const_string "*")])])
3379
3380
3381 ;; On the mips16, we can split ld $r,N($r) into an add and a load,
3382 ;; when the original load is a 4 byte instruction but the add and the
3383 ;; load are 2 2 byte instructions.
3384
3385 (define_split
3386   [(set (match_operand:DI 0 "register_operand")
3387         (mem:DI (plus:DI (match_dup 0)
3388                          (match_operand:DI 1 "const_int_operand"))))]
3389   "TARGET_64BIT && TARGET_MIPS16 && reload_completed
3390    && !TARGET_DEBUG_D_MODE
3391    && REG_P (operands[0])
3392    && M16_REG_P (REGNO (operands[0]))
3393    && GET_CODE (operands[1]) == CONST_INT
3394    && ((INTVAL (operands[1]) < 0
3395         && INTVAL (operands[1]) >= -0x10)
3396        || (INTVAL (operands[1]) >= 32 * 8
3397            && INTVAL (operands[1]) <= 31 * 8 + 0x8)
3398        || (INTVAL (operands[1]) >= 0
3399            && INTVAL (operands[1]) < 32 * 8
3400            && (INTVAL (operands[1]) & 7) != 0))"
3401   [(set (match_dup 0) (plus:DI (match_dup 0) (match_dup 1)))
3402    (set (match_dup 0) (mem:DI (plus:DI (match_dup 0) (match_dup 2))))]
3403 {
3404   HOST_WIDE_INT val = INTVAL (operands[1]);
3405
3406   if (val < 0)
3407     operands[2] = const0_rtx;
3408   else if (val >= 32 * 8)
3409     {
3410       int off = val & 7;
3411
3412       operands[1] = GEN_INT (0x8 + off);
3413       operands[2] = GEN_INT (val - off - 0x8);
3414     }
3415   else
3416     {
3417       int off = val & 7;
3418
3419       operands[1] = GEN_INT (off);
3420       operands[2] = GEN_INT (val - off);
3421     }
3422 })
3423
3424 ;; 32-bit Integer moves
3425
3426 ;; Unlike most other insns, the move insns can't be split with
3427 ;; different predicates, because register spilling and other parts of
3428 ;; the compiler, have memoized the insn number already.
3429
3430 (define_expand "movsi"
3431   [(set (match_operand:SI 0 "")
3432         (match_operand:SI 1 ""))]
3433   ""
3434 {
3435   if (mips_legitimize_move (SImode, operands[0], operands[1]))
3436     DONE;
3437 })
3438
3439 ;; The difference between these two is whether or not ints are allowed
3440 ;; in FP registers (off by default, use -mdebugh to enable).
3441
3442 (define_insn "*movsi_internal"
3443   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,d,e,d,m,*f,*f,*f,*d,*m,*d,*z,*a,*d,*B*C*D,*B*C*D,*d,*m")
3444         (match_operand:SI 1 "move_operand" "d,U,T,m,dJ,*f,*d*J,*m,*f,*f,*z,*d,*J*d,*A,*d,*m,*B*C*D,*B*C*D"))]
3445   "!TARGET_MIPS16
3446    && (register_operand (operands[0], SImode)
3447        || reg_or_0_operand (operands[1], SImode))"
3448   { return mips_output_move (operands[0], operands[1]); }
3449   [(set_attr "type"     "arith,const,const,load,store,fmove,mtc,fpload,mfc,fpstore,mfc,mtc,mthilo,mfhilo,mtc,load,mfc,store")
3450    (set_attr "mode"     "SI")
3451    (set_attr "length"   "4,*,*,*,*,4,4,*,4,*,4,4,4,4,4,*,4,*")])
3452
3453 (define_insn "*movsi_mips16"
3454   [(set (match_operand:SI 0 "nonimmediate_operand" "=d,y,d,d,d,d,d,m")
3455         (match_operand:SI 1 "move_operand" "d,d,y,K,N,U,m,d"))]
3456   "TARGET_MIPS16
3457    && (register_operand (operands[0], SImode)
3458        || register_operand (operands[1], SImode))"
3459   { return mips_output_move (operands[0], operands[1]); }
3460   [(set_attr "type"     "arith,arith,arith,arith,arith,const,load,store")
3461    (set_attr "mode"     "SI")
3462    (set_attr_alternative "length"
3463                 [(const_int 4)
3464                  (const_int 4)
3465                  (const_int 4)
3466                  (if_then_else (match_operand:VOID 1 "m16_uimm8_1")
3467                                (const_int 4)
3468                                (const_int 8))
3469                  (if_then_else (match_operand:VOID 1 "m16_nuimm8_1")
3470                                (const_int 8)
3471                                (const_int 12))
3472                  (const_string "*")
3473                  (const_string "*")
3474                  (const_string "*")])])
3475
3476 ;; On the mips16, we can split lw $r,N($r) into an add and a load,
3477 ;; when the original load is a 4 byte instruction but the add and the
3478 ;; load are 2 2 byte instructions.
3479
3480 (define_split
3481   [(set (match_operand:SI 0 "register_operand")
3482         (mem:SI (plus:SI (match_dup 0)
3483                          (match_operand:SI 1 "const_int_operand"))))]
3484   "TARGET_MIPS16 && reload_completed && !TARGET_DEBUG_D_MODE
3485    && REG_P (operands[0])
3486    && M16_REG_P (REGNO (operands[0]))
3487    && GET_CODE (operands[1]) == CONST_INT
3488    && ((INTVAL (operands[1]) < 0
3489         && INTVAL (operands[1]) >= -0x80)
3490        || (INTVAL (operands[1]) >= 32 * 4
3491            && INTVAL (operands[1]) <= 31 * 4 + 0x7c)
3492        || (INTVAL (operands[1]) >= 0
3493            && INTVAL (operands[1]) < 32 * 4
3494            && (INTVAL (operands[1]) & 3) != 0))"
3495   [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 1)))
3496    (set (match_dup 0) (mem:SI (plus:SI (match_dup 0) (match_dup 2))))]
3497 {
3498   HOST_WIDE_INT val = INTVAL (operands[1]);
3499
3500   if (val < 0)
3501     operands[2] = const0_rtx;
3502   else if (val >= 32 * 4)
3503     {
3504       int off = val & 3;
3505
3506       operands[1] = GEN_INT (0x7c + off);
3507       operands[2] = GEN_INT (val - off - 0x7c);
3508     }
3509   else
3510     {
3511       int off = val & 3;
3512
3513       operands[1] = GEN_INT (off);
3514       operands[2] = GEN_INT (val - off);
3515     }
3516 })
3517
3518 ;; On the mips16, we can split a load of certain constants into a load
3519 ;; and an add.  This turns a 4 byte instruction into 2 2 byte
3520 ;; instructions.
3521
3522 (define_split
3523   [(set (match_operand:SI 0 "register_operand")
3524         (match_operand:SI 1 "const_int_operand"))]
3525   "TARGET_MIPS16 && reload_completed && !TARGET_DEBUG_D_MODE
3526    && REG_P (operands[0])
3527    && M16_REG_P (REGNO (operands[0]))
3528    && GET_CODE (operands[1]) == CONST_INT
3529    && INTVAL (operands[1]) >= 0x100
3530    && INTVAL (operands[1]) <= 0xff + 0x7f"
3531   [(set (match_dup 0) (match_dup 1))
3532    (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 2)))]
3533 {
3534   int val = INTVAL (operands[1]);
3535
3536   operands[1] = GEN_INT (0xff);
3537   operands[2] = GEN_INT (val - 0xff);
3538 })
3539
3540 ;; This insn handles moving CCmode values.  It's really just a
3541 ;; slightly simplified copy of movsi_internal2, with additional cases
3542 ;; to move a condition register to a general register and to move
3543 ;; between the general registers and the floating point registers.
3544
3545 (define_insn "movcc"
3546   [(set (match_operand:CC 0 "nonimmediate_operand" "=d,*d,*d,*m,*d,*f,*f,*f,*m")
3547         (match_operand:CC 1 "general_operand" "z,*d,*m,*d,*f,*d,*f,*m,*f"))]
3548   "ISA_HAS_8CC && TARGET_HARD_FLOAT"
3549   { return mips_output_move (operands[0], operands[1]); }
3550   [(set_attr "type"     "multi,arith,load,store,mfc,mtc,fmove,fpload,fpstore")
3551    (set_attr "mode"     "SI")
3552    (set_attr "length"   "8,4,*,*,4,4,4,*,*")])
3553
3554 ;; Reload condition code registers.  reload_incc and reload_outcc
3555 ;; both handle moves from arbitrary operands into condition code
3556 ;; registers.  reload_incc handles the more common case in which
3557 ;; a source operand is constrained to be in a condition-code
3558 ;; register, but has not been allocated to one.
3559 ;;
3560 ;; Sometimes, such as in movcc, we have a CCmode destination whose
3561 ;; constraints do not include 'z'.  reload_outcc handles the case
3562 ;; when such an operand is allocated to a condition-code register.
3563 ;;
3564 ;; Note that reloads from a condition code register to some
3565 ;; other location can be done using ordinary moves.  Moving
3566 ;; into a GPR takes a single movcc, moving elsewhere takes
3567 ;; two.  We can leave these cases to the generic reload code.
3568 (define_expand "reload_incc"
3569   [(set (match_operand:CC 0 "fcc_reload_operand" "=z")
3570         (match_operand:CC 1 "general_operand" ""))
3571    (clobber (match_operand:TF 2 "register_operand" "=&f"))]
3572   "ISA_HAS_8CC && TARGET_HARD_FLOAT"
3573 {
3574   mips_emit_fcc_reload (operands[0], operands[1], operands[2]);
3575   DONE;
3576 })
3577
3578 (define_expand "reload_outcc"
3579   [(set (match_operand:CC 0 "fcc_reload_operand" "=z")
3580         (match_operand:CC 1 "register_operand" ""))
3581    (clobber (match_operand:TF 2 "register_operand" "=&f"))]
3582   "ISA_HAS_8CC && TARGET_HARD_FLOAT"
3583 {
3584   mips_emit_fcc_reload (operands[0], operands[1], operands[2]);
3585   DONE;
3586 })
3587
3588 ;; MIPS4 supports loading and storing a floating point register from
3589 ;; the sum of two general registers.  We use two versions for each of
3590 ;; these four instructions: one where the two general registers are
3591 ;; SImode, and one where they are DImode.  This is because general
3592 ;; registers will be in SImode when they hold 32-bit values, but,
3593 ;; since the 32-bit values are always sign extended, the [ls][wd]xc1
3594 ;; instructions will still work correctly.
3595
3596 ;; ??? Perhaps it would be better to support these instructions by
3597 ;; modifying GO_IF_LEGITIMATE_ADDRESS and friends.  However, since
3598 ;; these instructions can only be used to load and store floating
3599 ;; point registers, that would probably cause trouble in reload.
3600
3601 (define_insn "*<ANYF:loadx>_<P:mode>"
3602   [(set (match_operand:ANYF 0 "register_operand" "=f")
3603         (mem:ANYF (plus:P (match_operand:P 1 "register_operand" "d")
3604                           (match_operand:P 2 "register_operand" "d"))))]
3605   "ISA_HAS_FP4"
3606   "<ANYF:loadx>\t%0,%1(%2)"
3607   [(set_attr "type" "fpidxload")
3608    (set_attr "mode" "<ANYF:UNITMODE>")])
3609
3610 (define_insn "*<ANYF:storex>_<P:mode>"
3611   [(set (mem:ANYF (plus:P (match_operand:P 1 "register_operand" "d")
3612                           (match_operand:P 2 "register_operand" "d")))
3613         (match_operand:ANYF 0 "register_operand" "f"))]
3614   "ISA_HAS_FP4"
3615   "<ANYF:storex>\t%0,%1(%2)"
3616   [(set_attr "type" "fpidxstore")
3617    (set_attr "mode" "<ANYF:UNITMODE>")])
3618
3619 ;; 16-bit Integer moves
3620
3621 ;; Unlike most other insns, the move insns can't be split with
3622 ;; different predicates, because register spilling and other parts of
3623 ;; the compiler, have memoized the insn number already.
3624 ;; Unsigned loads are used because LOAD_EXTEND_OP returns ZERO_EXTEND.
3625
3626 (define_expand "movhi"
3627   [(set (match_operand:HI 0 "")
3628         (match_operand:HI 1 ""))]
3629   ""
3630 {
3631   if (mips_legitimize_move (HImode, operands[0], operands[1]))
3632     DONE;
3633 })
3634
3635 (define_insn "*movhi_internal"
3636   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,d,d,m,*d,*f,*f,*x")
3637         (match_operand:HI 1 "move_operand"         "d,I,m,dJ,*f,*d,*f,*d"))]
3638   "!TARGET_MIPS16
3639    && (register_operand (operands[0], HImode)
3640        || reg_or_0_operand (operands[1], HImode))"
3641   "@
3642     move\t%0,%1
3643     li\t%0,%1
3644     lhu\t%0,%1
3645     sh\t%z1,%0
3646     mfc1\t%0,%1
3647     mtc1\t%1,%0
3648     mov.s\t%0,%1
3649     mt%0\t%1"
3650   [(set_attr "type"     "arith,arith,load,store,mfc,mtc,fmove,mthilo")
3651    (set_attr "mode"     "HI")
3652    (set_attr "length"   "4,4,*,*,4,4,4,4")])
3653
3654 (define_insn "*movhi_mips16"
3655   [(set (match_operand:HI 0 "nonimmediate_operand" "=d,y,d,d,d,d,m")
3656         (match_operand:HI 1 "move_operand"         "d,d,y,K,N,m,d"))]
3657   "TARGET_MIPS16
3658    && (register_operand (operands[0], HImode)
3659        || register_operand (operands[1], HImode))"
3660   "@
3661     move\t%0,%1
3662     move\t%0,%1
3663     move\t%0,%1
3664     li\t%0,%1
3665     #
3666     lhu\t%0,%1
3667     sh\t%1,%0"
3668   [(set_attr "type"     "arith,arith,arith,arith,arith,load,store")
3669    (set_attr "mode"     "HI")
3670    (set_attr_alternative "length"
3671                 [(const_int 4)
3672                  (const_int 4)
3673                  (const_int 4)
3674                  (if_then_else (match_operand:VOID 1 "m16_uimm8_1")
3675                                (const_int 4)
3676                                (const_int 8))
3677                  (if_then_else (match_operand:VOID 1 "m16_nuimm8_1")
3678                                (const_int 8)
3679                                (const_int 12))
3680                  (const_string "*")
3681                  (const_string "*")])])
3682
3683
3684 ;; On the mips16, we can split lh $r,N($r) into an add and a load,
3685 ;; when the original load is a 4 byte instruction but the add and the
3686 ;; load are 2 2 byte instructions.
3687
3688 (define_split
3689   [(set (match_operand:HI 0 "register_operand")
3690         (mem:HI (plus:SI (match_dup 0)
3691                          (match_operand:SI 1 "const_int_operand"))))]
3692   "TARGET_MIPS16 && reload_completed && !TARGET_DEBUG_D_MODE
3693    && REG_P (operands[0])
3694    && M16_REG_P (REGNO (operands[0]))
3695    && GET_CODE (operands[1]) == CONST_INT
3696    && ((INTVAL (operands[1]) < 0
3697         && INTVAL (operands[1]) >= -0x80)
3698        || (INTVAL (operands[1]) >= 32 * 2
3699            && INTVAL (operands[1]) <= 31 * 2 + 0x7e)
3700        || (INTVAL (operands[1]) >= 0
3701            && INTVAL (operands[1]) < 32 * 2
3702            && (INTVAL (operands[1]) & 1) != 0))"
3703   [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 1)))
3704    (set (match_dup 0) (mem:HI (plus:SI (match_dup 0) (match_dup 2))))]
3705 {
3706   HOST_WIDE_INT val = INTVAL (operands[1]);
3707
3708   if (val < 0)
3709     operands[2] = const0_rtx;
3710   else if (val >= 32 * 2)
3711     {
3712       int off = val & 1;
3713
3714       operands[1] = GEN_INT (0x7e + off);
3715       operands[2] = GEN_INT (val - off - 0x7e);
3716     }
3717   else
3718     {
3719       int off = val & 1;
3720
3721       operands[1] = GEN_INT (off);
3722       operands[2] = GEN_INT (val - off);
3723     }
3724 })
3725
3726 ;; 8-bit Integer moves
3727
3728 ;; Unlike most other insns, the move insns can't be split with
3729 ;; different predicates, because register spilling and other parts of
3730 ;; the compiler, have memoized the insn number already.
3731 ;; Unsigned loads are used because LOAD_EXTEND_OP returns ZERO_EXTEND.
3732
3733 (define_expand "movqi"
3734   [(set (match_operand:QI 0 "")
3735         (match_operand:QI 1 ""))]
3736   ""
3737 {
3738   if (mips_legitimize_move (QImode, operands[0], operands[1]))
3739     DONE;
3740 })
3741
3742 (define_insn "*movqi_internal"
3743   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,d,d,m,*d,*f,*f,*x")
3744         (match_operand:QI 1 "move_operand"         "d,I,m,dJ,*f,*d,*f,*d"))]
3745   "!TARGET_MIPS16
3746    && (register_operand (operands[0], QImode)
3747        || reg_or_0_operand (operands[1], QImode))"
3748   "@
3749     move\t%0,%1
3750     li\t%0,%1
3751     lbu\t%0,%1
3752     sb\t%z1,%0
3753     mfc1\t%0,%1
3754     mtc1\t%1,%0
3755     mov.s\t%0,%1
3756     mt%0\t%1"
3757   [(set_attr "type"     "arith,arith,load,store,mfc,mtc,fmove,mthilo")
3758    (set_attr "mode"     "QI")
3759    (set_attr "length"   "4,4,*,*,4,4,4,4")])
3760
3761 (define_insn "*movqi_mips16"
3762   [(set (match_operand:QI 0 "nonimmediate_operand" "=d,y,d,d,d,d,m")
3763         (match_operand:QI 1 "move_operand"         "d,d,y,K,N,m,d"))]
3764   "TARGET_MIPS16
3765    && (register_operand (operands[0], QImode)
3766        || register_operand (operands[1], QImode))"
3767   "@
3768     move\t%0,%1
3769     move\t%0,%1
3770     move\t%0,%1
3771     li\t%0,%1
3772     #
3773     lbu\t%0,%1
3774     sb\t%1,%0"
3775   [(set_attr "type"     "arith,arith,arith,arith,arith,load,store")
3776    (set_attr "mode"     "QI")
3777    (set_attr "length"   "4,4,4,4,8,*,*")])
3778
3779 ;; On the mips16, we can split lb $r,N($r) into an add and a load,
3780 ;; when the original load is a 4 byte instruction but the add and the
3781 ;; load are 2 2 byte instructions.
3782
3783 (define_split
3784   [(set (match_operand:QI 0 "register_operand")
3785         (mem:QI (plus:SI (match_dup 0)
3786                          (match_operand:SI 1 "const_int_operand"))))]
3787   "TARGET_MIPS16 && reload_completed && !TARGET_DEBUG_D_MODE
3788    && REG_P (operands[0])
3789    && M16_REG_P (REGNO (operands[0]))
3790    && GET_CODE (operands[1]) == CONST_INT
3791    && ((INTVAL (operands[1]) < 0
3792         && INTVAL (operands[1]) >= -0x80)
3793        || (INTVAL (operands[1]) >= 32
3794            && INTVAL (operands[1]) <= 31 + 0x7f))"
3795   [(set (match_dup 0) (plus:SI (match_dup 0) (match_dup 1)))
3796    (set (match_dup 0) (mem:QI (plus:SI (match_dup 0) (match_dup 2))))]
3797 {
3798   HOST_WIDE_INT val = INTVAL (operands[1]);
3799
3800   if (val < 0)
3801     operands[2] = const0_rtx;
3802   else
3803     {
3804       operands[1] = GEN_INT (0x7f);
3805       operands[2] = GEN_INT (val - 0x7f);
3806     }
3807 })
3808
3809 ;; 32-bit floating point moves
3810
3811 (define_expand "movsf"
3812   [(set (match_operand:SF 0 "")
3813         (match_operand:SF 1 ""))]
3814   ""
3815 {
3816   if (mips_legitimize_move (SFmode, operands[0], operands[1]))
3817     DONE;
3818 })
3819
3820 (define_insn "*movsf_hardfloat"
3821   [(set (match_operand:SF 0 "nonimmediate_operand" "=f,f,f,m,m,*f,*d,*d,*d,*m")
3822         (match_operand:SF 1 "move_operand" "f,G,m,f,G,*d,*f,*G*d,*m,*d"))]
3823   "TARGET_HARD_FLOAT
3824    && (register_operand (operands[0], SFmode)
3825        || reg_or_0_operand (operands[1], SFmode))"
3826   { return mips_output_move (operands[0], operands[1]); }
3827   [(set_attr "type"     "fmove,mtc,fpload,fpstore,store,mtc,mfc,arith,load,store")
3828    (set_attr "mode"     "SF")
3829    (set_attr "length"   "4,4,*,*,*,4,4,4,*,*")])
3830
3831 (define_insn "*movsf_softfloat"
3832   [(set (match_operand:SF 0 "nonimmediate_operand" "=d,d,m")
3833         (match_operand:SF 1 "move_operand" "Gd,m,d"))]
3834   "TARGET_SOFT_FLOAT && !TARGET_MIPS16
3835    && (register_operand (operands[0], SFmode)
3836        || reg_or_0_operand (operands[1], SFmode))"
3837   { return mips_output_move (operands[0], operands[1]); }
3838   [(set_attr "type"     "arith,load,store")
3839    (set_attr "mode"     "SF")
3840    (set_attr "length"   "4,*,*")])
3841
3842 (define_insn "*movsf_mips16"
3843   [(set (match_operand:SF 0 "nonimmediate_operand" "=d,y,d,d,m")
3844         (match_operand:SF 1 "move_operand" "d,d,y,m,d"))]
3845   "TARGET_MIPS16
3846    && (register_operand (operands[0], SFmode)
3847        || register_operand (operands[1], SFmode))"
3848   { return mips_output_move (operands[0], operands[1]); }
3849   [(set_attr "type"     "arith,arith,arith,load,store")
3850    (set_attr "mode"     "SF")
3851    (set_attr "length"   "4,4,4,*,*")])
3852
3853
3854 ;; 64-bit floating point moves
3855
3856 (define_expand "movdf"
3857   [(set (match_operand:DF 0 "")
3858         (match_operand:DF 1 ""))]
3859   ""
3860 {
3861   if (mips_legitimize_move (DFmode, operands[0], operands[1]))
3862     DONE;
3863 })
3864
3865 (define_insn "*movdf_hardfloat_64bit"
3866   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,m,m,*f,*d,*d,*d,*m")
3867         (match_operand:DF 1 "move_operand" "f,G,m,f,G,*d,*f,*d*G,*m,*d"))]
3868   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && TARGET_64BIT
3869    && (register_operand (operands[0], DFmode)
3870        || reg_or_0_operand (operands[1], DFmode))"
3871   { return mips_output_move (operands[0], operands[1]); }
3872   [(set_attr "type"     "fmove,mtc,fpload,fpstore,store,mtc,mfc,arith,load,store")
3873    (set_attr "mode"     "DF")
3874    (set_attr "length"   "4,4,*,*,*,4,4,4,*,*")])
3875
3876 ;; This pattern applies to both !TARGET_FLOAT64 and TARGET_FLOAT64.
3877 (define_insn "*movdf_hardfloat_32bit"
3878   [(set (match_operand:DF 0 "nonimmediate_operand" "=f,f,f,m,m,*f,*d,*d,*d,*m")
3879         (match_operand:DF 1 "move_operand" "f,G,m,f,G,*d,*f,*d*G,*m,*d"))]
3880   "TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT && !TARGET_64BIT
3881    && (register_operand (operands[0], DFmode)
3882        || reg_or_0_operand (operands[1], DFmode))"
3883   { return mips_output_move (operands[0], operands[1]); }
3884   [(set_attr "type"     "fmove,mtc,fpload,fpstore,store,mtc,mfc,arith,load,store")
3885    (set_attr "mode"     "DF")
3886    (set_attr "length"   "4,8,*,*,*,8,8,8,*,*")])
3887
3888 (define_insn "*movdf_softfloat"
3889   [(set (match_operand:DF 0 "nonimmediate_operand" "=d,d,m,d,f,f")
3890         (match_operand:DF 1 "move_operand" "dG,m,dG,f,d,f"))]
3891   "(TARGET_SOFT_FLOAT || TARGET_SINGLE_FLOAT) && !TARGET_MIPS16
3892    && (register_operand (operands[0], DFmode)
3893        || reg_or_0_operand (operands[1], DFmode))"
3894   { return mips_output_move (operands[0], operands[1]); }
3895   [(set_attr "type"     "arith,load,store,mfc,mtc,fmove")
3896    (set_attr "mode"     "DF")
3897    (set_attr "length"   "8,*,*,4,4,4")])
3898
3899 (define_insn "*movdf_mips16"
3900   [(set (match_operand:DF 0 "nonimmediate_operand" "=d,y,d,d,m")
3901         (match_operand:DF 1 "move_operand" "d,d,y,m,d"))]
3902   "TARGET_MIPS16
3903    && (register_operand (operands[0], DFmode)
3904        || register_operand (operands[1], DFmode))"
3905   { return mips_output_move (operands[0], operands[1]); }
3906   [(set_attr "type"     "arith,arith,arith,load,store")
3907    (set_attr "mode"     "DF")
3908    (set_attr "length"   "8,8,8,*,*")])
3909
3910 (define_split
3911   [(set (match_operand:DI 0 "nonimmediate_operand")
3912         (match_operand:DI 1 "move_operand"))]
3913   "reload_completed && !TARGET_64BIT
3914    && mips_split_64bit_move_p (operands[0], operands[1])"
3915   [(const_int 0)]
3916 {
3917   mips_split_64bit_move (operands[0], operands[1]);
3918   DONE;
3919 })
3920
3921 (define_split
3922   [(set (match_operand:DF 0 "nonimmediate_operand")
3923         (match_operand:DF 1 "move_operand"))]
3924   "reload_completed && !TARGET_64BIT
3925    && mips_split_64bit_move_p (operands[0], operands[1])"
3926   [(const_int 0)]
3927 {
3928   mips_split_64bit_move (operands[0], operands[1]);
3929   DONE;
3930 })
3931
3932 ;; When generating mips16 code, split moves of negative constants into
3933 ;; a positive "li" followed by a negation.
3934 (define_split
3935   [(set (match_operand 0 "register_operand")
3936         (match_operand 1 "const_int_operand"))]
3937   "TARGET_MIPS16 && reload_completed && INTVAL (operands[1]) < 0"
3938   [(set (match_dup 2)
3939         (match_dup 3))
3940    (set (match_dup 2)
3941         (neg:SI (match_dup 2)))]
3942 {
3943   operands[2] = gen_lowpart (SImode, operands[0]);
3944   operands[3] = GEN_INT (-INTVAL (operands[1]));
3945 })
3946
3947 ;; 64-bit paired-single floating point moves
3948
3949 (define_expand "movv2sf"
3950   [(set (match_operand:V2SF 0)
3951         (match_operand:V2SF 1))]
3952   "TARGET_PAIRED_SINGLE_FLOAT"
3953 {
3954   if (mips_legitimize_move (V2SFmode, operands[0], operands[1]))
3955     DONE;
3956 })
3957
3958 (define_insn "movv2sf_hardfloat_64bit"
3959   [(set (match_operand:V2SF 0 "nonimmediate_operand" "=f,f,f,m,m,*f,*d,*d,*d,*m")
3960         (match_operand:V2SF 1 "move_operand" "f,YG,m,f,YG,*d,*f,*d*YG,*m,*d"))]
3961   "TARGET_PAIRED_SINGLE_FLOAT
3962    && TARGET_64BIT
3963    && (register_operand (operands[0], V2SFmode)
3964        || reg_or_0_operand (operands[1], V2SFmode))"
3965   { return mips_output_move (operands[0], operands[1]); }
3966   [(set_attr "type" "fmove,mtc,fpload,fpstore,store,mtc,mfc,arith,load,store")
3967    (set_attr "mode" "SF")
3968    (set_attr "length" "4,4,*,*,*,4,4,4,*,*")])
3969
3970 ;; The HI and LO registers are not truly independent.  If we move an mthi
3971 ;; instruction before an mflo instruction, it will make the result of the
3972 ;; mflo unpredictable.  The same goes for mtlo and mfhi.
3973 ;;
3974 ;; We cope with this by making the mflo and mfhi patterns use both HI and LO.
3975 ;; Operand 1 is the register we want, operand 2 is the other one.
3976 ;;
3977 ;; When generating VR4120 or VR4130 code, we use macc{,hi} and
3978 ;; dmacc{,hi} instead of mfhi and mflo.  This avoids both