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