home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / NeXT / GnuSource / cc-61.0.1 / cc / config / vax.md < prev    next >
Text File  |  1991-06-03  |  49KB  |  1,791 lines
  1. ;;- Machine description for GNU compiler, Vax Version
  2. ;;   Copyright (C) 1987-1991 Free Software Foundation, Inc.
  3.  
  4. ;; This file is part of GNU CC.
  5.  
  6. ;; GNU CC is free software; you can redistribute it and/or modify
  7. ;; it under the terms of the GNU General Public License as published by
  8. ;; the Free Software Foundation; either version 2, or (at your option)
  9. ;; any later version.
  10.  
  11. ;; GNU CC is distributed in the hope that it will be useful,
  12. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. ;; GNU General Public License for more details.
  15.  
  16. ;; You should have received a copy of the GNU General Public License
  17. ;; along with GNU CC; see the file COPYING.  If not, write to
  18. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20.  
  21. ;;- Instruction patterns.  When multiple patterns apply,
  22. ;;- the first one in the file is chosen.
  23. ;;-
  24. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  25. ;;-
  26. ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code
  27. ;;- updates for most instructions.
  28.  
  29. ; tstsi is first test insn so that it is the one to match
  30. ; a constant argument.
  31.  
  32. (define_insn "tstsi"
  33.   [(set (cc0)
  34.     (match_operand:SI 0 "general_operand" "g"))]
  35.   ""
  36.   "tstl %0")
  37.  
  38. (define_insn "tsthi"
  39.   [(set (cc0)
  40.     (match_operand:HI 0 "general_operand" "g"))]
  41.   ""
  42.   "tstw %0")
  43.  
  44. (define_insn "tstqi"
  45.   [(set (cc0)
  46.     (match_operand:QI 0 "general_operand" "g"))]
  47.   ""
  48.   "tstb %0")
  49.  
  50. (define_insn "tstdf"
  51.   [(set (cc0)
  52.     (match_operand:DF 0 "general_operand" "gF"))]
  53.   ""
  54.   "tst%# %0")
  55.  
  56. (define_insn "tstsf"
  57.   [(set (cc0)
  58.     (match_operand:SF 0 "general_operand" "gF"))]
  59.   ""
  60.   "tstf %0")
  61.  
  62. ;; Put cmpsi first among compare insns so it matches two CONST_INT operands.
  63.  
  64. (define_insn "cmpsi"
  65.   [(set (cc0)
  66.     (compare (match_operand:SI 0 "general_operand" "g")
  67.          (match_operand:SI 1 "general_operand" "g")))]
  68.   ""
  69.   "cmpl %0,%1")
  70.  
  71. (define_insn "cmphi"
  72.   [(set (cc0)
  73.     (compare (match_operand:HI 0 "general_operand" "g")
  74.          (match_operand:HI 1 "general_operand" "g")))]
  75.   ""
  76.   "cmpw %0,%1")
  77.  
  78. (define_insn "cmpqi"
  79.   [(set (cc0)
  80.     (compare (match_operand:QI 0 "general_operand" "g")
  81.          (match_operand:QI 1 "general_operand" "g")))]
  82.   ""
  83.   "cmpb %0,%1")
  84.  
  85. (define_insn "cmpdf"
  86.   [(set (cc0)
  87.     (compare (match_operand:DF 0 "general_operand" "gF")
  88.          (match_operand:DF 1 "general_operand" "gF")))]
  89.   ""
  90.   "cmp%# %0,%1")
  91.  
  92. (define_insn "cmpsf"
  93.   [(set (cc0)
  94.     (compare (match_operand:SF 0 "general_operand" "gF")
  95.          (match_operand:SF 1 "general_operand" "gF")))]
  96.   ""
  97.   "cmpf %0,%1")
  98.  
  99. (define_insn ""
  100.   [(set (cc0)
  101.     (and:SI (match_operand:SI 0 "general_operand" "g")
  102.         (match_operand:SI 1 "general_operand" "g")))]
  103.   ""
  104.   "bitl %0,%1")
  105.  
  106. (define_insn ""
  107.   [(set (cc0)
  108.     (and:HI (match_operand:HI 0 "general_operand" "g")
  109.         (match_operand:HI 1 "general_operand" "g")))]
  110.   ""
  111.   "bitw %0,%1")
  112.  
  113. (define_insn ""
  114.   [(set (cc0)
  115.     (and:QI (match_operand:QI 0 "general_operand" "g")
  116.         (match_operand:QI 1 "general_operand" "g")))]
  117.   ""
  118.   "bitb %0,%1")
  119.  
  120. (define_insn "movdf"
  121.   [(set (match_operand:DF 0 "general_operand" "=g,g")
  122.     (match_operand:DF 1 "general_operand" "G,gF"))]
  123.   ""
  124.   "@
  125.    clr%# %0
  126.    mov%# %1,%0")
  127.  
  128. (define_insn "movsf"
  129.   [(set (match_operand:SF 0 "general_operand" "=g,g")
  130.     (match_operand:SF 1 "general_operand" "G,gF"))]
  131.   ""
  132.   "@
  133.    clrf %0
  134.    movf %1,%0")
  135.  
  136. ;; Some vaxes don't support this instruction.
  137. ;;(define_insn "movti"
  138. ;;  [(set (match_operand:TI 0 "general_operand" "=g")
  139. ;;    (match_operand:TI 1 "general_operand" "g"))]
  140. ;;  ""
  141. ;;  "movh %1,%0")
  142.  
  143. (define_insn "movdi"
  144.   [(set (match_operand:DI 0 "general_operand" "=g,g")
  145.     (match_operand:DI 1 "general_operand" "I,g"))]
  146.   ""
  147.   "@
  148.    clrq %0
  149.    movq %1,%0")
  150.  
  151. (define_insn "movsi"
  152.   [(set (match_operand:SI 0 "general_operand" "=g")
  153.     (match_operand:SI 1 "general_operand" "g"))]
  154.   ""
  155.   "*
  156. {
  157.   rtx link;
  158.   if (operands[1] == const1_rtx
  159.       && (link = find_reg_note (insn, REG_WAS_0, 0))
  160.       /* Make sure the insn that stored the 0 is still present.  */
  161.       && ! INSN_DELETED_P (XEXP (link, 0))
  162.       && GET_CODE (XEXP (link, 0)) != NOTE
  163.       /* Make sure cross jumping didn't happen here.  */
  164.       && no_labels_between_p (XEXP (link, 0), insn))
  165.     /* Fastest way to change a 0 to a 1.  */
  166.     return \"incl %0\";
  167.   if (GET_CODE (operands[1]) == SYMBOL_REF || GET_CODE (operands[1]) == CONST)
  168.     {
  169.       if (push_operand (operands[0], SImode))
  170.     return \"pushab %a1\";
  171.       return \"movab %a1,%0\";
  172.     }
  173.   /* this is slower than a movl, except when pushing an operand */
  174.   if (operands[1] == const0_rtx)
  175.     return \"clrl %0\";
  176.   if (GET_CODE (operands[1]) == CONST_INT
  177.       && (unsigned) INTVAL (operands[1]) >= 64)
  178.     {
  179.       int i = INTVAL (operands[1]);
  180.       if ((unsigned)(~i) < 64)
  181.     {
  182.       operands[1] = gen_rtx (CONST_INT, VOIDmode, ~i);
  183.       return \"mcoml %1,%0\";
  184.     }
  185.       if ((unsigned)i < 127)
  186.     {
  187.       operands[1] = gen_rtx (CONST_INT, VOIDmode, 63);
  188.       operands[2] = gen_rtx (CONST_INT, VOIDmode, i-63);
  189.       return \"addl3 %2,%1,%0\";
  190.     }
  191.       /* trading speed for space */
  192.       if ((unsigned)i < 0x100)
  193.     return \"movzbl %1,%0\";
  194.       if (i >= -0x80 && i < 0)
  195.     return \"cvtbl %1,%0\";
  196.       if ((unsigned)i < 0x10000)
  197.     return \"movzwl %1,%0\";
  198.       if (i >= -0x8000 && i < 0)
  199.     return \"cvtwl %1,%0\";
  200.     }
  201.   if (push_operand (operands[0], SImode))
  202.     return \"pushl %1\";
  203.   return \"movl %1,%0\";
  204. }")
  205.  
  206. (define_insn "movhi"
  207.   [(set (match_operand:HI 0 "general_operand" "=g")
  208.     (match_operand:HI 1 "general_operand" "g"))]
  209.   ""
  210.   "*
  211. {
  212.   rtx link;
  213.   if (operands[1] == const1_rtx
  214.       && (link = find_reg_note (insn, REG_WAS_0, 0))
  215.       /* Make sure the insn that stored the 0 is still present.  */
  216.       && ! INSN_DELETED_P (XEXP (link, 0))
  217.       && GET_CODE (XEXP (link, 0)) != NOTE
  218.       /* Make sure cross jumping didn't happen here.  */
  219.       && no_labels_between_p (XEXP (link, 0), insn))
  220.     /* Fastest way to change a 0 to a 1.  */
  221.     return \"incw %0\";
  222.   if (operands[1] == const0_rtx)
  223.     return \"clrw %0\";
  224.   if (GET_CODE (operands[1]) == CONST_INT
  225.       && (unsigned) INTVAL (operands[1]) >= 64)
  226.     {
  227.       int i = INTVAL (operands[1]);
  228.       if ((unsigned)((~i) & 0xffff) < 64)
  229.     {
  230.       operands[1] = gen_rtx (CONST_INT, VOIDmode, (~i) & 0xffff);
  231.       return \"mcomw %1,%0\";
  232.     }
  233.       if ((unsigned)(i & 0xffff) < 127)
  234.     {
  235.        operands[1] = gen_rtx (CONST_INT, VOIDmode, 63);
  236.        operands[2] = gen_rtx (CONST_INT, VOIDmode, (i-63) & 0xffff);
  237.        return \"addw3 %2,%1,%0\";
  238.     }
  239.       /* this is a lot slower, and only saves 1 measly byte! */
  240.       /* if ((unsigned)i < 0x100)
  241.        return \"movzbw %1,%0\"; */
  242.       /* if (i >= -0x80 && i < 0)
  243.        return \"cvtbw %1,%0\"; */
  244.     }
  245.   return \"movw %1,%0\";
  246. }")
  247.  
  248. (define_insn "movqi"
  249.   [(set (match_operand:QI 0 "general_operand" "=g")
  250.     (match_operand:QI 1 "general_operand" "g"))]
  251.   ""
  252.   "*
  253. {
  254.   if (operands[1] == const0_rtx)
  255.     return \"clrb %0\";
  256.   if (GET_CODE (operands[1]) == CONST_INT
  257.       && (unsigned) INTVAL (operands[1]) >= 64)
  258.     {
  259.       int i = INTVAL (operands[1]);
  260.       if ((unsigned)((~i) & 0xff) < 64)
  261.     {
  262.       operands[1] = gen_rtx (CONST_INT, VOIDmode, (~i) & 0xff);
  263.       return \"mcomb %1,%0\";
  264.     }
  265.     }
  266.   return \"movb %1,%0\";
  267. }")
  268.  
  269. ;; The definition of this insn does not really explain what it does,
  270. ;; but it should suffice
  271. ;; that anything generated as this insn will be recognized as one
  272. ;; and that it won't successfully combine with anything.
  273. (define_insn "movstrhi"
  274.   [(set (match_operand:BLK 0 "general_operand" "=g")
  275.     (match_operand:BLK 1 "general_operand" "g"))
  276.    (use (match_operand:HI 2 "general_operand" "g"))
  277.    (clobber (reg:SI 0))
  278.    (clobber (reg:SI 1))
  279.    (clobber (reg:SI 2))
  280.    (clobber (reg:SI 3))
  281.    (clobber (reg:SI 4))
  282.    (clobber (reg:SI 5))]
  283.   ""
  284.   "movc3 %2,%1,%0")
  285.  
  286. ;; Extension and truncation insns.
  287. ;; Those for integer source operand
  288. ;; are ordered widest source type first.
  289.  
  290. (define_insn "truncsiqi2"
  291.   [(set (match_operand:QI 0 "general_operand" "=g")
  292.     (truncate:QI (match_operand:SI 1 "general_operand" "g")))]
  293.   ""
  294.   "cvtlb %1,%0")
  295.  
  296. (define_insn "truncsihi2"
  297.   [(set (match_operand:HI 0 "general_operand" "=g")
  298.     (truncate:HI (match_operand:SI 1 "general_operand" "g")))]
  299.   ""
  300.   "cvtlw %1,%0")
  301.  
  302. (define_insn "trunchiqi2"
  303.   [(set (match_operand:QI 0 "general_operand" "=g")
  304.     (truncate:QI (match_operand:HI 1 "general_operand" "g")))]
  305.   ""
  306.   "cvtwb %1,%0")
  307.  
  308. (define_insn "extendhisi2"
  309.   [(set (match_operand:SI 0 "general_operand" "=g")
  310.     (sign_extend:SI (match_operand:HI 1 "general_operand" "g")))]
  311.   ""
  312.   "cvtwl %1,%0")
  313.  
  314. (define_insn "extendqihi2"
  315.   [(set (match_operand:HI 0 "general_operand" "=g")
  316.     (sign_extend:HI (match_operand:QI 1 "general_operand" "g")))]
  317.   ""
  318.   "cvtbw %1,%0")
  319.  
  320. (define_insn "extendqisi2"
  321.   [(set (match_operand:SI 0 "general_operand" "=g")
  322.     (sign_extend:SI (match_operand:QI 1 "general_operand" "g")))]
  323.   ""
  324.   "cvtbl %1,%0")
  325.  
  326. (define_insn "extendsfdf2"
  327.   [(set (match_operand:DF 0 "general_operand" "=g")
  328.     (float_extend:DF (match_operand:SF 1 "general_operand" "gF")))]
  329.   ""
  330.   "cvtf%# %1,%0")
  331.  
  332. (define_insn "truncdfsf2"
  333.   [(set (match_operand:SF 0 "general_operand" "=g")
  334.     (float_truncate:SF (match_operand:DF 1 "general_operand" "gF")))]
  335.   ""
  336.   "cvt%#f %1,%0")
  337.  
  338. (define_insn "zero_extendhisi2"
  339.   [(set (match_operand:SI 0 "general_operand" "=g")
  340.     (zero_extend:SI (match_operand:HI 1 "general_operand" "g")))]
  341.   ""
  342.   "movzwl %1,%0")
  343.  
  344. (define_insn "zero_extendqihi2"
  345.   [(set (match_operand:HI 0 "general_operand" "=g")
  346.     (zero_extend:HI (match_operand:QI 1 "general_operand" "g")))]
  347.   ""
  348.   "movzbw %1,%0")
  349.  
  350. (define_insn "zero_extendqisi2"
  351.   [(set (match_operand:SI 0 "general_operand" "=g")
  352.     (zero_extend:SI (match_operand:QI 1 "general_operand" "g")))]
  353.   ""
  354.   "movzbl %1,%0")
  355.  
  356. ;; Fix-to-float conversion insns.
  357. ;; Note that the ones that start with SImode come first.
  358. ;; That is so that an operand that is a CONST_INT
  359. ;; (and therefore lacks a specific machine mode).
  360. ;; will be recognized as SImode (which is always valid)
  361. ;; rather than as QImode or HImode.
  362.  
  363. (define_insn "floatsisf2"
  364.   [(set (match_operand:SF 0 "general_operand" "=g")
  365.     (float:SF (match_operand:SI 1 "general_operand" "g")))]
  366.   ""
  367.   "cvtlf %1,%0")
  368.  
  369. (define_insn "floatsidf2"
  370.   [(set (match_operand:DF 0 "general_operand" "=g")
  371.     (float:DF (match_operand:SI 1 "general_operand" "g")))]
  372.   ""
  373.   "cvtl%# %1,%0")
  374.  
  375. (define_insn "floathisf2"
  376.   [(set (match_operand:SF 0 "general_operand" "=g")
  377.     (float:SF (match_operand:HI 1 "general_operand" "g")))]
  378.   ""
  379.   "cvtwf %1,%0")
  380.  
  381. (define_insn "floathidf2"
  382.   [(set (match_operand:DF 0 "general_operand" "=g")
  383.     (float:DF (match_operand:HI 1 "general_operand" "g")))]
  384.   ""
  385.   "cvtw%# %1,%0")
  386.  
  387. (define_insn "floatqisf2"
  388.   [(set (match_operand:SF 0 "general_operand" "=g")
  389.     (float:SF (match_operand:QI 1 "general_operand" "g")))]
  390.   ""
  391.   "cvtbf %1,%0")
  392.  
  393. (define_insn "floatqidf2"
  394.   [(set (match_operand:DF 0 "general_operand" "=g")
  395.     (float:DF (match_operand:QI 1 "general_operand" "g")))]
  396.   ""
  397.   "cvtb%# %1,%0")
  398.  
  399. ;; Float-to-fix conversion insns.
  400.  
  401. (define_insn "fix_truncsfqi2"
  402.   [(set (match_operand:QI 0 "general_operand" "=g")
  403.     (fix:QI (fix:SF (match_operand:SF 1 "general_operand" "gF"))))]
  404.   ""
  405.   "cvtfb %1,%0")
  406.  
  407. (define_insn "fix_truncsfhi2"
  408.   [(set (match_operand:HI 0 "general_operand" "=g")
  409.     (fix:HI (fix:SF (match_operand:SF 1 "general_operand" "gF"))))]
  410.   ""
  411.   "cvtfw %1,%0")
  412.  
  413. (define_insn "fix_truncsfsi2"
  414.   [(set (match_operand:SI 0 "general_operand" "=g")
  415.     (fix:SI (fix:SF (match_operand:SF 1 "general_operand" "gF"))))]
  416.   ""
  417.   "cvtfl %1,%0")
  418.  
  419. (define_insn "fix_truncdfqi2"
  420.   [(set (match_operand:QI 0 "general_operand" "=g")
  421.     (fix:QI (fix:DF (match_operand:DF 1 "general_operand" "gF"))))]
  422.   ""
  423.   "cvt%#b %1,%0")
  424.  
  425. (define_insn "fix_truncdfhi2"
  426.   [(set (match_operand:HI 0 "general_operand" "=g")
  427.     (fix:HI (fix:DF (match_operand:DF 1 "general_operand" "gF"))))]
  428.   ""
  429.   "cvt%#w %1,%0")
  430.  
  431. (define_insn "fix_truncdfsi2"
  432.   [(set (match_operand:SI 0 "general_operand" "=g")
  433.     (fix:SI (fix:DF (match_operand:DF 1 "general_operand" "gF"))))]
  434.   ""
  435.   "cvt%#l %1,%0")
  436.  
  437. ;;- All kinds of add instructions.
  438.  
  439. (define_insn "adddf3"
  440.   [(set (match_operand:DF 0 "general_operand" "=g,g,g")
  441.     (plus:DF (match_operand:DF 1 "general_operand" "0,gF,gF")
  442.          (match_operand:DF 2 "general_operand" "gF,0,gF")))]
  443.   ""
  444.   "@
  445.    add%#2 %2,%0
  446.    add%#2 %1,%0
  447.    add%#3 %1,%2,%0")
  448.  
  449. (define_insn "addsf3"
  450.   [(set (match_operand:SF 0 "general_operand" "=g,g,g")
  451.     (plus:SF (match_operand:SF 1 "general_operand" "0,gF,gF")
  452.          (match_operand:SF 2 "general_operand" "gF,0,gF")))]
  453.   ""
  454.   "@
  455.    addf2 %2,%0
  456.    addf2 %1,%0
  457.    addf3 %1,%2,%0")
  458.  
  459. (define_insn "addsi3"
  460.   [(set (match_operand:SI 0 "general_operand" "=g")
  461.     (plus:SI (match_operand:SI 1 "general_operand" "g")
  462.          (match_operand:SI 2 "general_operand" "g")))]
  463.   ""
  464.   "*
  465. {
  466.   if (rtx_equal_p (operands[0], operands[1]))
  467.     {
  468.       if (operands[2] == const1_rtx)
  469.     return \"incl %0\";
  470.       if (operands[2] == constm1_rtx)
  471.     return \"decl %0\";
  472.       if (GET_CODE (operands[2]) == CONST_INT
  473.       && (unsigned) (- INTVAL (operands[2])) < 64)
  474.     return \"subl2 $%n2,%0\";
  475.       if (GET_CODE (operands[2]) == CONST_INT
  476.       && (unsigned) INTVAL (operands[2]) >= 64
  477.       && GET_CODE (operands[1]) == REG)
  478.     return \"movab %c2(%1),%0\";
  479.       return \"addl2 %2,%0\";
  480.     }
  481.   if (rtx_equal_p (operands[0], operands[2]))
  482.     return \"addl2 %1,%0\";
  483.   if (GET_CODE (operands[2]) == CONST_INT
  484.       && (unsigned) (- INTVAL (operands[2])) < 64)
  485.     return \"subl3 $%n2,%1,%0\";
  486.   if (GET_CODE (operands[2]) == CONST_INT
  487.       && (unsigned) INTVAL (operands[2]) >= 64
  488.       && GET_CODE (operands[1]) == REG)
  489.     {
  490.       if (push_operand (operands[0], SImode))
  491.     return \"pushab %c2(%1)\";
  492.       return \"movab %c2(%1),%0\";
  493.     }
  494.   return \"addl3 %1,%2,%0\";
  495. }")
  496.  
  497. (define_insn "addhi3"
  498.   [(set (match_operand:HI 0 "general_operand" "=g")
  499.     (plus:HI (match_operand:HI 1 "general_operand" "g")
  500.          (match_operand:HI 2 "general_operand" "g")))]
  501.   ""
  502.   "*
  503. {
  504.   if (rtx_equal_p (operands[0], operands[1]))
  505.     {
  506.       if (operands[2] == const1_rtx)
  507.     return \"incw %0\";
  508.       if (operands[2] == constm1_rtx)
  509.     return \"decw %0\";
  510.       if (GET_CODE (operands[2]) == CONST_INT
  511.       && (unsigned) (- INTVAL (operands[2])) < 64)
  512.     return \"subw2 $%n2,%0\";
  513.       return \"addw2 %2,%0\";
  514.     }
  515.   if (rtx_equal_p (operands[0], operands[2]))
  516.     return \"addw2 %1,%0\";
  517.   if (GET_CODE (operands[2]) == CONST_INT
  518.       && (unsigned) (- INTVAL (operands[2])) < 64)
  519.     return \"subw3 $%n2,%1,%0\";
  520.   return \"addw3 %1,%2,%0\";
  521. }")
  522.  
  523. (define_insn "addqi3"
  524.   [(set (match_operand:QI 0 "general_operand" "=g")
  525.     (plus:QI (match_operand:QI 1 "general_operand" "g")
  526.          (match_operand:QI 2 "general_operand" "g")))]
  527.   ""
  528.   "*
  529. {
  530.   if (rtx_equal_p (operands[0], operands[1]))
  531.     {
  532.       if (operands[2] == const1_rtx)
  533.     return \"incb %0\";
  534.       if (operands[2] == constm1_rtx)
  535.     return \"decb %0\";
  536.       if (GET_CODE (operands[2]) == CONST_INT
  537.       && (unsigned) (- INTVAL (operands[2])) < 64)
  538.     return \"subb2 $%n2,%0\";
  539.       return \"addb2 %2,%0\";
  540.     }
  541.   if (rtx_equal_p (operands[0], operands[2]))
  542.     return \"addb2 %1,%0\";
  543.   if (GET_CODE (operands[2]) == CONST_INT
  544.       && (unsigned) (- INTVAL (operands[2])) < 64)
  545.     return \"subb3 $%n2,%1,%0\";
  546.   return \"addb3 %1,%2,%0\";
  547. }")
  548.  
  549. ;; The add-with-carry (adwc) instruction only accepts two operands.
  550. (define_insn "adddi3"
  551.   [(set (match_operand:DI 0 "general_operand" "=ro>,ro>")
  552.     (plus:DI (match_operand:DI 1 "general_operand" "0,ro>")
  553.          (match_operand:DI 2 "general_operand" "Fro,F")))]
  554.   ""
  555.   "*
  556. {
  557.   rtx low[3];
  558.   char *pattern;
  559.   int carry = 1;
  560.  
  561.   split_quadword_operands (operands, low, 3);
  562.   /* Add low parts.  */
  563.   if (rtx_equal_p (operands[0], operands[1]))
  564.     {
  565.       if (low[2] == const0_rtx)
  566.     /* Should examine operand, punt if not POST_INC.  */
  567.     pattern = \"tstl %0\", carry = 0;
  568.       else if (low[2] == const1_rtx)
  569.         pattern = \"incl %0\";
  570.       else
  571.         pattern = \"addl2 %2,%0\";
  572.     }
  573.   else
  574.     {
  575.       if (low[2] == const0_rtx)
  576.     pattern = \"movl %1,%0\", carry = 0;
  577.       else
  578.     pattern = \"addl3 %2,%1,%0\";
  579.     }
  580.   if (pattern)
  581.     output_asm_insn (pattern, low);
  582.   if (!carry)
  583.     /* If CARRY is 0, we don't have any carry value to worry about.  */
  584.     return OUT_FCN (CODE_FOR_addsi3) (operands, insn);
  585.   /* %0 = C + %1 + %2 */
  586.   if (!rtx_equal_p (operands[0], operands[1]))
  587.     output_asm_insn ((operands[1] == const0_rtx
  588.               ? \"clrl %0\"
  589.               : \"movl %1,%0\"), operands);
  590.   return \"adwc %2,%0\";
  591. }")
  592.  
  593. ;;- All kinds of subtract instructions.
  594.  
  595. (define_insn "subdf3"
  596.   [(set (match_operand:DF 0 "general_operand" "=g,g")
  597.     (minus:DF (match_operand:DF 1 "general_operand" "0,gF")
  598.           (match_operand:DF 2 "general_operand" "gF,gF")))]
  599.   ""
  600.   "@
  601.    sub%#2 %2,%0
  602.    sub%#3 %2,%1,%0")
  603.  
  604. (define_insn "subsf3"
  605.   [(set (match_operand:SF 0 "general_operand" "=g,g")
  606.     (minus:SF (match_operand:SF 1 "general_operand" "0,gF")
  607.           (match_operand:SF 2 "general_operand" "gF,gF")))]
  608.   ""
  609.   "@
  610.    subf2 %2,%0
  611.    subf3 %2,%1,%0")
  612.  
  613. (define_insn "subsi3"
  614.   [(set (match_operand:SI 0 "general_operand" "=g,g")
  615.     (minus:SI (match_operand:SI 1 "general_operand" "0,g")
  616.           (match_operand:SI 2 "general_operand" "g,g")))]
  617.   ""
  618.   "@
  619.    subl2 %2,%0
  620.    subl3 %2,%1,%0")
  621.  
  622. (define_insn "subhi3"
  623.   [(set (match_operand:HI 0 "general_operand" "=g,g")
  624.     (minus:HI (match_operand:HI 1 "general_operand" "0,g")
  625.           (match_operand:HI 2 "general_operand" "g,g")))]
  626.   ""
  627.   "@
  628.    subw2 %2,%0
  629.    subw3 %2,%1,%0")
  630.  
  631. (define_insn "subqi3"
  632.   [(set (match_operand:QI 0 "general_operand" "=g,g")
  633.     (minus:QI (match_operand:QI 1 "general_operand" "0,g")
  634.           (match_operand:QI 2 "general_operand" "g,g")))]
  635.   ""
  636.   "@
  637.    subb2 %2,%0
  638.    subb3 %2,%1,%0")
  639.  
  640. ;; The subtract-with-carry (sbwc) instruction only takes two operands.
  641. (define_insn "subdi3"
  642.   [(set (match_operand:DI 0 "general_operand" "=or>,or>")
  643.     (minus:DI (match_operand:DI 1 "general_operand" "0,or>")
  644.           (match_operand:DI 2 "general_operand" "For,F")))]
  645.   ""
  646.   "*
  647. {
  648.   rtx low[3];
  649.   char *pattern;
  650.   int carry = 1;
  651.  
  652.   split_quadword_operands (operands, low, 3);
  653.   /* Subtract low parts.  */
  654.   if (rtx_equal_p (operands[0], operands[1]))
  655.     {
  656.       if (low[2] == const0_rtx)
  657.     pattern = 0, carry = 0;
  658.       else if (low[2] == constm1_rtx)
  659.     pattern = \"decl %0\";
  660.       else
  661.     pattern = \"subl2 %2,%0\";
  662.     }
  663.   else
  664.     {
  665.       if (low[2] == constm1_rtx)
  666.     pattern = \"decl %0\";
  667.       else if (low[2] == const0_rtx)
  668.     pattern = OUT_FCN (CODE_FOR_movsi) (low, insn), carry = 0;
  669.       else
  670.     pattern = \"subl3 %2,%1,%0\";
  671.     }
  672.   if (pattern)
  673.     output_asm_insn (pattern, low);
  674.   if (carry)
  675.     {
  676.       if (!rtx_equal_p (operands[0], operands[1]))
  677.     return \"movl %1,%0\;sbwc %2,%0\";
  678.       return \"sbwc %2,%0\";
  679.       /* %0 = %2 - %1 - C */
  680.     }
  681.   return OUT_FCN (CODE_FOR_subsi3) (operands, insn);
  682. }")
  683.  
  684. ;;- Multiply instructions.
  685.  
  686. (define_insn "muldf3"
  687.   [(set (match_operand:DF 0 "general_operand" "=g,g,g")
  688.     (mult:DF (match_operand:DF 1 "general_operand" "0,gF,gF")
  689.          (match_operand:DF 2 "general_operand" "gF,0,gF")))]
  690.   ""
  691.   "@
  692.    mul%#2 %2,%0
  693.    mul%#2 %1,%0
  694.    mul%#3 %1,%2,%0")
  695.  
  696. (define_insn "mulsf3"
  697.   [(set (match_operand:SF 0 "general_operand" "=g,g,g")
  698.     (mult:SF (match_operand:SF 1 "general_operand" "0,gF,gF")
  699.          (match_operand:SF 2 "general_operand" "gF,0,gF")))]
  700.   ""
  701.   "@
  702.    mulf2 %2,%0
  703.    mulf2 %1,%0
  704.    mulf3 %1,%2,%0")
  705.  
  706. (define_insn "mulsi3"
  707.   [(set (match_operand:SI 0 "general_operand" "=g,g,g")
  708.     (mult:SI (match_operand:SI 1 "general_operand" "0,g,g")
  709.          (match_operand:SI 2 "general_operand" "g,0,g")))]
  710.   ""
  711.   "@
  712.    mull2 %2,%0
  713.    mull2 %1,%0
  714.    mull3 %1,%2,%0")
  715.  
  716. (define_insn "mulhi3"
  717.   [(set (match_operand:HI 0 "general_operand" "=g,g,")
  718.     (mult:HI (match_operand:HI 1 "general_operand" "0,g,g")
  719.          (match_operand:HI 2 "general_operand" "g,0,g")))]
  720.   ""
  721.   "@
  722.    mulw2 %2,%0
  723.    mulw2 %1,%0
  724.    mulw3 %1,%2,%0")
  725.  
  726. (define_insn "mulqi3"
  727.   [(set (match_operand:QI 0 "general_operand" "=g,g,g")
  728.     (mult:QI (match_operand:QI 1 "general_operand" "0,g,g")
  729.          (match_operand:QI 2 "general_operand" "g,0,g")))]
  730.   ""
  731.   "@
  732.    mulb2 %2,%0
  733.    mulb2 %1,%0
  734.    mulb3 %1,%2,%0")
  735.  
  736. (define_insn "mulsidi3"
  737.   [(set (match_operand:DI 0 "general_operand" "=g")
  738.     (mult:DI (sign_extend:DI (match_operand:SI 1 "general_operand" "g"))
  739.          (sign_extend:DI (match_operand:SI 2 "general_operand" "g"))))]
  740.   ""
  741.   "emul %1,%2,$0,%0")
  742.  
  743. (define_insn ""
  744.   [(set (match_operand:DI 0 "general_operand" "=g")
  745.     (plus:DI
  746.      (mult:DI (sign_extend:DI (match_operand:SI 1 "general_operand" "g"))
  747.           (sign_extend:DI (match_operand:SI 2 "general_operand" "g")))
  748.      (sign_extend:DI (match_operand:SI 3 "general_operand" "g"))))]
  749.   ""
  750.   "emul %1,%2,%3,%0")
  751.  
  752. ;; 'F' constraint means type CONST_DOUBLE
  753. (define_insn ""
  754.   [(set (match_operand:DI 0 "general_operand" "=g")
  755.     (plus:DI
  756.      (mult:DI (sign_extend:DI (match_operand:SI 1 "general_operand" "g"))
  757.           (sign_extend:DI (match_operand:SI 2 "general_operand" "g")))
  758.      (match_operand:DI 3 "immediate_operand" "F")))]
  759.   "GET_CODE (operands[3]) == CONST_DOUBLE 
  760.     && CONST_DOUBLE_HIGH (operands[3]) == (CONST_DOUBLE_LOW (operands[3]) >> 31)"
  761.   "*
  762. {
  763.   if (CONST_DOUBLE_HIGH (operands[3]))
  764.     operands[3] = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_LOW (operands[3]));
  765.   return \"emul %1,%2,%3,%0\";
  766. }")
  767.  
  768. ;;- Divide instructions.
  769.  
  770. (define_insn "divdf3"
  771.   [(set (match_operand:DF 0 "general_operand" "=g,g")
  772.     (div:DF (match_operand:DF 1 "general_operand" "0,gF")
  773.         (match_operand:DF 2 "general_operand" "gF,gF")))]
  774.   ""
  775.   "@
  776.    div%#2 %2,%0
  777.    div%#3 %2,%1,%0")
  778.  
  779. (define_insn "divsf3"
  780.   [(set (match_operand:SF 0 "general_operand" "=g,g")
  781.     (div:SF (match_operand:SF 1 "general_operand" "0,gF")
  782.         (match_operand:SF 2 "general_operand" "gF,gF")))]
  783.   ""
  784.   "@
  785.    divf2 %2,%0
  786.    divf3 %2,%1,%0")
  787.  
  788. (define_insn "divsi3"
  789.   [(set (match_operand:SI 0 "general_operand" "=g,g")
  790.     (div:SI (match_operand:SI 1 "general_operand" "0,g")
  791.         (match_operand:SI 2 "general_operand" "g,g")))]
  792.   ""
  793.   "@
  794.    divl2 %2,%0
  795.    divl3 %2,%1,%0")
  796.  
  797. (define_insn "divhi3"
  798.   [(set (match_operand:HI 0 "general_operand" "=g,g")
  799.     (div:HI (match_operand:HI 1 "general_operand" "0,g")
  800.         (match_operand:HI 2 "general_operand" "g,g")))]
  801.   ""
  802.   "@
  803.    divw2 %2,%0
  804.    divw3 %2,%1,%0")
  805.  
  806. (define_insn "divqi3"
  807.   [(set (match_operand:QI 0 "general_operand" "=g,g")
  808.     (div:QI (match_operand:QI 1 "general_operand" "0,g")
  809.         (match_operand:QI 2 "general_operand" "g,g")))]
  810.   ""
  811.   "@
  812.    divb2 %2,%0
  813.    divb3 %2,%1,%0")
  814.  
  815. ;This is left out because it is very slow;
  816. ;we are better off programming around the "lack" of this insn.
  817. ;(define_insn "divmoddisi4"
  818. ;  [(set (match_operand:SI 0 "general_operand" "=g")
  819. ;    (div:SI (match_operand:DI 1 "general_operand" "g")
  820. ;        (match_operand:SI 2 "general_operand" "g")))
  821. ;   (set (match_operand:SI 3 "general_operand" "=g")
  822. ;    (mod:SI (match_operand:DI 1 "general_operand" "g")
  823. ;        (match_operand:SI 2 "general_operand" "g")))]
  824. ;  ""
  825. ;  "ediv %2,%1,%0,%3")
  826.  
  827. ;; Bit-and on the vax is done with a clear-bits insn.
  828. (define_expand "andsi3"
  829.   [(set (match_operand:SI 0 "general_operand" "=g")
  830.     (and:SI (not:SI (match_operand:SI 1 "general_operand" "g"))
  831.         (match_operand:SI 2 "general_operand" "g")))]
  832.   ""
  833.   "
  834. {
  835.   if (GET_CODE (operands[1]) == CONST_INT)
  836.     operands[1] = gen_rtx (CONST_INT, VOIDmode, ~INTVAL (operands[1]));
  837.   else
  838.     operands[1] = expand_unop (SImode, one_cmpl_optab, operands[1], 0, 1);
  839. }")
  840.  
  841. (define_expand "andhi3"
  842.   [(set (match_operand:HI 0 "general_operand" "=g")
  843.     (and:HI (not:HI (match_operand:HI 1 "general_operand" "g"))
  844.         (match_operand:HI 2 "general_operand" "g")))]
  845.   ""
  846.   "
  847. {
  848.   rtx op = operands[1];
  849.   if (GET_CODE (op) == CONST_INT)
  850.     operands[1] = gen_rtx (CONST_INT, VOIDmode,
  851.                ((1 << 16) - 1) & ~INTVAL (op));
  852.   else
  853.     operands[1] = expand_unop (HImode, one_cmpl_optab, op, 0, 1);
  854. }")
  855.  
  856. (define_expand "andqi3"
  857.   [(set (match_operand:QI 0 "general_operand" "=g")
  858.     (and:QI (not:QI (match_operand:QI 1 "general_operand" "g"))
  859.         (match_operand:QI 2 "general_operand" "g")))]
  860.   ""
  861.   "
  862. {
  863.   rtx op = operands[1];
  864.   if (GET_CODE (op) == CONST_INT)
  865.     operands[1] = gen_rtx (CONST_INT, VOIDmode,
  866.                ((1 << 8) - 1) & ~INTVAL (op));
  867.   else
  868.     operands[1] = expand_unop (QImode, one_cmpl_optab, op, 0, 1);
  869. }")
  870.  
  871. (define_insn ""
  872.   [(set (match_operand:SI 0 "general_operand" "=g,g")
  873.     (and:SI (not:SI (match_operand:SI 1 "general_operand" "g,g"))
  874.         (match_operand:SI 2 "general_operand" "0,g")))]
  875.   ""
  876.   "@
  877.    bicl2 %1,%0
  878.    bicl3 %1,%2,%0")
  879.  
  880. (define_insn ""
  881.   [(set (match_operand:HI 0 "general_operand" "=g,g")
  882.     (and:HI (not:HI (match_operand:HI 1 "general_operand" "g,g"))
  883.         (match_operand:HI 2 "general_operand" "0,g")))]
  884.   ""
  885.   "@
  886.    bicw2 %1,%0
  887.    bicw3 %1,%2,%0")
  888.  
  889. (define_insn ""
  890.   [(set (match_operand:QI 0 "general_operand" "=g,g")
  891.     (and:QI (not:QI (match_operand:QI 1 "general_operand" "g,g"))
  892.         (match_operand:QI 2 "general_operand" "0,g")))]
  893.   ""
  894.   "@
  895.    bicb2 %1,%0
  896.    bicb3 %1,%2,%0")
  897.  
  898. ;; The following used to be needed because constant propagation can
  899. ;; create them starting from the bic insn patterns above.  This is no
  900. ;; longer a problem.  However, having these patterns allows optimization
  901. ;; opportunities in combine.c.
  902.  
  903. (define_insn ""
  904.   [(set (match_operand:SI 0 "general_operand" "=g,g")
  905.     (and:SI (match_operand:SI 1 "general_operand" "0,g")
  906.         (match_operand:SI 2 "const_int_operand" "n,n")))]
  907.   ""
  908.   "@
  909.    bicl2 %N2,%0
  910.    bicl3 %N2,%1,%0")
  911.  
  912. (define_insn ""
  913.   [(set (match_operand:HI 0 "general_operand" "=g,g")
  914.     (and:HI (match_operand:HI 1 "general_operand" "0,g")
  915.         (match_operand:HI 2 "const_int_operand" "n,n")))]
  916.   ""
  917.   "@
  918.    bicw2 %H2,%0
  919.    bicw3 %H2,%1,%0")
  920.  
  921. (define_insn ""
  922.   [(set (match_operand:QI 0 "general_operand" "=g,g")
  923.     (and:QI (match_operand:QI 1 "general_operand" "0,g")
  924.         (match_operand:QI 2 "const_int_operand" "n,n")))]
  925.   ""
  926.   "@
  927.    bicb2 %B2,%0
  928.    bicb3 %B2,%1,%0")
  929.  
  930. ;;- Bit set instructions.
  931.  
  932. (define_insn "iorsi3"
  933.   [(set (match_operand:SI 0 "general_operand" "=g,g,g")
  934.     (ior:SI (match_operand:SI 1 "general_operand" "0,g,g")
  935.         (match_operand:SI 2 "general_operand" "g,0,g")))]
  936.   ""
  937.   "@
  938.    bisl2 %2,%0
  939.    bisl2 %1,%0
  940.    bisl3 %2,%1,%0")
  941.  
  942. (define_insn "iorhi3"
  943.   [(set (match_operand:HI 0 "general_operand" "=g,g,g")
  944.     (ior:HI (match_operand:HI 1 "general_operand" "0,g,g")
  945.         (match_operand:HI 2 "general_operand" "g,0,g")))]
  946.   ""
  947.   "@
  948.    bisw2 %2,%0
  949.    bisw2 %1,%0
  950.    bisw3 %2,%1,%0")
  951.  
  952. (define_insn "iorqi3"
  953.   [(set (match_operand:QI 0 "general_operand" "=g,g,g")
  954.     (ior:QI (match_operand:QI 1 "general_operand" "0,g,g")
  955.         (match_operand:QI 2 "general_operand" "g,0,g")))]
  956.   ""
  957.   "@
  958.    bisb2 %2,%0
  959.    bisb2 %1,%0
  960.    bisb3 %2,%1,%0")
  961.  
  962. ;;- xor instructions.
  963.  
  964. (define_insn "xorsi3"
  965.   [(set (match_operand:SI 0 "general_operand" "=g,g,g")
  966.     (xor:SI (match_operand:SI 1 "general_operand" "0,g,g")
  967.         (match_operand:SI 2 "general_operand" "g,0,g")))]
  968.   ""
  969.   "@
  970.    xorl2 %2,%0
  971.    xorl2 %1,%0
  972.    xorl3 %2,%1,%0")
  973.  
  974. (define_insn "xorhi3"
  975.   [(set (match_operand:HI 0 "general_operand" "=g,g,g")
  976.     (xor:HI (match_operand:HI 1 "general_operand" "0,g,g")
  977.         (match_operand:HI 2 "general_operand" "g,0,g")))]
  978.   ""
  979.   "@
  980.    xorw2 %2,%0
  981.    xorw2 %1,%0
  982.    xorw3 %2,%1,%0")
  983.  
  984. (define_insn "xorqi3"
  985.   [(set (match_operand:QI 0 "general_operand" "=g,g,g")
  986.     (xor:QI (match_operand:QI 1 "general_operand" "0,g,g")
  987.         (match_operand:QI 2 "general_operand" "g,0,g")))]
  988.   ""
  989.   "@
  990.    xorb2 %2,%0
  991.    xorb2 %1,%0
  992.    xorb3 %2,%1,%0")
  993.  
  994. (define_insn "negdf2"
  995.   [(set (match_operand:DF 0 "general_operand" "=g")
  996.     (neg:DF (match_operand:DF 1 "general_operand" "gF")))]
  997.   ""
  998.   "mneg%# %1,%0")
  999.  
  1000. (define_insn "negsf2"
  1001.   [(set (match_operand:SF 0 "general_operand" "=g")
  1002.     (neg:SF (match_operand:SF 1 "general_operand" "gF")))]
  1003.   ""
  1004.   "mnegf %1,%0")
  1005.  
  1006. (define_insn "negsi2"
  1007.   [(set (match_operand:SI 0 "general_operand" "=g")
  1008.     (neg:SI (match_operand:SI 1 "general_operand" "g")))]
  1009.   ""
  1010.   "mnegl %1,%0")
  1011.  
  1012. (define_insn "neghi2"
  1013.   [(set (match_operand:HI 0 "general_operand" "=g")
  1014.     (neg:HI (match_operand:HI 1 "general_operand" "g")))]
  1015.   ""
  1016.   "mnegw %1,%0")
  1017.  
  1018. (define_insn "negqi2"
  1019.   [(set (match_operand:QI 0 "general_operand" "=g")
  1020.     (neg:QI (match_operand:QI 1 "general_operand" "g")))]
  1021.   ""
  1022.   "mnegb %1,%0")
  1023.  
  1024. (define_insn "one_cmplsi2"
  1025.   [(set (match_operand:SI 0 "general_operand" "=g")
  1026.     (not:SI (match_operand:SI 1 "general_operand" "g")))]
  1027.   ""
  1028.   "mcoml %1,%0")
  1029.  
  1030. (define_insn "one_cmplhi2"
  1031.   [(set (match_operand:HI 0 "general_operand" "=g")
  1032.     (not:HI (match_operand:HI 1 "general_operand" "g")))]
  1033.   ""
  1034.   "mcomw %1,%0")
  1035.  
  1036. (define_insn "one_cmplqi2"
  1037.   [(set (match_operand:QI 0 "general_operand" "=g")
  1038.     (not:QI (match_operand:QI 1 "general_operand" "g")))]
  1039.   ""
  1040.   "mcomb %1,%0")
  1041.  
  1042. ;; Arithmetic right shift on the vax works by negating the shift count,
  1043. ;; then emitting a right shift with the shift count negated.  This means
  1044. ;; that all actual shift counts in the RTL will be positive.  This 
  1045. ;; prevents converting shifts to ZERO_EXTRACTs with negative positions,
  1046. ;; which isn't valid.
  1047. (define_expand "ashrsi3"
  1048.   [(set (match_operand:SI 0 "general_operand" "=g")
  1049.     (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
  1050.            (match_operand:QI 2 "general_operand" "g")))]
  1051.   ""
  1052.   "
  1053. {
  1054.   if (GET_CODE (operands[2]) != CONST_INT)
  1055.     operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
  1056. }")
  1057.  
  1058. (define_insn ""
  1059.   [(set (match_operand:SI 0 "general_operand" "=g")
  1060.     (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
  1061.              (match_operand:QI 2 "const_int_operand" "n")))]
  1062.   ""
  1063.   "ashl $%n2,%1,%0")
  1064.  
  1065. (define_insn ""
  1066.   [(set (match_operand:SI 0 "general_operand" "=g")
  1067.     (ashiftrt:SI (match_operand:SI 1 "general_operand" "g")
  1068.              (neg:QI (match_operand:QI 2 "general_operand" "g"))))]
  1069.   ""
  1070.   "ashl %2,%1,%0")
  1071.  
  1072. (define_insn "ashlsi3"
  1073.   [(set (match_operand:SI 0 "general_operand" "=g")
  1074.     (ashift:SI (match_operand:SI 1 "general_operand" "g")
  1075.            (match_operand:QI 2 "general_operand" "g")))]
  1076.   ""
  1077.   "*
  1078. {
  1079.   if (operands[2] == const1_rtx && rtx_equal_p (operands[0], operands[1]))
  1080.     return \"addl2 %0,%0\";
  1081.   if (GET_CODE (operands[1]) == REG
  1082.       && GET_CODE (operands[2]) == CONST_INT)
  1083.     {
  1084.       int i = INTVAL (operands[2]);
  1085.       if (i == 1)
  1086.     return \"addl3 %1,%1,%0\";
  1087.       if (i == 2)
  1088.     return \"moval 0[%1],%0\";
  1089.       if (i == 3)
  1090.     return \"movad 0[%1],%0\";
  1091.     }
  1092.   return \"ashl %2,%1,%0\";
  1093. }")
  1094.  
  1095. ;; Arithmetic right shift on the vax works by negating the shift count.
  1096. (define_expand "ashrdi3"
  1097.   [(set (match_operand:DI 0 "general_operand" "=g")
  1098.     (ashiftrt:DI (match_operand:DI 1 "general_operand" "g")
  1099.              (match_operand:QI 2 "general_operand" "g")))]
  1100.   ""
  1101.   "
  1102. {
  1103.   operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
  1104. }")
  1105.  
  1106. (define_insn "ashldi3"
  1107.   [(set (match_operand:DI 0 "general_operand" "=g")
  1108.     (ashift:DI (match_operand:DI 1 "general_operand" "g")
  1109.            (match_operand:QI 2 "general_operand" "g")))]
  1110.   ""
  1111.   "ashq %2,%1,%0")
  1112.  
  1113. (define_insn ""
  1114.   [(set (match_operand:DI 0 "general_operand" "=g")
  1115.     (ashiftrt:DI (match_operand:DI 1 "general_operand" "g")
  1116.              (neg:QI (match_operand:QI 2 "general_operand" "g"))))]
  1117.   ""
  1118.   "ashq %2,%1,%0")
  1119.  
  1120. ;; Rotate right on the vax works by negating the shift count.
  1121. (define_expand "rotrsi3"
  1122.   [(set (match_operand:SI 0 "general_operand" "=g")
  1123.     (rotatert:SI (match_operand:SI 1 "general_operand" "g")
  1124.              (match_operand:QI 2 "general_operand" "g")))]
  1125.   ""
  1126.   "
  1127. {
  1128.   if (GET_CODE (operands[2]) != CONST_INT)
  1129.     operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
  1130. }")
  1131.  
  1132. (define_insn "rotlsi3"
  1133.   [(set (match_operand:SI 0 "general_operand" "=g")
  1134.     (rotate:SI (match_operand:SI 1 "general_operand" "g")
  1135.            (match_operand:QI 2 "general_operand" "g")))]
  1136.   ""
  1137.   "rotl %2,%1,%0")
  1138.  
  1139. (define_insn ""
  1140.   [(set (match_operand:SI 0 "general_operand" "=g")
  1141.     (rotatert:SI (match_operand:SI 1 "general_operand" "g")
  1142.              (match_operand:QI 2 "const_int_operand" "n")))]
  1143.   ""
  1144.   "rotl $%n2,%1,%0")
  1145.  
  1146. (define_insn ""
  1147.   [(set (match_operand:SI 0 "general_operand" "=g")
  1148.     (rotatert:SI (match_operand:SI 1 "general_operand" "g")
  1149.              (neg:QI (match_operand:QI 2 "general_operand" "g"))))]
  1150.   ""
  1151.   "rotl %2,%1,%0")
  1152.  
  1153. ;This insn is probably slower than a multiply and an add.
  1154. ;(define_insn ""
  1155. ;  [(set (match_operand:SI 0 "general_operand" "=g")
  1156. ;    (mult:SI (plus:SI (match_operand:SI 1 "general_operand" "g")
  1157. ;              (match_operand:SI 2 "general_operand" "g"))
  1158. ;         (match_operand:SI 3 "general_operand" "g")))]
  1159. ;  ""
  1160. ;  "index %1,$0x80000000,$0x7fffffff,%3,%2,%0")
  1161.  
  1162. ;; Special cases of bit-field insns which we should
  1163. ;; recognize in preference to the general case.
  1164. ;; These handle aligned 8-bit and 16-bit fields,
  1165. ;; which can usually be done with move instructions.
  1166.  
  1167. (define_insn ""
  1168.   [(set (zero_extract:SI (match_operand:SI 0 "general_operand" "+ro")
  1169.              (match_operand:QI 1 "const_int_operand" "n")
  1170.              (match_operand:SI 2 "const_int_operand" "n"))
  1171.     (match_operand:SI 3 "general_operand" "g"))]
  1172.    "(INTVAL (operands[1]) == 8 || INTVAL (operands[1]) == 16)
  1173.    && INTVAL (operands[2]) % INTVAL (operands[1]) == 0
  1174.    && (GET_CODE (operands[0]) == REG
  1175.        || ! mode_dependent_address_p (XEXP (operands[0], 0)))"
  1176.   "*
  1177. {
  1178.   if (REG_P (operands[0]))
  1179.     {
  1180.       if (INTVAL (operands[2]) != 0)
  1181.     return \"insv %3,%2,%1,%0\";
  1182.     }
  1183.   else
  1184.     operands[0]
  1185.       = adj_offsettable_operand (operands[0], INTVAL (operands[2]) / 8);
  1186.  
  1187.   if (INTVAL (operands[1]) == 8)
  1188.     return \"movb %3,%0\";
  1189.   return \"movw %3,%0\";
  1190. }")
  1191.  
  1192. (define_insn ""
  1193.   [(set (match_operand:SI 0 "general_operand" "=&g")
  1194.     (zero_extract:SI (match_operand:SI 1 "general_operand" "ro")
  1195.              (match_operand:QI 2 "const_int_operand" "n")
  1196.              (match_operand:SI 3 "const_int_operand" "n")))]
  1197.   "(INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
  1198.    && INTVAL (operands[3]) % INTVAL (operands[2]) == 0
  1199.    && (GET_CODE (operands[1]) == REG
  1200.        || ! mode_dependent_address_p (XEXP (operands[1], 0)))"
  1201.   "*
  1202. {
  1203.   if (REG_P (operands[1]))
  1204.     {
  1205.       if (INTVAL (operands[3]) != 0)
  1206.     return \"extzv %3,%2,%1,%0\";
  1207.     }
  1208.   else
  1209.     operands[1]
  1210.       = adj_offsettable_operand (operands[1], INTVAL (operands[3]) / 8);
  1211.  
  1212.   if (INTVAL (operands[2]) == 8)
  1213.     return \"movzbl %1,%0\";
  1214.   return \"movzwl %1,%0\";
  1215. }")
  1216.  
  1217. (define_insn ""
  1218.   [(set (match_operand:SI 0 "general_operand" "=g")
  1219.     (sign_extract:SI (match_operand:SI 1 "general_operand" "ro")
  1220.              (match_operand:QI 2 "const_int_operand" "n")
  1221.              (match_operand:SI 3 "const_int_operand" "n")))]
  1222.   "(INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16)
  1223.    && INTVAL (operands[3]) % INTVAL (operands[2]) == 0
  1224.    && (GET_CODE (operands[1]) == REG
  1225.        || ! mode_dependent_address_p (XEXP (operands[1], 0)))"
  1226.   "*
  1227. {
  1228.   if (REG_P (operands[1]))
  1229.     {
  1230.       if (INTVAL (operands[3]) != 0)
  1231.     return \"extv %3,%2,%1,%0\";
  1232.     }
  1233.   else
  1234.     operands[1]
  1235.       = adj_offsettable_operand (operands[1], INTVAL (operands[3]) / 8);
  1236.  
  1237.   if (INTVAL (operands[2]) == 8)
  1238.     return \"cvtbl %1,%0\";
  1239.   return \"cvtwl %1,%0\";
  1240. }")
  1241.  
  1242. ;; Register-only SImode cases of bit-field insns.
  1243.  
  1244. (define_insn ""
  1245.   [(set (cc0)
  1246.     (compare
  1247.      (sign_extract:SI (match_operand:SI 0 "nonmemory_operand" "r")
  1248.               (match_operand:QI 1 "general_operand" "g")
  1249.               (match_operand:SI 2 "general_operand" "g"))
  1250.      (match_operand:SI 3 "general_operand" "g")))]
  1251.   ""
  1252.   "cmpv %2,%1,%0,%3")
  1253.  
  1254. (define_insn ""
  1255.   [(set (cc0)
  1256.     (compare
  1257.      (zero_extract:SI (match_operand:SI 0 "nonmemory_operand" "r")
  1258.               (match_operand:QI 1 "general_operand" "g")
  1259.               (match_operand:SI 2 "general_operand" "g"))
  1260.      (match_operand:SI 3 "general_operand" "g")))]
  1261.   ""
  1262.   "cmpzv %2,%1,%0,%3")
  1263.  
  1264. (define_insn ""
  1265.   [(set (match_operand:SI 0 "general_operand" "=g")
  1266.     (sign_extract:SI (match_operand:SI 1 "nonmemory_operand" "r")
  1267.              (match_operand:QI 2 "general_operand" "g")
  1268.              (match_operand:SI 3 "general_operand" "g")))]
  1269.   ""
  1270.   "extv %3,%2,%1,%0")
  1271.  
  1272. (define_insn ""
  1273.   [(set (match_operand:SI 0 "general_operand" "=g")
  1274.     (zero_extract:SI (match_operand:SI 1 "nonmemory_operand" "r")
  1275.              (match_operand:QI 2 "general_operand" "g")
  1276.              (match_operand:SI 3 "general_operand" "g")))]
  1277.   ""
  1278.   "extzv %3,%2,%1,%0")
  1279.  
  1280. ;; Non-register cases.
  1281. ;; nonimmediate_operand is used to make sure that mode-ambiguous cases
  1282. ;; don't match these (and therefore match the cases above instead).
  1283.  
  1284. (define_insn ""
  1285.   [(set (cc0)
  1286.     (compare
  1287.      (sign_extract:SI (match_operand:QI 0 "nonimmediate_operand" "rm")
  1288.               (match_operand:QI 1 "general_operand" "g")
  1289.               (match_operand:SI 2 "general_operand" "g"))
  1290.      (match_operand:SI 3 "general_operand" "g")))]
  1291.   ""
  1292.   "cmpv %2,%1,%0,%3")
  1293.  
  1294. (define_insn ""
  1295.   [(set (cc0)
  1296.     (compare
  1297.      (zero_extract:SI (match_operand:QI 0 "nonimmediate_operand" "rm")
  1298.               (match_operand:QI 1 "general_operand" "g")
  1299.               (match_operand:SI 2 "general_operand" "g"))
  1300.      (match_operand:SI 3 "general_operand" "g")))]
  1301.   ""
  1302.   "cmpzv %2,%1,%0,%3")
  1303.  
  1304. (define_insn "extv"
  1305.   [(set (match_operand:SI 0 "general_operand" "=g")
  1306.     (sign_extract:SI (match_operand:QI 1 "nonimmediate_operand" "rm")
  1307.              (match_operand:QI 2 "general_operand" "g")
  1308.              (match_operand:SI 3 "general_operand" "g")))]
  1309.   ""
  1310.   "extv %3,%2,%1,%0")
  1311.  
  1312. (define_insn "extzv"
  1313.   [(set (match_operand:SI 0 "general_operand" "=g")
  1314.     (zero_extract:SI (match_operand:QI 1 "nonimmediate_operand" "rm")
  1315.              (match_operand:QI 2 "general_operand" "g")
  1316.              (match_operand:SI 3 "general_operand" "g")))]
  1317.   ""
  1318.   "extzv %3,%2,%1,%0")
  1319.  
  1320. (define_insn "insv"
  1321.   [(set (zero_extract:SI (match_operand:QI 0 "general_operand" "+g")
  1322.              (match_operand:QI 1 "general_operand" "g")
  1323.              (match_operand:SI 2 "general_operand" "g"))
  1324.     (match_operand:SI 3 "general_operand" "g"))]
  1325.   ""
  1326.   "insv %3,%2,%1,%0")
  1327.  
  1328. (define_insn ""
  1329.   [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
  1330.              (match_operand:QI 1 "general_operand" "g")
  1331.              (match_operand:SI 2 "general_operand" "g"))
  1332.     (match_operand:SI 3 "general_operand" "g"))]
  1333.   ""
  1334.   "insv %3,%2,%1,%0")
  1335.  
  1336. (define_insn "jump"
  1337.   [(set (pc)
  1338.     (label_ref (match_operand 0 "" "")))]
  1339.   ""
  1340.   "jbr %l0")
  1341.  
  1342. (define_insn "beq"
  1343.   [(set (pc)
  1344.     (if_then_else (eq (cc0)
  1345.               (const_int 0))
  1346.               (label_ref (match_operand 0 "" ""))
  1347.               (pc)))]
  1348.   ""
  1349.   "jeql %l0")
  1350.  
  1351. (define_insn "bne"
  1352.   [(set (pc)
  1353.     (if_then_else (ne (cc0)
  1354.               (const_int 0))
  1355.               (label_ref (match_operand 0 "" ""))
  1356.               (pc)))]
  1357.   ""
  1358.   "jneq %l0")
  1359.  
  1360. (define_insn "bgt"
  1361.   [(set (pc)
  1362.     (if_then_else (gt (cc0)
  1363.               (const_int 0))
  1364.               (label_ref (match_operand 0 "" ""))
  1365.               (pc)))]
  1366.   ""
  1367.   "jgtr %l0")
  1368.  
  1369. (define_insn "bgtu"
  1370.   [(set (pc)
  1371.     (if_then_else (gtu (cc0)
  1372.                (const_int 0))
  1373.               (label_ref (match_operand 0 "" ""))
  1374.               (pc)))]
  1375.   ""
  1376.   "jgtru %l0")
  1377.  
  1378. (define_insn "blt"
  1379.   [(set (pc)
  1380.     (if_then_else (lt (cc0)
  1381.               (const_int 0))
  1382.               (label_ref (match_operand 0 "" ""))
  1383.               (pc)))]
  1384.   ""
  1385.   "jlss %l0")
  1386.  
  1387. (define_insn "bltu"
  1388.   [(set (pc)
  1389.     (if_then_else (ltu (cc0)
  1390.                (const_int 0))
  1391.               (label_ref (match_operand 0 "" ""))
  1392.               (pc)))]
  1393.   ""
  1394.   "jlssu %l0")
  1395.  
  1396. (define_insn "bge"
  1397.   [(set (pc)
  1398.     (if_then_else (ge (cc0)
  1399.               (const_int 0))
  1400.               (label_ref (match_operand 0 "" ""))
  1401.               (pc)))]
  1402.   ""
  1403.   "jgeq %l0")
  1404.  
  1405. (define_insn "bgeu"
  1406.   [(set (pc)
  1407.     (if_then_else (geu (cc0)
  1408.                (const_int 0))
  1409.               (label_ref (match_operand 0 "" ""))
  1410.               (pc)))]
  1411.   ""
  1412.   "jgequ %l0")
  1413.  
  1414. (define_insn "ble"
  1415.   [(set (pc)
  1416.     (if_then_else (le (cc0)
  1417.               (const_int 0))
  1418.               (label_ref (match_operand 0 "" ""))
  1419.               (pc)))]
  1420.   ""
  1421.   "jleq %l0")
  1422.  
  1423. (define_insn "bleu"
  1424.   [(set (pc)
  1425.     (if_then_else (leu (cc0)
  1426.                (const_int 0))
  1427.               (label_ref (match_operand 0 "" ""))
  1428.               (pc)))]
  1429.   ""
  1430.   "jlequ %l0")
  1431.  
  1432. ;; Recognize reversed jumps.
  1433. (define_insn ""
  1434.   [(set (pc)
  1435.     (if_then_else (match_operator 0 "comparison_operator"
  1436.                       [(cc0)
  1437.                        (const_int 0)])
  1438.               (pc)
  1439.               (label_ref (match_operand 1 "" ""))))]
  1440.   ""
  1441.   "j%C0 %l1") ; %C0 negates condition
  1442.  
  1443. ;; Recognize jbs, jlbs, jbc and jlbc instructions.
  1444.  
  1445. (define_insn ""
  1446.   [(set (pc)
  1447.     (if_then_else
  1448.      (ne (zero_extract:SI (match_operand:QI 0 "nonimmediate_operand" "g,g")
  1449.                   (const_int 1)
  1450.                   (match_operand:SI 1 "general_operand" "I,g"))
  1451.          (const_int 0))
  1452.      (label_ref (match_operand 2 "" ""))
  1453.      (pc)))]
  1454.   ""
  1455.   "@
  1456.    jlbs %0,%l2
  1457.    jbs %1,%0,%l2")
  1458.  
  1459. (define_insn ""
  1460.   [(set (pc)
  1461.     (if_then_else
  1462.      (eq (zero_extract:SI (match_operand:QI 0 "nonimmediate_operand" "g,g")
  1463.                   (const_int 1)
  1464.                   (match_operand:SI 1 "general_operand" "I,g"))
  1465.          (const_int 0))
  1466.      (label_ref (match_operand 2 "" ""))
  1467.      (pc)))]
  1468.   ""
  1469.   "@
  1470.    jlbc %0,%l2
  1471.    jbc %1,%0,%l2")
  1472.  
  1473. (define_insn ""
  1474.   [(set (pc)
  1475.     (if_then_else
  1476.      (ne (zero_extract:SI (match_operand:SI 0 "register_operand" "r,r")
  1477.                   (const_int 1)
  1478.                   (match_operand:SI 1 "general_operand" "I,g"))
  1479.          (const_int 0))
  1480.      (label_ref (match_operand 2 "" ""))
  1481.      (pc)))]
  1482.   ""
  1483.   "@
  1484.    jlbs %0,%l2
  1485.    jbs %1,%0,%l2")
  1486.  
  1487. (define_insn ""
  1488.   [(set (pc)
  1489.     (if_then_else
  1490.      (eq (zero_extract:SI (match_operand:SI 0 "register_operand" "r,r")
  1491.                   (const_int 1)
  1492.                   (match_operand:SI 1 "general_operand" "I,g"))
  1493.          (const_int 0))
  1494.      (label_ref (match_operand 2 "" ""))
  1495.      (pc)))]
  1496.   ""
  1497.   "@
  1498.    jlbc %0,%l2
  1499.    jbc %1,%0,%l2")
  1500.  
  1501. ;; Subtract-and-jump and Add-and-jump insns.
  1502. ;; These are not used when output is for the Unix assembler
  1503. ;; because it does not know how to modify them to reach far.
  1504.  
  1505. ;; Normal sob insns.
  1506.  
  1507. (define_insn ""
  1508.   [(set (pc)
  1509.     (if_then_else
  1510.      (gt (match_operand:SI 0 "general_operand" "+g")
  1511.          (const_int 1))
  1512.      (label_ref (match_operand 1 "" ""))
  1513.      (pc)))
  1514.    (set (match_dup 0)
  1515.     (plus:SI (match_dup 0)
  1516.          (const_int -1)))]
  1517.   "!TARGET_UNIX_ASM"
  1518.   "jsobgtr %0,%l1")
  1519.  
  1520. (define_insn ""
  1521.   [(set (pc)
  1522.     (if_then_else
  1523.      (ge (match_operand:SI 0 "general_operand" "+g")
  1524.          (const_int 1))
  1525.      (label_ref (match_operand 1 "" ""))
  1526.      (pc)))
  1527.    (set (match_dup 0)
  1528.     (plus:SI (match_dup 0)
  1529.          (const_int -1)))]
  1530.   "!TARGET_UNIX_ASM"
  1531.   "jsobgeq %0,%l1")
  1532.  
  1533. ;; Normal aob insns.  Define a version for when operands[1] is a constant.
  1534. (define_insn ""
  1535.   [(set (pc)
  1536.     (if_then_else
  1537.      (lt (plus:SI (match_operand:SI 0 "general_operand" "+g")
  1538.               (const_int 1))
  1539.          (match_operand:SI 1 "general_operand" "g"))
  1540.      (label_ref (match_operand 2 "" ""))
  1541.      (pc)))
  1542.    (set (match_dup 0)
  1543.     (plus:SI (match_dup 0)
  1544.          (const_int 1)))]
  1545.   "!TARGET_UNIX_ASM"
  1546.   "jaoblss %1,%0,%l2")
  1547.  
  1548. (define_insn ""
  1549.   [(set (pc)
  1550.     (if_then_else
  1551.      (lt (match_operand:SI 0 "general_operand" "+g")
  1552.          (match_operand:SI 1 "general_operand" "g"))
  1553.      (label_ref (match_operand 2 "" ""))
  1554.      (pc)))
  1555.    (set (match_dup 0)
  1556.     (plus:SI (match_dup 0)
  1557.          (const_int 1)))]
  1558.   "!TARGET_UNIX_ASM && GET_CODE (operands[1]) == CONST_INT"
  1559.   "jaoblss %P1,%0,%l2")
  1560.  
  1561. (define_insn ""
  1562.   [(set (pc)
  1563.     (if_then_else
  1564.      (le (plus:SI (match_operand:SI 0 "general_operand" "+g")
  1565.               (const_int 1))
  1566.          (match_operand:SI 1 "general_operand" "g"))
  1567.      (label_ref (match_operand 2 "" ""))
  1568.      (pc)))
  1569.    (set (match_dup 0)
  1570.     (plus:SI (match_dup 0)
  1571.          (const_int 1)))]
  1572.   "!TARGET_UNIX_ASM"
  1573.   "jaobleq %1,%0,%l2")
  1574.  
  1575. (define_insn ""
  1576.   [(set (pc)
  1577.     (if_then_else
  1578.      (le (match_operand:SI 0 "general_operand" "+g")
  1579.          (match_operand:SI 1 "general_operand" "g"))
  1580.      (label_ref (match_operand 2 "" ""))
  1581.      (pc)))
  1582.    (set (match_dup 0)
  1583.     (plus:SI (match_dup 0)
  1584.          (const_int 1)))]
  1585.   "!TARGET_UNIX_ASM && GET_CODE (operands[1]) == CONST_INT"
  1586.   "jaobleq %P1,%0,%l2")
  1587.  
  1588. ;; Something like a sob insn, but compares against -1.
  1589. ;; This finds `while (foo--)' which was changed to `while (--foo != -1)'.
  1590.  
  1591. (define_insn ""
  1592.   [(set (pc)
  1593.     (if_then_else
  1594.      (ne (match_operand:SI 0 "general_operand" "g")
  1595.          (const_int 0))
  1596.      (label_ref (match_operand 1 "" ""))
  1597.      (pc)))
  1598.    (set (match_dup 0)
  1599.     (plus:SI (match_dup 0)
  1600.          (const_int -1)))]
  1601.   ""
  1602.   "decl %0\;jgequ %l1")
  1603.  
  1604. ;; Note that operand 1 is total size of args, in bytes,
  1605. ;; and what the call insn wants is the number of words.
  1606. (define_insn "call_pop"
  1607.   [(call (match_operand:QI 0 "memory_operand" "m")
  1608.      (match_operand:QI 1 "general_operand" "g"))
  1609.    (set (reg:SI 15) (plus:SI (reg:SI 15)
  1610.                  (match_operand:SI 3 "immediate_operand" "i")))]
  1611.   ""
  1612.   "*
  1613.   if (GET_CODE (operands[1]) != CONST_INT || INTVAL (operands[1]) > 255 * 4)
  1614.     /* Vax `calls' really uses only one byte of #args, so pop explicitly.  */
  1615.     return \"calls $0,%0\;addl2 %1,sp\";
  1616.   operands[1] = gen_rtx (CONST_INT, VOIDmode, (INTVAL (operands[1]) + 3)/ 4);
  1617.   return \"calls %1,%0\";
  1618. ")
  1619.  
  1620. (define_insn "call_value_pop"
  1621.   [(set (match_operand 0 "" "=g")
  1622.     (call (match_operand:QI 1 "memory_operand" "m")
  1623.           (match_operand:QI 2 "general_operand" "g")))
  1624.    (set (reg:SI 15) (plus:SI (reg:SI 15)
  1625.                  (match_operand:SI 4 "immediate_operand" "i")))]
  1626.   ""
  1627.   "*
  1628.   if (GET_CODE (operands[2]) != CONST_INT || INTVAL (operands[2]) > 255 * 4)
  1629.     /* Vax `calls' really uses only one byte of #args, so pop explicitly.  */
  1630.     return \"calls $0,%1\;addl2 %2,sp\";
  1631.   operands[2] = gen_rtx (CONST_INT, VOIDmode, (INTVAL (operands[2]) + 3)/ 4);
  1632.   return \"calls %2,%1\";
  1633. ")
  1634.  
  1635. (define_insn "return"
  1636.   [(return)]
  1637.   ""
  1638.   "ret")
  1639.  
  1640. (define_insn "nop"
  1641.   [(const_int 0)]
  1642.   ""
  1643.   "nop")
  1644.  
  1645. (define_insn "indirect_jump"
  1646.   [(set (pc) (match_operand:SI 0 "general_operand" "r"))]
  1647.   "(GET_CODE (operands[0]) != MEM || offsettable_memref_p (operands[0]))"
  1648.   "jmp (%0)")
  1649.  
  1650. (define_insn "casesi"
  1651.   [(set (pc)
  1652.     (if_then_else (le (minus:SI (match_operand:SI 0 "general_operand" "g")
  1653.                     (match_operand:SI 1 "general_operand" "g"))
  1654.               (match_operand:SI 2 "general_operand" "g"))
  1655.               (plus:SI (sign_extend:SI
  1656.                 (mem:HI (plus:SI (pc)
  1657.                          (minus:SI (match_dup 0)
  1658.                                (match_dup 1)))))
  1659.                    (label_ref:SI (match_operand 3 "" "")))
  1660.               (pc)))]
  1661.   ""
  1662.   "casel %0,%1,%2")
  1663.  
  1664. ;; This used to arise from the preceding by simplification
  1665. ;; if operand 1 is zero.  Perhaps it is no longer necessary.
  1666. (define_insn ""
  1667.   [(set (pc)
  1668.     (if_then_else (le (match_operand:SI 0 "general_operand" "g")
  1669.               (match_operand:SI 1 "general_operand" "g"))
  1670.               (plus:SI (sign_extend:SI
  1671.                 (mem:HI (plus:SI (pc)
  1672.                          (minus:SI (match_dup 0)
  1673.                                (const_int 0)))))
  1674.                    (label_ref:SI (match_operand 3 "" "")))
  1675.               (pc)))]
  1676.   ""
  1677.   "casel %0,$0,%1")
  1678.  
  1679. ;;- load or push effective address 
  1680. ;; These come after the move and add/sub patterns
  1681. ;; because we don't want pushl $1 turned into pushad 1.
  1682. ;; or addl3 r1,r2,r3 turned into movab 0(r1)[r2],r3.
  1683.  
  1684. (define_insn ""
  1685.   [(set (match_operand:SI 0 "general_operand" "=<,g")
  1686.     (match_operand:QI 1 "address_operand" "p,p"))]
  1687.   ""
  1688.   "@
  1689.    pushab %a1
  1690.    movab %a1,%0")
  1691.  
  1692. (define_insn ""
  1693.   [(set (match_operand:SI 0 "general_operand" "=<,g")
  1694.     (match_operand:HI 1 "address_operand" "p,p"))]
  1695.   ""
  1696.   "@
  1697.    pushaw %a1
  1698.    movaw %a1,%0")
  1699.  
  1700. (define_insn ""
  1701.   [(set (match_operand:SI 0 "general_operand" "=<,g")
  1702.     (match_operand:SI 1 "address_operand" "p,p"))]
  1703.   ""
  1704.   "@
  1705.    pushal %a1
  1706.    moval %a1,%0")
  1707.  
  1708. (define_insn ""
  1709.   [(set (match_operand:SI 0 "general_operand" "=<,g")
  1710.     (match_operand:DI 1 "address_operand" "p,p"))]
  1711.   ""
  1712.   "@
  1713.    pushaq %a1
  1714.    movaq %a1,%0")
  1715.  
  1716. (define_insn ""
  1717.   [(set (match_operand:SI 0 "general_operand" "=<,g")
  1718.     (match_operand:SF 1 "address_operand" "p,p"))]
  1719.   ""
  1720.   "@
  1721.    pushaf %a1
  1722.    movaf %a1,%0")
  1723.  
  1724. (define_insn ""
  1725.   [(set (match_operand:SI 0 "general_operand" "=<,g")
  1726.     (match_operand:DF 1 "address_operand" "p,p"))]
  1727.   ""
  1728.   "@
  1729.    pushad %a1
  1730.    movad %a1,%0")
  1731.  
  1732. ;; Optimize   extzv ...,z;    andl2 ...,z
  1733. ;; with other operands constant.
  1734. ;;
  1735. ;; This used to be a peephole, but it is more straightforward to do it
  1736. ;; as a single insn.  However, we must force the output to be a register
  1737. ;; so that we know that we can assign to it twice.
  1738. (define_insn ""
  1739.   [(set (match_operand:SI 0 "general_operand" "=&r")
  1740.     (and:SI (zero_extract:SI (match_operand:SI 1 "general_operand" "g")
  1741.                  (match_operand:QI 2 "const_int_operand" "n")
  1742.                  (match_operand:SI 3 "const_int_operand" "n"))
  1743.         (match_operand:SI 4 "const_int_operand" "n")))]
  1744.   "(INTVAL (operands[2]) + INTVAL (operands[3])) == 32"
  1745.   "*
  1746. {
  1747.   unsigned long mask = INTVAL (operands[4]);
  1748.   operands[3] = gen_rtx (CONST_INT, VOIDmode, -INTVAL (operands[3]));
  1749.  
  1750.   if ((floor_log2 (mask) + 1) >= INTVAL (operands[2]))
  1751.     mask &= ((1 << INTVAL (operands[2])) - 1);
  1752.  
  1753.   operands[4] = gen_rtx (CONST_INT, VOIDmode, ~mask);
  1754.   return \"rotl %3,%1,%0\;bicl2 %4,%0\";
  1755. }")
  1756.  
  1757. ;; Optimize   andl3 x,y,z; extzv z,....,z
  1758.  
  1759. (define_insn ""
  1760.   [(set (match_operand:SI 0 "general_operand" "=&r")
  1761.     (zero_extract:SI (and:SI (match_operand:SI 1 "general_operand" "g")
  1762.                  (match_operand:SI 2 "const_int_operand" "n"))
  1763.              (match_operand:QI 3 "const_int_operand" "n")
  1764.              (match_operand:SI 4 "const_int_operand" "n")))]
  1765.   "(INTVAL (operands[3]) + INTVAL (operands[4])) == 32"
  1766.   "*
  1767. {
  1768.   unsigned long mask = INTVAL (operands[4]);
  1769.  
  1770.   mask &= ~((1 << INTVAL (operands[4])) - 1);
  1771.   operands[2] = gen_rtx (CONST_INT, VOIDmode, ~mask);
  1772.  
  1773.   operands[4] = gen_rtx (CONST_INT, VOIDmode, -INTVAL (operands[4]));
  1774.  
  1775.   if (rtx_equal_p (operands[0], operands[1]))
  1776.     output_asm_insn (\"bicl2 %2,%0\", operands);
  1777.   else
  1778.     output_asm_insn (\"bicl3 %2,%1,%0\", operands);
  1779.   return \"rotl %4,%0,%0\";
  1780. }")
  1781.  
  1782. ;;- Local variables:
  1783. ;;- mode:emacs-lisp
  1784. ;;- comment-start: ";;- "
  1785. ;;- eval: (set-syntax-table (copy-sequence (syntax-table)))
  1786. ;;- eval: (modify-syntax-entry ?[ "(]")
  1787. ;;- eval: (modify-syntax-entry ?] ")[")
  1788. ;;- eval: (modify-syntax-entry ?{ "(}")
  1789. ;;- eval: (modify-syntax-entry ?} "){")
  1790. ;;- End:
  1791.