OSDN Git Service

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