1; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers | FileCheck %s 2 3; Test that basic immediates assemble as expected. 4 5target triple = "wasm32-unknown-unknown" 6 7; CHECK-LABEL: zero_i32: 8; CHECK-NEXT: .functype zero_i32 () -> (i32){{$}} 9; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 0{{$}} 10; CHECK-NEXT: return $pop[[NUM]]{{$}} 11define i32 @zero_i32() { 12 ret i32 0 13} 14 15; CHECK-LABEL: one_i32: 16; CHECK-NEXT: .functype one_i32 () -> (i32){{$}} 17; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 1{{$}} 18; CHECK-NEXT: return $pop[[NUM]]{{$}} 19define i32 @one_i32() { 20 ret i32 1 21} 22 23; CHECK-LABEL: max_i32: 24; CHECK-NEXT: .functype max_i32 () -> (i32){{$}} 25; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 2147483647{{$}} 26; CHECK-NEXT: return $pop[[NUM]]{{$}} 27define i32 @max_i32() { 28 ret i32 2147483647 29} 30 31; CHECK-LABEL: min_i32: 32; CHECK-NEXT: .functype min_i32 () -> (i32){{$}} 33; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, -2147483648{{$}} 34; CHECK-NEXT: return $pop[[NUM]]{{$}} 35define i32 @min_i32() { 36 ret i32 -2147483648 37} 38 39; CHECK-LABEL: zero_i64: 40; CHECK-NEXT: .functype zero_i64 () -> (i64){{$}} 41; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 0{{$}} 42; CHECK-NEXT: return $pop[[NUM]]{{$}} 43define i64 @zero_i64() { 44 ret i64 0 45} 46 47; CHECK-LABEL: one_i64: 48; CHECK-NEXT: .functype one_i64 () -> (i64){{$}} 49; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 1{{$}} 50; CHECK-NEXT: return $pop[[NUM]]{{$}} 51define i64 @one_i64() { 52 ret i64 1 53} 54 55; CHECK-LABEL: max_i64: 56; CHECK-NEXT: .functype max_i64 () -> (i64){{$}} 57; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 9223372036854775807{{$}} 58; CHECK-NEXT: return $pop[[NUM]]{{$}} 59define i64 @max_i64() { 60 ret i64 9223372036854775807 61} 62 63; CHECK-LABEL: min_i64: 64; CHECK-NEXT: .functype min_i64 () -> (i64){{$}} 65; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, -9223372036854775808{{$}} 66; CHECK-NEXT: return $pop[[NUM]]{{$}} 67define i64 @min_i64() { 68 ret i64 -9223372036854775808 69} 70 71; CHECK-LABEL: negzero_f32: 72; CHECK-NEXT: .functype negzero_f32 () -> (f32){{$}} 73; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -0x0p0{{$}} 74; CHECK-NEXT: return $pop[[NUM]]{{$}} 75define float @negzero_f32() { 76 ret float -0.0 77} 78 79; CHECK-LABEL: zero_f32: 80; CHECK-NEXT: .functype zero_f32 () -> (f32){{$}} 81; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x0p0{{$}} 82; CHECK-NEXT: return $pop[[NUM]]{{$}} 83define float @zero_f32() { 84 ret float 0.0 85} 86 87; CHECK-LABEL: one_f32: 88; CHECK-NEXT: .functype one_f32 () -> (f32){{$}} 89; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x1p0{{$}} 90; CHECK-NEXT: return $pop[[NUM]]{{$}} 91define float @one_f32() { 92 ret float 1.0 93} 94 95; CHECK-LABEL: two_f32: 96; CHECK-NEXT: .functype two_f32 () -> (f32){{$}} 97; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x1p1{{$}} 98; CHECK-NEXT: return $pop[[NUM]]{{$}} 99define float @two_f32() { 100 ret float 2.0 101} 102 103; CHECK-LABEL: nan_f32: 104; CHECK-NEXT: .functype nan_f32 () -> (f32){{$}} 105; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, nan{{$}} 106; CHECK-NEXT: return $pop[[NUM]]{{$}} 107define float @nan_f32() { 108 ret float 0x7FF8000000000000 109} 110 111; CHECK-LABEL: negnan_f32: 112; CHECK-NEXT: .functype negnan_f32 () -> (f32){{$}} 113; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan{{$}} 114; CHECK-NEXT: return $pop[[NUM]]{{$}} 115define float @negnan_f32() { 116 ret float 0xFFF8000000000000 117} 118 119; CHECK-LABEL: inf_f32: 120; CHECK-NEXT: .functype inf_f32 () -> (f32){{$}} 121; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, infinity{{$}} 122; CHECK-NEXT: return $pop[[NUM]]{{$}} 123define float @inf_f32() { 124 ret float 0x7FF0000000000000 125} 126 127; CHECK-LABEL: neginf_f32: 128; CHECK-NEXT: .functype neginf_f32 () -> (f32){{$}} 129; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -infinity{{$}} 130; CHECK-NEXT: return $pop[[NUM]]{{$}} 131define float @neginf_f32() { 132 ret float 0xFFF0000000000000 133} 134 135; CHECK-LABEL: custom_nan_f32: 136; CHECK-NEXT: .functype custom_nan_f32 () -> (f32){{$}} 137; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan:0x6bcdef{{$}} 138; CHECK-NEXT: return $pop[[NUM]]{{$}} 139define float @custom_nan_f32() { 140 ret float 0xFFFD79BDE0000000 141} 142 143; CHECK-LABEL: custom_nans_f32: 144; CHECK-NEXT: .functype custom_nans_f32 () -> (f32){{$}} 145; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan:0x2bcdef{{$}} 146; CHECK-NEXT: return $pop[[NUM]]{{$}} 147define float @custom_nans_f32() { 148 ret float 0xFFF579BDE0000000 149} 150 151; CHECK-LABEL: negzero_f64: 152; CHECK-NEXT: .functype negzero_f64 () -> (f64){{$}} 153; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -0x0p0{{$}} 154; CHECK-NEXT: return $pop[[NUM]]{{$}} 155define double @negzero_f64() { 156 ret double -0.0 157} 158 159; CHECK-LABEL: zero_f64: 160; CHECK-NEXT: .functype zero_f64 () -> (f64){{$}} 161; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x0p0{{$}} 162; CHECK-NEXT: return $pop[[NUM]]{{$}} 163define double @zero_f64() { 164 ret double 0.0 165} 166 167; CHECK-LABEL: one_f64: 168; CHECK-NEXT: .functype one_f64 () -> (f64){{$}} 169; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x1p0{{$}} 170; CHECK-NEXT: return $pop[[NUM]]{{$}} 171define double @one_f64() { 172 ret double 1.0 173} 174 175; CHECK-LABEL: two_f64: 176; CHECK-NEXT: .functype two_f64 () -> (f64){{$}} 177; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x1p1{{$}} 178; CHECK-NEXT: return $pop[[NUM]]{{$}} 179define double @two_f64() { 180 ret double 2.0 181} 182 183; CHECK-LABEL: nan_f64: 184; CHECK-NEXT: .functype nan_f64 () -> (f64){{$}} 185; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, nan{{$}} 186; CHECK-NEXT: return $pop[[NUM]]{{$}} 187define double @nan_f64() { 188 ret double 0x7FF8000000000000 189} 190 191; CHECK-LABEL: negnan_f64: 192; CHECK-NEXT: .functype negnan_f64 () -> (f64){{$}} 193; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan{{$}} 194; CHECK-NEXT: return $pop[[NUM]]{{$}} 195define double @negnan_f64() { 196 ret double 0xFFF8000000000000 197} 198 199; CHECK-LABEL: inf_f64: 200; CHECK-NEXT: .functype inf_f64 () -> (f64){{$}} 201; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, infinity{{$}} 202; CHECK-NEXT: return $pop[[NUM]]{{$}} 203define double @inf_f64() { 204 ret double 0x7FF0000000000000 205} 206 207; CHECK-LABEL: neginf_f64: 208; CHECK-NEXT: .functype neginf_f64 () -> (f64){{$}} 209; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -infinity{{$}} 210; CHECK-NEXT: return $pop[[NUM]]{{$}} 211define double @neginf_f64() { 212 ret double 0xFFF0000000000000 213} 214 215;; Custom NaN playloads are currently not always preserved because of the use of 216;; native doubles in the MC layer. TODO: fix this problem or decide we don't 217;; care about preserving NaN payloads. 218 219; XXX-CHECK-LABEL: custom_nan_f64: 220; XXX-CHECK-NEXT: .functype custom_nan_f64 () -> (f64){{$}} 221; XXX-CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan:0xabcdef0123456{{$}} 222; XXX-CHECK-NEXT: return $pop[[NUM]]{{$}} 223; define double @custom_nan_f64() { 224; ret double 0xFFFABCDEF0123456 225; } 226 227; XXX-CHECK-LABEL: custom_nans_f64: 228; XXX-CHECK-NEXT: .functype custom_nans_f64 () -> (f64){{$}} 229; XXX-CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan:0x2bcdef0123456{{$}} 230; XXX-CHECK-NEXT: return $pop[[NUM]]{{$}} 231; define double @custom_nans_f64() { 232; ret double 0xFFF2BCDEF0123456 233; } 234