OSDN Git Service

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