1; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py 2; RUN: llc -mtriple=i686-unknown-linux-gnu < %s | FileCheck %s --check-prefixes=CHECK,X86 3; RUN: llc -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s --check-prefixes=CHECK,X64 4 5;------------------------------------------------------------------------------; 6; Odd divisors 7;------------------------------------------------------------------------------; 8 9define i32 @test_urem_odd(i32 %X) nounwind { 10; X86-LABEL: test_urem_odd: 11; X86: # %bb.0: 12; X86-NEXT: imull $-858993459, {{[0-9]+}}(%esp), %ecx # imm = 0xCCCCCCCD 13; X86-NEXT: xorl %eax, %eax 14; X86-NEXT: cmpl $858993460, %ecx # imm = 0x33333334 15; X86-NEXT: setb %al 16; X86-NEXT: retl 17; 18; X64-LABEL: test_urem_odd: 19; X64: # %bb.0: 20; X64-NEXT: imull $-858993459, %edi, %ecx # imm = 0xCCCCCCCD 21; X64-NEXT: xorl %eax, %eax 22; X64-NEXT: cmpl $858993460, %ecx # imm = 0x33333334 23; X64-NEXT: setb %al 24; X64-NEXT: retq 25 %urem = urem i32 %X, 5 26 %cmp = icmp eq i32 %urem, 0 27 %ret = zext i1 %cmp to i32 28 ret i32 %ret 29} 30 31define i32 @test_urem_odd_25(i32 %X) nounwind { 32; X86-LABEL: test_urem_odd_25: 33; X86: # %bb.0: 34; X86-NEXT: imull $-1030792151, {{[0-9]+}}(%esp), %ecx # imm = 0xC28F5C29 35; X86-NEXT: xorl %eax, %eax 36; X86-NEXT: cmpl $171798692, %ecx # imm = 0xA3D70A4 37; X86-NEXT: setb %al 38; X86-NEXT: retl 39; 40; X64-LABEL: test_urem_odd_25: 41; X64: # %bb.0: 42; X64-NEXT: imull $-1030792151, %edi, %ecx # imm = 0xC28F5C29 43; X64-NEXT: xorl %eax, %eax 44; X64-NEXT: cmpl $171798692, %ecx # imm = 0xA3D70A4 45; X64-NEXT: setb %al 46; X64-NEXT: retq 47 %urem = urem i32 %X, 25 48 %cmp = icmp eq i32 %urem, 0 49 %ret = zext i1 %cmp to i32 50 ret i32 %ret 51} 52 53; This is like test_urem_odd, except the divisor has bit 30 set. 54define i32 @test_urem_odd_bit30(i32 %X) nounwind { 55; X86-LABEL: test_urem_odd_bit30: 56; X86: # %bb.0: 57; X86-NEXT: imull $1789569707, {{[0-9]+}}(%esp), %ecx # imm = 0x6AAAAAAB 58; X86-NEXT: xorl %eax, %eax 59; X86-NEXT: cmpl $4, %ecx 60; X86-NEXT: setb %al 61; X86-NEXT: retl 62; 63; X64-LABEL: test_urem_odd_bit30: 64; X64: # %bb.0: 65; X64-NEXT: imull $1789569707, %edi, %ecx # imm = 0x6AAAAAAB 66; X64-NEXT: xorl %eax, %eax 67; X64-NEXT: cmpl $4, %ecx 68; X64-NEXT: setb %al 69; X64-NEXT: retq 70 %urem = urem i32 %X, 1073741827 71 %cmp = icmp eq i32 %urem, 0 72 %ret = zext i1 %cmp to i32 73 ret i32 %ret 74} 75 76; This is like test_urem_odd, except the divisor has bit 31 set. 77define i32 @test_urem_odd_bit31(i32 %X) nounwind { 78; X86-LABEL: test_urem_odd_bit31: 79; X86: # %bb.0: 80; X86-NEXT: imull $715827883, {{[0-9]+}}(%esp), %ecx # imm = 0x2AAAAAAB 81; X86-NEXT: xorl %eax, %eax 82; X86-NEXT: cmpl $2, %ecx 83; X86-NEXT: setb %al 84; X86-NEXT: retl 85; 86; X64-LABEL: test_urem_odd_bit31: 87; X64: # %bb.0: 88; X64-NEXT: imull $715827883, %edi, %ecx # imm = 0x2AAAAAAB 89; X64-NEXT: xorl %eax, %eax 90; X64-NEXT: cmpl $2, %ecx 91; X64-NEXT: setb %al 92; X64-NEXT: retq 93 %urem = urem i32 %X, 2147483651 94 %cmp = icmp eq i32 %urem, 0 95 %ret = zext i1 %cmp to i32 96 ret i32 %ret 97} 98 99;------------------------------------------------------------------------------; 100; Even divisors 101;------------------------------------------------------------------------------; 102 103define i16 @test_urem_even(i16 %X) nounwind { 104; X86-LABEL: test_urem_even: 105; X86: # %bb.0: 106; X86-NEXT: imull $28087, {{[0-9]+}}(%esp), %eax # imm = 0x6DB7 107; X86-NEXT: rorw %ax 108; X86-NEXT: movzwl %ax, %ecx 109; X86-NEXT: xorl %eax, %eax 110; X86-NEXT: cmpl $4682, %ecx # imm = 0x124A 111; X86-NEXT: setae %al 112; X86-NEXT: # kill: def $ax killed $ax killed $eax 113; X86-NEXT: retl 114; 115; X64-LABEL: test_urem_even: 116; X64: # %bb.0: 117; X64-NEXT: imull $28087, %edi, %eax # imm = 0x6DB7 118; X64-NEXT: rorw %ax 119; X64-NEXT: movzwl %ax, %ecx 120; X64-NEXT: xorl %eax, %eax 121; X64-NEXT: cmpl $4682, %ecx # imm = 0x124A 122; X64-NEXT: setae %al 123; X64-NEXT: # kill: def $ax killed $ax killed $eax 124; X64-NEXT: retq 125 %urem = urem i16 %X, 14 126 %cmp = icmp ne i16 %urem, 0 127 %ret = zext i1 %cmp to i16 128 ret i16 %ret 129} 130 131define i32 @test_urem_even_100(i32 %X) nounwind { 132; X86-LABEL: test_urem_even_100: 133; X86: # %bb.0: 134; X86-NEXT: imull $-1030792151, {{[0-9]+}}(%esp), %ecx # imm = 0xC28F5C29 135; X86-NEXT: rorl $2, %ecx 136; X86-NEXT: xorl %eax, %eax 137; X86-NEXT: cmpl $42949673, %ecx # imm = 0x28F5C29 138; X86-NEXT: setb %al 139; X86-NEXT: retl 140; 141; X64-LABEL: test_urem_even_100: 142; X64: # %bb.0: 143; X64-NEXT: imull $-1030792151, %edi, %ecx # imm = 0xC28F5C29 144; X64-NEXT: rorl $2, %ecx 145; X64-NEXT: xorl %eax, %eax 146; X64-NEXT: cmpl $42949673, %ecx # imm = 0x28F5C29 147; X64-NEXT: setb %al 148; X64-NEXT: retq 149 %urem = urem i32 %X, 100 150 %cmp = icmp eq i32 %urem, 0 151 %ret = zext i1 %cmp to i32 152 ret i32 %ret 153} 154 155; This is like test_urem_even, except the divisor has bit 30 set. 156define i32 @test_urem_even_bit30(i32 %X) nounwind { 157; X86-LABEL: test_urem_even_bit30: 158; X86: # %bb.0: 159; X86-NEXT: imull $-51622203, {{[0-9]+}}(%esp), %ecx # imm = 0xFCEC4EC5 160; X86-NEXT: rorl $3, %ecx 161; X86-NEXT: xorl %eax, %eax 162; X86-NEXT: cmpl $4, %ecx 163; X86-NEXT: setb %al 164; X86-NEXT: retl 165; 166; X64-LABEL: test_urem_even_bit30: 167; X64: # %bb.0: 168; X64-NEXT: imull $-51622203, %edi, %ecx # imm = 0xFCEC4EC5 169; X64-NEXT: rorl $3, %ecx 170; X64-NEXT: xorl %eax, %eax 171; X64-NEXT: cmpl $4, %ecx 172; X64-NEXT: setb %al 173; X64-NEXT: retq 174 %urem = urem i32 %X, 1073741928 175 %cmp = icmp eq i32 %urem, 0 176 %ret = zext i1 %cmp to i32 177 ret i32 %ret 178} 179 180; This is like test_urem_odd, except the divisor has bit 31 set. 181define i32 @test_urem_even_bit31(i32 %X) nounwind { 182; X86-LABEL: test_urem_even_bit31: 183; X86: # %bb.0: 184; X86-NEXT: imull $-1157956869, {{[0-9]+}}(%esp), %ecx # imm = 0xBAFAFAFB 185; X86-NEXT: rorl %ecx 186; X86-NEXT: xorl %eax, %eax 187; X86-NEXT: cmpl $2, %ecx 188; X86-NEXT: setb %al 189; X86-NEXT: retl 190; 191; X64-LABEL: test_urem_even_bit31: 192; X64: # %bb.0: 193; X64-NEXT: imull $-1157956869, %edi, %ecx # imm = 0xBAFAFAFB 194; X64-NEXT: rorl %ecx 195; X64-NEXT: xorl %eax, %eax 196; X64-NEXT: cmpl $2, %ecx 197; X64-NEXT: setb %al 198; X64-NEXT: retq 199 %urem = urem i32 %X, 2147483750 200 %cmp = icmp eq i32 %urem, 0 201 %ret = zext i1 %cmp to i32 202 ret i32 %ret 203} 204 205;------------------------------------------------------------------------------; 206; Special case 207;------------------------------------------------------------------------------; 208 209; 'NE' predicate is fine too. 210define i32 @test_urem_odd_setne(i32 %X) nounwind { 211; X86-LABEL: test_urem_odd_setne: 212; X86: # %bb.0: 213; X86-NEXT: imull $-858993459, {{[0-9]+}}(%esp), %ecx # imm = 0xCCCCCCCD 214; X86-NEXT: xorl %eax, %eax 215; X86-NEXT: cmpl $858993460, %ecx # imm = 0x33333334 216; X86-NEXT: setae %al 217; X86-NEXT: retl 218; 219; X64-LABEL: test_urem_odd_setne: 220; X64: # %bb.0: 221; X64-NEXT: imull $-858993459, %edi, %ecx # imm = 0xCCCCCCCD 222; X64-NEXT: xorl %eax, %eax 223; X64-NEXT: cmpl $858993460, %ecx # imm = 0x33333334 224; X64-NEXT: setae %al 225; X64-NEXT: retq 226 %urem = urem i32 %X, 5 227 %cmp = icmp ne i32 %urem, 0 228 %ret = zext i1 %cmp to i32 229 ret i32 %ret 230} 231 232; The fold is only valid for positive divisors, negative-ones should be negated. 233define i32 @test_urem_negative_odd(i32 %X) nounwind { 234; X86-LABEL: test_urem_negative_odd: 235; X86: # %bb.0: 236; X86-NEXT: imull $858993459, {{[0-9]+}}(%esp), %ecx # imm = 0x33333333 237; X86-NEXT: xorl %eax, %eax 238; X86-NEXT: cmpl $2, %ecx 239; X86-NEXT: setae %al 240; X86-NEXT: retl 241; 242; X64-LABEL: test_urem_negative_odd: 243; X64: # %bb.0: 244; X64-NEXT: imull $858993459, %edi, %ecx # imm = 0x33333333 245; X64-NEXT: xorl %eax, %eax 246; X64-NEXT: cmpl $2, %ecx 247; X64-NEXT: setae %al 248; X64-NEXT: retq 249 %urem = urem i32 %X, -5 250 %cmp = icmp ne i32 %urem, 0 251 %ret = zext i1 %cmp to i32 252 ret i32 %ret 253} 254define i32 @test_urem_negative_even(i32 %X) nounwind { 255; X86-LABEL: test_urem_negative_even: 256; X86: # %bb.0: 257; X86-NEXT: imull $-920350135, {{[0-9]+}}(%esp), %ecx # imm = 0xC9249249 258; X86-NEXT: rorl %ecx 259; X86-NEXT: xorl %eax, %eax 260; X86-NEXT: cmpl $2, %ecx 261; X86-NEXT: setae %al 262; X86-NEXT: retl 263; 264; X64-LABEL: test_urem_negative_even: 265; X64: # %bb.0: 266; X64-NEXT: imull $-920350135, %edi, %ecx # imm = 0xC9249249 267; X64-NEXT: rorl %ecx 268; X64-NEXT: xorl %eax, %eax 269; X64-NEXT: cmpl $2, %ecx 270; X64-NEXT: setae %al 271; X64-NEXT: retq 272 %urem = urem i32 %X, -14 273 %cmp = icmp ne i32 %urem, 0 274 %ret = zext i1 %cmp to i32 275 ret i32 %ret 276} 277 278;------------------------------------------------------------------------------; 279; Negative tests 280;------------------------------------------------------------------------------; 281 282; We can lower remainder of division by one much better elsewhere. 283define i32 @test_urem_one(i32 %X) nounwind { 284; CHECK-LABEL: test_urem_one: 285; CHECK: # %bb.0: 286; CHECK-NEXT: movl $1, %eax 287; CHECK-NEXT: ret{{[l|q]}} 288 %urem = urem i32 %X, 1 289 %cmp = icmp eq i32 %urem, 0 290 %ret = zext i1 %cmp to i32 291 ret i32 %ret 292} 293 294; We can lower remainder of division by powers of two much better elsewhere. 295define i32 @test_urem_pow2(i32 %X) nounwind { 296; X86-LABEL: test_urem_pow2: 297; X86: # %bb.0: 298; X86-NEXT: xorl %eax, %eax 299; X86-NEXT: testb $15, {{[0-9]+}}(%esp) 300; X86-NEXT: sete %al 301; X86-NEXT: retl 302; 303; X64-LABEL: test_urem_pow2: 304; X64: # %bb.0: 305; X64-NEXT: xorl %eax, %eax 306; X64-NEXT: testb $15, %dil 307; X64-NEXT: sete %al 308; X64-NEXT: retq 309 %urem = urem i32 %X, 16 310 %cmp = icmp eq i32 %urem, 0 311 %ret = zext i1 %cmp to i32 312 ret i32 %ret 313} 314 315; The fold is only valid for positive divisors, and we can't negate INT_MIN. 316define i32 @test_urem_int_min(i32 %X) nounwind { 317; X86-LABEL: test_urem_int_min: 318; X86: # %bb.0: 319; X86-NEXT: xorl %eax, %eax 320; X86-NEXT: testl $2147483647, {{[0-9]+}}(%esp) # imm = 0x7FFFFFFF 321; X86-NEXT: sete %al 322; X86-NEXT: retl 323; 324; X64-LABEL: test_urem_int_min: 325; X64: # %bb.0: 326; X64-NEXT: xorl %eax, %eax 327; X64-NEXT: testl $2147483647, %edi # imm = 0x7FFFFFFF 328; X64-NEXT: sete %al 329; X64-NEXT: retq 330 %urem = urem i32 %X, 2147483648 331 %cmp = icmp eq i32 %urem, 0 332 %ret = zext i1 %cmp to i32 333 ret i32 %ret 334} 335 336; We can lower remainder of division by all-ones much better elsewhere. 337define i32 @test_urem_allones(i32 %X) nounwind { 338; X86-LABEL: test_urem_allones: 339; X86: # %bb.0: 340; X86-NEXT: xorl %ecx, %ecx 341; X86-NEXT: subl {{[0-9]+}}(%esp), %ecx 342; X86-NEXT: xorl %eax, %eax 343; X86-NEXT: cmpl $2, %ecx 344; X86-NEXT: setb %al 345; X86-NEXT: retl 346; 347; X64-LABEL: test_urem_allones: 348; X64: # %bb.0: 349; X64-NEXT: negl %edi 350; X64-NEXT: xorl %eax, %eax 351; X64-NEXT: cmpl $2, %edi 352; X64-NEXT: setb %al 353; X64-NEXT: retq 354 %urem = urem i32 %X, 4294967295 355 %cmp = icmp eq i32 %urem, 0 356 %ret = zext i1 %cmp to i32 357 ret i32 %ret 358} 359 360; Check illegal types. 361 362; https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=34366 363define void @ossfuzz34366() { 364; X86-LABEL: ossfuzz34366: 365; X86: # %bb.0: 366; X86-NEXT: movl (%eax), %eax 367; X86-NEXT: movl %eax, %ecx 368; X86-NEXT: andl $2147483647, %ecx # imm = 0x7FFFFFFF 369; X86-NEXT: orl %eax, %ecx 370; X86-NEXT: orl %eax, %ecx 371; X86-NEXT: orl %eax, %ecx 372; X86-NEXT: orl %eax, %ecx 373; X86-NEXT: sete (%eax) 374; X86-NEXT: retl 375; 376; X64-LABEL: ossfuzz34366: 377; X64: # %bb.0: 378; X64-NEXT: movq (%rax), %rax 379; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF 380; X64-NEXT: andq %rax, %rcx 381; X64-NEXT: orq %rax, %rcx 382; X64-NEXT: orq %rax, %rcx 383; X64-NEXT: orq %rax, %rcx 384; X64-NEXT: sete (%rax) 385; X64-NEXT: retq 386 %L10 = load i448, i448* undef, align 4 387 %B18 = urem i448 %L10, -363419362147803445274661903944002267176820680343659030140745099590319644056698961663095525356881782780381260803133088966767300814307328 388 %C13 = icmp ule i448 %B18, 0 389 store i1 %C13, i1* undef, align 1 390 ret void 391} 392