1; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck %s 2 3; Test that basic 64-bit integer operations assemble as expected. 4 5target triple = "wasm32-unknown-unknown" 6 7declare i64 @llvm.ctlz.i64(i64, i1) 8declare i64 @llvm.cttz.i64(i64, i1) 9declare i64 @llvm.ctpop.i64(i64) 10 11; CHECK-LABEL: add64: 12; CHECK-NEXT: .functype add64 (i64, i64) -> (i64){{$}} 13; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 14; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 15; CHECK-NEXT: i64.add $push0=, $pop[[L0]], $pop[[L1]]{{$}} 16; CHECK-NEXT: return $pop0{{$}} 17define i64 @add64(i64 %x, i64 %y) { 18 %a = add i64 %x, %y 19 ret i64 %a 20} 21 22; CHECK-LABEL: sub64: 23; CHECK-NEXT: .functype sub64 (i64, i64) -> (i64){{$}} 24; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 25; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 26; CHECK-NEXT: i64.sub $push0=, $pop[[L0]], $pop[[L1]]{{$}} 27; CHECK-NEXT: return $pop0{{$}} 28define i64 @sub64(i64 %x, i64 %y) { 29 %a = sub i64 %x, %y 30 ret i64 %a 31} 32 33; CHECK-LABEL: mul64: 34; CHECK-NEXT: .functype mul64 (i64, i64) -> (i64){{$}} 35; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 36; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 37; CHECK-NEXT: i64.mul $push0=, $pop[[L0]], $pop[[L1]]{{$}} 38; CHECK-NEXT: return $pop0{{$}} 39define i64 @mul64(i64 %x, i64 %y) { 40 %a = mul i64 %x, %y 41 ret i64 %a 42} 43 44; CHECK-LABEL: sdiv64: 45; CHECK-NEXT: .functype sdiv64 (i64, i64) -> (i64){{$}} 46; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 47; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 48; CHECK-NEXT: i64.div_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} 49; CHECK-NEXT: return $pop0{{$}} 50define i64 @sdiv64(i64 %x, i64 %y) { 51 %a = sdiv i64 %x, %y 52 ret i64 %a 53} 54 55; CHECK-LABEL: udiv64: 56; CHECK-NEXT: .functype udiv64 (i64, i64) -> (i64){{$}} 57; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 58; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 59; CHECK-NEXT: i64.div_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} 60; CHECK-NEXT: return $pop0{{$}} 61define i64 @udiv64(i64 %x, i64 %y) { 62 %a = udiv i64 %x, %y 63 ret i64 %a 64} 65 66; CHECK-LABEL: srem64: 67; CHECK-NEXT: .functype srem64 (i64, i64) -> (i64){{$}} 68; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 69; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 70; CHECK-NEXT: i64.rem_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} 71; CHECK-NEXT: return $pop0{{$}} 72define i64 @srem64(i64 %x, i64 %y) { 73 %a = srem i64 %x, %y 74 ret i64 %a 75} 76 77; CHECK-LABEL: urem64: 78; CHECK-NEXT: .functype urem64 (i64, i64) -> (i64){{$}} 79; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 80; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 81; CHECK-NEXT: i64.rem_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} 82; CHECK-NEXT: return $pop0{{$}} 83define i64 @urem64(i64 %x, i64 %y) { 84 %a = urem i64 %x, %y 85 ret i64 %a 86} 87 88; CHECK-LABEL: and64: 89; CHECK-NEXT: .functype and64 (i64, i64) -> (i64){{$}} 90; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 91; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 92; CHECK-NEXT: i64.and $push0=, $pop[[L0]], $pop[[L1]]{{$}} 93; CHECK-NEXT: return $pop0{{$}} 94define i64 @and64(i64 %x, i64 %y) { 95 %a = and i64 %x, %y 96 ret i64 %a 97} 98 99; CHECK-LABEL: or64: 100; CHECK-NEXT: .functype or64 (i64, i64) -> (i64){{$}} 101; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 102; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 103; CHECK-NEXT: i64.or $push0=, $pop[[L0]], $pop[[L1]]{{$}} 104; CHECK-NEXT: return $pop0{{$}} 105define i64 @or64(i64 %x, i64 %y) { 106 %a = or i64 %x, %y 107 ret i64 %a 108} 109 110; CHECK-LABEL: xor64: 111; CHECK-NEXT: .functype xor64 (i64, i64) -> (i64){{$}} 112; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 113; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 114; CHECK-NEXT: i64.xor $push0=, $pop[[L0]], $pop[[L1]]{{$}} 115; CHECK-NEXT: return $pop0{{$}} 116define i64 @xor64(i64 %x, i64 %y) { 117 %a = xor i64 %x, %y 118 ret i64 %a 119} 120 121; CHECK-LABEL: shl64: 122; CHECK-NEXT: .functype shl64 (i64, i64) -> (i64){{$}} 123; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 124; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 125; CHECK-NEXT: i64.shl $push0=, $pop[[L0]], $pop[[L1]]{{$}} 126; CHECK-NEXT: return $pop0{{$}} 127define i64 @shl64(i64 %x, i64 %y) { 128 %a = shl i64 %x, %y 129 ret i64 %a 130} 131 132; CHECK-LABEL: shr64: 133; CHECK-NEXT: .functype shr64 (i64, i64) -> (i64){{$}} 134; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 135; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 136; CHECK-NEXT: i64.shr_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} 137; CHECK-NEXT: return $pop0{{$}} 138define i64 @shr64(i64 %x, i64 %y) { 139 %a = lshr i64 %x, %y 140 ret i64 %a 141} 142 143; CHECK-LABEL: sar64: 144; CHECK-NEXT: .functype sar64 (i64, i64) -> (i64){{$}} 145; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 146; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 147; CHECK-NEXT: i64.shr_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} 148; CHECK-NEXT: return $pop0{{$}} 149define i64 @sar64(i64 %x, i64 %y) { 150 %a = ashr i64 %x, %y 151 ret i64 %a 152} 153 154; CHECK-LABEL: clz64: 155; CHECK-NEXT: .functype clz64 (i64) -> (i64){{$}} 156; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 157; CHECK-NEXT: i64.clz $push0=, $pop[[L0]]{{$}} 158; CHECK-NEXT: return $pop0{{$}} 159define i64 @clz64(i64 %x) { 160 %a = call i64 @llvm.ctlz.i64(i64 %x, i1 false) 161 ret i64 %a 162} 163 164; CHECK-LABEL: clz64_zero_undef: 165; CHECK-NEXT: .functype clz64_zero_undef (i64) -> (i64){{$}} 166; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 167; CHECK-NEXT: i64.clz $push0=, $pop[[L0]]{{$}} 168; CHECK-NEXT: return $pop0{{$}} 169define i64 @clz64_zero_undef(i64 %x) { 170 %a = call i64 @llvm.ctlz.i64(i64 %x, i1 true) 171 ret i64 %a 172} 173 174; CHECK-LABEL: ctz64: 175; CHECK-NEXT: .functype ctz64 (i64) -> (i64){{$}} 176; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 177; CHECK-NEXT: i64.ctz $push0=, $pop[[L0]]{{$}} 178; CHECK-NEXT: return $pop0{{$}} 179define i64 @ctz64(i64 %x) { 180 %a = call i64 @llvm.cttz.i64(i64 %x, i1 false) 181 ret i64 %a 182} 183 184; CHECK-LABEL: ctz64_zero_undef: 185; CHECK-NEXT: .functype ctz64_zero_undef (i64) -> (i64){{$}} 186; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 187; CHECK-NEXT: i64.ctz $push0=, $pop[[L0]]{{$}} 188; CHECK-NEXT: return $pop0{{$}} 189define i64 @ctz64_zero_undef(i64 %x) { 190 %a = call i64 @llvm.cttz.i64(i64 %x, i1 true) 191 ret i64 %a 192} 193 194; CHECK-LABEL: popcnt64: 195; CHECK-NEXT: .functype popcnt64 (i64) -> (i64){{$}} 196; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 197; CHECK-NEXT: i64.popcnt $push0=, $pop[[L0]]{{$}} 198; CHECK-NEXT: return $pop0{{$}} 199define i64 @popcnt64(i64 %x) { 200 %a = call i64 @llvm.ctpop.i64(i64 %x) 201 ret i64 %a 202} 203 204; CHECK-LABEL: eqz64: 205; CHECK-NEXT: .functype eqz64 (i64) -> (i32){{$}} 206; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 207; CHECK-NEXT: i64.eqz $push0=, $pop[[L0]]{{$}} 208; CHECK-NEXT: return $pop0{{$}} 209define i32 @eqz64(i64 %x) { 210 %a = icmp eq i64 %x, 0 211 %b = zext i1 %a to i32 212 ret i32 %b 213} 214 215; CHECK-LABEL: rotl: 216; CHECK-NEXT: .functype rotl (i64, i64) -> (i64){{$}} 217; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 218; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 219; CHECK-NEXT: i64.rotl $push0=, $pop[[L0]], $pop[[L1]] 220; CHECK-NEXT: return $pop0{{$}} 221define i64 @rotl(i64 %x, i64 %y) { 222 %z = sub i64 64, %y 223 %b = shl i64 %x, %y 224 %c = lshr i64 %x, %z 225 %d = or i64 %b, %c 226 ret i64 %d 227} 228 229; CHECK-LABEL: masked_rotl: 230; CHECK-NEXT: .functype masked_rotl (i64, i64) -> (i64){{$}} 231; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 232; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 233; CHECK-NEXT: i64.rotl $push0=, $pop[[L0]], $pop[[L1]] 234; CHECK-NEXT: return $pop0{{$}} 235define i64 @masked_rotl(i64 %x, i64 %y) { 236 %a = and i64 %y, 63 237 %z = sub i64 64, %a 238 %b = shl i64 %x, %a 239 %c = lshr i64 %x, %z 240 %d = or i64 %b, %c 241 ret i64 %d 242} 243 244; CHECK-LABEL: rotr: 245; CHECK-NEXT: .functype rotr (i64, i64) -> (i64){{$}} 246; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 247; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 248; CHECK-NEXT: i64.rotr $push0=, $pop[[L0]], $pop[[L1]] 249; CHECK-NEXT: return $pop0{{$}} 250define i64 @rotr(i64 %x, i64 %y) { 251 %z = sub i64 64, %y 252 %b = lshr i64 %x, %y 253 %c = shl i64 %x, %z 254 %d = or i64 %b, %c 255 ret i64 %d 256} 257 258; CHECK-LABEL: masked_rotr: 259; CHECK-NEXT: .functype masked_rotr (i64, i64) -> (i64){{$}} 260; CHECK-NEXT: local.get $push[[L0:[0-9]+]]=, 0{{$}} 261; CHECK-NEXT: local.get $push[[L1:[0-9]+]]=, 1{{$}} 262; CHECK-NEXT: i64.rotr $push0=, $pop[[L0]], $pop[[L1]] 263; CHECK-NEXT: return $pop0{{$}} 264define i64 @masked_rotr(i64 %x, i64 %y) { 265 %a = and i64 %y, 63 266 %z = sub i64 64, %a 267 %b = lshr i64 %x, %a 268 %c = shl i64 %x, %z 269 %d = or i64 %b, %c 270 ret i64 %d 271} 272