test/CodeGen/JS/simd-shuffle.ll - Issue 1692803002: Remove Emscripten support

Side by Side Diff: test/CodeGen/JS/simd-shuffle.ll

Issue 1692803002: Remove Emscripten support (Closed) Base URL: https://chromium.googlesource.com/a/native_client/pnacl-llvm.git@master

Patch Set: Created 4 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 ; RUN: llc < %s \| FileCheck %s

2

3 target datalayout = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64 :64:64-p:32:32:32-v128:32:128-n32-S128"

4 target triple = "asmjs-unknown-emscripten"

5

6 ; CHECK: function _splat_int32x4($a,$b) {

7 ; CHECK: $a = SIMD_int32x4_check($a);

8 ; CHECK: $b = SIMD_int32x4_check($b);

9 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

10 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 0, 0, 0);

11 ; CHECK: return (SIMD_int32x4_check($sel));

12 ; CHECK: }

13 define <4 x i32> @splat_int32x4(<4 x i32> %a, <4 x i32> %b) nounwind {

14 entry:

15 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32><i32 0, i32 0, i32 0 , i32 0>

16 ret <4 x i32> %sel

17 }

18

19 ; CHECK: function _swizzle_int32x4($a,$b) {

20 ; CHECK: $a = SIMD_int32x4_check($a);

21 ; CHECK: $b = SIMD_int32x4_check($b);

22 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

23 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 3, 1, 2);

24 ; CHECK: return (SIMD_int32x4_check($sel));

25 ; CHECK: }

26 define <4 x i32> @swizzle_int32x4(<4 x i32> %a, <4 x i32> %b) nounwind {

27 entry:

28 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32><i32 0, i32 3, i32 1 , i32 2>

29 ret <4 x i32> %sel

30 }

31

32 ; CHECK: function _swizzlehi_int32x4($a,$b) {

33 ; CHECK: $a = SIMD_int32x4_check($a);

34 ; CHECK: $b = SIMD_int32x4_check($b);

35 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

36 ; CHECK: $sel = SIMD_int32x4_swizzle($b, 2, 1, 3, 0);

37 ; CHECK: return (SIMD_int32x4_check($sel));

38 ; CHECK: }

39 define <4 x i32> @swizzlehi_int32x4(<4 x i32> %a, <4 x i32> %b) nounwind {

40 entry:

41 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32><i32 6, i32 5, i32 7 , i32 4>

42 ret <4 x i32> %sel

43 }

44

45 ; CHECK: function _shuffleXY_float32x4to3($a,$b) {

46 ; CHECK: $a = SIMD_float32x4_check($a);

47 ; CHECK: $b = SIMD_float32x4_check($b);

48 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

49 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 7, 0, 0);

50 ; CHECK: return (SIMD_float32x4_check($sel));

51 ; CHECK: }

52 define <3 x float> @shuffleXY_float32x4to3(<4 x float> %a, <4 x float> %b) nounw ind {

53 entry:

54 %sel = shufflevector <4 x float> %a, <4 x float> %b, <3 x i32><i32 7, i32 0, i 32 undef>

55 ret <3 x float> %sel

56 }

57

58 ; CHECK: function _shuffle_int32x4($a,$b) {

59 ; CHECK: $a = SIMD_int32x4_check($a);

60 ; CHECK: $b = SIMD_int32x4_check($b);

61 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

62 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 7, 0, 5, 3);

63 ; CHECK: return (SIMD_int32x4_check($sel));

64 ; CHECK: }

65 define <4 x i32> @shuffle_int32x4(<4 x i32> %a, <4 x i32> %b) nounwind {

66 entry:

67 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32><i32 7, i32 0, i32 5 , i32 3>

68 ret <4 x i32> %sel

69 }

70

71 ; CHECK: function _shuffleXY_int32x4($a,$b) {

72 ; CHECK: $a = SIMD_int32x4_check($a);

73 ; CHECK: $b = SIMD_int32x4_check($b);

74 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

75 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 7, 0, 0, 0);

76 ; CHECK: return (SIMD_int32x4_check($sel));

77 ; CHECK: }

78 define <4 x i32> @shuffleXY_int32x4(<4 x i32> %a, <4 x i32> %b) nounwind {

79 entry:

80 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32><i32 7, i32 0, i32 u ndef, i32 undef>

81 ret <4 x i32> %sel

82 }

83

84 ; CHECK: function _splat_int32x3($a,$b) {

85 ; CHECK: $a = SIMD_int32x4_check($a);

86 ; CHECK: $b = SIMD_int32x4_check($b);

87 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

88 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 0, 0, 0);

89 ; CHECK: return (SIMD_int32x4_check($sel));

90 ; CHECK: }

91 define <3 x i32> @splat_int32x3(<3 x i32> %a, <3 x i32> %b) nounwind {

92 entry:

93 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <3 x i32><i32 0, i32 0, i32 0 >

94 ret <3 x i32> %sel

95 }

96

97 ; CHECK: function _swizzle_int32x3($a,$b) {

98 ; CHECK: $a = SIMD_int32x4_check($a);

99 ; CHECK: $b = SIMD_int32x4_check($b);

100 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

101 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 2, 1, 0);

102 ; CHECK: return (SIMD_int32x4_check($sel));

103 ; CHECK: }

104 define <3 x i32> @swizzle_int32x3(<3 x i32> %a, <3 x i32> %b) nounwind {

105 entry:

106 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <3 x i32><i32 0, i32 2, i32 1 >

107 ret <3 x i32> %sel

108 }

109

110 ; CHECK: function _swizzlehi_int32x3($a,$b) {

111 ; CHECK: $a = SIMD_int32x4_check($a);

112 ; CHECK: $b = SIMD_int32x4_check($b);

113 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

114 ; CHECK: $sel = SIMD_int32x4_swizzle($b, 0, 2, 1, 0);

115 ; CHECK: return (SIMD_int32x4_check($sel));

116 ; CHECK: }

117 define <3 x i32> @swizzlehi_int32x3(<3 x i32> %a, <3 x i32> %b) nounwind {

118 entry:

119 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <3 x i32><i32 3, i32 5, i32 4 >

120 ret <3 x i32> %sel

121 }

122

123 ; CHECK: function _shuffle_int32x3($a,$b) {

124 ; CHECK: $a = SIMD_int32x4_check($a);

125 ; CHECK: $b = SIMD_int32x4_check($b);

126 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

127 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 6, 0, 5);

128 ; CHECK: return (SIMD_int32x4_check($sel));

129 ; CHECK: }

130 define <3 x i32> @shuffle_int32x3(<3 x i32> %a, <3 x i32> %b) nounwind {

131 entry:

132 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <3 x i32><i32 5, i32 0, i32 4 >

133 ret <3 x i32> %sel

134 }

135

136 ; CHECK: function _shuffleXY_int32x3($a,$b) {

137 ; CHECK: $a = SIMD_int32x4_check($a);

138 ; CHECK: $b = SIMD_int32x4_check($b);

139 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

140 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 6, 0, 0);

141 ; CHECK: return (SIMD_int32x4_check($sel));

142 ; CHECK: }

143 define <3 x i32> @shuffleXY_int32x3(<3 x i32> %a, <3 x i32> %b) nounwind {

144 entry:

145 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <3 x i32><i32 5, i32 0, i32 u ndef>

146 ret <3 x i32> %sel

147 }

148

149 ; CHECK: function _splat_int32x3to4($a,$b) {

150 ; CHECK: $a = SIMD_int32x4_check($a);

151 ; CHECK: $b = SIMD_int32x4_check($b);

152 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

153 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 0, 0, 0);

154 ; CHECK: return (SIMD_int32x4_check($sel));

155 ; CHECK: }

156 define <4 x i32> @splat_int32x3to4(<3 x i32> %a, <3 x i32> %b) nounwind {

157 entry:

158 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <4 x i32><i32 0, i32 0, i32 0 , i32 0>

159 ret <4 x i32> %sel

160 }

161

162 ; CHECK: function _swizzle_int32x3to4($a,$b) {

163 ; CHECK: $a = SIMD_int32x4_check($a);

164 ; CHECK: $b = SIMD_int32x4_check($b);

165 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

166 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 2, 1, 2);

167 ; CHECK: return (SIMD_int32x4_check($sel));

168 ; CHECK: }

169 define <4 x i32> @swizzle_int32x3to4(<3 x i32> %a, <3 x i32> %b) nounwind {

170 entry:

171 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <4 x i32><i32 0, i32 2, i32 1 , i32 2>

172 ret <4 x i32> %sel

173 }

174

175 ; CHECK: function _swizzlehi_int32x3to4($a,$b) {

176 ; CHECK: $a = SIMD_int32x4_check($a);

177 ; CHECK: $b = SIMD_int32x4_check($b);

178 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

179 ; CHECK: $sel = SIMD_int32x4_swizzle($b, 2, 1, 0, 2);

180 ; CHECK: return (SIMD_int32x4_check($sel));

181 ; CHECK: }

182 define <4 x i32> @swizzlehi_int32x3to4(<3 x i32> %a, <3 x i32> %b) nounwind {

183 entry:

184 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <4 x i32><i32 5, i32 4, i32 3 , i32 5>

185 ret <4 x i32> %sel

186 }

187

188 ; CHECK: function _shuffle_int32x3to4($a,$b) {

189 ; CHECK: $a = SIMD_int32x4_check($a);

190 ; CHECK: $b = SIMD_int32x4_check($b);

191 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

192 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 6, 0, 5, 2);

193 ; CHECK: return (SIMD_int32x4_check($sel));

194 ; CHECK: }

195 define <4 x i32> @shuffle_int32x3to4(<3 x i32> %a, <3 x i32> %b) nounwind {

196 entry:

197 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <4 x i32><i32 5, i32 0, i32 4 , i32 2>

198 ret <4 x i32> %sel

199 }

200

201 ; CHECK: function _shuffleXY_int32x3to4($a,$b) {

202 ; CHECK: $a = SIMD_int32x4_check($a);

203 ; CHECK: $b = SIMD_int32x4_check($b);

204 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

205 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 6, 0, 0, 0);

206 ; CHECK: return (SIMD_int32x4_check($sel));

207 ; CHECK: }

208 define <4 x i32> @shuffleXY_int32x3to4(<3 x i32> %a, <3 x i32> %b) nounwind {

209 entry:

210 %sel = shufflevector <3 x i32> %a, <3 x i32> %b, <4 x i32><i32 5, i32 0, i32 u ndef, i32 undef>

211 ret <4 x i32> %sel

212 }

213

214 ; CHECK: function _splat_int32x4to3($a,$b) {

215 ; CHECK: $a = SIMD_int32x4_check($a);

216 ; CHECK: $b = SIMD_int32x4_check($b);

217 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

218 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 0, 0, 0);

219 ; CHECK: return (SIMD_int32x4_check($sel));

220 ; CHECK: }

221 define <3 x i32> @splat_int32x4to3(<4 x i32> %a, <4 x i32> %b) nounwind {

222 entry:

223 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <3 x i32><i32 0, i32 0, i32 0 >

224 ret <3 x i32> %sel

225 }

226

227 ; CHECK: function _swizzle_int32x4to3($a,$b) {

228 ; CHECK: $a = SIMD_int32x4_check($a);

229 ; CHECK: $b = SIMD_int32x4_check($b);

230 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

231 ; CHECK: $sel = SIMD_int32x4_swizzle($a, 0, 3, 1, 0);

232 ; CHECK: return (SIMD_int32x4_check($sel));

233 ; CHECK: }

234 define <3 x i32> @swizzle_int32x4to3(<4 x i32> %a, <4 x i32> %b) nounwind {

235 entry:

236 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <3 x i32><i32 0, i32 3, i32 1 >

237 ret <3 x i32> %sel

238 }

239

240 ; CHECK: function _swizzlehi_int32x4to3($a,$b) {

241 ; CHECK: $a = SIMD_int32x4_check($a);

242 ; CHECK: $b = SIMD_int32x4_check($b);

243 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

244 ; CHECK: $sel = SIMD_int32x4_swizzle($b, 2, 1, 3, 0);

245 ; CHECK: return (SIMD_int32x4_check($sel));

246 ; CHECK: }

247 define <3 x i32> @swizzlehi_int32x4to3(<4 x i32> %a, <4 x i32> %b) nounwind {

248 entry:

249 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <3 x i32><i32 6, i32 5, i32 7 >

250 ret <3 x i32> %sel

251 }

252

253 ; CHECK: function _shuffle_int32x4to3($a,$b) {

254 ; CHECK: $a = SIMD_int32x4_check($a);

255 ; CHECK: $b = SIMD_int32x4_check($b);

256 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

257 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 7, 0, 5);

258 ; CHECK: return (SIMD_int32x4_check($sel));

259 ; CHECK: }

260 define <3 x i32> @shuffle_int32x4to3(<4 x i32> %a, <4 x i32> %b) nounwind {

261 entry:

262 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <3 x i32><i32 7, i32 0, i32 5 >

263 ret <3 x i32> %sel

264 }

265

266 ; CHECK: function _shuffleXY_int32x4to3($a,$b) {

267 ; CHECK: $a = SIMD_int32x4_check($a);

268 ; CHECK: $b = SIMD_int32x4_check($b);

269 ; CHECK: var $sel = SIMD_int32x4(0,0,0,0)

270 ; CHECK: $sel = SIMD_int32x4_shuffle($a, $b, 7, 0, 0);

271 ; CHECK: return (SIMD_int32x4_check($sel));

272 ; CHECK: }

273 define <3 x i32> @shuffleXY_int32x4to3(<4 x i32> %a, <4 x i32> %b) nounwind {

274 entry:

275 %sel = shufflevector <4 x i32> %a, <4 x i32> %b, <3 x i32><i32 7, i32 0, i32 u ndef>

276 ret <3 x i32> %sel

277 }

278

279 ; CHECK: function _splat_float32x4($a,$b) {

280 ; CHECK: $a = SIMD_float32x4_check($a);

281 ; CHECK: $b = SIMD_float32x4_check($b);

282 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

283 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 0, 0, 0);

284 ; CHECK: return (SIMD_float32x4_check($sel));

285 ; CHECK: }

286 define <4 x float> @splat_float32x4(<4 x float> %a, <4 x float> %b) nounwind {

287 entry:

288 %sel = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32><i32 0, i32 0, i 32 0, i32 0>

289 ret <4 x float> %sel

290 }

291

292 ; CHECK: function _swizzle_float32x4($a,$b) {

293 ; CHECK: $a = SIMD_float32x4_check($a);

294 ; CHECK: $b = SIMD_float32x4_check($b);

295 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

296 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 3, 1, 2);

297 ; CHECK: return (SIMD_float32x4_check($sel));

298 ; CHECK: }

299 define <4 x float> @swizzle_float32x4(<4 x float> %a, <4 x float> %b) nounwind {

300 entry:

301 %sel = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32><i32 0, i32 3, i 32 1, i32 2>

302 ret <4 x float> %sel

303 }

304

305 ; CHECK: function _swizzlehi_float32x4($a,$b) {

306 ; CHECK: $a = SIMD_float32x4_check($a);

307 ; CHECK: $b = SIMD_float32x4_check($b);

308 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

309 ; CHECK: $sel = SIMD_float32x4_swizzle($b, 2, 1, 3, 0);

310 ; CHECK: return (SIMD_float32x4_check($sel));

311 ; CHECK: }

312 define <4 x float> @swizzlehi_float32x4(<4 x float> %a, <4 x float> %b) nounwind {

313 entry:

314 %sel = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32><i32 6, i32 5, i 32 7, i32 4>

315 ret <4 x float> %sel

316 }

317

318 ; CHECK: function _shuffle_float32x4($a,$b) {

319 ; CHECK: $a = SIMD_float32x4_check($a);

320 ; CHECK: $b = SIMD_float32x4_check($b);

321 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

322 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 7, 0, 5, 3);

323 ; CHECK: return (SIMD_float32x4_check($sel));

324 ; CHECK: }

325 define <4 x float> @shuffle_float32x4(<4 x float> %a, <4 x float> %b) nounwind {

326 entry:

327 %sel = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32><i32 7, i32 0, i 32 5, i32 3>

328 ret <4 x float> %sel

329 }

330

331 ; CHECK: function _shuffleXY_float32x4($a,$b) {

332 ; CHECK: $a = SIMD_float32x4_check($a);

333 ; CHECK: $b = SIMD_float32x4_check($b);

334 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

335 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 7, 0, 0, 0);

336 ; CHECK: return (SIMD_float32x4_check($sel));

337 ; CHECK: }

338 define <4 x float> @shuffleXY_float32x4(<4 x float> %a, <4 x float> %b) nounwind {

339 entry:

340 %sel = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32><i32 7, i32 0, i 32 undef, i32 undef>

341 ret <4 x float> %sel

342 }

343

344 ; CHECK: function _splat_float32x3($a,$b) {

345 ; CHECK: $a = SIMD_float32x4_check($a);

346 ; CHECK: $b = SIMD_float32x4_check($b);

347 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

348 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 0, 0, 0);

349 ; CHECK: return (SIMD_float32x4_check($sel));

350 ; CHECK: }

351 define <3 x float> @splat_float32x3(<3 x float> %a, <3 x float> %b) nounwind {

352 entry:

353 %sel = shufflevector <3 x float> %a, <3 x float> %b, <3 x i32><i32 0, i32 0, i 32 0>

354 ret <3 x float> %sel

355 }

356

357 ; CHECK: function _swizzle_float32x3($a,$b) {

358 ; CHECK: $a = SIMD_float32x4_check($a);

359 ; CHECK: $b = SIMD_float32x4_check($b);

360 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

361 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 2, 1, 0);

362 ; CHECK: return (SIMD_float32x4_check($sel));

363 ; CHECK: }

364 define <3 x float> @swizzle_float32x3(<3 x float> %a, <3 x float> %b) nounwind {

365 entry:

366 %sel = shufflevector <3 x float> %a, <3 x float> %b, <3 x i32><i32 0, i32 2, i 32 1>

367 ret <3 x float> %sel

368 }

369

370 ; CHECK: function _swizzlehi_float32x3($a,$b) {

371 ; CHECK: $a = SIMD_float32x4_check($a);

372 ; CHECK: $b = SIMD_float32x4_check($b);

373 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

374 ; CHECK: $sel = SIMD_float32x4_swizzle($b, 0, 2, 1, 0);

375 ; CHECK: return (SIMD_float32x4_check($sel));

376 ; CHECK: }

377 define <3 x float> @swizzlehi_float32x3(<3 x float> %a, <3 x float> %b) nounwind {

378 entry:

379 %sel = shufflevector <3 x float> %a, <3 x float> %b, <3 x i32><i32 3, i32 5, i 32 4>

380 ret <3 x float> %sel

381 }

382

383 ; CHECK: function _shuffle_float32x3($a,$b) {

384 ; CHECK: $a = SIMD_float32x4_check($a);

385 ; CHECK: $b = SIMD_float32x4_check($b);

386 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

387 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 6, 0, 5);

388 ; CHECK: return (SIMD_float32x4_check($sel));

389 ; CHECK: }

390 define <3 x float> @shuffle_float32x3(<3 x float> %a, <3 x float> %b) nounwind {

391 entry:

392 %sel = shufflevector <3 x float> %a, <3 x float> %b, <3 x i32><i32 5, i32 0, i 32 4>

393 ret <3 x float> %sel

394 }

395

396 ; CHECK: function _shuffleXY_float32x3($a,$b) {

397 ; CHECK: $a = SIMD_float32x4_check($a);

398 ; CHECK: $b = SIMD_float32x4_check($b);

399 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

400 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 6, 0, 0);

401 ; CHECK: return (SIMD_float32x4_check($sel));

402 ; CHECK: }

403 define <3 x float> @shuffleXY_float32x3(<3 x float> %a, <3 x float> %b) nounwind {

404 entry:

405 %sel = shufflevector <3 x float> %a, <3 x float> %b, <3 x i32><i32 5, i32 0, i 32 undef>

406 ret <3 x float> %sel

407 }

408

409 ; CHECK: function _splat_float32x3to4($a,$b) {

410 ; CHECK: $a = SIMD_float32x4_check($a);

411 ; CHECK: $b = SIMD_float32x4_check($b);

412 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

413 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 0, 0, 0);

414 ; CHECK: return (SIMD_float32x4_check($sel));

415 ; CHECK: }

416 define <4 x float> @splat_float32x3to4(<3 x float> %a, <3 x float> %b) nounwind {

417 entry:

418 %sel = shufflevector <3 x float> %a, <3 x float> %b, <4 x i32><i32 0, i32 0, i 32 0, i32 0>

419 ret <4 x float> %sel

420 }

421

422 ; CHECK: function _swizzle_float32x3to4($a,$b) {

423 ; CHECK: $a = SIMD_float32x4_check($a);

424 ; CHECK: $b = SIMD_float32x4_check($b);

425 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

426 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 2, 1, 2);

427 ; CHECK: return (SIMD_float32x4_check($sel));

428 ; CHECK: }

429 define <4 x float> @swizzle_float32x3to4(<3 x float> %a, <3 x float> %b) nounwin d {

430 entry:

431 %sel = shufflevector <3 x float> %a, <3 x float> %b, <4 x i32><i32 0, i32 2, i 32 1, i32 2>

432 ret <4 x float> %sel

433 }

434

435 ; CHECK: function _swizzlehi_float32x3to4($a,$b) {

436 ; CHECK: $a = SIMD_float32x4_check($a);

437 ; CHECK: $b = SIMD_float32x4_check($b);

438 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

439 ; CHECK: $sel = SIMD_float32x4_swizzle($b, 2, 1, 0, 2);

440 ; CHECK: return (SIMD_float32x4_check($sel));

441 ; CHECK: }

442 define <4 x float> @swizzlehi_float32x3to4(<3 x float> %a, <3 x float> %b) nounw ind {

443 entry:

444 %sel = shufflevector <3 x float> %a, <3 x float> %b, <4 x i32><i32 5, i32 4, i 32 3, i32 5>

445 ret <4 x float> %sel

446 }

447

448 ; CHECK: function _shuffle_float32x3to4($a,$b) {

449 ; CHECK: $a = SIMD_float32x4_check($a);

450 ; CHECK: $b = SIMD_float32x4_check($b);

451 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

452 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 6, 0, 5, 2);

453 ; CHECK: return (SIMD_float32x4_check($sel));

454 ; CHECK: }

455 define <4 x float> @shuffle_float32x3to4(<3 x float> %a, <3 x float> %b) nounwin d {

456 entry:

457 %sel = shufflevector <3 x float> %a, <3 x float> %b, <4 x i32><i32 5, i32 0, i 32 4, i32 2>

458 ret <4 x float> %sel

459 }

460

461 ; CHECK: function _shuffleXY_float32x3to4($a,$b) {

462 ; CHECK: $a = SIMD_float32x4_check($a);

463 ; CHECK: $b = SIMD_float32x4_check($b);

464 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

465 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 6, 0, 0, 0);

466 ; CHECK: return (SIMD_float32x4_check($sel));

467 ; CHECK: }

468 define <4 x float> @shuffleXY_float32x3to4(<3 x float> %a, <3 x float> %b) nounw ind {

469 entry:

470 %sel = shufflevector <3 x float> %a, <3 x float> %b, <4 x i32><i32 5, i32 0, i 32 undef, i32 undef>

471 ret <4 x float> %sel

472 }

473

474 ; CHECK: function _splat_float32x4to3($a,$b) {

475 ; CHECK: $a = SIMD_float32x4_check($a);

476 ; CHECK: $b = SIMD_float32x4_check($b);

477 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

478 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 0, 0, 0);

479 ; CHECK: return (SIMD_float32x4_check($sel));

480 ; CHECK: }

481 define <3 x float> @splat_float32x4to3(<4 x float> %a, <4 x float> %b) nounwind {

482 entry:

483 %sel = shufflevector <4 x float> %a, <4 x float> %b, <3 x i32><i32 0, i32 0, i 32 0>

484 ret <3 x float> %sel

485 }

486

487 ; CHECK: function _swizzle_float32x4to3($a,$b) {

488 ; CHECK: $a = SIMD_float32x4_check($a);

489 ; CHECK: $b = SIMD_float32x4_check($b);

490 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

491 ; CHECK: $sel = SIMD_float32x4_swizzle($a, 0, 3, 1, 0);

492 ; CHECK: return (SIMD_float32x4_check($sel));

493 ; CHECK: }

494 define <3 x float> @swizzle_float32x4to3(<4 x float> %a, <4 x float> %b) nounwin d {

495 entry:

496 %sel = shufflevector <4 x float> %a, <4 x float> %b, <3 x i32><i32 0, i32 3, i 32 1>

497 ret <3 x float> %sel

498 }

499

500 ; CHECK: function _swizzlehi_float32x4to3($a,$b) {

501 ; CHECK: $a = SIMD_float32x4_check($a);

502 ; CHECK: $b = SIMD_float32x4_check($b);

503 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

504 ; CHECK: $sel = SIMD_float32x4_swizzle($b, 2, 1, 3, 0);

505 ; CHECK: return (SIMD_float32x4_check($sel));

506 ; CHECK: }

507 define <3 x float> @swizzlehi_float32x4to3(<4 x float> %a, <4 x float> %b) nounw ind {

508 entry:

509 %sel = shufflevector <4 x float> %a, <4 x float> %b, <3 x i32><i32 6, i32 5, i 32 7>

510 ret <3 x float> %sel

511 }

512

513 ; CHECK: function _shuffle_float32x4to3($a,$b) {

514 ; CHECK: $a = SIMD_float32x4_check($a);

515 ; CHECK: $b = SIMD_float32x4_check($b);

516 ; CHECK: var $sel = SIMD_float32x4(0,0,0,0)

517 ; CHECK: $sel = SIMD_float32x4_shuffle($a, $b, 7, 0, 5);

518 ; CHECK: return (SIMD_float32x4_check($sel));

519 ; CHECK: }

520 define <3 x float> @shuffle_float32x4to3(<4 x float> %a, <4 x float> %b) nounwin d {

521 entry:

522 %sel = shufflevector <4 x float> %a, <4 x float> %b, <3 x i32><i32 7, i32 0, i 32 5>

523 ret <3 x float> %sel

524 }

OLD	NEW

« no previous file with comments | « test/CodeGen/JS/simd-shift.ll ('k') | test/CodeGen/JS/splat-precise-f32.ll » ('j') | no next file with comments »