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