llvm/test/CodeGen/RISCV/rv32zbs.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=riscv32 -verify-machineinstrs < %s \
   3 ; RUN:   | FileCheck %s -check-prefixes=CHECK,RV32I
   4 ; RUN: llc -mtriple=riscv32 -mattr=+zbs -verify-machineinstrs < %s \
   5 ; RUN:   | FileCheck %s -check-prefixes=CHECK,RV32ZBS
   6
   7 define i32 @bclr_i32(i32 %a, i32 %b) nounwind {
   8 ; RV32I-LABEL: bclr_i32:
   9 ; RV32I:       # %bb.0:
  10 ; RV32I-NEXT:    li a2, 1
  11 ; RV32I-NEXT:    sll a1, a2, a1
  12 ; RV32I-NEXT:    not a1, a1
  13 ; RV32I-NEXT:    and a0, a1, a0
  14 ; RV32I-NEXT:    ret
  15 ;
  16 ; RV32ZBS-LABEL: bclr_i32:
  17 ; RV32ZBS:       # %bb.0:
  18 ; RV32ZBS-NEXT:    bclr a0, a0, a1
  19 ; RV32ZBS-NEXT:    ret
  20   %and = and i32 %b, 31
  21   %shl = shl nuw i32 1, %and
  22   %neg = xor i32 %shl, -1
  23   %and1 = and i32 %neg, %a
  24   ret i32 %and1
  25 }
  26
  27 define i32 @bclr_i32_no_mask(i32 %a, i32 %b) nounwind {
  28 ; RV32I-LABEL: bclr_i32_no_mask:
  29 ; RV32I:       # %bb.0:
  30 ; RV32I-NEXT:    li a2, 1
  31 ; RV32I-NEXT:    sll a1, a2, a1
  32 ; RV32I-NEXT:    not a1, a1
  33 ; RV32I-NEXT:    and a0, a1, a0
  34 ; RV32I-NEXT:    ret
  35 ;
  36 ; RV32ZBS-LABEL: bclr_i32_no_mask:
  37 ; RV32ZBS:       # %bb.0:
  38 ; RV32ZBS-NEXT:    bclr a0, a0, a1
  39 ; RV32ZBS-NEXT:    ret
  40   %shl = shl nuw i32 1, %b
  41   %neg = xor i32 %shl, -1
  42   %and1 = and i32 %neg, %a
  43   ret i32 %and1
  44 }
  45
  46 define i64 @bclr_i64(i64 %a, i64 %b) nounwind {
  47 ; RV32I-LABEL: bclr_i64:
  48 ; RV32I:       # %bb.0:
  49 ; RV32I-NEXT:    li a3, 1
  50 ; RV32I-NEXT:    sll a4, a3, a2
  51 ; RV32I-NEXT:    andi a2, a2, 63
  52 ; RV32I-NEXT:    addi a5, a2, -32
  53 ; RV32I-NEXT:    slti a5, a5, 0
  54 ; RV32I-NEXT:    neg a6, a5
  55 ; RV32I-NEXT:    and a4, a6, a4
  56 ; RV32I-NEXT:    sll a2, a3, a2
  57 ; RV32I-NEXT:    addi a5, a5, -1
  58 ; RV32I-NEXT:    and a2, a5, a2
  59 ; RV32I-NEXT:    not a3, a4
  60 ; RV32I-NEXT:    not a2, a2
  61 ; RV32I-NEXT:    and a0, a3, a0
  62 ; RV32I-NEXT:    and a1, a2, a1
  63 ; RV32I-NEXT:    ret
  64 ;
  65 ; RV32ZBS-LABEL: bclr_i64:
  66 ; RV32ZBS:       # %bb.0:
  67 ; RV32ZBS-NEXT:    andi a3, a2, 63
  68 ; RV32ZBS-NEXT:    addi a4, a3, -32
  69 ; RV32ZBS-NEXT:    slti a4, a4, 0
  70 ; RV32ZBS-NEXT:    neg a5, a4
  71 ; RV32ZBS-NEXT:    bset a2, zero, a2
  72 ; RV32ZBS-NEXT:    and a2, a5, a2
  73 ; RV32ZBS-NEXT:    bset a3, zero, a3
  74 ; RV32ZBS-NEXT:    addi a4, a4, -1
  75 ; RV32ZBS-NEXT:    and a3, a4, a3
  76 ; RV32ZBS-NEXT:    not a3, a3
  77 ; RV32ZBS-NEXT:    not a2, a2
  78 ; RV32ZBS-NEXT:    and a0, a2, a0
  79 ; RV32ZBS-NEXT:    and a1, a3, a1
  80 ; RV32ZBS-NEXT:    ret
  81   %and = and i64 %b, 63
  82   %shl = shl nuw i64 1, %and
  83   %neg = xor i64 %shl, -1
  84   %and1 = and i64 %neg, %a
  85   ret i64 %and1
  86 }
  87
  88 define i32 @bset_i32(i32 %a, i32 %b) nounwind {
  89 ; RV32I-LABEL: bset_i32:
  90 ; RV32I:       # %bb.0:
  91 ; RV32I-NEXT:    li a2, 1
  92 ; RV32I-NEXT:    sll a1, a2, a1
  93 ; RV32I-NEXT:    or a0, a1, a0
  94 ; RV32I-NEXT:    ret
  95 ;
  96 ; RV32ZBS-LABEL: bset_i32:
  97 ; RV32ZBS:       # %bb.0:
  98 ; RV32ZBS-NEXT:    bset a0, a0, a1
  99 ; RV32ZBS-NEXT:    ret
 100   %and = and i32 %b, 31
 101   %shl = shl nuw i32 1, %and
 102   %or = or i32 %shl, %a
 103   ret i32 %or
 104 }
 105
 106 define i32 @bset_i32_no_mask(i32 %a, i32 %b) nounwind {
 107 ; RV32I-LABEL: bset_i32_no_mask:
 108 ; RV32I:       # %bb.0:
 109 ; RV32I-NEXT:    li a2, 1
 110 ; RV32I-NEXT:    sll a1, a2, a1
 111 ; RV32I-NEXT:    or a0, a1, a0
 112 ; RV32I-NEXT:    ret
 113 ;
 114 ; RV32ZBS-LABEL: bset_i32_no_mask:
 115 ; RV32ZBS:       # %bb.0:
 116 ; RV32ZBS-NEXT:    bset a0, a0, a1
 117 ; RV32ZBS-NEXT:    ret
 118   %shl = shl nuw i32 1, %b
 119   %or = or i32 %shl, %a
 120   ret i32 %or
 121 }
 122
 123 ; We can use bsetw for 1 << x by setting the first source to zero.
 124 define signext i32 @bset_i32_zero(i32 signext %a) nounwind {
 125 ; RV32I-LABEL: bset_i32_zero:
 126 ; RV32I:       # %bb.0:
 127 ; RV32I-NEXT:    li a1, 1
 128 ; RV32I-NEXT:    sll a0, a1, a0
 129 ; RV32I-NEXT:    ret
 130 ;
 131 ; RV32ZBS-LABEL: bset_i32_zero:
 132 ; RV32ZBS:       # %bb.0:
 133 ; RV32ZBS-NEXT:    bset a0, zero, a0
 134 ; RV32ZBS-NEXT:    ret
 135   %shl = shl i32 1, %a
 136   ret i32 %shl
 137 }
 138
 139 ; As we are not matching directly i64 code patterns on RV32 some i64 patterns
 140 ; don't have yet any matching bit manipulation instructions on RV32.
 141 ; This test is presented here in case future expansions of the Bitmanip
 142 ; extensions introduce instructions suitable for this pattern.
 143
 144 define i64 @bset_i64(i64 %a, i64 %b) nounwind {
 145 ; RV32I-LABEL: bset_i64:
 146 ; RV32I:       # %bb.0:
 147 ; RV32I-NEXT:    li a3, 1
 148 ; RV32I-NEXT:    sll a2, a3, a2
 149 ; RV32I-NEXT:    srai a3, a2, 31
 150 ; RV32I-NEXT:    or a0, a2, a0
 151 ; RV32I-NEXT:    or a1, a3, a1
 152 ; RV32I-NEXT:    ret
 153 ;
 154 ; RV32ZBS-LABEL: bset_i64:
 155 ; RV32ZBS:       # %bb.0:
 156 ; RV32ZBS-NEXT:    bset a3, zero, a2
 157 ; RV32ZBS-NEXT:    srai a3, a3, 31
 158 ; RV32ZBS-NEXT:    bset a0, a0, a2
 159 ; RV32ZBS-NEXT:    or a1, a3, a1
 160 ; RV32ZBS-NEXT:    ret
 161   %1 = trunc i64 %b to i32
 162   %conv = and i32 %1, 63
 163   %shl = shl nuw i32 1, %conv
 164   %conv1 = sext i32 %shl to i64
 165   %or = or i64 %conv1, %a
 166   ret i64 %or
 167 }
 168
 169 define signext i64 @bset_i64_zero(i64 signext %a) nounwind {
 170 ; RV32I-LABEL: bset_i64_zero:
 171 ; RV32I:       # %bb.0:
 172 ; RV32I-NEXT:    li a1, 1
 173 ; RV32I-NEXT:    sll a1, a1, a0
 174 ; RV32I-NEXT:    addi a0, a0, -32
 175 ; RV32I-NEXT:    slti a2, a0, 0
 176 ; RV32I-NEXT:    neg a0, a2
 177 ; RV32I-NEXT:    and a0, a0, a1
 178 ; RV32I-NEXT:    addi a2, a2, -1
 179 ; RV32I-NEXT:    and a1, a2, a1
 180 ; RV32I-NEXT:    ret
 181 ;
 182 ; RV32ZBS-LABEL: bset_i64_zero:
 183 ; RV32ZBS:       # %bb.0:
 184 ; RV32ZBS-NEXT:    addi a1, a0, -32
 185 ; RV32ZBS-NEXT:    slti a1, a1, 0
 186 ; RV32ZBS-NEXT:    neg a2, a1
 187 ; RV32ZBS-NEXT:    bset a3, zero, a0
 188 ; RV32ZBS-NEXT:    and a0, a2, a3
 189 ; RV32ZBS-NEXT:    addi a1, a1, -1
 190 ; RV32ZBS-NEXT:    and a1, a1, a3
 191 ; RV32ZBS-NEXT:    ret
 192   %shl = shl i64 1, %a
 193   ret i64 %shl
 194 }
 195
 196 define i32 @binv_i32(i32 %a, i32 %b) nounwind {
 197 ; RV32I-LABEL: binv_i32:
 198 ; RV32I:       # %bb.0:
 199 ; RV32I-NEXT:    li a2, 1
 200 ; RV32I-NEXT:    sll a1, a2, a1
 201 ; RV32I-NEXT:    xor a0, a1, a0
 202 ; RV32I-NEXT:    ret
 203 ;
 204 ; RV32ZBS-LABEL: binv_i32:
 205 ; RV32ZBS:       # %bb.0:
 206 ; RV32ZBS-NEXT:    binv a0, a0, a1
 207 ; RV32ZBS-NEXT:    ret
 208   %and = and i32 %b, 31
 209   %shl = shl nuw i32 1, %and
 210   %xor = xor i32 %shl, %a
 211   ret i32 %xor
 212 }
 213
 214 ; As we are not matching directly i64 code patterns on RV32 some i64 patterns
 215 ; don't have yet any matching bit manipulation instructions on RV32.
 216 ; This test is presented here in case future expansions of the Bitmanip
 217 ; extensions introduce instructions suitable for this pattern.
 218
 219 define i64 @binv_i64(i64 %a, i64 %b) nounwind {
 220 ; RV32I-LABEL: binv_i64:
 221 ; RV32I:       # %bb.0:
 222 ; RV32I-NEXT:    li a3, 1
 223 ; RV32I-NEXT:    sll a2, a3, a2
 224 ; RV32I-NEXT:    srai a3, a2, 31
 225 ; RV32I-NEXT:    xor a0, a2, a0
 226 ; RV32I-NEXT:    xor a1, a3, a1
 227 ; RV32I-NEXT:    ret
 228 ;
 229 ; RV32ZBS-LABEL: binv_i64:
 230 ; RV32ZBS:       # %bb.0:
 231 ; RV32ZBS-NEXT:    bset a3, zero, a2
 232 ; RV32ZBS-NEXT:    srai a3, a3, 31
 233 ; RV32ZBS-NEXT:    binv a0, a0, a2
 234 ; RV32ZBS-NEXT:    xor a1, a3, a1
 235 ; RV32ZBS-NEXT:    ret
 236   %1 = trunc i64 %b to i32
 237   %conv = and i32 %1, 63
 238   %shl = shl nuw i32 1, %conv
 239   %conv1 = sext i32 %shl to i64
 240   %xor = xor i64 %conv1, %a
 241   ret i64 %xor
 242 }
 243
 244 define i32 @bext_i32(i32 %a, i32 %b) nounwind {
 245 ; RV32I-LABEL: bext_i32:
 246 ; RV32I:       # %bb.0:
 247 ; RV32I-NEXT:    srl a0, a0, a1
 248 ; RV32I-NEXT:    andi a0, a0, 1
 249 ; RV32I-NEXT:    ret
 250 ;
 251 ; RV32ZBS-LABEL: bext_i32:
 252 ; RV32ZBS:       # %bb.0:
 253 ; RV32ZBS-NEXT:    bext a0, a0, a1
 254 ; RV32ZBS-NEXT:    ret
 255   %and = and i32 %b, 31
 256   %shr = lshr i32 %a, %and
 257   %and1 = and i32 %shr, 1
 258   ret i32 %and1
 259 }
 260
 261 define i32 @bext_i32_no_mask(i32 %a, i32 %b) nounwind {
 262 ; RV32I-LABEL: bext_i32_no_mask:
 263 ; RV32I:       # %bb.0:
 264 ; RV32I-NEXT:    srl a0, a0, a1
 265 ; RV32I-NEXT:    andi a0, a0, 1
 266 ; RV32I-NEXT:    ret
 267 ;
 268 ; RV32ZBS-LABEL: bext_i32_no_mask:
 269 ; RV32ZBS:       # %bb.0:
 270 ; RV32ZBS-NEXT:    bext a0, a0, a1
 271 ; RV32ZBS-NEXT:    ret
 272   %shr = lshr i32 %a, %b
 273   %and1 = and i32 %shr, 1
 274   ret i32 %and1
 275 }
 276
 277 ; As we are not matching directly i64 code patterns on RV32 some i64 patterns
 278 ; don't have yet any matching bit manipulation instructions on RV32.
 279 ; This test is presented here in case future expansions of the Bitmanip
 280 ; extensions introduce instructions suitable for this pattern.
 281
 282 define i64 @bext_i64(i64 %a, i64 %b) nounwind {
 283 ; CHECK-LABEL: bext_i64:
 284 ; CHECK:       # %bb.0:
 285 ; CHECK-NEXT:    andi a3, a2, 63
 286 ; CHECK-NEXT:    addi a4, a3, -32
 287 ; CHECK-NEXT:    bltz a4, .LBB12_2
 288 ; CHECK-NEXT:  # %bb.1:
 289 ; CHECK-NEXT:    srl a0, a1, a3
 290 ; CHECK-NEXT:    j .LBB12_3
 291 ; CHECK-NEXT:  .LBB12_2:
 292 ; CHECK-NEXT:    srl a0, a0, a2
 293 ; CHECK-NEXT:    slli a1, a1, 1
 294 ; CHECK-NEXT:    not a2, a3
 295 ; CHECK-NEXT:    sll a1, a1, a2
 296 ; CHECK-NEXT:    or a0, a0, a1
 297 ; CHECK-NEXT:  .LBB12_3:
 298 ; CHECK-NEXT:    andi a0, a0, 1
 299 ; CHECK-NEXT:    li a1, 0
 300 ; CHECK-NEXT:    ret
 301   %conv = and i64 %b, 63
 302   %shr = lshr i64 %a, %conv
 303   %and1 = and i64 %shr, 1
 304   ret i64 %and1
 305 }
 306
 307 define i32 @bexti_i32(i32 %a) nounwind {
 308 ; RV32I-LABEL: bexti_i32:
 309 ; RV32I:       # %bb.0:
 310 ; RV32I-NEXT:    slli a0, a0, 26
 311 ; RV32I-NEXT:    srli a0, a0, 31
 312 ; RV32I-NEXT:    ret
 313 ;
 314 ; RV32ZBS-LABEL: bexti_i32:
 315 ; RV32ZBS:       # %bb.0:
 316 ; RV32ZBS-NEXT:    bexti a0, a0, 5
 317 ; RV32ZBS-NEXT:    ret
 318   %shr = lshr i32 %a, 5
 319   %and = and i32 %shr, 1
 320   ret i32 %and
 321 }
 322
 323 define i64 @bexti_i64(i64 %a) nounwind {
 324 ; RV32I-LABEL: bexti_i64:
 325 ; RV32I:       # %bb.0:
 326 ; RV32I-NEXT:    slli a0, a0, 26
 327 ; RV32I-NEXT:    srli a0, a0, 31
 328 ; RV32I-NEXT:    li a1, 0
 329 ; RV32I-NEXT:    ret
 330 ;
 331 ; RV32ZBS-LABEL: bexti_i64:
 332 ; RV32ZBS:       # %bb.0:
 333 ; RV32ZBS-NEXT:    bexti a0, a0, 5
 334 ; RV32ZBS-NEXT:    li a1, 0
 335 ; RV32ZBS-NEXT:    ret
 336   %shr = lshr i64 %a, 5
 337   %and = and i64 %shr, 1
 338   ret i64 %and
 339 }
 340
 341 define signext i32 @bexti_i32_cmp(i32 signext %a) nounwind {
 342 ; RV32I-LABEL: bexti_i32_cmp:
 343 ; RV32I:       # %bb.0:
 344 ; RV32I-NEXT:    slli a0, a0, 26
 345 ; RV32I-NEXT:    srli a0, a0, 31
 346 ; RV32I-NEXT:    ret
 347 ;
 348 ; RV32ZBS-LABEL: bexti_i32_cmp:
 349 ; RV32ZBS:       # %bb.0:
 350 ; RV32ZBS-NEXT:    bexti a0, a0, 5
 351 ; RV32ZBS-NEXT:    ret
 352   %and = and i32 %a, 32
 353   %cmp = icmp ne i32 %and, 0
 354   %zext = zext i1 %cmp to i32
 355   ret i32 %zext
 356 }
 357
 358 define i64 @bexti_i64_cmp(i64 %a) nounwind {
 359 ; RV32I-LABEL: bexti_i64_cmp:
 360 ; RV32I:       # %bb.0:
 361 ; RV32I-NEXT:    slli a0, a0, 26
 362 ; RV32I-NEXT:    srli a0, a0, 31
 363 ; RV32I-NEXT:    li a1, 0
 364 ; RV32I-NEXT:    ret
 365 ;
 366 ; RV32ZBS-LABEL: bexti_i64_cmp:
 367 ; RV32ZBS:       # %bb.0:
 368 ; RV32ZBS-NEXT:    bexti a0, a0, 5
 369 ; RV32ZBS-NEXT:    li a1, 0
 370 ; RV32ZBS-NEXT:    ret
 371   %and = and i64 %a, 32
 372   %cmp = icmp ne i64 %and, 0
 373   %zext = zext i1 %cmp to i64
 374   ret i64 %zext
 375 }
 376
 377 define i32 @bclri_i32_10(i32 %a) nounwind {
 378 ; CHECK-LABEL: bclri_i32_10:
 379 ; CHECK:       # %bb.0:
 380 ; CHECK-NEXT:    andi a0, a0, -1025
 381 ; CHECK-NEXT:    ret
 382   %and = and i32 %a, -1025
 383   ret i32 %and
 384 }
 385
 386 define i32 @bclri_i32_11(i32 %a) nounwind {
 387 ; RV32I-LABEL: bclri_i32_11:
 388 ; RV32I:       # %bb.0:
 389 ; RV32I-NEXT:    lui a1, 1048575
 390 ; RV32I-NEXT:    addi a1, a1, 2047
 391 ; RV32I-NEXT:    and a0, a0, a1
 392 ; RV32I-NEXT:    ret
 393 ;
 394 ; RV32ZBS-LABEL: bclri_i32_11:
 395 ; RV32ZBS:       # %bb.0:
 396 ; RV32ZBS-NEXT:    bclri a0, a0, 11
 397 ; RV32ZBS-NEXT:    ret
 398   %and = and i32 %a, -2049
 399   ret i32 %and
 400 }
 401
 402 define i32 @bclri_i32_30(i32 %a) nounwind {
 403 ; RV32I-LABEL: bclri_i32_30:
 404 ; RV32I:       # %bb.0:
 405 ; RV32I-NEXT:    lui a1, 786432
 406 ; RV32I-NEXT:    addi a1, a1, -1
 407 ; RV32I-NEXT:    and a0, a0, a1
 408 ; RV32I-NEXT:    ret
 409 ;
 410 ; RV32ZBS-LABEL: bclri_i32_30:
 411 ; RV32ZBS:       # %bb.0:
 412 ; RV32ZBS-NEXT:    bclri a0, a0, 30
 413 ; RV32ZBS-NEXT:    ret
 414   %and = and i32 %a, -1073741825
 415   ret i32 %and
 416 }
 417
 418 define i32 @bclri_i32_31(i32 %a) nounwind {
 419 ; RV32I-LABEL: bclri_i32_31:
 420 ; RV32I:       # %bb.0:
 421 ; RV32I-NEXT:    slli a0, a0, 1
 422 ; RV32I-NEXT:    srli a0, a0, 1
 423 ; RV32I-NEXT:    ret
 424 ;
 425 ; RV32ZBS-LABEL: bclri_i32_31:
 426 ; RV32ZBS:       # %bb.0:
 427 ; RV32ZBS-NEXT:    bclri a0, a0, 31
 428 ; RV32ZBS-NEXT:    ret
 429   %and = and i32 %a, -2147483649
 430   ret i32 %and
 431 }
 432
 433 define i32 @bclri_i32_large0(i32 %a) nounwind {
 434 ; RV32I-LABEL: bclri_i32_large0:
 435 ; RV32I:       # %bb.0:
 436 ; RV32I-NEXT:    lui a1, 1044480
 437 ; RV32I-NEXT:    addi a1, a1, -256
 438 ; RV32I-NEXT:    and a0, a0, a1
 439 ; RV32I-NEXT:    ret
 440 ;
 441 ; RV32ZBS-LABEL: bclri_i32_large0:
 442 ; RV32ZBS:       # %bb.0:
 443 ; RV32ZBS-NEXT:    andi a0, a0, -256
 444 ; RV32ZBS-NEXT:    bclri a0, a0, 24
 445 ; RV32ZBS-NEXT:    ret
 446   %and = and i32 %a, -16777472
 447   ret i32 %and
 448 }
 449
 450 define i32 @bclri_i32_large1(i32 %a) nounwind {
 451 ; RV32I-LABEL: bclri_i32_large1:
 452 ; RV32I:       # %bb.0:
 453 ; RV32I-NEXT:    lui a1, 1044464
 454 ; RV32I-NEXT:    addi a1, a1, -1
 455 ; RV32I-NEXT:    and a0, a0, a1
 456 ; RV32I-NEXT:    ret
 457 ;
 458 ; RV32ZBS-LABEL: bclri_i32_large1:
 459 ; RV32ZBS:       # %bb.0:
 460 ; RV32ZBS-NEXT:    bclri a0, a0, 16
 461 ; RV32ZBS-NEXT:    bclri a0, a0, 24
 462 ; RV32ZBS-NEXT:    ret
 463   %and = and i32 %a, -16842753
 464   ret i32 %and
 465 }
 466
 467 define i32 @bclri_i32_large2(i32 %0) {
 468 ; RV32I-LABEL: bclri_i32_large2:
 469 ; RV32I:       # %bb.0:
 470 ; RV32I-NEXT:    lui a1, 524288
 471 ; RV32I-NEXT:    addi a1, a1, -5
 472 ; RV32I-NEXT:    and a0, a0, a1
 473 ; RV32I-NEXT:    ret
 474 ;
 475 ; RV32ZBS-LABEL: bclri_i32_large2:
 476 ; RV32ZBS:       # %bb.0:
 477 ; RV32ZBS-NEXT:    bclri a0, a0, 2
 478 ; RV32ZBS-NEXT:    bclri a0, a0, 31
 479 ; RV32ZBS-NEXT:    ret
 480   %2 = and i32 %0, 2147483643
 481   ret i32 %2
 482 }
 483
 484 define i32 @bclri_i32_large3(i32 %0) {
 485 ; RV32I-LABEL: bclri_i32_large3:
 486 ; RV32I:       # %bb.0:
 487 ; RV32I-NEXT:    lui a1, 524288
 488 ; RV32I-NEXT:    addi a1, a1, -6
 489 ; RV32I-NEXT:    and a0, a0, a1
 490 ; RV32I-NEXT:    ret
 491 ;
 492 ; RV32ZBS-LABEL: bclri_i32_large3:
 493 ; RV32ZBS:       # %bb.0:
 494 ; RV32ZBS-NEXT:    andi a0, a0, -6
 495 ; RV32ZBS-NEXT:    bclri a0, a0, 31
 496 ; RV32ZBS-NEXT:    ret
 497   %2 = and i32 %0, 2147483642
 498   ret i32 %2
 499 }
 500
 501 define i32 @bseti_i32_10(i32 %a) nounwind {
 502 ; CHECK-LABEL: bseti_i32_10:
 503 ; CHECK:       # %bb.0:
 504 ; CHECK-NEXT:    ori a0, a0, 1024
 505 ; CHECK-NEXT:    ret
 506   %or = or i32 %a, 1024
 507   ret i32 %or
 508 }
 509
 510 define i32 @bseti_i32_11(i32 %a) nounwind {
 511 ; RV32I-LABEL: bseti_i32_11:
 512 ; RV32I:       # %bb.0:
 513 ; RV32I-NEXT:    li a1, 1
 514 ; RV32I-NEXT:    slli a1, a1, 11
 515 ; RV32I-NEXT:    or a0, a0, a1
 516 ; RV32I-NEXT:    ret
 517 ;
 518 ; RV32ZBS-LABEL: bseti_i32_11:
 519 ; RV32ZBS:       # %bb.0:
 520 ; RV32ZBS-NEXT:    bseti a0, a0, 11
 521 ; RV32ZBS-NEXT:    ret
 522   %or = or i32 %a, 2048
 523   ret i32 %or
 524 }
 525
 526 define i32 @bseti_i32_30(i32 %a) nounwind {
 527 ; RV32I-LABEL: bseti_i32_30:
 528 ; RV32I:       # %bb.0:
 529 ; RV32I-NEXT:    lui a1, 262144
 530 ; RV32I-NEXT:    or a0, a0, a1
 531 ; RV32I-NEXT:    ret
 532 ;
 533 ; RV32ZBS-LABEL: bseti_i32_30:
 534 ; RV32ZBS:       # %bb.0:
 535 ; RV32ZBS-NEXT:    bseti a0, a0, 30
 536 ; RV32ZBS-NEXT:    ret
 537   %or = or i32 %a, 1073741824
 538   ret i32 %or
 539 }
 540
 541 define i32 @bseti_i32_31(i32 %a) nounwind {
 542 ; RV32I-LABEL: bseti_i32_31:
 543 ; RV32I:       # %bb.0:
 544 ; RV32I-NEXT:    lui a1, 524288
 545 ; RV32I-NEXT:    or a0, a0, a1
 546 ; RV32I-NEXT:    ret
 547 ;
 548 ; RV32ZBS-LABEL: bseti_i32_31:
 549 ; RV32ZBS:       # %bb.0:
 550 ; RV32ZBS-NEXT:    bseti a0, a0, 31
 551 ; RV32ZBS-NEXT:    ret
 552   %or = or i32 %a, 2147483648
 553   ret i32 %or
 554 }
 555
 556 define i32 @binvi_i32_10(i32 %a) nounwind {
 557 ; CHECK-LABEL: binvi_i32_10:
 558 ; CHECK:       # %bb.0:
 559 ; CHECK-NEXT:    xori a0, a0, 1024
 560 ; CHECK-NEXT:    ret
 561   %xor = xor i32 %a, 1024
 562   ret i32 %xor
 563 }
 564
 565 define i32 @binvi_i32_11(i32 %a) nounwind {
 566 ; RV32I-LABEL: binvi_i32_11:
 567 ; RV32I:       # %bb.0:
 568 ; RV32I-NEXT:    li a1, 1
 569 ; RV32I-NEXT:    slli a1, a1, 11
 570 ; RV32I-NEXT:    xor a0, a0, a1
 571 ; RV32I-NEXT:    ret
 572 ;
 573 ; RV32ZBS-LABEL: binvi_i32_11:
 574 ; RV32ZBS:       # %bb.0:
 575 ; RV32ZBS-NEXT:    binvi a0, a0, 11
 576 ; RV32ZBS-NEXT:    ret
 577   %xor = xor i32 %a, 2048
 578   ret i32 %xor
 579 }
 580
 581 define i32 @binvi_i32_30(i32 %a) nounwind {
 582 ; RV32I-LABEL: binvi_i32_30:
 583 ; RV32I:       # %bb.0:
 584 ; RV32I-NEXT:    lui a1, 262144
 585 ; RV32I-NEXT:    xor a0, a0, a1
 586 ; RV32I-NEXT:    ret
 587 ;
 588 ; RV32ZBS-LABEL: binvi_i32_30:
 589 ; RV32ZBS:       # %bb.0:
 590 ; RV32ZBS-NEXT:    binvi a0, a0, 30
 591 ; RV32ZBS-NEXT:    ret
 592   %xor = xor i32 %a, 1073741824
 593   ret i32 %xor
 594 }
 595
 596 define i32 @binvi_i32_31(i32 %a) nounwind {
 597 ; RV32I-LABEL: binvi_i32_31:
 598 ; RV32I:       # %bb.0:
 599 ; RV32I-NEXT:    lui a1, 524288
 600 ; RV32I-NEXT:    xor a0, a0, a1
 601 ; RV32I-NEXT:    ret
 602 ;
 603 ; RV32ZBS-LABEL: binvi_i32_31:
 604 ; RV32ZBS:       # %bb.0:
 605 ; RV32ZBS-NEXT:    binvi a0, a0, 31
 606 ; RV32ZBS-NEXT:    ret
 607   %xor = xor i32 %a, 2147483648
 608   ret i32 %xor
 609 }
 610
 611 define i32 @xor_i32_4098(i32 %a) nounwind {
 612 ; RV32I-LABEL: xor_i32_4098:
 613 ; RV32I:       # %bb.0:
 614 ; RV32I-NEXT:    lui a1, 1
 615 ; RV32I-NEXT:    addi a1, a1, 2
 616 ; RV32I-NEXT:    xor a0, a0, a1
 617 ; RV32I-NEXT:    ret
 618 ;
 619 ; RV32ZBS-LABEL: xor_i32_4098:
 620 ; RV32ZBS:       # %bb.0:
 621 ; RV32ZBS-NEXT:    binvi a0, a0, 1
 622 ; RV32ZBS-NEXT:    binvi a0, a0, 12
 623 ; RV32ZBS-NEXT:    ret
 624   %xor = xor i32 %a, 4098
 625   ret i32 %xor
 626 }
 627
 628 define i32 @xor_i32_4099(i32 %a) nounwind {
 629 ; RV32I-LABEL: xor_i32_4099:
 630 ; RV32I:       # %bb.0:
 631 ; RV32I-NEXT:    lui a1, 1
 632 ; RV32I-NEXT:    addi a1, a1, 3
 633 ; RV32I-NEXT:    xor a0, a0, a1
 634 ; RV32I-NEXT:    ret
 635 ;
 636 ; RV32ZBS-LABEL: xor_i32_4099:
 637 ; RV32ZBS:       # %bb.0:
 638 ; RV32ZBS-NEXT:    xori a0, a0, 3
 639 ; RV32ZBS-NEXT:    binvi a0, a0, 12
 640 ; RV32ZBS-NEXT:    ret
 641   %xor = xor i32 %a, 4099
 642   ret i32 %xor
 643 }
 644
 645 define i32 @xor_i32_96(i32 %a) nounwind {
 646 ; CHECK-LABEL: xor_i32_96:
 647 ; CHECK:       # %bb.0:
 648 ; CHECK-NEXT:    xori a0, a0, 96
 649 ; CHECK-NEXT:    ret
 650   %xor = xor i32 %a, 96
 651   ret i32 %xor
 652 }
 653
 654 define i32 @xor_i32_66901(i32 %a) nounwind {
 655 ; RV32I-LABEL: xor_i32_66901:
 656 ; RV32I:       # %bb.0:
 657 ; RV32I-NEXT:    lui a1, 16
 658 ; RV32I-NEXT:    addi a1, a1, 1365
 659 ; RV32I-NEXT:    xor a0, a0, a1
 660 ; RV32I-NEXT:    ret
 661 ;
 662 ; RV32ZBS-LABEL: xor_i32_66901:
 663 ; RV32ZBS:       # %bb.0:
 664 ; RV32ZBS-NEXT:    xori a0, a0, 1365
 665 ; RV32ZBS-NEXT:    binvi a0, a0, 16
 666 ; RV32ZBS-NEXT:    ret
 667   %xor = xor i32 %a, 66901
 668   ret i32 %xor
 669 }
 670
 671 define i32 @or_i32_4098(i32 %a) nounwind {
 672 ; RV32I-LABEL: or_i32_4098:
 673 ; RV32I:       # %bb.0:
 674 ; RV32I-NEXT:    lui a1, 1
 675 ; RV32I-NEXT:    addi a1, a1, 2
 676 ; RV32I-NEXT:    or a0, a0, a1
 677 ; RV32I-NEXT:    ret
 678 ;
 679 ; RV32ZBS-LABEL: or_i32_4098:
 680 ; RV32ZBS:       # %bb.0:
 681 ; RV32ZBS-NEXT:    bseti a0, a0, 1
 682 ; RV32ZBS-NEXT:    bseti a0, a0, 12
 683 ; RV32ZBS-NEXT:    ret
 684   %or = or i32 %a, 4098
 685   ret i32 %or
 686 }
 687
 688 define i32 @or_i32_4099(i32 %a) nounwind {
 689 ; RV32I-LABEL: or_i32_4099:
 690 ; RV32I:       # %bb.0:
 691 ; RV32I-NEXT:    lui a1, 1
 692 ; RV32I-NEXT:    addi a1, a1, 3
 693 ; RV32I-NEXT:    or a0, a0, a1
 694 ; RV32I-NEXT:    ret
 695 ;
 696 ; RV32ZBS-LABEL: or_i32_4099:
 697 ; RV32ZBS:       # %bb.0:
 698 ; RV32ZBS-NEXT:    ori a0, a0, 3
 699 ; RV32ZBS-NEXT:    bseti a0, a0, 12
 700 ; RV32ZBS-NEXT:    ret
 701   %or = or i32 %a, 4099
 702   ret i32 %or
 703 }
 704
 705 define i32 @or_i32_96(i32 %a) nounwind {
 706 ; CHECK-LABEL: or_i32_96:
 707 ; CHECK:       # %bb.0:
 708 ; CHECK-NEXT:    ori a0, a0, 96
 709 ; CHECK-NEXT:    ret
 710   %or = or i32 %a, 96
 711   ret i32 %or
 712 }
 713
 714 define i32 @or_i32_66901(i32 %a) nounwind {
 715 ; RV32I-LABEL: or_i32_66901:
 716 ; RV32I:       # %bb.0:
 717 ; RV32I-NEXT:    lui a1, 16
 718 ; RV32I-NEXT:    addi a1, a1, 1365
 719 ; RV32I-NEXT:    or a0, a0, a1
 720 ; RV32I-NEXT:    ret
 721 ;
 722 ; RV32ZBS-LABEL: or_i32_66901:
 723 ; RV32ZBS:       # %bb.0:
 724 ; RV32ZBS-NEXT:    ori a0, a0, 1365
 725 ; RV32ZBS-NEXT:    bseti a0, a0, 16
 726 ; RV32ZBS-NEXT:    ret
 727   %or = or i32 %a, 66901
 728   ret i32 %or
 729 }