1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt < %s -passes=instsimplify -S | FileCheck %s 3 4; TODO: the instructions with poison operands should return poison 5 6declare i81 @llvm.smax.i81(i81, i81) 7declare i8 @llvm.smax.i8(i8, i8) 8declare <2 x i8> @llvm.smax.v2i8(<2 x i8>, <2 x i8>) 9declare i3 @llvm.smin.i3(i3, i3) 10declare i8 @llvm.smin.i8(i8, i8) 11declare <2 x i8> @llvm.smin.v2i8(<2 x i8>, <2 x i8>) 12declare i8 @llvm.umax.i8(i8, i8) 13declare <2 x i8> @llvm.umax.v2i8(<2 x i8>, <2 x i8>) 14declare i8 @llvm.umin.i8(i8, i8) 15declare <2 x i8> @llvm.umin.v2i8(<2 x i8>, <2 x i8>) 16declare void @llvm.assume(i1) 17 18@g = external dso_local global [9 x i32], align 4 19 20define i8 @constexpr_maxvalue() { 21; CHECK-LABEL: @constexpr_maxvalue( 22; CHECK-NEXT: ret i8 ptrtoint (ptr @g to i8) 23; 24 %umin = call i8 @llvm.umin.i8(i8 255, i8 ptrtoint (ptr @g to i8)) 25 ret i8 %umin 26} 27 28define i8 @constexpr_maxvalue_commute() { 29; CHECK-LABEL: @constexpr_maxvalue_commute( 30; CHECK-NEXT: ret i8 ptrtoint (ptr @g to i8) 31; 32 %umin = call i8 @llvm.umin.i8(i8 ptrtoint (ptr @g to i8), i8 255) 33 ret i8 %umin 34} 35 36define i81 @smax_sameval(i81 %x) { 37; CHECK-LABEL: @smax_sameval( 38; CHECK-NEXT: ret i81 [[X:%.*]] 39; 40 %r = call i81 @llvm.smax.i81(i81 %x, i81 %x) 41 ret i81 %r 42} 43 44define i3 @smin_sameval(i3 %x) { 45; CHECK-LABEL: @smin_sameval( 46; CHECK-NEXT: ret i3 [[X:%.*]] 47; 48 %r = call i3 @llvm.smin.i3(i3 %x, i3 %x) 49 ret i3 %r 50} 51 52define <2 x i8> @umax_sameval(<2 x i8> %x) { 53; CHECK-LABEL: @umax_sameval( 54; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 55; 56 %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %x, <2 x i8> %x) 57 ret <2 x i8> %r 58} 59 60define <2 x i8> @umin_sameval(<2 x i8> %x) { 61; CHECK-LABEL: @umin_sameval( 62; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 63; 64 %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> %x) 65 ret <2 x i8> %r 66} 67 68define i81 @smax_undef(i81 %x) { 69; CHECK-LABEL: @smax_undef( 70; CHECK-NEXT: ret i81 1208925819614629174706175 71; 72 %r = call i81 @llvm.smax.i81(i81 undef, i81 %x) 73 ret i81 %r 74} 75 76define i81 @smax_poison(i81 %x) { 77; CHECK-LABEL: @smax_poison( 78; CHECK-NEXT: ret i81 1208925819614629174706175 79; 80 %r = call i81 @llvm.smax.i81(i81 poison, i81 %x) 81 ret i81 %r 82} 83 84define i3 @smin_undef(i3 %x) { 85; CHECK-LABEL: @smin_undef( 86; CHECK-NEXT: ret i3 -4 87; 88 %r = call i3 @llvm.smin.i3(i3 %x, i3 undef) 89 ret i3 %r 90} 91 92define i3 @smin_poison(i3 %x) { 93; CHECK-LABEL: @smin_poison( 94; CHECK-NEXT: ret i3 -4 95; 96 %r = call i3 @llvm.smin.i3(i3 %x, i3 poison) 97 ret i3 %r 98} 99 100define <2 x i8> @umax_undef(<2 x i8> %x) { 101; CHECK-LABEL: @umax_undef( 102; CHECK-NEXT: ret <2 x i8> splat (i8 -1) 103; 104 %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> undef, <2 x i8> %x) 105 ret <2 x i8> %r 106} 107 108define <2 x i8> @umax_poison(<2 x i8> %x) { 109; CHECK-LABEL: @umax_poison( 110; CHECK-NEXT: ret <2 x i8> splat (i8 -1) 111; 112 %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> poison, <2 x i8> %x) 113 ret <2 x i8> %r 114} 115 116define <2 x i8> @umin_undef(<2 x i8> %x) { 117; CHECK-LABEL: @umin_undef( 118; CHECK-NEXT: ret <2 x i8> zeroinitializer 119; 120 %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> undef) 121 ret <2 x i8> %r 122} 123 124define <2 x i8> @umin_poison(<2 x i8> %x) { 125; CHECK-LABEL: @umin_poison( 126; CHECK-NEXT: ret <2 x i8> zeroinitializer 127; 128 %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> poison) 129 ret <2 x i8> %r 130} 131 132define i8 @smax_maxval(i8 %x) { 133; CHECK-LABEL: @smax_maxval( 134; CHECK-NEXT: ret i8 127 135; 136 %r = call i8 @llvm.smax.i8(i8 %x, i8 127) 137 ret i8 %r 138} 139 140define <2 x i8> @smax_maxval_commute(<2 x i8> %x) { 141; CHECK-LABEL: @smax_maxval_commute( 142; CHECK-NEXT: ret <2 x i8> splat (i8 127) 143; 144 %r = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 127, i8 127>, <2 x i8> %x) 145 ret <2 x i8> %r 146} 147 148define i8 @smin_minval(i8 %x) { 149; CHECK-LABEL: @smin_minval( 150; CHECK-NEXT: ret i8 -128 151; 152 %r = call i8 @llvm.smin.i8(i8 -128, i8 %x) 153 ret i8 %r 154} 155 156define <2 x i8> @smin_minval_commute(<2 x i8> %x) { 157; CHECK-LABEL: @smin_minval_commute( 158; CHECK-NEXT: ret <2 x i8> splat (i8 -128) 159; 160 %r = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 -128, i8 -128>) 161 ret <2 x i8> %r 162} 163 164define i8 @umax_maxval(i8 %x) { 165; CHECK-LABEL: @umax_maxval( 166; CHECK-NEXT: ret i8 -1 167; 168 %r = call i8 @llvm.umax.i8(i8 %x, i8 255) 169 ret i8 %r 170} 171 172define <2 x i8> @umax_maxval_commute(<2 x i8> %x) { 173; CHECK-LABEL: @umax_maxval_commute( 174; CHECK-NEXT: ret <2 x i8> splat (i8 -1) 175; 176 %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 255, i8 255>, <2 x i8> %x) 177 ret <2 x i8> %r 178} 179 180define i8 @umin_minval(i8 %x) { 181; CHECK-LABEL: @umin_minval( 182; CHECK-NEXT: ret i8 0 183; 184 %r = call i8 @llvm.umin.i8(i8 0, i8 %x) 185 ret i8 %r 186} 187 188define <2 x i8> @umin_minval_commute(<2 x i8> %x) { 189; CHECK-LABEL: @umin_minval_commute( 190; CHECK-NEXT: ret <2 x i8> zeroinitializer 191; 192 %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> zeroinitializer) 193 ret <2 x i8> %r 194} 195 196define i8 @smax_minval(i8 %x) { 197; CHECK-LABEL: @smax_minval( 198; CHECK-NEXT: ret i8 [[X:%.*]] 199; 200 %r = call i8 @llvm.smax.i8(i8 %x, i8 -128) 201 ret i8 %r 202} 203 204define <2 x i8> @smax_minval_commute(<2 x i8> %x) { 205; CHECK-LABEL: @smax_minval_commute( 206; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 207; 208 %r = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 -128, i8 -128>, <2 x i8> %x) 209 ret <2 x i8> %r 210} 211 212define i8 @smin_maxval(i8 %x) { 213; CHECK-LABEL: @smin_maxval( 214; CHECK-NEXT: ret i8 [[X:%.*]] 215; 216 %r = call i8 @llvm.smin.i8(i8 127, i8 %x) 217 ret i8 %r 218} 219 220define <2 x i8> @smin_maxval_commute(<2 x i8> %x) { 221; CHECK-LABEL: @smin_maxval_commute( 222; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 223; 224 %r = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 127, i8 127>) 225 ret <2 x i8> %r 226} 227 228define i8 @umax_minval(i8 %x) { 229; CHECK-LABEL: @umax_minval( 230; CHECK-NEXT: ret i8 [[X:%.*]] 231; 232 %r = call i8 @llvm.umax.i8(i8 %x, i8 0) 233 ret i8 %r 234} 235 236define <2 x i8> @umax_minval_commute(<2 x i8> %x) { 237; CHECK-LABEL: @umax_minval_commute( 238; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 239; 240 %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> zeroinitializer, <2 x i8> %x) 241 ret <2 x i8> %r 242} 243 244define i8 @umin_maxval(i8 %x) { 245; CHECK-LABEL: @umin_maxval( 246; CHECK-NEXT: ret i8 [[X:%.*]] 247; 248 %r = call i8 @llvm.umin.i8(i8 255, i8 %x) 249 ret i8 %r 250} 251 252define <2 x i8> @umin_maxval_commute(<2 x i8> %x) { 253; CHECK-LABEL: @umin_maxval_commute( 254; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 255; 256 %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 255, i8 255>) 257 ret <2 x i8> %r 258} 259 260define <2 x i8> @smax_maxval_partial_poison(<2 x i8> %x) { 261; CHECK-LABEL: @smax_maxval_partial_poison( 262; CHECK-NEXT: ret <2 x i8> splat (i8 127) 263; 264 %r = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 poison, i8 127>, <2 x i8> %x) 265 ret <2 x i8> %r 266} 267 268define <2 x i8> @smin_minval_partial_poison(<2 x i8> %x) { 269; CHECK-LABEL: @smin_minval_partial_poison( 270; CHECK-NEXT: ret <2 x i8> splat (i8 -128) 271; 272 %r = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 -128, i8 poison>) 273 ret <2 x i8> %r 274} 275 276define <2 x i8> @umax_maxval_partial_poison(<2 x i8> %x) { 277; CHECK-LABEL: @umax_maxval_partial_poison( 278; CHECK-NEXT: ret <2 x i8> splat (i8 -1) 279; 280 %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 255, i8 poison>, <2 x i8> %x) 281 ret <2 x i8> %r 282} 283 284define <2 x i8> @umin_minval_partial_poison(<2 x i8> %x) { 285; CHECK-LABEL: @umin_minval_partial_poison( 286; CHECK-NEXT: ret <2 x i8> zeroinitializer 287; 288 %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 poison, i8 0>) 289 ret <2 x i8> %r 290} 291 292define <2 x i8> @smax_minval_partial_poison(<2 x i8> %x) { 293; CHECK-LABEL: @smax_minval_partial_poison( 294; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 295; 296 %r = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 poison, i8 -128>, <2 x i8> %x) 297 ret <2 x i8> %r 298} 299 300define <2 x i8> @smin_maxval_partial_poison(<2 x i8> %x) { 301; CHECK-LABEL: @smin_maxval_partial_poison( 302; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 303; 304 %r = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 poison, i8 127>) 305 ret <2 x i8> %r 306} 307 308define <2 x i8> @umax_minval_partial_poison(<2 x i8> %x) { 309; CHECK-LABEL: @umax_minval_partial_poison( 310; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 311; 312 %r = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 0, i8 poison>, <2 x i8> %x) 313 ret <2 x i8> %r 314} 315 316define <2 x i8> @umin_maxval_partial_poison(<2 x i8> %x) { 317; CHECK-LABEL: @umin_maxval_partial_poison( 318; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 319; 320 %r = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 255, i8 poison>) 321 ret <2 x i8> %r 322} 323 324define i8 @umax_umax(i8 %x, i8 %y) { 325; CHECK-LABEL: @umax_umax( 326; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 327; CHECK-NEXT: ret i8 [[M]] 328; 329 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 330 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %m) 331 ret i8 %m2 332} 333 334define i8 @umax_umax_commute1(i8 %x, i8 %y) { 335; CHECK-LABEL: @umax_umax_commute1( 336; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 337; CHECK-NEXT: ret i8 [[M]] 338; 339 %m = call i8 @llvm.umax.i8(i8 %y, i8 %x) 340 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %m) 341 ret i8 %m2 342} 343 344define i8 @umax_umax_commute2(i8 %x, i8 %y) { 345; CHECK-LABEL: @umax_umax_commute2( 346; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 347; CHECK-NEXT: ret i8 [[M]] 348; 349 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 350 %m2 = call i8 @llvm.umax.i8(i8 %m, i8 %x) 351 ret i8 %m2 352} 353 354define <2 x i8> @umax_umax_commute3(<2 x i8> %x, <2 x i8> %y) { 355; CHECK-LABEL: @umax_umax_commute3( 356; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.umax.v2i8(<2 x i8> [[Y:%.*]], <2 x i8> [[X:%.*]]) 357; CHECK-NEXT: ret <2 x i8> [[M]] 358; 359 %m = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %y, <2 x i8> %x) 360 %m2 = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %m, <2 x i8> %x) 361 ret <2 x i8> %m2 362} 363 364define i8 @umin_umin(i8 %x, i8 %y) { 365; CHECK-LABEL: @umin_umin( 366; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 367; CHECK-NEXT: ret i8 [[M]] 368; 369 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 370 %m2 = call i8 @llvm.umin.i8(i8 %x, i8 %m) 371 ret i8 %m2 372} 373 374define i8 @umin_umin_commute1(i8 %x, i8 %y) { 375; CHECK-LABEL: @umin_umin_commute1( 376; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 377; CHECK-NEXT: ret i8 [[M]] 378; 379 %m = call i8 @llvm.umin.i8(i8 %y, i8 %x) 380 %m2 = call i8 @llvm.umin.i8(i8 %x, i8 %m) 381 ret i8 %m2 382} 383 384define <2 x i8> @umin_umin_commute2(<2 x i8> %x, <2 x i8> %y) { 385; CHECK-LABEL: @umin_umin_commute2( 386; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) 387; CHECK-NEXT: ret <2 x i8> [[M]] 388; 389 %m = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> %y) 390 %m2 = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %m, <2 x i8> %x) 391 ret <2 x i8> %m2 392} 393 394define i8 @umin_umin_commute3(i8 %x, i8 %y) { 395; CHECK-LABEL: @umin_umin_commute3( 396; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 397; CHECK-NEXT: ret i8 [[M]] 398; 399 %m = call i8 @llvm.umin.i8(i8 %y, i8 %x) 400 %m2 = call i8 @llvm.umin.i8(i8 %m, i8 %x) 401 ret i8 %m2 402} 403 404define i8 @smax_smax(i8 %x, i8 %y) { 405; CHECK-LABEL: @smax_smax( 406; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 407; CHECK-NEXT: ret i8 [[M]] 408; 409 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 410 %m2 = call i8 @llvm.smax.i8(i8 %x, i8 %m) 411 ret i8 %m2 412} 413 414define <2 x i8> @smax_smax_commute1(<2 x i8> %x, <2 x i8> %y) { 415; CHECK-LABEL: @smax_smax_commute1( 416; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> [[Y:%.*]], <2 x i8> [[X:%.*]]) 417; CHECK-NEXT: ret <2 x i8> [[M]] 418; 419 %m = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %y, <2 x i8> %x) 420 %m2 = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %x, <2 x i8> %m) 421 ret <2 x i8> %m2 422} 423 424define i8 @smax_smax_commute2(i8 %x, i8 %y) { 425; CHECK-LABEL: @smax_smax_commute2( 426; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 427; CHECK-NEXT: ret i8 [[M]] 428; 429 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 430 %m2 = call i8 @llvm.smax.i8(i8 %m, i8 %x) 431 ret i8 %m2 432} 433 434define i8 @smax_smax_commute3(i8 %x, i8 %y) { 435; CHECK-LABEL: @smax_smax_commute3( 436; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 437; CHECK-NEXT: ret i8 [[M]] 438; 439 %m = call i8 @llvm.smax.i8(i8 %y, i8 %x) 440 %m2 = call i8 @llvm.smax.i8(i8 %m, i8 %x) 441 ret i8 %m2 442} 443 444define <2 x i8> @smin_smin(<2 x i8> %x, <2 x i8> %y) { 445; CHECK-LABEL: @smin_smin( 446; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.smin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> [[Y:%.*]]) 447; CHECK-NEXT: ret <2 x i8> [[M]] 448; 449 %m = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> %y) 450 %m2 = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> %m) 451 ret <2 x i8> %m2 452} 453 454define i8 @smin_smin_commute1(i8 %x, i8 %y) { 455; CHECK-LABEL: @smin_smin_commute1( 456; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 457; CHECK-NEXT: ret i8 [[M]] 458; 459 %m = call i8 @llvm.smin.i8(i8 %y, i8 %x) 460 %m2 = call i8 @llvm.smin.i8(i8 %x, i8 %m) 461 ret i8 %m2 462} 463 464define i8 @smin_smin_commute2(i8 %x, i8 %y) { 465; CHECK-LABEL: @smin_smin_commute2( 466; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 467; CHECK-NEXT: ret i8 [[M]] 468; 469 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 470 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 %x) 471 ret i8 %m2 472} 473 474define i8 @smin_smin_commute3(i8 %x, i8 %y) { 475; CHECK-LABEL: @smin_smin_commute3( 476; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 477; CHECK-NEXT: ret i8 [[M]] 478; 479 %m = call i8 @llvm.smin.i8(i8 %y, i8 %x) 480 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 %x) 481 ret i8 %m2 482} 483 484define i8 @umax_umin(i8 %x, i8 %y) { 485; CHECK-LABEL: @umax_umin( 486; CHECK-NEXT: ret i8 [[X:%.*]] 487; 488 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 489 %m2 = call i8 @llvm.umin.i8(i8 %x, i8 %m) 490 ret i8 %m2 491} 492 493define i8 @umax_umin_commute1(i8 %x, i8 %y) { 494; CHECK-LABEL: @umax_umin_commute1( 495; CHECK-NEXT: ret i8 [[X:%.*]] 496; 497 %m = call i8 @llvm.umax.i8(i8 %y, i8 %x) 498 %m2 = call i8 @llvm.umin.i8(i8 %x, i8 %m) 499 ret i8 %m2 500} 501 502define i8 @umax_umin_commute2(i8 %x, i8 %y) { 503; CHECK-LABEL: @umax_umin_commute2( 504; CHECK-NEXT: ret i8 [[X:%.*]] 505; 506 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 507 %m2 = call i8 @llvm.umin.i8(i8 %m, i8 %x) 508 ret i8 %m2 509} 510 511define <2 x i8> @umax_umin_commute3(<2 x i8> %x, <2 x i8> %y) { 512; CHECK-LABEL: @umax_umin_commute3( 513; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 514; 515 %m = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %y, <2 x i8> %x) 516 %m2 = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %m, <2 x i8> %x) 517 ret <2 x i8> %m2 518} 519 520define i8 @umin_umax(i8 %x, i8 %y) { 521; CHECK-LABEL: @umin_umax( 522; CHECK-NEXT: ret i8 [[X:%.*]] 523; 524 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 525 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %m) 526 ret i8 %m2 527} 528 529define i8 @umin_umax_commute1(i8 %x, i8 %y) { 530; CHECK-LABEL: @umin_umax_commute1( 531; CHECK-NEXT: ret i8 [[X:%.*]] 532; 533 %m = call i8 @llvm.umin.i8(i8 %y, i8 %x) 534 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %m) 535 ret i8 %m2 536} 537 538define <2 x i8> @umin_umax_commute2(<2 x i8> %x, <2 x i8> %y) { 539; CHECK-LABEL: @umin_umax_commute2( 540; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 541; 542 %m = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> %y) 543 %m2 = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %m, <2 x i8> %x) 544 ret <2 x i8> %m2 545} 546 547define i8 @umin_umax_commute3(i8 %x, i8 %y) { 548; CHECK-LABEL: @umin_umax_commute3( 549; CHECK-NEXT: ret i8 [[X:%.*]] 550; 551 %m = call i8 @llvm.umin.i8(i8 %y, i8 %x) 552 %m2 = call i8 @llvm.umax.i8(i8 %m, i8 %x) 553 ret i8 %m2 554} 555 556define i8 @smax_smin(i8 %x, i8 %y) { 557; CHECK-LABEL: @smax_smin( 558; CHECK-NEXT: ret i8 [[X:%.*]] 559; 560 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 561 %m2 = call i8 @llvm.smin.i8(i8 %x, i8 %m) 562 ret i8 %m2 563} 564 565define <2 x i8> @smax_smin_commute1(<2 x i8> %x, <2 x i8> %y) { 566; CHECK-LABEL: @smax_smin_commute1( 567; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 568; 569 %m = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %y, <2 x i8> %x) 570 %m2 = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> %m) 571 ret <2 x i8> %m2 572} 573 574define i8 @smax_smin_commute2(i8 %x, i8 %y) { 575; CHECK-LABEL: @smax_smin_commute2( 576; CHECK-NEXT: ret i8 [[X:%.*]] 577; 578 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 579 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 %x) 580 ret i8 %m2 581} 582 583define i8 @smax_smin_commute3(i8 %x, i8 %y) { 584; CHECK-LABEL: @smax_smin_commute3( 585; CHECK-NEXT: ret i8 [[X:%.*]] 586; 587 %m = call i8 @llvm.smax.i8(i8 %y, i8 %x) 588 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 %x) 589 ret i8 %m2 590} 591 592define <2 x i8> @smin_smax(<2 x i8> %x, <2 x i8> %y) { 593; CHECK-LABEL: @smin_smax( 594; CHECK-NEXT: ret <2 x i8> [[X:%.*]] 595; 596 %m = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> %y) 597 %m2 = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %x, <2 x i8> %m) 598 ret <2 x i8> %m2 599} 600 601define i8 @smin_smax_commute1(i8 %x, i8 %y) { 602; CHECK-LABEL: @smin_smax_commute1( 603; CHECK-NEXT: ret i8 [[X:%.*]] 604; 605 %m = call i8 @llvm.smin.i8(i8 %y, i8 %x) 606 %m2 = call i8 @llvm.smax.i8(i8 %x, i8 %m) 607 ret i8 %m2 608} 609 610define i8 @smin_smax_commute2(i8 %x, i8 %y) { 611; CHECK-LABEL: @smin_smax_commute2( 612; CHECK-NEXT: ret i8 [[X:%.*]] 613; 614 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 615 %m2 = call i8 @llvm.smax.i8(i8 %m, i8 %x) 616 ret i8 %m2 617} 618 619define i8 @smin_smax_commute3(i8 %x, i8 %y) { 620; CHECK-LABEL: @smin_smax_commute3( 621; CHECK-NEXT: ret i8 [[X:%.*]] 622; 623 %m = call i8 @llvm.smin.i8(i8 %y, i8 %x) 624 %m2 = call i8 @llvm.smax.i8(i8 %m, i8 %x) 625 ret i8 %m2 626} 627 628; Negative test - mismatched intrinsics. 629 630define i8 @smax_umin(i8 %x, i8 %y) { 631; CHECK-LABEL: @smax_umin( 632; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 633; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[M]], i8 [[X]]) 634; CHECK-NEXT: ret i8 [[M2]] 635; 636 %m = call i8 @llvm.smax.i8(i8 %y, i8 %x) 637 %m2 = call i8 @llvm.umin.i8(i8 %m, i8 %x) 638 ret i8 %m2 639} 640 641; Negative test - mismatched intrinsics. 642 643define i8 @smax_umax(i8 %x, i8 %y) { 644; CHECK-LABEL: @smax_umax( 645; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 646; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[M]], i8 [[X]]) 647; CHECK-NEXT: ret i8 [[M2]] 648; 649 %m = call i8 @llvm.smax.i8(i8 %y, i8 %x) 650 %m2 = call i8 @llvm.umax.i8(i8 %m, i8 %x) 651 ret i8 %m2 652} 653 654; Negative test - mismatched intrinsics. 655 656define i8 @umax_smin(i8 %x, i8 %y) { 657; CHECK-LABEL: @umax_smin( 658; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 659; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[M]], i8 [[X]]) 660; CHECK-NEXT: ret i8 [[M2]] 661; 662 %m = call i8 @llvm.umax.i8(i8 %y, i8 %x) 663 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 %x) 664 ret i8 %m2 665} 666 667; Negative test - mismatched intrinsics. 668 669define i8 @umin_smin(i8 %x, i8 %y) { 670; CHECK-LABEL: @umin_smin( 671; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 672; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[M]], i8 [[X]]) 673; CHECK-NEXT: ret i8 [[M2]] 674; 675 %m = call i8 @llvm.umin.i8(i8 %y, i8 %x) 676 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 %x) 677 ret i8 %m2 678} 679 680define i8 @umax_umax_constants(i8 %x) { 681; CHECK-LABEL: @umax_umax_constants( 682; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 9) 683; CHECK-NEXT: ret i8 [[M]] 684; 685 %m = call i8 @llvm.umax.i8(i8 %x, i8 9) 686 %m2 = call i8 @llvm.umax.i8(i8 7, i8 %m) 687 ret i8 %m2 688} 689 690define i8 @umax_umax_constants_commute1(i8 %x) { 691; CHECK-LABEL: @umax_umax_constants_commute1( 692; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umax.i8(i8 -128, i8 [[X:%.*]]) 693; CHECK-NEXT: ret i8 [[M]] 694; 695 %m = call i8 @llvm.umax.i8(i8 128, i8 %x) 696 %m2 = call i8 @llvm.umax.i8(i8 7, i8 %m) 697 ret i8 %m2 698} 699 700define i8 @umax_umax_constants_commute2(i8 %x) { 701; CHECK-LABEL: @umax_umax_constants_commute2( 702; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 -56) 703; CHECK-NEXT: ret i8 [[M]] 704; 705 %m = call i8 @llvm.umax.i8(i8 %x, i8 200) 706 %m2 = call i8 @llvm.umax.i8(i8 %m, i8 127) 707 ret i8 %m2 708} 709 710define <2 x i8> @umax_umax_constants_commute3(<2 x i8> %x) { 711; CHECK-LABEL: @umax_umax_constants_commute3( 712; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.umax.v2i8(<2 x i8> splat (i8 -2), <2 x i8> [[X:%.*]]) 713; CHECK-NEXT: ret <2 x i8> [[M]] 714; 715 %m = call <2 x i8> @llvm.umax.v2i8(<2 x i8> <i8 254, i8 254>, <2 x i8> %x) 716 %m2 = call <2 x i8> @llvm.umax.v2i8(<2 x i8> %m, <2 x i8> <i8 128, i8 128>) 717 ret <2 x i8> %m2 718} 719 720define i8 @umin_umin_constants(i8 %x) { 721; CHECK-LABEL: @umin_umin_constants( 722; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 7) 723; CHECK-NEXT: ret i8 [[M]] 724; 725 %m = call i8 @llvm.umin.i8(i8 %x, i8 7) 726 %m2 = call i8 @llvm.umin.i8(i8 9, i8 %m) 727 ret i8 %m2 728} 729 730define i8 @umin_umin_constants_commute1(i8 %x) { 731; CHECK-LABEL: @umin_umin_constants_commute1( 732; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 7, i8 [[X:%.*]]) 733; CHECK-NEXT: ret i8 [[M]] 734; 735 %m = call i8 @llvm.umin.i8(i8 7, i8 %x) 736 %m2 = call i8 @llvm.umin.i8(i8 128, i8 %m) 737 ret i8 %m2 738} 739 740define <2 x i8> @umin_umin_constants_commute2(<2 x i8> %x) { 741; CHECK-LABEL: @umin_umin_constants_commute2( 742; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> splat (i8 127)) 743; CHECK-NEXT: ret <2 x i8> [[M]] 744; 745 %m = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 127, i8 127>) 746 %m2 = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %m, <2 x i8> <i8 200, i8 poison>) 747 ret <2 x i8> %m2 748} 749 750define i8 @umin_umin_constants_commute3(i8 %x) { 751; CHECK-LABEL: @umin_umin_constants_commute3( 752; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.umin.i8(i8 -128, i8 [[X:%.*]]) 753; CHECK-NEXT: ret i8 [[M]] 754; 755 %m = call i8 @llvm.umin.i8(i8 128, i8 %x) 756 %m2 = call i8 @llvm.umin.i8(i8 %m, i8 254) 757 ret i8 %m2 758} 759 760define i8 @smax_smax_constants(i8 %x) { 761; CHECK-LABEL: @smax_smax_constants( 762; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 9) 763; CHECK-NEXT: ret i8 [[M]] 764; 765 %m = call i8 @llvm.smax.i8(i8 %x, i8 9) 766 %m2 = call i8 @llvm.smax.i8(i8 7, i8 %m) 767 ret i8 %m2 768} 769 770define <2 x i8> @smax_smax_constants_commute1(<2 x i8> %x) { 771; CHECK-LABEL: @smax_smax_constants_commute1( 772; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> splat (i8 7), <2 x i8> [[X:%.*]]) 773; CHECK-NEXT: ret <2 x i8> [[M]] 774; 775 %m = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 7, i8 7>, <2 x i8> %x) 776 %m2 = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 -127, i8 -127>, <2 x i8> %m) 777 ret <2 x i8> %m2 778} 779 780define i8 @smax_smax_constants_commute2(i8 %x) { 781; CHECK-LABEL: @smax_smax_constants_commute2( 782; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 0) 783; CHECK-NEXT: ret i8 [[M]] 784; 785 %m = call i8 @llvm.smax.i8(i8 %x, i8 0) 786 %m2 = call i8 @llvm.smax.i8(i8 %m, i8 -1) 787 ret i8 %m2 788} 789 790define i8 @smax_smax_constants_commute3(i8 %x) { 791; CHECK-LABEL: @smax_smax_constants_commute3( 792; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smax.i8(i8 -1, i8 [[X:%.*]]) 793; CHECK-NEXT: ret i8 [[M]] 794; 795 %m = call i8 @llvm.smax.i8(i8 -1, i8 %x) 796 %m2 = call i8 @llvm.smax.i8(i8 %m, i8 -127) 797 ret i8 %m2 798} 799 800define <2 x i8> @smin_smin_constants(<2 x i8> %x) { 801; CHECK-LABEL: @smin_smin_constants( 802; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.smin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> splat (i8 7)) 803; CHECK-NEXT: ret <2 x i8> [[M]] 804; 805 %m = call <2 x i8> @llvm.smin.v2i8(<2 x i8> %x, <2 x i8> <i8 7, i8 7>) 806 %m2 = call <2 x i8> @llvm.smin.v2i8(<2 x i8> <i8 poison, i8 9>, <2 x i8> %m) 807 ret <2 x i8> %m2 808} 809 810define i8 @smin_smin_constants_commute1(i8 %x) { 811; CHECK-LABEL: @smin_smin_constants_commute1( 812; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 -127, i8 [[X:%.*]]) 813; CHECK-NEXT: ret i8 [[M]] 814; 815 %m = call i8 @llvm.smin.i8(i8 -127, i8 %x) 816 %m2 = call i8 @llvm.smin.i8(i8 7, i8 %m) 817 ret i8 %m2 818} 819 820define i8 @smin_smin_constants_commute2(i8 %x) { 821; CHECK-LABEL: @smin_smin_constants_commute2( 822; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 -1) 823; CHECK-NEXT: ret i8 [[M]] 824; 825 %m = call i8 @llvm.smin.i8(i8 %x, i8 -1) 826 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 0) 827 ret i8 %m2 828} 829 830define i8 @smin_smin_constants_commute3(i8 %x) { 831; CHECK-LABEL: @smin_smin_constants_commute3( 832; CHECK-NEXT: [[M:%.*]] = call i8 @llvm.smin.i8(i8 -127, i8 [[X:%.*]]) 833; CHECK-NEXT: ret i8 [[M]] 834; 835 %m = call i8 @llvm.smin.i8(i8 -127, i8 %x) 836 %m2 = call i8 @llvm.smin.i8(i8 %m, i8 -1) 837 ret i8 %m2 838} 839 840; Negative test - undef in inner constant must not propagate. 841 842define <2 x i8> @umin_umin_constants_partial_undef(<2 x i8> %x) { 843; CHECK-LABEL: @umin_umin_constants_partial_undef( 844; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 7, i8 undef>) 845; CHECK-NEXT: [[M2:%.*]] = call <2 x i8> @llvm.umin.v2i8(<2 x i8> splat (i8 9), <2 x i8> [[M]]) 846; CHECK-NEXT: ret <2 x i8> [[M2]] 847; 848 %m = call <2 x i8> @llvm.umin.v2i8(<2 x i8> %x, <2 x i8> <i8 7, i8 undef> ) 849 %m2 = call <2 x i8> @llvm.umin.v2i8(<2 x i8> <i8 9, i8 9>, <2 x i8> %m) 850 ret <2 x i8> %m2 851} 852 853; Negative test - undef in inner constant must not propagate. 854 855define <2 x i8> @smax_smax_constants_partial_undef(<2 x i8> %x) { 856; CHECK-LABEL: @smax_smax_constants_partial_undef( 857; CHECK-NEXT: [[M:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> [[X:%.*]], <2 x i8> <i8 undef, i8 10>) 858; CHECK-NEXT: [[M2:%.*]] = call <2 x i8> @llvm.smax.v2i8(<2 x i8> splat (i8 9), <2 x i8> [[M]]) 859; CHECK-NEXT: ret <2 x i8> [[M2]] 860; 861 %m = call <2 x i8> @llvm.smax.v2i8(<2 x i8> %x, <2 x i8> <i8 undef, i8 10> ) 862 %m2 = call <2 x i8> @llvm.smax.v2i8(<2 x i8> <i8 9, i8 9>, <2 x i8> %m) 863 ret <2 x i8> %m2 864} 865 866define i1 @smax_slt(i8 %x, i8 %y) { 867; CHECK-LABEL: @smax_slt( 868; CHECK-NEXT: ret i1 false 869; 870 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 871 %r = icmp slt i8 %m, %x 872 ret i1 %r 873} 874 875define i1 @smax_sge(i8 %x, i8 %y) { 876; CHECK-LABEL: @smax_sge( 877; CHECK-NEXT: ret i1 true 878; 879 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 880 %r = icmp sge i8 %m, %x 881 ret i1 %r 882} 883 884define i1 @umax_ult(i8 %x, i8 %y) { 885; CHECK-LABEL: @umax_ult( 886; CHECK-NEXT: ret i1 false 887; 888 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 889 %r = icmp ult i8 %m, %x 890 ret i1 %r 891} 892 893define i1 @umax_uge(i8 %x, i8 %y) { 894; CHECK-LABEL: @umax_uge( 895; CHECK-NEXT: ret i1 true 896; 897 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 898 %r = icmp uge i8 %m, %x 899 ret i1 %r 900} 901 902define i1 @smax_sgt(i8 %x, i8 %y) { 903; CHECK-LABEL: @smax_sgt( 904; CHECK-NEXT: ret i1 false 905; 906 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 907 %r = icmp sgt i8 %x, %m 908 ret i1 %r 909} 910 911define i1 @smax_sle(i8 %x, i8 %y) { 912; CHECK-LABEL: @smax_sle( 913; CHECK-NEXT: ret i1 true 914; 915 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 916 %r = icmp sle i8 %x, %m 917 ret i1 %r 918} 919 920define i1 @umax_ugt(i8 %x, i8 %y) { 921; CHECK-LABEL: @umax_ugt( 922; CHECK-NEXT: ret i1 false 923; 924 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 925 %r = icmp ugt i8 %x, %m 926 ret i1 %r 927} 928 929define i1 @umax_ule(i8 %x, i8 %y) { 930; CHECK-LABEL: @umax_ule( 931; CHECK-NEXT: ret i1 true 932; 933 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 934 %r = icmp ule i8 %x, %m 935 ret i1 %r 936} 937 938define i1 @smin_sgt(i8 %x, i8 %y) { 939; CHECK-LABEL: @smin_sgt( 940; CHECK-NEXT: ret i1 false 941; 942 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 943 %r = icmp sgt i8 %m, %x 944 ret i1 %r 945} 946 947define i1 @smin_sle(i8 %x, i8 %y) { 948; CHECK-LABEL: @smin_sle( 949; CHECK-NEXT: ret i1 true 950; 951 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 952 %r = icmp sle i8 %m, %x 953 ret i1 %r 954} 955 956define i1 @umin_ugt(i8 %x, i8 %y) { 957; CHECK-LABEL: @umin_ugt( 958; CHECK-NEXT: ret i1 false 959; 960 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 961 %r = icmp ugt i8 %m, %x 962 ret i1 %r 963} 964 965define i1 @umin_ule(i8 %x, i8 %y) { 966; CHECK-LABEL: @umin_ule( 967; CHECK-NEXT: ret i1 true 968; 969 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 970 %r = icmp ule i8 %m, %x 971 ret i1 %r 972} 973 974define i1 @smin_slt(i8 %x, i8 %y) { 975; CHECK-LABEL: @smin_slt( 976; CHECK-NEXT: ret i1 false 977; 978 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 979 %r = icmp slt i8 %x, %m 980 ret i1 %r 981} 982 983define i1 @smin_sge(i8 %x, i8 %y) { 984; CHECK-LABEL: @smin_sge( 985; CHECK-NEXT: ret i1 true 986; 987 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 988 %r = icmp sge i8 %x, %m 989 ret i1 %r 990} 991 992define i1 @umin_ult(i8 %x, i8 %y) { 993; CHECK-LABEL: @umin_ult( 994; CHECK-NEXT: ret i1 false 995; 996 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 997 %r = icmp ult i8 %x, %m 998 ret i1 %r 999} 1000 1001define i1 @umin_uge(i8 %x, i8 %y) { 1002; CHECK-LABEL: @umin_uge( 1003; CHECK-NEXT: ret i1 true 1004; 1005 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1006 %r = icmp uge i8 %x, %m 1007 ret i1 %r 1008} 1009 1010define i1 @smaxmin_sge(i8 %x, i8 %y, i8 %z) { 1011; CHECK-LABEL: @smaxmin_sge( 1012; CHECK-NEXT: ret i1 true 1013; 1014 %max = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1015 %min = call i8 @llvm.smin.i8(i8 %z, i8 %x) 1016 %c = icmp sge i8 %max, %min 1017 ret i1 %c 1018} 1019 1020define i1 @smaxmin_sgt(i8 %x, i8 %y, i8 %z) { 1021; CHECK-LABEL: @smaxmin_sgt( 1022; CHECK-NEXT: ret i1 false 1023; 1024 %max = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1025 %min = call i8 @llvm.smin.i8(i8 %z, i8 %x) 1026 %c = icmp sgt i8 %min, %max 1027 ret i1 %c 1028} 1029 1030define i1 @smaxmin_sle(i8 %x, i8 %y, i8 %z) { 1031; CHECK-LABEL: @smaxmin_sle( 1032; CHECK-NEXT: ret i1 true 1033; 1034 %max = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1035 %min = call i8 @llvm.smin.i8(i8 %z, i8 %x) 1036 %c = icmp sle i8 %min, %max 1037 ret i1 %c 1038} 1039 1040define i1 @smaxmin_slt(i8 %x, i8 %y, i8 %z) { 1041; CHECK-LABEL: @smaxmin_slt( 1042; CHECK-NEXT: ret i1 false 1043; 1044 %max = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1045 %min = call i8 @llvm.smin.i8(i8 %z, i8 %x) 1046 %c = icmp slt i8 %max, %min 1047 ret i1 %c 1048} 1049 1050define i1 @umaxmin_uge(i8 %x, i8 %y, i8 %z) { 1051; CHECK-LABEL: @umaxmin_uge( 1052; CHECK-NEXT: ret i1 true 1053; 1054 %max = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1055 %min = call i8 @llvm.umin.i8(i8 %z, i8 %x) 1056 %c = icmp uge i8 %max, %min 1057 ret i1 %c 1058} 1059 1060define i1 @umaxmin_ugt(i8 %x, i8 %y, i8 %z) { 1061; CHECK-LABEL: @umaxmin_ugt( 1062; CHECK-NEXT: ret i1 false 1063; 1064 %max = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1065 %min = call i8 @llvm.umin.i8(i8 %z, i8 %x) 1066 %c = icmp ugt i8 %min, %max 1067 ret i1 %c 1068} 1069 1070define i1 @umaxmin_ule(i8 %x, i8 %y, i8 %z) { 1071; CHECK-LABEL: @umaxmin_ule( 1072; CHECK-NEXT: ret i1 true 1073; 1074 %max = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1075 %min = call i8 @llvm.umin.i8(i8 %z, i8 %x) 1076 %c = icmp ule i8 %min, %max 1077 ret i1 %c 1078} 1079 1080define i1 @umaxmin_ult(i8 %x, i8 %y, i8 %z) { 1081; CHECK-LABEL: @umaxmin_ult( 1082; CHECK-NEXT: ret i1 false 1083; 1084 %max = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1085 %min = call i8 @llvm.umin.i8(i8 %z, i8 %x) 1086 %c = icmp ult i8 %max, %min 1087 ret i1 %c 1088} 1089 1090; Negative test - should reduce via instcombine, but not here. 1091 1092define i1 @smax_eq(i8 %x, i8 %y) { 1093; CHECK-LABEL: @smax_eq( 1094; CHECK-NEXT: [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1095; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MAX]], [[X]] 1096; CHECK-NEXT: ret i1 [[R]] 1097; 1098 %max = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1099 %r = icmp eq i8 %max, %x 1100 ret i1 %r 1101} 1102 1103; Negative test - should reduce via instcombine, but not here. 1104 1105define i1 @smax_eq_commute(i8 %x, i8 %y) { 1106; CHECK-LABEL: @smax_eq_commute( 1107; CHECK-NEXT: [[MAX:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1108; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[X]], [[MAX]] 1109; CHECK-NEXT: ret i1 [[R]] 1110; 1111 %max = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1112 %r = icmp eq i8 %x, %max 1113 ret i1 %r 1114} 1115 1116; Negative test - should reduce via instcombine, but not here. 1117 1118define i1 @umax_eq(i8 %x, i8 %y) { 1119; CHECK-LABEL: @umax_eq( 1120; CHECK-NEXT: [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1121; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MAX]], [[X]] 1122; CHECK-NEXT: ret i1 [[R]] 1123; 1124 %max = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1125 %r = icmp eq i8 %max, %x 1126 ret i1 %r 1127} 1128 1129; Negative test - should reduce via instcombine, but not here. 1130 1131define i1 @umax_eq_commute(i8 %x, i8 %y) { 1132; CHECK-LABEL: @umax_eq_commute( 1133; CHECK-NEXT: [[MAX:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1134; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[X]], [[MAX]] 1135; CHECK-NEXT: ret i1 [[R]] 1136; 1137 %max = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1138 %r = icmp eq i8 %x, %max 1139 ret i1 %r 1140} 1141 1142define i8 @smax_smax_smax(i8 %x, i8 %y) { 1143; CHECK-LABEL: @smax_smax_smax( 1144; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1145; CHECK-NEXT: ret i8 [[M1]] 1146; 1147 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1148 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1149 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1150 ret i8 %r 1151} 1152 1153define i8 @smax_smax_smin(i8 %x, i8 %y) { 1154; CHECK-LABEL: @smax_smax_smin( 1155; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1156; CHECK-NEXT: ret i8 [[M1]] 1157; 1158 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1159 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1160 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1161 ret i8 %r 1162} 1163 1164define i8 @smax_smax_umax(i8 %x, i8 %y) { 1165; CHECK-LABEL: @smax_smax_umax( 1166; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1167; CHECK-NEXT: ret i8 [[M1]] 1168; 1169 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1170 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1171 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1172 ret i8 %r 1173} 1174 1175define i8 @smax_smax_umin(i8 %x, i8 %y) { 1176; CHECK-LABEL: @smax_smax_umin( 1177; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1178; CHECK-NEXT: ret i8 [[M1]] 1179; 1180 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1181 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1182 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1183 ret i8 %r 1184} 1185 1186define i8 @smax_smin_smax(i8 %x, i8 %y) { 1187; CHECK-LABEL: @smax_smin_smax( 1188; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1189; CHECK-NEXT: ret i8 [[M2]] 1190; 1191 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1192 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1193 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1194 ret i8 %r 1195} 1196 1197define i8 @smax_smin_smin(i8 %x, i8 %y) { 1198; CHECK-LABEL: @smax_smin_smin( 1199; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1200; CHECK-NEXT: ret i8 [[M2]] 1201; 1202 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1203 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1204 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1205 ret i8 %r 1206} 1207 1208define i8 @smax_smin_umax(i8 %x, i8 %y) { 1209; CHECK-LABEL: @smax_smin_umax( 1210; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1211; CHECK-NEXT: ret i8 [[M2]] 1212; 1213 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1214 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1215 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1216 ret i8 %r 1217} 1218 1219define i8 @smax_smin_umin(i8 %x, i8 %y) { 1220; CHECK-LABEL: @smax_smin_umin( 1221; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1222; CHECK-NEXT: ret i8 [[M2]] 1223; 1224 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1225 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1226 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1227 ret i8 %r 1228} 1229 1230define i8 @smax_umax_smax(i8 %x, i8 %y) { 1231; CHECK-LABEL: @smax_umax_smax( 1232; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1233; CHECK-NEXT: ret i8 [[M2]] 1234; 1235 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1236 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1237 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1238 ret i8 %r 1239} 1240 1241define i8 @smax_umax_smin(i8 %x, i8 %y) { 1242; CHECK-LABEL: @smax_umax_smin( 1243; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1244; CHECK-NEXT: ret i8 [[M1]] 1245; 1246 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1247 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1248 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1249 ret i8 %r 1250} 1251 1252; This could simplify (commuted min/max op). 1253 1254define i8 @smax_umax_umax(i8 %x, i8 %y) { 1255; CHECK-LABEL: @smax_umax_umax( 1256; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1257; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]]) 1258; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]]) 1259; CHECK-NEXT: ret i8 [[R]] 1260; 1261 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1262 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1263 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1264 ret i8 %r 1265} 1266 1267; This could combine - smax(x,y) - but does not simplify. 1268 1269define i8 @smax_umax_umin(i8 %x, i8 %y) { 1270; CHECK-LABEL: @smax_umax_umin( 1271; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1272; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]]) 1273; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]]) 1274; CHECK-NEXT: ret i8 [[R]] 1275; 1276 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1277 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1278 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1279 ret i8 %r 1280} 1281 1282define i8 @smax_umin_smax(i8 %x, i8 %y) { 1283; CHECK-LABEL: @smax_umin_smax( 1284; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1285; CHECK-NEXT: ret i8 [[M2]] 1286; 1287 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1288 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1289 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1290 ret i8 %r 1291} 1292 1293define i8 @smax_umin_smin(i8 %x, i8 %y) { 1294; CHECK-LABEL: @smax_umin_smin( 1295; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1296; CHECK-NEXT: ret i8 [[M1]] 1297; 1298 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1299 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1300 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1301 ret i8 %r 1302} 1303 1304; This could combine - smax(x,y) - but does not simplify. 1305 1306define i8 @smax_umin_umax(i8 %x, i8 %y) { 1307; CHECK-LABEL: @smax_umin_umax( 1308; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1309; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]]) 1310; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]]) 1311; CHECK-NEXT: ret i8 [[R]] 1312; 1313 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1314 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1315 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1316 ret i8 %r 1317} 1318 1319; This could simplify (commuted min/max op). 1320 1321define i8 @smax_umin_umin(i8 %x, i8 %y) { 1322; CHECK-LABEL: @smax_umin_umin( 1323; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1324; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]]) 1325; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smax.i8(i8 [[M1]], i8 [[M2]]) 1326; CHECK-NEXT: ret i8 [[R]] 1327; 1328 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1329 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1330 %r = call i8 @llvm.smax.i8(i8 %m1, i8 %m2) 1331 ret i8 %r 1332} 1333 1334define i8 @smin_smax_smax(i8 %x, i8 %y) { 1335; CHECK-LABEL: @smin_smax_smax( 1336; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1337; CHECK-NEXT: ret i8 [[M2]] 1338; 1339 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1340 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1341 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1342 ret i8 %r 1343} 1344 1345define i8 @smin_smax_smin(i8 %x, i8 %y) { 1346; CHECK-LABEL: @smin_smax_smin( 1347; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1348; CHECK-NEXT: ret i8 [[M2]] 1349; 1350 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1351 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1352 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1353 ret i8 %r 1354} 1355 1356define i8 @smin_smax_umax(i8 %x, i8 %y) { 1357; CHECK-LABEL: @smin_smax_umax( 1358; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1359; CHECK-NEXT: ret i8 [[M2]] 1360; 1361 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1362 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1363 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1364 ret i8 %r 1365} 1366 1367define i8 @smin_smax_umin(i8 %x, i8 %y) { 1368; CHECK-LABEL: @smin_smax_umin( 1369; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1370; CHECK-NEXT: ret i8 [[M2]] 1371; 1372 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1373 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1374 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1375 ret i8 %r 1376} 1377 1378define i8 @smin_smin_smax(i8 %x, i8 %y) { 1379; CHECK-LABEL: @smin_smin_smax( 1380; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1381; CHECK-NEXT: ret i8 [[M1]] 1382; 1383 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1384 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1385 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1386 ret i8 %r 1387} 1388 1389define i8 @smin_smin_smin(i8 %x, i8 %y) { 1390; CHECK-LABEL: @smin_smin_smin( 1391; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1392; CHECK-NEXT: ret i8 [[M1]] 1393; 1394 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1395 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1396 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1397 ret i8 %r 1398} 1399 1400define i8 @smin_smin_umax(i8 %x, i8 %y) { 1401; CHECK-LABEL: @smin_smin_umax( 1402; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1403; CHECK-NEXT: ret i8 [[M1]] 1404; 1405 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1406 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1407 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1408 ret i8 %r 1409} 1410 1411define i8 @smin_smin_umin(i8 %x, i8 %y) { 1412; CHECK-LABEL: @smin_smin_umin( 1413; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1414; CHECK-NEXT: ret i8 [[M1]] 1415; 1416 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1417 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1418 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1419 ret i8 %r 1420} 1421 1422define i8 @smin_umax_smax(i8 %x, i8 %y) { 1423; CHECK-LABEL: @smin_umax_smax( 1424; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1425; CHECK-NEXT: ret i8 [[M1]] 1426; 1427 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1428 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1429 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1430 ret i8 %r 1431} 1432 1433define i8 @smin_umax_smin(i8 %x, i8 %y) { 1434; CHECK-LABEL: @smin_umax_smin( 1435; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1436; CHECK-NEXT: ret i8 [[M2]] 1437; 1438 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1439 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1440 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1441 ret i8 %r 1442} 1443 1444; This could simplify (commuted min/max op). 1445 1446define i8 @smin_umax_umax(i8 %x, i8 %y) { 1447; CHECK-LABEL: @smin_umax_umax( 1448; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1449; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]]) 1450; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]]) 1451; CHECK-NEXT: ret i8 [[R]] 1452; 1453 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1454 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1455 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1456 ret i8 %r 1457} 1458 1459; This could combine - smin(x,y) - but does not simplify. 1460 1461define i8 @smin_umax_umin(i8 %x, i8 %y) { 1462; CHECK-LABEL: @smin_umax_umin( 1463; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1464; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]]) 1465; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]]) 1466; CHECK-NEXT: ret i8 [[R]] 1467; 1468 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1469 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1470 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1471 ret i8 %r 1472} 1473 1474define i8 @smin_umin_smax(i8 %x, i8 %y) { 1475; CHECK-LABEL: @smin_umin_smax( 1476; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1477; CHECK-NEXT: ret i8 [[M1]] 1478; 1479 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1480 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1481 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1482 ret i8 %r 1483} 1484 1485define i8 @smin_umin_smin(i8 %x, i8 %y) { 1486; CHECK-LABEL: @smin_umin_smin( 1487; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1488; CHECK-NEXT: ret i8 [[M2]] 1489; 1490 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1491 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1492 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1493 ret i8 %r 1494} 1495 1496; This could combine - smin(x,y) - but does not simplify. 1497 1498define i8 @smin_umin_umax(i8 %x, i8 %y) { 1499; CHECK-LABEL: @smin_umin_umax( 1500; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1501; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y]], i8 [[X]]) 1502; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]]) 1503; CHECK-NEXT: ret i8 [[R]] 1504; 1505 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1506 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1507 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1508 ret i8 %r 1509} 1510 1511; This could simplify (commuted min/max op). 1512 1513define i8 @smin_umin_umin(i8 %x, i8 %y) { 1514; CHECK-LABEL: @smin_umin_umin( 1515; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1516; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y]], i8 [[X]]) 1517; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.smin.i8(i8 [[M1]], i8 [[M2]]) 1518; CHECK-NEXT: ret i8 [[R]] 1519; 1520 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1521 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1522 %r = call i8 @llvm.smin.i8(i8 %m1, i8 %m2) 1523 ret i8 %r 1524} 1525 1526; This could simplify (commuted min/max op). 1527 1528define i8 @umax_smax_smax(i8 %x, i8 %y) { 1529; CHECK-LABEL: @umax_smax_smax( 1530; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1531; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]]) 1532; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]]) 1533; CHECK-NEXT: ret i8 [[R]] 1534; 1535 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1536 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1537 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1538 ret i8 %r 1539} 1540 1541; This could combine - umax(x,y) - but does not simplify. 1542 1543define i8 @umax_smax_smin(i8 %x, i8 %y) { 1544; CHECK-LABEL: @umax_smax_smin( 1545; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1546; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]]) 1547; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]]) 1548; CHECK-NEXT: ret i8 [[R]] 1549; 1550 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1551 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1552 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1553 ret i8 %r 1554} 1555 1556define i8 @umax_smax_umax(i8 %x, i8 %y) { 1557; CHECK-LABEL: @umax_smax_umax( 1558; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1559; CHECK-NEXT: ret i8 [[M2]] 1560; 1561 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1562 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1563 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1564 ret i8 %r 1565} 1566 1567define i8 @umax_smax_umin(i8 %x, i8 %y) { 1568; CHECK-LABEL: @umax_smax_umin( 1569; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1570; CHECK-NEXT: ret i8 [[M1]] 1571; 1572 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1573 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1574 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1575 ret i8 %r 1576} 1577 1578; This could combine - umax(x,y) - but does not simplify. 1579 1580define i8 @umax_smin_smax(i8 %x, i8 %y) { 1581; CHECK-LABEL: @umax_smin_smax( 1582; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1583; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]]) 1584; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]]) 1585; CHECK-NEXT: ret i8 [[R]] 1586; 1587 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1588 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1589 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1590 ret i8 %r 1591} 1592 1593; This could simplify (commuted min/max op). 1594 1595define i8 @umax_smin_smin(i8 %x, i8 %y) { 1596; CHECK-LABEL: @umax_smin_smin( 1597; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1598; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]]) 1599; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umax.i8(i8 [[M1]], i8 [[M2]]) 1600; CHECK-NEXT: ret i8 [[R]] 1601; 1602 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1603 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1604 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1605 ret i8 %r 1606} 1607 1608define i8 @umax_smin_umax(i8 %x, i8 %y) { 1609; CHECK-LABEL: @umax_smin_umax( 1610; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1611; CHECK-NEXT: ret i8 [[M2]] 1612; 1613 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1614 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1615 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1616 ret i8 %r 1617} 1618 1619define i8 @umax_smin_umin(i8 %x, i8 %y) { 1620; CHECK-LABEL: @umax_smin_umin( 1621; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1622; CHECK-NEXT: ret i8 [[M1]] 1623; 1624 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1625 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1626 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1627 ret i8 %r 1628} 1629 1630define i8 @umax_umax_smax(i8 %x, i8 %y) { 1631; CHECK-LABEL: @umax_umax_smax( 1632; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1633; CHECK-NEXT: ret i8 [[M1]] 1634; 1635 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1636 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1637 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1638 ret i8 %r 1639} 1640 1641define i8 @umax_umax_smin(i8 %x, i8 %y) { 1642; CHECK-LABEL: @umax_umax_smin( 1643; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1644; CHECK-NEXT: ret i8 [[M1]] 1645; 1646 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1647 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1648 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1649 ret i8 %r 1650} 1651 1652define i8 @umax_umax_umax(i8 %x, i8 %y) { 1653; CHECK-LABEL: @umax_umax_umax( 1654; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1655; CHECK-NEXT: ret i8 [[M1]] 1656; 1657 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1658 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1659 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1660 ret i8 %r 1661} 1662 1663define i8 @umax_umax_umin(i8 %x, i8 %y) { 1664; CHECK-LABEL: @umax_umax_umin( 1665; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1666; CHECK-NEXT: ret i8 [[M1]] 1667; 1668 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1669 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1670 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1671 ret i8 %r 1672} 1673 1674define i8 @umax_umin_smax(i8 %x, i8 %y) { 1675; CHECK-LABEL: @umax_umin_smax( 1676; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1677; CHECK-NEXT: ret i8 [[M2]] 1678; 1679 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1680 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1681 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1682 ret i8 %r 1683} 1684 1685define i8 @umax_umin_smin(i8 %x, i8 %y) { 1686; CHECK-LABEL: @umax_umin_smin( 1687; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1688; CHECK-NEXT: ret i8 [[M2]] 1689; 1690 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1691 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1692 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1693 ret i8 %r 1694} 1695 1696define i8 @umax_umin_umax(i8 %x, i8 %y) { 1697; CHECK-LABEL: @umax_umin_umax( 1698; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1699; CHECK-NEXT: ret i8 [[M2]] 1700; 1701 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1702 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1703 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1704 ret i8 %r 1705} 1706 1707define i8 @umax_umin_umin(i8 %x, i8 %y) { 1708; CHECK-LABEL: @umax_umin_umin( 1709; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1710; CHECK-NEXT: ret i8 [[M2]] 1711; 1712 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1713 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1714 %r = call i8 @llvm.umax.i8(i8 %m1, i8 %m2) 1715 ret i8 %r 1716} 1717 1718; This could simplify (commuted min/max op). 1719 1720define i8 @umin_smax_smax(i8 %x, i8 %y) { 1721; CHECK-LABEL: @umin_smax_smax( 1722; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1723; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]]) 1724; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]]) 1725; CHECK-NEXT: ret i8 [[R]] 1726; 1727 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1728 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1729 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1730 ret i8 %r 1731} 1732 1733; This could combine - umin(x,y) - but does not simplify. 1734 1735define i8 @umin_smax_smin(i8 %x, i8 %y) { 1736; CHECK-LABEL: @umin_smax_smin( 1737; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1738; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]]) 1739; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]]) 1740; CHECK-NEXT: ret i8 [[R]] 1741; 1742 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1743 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1744 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1745 ret i8 %r 1746} 1747 1748define i8 @umin_smax_umax(i8 %x, i8 %y) { 1749; CHECK-LABEL: @umin_smax_umax( 1750; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smax.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1751; CHECK-NEXT: ret i8 [[M1]] 1752; 1753 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1754 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1755 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1756 ret i8 %r 1757} 1758 1759define i8 @umin_smax_umin(i8 %x, i8 %y) { 1760; CHECK-LABEL: @umin_smax_umin( 1761; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1762; CHECK-NEXT: ret i8 [[M2]] 1763; 1764 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 1765 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1766 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1767 ret i8 %r 1768} 1769 1770; This could combine - umin(x,y) - but does not simplify. 1771 1772define i8 @umin_smin_smax(i8 %x, i8 %y) { 1773; CHECK-LABEL: @umin_smin_smax( 1774; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1775; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y]], i8 [[X]]) 1776; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]]) 1777; CHECK-NEXT: ret i8 [[R]] 1778; 1779 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1780 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1781 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1782 ret i8 %r 1783} 1784 1785; This could simplify (commuted min/max op). 1786 1787define i8 @umin_smin_smin(i8 %x, i8 %y) { 1788; CHECK-LABEL: @umin_smin_smin( 1789; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1790; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y]], i8 [[X]]) 1791; CHECK-NEXT: [[R:%.*]] = call i8 @llvm.umin.i8(i8 [[M1]], i8 [[M2]]) 1792; CHECK-NEXT: ret i8 [[R]] 1793; 1794 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1795 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1796 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1797 ret i8 %r 1798} 1799 1800define i8 @umin_smin_umax(i8 %x, i8 %y) { 1801; CHECK-LABEL: @umin_smin_umax( 1802; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.smin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1803; CHECK-NEXT: ret i8 [[M1]] 1804; 1805 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1806 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1807 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1808 ret i8 %r 1809} 1810 1811define i8 @umin_smin_umin(i8 %x, i8 %y) { 1812; CHECK-LABEL: @umin_smin_umin( 1813; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1814; CHECK-NEXT: ret i8 [[M2]] 1815; 1816 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 1817 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1818 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1819 ret i8 %r 1820} 1821 1822define i8 @umin_umax_smax(i8 %x, i8 %y) { 1823; CHECK-LABEL: @umin_umax_smax( 1824; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1825; CHECK-NEXT: ret i8 [[M2]] 1826; 1827 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1828 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1829 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1830 ret i8 %r 1831} 1832 1833define i8 @umin_umax_smin(i8 %x, i8 %y) { 1834; CHECK-LABEL: @umin_umax_smin( 1835; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.smin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1836; CHECK-NEXT: ret i8 [[M2]] 1837; 1838 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1839 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1840 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1841 ret i8 %r 1842} 1843 1844define i8 @umin_umax_umax(i8 %x, i8 %y) { 1845; CHECK-LABEL: @umin_umax_umax( 1846; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umax.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1847; CHECK-NEXT: ret i8 [[M2]] 1848; 1849 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1850 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1851 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1852 ret i8 %r 1853} 1854 1855define i8 @umin_umax_umin(i8 %x, i8 %y) { 1856; CHECK-LABEL: @umin_umax_umin( 1857; CHECK-NEXT: [[M2:%.*]] = call i8 @llvm.umin.i8(i8 [[Y:%.*]], i8 [[X:%.*]]) 1858; CHECK-NEXT: ret i8 [[M2]] 1859; 1860 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 1861 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1862 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1863 ret i8 %r 1864} 1865 1866define i8 @umin_umin_smax(i8 %x, i8 %y) { 1867; CHECK-LABEL: @umin_umin_smax( 1868; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1869; CHECK-NEXT: ret i8 [[M1]] 1870; 1871 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1872 %m2 = call i8 @llvm.smax.i8(i8 %y, i8 %x) 1873 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1874 ret i8 %r 1875} 1876 1877define i8 @umin_umin_smin(i8 %x, i8 %y) { 1878; CHECK-LABEL: @umin_umin_smin( 1879; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1880; CHECK-NEXT: ret i8 [[M1]] 1881; 1882 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1883 %m2 = call i8 @llvm.smin.i8(i8 %y, i8 %x) 1884 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1885 ret i8 %r 1886} 1887 1888define i8 @umin_umin_umax(i8 %x, i8 %y) { 1889; CHECK-LABEL: @umin_umin_umax( 1890; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1891; CHECK-NEXT: ret i8 [[M1]] 1892; 1893 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1894 %m2 = call i8 @llvm.umax.i8(i8 %y, i8 %x) 1895 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1896 ret i8 %r 1897} 1898 1899define i8 @umin_umin_umin(i8 %x, i8 %y) { 1900; CHECK-LABEL: @umin_umin_umin( 1901; CHECK-NEXT: [[M1:%.*]] = call i8 @llvm.umin.i8(i8 [[X:%.*]], i8 [[Y:%.*]]) 1902; CHECK-NEXT: ret i8 [[M1]] 1903; 1904 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1905 %m2 = call i8 @llvm.umin.i8(i8 %y, i8 %x) 1906 %r = call i8 @llvm.umin.i8(i8 %m1, i8 %m2) 1907 ret i8 %r 1908} 1909 1910define i1 @umin_ult_diff_const(i8 %x) { 1911; CHECK-LABEL: @umin_ult_diff_const( 1912; CHECK-NEXT: ret i1 true 1913; 1914 %m = call i8 @llvm.umin.i8(i8 %x, i8 10) 1915 %c = icmp ult i8 %m, 20 1916 ret i1 %c 1917} 1918 1919define i1 @umax_ugt_diff_const(i8 %x) { 1920; CHECK-LABEL: @umax_ugt_diff_const( 1921; CHECK-NEXT: ret i1 true 1922; 1923 %m = call i8 @llvm.umax.i8(i8 %x, i8 10) 1924 %c = icmp ugt i8 %m, 5 1925 ret i1 %c 1926} 1927 1928define i1 @smin_slt_diff_const(i8 %x) { 1929; CHECK-LABEL: @smin_slt_diff_const( 1930; CHECK-NEXT: ret i1 true 1931; 1932 %m = call i8 @llvm.smin.i8(i8 %x, i8 10) 1933 %c = icmp slt i8 %m, 20 1934 ret i1 %c 1935} 1936 1937define i1 @smax_sgt_diff_const(i8 %x) { 1938; CHECK-LABEL: @smax_sgt_diff_const( 1939; CHECK-NEXT: ret i1 true 1940; 1941 %m = call i8 @llvm.smax.i8(i8 %x, i8 10) 1942 %c = icmp sgt i8 %m, 5 1943 ret i1 %c 1944} 1945 1946define i8 @umin_assume_uge(i8 %x, i8 %y) { 1947; CHECK-LABEL: @umin_assume_uge( 1948; CHECK-NEXT: [[C:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]] 1949; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 1950; CHECK-NEXT: ret i8 [[Y]] 1951; 1952 %c = icmp uge i8 %x, %y 1953 call void @llvm.assume(i1 %c) 1954 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1955 ret i8 %m 1956} 1957 1958define i8 @umin_assume_ugt(i8 %x, i8 %y) { 1959; CHECK-LABEL: @umin_assume_ugt( 1960; CHECK-NEXT: [[C:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]] 1961; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 1962; CHECK-NEXT: ret i8 [[Y]] 1963; 1964 %c = icmp ugt i8 %x, %y 1965 call void @llvm.assume(i1 %c) 1966 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1967 ret i8 %m 1968} 1969 1970define i8 @umin_assume_ule(i8 %x, i8 %y) { 1971; CHECK-LABEL: @umin_assume_ule( 1972; CHECK-NEXT: [[C:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]] 1973; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 1974; CHECK-NEXT: ret i8 [[X]] 1975; 1976 %c = icmp ule i8 %x, %y 1977 call void @llvm.assume(i1 %c) 1978 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1979 ret i8 %m 1980} 1981 1982define i8 @umin_assume_ult(i8 %x, i8 %y) { 1983; CHECK-LABEL: @umin_assume_ult( 1984; CHECK-NEXT: [[C:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]] 1985; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 1986; CHECK-NEXT: ret i8 [[X]] 1987; 1988 %c = icmp ult i8 %x, %y 1989 call void @llvm.assume(i1 %c) 1990 %m = call i8 @llvm.umin.i8(i8 %x, i8 %y) 1991 ret i8 %m 1992} 1993 1994define i8 @umax_assume_uge(i8 %x, i8 %y) { 1995; CHECK-LABEL: @umax_assume_uge( 1996; CHECK-NEXT: [[C:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]] 1997; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 1998; CHECK-NEXT: ret i8 [[X]] 1999; 2000 %c = icmp uge i8 %x, %y 2001 call void @llvm.assume(i1 %c) 2002 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2003 ret i8 %m 2004} 2005 2006define i8 @umax_assume_ugt(i8 %x, i8 %y) { 2007; CHECK-LABEL: @umax_assume_ugt( 2008; CHECK-NEXT: [[C:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]] 2009; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2010; CHECK-NEXT: ret i8 [[X]] 2011; 2012 %c = icmp ugt i8 %x, %y 2013 call void @llvm.assume(i1 %c) 2014 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2015 ret i8 %m 2016} 2017 2018define i8 @umax_assume_ule(i8 %x, i8 %y) { 2019; CHECK-LABEL: @umax_assume_ule( 2020; CHECK-NEXT: [[C:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]] 2021; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2022; CHECK-NEXT: ret i8 [[Y]] 2023; 2024 %c = icmp ule i8 %x, %y 2025 call void @llvm.assume(i1 %c) 2026 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2027 ret i8 %m 2028} 2029 2030define i8 @umax_assume_ult(i8 %x, i8 %y) { 2031; CHECK-LABEL: @umax_assume_ult( 2032; CHECK-NEXT: [[C:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]] 2033; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2034; CHECK-NEXT: ret i8 [[Y]] 2035; 2036 %c = icmp ult i8 %x, %y 2037 call void @llvm.assume(i1 %c) 2038 %m = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2039 ret i8 %m 2040} 2041 2042define i8 @smin_assume_sge(i8 %x, i8 %y) { 2043; CHECK-LABEL: @smin_assume_sge( 2044; CHECK-NEXT: [[C:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]] 2045; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2046; CHECK-NEXT: ret i8 [[Y]] 2047; 2048 %c = icmp sge i8 %x, %y 2049 call void @llvm.assume(i1 %c) 2050 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 2051 ret i8 %m 2052} 2053 2054define i8 @smin_assume_sgt(i8 %x, i8 %y) { 2055; CHECK-LABEL: @smin_assume_sgt( 2056; CHECK-NEXT: [[C:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]] 2057; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2058; CHECK-NEXT: ret i8 [[Y]] 2059; 2060 %c = icmp sgt i8 %x, %y 2061 call void @llvm.assume(i1 %c) 2062 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 2063 ret i8 %m 2064} 2065 2066define i8 @smin_assume_sle(i8 %x, i8 %y) { 2067; CHECK-LABEL: @smin_assume_sle( 2068; CHECK-NEXT: [[C:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]] 2069; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2070; CHECK-NEXT: ret i8 [[X]] 2071; 2072 %c = icmp sle i8 %x, %y 2073 call void @llvm.assume(i1 %c) 2074 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 2075 ret i8 %m 2076} 2077 2078define i8 @smin_assume_slt(i8 %x, i8 %y) { 2079; CHECK-LABEL: @smin_assume_slt( 2080; CHECK-NEXT: [[C:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]] 2081; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2082; CHECK-NEXT: ret i8 [[X]] 2083; 2084 %c = icmp slt i8 %x, %y 2085 call void @llvm.assume(i1 %c) 2086 %m = call i8 @llvm.smin.i8(i8 %x, i8 %y) 2087 ret i8 %m 2088} 2089 2090define i8 @smax_assume_sge(i8 %x, i8 %y) { 2091; CHECK-LABEL: @smax_assume_sge( 2092; CHECK-NEXT: [[C:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]] 2093; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2094; CHECK-NEXT: ret i8 [[X]] 2095; 2096 %c = icmp sge i8 %x, %y 2097 call void @llvm.assume(i1 %c) 2098 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 2099 ret i8 %m 2100} 2101 2102define i8 @smax_assume_sgt(i8 %x, i8 %y) { 2103; CHECK-LABEL: @smax_assume_sgt( 2104; CHECK-NEXT: [[C:%.*]] = icmp sgt i8 [[X:%.*]], [[Y:%.*]] 2105; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2106; CHECK-NEXT: ret i8 [[X]] 2107; 2108 %c = icmp sgt i8 %x, %y 2109 call void @llvm.assume(i1 %c) 2110 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 2111 ret i8 %m 2112} 2113 2114define i8 @smax_assume_sle(i8 %x, i8 %y) { 2115; CHECK-LABEL: @smax_assume_sle( 2116; CHECK-NEXT: [[C:%.*]] = icmp sle i8 [[X:%.*]], [[Y:%.*]] 2117; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2118; CHECK-NEXT: ret i8 [[Y]] 2119; 2120 %c = icmp sle i8 %x, %y 2121 call void @llvm.assume(i1 %c) 2122 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 2123 ret i8 %m 2124} 2125 2126define i8 @smax_assume_slt(i8 %x, i8 %y) { 2127; CHECK-LABEL: @smax_assume_slt( 2128; CHECK-NEXT: [[C:%.*]] = icmp slt i8 [[X:%.*]], [[Y:%.*]] 2129; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) 2130; CHECK-NEXT: ret i8 [[Y]] 2131; 2132 %c = icmp slt i8 %x, %y 2133 call void @llvm.assume(i1 %c) 2134 %m = call i8 @llvm.smax.i8(i8 %x, i8 %y) 2135 ret i8 %m 2136} 2137 2138define i8 @umax_add_nuw_1(i8 %x) { 2139; CHECK-LABEL: @umax_add_nuw_1( 2140; CHECK-NEXT: [[ADD:%.*]] = add nuw i8 [[X:%.*]], 1 2141; CHECK-NEXT: ret i8 [[ADD]] 2142; 2143 %add = add nuw i8 %x, 1 2144 %max = call i8 @llvm.umax.i8(i8 %add, i8 %x) 2145 ret i8 %max 2146} 2147 2148define i8 @umax_add_nuw_2(i8 %x) { 2149; CHECK-LABEL: @umax_add_nuw_2( 2150; CHECK-NEXT: [[ADD:%.*]] = add nuw i8 [[X:%.*]], 42 2151; CHECK-NEXT: ret i8 [[ADD]] 2152; 2153 %add = add nuw i8 %x, 42 2154 %max = call i8 @llvm.umax.i8(i8 %add, i8 42) 2155 ret i8 %max 2156} 2157 2158define i8 @umax_range_metadata(ptr %p1, ptr %p2) { 2159; CHECK-LABEL: @umax_range_metadata( 2160; CHECK-NEXT: [[Y:%.*]] = load i8, ptr [[P2:%.*]], align 1, !range [[RNG0:![0-9]+]] 2161; CHECK-NEXT: ret i8 [[Y]] 2162; 2163 %x = load i8, ptr %p1, !range !{i8 0, i8 10} 2164 %y = load i8, ptr %p2, !range !{i8 20, i8 30} 2165 %max = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2166 ret i8 %max 2167} 2168 2169define i8 @umax_zext_sext(i4 %x) { 2170; CHECK-LABEL: @umax_zext_sext( 2171; CHECK-NEXT: [[SEXT:%.*]] = sext i4 [[X:%.*]] to i8 2172; CHECK-NEXT: ret i8 [[SEXT]] 2173; 2174 %zext = zext i4 %x to i8 2175 %sext = sext i4 %x to i8 2176 %max = call i8 @llvm.umax.i8(i8 %zext, i8 %sext) 2177 ret i8 %max 2178} 2179 2180define i8 @umax_lshr(i8 %x, i8 %y) { 2181; CHECK-LABEL: @umax_lshr( 2182; CHECK-NEXT: ret i8 [[X:%.*]] 2183; 2184 %shr = lshr i8 %x, %y 2185 %max = call i8 @llvm.umax.i8(i8 %x, i8 %shr) 2186 ret i8 %max 2187} 2188 2189define i8 @umax_dom_cond_uge(i8 %x, i8 %y) { 2190; CHECK-LABEL: @umax_dom_cond_uge( 2191; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]] 2192; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] 2193; CHECK: true: 2194; CHECK-NEXT: ret i8 [[X]] 2195; CHECK: false: 2196; CHECK-NEXT: ret i8 [[Y]] 2197; 2198 %cmp = icmp uge i8 %x, %y 2199 br i1 %cmp, label %true, label %false 2200 2201true: 2202 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2203 ret i8 %m1 2204 2205false: 2206 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2207 ret i8 %m2 2208} 2209 2210define i8 @umax_dom_cond_ugt(i8 %x, i8 %y) { 2211; CHECK-LABEL: @umax_dom_cond_ugt( 2212; CHECK-NEXT: [[CMP:%.*]] = icmp ugt i8 [[X:%.*]], [[Y:%.*]] 2213; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] 2214; CHECK: true: 2215; CHECK-NEXT: ret i8 [[X]] 2216; CHECK: false: 2217; CHECK-NEXT: ret i8 [[Y]] 2218; 2219 %cmp = icmp ugt i8 %x, %y 2220 br i1 %cmp, label %true, label %false 2221 2222true: 2223 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2224 ret i8 %m1 2225 2226false: 2227 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2228 ret i8 %m2 2229} 2230 2231define i8 @umax_dom_cond_ule(i8 %x, i8 %y) { 2232; CHECK-LABEL: @umax_dom_cond_ule( 2233; CHECK-NEXT: [[CMP:%.*]] = icmp ule i8 [[X:%.*]], [[Y:%.*]] 2234; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] 2235; CHECK: true: 2236; CHECK-NEXT: ret i8 [[Y]] 2237; CHECK: false: 2238; CHECK-NEXT: ret i8 [[X]] 2239; 2240 %cmp = icmp ule i8 %x, %y 2241 br i1 %cmp, label %true, label %false 2242 2243true: 2244 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2245 ret i8 %m1 2246 2247false: 2248 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2249 ret i8 %m2 2250} 2251 2252define i8 @umax_dom_cond_ult(i8 %x, i8 %y) { 2253; CHECK-LABEL: @umax_dom_cond_ult( 2254; CHECK-NEXT: [[CMP:%.*]] = icmp ult i8 [[X:%.*]], [[Y:%.*]] 2255; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] 2256; CHECK: true: 2257; CHECK-NEXT: ret i8 [[Y]] 2258; CHECK: false: 2259; CHECK-NEXT: ret i8 [[X]] 2260; 2261 %cmp = icmp ult i8 %x, %y 2262 br i1 %cmp, label %true, label %false 2263 2264true: 2265 %m1 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2266 ret i8 %m1 2267 2268false: 2269 %m2 = call i8 @llvm.umax.i8(i8 %x, i8 %y) 2270 ret i8 %m2 2271} 2272 2273define i8 @umin_dom_cond_uge(i8 %x, i8 %y) { 2274; CHECK-LABEL: @umin_dom_cond_uge( 2275; CHECK-NEXT: [[CMP:%.*]] = icmp uge i8 [[X:%.*]], [[Y:%.*]] 2276; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] 2277; CHECK: true: 2278; CHECK-NEXT: ret i8 [[Y]] 2279; CHECK: false: 2280; CHECK-NEXT: ret i8 [[X]] 2281; 2282 %cmp = icmp uge i8 %x, %y 2283 br i1 %cmp, label %true, label %false 2284 2285true: 2286 %m1 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 2287 ret i8 %m1 2288 2289false: 2290 %m2 = call i8 @llvm.umin.i8(i8 %x, i8 %y) 2291 ret i8 %m2 2292} 2293 2294define i8 @smax_dom_cond_sge(i8 %x, i8 %y) { 2295; CHECK-LABEL: @smax_dom_cond_sge( 2296; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]] 2297; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] 2298; CHECK: true: 2299; CHECK-NEXT: ret i8 [[X]] 2300; CHECK: false: 2301; CHECK-NEXT: ret i8 [[Y]] 2302; 2303 %cmp = icmp sge i8 %x, %y 2304 br i1 %cmp, label %true, label %false 2305 2306true: 2307 %m1 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 2308 ret i8 %m1 2309 2310false: 2311 %m2 = call i8 @llvm.smax.i8(i8 %x, i8 %y) 2312 ret i8 %m2 2313} 2314 2315define i8 @smin_dom_cond_sge(i8 %x, i8 %y) { 2316; CHECK-LABEL: @smin_dom_cond_sge( 2317; CHECK-NEXT: [[CMP:%.*]] = icmp sge i8 [[X:%.*]], [[Y:%.*]] 2318; CHECK-NEXT: br i1 [[CMP]], label [[TRUE:%.*]], label [[FALSE:%.*]] 2319; CHECK: true: 2320; CHECK-NEXT: ret i8 [[Y]] 2321; CHECK: false: 2322; CHECK-NEXT: ret i8 [[X]] 2323; 2324 %cmp = icmp sge i8 %x, %y 2325 br i1 %cmp, label %true, label %false 2326 2327true: 2328 %m1 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 2329 ret i8 %m1 2330 2331false: 2332 %m2 = call i8 @llvm.smin.i8(i8 %x, i8 %y) 2333 ret i8 %m2 2334} 2335 2336; Tests from PR65833 2337define i8 @umin_and_mask(i8 %x) { 2338; CHECK-LABEL: @umin_and_mask( 2339; CHECK-NEXT: [[AND1:%.*]] = and i8 [[X:%.*]], 1 2340; CHECK-NEXT: ret i8 [[AND1]] 2341; 2342 %and1 = and i8 %x, 1 2343 %and2 = and i8 %x, 3 2344 %val = call i8 @llvm.umin.i8(i8 %and1, i8 %and2) 2345 ret i8 %val 2346} 2347 2348define i8 @umax_and_mask(i8 %x) { 2349; CHECK-LABEL: @umax_and_mask( 2350; CHECK-NEXT: [[AND2:%.*]] = and i8 [[X:%.*]], 3 2351; CHECK-NEXT: ret i8 [[AND2]] 2352; 2353 %and1 = and i8 %x, 1 2354 %and2 = and i8 %x, 3 2355 %val = call i8 @llvm.umax.i8(i8 %and1, i8 %and2) 2356 ret i8 %val 2357} 2358 2359define i8 @umin_or_mask(i8 %x) { 2360; CHECK-LABEL: @umin_or_mask( 2361; CHECK-NEXT: [[AND1:%.*]] = or i8 [[X:%.*]], 1 2362; CHECK-NEXT: ret i8 [[AND1]] 2363; 2364 %and1 = or i8 %x, 1 2365 %and2 = or i8 %x, 3 2366 %val = call i8 @llvm.umin.i8(i8 %and1, i8 %and2) 2367 ret i8 %val 2368} 2369 2370define i8 @umax_or_mask(i8 %x) { 2371; CHECK-LABEL: @umax_or_mask( 2372; CHECK-NEXT: [[AND2:%.*]] = or i8 [[X:%.*]], 3 2373; CHECK-NEXT: ret i8 [[AND2]] 2374; 2375 %and1 = or i8 %x, 1 2376 %and2 = or i8 %x, 3 2377 %val = call i8 @llvm.umax.i8(i8 %and1, i8 %and2) 2378 ret i8 %val 2379} 2380 2381define i8 @umin_and_mask_negative(i8 %x) { 2382; CHECK-LABEL: @umin_and_mask_negative( 2383; CHECK-NEXT: [[AND1:%.*]] = and i8 [[X:%.*]], 1 2384; CHECK-NEXT: [[AND2:%.*]] = and i8 [[X]], 2 2385; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.umin.i8(i8 [[AND1]], i8 [[AND2]]) 2386; CHECK-NEXT: ret i8 [[VAL]] 2387; 2388 %and1 = and i8 %x, 1 2389 %and2 = and i8 %x, 2 2390 %val = call i8 @llvm.umin.i8(i8 %and1, i8 %and2) 2391 ret i8 %val 2392} 2393 2394define i8 @umax_and_mask_negative(i8 %x) { 2395; CHECK-LABEL: @umax_and_mask_negative( 2396; CHECK-NEXT: [[AND1:%.*]] = and i8 [[X:%.*]], 1 2397; CHECK-NEXT: [[AND2:%.*]] = and i8 [[X]], 2 2398; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.umax.i8(i8 [[AND1]], i8 [[AND2]]) 2399; CHECK-NEXT: ret i8 [[VAL]] 2400; 2401 %and1 = and i8 %x, 1 2402 %and2 = and i8 %x, 2 2403 %val = call i8 @llvm.umax.i8(i8 %and1, i8 %and2) 2404 ret i8 %val 2405} 2406 2407define i8 @umin_or_mask_negative(i8 %x) { 2408; CHECK-LABEL: @umin_or_mask_negative( 2409; CHECK-NEXT: [[AND1:%.*]] = or i8 [[X:%.*]], 1 2410; CHECK-NEXT: [[AND2:%.*]] = or i8 [[X]], 2 2411; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.umin.i8(i8 [[AND1]], i8 [[AND2]]) 2412; CHECK-NEXT: ret i8 [[VAL]] 2413; 2414 %and1 = or i8 %x, 1 2415 %and2 = or i8 %x, 2 2416 %val = call i8 @llvm.umin.i8(i8 %and1, i8 %and2) 2417 ret i8 %val 2418} 2419 2420define i8 @umax_or_mask_negative(i8 %x) { 2421; CHECK-LABEL: @umax_or_mask_negative( 2422; CHECK-NEXT: [[AND1:%.*]] = or i8 [[X:%.*]], 1 2423; CHECK-NEXT: [[AND2:%.*]] = or i8 [[X]], 2 2424; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.umax.i8(i8 [[AND1]], i8 [[AND2]]) 2425; CHECK-NEXT: ret i8 [[VAL]] 2426; 2427 %and1 = or i8 %x, 1 2428 %and2 = or i8 %x, 2 2429 %val = call i8 @llvm.umax.i8(i8 %and1, i8 %and2) 2430 ret i8 %val 2431} 2432 2433define i8 @smin_and_mask_subset1(i8 %x) { 2434; CHECK-LABEL: @smin_and_mask_subset1( 2435; CHECK-NEXT: [[AND1:%.*]] = and i8 [[X:%.*]], 1 2436; CHECK-NEXT: ret i8 [[AND1]] 2437; 2438 %and1 = and i8 %x, 1 2439 %and2 = and i8 %x, 3 2440 %val = call i8 @llvm.smin.i8(i8 %and1, i8 %and2) 2441 ret i8 %val 2442} 2443 2444define i8 @smax_and_mask_subset1(i8 %x) { 2445; CHECK-LABEL: @smax_and_mask_subset1( 2446; CHECK-NEXT: [[AND2:%.*]] = and i8 [[X:%.*]], 3 2447; CHECK-NEXT: ret i8 [[AND2]] 2448; 2449 %and1 = and i8 %x, 1 2450 %and2 = and i8 %x, 3 2451 %val = call i8 @llvm.smax.i8(i8 %and1, i8 %and2) 2452 ret i8 %val 2453} 2454 2455define i8 @smin_or_mask_subset1(i8 %x) { 2456; CHECK-LABEL: @smin_or_mask_subset1( 2457; CHECK-NEXT: [[AND1:%.*]] = or i8 [[X:%.*]], 1 2458; CHECK-NEXT: ret i8 [[AND1]] 2459; 2460 %and1 = or i8 %x, 1 2461 %and2 = or i8 %x, 3 2462 %val = call i8 @llvm.smin.i8(i8 %and1, i8 %and2) 2463 ret i8 %val 2464} 2465 2466define i8 @smax_or_mask_subset1(i8 %x) { 2467; CHECK-LABEL: @smax_or_mask_subset1( 2468; CHECK-NEXT: [[AND2:%.*]] = or i8 [[X:%.*]], 3 2469; CHECK-NEXT: ret i8 [[AND2]] 2470; 2471 %and1 = or i8 %x, 1 2472 %and2 = or i8 %x, 3 2473 %val = call i8 @llvm.smax.i8(i8 %and1, i8 %and2) 2474 ret i8 %val 2475} 2476 2477define i8 @smin_and_mask_subset2(i8 %x) { 2478; CHECK-LABEL: @smin_and_mask_subset2( 2479; CHECK-NEXT: [[AND1:%.*]] = and i8 [[X:%.*]], -4 2480; CHECK-NEXT: ret i8 [[AND1]] 2481; 2482 %and1 = and i8 %x, -4 2483 %and2 = and i8 %x, -3 2484 %val = call i8 @llvm.smin.i8(i8 %and1, i8 %and2) 2485 ret i8 %val 2486} 2487 2488define i8 @smax_and_mask_subset2(i8 %x) { 2489; CHECK-LABEL: @smax_and_mask_subset2( 2490; CHECK-NEXT: [[AND2:%.*]] = and i8 [[X:%.*]], -3 2491; CHECK-NEXT: ret i8 [[AND2]] 2492; 2493 %and1 = and i8 %x, -4 2494 %and2 = and i8 %x, -3 2495 %val = call i8 @llvm.smax.i8(i8 %and1, i8 %and2) 2496 ret i8 %val 2497} 2498 2499define i8 @smin_or_mask_subset2(i8 %x) { 2500; CHECK-LABEL: @smin_or_mask_subset2( 2501; CHECK-NEXT: [[AND1:%.*]] = or i8 [[X:%.*]], -4 2502; CHECK-NEXT: ret i8 [[AND1]] 2503; 2504 %and1 = or i8 %x, -4 2505 %and2 = or i8 %x, -3 2506 %val = call i8 @llvm.smin.i8(i8 %and1, i8 %and2) 2507 ret i8 %val 2508} 2509 2510define i8 @smax_or_mask_subset2(i8 %x) { 2511; CHECK-LABEL: @smax_or_mask_subset2( 2512; CHECK-NEXT: [[AND2:%.*]] = or i8 [[X:%.*]], -3 2513; CHECK-NEXT: ret i8 [[AND2]] 2514; 2515 %and1 = or i8 %x, -4 2516 %and2 = or i8 %x, -3 2517 %val = call i8 @llvm.smax.i8(i8 %and1, i8 %and2) 2518 ret i8 %val 2519} 2520 2521define i8 @smin_and_mask_negative(i8 %x) { 2522; CHECK-LABEL: @smin_and_mask_negative( 2523; CHECK-NEXT: [[AND1:%.*]] = and i8 [[X:%.*]], 1 2524; CHECK-NEXT: [[AND2:%.*]] = and i8 [[X]], -3 2525; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.smin.i8(i8 [[AND1]], i8 [[AND2]]) 2526; CHECK-NEXT: ret i8 [[VAL]] 2527; 2528 %and1 = and i8 %x, 1 2529 %and2 = and i8 %x, -3 2530 %val = call i8 @llvm.smin.i8(i8 %and1, i8 %and2) 2531 ret i8 %val 2532} 2533 2534define i8 @smax_and_mask_negative(i8 %x) { 2535; CHECK-LABEL: @smax_and_mask_negative( 2536; CHECK-NEXT: [[AND1:%.*]] = and i8 [[X:%.*]], 1 2537; CHECK-NEXT: [[AND2:%.*]] = and i8 [[X]], -3 2538; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.smax.i8(i8 [[AND1]], i8 [[AND2]]) 2539; CHECK-NEXT: ret i8 [[VAL]] 2540; 2541 %and1 = and i8 %x, 1 2542 %and2 = and i8 %x, -3 2543 %val = call i8 @llvm.smax.i8(i8 %and1, i8 %and2) 2544 ret i8 %val 2545} 2546 2547define i8 @smin_or_mask_negative(i8 %x) { 2548; CHECK-LABEL: @smin_or_mask_negative( 2549; CHECK-NEXT: [[AND1:%.*]] = or i8 [[X:%.*]], 1 2550; CHECK-NEXT: [[AND2:%.*]] = or i8 [[X]], -3 2551; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.smin.i8(i8 [[AND1]], i8 [[AND2]]) 2552; CHECK-NEXT: ret i8 [[VAL]] 2553; 2554 %and1 = or i8 %x, 1 2555 %and2 = or i8 %x, -3 2556 %val = call i8 @llvm.smin.i8(i8 %and1, i8 %and2) 2557 ret i8 %val 2558} 2559 2560define i8 @smax_or_mask_negative(i8 %x) { 2561; CHECK-LABEL: @smax_or_mask_negative( 2562; CHECK-NEXT: [[AND1:%.*]] = or i8 [[X:%.*]], 1 2563; CHECK-NEXT: [[AND2:%.*]] = or i8 [[X]], -3 2564; CHECK-NEXT: [[VAL:%.*]] = call i8 @llvm.smax.i8(i8 [[AND1]], i8 [[AND2]]) 2565; CHECK-NEXT: ret i8 [[VAL]] 2566; 2567 %and1 = or i8 %x, 1 2568 %and2 = or i8 %x, -3 2569 %val = call i8 @llvm.smax.i8(i8 %and1, i8 %and2) 2570 ret i8 %val 2571} 2572