OSDN Git Service

09b4211ca960f7221fd04b09cf75d72b42961e60
[pf3gnuchains/gcc-fork.git] / gcc / config / 1750a / 1750a.md
1 ;;- Machine description for GNU compiler
2 ;;- MIL-STD-1750A version.
3 ;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
4 ;; Contributed by O.M.Kellogg, DASA (oliver.kellogg@space.otn.dasa.de).
5
6 ;; This file is part of GNU CC.
7
8 ;; GNU CC is free software; you can redistribute it and/or modify
9 ;; it under the terms of the GNU General Public License as published by
10 ;; the Free Software Foundation; either version 1, or (at your option)
11 ;; any later version.
12
13 ;; GNU CC is distributed in the hope that it will be useful,
14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 ;; GNU General Public License for more details.
17
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with GNU CC; see the file COPYING.  If not, write to
20 ;; the Free Software Foundation, 59 Temple Place - Suite 330,
21 ;; Boston, MA 02111-1307, USA.
22
23
24 ;;- instruction definitions
25
26 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
27
28 ;;- When naming insn's (operand 0 of define_insn) be careful about using
29 ;;- names from other targets machine descriptions.
30
31 ;; MIL-STD-1750 specific remarks:
32 ;;
33 ;; 1) BITS_PER_UNIT = 16
34 ;;
35 ;; 2) GCC   to    MIL-STD-1750       data type mappings:
36 ;;    QImode => single integer (16 bits or 1 reg).
37 ;;    HImode => double integer (32 bits or 2 regs).
38 ;;    HFmode => single precision float (32 bits or 2 regs).
39 ;;    TQFmode => extended precision float (48 bits or 3 regs).
40 ;; 
41 ;; 3) Immediate integer operands Constraints:
42 ;;    'I'  1 .. 16
43 ;;    'J' -1 ..-16
44 ;;    'K'  0 .. 15
45 ;;    'L'  0 .. 255
46 ;;    'M' -32768 .. 32767
47 ;;    'O' => 0  (for optimizations and GCC quirks)
48 ;;
49 ;; Further notes:
50 ;;-  Assembly output ending in ".M" are macros in file M1750.INC
51
52
53 ;; stackpush
54 (define_insn ""
55   [(set (match_operand:QI 0 "push_operand" "=<")
56         (match_operand:QI 1 "general_operand" "r"))]
57   ""
58   "pshm r%1,r%1")
59
60 (define_insn ""
61   [(set (match_operand:HI 0 "push_operand" "=<")
62         (match_operand:HI 1 "general_operand" "r"))]
63   ""
64   "pshm r%1,r%d1")
65
66 (define_insn ""
67   [(set (match_operand:HF 0 "push_operand" "=<")
68         (match_operand:HF 1 "general_operand" "r"))]
69   ""
70   "pshm r%1,r%d1")
71
72 (define_insn ""
73   [(set (match_operand:TQF 0 "push_operand" "=<")
74         (match_operand:TQF 1 "general_operand" "r"))]
75   ""
76   "pshm r%1,r%t1")
77
78 ;; stackpop
79 (define_insn ""
80   [(set (match_operand:QI 0 "general_operand" "=r")
81         (match_operand:QI 1 "push_operand" ">"))]
82   ""
83   "popm r%1,r%1")
84
85 (define_insn ""
86   [(set (match_operand:HI 0 "general_operand" "=r")
87         (match_operand:HI 1 "push_operand" ">"))]
88   ""
89   "popm r%1,r%d1")
90
91 (define_insn ""
92   [(set (match_operand:HF 0 "general_operand" "=r")
93         (match_operand:HF 1 "push_operand" ">"))]
94   ""
95   "popm r%1,r%d1")
96    
97 (define_insn ""
98   [(set (match_operand:TQF 0 "general_operand" "=r")
99         (match_operand:TQF 1 "push_operand" ">"))]
100   ""
101   "popm r%1,r%t1")
102
103
104 ;; Test operations.
105
106 (define_insn "tstqi"
107   [(set (cc0)
108         (match_operand:QI 0 "register_operand" "r"))]
109   ""
110   "lr r%0,r%0   ; from tstqi")
111
112 (define_insn "tsthi"
113   [(set (cc0)
114         (match_operand:HI 0 "register_operand" "r"))]
115   ""
116   "dlr r%0,r%0   ; from tsthi")
117
118 ; With 1750A floats, testing the most significant word suffices.
119
120 (define_insn "tsthf"
121   [(set (cc0)
122         (match_operand:HF 0 "register_operand" "r"))]
123   ""
124   "lr r%0,r%0   ; tsthf")
125
126 (define_insn "tsttqf"
127   [(set (cc0)
128         (match_operand:TQF 0 "register_operand" "r"))]
129   ""
130   "lr r%0,r%0   ; tsttqf")
131
132
133 ;; block move.
134
135 (define_insn "movstrqi"
136   [(set (match_operand:BLK 0 "mov_memory_operand" "m")
137         (match_operand:BLK 1 "mov_memory_operand" "m"))
138    (use (match_operand:QI 2 "general_operand" "r"))
139    (match_operand 3 "" "")
140    (clobber (match_dup 0))
141    (clobber (match_dup 1))
142    (clobber (match_dup 2))]
143   ""
144   "*
145    {
146      rtx regops[3];
147
148      regops[0] = XEXP (operands[0], 0);
149      regops[1] = XEXP (operands[1], 0);
150      regops[2] = operands[2];
151
152      return movcnt_regno_adjust (regops);
153    } ")
154
155
156 ;; compare instructions.
157
158 (define_insn "cmpqi"
159   [(set (cc0)
160         (compare (match_operand:QI 0 "register_operand" "r,r,r,r,r")
161                  (match_operand:QI 1 "general_operand"  "I,J,i,r,m")))]
162   ""
163   "*
164    {
165      if (next_cc_user_is_unsigned (insn))
166        switch (which_alternative)
167          {
168          case 0:
169          case 1:
170          case 2:
171            return \"ucim.m %0,%1\";
172          case 3:
173            return \"ucr.m %0,%1\";
174          case 4:
175            return \"uc.m %0,%1\";
176          }
177      else
178        switch (which_alternative)
179          {
180          case 0:
181            return \"cisp r%0,%1\";
182          case 1:
183            return \"cisn r%0,%J1\";
184          case 2:
185            return \"cim  r%0,%1\";
186          case 3:
187            return \"cr   r%0,r%1\";
188          case 4:
189            return \"c    r%0,%1\";
190          }
191    } ")
192
193 (define_insn "cmphi"
194   [(set (cc0)
195         (compare (match_operand:HI 0 "general_operand" "r,r")
196                  (match_operand:HI 1 "general_operand" "r,m")))]
197   ""
198   "@
199     dcr r%0,r%1
200     dc  r%0,%1 ")
201
202 (define_insn "cmphf"
203  [(set (cc0)
204        (compare (match_operand:HF 0 "general_operand" "r,r")
205                 (match_operand:HF 1 "general_operand" "r,m")))]
206  ""
207  "@
208    fcr r%0,r%1
209    fc  r%0,%1 ")
210
211 (define_insn "cmptqf"
212   [(set (cc0)
213         (compare (match_operand:TQF 0 "general_operand" "r,r")
214                  (match_operand:TQF 1 "general_operand" "r,m")))]
215   ""
216   "@
217     efcr r%0,r%1
218     efc  r%0,%1 ")
219
220
221 ;; truncation instructions
222 ;;- 1750: any needed?
223
224 (define_insn "trunchiqi2"
225   [(set (match_operand:QI 0 "register_operand" "=r")
226         (truncate:QI (match_operand:HI 1 "register_operand" "r")))]
227   ""
228   "lr  r%0,r%d1")
229
230
231 ;; zero extension instructions: not defined, GCC can synthesize
232
233 ;; sign extension instructions
234
235 (define_insn "extendqihi2"
236   [(set (match_operand:HI 0 "register_operand" "=r,r")
237         (sign_extend:HI (match_operand:QI 1 "general_operand" "r,m")) )]
238   ""
239   "*
240     if (which_alternative == 0)
241       {
242         if (REGNO (operands [0]) != REGNO (operands [1]))
243           output_asm_insn (\"lr r%0,r%1\", operands);
244       }
245     else
246       output_asm_insn (\"l  r%0,%1\", operands);
247     return \"dsra r%0,16  ;extendqihi2\";
248   ")
249
250
251 ;; Conversions between float and double.
252
253 ; 1750 HF-to-TQF extend: just append 16 bits (least signif.) with all bits zero
254 (define_insn "extendhftqf2"
255   [(set (match_operand:TQF 0 "register_operand" "=r,r")
256         (float_extend:TQF (match_operand:HF 1 "general_operand" "r,m")))]
257   ""
258   "*
259     output_asm_insn(\"xorr r%t0,r%t0   ;extendhftqf2\", operands);
260     if (which_alternative == 0)
261       {
262         if (REGNO (operands[1]) != REGNO (operands[0]))
263           return \"dlr r%0,r%1\";
264         else
265           return \";\";
266       }
267     else
268       return \"dl  r%0,%1\";
269    ")
270
271 ; 1750 TQF-to-HF truncate is a no-op: just leave away the least signif. 16 bits
272 (define_insn "trunctqfhf2"
273   [(set (match_operand:HF 0 "register_operand" "=r,r")
274         (float_truncate:HF
275           (match_operand:TQF 1 "general_operand" "r,m")))]
276   ""
277   "@
278      dlr r%0,r%1  ;trunctqfhf2
279      dl  r%0,%1   ;trunctqfhf2 ")
280
281
282 ;; Conversion between fixed point and floating point.
283
284 (define_insn "floatqihf2"
285   [(set           (match_operand:HF 0 "register_operand" "=r")
286         (float:HF (match_operand:QI 1 "register_operand" "r")))]
287   ""
288   "flt r%0,r%1")
289
290 (define_insn "floathitqf2"
291   [(set           (match_operand:TQF 0 "register_operand" "=r")
292         (float:TQF (match_operand:HI 1 "register_operand" "r")))]
293   ""
294   "eflt r%0,r%1")
295
296
297 ;; Convert floats to ints
298
299 (define_insn "fix_trunchfqi2"
300   [(set                 (match_operand:QI 0 "register_operand" "=r")
301         (fix:QI (fix:HF (match_operand:HF 1 "register_operand" "r"))))]
302   ""
303   "fix r%0,r%1")
304
305 (define_insn "fix_trunctqfhi2"
306   [(set                 (match_operand:HI 0 "register_operand" "=r")
307         (fix:HI (fix:TQF (match_operand:TQF 1 "register_operand" "r"))))]
308   ""
309   "efix r%0,r%1")
310
311
312 ;; Move instructions
313
314 ;; We can't deal with normal byte-size characters, only with WIDE characters!
315 ;; This may appear as a serious restriction, but it also opens the doors
316 ;; for ISO 10646  :-)
317
318 ;; 16-bit moves
319
320 (define_insn "movqi"
321   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,r,r,m,m")
322         (match_operand:QI 1 "general_operand"  "O,I,J,i,r,m,r,K"))]
323   ""
324   "@
325      xorr r%0,r%0
326      lisp r%0,%1
327      lisn r%0,%J1
328      lim  r%0,%1
329      lr   r%0,r%1
330      l    r%0,%1
331      st   r%1,%0
332      stc  %1,%0   ")
333
334 ;; 32-bit moves
335
336 (define_insn ""
337   [(set (match_operand:HI 0 "general_operand" "=r,r,r,r,r,m,m")
338         (match_operand:HI 1 "general_operand"  "O,I,J,r,m,r,K"))]
339   ""
340   "@
341     xorr r%0,r%0\;xorr r%d0,r%d0
342     xorr r%0,r%0\;lisp r%d0,%1
343     lisn r%0,1  \;lisn r%d0,%J1
344     dlr  r%0,r%1
345     dl   r%0,%1
346     dst  r%1,%0
347     stc  0,%0   \;stc  %1,%A0 ")
348
349 (define_expand "movhi"
350   [(set (match_operand:HI 0 "general_operand" "=g")
351         (match_operand:HI 1 "general_operand"  "g"))]
352   ""
353   "
354    {
355      rtx op1 = operands[1];
356      if (GET_CODE (operands[0]) == MEM)
357        {
358          if (GET_CODE (op1) == MEM
359              || (GET_CODE (op1) == CONST_INT
360                  && (INTVAL (op1) < 0 || INTVAL (op1) > 15)))
361            operands[1] = force_reg (HImode, operands[1]);
362        }
363      else if (GET_CODE (op1) == CONST_INT
364               && (INTVAL (op1) < -16 || INTVAL (op1) > 16))
365        operands[1] = force_const_mem (HImode, operands[1]);
366    }")
367
368
369 ;; Single-Float moves
370
371 (define_insn "movhf"
372   [(set (match_operand:HF 0 "general_operand" "=r,r,m,m")
373         (match_operand:HF 1 "general_operand"  "r,m,r,G"))]
374   ""
375   "@
376     dlr  r%0,r%1
377     dl   r%0,%1
378     dst  r%1,%0
379     stc  0,%0   \;stc 0,%A0 ")
380
381
382 ;; Longfloat moves
383
384 (define_insn "movtqf"
385   [(set (match_operand:TQF 0 "general_operand" "=r,r,m")
386         (match_operand:TQF 1 "general_operand"  "r,m,r"))]
387   ""
388   "@
389     eflr.m %0,%1
390     efl  r%0,%1
391     efst r%1,%0 ")
392
393
394 ;; add instructions 
395
396 ;; single integer
397
398 (define_insn "addqi3"
399   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,r,m,m")
400         (plus:QI (match_operand:QI 1 "general_operand" "%0,0,0,0,0,0,0")
401                  (match_operand:QI 2 "general_operand"  "I,J,i,r,m,I,J")))]
402   ""
403   "*
404     switch (which_alternative)
405       {
406         case 0:
407           return \"aisp r%0,%2\";
408         case 1:
409           return \"sisp r%0,%J2\";
410         case 2:
411           if (INTVAL(operands[2]) < 0)
412             return \"sim r%0,%J2\";
413           else
414             return \"aim r%0,%2\";
415         case 3:
416           return \"ar r%0,r%2\";
417         case 4:
418           return \"a r%0,%2\";
419         case 5:
420           return \"incm %2,%0\";
421         case 6:
422           return \"decm %J2,%0\";
423       } ")
424
425 ;; double integer
426 (define_insn "addhi3"
427   [(set (match_operand:HI 0 "register_operand" "=r,r")
428         (plus:HI (match_operand:HI 1 "register_operand" "%0,0")
429                  (match_operand:HI 2 "general_operand" "r,m")))]
430   ""
431   "@
432     dar r%0,r%2
433     da  r%0,%2 ")
434
435 (define_insn "addhf3"
436   [(set (match_operand:HF 0 "register_operand" "=r,r")
437         (plus:HF (match_operand:HF 1 "register_operand" "%0,0")
438                  (match_operand:HF 2 "general_operand" "r,m")))]
439   ""
440   "@
441     far r%0,r%2
442     fa  r%0,%2 ")
443
444 (define_insn "addtqf3"
445   [(set (match_operand:TQF 0 "register_operand" "=r,r")
446         (plus:TQF (match_operand:TQF 1 "register_operand" "%0,0")
447                  (match_operand:TQF 2 "general_operand" "r,m")))]
448   ""
449   "@
450     efar r%0,r%2
451     efa  r%0,%2 ")
452
453
454 ;; subtract instructions
455
456 ;; single integer
457 (define_insn "subqi3"
458   [(set (match_operand:QI 0 "general_operand" "=r,r,r,r,m")
459         (minus:QI (match_operand:QI 1 "general_operand" "0,0,0,0,0")
460                   (match_operand:QI 2 "general_operand"  "I,i,r,m,I")))]
461   ""
462   "@
463     sisp r%0,%2
464     sim  r%0,%2
465     sr   r%0,r%2
466     s    r%0,%2
467     decm %2,%0 ")
468
469 ;; double integer
470 (define_insn "subhi3"
471   [(set (match_operand:HI 0 "register_operand" "=r,r")
472         (minus:HI (match_operand:HI 1 "register_operand" "0,0")
473                   (match_operand:HI 2 "general_operand" "r,m")))]
474   ""
475   "@
476     dsr r%0,r%2
477     ds  r%0,%2 ")
478
479 (define_insn "subhf3"
480   [(set (match_operand:HF 0 "register_operand" "=r,r")
481         (minus:HF (match_operand:HF 1 "register_operand" "0,0")
482                   (match_operand:HF 2 "general_operand" "r,m")))]
483   ""
484   "@
485     fsr r%0,r%2
486     fs  r%0,%2 ")
487
488 (define_insn "subtqf3"
489   [(set (match_operand:TQF 0 "register_operand" "=r,r")
490         (minus:TQF (match_operand:TQF 1 "register_operand" "0,0")
491                   (match_operand:TQF 2 "general_operand" "r,m")))]
492   ""
493   "@
494     efsr r%0,r%2
495     efs  r%0,%2 ")
496
497
498 ;; multiply instructions
499
500 (define_insn "mulqi3"
501   [(set (match_operand:QI 0 "register_operand" "=r,r,r,r,r")
502         (mult:QI (match_operand:QI 1 "register_operand" "%0,0,0,0,0")
503                  (match_operand:QI 2 "general_operand"  "I,J,M,r,m")))]
504   ""
505   "@
506      misp r%0,%2
507      misn r%0,%J2
508      msim r%0,%2
509      msr  r%0,r%2
510      ms   r%0,%2  ")
511
512
513 ; 32-bit product
514 (define_insn "mulqihi3"
515   [(set (match_operand:HI 0 "register_operand" "=r,r,r")
516     (mult:HI (sign_extend:HI (match_operand:QI 1 "register_operand" "%r,r,r"))
517              (sign_extend:HI (match_operand:QI 2 "general_operand" "r,m,i"))))]
518   ""
519   "*
520     if (REGNO (operands[1]) != REGNO (operands[0]))
521       output_asm_insn (\"lr r%0,r%1\", operands);
522
523     switch (which_alternative)
524       {
525       case 0:
526         return \"mr  r%0,r%2\";
527       case 1:
528         return \"m   r%0,%2\";
529       case 2:
530         return \"mim r%0,%2\";
531       }
532   ")
533
534
535 (define_insn "mulhi3"
536   [(set (match_operand:HI 0 "register_operand" "=r,r")
537         (mult:HI (match_operand:HI 1 "register_operand" "%0,0")
538                  (match_operand:HI 2 "general_operand" "r,m")))]
539   ""
540   "@
541     dmr r%0,r%2
542     dm  r%0,%2 ")
543
544 ; not available on 1750: "umulhi3","umulhisi3","umulsi3" (unsigned multiply's)
545
546 (define_insn "mulhf3"
547   [(set (match_operand:HF 0 "register_operand" "=r,r")
548         (mult:HF (match_operand:HF 1 "register_operand" "%0,0")
549                  (match_operand:HF 2 "general_operand" "r,m")))]
550   ""
551   "@
552     fmr r%0,r%2
553     fm  r%0,%2 ")
554
555 (define_insn "multqf3"
556   [(set (match_operand:TQF 0 "register_operand" "=r,r")
557         (mult:TQF (match_operand:TQF 1 "register_operand" "%0,0")
558                  (match_operand:TQF 2 "general_operand" "r,m")))]
559   ""
560   "@
561     efmr r%0,r%2
562     efm  r%0,%2 ")
563
564
565 ;; divide instructions
566 ;; The 1750 16bit integer division instructions deliver a 16-bit
567 ;; quotient and a 16-bit remainder, where the remainder is in the next higher
568 ;; register number above the quotient. For now, we haven't found a way
569 ;; to give the reload pass knowledge of this property. So we make do with
570 ;; whatever registers the allocator wants, and willy-nilly output a pair of
571 ;; register-copy ops when needed. (See mod_regno_adjust() in file aux-output.c)
572 ;; A comment in the description of `divmodM4' suggests that one leave the divM3
573 ;; undefined when there is a divmodM4 available.
574
575 (define_insn "divmodqi4"
576   [(set (match_operand:QI 0 "register_operand" "=r,r,r,r,r")
577         (div:QI (match_operand:QI 1 "register_operand" "0,0,0,0,0")
578                 (match_operand:QI 2 "general_operand"  "I,J,M,r,m")))
579    (set (match_operand:QI 3 "register_operand" "=r,r,r,r,r")
580         (mod:QI (match_dup 1) (match_dup 2)))]
581   ""
582   "*
583    {
584      char *istr;
585      switch(which_alternative)
586        {
587        case 0:
588          istr = \"disp\";
589          break;
590        case 1:
591          {
592            rtx new_opnds[4];
593            new_opnds[0] = operands[0];
594            new_opnds[1] = operands[1];
595            new_opnds[2] = gen_rtx (CONST_INT, VOIDmode, -INTVAL(operands[2]));
596            new_opnds[3] = operands[3];
597            istr = \"disn\";
598            return mod_regno_adjust (istr, new_opnds);
599          }
600          break;
601        case 2:
602          istr = \"dvim\";
603          break;
604        case 3:
605          istr = \"dvr \";
606          break;
607        case 4:
608          istr = \"dv  \";
609          break;
610       }
611       return mod_regno_adjust (istr, operands);
612      }")
613
614 ;; Division for other types is straightforward.
615
616 (define_insn "divhi3"
617   [(set (match_operand:HI 0 "register_operand" "=r,r")
618         (div:HI (match_operand:HI 1 "register_operand" "0,0")
619                 (match_operand:HI 2 "general_operand" "r,m")))]
620   ""
621   "@
622     ddr r%0,r%2
623     dd  r%0,%2 ")
624
625 (define_insn "divhf3"
626   [(set (match_operand:HF 0 "register_operand" "=r,r")
627         (div:HF (match_operand:HF 1 "register_operand" "0,0")
628                 (match_operand:HF 2 "general_operand" "r,m")))]
629   ""
630   "@
631     fdr r%0,r%2
632     fd  r%0,%2 ")
633
634 (define_insn "divtqf3"
635   [(set (match_operand:TQF 0 "register_operand" "=r,r")
636         (div:TQF (match_operand:TQF 1 "register_operand" "0,0")
637                 (match_operand:TQF 2 "general_operand" "r,m")))]
638   ""
639   "@
640     efdr r%0,r%2
641     efd  r%0,%2 ")
642
643
644 ;; Other arithmetic instructions:
645
646 ;; Absolute value
647
648 (define_insn "absqi2"
649   [(set (match_operand:QI 0 "register_operand" "=r")
650         (abs:QI (match_operand:QI 1 "register_operand" "r")))]
651   ""
652   "abs r%0,r%1")
653
654 (define_insn "abshi2"
655   [(set (match_operand:HI 0 "register_operand" "=r")
656         (abs:HI (match_operand:HI 1 "register_operand" "r")))]
657   ""
658   "dabs r%0,r%1")
659
660 (define_insn "abshf2"
661   [(set (match_operand:HF 0 "register_operand" "=r")
662         (abs:HF (match_operand:HF 1 "register_operand" "r")))]
663   ""
664   "fabs r%0,r%1")
665
666
667 ;; Negation
668
669 (define_insn "negqi2"
670   [(set (match_operand:QI 0 "register_operand" "=r")
671         (neg:QI (match_operand:QI 1 "register_operand" "r")))]
672   ""
673   "neg r%0,r%1")
674
675 (define_insn "neghi2"
676   [(set (match_operand:HI 0 "register_operand" "=r")
677         (neg:HI (match_operand:HI 1 "register_operand" "r")))]
678   ""
679   "dneg r%0,r%1")
680
681 (define_insn "neghf2"
682   [(set (match_operand:HF 0 "register_operand" "=r")
683         (neg:HF (match_operand:HF 1 "register_operand" "r")))]
684   ""
685   "fneg r%0,r%1")
686
687 ; The 1750A does not have an extended float negate instruction, so simulate.
688 (define_expand "negtqf2"
689   [(set (match_operand:TQF 0 "register_operand" "=&r")
690         (neg:TQF (match_operand:TQF 1 "register_operand" "r")))]
691   ""
692   "
693    emit_insn(gen_rtx(SET,VOIDmode,operands[0],CONST0_RTX(TQFmode)));
694    emit_insn(gen_rtx(SET,VOIDmode,operands[0],
695              gen_rtx(MINUS,TQFmode,operands[0],operands[1])));
696    DONE;
697   ")
698
699
700 ;; bit-logical instructions
701
702 ;; Set Bit
703 (define_insn ""
704   [(set (match_operand:QI 0 "general_operand" "=r,m")
705         (ior:QI  (match_operand:QI 1 "general_operand" "0,0")
706                  (match_operand:QI 2 "const_int_operand" "i,i")))]
707   "one_bit_set_p (INTVAL (operands [2]))"
708   "@
709     sbr    %b2,r%0
710     sb     %b2,%0")
711
712 ;; Reset Bit
713 (define_insn ""
714   [(set (match_operand:QI 0 "general_operand" "=r,m")
715         (and:QI  (match_operand:QI 1 "general_operand" "0,0")
716                  (match_operand:QI 2 "const_int_operand" "i,i")))]
717   "one_bit_set_p ((~INTVAL (operands [2])) & 0xffff)"
718   "@
719     rbr    %B2,r%0
720     rb     %B2,%0")
721
722 ;; Set Variable Bit
723 (define_insn ""
724   [(set (match_operand:QI 0 "register_operand" "=r")
725         (ior:QI  (match_operand:QI 1 "register_operand" "0")
726                  (lshiftrt:QI (const_int 0x8000)
727                       (match_operand:QI 2 "register_operand" "r"))))]
728   ""
729   "svbr   r%2,%r0")
730
731 ;; Reset Variable Bit
732 (define_insn ""
733   [(set (match_operand:QI 0 "general_operand" "=r")
734         (and:QI  (match_operand:QI 1 "general_operand" "0")
735             (not:QI (lshiftrt:QI (const_int 0x8000)
736                         (match_operand:QI 2 "register_operand" "r")))))]
737   ""
738   "rvbr   r%2,%r0")
739
740
741 ;; AND
742
743 (define_insn "andqi3"
744   [(set (match_operand:QI 0 "general_operand" "=r,r,r")
745         (and:QI (match_operand:QI 1 "general_operand" "%0,0,0")
746                 (match_operand:QI 2 "general_operand" "M,r,m")))]
747   ""
748   "@
749     andm r%0,%2
750     andr r%0,r%2
751     and  r%0,%2 ")
752
753 ; This sets incorrect condition codes. See notice_update_cc()
754 (define_insn "andhi3"
755   [(set (match_operand:HI 0 "register_operand" "=r")
756         (and:HI (match_operand:HI 1 "register_operand" "%0")
757                 (match_operand:HI 2 "register_operand" "r")))]
758   ""
759   "danr.m %0,%2")
760
761 ;; OR
762
763 (define_insn "iorqi3"
764   [(set (match_operand:QI 0 "general_operand" "=r,r,r")
765         (ior:QI  (match_operand:QI 1 "general_operand" "%0,0,0")
766                  (match_operand:QI 2 "general_operand" "M,r,m")))]
767   ""
768   "@
769     orim r%0,%2
770     orr  r%0,r%2
771     or   r%0,%2 ")
772
773 ; This sets incorrect condition codes. See notice_update_cc()
774 (define_insn "iorhi3"
775   [(set (match_operand:HI 0 "register_operand" "=r")
776         (ior:HI (match_operand:HI 1 "register_operand" "%0")
777                 (match_operand:HI 2 "register_operand" "r")))]
778   ""
779   "dorr.m %0,%2")
780
781 ;; XOR
782
783 (define_insn "xorqi3"
784   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
785         (xor:QI (match_operand:QI 1 "register_operand" "%0,0,0")
786                 (match_operand:QI 2 "general_operand"  "M,r,m")))]
787   ""
788   "@
789     xorm r%0,%2
790     xorr r%0,r%2
791     xor  r%0,%2 ")
792
793 ; This sets incorrect condition codes. See notice_update_cc()
794 (define_insn "xorhi3"
795   [(set (match_operand:HI 0 "register_operand" "=r")
796         (xor:HI (match_operand:HI 1 "register_operand" "%0")
797                 (match_operand:HI 2 "register_operand" "r")))]
798   ""
799   "dxrr.m %0,%2")
800
801 ;; NAND
802
803 (define_insn ""
804   [(set (match_operand:QI 0 "register_operand" "=r,r,r")
805         (ior:QI (not:QI (match_operand:QI 1 "register_operand" "%0,0,0"))
806                 (not:QI (match_operand:QI 2 "general_operand" "M,r,m"))))]
807   ""
808   "@
809     nim r%0,%2
810     nr  r%0,r%2
811     n   r%0,%2 ")
812
813 ; This sets incorrect condition codes. See notice_update_cc()
814 (define_insn ""
815   [(set (match_operand:HI 0 "register_operand" "=r")
816         (ior:HI (not:HI (match_operand:HI 1 "register_operand" "%0"))
817                 (not:HI (match_operand:HI 2 "register_operand" "r"))))]
818   ""
819   "dnr.m %0,%2")
820
821 ;; NOT
822
823 (define_insn "one_cmplqi2"
824   [(set (match_operand:QI 0 "register_operand" "=r")
825         (not:QI (match_operand:QI 1 "register_operand" "0")))]
826   ""
827   "nr r%0,r%0")
828
829 ; This sets incorrect condition codes. See notice_update_cc()
830 (define_insn "one_cmplhi2"
831   [(set (match_operand:HI 0 "register_operand" "=r")
832         (not:HI (match_operand:HI 1 "register_operand" "0")))]
833   ""
834   "dnr.m %0,%0")
835
836
837 ;; Shift instructions
838
839 ; (What to the 1750 is logical-shift-left, GCC likes to call "arithmetic")
840 (define_insn "ashlqi3"
841   [(set (match_operand:QI 0 "register_operand" "=r,r")
842         (ashift:QI (match_operand:QI 1 "register_operand" "0,0")
843                    (match_operand:QI 2 "nonmemory_operand" "I,r")))]
844   ""
845   "@
846     sll r%0,%2
847     slr r%0,r%2 ")
848
849 (define_insn "ashlhi3"
850   [(set (match_operand:HI 0 "register_operand" "=r,r")
851         (ashift:HI (match_operand:HI 1 "register_operand" "0,0")
852                    (match_operand:QI 2 "nonmemory_operand" "L,r")))]
853   ""                        ; the 'L' constraint is a slight imprecise...
854   "*
855     if (which_alternative == 1)
856       return \"dslr r%0,r%2\";
857     else if (INTVAL(operands[2]) <= 16)
858       return \"dsll r%0,%2\";
859     else
860       {
861         output_asm_insn (\"dsll r%0,16  ; ashlhi3 shiftcnt > 16\", operands);
862         return \"sll r%0,%w2\";
863       }
864   ")
865
866
867 ;; Right shift by a variable shiftcount works by negating the shift count,
868 ;; then emitting a right shift with the shift count negated.  This means
869 ;; that all actual shift counts in the RTL will be positive.  This 
870 ;; prevents converting shifts to ZERO_EXTRACTs with negative positions,
871 ;; which isn't valid.
872 (define_expand "lshrqi3"
873   [(set (match_operand:QI 0 "register_operand" "=r")
874         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
875                      (match_operand:QI 2 "nonmemory_operand" "g")))]
876   ""
877   "
878 {
879   if (GET_CODE (operands[2]) != CONST_INT)
880     operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
881 }")
882
883 (define_insn ""
884   [(set (match_operand:QI 0 "register_operand" "=r")
885         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
886                      (match_operand:QI 2 "immediate_operand" "I")))]
887   ""
888   "srl r%0,%2")
889
890 (define_insn ""
891   [(set (match_operand:QI 0 "register_operand" "=r")
892         (lshiftrt:QI (match_operand:QI 1 "register_operand" "0")
893                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
894   ""
895   "slr r%0,r%2 ")
896
897 ;; Same thing for HImode.
898
899 (define_expand "lshrhi3"
900   [(set (match_operand:HI 0 "register_operand" "=r")
901         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
902                      (match_operand:QI 2 "nonmemory_operand" "g")))]
903   ""
904   "
905   {
906     if (GET_CODE (operands[2]) != CONST_INT)
907       operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
908   }")
909
910 (define_insn ""
911   [(set (match_operand:HI 0 "register_operand" "=r")
912         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
913                      (match_operand:QI 2 "immediate_operand" "L")))]
914   ""
915   "*
916     if (INTVAL (operands[2]) <= 16)
917       return \"dsrl r%0,%2\";
918     output_asm_insn (\"dsrl r%0,16  ; lshrhi3 shiftcount > 16\", operands);
919     return \"srl  r%d0,%w2\";
920   ")
921
922 (define_insn ""
923   [(set (match_operand:HI 0 "register_operand" "=r")
924         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
925                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
926   ""
927   "dslr r%0,r%2 ")
928
929 ;; Same applies for arithmetic shift right.
930 (define_expand "ashrqi3"
931   [(set (match_operand:QI 0 "register_operand" "=r")
932         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
933                      (match_operand:QI 2 "nonmemory_operand" "g")))]
934   ""
935   "
936   {
937     if (GET_CODE (operands[2]) != CONST_INT)
938       operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
939   }")
940
941 (define_insn ""
942   [(set (match_operand:QI 0 "register_operand" "=r")
943         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
944                      (match_operand:QI 2 "immediate_operand" "I")))]
945   ""
946   "sra r%0,%2")
947
948 (define_insn ""
949   [(set (match_operand:QI 0 "register_operand" "=r")
950         (ashiftrt:QI (match_operand:QI 1 "register_operand" "0")
951                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
952   ""
953   "sar r%0,r%2 ")
954
955 ;; HImode arithmetic shift right.
956 (define_expand "ashrhi3"
957   [(set (match_operand:HI 0 "register_operand" "=r")
958         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
959                      (match_operand:QI 2 "nonmemory_operand" "g")))]
960   ""
961   "
962   {
963     if (GET_CODE (operands[2]) != CONST_INT)
964       operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
965   }")
966
967 (define_insn ""
968   [(set (match_operand:HI 0 "register_operand" "=r")
969         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
970                      (match_operand:QI 2 "immediate_operand" "L")))]
971   ""
972   "*
973     if (INTVAL (operands[2]) <= 16)
974       return \"dsra r%0,%2\";
975     output_asm_insn (\"dsra r%0,16  ; ashrhi3 shiftcount > 16\", operands);
976     return \"sra  r%d0,%w2\";
977   ")
978
979 (define_insn ""
980   [(set (match_operand:HI 0 "register_operand" "=r")
981         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
982                      (neg:QI (match_operand:QI 2 "register_operand" "r"))))]
983   ""
984   "dsar r%0,r%2 ")
985
986
987 ;; rotate instructions
988
989 (define_insn "rotlqi3"
990   [(set (match_operand:QI 0 "register_operand" "=r,r")
991         (rotate:QI (match_operand:QI 1 "register_operand" "0,0")
992                    (match_operand:QI 2 "nonmemory_operand" "I,r")))]
993   ""
994   "@
995     slc r%0,%2
996     scr r%0,r%2 ")
997
998 (define_insn "rotlhi3"
999   [(set (match_operand:HI 0 "register_operand" "=r,r")
1000         (rotate:HI (match_operand:HI 1 "register_operand" "0,0")
1001                    (match_operand:QI 2 "nonmemory_operand" "I,r")))]
1002   ""
1003   "@
1004     dslc r%0,%2
1005     dscr r%0,r%2 ")
1006
1007 (define_insn "rotrqi3"
1008   [(set (match_operand:QI 0 "register_operand" "=r")
1009         (rotatert:QI (match_operand:QI 1 "register_operand" "0")
1010                      (match_operand:QI 2 "register_operand" "r")))]
1011   ""
1012   "neg r%2,r%2\;scr r%0,r%2 ")
1013
1014 (define_insn "rotrhi3"
1015   [(set (match_operand:HI 0 "register_operand" "=r")
1016         (rotatert:HI (match_operand:HI 1 "register_operand" "0")
1017                      (match_operand:QI 2 "nonmemory_operand" "r")))]
1018   ""
1019   "neg  r%2,r%2\;dscr r%0,r%2 ")
1020
1021
1022
1023 ;; Special cases of bit-field insns which we should
1024 ;; recognize in preference to the general case.
1025 ;; These handle aligned 8-bit and 16-bit fields,
1026 ;; which can usually be done with move instructions.
1027 ;    1750: t.b.d.
1028 ;********************
1029
1030 ;; Bit field instructions, general cases.
1031 ;; "o,d" constraint causes a nonoffsetable memref to match the "o"
1032 ;; so that its address is reloaded.
1033
1034 ;; (define_insn "extv" ...
1035
1036 ;; (define_insn "extzv" ...
1037
1038 ;; (define_insn "insv" ...
1039
1040 ;; Now recognize bit field insns that operate on registers
1041 ;; (or at least were intended to do so).
1042 ;[unnamed only]
1043
1044 ;; Special patterns for optimizing bit-field instructions.
1045 ;**************************************
1046
1047 ; cc status test ops n.a. on 1750 ......... e.g. "sleu" on 68k:
1048 ;  [(set (match_operand:QI 0 "general_operand" "=d")
1049 ;        (leu (cc0) (const_int 0)))]
1050 ;  ""
1051 ;  "* cc_status = cc_prev_status;
1052 ;     return \"sls %0\"; ")
1053
1054
1055 ;; Basic conditional jump instructions.
1056
1057 (define_insn "beq"
1058   [(set (pc)
1059         (if_then_else (eq (cc0)
1060                           (const_int 0))
1061                       (label_ref (match_operand 0 "" ""))
1062                       (pc)))]
1063   ""
1064   "* return branch_or_jump (\"ez\", CODE_LABEL_NUMBER (operands[0]));
1065   ")
1066
1067 (define_insn "bne"
1068   [(set (pc)
1069         (if_then_else (ne (cc0)
1070                           (const_int 0))
1071                       (label_ref (match_operand 0 "" ""))
1072                       (pc)))]
1073   ""
1074   "* return branch_or_jump (\"nz\", CODE_LABEL_NUMBER (operands[0]));
1075   ")
1076
1077 (define_insn "bgt"
1078   [(set (pc)
1079         (if_then_else (gt (cc0)
1080                           (const_int 0))
1081                       (label_ref (match_operand 0 "" ""))
1082                       (pc)))]
1083   ""
1084   "* return branch_or_jump (\"gt\", CODE_LABEL_NUMBER (operands[0]));
1085   ")
1086
1087 (define_insn "blt"
1088   [(set (pc)
1089         (if_then_else (lt (cc0)
1090                           (const_int 0))
1091                       (label_ref (match_operand 0 "" ""))
1092                       (pc)))]
1093   ""
1094   "* return branch_or_jump (\"lt\", CODE_LABEL_NUMBER (operands[0]));
1095   ")
1096
1097 (define_insn "bge"
1098   [(set (pc)
1099         (if_then_else (ge (cc0)
1100                           (const_int 0))
1101                       (label_ref (match_operand 0 "" ""))
1102                       (pc)))]
1103   ""
1104   "* return branch_or_jump (\"ge\", CODE_LABEL_NUMBER (operands[0]));
1105   ")
1106
1107 (define_insn "ble"
1108   [(set (pc)
1109         (if_then_else (le (cc0)
1110                           (const_int 0))
1111                       (label_ref (match_operand 0 "" ""))
1112                       (pc)))]
1113   ""
1114   "* return branch_or_jump (\"le\", CODE_LABEL_NUMBER (operands[0]));
1115   ")
1116
1117
1118 ; no unsigned branches available on 1750. But GCC still needs them, so faking:
1119
1120 (define_insn "bgtu"
1121   [(set (pc)
1122         (if_then_else (gtu (cc0)
1123                           (const_int 0))
1124                       (label_ref (match_operand 0 "" ""))
1125                       (pc)))]
1126   ""
1127   "jc gt,%l0 ; Warning: this should be an *unsigned* test!")
1128
1129 (define_insn "bltu"
1130   [(set (pc)
1131         (if_then_else (ltu (cc0)
1132                           (const_int 0))
1133                       (label_ref (match_operand 0 "" ""))
1134                       (pc)))]
1135   ""
1136   "jc lt,%l0 ; Warning: this should be an *unsigned* test!")
1137
1138 (define_insn "bgeu"
1139   [(set (pc)
1140         (if_then_else (geu (cc0)
1141                           (const_int 0))
1142                       (label_ref (match_operand 0 "" ""))
1143                       (pc)))]
1144   ""
1145   "jc ge,%l0 ; Warning: this should be an *unsigned* test!")
1146
1147 (define_insn "bleu"
1148   [(set (pc)
1149         (if_then_else (leu (cc0)
1150                           (const_int 0))
1151                       (label_ref (match_operand 0 "" ""))
1152                       (pc)))]
1153   ""
1154   "jc le,%l0 ; Warning: this should be an *unsigned* test!")
1155
1156
1157 ;; Negated conditional jump instructions.
1158
1159 (define_insn ""
1160   [(set (pc)
1161         (if_then_else (eq (cc0)
1162                           (const_int 0))
1163                       (pc)
1164                       (label_ref (match_operand 0 "" ""))))]
1165   ""
1166   "* return branch_or_jump (\"nz\", CODE_LABEL_NUMBER (operands[0]));
1167   ")
1168
1169 (define_insn ""
1170   [(set (pc)
1171         (if_then_else (ne (cc0)
1172                           (const_int 0))
1173                       (pc)
1174                       (label_ref (match_operand 0 "" ""))))]
1175   ""
1176   "* return branch_or_jump (\"ez\", CODE_LABEL_NUMBER (operands[0]));
1177   ")
1178
1179 (define_insn ""
1180   [(set (pc)
1181         (if_then_else (gt (cc0)
1182                           (const_int 0))
1183                       (pc)
1184                       (label_ref (match_operand 0 "" ""))))]
1185   ""
1186   "* return branch_or_jump (\"le\", CODE_LABEL_NUMBER (operands[0]));
1187   ")
1188
1189 (define_insn ""
1190   [(set (pc)
1191         (if_then_else (lt (cc0)
1192                           (const_int 0))
1193                       (pc)
1194                       (label_ref (match_operand 0 "" ""))))]
1195   ""
1196   "* return branch_or_jump (\"ge\", CODE_LABEL_NUMBER (operands[0]));
1197   ")
1198
1199 (define_insn ""
1200   [(set (pc)
1201         (if_then_else (ge (cc0)
1202                           (const_int 0))
1203                       (pc)
1204                       (label_ref (match_operand 0 "" ""))))]
1205   ""
1206   "* return branch_or_jump (\"lt\", CODE_LABEL_NUMBER (operands[0]));
1207   ")
1208
1209 (define_insn ""
1210   [(set (pc)
1211         (if_then_else (le (cc0)
1212                           (const_int 0))
1213                       (pc)
1214                       (label_ref (match_operand 0 "" ""))))]
1215   ""
1216   "* return branch_or_jump (\"gt\", CODE_LABEL_NUMBER (operands[0]));
1217   ")
1218
1219
1220 ;; Negated unsigned conditional jump instructions (faked for 1750).
1221
1222 (define_insn ""
1223   [(set (pc)
1224         (if_then_else (gtu (cc0)
1225                           (const_int 0))
1226                       (pc)
1227                       (label_ref (match_operand 0 "" ""))))]
1228   ""
1229   "jc le,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1230
1231 (define_insn ""
1232   [(set (pc)
1233         (if_then_else (ltu (cc0)
1234                           (const_int 0))
1235                       (pc)
1236                       (label_ref (match_operand 0 "" ""))))]
1237   ""
1238   "jc ge,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1239
1240 (define_insn ""
1241   [(set (pc)
1242         (if_then_else (geu (cc0)
1243                           (const_int 0))
1244                       (pc)
1245                       (label_ref (match_operand 0 "" ""))))]
1246   ""
1247   "jc lt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1248
1249 (define_insn ""
1250   [(set (pc)
1251         (if_then_else (leu (cc0)
1252                           (const_int 0))
1253                       (pc)
1254                       (label_ref (match_operand 0 "" ""))))]
1255   ""
1256   "jc gt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!")
1257
1258 ;; Tablejump 
1259 ;; 1750 note: CASE_VECTOR_PC_RELATIVE is not defined
1260 (define_insn "tablejump"
1261   [(set (pc)
1262         (match_operand:QI 0 "register_operand" "b"))
1263    (use (label_ref (match_operand 1 "" "")))]
1264   ""
1265   "jc 15,0,r%0   ; tablejump label_ref=%1")
1266
1267
1268 ;; Unconditional jump
1269 (define_insn "jump"
1270   [(set (pc)
1271         (label_ref (match_operand 0 "" "")))]
1272   ""
1273   "jc 15,%0")
1274
1275 ;; Call subroutine, returning value in operand 0
1276 ;; (which must be a hard register).
1277 (define_insn "call_value"
1278   [(set (match_operand 0 "register_operand" "r")
1279         (call (match_operand:QI 1 "memory_operand" "m")
1280               (match_operand:QI 2 "general_operand" "g")))]
1281   ;; Operand 2 not really used for 1750.
1282   ""
1283   "sjs r15,%1   ; return value in R0")
1284
1285 ;; Call subroutine with no return value.
1286
1287 ;;  Operand 1 not really used in MIL-STD-1750.
1288 (define_insn ""
1289   [(call (match_operand:QI 0 "memory_operand" "mp")
1290          (match_operand:QI 1 "general_operand" ""))]
1291   ""
1292   "sjs r15,%0   ; no return value")
1293
1294 ;;;;;;;;;;;; 1750: NOT READY YET.
1295 (define_insn "call"
1296   [(call (match_operand:QI 0 "" "")
1297          (match_operand:QI 1 "" ""))]
1298   ""
1299   "ANYCALL %0")
1300
1301
1302 ; (define_insn "return"
1303 ;   [(return)]
1304 ;   ""
1305 ;   "*
1306 ;    { 
1307 ;         rtx oprnd = gen_rtx(CONST_INT,VOIDmode,get_frame_size());
1308 ;         output_asm_insn(\"ret.m  %0\",&oprnd);
1309 ;         return \"\;\";
1310 ;    } ")
1311
1312 (define_insn "indirect_jump"
1313   [(set (pc) (match_operand:QI 0 "address_operand" "p"))]
1314   ""
1315   "jci 15,%0")
1316
1317 (define_insn "nop"
1318   [(const_int 0)]
1319   ""
1320   "nop")
1321
1322
1323 ;; Subtract One and Jump (if non-zero)
1324 (define_peephole 
1325   [(set (match_operand:QI 0 "register_operand" "=r")
1326         (plus:QI (match_operand:QI 1 "register_operand" "%0")
1327                  (match_operand:QI 2 "immediate_operand" "J")))
1328    (set (cc0) (match_dup 0))
1329    (set (pc)
1330         (if_then_else (ne (cc0) (const_int 0))
1331          (label_ref (match_operand 3 "" ""))
1332          (pc)))
1333    ]
1334   "INTVAL(operands[2]) == -1"
1335   "soj r%0,%3")
1336
1337 ;; Combine a Load Register with subsequent increment/decrement into a LIM
1338 (define_peephole 
1339   [(set (match_operand:QI 0 "register_operand" "=r")
1340         (match_operand:QI 1 "register_operand" "b"))
1341    (set (match_dup 0)
1342         (plus:QI (match_dup 0)
1343                  (match_operand:QI 2 "immediate_operand" "i")))]
1344   "REGNO(operands[1]) > 0"
1345   "lim r%0,%2,r%1  ; LR,inc/dec peephole")
1346
1347 ;; Eliminate the redundant load in a store/load sequence
1348 (define_peephole 
1349   [(set (mem:QI (plus:QI (match_operand:QI 0 "register_operand" "r")
1350                           (match_operand:QI 1 "immediate_operand" "i")))
1351         (match_operand:QI 2 "register_operand" "r"))
1352    (set (match_operand:QI 3 "register_operand" "=r")
1353         (mem:QI (plus:QI (match_dup 0)
1354                          (match_dup 1))))
1355    ]
1356   "REGNO(operands[2]) == REGNO(operands[3])"
1357   "st r%2,%1,r%0  ; eliminated previous redundant load")
1358
1359 ;;;End.