OSDN Git Service

* pa-protos.h (prefetch_operand): Delete.
[pf3gnuchains/gcc-fork.git] / gcc / config / pa / pa.md
1 ;;- Machine description for HP PA-RISC architecture for GCC compiler
2 ;;   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 ;;   2002, 2003, 2004 Free Software Foundation, Inc.
4 ;;   Contributed by the Center for Software Science at the University
5 ;;   of Utah.
6
7 ;; This file is part of GCC.
8
9 ;; GCC is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation; either version 2, or (at your option)
12 ;; any later version.
13
14 ;; GCC is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 ;; GNU General Public License for more details.
18
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GCC; see the file COPYING.  If not, write to
21 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
22 ;; Boston, MA 02111-1307, USA.
23
24 ;; This gcc Version 2 machine description is inspired by sparc.md and
25 ;; mips.md.
26
27 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
28
29 ;; Uses of UNSPEC in this file:
30
31 (define_constants
32   [(UNSPEC_CFFC         0)      ; canonicalize_funcptr_for_compare
33    (UNSPEC_GOTO         1)      ; indirect_goto
34    (UNSPEC_DLTIND14R    2)      ; 
35   ])
36
37 ;; UNSPEC_VOLATILE:
38
39 (define_constants
40   [(UNSPECV_BLOCKAGE    0)      ; blockage
41    (UNSPECV_DCACHE      1)      ; dcacheflush
42    (UNSPECV_ICACHE      2)      ; icacheflush
43    (UNSPECV_OPC         3)      ; outline_prologue_call
44    (UNSPECV_OEC         4)      ; outline_epilogue_call
45    (UNSPECV_LONGJMP     5)      ; builtin_longjmp
46   ])
47
48 ;; Insn type.  Used to default other attribute values.
49
50 ;; type "unary" insns have one input operand (1) and one output operand (0)
51 ;; type "binary" insns have two input operands (1,2) and one output (0)
52
53 (define_attr "type"
54   "move,unary,binary,shift,nullshift,compare,load,store,uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,fpload,fpstore,fpalu,fpcc,fpmulsgl,fpmuldbl,fpdivsgl,fpdivdbl,fpsqrtsgl,fpsqrtdbl,multi,milli,parallel_branch"
55   (const_string "binary"))
56
57 (define_attr "pa_combine_type"
58   "fmpy,faddsub,uncond_branch,addmove,none"
59   (const_string "none"))
60
61 ;; Processor type (for scheduling, not code generation) -- this attribute
62 ;; must exactly match the processor_type enumeration in pa.h.
63 ;;
64 ;; FIXME: Add 800 scheduling for completeness?
65
66 (define_attr "cpu" "700,7100,7100LC,7200,7300,8000" (const (symbol_ref "pa_cpu_attr")))
67
68 ;; Length (in # of bytes).
69 (define_attr "length" ""
70   (cond [(eq_attr "type" "load,fpload")
71          (if_then_else (match_operand 1 "symbolic_memory_operand" "")
72                        (const_int 8) (const_int 4))
73
74          (eq_attr "type" "store,fpstore")
75          (if_then_else (match_operand 0 "symbolic_memory_operand" "")
76                        (const_int 8) (const_int 4))
77
78          (eq_attr "type" "binary,shift,nullshift")
79          (if_then_else (match_operand 2 "arith_operand" "")
80                        (const_int 4) (const_int 12))
81
82          (eq_attr "type" "move,unary,shift,nullshift")
83          (if_then_else (match_operand 1 "arith_operand" "")
84                        (const_int 4) (const_int 8))]
85
86         (const_int 4)))
87
88 (define_asm_attributes
89   [(set_attr "length" "4")
90    (set_attr "type" "multi")])
91
92 ;; Attributes for instruction and branch scheduling
93
94 ;; For conditional branches.
95 (define_attr "in_branch_delay" "false,true"
96   (if_then_else (and (eq_attr "type" "!uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch")
97                      (eq_attr "length" "4"))
98                 (const_string "true")
99                 (const_string "false")))
100
101 ;; Disallow instructions which use the FPU since they will tie up the FPU
102 ;; even if the instruction is nullified.
103 (define_attr "in_nullified_branch_delay" "false,true"
104   (if_then_else (and (eq_attr "type" "!uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpdivdbl,fpsqrtsgl,fpsqrtdbl,parallel_branch")
105                      (eq_attr "length" "4"))
106                 (const_string "true")
107                 (const_string "false")))
108
109 ;; For calls and millicode calls.  Allow unconditional branches in the
110 ;; delay slot.
111 (define_attr "in_call_delay" "false,true"
112   (cond [(and (eq_attr "type" "!uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch")
113               (eq_attr "length" "4"))
114            (const_string "true")
115          (eq_attr "type" "uncond_branch")
116            (if_then_else (ne (symbol_ref "TARGET_JUMP_IN_DELAY")
117                              (const_int 0))
118                          (const_string "true")
119                          (const_string "false"))]
120         (const_string "false")))
121
122
123 ;; Call delay slot description.
124 (define_delay (eq_attr "type" "call")
125   [(eq_attr "in_call_delay" "true") (nil) (nil)])
126
127 ;; Millicode call delay slot description.
128 (define_delay (eq_attr "type" "milli")
129   [(eq_attr "in_call_delay" "true") (nil) (nil)])
130
131 ;; Return and other similar instructions.
132 (define_delay (eq_attr "type" "btable_branch,branch,parallel_branch")
133   [(eq_attr "in_branch_delay" "true") (nil) (nil)])
134
135 ;; Floating point conditional branch delay slot description and
136 (define_delay (eq_attr "type" "fbranch")
137   [(eq_attr "in_branch_delay" "true")
138    (eq_attr "in_nullified_branch_delay" "true")
139    (nil)])
140
141 ;; Integer conditional branch delay slot description.
142 ;; Nullification of conditional branches on the PA is dependent on the
143 ;; direction of the branch.  Forward branches nullify true and
144 ;; backward branches nullify false.  If the direction is unknown
145 ;; then nullification is not allowed.
146 (define_delay (eq_attr "type" "cbranch")
147   [(eq_attr "in_branch_delay" "true")
148    (and (eq_attr "in_nullified_branch_delay" "true")
149         (attr_flag "forward"))
150    (and (eq_attr "in_nullified_branch_delay" "true")
151         (attr_flag "backward"))])
152
153 (define_delay (and (eq_attr "type" "uncond_branch")
154                    (eq (symbol_ref "following_call (insn)")
155                        (const_int 0)))
156   [(eq_attr "in_branch_delay" "true") (nil) (nil)])
157
158 ;; Memory. Disregarding Cache misses, the Mustang memory times are:
159 ;; load: 2, fpload: 3
160 ;; store, fpstore: 3, no D-cache operations should be scheduled.
161
162 ;; The Timex (aka 700) has two floating-point units: ALU, and MUL/DIV/SQRT.
163 ;; Timings:
164 ;; Instruction  Time    Unit    Minimum Distance (unit contention)
165 ;; fcpy         3       ALU     2
166 ;; fabs         3       ALU     2
167 ;; fadd         3       ALU     2
168 ;; fsub         3       ALU     2
169 ;; fcmp         3       ALU     2
170 ;; fcnv         3       ALU     2
171 ;; fmpyadd      3       ALU,MPY 2
172 ;; fmpysub      3       ALU,MPY 2
173 ;; fmpycfxt     3       ALU,MPY 2
174 ;; fmpy         3       MPY     2
175 ;; fmpyi        3       MPY     2
176 ;; fdiv,sgl     10      MPY     10
177 ;; fdiv,dbl     12      MPY     12
178 ;; fsqrt,sgl    14      MPY     14
179 ;; fsqrt,dbl    18      MPY     18
180 ;;
181 ;; We don't model fmpyadd/fmpysub properly as those instructions
182 ;; keep both the FP ALU and MPY units busy.  Given that these
183 ;; processors are obsolete, I'm not going to spend the time to
184 ;; model those instructions correctly.
185
186 (define_automaton "pa700")
187 (define_cpu_unit "dummy_700,mem_700,fpalu_700,fpmpy_700" "pa700")
188
189 (define_insn_reservation "W0" 4
190   (and (eq_attr "type" "fpcc")
191        (eq_attr "cpu" "700"))
192   "fpalu_700*2")
193
194 (define_insn_reservation "W1" 3
195   (and (eq_attr "type" "fpalu")
196        (eq_attr "cpu" "700"))
197   "fpalu_700*2")
198
199 (define_insn_reservation "W2" 3
200   (and (eq_attr "type" "fpmulsgl,fpmuldbl")
201        (eq_attr "cpu" "700"))
202   "fpmpy_700*2")
203
204 (define_insn_reservation "W3" 10
205   (and (eq_attr "type" "fpdivsgl")
206        (eq_attr "cpu" "700"))
207   "fpmpy_700*10")
208
209 (define_insn_reservation "W4" 12
210   (and (eq_attr "type" "fpdivdbl")
211        (eq_attr "cpu" "700"))
212   "fpmpy_700*12")
213
214 (define_insn_reservation "W5" 14
215   (and (eq_attr "type" "fpsqrtsgl")
216        (eq_attr "cpu" "700"))
217   "fpmpy_700*14")
218
219 (define_insn_reservation "W6" 18
220   (and (eq_attr "type" "fpsqrtdbl")
221        (eq_attr "cpu" "700"))
222   "fpmpy_700*18")
223
224 (define_insn_reservation "W7" 2
225   (and (eq_attr "type" "load")
226        (eq_attr "cpu" "700"))
227   "mem_700")
228
229 (define_insn_reservation "W8" 2
230   (and (eq_attr "type" "fpload")
231        (eq_attr "cpu" "700"))
232   "mem_700")
233
234 (define_insn_reservation "W9" 3
235   (and (eq_attr "type" "store")
236        (eq_attr "cpu" "700"))
237   "mem_700*3")
238
239 (define_insn_reservation "W10" 3
240   (and (eq_attr "type" "fpstore")
241        (eq_attr "cpu" "700"))
242   "mem_700*3")
243
244 (define_insn_reservation "W11" 1
245   (and (eq_attr "type" "!fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpdivdbl,fpsqrtsgl,fpsqrtdbl,load,fpload,store,fpstore")
246        (eq_attr "cpu" "700"))
247   "dummy_700")
248
249 ;; We have a bypass for all computations in the FP unit which feed an
250 ;; FP store as long as the sizes are the same.
251 (define_bypass 2 "W1,W2" "W10" "hppa_fpstore_bypass_p")
252 (define_bypass 9 "W3" "W10" "hppa_fpstore_bypass_p")
253 (define_bypass 11 "W4" "W10" "hppa_fpstore_bypass_p")
254 (define_bypass 13 "W5" "W10" "hppa_fpstore_bypass_p")
255 (define_bypass 17 "W6" "W10" "hppa_fpstore_bypass_p")
256
257 ;; We have an "anti-bypass" for FP loads which feed an FP store.
258 (define_bypass 4 "W8" "W10" "hppa_fpstore_bypass_p")
259
260 ;; Function units for the 7100 and 7150.  The 7100/7150 can dual-issue
261 ;; floating point computations with non-floating point computations (fp loads
262 ;; and stores are not fp computations).
263 ;;
264 ;; Memory. Disregarding Cache misses, memory loads take two cycles; stores also
265 ;; take two cycles, during which no Dcache operations should be scheduled.
266 ;; Any special cases are handled in pa_adjust_cost.  The 7100, 7150 and 7100LC
267 ;; all have the same memory characteristics if one disregards cache misses.
268 ;;
269 ;; The 7100/7150 has three floating-point units: ALU, MUL, and DIV.
270 ;; There's no value in modeling the ALU and MUL separately though
271 ;; since there can never be a functional unit conflict given the
272 ;; latency and issue rates for those units.
273 ;;
274 ;; Timings:
275 ;; Instruction  Time    Unit    Minimum Distance (unit contention)
276 ;; fcpy         2       ALU     1
277 ;; fabs         2       ALU     1
278 ;; fadd         2       ALU     1
279 ;; fsub         2       ALU     1
280 ;; fcmp         2       ALU     1
281 ;; fcnv         2       ALU     1
282 ;; fmpyadd      2       ALU,MPY 1
283 ;; fmpysub      2       ALU,MPY 1
284 ;; fmpycfxt     2       ALU,MPY 1
285 ;; fmpy         2       MPY     1
286 ;; fmpyi        2       MPY     1
287 ;; fdiv,sgl     8       DIV     8
288 ;; fdiv,dbl     15      DIV     15
289 ;; fsqrt,sgl    8       DIV     8
290 ;; fsqrt,dbl    15      DIV     15
291
292 (define_automaton "pa7100")
293 (define_cpu_unit "i_7100, f_7100,fpmac_7100,fpdivsqrt_7100,mem_7100" "pa7100")
294
295 (define_insn_reservation "X0" 2
296   (and (eq_attr "type" "fpcc,fpalu,fpmulsgl,fpmuldbl")
297        (eq_attr "cpu" "7100"))
298   "f_7100,fpmac_7100")
299
300 (define_insn_reservation "X1" 8
301   (and (eq_attr "type" "fpdivsgl,fpsqrtsgl")
302        (eq_attr "cpu" "7100"))
303   "f_7100+fpdivsqrt_7100,fpdivsqrt_7100*7")
304
305 (define_insn_reservation "X2" 15
306   (and (eq_attr "type" "fpdivdbl,fpsqrtdbl")
307        (eq_attr "cpu" "7100"))
308   "f_7100+fpdivsqrt_7100,fpdivsqrt_7100*14")
309
310 (define_insn_reservation "X3" 2
311   (and (eq_attr "type" "load")
312        (eq_attr "cpu" "7100"))
313   "i_7100+mem_7100")
314
315 (define_insn_reservation "X4" 2
316   (and (eq_attr "type" "fpload")
317        (eq_attr "cpu" "7100"))
318   "i_7100+mem_7100")
319
320 (define_insn_reservation "X5" 2
321   (and (eq_attr "type" "store")
322        (eq_attr "cpu" "7100"))
323   "i_7100+mem_7100,mem_7100")
324
325 (define_insn_reservation "X6" 2
326   (and (eq_attr "type" "fpstore")
327        (eq_attr "cpu" "7100"))
328   "i_7100+mem_7100,mem_7100")
329
330 (define_insn_reservation "X7" 1
331   (and (eq_attr "type" "!fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpsqrtsgl,fpdivdbl,fpsqrtdbl,load,fpload,store,fpstore")
332        (eq_attr "cpu" "7100"))
333   "i_7100")
334
335 ;; We have a bypass for all computations in the FP unit which feed an
336 ;; FP store as long as the sizes are the same.
337 (define_bypass 1 "X0" "X6" "hppa_fpstore_bypass_p")
338 (define_bypass 7 "X1" "X6" "hppa_fpstore_bypass_p")
339 (define_bypass 14 "X2" "X6" "hppa_fpstore_bypass_p")
340
341 ;; We have an "anti-bypass" for FP loads which feed an FP store.
342 (define_bypass 3 "X4" "X6" "hppa_fpstore_bypass_p")
343
344 ;; The 7100LC has three floating-point units: ALU, MUL, and DIV.
345 ;; There's no value in modeling the ALU and MUL separately though
346 ;; since there can never be a functional unit conflict that
347 ;; can be avoided given the latency, issue rates and mandatory
348 ;; one cycle cpu-wide lock for a double precision fp multiply.
349 ;;
350 ;; Timings:
351 ;; Instruction  Time    Unit    Minimum Distance (unit contention)
352 ;; fcpy         2       ALU     1
353 ;; fabs         2       ALU     1
354 ;; fadd         2       ALU     1
355 ;; fsub         2       ALU     1
356 ;; fcmp         2       ALU     1
357 ;; fcnv         2       ALU     1
358 ;; fmpyadd,sgl  2       ALU,MPY 1
359 ;; fmpyadd,dbl  3       ALU,MPY 2
360 ;; fmpysub,sgl  2       ALU,MPY 1
361 ;; fmpysub,dbl  3       ALU,MPY 2
362 ;; fmpycfxt,sgl 2       ALU,MPY 1
363 ;; fmpycfxt,dbl 3       ALU,MPY 2
364 ;; fmpy,sgl     2       MPY     1
365 ;; fmpy,dbl     3       MPY     2
366 ;; fmpyi        3       MPY     2
367 ;; fdiv,sgl     8       DIV     8
368 ;; fdiv,dbl     15      DIV     15
369 ;; fsqrt,sgl    8       DIV     8
370 ;; fsqrt,dbl    15      DIV     15
371 ;;
372 ;; The PA7200 is just like the PA7100LC except that there is
373 ;; no store-store penalty.
374 ;;
375 ;; The PA7300 is just like the PA7200 except that there is
376 ;; no store-load penalty.
377 ;;
378 ;; Note there are some aspects of the 7100LC we are not modeling
379 ;; at the moment.  I'll be reviewing the 7100LC scheduling info
380 ;; shortly and updating this description.
381 ;;
382 ;;   load-load pairs
383 ;;   store-store pairs
384 ;;   other issue modeling
385
386 (define_automaton "pa7100lc")
387 (define_cpu_unit "i0_7100lc, i1_7100lc, f_7100lc" "pa7100lc")
388 (define_cpu_unit "fpmac_7100lc" "pa7100lc")
389 (define_cpu_unit "mem_7100lc" "pa7100lc")
390
391 ;; Double precision multiplies lock the entire CPU for one
392 ;; cycle.  There is no way to avoid this lock and trying to
393 ;; schedule around the lock is pointless and thus there is no
394 ;; value in trying to model this lock.
395 ;;
396 ;; Not modeling the lock allows us to treat fp multiplies just
397 ;; like any other FP alu instruction.  It allows for a smaller
398 ;; DFA and may reduce register pressure.
399 (define_insn_reservation "Y0" 2
400   (and (eq_attr "type" "fpcc,fpalu,fpmulsgl,fpmuldbl")
401        (eq_attr "cpu" "7100LC,7200,7300"))
402   "f_7100lc,fpmac_7100lc")
403
404 ;; fp division and sqrt instructions lock the entire CPU for
405 ;; 7 cycles (single precision) or 14 cycles (double precision).
406 ;; There is no way to avoid this lock and trying to schedule
407 ;; around the lock is pointless and thus there is no value in
408 ;; trying to model this lock.  Not modeling the lock allows
409 ;; for a smaller DFA and may reduce register pressure.
410 (define_insn_reservation "Y1" 1
411   (and (eq_attr "type" "fpdivsgl,fpsqrtsgl,fpdivdbl,fpsqrtdbl")
412        (eq_attr "cpu" "7100LC,7200,7300"))
413   "f_7100lc")
414
415 (define_insn_reservation "Y2" 2
416   (and (eq_attr "type" "load")
417        (eq_attr "cpu" "7100LC,7200,7300"))
418   "i1_7100lc+mem_7100lc")
419
420 (define_insn_reservation "Y3" 2
421   (and (eq_attr "type" "fpload")
422        (eq_attr "cpu" "7100LC,7200,7300"))
423   "i1_7100lc+mem_7100lc")
424
425 (define_insn_reservation "Y4" 2
426   (and (eq_attr "type" "store")
427        (eq_attr "cpu" "7100LC"))
428   "i1_7100lc+mem_7100lc,mem_7100lc")
429
430 (define_insn_reservation "Y5" 2
431   (and (eq_attr "type" "fpstore")
432        (eq_attr "cpu" "7100LC"))
433   "i1_7100lc+mem_7100lc,mem_7100lc")
434
435 (define_insn_reservation "Y6" 1
436   (and (eq_attr "type" "shift,nullshift")
437        (eq_attr "cpu" "7100LC,7200,7300"))
438   "i1_7100lc")
439
440 (define_insn_reservation "Y7" 1
441   (and (eq_attr "type" "!fpcc,fpalu,fpmulsgl,fpmuldbl,fpdivsgl,fpsqrtsgl,fpdivdbl,fpsqrtdbl,load,fpload,store,fpstore,shift,nullshift")
442        (eq_attr "cpu" "7100LC,7200,7300"))
443   "(i0_7100lc|i1_7100lc)")
444
445 ;; The 7200 has a store-load penalty
446 (define_insn_reservation "Y8" 2
447   (and (eq_attr "type" "store")
448        (eq_attr "cpu" "7200"))
449   "i1_7100lc,mem_7100lc")
450
451 (define_insn_reservation "Y9" 2
452   (and (eq_attr "type" "fpstore")
453        (eq_attr "cpu" "7200"))
454   "i1_7100lc,mem_7100lc")
455
456 ;; The 7300 has no penalty for store-store or store-load
457 (define_insn_reservation "Y10" 2
458   (and (eq_attr "type" "store")
459        (eq_attr "cpu" "7300"))
460   "i1_7100lc")
461
462 (define_insn_reservation "Y11" 2
463   (and (eq_attr "type" "fpstore")
464        (eq_attr "cpu" "7300"))
465   "i1_7100lc")
466
467 ;; We have an "anti-bypass" for FP loads which feed an FP store.
468 (define_bypass 3 "Y3" "Y5,Y9,Y11" "hppa_fpstore_bypass_p")
469
470 ;; Scheduling for the PA8000 is somewhat different than scheduling for a
471 ;; traditional architecture.
472 ;;
473 ;; The PA8000 has a large (56) entry reorder buffer that is split between
474 ;; memory and non-memory operations.
475 ;;
476 ;; The PA8000 can issue two memory and two non-memory operations per cycle to
477 ;; the function units, with the exception of branches and multi-output
478 ;; instructions.  The PA8000 can retire two non-memory operations per cycle
479 ;; and two memory operations per cycle, only one of which may be a store.
480 ;;
481 ;; Given the large reorder buffer, the processor can hide most latencies.
482 ;; According to HP, they've got the best results by scheduling for retirement
483 ;; bandwidth with limited latency scheduling for floating point operations.
484 ;; Latency for integer operations and memory references is ignored.
485 ;;
486 ;;
487 ;; We claim floating point operations have a 2 cycle latency and are
488 ;; fully pipelined, except for div and sqrt which are not pipelined and
489 ;; take from 17 to 31 cycles to complete.
490 ;;
491 ;; It's worth noting that there is no way to saturate all the functional
492 ;; units on the PA8000 as there is not enough issue bandwidth.
493
494 (define_automaton "pa8000")
495 (define_cpu_unit "inm0_8000, inm1_8000, im0_8000, im1_8000" "pa8000")
496 (define_cpu_unit "rnm0_8000, rnm1_8000, rm0_8000, rm1_8000" "pa8000")
497 (define_cpu_unit "store_8000" "pa8000")
498 (define_cpu_unit "f0_8000, f1_8000" "pa8000")
499 (define_cpu_unit "fdivsqrt0_8000, fdivsqrt1_8000" "pa8000")
500 (define_reservation "inm_8000" "inm0_8000 | inm1_8000")
501 (define_reservation "im_8000" "im0_8000 | im1_8000")
502 (define_reservation "rnm_8000" "rnm0_8000 | rnm1_8000")
503 (define_reservation "rm_8000" "rm0_8000 | rm1_8000")
504 (define_reservation "f_8000" "f0_8000 | f1_8000")
505 (define_reservation "fdivsqrt_8000" "fdivsqrt0_8000 | fdivsqrt1_8000")
506
507 ;; We can issue any two memops per cycle, but we can only retire
508 ;; one memory store per cycle.  We assume that the reorder buffer
509 ;; will hide any memory latencies per HP's recommendation.
510 (define_insn_reservation "Z0" 0
511   (and
512     (eq_attr "type" "load,fpload")
513     (eq_attr "cpu" "8000"))
514   "im_8000,rm_8000")
515
516 (define_insn_reservation "Z1" 0
517   (and
518     (eq_attr "type" "store,fpstore")
519     (eq_attr "cpu" "8000"))
520   "im_8000,rm_8000+store_8000")
521
522 ;; We can issue and retire two non-memory operations per cycle with
523 ;; a few exceptions (branches).  This group catches those we want
524 ;; to assume have zero latency.
525 (define_insn_reservation "Z2" 0
526   (and
527     (eq_attr "type" "!load,fpload,store,fpstore,uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch,fpcc,fpalu,fpmulsgl,fpmuldbl,fpsqrtsgl,fpsqrtdbl,fpdivsgl,fpdivdbl")
528     (eq_attr "cpu" "8000"))
529   "inm_8000,rnm_8000")
530
531 ;; Branches use both slots in the non-memory issue and
532 ;; retirement unit.
533 (define_insn_reservation "Z3" 0
534   (and
535     (eq_attr "type" "uncond_branch,btable_branch,branch,cbranch,fbranch,call,dyncall,multi,milli,parallel_branch")
536     (eq_attr "cpu" "8000"))
537   "inm0_8000+inm1_8000,rnm0_8000+rnm1_8000")
538
539 ;; We partial latency schedule the floating point units.
540 ;; They can issue/retire two at a time in the non-memory
541 ;; units.  We fix their latency at 2 cycles and they
542 ;; are fully pipelined.
543 (define_insn_reservation "Z4" 1
544  (and
545    (eq_attr "type" "fpcc,fpalu,fpmulsgl,fpmuldbl")
546    (eq_attr "cpu" "8000"))
547  "inm_8000,f_8000,rnm_8000")
548
549 ;; The fdivsqrt units are not pipelined and have a very long latency.  
550 ;; To keep the DFA from exploding, we do not show all the
551 ;; reservations for the divsqrt unit.
552 (define_insn_reservation "Z5" 17
553  (and
554    (eq_attr "type" "fpdivsgl,fpsqrtsgl")
555    (eq_attr "cpu" "8000"))
556  "inm_8000,fdivsqrt_8000*6,rnm_8000")
557
558 (define_insn_reservation "Z6" 31
559  (and
560    (eq_attr "type" "fpdivdbl,fpsqrtdbl")
561    (eq_attr "cpu" "8000"))
562  "inm_8000,fdivsqrt_8000*6,rnm_8000")
563
564
565 \f
566 ;; Compare instructions.
567 ;; This controls RTL generation and register allocation.
568
569 ;; We generate RTL for comparisons and branches by having the cmpxx
570 ;; patterns store away the operands.  Then, the scc and bcc patterns
571 ;; emit RTL for both the compare and the branch.
572 ;;
573
574 (define_expand "cmpdi"
575   [(set (reg:CC 0)
576         (compare:CC (match_operand:DI 0 "reg_or_0_operand" "")
577                     (match_operand:DI 1 "register_operand" "")))]
578   "TARGET_64BIT"
579
580   "
581 {
582  hppa_compare_op0 = operands[0];
583  hppa_compare_op1 = operands[1];
584  hppa_branch_type = CMP_SI;
585  DONE;
586 }")
587
588 (define_expand "cmpsi"
589   [(set (reg:CC 0)
590         (compare:CC (match_operand:SI 0 "reg_or_0_operand" "")
591                     (match_operand:SI 1 "arith5_operand" "")))]
592   ""
593   "
594 {
595  hppa_compare_op0 = operands[0];
596  hppa_compare_op1 = operands[1];
597  hppa_branch_type = CMP_SI;
598  DONE;
599 }")
600
601 (define_expand "cmpsf"
602   [(set (reg:CCFP 0)
603         (compare:CCFP (match_operand:SF 0 "reg_or_0_operand" "")
604                       (match_operand:SF 1 "reg_or_0_operand" "")))]
605   "! TARGET_SOFT_FLOAT"
606   "
607 {
608   hppa_compare_op0 = operands[0];
609   hppa_compare_op1 = operands[1];
610   hppa_branch_type = CMP_SF;
611   DONE;
612 }")
613
614 (define_expand "cmpdf"
615   [(set (reg:CCFP 0)
616       (compare:CCFP (match_operand:DF 0 "reg_or_0_operand" "")
617                     (match_operand:DF 1 "reg_or_0_operand" "")))]
618   "! TARGET_SOFT_FLOAT"
619   "
620 {
621   hppa_compare_op0 = operands[0];
622   hppa_compare_op1 = operands[1];
623   hppa_branch_type = CMP_DF;
624   DONE;
625 }")
626
627 (define_insn ""
628   [(set (reg:CCFP 0)
629         (match_operator:CCFP 2 "comparison_operator"
630                              [(match_operand:SF 0 "reg_or_0_operand" "fG")
631                               (match_operand:SF 1 "reg_or_0_operand" "fG")]))]
632   "! TARGET_SOFT_FLOAT"
633   "fcmp,sgl,%Y2 %f0,%f1"
634   [(set_attr "length" "4")
635    (set_attr "type" "fpcc")])
636
637 (define_insn ""
638   [(set (reg:CCFP 0)
639         (match_operator:CCFP 2 "comparison_operator"
640                              [(match_operand:DF 0 "reg_or_0_operand" "fG")
641                               (match_operand:DF 1 "reg_or_0_operand" "fG")]))]
642   "! TARGET_SOFT_FLOAT"
643   "fcmp,dbl,%Y2 %f0,%f1"
644   [(set_attr "length" "4")
645    (set_attr "type" "fpcc")])
646
647 ;; Provide a means to emit the movccfp0 and movccfp1 optimization
648 ;; placeholders.  This is necessary in rare situations when a
649 ;; placeholder is re-emitted (see PR 8705).
650
651 (define_expand "movccfp"
652   [(set (reg:CCFP 0)
653         (match_operand 0 "const_int_operand" ""))]
654   "! TARGET_SOFT_FLOAT"
655   "
656 {
657   if ((unsigned HOST_WIDE_INT) INTVAL (operands[0]) > 1)
658     FAIL;
659 }")
660
661 ;; The following patterns are optimization placeholders.  In almost
662 ;; all cases, the user of the condition code will be simplified and the
663 ;; original condition code setting insn should be eliminated.
664
665 (define_insn "*movccfp0"
666   [(set (reg:CCFP 0)
667         (const_int 0))]
668   "! TARGET_SOFT_FLOAT"
669   "fcmp,dbl,= %%fr0,%%fr0"
670   [(set_attr "length" "4")
671    (set_attr "type" "fpcc")])
672
673 (define_insn "*movccfp1"
674   [(set (reg:CCFP 0)
675         (const_int 1))]
676   "! TARGET_SOFT_FLOAT"
677   "fcmp,dbl,!= %%fr0,%%fr0"
678   [(set_attr "length" "4")
679    (set_attr "type" "fpcc")])
680
681 ;; scc insns.
682
683 (define_expand "seq"
684   [(set (match_operand:SI 0 "register_operand" "")
685         (eq:SI (match_dup 1)
686                (match_dup 2)))]
687   "!TARGET_64BIT"
688   "
689 {
690   /* fp scc patterns rarely match, and are not a win on the PA.  */
691   if (hppa_branch_type != CMP_SI)
692     FAIL;
693   /* set up operands from compare.  */
694   operands[1] = hppa_compare_op0;
695   operands[2] = hppa_compare_op1;
696   /* fall through and generate default code */
697 }")
698
699 (define_expand "sne"
700   [(set (match_operand:SI 0 "register_operand" "")
701         (ne:SI (match_dup 1)
702                (match_dup 2)))]
703   "!TARGET_64BIT"
704   "
705 {
706   /* fp scc patterns rarely match, and are not a win on the PA.  */
707   if (hppa_branch_type != CMP_SI)
708     FAIL;
709   operands[1] = hppa_compare_op0;
710   operands[2] = hppa_compare_op1;
711 }")
712
713 (define_expand "slt"
714   [(set (match_operand:SI 0 "register_operand" "")
715         (lt:SI (match_dup 1)
716                (match_dup 2)))]
717   "!TARGET_64BIT"
718   "
719 {
720   /* fp scc patterns rarely match, and are not a win on the PA.  */
721   if (hppa_branch_type != CMP_SI)
722     FAIL;
723   operands[1] = hppa_compare_op0;
724   operands[2] = hppa_compare_op1;
725 }")
726
727 (define_expand "sgt"
728   [(set (match_operand:SI 0 "register_operand" "")
729         (gt:SI (match_dup 1)
730                (match_dup 2)))]
731   "!TARGET_64BIT"
732   "
733 {
734   /* fp scc patterns rarely match, and are not a win on the PA.  */
735   if (hppa_branch_type != CMP_SI)
736     FAIL;
737   operands[1] = hppa_compare_op0;
738   operands[2] = hppa_compare_op1;
739 }")
740
741 (define_expand "sle"
742   [(set (match_operand:SI 0 "register_operand" "")
743         (le:SI (match_dup 1)
744                (match_dup 2)))]
745   "!TARGET_64BIT"
746   "
747 {
748   /* fp scc patterns rarely match, and are not a win on the PA.  */
749   if (hppa_branch_type != CMP_SI)
750     FAIL;
751   operands[1] = hppa_compare_op0;
752   operands[2] = hppa_compare_op1;
753 }")
754
755 (define_expand "sge"
756   [(set (match_operand:SI 0 "register_operand" "")
757         (ge:SI (match_dup 1)
758                (match_dup 2)))]
759   "!TARGET_64BIT"
760   "
761 {
762   /* fp scc patterns rarely match, and are not a win on the PA.  */
763   if (hppa_branch_type != CMP_SI)
764     FAIL;
765   operands[1] = hppa_compare_op0;
766   operands[2] = hppa_compare_op1;
767 }")
768
769 (define_expand "sltu"
770   [(set (match_operand:SI 0 "register_operand" "")
771         (ltu:SI (match_dup 1)
772                 (match_dup 2)))]
773   "!TARGET_64BIT"
774   "
775 {
776   if (hppa_branch_type != CMP_SI)
777     FAIL;
778   operands[1] = hppa_compare_op0;
779   operands[2] = hppa_compare_op1;
780 }")
781
782 (define_expand "sgtu"
783   [(set (match_operand:SI 0 "register_operand" "")
784         (gtu:SI (match_dup 1)
785                 (match_dup 2)))]
786   "!TARGET_64BIT"
787   "
788 {
789   if (hppa_branch_type != CMP_SI)
790     FAIL;
791   operands[1] = hppa_compare_op0;
792   operands[2] = hppa_compare_op1;
793 }")
794
795 (define_expand "sleu"
796   [(set (match_operand:SI 0 "register_operand" "")
797         (leu:SI (match_dup 1)
798                 (match_dup 2)))]
799   "!TARGET_64BIT"
800   "
801 {
802   if (hppa_branch_type != CMP_SI)
803     FAIL;
804   operands[1] = hppa_compare_op0;
805   operands[2] = hppa_compare_op1;
806 }")
807
808 (define_expand "sgeu"
809   [(set (match_operand:SI 0 "register_operand" "")
810         (geu:SI (match_dup 1)
811                 (match_dup 2)))]
812   "!TARGET_64BIT"
813   "
814 {
815   if (hppa_branch_type != CMP_SI)
816     FAIL;
817   operands[1] = hppa_compare_op0;
818   operands[2] = hppa_compare_op1;
819 }")
820
821 ;; Instruction canonicalization puts immediate operands second, which
822 ;; is the reverse of what we want.
823
824 (define_insn "scc"
825   [(set (match_operand:SI 0 "register_operand" "=r")
826         (match_operator:SI 3 "comparison_operator"
827                            [(match_operand:SI 1 "register_operand" "r")
828                             (match_operand:SI 2 "arith11_operand" "rI")]))]
829   ""
830   "{com%I2clr|cmp%I2clr},%B3 %2,%1,%0\;ldi 1,%0"
831   [(set_attr "type" "binary")
832    (set_attr "length" "8")])
833
834 (define_insn ""
835   [(set (match_operand:DI 0 "register_operand" "=r")
836         (match_operator:DI 3 "comparison_operator"
837                            [(match_operand:DI 1 "register_operand" "r")
838                             (match_operand:DI 2 "arith11_operand" "rI")]))]
839   "TARGET_64BIT"
840   "cmp%I2clr,*%B3 %2,%1,%0\;ldi 1,%0"
841   [(set_attr "type" "binary")
842    (set_attr "length" "8")])
843
844 (define_insn "iorscc"
845   [(set (match_operand:SI 0 "register_operand" "=r")
846         (ior:SI (match_operator:SI 3 "comparison_operator"
847                                    [(match_operand:SI 1 "register_operand" "r")
848                                     (match_operand:SI 2 "arith11_operand" "rI")])
849                 (match_operator:SI 6 "comparison_operator"
850                                    [(match_operand:SI 4 "register_operand" "r")
851                                     (match_operand:SI 5 "arith11_operand" "rI")])))]
852   ""
853   "{com%I2clr|cmp%I2clr},%S3 %2,%1,%%r0\;{com%I5clr|cmp%I5clr},%B6 %5,%4,%0\;ldi 1,%0"
854   [(set_attr "type" "binary")
855    (set_attr "length" "12")])
856
857 (define_insn ""
858   [(set (match_operand:DI 0 "register_operand" "=r")
859         (ior:DI (match_operator:DI 3 "comparison_operator"
860                                    [(match_operand:DI 1 "register_operand" "r")
861                                     (match_operand:DI 2 "arith11_operand" "rI")])
862                 (match_operator:DI 6 "comparison_operator"
863                                    [(match_operand:DI 4 "register_operand" "r")
864                                     (match_operand:DI 5 "arith11_operand" "rI")])))]
865   "TARGET_64BIT"
866   "cmp%I2clr,*%S3 %2,%1,%%r0\;cmp%I5clr,*%B6 %5,%4,%0\;ldi 1,%0"
867   [(set_attr "type" "binary")
868    (set_attr "length" "12")])
869
870 ;; Combiner patterns for common operations performed with the output
871 ;; from an scc insn (negscc and incscc).
872 (define_insn "negscc"
873   [(set (match_operand:SI 0 "register_operand" "=r")
874         (neg:SI (match_operator:SI 3 "comparison_operator"
875                [(match_operand:SI 1 "register_operand" "r")
876                 (match_operand:SI 2 "arith11_operand" "rI")])))]
877   ""
878   "{com%I2clr|cmp%I2clr},%B3 %2,%1,%0\;ldi -1,%0"
879   [(set_attr "type" "binary")
880    (set_attr "length" "8")])
881
882 (define_insn ""
883   [(set (match_operand:DI 0 "register_operand" "=r")
884         (neg:DI (match_operator:DI 3 "comparison_operator"
885                [(match_operand:DI 1 "register_operand" "r")
886                 (match_operand:DI 2 "arith11_operand" "rI")])))]
887   "TARGET_64BIT"
888   "cmp%I2clr,*%B3 %2,%1,%0\;ldi -1,%0"
889   [(set_attr "type" "binary")
890    (set_attr "length" "8")])
891
892 ;; Patterns for adding/subtracting the result of a boolean expression from
893 ;; a register.  First we have special patterns that make use of the carry
894 ;; bit, and output only two instructions.  For the cases we can't in
895 ;; general do in two instructions, the incscc pattern at the end outputs
896 ;; two or three instructions.
897
898 (define_insn ""
899   [(set (match_operand:SI 0 "register_operand" "=r")
900         (plus:SI (leu:SI (match_operand:SI 2 "register_operand" "r")
901                          (match_operand:SI 3 "arith11_operand" "rI"))
902                  (match_operand:SI 1 "register_operand" "r")))]
903   ""
904   "sub%I3 %3,%2,%%r0\;{addc|add,c} %%r0,%1,%0"
905   [(set_attr "type" "binary")
906    (set_attr "length" "8")])
907
908 (define_insn ""
909   [(set (match_operand:DI 0 "register_operand" "=r")
910         (plus:DI (leu:DI (match_operand:DI 2 "register_operand" "r")
911                          (match_operand:DI 3 "arith11_operand" "rI"))
912                  (match_operand:DI 1 "register_operand" "r")))]
913   "TARGET_64BIT"
914   "sub%I3 %3,%2,%%r0\;add,dc %%r0,%1,%0"
915   [(set_attr "type" "binary")
916    (set_attr "length" "8")])
917
918 ; This need only accept registers for op3, since canonicalization
919 ; replaces geu with gtu when op3 is an integer.
920 (define_insn ""
921   [(set (match_operand:SI 0 "register_operand" "=r")
922         (plus:SI (geu:SI (match_operand:SI 2 "register_operand" "r")
923                          (match_operand:SI 3 "register_operand" "r"))
924                  (match_operand:SI 1 "register_operand" "r")))]
925   ""
926   "sub %2,%3,%%r0\;{addc|add,c} %%r0,%1,%0"
927   [(set_attr "type" "binary")
928    (set_attr "length" "8")])
929
930 (define_insn ""
931   [(set (match_operand:DI 0 "register_operand" "=r")
932         (plus:DI (geu:DI (match_operand:DI 2 "register_operand" "r")
933                          (match_operand:DI 3 "register_operand" "r"))
934                  (match_operand:DI 1 "register_operand" "r")))]
935   "TARGET_64BIT"
936   "sub %2,%3,%%r0\;add,dc %%r0,%1,%0"
937   [(set_attr "type" "binary")
938    (set_attr "length" "8")])
939
940 ; Match only integers for op3 here.  This is used as canonical form of the
941 ; geu pattern when op3 is an integer.  Don't match registers since we can't
942 ; make better code than the general incscc pattern.
943 (define_insn ""
944   [(set (match_operand:SI 0 "register_operand" "=r")
945         (plus:SI (gtu:SI (match_operand:SI 2 "register_operand" "r")
946                          (match_operand:SI 3 "int11_operand" "I"))
947                  (match_operand:SI 1 "register_operand" "r")))]
948   ""
949   "addi %k3,%2,%%r0\;{addc|add,c} %%r0,%1,%0"
950   [(set_attr "type" "binary")
951    (set_attr "length" "8")])
952
953 (define_insn ""
954   [(set (match_operand:DI 0 "register_operand" "=r")
955         (plus:DI (gtu:DI (match_operand:DI 2 "register_operand" "r")
956                          (match_operand:DI 3 "int11_operand" "I"))
957                  (match_operand:DI 1 "register_operand" "r")))]
958   "TARGET_64BIT"
959   "addi %k3,%2,%%r0\;add,dc %%r0,%1,%0"
960   [(set_attr "type" "binary")
961    (set_attr "length" "8")])
962
963 (define_insn "incscc"
964   [(set (match_operand:SI 0 "register_operand" "=r,r")
965         (plus:SI (match_operator:SI 4 "comparison_operator"
966                     [(match_operand:SI 2 "register_operand" "r,r")
967                      (match_operand:SI 3 "arith11_operand" "rI,rI")])
968                  (match_operand:SI 1 "register_operand" "0,?r")))]
969   ""
970   "@
971    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi 1,%0,%0
972    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi,tr 1,%1,%0\;copy %1,%0"
973   [(set_attr "type" "binary,binary")
974    (set_attr "length" "8,12")])
975
976 (define_insn ""
977   [(set (match_operand:DI 0 "register_operand" "=r,r")
978         (plus:DI (match_operator:DI 4 "comparison_operator"
979                     [(match_operand:DI 2 "register_operand" "r,r")
980                      (match_operand:DI 3 "arith11_operand" "rI,rI")])
981                  (match_operand:DI 1 "register_operand" "0,?r")))]
982   "TARGET_64BIT"
983   "@
984    cmp%I3clr,*%B4 %3,%2,%%r0\;addi 1,%0,%0
985    cmp%I3clr,*%B4 %3,%2,%%r0\;addi,tr 1,%1,%0\;copy %1,%0"
986   [(set_attr "type" "binary,binary")
987    (set_attr "length" "8,12")])
988
989 (define_insn ""
990   [(set (match_operand:SI 0 "register_operand" "=r")
991         (minus:SI (match_operand:SI 1 "register_operand" "r")
992                   (gtu:SI (match_operand:SI 2 "register_operand" "r")
993                           (match_operand:SI 3 "arith11_operand" "rI"))))]
994   ""
995   "sub%I3 %3,%2,%%r0\;{subb|sub,b} %1,%%r0,%0"
996   [(set_attr "type" "binary")
997    (set_attr "length" "8")])
998
999 (define_insn ""
1000   [(set (match_operand:DI 0 "register_operand" "=r")
1001         (minus:DI (match_operand:DI 1 "register_operand" "r")
1002                   (gtu:DI (match_operand:DI 2 "register_operand" "r")
1003                           (match_operand:DI 3 "arith11_operand" "rI"))))]
1004   "TARGET_64BIT"
1005   "sub%I3 %3,%2,%%r0\;sub,db %1,%%r0,%0"
1006   [(set_attr "type" "binary")
1007    (set_attr "length" "8")])
1008
1009 (define_insn ""
1010   [(set (match_operand:SI 0 "register_operand" "=r")
1011         (minus:SI (minus:SI (match_operand:SI 1 "register_operand" "r")
1012                             (gtu:SI (match_operand:SI 2 "register_operand" "r")
1013                                     (match_operand:SI 3 "arith11_operand" "rI")))
1014                   (match_operand:SI 4 "register_operand" "r")))]
1015   ""
1016   "sub%I3 %3,%2,%%r0\;{subb|sub,b} %1,%4,%0"
1017   [(set_attr "type" "binary")
1018    (set_attr "length" "8")])
1019
1020 (define_insn ""
1021   [(set (match_operand:DI 0 "register_operand" "=r")
1022         (minus:DI (minus:DI (match_operand:DI 1 "register_operand" "r")
1023                             (gtu:DI (match_operand:DI 2 "register_operand" "r")
1024                                     (match_operand:DI 3 "arith11_operand" "rI")))
1025                   (match_operand:DI 4 "register_operand" "r")))]
1026   "TARGET_64BIT"
1027   "sub%I3 %3,%2,%%r0\;sub,db %1,%4,%0"
1028   [(set_attr "type" "binary")
1029    (set_attr "length" "8")])
1030
1031 ; This need only accept registers for op3, since canonicalization
1032 ; replaces ltu with leu when op3 is an integer.
1033 (define_insn ""
1034   [(set (match_operand:SI 0 "register_operand" "=r")
1035         (minus:SI (match_operand:SI 1 "register_operand" "r")
1036                   (ltu:SI (match_operand:SI 2 "register_operand" "r")
1037                           (match_operand:SI 3 "register_operand" "r"))))]
1038   ""
1039   "sub %2,%3,%%r0\;{subb|sub,b} %1,%%r0,%0"
1040   [(set_attr "type" "binary")
1041    (set_attr "length" "8")])
1042
1043 (define_insn ""
1044   [(set (match_operand:DI 0 "register_operand" "=r")
1045         (minus:DI (match_operand:DI 1 "register_operand" "r")
1046                   (ltu:DI (match_operand:DI 2 "register_operand" "r")
1047                           (match_operand:DI 3 "register_operand" "r"))))]
1048   "TARGET_64BIT"
1049   "sub %2,%3,%%r0\;sub,db %1,%%r0,%0"
1050   [(set_attr "type" "binary")
1051    (set_attr "length" "8")])
1052
1053 (define_insn ""
1054   [(set (match_operand:SI 0 "register_operand" "=r")
1055         (minus:SI (minus:SI (match_operand:SI 1 "register_operand" "r")
1056                             (ltu:SI (match_operand:SI 2 "register_operand" "r")
1057                                     (match_operand:SI 3 "register_operand" "r")))
1058                   (match_operand:SI 4 "register_operand" "r")))]
1059   ""
1060   "sub %2,%3,%%r0\;{subb|sub,b} %1,%4,%0"
1061   [(set_attr "type" "binary")
1062    (set_attr "length" "8")])
1063
1064 (define_insn ""
1065   [(set (match_operand:DI 0 "register_operand" "=r")
1066         (minus:DI (minus:DI (match_operand:DI 1 "register_operand" "r")
1067                             (ltu:DI (match_operand:DI 2 "register_operand" "r")
1068                                     (match_operand:DI 3 "register_operand" "r")))
1069                   (match_operand:DI 4 "register_operand" "r")))]
1070   "TARGET_64BIT"
1071   "sub %2,%3,%%r0\;sub,db %1,%4,%0"
1072   [(set_attr "type" "binary")
1073    (set_attr "length" "8")])
1074
1075 ; Match only integers for op3 here.  This is used as canonical form of the
1076 ; ltu pattern when op3 is an integer.  Don't match registers since we can't
1077 ; make better code than the general incscc pattern.
1078 (define_insn ""
1079   [(set (match_operand:SI 0 "register_operand" "=r")
1080         (minus:SI (match_operand:SI 1 "register_operand" "r")
1081                   (leu:SI (match_operand:SI 2 "register_operand" "r")
1082                           (match_operand:SI 3 "int11_operand" "I"))))]
1083   ""
1084   "addi %k3,%2,%%r0\;{subb|sub,b} %1,%%r0,%0"
1085   [(set_attr "type" "binary")
1086    (set_attr "length" "8")])
1087
1088 (define_insn ""
1089   [(set (match_operand:DI 0 "register_operand" "=r")
1090         (minus:DI (match_operand:DI 1 "register_operand" "r")
1091                   (leu:DI (match_operand:DI 2 "register_operand" "r")
1092                           (match_operand:DI 3 "int11_operand" "I"))))]
1093   "TARGET_64BIT"
1094   "addi %k3,%2,%%r0\;sub,db %1,%%r0,%0"
1095   [(set_attr "type" "binary")
1096    (set_attr "length" "8")])
1097
1098 (define_insn ""
1099   [(set (match_operand:SI 0 "register_operand" "=r")
1100         (minus:SI (minus:SI (match_operand:SI 1 "register_operand" "r")
1101                             (leu:SI (match_operand:SI 2 "register_operand" "r")
1102                                     (match_operand:SI 3 "int11_operand" "I")))
1103                   (match_operand:SI 4 "register_operand" "r")))]
1104   ""
1105   "addi %k3,%2,%%r0\;{subb|sub,b} %1,%4,%0"
1106   [(set_attr "type" "binary")
1107    (set_attr "length" "8")])
1108
1109 (define_insn ""
1110   [(set (match_operand:DI 0 "register_operand" "=r")
1111         (minus:DI (minus:DI (match_operand:DI 1 "register_operand" "r")
1112                             (leu:DI (match_operand:DI 2 "register_operand" "r")
1113                                     (match_operand:DI 3 "int11_operand" "I")))
1114                   (match_operand:DI 4 "register_operand" "r")))]
1115   "TARGET_64BIT"
1116   "addi %k3,%2,%%r0\;sub,db %1,%4,%0"
1117   [(set_attr "type" "binary")
1118    (set_attr "length" "8")])
1119
1120 (define_insn "decscc"
1121   [(set (match_operand:SI 0 "register_operand" "=r,r")
1122         (minus:SI (match_operand:SI 1 "register_operand" "0,?r")
1123                   (match_operator:SI 4 "comparison_operator"
1124                      [(match_operand:SI 2 "register_operand" "r,r")
1125                       (match_operand:SI 3 "arith11_operand" "rI,rI")])))]
1126   ""
1127   "@
1128    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi -1,%0,%0
1129    {com%I3clr|cmp%I3clr},%B4 %3,%2,%%r0\;addi,tr -1,%1,%0\;copy %1,%0"
1130   [(set_attr "type" "binary,binary")
1131    (set_attr "length" "8,12")])
1132
1133 (define_insn ""
1134   [(set (match_operand:DI 0 "register_operand" "=r,r")
1135         (minus:DI (match_operand:DI 1 "register_operand" "0,?r")
1136                   (match_operator:DI 4 "comparison_operator"
1137                      [(match_operand:DI 2 "register_operand" "r,r")
1138                       (match_operand:DI 3 "arith11_operand" "rI,rI")])))]
1139   "TARGET_64BIT"
1140   "@
1141    cmp%I3clr,*%B4 %3,%2,%%r0\;addi -1,%0,%0
1142    cmp%I3clr,*%B4 %3,%2,%%r0\;addi,tr -1,%1,%0\;copy %1,%0"
1143   [(set_attr "type" "binary,binary")
1144    (set_attr "length" "8,12")])
1145
1146 ; Patterns for max and min.  (There is no need for an earlyclobber in the
1147 ; last alternative since the middle alternative will match if op0 == op1.)
1148
1149 (define_insn "sminsi3"
1150   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1151         (smin:SI (match_operand:SI 1 "register_operand" "%0,0,r")
1152                  (match_operand:SI 2 "arith11_operand" "r,I,M")))]
1153   ""
1154   "@
1155   {comclr|cmpclr},> %2,%0,%%r0\;copy %2,%0
1156   {comiclr|cmpiclr},> %2,%0,%%r0\;ldi %2,%0
1157   {comclr|cmpclr},> %1,%r2,%0\;copy %1,%0"
1158 [(set_attr "type" "multi,multi,multi")
1159  (set_attr "length" "8,8,8")])
1160
1161 (define_insn "smindi3"
1162   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
1163         (smin:DI (match_operand:DI 1 "register_operand" "%0,0,r")
1164                  (match_operand:DI 2 "arith11_operand" "r,I,M")))]
1165   "TARGET_64BIT"
1166   "@
1167   cmpclr,*> %2,%0,%%r0\;copy %2,%0
1168   cmpiclr,*> %2,%0,%%r0\;ldi %2,%0
1169   cmpclr,*> %1,%r2,%0\;copy %1,%0"
1170 [(set_attr "type" "multi,multi,multi")
1171  (set_attr "length" "8,8,8")])
1172
1173 (define_insn "uminsi3"
1174   [(set (match_operand:SI 0 "register_operand" "=r,r")
1175         (umin:SI (match_operand:SI 1 "register_operand" "%0,0")
1176                  (match_operand:SI 2 "arith11_operand" "r,I")))]
1177   ""
1178   "@
1179   {comclr|cmpclr},>> %2,%0,%%r0\;copy %2,%0
1180   {comiclr|cmpiclr},>> %2,%0,%%r0\;ldi %2,%0"
1181 [(set_attr "type" "multi,multi")
1182  (set_attr "length" "8,8")])
1183
1184 (define_insn "umindi3"
1185   [(set (match_operand:DI 0 "register_operand" "=r,r")
1186         (umin:DI (match_operand:DI 1 "register_operand" "%0,0")
1187                  (match_operand:DI 2 "arith11_operand" "r,I")))]
1188   "TARGET_64BIT"
1189   "@
1190   cmpclr,*>> %2,%0,%%r0\;copy %2,%0
1191   cmpiclr,*>> %2,%0,%%r0\;ldi %2,%0"
1192 [(set_attr "type" "multi,multi")
1193  (set_attr "length" "8,8")])
1194
1195 (define_insn "smaxsi3"
1196   [(set (match_operand:SI 0 "register_operand" "=r,r,r")
1197         (smax:SI (match_operand:SI 1 "register_operand" "%0,0,r")
1198                  (match_operand:SI 2 "arith11_operand" "r,I,M")))]
1199   ""
1200   "@
1201   {comclr|cmpclr},< %2,%0,%%r0\;copy %2,%0
1202   {comiclr|cmpiclr},< %2,%0,%%r0\;ldi %2,%0
1203   {comclr|cmpclr},< %1,%r2,%0\;copy %1,%0"
1204 [(set_attr "type" "multi,multi,multi")
1205  (set_attr "length" "8,8,8")])
1206
1207 (define_insn "smaxdi3"
1208   [(set (match_operand:DI 0 "register_operand" "=r,r,r")
1209         (smax:DI (match_operand:DI 1 "register_operand" "%0,0,r")
1210                  (match_operand:DI 2 "arith11_operand" "r,I,M")))]
1211   "TARGET_64BIT"
1212   "@
1213   cmpclr,*< %2,%0,%%r0\;copy %2,%0
1214   cmpiclr,*< %2,%0,%%r0\;ldi %2,%0
1215   cmpclr,*< %1,%r2,%0\;copy %1,%0"
1216 [(set_attr "type" "multi,multi,multi")
1217  (set_attr "length" "8,8,8")])
1218
1219 (define_insn "umaxsi3"
1220   [(set (match_operand:SI 0 "register_operand" "=r,r")
1221         (umax:SI (match_operand:SI 1 "register_operand" "%0,0")
1222                  (match_operand:SI 2 "arith11_operand" "r,I")))]
1223   ""
1224   "@
1225   {comclr|cmpclr},<< %2,%0,%%r0\;copy %2,%0
1226   {comiclr|cmpiclr},<< %2,%0,%%r0\;ldi %2,%0"
1227 [(set_attr "type" "multi,multi")
1228  (set_attr "length" "8,8")])
1229
1230 (define_insn "umaxdi3"
1231   [(set (match_operand:DI 0 "register_operand" "=r,r")
1232         (umax:DI (match_operand:DI 1 "register_operand" "%0,0")
1233                  (match_operand:DI 2 "arith11_operand" "r,I")))]
1234   "TARGET_64BIT"
1235   "@
1236   cmpclr,*<< %2,%0,%%r0\;copy %2,%0
1237   cmpiclr,*<< %2,%0,%%r0\;ldi %2,%0"
1238 [(set_attr "type" "multi,multi")
1239  (set_attr "length" "8,8")])
1240
1241 (define_insn "abssi2"
1242   [(set (match_operand:SI 0 "register_operand" "=r")
1243         (abs:SI (match_operand:SI 1 "register_operand" "r")))]
1244   ""
1245   "or,>= %%r0,%1,%0\;subi 0,%0,%0"
1246   [(set_attr "type" "multi")
1247    (set_attr "length" "8")])
1248
1249 (define_insn "absdi2"
1250   [(set (match_operand:DI 0 "register_operand" "=r")
1251         (abs:DI (match_operand:DI 1 "register_operand" "r")))]
1252   "TARGET_64BIT"
1253   "or,*>= %%r0,%1,%0\;subi 0,%0,%0"
1254   [(set_attr "type" "multi")
1255    (set_attr "length" "8")])
1256
1257 ;;; Experimental conditional move patterns
1258
1259 (define_expand "movsicc"
1260   [(set (match_operand:SI 0 "register_operand" "")
1261         (if_then_else:SI
1262          (match_operator 1 "comparison_operator"
1263             [(match_dup 4)
1264              (match_dup 5)])
1265          (match_operand:SI 2 "reg_or_cint_move_operand" "")
1266          (match_operand:SI 3 "reg_or_cint_move_operand" "")))]
1267   ""
1268   "
1269 {
1270   enum rtx_code code = GET_CODE (operands[1]);
1271
1272   if (hppa_branch_type != CMP_SI)
1273     FAIL;
1274
1275   if (GET_MODE (hppa_compare_op0) != GET_MODE (hppa_compare_op1)
1276       || GET_MODE (hppa_compare_op0) != GET_MODE (operands[0]))
1277     FAIL;
1278
1279   /* operands[1] is currently the result of compare_from_rtx.  We want to
1280      emit a compare of the original operands.  */
1281   operands[1] = gen_rtx_fmt_ee (code, SImode, hppa_compare_op0, hppa_compare_op1);
1282   operands[4] = hppa_compare_op0;
1283   operands[5] = hppa_compare_op1;
1284 }")
1285
1286 ;; We used to accept any register for op1.
1287 ;;
1288 ;; However, it loses sometimes because the compiler will end up using
1289 ;; different registers for op0 and op1 in some critical cases.  local-alloc
1290 ;; will  not tie op0 and op1 because op0 is used in multiple basic blocks.
1291 ;;
1292 ;; If/when global register allocation supports tying we should allow any
1293 ;; register for op1 again.
1294 (define_insn ""
1295   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r")
1296         (if_then_else:SI
1297          (match_operator 2 "comparison_operator"
1298             [(match_operand:SI 3 "register_operand" "r,r,r,r")
1299              (match_operand:SI 4 "arith11_operand" "rI,rI,rI,rI")])
1300          (match_operand:SI 1 "reg_or_cint_move_operand" "0,J,N,K")
1301          (const_int 0)))]
1302   ""
1303   "@
1304    {com%I4clr|cmp%I4clr},%S2 %4,%3,%%r0\;ldi 0,%0
1305    {com%I4clr|cmp%I4clr},%B2 %4,%3,%0\;ldi %1,%0
1306    {com%I4clr|cmp%I4clr},%B2 %4,%3,%0\;ldil L'%1,%0
1307    {com%I4clr|cmp%I4clr},%B2 %4,%3,%0\;{zdepi|depwi,z} %Z1,%0"
1308   [(set_attr "type" "multi,multi,multi,nullshift")
1309    (set_attr "length" "8,8,8,8")])
1310
1311 (define_insn ""
1312   [(set (match_operand:SI 0 "register_operand" "=r,r,r,r,r,r,r,r")
1313         (if_then_else:SI
1314          (match_operator 5 "comparison_operator"
1315             [(match_operand:SI 3 "register_operand" "r,r,r,r,r,r,r,r")
1316              (match_operand:SI 4 "arith11_operand" "rI,rI,rI,rI,rI,rI,rI,rI")])
1317          (match_operand:SI 1 "reg_or_cint_move_operand" "0,0,0,0,r,J,N,K")
1318          (match_operand:SI 2 "reg_or_cint_move_operand" "r,J,N,K,0,0,0,0")))]
1319   ""
1320   "@
1321    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;copy %2,%0
1322    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;ldi %2,%0
1323    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;ldil L'%2,%0
1324    {com%I4clr|cmp%I4clr},%S5 %4,%3,%%r0\;{zdepi|depwi,z} %Z2,%0
1325    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;copy %1,%0
1326    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;ldi %1,%0
1327    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;ldil L'%1,%0
1328    {com%I4clr|cmp%I4clr},%B5 %4,%3,%%r0\;{zdepi|depwi,z} %Z1,%0"
1329   [(set_attr "type" "multi,multi,multi,nullshift,multi,multi,multi,nullshift")
1330    (set_attr "length" "8,8,8,8,8,8,8,8")])
1331
1332 (define_expand "movdicc"
1333   [(set (match_operand:DI 0 "register_operand" "")
1334         (if_then_else:DI
1335          (match_operator 1 "comparison_operator"
1336             [(match_dup 4)
1337              (match_dup 5)])
1338          (match_operand:DI 2 "reg_or_cint_move_operand" "")
1339          (match_operand:DI 3 "reg_or_cint_move_operand" "")))]
1340   "TARGET_64BIT"
1341   "
1342 {
1343   enum rtx_code code = GET_CODE (operands[1]);
1344
1345   if (hppa_branch_type != CMP_SI)
1346     FAIL;
1347
1348   if (GET_MODE (hppa_compare_op0) != GET_MODE (hppa_compare_op1)
1349       || GET_MODE (hppa_compare_op0) != GET_MODE (operands[0]))
1350     FAIL;
1351
1352   /* operands[1] is currently the result of compare_from_rtx.  We want to
1353      emit a compare of the original operands.  */
1354   operands[1] = gen_rtx_fmt_ee (code, DImode, hppa_compare_op0, hppa_compare_op1);
1355   operands[4] = hppa_compare_op0;
1356   operands[5] = hppa_compare_op1;
1357 }")
1358
1359 ; We need the first constraint alternative in order to avoid
1360 ; earlyclobbers on all other alternatives.
1361 (define_insn ""
1362   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r,r")
1363         (if_then_else:DI
1364          (match_operator 2 "comparison_operator"
1365             [(match_operand:DI 3 "register_operand" "r,r,r,r,r")
1366              (match_operand:DI 4 "arith11_operand" "rI,rI,rI,rI,rI")])
1367          (match_operand:DI 1 "reg_or_cint_move_operand" "0,r,J,N,K")
1368          (const_int 0)))]
1369   "TARGET_64BIT"
1370   "@
1371    cmp%I4clr,*%S2 %4,%3,%%r0\;ldi 0,%0
1372    cmp%I4clr,*%B2 %4,%3,%0\;copy %1,%0
1373    cmp%I4clr,*%B2 %4,%3,%0\;ldi %1,%0
1374    cmp%I4clr,*%B2 %4,%3,%0\;ldil L'%1,%0
1375    cmp%I4clr,*%B2 %4,%3,%0\;depdi,z %z1,%0"
1376   [(set_attr "type" "multi,multi,multi,multi,nullshift")
1377    (set_attr "length" "8,8,8,8,8")])
1378
1379 (define_insn ""
1380   [(set (match_operand:DI 0 "register_operand" "=r,r,r,r,r,r,r,r")
1381         (if_then_else:DI
1382          (match_operator 5 "comparison_operator"
1383             [(match_operand:DI 3 "register_operand" "r,r,r,r,r,r,r,r")
1384              (match_operand:DI 4 "arith11_operand" "rI,rI,rI,rI,rI,rI,rI,rI")])
1385          (match_operand:DI 1 "reg_or_cint_move_operand" "0,0,0,0,r,J,N,K")
1386          (match_operand:DI 2 "reg_or_cint_move_operand" "r,J,N,K,0,0,0,0")))]
1387   "TARGET_64BIT"
1388   "@
1389    cmp%I4clr,*%S5 %4,%3,%%r0\;copy %2,%0
1390    cmp%I4clr,*%S5 %4,%3,%%r0\;ldi %2,%0
1391    cmp%I4clr,*%S5 %4,%3,%%r0\;ldil L'%2,%0
1392    cmp%I4clr,*%S5 %4,%3,%%r0\;depdi,z %z2,%0
1393    cmp%I4clr,*%B5 %4,%3,%%r0\;copy %1,%0
1394    cmp%I4clr,*%B5 %4,%3,%%r0\;ldi %1,%0
1395    cmp%I4clr,*%B5 %4,%3,%%r0\;ldil L'%1,%0
1396    cmp%I4clr,*%B5 %4,%3,%%r0\;depdi,z %z1,%0"
1397   [(set_attr "type" "multi,multi,multi,nullshift,multi,multi,multi,nullshift")
1398    (set_attr "length" "8,8,8,8,8,8,8,8")])
1399
1400 ;; Conditional Branches
1401
1402 (define_expand "beq"
1403   [(set (pc)
1404         (if_then_else (eq (match_dup 1) (match_dup 2))
1405                       (label_ref (match_operand 0 "" ""))
1406                       (pc)))]
1407   ""
1408   "
1409 {
1410   if (hppa_branch_type != CMP_SI)
1411     {
1412       emit_insn (gen_cmp_fp (EQ, hppa_compare_op0, hppa_compare_op1));
1413       emit_bcond_fp (NE, operands[0]);
1414       DONE;
1415     }
1416   /* set up operands from compare.  */
1417   operands[1] = hppa_compare_op0;
1418   operands[2] = hppa_compare_op1;
1419   /* fall through and generate default code */
1420 }")
1421
1422 (define_expand "bne"
1423   [(set (pc)
1424         (if_then_else (ne (match_dup 1) (match_dup 2))
1425                       (label_ref (match_operand 0 "" ""))
1426                       (pc)))]
1427   ""
1428   "
1429 {
1430   if (hppa_branch_type != CMP_SI)
1431     {
1432       emit_insn (gen_cmp_fp (NE, hppa_compare_op0, hppa_compare_op1));
1433       emit_bcond_fp (NE, operands[0]);
1434       DONE;
1435     }
1436   operands[1] = hppa_compare_op0;
1437   operands[2] = hppa_compare_op1;
1438 }")
1439
1440 (define_expand "bgt"
1441   [(set (pc)
1442         (if_then_else (gt (match_dup 1) (match_dup 2))
1443                       (label_ref (match_operand 0 "" ""))
1444                       (pc)))]
1445   ""
1446   "
1447 {
1448   if (hppa_branch_type != CMP_SI)
1449     {
1450       emit_insn (gen_cmp_fp (GT, hppa_compare_op0, hppa_compare_op1));
1451       emit_bcond_fp (NE, operands[0]);
1452       DONE;
1453     }
1454   operands[1] = hppa_compare_op0;
1455   operands[2] = hppa_compare_op1;
1456 }")
1457
1458 (define_expand "blt"
1459   [(set (pc)
1460         (if_then_else (lt (match_dup 1) (match_dup 2))
1461                       (label_ref (match_operand 0 "" ""))
1462                       (pc)))]
1463   ""
1464   "
1465 {
1466   if (hppa_branch_type != CMP_SI)
1467     {
1468       emit_insn (gen_cmp_fp (LT, hppa_compare_op0, hppa_compare_op1));
1469       emit_bcond_fp (NE, operands[0]);
1470       DONE;
1471     }
1472   operands[1] = hppa_compare_op0;
1473   operands[2] = hppa_compare_op1;
1474 }")
1475
1476 (define_expand "bge"
1477   [(set (pc)
1478         (if_then_else (ge (match_dup 1) (match_dup 2))
1479                       (label_ref (match_operand 0 "" ""))
1480                       (pc)))]
1481   ""
1482   "
1483 {
1484   if (hppa_branch_type != CMP_SI)
1485     {
1486       emit_insn (gen_cmp_fp (GE, hppa_compare_op0, hppa_compare_op1));
1487       emit_bcond_fp (NE, operands[0]);
1488       DONE;
1489     }
1490   operands[1] = hppa_compare_op0;
1491   operands[2] = hppa_compare_op1;
1492 }")
1493
1494 (define_expand "ble"
1495   [(set (pc)
1496         (if_then_else (le (match_dup 1) (match_dup 2))
1497                       (label_ref (match_operand 0 "" ""))
1498                       (pc)))]
1499   ""
1500   "
1501 {
1502   if (hppa_branch_type != CMP_SI)
1503     {
1504       emit_insn (gen_cmp_fp (LE, hppa_compare_op0, hppa_compare_op1));
1505       emit_bcond_fp (NE, operands[0]);
1506       DONE;
1507     }
1508   operands[1] = hppa_compare_op0;
1509   operands[2] = hppa_compare_op1;
1510 }")
1511
1512 (define_expand "bgtu"
1513   [(set (pc)
1514         (if_then_else (gtu (match_dup 1) (match_dup 2))
1515                       (label_ref (match_operand 0 "" ""))
1516                       (pc)))]
1517   ""
1518   "
1519 {
1520   if (hppa_branch_type != CMP_SI)
1521     FAIL;
1522   operands[1] = hppa_compare_op0;
1523   operands[2] = hppa_compare_op1;
1524 }")
1525
1526 (define_expand "bltu"
1527   [(set (pc)
1528         (if_then_else (ltu (match_dup 1) (match_dup 2))
1529                       (label_ref (match_operand 0 "" ""))
1530                       (pc)))]
1531   ""
1532   "
1533 {
1534   if (hppa_branch_type != CMP_SI)
1535     FAIL;
1536   operands[1] = hppa_compare_op0;
1537   operands[2] = hppa_compare_op1;
1538 }")
1539
1540 (define_expand "bgeu"
1541   [(set (pc)
1542         (if_then_else (geu (match_dup 1) (match_dup 2))
1543                       (label_ref (match_operand 0 "" ""))
1544                       (pc)))]
1545   ""
1546   "
1547 {
1548   if (hppa_branch_type != CMP_SI)
1549     FAIL;
1550   operands[1] = hppa_compare_op0;
1551   operands[2] = hppa_compare_op1;
1552 }")
1553
1554 (define_expand "bleu"
1555   [(set (pc)
1556         (if_then_else (leu (match_dup 1) (match_dup 2))
1557                       (label_ref (match_operand 0 "" ""))
1558                       (pc)))]
1559   ""
1560   "
1561 {
1562   if (hppa_branch_type != CMP_SI)
1563     FAIL;
1564   operands[1] = hppa_compare_op0;
1565   operands[2] = hppa_compare_op1;
1566 }")
1567
1568 (define_expand "bltgt"
1569   [(set (pc)
1570         (if_then_else (ltgt (match_dup 1) (match_dup 2))
1571                       (label_ref (match_operand 0 "" ""))
1572                       (pc)))]
1573   ""
1574   "
1575 {
1576   if (hppa_branch_type == CMP_SI)
1577     FAIL;
1578   emit_insn (gen_cmp_fp (LTGT, hppa_compare_op0, hppa_compare_op1));
1579   emit_bcond_fp (NE, operands[0]);
1580   DONE;
1581 }")
1582
1583 (define_expand "bunle"
1584   [(set (pc)
1585         (if_then_else (unle (match_dup 1) (match_dup 2))
1586                       (label_ref (match_operand 0 "" ""))
1587                       (pc)))]
1588   ""
1589   "
1590 {
1591   if (hppa_branch_type == CMP_SI)
1592     FAIL;
1593   emit_insn (gen_cmp_fp (UNLE, hppa_compare_op0, hppa_compare_op1));
1594   emit_bcond_fp (NE, operands[0]);
1595   DONE;
1596 }")
1597
1598 (define_expand "bunlt"
1599   [(set (pc)
1600         (if_then_else (unlt (match_dup 1) (match_dup 2))
1601                       (label_ref (match_operand 0 "" ""))
1602                       (pc)))]
1603   ""
1604   "
1605 {
1606   if (hppa_branch_type == CMP_SI)
1607     FAIL;
1608   emit_insn (gen_cmp_fp (UNLT, hppa_compare_op0, hppa_compare_op1));
1609   emit_bcond_fp (NE, operands[0]);
1610   DONE;
1611 }")
1612
1613 (define_expand "bunge"
1614   [(set (pc)
1615         (if_then_else (unge (match_dup 1) (match_dup 2))
1616                       (label_ref (match_operand 0 "" ""))
1617                       (pc)))]
1618   ""
1619   "
1620 {
1621   if (hppa_branch_type == CMP_SI)
1622     FAIL;
1623   emit_insn (gen_cmp_fp (UNGE, hppa_compare_op0, hppa_compare_op1));
1624   emit_bcond_fp (NE, operands[0]);
1625   DONE;
1626 }")
1627
1628 (define_expand "bungt"
1629   [(set (pc)
1630         (if_then_else (ungt (match_dup 1) (match_dup 2))
1631                       (label_ref (match_operand 0 "" ""))
1632                       (pc)))]
1633   ""
1634   "
1635 {
1636   if (hppa_branch_type == CMP_SI)
1637     FAIL;
1638   emit_insn (gen_cmp_fp (UNGT, hppa_compare_op0, hppa_compare_op1));
1639   emit_bcond_fp (NE, operands[0]);
1640   DONE;
1641 }")
1642
1643 (define_expand "buneq"
1644   [(set (pc)
1645         (if_then_else (uneq (match_dup 1) (match_dup 2))
1646                       (label_ref (match_operand 0 "" ""))
1647                       (pc)))]
1648   ""
1649   "
1650 {
1651   if (hppa_branch_type == CMP_SI)
1652     FAIL;
1653   emit_insn (gen_cmp_fp (UNEQ, hppa_compare_op0, hppa_compare_op1));
1654   emit_bcond_fp (NE, operands[0]);
1655   DONE;
1656 }")
1657
1658 (define_expand "bunordered"
1659   [(set (pc)
1660         (if_then_else (unordered (match_dup 1) (match_dup 2))
1661                       (label_ref (match_operand 0 "" ""))
1662                       (pc)))]
1663   ""
1664   "
1665 {
1666   if (hppa_branch_type == CMP_SI)
1667     FAIL;
1668   emit_insn (gen_cmp_fp (UNORDERED, hppa_compare_op0, hppa_compare_op1));
1669   emit_bcond_fp (NE, operands[0]);
1670   DONE;
1671 }")
1672
1673 (define_expand "bordered"
1674   [(set (pc)
1675         (if_then_else (ordered (match_dup 1) (match_dup 2))
1676                       (label_ref (match_operand 0 "" ""))
1677                       (pc)))]
1678   ""
1679   "
1680 {
1681   if (hppa_branch_type == CMP_SI)
1682     FAIL;
1683   emit_insn (gen_cmp_fp (ORDERED, hppa_compare_op0, hppa_compare_op1));
1684   emit_bcond_fp (NE, operands[0]);
1685   DONE;
1686 }")
1687
1688 ;; Match the branch patterns.
1689
1690
1691 ;; Note a long backward conditional branch with an annulled delay slot
1692 ;; has a length of 12.
1693 (define_insn ""
1694   [(set (pc)
1695         (if_then_else
1696          (match_operator 3 "comparison_operator"
1697                          [(match_operand:SI 1 "reg_or_0_operand" "rM")
1698                           (match_operand:SI 2 "arith5_operand" "rL")])
1699          (label_ref (match_operand 0 "" ""))
1700          (pc)))]
1701   ""
1702   "*
1703 {
1704   return output_cbranch (operands, INSN_ANNULLED_BRANCH_P (insn),
1705                          get_attr_length (insn), 0, insn);
1706 }"
1707 [(set_attr "type" "cbranch")
1708  (set (attr "length")
1709     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1710                (const_int 8184))
1711            (const_int 4)
1712            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1713                (const_int 262100))
1714            (const_int 8)
1715            (eq (symbol_ref "flag_pic") (const_int 0))
1716            (const_int 20)]
1717           (const_int 28)))])
1718
1719 ;; Match the negated branch.
1720
1721 (define_insn ""
1722   [(set (pc)
1723         (if_then_else
1724          (match_operator 3 "comparison_operator"
1725                          [(match_operand:SI 1 "reg_or_0_operand" "rM")
1726                           (match_operand:SI 2 "arith5_operand" "rL")])
1727          (pc)
1728          (label_ref (match_operand 0 "" ""))))]
1729   ""
1730   "*
1731 {
1732   return output_cbranch (operands, INSN_ANNULLED_BRANCH_P (insn),
1733                          get_attr_length (insn), 1, insn);
1734 }"
1735 [(set_attr "type" "cbranch")
1736  (set (attr "length")
1737     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1738                (const_int 8184))
1739            (const_int 4)
1740            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1741                (const_int 262100))
1742            (const_int 8)
1743            (eq (symbol_ref "flag_pic") (const_int 0))
1744            (const_int 20)]
1745           (const_int 28)))])
1746
1747 (define_insn ""
1748   [(set (pc)
1749         (if_then_else
1750          (match_operator 3 "comparison_operator"
1751                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1752                           (match_operand:DI 2 "reg_or_0_operand" "rM")])
1753          (label_ref (match_operand 0 "" ""))
1754          (pc)))]
1755   "TARGET_64BIT"
1756   "*
1757 {
1758   return output_cbranch (operands, INSN_ANNULLED_BRANCH_P (insn),
1759                          get_attr_length (insn), 0, insn);
1760 }"
1761 [(set_attr "type" "cbranch")
1762  (set (attr "length")
1763     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1764                (const_int 8184))
1765            (const_int 4)
1766            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1767                (const_int 262100))
1768            (const_int 8)
1769            (eq (symbol_ref "flag_pic") (const_int 0))
1770            (const_int 20)]
1771           (const_int 28)))])
1772
1773 ;; Match the negated branch.
1774
1775 (define_insn ""
1776   [(set (pc)
1777         (if_then_else
1778          (match_operator 3 "comparison_operator"
1779                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1780                           (match_operand:DI 2 "reg_or_0_operand" "rM")])
1781          (pc)
1782          (label_ref (match_operand 0 "" ""))))]
1783   "TARGET_64BIT"
1784   "*
1785 {
1786   return output_cbranch (operands, INSN_ANNULLED_BRANCH_P (insn),
1787                          get_attr_length (insn), 1, insn);
1788 }"
1789 [(set_attr "type" "cbranch")
1790  (set (attr "length")
1791     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1792                (const_int 8184))
1793            (const_int 4)
1794            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1795                (const_int 262100))
1796            (const_int 8)
1797            (eq (symbol_ref "flag_pic") (const_int 0))
1798            (const_int 20)]
1799           (const_int 28)))])
1800 (define_insn ""
1801   [(set (pc)
1802         (if_then_else
1803          (match_operator 3 "cmpib_comparison_operator"
1804                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1805                           (match_operand:DI 2 "arith5_operand" "rL")])
1806          (label_ref (match_operand 0 "" ""))
1807          (pc)))]
1808   "TARGET_64BIT"
1809   "*
1810 {
1811   return output_cbranch (operands, INSN_ANNULLED_BRANCH_P (insn),
1812                          get_attr_length (insn), 0, insn);
1813 }"
1814 [(set_attr "type" "cbranch")
1815  (set (attr "length")
1816     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1817                (const_int 8184))
1818            (const_int 4)
1819            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1820                (const_int 262100))
1821            (const_int 8)
1822            (eq (symbol_ref "flag_pic") (const_int 0))
1823            (const_int 20)]
1824           (const_int 28)))])
1825
1826 ;; Match the negated branch.
1827
1828 (define_insn ""
1829   [(set (pc)
1830         (if_then_else
1831          (match_operator 3 "cmpib_comparison_operator"
1832                          [(match_operand:DI 1 "reg_or_0_operand" "rM")
1833                           (match_operand:DI 2 "arith5_operand" "rL")])
1834          (pc)
1835          (label_ref (match_operand 0 "" ""))))]
1836   "TARGET_64BIT"
1837   "*
1838 {
1839   return output_cbranch (operands, INSN_ANNULLED_BRANCH_P (insn),
1840                          get_attr_length (insn), 1, insn);
1841 }"
1842 [(set_attr "type" "cbranch")
1843  (set (attr "length")
1844     (cond [(lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1845                (const_int 8184))
1846            (const_int 4)
1847            (lt (abs (minus (match_dup 0) (plus (pc) (const_int 8))))
1848                (const_int 262100))
1849            (const_int 8)
1850            (eq (symbol_ref "flag_pic") (const_int 0))
1851            (const_int 20)]
1852           (const_int 28)))])
1853
1854 ;; Branch on Bit patterns.
1855 (define_insn ""
1856   [(set (pc)
1857         (if_then_else
1858          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
1859                               (const_int 1)
1860                               (match_operand:SI 1 "uint5_operand" ""))
1861              (const_int 0))
1862          (label_ref (match_operand 2 "" ""))
1863          (pc)))]
1864   ""
1865   "*
1866 {
1867   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
1868                          get_attr_length (insn), 0, insn, 0);
1869 }"
1870 [(set_attr "type" "cbranch")
1871  (set (attr "length")
1872     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1873                       (const_int 8184))
1874            (const_int 4)
1875            (const_int 8)))])
1876
1877 (define_insn ""
1878   [(set (pc)
1879         (if_then_else
1880          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
1881                               (const_int 1)
1882                               (match_operand:DI 1 "uint32_operand" ""))
1883              (const_int 0))
1884          (label_ref (match_operand 2 "" ""))
1885          (pc)))]
1886   "TARGET_64BIT"
1887   "*
1888 {
1889   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
1890                          get_attr_length (insn), 0, insn, 0);
1891 }"
1892 [(set_attr "type" "cbranch")
1893  (set (attr "length")
1894     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1895                       (const_int 8184))
1896            (const_int 4)
1897            (const_int 8)))])
1898
1899 (define_insn ""
1900   [(set (pc)
1901         (if_then_else
1902          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
1903                               (const_int 1)
1904                               (match_operand:SI 1 "uint5_operand" ""))
1905              (const_int 0))
1906          (pc)
1907          (label_ref (match_operand 2 "" ""))))]
1908   ""
1909   "*
1910 {
1911   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
1912                          get_attr_length (insn), 1, insn, 0);
1913 }"
1914 [(set_attr "type" "cbranch")
1915  (set (attr "length")
1916     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1917                       (const_int 8184))
1918            (const_int 4)
1919            (const_int 8)))])
1920
1921 (define_insn ""
1922   [(set (pc)
1923         (if_then_else
1924          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
1925                               (const_int 1)
1926                               (match_operand:DI 1 "uint32_operand" ""))
1927              (const_int 0))
1928          (pc)
1929          (label_ref (match_operand 2 "" ""))))]
1930   "TARGET_64BIT"
1931   "*
1932 {
1933   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
1934                          get_attr_length (insn), 1, insn, 0);
1935 }"
1936 [(set_attr "type" "cbranch")
1937  (set (attr "length")
1938     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1939                       (const_int 8184))
1940            (const_int 4)
1941            (const_int 8)))])
1942
1943 (define_insn ""
1944   [(set (pc)
1945         (if_then_else
1946          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
1947                               (const_int 1)
1948                               (match_operand:SI 1 "uint5_operand" ""))
1949              (const_int 0))
1950          (label_ref (match_operand 2 "" ""))
1951          (pc)))]
1952   ""
1953   "*
1954 {
1955   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
1956                          get_attr_length (insn), 0, insn, 1);
1957 }"
1958 [(set_attr "type" "cbranch")
1959  (set (attr "length")
1960     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1961                       (const_int 8184))
1962            (const_int 4)
1963            (const_int 8)))])
1964
1965 (define_insn ""
1966   [(set (pc)
1967         (if_then_else
1968          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
1969                               (const_int 1)
1970                               (match_operand:DI 1 "uint32_operand" ""))
1971              (const_int 0))
1972          (label_ref (match_operand 2 "" ""))
1973          (pc)))]
1974   "TARGET_64BIT"
1975   "*
1976 {
1977   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
1978                          get_attr_length (insn), 0, insn, 1);
1979 }"
1980 [(set_attr "type" "cbranch")
1981  (set (attr "length")
1982     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
1983                       (const_int 8184))
1984            (const_int 4)
1985            (const_int 8)))])
1986
1987 (define_insn ""
1988   [(set (pc)
1989         (if_then_else
1990          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
1991                               (const_int 1)
1992                               (match_operand:SI 1 "uint5_operand" ""))
1993              (const_int 0))
1994          (pc)
1995          (label_ref (match_operand 2 "" ""))))]
1996   ""
1997   "*
1998 {
1999   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
2000                          get_attr_length (insn), 1, insn, 1);
2001 }"
2002 [(set_attr "type" "cbranch")
2003  (set (attr "length")
2004     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2005                       (const_int 8184))
2006            (const_int 4)
2007            (const_int 8)))])
2008
2009 (define_insn ""
2010   [(set (pc)
2011         (if_then_else
2012          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2013                               (const_int 1)
2014                               (match_operand:DI 1 "uint32_operand" ""))
2015              (const_int 0))
2016          (pc)
2017          (label_ref (match_operand 2 "" ""))))]
2018   "TARGET_64BIT"
2019   "*
2020 {
2021   return output_bb (operands, INSN_ANNULLED_BRANCH_P (insn),
2022                          get_attr_length (insn), 1, insn, 1);
2023 }"
2024 [(set_attr "type" "cbranch")
2025  (set (attr "length")
2026     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2027                       (const_int 8184))
2028            (const_int 4)
2029            (const_int 8)))])
2030
2031 ;; Branch on Variable Bit patterns.
2032 (define_insn ""
2033   [(set (pc)
2034         (if_then_else
2035          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2036                               (const_int 1)
2037                               (match_operand:SI 1 "register_operand" "q"))
2038              (const_int 0))
2039          (label_ref (match_operand 2 "" ""))
2040          (pc)))]
2041   ""
2042   "*
2043 {
2044   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2045                      get_attr_length (insn), 0, insn, 0);
2046 }"
2047 [(set_attr "type" "cbranch")
2048  (set (attr "length")
2049     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2050                       (const_int 8184))
2051            (const_int 4)
2052            (const_int 8)))])
2053
2054 (define_insn ""
2055   [(set (pc)
2056         (if_then_else
2057          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2058                               (const_int 1)
2059                               (match_operand:DI 1 "register_operand" "q"))
2060              (const_int 0))
2061          (label_ref (match_operand 2 "" ""))
2062          (pc)))]
2063   "TARGET_64BIT"
2064   "*
2065 {
2066   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2067                      get_attr_length (insn), 0, insn, 0);
2068 }"
2069 [(set_attr "type" "cbranch")
2070  (set (attr "length")
2071     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2072                       (const_int 8184))
2073            (const_int 4)
2074            (const_int 8)))])
2075
2076 (define_insn ""
2077   [(set (pc)
2078         (if_then_else
2079          (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2080                               (const_int 1)
2081                               (match_operand:SI 1 "register_operand" "q"))
2082              (const_int 0))
2083          (pc)
2084          (label_ref (match_operand 2 "" ""))))]
2085   ""
2086   "*
2087 {
2088   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2089                      get_attr_length (insn), 1, insn, 0);
2090 }"
2091 [(set_attr "type" "cbranch")
2092  (set (attr "length")
2093     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2094                       (const_int 8184))
2095            (const_int 4)
2096            (const_int 8)))])
2097
2098 (define_insn ""
2099   [(set (pc)
2100         (if_then_else
2101          (ne (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2102                               (const_int 1)
2103                               (match_operand:DI 1 "register_operand" "q"))
2104              (const_int 0))
2105          (pc)
2106          (label_ref (match_operand 2 "" ""))))]
2107   "TARGET_64BIT"
2108   "*
2109 {
2110   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2111                      get_attr_length (insn), 1, insn, 0);
2112 }"
2113 [(set_attr "type" "cbranch")
2114  (set (attr "length")
2115     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2116                       (const_int 8184))
2117            (const_int 4)
2118            (const_int 8)))])
2119
2120 (define_insn ""
2121   [(set (pc)
2122         (if_then_else
2123          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2124                               (const_int 1)
2125                               (match_operand:SI 1 "register_operand" "q"))
2126              (const_int 0))
2127          (label_ref (match_operand 2 "" ""))
2128          (pc)))]
2129   ""
2130   "*
2131 {
2132   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2133                      get_attr_length (insn), 0, insn, 1);
2134 }"
2135 [(set_attr "type" "cbranch")
2136  (set (attr "length")
2137     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2138                       (const_int 8184))
2139            (const_int 4)
2140            (const_int 8)))])
2141
2142 (define_insn ""
2143   [(set (pc)
2144         (if_then_else
2145          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2146                               (const_int 1)
2147                               (match_operand:DI 1 "register_operand" "q"))
2148              (const_int 0))
2149          (label_ref (match_operand 2 "" ""))
2150          (pc)))]
2151   "TARGET_64BIT"
2152   "*
2153 {
2154   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2155                      get_attr_length (insn), 0, insn, 1);
2156 }"
2157 [(set_attr "type" "cbranch")
2158  (set (attr "length")
2159     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2160                       (const_int 8184))
2161            (const_int 4)
2162            (const_int 8)))])
2163
2164 (define_insn ""
2165   [(set (pc)
2166         (if_then_else
2167          (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r")
2168                               (const_int 1)
2169                               (match_operand:SI 1 "register_operand" "q"))
2170              (const_int 0))
2171          (pc)
2172          (label_ref (match_operand 2 "" ""))))]
2173   ""
2174   "*
2175 {
2176   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2177                      get_attr_length (insn), 1, insn, 1);
2178 }"
2179 [(set_attr "type" "cbranch")
2180  (set (attr "length")
2181     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2182                       (const_int 8184))
2183            (const_int 4)
2184            (const_int 8)))])
2185
2186 (define_insn ""
2187   [(set (pc)
2188         (if_then_else
2189          (eq (zero_extract:DI (match_operand:DI 0 "register_operand" "r")
2190                               (const_int 1)
2191                               (match_operand:DI 1 "register_operand" "q"))
2192              (const_int 0))
2193          (pc)
2194          (label_ref (match_operand 2 "" ""))))]
2195   "TARGET_64BIT"
2196   "*
2197 {
2198   return output_bvb (operands, INSN_ANNULLED_BRANCH_P (insn),
2199                      get_attr_length (insn), 1, insn, 1);
2200 }"
2201 [(set_attr "type" "cbranch")
2202  (set (attr "length")
2203     (if_then_else (lt (abs (minus (match_dup 2) (plus (pc) (const_int 8))))
2204                       (const_int 8184))
2205            (const_int 4)
2206            (const_int 8)))])
2207
2208 ;; Floating point branches
2209 (define_insn ""
2210   [(set (pc) (if_then_else (ne (reg:CCFP 0) (const_int 0))
2211                            (label_ref (match_operand 0 "" ""))
2212                            (pc)))]
2213   "! TARGET_SOFT_FLOAT"
2214   "*
2215 {
2216   if (INSN_ANNULLED_BRANCH_P (insn))
2217     return \"ftest\;b,n %0\";
2218   else
2219     return \"ftest\;b%* %0\";
2220 }"
2221   [(set_attr "type" "fbranch")
2222    (set_attr "length" "8")])
2223
2224 (define_insn ""
2225   [(set (pc) (if_then_else (ne (reg:CCFP 0) (const_int 0))
2226                            (pc)
2227                            (label_ref (match_operand 0 "" ""))))]
2228   "! TARGET_SOFT_FLOAT"
2229   "*
2230 {
2231   if (INSN_ANNULLED_BRANCH_P (insn))
2232     return \"ftest\;add,tr %%r0,%%r0,%%r0\;b,n %0\";
2233   else
2234     return \"ftest\;add,tr %%r0,%%r0,%%r0\;b%* %0\";
2235 }"
2236   [(set_attr "type" "fbranch")
2237    (set_attr "length" "12")])
2238
2239 ;; Move instructions
2240
2241 (define_expand "movsi"
2242   [(set (match_operand:SI 0 "general_operand" "")
2243         (match_operand:SI 1 "general_operand" ""))]
2244   ""
2245   "
2246 {
2247   if (emit_move_sequence (operands, SImode, 0))
2248     DONE;
2249 }")
2250
2251 ;; Reloading an SImode or DImode value requires a scratch register if
2252 ;; going in to or out of float point registers.
2253
2254 (define_expand "reload_insi"
2255   [(set (match_operand:SI 0 "register_operand" "=Z")
2256         (match_operand:SI 1 "non_hard_reg_operand" ""))
2257    (clobber (match_operand:SI 2 "register_operand" "=&r"))]
2258   ""
2259   "
2260 {
2261   if (emit_move_sequence (operands, SImode, operands[2]))
2262     DONE;
2263
2264   /* We don't want the clobber emitted, so handle this ourselves.  */
2265   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
2266   DONE;
2267 }")
2268
2269 (define_expand "reload_outsi"
2270   [(set (match_operand:SI 0 "non_hard_reg_operand" "")
2271         (match_operand:SI 1  "register_operand" "Z"))
2272    (clobber (match_operand:SI 2 "register_operand" "=&r"))]
2273   ""
2274   "
2275 {
2276   if (emit_move_sequence (operands, SImode, operands[2]))
2277     DONE;
2278
2279   /* We don't want the clobber emitted, so handle this ourselves.  */
2280   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
2281   DONE;
2282 }")
2283
2284 (define_insn ""
2285   [(set (match_operand:SI 0 "move_dest_operand"
2286                           "=r,r,r,r,r,r,Q,!*q,!r,!*f,*f,T")
2287         (match_operand:SI 1 "move_src_operand"
2288                           "A,r,J,N,K,RQ,rM,!rM,!*q,!*fM,RT,*f"))]
2289   "(register_operand (operands[0], SImode)
2290     || reg_or_0_operand (operands[1], SImode))
2291    && !TARGET_SOFT_FLOAT"
2292   "@
2293    ldw RT'%A1,%0
2294    copy %1,%0
2295    ldi %1,%0
2296    ldil L'%1,%0
2297    {zdepi|depwi,z} %Z1,%0
2298    ldw%M1 %1,%0
2299    stw%M0 %r1,%0
2300    mtsar %r1
2301    {mfctl|mfctl,w} %%sar,%0
2302    fcpy,sgl %f1,%0
2303    fldw%F1 %1,%0
2304    fstw%F0 %1,%0"
2305   [(set_attr "type" "load,move,move,move,shift,load,store,move,move,fpalu,fpload,fpstore")
2306    (set_attr "pa_combine_type" "addmove")
2307    (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4")])
2308
2309 (define_insn ""
2310   [(set (match_operand:SI 0 "indexed_memory_operand" "=R")
2311         (match_operand:SI 1 "register_operand" "f"))]
2312   "!TARGET_SOFT_FLOAT
2313    && !TARGET_DISABLE_INDEXING
2314    && reload_completed"
2315   "fstw%F0 %1,%0"
2316   [(set_attr "type" "fpstore")
2317    (set_attr "pa_combine_type" "addmove")
2318    (set_attr "length" "4")])
2319
2320 ; Rewrite RTL using an indexed store.  This will allow the insn that
2321 ; computes the address to be deleted if the register it sets is dead.
2322 (define_peephole2
2323   [(set (match_operand:SI 0 "register_operand" "")
2324         (plus:SI (mult:SI (match_operand:SI 1 "register_operand" "")
2325                           (const_int 4))
2326                  (match_operand:SI 2 "register_operand" "")))
2327    (set (mem:SI (match_dup 0))
2328         (match_operand:SI 3 "register_operand" ""))]
2329   "!TARGET_SOFT_FLOAT
2330    && !TARGET_DISABLE_INDEXING
2331    && REG_OK_FOR_BASE_P (operands[2])
2332    && FP_REGNO_P (REGNO (operands[3]))"
2333   [(set (mem:SI (plus:SI (mult:SI (match_dup 1) (const_int 4)) (match_dup 2)))
2334         (match_dup 3))
2335    (set (match_dup 0) (plus:SI (mult:SI (match_dup 1) (const_int 4))
2336                                (match_dup 2)))]
2337   "")
2338
2339 (define_peephole2
2340   [(set (match_operand:SI 0 "register_operand" "")
2341         (plus:SI (match_operand:SI 2 "register_operand" "")
2342                  (mult:SI (match_operand:SI 1 "register_operand" "")
2343                           (const_int 4))))
2344    (set (mem:SI (match_dup 0))
2345         (match_operand:SI 3 "register_operand" ""))]
2346   "!TARGET_SOFT_FLOAT
2347    && !TARGET_DISABLE_INDEXING
2348    && REG_OK_FOR_BASE_P (operands[2])
2349    && FP_REGNO_P (REGNO (operands[3]))"
2350   [(set (mem:SI (plus:SI (mult:SI (match_dup 1) (const_int 4)) (match_dup 2)))
2351         (match_dup 3))
2352    (set (match_dup 0) (plus:SI (mult:SI (match_dup 1) (const_int 4))
2353                                (match_dup 2)))]
2354   "")
2355
2356 (define_peephole2
2357   [(set (match_operand:DI 0 "register_operand" "")
2358         (plus:DI (mult:DI (match_operand:DI 1 "register_operand" "")
2359                           (const_int 4))
2360                  (match_operand:DI 2 "register_operand" "")))
2361    (set (mem:SI (match_dup 0))
2362         (match_operand:SI 3 "register_operand" ""))]
2363   "!TARGET_SOFT_FLOAT
2364    && !TARGET_DISABLE_INDEXING
2365    && TARGET_64BIT
2366    && REG_OK_FOR_BASE_P (operands[2])
2367    && FP_REGNO_P (REGNO (operands[3]))"
2368   [(set (mem:SI (plus:DI (mult:DI (match_dup 1) (const_int 4)) (match_dup 2)))
2369         (match_dup 3))
2370    (set (match_dup 0) (plus:DI (mult:DI (match_dup 1) (const_int 4))
2371                                (match_dup 2)))]
2372   "")
2373
2374 (define_peephole2
2375   [(set (match_operand:DI 0 "register_operand" "")
2376         (plus:DI (match_operand:DI 2 "register_operand" "")
2377                  (mult:DI (match_operand:DI 1 "register_operand" "")
2378                           (const_int 4))))
2379    (set (mem:SI (match_dup 0))
2380         (match_operand:SI 3 "register_operand" ""))]
2381   "!TARGET_SOFT_FLOAT
2382    && !TARGET_DISABLE_INDEXING
2383    && TARGET_64BIT
2384    && REG_OK_FOR_BASE_P (operands[2])
2385    && FP_REGNO_P (REGNO (operands[3]))"
2386   [(set (mem:SI (plus:DI (mult:DI (match_dup 1) (const_int 4)) (match_dup 2)))
2387         (match_dup 3))
2388    (set (match_dup 0) (plus:DI (mult:DI (match_dup 1) (const_int 4))
2389                                (match_dup 2)))]
2390   "")
2391
2392 (define_peephole2
2393   [(set (match_operand:SI 0 "register_operand" "")
2394         (plus:SI (match_operand:SI 1 "register_operand" "")
2395                  (match_operand:SI 2 "register_operand" "")))
2396    (set (mem:SI (match_dup 0))
2397         (match_operand:SI 3 "register_operand" ""))]
2398   "!TARGET_SOFT_FLOAT
2399    && !TARGET_DISABLE_INDEXING
2400    && REG_OK_FOR_BASE_P (operands[1])
2401    && (TARGET_NO_SPACE_REGS
2402        || (!REG_POINTER (operands[1]) && REG_POINTER (operands[2])))
2403    && FP_REGNO_P (REGNO (operands[3]))"
2404   [(set (mem:SI (plus:SI (match_dup 1) (match_dup 2)))
2405         (match_dup 3))
2406    (set (match_dup 0) (plus:SI (match_dup 1) (match_dup 2)))]
2407   "")
2408
2409 (define_peephole2
2410   [(set (match_operand:SI 0 "register_operand" "")
2411         (plus:SI (match_operand:SI 1 "register_operand" "")
2412                  (match_operand:SI 2 "register_operand" "")))
2413    (set (mem:SI (match_dup 0))
2414         (match_operand:SI 3 "register_operand" ""))]
2415   "!TARGET_SOFT_FLOAT
2416    && !TARGET_DISABLE_INDEXING
2417    && REG_OK_FOR_BASE_P (operands[2])
2418    && (TARGET_NO_SPACE_REGS
2419        || (REG_POINTER (operands[1]) && !REG_POINTER (operands[2])))
2420    && FP_REGNO_P (REGNO (operands[3]))"
2421   [(set (mem:SI (plus:SI (match_dup 2) (match_dup 1)))
2422         (match_dup 3))
2423    (set (match_dup 0) (plus:SI (match_dup 2) (match_dup 1)))]
2424   "")
2425
2426 (define_peephole2
2427   [(set (match_operand:DI 0 "register_operand" "")
2428         (plus:DI (match_operand:DI 1 "register_operand" "")
2429                  (match_operand:DI 2 "register_operand" "")))
2430    (set (mem:SI (match_dup 0))
2431         (match_operand:SI 3 "register_operand" ""))]
2432   "!TARGET_SOFT_FLOAT
2433    && !TARGET_DISABLE_INDEXING
2434    && TARGET_64BIT
2435    && REG_OK_FOR_BASE_P (operands[1])
2436    && (TARGET_NO_SPACE_REGS
2437        || (!REG_POINTER (operands[1]) && REG_POINTER (operands[2])))
2438    && FP_REGNO_P (REGNO (operands[3]))"
2439   [(set (mem:SI (plus:DI (match_dup 1) (match_dup 2)))
2440         (match_dup 3))
2441    (set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))]
2442   "")
2443
2444 (define_peephole2
2445   [(set (match_operand:DI 0 "register_operand" "")
2446         (plus:DI (match_operand:DI 1 "register_operand" "")
2447                  (match_operand:DI 2 "register_operand" "")))
2448    (set (mem:SI (match_dup 0))
2449         (match_operand:SI 3 "register_operand" ""))]
2450   "!TARGET_SOFT_FLOAT
2451    && !TARGET_DISABLE_INDEXING
2452    && TARGET_64BIT
2453    && REG_OK_FOR_BASE_P (operands[2])
2454    && (TARGET_NO_SPACE_REGS
2455        || (REG_POINTER (operands[1]) && !REG_POINTER (operands[2])))
2456    && FP_REGNO_P (REGNO (operands[3]))"
2457   [(set (mem:SI (plus:DI (match_dup 2) (match_dup 1)))
2458         (match_dup 3))
2459    (set (match_dup 0) (plus:DI (match_dup 2) (match_dup 1)))]
2460   "")
2461
2462 (define_insn ""
2463   [(set (match_operand:SI 0 "move_dest_operand"
2464                           "=r,r,r,r,r,r,Q,!*q,!r")
2465         (match_operand:SI 1 "move_src_operand"
2466                           "A,r,J,N,K,RQ,rM,!rM,!*q"))]
2467   "(register_operand (operands[0], SImode)
2468     || reg_or_0_operand (operands[1], SImode))
2469    && TARGET_SOFT_FLOAT"
2470   "@
2471    ldw RT'%A1,%0
2472    copy %1,%0
2473    ldi %1,%0
2474    ldil L'%1,%0
2475    {zdepi|depwi,z} %Z1,%0
2476    ldw%M1 %1,%0
2477    stw%M0 %r1,%0
2478    mtsar %r1
2479    {mfctl|mfctl,w} %%sar,%0"
2480   [(set_attr "type" "load,move,move,move,move,load,store,move,move")
2481    (set_attr "pa_combine_type" "addmove")
2482    (set_attr "length" "4,4,4,4,4,4,4,4,4")])
2483
2484 ;; Load or store with base-register modification.
2485 (define_insn ""
2486   [(set (match_operand:SI 0 "register_operand" "=r")
2487         (mem:SI (plus:DI (match_operand:DI 1 "register_operand" "+r")
2488                          (match_operand:DI 2 "int5_operand" "L"))))
2489    (set (match_dup 1)
2490         (plus:DI (match_dup 1) (match_dup 2)))]
2491   "TARGET_64BIT"
2492   "ldw,mb %2(%1),%0"
2493   [(set_attr "type" "load")
2494    (set_attr "length" "4")])
2495
2496 ; And a zero extended variant.
2497 (define_insn ""
2498   [(set (match_operand:DI 0 "register_operand" "=r")
2499         (zero_extend:DI (mem:SI
2500                           (plus:DI
2501                             (match_operand:DI 1 "register_operand" "+r")
2502                             (match_operand:DI 2 "int5_operand" "L")))))
2503    (set (match_dup 1)
2504         (plus:DI (match_dup 1) (match_dup 2)))]
2505   "TARGET_64BIT"
2506   "ldw,mb %2(%1),%0"
2507   [(set_attr "type" "load")
2508    (set_attr "length" "4")])
2509
2510 (define_expand "pre_load"
2511   [(parallel [(set (match_operand:SI 0 "register_operand" "")
2512               (mem (plus (match_operand 1 "register_operand" "")
2513                                (match_operand 2 "pre_cint_operand" ""))))
2514               (set (match_dup 1)
2515                    (plus (match_dup 1) (match_dup 2)))])]
2516   ""
2517   "
2518 {
2519   if (TARGET_64BIT)
2520     {
2521       emit_insn (gen_pre_ldd (operands[0], operands[1], operands[2]));
2522       DONE;
2523     }
2524   emit_insn (gen_pre_ldw (operands[0], operands[1], operands[2]));
2525   DONE;
2526 }")
2527
2528 (define_insn "pre_ldw"
2529   [(set (match_operand:SI 0 "register_operand" "=r")
2530         (mem:SI (plus:SI (match_operand:SI 1 "register_operand" "+r")
2531                          (match_operand:SI 2 "pre_cint_operand" ""))))
2532    (set (match_dup 1)
2533         (plus:SI (match_dup 1) (match_dup 2)))]
2534   ""
2535   "*
2536 {
2537   if (INTVAL (operands[2]) < 0)
2538     return \"{ldwm|ldw,mb} %2(%1),%0\";
2539   return \"{ldws|ldw},mb %2(%1),%0\";
2540 }"
2541   [(set_attr "type" "load")
2542    (set_attr "length" "4")])
2543
2544 (define_insn "pre_ldd"
2545   [(set (match_operand:DI 0 "register_operand" "=r")
2546         (mem:DI (plus:DI (match_operand:DI 1 "register_operand" "+r")
2547                          (match_operand:DI 2 "pre_cint_operand" ""))))
2548    (set (match_dup 1)
2549         (plus:DI (match_dup 1) (match_dup 2)))]
2550   "TARGET_64BIT"
2551   "ldd,mb %2(%1),%0"
2552   [(set_attr "type" "load")
2553    (set_attr "length" "4")])
2554
2555 (define_insn ""
2556   [(set (mem:SI (plus:SI (match_operand:SI 0 "register_operand" "+r")
2557                          (match_operand:SI 1 "pre_cint_operand" "")))
2558         (match_operand:SI 2 "reg_or_0_operand" "rM"))
2559    (set (match_dup 0)
2560         (plus:SI (match_dup 0) (match_dup 1)))]
2561   ""
2562   "*
2563 {
2564   if (INTVAL (operands[1]) < 0)
2565     return \"{stwm|stw,mb} %r2,%1(%0)\";
2566   return \"{stws|stw},mb %r2,%1(%0)\";
2567 }"
2568   [(set_attr "type" "store")
2569    (set_attr "length" "4")])
2570
2571 (define_insn ""
2572   [(set (match_operand:SI 0 "register_operand" "=r")
2573         (mem:SI (match_operand:SI 1 "register_operand" "+r")))
2574    (set (match_dup 1)
2575         (plus:SI (match_dup 1)
2576                  (match_operand:SI 2 "post_cint_operand" "")))]
2577   ""
2578   "*
2579 {
2580   if (INTVAL (operands[2]) > 0)
2581     return \"{ldwm|ldw,ma} %2(%1),%0\";
2582   return \"{ldws|ldw},ma %2(%1),%0\";
2583 }"
2584   [(set_attr "type" "load")
2585    (set_attr "length" "4")])
2586
2587 (define_expand "post_store"
2588   [(parallel [(set (mem (match_operand 0 "register_operand" ""))
2589                    (match_operand 1 "reg_or_0_operand" ""))
2590               (set (match_dup 0)
2591                    (plus (match_dup 0)
2592                          (match_operand 2 "post_cint_operand" "")))])]
2593   ""
2594   "
2595 {
2596   if (TARGET_64BIT)
2597     {
2598       emit_insn (gen_post_std (operands[0], operands[1], operands[2]));
2599       DONE;
2600     }
2601   emit_insn (gen_post_stw (operands[0], operands[1], operands[2]));
2602   DONE;
2603 }")
2604
2605 (define_insn "post_stw"
2606   [(set (mem:SI (match_operand:SI 0 "register_operand" "+r"))
2607         (match_operand:SI 1 "reg_or_0_operand" "rM"))
2608    (set (match_dup 0)
2609         (plus:SI (match_dup 0)
2610                  (match_operand:SI 2 "post_cint_operand" "")))]
2611   ""
2612   "*
2613 {
2614   if (INTVAL (operands[2]) > 0)
2615     return \"{stwm|stw,ma} %r1,%2(%0)\";
2616   return \"{stws|stw},ma %r1,%2(%0)\";
2617 }"
2618   [(set_attr "type" "store")
2619    (set_attr "length" "4")])
2620
2621 (define_insn "post_std"
2622   [(set (mem:DI (match_operand:DI 0 "register_operand" "+r"))
2623         (match_operand:DI 1 "reg_or_0_operand" "rM"))
2624    (set (match_dup 0)
2625         (plus:DI (match_dup 0)
2626                  (match_operand:DI 2 "post_cint_operand" "")))]
2627   "TARGET_64BIT"
2628   "std,ma %r1,%2(%0)"
2629   [(set_attr "type" "store")
2630    (set_attr "length" "4")])
2631
2632 ;; For loading the address of a label while generating PIC code.
2633 ;; Note since this pattern can be created at reload time (via movsi), all
2634 ;; the same rules for movsi apply here.  (no new pseudos, no temporaries).
2635 (define_insn ""
2636   [(set (match_operand 0 "pmode_register_operand" "=a")
2637         (match_operand 1 "pic_label_operand" ""))]
2638   "TARGET_PA_20"
2639   "*
2640 {
2641   rtx xoperands[3];
2642
2643   xoperands[0] = operands[0];
2644   xoperands[1] = operands[1];
2645   xoperands[2] = gen_label_rtx ();
2646
2647   (*targetm.asm_out.internal_label) (asm_out_file, \"L\",
2648                                      CODE_LABEL_NUMBER (xoperands[2]));
2649   output_asm_insn (\"mfia %0\", xoperands);
2650
2651   /* If we're trying to load the address of a label that happens to be
2652      close, then we can use a shorter sequence.  */
2653   if (GET_CODE (operands[1]) == LABEL_REF
2654       && !LABEL_REF_NONLOCAL_P (operands[1])
2655       && INSN_ADDRESSES_SET_P ()
2656       && abs (INSN_ADDRESSES (INSN_UID (XEXP (operands[1], 0)))
2657                 - INSN_ADDRESSES (INSN_UID (insn))) < 8100)
2658     output_asm_insn (\"ldo %1-%2(%0),%0\", xoperands);
2659   else
2660     {
2661       output_asm_insn (\"addil L%%%1-%2,%0\", xoperands);
2662       output_asm_insn (\"ldo R%%%1-%2(%0),%0\", xoperands);
2663     }
2664   return \"\";
2665 }"
2666   [(set_attr "type" "multi")
2667    (set_attr "length" "12")])           ; 8 or 12
2668
2669 (define_insn ""
2670   [(set (match_operand 0 "pmode_register_operand" "=a")
2671         (match_operand 1 "pic_label_operand" ""))]
2672   "!TARGET_PA_20"
2673   "*
2674 {
2675   rtx xoperands[3];
2676
2677   xoperands[0] = operands[0];
2678   xoperands[1] = operands[1];
2679   xoperands[2] = gen_label_rtx ();
2680
2681   output_asm_insn (\"bl .+8,%0\", xoperands);
2682   output_asm_insn (\"depi 0,31,2,%0\", xoperands);
2683   (*targetm.asm_out.internal_label) (asm_out_file, \"L\",
2684                                      CODE_LABEL_NUMBER (xoperands[2]));
2685
2686   /* If we're trying to load the address of a label that happens to be
2687      close, then we can use a shorter sequence.  */
2688   if (GET_CODE (operands[1]) == LABEL_REF
2689       && !LABEL_REF_NONLOCAL_P (operands[1])
2690       && INSN_ADDRESSES_SET_P ()
2691       && abs (INSN_ADDRESSES (INSN_UID (XEXP (operands[1], 0)))
2692                 - INSN_ADDRESSES (INSN_UID (insn))) < 8100)
2693     output_asm_insn (\"ldo %1-%2(%0),%0\", xoperands);
2694   else
2695     {
2696       output_asm_insn (\"addil L%%%1-%2,%0\", xoperands);
2697       output_asm_insn (\"ldo R%%%1-%2(%0),%0\", xoperands);
2698     }
2699   return \"\";
2700 }"
2701   [(set_attr "type" "multi")
2702    (set_attr "length" "16")])           ; 12 or 16
2703
2704 (define_insn ""
2705   [(set (match_operand:SI 0 "register_operand" "=a")
2706         (plus:SI (match_operand:SI 1 "register_operand" "r")
2707                  (high:SI (match_operand 2 "" ""))))]
2708   "symbolic_operand (operands[2], Pmode)
2709    && ! function_label_operand (operands[2], Pmode)
2710    && flag_pic"
2711   "addil LT'%G2,%1"
2712   [(set_attr "type" "binary")
2713    (set_attr "length" "4")])
2714
2715 (define_insn ""
2716   [(set (match_operand:DI 0 "register_operand" "=a")
2717         (plus:DI (match_operand:DI 1 "register_operand" "r")
2718                  (high:DI (match_operand 2 "" ""))))]
2719   "symbolic_operand (operands[2], Pmode)
2720    && ! function_label_operand (operands[2], Pmode)
2721    && TARGET_64BIT
2722    && flag_pic"
2723   "addil LT'%G2,%1"
2724   [(set_attr "type" "binary")
2725    (set_attr "length" "4")])
2726
2727 ;; Always use addil rather than ldil;add sequences.  This allows the
2728 ;; HP linker to eliminate the dp relocation if the symbolic operand
2729 ;; lives in the TEXT space.
2730 (define_insn ""
2731   [(set (match_operand:SI 0 "register_operand" "=a")
2732         (high:SI (match_operand 1 "" "")))]
2733   "symbolic_operand (operands[1], Pmode)
2734    && ! function_label_operand (operands[1], Pmode)
2735    && ! read_only_operand (operands[1], Pmode)
2736    && ! flag_pic"
2737   "*
2738 {
2739   if (TARGET_LONG_LOAD_STORE)
2740     return \"addil NLR'%H1,%%r27\;ldo N'%H1(%%r1),%%r1\";
2741   else
2742     return \"addil LR'%H1,%%r27\";
2743 }"
2744   [(set_attr "type" "binary")
2745    (set (attr "length")
2746       (if_then_else (eq (symbol_ref "TARGET_LONG_LOAD_STORE") (const_int 0))
2747                     (const_int 4)
2748                     (const_int 8)))])
2749
2750
2751 ;; This is for use in the prologue/epilogue code.  We need it
2752 ;; to add large constants to a stack pointer or frame pointer.
2753 ;; Because of the additional %r1 pressure, we probably do not
2754 ;; want to use this in general code, so make it available
2755 ;; only after reload.
2756 (define_insn ""
2757   [(set (match_operand:SI 0 "register_operand" "=!a,*r")
2758         (plus:SI (match_operand:SI 1 "register_operand" "r,r")
2759                  (high:SI (match_operand 2 "const_int_operand" ""))))]
2760   "reload_completed"
2761   "@
2762    addil L'%G2,%1
2763    ldil L'%G2,%0\;{addl|add,l} %0,%1,%0"
2764   [(set_attr "type" "binary,binary")
2765    (set_attr "length" "4,8")])
2766
2767 (define_insn ""
2768   [(set (match_operand:DI 0 "register_operand" "=!a,*r")
2769         (plus:DI (match_operand:DI 1 "register_operand" "r,r")
2770                  (high:DI (match_operand 2 "const_int_operand" ""))))]
2771   "reload_completed && TARGET_64BIT"
2772   "@
2773    addil L'%G2,%1
2774    ldil L'%G2,%0\;{addl|add,l} %0,%1,%0"
2775   [(set_attr "type" "binary,binary")
2776    (set_attr "length" "4,8")])
2777
2778 (define_insn ""
2779   [(set (match_operand:SI 0 "register_operand" "=r")
2780         (high:SI (match_operand 1 "" "")))]
2781   "(!flag_pic || !symbolic_operand (operands[1], Pmode))
2782     && !is_function_label_plus_const (operands[1])"
2783   "*
2784 {
2785   if (symbolic_operand (operands[1], Pmode))
2786     return \"ldil LR'%H1,%0\";
2787   else
2788     return \"ldil L'%G1,%0\";
2789 }"
2790   [(set_attr "type" "move")
2791    (set_attr "length" "4")])
2792
2793 (define_insn ""
2794   [(set (match_operand:DI 0 "register_operand" "=r")
2795         (high:DI (match_operand 1 "const_int_operand" "")))]
2796   "TARGET_64BIT"
2797   "ldil L'%G1,%0";
2798   [(set_attr "type" "move")
2799    (set_attr "length" "4")])
2800
2801 (define_insn ""
2802   [(set (match_operand:DI 0 "register_operand" "=r")
2803         (lo_sum:DI (match_operand:DI 1 "register_operand" "r")
2804                    (match_operand:DI 2 "const_int_operand" "i")))]
2805   "TARGET_64BIT"
2806   "ldo R'%G2(%1),%0";
2807   [(set_attr "type" "move")
2808    (set_attr "length" "4")])
2809
2810 (define_insn ""
2811   [(set (match_operand:SI 0 "register_operand" "=r")
2812         (lo_sum:SI (match_operand:SI 1 "register_operand" "r")
2813                    (match_operand:SI 2 "immediate_operand" "i")))]
2814   "!is_function_label_plus_const (operands[2])"
2815   "*
2816 {
2817   if (flag_pic && symbolic_operand (operands[2], Pmode))
2818     abort ();
2819   else if (symbolic_operand (operands[2], Pmode))
2820     return \"ldo RR'%G2(%1),%0\";
2821   else
2822     return \"ldo R'%G2(%1),%0\";
2823 }"
2824   [(set_attr "type" "move")
2825    (set_attr "length" "4")])
2826
2827 ;; Now that a symbolic_address plus a constant is broken up early
2828 ;; in the compilation phase (for better CSE) we need a special
2829 ;; combiner pattern to load the symbolic address plus the constant
2830 ;; in only 2 instructions. (For cases where the symbolic address
2831 ;; was not a common subexpression.)
2832 (define_split
2833   [(set (match_operand:SI 0 "register_operand" "")
2834         (match_operand:SI 1 "symbolic_operand" ""))
2835    (clobber (match_operand:SI 2 "register_operand" ""))]
2836   "! (flag_pic && pic_label_operand (operands[1], SImode))"
2837   [(set (match_dup 2) (high:SI (match_dup 1)))
2838    (set (match_dup 0) (lo_sum:SI (match_dup 2) (match_dup 1)))]
2839   "")
2840
2841 ;; hppa_legitimize_address goes to a great deal of trouble to
2842 ;; create addresses which use indexing.  In some cases, this
2843 ;; is a lose because there isn't any store instructions which
2844 ;; allow indexed addresses (with integer register source).
2845 ;;
2846 ;; These define_splits try to turn a 3 insn store into
2847 ;; a 2 insn store with some creative RTL rewriting.
2848 (define_split
2849   [(set (mem:SI (plus:SI (mult:SI (match_operand:SI 0 "register_operand" "")
2850                                (match_operand:SI 1 "shadd_operand" ""))
2851                    (plus:SI (match_operand:SI 2 "register_operand" "")
2852                             (match_operand:SI 3 "const_int_operand" ""))))
2853         (match_operand:SI 4 "register_operand" ""))
2854    (clobber (match_operand:SI 5 "register_operand" ""))]
2855   ""
2856   [(set (match_dup 5) (plus:SI (mult:SI (match_dup 0) (match_dup 1))
2857                                (match_dup 2)))
2858    (set (mem:SI (plus:SI (match_dup 5) (match_dup 3))) (match_dup 4))]
2859   "")
2860
2861 (define_split
2862   [(set (mem:HI (plus:SI (mult:SI (match_operand:SI 0 "register_operand" "")
2863                                (match_operand:SI 1 "shadd_operand" ""))
2864                    (plus:SI (match_operand:SI 2 "register_operand" "")
2865                             (match_operand:SI 3 "const_int_operand" ""))))
2866         (match_operand:HI 4 "register_operand" ""))
2867    (clobber (match_operand:SI 5 "register_operand" ""))]
2868   ""
2869   [(set (match_dup 5) (plus:SI (mult:SI (match_dup 0) (match_dup 1))
2870                                (match_dup 2)))
2871    (set (mem:HI (plus:SI (match_dup 5) (match_dup 3))) (match_dup 4))]
2872   "")
2873
2874 (define_split
2875   [(set (mem:QI (plus:SI (mult:SI (match_operand:SI 0 "register_operand" "")
2876                                (match_operand:SI 1 "shadd_operand" ""))
2877                    (plus:SI (match_operand:SI 2 "register_operand" "")
2878                             (match_operand:SI 3 "const_int_operand" ""))))
2879         (match_operand:QI 4 "register_operand" ""))
2880    (clobber (match_operand:SI 5 "register_operand" ""))]
2881   ""
2882   [(set (match_dup 5) (plus:SI (mult:SI (match_dup 0) (match_dup 1))
2883                                (match_dup 2)))
2884    (set (mem:QI (plus:SI (match_dup 5) (match_dup 3))) (match_dup 4))]
2885   "")
2886
2887 (define_expand "movhi"
2888   [(set (match_operand:HI 0 "general_operand" "")
2889         (match_operand:HI 1 "general_operand" ""))]
2890   ""
2891   "
2892 {
2893   if (emit_move_sequence (operands, HImode, 0))
2894     DONE;
2895 }")
2896
2897 (define_insn ""
2898   [(set (match_operand:HI 0 "move_dest_operand"
2899                           "=r,r,r,r,r,Q,!*q,!r,!*f")
2900         (match_operand:HI 1 "move_src_operand"
2901                           "r,J,N,K,RQ,rM,!rM,!*q,!*fM"))]
2902   "register_operand (operands[0], HImode)
2903    || reg_or_0_operand (operands[1], HImode)"
2904   "@
2905    copy %1,%0
2906    ldi %1,%0
2907    ldil L'%1,%0
2908    {zdepi|depwi,z} %Z1,%0
2909    ldh%M1 %1,%0
2910    sth%M0 %r1,%0
2911    mtsar %r1
2912    {mfctl|mfctl,w} %sar,%0
2913    fcpy,sgl %f1,%0"
2914   [(set_attr "type" "move,move,move,shift,load,store,move,move,fpalu")
2915    (set_attr "pa_combine_type" "addmove")
2916    (set_attr "length" "4,4,4,4,4,4,4,4,4")])
2917
2918 (define_insn ""
2919   [(set (match_operand:HI 0 "register_operand" "=r")
2920         (mem:HI (plus:SI (match_operand:SI 1 "register_operand" "+r")
2921                          (match_operand:SI 2 "int5_operand" "L"))))
2922    (set (match_dup 1)
2923         (plus:SI (match_dup 1) (match_dup 2)))]
2924   ""
2925   "{ldhs|ldh},mb %2(%1),%0"
2926   [(set_attr "type" "load")
2927    (set_attr "length" "4")])
2928
2929 (define_insn ""
2930   [(set (match_operand:HI 0 "register_operand" "=r")
2931         (mem:HI (plus:DI (match_operand:DI 1 "register_operand" "+r")
2932                          (match_operand:DI 2 "int5_operand" "L"))))
2933    (set (match_dup 1)
2934         (plus:DI (match_dup 1) (match_dup 2)))]
2935   "TARGET_64BIT"
2936   "ldh,mb %2(%1),%0"
2937   [(set_attr "type" "load")
2938    (set_attr "length" "4")])
2939
2940 ; And a zero extended variant.
2941 (define_insn ""
2942   [(set (match_operand:DI 0 "register_operand" "=r")
2943         (zero_extend:DI (mem:HI
2944                           (plus:DI
2945                             (match_operand:DI 1 "register_operand" "+r")
2946                             (match_operand:DI 2 "int5_operand" "L")))))
2947    (set (match_dup 1)
2948         (plus:DI (match_dup 1) (match_dup 2)))]
2949   "TARGET_64BIT"
2950   "ldh,mb %2(%1),%0"
2951   [(set_attr "type" "load")
2952    (set_attr "length" "4")])
2953
2954 (define_insn ""
2955   [(set (match_operand:SI 0 "register_operand" "=r")
2956         (zero_extend:SI (mem:HI
2957                           (plus:SI
2958                             (match_operand:SI 1 "register_operand" "+r")
2959                             (match_operand:SI 2 "int5_operand" "L")))))
2960    (set (match_dup 1)
2961         (plus:SI (match_dup 1) (match_dup 2)))]
2962   ""
2963   "{ldhs|ldh},mb %2(%1),%0"
2964   [(set_attr "type" "load")
2965    (set_attr "length" "4")])
2966
2967 (define_insn ""
2968   [(set (match_operand:SI 0 "register_operand" "=r")
2969         (zero_extend:SI (mem:HI
2970                           (plus:DI
2971                             (match_operand:DI 1 "register_operand" "+r")
2972                             (match_operand:DI 2 "int5_operand" "L")))))
2973    (set (match_dup 1)
2974         (plus:DI (match_dup 1) (match_dup 2)))]
2975   "TARGET_64BIT"
2976   "ldh,mb %2(%1),%0"
2977   [(set_attr "type" "load")
2978    (set_attr "length" "4")])
2979
2980 (define_insn ""
2981   [(set (mem:HI (plus:SI (match_operand:SI 0 "register_operand" "+r")
2982                          (match_operand:SI 1 "int5_operand" "L")))
2983         (match_operand:HI 2 "reg_or_0_operand" "rM"))
2984    (set (match_dup 0)
2985         (plus:SI (match_dup 0) (match_dup 1)))]
2986   ""
2987   "{sths|sth},mb %r2,%1(%0)"
2988   [(set_attr "type" "store")
2989    (set_attr "length" "4")])
2990
2991 (define_insn ""
2992   [(set (mem:HI (plus:DI (match_operand:DI 0 "register_operand" "+r")
2993                          (match_operand:DI 1 "int5_operand" "L")))
2994         (match_operand:HI 2 "reg_or_0_operand" "rM"))
2995    (set (match_dup 0)
2996         (plus:DI (match_dup 0) (match_dup 1)))]
2997   "TARGET_64BIT"
2998   "sth,mb %r2,%1(%0)"
2999   [(set_attr "type" "store")
3000    (set_attr "length" "4")])
3001
3002 (define_insn ""
3003   [(set (match_operand:HI 0 "register_operand" "=r")
3004         (plus:HI (match_operand:HI 1 "register_operand" "r")
3005                  (match_operand 2 "const_int_operand" "J")))]
3006   ""
3007   "ldo %2(%1),%0"
3008   [(set_attr "type" "binary")
3009    (set_attr "pa_combine_type" "addmove")
3010    (set_attr "length" "4")])
3011
3012 (define_expand "movqi"
3013   [(set (match_operand:QI 0 "general_operand" "")
3014         (match_operand:QI 1 "general_operand" ""))]
3015   ""
3016   "
3017 {
3018   if (emit_move_sequence (operands, QImode, 0))
3019     DONE;
3020 }")
3021
3022 (define_insn ""
3023   [(set (match_operand:QI 0 "move_dest_operand"
3024                           "=r,r,r,r,r,Q,!*q,!r,!*f")
3025         (match_operand:QI 1 "move_src_operand"
3026                           "r,J,N,K,RQ,rM,!rM,!*q,!*fM"))]
3027   "register_operand (operands[0], QImode)
3028    || reg_or_0_operand (operands[1], QImode)"
3029   "@
3030    copy %1,%0
3031    ldi %1,%0
3032    ldil L'%1,%0
3033    {zdepi|depwi,z} %Z1,%0
3034    ldb%M1 %1,%0
3035    stb%M0 %r1,%0
3036    mtsar %r1
3037    {mfctl|mfctl,w} %%sar,%0
3038    fcpy,sgl %f1,%0"
3039   [(set_attr "type" "move,move,move,shift,load,store,move,move,fpalu")
3040    (set_attr "pa_combine_type" "addmove")
3041    (set_attr "length" "4,4,4,4,4,4,4,4,4")])
3042
3043 (define_insn ""
3044   [(set (match_operand:QI 0 "register_operand" "=r")
3045         (mem:QI (plus:SI (match_operand:SI 1 "register_operand" "+r")
3046                          (match_operand:SI 2 "int5_operand" "L"))))
3047    (set (match_dup 1) (plus:SI (match_dup 1) (match_dup 2)))]
3048   ""
3049   "{ldbs|ldb},mb %2(%1),%0"
3050   [(set_attr "type" "load")
3051    (set_attr "length" "4")])
3052
3053 (define_insn ""
3054   [(set (match_operand:QI 0 "register_operand" "=r")
3055         (mem:QI (plus:DI (match_operand:DI 1 "register_operand" "+r")
3056                          (match_operand:DI 2 "int5_operand" "L"))))
3057    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3058   "TARGET_64BIT"
3059   "ldb,mb %2(%1),%0"
3060   [(set_attr "type" "load")
3061    (set_attr "length" "4")])
3062
3063 ; Now the same thing with zero extensions.
3064 (define_insn ""
3065   [(set (match_operand:DI 0 "register_operand" "=r")
3066         (zero_extend:DI (mem:QI (plus:DI
3067                                   (match_operand:DI 1 "register_operand" "+r")
3068                                   (match_operand:DI 2 "int5_operand" "L")))))
3069    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3070   "TARGET_64BIT"
3071   "ldb,mb %2(%1),%0"
3072   [(set_attr "type" "load")
3073    (set_attr "length" "4")])
3074
3075 (define_insn ""
3076   [(set (match_operand:SI 0 "register_operand" "=r")
3077         (zero_extend:SI (mem:QI (plus:SI
3078                                   (match_operand:SI 1 "register_operand" "+r")
3079                                   (match_operand:SI 2 "int5_operand" "L")))))
3080    (set (match_dup 1) (plus:SI (match_dup 1) (match_dup 2)))]
3081   ""
3082   "{ldbs|ldb},mb %2(%1),%0"
3083   [(set_attr "type" "load")
3084    (set_attr "length" "4")])
3085
3086 (define_insn ""
3087   [(set (match_operand:SI 0 "register_operand" "=r")
3088         (zero_extend:SI (mem:QI (plus:DI
3089                                   (match_operand:DI 1 "register_operand" "+r")
3090                                   (match_operand:DI 2 "int5_operand" "L")))))
3091    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3092   "TARGET_64BIT"
3093   "ldb,mb %2(%1),%0"
3094   [(set_attr "type" "load")
3095    (set_attr "length" "4")])
3096
3097 (define_insn ""
3098   [(set (match_operand:HI 0 "register_operand" "=r")
3099         (zero_extend:HI (mem:QI (plus:SI
3100                                   (match_operand:SI 1 "register_operand" "+r")
3101                                   (match_operand:SI 2 "int5_operand" "L")))))
3102    (set (match_dup 1) (plus:SI (match_dup 1) (match_dup 2)))]
3103   ""
3104   "{ldbs|ldb},mb %2(%1),%0"
3105   [(set_attr "type" "load")
3106    (set_attr "length" "4")])
3107
3108 (define_insn ""
3109   [(set (match_operand:HI 0 "register_operand" "=r")
3110         (zero_extend:HI (mem:QI (plus:DI
3111                                   (match_operand:DI 1 "register_operand" "+r")
3112                                   (match_operand:DI 2 "int5_operand" "L")))))
3113    (set (match_dup 1) (plus:DI (match_dup 1) (match_dup 2)))]
3114   "TARGET_64BIT"
3115   "ldb,mb %2(%1),%0"
3116   [(set_attr "type" "load")
3117    (set_attr "length" "4")])
3118
3119 (define_insn ""
3120   [(set (mem:QI (plus:SI (match_operand:SI 0 "register_operand" "+r")
3121                          (match_operand:SI 1 "int5_operand" "L")))
3122         (match_operand:QI 2 "reg_or_0_operand" "rM"))
3123    (set (match_dup 0)
3124         (plus:SI (match_dup 0) (match_dup 1)))]
3125   ""
3126   "{stbs|stb},mb %r2,%1(%0)"
3127   [(set_attr "type" "store")
3128    (set_attr "length" "4")])
3129
3130 (define_insn ""
3131   [(set (mem:QI (plus:DI (match_operand:DI 0 "register_operand" "+r")
3132                          (match_operand:DI 1 "int5_operand" "L")))
3133         (match_operand:QI 2 "reg_or_0_operand" "rM"))
3134    (set (match_dup 0)
3135         (plus:DI (match_dup 0) (match_dup 1)))]
3136   "TARGET_64BIT"
3137   "stb,mb %r2,%1(%0)"
3138   [(set_attr "type" "store")
3139    (set_attr "length" "4")])
3140
3141 ;; The definition of this insn does not really explain what it does,
3142 ;; but it should suffice that anything generated as this insn will be
3143 ;; recognized as a movmemsi operation, and that it will not successfully
3144 ;; combine with anything.
3145 (define_expand "movmemsi"
3146   [(parallel [(set (match_operand:BLK 0 "" "")
3147                    (match_operand:BLK 1 "" ""))
3148               (clobber (match_dup 4))
3149               (clobber (match_dup 5))
3150               (clobber (match_dup 6))
3151               (clobber (match_dup 7))
3152               (clobber (match_dup 8))
3153               (use (match_operand:SI 2 "arith_operand" ""))
3154               (use (match_operand:SI 3 "const_int_operand" ""))])]
3155   "!TARGET_64BIT && optimize > 0"
3156   "
3157 {
3158   int size, align;
3159
3160   /* HP provides very fast block move library routine for the PA;
3161      this routine includes:
3162
3163         4x4 byte at a time block moves,
3164         1x4 byte at a time with alignment checked at runtime with
3165             attempts to align the source and destination as needed
3166         1x1 byte loop
3167
3168      With that in mind, here's the heuristics to try and guess when
3169      the inlined block move will be better than the library block
3170      move:
3171
3172         If the size isn't constant, then always use the library routines.
3173
3174         If the size is large in respect to the known alignment, then use
3175         the library routines.
3176
3177         If the size is small in respect to the known alignment, then open
3178         code the copy (since that will lead to better scheduling).
3179
3180         Else use the block move pattern.   */
3181
3182   /* Undetermined size, use the library routine.  */
3183   if (GET_CODE (operands[2]) != CONST_INT)
3184     FAIL;
3185
3186   size = INTVAL (operands[2]);
3187   align = INTVAL (operands[3]);
3188   align = align > 4 ? 4 : align;
3189
3190   /* If size/alignment is large, then use the library routines.  */
3191   if (size / align > 16)
3192     FAIL;
3193
3194   /* This does happen, but not often enough to worry much about.  */
3195   if (size / align < MOVE_RATIO)
3196     FAIL;
3197   
3198   /* Fall through means we're going to use our block move pattern.  */
3199   operands[0]
3200     = replace_equiv_address (operands[0],
3201                              copy_to_mode_reg (SImode, XEXP (operands[0], 0)));
3202   operands[1]
3203     = replace_equiv_address (operands[1],
3204                              copy_to_mode_reg (SImode, XEXP (operands[1], 0)));
3205   operands[4] = gen_reg_rtx (SImode);
3206   operands[5] = gen_reg_rtx (SImode);
3207   operands[6] = gen_reg_rtx (SImode);
3208   operands[7] = gen_reg_rtx (SImode);
3209   operands[8] = gen_reg_rtx (SImode);
3210 }")
3211
3212 ;; The operand constraints are written like this to support both compile-time
3213 ;; and run-time determined byte counts.  The expander and output_block_move
3214 ;; only support compile-time determined counts at this time.
3215 ;;
3216 ;; If the count is run-time determined, the register with the byte count
3217 ;; is clobbered by the copying code, and therefore it is forced to operand 2.
3218 ;;
3219 ;; We used to clobber operands 0 and 1.  However, a change to regrename.c
3220 ;; broke this semantic for pseudo registers.  We can't use match_scratch
3221 ;; as this requires two registers in the class R1_REGS when the MEMs for
3222 ;; operands 0 and 1 are both equivalent to symbolic MEMs.  Thus, we are
3223 ;; forced to internally copy operands 0 and 1 to operands 7 and 8,
3224 ;; respectively.  We then split or peephole optimize after reload.
3225 (define_insn "movmemsi_prereload"
3226   [(set (mem:BLK (match_operand:SI 0 "register_operand" "r,r"))
3227         (mem:BLK (match_operand:SI 1 "register_operand" "r,r")))
3228    (clobber (match_operand:SI 2 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3229    (clobber (match_operand:SI 3 "register_operand" "=&r,&r"))   ;item tmp1
3230    (clobber (match_operand:SI 6 "register_operand" "=&r,&r"))   ;item tmp2
3231    (clobber (match_operand:SI 7 "register_operand" "=&r,&r"))   ;item tmp3
3232    (clobber (match_operand:SI 8 "register_operand" "=&r,&r"))   ;item tmp4
3233    (use (match_operand:SI 4 "arith_operand" "J,2"))      ;byte count
3234    (use (match_operand:SI 5 "const_int_operand" "n,n"))] ;alignment
3235   "!TARGET_64BIT"
3236   "#"
3237   [(set_attr "type" "multi,multi")])
3238
3239 (define_split
3240   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3241                    (match_operand:BLK 1 "memory_operand" ""))
3242               (clobber (match_operand:SI 2 "register_operand" ""))
3243               (clobber (match_operand:SI 3 "register_operand" ""))
3244               (clobber (match_operand:SI 6 "register_operand" ""))
3245               (clobber (match_operand:SI 7 "register_operand" ""))
3246               (clobber (match_operand:SI 8 "register_operand" ""))
3247               (use (match_operand:SI 4 "arith_operand" ""))
3248               (use (match_operand:SI 5 "const_int_operand" ""))])]
3249   "!TARGET_64BIT && reload_completed && !flag_peephole2
3250    && GET_CODE (operands[0]) == MEM
3251    && register_operand (XEXP (operands[0], 0), SImode)
3252    && GET_CODE (operands[1]) == MEM
3253    && register_operand (XEXP (operands[1], 0), SImode)"
3254   [(set (match_dup 7) (match_dup 9))
3255    (set (match_dup 8) (match_dup 10))
3256    (parallel [(set (match_dup 0) (match_dup 1))
3257               (clobber (match_dup 2))
3258               (clobber (match_dup 3))
3259               (clobber (match_dup 6))
3260               (clobber (match_dup 7))
3261               (clobber (match_dup 8))
3262               (use (match_dup 4))
3263               (use (match_dup 5))
3264               (const_int 0)])]
3265   "
3266 {
3267   operands[9] = XEXP (operands[0], 0);
3268   operands[10] = XEXP (operands[1], 0);
3269   operands[0] = replace_equiv_address (operands[0], operands[7]);
3270   operands[1] = replace_equiv_address (operands[1], operands[8]);
3271 }")
3272
3273 (define_peephole2
3274   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3275                    (match_operand:BLK 1 "memory_operand" ""))
3276               (clobber (match_operand:SI 2 "register_operand" ""))
3277               (clobber (match_operand:SI 3 "register_operand" ""))
3278               (clobber (match_operand:SI 6 "register_operand" ""))
3279               (clobber (match_operand:SI 7 "register_operand" ""))
3280               (clobber (match_operand:SI 8 "register_operand" ""))
3281               (use (match_operand:SI 4 "arith_operand" ""))
3282               (use (match_operand:SI 5 "const_int_operand" ""))])]
3283   "!TARGET_64BIT
3284    && GET_CODE (operands[0]) == MEM
3285    && register_operand (XEXP (operands[0], 0), SImode)
3286    && GET_CODE (operands[1]) == MEM
3287    && register_operand (XEXP (operands[1], 0), SImode)"
3288   [(parallel [(set (match_dup 0) (match_dup 1))
3289               (clobber (match_dup 2))
3290               (clobber (match_dup 3))
3291               (clobber (match_dup 6))
3292               (clobber (match_dup 7))
3293               (clobber (match_dup 8))
3294               (use (match_dup 4))
3295               (use (match_dup 5))
3296               (const_int 0)])]
3297   "
3298 {
3299   rtx addr = XEXP (operands[0], 0);
3300   if (dead_or_set_p (curr_insn, addr))
3301     operands[7] = addr;
3302   else
3303     {
3304       emit_insn (gen_rtx_SET (VOIDmode, operands[7], addr));
3305       operands[0] = replace_equiv_address (operands[0], operands[7]);
3306     }
3307
3308   addr = XEXP (operands[1], 0);
3309   if (dead_or_set_p (curr_insn, addr))
3310     operands[8] = addr;
3311   else
3312     {
3313       emit_insn (gen_rtx_SET (VOIDmode, operands[8], addr));
3314       operands[1] = replace_equiv_address (operands[1], operands[8]);
3315     }
3316 }")
3317
3318 (define_insn "movmemsi_postreload"
3319   [(set (mem:BLK (match_operand:SI 0 "register_operand" "+r,r"))
3320         (mem:BLK (match_operand:SI 1 "register_operand" "+r,r")))
3321    (clobber (match_operand:SI 2 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3322    (clobber (match_operand:SI 3 "register_operand" "=&r,&r"))   ;item tmp1
3323    (clobber (match_operand:SI 6 "register_operand" "=&r,&r"))   ;item tmp2
3324    (clobber (match_dup 0))
3325    (clobber (match_dup 1))
3326    (use (match_operand:SI 4 "arith_operand" "J,2"))      ;byte count
3327    (use (match_operand:SI 5 "const_int_operand" "n,n"))  ;alignment
3328    (const_int 0)]
3329   "!TARGET_64BIT && reload_completed"
3330   "* return output_block_move (operands, !which_alternative);"
3331   [(set_attr "type" "multi,multi")])
3332
3333 (define_expand "movmemdi"
3334   [(parallel [(set (match_operand:BLK 0 "" "")
3335                    (match_operand:BLK 1 "" ""))
3336               (clobber (match_dup 4))
3337               (clobber (match_dup 5))
3338               (clobber (match_dup 6))
3339               (clobber (match_dup 7))
3340               (clobber (match_dup 8))
3341               (use (match_operand:DI 2 "arith_operand" ""))
3342               (use (match_operand:DI 3 "const_int_operand" ""))])]
3343   "TARGET_64BIT && optimize > 0"
3344   "
3345 {
3346   int size, align;
3347
3348   /* HP provides very fast block move library routine for the PA;
3349      this routine includes:
3350
3351         4x4 byte at a time block moves,
3352         1x4 byte at a time with alignment checked at runtime with
3353             attempts to align the source and destination as needed
3354         1x1 byte loop
3355
3356      With that in mind, here's the heuristics to try and guess when
3357      the inlined block move will be better than the library block
3358      move:
3359
3360         If the size isn't constant, then always use the library routines.
3361
3362         If the size is large in respect to the known alignment, then use
3363         the library routines.
3364
3365         If the size is small in respect to the known alignment, then open
3366         code the copy (since that will lead to better scheduling).
3367
3368         Else use the block move pattern.   */
3369
3370   /* Undetermined size, use the library routine.  */
3371   if (GET_CODE (operands[2]) != CONST_INT)
3372     FAIL;
3373
3374   size = INTVAL (operands[2]);
3375   align = INTVAL (operands[3]);
3376   align = align > 8 ? 8 : align;
3377
3378   /* If size/alignment is large, then use the library routines.  */
3379   if (size / align > 16)
3380     FAIL;
3381
3382   /* This does happen, but not often enough to worry much about.  */
3383   if (size / align < MOVE_RATIO)
3384     FAIL;
3385   
3386   /* Fall through means we're going to use our block move pattern.  */
3387   operands[0]
3388     = replace_equiv_address (operands[0],
3389                              copy_to_mode_reg (DImode, XEXP (operands[0], 0)));
3390   operands[1]
3391     = replace_equiv_address (operands[1],
3392                              copy_to_mode_reg (DImode, XEXP (operands[1], 0)));
3393   operands[4] = gen_reg_rtx (DImode);
3394   operands[5] = gen_reg_rtx (DImode);
3395   operands[6] = gen_reg_rtx (DImode);
3396   operands[7] = gen_reg_rtx (DImode);
3397   operands[8] = gen_reg_rtx (DImode);
3398 }")
3399
3400 ;; The operand constraints are written like this to support both compile-time
3401 ;; and run-time determined byte counts.  The expander and output_block_move
3402 ;; only support compile-time determined counts at this time.
3403 ;;
3404 ;; If the count is run-time determined, the register with the byte count
3405 ;; is clobbered by the copying code, and therefore it is forced to operand 2.
3406 ;;
3407 ;; We used to clobber operands 0 and 1.  However, a change to regrename.c
3408 ;; broke this semantic for pseudo registers.  We can't use match_scratch
3409 ;; as this requires two registers in the class R1_REGS when the MEMs for
3410 ;; operands 0 and 1 are both equivalent to symbolic MEMs.  Thus, we are
3411 ;; forced to internally copy operands 0 and 1 to operands 7 and 8,
3412 ;; respectively.  We then split or peephole optimize after reload.
3413 (define_insn "movmemdi_prereload"
3414   [(set (mem:BLK (match_operand:DI 0 "register_operand" "r,r"))
3415         (mem:BLK (match_operand:DI 1 "register_operand" "r,r")))
3416    (clobber (match_operand:DI 2 "register_operand" "=&r,&r"))   ;loop cnt/tmp
3417    (clobber (match_operand:DI 3 "register_operand" "=&r,&r"))   ;item tmp1
3418    (clobber (match_operand:DI 6 "register_operand" "=&r,&r"))   ;item tmp2
3419    (clobber (match_operand:DI 7 "register_operand" "=&r,&r"))   ;item tmp3
3420    (clobber (match_operand:DI 8 "register_operand" "=&r,&r"))   ;item tmp4
3421    (use (match_operand:DI 4 "arith_operand" "J,2"))      ;byte count
3422    (use (match_operand:DI 5 "const_int_operand" "n,n"))] ;alignment
3423   "TARGET_64BIT"
3424   "#"
3425   [(set_attr "type" "multi,multi")])
3426
3427 (define_split
3428   [(parallel [(set (match_operand:BLK 0 "memory_operand" "")
3429                    (match_operand:BLK 1 "memory_operand" ""))
3430               (clobber (match_operand:DI 2 "register_operand" ""))
3431               (clobber (match_operand:DI 3 "register_operand" ""))
3432               (clobber (match_operand:DI 6 "register_operand" ""))
3433               (clobber (match_operand:DI 7 "register_operand" ""))
3434               (clobber (match_operand:DI 8 "register_operand" ""))
3435               (use (match_operand:DI 4 "arith_operand" ""))
3436               (use (match_operand:DI 5 "const_int_operand" ""))])]
3437   "TARGET_64BIT && reload_completed && !flag_peephole2
3438    && GET_CODE (operands[0]) == MEM
3439    && register_operand (XEXP (operands[0], 0), DImode)
3440    && GET_CODE (operands[1]) == MEM
3441    && register_operand (XEXP (operands[1], 0), DImode)"
3442   [(set (match_dup 7) (match_dup 9))
3443    (set (match_dup 8) (match_dup 10))