gcc/config/stormy16/stormy16.md

   1 ;; XSTORMY16 Machine description template
   2 ;; Copyright (C) 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005, 2007, 2008
   3 ;; Free Software Foundation, Inc.
   4 ;; Contributed by Red Hat, Inc.
   5
   6 ;; This file is part of GCC.
   7
   8 ;; GCC 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 3, or (at your option)
  11 ;; any later version.
  12
  13 ;; GCC 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 GCC; see the file COPYING3.  If not see
  20 ;; <http://www.gnu.org/licenses/>.
  21
  22 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
  23
  24 ;; Constraints
  25 ;; a  $0
  26 ;; b  $1
  27 ;; c  $2
  28 ;; d  $8
  29 ;; e  $0..$7
  30 ;; t  $0..$1
  31 ;; z  $8..$9
  32 ;; I  0..3
  33 ;; J  2**N mask
  34 ;; K  2**N antimask
  35 ;; L  0..255
  36 ;; M  -255..0
  37 ;; N  -3..0
  38 ;; O  1..4
  39 ;; P  -4..-1
  40 ;; Q  post-inc mem (push)
  41 ;; R  pre-dec mem (pop)
  42 ;; S  immediate mem
  43 ;; T  Rx
  44 ;; U  -inf..1 or 16..inf
  45 ;; Z  0
  46
  47 (define_constants
  48   [
  49     (CARRY_REG 16)
  50   ]
  51 )
  52 \f
  53 ;; ::::::::::::::::::::
  54 ;; ::
  55 ;; :: Attributes
  56 ;; ::
  57 ;; ::::::::::::::::::::
  58
  59 ; Categorize branches for the conditional in the length attribute.
  60 (define_attr "branch_class" "notdirectbranch,br12,bcc12,bcc8p2,bcc8p4"
  61     (const_string "notdirectbranch"))
  62
  63 ; The length of an instruction, used for branch shortening.
  64 (define_attr "length" ""
  65   (cond
  66    [(eq_attr "branch_class" "br12")
  67      (if_then_else (and (ge (minus (match_dup 0) (pc)) (const_int -2046))
  68                         (lt (minus (match_dup 0) (pc)) (const_int 2048)))
  69                    (const_int 2)
  70                    (const_int 4))
  71     (eq_attr "branch_class" "bcc12")
  72      (if_then_else (and (ge (minus (match_dup 0) (pc)) (const_int -2044))
  73                         (lt (minus (match_dup 0) (pc)) (const_int 2048)))
  74                    (const_int 4)
  75                    (const_int 8))
  76     (eq_attr "branch_class" "bcc8p2")
  77      (if_then_else (and (ge (minus (match_dup 0) (pc)) (const_int -124))
  78                         (lt (minus (match_dup 0) (pc)) (const_int 128)))
  79                    (const_int 4)
  80                    (const_int 8))
  81     (eq_attr "branch_class" "bcc8p4")
  82      (if_then_else (and (ge (minus (match_dup 0) (pc)) (const_int -122))
  83                         (lt (minus (match_dup 0) (pc)) (const_int 128)))
  84                    (const_int 6)
  85                    (const_int 10))]
  86    (const_int 2)))
  87
  88 ; The operand which determines the setting of Rpsw.
  89 ; The numbers indicate the operand number,
  90 ; 'clobber' indicates it is changed in some unspecified way
  91 ; 'nop' means it is not changed.
  92 (define_attr "psw_operand" "clobber,nop,0,1,2,3,4" (const_string "0"))
  93
  94 (define_asm_attributes [(set_attr "length" "4")
  95                         (set_attr "psw_operand" "clobber")])
  96
  97 (include "predicates.md")
  98 \f
  99 ;; ::::::::::::::::::::
 100 ;; ::
 101 ;; :: Moves
 102 ;; ::
 103 ;; ::::::::::::::::::::
 104 ;; push/pop qi and hi are here as separate insns rather than part of
 105 ;; the movqi/hi patterns because we need to ensure that reload isn't
 106 ;; passed anything it can't cope with.  Without these patterns, we
 107 ;; might end up with
 108
 109 ;; (set (mem (post_inc (sp))) mem (post_inc (reg)))
 110
 111 ;; If, in this example, reg needs reloading, reload will read reg from
 112 ;; the stack , adjust sp, and store reg back at what is now the wrong
 113 ;; offset.  By using separate patterns for push and pop we ensure that
 114 ;; insns like this one are never generated.
 115
 116 (define_insn "pushqi1"
 117   [(set (mem:QI (post_inc (reg:HI 15)))
 118         (match_operand:QI 0 "register_operand" "r"))]
 119   ""
 120   "push %0"
 121   [(set_attr "psw_operand" "nop")
 122    (set_attr "length" "2")])
 123
 124 (define_insn "popqi1"
 125   [(set (match_operand:QI 0 "register_operand" "=r")
 126         (mem:QI (pre_dec (reg:HI 15))))]
 127   ""
 128   "pop %0"
 129   [(set_attr "psw_operand" "nop")
 130    (set_attr "length" "2")])
 131
 132 (define_expand "movqi"
 133   [(set (match_operand:QI 0 "nonimmediate_nonstack_operand" "")
 134         (match_operand:QI 1 "general_operand" ""))]
 135   ""
 136   { xstormy16_expand_move (QImode, operands[0], operands[1]);
 137     DONE;
 138   })
 139
 140 (define_insn "movqi_internal"
 141   [(set (match_operand:QI 0 "nonimmediate_nonstack_operand" "=r,m,e,e,T,r,S,W,e")
 142         (match_operand:QI 1 "general_operand"       "r,e,m,i,i,i,i,ie,W"))]
 143   ""
 144   "@
 145    mov %0,%1
 146    mov.b %0,%1
 147    mov.b %0,%1
 148    mov %0,%1
 149    mov Rx,%1
 150    mov %0,%1
 151    mov.b %0,%1
 152    mov.b %0,%1
 153    mov.b %0,%1"
 154   [(set_attr_alternative "length"
 155              [(const_int 2)
 156               (if_then_else (match_operand:QI 0 "short_memory_operand" "")
 157                             (const_int 2)
 158                             (const_int 4))
 159               (if_then_else (match_operand:QI 1 "short_memory_operand" "")
 160                             (const_int 2)
 161                             (const_int 4))
 162               (const_int 2)
 163               (const_int 2)
 164               (const_int 4)
 165               (const_int 4)
 166               (const_int 2)
 167               (const_int 2)])
 168    (set_attr "psw_operand" "0,0,0,0,nop,0,nop,0,0")])
 169
 170 (define_insn "pushhi1"
 171   [(set (mem:HI (post_inc (reg:HI 15)))
 172         (match_operand:HI 0 "register_operand" "r"))]
 173   ""
 174   "push %0"
 175   [(set_attr "psw_operand" "nop")
 176    (set_attr "length" "2")])
 177
 178 (define_insn "pophi1"
 179   [(set (match_operand:HI 0 "register_operand" "=r")
 180         (mem:HI (pre_dec (reg:HI 15))))]
 181   ""
 182   "pop %0"
 183   [(set_attr "psw_operand" "nop")
 184    (set_attr "length" "2")])
 185
 186 (define_expand "movhi"
 187   [(set (match_operand:HI 0 "nonimmediate_nonstack_operand" "")
 188         (match_operand:HI 1 "xs_hi_general_operand" ""))]
 189   ""
 190   { xstormy16_expand_move (HImode, operands[0], operands[1]);
 191     DONE;
 192   })
 193
 194 (define_insn "movhi_internal"
 195   [(set (match_operand:HI 0 "nonimmediate_nonstack_operand" "=r,m,e,e,T,r,S,W,e")
 196         (match_operand:HI 1 "xs_hi_general_operand"          "r,e,m,L,L,i,i,ie,W"))]
 197   ""
 198   "@
 199    mov %0,%1
 200    mov.w %0,%1
 201    mov.w %0,%1
 202    mov.w %0,%1
 203    mov.w Rx,%1
 204    mov.w %0,%1
 205    mov.w %0,%1
 206    mov.w %0,%1
 207    mov.w %0,%1"
 208   [(set_attr_alternative "length"
 209              [(const_int 2)
 210               (if_then_else (match_operand:QI 0 "short_memory_operand" "")
 211                             (const_int 2)
 212                             (const_int 4))
 213               (if_then_else (match_operand:QI 1 "short_memory_operand" "")
 214                             (const_int 2)
 215                             (const_int 4))
 216               (const_int 2)
 217               (const_int 2)
 218               (const_int 4)
 219               (const_int 4)
 220               (const_int 4)
 221               (const_int 4)])
 222    (set_attr "psw_operand" "0,0,0,0,nop,0,nop,0,0")])
 223
 224 (define_expand "movsi"
 225   [(set (match_operand:SI 0 "nonimmediate_operand" "")
 226         (match_operand:SI 1 "general_operand" ""))]
 227   ""
 228   { xstormy16_expand_move (SImode, operands[0], operands[1]);
 229     DONE;
 230   })
 231
 232 (define_insn_and_split "*movsi_internal"
 233   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,Q,r,m,e,&e,e,r,S")
 234         (match_operand:SI 1 "general_operand"       "r,r,R,e,o, V,L,i,i"))]
 235   ""
 236   "#"
 237   "reload_completed"
 238   [(pc)]
 239   { xstormy16_split_move (SImode, operands[0], operands[1]);
 240     DONE;
 241   }
 242   [(set_attr_alternative "length"
 243              [(const_int 4)
 244               (const_int 4)
 245               (const_int 4)
 246               (if_then_else (match_operand:QI 0 "short_memory_operand" "")
 247                             (const_int 6)
 248                             (const_int 8))
 249               (if_then_else (match_operand:QI 1 "short_memory_operand" "")
 250                             (const_int 6)
 251                             (const_int 8))
 252               (if_then_else (match_operand:QI 1 "short_memory_operand" "")
 253                             (const_int 6)
 254                             (const_int 8))
 255               (const_int 4)
 256               (const_int 8)
 257               (const_int 8)])])
 258 \f
 259 ;; ::::::::::::::::::::
 260 ;; ::
 261 ;; :: Conversions
 262 ;; ::
 263 ;; ::::::::::::::::::::
 264
 265 (define_insn "extendqihi2"
 266   [(set (match_operand:HI 0 "register_operand" "=r")
 267         (sign_extend:HI (match_operand:QI 1 "register_operand" "0")))]
 268   ""
 269   "cbw %0")
 270
 271 (define_insn "zero_extendqihi2"
 272   [(set (match_operand:HI                 0 "register_operand"     "=e,r")
 273         (zero_extend:HI (match_operand:QI 1 "nonimmediate_operand" "m,0")))]
 274   ""
 275   "@
 276    mov.b %0, %1
 277    shl %0,#8\n\tshr %0,#8"
 278   [(set_attr "psw_operand" "nop,0")
 279    (set_attr_alternative "length"
 280              [(const_int 4)
 281               (const_int 8)])])
 282 \f
 283 ;; ::::::::::::::::::::
 284 ;; ::
 285 ;; :: Bit field extraction
 286 ;; ::
 287 ;; ::::::::::::::::::::
 288
 289 ;; Extract an unsigned bit field
 290 ;(define_insn "extzv"
 291 ;  [(set (match_operand:SI 0 "register_operand" "=r")
 292 ;       (zero_extract:SI (match_operand:SI 1 "register_operand" "r")
 293 ;                        (match_operand:SI 2 "const_int_operand" "n")
 294 ;                        (match_operand:SI 3 "const_int_operand" "n")))]
 295 ;  ""
 296 ;  "extzv %0,%1,%2,%3"
 297 ;  [(set_attr "length" "4")])
 298
 299 ;; Insert a bit field
 300 ;(define_insn "insv"
 301 ;  [(set (zero_extract:SI (match_operand:SI 0 "register_operand" "+r")
 302 ;                        (match_operand:SI 1 "const_int_operand" "n")
 303 ;                        (match_operand:SI 2 "const_int_operand" "n"))
 304 ;       (match_operand:SI 3 "nonmemory_operand" "ri"))]
 305 ;  ""
 306 ;  "insv %0,%1,%2,%3"
 307 ;  [(set_attr "length" "4")])
 308
 309 \f
 310 ;; ::::::::::::::::::::
 311 ;; ::
 312 ;; :: 16-bit Integer arithmetic
 313 ;; ::
 314 ;; ::::::::::::::::::::
 315
 316 ;; Addition
 317 ; Note - the early clobber modifier is no longer needed on operand 3
 318 ; and in fact can cause some reload spill failures if it is present.
 319 ; Note that the 'Z' constraint matches "add $reg,0", which reload
 320 ; will occasionally emit.  We avoid the "add $reg,imm" match because
 321 ; it clobbers the carry.
 322 (define_insn "addhi3"
 323   [(set (match_operand:HI 0 "register_operand" "=r,r,r,T,T,r,r,r")
 324         (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0,0,0,0,0,0")
 325                  (match_operand:HI 2 "xs_hi_nonmemory_operand" "O,P,Z,L,M,Ir,N,i")))
 326    (clobber (reg:BI CARRY_REG))]
 327   ""
 328   "@
 329    inc %0,%o2
 330    dec %0,%O2
 331    ;
 332    add Rx,%2
 333    sub Rx,#%n2
 334    add %0,%2
 335    sub %0,#%n2
 336    add %0,%2"
 337   [(set_attr "length" "2,2,0,2,2,2,2,4")])
 338
 339 (define_insn "addchi4"
 340   [(set (match_operand:HI 0 "register_operand" "=T,r,r")
 341         (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0")
 342                  (match_operand:HI 2 "xs_hi_nonmemory_operand" "L,Ir,i")))
 343    (set (reg:BI CARRY_REG)
 344         (truncate:BI (lshiftrt:SI (plus:SI (zero_extend:SI (match_dup 1))
 345                                            (zero_extend:SI (match_dup 2)))
 346                                   (const_int 16))))]
 347   ""
 348   "@
 349    add Rx,%2
 350    add %0,%2
 351    add %0,%2"
 352   [(set_attr "length" "2,2,4")])
 353
 354 (define_insn "addchi5"
 355   [(set (match_operand:HI 0 "register_operand" "=T,r,r")
 356         (plus:HI (plus:HI (match_operand:HI 1 "register_operand" "%0,0,0")
 357                           (zero_extend:HI (reg:BI CARRY_REG)))
 358                  (match_operand:HI 2 "xs_hi_nonmemory_operand" "L,Ir,i")))
 359    (set (reg:BI CARRY_REG)
 360         (truncate:BI (lshiftrt:SI (plus:SI (plus:SI
 361                                             (zero_extend:SI (match_dup 1))
 362                                             (zero_extend:SI (reg:BI CARRY_REG)))
 363                                            (zero_extend:SI (match_dup 2)))
 364                                   (const_int 16))))]
 365   ""
 366   "@
 367    adc Rx,%2
 368    adc %0,%2
 369    adc %0,%2"
 370   [(set_attr "length" "2,2,4")])
 371
 372 ;; Subtraction
 373 ; Operand 3 is marked earlyclobber because that helps reload
 374 ; to generate better code---this pattern will never need the
 375 ; carry register as an input, and some output reloads or input
 376 ; reloads might need to use it.  In fact, without the '&' reload
 377 ; will fail in some cases.
 378 (define_insn "subhi3"
 379   [(set (match_operand:HI 0 "register_operand" "=r,r,T,T,r,r,r")
 380         (minus:HI (match_operand:HI 1 "register_operand" "0,0,0,0,0,0,0")
 381                   (match_operand:HI 2 "xs_hi_nonmemory_operand" "O,P,L,M,rI,M,i")))
 382    (clobber (reg:BI CARRY_REG))]
 383   ""
 384   "@
 385    dec %0,%o2
 386    inc %0,%O2
 387    sub Rx,%2
 388    add Rx,#%n2
 389    sub %0,%2
 390    add %0,#%n2
 391    sub %0,%2"
 392   [(set_attr "length" "2,2,2,2,2,2,4")])
 393
 394 (define_insn "subchi4"
 395   [(set (match_operand:HI 0 "register_operand" "=T,r,r")
 396         (minus:HI (match_operand:HI 1 "register_operand" "0,0,0")
 397                   (match_operand:HI 2 "xs_hi_nonmemory_operand" "L,Ir,i")))
 398    (set (reg:BI CARRY_REG)
 399         (truncate:BI (lshiftrt:SI (minus:SI (zero_extend:SI (match_dup 1))
 400                                             (zero_extend:SI (match_dup 2)))
 401                                   (const_int 16))))]
 402   ""
 403   "@
 404    sub Rx,%2
 405    sub %0,%2
 406    sub %0,%2"
 407   [(set_attr "length" "2,2,4")])
 408
 409 (define_insn "subchi5"
 410   [(set (match_operand:HI 0 "register_operand" "=T,r,r")
 411         (minus:HI (minus:HI (match_operand:HI 1 "register_operand" "0,0,0")
 412                           (zero_extend:HI (reg:BI CARRY_REG)))
 413                  (match_operand:HI 2 "xs_hi_nonmemory_operand" "L,Ir,i")))
 414    (set (reg:BI CARRY_REG)
 415         (truncate:BI (lshiftrt:SI (minus:SI (minus:SI
 416                                              (zero_extend:SI (match_dup 1))
 417                                              (zero_extend:SI (reg:BI CARRY_REG)))
 418                                             (zero_extend:SI (match_dup 2)))
 419                                   (const_int 16))))]
 420   ""
 421   "@
 422    sbc Rx,%2
 423    sbc %0,%2
 424    sbc %0,%2"
 425   [(set_attr "length" "2,2,4")])
 426
 427 ; Basic multiplication
 428 (define_insn "mulhi3"
 429   [(set (match_operand:HI 0 "register_operand" "=a")
 430         (mult:HI (match_operand:HI 1 "register_operand" "%a")
 431                  (match_operand:HI 2 "register_operand" "c")))
 432    (clobber (match_scratch:HI 3 "=b"))
 433    ]
 434   ""
 435   "mul"
 436   [(set_attr "psw_operand" "nop")])
 437
 438 ;; Unsigned multiplication producing 64-bit results from 32-bit inputs
 439 ; The constraint on operand 0 is 't' because it is actually two regs
 440 ; long, and both regs must match the constraint.
 441 (define_insn "umulhisi3"
 442   [(set (match_operand:SI 0 "register_operand" "=t")
 443         (mult:SI (zero_extend:SI (match_operand:HI 1 "register_operand" "%a"))
 444                  (zero_extend:SI (match_operand:HI 2 "register_operand" "c"))))
 445    ]
 446   ""
 447   "mul"
 448   [(set_attr "psw_operand" "nop")])
 449
 450 ;; Unsigned division giving both quotient and remainder
 451 (define_insn "udivmodhi4"
 452   [(set (match_operand:HI 0 "register_operand" "=a")
 453         (udiv:HI (match_operand:HI 1 "register_operand" "a")
 454                  (match_operand:HI 2 "register_operand" "c")))
 455    (set (match_operand:HI 3 "register_operand" "=b")
 456         (umod:HI (match_dup 1)
 457                  (match_dup 2)))]
 458   ""
 459   "div"
 460   [(set_attr "psw_operand" "nop")])
 461
 462 ;; Signed division giving both quotient and remainder
 463 (define_insn "divmodhi4"
 464   [(set (match_operand:HI 0 "register_operand" "=a")
 465         (div:HI (match_operand:HI 1 "register_operand" "a")
 466                  (match_operand:HI 2 "register_operand" "c")))
 467    (set (match_operand:HI 3 "register_operand" "=b")
 468         (mod:HI (match_dup 1)
 469                  (match_dup 2)))]
 470   ""
 471   "sdiv"
 472   [(set_attr "psw_operand" "nop")])
 473
 474 ;; Signed 32/16 division
 475 (define_insn "sdivlh"
 476   [(set (match_operand:HI 0 "register_operand" "=a")
 477         (div:HI (match_operand:SI 2 "register_operand" "t")
 478                  (match_operand:HI 3 "register_operand" "c")))
 479    (set (match_operand:HI 1 "register_operand" "=b")
 480         (mod:HI (match_dup 2)
 481                  (match_dup 3)))]
 482   ""
 483   "sdivlh"
 484   [(set_attr "psw_operand" "nop")])
 485
 486 ;; Unsigned 32/16 division
 487 (define_insn "udivlh"
 488   [(set (match_operand:HI 0 "register_operand" "=a")
 489         (udiv:HI (match_operand:SI 2 "register_operand" "t")
 490                  (match_operand:HI 3 "register_operand" "c")))
 491    (set (match_operand:HI 1 "register_operand" "=b")
 492         (umod:HI (match_dup 2)
 493                  (match_dup 3)))]
 494   ""
 495   "divlh"
 496   [(set_attr "psw_operand" "nop")])
 497
 498 ;; Negation
 499
 500 (define_expand "neghi2"
 501   [(set (match_operand:HI 0 "register_operand" "")
 502         (not:HI (match_operand:HI 1 "register_operand" "")))
 503    (parallel [(set (match_dup 0) (plus:HI (match_dup 0) (const_int 1)))
 504               (clobber (reg:BI CARRY_REG))])]
 505   ""
 506   "")
 507 \f
 508 ;; ::::::::::::::::::::
 509 ;; ::
 510 ;; :: 16-bit Integer Shifts and Rotates
 511 ;; ::
 512 ;; ::::::::::::::::::::
 513
 514 ;; Arithmetic Shift Left
 515 (define_insn "ashlhi3"
 516   [(set (match_operand:HI 0 "register_operand" "=r")
 517         (ashift:HI (match_operand:HI 1 "register_operand" "0")
 518                    (match_operand:HI 2 "nonmemory_operand" "ri")))
 519    (clobber (reg:BI CARRY_REG))]
 520   ""
 521   "shl %0,%2")
 522
 523 ;; Arithmetic Shift Right
 524 (define_insn "ashrhi3"
 525   [(set (match_operand:HI 0 "register_operand" "=r")
 526         (ashiftrt:HI (match_operand:HI 1 "register_operand" "0")
 527                      (match_operand:HI 2 "nonmemory_operand" "ri")))
 528    (clobber (reg:BI CARRY_REG))]
 529   ""
 530   "asr %0,%2")
 531
 532 ;; Logical Shift Right
 533 (define_insn "lshrhi3"
 534   [(set (match_operand:HI 0 "register_operand" "=r")
 535         (lshiftrt:HI (match_operand:HI 1 "register_operand" "0")
 536                      (match_operand:HI 2 "nonmemory_operand" "ri")))
 537    (clobber (reg:BI CARRY_REG))]
 538   ""
 539   "shr %0,%2")
 540 \f
 541 ;; ::::::::::::::::::::
 542 ;; ::
 543 ;; :: 16-Bit Integer Logical operations
 544 ;; ::
 545 ;; ::::::::::::::::::::
 546
 547 ;; Logical AND, 16-bit integers
 548 (define_insn "andhi3"
 549   [(set (match_operand:HI 0 "xstormy16_splittable_below100_or_register" "=T,r,r,r,W")
 550         (and:HI (match_operand:HI 1 "xstormy16_below100_or_register" "%0,0,0,0,0")
 551                 (match_operand:HI 2 "nonmemory_operand" "L,r,K,i,K")))]
 552   ""
 553   "@
 554    and Rx,%2
 555    and %0,%2
 556    clr1 %0,%B2
 557    and %0,%2
 558    #"
 559   [(set_attr "length" "2,2,2,4,2")])
 560
 561 (define_split
 562   [(set (match_operand:HI 0 "xstormy16_below100_operand" "")
 563         (and:HI (match_operand:HI 1 "xstormy16_below100_operand" "")
 564                 (match_operand:HI 2 "xstormy16_onebit_clr_operand" "")))]
 565   ""
 566   [(set (match_dup 3)
 567         (and:QI (match_dup 4)
 568                 (match_dup 5)))]
 569   { int s = ((INTVAL (operands[2]) & 0xff) == 0xff) ? 1 : 0;
 570     operands[3] = simplify_gen_subreg (QImode, operands[0], HImode, s);
 571     operands[4] = simplify_gen_subreg (QImode, operands[1], HImode, s);
 572     operands[5] = simplify_gen_subreg (QImode, operands[2], HImode, s);
 573     operands[5] = GEN_INT (INTVAL (operands[5]) | ~ (HOST_WIDE_INT) 0xff);
 574   })
 575
 576 ;; Inclusive OR, 16-bit integers
 577 (define_insn "iorhi3"
 578   [(set (match_operand:HI 0 "xstormy16_splittable_below100_or_register" "=T,r,r,r,W")
 579         (ior:HI (match_operand:HI 1 "xstormy16_below100_or_register" "%0,0,0,0,0")
 580                 (match_operand:HI 2 "nonmemory_operand" "L,r,J,i,J")))]
 581   ""
 582   "@
 583    or Rx,%2
 584    or %0,%2
 585    set1 %0,%B2
 586    or %0,%2
 587    #"
 588   [(set_attr "length" "2,2,2,4,2")])
 589
 590 (define_split
 591   [(set (match_operand:HI 0 "xstormy16_below100_operand" "")
 592         (ior:HI (match_operand:HI 1 "xstormy16_below100_operand" "")
 593                 (match_operand:HI 2 "xstormy16_onebit_set_operand" "")))]
 594   ""
 595   [(set (match_dup 3)
 596         (ior:QI (match_dup 4)
 597                 (match_dup 5)))]
 598   { int s = ((INTVAL (operands[2]) & 0xff) == 0x00) ? 1 : 0;
 599     operands[3] = simplify_gen_subreg (QImode, operands[0], HImode, s);
 600     operands[4] = simplify_gen_subreg (QImode, operands[1], HImode, s);
 601     operands[5] = simplify_gen_subreg (QImode, operands[2], HImode, s);
 602     operands[5] = GEN_INT (INTVAL (operands[5]) & 0xff);
 603   })
 604
 605 ;; Exclusive OR, 16-bit integers
 606 (define_insn "xorhi3"
 607   [(set (match_operand:HI 0 "register_operand" "=T,r,r")
 608         (xor:HI (match_operand:HI 1 "register_operand" "%0,0,0")
 609                 (match_operand:HI 2 "nonmemory_operand" "L,r,i")))]
 610   ""
 611   "@
 612    xor Rx,%2
 613    xor %0,%2
 614    xor %0,%2"
 615   [(set_attr "length" "2,2,4")])
 616
 617 ;; One's complement, 16-bit integers
 618 (define_insn "one_cmplhi2"
 619   [(set (match_operand:HI 0 "register_operand" "=r")
 620         (not:HI (match_operand:HI 1 "register_operand" "0")))]
 621   ""
 622   "not %0")
 623 \f
 624 ;; ::::::::::::::::::::
 625 ;; ::
 626 ;; :: 32-bit Integer arithmetic
 627 ;; ::
 628 ;; ::::::::::::::::::::
 629
 630 ;; Addition
 631 (define_insn_and_split "addsi3"
 632   [(set (match_operand:SI 0 "register_operand" "=r")
 633         (plus:SI (match_operand:SI 1 "register_operand" "%0")
 634                  (match_operand:SI 2 "nonmemory_operand" "ri")))
 635    (clobber (reg:BI CARRY_REG))]
 636   ""
 637   "#"
 638   "reload_completed"
 639   [(pc)]
 640   { xstormy16_expand_arith (SImode, PLUS, operands[0], operands[1],
 641                             operands[2]);
 642     DONE;
 643   }
 644   [(set_attr "length" "4")])
 645
 646 ;; Subtraction
 647 (define_insn_and_split "subsi3"
 648   [(set (match_operand:SI 0 "register_operand" "=r")
 649         (minus:SI (match_operand:SI 1 "register_operand" "0")
 650                  (match_operand:SI 2 "nonmemory_operand" "ri")))
 651    (clobber (reg:BI CARRY_REG))]
 652   ""
 653   "#"
 654   "reload_completed"
 655   [(pc)]
 656   { xstormy16_expand_arith (SImode, MINUS, operands[0], operands[1],
 657                             operands[2]);
 658     DONE;
 659   }
 660   [(set_attr "length" "4")])
 661
 662 (define_expand "negsi2"
 663   [(parallel [(set (match_operand:SI 0 "register_operand" "")
 664                    (neg:SI (match_operand:SI 1 "register_operand" "")))
 665               (clobber (reg:BI CARRY_REG))])]
 666   ""
 667   { operands[2] = gen_reg_rtx (HImode); })
 668
 669 (define_insn_and_split "*negsi2_internal"
 670   [(set (match_operand:SI 0 "register_operand" "=&r")
 671         (neg:SI (match_operand:SI 1 "register_operand" "r")))
 672    (clobber (reg:BI CARRY_REG))]
 673   ""
 674   "#"
 675   "reload_completed"
 676   [(pc)]
 677   { xstormy16_expand_arith (SImode, NEG, operands[0], operands[0],
 678                             operands[1]);
 679     DONE;
 680   })
 681
 682 ;; ::::::::::::::::::::
 683 ;; ::
 684 ;; :: 32-bit Integer Shifts and Rotates
 685 ;; ::
 686 ;; ::::::::::::::::::::
 687
 688 ;; Arithmetic Shift Left
 689 (define_expand "ashlsi3"
 690   [(parallel [(set (match_operand:SI 0 "register_operand" "")
 691                    (ashift:SI (match_operand:SI 1 "register_operand" "")
 692                               (match_operand:SI 2 "const_int_operand" "")))
 693               (clobber (reg:BI CARRY_REG))
 694               (clobber (match_dup 3))])]
 695   ""
 696   { if (! const_int_operand (operands[2], SImode))
 697       FAIL;
 698     operands[3] = gen_reg_rtx (HImode);
 699   })
 700
 701 ;; Arithmetic Shift Right
 702 (define_expand "ashrsi3"
 703   [(parallel [(set (match_operand:SI 0 "register_operand" "")
 704                    (ashiftrt:SI (match_operand:SI 1 "register_operand" "")
 705                                 (match_operand:SI 2 "const_int_operand" "")))
 706               (clobber (reg:BI CARRY_REG))
 707               (clobber (match_dup 3))])]
 708   ""
 709   { if (! const_int_operand (operands[2], SImode))
 710       FAIL;
 711     operands[3] = gen_reg_rtx (HImode);
 712   })
 713
 714 ;; Logical Shift Right
 715 (define_expand "lshrsi3"
 716   [(parallel [(set (match_operand:SI 0 "register_operand" "")
 717                    (lshiftrt:SI (match_operand:SI 1 "register_operand" "")
 718                                 (match_operand:SI 2 "const_int_operand" "")))
 719               (clobber (reg:BI CARRY_REG))
 720               (clobber (match_dup 3))])]
 721   ""
 722   { if (! const_int_operand (operands[2], SImode))
 723       FAIL;
 724     operands[3] = gen_reg_rtx (HImode);
 725   })
 726
 727 (define_insn "*shiftsi"
 728   [(set (match_operand:SI 0 "register_operand" "=r,r")
 729         (match_operator:SI 4 "shift_operator"
 730          [(match_operand:SI 1 "register_operand" "0,0")
 731           (match_operand:SI 2 "const_int_operand" "U,n")]))
 732    (clobber (reg:BI CARRY_REG))
 733    (clobber (match_operand:HI 3 "" "=X,r"))]
 734   ""
 735   "* return xstormy16_output_shift (SImode, GET_CODE (operands[4]),
 736                                     operands[0], operands[2], operands[3]);"
 737   [(set_attr "length" "6,10")
 738    (set_attr "psw_operand" "clobber,clobber")])
 739 \f
 740 ;; ::::::::::::::::::::
 741 ;; ::
 742 ;; :: Comparisons
 743 ;; ::
 744 ;; ::::::::::::::::::::
 745
 746 ;; Note, we store the operands in the comparison insns, and use them later
 747 ;; when generating the branch or scc operation.
 748
 749 ;; First the routines called by the machine independent part of the compiler
 750 (define_expand "cmphi"
 751   [(set (cc0)
 752         (compare (match_operand:HI 0 "register_operand" "")
 753                  (match_operand:HI 1 "nonmemory_operand" "")))]
 754   ""
 755   {
 756     xstormy16_compare_op0 = operands[0];
 757     xstormy16_compare_op1 = operands[1];
 758     DONE;
 759   })
 760
 761 ; There are no real SImode comparisons, but some can be emulated
 762 ; by performing a SImode subtract and looking at the condition flags.
 763 (define_expand "cmpsi"
 764   [(set (cc0)
 765         (compare (match_operand:SI 0 "register_operand" "")
 766                  (match_operand:SI 1 "nonmemory_operand" "")))]
 767   ""
 768   {
 769     xstormy16_compare_op0 = operands[0];
 770     xstormy16_compare_op1 = operands[1];
 771     DONE;
 772   })
 773 \f
 774 ;; ::::::::::::::::::::
 775 ;; ::
 776 ;; :: Branches
 777 ;; ::
 778 ;; ::::::::::::::::::::
 779
 780 (define_expand "beq"
 781   [(use (match_operand 0 "" ""))]
 782   ""
 783   { xstormy16_emit_cbranch (EQ, operands[0]); DONE; })
 784
 785 (define_expand "bne"
 786   [(use (match_operand 0 "" ""))]
 787   ""
 788   { xstormy16_emit_cbranch (NE, operands[0]); DONE; })
 789
 790 (define_expand "bge"
 791   [(use (match_operand 0 "" ""))]
 792   ""
 793   { xstormy16_emit_cbranch (GE, operands[0]); DONE; })
 794
 795 (define_expand "bgt"
 796   [(use (match_operand 0 "" ""))]
 797   ""
 798   { xstormy16_emit_cbranch (GT, operands[0]); DONE; })
 799
 800 (define_expand "ble"
 801   [(use (match_operand 0 "" ""))]
 802   ""
 803   { xstormy16_emit_cbranch (LE, operands[0]); DONE; })
 804
 805 (define_expand "blt"
 806   [(use (match_operand 0 "" ""))]
 807   ""
 808   { xstormy16_emit_cbranch (LT, operands[0]); DONE; })
 809
 810 (define_expand "bgeu"
 811   [(use (match_operand 0 "" ""))]
 812   ""
 813   { xstormy16_emit_cbranch (GEU, operands[0]); DONE; })
 814
 815 (define_expand "bgtu"
 816   [(use (match_operand 0 "" ""))]
 817   ""
 818   { xstormy16_emit_cbranch (GTU, operands[0]); DONE; })
 819
 820 (define_expand "bleu"
 821   [(use (match_operand 0 "" ""))]
 822   ""
 823   { xstormy16_emit_cbranch (LEU, operands[0]); DONE; })
 824
 825 (define_expand "bltu"
 826   [(use (match_operand 0 "" ""))]
 827   ""
 828   { xstormy16_emit_cbranch (LTU, operands[0]); DONE; })
 829
 830 (define_insn "cbranchhi"
 831   [(set (pc)
 832         (if_then_else (match_operator:HI 1 "comparison_operator"
 833                                       [(match_operand:HI 2 "nonmemory_operand"
 834                                         "r,e,L")
 835                                        (match_operand:HI 3 "nonmemory_operand"
 836                                                       "r,L,e")])
 837                       (label_ref (match_operand 0 "" ""))
 838                       (pc)))
 839    (clobber (reg:BI CARRY_REG))]
 840   ""
 841   "*
 842 {
 843   return xstormy16_output_cbranch_hi (operands[1], \"%l0\", 0, insn);
 844 }"
 845   [(set_attr "branch_class" "bcc12")
 846    (set_attr "psw_operand" "0,0,1")])
 847
 848 (define_insn "cbranchhi_neg"
 849   [(set (pc)
 850         (if_then_else (match_operator:HI 1 "comparison_operator"
 851                                       [(match_operand:HI 2 "nonmemory_operand"
 852                                                          "r,e,L")
 853                                        (match_operand:HI 3 "nonmemory_operand"
 854                                                          "r,L,e")])
 855                       (pc)
 856                       (label_ref (match_operand 0 "" ""))))
 857    (clobber (reg:BI CARRY_REG))]
 858   ""
 859   "*
 860 {
 861   return xstormy16_output_cbranch_hi (operands[1], \"%l0\", 1, insn);
 862 }"
 863   [(set_attr "branch_class" "bcc12")
 864    (set_attr "psw_operand" "0,0,1")])
 865
 866 (define_insn "*eqbranchsi"
 867   [(set (pc)
 868         (if_then_else (match_operator:SI 1 "equality_operator"
 869                                       [(match_operand:SI 2 "register_operand"
 870                                                          "r")
 871                                        (const_int 0)])
 872                       (label_ref (match_operand 0 "" ""))
 873                       (pc)))
 874    (clobber (match_operand:SI 3 "register_operand" "=2"))]
 875   ""
 876   "*
 877 {
 878   return xstormy16_output_cbranch_si (operands[1], \"%l0\", 0, insn);
 879 }"
 880   [(set_attr "branch_class" "bcc8p2")
 881    (set_attr "psw_operand" "clobber")])
 882
 883 (define_insn_and_split "*ineqbranchsi"
 884   [(set (pc)
 885         (if_then_else (match_operator:SI 1 "xstormy16_ineqsi_operator"
 886                                       [(match_operand:SI 2 "register_operand"
 887                                                          "r")
 888                                        (match_operand:SI 3 "nonmemory_operand"
 889                                                          "ri")])
 890                       (label_ref (match_operand 0 "" ""))
 891                       (pc)))
 892    (clobber (match_operand:SI 4 "register_operand" "=2"))
 893    (clobber (reg:BI CARRY_REG))]
 894   ""
 895   "#"
 896   "reload_completed"
 897   [(pc)]
 898   { xstormy16_split_cbranch (SImode, operands[0], operands[1], operands[2]); DONE; }
 899   [(set_attr "length" "8")])
 900
 901 (define_insn "*ineqbranch_1"
 902   [(set (pc)
 903         (if_then_else (match_operator:HI 4 "xstormy16_ineqsi_operator"
 904                        [(minus:HI (match_operand:HI 1 "register_operand" "T,r,r")
 905                            (zero_extend:HI (reg:BI CARRY_REG)))
 906                         (match_operand:HI 3 "nonmemory_operand" "L,r,i")])
 907                       (label_ref (match_operand 0 "" ""))
 908                       (pc)))
 909    (set (match_operand:HI 2 "register_operand" "=1,1,1")
 910         (minus:HI (minus:HI (match_dup 1) (zero_extend:HI (reg:BI CARRY_REG)))
 911                   (match_dup 3)))
 912    (clobber (reg:BI CARRY_REG))]
 913   ""
 914   "*
 915 {
 916   return xstormy16_output_cbranch_si (operands[4], \"%l0\", 0, insn);
 917 }"
 918   [(set_attr "branch_class" "bcc8p2,bcc8p2,bcc8p4")
 919    (set_attr "psw_operand" "2,2,2")])
 920 \f
 921 ;; ::::::::::::::::::::
 922 ;; ::
 923 ;; :: Call and branch instructions
 924 ;; ::
 925 ;; ::::::::::::::::::::
 926
 927 ;; Subroutine call instruction returning no value.  Operand 0 is the function
 928 ;; to call; operand 1 is the number of bytes of arguments pushed (in mode
 929 ;; `SImode', except it is normally a `const_int'); operand 2 is the number of
 930 ;; registers used as operands.
 931
 932 ;; On most machines, operand 2 is not actually stored into the RTL pattern.  It
 933 ;; is supplied for the sake of some RISC machines which need to put this
 934 ;; information into the assembler code; they can put it in the RTL instead of
 935 ;; operand 1.
 936
 937 (define_expand "call"
 938   [(call (match_operand:HI 0 "memory_operand" "m")
 939          (match_operand 1 "" ""))
 940    (use (match_operand 2 "immediate_operand" ""))]
 941   ""
 942   "xstormy16_expand_call (NULL_RTX, operands[0], operands[1]); DONE;")
 943
 944 ;; Subroutine call instruction returning a value.  Operand 0 is the hard
 945 ;; register in which the value is returned.  There are three more operands, the
 946 ;; same as the three operands of the `call' instruction (but with numbers
 947 ;; increased by one).
 948
 949 ;; Subroutines that return `BLKmode' objects use the `call' insn.
 950
 951 (define_expand "call_value"
 952   [(set (match_operand 0 "register_operand" "=r")
 953         (call (match_operand:HI 1 "memory_operand" "m")
 954               (match_operand:SI 2 "" "")))
 955         (use (match_operand 3 "immediate_operand" ""))]
 956   ""
 957   "xstormy16_expand_call (operands[0], operands[1], operands[2]); DONE;")
 958
 959 (define_insn "*call_internal"
 960   [(call (mem:HI (match_operand:HI 0 "nonmemory_operand" "i,r"))
 961          (match_operand 1 "" ""))
 962    (use (match_operand:HI 2 "nonmemory_operand" "X,z"))]
 963   ""
 964   "@
 965    callf %C0
 966    call %2,%0"
 967   [(set_attr "length" "4,2")
 968    (set_attr "psw_operand" "clobber")])
 969
 970 (define_insn "*call_value_internal"
 971   [(set (match_operand 3 "register_operand" "=r,r")
 972         (call (mem:HI (match_operand:HI 0 "nonmemory_operand" "i,r"))
 973               (match_operand 1 "" "")))
 974    (use (match_operand:HI 2 "nonmemory_operand" "X,z"))]
 975   ""
 976   "@
 977    callf %C0
 978    call %2,%0"
 979   [(set_attr "length" "4,2")
 980    (set_attr "psw_operand" "clobber")])
 981
 982 ;; Subroutine return
 983 (define_expand "return"
 984   [(return)]
 985   "direct_return()"
 986   "")
 987
 988 (define_insn "return_internal"
 989   [(return)]
 990   ""
 991   "ret"
 992   [(set_attr "psw_operand" "nop")])
 993
 994 (define_insn "return_internal_interrupt"
 995   [(return)
 996    (unspec_volatile [(const_int 0)] 1)]
 997   ""
 998   "iret"
 999   [(set_attr "psw_operand" "clobber")])
1000
1001 ;; Normal unconditional jump
1002 (define_insn "jump"
1003   [(set (pc) (label_ref (match_operand 0 "" "")))]
1004   ""
1005   "*
1006 {
1007   return xstormy16_output_cbranch_hi (NULL_RTX, \"%l0\", 0, insn);
1008 }"
1009   [(set_attr "branch_class" "br12")
1010    (set_attr "psw_operand" "nop")])
1011
1012 ;; Indirect jump through a register
1013 (define_expand "indirect_jump"
1014   [(set (match_dup 1) (const_int 0))
1015    (parallel [(set (pc) (match_operand:HI 0 "register_operand" ""))
1016               (use (match_dup 1))])]
1017   ""
1018   "operands[1] = gen_reg_rtx (HImode);")
1019
1020 (define_insn ""
1021   [(set (pc) (match_operand:HI 0 "register_operand" "r"))
1022    (use (match_operand:HI 1 "register_operand" "z"))]
1023   ""
1024   "jmp %1,%0"
1025   [(set_attr "length" "4")
1026    (set_attr "psw_operand" "nop")])
1027
1028 ;; Table-based switch statements.
1029 (define_expand "casesi"
1030   [(use (match_operand:SI 0 "register_operand" ""))
1031    (use (match_operand:SI 1 "immediate_operand" ""))
1032    (use (match_operand:SI 2 "immediate_operand" ""))
1033    (use (label_ref (match_operand 3 "" "")))
1034    (use (label_ref (match_operand 4 "" "")))]
1035   ""
1036   "
1037 {
1038   xstormy16_expand_casesi (operands[0], operands[1], operands[2],
1039                           operands[3], operands[4]);
1040   DONE;
1041 }")
1042
1043 (define_insn "tablejump_pcrel"
1044   [(set (pc) (mem:HI (plus:HI (pc)
1045                               (match_operand:HI 0 "register_operand" "r"))))
1046    (use (label_ref:SI (match_operand 1 "" "")))]
1047   ""
1048   "br %0"
1049   [(set_attr "psw_operand" "nop")])
1050 \f
1051 ;; ::::::::::::::::::::
1052 ;; ::
1053 ;; :: Prologue and Epilogue instructions
1054 ;; ::
1055 ;; ::::::::::::::::::::
1056
1057 ;; Called after register allocation to add any instructions needed for
1058 ;; the prologue.  Using a prologue insn is favored compared to putting
1059 ;; all of the instructions in the TARGET_ASM_FUNCTION_PROLOGUE macro,
1060 ;; since it allows the scheduler to intermix instructions with the
1061 ;; saves of the caller saved registers.  In some cases, it might be
1062 ;; necessary to emit a barrier instruction as the last insn to prevent
1063 ;; such scheduling.
1064 (define_expand "prologue"
1065   [(const_int 1)]
1066   ""
1067   {
1068     xstormy16_expand_prologue ();
1069     DONE;
1070   })
1071
1072 ;; Called after register allocation to add any instructions needed for
1073 ;; the epilogue.  Using an epilogue insn is favored compared to putting
1074 ;; all of the instructions in the TARGET_ASM_FUNCTION_EPILOGUE macro,
1075 ;; since it allows the scheduler to intermix instructions with the
1076 ;; restores of the caller saved registers.  In some cases, it might be
1077 ;; necessary to emit a barrier instruction as the first insn to
1078 ;; prevent such scheduling.
1079 (define_expand "epilogue"
1080   [(const_int 2)]
1081   ""
1082   {
1083     xstormy16_expand_epilogue ();
1084     DONE;
1085   })
1086 \f
1087 ;; ::::::::::::::::::::
1088 ;; ::
1089 ;; :: Miscellaneous instructions
1090 ;; ::
1091 ;; ::::::::::::::::::::
1092
1093 ;; No operation, needed in case the user uses -g but not -O.
1094 (define_insn "nop"
1095   [(const_int 0)]
1096   ""
1097   "nop"
1098   [(set_attr "psw_operand" "nop")])
1099
1100 ;; Pseudo instruction that prevents the scheduler from moving code above this
1101 ;; point.
1102 (define_insn "blockage"
1103   [(unspec_volatile [(const_int 0)] 0)]
1104   ""
1105   ""
1106   [(set_attr "length" "0")
1107    (set_attr "psw_operand" "nop")])
1108
1109 ;;---------------------------------------------------------------------------
1110
1111 (define_expand "iorqi3"
1112   [(match_operand:QI 0 "xstormy16_below100_or_register" "")
1113    (match_operand:QI 1 "xstormy16_below100_or_register" "")
1114    (match_operand:QI 2 "nonmemory_operand" "")]
1115   ""
1116   {
1117     xstormy16_expand_iorqi3 (operands);
1118     DONE;
1119   })
1120
1121 (define_insn "iorqi3_internal"
1122   [(set (match_operand:QI 0 "xstormy16_below100_or_register" "=Wr")
1123         (ior:QI (match_operand:QI 1 "xstormy16_below100_or_register" "0")
1124                 (match_operand:QI 2 "xstormy16_onebit_set_operand" "i")))]
1125   ""
1126   "set1 %0,%B2"
1127   [(set_attr "length" "2")
1128    (set_attr "psw_operand" "0")])
1129
1130 (define_peephole2
1131   [(set (match_operand:QI 0 "register_operand" "")
1132         (match_operand:QI 1 "xstormy16_below100_operand" ""))
1133    (set (match_operand:HI 2 "register_operand" "")
1134         (ior:HI (match_operand:HI 3 "register_operand" "")
1135                 (match_operand:QI 4 "xstormy16_onebit_set_operand" "")))
1136    (set (match_operand:QI 5 "xstormy16_below100_operand" "")
1137         (match_operand:QI 6 "register_operand" ""))
1138    ]
1139   "REGNO (operands[0]) == REGNO (operands[2])
1140    && REGNO (operands[0]) == REGNO (operands[3])
1141    && REGNO (operands[0]) == REGNO (operands[6])
1142    && rtx_equal_p (operands[1], operands[5])"
1143   [(set (match_dup 1)
1144         (ior:QI (match_dup 1)
1145                 (match_dup 4)))
1146    ]
1147   "")
1148
1149
1150 (define_expand "andqi3"
1151   [(match_operand:QI 0 "xstormy16_below100_or_register" "")
1152    (match_operand:QI 1 "xstormy16_below100_or_register" "")
1153    (match_operand:QI 2 "nonmemory_operand" "")]
1154   ""
1155   {
1156     xstormy16_expand_andqi3 (operands);
1157     DONE;
1158   })
1159
1160 (define_insn "andqi3_internal"
1161   [(set (match_operand:QI 0 "xstormy16_below100_or_register" "=Wr")
1162         (and:QI (match_operand:QI 1 "xstormy16_below100_or_register" "0")
1163                 (match_operand:QI 2 "xstormy16_onebit_clr_operand" "i")))]
1164   ""
1165   "clr1 %0,%B2"
1166   [(set_attr "length" "2")
1167    (set_attr "psw_operand" "0")])
1168
1169 (define_peephole2
1170   [(set (match_operand:HI 0 "register_operand" "")
1171         (and:HI (match_operand:HI 1 "register_operand" "")
1172                 (match_operand 2 "immediate_operand" "")))
1173    (set (match_operand:HI 3 "register_operand" "")
1174         (zero_extend:HI (match_operand:QI 4 "register_operand" "")));
1175    ]
1176   "REGNO (operands[0]) == REGNO (operands[1])
1177    && REGNO (operands[0]) == REGNO (operands[3])
1178    && REGNO (operands[0]) == REGNO (operands[4])"
1179   [(set (match_dup 0)
1180         (and:HI (match_dup 1)
1181                 (match_dup 5)))
1182    ]
1183   "operands[5] = GEN_INT (INTVAL (operands[2]) & 0xff);")
1184
1185 (define_peephole2
1186   [(set (match_operand:QI 0 "register_operand" "")
1187         (match_operand:QI 1 "xstormy16_below100_operand" ""))
1188    (set (match_operand:HI 2 "register_operand" "")
1189         (and:HI (match_operand:HI 3 "register_operand" "")
1190                 (match_operand:QI 4 "xstormy16_onebit_clr_operand" "")))
1191    (set (match_operand:QI 5 "xstormy16_below100_operand" "")
1192         (match_operand:QI 6 "register_operand" ""))
1193    ]
1194   "REGNO (operands[0]) == REGNO (operands[2])
1195    && REGNO (operands[0]) == REGNO (operands[3])
1196    && REGNO (operands[0]) == REGNO (operands[6])
1197    && rtx_equal_p (operands[1], operands[5])"
1198   [(set (match_dup 1)
1199         (and:QI (match_dup 1)
1200                 (match_dup 4)))
1201    ]
1202   "")
1203
1204 ;; GCC uses different techniques to optimize MSB and LSB accesses, so
1205 ;; we have to code those separately.
1206
1207 (define_insn "*bclrx"
1208   [(set (pc)
1209         (if_then_else (eq:HI (and:QI (match_operand:QI 1 "xstormy16_below100_operand" "W")
1210                                      (match_operand:HI 2 "immediate_operand" "i"))
1211                              (const_int 0))
1212                       (label_ref (match_operand 0 "" ""))
1213                       (pc)))
1214    (clobber (reg:BI CARRY_REG))]
1215   ""
1216   "bn %1,%B2,%l0"
1217   [(set_attr "length" "4")
1218    (set_attr "psw_operand" "nop")])
1219
1220 (define_insn "*bclrx2"
1221   [(set (pc)
1222         (if_then_else (zero_extract:HI
1223                        (xor:HI (subreg:HI
1224                                 (match_operand:QI 1 "xstormy16_below100_operand" "W") 0)
1225                                (match_operand:HI 2 "xstormy16_onebit_set_operand" "J"))
1226                        (const_int 1)
1227                        (match_operand:HI 3 "immediate_operand" "i"))
1228                       (label_ref (match_operand 0 "" ""))
1229                       (pc)))
1230    (clobber (reg:BI CARRY_REG))]
1231   ""
1232   "bn %1,%B2,%l0"
1233   [(set_attr "length" "4")
1234    (set_attr "psw_operand" "nop")])
1235
1236 (define_insn "*bclrx3"
1237   [(set (pc)
1238         (if_then_else (eq:HI (and:HI (zero_extend:HI (match_operand:QI 1 "xstormy16_below100_operand" "W"))
1239                                      (match_operand:HI 2 "immediate_operand" "i"))
1240                              (const_int 0))
1241                       (label_ref (match_operand 0 "" ""))
1242                       (pc)))
1243    (clobber (reg:BI CARRY_REG))]
1244   ""
1245   "bn %1,%B2,%l0"
1246   [(set_attr "length" "4")
1247    (set_attr "psw_operand" "nop")])
1248
1249 (define_insn "*bclr7"
1250   [(set (pc)
1251         (if_then_else (xor:HI (lshiftrt:HI (subreg:HI
1252                                             (match_operand:QI 1 "xstormy16_below100_operand" "W") 0)
1253                                            (const_int 7))
1254                               (const_int 1))
1255                       (label_ref (match_operand 0 "" ""))
1256                       (pc)))
1257    (clobber (reg:BI CARRY_REG))]
1258   ""
1259   "bn %1,#7,%l0"
1260   [(set_attr "length" "4")
1261    (set_attr "psw_operand" "nop")])
1262
1263 (define_insn "*bclr15"
1264   [(set (pc)
1265         (if_then_else (ge:HI (sign_extend:HI (match_operand:QI 1 "xstormy16_below100_operand" "W"))
1266                              (const_int 0))
1267                       (label_ref (match_operand 0 "" ""))
1268                       (pc)))
1269    (clobber (reg:BI CARRY_REG))]
1270   ""
1271   "bn %1,#7,%l0"
1272   [(set_attr "length" "4")
1273    (set_attr "psw_operand" "nop")])
1274
1275 (define_insn "*bsetx"
1276   [(set (pc)
1277         (if_then_else (ne:HI (and:QI (match_operand:QI 1 "xstormy16_below100_operand" "W")
1278                                      (match_operand:HI 2 "immediate_operand" "i"))
1279                              (const_int 0))
1280                       (label_ref (match_operand 0 "" ""))
1281                       (pc)))
1282    (clobber (reg:BI CARRY_REG))]
1283   ""
1284   "bp %1,%B2,%l0"
1285   [(set_attr "length" "4")
1286    (set_attr "psw_operand" "nop")])
1287
1288 (define_insn "*bsetx2"
1289   [(set (pc)
1290         (if_then_else (zero_extract:HI (match_operand:QI 1 "xstormy16_below100_operand" "W")
1291                                        (const_int 1)
1292                                        (match_operand:HI 2 "immediate_operand" "i"))
1293                       (label_ref (match_operand 0 "" ""))
1294                       (pc)))
1295    (clobber (reg:BI CARRY_REG))]
1296   ""
1297   "bp %1,%b2,%l0"
1298   [(set_attr "length" "4")
1299    (set_attr "psw_operand" "nop")])
1300
1301 (define_insn "*bsetx3"
1302   [(set (pc)
1303         (if_then_else (ne:HI (and:HI (zero_extend:HI (match_operand:QI 1 "xstormy16_below100_operand" "W"))
1304                                      (match_operand:HI 2 "immediate_operand" "i"))
1305                              (const_int 0))
1306                       (label_ref (match_operand 0 "" ""))
1307                       (pc)))
1308    (clobber (reg:BI CARRY_REG))]
1309   ""
1310   "bp %1,%B2,%l0"
1311   [(set_attr "length" "4")
1312    (set_attr "psw_operand" "nop")])
1313
1314 (define_insn "*bset7"
1315   [(set (pc)
1316         (if_then_else (lshiftrt:HI (subreg:HI (match_operand:QI 1 "xstormy16_below100_operand" "W") 0)
1317                                    (const_int 7))
1318                       (label_ref (match_operand 0 "" ""))
1319                       (pc)))
1320    (clobber (reg:BI CARRY_REG))]
1321   ""
1322   "bp %1,#7,%l0"
1323   [(set_attr "length" "4")
1324    (set_attr "psw_operand" "nop")])
1325
1326 (define_insn "*bset15"
1327   [(set (pc)
1328         (if_then_else (lt:HI (sign_extend:HI (match_operand:QI 1 "xstormy16_below100_operand" "W"))
1329                              (const_int 0))
1330                       (label_ref (match_operand 0 "" ""))
1331                       (pc)))
1332    (clobber (reg:BI CARRY_REG))]
1333   ""
1334   "bp %1,#7,%l0"
1335   [(set_attr "length" "4")
1336    (set_attr "psw_operand" "nop")])