gcc/config/riscv/bitmanip.md

   1 ;; Machine description for RISC-V Bit Manipulation operations.
   2 ;; Copyright (C) 2021-2023 Free Software Foundation, Inc.
   3
   4 ;; This file is part of GCC.
   5
   6 ;; GCC 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 3, or (at your option)
   9 ;; any later version.
  10
  11 ;; GCC 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 GCC; see the file COPYING3.  If not see
  18 ;; <http://www.gnu.org/licenses/>.
  19
  20 ;; ZBA extension.
  21
  22 (define_insn "*zero_extendsidi2_bitmanip"
  23   [(set (match_operand:DI 0 "register_operand" "=r,r")
  24         (zero_extend:DI (match_operand:SI 1 "nonimmediate_operand" "r,m")))]
  25   "TARGET_64BIT && TARGET_ZBA"
  26   "@
  27    zext.w\t%0,%1
  28    lwu\t%0,%1"
  29   [(set_attr "type" "bitmanip,load")
  30    (set_attr "mode" "DI")])
  31
  32 (define_insn "*shNadd"
  33   [(set (match_operand:X 0 "register_operand" "=r")
  34         (plus:X (ashift:X (match_operand:X 1 "register_operand" "r")
  35                           (match_operand:QI 2 "imm123_operand" "Ds3"))
  36                 (match_operand:X 3 "register_operand" "r")))]
  37   "TARGET_ZBA"
  38   "sh%2add\t%0,%1,%3"
  39   [(set_attr "type" "bitmanip")
  40    (set_attr "mode" "<X:MODE>")])
  41
  42 ; When using strength-reduction, we will reduce a multiplication to a
  43 ; sequence of shifts and adds.  If this is performed with 32-bit types
  44 ; and followed by a division, the lack of w-form sh[123]add will make
  45 ; combination impossible and lead to a slli + addw being generated.
  46 ; Split the sequence with the knowledge that a w-form div will perform
  47 ; implicit sign-extensions.
  48 (define_split
  49   [(set (match_operand:DI 0 "register_operand")
  50         (sign_extend:DI (div:SI (plus:SI (ashift:SI (subreg:SI (match_operand:DI 1 "register_operand") 0)
  51                                                     (match_operand:QI 2 "imm123_operand"))
  52                                          (subreg:SI (match_operand:DI 3 "register_operand") 0))
  53                                 (subreg:SI (match_operand:DI 4 "register_operand") 0))))
  54    (clobber (match_operand:DI 5 "register_operand"))]
  55   "TARGET_64BIT && TARGET_ZBA"
  56    [(set (match_dup 5) (plus:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))
  57     (set (match_dup 0) (sign_extend:DI (div:SI (subreg:SI (match_dup 5) 0) (subreg:SI (match_dup 4) 0))))])
  58
  59 ; Zba does not provide W-forms of sh[123]add(.uw)?, which leads to an
  60 ; interesting irregularity: we can generate a signed 32-bit result
  61 ; using slli(.uw)?+ addw, but a unsigned 32-bit result can be more
  62 ; efficiently be generated as sh[123]add+zext.w (the .uw can be
  63 ; dropped, if we zero-extend the output anyway).
  64 ;
  65 ; To enable this optimization, we split [ slli(.uw)?, addw, zext.w ]
  66 ; into [ sh[123]add, zext.w ] for use during combine.
  67 (define_split
  68   [(set (match_operand:DI 0 "register_operand")
  69         (zero_extend:DI (plus:SI (ashift:SI (subreg:SI (match_operand:DI 1 "register_operand") 0)
  70                                                        (match_operand:QI 2 "imm123_operand"))
  71                                  (subreg:SI (match_operand:DI 3 "register_operand") 0))))]
  72   "TARGET_64BIT && TARGET_ZBA"
  73   [(set (match_dup 0) (plus:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 3)))
  74    (set (match_dup 0) (zero_extend:DI (subreg:SI (match_dup 0) 0)))])
  75
  76 (define_split
  77   [(set (match_operand:DI 0 "register_operand")
  78         (zero_extend:DI (plus:SI (subreg:SI (and:DI (ashift:DI (match_operand:DI 1 "register_operand")
  79                                                                (match_operand:QI 2 "imm123_operand"))
  80                                                     (match_operand:DI 3 "consecutive_bits_operand")) 0)
  81                                  (subreg:SI (match_operand:DI 4 "register_operand") 0))))]
  82   "TARGET_64BIT && TARGET_ZBA
  83    && riscv_shamt_matches_mask_p (INTVAL (operands[2]), INTVAL (operands[3]))"
  84   [(set (match_dup 0) (plus:DI (ashift:DI (match_dup 1) (match_dup 2)) (match_dup 4)))
  85    (set (match_dup 0) (zero_extend:DI (subreg:SI (match_dup 0) 0)))])
  86
  87 ; Make sure that an andi followed by a sh[123]add remains a two instruction
  88 ; sequence--and is not torn apart into slli, slri, add.
  89 (define_insn_and_split "*andi_add.uw"
  90   [(set (match_operand:DI 0 "register_operand" "=r")
  91         (plus:DI (and:DI (ashift:DI (match_operand:DI 1 "register_operand" "r")
  92                                     (match_operand:QI 2 "imm123_operand" "Ds3"))
  93                          (match_operand:DI 3 "consecutive_bits_operand" ""))
  94                  (match_operand:DI 4 "register_operand" "r")))
  95    (clobber (match_scratch:DI 5 "=&r"))]
  96   "TARGET_64BIT && TARGET_ZBA
  97    && riscv_shamt_matches_mask_p (INTVAL (operands[2]), INTVAL (operands[3]))
  98    && SMALL_OPERAND (INTVAL (operands[3]) >> INTVAL (operands[2]))"
  99   "#"
 100   "&& reload_completed"
 101   [(set (match_dup 5) (and:DI (match_dup 1) (match_dup 3)))
 102    (set (match_dup 0) (plus:DI (ashift:DI (match_dup 5) (match_dup 2))
 103                                (match_dup 4)))]
 104 {
 105         operands[3] = GEN_INT (INTVAL (operands[3]) >> INTVAL (operands[2]));
 106 })
 107
 108 (define_insn "*shNadduw"
 109   [(set (match_operand:DI 0 "register_operand" "=r")
 110         (plus:DI
 111           (and:DI (ashift:DI (match_operand:DI 1 "register_operand" "r")
 112                              (match_operand:QI 2 "imm123_operand" "Ds3"))
 113                  (match_operand 3 "immediate_operand" "n"))
 114           (match_operand:DI 4 "register_operand" "r")))]
 115   "TARGET_64BIT && TARGET_ZBA
 116    && (INTVAL (operands[3]) >> INTVAL (operands[2])) == 0xffffffff"
 117   "sh%2add.uw\t%0,%1,%4"
 118   [(set_attr "type" "bitmanip")
 119    (set_attr "mode" "DI")])
 120
 121 ;; During combine, we may encounter an attempt to combine
 122 ;;   slli rtmp, rs, #imm
 123 ;;   zext.w rtmp, rtmp
 124 ;;   sh[123]add rd, rtmp, rs2
 125 ;; which will lead to the immediate not satisfying the above constraints.
 126 ;; By splitting the compound expression, we can simplify to a slli and a
 127 ;; sh[123]add.uw.
 128 (define_split
 129   [(set (match_operand:DI 0 "register_operand")
 130         (plus:DI (and:DI (ashift:DI (match_operand:DI 1 "register_operand")
 131                                     (match_operand:QI 2 "immediate_operand"))
 132                          (match_operand:DI 3 "consecutive_bits_operand"))
 133                  (match_operand:DI 4 "register_operand")))
 134    (clobber (match_operand:DI 5 "register_operand"))]
 135   "TARGET_64BIT && TARGET_ZBA"
 136   [(set (match_dup 5) (ashift:DI (match_dup 1) (match_dup 6)))
 137    (set (match_dup 0) (plus:DI (and:DI (ashift:DI (match_dup 5)
 138                                                   (match_dup 7))
 139                                        (match_dup 8))
 140                                (match_dup 4)))]
 141 {
 142         unsigned HOST_WIDE_INT mask = UINTVAL (operands[3]);
 143         /* scale: shift within the sh[123]add.uw */
 144         unsigned HOST_WIDE_INT scale = 32 - clz_hwi (mask);
 145         /* bias:  pre-scale amount (i.e. the prior shift amount) */
 146         int bias = ctz_hwi (mask) - scale;
 147
 148         /* If the bias + scale don't add up to operand[2], reject. */
 149         if ((scale + bias) != UINTVAL (operands[2]))
 150            FAIL;
 151
 152         /* If the shift-amount is out-of-range for sh[123]add.uw, reject. */
 153         if ((scale < 1) || (scale > 3))
 154            FAIL;
 155
 156         /* If there's no bias, the '*shNadduw' pattern should have matched. */
 157         if (bias == 0)
 158            FAIL;
 159
 160         operands[6] = GEN_INT (bias);
 161         operands[7] = GEN_INT (scale);
 162         operands[8] = GEN_INT (0xffffffffULL << scale);
 163 })
 164
 165 (define_insn "*add.uw"
 166   [(set (match_operand:DI 0 "register_operand" "=r")
 167         (plus:DI (zero_extend:DI
 168                    (match_operand:SI 1 "register_operand" "r"))
 169                  (match_operand:DI 2 "register_operand" "r")))]
 170   "TARGET_64BIT && TARGET_ZBA"
 171   "add.uw\t%0,%1,%2"
 172   [(set_attr "type" "bitmanip")
 173    (set_attr "mode" "DI")])
 174
 175 (define_insn "*slliuw"
 176   [(set (match_operand:DI 0 "register_operand" "=r")
 177         (and:DI (ashift:DI (match_operand:DI 1 "register_operand" "r")
 178                            (match_operand:QI 2 "immediate_operand" "I"))
 179                 (match_operand 3 "immediate_operand" "n")))]
 180   "TARGET_64BIT && TARGET_ZBA
 181    && (INTVAL (operands[3]) >> INTVAL (operands[2])) == 0xffffffff"
 182   "slli.uw\t%0,%1,%2"
 183   [(set_attr "type" "bitmanip")
 184    (set_attr "mode" "DI")])
 185
 186 ;; ZBB extension.
 187
 188 (define_expand "clzdi2"
 189   [(set (match_operand:DI 0 "register_operand")
 190         (clz:DI (match_operand:DI 1 "register_operand")))]
 191   "TARGET_64BIT && (TARGET_ZBB || TARGET_XTHEADBB)")
 192
 193 (define_expand "clzsi2"
 194   [(set (match_operand:SI 0 "register_operand")
 195         (clz:SI (match_operand:SI 1 "register_operand")))]
 196   "TARGET_ZBB || (!TARGET_64BIT && TARGET_XTHEADBB)")
 197
 198 (define_expand "ctz<mode>2"
 199   [(set (match_operand:GPR 0 "register_operand")
 200         (ctz:GPR (match_operand:GPR 1 "register_operand")))]
 201   "TARGET_ZBB")
 202
 203 (define_expand "popcount<mode>2"
 204   [(set (match_operand:GPR 0 "register_operand")
 205         (popcount:GPR (match_operand:GPR 1 "register_operand")))]
 206   "TARGET_ZBB")
 207
 208 (define_insn "*<optab>_not<mode>"
 209   [(set (match_operand:X 0 "register_operand" "=r")
 210         (bitmanip_bitwise:X (not:X (match_operand:X 1 "register_operand" "r"))
 211                             (match_operand:X 2 "register_operand" "r")))]
 212   "TARGET_ZBB || TARGET_ZBKB"
 213   "<insn>n\t%0,%2,%1"
 214   [(set_attr "type" "bitmanip")
 215    (set_attr "mode" "<X:MODE>")])
 216
 217 ;; '(a >= 0) ? b : 0' is emitted branchless (from if-conversion).  Without a
 218 ;; bit of extra help for combine (i.e., the below split), we end up emitting
 219 ;; not/srai/and instead of combining the not into an andn.
 220 (define_split
 221   [(set (match_operand:DI 0 "register_operand")
 222         (and:DI (neg:DI (ge:DI (match_operand:DI 1 "register_operand")
 223                                (const_int 0)))
 224                 (match_operand:DI 2 "register_operand")))
 225    (clobber (match_operand:DI 3 "register_operand"))]
 226   "TARGET_ZBB || TARGET_ZBKB"
 227   [(set (match_dup 3) (ashiftrt:DI (match_dup 1) (const_int 63)))
 228    (set (match_dup 0) (and:DI (not:DI (match_dup 3)) (match_dup 2)))])
 229
 230 (define_insn "*xor_not<mode>"
 231   [(set (match_operand:X 0 "register_operand" "=r")
 232         (not:X (xor:X (match_operand:X 1 "register_operand" "r")
 233                       (match_operand:X 2 "register_operand" "r"))))]
 234   "TARGET_ZBB || TARGET_ZBKB"
 235   "xnor\t%0,%1,%2"
 236   [(set_attr "type" "bitmanip")
 237    (set_attr "mode" "<X:MODE>")])
 238
 239 (define_insn "*<bitmanip_optab>si2"
 240   [(set (match_operand:SI 0 "register_operand" "=r")
 241         (clz_ctz_pcnt:SI (match_operand:SI 1 "register_operand" "r")))]
 242   "TARGET_ZBB"
 243   "<bitmanip_insn>%~\t%0,%1"
 244   [(set_attr "type" "<bitmanip_insn>")
 245    (set_attr "mode" "SI")])
 246
 247 (define_insn "*<bitmanip_optab>disi2"
 248   [(set (match_operand:DI 0 "register_operand" "=r")
 249         (any_extend:DI
 250           (clz_ctz_pcnt:SI (match_operand:SI 1 "register_operand" "r"))))]
 251   "TARGET_64BIT && TARGET_ZBB"
 252   "<bitmanip_insn>w\t%0,%1"
 253   [(set_attr "type" "<bitmanip_insn>")
 254    (set_attr "mode" "SI")])
 255
 256 ;; A SImode clz_ctz_pcnt may be extended to DImode via subreg.
 257 (define_insn "*<bitmanip_optab>disi2_sext"
 258   [(set (match_operand:DI 0 "register_operand" "=r")
 259         (and:DI (subreg:DI
 260           (clz_ctz_pcnt:SI (match_operand:SI 1 "register_operand" "r")) 0)
 261           (match_operand:DI 2 "const_int_operand")))]
 262   "TARGET_64BIT && TARGET_ZBB && ((INTVAL (operands[2]) & 0x3f) == 0x3f)"
 263   "<bitmanip_insn>w\t%0,%1"
 264   [(set_attr "type" "bitmanip")
 265    (set_attr "mode" "SI")])
 266
 267 (define_insn "*<bitmanip_optab>di2"
 268   [(set (match_operand:DI 0 "register_operand" "=r")
 269         (clz_ctz_pcnt:DI (match_operand:DI 1 "register_operand" "r")))]
 270   "TARGET_64BIT && TARGET_ZBB"
 271   "<bitmanip_insn>\t%0,%1"
 272   [(set_attr "type" "<bitmanip_insn>")
 273    (set_attr "mode" "DI")])
 274
 275 (define_insn "*zero_extendhi<GPR:mode>2_bitmanip"
 276   [(set (match_operand:GPR 0 "register_operand" "=r,r")
 277         (zero_extend:GPR (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
 278   "TARGET_ZBB"
 279   "@
 280    zext.h\t%0,%1
 281    lhu\t%0,%1"
 282   [(set_attr "type" "bitmanip,load")
 283    (set_attr "mode" "<GPR:MODE>")])
 284
 285 (define_insn "*extend<SHORT:mode><SUPERQI:mode>2_zbb"
 286   [(set (match_operand:SUPERQI   0 "register_operand"     "=r,r")
 287         (sign_extend:SUPERQI
 288             (match_operand:SHORT 1 "nonimmediate_operand" " r,m")))]
 289   "TARGET_ZBB"
 290   "@
 291    sext.<SHORT:size>\t%0,%1
 292    l<SHORT:size>\t%0,%1"
 293   [(set_attr "type" "bitmanip,load")
 294    (set_attr "mode" "<SUPERQI:MODE>")])
 295
 296 (define_insn "*zero_extendhi<GPR:mode>2_zbb"
 297   [(set (match_operand:GPR    0 "register_operand"     "=r,r")
 298         (zero_extend:GPR
 299             (match_operand:HI 1 "nonimmediate_operand" " r,m")))]
 300   "TARGET_ZBB"
 301   "@
 302    zext.h\t%0,%1
 303    lhu\t%0,%1"
 304   [(set_attr "type" "bitmanip,load")
 305    (set_attr "mode" "HI")])
 306
 307 (define_expand "rotrdi3"
 308   [(set (match_operand:DI 0 "register_operand")
 309         (rotatert:DI (match_operand:DI 1 "register_operand")
 310                      (match_operand:QI 2 "arith_operand")))]
 311   "TARGET_64BIT && (TARGET_ZBB || TARGET_XTHEADBB || TARGET_ZBKB)"
 312 {
 313   if (TARGET_XTHEADBB && !immediate_operand (operands[2], VOIDmode))
 314     FAIL;
 315 })
 316
 317 (define_insn "*rotrsi3"
 318   [(set (match_operand:SI 0 "register_operand" "=r")
 319         (rotatert:SI (match_operand:SI 1 "register_operand" "r")
 320                      (match_operand:QI 2 "arith_operand" "rI")))]
 321   "TARGET_ZBB || TARGET_ZBKB"
 322   "ror%i2%~\t%0,%1,%2"
 323   [(set_attr "type" "bitmanip")])
 324
 325 (define_expand "rotrsi3"
 326   [(set (match_operand:SI 0 "register_operand" "=r")
 327        (rotatert:SI (match_operand:SI 1 "register_operand" "r")
 328                     (match_operand:QI 2 "arith_operand" "rI")))]
 329   "TARGET_ZBB || TARGET_ZBKB || TARGET_XTHEADBB"
 330 {
 331   if (TARGET_XTHEADBB && !immediate_operand (operands[2], VOIDmode))
 332     FAIL;
 333   if (TARGET_64BIT && register_operand (operands[2], QImode))
 334     {
 335       rtx t = gen_reg_rtx (DImode);
 336       emit_insn (gen_rotrsi3_sext (t, operands[1], operands[2]));
 337       t = gen_lowpart (SImode, t);
 338       SUBREG_PROMOTED_VAR_P (t) = 1;
 339       SUBREG_PROMOTED_SET (t, SRP_SIGNED);
 340       emit_move_insn (operands[0], t);
 341       DONE;
 342     }
 343 })
 344
 345 (define_insn "*rotrdi3"
 346   [(set (match_operand:DI 0 "register_operand" "=r")
 347         (rotatert:DI (match_operand:DI 1 "register_operand" "r")
 348                      (match_operand:QI 2 "arith_operand" "rI")))]
 349   "TARGET_64BIT && (TARGET_ZBB || TARGET_ZBKB)"
 350   "ror%i2\t%0,%1,%2"
 351   [(set_attr "type" "bitmanip")])
 352
 353 (define_insn "rotrsi3_sext"
 354   [(set (match_operand:DI 0 "register_operand" "=r")
 355         (sign_extend:DI (rotatert:SI (match_operand:SI 1 "register_operand" "r")
 356                                  (match_operand:QI 2 "arith_operand" "rI"))))]
 357   "TARGET_64BIT && (TARGET_ZBB || TARGET_ZBKB)"
 358   "ror%i2%~\t%0,%1,%2"
 359   [(set_attr "type" "bitmanip")])
 360
 361 (define_insn "*rotlsi3"
 362   [(set (match_operand:SI 0 "register_operand" "=r")
 363         (rotate:SI (match_operand:SI 1 "register_operand" "r")
 364                    (match_operand:QI 2 "register_operand" "r")))]
 365   "TARGET_ZBB || TARGET_ZBKB"
 366   "rol%~\t%0,%1,%2"
 367   [(set_attr "type" "bitmanip")])
 368
 369 (define_expand "rotlsi3"
 370   [(set (match_operand:SI 0 "register_operand" "=r")
 371        (rotate:SI (match_operand:SI 1 "register_operand" "r")
 372                   (match_operand:QI 2 "register_operand" "r")))]
 373   "TARGET_ZBB || TARGET_ZBKB"
 374 {
 375   if (TARGET_64BIT)
 376     {
 377       rtx t = gen_reg_rtx (DImode);
 378       emit_insn (gen_rotlsi3_sext (t, operands[1], operands[2]));
 379       t = gen_lowpart (SImode, t);
 380       SUBREG_PROMOTED_VAR_P (t) = 1;
 381       SUBREG_PROMOTED_SET (t, SRP_SIGNED);
 382       emit_move_insn (operands[0], t);
 383       DONE;
 384     }
 385 })
 386
 387 (define_insn "rotldi3"
 388   [(set (match_operand:DI 0 "register_operand" "=r")
 389         (rotate:DI (match_operand:DI 1 "register_operand" "r")
 390                    (match_operand:QI 2 "register_operand" "r")))]
 391   "TARGET_64BIT && (TARGET_ZBB || TARGET_ZBKB)"
 392   "rol\t%0,%1,%2"
 393   [(set_attr "type" "bitmanip")])
 394
 395 (define_insn "rotlsi3_sext"
 396   [(set (match_operand:DI 0 "register_operand" "=r")
 397         (sign_extend:DI (rotate:SI (match_operand:SI 1 "register_operand" "r")
 398                                    (match_operand:QI 2 "register_operand" "r"))))]
 399   "TARGET_64BIT && (TARGET_ZBB || TARGET_ZBKB)"
 400   "rolw\t%0,%1,%2"
 401   [(set_attr "type" "bitmanip")])
 402
 403 (define_insn_and_split "*<bitmanip_optab><GPR:mode>3_mask"
 404   [(set (match_operand:GPR     0 "register_operand" "= r")
 405         (bitmanip_rotate:GPR
 406             (match_operand:GPR 1 "register_operand" "  r")
 407             (match_operator 4 "subreg_lowpart_operator"
 408              [(and:GPR2
 409                (match_operand:GPR2 2 "register_operand"  "r")
 410                (match_operand 3 "<GPR:shiftm1>" "<GPR:shiftm1p>"))])))]
 411   "TARGET_ZBB || TARGET_ZBKB"
 412   "#"
 413   "&& 1"
 414   [(set (match_dup 0)
 415         (bitmanip_rotate:GPR (match_dup 1)
 416                              (match_dup 2)))]
 417   "operands[2] = gen_lowpart (QImode, operands[2]);"
 418   [(set_attr "type" "bitmanip")
 419    (set_attr "mode" "<GPR:MODE>")])
 420
 421 (define_insn_and_split "*<bitmanip_optab>si3_sext_mask"
 422   [(set (match_operand:DI     0 "register_operand" "= r")
 423   (sign_extend:DI (bitmanip_rotate:SI
 424             (match_operand:SI 1 "register_operand" "  r")
 425             (match_operator 4 "subreg_lowpart_operator"
 426              [(and:GPR
 427                (match_operand:GPR 2 "register_operand"  "r")
 428                (match_operand 3 "const_si_mask_operand"))]))))]
 429   "TARGET_64BIT && (TARGET_ZBB || TARGET_ZBKB)"
 430   "#"
 431   "&& 1"
 432   [(set (match_dup 0)
 433   (sign_extend:DI (bitmanip_rotate:SI (match_dup 1)
 434                            (match_dup 2))))]
 435   "operands[2] = gen_lowpart (QImode, operands[2]);"
 436   [(set_attr "type" "bitmanip")
 437    (set_attr "mode" "DI")])
 438
 439 ;; orc.b (or-combine) is added as an unspec for the benefit of the support
 440 ;; for optimized string functions (such as strcmp).
 441 (define_insn "orcb<mode>2"
 442   [(set (match_operand:X 0 "register_operand" "=r")
 443         (unspec:X [(match_operand:X 1 "register_operand" "r")] UNSPEC_ORC_B))]
 444   "TARGET_ZBB"
 445   "orc.b\t%0,%1"
 446   [(set_attr "type" "bitmanip")])
 447
 448 (define_expand "bswapdi2"
 449   [(set (match_operand:DI 0 "register_operand")
 450         (bswap:DI (match_operand:DI 1 "register_operand")))]
 451   "TARGET_64BIT && (TARGET_ZBB || TARGET_XTHEADBB || TARGET_ZBKB)")
 452
 453 (define_expand "bswapsi2"
 454   [(set (match_operand:SI 0 "register_operand")
 455         (bswap:SI (match_operand:SI 1 "register_operand")))]
 456   "(!TARGET_64BIT && (TARGET_ZBB || TARGET_ZBKB)) || TARGET_XTHEADBB")
 457
 458 (define_insn "*bswap<mode>2"
 459   [(set (match_operand:X 0 "register_operand" "=r")
 460         (bswap:X (match_operand:X 1 "register_operand" "r")))]
 461   "TARGET_ZBB || TARGET_ZBKB"
 462   "rev8\t%0,%1"
 463   [(set_attr "type" "bitmanip")])
 464
 465 ;; HI bswap can be emulated using SI/DI bswap followed
 466 ;; by a logical shift right
 467 ;; SI bswap for TARGET_64BIT is already similarly in
 468 ;; the common code.
 469 (define_expand "bswaphi2"
 470   [(set (match_operand:HI 0 "register_operand" "=r")
 471         (bswap:HI (match_operand:HI 1 "register_operand" "r")))]
 472   "TARGET_ZBB"
 473 {
 474   rtx tmp = gen_reg_rtx (word_mode);
 475   rtx newop1 = gen_lowpart (word_mode, operands[1]);
 476   if (TARGET_64BIT)
 477     emit_insn (gen_bswapdi2 (tmp, newop1));
 478   else
 479     emit_insn (gen_bswapsi2 (tmp, newop1));
 480   rtx tmp1 = gen_reg_rtx (word_mode);
 481   if (TARGET_64BIT)
 482     emit_insn (gen_lshrdi3 (tmp1, tmp, GEN_INT (64 - 16)));
 483   else
 484     emit_insn (gen_lshrsi3 (tmp1, tmp, GEN_INT (32 - 16)));
 485   emit_move_insn (operands[0], gen_lowpart (HImode, tmp1));
 486   DONE;
 487 })
 488
 489 (define_expand "<bitmanip_optab>di3"
 490   [(set (match_operand:DI 0 "register_operand" "=r")
 491         (bitmanip_minmax:DI (match_operand:DI 1 "register_operand" "r")
 492                             (match_operand:DI 2 "register_operand" "r")))]
 493   "TARGET_64BIT && TARGET_ZBB")
 494
 495 (define_expand "<bitmanip_optab>si3"
 496   [(set (match_operand:SI 0 "register_operand" "=r")
 497         (bitmanip_minmax:SI (match_operand:SI 1 "register_operand" "r")
 498                             (match_operand:SI 2 "register_operand" "r")))]
 499   "TARGET_ZBB"
 500 {
 501   if (TARGET_64BIT)
 502     {
 503       rtx t = gen_reg_rtx (DImode);
 504       operands[1] = force_reg (DImode, gen_rtx_SIGN_EXTEND (DImode, operands[1]));
 505       operands[2] = force_reg (DImode, gen_rtx_SIGN_EXTEND (DImode, operands[2]));
 506       emit_insn (gen_<bitmanip_optab>di3 (t, operands[1], operands[2]));
 507       emit_move_insn (operands[0], gen_lowpart (SImode, t));
 508       DONE;
 509     }
 510 })
 511
 512 (define_insn "*<bitmanip_optab><mode>3"
 513   [(set (match_operand:X 0 "register_operand" "=r")
 514         (bitmanip_minmax:X (match_operand:X 1 "register_operand" "r")
 515                            (match_operand:X 2 "reg_or_0_operand" "rJ")))]
 516   "TARGET_ZBB"
 517   "<bitmanip_insn>\t%0,%1,%z2"
 518   [(set_attr "type" "<bitmanip_insn>")])
 519
 520 ;; Optimize the common case of a SImode min/max against a constant
 521 ;; that is safe both for sign- and zero-extension.
 522 (define_insn_and_split "*minmax"
 523   [(set (match_operand:DI 0 "register_operand" "=r")
 524         (sign_extend:DI
 525           (subreg:SI
 526             (bitmanip_minmax:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "r"))
 527                                                 (match_operand:DI 2 "immediate_operand" "i"))
 528            0)))
 529    (clobber (match_scratch:DI 3 "=&r"))
 530    (clobber (match_scratch:DI 4 "=&r"))]
 531   "TARGET_64BIT && TARGET_ZBB && sext_hwi (INTVAL (operands[2]), 32) >= 0"
 532   "#"
 533   "&& reload_completed"
 534   [(set (match_dup 3) (sign_extend:DI (match_dup 1)))
 535    (set (match_dup 4) (match_dup 2))
 536    (set (match_dup 0) (<minmax_optab>:DI (match_dup 3) (match_dup 4)))])
 537
 538 ;; ZBS extension.
 539
 540 (define_insn "*bset<mode>"
 541   [(set (match_operand:X 0 "register_operand" "=r")
 542         (ior:X (ashift:X (const_int 1)
 543                          (match_operand:QI 2 "register_operand" "r"))
 544                (match_operand:X 1 "register_operand" "r")))]
 545   "TARGET_ZBS"
 546   "bset\t%0,%1,%2"
 547   [(set_attr "type" "bitmanip")])
 548
 549 (define_insn "*bset<mode>_mask"
 550   [(set (match_operand:X 0 "register_operand" "=r")
 551         (ior:X (ashift:X (const_int 1)
 552                          (subreg:QI
 553                           (and:X (match_operand:X 2 "register_operand" "r")
 554                                  (match_operand 3 "<X:shiftm1>" "<X:shiftm1p>")) 0))
 555                (match_operand:X 1 "register_operand" "r")))]
 556   "TARGET_ZBS"
 557   "bset\t%0,%1,%2"
 558   [(set_attr "type" "bitmanip")])
 559
 560 (define_insn "*bset<mode>_1"
 561   [(set (match_operand:X 0 "register_operand" "=r")
 562         (ashift:X (const_int 1)
 563                   (match_operand:QI 1 "register_operand" "r")))]
 564   "TARGET_ZBS"
 565   "bset\t%0,x0,%1"
 566   [(set_attr "type" "bitmanip")])
 567
 568 (define_insn "*bset<mode>_1_mask"
 569   [(set (match_operand:X 0 "register_operand" "=r")
 570         (ashift:X (const_int 1)
 571                   (subreg:QI
 572                    (and:X (match_operand:X 1 "register_operand" "r")
 573                           (match_operand 2 "<X:shiftm1>" "<X:shiftm1p>")) 0)))]
 574   "TARGET_ZBS"
 575   "bset\t%0,x0,%1"
 576   [(set_attr "type" "bitmanip")])
 577
 578 (define_insn "*bseti<mode>"
 579   [(set (match_operand:X 0 "register_operand" "=r")
 580         (ior:X (match_operand:X 1 "register_operand" "r")
 581                (match_operand:X 2 "single_bit_mask_operand" "DbS")))]
 582   "TARGET_ZBS"
 583   "bseti\t%0,%1,%S2"
 584   [(set_attr "type" "bitmanip")])
 585
 586 ;; As long as the SImode operand is not a partial subreg, we can use a
 587 ;; bseti without postprocessing, as the middle end is smart enough to
 588 ;; stay away from the signbit.
 589 (define_insn "*bsetidisi"
 590   [(set (match_operand:DI 0 "register_operand" "=r")
 591         (ior:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "r"))
 592                 (match_operand 2 "single_bit_mask_operand" "i")))]
 593   "TARGET_ZBS && TARGET_64BIT
 594    && !partial_subreg_p (operands[1])"
 595   "bseti\t%0,%1,%S2"
 596   [(set_attr "type" "bitmanip")])
 597
 598 (define_insn "*bclr<mode>"
 599   [(set (match_operand:X 0 "register_operand" "=r")
 600         (and:X (rotate:X (const_int -2)
 601                          (match_operand:QI 2 "register_operand" "r"))
 602                (match_operand:X 1 "register_operand" "r")))]
 603   "TARGET_ZBS"
 604   "bclr\t%0,%1,%2"
 605   [(set_attr "type" "bitmanip")])
 606
 607 (define_insn "*bclri<mode>"
 608   [(set (match_operand:X 0 "register_operand" "=r")
 609         (and:X (match_operand:X 1 "register_operand" "r")
 610                (match_operand:X 2 "not_single_bit_mask_operand" "DnS")))]
 611   "TARGET_ZBS"
 612   "bclri\t%0,%1,%T2"
 613   [(set_attr "type" "bitmanip")])
 614
 615 ;; In case we have "val & ~IMM" where ~IMM has 2 bits set.
 616 (define_insn_and_split "*bclri<mode>_nottwobits"
 617   [(set (match_operand:X 0 "register_operand" "=r")
 618         (and:X (match_operand:X 1 "register_operand" "r")
 619                (match_operand:X 2 "const_nottwobits_not_arith_operand" "i")))]
 620   "TARGET_ZBS && !paradoxical_subreg_p (operands[1])"
 621   "#"
 622   "&& reload_completed"
 623   [(set (match_dup 0) (and:X (match_dup 1) (match_dup 3)))
 624    (set (match_dup 0) (and:X (match_dup 0) (match_dup 4)))]
 625 {
 626         unsigned HOST_WIDE_INT bits = ~UINTVAL (operands[2]);
 627         unsigned HOST_WIDE_INT topbit = HOST_WIDE_INT_1U << floor_log2 (bits);
 628
 629         operands[3] = GEN_INT (~bits | topbit);
 630         operands[4] = GEN_INT (~topbit);
 631 })
 632
 633 ;; In case of a paradoxical subreg, the sign bit and the high bits are
 634 ;; not allowed to be changed
 635 (define_insn_and_split "*bclridisi_nottwobits"
 636   [(set (match_operand:DI 0 "register_operand" "=r")
 637         (and:DI (match_operand:DI 1 "register_operand" "r")
 638                 (match_operand:DI 2 "const_nottwobits_not_arith_operand" "i")))]
 639   "TARGET_64BIT && TARGET_ZBS
 640    && clz_hwi (~UINTVAL (operands[2])) > 33"
 641   "#"
 642   "&& reload_completed"
 643   [(set (match_dup 0) (and:DI (match_dup 1) (match_dup 3)))
 644    (set (match_dup 0) (and:DI (match_dup 0) (match_dup 4)))]
 645 {
 646         unsigned HOST_WIDE_INT bits = ~UINTVAL (operands[2]);
 647         unsigned HOST_WIDE_INT topbit = HOST_WIDE_INT_1U << floor_log2 (bits);
 648
 649         operands[3] = GEN_INT (~bits | topbit);
 650         operands[4] = GEN_INT (~topbit);
 651 })
 652
 653 (define_insn "*binv<mode>"
 654   [(set (match_operand:X 0 "register_operand" "=r")
 655         (xor:X (ashift:X (const_int 1)
 656                          (match_operand:QI 2 "register_operand" "r"))
 657                (match_operand:X 1 "register_operand" "r")))]
 658   "TARGET_ZBS"
 659   "binv\t%0,%1,%2"
 660   [(set_attr "type" "bitmanip")])
 661
 662 (define_insn "*binvi<mode>"
 663   [(set (match_operand:X 0 "register_operand" "=r")
 664         (xor:X (match_operand:X 1 "register_operand" "r")
 665                (match_operand:X 2 "single_bit_mask_operand" "DbS")))]
 666   "TARGET_ZBS"
 667   "binvi\t%0,%1,%S2"
 668   [(set_attr "type" "bitmanip")])
 669
 670 (define_insn "*bext<mode>"
 671   [(set (match_operand:X 0 "register_operand" "=r")
 672         (zero_extract:X (match_operand:X 1 "register_operand" "r")
 673                         (const_int 1)
 674                         (zero_extend:X
 675                          (match_operand:QI 2 "register_operand" "r"))))]
 676   "TARGET_ZBS"
 677   "bext\t%0,%1,%2"
 678   [(set_attr "type" "bitmanip")])
 679
 680 ;; When performing `(a & (1UL << bitno)) ? 0 : -1` the combiner
 681 ;; usually has the `bitno` typed as X-mode (i.e. no further
 682 ;; zero-extension is performed around the bitno).
 683 (define_insn "*bext<mode>"
 684   [(set (match_operand:X 0 "register_operand" "=r")
 685         (zero_extract:X (match_operand:X 1 "register_operand" "r")
 686                         (const_int 1)
 687                         (match_operand:X 2 "register_operand" "r")))]
 688   "TARGET_ZBS"
 689   "bext\t%0,%1,%2"
 690   [(set_attr "type" "bitmanip")])
 691
 692 (define_insn "*bexti"
 693   [(set (match_operand:X 0 "register_operand" "=r")
 694         (zero_extract:X (match_operand:X 1 "register_operand" "r")
 695                         (const_int 1)
 696                         (match_operand 2 "immediate_operand" "n")))]
 697   "TARGET_ZBS && UINTVAL (operands[2]) < GET_MODE_BITSIZE (<MODE>mode)"
 698   "bexti\t%0,%1,%2"
 699   [(set_attr "type" "bitmanip")])
 700
 701 ;; Split for "(a & (1 << BIT_NO)) ? 0 : 1":
 702 ;; We avoid reassociating "(~(a >> BIT_NO)) & 1" into "((~a) >> BIT_NO) & 1",
 703 ;; so we don't have to use a temporary.  Instead we extract the bit and then
 704 ;; invert bit 0 ("a ^ 1") only.
 705 (define_split
 706   [(set (match_operand:X 0 "register_operand")
 707         (and:X (not:X (lshiftrt:X (match_operand:X 1 "register_operand")
 708                                   (subreg:QI (match_operand:X 2 "register_operand") 0)))
 709                (const_int 1)))]
 710   "TARGET_ZBS"
 711   [(set (match_dup 0) (zero_extract:X (match_dup 1)
 712                                       (const_int 1)
 713                                       (match_dup 2)))
 714    (set (match_dup 0) (xor:X (match_dup 0) (const_int 1)))])
 715
 716 ;; We can create a polarity-reversed mask (i.e. bit N -> { set = 0, clear = -1 })
 717 ;; using a bext(i) followed by an addi instruction.
 718 ;; This splits the canonical representation of "(a & (1 << BIT_NO)) ? 0 : -1".
 719 (define_split
 720   [(set (match_operand:GPR 0 "register_operand")
 721        (neg:GPR (eq:GPR (zero_extract:GPR (match_operand:GPR 1 "register_operand")
 722                                           (const_int 1)
 723                                           (match_operand 2))
 724                         (const_int 0))))]
 725   "TARGET_ZBS"
 726   [(set (match_dup 0) (zero_extract:GPR (match_dup 1) (const_int 1) (match_dup 2)))
 727    (set (match_dup 0) (plus:GPR (match_dup 0) (const_int -1)))])
 728
 729 ;; Catch those cases where we can use a bseti/binvi + ori/xori or
 730 ;; bseti/binvi + bseti/binvi instead of a lui + addi + or/xor sequence.
 731 (define_insn_and_split "*<or_optab>i<mode>_extrabit"
 732   [(set (match_operand:X 0 "register_operand" "=r")
 733         (any_or:X (match_operand:X 1 "register_operand" "r")
 734                   (match_operand:X 2 "uimm_extra_bit_or_twobits" "i")))]
 735   "TARGET_ZBS"
 736   "#"
 737   "&& reload_completed"
 738   [(set (match_dup 0) (<or_optab>:X (match_dup 1) (match_dup 3)))
 739    (set (match_dup 0) (<or_optab>:X (match_dup 0) (match_dup 4)))]
 740 {
 741         unsigned HOST_WIDE_INT bits = UINTVAL (operands[2]);
 742         unsigned HOST_WIDE_INT topbit = HOST_WIDE_INT_1U << floor_log2 (bits);
 743
 744         operands[3] = GEN_INT (bits &~ topbit);
 745         operands[4] = GEN_INT (topbit);
 746 })
 747
 748 ;; Same to use blcri + andi and blcri + bclri
 749 (define_insn_and_split "*andi<mode>_extrabit"
 750   [(set (match_operand:X 0 "register_operand" "=r")
 751         (and:X (match_operand:X 1 "register_operand" "r")
 752                (match_operand:X 2 "not_uimm_extra_bit_or_nottwobits" "i")))]
 753   "TARGET_ZBS"
 754   "#"
 755   "&& reload_completed"
 756   [(set (match_dup 0) (and:X (match_dup 1) (match_dup 3)))
 757    (set (match_dup 0) (and:X (match_dup 0) (match_dup 4)))]
 758 {
 759         unsigned HOST_WIDE_INT bits = UINTVAL (operands[2]);
 760         unsigned HOST_WIDE_INT topbit = HOST_WIDE_INT_1U << floor_log2 (~bits);
 761
 762         operands[3] = GEN_INT (bits | topbit);
 763         operands[4] = GEN_INT (~topbit);
 764 })
 765
 766 ;; IF_THEN_ELSE: test for 2 bits of opposite polarity
 767 (define_insn_and_split "*branch<X:mode>_mask_twobits_equals_singlebit"
 768   [(set (pc)
 769         (if_then_else
 770           (match_operator 1 "equality_operator"
 771             [(and:X (match_operand:X 2 "register_operand" "r")
 772                     (match_operand:X 3 "const_twobits_not_arith_operand" "i"))
 773              (match_operand:X 4 "single_bit_mask_operand" "i")])
 774          (label_ref (match_operand 0 "" ""))
 775          (pc)))
 776    (clobber (match_scratch:X 5 "=&r"))
 777    (clobber (match_scratch:X 6 "=&r"))]
 778   "TARGET_ZBS && TARGET_ZBB"
 779   "#"
 780   "&& reload_completed"
 781   [(set (match_dup 5) (zero_extract:X (match_dup 2)
 782                                       (const_int 1)
 783                                       (match_dup 8)))
 784    (set (match_dup 6) (zero_extract:X (match_dup 2)
 785                                       (const_int 1)
 786                                       (match_dup 9)))
 787    (set (match_dup 6) (and:X (not:X (match_dup 6)) (match_dup 5)))
 788    (set (pc) (if_then_else (match_op_dup 1 [(match_dup 6) (const_int 0)])
 789                            (label_ref (match_dup 0))
 790                            (pc)))]
 791 {
 792    unsigned HOST_WIDE_INT twobits_mask = UINTVAL (operands[3]);
 793    unsigned HOST_WIDE_INT singlebit_mask = UINTVAL (operands[4]);
 794
 795    /* We should never see an unsatisfiable condition.  */
 796    gcc_assert (twobits_mask & singlebit_mask);
 797
 798    int setbit = ctz_hwi (singlebit_mask);
 799    int clearbit = ctz_hwi (twobits_mask & ~singlebit_mask);
 800
 801    operands[1] = gen_rtx_fmt_ee (GET_CODE (operands[1]) == NE ? EQ : NE,
 802                                  <X:MODE>mode, operands[6], GEN_INT(0));
 803
 804    operands[8] = GEN_INT (setbit);
 805    operands[9] = GEN_INT (clearbit);
 806 })
 807
 808 ;; IF_THEN_ELSE: test for (a & (1 << BIT_NO))
 809 (define_insn_and_split "*branch<X:mode>_bext"
 810   [(set (pc)
 811         (if_then_else
 812           (match_operator 1 "equality_operator"
 813          [(zero_extract:X (match_operand:X 2 "register_operand" "r")
 814                           (const_int 1)
 815                           (zero_extend:X
 816                             (match_operand:QI 3 "register_operand" "r")))
 817             (const_int 0)])
 818         (label_ref (match_operand 0 "" ""))
 819         (pc)))
 820   (clobber (match_scratch:X 4 "=&r"))]
 821   "TARGET_ZBS"
 822   "#"
 823   "&& reload_completed"
 824   [(set (match_dup 4) (zero_extract:X (match_dup 2)
 825                                         (const_int 1)
 826                                         (zero_extend:X (match_dup 3))))
 827    (set (pc) (if_then_else (match_op_dup 1 [(match_dup 4) (const_int 0)])
 828                            (label_ref (match_dup 0))
 829                            (pc)))])
 830
 831 ;; ZBKC or ZBC extension
 832 (define_insn "riscv_clmul_<mode>"
 833   [(set (match_operand:X 0 "register_operand" "=r")
 834         (unspec:X [(match_operand:X 1 "register_operand" "r")
 835                   (match_operand:X 2 "register_operand" "r")]
 836                   UNSPEC_CLMUL))]
 837   "TARGET_ZBKC || TARGET_ZBC"
 838   "clmul\t%0,%1,%2"
 839   [(set_attr "type" "clmul")])
 840
 841 (define_insn "riscv_clmulh_<mode>"
 842   [(set (match_operand:X 0 "register_operand" "=r")
 843         (unspec:X [(match_operand:X 1 "register_operand" "r")
 844                   (match_operand:X 2 "register_operand" "r")]
 845                   UNSPEC_CLMULH))]
 846   "TARGET_ZBKC || TARGET_ZBC"
 847   "clmulh\t%0,%1,%2"
 848   [(set_attr "type" "clmul")])
 849
 850 ;; ZBC extension
 851 (define_insn "riscv_clmulr_<mode>"
 852   [(set (match_operand:X 0 "register_operand" "=r")
 853         (unspec:X [(match_operand:X 1 "register_operand" "r")
 854                   (match_operand:X 2 "register_operand" "r")]
 855                   UNSPEC_CLMULR))]
 856   "TARGET_ZBC"
 857   "clmulr\t%0,%1,%2"
 858   [(set_attr "type" "clmul")])