ip2k.md

gcc-you can use this code to learn something about gcc, and inquire further into linux,

      }
  }"
  [(set_attr "clobberw" "no,yes,yes,yes,yes,yes,yes")])

(define_insn "*adddi3_zero_extendqi" ;		       0   1   2   3   4
  [(set (match_operand:DI 0 "nonimmediate_operand"  "=ro, rS,&ro,&rS,&rS")
        (plus:DI
	 (zero_extend:DI
	  (match_operand:QI 1 "nonimmediate_operand" "rS,roR, rS,roR, rS"))
	 (match_operand:DI 2 "general_operand"        "0,  0,rSi,rSi,roi")))]
  ""
  "*{
    switch (which_alternative)
      {
        case 0:
        case 1:
	  OUT_AS2 (mov, w, %1);
	  OUT_AS2 (add, %Z0, w);
	  OUT_AS1 (clr, wreg);
	  OUT_AS2 (addc, %Y0, w);
	  OUT_AS2 (addc, %X0, w);
	  OUT_AS2 (addc, %W0, w);
	  OUT_AS2 (addc, %V0, w);
	  OUT_AS2 (addc, %U0, w);
	  OUT_AS2 (addc, %T0, w);
	  OUT_AS2 (addc, %S0, w);
          return \"\";

        case 2:
        case 3:
        case 4:
	  OUT_AS2 (mov, w, %1);
	  OUT_AS2 (add, w, %Z2);
	  OUT_AS2 (mov, %Z0, w);
	  OUT_AS2 (mov, w, %Y2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %Y0, w);
	  OUT_AS2 (mov, w, %X2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %X0, w);
	  OUT_AS2 (mov, w, %W2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %W0, w);
	  OUT_AS2 (mov, w, %V2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %V0, w);
	  OUT_AS2 (mov, w, %U2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %U0, w);
	  OUT_AS2 (mov, w, %T2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %T0, w);
	  OUT_AS2 (mov, w, %S2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %S0, w);
          return \"\";

        default:
          abort();
      }
  }")

(define_insn "*adddi3_zero_extendhi" ;		      0  1   2   3   4
  [(set (match_operand:DI 0 "nonimmediate_operand"  "=ro,rS,&ro,&rS,&rS")
        (plus:DI
	 (zero_extend:DI
	  (match_operand:HI 1 "nonimmediate_operand" "rS,ro, rS, ro, rS"))
	 (match_operand:DI 2 "general_operand"        "0, 0,rSi,rSi,roi")))]
  ""
  "*{
    switch (which_alternative)
      {
        case 0:
        case 1:
          OUT_AS2 (mov, w, %L1);
	  OUT_AS2 (add, %Z0, w);
	  OUT_AS2 (mov, w, %H1);
	  OUT_AS2 (addc, %Y0, w);
	  OUT_AS1 (clr, wreg);
	  OUT_AS2 (addc, %X0, w);
	  OUT_AS2 (addc, %W0, w);
	  OUT_AS2 (addc, %V0, w);
	  OUT_AS2 (addc, %U0, w);
	  OUT_AS2 (addc, %T0, w);
	  OUT_AS2 (addc, %S0, w);
	  return \"\";

        case 2:
        case 3:
        case 4:
	  OUT_AS2 (mov, w, %L1);
	  OUT_AS2 (add, w, %Z2);
	  OUT_AS2 (mov, %Z0, w);
	  OUT_AS2 (mov, w, %Y2);
	  OUT_AS2 (addc, w, %H1);
	  OUT_AS2 (mov, %Y0, w);
	  OUT_AS2 (mov, w, %X2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %X0, w);
	  OUT_AS2 (mov, w, %W2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %W0, w);
	  OUT_AS2 (mov, w, %V2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %V0, w);
	  OUT_AS2 (mov, w, %U2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %U0, w);
	  OUT_AS2 (mov, w, %T2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %T0, w);
	  OUT_AS2 (mov, w, %S2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %S0, w);
          return \"\";

        default:
          abort();
      }
  }")

(define_insn "*adddi3_zero_extendsi" ;		       0  1   2   3   4
  [(set (match_operand:DI 0 "nonimmediate_operand"  "=ro,rS,&ro,&rS,&rS")
        (plus:DI
	 (zero_extend:DI
	  (match_operand:SI 1 "nonimmediate_operand" "rS,ro, rS, ro, rS"))
	 (match_operand:DI 2 "general_operand"        "0, 0,rSi,rSi,roi")))]
  ""
  "*{
    switch (which_alternative)
      {
        case 0:
        case 1:
          OUT_AS2 (mov, w, %D1);
	  OUT_AS2 (add, %Z0, w);
	  OUT_AS2 (mov, w, %C1);
	  OUT_AS2 (addc, %Y0, w);
	  OUT_AS2 (mov, w, %B1);
	  OUT_AS2 (addc, %X0, w);
	  OUT_AS2 (mov, w, %A1);
	  OUT_AS2 (addc, %W0, w);
	  OUT_AS1 (clr, wreg);
	  OUT_AS2 (addc, %V0, w);
	  OUT_AS2 (addc, %U0, w);
	  OUT_AS2 (addc, %T0, w);
	  OUT_AS2 (addc, %S0, w);
          return \"\";

        case 2:
        case 3:
        case 4:
	  OUT_AS2 (mov, w, %D1);
	  OUT_AS2 (add, w, %Z2);
	  OUT_AS2 (mov, %Z0, w);
	  OUT_AS2 (mov, w, %Y2);
	  OUT_AS2 (addc, w, %C1);
	  OUT_AS2 (mov, %Y0, w);
	  OUT_AS2 (mov, w, %X2);
	  OUT_AS2 (addc, w, %B1);
	  OUT_AS2 (mov, %X0, w);
	  OUT_AS2 (mov, w, %W2);
	  OUT_AS2 (addc, w, %A1);
	  OUT_AS2 (mov, %W0, w);
	  OUT_AS2 (mov, w, %V2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %V0, w);
	  OUT_AS2 (mov, w, %U2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %U0, w);
	  OUT_AS2 (mov, w, %T2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %T0, w);
	  OUT_AS2 (mov, w, %S2);
	  OUT_AS2 (addc, w, $ff);
	  OUT_AS2 (mov, %S0, w);
          return \"\";

        default:
          abort();
      }
  }")

;;
;; Subtract bytes.
;;

(define_expand "subqi3"
  [(set (match_operand:QI 0 "nonimmediate_operand" "")
        (minus:QI (match_operand:QI 1 "general_operand" "")
		  (match_operand:QI 2 "general_operand" "")))]
  ""
  "if (GET_CODE (operands[2]) == CONST_INT)
     {
       emit_insn (gen_addqi3 (operands[0], operands[1],
                              gen_int_mode (-INTVAL (operands[2]), QImode)));
       DONE;
     }
  ")

(define_insn "*push_subqi3"
  [(set (match_operand:QI 0 "push_operand"               "=<,  <")
  	(minus:QI (match_operand:QI 1 "general_operand"   "g,rSn")
		  (match_operand:QI 2 "general_operand" "rSn,  g")))]
  ""
  "@
   push\\t%1%<\;mov\\tw,%2\;sub\\t1(SP),w%>
   push\\t%1%<\;mov\\tw,%2\;sub\\t1(SP),w%>")

(define_insn "*subqi3_w"
  [(set (reg:QI 10)
	(minus:QI (match_operand:QI 0 "general_operand"  "rS,rSi,  g,rSi")
		  (match_operand:QI 1 "general_operand" "rSi, rS,rSi,  g")))]
  "(ip2k_reorg_split_qimode)"
  "@
   mov\\tw,%1\;sub\\tw,%0
   mov\\tw,%1\;sub\\tw,%0
   mov\\tw,%1\;sub\\tw,%0
   mov\\tw,%1\;sub\\tw,%0")

(define_insn_and_split "*subqi3"
  [(set
    (match_operand:QI
     0 "nonimmediate_operand" "=k,k,z,z,djyoR,djyoR,djyS,djyoR,  g,  g, rS, rS")
    (minus:QI
     (match_operand:QI
      1 "general_operand"     "0,0,0,0,    0,    0,   0,    0, rS,rSi,  g,rSi")
     (match_operand:QI
      2 "general_operand"     "M,g,M,g,    M,    N,   g,  rSi,rSi, rS,rSi,  g")))]
  ""
  "@
   incsnz\\t%0\;dec\\tiph
   mov\\tw,%2\;sub\\t%0,w
   incsnz\\t%0\;dec\\tdph
   mov\\tw,%2\;sub\\t%0,w
   inc\\t%0
   dec\\t%0
   mov\\tw,%2\;sub\\t%0,w
   mov\\tw,%2\;sub\\t%0,w
   #
   #
   #
   #"
  "(ip2k_reorg_split_qimode
    && ! rtx_equal_p (operands[0], operands[1]))"
  [(set (reg:QI 10)
  	(minus:QI (match_dup 1)
		  (match_dup 2)))
   (set (match_dup 0)
   	(reg:QI 10))]
  ""
  [(set_attr "skip" "no,no,no,no,yes,yes,no,no,no,no,no,no")
   (set_attr "clobberw" "no,yes,no,yes,no,no,yes,yes,yes,yes,yes,yes")])

;;
;; Subtract 16-bit integers.
;;

(define_expand "subhi3"
  [(set (match_operand:HI 0 "nonimmediate_operand" "")
        (minus:HI (match_operand:HI 1 "general_operand" "")
		  (match_operand:HI 2 "general_operand" "")))]
  ""
  "if (GET_CODE (operands[2]) == CONST_INT)
     {
       emit_insn (gen_addhi3 (operands[0], operands[1],
                              gen_int_mode (-INTVAL (operands[2]), HImode)));
       DONE;
     }
  ")

(define_insn "*push_subhi3"
  [(set (match_operand:HI 0 "push_operand"               "=<,  <")
  	(minus:HI (match_operand:HI 1 "general_operand" "ron,rSn")
		  (match_operand:HI 2 "general_operand" "rSn,ron")))]
  ""
  "@
   push\\t%L1%<\;mov\\tw,%L2\;sub\\t1(SP),w\;push\\t%H1%<\;mov\\tw,%H2\;subc\\t1(SP),w%>%>
   push\\t%L1%<\;mov\\tw,%L2\;sub\\t1(SP),w\;push\\t%H1%<\;mov\\tw,%H2\;subc\\t1(SP),w%>%>")

(define_insn "*subhi3_imm"
  [(set
    (match_operand:HI 0 "nonimmediate_operand"     "=a,a,a,a,do,&r,&ro,&rS")
    (minus:HI (match_operand:HI 1 "general_operand" "0,0,0,0, 0,ro, rS, ro")
	      (match_operand 2 "immediate_operand"  "N,M,P,i, i, O,  i,  i")))]
  ""
  "@
   dec\\t%L0
   inc\\t%L0
   mov\\tw,%2\;sub\\t%L0,w
   mov\\tw,%L2\;sub\\t%L0,w\;mov\\tw,%H2\;sub\\t%H0,w
   mov\\tw,%L2\;sub\\t%L0,w\;mov\\tw,%H2\;subc\\t%H0,w
   mov\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H1\;mov\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H2\;subc\\tw,%H1\;mov\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H2\;subc\\tw,%H1\;mov\\t%H0,w"
  [(set_attr "skip" "yes,yes,no,no,no,no,no,no")
   (set_attr "clobberw" "no,no,yes,yes,yes,yes,yes,yes")])

(define_insn "*subhi3_ximm_zero_extend"
  [(set (match_operand:HI 0 "nonimmediate_operand"            "=ro, rS")
  	(minus:HI (match_operand:HI 1 "immediate_operand"       "i,  i")
		  (zero_extend:HI
		    (match_operand:QI 2 "nonimmediate_operand" "rS,roR"))))]
  ""
  "@
   mov\\tw,%2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H1\;mov\\t%H0,w\;clr\\twreg\;subc\\t%H0,w
   mov\\tw,%2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H1\;mov\\t%H0,w\;clr\\twreg\;subc\\t%H0,w")

(define_insn "*subhi3_ximm"
  [(set (match_operand:HI 0 "nonimmediate_operand"         "=&uo,&ro,&rS")
  	(minus:HI (match_operand:HI 1 "immediate_operand"     "i,  i,  i")
		  (match_operand:HI 2 "nonimmediate_operand"  "0, rS, ro")))]
  ""
  "@
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;push\\t%H2%<\;mov\\tw,%H1\;mov\\t%H0,w\;pop\\twreg%>\;subc\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H1\;mov\\t%H0,w\;mov\\tw,%H2\;subc\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H1\;mov\\t%H0,w\;mov\\tw,%H2\;subc\\t%H0,w")

(define_insn "*subhi3_nonimm_zero_extend"
  [(set
    (match_operand:HI 0 "nonimmediate_operand" "=a,ro, rS,&ro,&rS,&rS")
    (minus:HI
     (match_operand:HI 1 "nonimmediate_operand" "0, 0,  0, rS, ro, rS")
     (zero_extend:HI
      (match_operand:QI 2 "general_operand"   "roR,rS,roR, rS, rS,roR"))))]
  ""
  "@
   mov\\tw,%2\;sub\\t%L0,w
   mov\\tw,%2\;sub\\t%L0,w\;clr\\twreg\;subc\\t%H0,w
   mov\\tw,%2\;sub\\t%L0,w\;clr\\twreg\;subc\\t%H0,w
   mov\\tw,%2\;sub\\tw,%L1\;mov\\t%L0,w\;clr\\twreg\;subc\\tw,%H1\;mov\\t%H0,w
   mov\\tw,%2\;sub\\tw,%L1\;mov\\t%L0,w\;clr\\twreg\;subc\\tw,%H1\;mov\\t%H0,w
   mov\\tw,%2\;sub\\tw,%L1\;mov\\t%L0,w\;clr\\twreg\;subc\\tw,%H1\;mov\\t%H0,w")

(define_insn "*subhi3_nonimm" ;		          0  1  2   3   4   5  6
  [(set
    (match_operand:HI 0 "nonimmediate_operand"  "=a,dS, o,&rS,&rS,&rS, o")
    (minus:HI
     (match_operand:HI 1 "nonimmediate_operand"  "0, 0, 0, ro, ro, rS,rS")
     (match_operand:HI 2 "nonimmediate_operand" "ro,ro,rS,  0, rS, ro,rS")))]
  ""
  "@
   mov\\tw,%L2\;sub\\t%L0,w\;mov\\tw,%H2\;sub\\t%H0,w
   mov\\tw,%L2\;sub\\t%L0,w\;mov\\tw,%H2\;subc\\t%H0,w
   mov\\tw,%L2\;sub\\t%L0,w\;mov\\tw,%H2\;subc\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H2\;subc\\tw,%H1\;mov\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H2\;subc\\tw,%H1\;mov\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H2\;subc\\tw,%H1\;mov\\t%H0,w
   mov\\tw,%L2\;sub\\tw,%L1\;mov\\t%L0,w\;mov\\tw,%H2\;subc\\tw,%H1\;mov\\t%H0,w")

;;
;; Subtract 32-bit integers.
;;

(define_insn "subsi3" ;	        0  1   2   3   4   5   6   7   8   9   a   b
  [(set
    (match_operand:SI
     0 "nonimmediate_operand" "=ro,ro, ro, rS,&ro,&rS,&ro,&rS,&rS,&ro,&ro,&rS")
    (minus:SI
     (match_operand:SI
      1 "general_operand"    "0, 0,  0,  0,  i, ro, rS, rS, ro, rS,  i,  i")
     (match_operand:SI
      2 "general_operand"    "M, N,rSi,roi,  0,  0,  0,roi,rSi,rSi, rS, ro")))]
  ""
  "*{
    switch (which_alternative) {
    case 0:
      return AS2 (mov, w, #1) CR_TAB
             AS2 (add, %D0, w) CR_TAB
	     AS1 (clr, wreg) CR_TAB
	     AS2 (addc, %C0, w) CR_TAB
	     AS2 (addc, %B0, w) CR_TAB
	     AS2 (addc, %A0, w);
      
    case 1:
      return AS2 (mov, w, #-1) CR_TAB
             AS2 (sub, %D0, w) CR_TAB
	     AS2 (subc, %C0, w) CR_TAB
	     AS2 (subc, %B0, w) CR_TAB
	     AS2 (subc, %A0, w);
      
    case 2:
    case 3:
      return AS2 (mov, w, %D2) CR_TAB
             AS2 (sub, %D0, w) CR_TAB
	     AS2 (mov, w, %C2) CR_TAB
	     AS2 (subc, %C0, w) CR_TAB
	     AS2 (mov, w, %B2) CR_TAB
	     AS2 (subc, %B0, w) CR_TAB
	     AS2 (mov, w, %A2) CR_TAB
	     AS2 (subc, %A0, w);

    case 4:
      return AS2 (mov, w, %D2) CR_TAB
             AS2 (sub, w, %D1) CR_TAB
	     AS2 (mov, %D0, w) CR_TAB
	     AS1 (push, %C2%<) CR_TAB
	     AS2 (mov, w, %C1) CR_TAB
	     AS2 (mov, %C0, w) CR_TAB
	     AS1 (pop, wreg%>) CR_TAB
	     AS2 (subc, %C0, w) CR_TAB
	     AS1 (push, %B2%<) CR_TAB