fp.isa (7648:3e561a5c0456) fp.isa (7760:e93e7e0caae1)
1// -*- mode:c++ -*-
2
3// Copyright (c) 2010 ARM Limited
4// All rights reserved
5//
6// The license below extends only to copyright in the software and shall
7// not be construed as granting a license to any other intellectual
8// property including but not limited to intellectual property relating

--- 180 unchanged lines hidden (view full) ---

189
190 header_output = ""
191 decoder_output = ""
192 exec_output = ""
193
194 vmsrIop = InstObjParams("vmsr", "Vmsr", "FpRegRegOp",
195 { "code": vmsrEnabledCheckCode + \
196 "MiscDest = Op1;",
1// -*- mode:c++ -*-
2
3// Copyright (c) 2010 ARM Limited
4// All rights reserved
5//
6// The license below extends only to copyright in the software and shall
7// not be construed as granting a license to any other intellectual
8// property including but not limited to intellectual property relating

--- 180 unchanged lines hidden (view full) ---

189
190 header_output = ""
191 decoder_output = ""
192 exec_output = ""
193
194 vmsrIop = InstObjParams("vmsr", "Vmsr", "FpRegRegOp",
195 { "code": vmsrEnabledCheckCode + \
196 "MiscDest = Op1;",
197 "predicate_test": predicateTest },
197 "predicate_test": predicateTest,
198 "op_class": "SimdFloatMiscOp" },
198 ["IsSerializeAfter","IsNonSpeculative"])
199 header_output += FpRegRegOpDeclare.subst(vmsrIop);
200 decoder_output += FpRegRegOpConstructor.subst(vmsrIop);
201 exec_output += PredOpExecute.subst(vmsrIop);
202
203 vmsrFpscrCode = vmsrEnabledCheckCode + '''
204 Fpscr = Op1 & ~FpCondCodesMask;
205 FpCondCodes = Op1 & FpCondCodesMask;
206 '''
207 vmsrFpscrIop = InstObjParams("vmsr", "VmsrFpscr", "FpRegRegOp",
208 { "code": vmsrFpscrCode,
199 ["IsSerializeAfter","IsNonSpeculative"])
200 header_output += FpRegRegOpDeclare.subst(vmsrIop);
201 decoder_output += FpRegRegOpConstructor.subst(vmsrIop);
202 exec_output += PredOpExecute.subst(vmsrIop);
203
204 vmsrFpscrCode = vmsrEnabledCheckCode + '''
205 Fpscr = Op1 & ~FpCondCodesMask;
206 FpCondCodes = Op1 & FpCondCodesMask;
207 '''
208 vmsrFpscrIop = InstObjParams("vmsr", "VmsrFpscr", "FpRegRegOp",
209 { "code": vmsrFpscrCode,
209 "predicate_test": predicateTest }, [])
210 "predicate_test": predicateTest,
211 "op_class": "SimdFloatMiscOp" }, [])
210 header_output += FpRegRegOpDeclare.subst(vmsrFpscrIop);
211 decoder_output += FpRegRegOpConstructor.subst(vmsrFpscrIop);
212 exec_output += PredOpExecute.subst(vmsrFpscrIop);
213
214 vmrsIop = InstObjParams("vmrs", "Vmrs", "FpRegRegOp",
215 { "code": vmrsEnabledCheckCode + \
212 header_output += FpRegRegOpDeclare.subst(vmsrFpscrIop);
213 decoder_output += FpRegRegOpConstructor.subst(vmsrFpscrIop);
214 exec_output += PredOpExecute.subst(vmsrFpscrIop);
215
216 vmrsIop = InstObjParams("vmrs", "Vmrs", "FpRegRegOp",
217 { "code": vmrsEnabledCheckCode + \
216 "Dest = MiscOp1;",
217 "predicate_test": predicateTest }, [])
218 "Dest = MiscOp1;",
219 "predicate_test": predicateTest,
220 "op_class": "SimdFloatMiscOp" }, [])
218 header_output += FpRegRegOpDeclare.subst(vmrsIop);
219 decoder_output += FpRegRegOpConstructor.subst(vmrsIop);
220 exec_output += PredOpExecute.subst(vmrsIop);
221
222 vmrsFpscrIop = InstObjParams("vmrs", "VmrsFpscr", "FpRegRegOp",
223 { "code": vmrsEnabledCheckCode + \
224 "Dest = Fpscr | FpCondCodes;",
221 header_output += FpRegRegOpDeclare.subst(vmrsIop);
222 decoder_output += FpRegRegOpConstructor.subst(vmrsIop);
223 exec_output += PredOpExecute.subst(vmrsIop);
224
225 vmrsFpscrIop = InstObjParams("vmrs", "VmrsFpscr", "FpRegRegOp",
226 { "code": vmrsEnabledCheckCode + \
227 "Dest = Fpscr | FpCondCodes;",
225 "predicate_test": predicateTest }, [])
228 "predicate_test": predicateTest,
229 "op_class": "SimdFloatMiscOp" }, [])
226 header_output += FpRegRegOpDeclare.subst(vmrsFpscrIop);
227 decoder_output += FpRegRegOpConstructor.subst(vmrsFpscrIop);
228 exec_output += PredOpExecute.subst(vmrsFpscrIop);
229
230 vmrsApsrCode = vmrsEnabledCheckCode + '''
231 Dest = (MiscOp1 & imm) | (Dest & ~imm);
232 '''
233 vmrsApsrIop = InstObjParams("vmrs", "VmrsApsr", "FpRegRegImmOp",
234 { "code": vmrsApsrCode,
230 header_output += FpRegRegOpDeclare.subst(vmrsFpscrIop);
231 decoder_output += FpRegRegOpConstructor.subst(vmrsFpscrIop);
232 exec_output += PredOpExecute.subst(vmrsFpscrIop);
233
234 vmrsApsrCode = vmrsEnabledCheckCode + '''
235 Dest = (MiscOp1 & imm) | (Dest & ~imm);
236 '''
237 vmrsApsrIop = InstObjParams("vmrs", "VmrsApsr", "FpRegRegImmOp",
238 { "code": vmrsApsrCode,
235 "predicate_test": predicateTest }, [])
239 "predicate_test": predicateTest,
240 "op_class": "SimdFloatMiscOp" }, [])
236 header_output += FpRegRegImmOpDeclare.subst(vmrsApsrIop);
237 decoder_output += FpRegRegImmOpConstructor.subst(vmrsApsrIop);
238 exec_output += PredOpExecute.subst(vmrsApsrIop);
239
240 vmrsApsrFpscrCode = vmrsEnabledCheckCode + '''
241 assert((imm & ~FpCondCodesMask) == 0);
242 Dest = (FpCondCodes & imm) | (Dest & ~imm);
243 '''
244 vmrsApsrFpscrIop = InstObjParams("vmrs", "VmrsApsrFpscr", "FpRegRegImmOp",
245 { "code": vmrsApsrFpscrCode,
241 header_output += FpRegRegImmOpDeclare.subst(vmrsApsrIop);
242 decoder_output += FpRegRegImmOpConstructor.subst(vmrsApsrIop);
243 exec_output += PredOpExecute.subst(vmrsApsrIop);
244
245 vmrsApsrFpscrCode = vmrsEnabledCheckCode + '''
246 assert((imm & ~FpCondCodesMask) == 0);
247 Dest = (FpCondCodes & imm) | (Dest & ~imm);
248 '''
249 vmrsApsrFpscrIop = InstObjParams("vmrs", "VmrsApsrFpscr", "FpRegRegImmOp",
250 { "code": vmrsApsrFpscrCode,
246 "predicate_test": predicateTest }, [])
251 "predicate_test": predicateTest,
252 "op_class": "SimdFloatMiscOp" }, [])
247 header_output += FpRegRegImmOpDeclare.subst(vmrsApsrFpscrIop);
248 decoder_output += FpRegRegImmOpConstructor.subst(vmrsApsrFpscrIop);
249 exec_output += PredOpExecute.subst(vmrsApsrFpscrIop);
250
251 vmovImmSCode = vfpEnabledCheckCode + '''
252 FpDest.uw = bits(imm, 31, 0);
253 '''
254 vmovImmSIop = InstObjParams("vmov", "VmovImmS", "FpRegImmOp",
255 { "code": vmovImmSCode,
253 header_output += FpRegRegImmOpDeclare.subst(vmrsApsrFpscrIop);
254 decoder_output += FpRegRegImmOpConstructor.subst(vmrsApsrFpscrIop);
255 exec_output += PredOpExecute.subst(vmrsApsrFpscrIop);
256
257 vmovImmSCode = vfpEnabledCheckCode + '''
258 FpDest.uw = bits(imm, 31, 0);
259 '''
260 vmovImmSIop = InstObjParams("vmov", "VmovImmS", "FpRegImmOp",
261 { "code": vmovImmSCode,
256 "predicate_test": predicateTest }, [])
262 "predicate_test": predicateTest,
263 "op_class": "SimdFloatMiscOp" }, [])
257 header_output += FpRegImmOpDeclare.subst(vmovImmSIop);
258 decoder_output += FpRegImmOpConstructor.subst(vmovImmSIop);
259 exec_output += PredOpExecute.subst(vmovImmSIop);
260
261 vmovImmDCode = vfpEnabledCheckCode + '''
262 FpDestP0.uw = bits(imm, 31, 0);
263 FpDestP1.uw = bits(imm, 63, 32);
264 '''
265 vmovImmDIop = InstObjParams("vmov", "VmovImmD", "FpRegImmOp",
266 { "code": vmovImmDCode,
264 header_output += FpRegImmOpDeclare.subst(vmovImmSIop);
265 decoder_output += FpRegImmOpConstructor.subst(vmovImmSIop);
266 exec_output += PredOpExecute.subst(vmovImmSIop);
267
268 vmovImmDCode = vfpEnabledCheckCode + '''
269 FpDestP0.uw = bits(imm, 31, 0);
270 FpDestP1.uw = bits(imm, 63, 32);
271 '''
272 vmovImmDIop = InstObjParams("vmov", "VmovImmD", "FpRegImmOp",
273 { "code": vmovImmDCode,
267 "predicate_test": predicateTest }, [])
274 "predicate_test": predicateTest,
275 "op_class": "SimdFloatMiscOp" }, [])
268 header_output += FpRegImmOpDeclare.subst(vmovImmDIop);
269 decoder_output += FpRegImmOpConstructor.subst(vmovImmDIop);
270 exec_output += PredOpExecute.subst(vmovImmDIop);
271
272 vmovImmQCode = vfpEnabledCheckCode + '''
273 FpDestP0.uw = bits(imm, 31, 0);
274 FpDestP1.uw = bits(imm, 63, 32);
275 FpDestP2.uw = bits(imm, 31, 0);
276 FpDestP3.uw = bits(imm, 63, 32);
277 '''
278 vmovImmQIop = InstObjParams("vmov", "VmovImmQ", "FpRegImmOp",
279 { "code": vmovImmQCode,
276 header_output += FpRegImmOpDeclare.subst(vmovImmDIop);
277 decoder_output += FpRegImmOpConstructor.subst(vmovImmDIop);
278 exec_output += PredOpExecute.subst(vmovImmDIop);
279
280 vmovImmQCode = vfpEnabledCheckCode + '''
281 FpDestP0.uw = bits(imm, 31, 0);
282 FpDestP1.uw = bits(imm, 63, 32);
283 FpDestP2.uw = bits(imm, 31, 0);
284 FpDestP3.uw = bits(imm, 63, 32);
285 '''
286 vmovImmQIop = InstObjParams("vmov", "VmovImmQ", "FpRegImmOp",
287 { "code": vmovImmQCode,
280 "predicate_test": predicateTest }, [])
288 "predicate_test": predicateTest,
289 "op_class": "SimdFloatMiscOp" }, [])
281 header_output += FpRegImmOpDeclare.subst(vmovImmQIop);
282 decoder_output += FpRegImmOpConstructor.subst(vmovImmQIop);
283 exec_output += PredOpExecute.subst(vmovImmQIop);
284
285 vmovRegSCode = vfpEnabledCheckCode + '''
286 FpDest.uw = FpOp1.uw;
287 '''
288 vmovRegSIop = InstObjParams("vmov", "VmovRegS", "FpRegRegOp",
289 { "code": vmovRegSCode,
290 header_output += FpRegImmOpDeclare.subst(vmovImmQIop);
291 decoder_output += FpRegImmOpConstructor.subst(vmovImmQIop);
292 exec_output += PredOpExecute.subst(vmovImmQIop);
293
294 vmovRegSCode = vfpEnabledCheckCode + '''
295 FpDest.uw = FpOp1.uw;
296 '''
297 vmovRegSIop = InstObjParams("vmov", "VmovRegS", "FpRegRegOp",
298 { "code": vmovRegSCode,
290 "predicate_test": predicateTest }, [])
299 "predicate_test": predicateTest,
300 "op_class": "SimdFloatMiscOp" }, [])
291 header_output += FpRegRegOpDeclare.subst(vmovRegSIop);
292 decoder_output += FpRegRegOpConstructor.subst(vmovRegSIop);
293 exec_output += PredOpExecute.subst(vmovRegSIop);
294
295 vmovRegDCode = vfpEnabledCheckCode + '''
296 FpDestP0.uw = FpOp1P0.uw;
297 FpDestP1.uw = FpOp1P1.uw;
298 '''
299 vmovRegDIop = InstObjParams("vmov", "VmovRegD", "FpRegRegOp",
300 { "code": vmovRegDCode,
301 header_output += FpRegRegOpDeclare.subst(vmovRegSIop);
302 decoder_output += FpRegRegOpConstructor.subst(vmovRegSIop);
303 exec_output += PredOpExecute.subst(vmovRegSIop);
304
305 vmovRegDCode = vfpEnabledCheckCode + '''
306 FpDestP0.uw = FpOp1P0.uw;
307 FpDestP1.uw = FpOp1P1.uw;
308 '''
309 vmovRegDIop = InstObjParams("vmov", "VmovRegD", "FpRegRegOp",
310 { "code": vmovRegDCode,
301 "predicate_test": predicateTest }, [])
311 "predicate_test": predicateTest,
312 "op_class": "SimdFloatMiscOp" }, [])
302 header_output += FpRegRegOpDeclare.subst(vmovRegDIop);
303 decoder_output += FpRegRegOpConstructor.subst(vmovRegDIop);
304 exec_output += PredOpExecute.subst(vmovRegDIop);
305
306 vmovRegQCode = vfpEnabledCheckCode + '''
307 FpDestP0.uw = FpOp1P0.uw;
308 FpDestP1.uw = FpOp1P1.uw;
309 FpDestP2.uw = FpOp1P2.uw;
310 FpDestP3.uw = FpOp1P3.uw;
311 '''
312 vmovRegQIop = InstObjParams("vmov", "VmovRegQ", "FpRegRegOp",
313 { "code": vmovRegQCode,
313 header_output += FpRegRegOpDeclare.subst(vmovRegDIop);
314 decoder_output += FpRegRegOpConstructor.subst(vmovRegDIop);
315 exec_output += PredOpExecute.subst(vmovRegDIop);
316
317 vmovRegQCode = vfpEnabledCheckCode + '''
318 FpDestP0.uw = FpOp1P0.uw;
319 FpDestP1.uw = FpOp1P1.uw;
320 FpDestP2.uw = FpOp1P2.uw;
321 FpDestP3.uw = FpOp1P3.uw;
322 '''
323 vmovRegQIop = InstObjParams("vmov", "VmovRegQ", "FpRegRegOp",
324 { "code": vmovRegQCode,
314 "predicate_test": predicateTest }, [])
325 "predicate_test": predicateTest,
326 "op_class": "SimdFloatMiscOp" }, [])
315 header_output += FpRegRegOpDeclare.subst(vmovRegQIop);
316 decoder_output += FpRegRegOpConstructor.subst(vmovRegQIop);
317 exec_output += PredOpExecute.subst(vmovRegQIop);
318
319 vmovCoreRegBCode = vfpEnabledCheckCode + '''
320 FpDest.uw = insertBits(FpDest.uw, imm * 8 + 7, imm * 8, Op1.ub);
321 '''
322 vmovCoreRegBIop = InstObjParams("vmov", "VmovCoreRegB", "FpRegRegImmOp",
323 { "code": vmovCoreRegBCode,
327 header_output += FpRegRegOpDeclare.subst(vmovRegQIop);
328 decoder_output += FpRegRegOpConstructor.subst(vmovRegQIop);
329 exec_output += PredOpExecute.subst(vmovRegQIop);
330
331 vmovCoreRegBCode = vfpEnabledCheckCode + '''
332 FpDest.uw = insertBits(FpDest.uw, imm * 8 + 7, imm * 8, Op1.ub);
333 '''
334 vmovCoreRegBIop = InstObjParams("vmov", "VmovCoreRegB", "FpRegRegImmOp",
335 { "code": vmovCoreRegBCode,
324 "predicate_test": predicateTest }, [])
336 "predicate_test": predicateTest,
337 "op_class": "SimdFloatMiscOp" }, [])
325 header_output += FpRegRegImmOpDeclare.subst(vmovCoreRegBIop);
326 decoder_output += FpRegRegImmOpConstructor.subst(vmovCoreRegBIop);
327 exec_output += PredOpExecute.subst(vmovCoreRegBIop);
328
329 vmovCoreRegHCode = vfpEnabledCheckCode + '''
330 FpDest.uw = insertBits(FpDest.uw, imm * 16 + 15, imm * 16, Op1.uh);
331 '''
332 vmovCoreRegHIop = InstObjParams("vmov", "VmovCoreRegH", "FpRegRegImmOp",
333 { "code": vmovCoreRegHCode,
338 header_output += FpRegRegImmOpDeclare.subst(vmovCoreRegBIop);
339 decoder_output += FpRegRegImmOpConstructor.subst(vmovCoreRegBIop);
340 exec_output += PredOpExecute.subst(vmovCoreRegBIop);
341
342 vmovCoreRegHCode = vfpEnabledCheckCode + '''
343 FpDest.uw = insertBits(FpDest.uw, imm * 16 + 15, imm * 16, Op1.uh);
344 '''
345 vmovCoreRegHIop = InstObjParams("vmov", "VmovCoreRegH", "FpRegRegImmOp",
346 { "code": vmovCoreRegHCode,
334 "predicate_test": predicateTest }, [])
347 "predicate_test": predicateTest,
348 "op_class": "SimdFloatMiscOp" }, [])
335 header_output += FpRegRegImmOpDeclare.subst(vmovCoreRegHIop);
336 decoder_output += FpRegRegImmOpConstructor.subst(vmovCoreRegHIop);
337 exec_output += PredOpExecute.subst(vmovCoreRegHIop);
338
339 vmovCoreRegWCode = vfpEnabledCheckCode + '''
340 FpDest.uw = Op1.uw;
341 '''
342 vmovCoreRegWIop = InstObjParams("vmov", "VmovCoreRegW", "FpRegRegOp",
343 { "code": vmovCoreRegWCode,
349 header_output += FpRegRegImmOpDeclare.subst(vmovCoreRegHIop);
350 decoder_output += FpRegRegImmOpConstructor.subst(vmovCoreRegHIop);
351 exec_output += PredOpExecute.subst(vmovCoreRegHIop);
352
353 vmovCoreRegWCode = vfpEnabledCheckCode + '''
354 FpDest.uw = Op1.uw;
355 '''
356 vmovCoreRegWIop = InstObjParams("vmov", "VmovCoreRegW", "FpRegRegOp",
357 { "code": vmovCoreRegWCode,
344 "predicate_test": predicateTest }, [])
358 "predicate_test": predicateTest,
359 "op_class": "SimdFloatMiscOp" }, [])
345 header_output += FpRegRegOpDeclare.subst(vmovCoreRegWIop);
346 decoder_output += FpRegRegOpConstructor.subst(vmovCoreRegWIop);
347 exec_output += PredOpExecute.subst(vmovCoreRegWIop);
348
349 vmovRegCoreUBCode = vfpEnabledCheckCode + '''
350 assert(imm < 4);
351 Dest = bits(FpOp1.uw, imm * 8 + 7, imm * 8);
352 '''
353 vmovRegCoreUBIop = InstObjParams("vmov", "VmovRegCoreUB", "FpRegRegImmOp",
354 { "code": vmovRegCoreUBCode,
360 header_output += FpRegRegOpDeclare.subst(vmovCoreRegWIop);
361 decoder_output += FpRegRegOpConstructor.subst(vmovCoreRegWIop);
362 exec_output += PredOpExecute.subst(vmovCoreRegWIop);
363
364 vmovRegCoreUBCode = vfpEnabledCheckCode + '''
365 assert(imm < 4);
366 Dest = bits(FpOp1.uw, imm * 8 + 7, imm * 8);
367 '''
368 vmovRegCoreUBIop = InstObjParams("vmov", "VmovRegCoreUB", "FpRegRegImmOp",
369 { "code": vmovRegCoreUBCode,
355 "predicate_test": predicateTest }, [])
370 "predicate_test": predicateTest,
371 "op_class": "SimdFloatMiscOp" }, [])
356 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreUBIop);
357 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreUBIop);
358 exec_output += PredOpExecute.subst(vmovRegCoreUBIop);
359
360 vmovRegCoreUHCode = vfpEnabledCheckCode + '''
361 assert(imm < 2);
362 Dest = bits(FpOp1.uw, imm * 16 + 15, imm * 16);
363 '''
364 vmovRegCoreUHIop = InstObjParams("vmov", "VmovRegCoreUH", "FpRegRegImmOp",
365 { "code": vmovRegCoreUHCode,
372 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreUBIop);
373 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreUBIop);
374 exec_output += PredOpExecute.subst(vmovRegCoreUBIop);
375
376 vmovRegCoreUHCode = vfpEnabledCheckCode + '''
377 assert(imm < 2);
378 Dest = bits(FpOp1.uw, imm * 16 + 15, imm * 16);
379 '''
380 vmovRegCoreUHIop = InstObjParams("vmov", "VmovRegCoreUH", "FpRegRegImmOp",
381 { "code": vmovRegCoreUHCode,
366 "predicate_test": predicateTest }, [])
382 "predicate_test": predicateTest,
383 "op_class": "SimdFloatMiscOp" }, [])
367 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreUHIop);
368 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreUHIop);
369 exec_output += PredOpExecute.subst(vmovRegCoreUHIop);
370
371 vmovRegCoreSBCode = vfpEnabledCheckCode + '''
372 assert(imm < 4);
373 Dest = sext<8>(bits(FpOp1.uw, imm * 8 + 7, imm * 8));
374 '''
375 vmovRegCoreSBIop = InstObjParams("vmov", "VmovRegCoreSB", "FpRegRegImmOp",
376 { "code": vmovRegCoreSBCode,
384 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreUHIop);
385 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreUHIop);
386 exec_output += PredOpExecute.subst(vmovRegCoreUHIop);
387
388 vmovRegCoreSBCode = vfpEnabledCheckCode + '''
389 assert(imm < 4);
390 Dest = sext<8>(bits(FpOp1.uw, imm * 8 + 7, imm * 8));
391 '''
392 vmovRegCoreSBIop = InstObjParams("vmov", "VmovRegCoreSB", "FpRegRegImmOp",
393 { "code": vmovRegCoreSBCode,
377 "predicate_test": predicateTest }, [])
394 "predicate_test": predicateTest,
395 "op_class": "SimdFloatMiscOp" }, [])
378 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreSBIop);
379 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreSBIop);
380 exec_output += PredOpExecute.subst(vmovRegCoreSBIop);
381
382 vmovRegCoreSHCode = vfpEnabledCheckCode + '''
383 assert(imm < 2);
384 Dest = sext<16>(bits(FpOp1.uw, imm * 16 + 15, imm * 16));
385 '''
386 vmovRegCoreSHIop = InstObjParams("vmov", "VmovRegCoreSH", "FpRegRegImmOp",
387 { "code": vmovRegCoreSHCode,
396 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreSBIop);
397 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreSBIop);
398 exec_output += PredOpExecute.subst(vmovRegCoreSBIop);
399
400 vmovRegCoreSHCode = vfpEnabledCheckCode + '''
401 assert(imm < 2);
402 Dest = sext<16>(bits(FpOp1.uw, imm * 16 + 15, imm * 16));
403 '''
404 vmovRegCoreSHIop = InstObjParams("vmov", "VmovRegCoreSH", "FpRegRegImmOp",
405 { "code": vmovRegCoreSHCode,
388 "predicate_test": predicateTest }, [])
406 "predicate_test": predicateTest,
407 "op_class": "SimdFloatMiscOp" }, [])
389 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreSHIop);
390 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreSHIop);
391 exec_output += PredOpExecute.subst(vmovRegCoreSHIop);
392
393 vmovRegCoreWCode = vfpEnabledCheckCode + '''
394 Dest = FpOp1.uw;
395 '''
396 vmovRegCoreWIop = InstObjParams("vmov", "VmovRegCoreW", "FpRegRegOp",
397 { "code": vmovRegCoreWCode,
408 header_output += FpRegRegImmOpDeclare.subst(vmovRegCoreSHIop);
409 decoder_output += FpRegRegImmOpConstructor.subst(vmovRegCoreSHIop);
410 exec_output += PredOpExecute.subst(vmovRegCoreSHIop);
411
412 vmovRegCoreWCode = vfpEnabledCheckCode + '''
413 Dest = FpOp1.uw;
414 '''
415 vmovRegCoreWIop = InstObjParams("vmov", "VmovRegCoreW", "FpRegRegOp",
416 { "code": vmovRegCoreWCode,
398 "predicate_test": predicateTest }, [])
417 "predicate_test": predicateTest,
418 "op_class": "SimdFloatMiscOp" }, [])
399 header_output += FpRegRegOpDeclare.subst(vmovRegCoreWIop);
400 decoder_output += FpRegRegOpConstructor.subst(vmovRegCoreWIop);
401 exec_output += PredOpExecute.subst(vmovRegCoreWIop);
402
403 vmov2Reg2CoreCode = vfpEnabledCheckCode + '''
404 FpDestP0.uw = Op1.uw;
405 FpDestP1.uw = Op2.uw;
406 '''
407 vmov2Reg2CoreIop = InstObjParams("vmov", "Vmov2Reg2Core", "FpRegRegRegOp",
408 { "code": vmov2Reg2CoreCode,
419 header_output += FpRegRegOpDeclare.subst(vmovRegCoreWIop);
420 decoder_output += FpRegRegOpConstructor.subst(vmovRegCoreWIop);
421 exec_output += PredOpExecute.subst(vmovRegCoreWIop);
422
423 vmov2Reg2CoreCode = vfpEnabledCheckCode + '''
424 FpDestP0.uw = Op1.uw;
425 FpDestP1.uw = Op2.uw;
426 '''
427 vmov2Reg2CoreIop = InstObjParams("vmov", "Vmov2Reg2Core", "FpRegRegRegOp",
428 { "code": vmov2Reg2CoreCode,
409 "predicate_test": predicateTest }, [])
429 "predicate_test": predicateTest,
430 "op_class": "SimdFloatMiscOp" }, [])
410 header_output += FpRegRegRegOpDeclare.subst(vmov2Reg2CoreIop);
411 decoder_output += FpRegRegRegOpConstructor.subst(vmov2Reg2CoreIop);
412 exec_output += PredOpExecute.subst(vmov2Reg2CoreIop);
413
414 vmov2Core2RegCode = vfpEnabledCheckCode + '''
415 Dest.uw = FpOp2P0.uw;
416 Op1.uw = FpOp2P1.uw;
417 '''
418 vmov2Core2RegIop = InstObjParams("vmov", "Vmov2Core2Reg", "FpRegRegRegOp",
419 { "code": vmov2Core2RegCode,
431 header_output += FpRegRegRegOpDeclare.subst(vmov2Reg2CoreIop);
432 decoder_output += FpRegRegRegOpConstructor.subst(vmov2Reg2CoreIop);
433 exec_output += PredOpExecute.subst(vmov2Reg2CoreIop);
434
435 vmov2Core2RegCode = vfpEnabledCheckCode + '''
436 Dest.uw = FpOp2P0.uw;
437 Op1.uw = FpOp2P1.uw;
438 '''
439 vmov2Core2RegIop = InstObjParams("vmov", "Vmov2Core2Reg", "FpRegRegRegOp",
440 { "code": vmov2Core2RegCode,
420 "predicate_test": predicateTest }, [])
441 "predicate_test": predicateTest,
442 "op_class": "SimdFloatMiscOp" }, [])
421 header_output += FpRegRegRegOpDeclare.subst(vmov2Core2RegIop);
422 decoder_output += FpRegRegRegOpConstructor.subst(vmov2Core2RegIop);
423 exec_output += PredOpExecute.subst(vmov2Core2RegIop);
424}};
425
426let {{
427
428 header_output = ""

--- 20 unchanged lines hidden (view full) ---

449 dbl(FpOp2P0.uw, FpOp2P1.uw),
450 %(func)s, fpscr.fz, fpscr.dn, fpscr.rMode);
451 '''
452 doubleUnaryOp = '''
453 unaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw), %(func)s,
454 fpscr.fz, fpscr.rMode)
455 '''
456
443 header_output += FpRegRegRegOpDeclare.subst(vmov2Core2RegIop);
444 decoder_output += FpRegRegRegOpConstructor.subst(vmov2Core2RegIop);
445 exec_output += PredOpExecute.subst(vmov2Core2RegIop);
446}};
447
448let {{
449
450 header_output = ""

--- 20 unchanged lines hidden (view full) ---

471 dbl(FpOp2P0.uw, FpOp2P1.uw),
472 %(func)s, fpscr.fz, fpscr.dn, fpscr.rMode);
473 '''
474 doubleUnaryOp = '''
475 unaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw), %(func)s,
476 fpscr.fz, fpscr.rMode)
477 '''
478
457 def buildBinFpOp(name, Name, base, singleOp, doubleOp):
479 def buildBinFpOp(name, Name, base, opClass, singleOp, doubleOp):
458 global header_output, decoder_output, exec_output
459
460 code = singleCode % { "op": singleBinOp }
461 code = code % { "func": singleOp }
462 sIop = InstObjParams(name + "s", Name + "S", base,
480 global header_output, decoder_output, exec_output
481
482 code = singleCode % { "op": singleBinOp }
483 code = code % { "func": singleOp }
484 sIop = InstObjParams(name + "s", Name + "S", base,
463 { "code": code, "predicate_test": predicateTest }, [])
485 { "code": code,
486 "predicate_test": predicateTest,
487 "op_class": opClass }, [])
464 code = doubleCode % { "op": doubleBinOp }
465 code = code % { "func": doubleOp }
466 dIop = InstObjParams(name + "d", Name + "D", base,
488 code = doubleCode % { "op": doubleBinOp }
489 code = code % { "func": doubleOp }
490 dIop = InstObjParams(name + "d", Name + "D", base,
467 { "code": code, "predicate_test": predicateTest }, [])
491 { "code": code,
492 "predicate_test": predicateTest,
493 "op_class": opClass }, [])
468
469 declareTempl = eval(base + "Declare");
470 constructorTempl = eval(base + "Constructor");
471
472 for iop in sIop, dIop:
473 header_output += declareTempl.subst(iop)
474 decoder_output += constructorTempl.subst(iop)
475 exec_output += PredOpExecute.subst(iop)
476
494
495 declareTempl = eval(base + "Declare");
496 constructorTempl = eval(base + "Constructor");
497
498 for iop in sIop, dIop:
499 header_output += declareTempl.subst(iop)
500 decoder_output += constructorTempl.subst(iop)
501 exec_output += PredOpExecute.subst(iop)
502
477 buildBinFpOp("vadd", "Vadd", "FpRegRegRegOp", "fpAddS", "fpAddD")
478 buildBinFpOp("vsub", "Vsub", "FpRegRegRegOp", "fpSubS", "fpSubD")
479 buildBinFpOp("vdiv", "Vdiv", "FpRegRegRegOp", "fpDivS", "fpDivD")
480 buildBinFpOp("vmul", "Vmul", "FpRegRegRegOp", "fpMulS", "fpMulD")
503 buildBinFpOp("vadd", "Vadd", "FpRegRegRegOp", "SimdFloatAddOp", "fpAddS",
504 "fpAddD")
505 buildBinFpOp("vsub", "Vsub", "FpRegRegRegOp", "SimdFloatAddOp", "fpSubS",
506 "fpSubD")
507 buildBinFpOp("vdiv", "Vdiv", "FpRegRegRegOp", "SimdFloatDivOp", "fpDivS",
508 "fpDivD")
509 buildBinFpOp("vmul", "Vmul", "FpRegRegRegOp", "SimdFloatMultOp", "fpMulS",
510 "fpMulD")
481
511
482 def buildUnaryFpOp(name, Name, base, singleOp, doubleOp = None):
512 def buildUnaryFpOp(name, Name, base, opClass, singleOp, doubleOp = None):
483 if doubleOp is None:
484 doubleOp = singleOp
485 global header_output, decoder_output, exec_output
486
487 code = singleCode % { "op": singleUnaryOp }
488 code = code % { "func": singleOp }
489 sIop = InstObjParams(name + "s", Name + "S", base,
513 if doubleOp is None:
514 doubleOp = singleOp
515 global header_output, decoder_output, exec_output
516
517 code = singleCode % { "op": singleUnaryOp }
518 code = code % { "func": singleOp }
519 sIop = InstObjParams(name + "s", Name + "S", base,
490 { "code": code, "predicate_test": predicateTest }, [])
520 { "code": code,
521 "predicate_test": predicateTest,
522 "op_class": opClass }, [])
491 code = doubleCode % { "op": doubleUnaryOp }
492 code = code % { "func": doubleOp }
493 dIop = InstObjParams(name + "d", Name + "D", base,
523 code = doubleCode % { "op": doubleUnaryOp }
524 code = code % { "func": doubleOp }
525 dIop = InstObjParams(name + "d", Name + "D", base,
494 { "code": code, "predicate_test": predicateTest }, [])
526 { "code": code,
527 "predicate_test": predicateTest,
528 "op_class": opClass }, [])
495
496 declareTempl = eval(base + "Declare");
497 constructorTempl = eval(base + "Constructor");
498
499 for iop in sIop, dIop:
500 header_output += declareTempl.subst(iop)
501 decoder_output += constructorTempl.subst(iop)
502 exec_output += PredOpExecute.subst(iop)
503
529
530 declareTempl = eval(base + "Declare");
531 constructorTempl = eval(base + "Constructor");
532
533 for iop in sIop, dIop:
534 header_output += declareTempl.subst(iop)
535 decoder_output += constructorTempl.subst(iop)
536 exec_output += PredOpExecute.subst(iop)
537
504 buildUnaryFpOp("vsqrt", "Vsqrt", "FpRegRegOp", "sqrtf", "sqrt")
538 buildUnaryFpOp("vsqrt", "Vsqrt", "FpRegRegOp", "SimdFloatSqrtOp", "sqrtf",
539 "sqrt")
505
540
506 def buildSimpleUnaryFpOp(name, Name, base, singleOp, doubleOp = None):
541 def buildSimpleUnaryFpOp(name, Name, base, opClass, singleOp,
542 doubleOp = None):
507 if doubleOp is None:
508 doubleOp = singleOp
509 global header_output, decoder_output, exec_output
510
511 sIop = InstObjParams(name + "s", Name + "S", base,
512 { "code": singleCode % { "op": singleOp },
543 if doubleOp is None:
544 doubleOp = singleOp
545 global header_output, decoder_output, exec_output
546
547 sIop = InstObjParams(name + "s", Name + "S", base,
548 { "code": singleCode % { "op": singleOp },
513 "predicate_test": predicateTest }, [])
549 "predicate_test": predicateTest,
550 "op_class": opClass }, [])
514 dIop = InstObjParams(name + "d", Name + "D", base,
515 { "code": doubleCode % { "op": doubleOp },
551 dIop = InstObjParams(name + "d", Name + "D", base,
552 { "code": doubleCode % { "op": doubleOp },
516 "predicate_test": predicateTest }, [])
553 "predicate_test": predicateTest,
554 "op_class": opClass }, [])
517
518 declareTempl = eval(base + "Declare");
519 constructorTempl = eval(base + "Constructor");
520
521 for iop in sIop, dIop:
522 header_output += declareTempl.subst(iop)
523 decoder_output += constructorTempl.subst(iop)
524 exec_output += PredOpExecute.subst(iop)
525
555
556 declareTempl = eval(base + "Declare");
557 constructorTempl = eval(base + "Constructor");
558
559 for iop in sIop, dIop:
560 header_output += declareTempl.subst(iop)
561 decoder_output += constructorTempl.subst(iop)
562 exec_output += PredOpExecute.subst(iop)
563
526 buildSimpleUnaryFpOp("vneg", "Vneg", "FpRegRegOp",
564 buildSimpleUnaryFpOp("vneg", "Vneg", "FpRegRegOp", "SimdFloatMiscOp",
527 "-FpOp1", "-dbl(FpOp1P0.uw, FpOp1P1.uw)")
565 "-FpOp1", "-dbl(FpOp1P0.uw, FpOp1P1.uw)")
528 buildSimpleUnaryFpOp("vabs", "Vabs", "FpRegRegOp",
566 buildSimpleUnaryFpOp("vabs", "Vabs", "FpRegRegOp", "SimdFloatMiscOp",
529 "fabsf(FpOp1)", "fabs(dbl(FpOp1P0.uw, FpOp1P1.uw))")
530}};
531
532let {{
533
534 header_output = ""
535 decoder_output = ""
536 exec_output = ""
537
538 vmlaSCode = vfpEnabledCheckCode + '''
539 FPSCR fpscr = Fpscr | FpCondCodes;
540 float mid = binaryOp(fpscr, FpOp1, FpOp2,
541 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
542 FpDest = binaryOp(fpscr, FpDest, mid, fpAddS,
543 fpscr.fz, fpscr.dn, fpscr.rMode);
544 FpCondCodes = fpscr & FpCondCodesMask;
545 '''
546 vmlaSIop = InstObjParams("vmlas", "VmlaS", "FpRegRegRegOp",
547 { "code": vmlaSCode,
567 "fabsf(FpOp1)", "fabs(dbl(FpOp1P0.uw, FpOp1P1.uw))")
568}};
569
570let {{
571
572 header_output = ""
573 decoder_output = ""
574 exec_output = ""
575
576 vmlaSCode = vfpEnabledCheckCode + '''
577 FPSCR fpscr = Fpscr | FpCondCodes;
578 float mid = binaryOp(fpscr, FpOp1, FpOp2,
579 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
580 FpDest = binaryOp(fpscr, FpDest, mid, fpAddS,
581 fpscr.fz, fpscr.dn, fpscr.rMode);
582 FpCondCodes = fpscr & FpCondCodesMask;
583 '''
584 vmlaSIop = InstObjParams("vmlas", "VmlaS", "FpRegRegRegOp",
585 { "code": vmlaSCode,
548 "predicate_test": predicateTest }, [])
586 "predicate_test": predicateTest,
587 "op_class": "SimdFloatMultAccOp" }, [])
549 header_output += FpRegRegRegOpDeclare.subst(vmlaSIop);
550 decoder_output += FpRegRegRegOpConstructor.subst(vmlaSIop);
551 exec_output += PredOpExecute.subst(vmlaSIop);
552
553 vmlaDCode = vfpEnabledCheckCode + '''
554 FPSCR fpscr = Fpscr | FpCondCodes;
555 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
556 dbl(FpOp2P0.uw, FpOp2P1.uw),
557 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
558 double dest = binaryOp(fpscr, dbl(FpDestP0.uw, FpDestP1.uw),
559 mid, fpAddD, fpscr.fz,
560 fpscr.dn, fpscr.rMode);
561 FpCondCodes = fpscr & FpCondCodesMask;
562 FpDestP0.uw = dblLow(dest);
563 FpDestP1.uw = dblHi(dest);
564 '''
565 vmlaDIop = InstObjParams("vmlad", "VmlaD", "FpRegRegRegOp",
566 { "code": vmlaDCode,
588 header_output += FpRegRegRegOpDeclare.subst(vmlaSIop);
589 decoder_output += FpRegRegRegOpConstructor.subst(vmlaSIop);
590 exec_output += PredOpExecute.subst(vmlaSIop);
591
592 vmlaDCode = vfpEnabledCheckCode + '''
593 FPSCR fpscr = Fpscr | FpCondCodes;
594 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
595 dbl(FpOp2P0.uw, FpOp2P1.uw),
596 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
597 double dest = binaryOp(fpscr, dbl(FpDestP0.uw, FpDestP1.uw),
598 mid, fpAddD, fpscr.fz,
599 fpscr.dn, fpscr.rMode);
600 FpCondCodes = fpscr & FpCondCodesMask;
601 FpDestP0.uw = dblLow(dest);
602 FpDestP1.uw = dblHi(dest);
603 '''
604 vmlaDIop = InstObjParams("vmlad", "VmlaD", "FpRegRegRegOp",
605 { "code": vmlaDCode,
567 "predicate_test": predicateTest }, [])
606 "predicate_test": predicateTest,
607 "op_class": "SimdFloatMultAccOp" }, [])
568 header_output += FpRegRegRegOpDeclare.subst(vmlaDIop);
569 decoder_output += FpRegRegRegOpConstructor.subst(vmlaDIop);
570 exec_output += PredOpExecute.subst(vmlaDIop);
571
572 vmlsSCode = vfpEnabledCheckCode + '''
573 FPSCR fpscr = Fpscr | FpCondCodes;
574 float mid = binaryOp(fpscr, FpOp1, FpOp2,
575 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
576 FpDest = binaryOp(fpscr, FpDest, -mid, fpAddS,
577 fpscr.fz, fpscr.dn, fpscr.rMode);
578 FpCondCodes = fpscr & FpCondCodesMask;
579 '''
580 vmlsSIop = InstObjParams("vmlss", "VmlsS", "FpRegRegRegOp",
581 { "code": vmlsSCode,
608 header_output += FpRegRegRegOpDeclare.subst(vmlaDIop);
609 decoder_output += FpRegRegRegOpConstructor.subst(vmlaDIop);
610 exec_output += PredOpExecute.subst(vmlaDIop);
611
612 vmlsSCode = vfpEnabledCheckCode + '''
613 FPSCR fpscr = Fpscr | FpCondCodes;
614 float mid = binaryOp(fpscr, FpOp1, FpOp2,
615 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
616 FpDest = binaryOp(fpscr, FpDest, -mid, fpAddS,
617 fpscr.fz, fpscr.dn, fpscr.rMode);
618 FpCondCodes = fpscr & FpCondCodesMask;
619 '''
620 vmlsSIop = InstObjParams("vmlss", "VmlsS", "FpRegRegRegOp",
621 { "code": vmlsSCode,
582 "predicate_test": predicateTest }, [])
622 "predicate_test": predicateTest,
623 "op_class": "SimdFloatMultAccOp" }, [])
583 header_output += FpRegRegRegOpDeclare.subst(vmlsSIop);
584 decoder_output += FpRegRegRegOpConstructor.subst(vmlsSIop);
585 exec_output += PredOpExecute.subst(vmlsSIop);
586
587 vmlsDCode = vfpEnabledCheckCode + '''
588 FPSCR fpscr = Fpscr | FpCondCodes;
589 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
590 dbl(FpOp2P0.uw, FpOp2P1.uw),
591 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
592 double dest = binaryOp(fpscr, dbl(FpDestP0.uw, FpDestP1.uw),
593 -mid, fpAddD, fpscr.fz,
594 fpscr.dn, fpscr.rMode);
595 FpCondCodes = fpscr & FpCondCodesMask;
596 FpDestP0.uw = dblLow(dest);
597 FpDestP1.uw = dblHi(dest);
598 '''
599 vmlsDIop = InstObjParams("vmlsd", "VmlsD", "FpRegRegRegOp",
600 { "code": vmlsDCode,
624 header_output += FpRegRegRegOpDeclare.subst(vmlsSIop);
625 decoder_output += FpRegRegRegOpConstructor.subst(vmlsSIop);
626 exec_output += PredOpExecute.subst(vmlsSIop);
627
628 vmlsDCode = vfpEnabledCheckCode + '''
629 FPSCR fpscr = Fpscr | FpCondCodes;
630 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
631 dbl(FpOp2P0.uw, FpOp2P1.uw),
632 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
633 double dest = binaryOp(fpscr, dbl(FpDestP0.uw, FpDestP1.uw),
634 -mid, fpAddD, fpscr.fz,
635 fpscr.dn, fpscr.rMode);
636 FpCondCodes = fpscr & FpCondCodesMask;
637 FpDestP0.uw = dblLow(dest);
638 FpDestP1.uw = dblHi(dest);
639 '''
640 vmlsDIop = InstObjParams("vmlsd", "VmlsD", "FpRegRegRegOp",
641 { "code": vmlsDCode,
601 "predicate_test": predicateTest }, [])
642 "predicate_test": predicateTest,
643 "op_class": "SimdFloatMultAccOp" }, [])
602 header_output += FpRegRegRegOpDeclare.subst(vmlsDIop);
603 decoder_output += FpRegRegRegOpConstructor.subst(vmlsDIop);
604 exec_output += PredOpExecute.subst(vmlsDIop);
605
606 vnmlaSCode = vfpEnabledCheckCode + '''
607 FPSCR fpscr = Fpscr | FpCondCodes;
608 float mid = binaryOp(fpscr, FpOp1, FpOp2,
609 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
610 FpDest = binaryOp(fpscr, -FpDest, -mid, fpAddS,
611 fpscr.fz, fpscr.dn, fpscr.rMode);
612 FpCondCodes = fpscr & FpCondCodesMask;
613 '''
614 vnmlaSIop = InstObjParams("vnmlas", "VnmlaS", "FpRegRegRegOp",
615 { "code": vnmlaSCode,
644 header_output += FpRegRegRegOpDeclare.subst(vmlsDIop);
645 decoder_output += FpRegRegRegOpConstructor.subst(vmlsDIop);
646 exec_output += PredOpExecute.subst(vmlsDIop);
647
648 vnmlaSCode = vfpEnabledCheckCode + '''
649 FPSCR fpscr = Fpscr | FpCondCodes;
650 float mid = binaryOp(fpscr, FpOp1, FpOp2,
651 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
652 FpDest = binaryOp(fpscr, -FpDest, -mid, fpAddS,
653 fpscr.fz, fpscr.dn, fpscr.rMode);
654 FpCondCodes = fpscr & FpCondCodesMask;
655 '''
656 vnmlaSIop = InstObjParams("vnmlas", "VnmlaS", "FpRegRegRegOp",
657 { "code": vnmlaSCode,
616 "predicate_test": predicateTest }, [])
658 "predicate_test": predicateTest,
659 "op_class": "SimdFloatMultAccOp" }, [])
617 header_output += FpRegRegRegOpDeclare.subst(vnmlaSIop);
618 decoder_output += FpRegRegRegOpConstructor.subst(vnmlaSIop);
619 exec_output += PredOpExecute.subst(vnmlaSIop);
620
621 vnmlaDCode = vfpEnabledCheckCode + '''
622 FPSCR fpscr = Fpscr | FpCondCodes;
623 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
624 dbl(FpOp2P0.uw, FpOp2P1.uw),
625 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
626 double dest = binaryOp(fpscr, -dbl(FpDestP0.uw, FpDestP1.uw),
627 -mid, fpAddD, fpscr.fz,
628 fpscr.dn, fpscr.rMode);
629 FpCondCodes = fpscr & FpCondCodesMask;
630 FpDestP0.uw = dblLow(dest);
631 FpDestP1.uw = dblHi(dest);
632 '''
633 vnmlaDIop = InstObjParams("vnmlad", "VnmlaD", "FpRegRegRegOp",
634 { "code": vnmlaDCode,
660 header_output += FpRegRegRegOpDeclare.subst(vnmlaSIop);
661 decoder_output += FpRegRegRegOpConstructor.subst(vnmlaSIop);
662 exec_output += PredOpExecute.subst(vnmlaSIop);
663
664 vnmlaDCode = vfpEnabledCheckCode + '''
665 FPSCR fpscr = Fpscr | FpCondCodes;
666 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
667 dbl(FpOp2P0.uw, FpOp2P1.uw),
668 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
669 double dest = binaryOp(fpscr, -dbl(FpDestP0.uw, FpDestP1.uw),
670 -mid, fpAddD, fpscr.fz,
671 fpscr.dn, fpscr.rMode);
672 FpCondCodes = fpscr & FpCondCodesMask;
673 FpDestP0.uw = dblLow(dest);
674 FpDestP1.uw = dblHi(dest);
675 '''
676 vnmlaDIop = InstObjParams("vnmlad", "VnmlaD", "FpRegRegRegOp",
677 { "code": vnmlaDCode,
635 "predicate_test": predicateTest }, [])
678 "predicate_test": predicateTest,
679 "op_class": "SimdFloatMultAccOp" }, [])
636 header_output += FpRegRegRegOpDeclare.subst(vnmlaDIop);
637 decoder_output += FpRegRegRegOpConstructor.subst(vnmlaDIop);
638 exec_output += PredOpExecute.subst(vnmlaDIop);
639
640 vnmlsSCode = vfpEnabledCheckCode + '''
641 FPSCR fpscr = Fpscr | FpCondCodes;
642 float mid = binaryOp(fpscr, FpOp1, FpOp2,
643 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
644 FpDest = binaryOp(fpscr, -FpDest, mid, fpAddS,
645 fpscr.fz, fpscr.dn, fpscr.rMode);
646 FpCondCodes = fpscr & FpCondCodesMask;
647 '''
648 vnmlsSIop = InstObjParams("vnmlss", "VnmlsS", "FpRegRegRegOp",
680 header_output += FpRegRegRegOpDeclare.subst(vnmlaDIop);
681 decoder_output += FpRegRegRegOpConstructor.subst(vnmlaDIop);
682 exec_output += PredOpExecute.subst(vnmlaDIop);
683
684 vnmlsSCode = vfpEnabledCheckCode + '''
685 FPSCR fpscr = Fpscr | FpCondCodes;
686 float mid = binaryOp(fpscr, FpOp1, FpOp2,
687 fpMulS, fpscr.fz, fpscr.dn, fpscr.rMode);
688 FpDest = binaryOp(fpscr, -FpDest, mid, fpAddS,
689 fpscr.fz, fpscr.dn, fpscr.rMode);
690 FpCondCodes = fpscr & FpCondCodesMask;
691 '''
692 vnmlsSIop = InstObjParams("vnmlss", "VnmlsS", "FpRegRegRegOp",
649 { "code": vnmlsSCode,
650 "predicate_test": predicateTest }, [])
693 { "code": vnmlsSCode,
694 "predicate_test": predicateTest,
695 "op_class": "SimdFloatMultAccOp" }, [])
651 header_output += FpRegRegRegOpDeclare.subst(vnmlsSIop);
652 decoder_output += FpRegRegRegOpConstructor.subst(vnmlsSIop);
653 exec_output += PredOpExecute.subst(vnmlsSIop);
654
655 vnmlsDCode = vfpEnabledCheckCode + '''
656 FPSCR fpscr = Fpscr | FpCondCodes;
657 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
658 dbl(FpOp2P0.uw, FpOp2P1.uw),
659 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
660 double dest = binaryOp(fpscr, -dbl(FpDestP0.uw, FpDestP1.uw),
661 mid, fpAddD, fpscr.fz,
662 fpscr.dn, fpscr.rMode);
663 FpCondCodes = fpscr & FpCondCodesMask;
664 FpDestP0.uw = dblLow(dest);
665 FpDestP1.uw = dblHi(dest);
666 '''
667 vnmlsDIop = InstObjParams("vnmlsd", "VnmlsD", "FpRegRegRegOp",
696 header_output += FpRegRegRegOpDeclare.subst(vnmlsSIop);
697 decoder_output += FpRegRegRegOpConstructor.subst(vnmlsSIop);
698 exec_output += PredOpExecute.subst(vnmlsSIop);
699
700 vnmlsDCode = vfpEnabledCheckCode + '''
701 FPSCR fpscr = Fpscr | FpCondCodes;
702 double mid = binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
703 dbl(FpOp2P0.uw, FpOp2P1.uw),
704 fpMulD, fpscr.fz, fpscr.dn, fpscr.rMode);
705 double dest = binaryOp(fpscr, -dbl(FpDestP0.uw, FpDestP1.uw),
706 mid, fpAddD, fpscr.fz,
707 fpscr.dn, fpscr.rMode);
708 FpCondCodes = fpscr & FpCondCodesMask;
709 FpDestP0.uw = dblLow(dest);
710 FpDestP1.uw = dblHi(dest);
711 '''
712 vnmlsDIop = InstObjParams("vnmlsd", "VnmlsD", "FpRegRegRegOp",
668 { "code": vnmlsDCode,
669 "predicate_test": predicateTest }, [])
713 { "code": vnmlsDCode,
714 "predicate_test": predicateTest,
715 "op_class": "SimdFloatMultAccOp" }, [])
670 header_output += FpRegRegRegOpDeclare.subst(vnmlsDIop);
671 decoder_output += FpRegRegRegOpConstructor.subst(vnmlsDIop);
672 exec_output += PredOpExecute.subst(vnmlsDIop);
673
674 vnmulSCode = vfpEnabledCheckCode + '''
675 FPSCR fpscr = Fpscr | FpCondCodes;
676 FpDest = -binaryOp(fpscr, FpOp1, FpOp2, fpMulS,
677 fpscr.fz, fpscr.dn, fpscr.rMode);
678 FpCondCodes = fpscr & FpCondCodesMask;
679 '''
680 vnmulSIop = InstObjParams("vnmuls", "VnmulS", "FpRegRegRegOp",
716 header_output += FpRegRegRegOpDeclare.subst(vnmlsDIop);
717 decoder_output += FpRegRegRegOpConstructor.subst(vnmlsDIop);
718 exec_output += PredOpExecute.subst(vnmlsDIop);
719
720 vnmulSCode = vfpEnabledCheckCode + '''
721 FPSCR fpscr = Fpscr | FpCondCodes;
722 FpDest = -binaryOp(fpscr, FpOp1, FpOp2, fpMulS,
723 fpscr.fz, fpscr.dn, fpscr.rMode);
724 FpCondCodes = fpscr & FpCondCodesMask;
725 '''
726 vnmulSIop = InstObjParams("vnmuls", "VnmulS", "FpRegRegRegOp",
681 { "code": vnmulSCode,
682 "predicate_test": predicateTest }, [])
727 { "code": vnmulSCode,
728 "predicate_test": predicateTest,
729 "op_class": "SimdFloatMultOp" }, [])
683 header_output += FpRegRegRegOpDeclare.subst(vnmulSIop);
684 decoder_output += FpRegRegRegOpConstructor.subst(vnmulSIop);
685 exec_output += PredOpExecute.subst(vnmulSIop);
686
687 vnmulDCode = vfpEnabledCheckCode + '''
688 FPSCR fpscr = Fpscr | FpCondCodes;
689 double dest = -binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
690 dbl(FpOp2P0.uw, FpOp2P1.uw),
691 fpMulD, fpscr.fz, fpscr.dn,
692 fpscr.rMode);
693 FpCondCodes = fpscr & FpCondCodesMask;
694 FpDestP0.uw = dblLow(dest);
695 FpDestP1.uw = dblHi(dest);
696 '''
697 vnmulDIop = InstObjParams("vnmuld", "VnmulD", "FpRegRegRegOp",
698 { "code": vnmulDCode,
730 header_output += FpRegRegRegOpDeclare.subst(vnmulSIop);
731 decoder_output += FpRegRegRegOpConstructor.subst(vnmulSIop);
732 exec_output += PredOpExecute.subst(vnmulSIop);
733
734 vnmulDCode = vfpEnabledCheckCode + '''
735 FPSCR fpscr = Fpscr | FpCondCodes;
736 double dest = -binaryOp(fpscr, dbl(FpOp1P0.uw, FpOp1P1.uw),
737 dbl(FpOp2P0.uw, FpOp2P1.uw),
738 fpMulD, fpscr.fz, fpscr.dn,
739 fpscr.rMode);
740 FpCondCodes = fpscr & FpCondCodesMask;
741 FpDestP0.uw = dblLow(dest);
742 FpDestP1.uw = dblHi(dest);
743 '''
744 vnmulDIop = InstObjParams("vnmuld", "VnmulD", "FpRegRegRegOp",
745 { "code": vnmulDCode,
699 "predicate_test": predicateTest }, [])
746 "predicate_test": predicateTest,
747 "op_class": "SimdFloatMultOp" }, [])
700 header_output += FpRegRegRegOpDeclare.subst(vnmulDIop);
701 decoder_output += FpRegRegRegOpConstructor.subst(vnmulDIop);
702 exec_output += PredOpExecute.subst(vnmulDIop);
703}};
704
705let {{
706
707 header_output = ""

--- 6 unchanged lines hidden (view full) ---

714 __asm__ __volatile__("" : "=m" (FpOp1.uw) : "m" (FpOp1.uw));
715 FpDest = FpOp1.uw;
716 __asm__ __volatile__("" :: "m" (FpDest));
717 finishVfp(fpscr, state, fpscr.fz);
718 FpCondCodes = fpscr & FpCondCodesMask;
719 '''
720 vcvtUIntFpSIop = InstObjParams("vcvt", "VcvtUIntFpS", "FpRegRegOp",
721 { "code": vcvtUIntFpSCode,
748 header_output += FpRegRegRegOpDeclare.subst(vnmulDIop);
749 decoder_output += FpRegRegRegOpConstructor.subst(vnmulDIop);
750 exec_output += PredOpExecute.subst(vnmulDIop);
751}};
752
753let {{
754
755 header_output = ""

--- 6 unchanged lines hidden (view full) ---

762 __asm__ __volatile__("" : "=m" (FpOp1.uw) : "m" (FpOp1.uw));
763 FpDest = FpOp1.uw;
764 __asm__ __volatile__("" :: "m" (FpDest));
765 finishVfp(fpscr, state, fpscr.fz);
766 FpCondCodes = fpscr & FpCondCodesMask;
767 '''
768 vcvtUIntFpSIop = InstObjParams("vcvt", "VcvtUIntFpS", "FpRegRegOp",
769 { "code": vcvtUIntFpSCode,
722 "predicate_test": predicateTest }, [])
770 "predicate_test": predicateTest,
771 "op_class": "SimdFloatCvtOp" }, [])
723 header_output += FpRegRegOpDeclare.subst(vcvtUIntFpSIop);
724 decoder_output += FpRegRegOpConstructor.subst(vcvtUIntFpSIop);
725 exec_output += PredOpExecute.subst(vcvtUIntFpSIop);
726
727 vcvtUIntFpDCode = vfpEnabledCheckCode + '''
728 FPSCR fpscr = Fpscr | FpCondCodes;
729 VfpSavedState state = prepFpState(fpscr.rMode);
730 __asm__ __volatile__("" : "=m" (FpOp1P0.uw) : "m" (FpOp1P0.uw));
731 double cDest = (uint64_t)FpOp1P0.uw;
732 __asm__ __volatile__("" :: "m" (cDest));
733 finishVfp(fpscr, state, fpscr.fz);
734 FpCondCodes = fpscr & FpCondCodesMask;
735 FpDestP0.uw = dblLow(cDest);
736 FpDestP1.uw = dblHi(cDest);
737 '''
738 vcvtUIntFpDIop = InstObjParams("vcvt", "VcvtUIntFpD", "FpRegRegOp",
739 { "code": vcvtUIntFpDCode,
772 header_output += FpRegRegOpDeclare.subst(vcvtUIntFpSIop);
773 decoder_output += FpRegRegOpConstructor.subst(vcvtUIntFpSIop);
774 exec_output += PredOpExecute.subst(vcvtUIntFpSIop);
775
776 vcvtUIntFpDCode = vfpEnabledCheckCode + '''
777 FPSCR fpscr = Fpscr | FpCondCodes;
778 VfpSavedState state = prepFpState(fpscr.rMode);
779 __asm__ __volatile__("" : "=m" (FpOp1P0.uw) : "m" (FpOp1P0.uw));
780 double cDest = (uint64_t)FpOp1P0.uw;
781 __asm__ __volatile__("" :: "m" (cDest));
782 finishVfp(fpscr, state, fpscr.fz);
783 FpCondCodes = fpscr & FpCondCodesMask;
784 FpDestP0.uw = dblLow(cDest);
785 FpDestP1.uw = dblHi(cDest);
786 '''
787 vcvtUIntFpDIop = InstObjParams("vcvt", "VcvtUIntFpD", "FpRegRegOp",
788 { "code": vcvtUIntFpDCode,
740 "predicate_test": predicateTest }, [])
789 "predicate_test": predicateTest,
790 "op_class": "SimdFloatCvtOp" }, [])
741 header_output += FpRegRegOpDeclare.subst(vcvtUIntFpDIop);
742 decoder_output += FpRegRegOpConstructor.subst(vcvtUIntFpDIop);
743 exec_output += PredOpExecute.subst(vcvtUIntFpDIop);
744
745 vcvtSIntFpSCode = vfpEnabledCheckCode + '''
746 FPSCR fpscr = Fpscr | FpCondCodes;
747 VfpSavedState state = prepFpState(fpscr.rMode);
748 __asm__ __volatile__("" : "=m" (FpOp1.sw) : "m" (FpOp1.sw));
749 FpDest = FpOp1.sw;
750 __asm__ __volatile__("" :: "m" (FpDest));
751 finishVfp(fpscr, state, fpscr.fz);
752 FpCondCodes = fpscr & FpCondCodesMask;
753 '''
754 vcvtSIntFpSIop = InstObjParams("vcvt", "VcvtSIntFpS", "FpRegRegOp",
755 { "code": vcvtSIntFpSCode,
791 header_output += FpRegRegOpDeclare.subst(vcvtUIntFpDIop);
792 decoder_output += FpRegRegOpConstructor.subst(vcvtUIntFpDIop);
793 exec_output += PredOpExecute.subst(vcvtUIntFpDIop);
794
795 vcvtSIntFpSCode = vfpEnabledCheckCode + '''
796 FPSCR fpscr = Fpscr | FpCondCodes;
797 VfpSavedState state = prepFpState(fpscr.rMode);
798 __asm__ __volatile__("" : "=m" (FpOp1.sw) : "m" (FpOp1.sw));
799 FpDest = FpOp1.sw;
800 __asm__ __volatile__("" :: "m" (FpDest));
801 finishVfp(fpscr, state, fpscr.fz);
802 FpCondCodes = fpscr & FpCondCodesMask;
803 '''
804 vcvtSIntFpSIop = InstObjParams("vcvt", "VcvtSIntFpS", "FpRegRegOp",
805 { "code": vcvtSIntFpSCode,
756 "predicate_test": predicateTest }, [])
806 "predicate_test": predicateTest,
807 "op_class": "SimdFloatCvtOp" }, [])
757 header_output += FpRegRegOpDeclare.subst(vcvtSIntFpSIop);
758 decoder_output += FpRegRegOpConstructor.subst(vcvtSIntFpSIop);
759 exec_output += PredOpExecute.subst(vcvtSIntFpSIop);
760
761 vcvtSIntFpDCode = vfpEnabledCheckCode + '''
762 FPSCR fpscr = Fpscr | FpCondCodes;
763 VfpSavedState state = prepFpState(fpscr.rMode);
764 __asm__ __volatile__("" : "=m" (FpOp1P0.sw) : "m" (FpOp1P0.sw));
765 double cDest = FpOp1P0.sw;
766 __asm__ __volatile__("" :: "m" (cDest));
767 finishVfp(fpscr, state, fpscr.fz);
768 FpCondCodes = fpscr & FpCondCodesMask;
769 FpDestP0.uw = dblLow(cDest);
770 FpDestP1.uw = dblHi(cDest);
771 '''
772 vcvtSIntFpDIop = InstObjParams("vcvt", "VcvtSIntFpD", "FpRegRegOp",
773 { "code": vcvtSIntFpDCode,
808 header_output += FpRegRegOpDeclare.subst(vcvtSIntFpSIop);
809 decoder_output += FpRegRegOpConstructor.subst(vcvtSIntFpSIop);
810 exec_output += PredOpExecute.subst(vcvtSIntFpSIop);
811
812 vcvtSIntFpDCode = vfpEnabledCheckCode + '''
813 FPSCR fpscr = Fpscr | FpCondCodes;
814 VfpSavedState state = prepFpState(fpscr.rMode);
815 __asm__ __volatile__("" : "=m" (FpOp1P0.sw) : "m" (FpOp1P0.sw));
816 double cDest = FpOp1P0.sw;
817 __asm__ __volatile__("" :: "m" (cDest));
818 finishVfp(fpscr, state, fpscr.fz);
819 FpCondCodes = fpscr & FpCondCodesMask;
820 FpDestP0.uw = dblLow(cDest);
821 FpDestP1.uw = dblHi(cDest);
822 '''
823 vcvtSIntFpDIop = InstObjParams("vcvt", "VcvtSIntFpD", "FpRegRegOp",
824 { "code": vcvtSIntFpDCode,
774 "predicate_test": predicateTest }, [])
825 "predicate_test": predicateTest,
826 "op_class": "SimdFloatCvtOp" }, [])
775 header_output += FpRegRegOpDeclare.subst(vcvtSIntFpDIop);
776 decoder_output += FpRegRegOpConstructor.subst(vcvtSIntFpDIop);
777 exec_output += PredOpExecute.subst(vcvtSIntFpDIop);
778
779 vcvtFpUIntSRCode = vfpEnabledCheckCode + '''
780 FPSCR fpscr = Fpscr | FpCondCodes;
781 VfpSavedState state = prepFpState(fpscr.rMode);
782 vfpFlushToZero(fpscr, FpOp1);
783 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
784 FpDest.uw = vfpFpSToFixed(FpOp1, false, false, 0, false);
785 __asm__ __volatile__("" :: "m" (FpDest.uw));
786 finishVfp(fpscr, state, fpscr.fz);
787 FpCondCodes = fpscr & FpCondCodesMask;
788 '''
789 vcvtFpUIntSRIop = InstObjParams("vcvt", "VcvtFpUIntSR", "FpRegRegOp",
790 { "code": vcvtFpUIntSRCode,
827 header_output += FpRegRegOpDeclare.subst(vcvtSIntFpDIop);
828 decoder_output += FpRegRegOpConstructor.subst(vcvtSIntFpDIop);
829 exec_output += PredOpExecute.subst(vcvtSIntFpDIop);
830
831 vcvtFpUIntSRCode = vfpEnabledCheckCode + '''
832 FPSCR fpscr = Fpscr | FpCondCodes;
833 VfpSavedState state = prepFpState(fpscr.rMode);
834 vfpFlushToZero(fpscr, FpOp1);
835 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
836 FpDest.uw = vfpFpSToFixed(FpOp1, false, false, 0, false);
837 __asm__ __volatile__("" :: "m" (FpDest.uw));
838 finishVfp(fpscr, state, fpscr.fz);
839 FpCondCodes = fpscr & FpCondCodesMask;
840 '''
841 vcvtFpUIntSRIop = InstObjParams("vcvt", "VcvtFpUIntSR", "FpRegRegOp",
842 { "code": vcvtFpUIntSRCode,
791 "predicate_test": predicateTest }, [])
843 "predicate_test": predicateTest,
844 "op_class": "SimdFloatCvtOp" }, [])
792 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntSRIop);
793 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntSRIop);
794 exec_output += PredOpExecute.subst(vcvtFpUIntSRIop);
795
796 vcvtFpUIntDRCode = vfpEnabledCheckCode + '''
797 FPSCR fpscr = Fpscr | FpCondCodes;
798 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
799 vfpFlushToZero(fpscr, cOp1);
800 VfpSavedState state = prepFpState(fpscr.rMode);
801 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
802 uint64_t result = vfpFpDToFixed(cOp1, false, false, 0, false);
803 __asm__ __volatile__("" :: "m" (result));
804 finishVfp(fpscr, state, fpscr.fz);
805 FpCondCodes = fpscr & FpCondCodesMask;
806 FpDestP0.uw = result;
807 '''
808 vcvtFpUIntDRIop = InstObjParams("vcvtr", "VcvtFpUIntDR", "FpRegRegOp",
809 { "code": vcvtFpUIntDRCode,
845 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntSRIop);
846 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntSRIop);
847 exec_output += PredOpExecute.subst(vcvtFpUIntSRIop);
848
849 vcvtFpUIntDRCode = vfpEnabledCheckCode + '''
850 FPSCR fpscr = Fpscr | FpCondCodes;
851 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
852 vfpFlushToZero(fpscr, cOp1);
853 VfpSavedState state = prepFpState(fpscr.rMode);
854 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
855 uint64_t result = vfpFpDToFixed(cOp1, false, false, 0, false);
856 __asm__ __volatile__("" :: "m" (result));
857 finishVfp(fpscr, state, fpscr.fz);
858 FpCondCodes = fpscr & FpCondCodesMask;
859 FpDestP0.uw = result;
860 '''
861 vcvtFpUIntDRIop = InstObjParams("vcvtr", "VcvtFpUIntDR", "FpRegRegOp",
862 { "code": vcvtFpUIntDRCode,
810 "predicate_test": predicateTest }, [])
863 "predicate_test": predicateTest,
864 "op_class": "SimdFloatCvtOp" }, [])
811 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntDRIop);
812 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntDRIop);
813 exec_output += PredOpExecute.subst(vcvtFpUIntDRIop);
814
815 vcvtFpSIntSRCode = vfpEnabledCheckCode + '''
816 FPSCR fpscr = Fpscr | FpCondCodes;
817 VfpSavedState state = prepFpState(fpscr.rMode);
818 vfpFlushToZero(fpscr, FpOp1);
819 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
820 FpDest.sw = vfpFpSToFixed(FpOp1, true, false, 0, false);
821 __asm__ __volatile__("" :: "m" (FpDest.sw));
822 finishVfp(fpscr, state, fpscr.fz);
823 FpCondCodes = fpscr & FpCondCodesMask;
824 '''
825 vcvtFpSIntSRIop = InstObjParams("vcvtr", "VcvtFpSIntSR", "FpRegRegOp",
826 { "code": vcvtFpSIntSRCode,
865 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntDRIop);
866 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntDRIop);
867 exec_output += PredOpExecute.subst(vcvtFpUIntDRIop);
868
869 vcvtFpSIntSRCode = vfpEnabledCheckCode + '''
870 FPSCR fpscr = Fpscr | FpCondCodes;
871 VfpSavedState state = prepFpState(fpscr.rMode);
872 vfpFlushToZero(fpscr, FpOp1);
873 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
874 FpDest.sw = vfpFpSToFixed(FpOp1, true, false, 0, false);
875 __asm__ __volatile__("" :: "m" (FpDest.sw));
876 finishVfp(fpscr, state, fpscr.fz);
877 FpCondCodes = fpscr & FpCondCodesMask;
878 '''
879 vcvtFpSIntSRIop = InstObjParams("vcvtr", "VcvtFpSIntSR", "FpRegRegOp",
880 { "code": vcvtFpSIntSRCode,
827 "predicate_test": predicateTest }, [])
881 "predicate_test": predicateTest,
882 "op_class": "SimdFloatCvtOp" }, [])
828 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntSRIop);
829 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntSRIop);
830 exec_output += PredOpExecute.subst(vcvtFpSIntSRIop);
831
832 vcvtFpSIntDRCode = vfpEnabledCheckCode + '''
833 FPSCR fpscr = Fpscr | FpCondCodes;
834 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
835 vfpFlushToZero(fpscr, cOp1);
836 VfpSavedState state = prepFpState(fpscr.rMode);
837 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
838 int64_t result = vfpFpDToFixed(cOp1, true, false, 0, false);
839 __asm__ __volatile__("" :: "m" (result));
840 finishVfp(fpscr, state, fpscr.fz);
841 FpCondCodes = fpscr & FpCondCodesMask;
842 FpDestP0.uw = result;
843 '''
844 vcvtFpSIntDRIop = InstObjParams("vcvtr", "VcvtFpSIntDR", "FpRegRegOp",
845 { "code": vcvtFpSIntDRCode,
883 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntSRIop);
884 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntSRIop);
885 exec_output += PredOpExecute.subst(vcvtFpSIntSRIop);
886
887 vcvtFpSIntDRCode = vfpEnabledCheckCode + '''
888 FPSCR fpscr = Fpscr | FpCondCodes;
889 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
890 vfpFlushToZero(fpscr, cOp1);
891 VfpSavedState state = prepFpState(fpscr.rMode);
892 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
893 int64_t result = vfpFpDToFixed(cOp1, true, false, 0, false);
894 __asm__ __volatile__("" :: "m" (result));
895 finishVfp(fpscr, state, fpscr.fz);
896 FpCondCodes = fpscr & FpCondCodesMask;
897 FpDestP0.uw = result;
898 '''
899 vcvtFpSIntDRIop = InstObjParams("vcvtr", "VcvtFpSIntDR", "FpRegRegOp",
900 { "code": vcvtFpSIntDRCode,
846 "predicate_test": predicateTest }, [])
901 "predicate_test": predicateTest,
902 "op_class": "SimdFloatCvtOp" }, [])
847 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntDRIop);
848 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntDRIop);
849 exec_output += PredOpExecute.subst(vcvtFpSIntDRIop);
850
851 vcvtFpUIntSCode = vfpEnabledCheckCode + '''
852 FPSCR fpscr = Fpscr | FpCondCodes;
853 vfpFlushToZero(fpscr, FpOp1);
854 VfpSavedState state = prepFpState(fpscr.rMode);
855 fesetround(FeRoundZero);
856 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
857 FpDest.uw = vfpFpSToFixed(FpOp1, false, false, 0);
858 __asm__ __volatile__("" :: "m" (FpDest.uw));
859 finishVfp(fpscr, state, fpscr.fz);
860 FpCondCodes = fpscr & FpCondCodesMask;
861 '''
862 vcvtFpUIntSIop = InstObjParams("vcvt", "VcvtFpUIntS", "FpRegRegOp",
863 { "code": vcvtFpUIntSCode,
903 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntDRIop);
904 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntDRIop);
905 exec_output += PredOpExecute.subst(vcvtFpSIntDRIop);
906
907 vcvtFpUIntSCode = vfpEnabledCheckCode + '''
908 FPSCR fpscr = Fpscr | FpCondCodes;
909 vfpFlushToZero(fpscr, FpOp1);
910 VfpSavedState state = prepFpState(fpscr.rMode);
911 fesetround(FeRoundZero);
912 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
913 FpDest.uw = vfpFpSToFixed(FpOp1, false, false, 0);
914 __asm__ __volatile__("" :: "m" (FpDest.uw));
915 finishVfp(fpscr, state, fpscr.fz);
916 FpCondCodes = fpscr & FpCondCodesMask;
917 '''
918 vcvtFpUIntSIop = InstObjParams("vcvt", "VcvtFpUIntS", "FpRegRegOp",
919 { "code": vcvtFpUIntSCode,
864 "predicate_test": predicateTest }, [])
920 "predicate_test": predicateTest,
921 "op_class": "SimdFloatCvtOp" }, [])
865 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntSIop);
866 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntSIop);
867 exec_output += PredOpExecute.subst(vcvtFpUIntSIop);
868
869 vcvtFpUIntDCode = vfpEnabledCheckCode + '''
870 FPSCR fpscr = Fpscr | FpCondCodes;
871 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
872 vfpFlushToZero(fpscr, cOp1);
873 VfpSavedState state = prepFpState(fpscr.rMode);
874 fesetround(FeRoundZero);
875 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
876 uint64_t result = vfpFpDToFixed(cOp1, false, false, 0);
877 __asm__ __volatile__("" :: "m" (result));
878 finishVfp(fpscr, state, fpscr.fz);
879 FpCondCodes = fpscr & FpCondCodesMask;
880 FpDestP0.uw = result;
881 '''
882 vcvtFpUIntDIop = InstObjParams("vcvt", "VcvtFpUIntD", "FpRegRegOp",
883 { "code": vcvtFpUIntDCode,
922 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntSIop);
923 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntSIop);
924 exec_output += PredOpExecute.subst(vcvtFpUIntSIop);
925
926 vcvtFpUIntDCode = vfpEnabledCheckCode + '''
927 FPSCR fpscr = Fpscr | FpCondCodes;
928 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
929 vfpFlushToZero(fpscr, cOp1);
930 VfpSavedState state = prepFpState(fpscr.rMode);
931 fesetround(FeRoundZero);
932 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
933 uint64_t result = vfpFpDToFixed(cOp1, false, false, 0);
934 __asm__ __volatile__("" :: "m" (result));
935 finishVfp(fpscr, state, fpscr.fz);
936 FpCondCodes = fpscr & FpCondCodesMask;
937 FpDestP0.uw = result;
938 '''
939 vcvtFpUIntDIop = InstObjParams("vcvt", "VcvtFpUIntD", "FpRegRegOp",
940 { "code": vcvtFpUIntDCode,
884 "predicate_test": predicateTest }, [])
941 "predicate_test": predicateTest,
942 "op_class": "SimdFloatCvtOp" }, [])
885 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntDIop);
886 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntDIop);
887 exec_output += PredOpExecute.subst(vcvtFpUIntDIop);
888
889 vcvtFpSIntSCode = vfpEnabledCheckCode + '''
890 FPSCR fpscr = Fpscr | FpCondCodes;
891 vfpFlushToZero(fpscr, FpOp1);
892 VfpSavedState state = prepFpState(fpscr.rMode);
893 fesetround(FeRoundZero);
894 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
895 FpDest.sw = vfpFpSToFixed(FpOp1, true, false, 0);
896 __asm__ __volatile__("" :: "m" (FpDest.sw));
897 finishVfp(fpscr, state, fpscr.fz);
898 FpCondCodes = fpscr & FpCondCodesMask;
899 '''
900 vcvtFpSIntSIop = InstObjParams("vcvt", "VcvtFpSIntS", "FpRegRegOp",
901 { "code": vcvtFpSIntSCode,
943 header_output += FpRegRegOpDeclare.subst(vcvtFpUIntDIop);
944 decoder_output += FpRegRegOpConstructor.subst(vcvtFpUIntDIop);
945 exec_output += PredOpExecute.subst(vcvtFpUIntDIop);
946
947 vcvtFpSIntSCode = vfpEnabledCheckCode + '''
948 FPSCR fpscr = Fpscr | FpCondCodes;
949 vfpFlushToZero(fpscr, FpOp1);
950 VfpSavedState state = prepFpState(fpscr.rMode);
951 fesetround(FeRoundZero);
952 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
953 FpDest.sw = vfpFpSToFixed(FpOp1, true, false, 0);
954 __asm__ __volatile__("" :: "m" (FpDest.sw));
955 finishVfp(fpscr, state, fpscr.fz);
956 FpCondCodes = fpscr & FpCondCodesMask;
957 '''
958 vcvtFpSIntSIop = InstObjParams("vcvt", "VcvtFpSIntS", "FpRegRegOp",
959 { "code": vcvtFpSIntSCode,
902 "predicate_test": predicateTest }, [])
960 "predicate_test": predicateTest,
961 "op_class": "SimdFloatCvtOp" }, [])
903 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntSIop);
904 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntSIop);
905 exec_output += PredOpExecute.subst(vcvtFpSIntSIop);
906
907 vcvtFpSIntDCode = vfpEnabledCheckCode + '''
908 FPSCR fpscr = Fpscr | FpCondCodes;
909 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
910 vfpFlushToZero(fpscr, cOp1);
911 VfpSavedState state = prepFpState(fpscr.rMode);
912 fesetround(FeRoundZero);
913 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
914 int64_t result = vfpFpDToFixed(cOp1, true, false, 0);
915 __asm__ __volatile__("" :: "m" (result));
916 finishVfp(fpscr, state, fpscr.fz);
917 FpCondCodes = fpscr & FpCondCodesMask;
918 FpDestP0.uw = result;
919 '''
920 vcvtFpSIntDIop = InstObjParams("vcvt", "VcvtFpSIntD", "FpRegRegOp",
921 { "code": vcvtFpSIntDCode,
962 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntSIop);
963 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntSIop);
964 exec_output += PredOpExecute.subst(vcvtFpSIntSIop);
965
966 vcvtFpSIntDCode = vfpEnabledCheckCode + '''
967 FPSCR fpscr = Fpscr | FpCondCodes;
968 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
969 vfpFlushToZero(fpscr, cOp1);
970 VfpSavedState state = prepFpState(fpscr.rMode);
971 fesetround(FeRoundZero);
972 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
973 int64_t result = vfpFpDToFixed(cOp1, true, false, 0);
974 __asm__ __volatile__("" :: "m" (result));
975 finishVfp(fpscr, state, fpscr.fz);
976 FpCondCodes = fpscr & FpCondCodesMask;
977 FpDestP0.uw = result;
978 '''
979 vcvtFpSIntDIop = InstObjParams("vcvt", "VcvtFpSIntD", "FpRegRegOp",
980 { "code": vcvtFpSIntDCode,
922 "predicate_test": predicateTest }, [])
981 "predicate_test": predicateTest,
982 "op_class": "SimdFloatCvtOp" }, [])
923 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntDIop);
924 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntDIop);
925 exec_output += PredOpExecute.subst(vcvtFpSIntDIop);
926
927 vcvtFpSFpDCode = vfpEnabledCheckCode + '''
928 FPSCR fpscr = Fpscr | FpCondCodes;
929 vfpFlushToZero(fpscr, FpOp1);
930 VfpSavedState state = prepFpState(fpscr.rMode);
931 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
932 double cDest = fixFpSFpDDest(Fpscr, FpOp1);
933 __asm__ __volatile__("" :: "m" (cDest));
934 finishVfp(fpscr, state, fpscr.fz);
935 FpCondCodes = fpscr & FpCondCodesMask;
936 FpDestP0.uw = dblLow(cDest);
937 FpDestP1.uw = dblHi(cDest);
938 '''
939 vcvtFpSFpDIop = InstObjParams("vcvt", "VcvtFpSFpD", "FpRegRegOp",
940 { "code": vcvtFpSFpDCode,
983 header_output += FpRegRegOpDeclare.subst(vcvtFpSIntDIop);
984 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSIntDIop);
985 exec_output += PredOpExecute.subst(vcvtFpSIntDIop);
986
987 vcvtFpSFpDCode = vfpEnabledCheckCode + '''
988 FPSCR fpscr = Fpscr | FpCondCodes;
989 vfpFlushToZero(fpscr, FpOp1);
990 VfpSavedState state = prepFpState(fpscr.rMode);
991 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
992 double cDest = fixFpSFpDDest(Fpscr, FpOp1);
993 __asm__ __volatile__("" :: "m" (cDest));
994 finishVfp(fpscr, state, fpscr.fz);
995 FpCondCodes = fpscr & FpCondCodesMask;
996 FpDestP0.uw = dblLow(cDest);
997 FpDestP1.uw = dblHi(cDest);
998 '''
999 vcvtFpSFpDIop = InstObjParams("vcvt", "VcvtFpSFpD", "FpRegRegOp",
1000 { "code": vcvtFpSFpDCode,
941 "predicate_test": predicateTest }, [])
1001 "predicate_test": predicateTest,
1002 "op_class": "SimdFloatCvtOp" }, [])
942 header_output += FpRegRegOpDeclare.subst(vcvtFpSFpDIop);
943 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSFpDIop);
944 exec_output += PredOpExecute.subst(vcvtFpSFpDIop);
945
946 vcvtFpDFpSCode = vfpEnabledCheckCode + '''
947 FPSCR fpscr = Fpscr | FpCondCodes;
948 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
949 vfpFlushToZero(fpscr, cOp1);
950 VfpSavedState state = prepFpState(fpscr.rMode);
951 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
952 FpDest = fixFpDFpSDest(Fpscr, cOp1);
953 __asm__ __volatile__("" :: "m" (FpDest));
954 finishVfp(fpscr, state, fpscr.fz);
955 FpCondCodes = fpscr & FpCondCodesMask;
956 '''
957 vcvtFpDFpSIop = InstObjParams("vcvt", "VcvtFpDFpS", "FpRegRegOp",
958 { "code": vcvtFpDFpSCode,
1003 header_output += FpRegRegOpDeclare.subst(vcvtFpSFpDIop);
1004 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSFpDIop);
1005 exec_output += PredOpExecute.subst(vcvtFpSFpDIop);
1006
1007 vcvtFpDFpSCode = vfpEnabledCheckCode + '''
1008 FPSCR fpscr = Fpscr | FpCondCodes;
1009 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1010 vfpFlushToZero(fpscr, cOp1);
1011 VfpSavedState state = prepFpState(fpscr.rMode);
1012 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
1013 FpDest = fixFpDFpSDest(Fpscr, cOp1);
1014 __asm__ __volatile__("" :: "m" (FpDest));
1015 finishVfp(fpscr, state, fpscr.fz);
1016 FpCondCodes = fpscr & FpCondCodesMask;
1017 '''
1018 vcvtFpDFpSIop = InstObjParams("vcvt", "VcvtFpDFpS", "FpRegRegOp",
1019 { "code": vcvtFpDFpSCode,
959 "predicate_test": predicateTest }, [])
1020 "predicate_test": predicateTest,
1021 "op_class": "SimdFloatCvtOp" }, [])
960 header_output += FpRegRegOpDeclare.subst(vcvtFpDFpSIop);
961 decoder_output += FpRegRegOpConstructor.subst(vcvtFpDFpSIop);
962 exec_output += PredOpExecute.subst(vcvtFpDFpSIop);
963
964 vcvtFpHTFpSCode = vfpEnabledCheckCode + '''
965 FPSCR fpscr = Fpscr | FpCondCodes;
966 vfpFlushToZero(fpscr, FpOp1);
967 VfpSavedState state = prepFpState(fpscr.rMode);
968 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
969 FpDest = vcvtFpHFpS(fpscr, fpscr.dn, fpscr.ahp,
970 bits(fpToBits(FpOp1), 31, 16));
971 __asm__ __volatile__("" :: "m" (FpDest));
972 finishVfp(fpscr, state, fpscr.fz);
973 FpCondCodes = fpscr & FpCondCodesMask;
974 '''
975 vcvtFpHTFpSIop = InstObjParams("vcvtt", "VcvtFpHTFpS", "FpRegRegOp",
976 { "code": vcvtFpHTFpSCode,
1022 header_output += FpRegRegOpDeclare.subst(vcvtFpDFpSIop);
1023 decoder_output += FpRegRegOpConstructor.subst(vcvtFpDFpSIop);
1024 exec_output += PredOpExecute.subst(vcvtFpDFpSIop);
1025
1026 vcvtFpHTFpSCode = vfpEnabledCheckCode + '''
1027 FPSCR fpscr = Fpscr | FpCondCodes;
1028 vfpFlushToZero(fpscr, FpOp1);
1029 VfpSavedState state = prepFpState(fpscr.rMode);
1030 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1031 FpDest = vcvtFpHFpS(fpscr, fpscr.dn, fpscr.ahp,
1032 bits(fpToBits(FpOp1), 31, 16));
1033 __asm__ __volatile__("" :: "m" (FpDest));
1034 finishVfp(fpscr, state, fpscr.fz);
1035 FpCondCodes = fpscr & FpCondCodesMask;
1036 '''
1037 vcvtFpHTFpSIop = InstObjParams("vcvtt", "VcvtFpHTFpS", "FpRegRegOp",
1038 { "code": vcvtFpHTFpSCode,
977 "predicate_test": predicateTest }, [])
1039 "predicate_test": predicateTest,
1040 "op_class": "SimdFloatCvtOp" }, [])
978 header_output += FpRegRegOpDeclare.subst(vcvtFpHTFpSIop);
979 decoder_output += FpRegRegOpConstructor.subst(vcvtFpHTFpSIop);
980 exec_output += PredOpExecute.subst(vcvtFpHTFpSIop);
981
982 vcvtFpHBFpSCode = vfpEnabledCheckCode + '''
983 FPSCR fpscr = Fpscr | FpCondCodes;
984 VfpSavedState state = prepFpState(fpscr.rMode);
985 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
986 FpDest = vcvtFpHFpS(fpscr, fpscr.dn, fpscr.ahp,
987 bits(fpToBits(FpOp1), 15, 0));
988 __asm__ __volatile__("" :: "m" (FpDest));
989 finishVfp(fpscr, state, fpscr.fz);
990 FpCondCodes = fpscr & FpCondCodesMask;
991 '''
992 vcvtFpHBFpSIop = InstObjParams("vcvtb", "VcvtFpHBFpS", "FpRegRegOp",
993 { "code": vcvtFpHBFpSCode,
1041 header_output += FpRegRegOpDeclare.subst(vcvtFpHTFpSIop);
1042 decoder_output += FpRegRegOpConstructor.subst(vcvtFpHTFpSIop);
1043 exec_output += PredOpExecute.subst(vcvtFpHTFpSIop);
1044
1045 vcvtFpHBFpSCode = vfpEnabledCheckCode + '''
1046 FPSCR fpscr = Fpscr | FpCondCodes;
1047 VfpSavedState state = prepFpState(fpscr.rMode);
1048 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1049 FpDest = vcvtFpHFpS(fpscr, fpscr.dn, fpscr.ahp,
1050 bits(fpToBits(FpOp1), 15, 0));
1051 __asm__ __volatile__("" :: "m" (FpDest));
1052 finishVfp(fpscr, state, fpscr.fz);
1053 FpCondCodes = fpscr & FpCondCodesMask;
1054 '''
1055 vcvtFpHBFpSIop = InstObjParams("vcvtb", "VcvtFpHBFpS", "FpRegRegOp",
1056 { "code": vcvtFpHBFpSCode,
994 "predicate_test": predicateTest }, [])
1057 "predicate_test": predicateTest,
1058 "op_class": "SimdFloatCvtOp" }, [])
995 header_output += FpRegRegOpDeclare.subst(vcvtFpHBFpSIop);
996 decoder_output += FpRegRegOpConstructor.subst(vcvtFpHBFpSIop);
997 exec_output += PredOpExecute.subst(vcvtFpHBFpSIop);
998
999 vcvtFpSFpHTCode = vfpEnabledCheckCode + '''
1000 FPSCR fpscr = Fpscr | FpCondCodes;
1001 vfpFlushToZero(fpscr, FpOp1);
1002 VfpSavedState state = prepFpState(fpscr.rMode);
1003 __asm__ __volatile__("" : "=m" (FpOp1), "=m" (FpDest.uw)
1004 : "m" (FpOp1), "m" (FpDest.uw));
1005 FpDest.uw = insertBits(FpDest.uw, 31, 16,,
1006 vcvtFpSFpH(fpscr, fpscr.fz, fpscr.dn,
1007 fpscr.rMode, fpscr.ahp, FpOp1));
1008 __asm__ __volatile__("" :: "m" (FpDest.uw));
1009 finishVfp(fpscr, state, fpscr.fz);
1010 FpCondCodes = fpscr & FpCondCodesMask;
1011 '''
1012 vcvtFpSFpHTIop = InstObjParams("vcvtt", "VcvtFpSFpHT", "FpRegRegOp",
1013 { "code": vcvtFpHTFpSCode,
1059 header_output += FpRegRegOpDeclare.subst(vcvtFpHBFpSIop);
1060 decoder_output += FpRegRegOpConstructor.subst(vcvtFpHBFpSIop);
1061 exec_output += PredOpExecute.subst(vcvtFpHBFpSIop);
1062
1063 vcvtFpSFpHTCode = vfpEnabledCheckCode + '''
1064 FPSCR fpscr = Fpscr | FpCondCodes;
1065 vfpFlushToZero(fpscr, FpOp1);
1066 VfpSavedState state = prepFpState(fpscr.rMode);
1067 __asm__ __volatile__("" : "=m" (FpOp1), "=m" (FpDest.uw)
1068 : "m" (FpOp1), "m" (FpDest.uw));
1069 FpDest.uw = insertBits(FpDest.uw, 31, 16,,
1070 vcvtFpSFpH(fpscr, fpscr.fz, fpscr.dn,
1071 fpscr.rMode, fpscr.ahp, FpOp1));
1072 __asm__ __volatile__("" :: "m" (FpDest.uw));
1073 finishVfp(fpscr, state, fpscr.fz);
1074 FpCondCodes = fpscr & FpCondCodesMask;
1075 '''
1076 vcvtFpSFpHTIop = InstObjParams("vcvtt", "VcvtFpSFpHT", "FpRegRegOp",
1077 { "code": vcvtFpHTFpSCode,
1014 "predicate_test": predicateTest }, [])
1078 "predicate_test": predicateTest,
1079 "op_class": "SimdFloatCvtOp" }, [])
1015 header_output += FpRegRegOpDeclare.subst(vcvtFpSFpHTIop);
1016 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSFpHTIop);
1017 exec_output += PredOpExecute.subst(vcvtFpSFpHTIop);
1018
1019 vcvtFpSFpHBCode = vfpEnabledCheckCode + '''
1020 FPSCR fpscr = Fpscr | FpCondCodes;
1021 vfpFlushToZero(fpscr, FpOp1);
1022 VfpSavedState state = prepFpState(fpscr.rMode);
1023 __asm__ __volatile__("" : "=m" (FpOp1), "=m" (FpDest.uw)
1024 : "m" (FpOp1), "m" (FpDest.uw));
1025 FpDest.uw = insertBits(FpDest.uw, 15, 0,
1026 vcvtFpSFpH(fpscr, fpscr.fz, fpscr.dn,
1027 fpscr.rMode, fpscr.ahp, FpOp1));
1028 __asm__ __volatile__("" :: "m" (FpDest.uw));
1029 finishVfp(fpscr, state, fpscr.fz);
1030 FpCondCodes = fpscr & FpCondCodesMask;
1031 '''
1032 vcvtFpSFpHBIop = InstObjParams("vcvtb", "VcvtFpSFpHB", "FpRegRegOp",
1033 { "code": vcvtFpSFpHBCode,
1080 header_output += FpRegRegOpDeclare.subst(vcvtFpSFpHTIop);
1081 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSFpHTIop);
1082 exec_output += PredOpExecute.subst(vcvtFpSFpHTIop);
1083
1084 vcvtFpSFpHBCode = vfpEnabledCheckCode + '''
1085 FPSCR fpscr = Fpscr | FpCondCodes;
1086 vfpFlushToZero(fpscr, FpOp1);
1087 VfpSavedState state = prepFpState(fpscr.rMode);
1088 __asm__ __volatile__("" : "=m" (FpOp1), "=m" (FpDest.uw)
1089 : "m" (FpOp1), "m" (FpDest.uw));
1090 FpDest.uw = insertBits(FpDest.uw, 15, 0,
1091 vcvtFpSFpH(fpscr, fpscr.fz, fpscr.dn,
1092 fpscr.rMode, fpscr.ahp, FpOp1));
1093 __asm__ __volatile__("" :: "m" (FpDest.uw));
1094 finishVfp(fpscr, state, fpscr.fz);
1095 FpCondCodes = fpscr & FpCondCodesMask;
1096 '''
1097 vcvtFpSFpHBIop = InstObjParams("vcvtb", "VcvtFpSFpHB", "FpRegRegOp",
1098 { "code": vcvtFpSFpHBCode,
1034 "predicate_test": predicateTest }, [])
1099 "predicate_test": predicateTest,
1100 "op_class": "SimdFloatCvtOp" }, [])
1035 header_output += FpRegRegOpDeclare.subst(vcvtFpSFpHBIop);
1036 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSFpHBIop);
1037 exec_output += PredOpExecute.subst(vcvtFpSFpHBIop);
1038
1039 vcmpSCode = vfpEnabledCheckCode + '''
1040 FPSCR fpscr = Fpscr | FpCondCodes;
1041 vfpFlushToZero(fpscr, FpDest, FpOp1);
1042 if (FpDest == FpOp1) {

--- 11 unchanged lines hidden (view full) ---

1054 if (signal1 || signal2)
1055 fpscr.ioc = 1;
1056 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1057 }
1058 FpCondCodes = fpscr & FpCondCodesMask;
1059 '''
1060 vcmpSIop = InstObjParams("vcmps", "VcmpS", "FpRegRegOp",
1061 { "code": vcmpSCode,
1101 header_output += FpRegRegOpDeclare.subst(vcvtFpSFpHBIop);
1102 decoder_output += FpRegRegOpConstructor.subst(vcvtFpSFpHBIop);
1103 exec_output += PredOpExecute.subst(vcvtFpSFpHBIop);
1104
1105 vcmpSCode = vfpEnabledCheckCode + '''
1106 FPSCR fpscr = Fpscr | FpCondCodes;
1107 vfpFlushToZero(fpscr, FpDest, FpOp1);
1108 if (FpDest == FpOp1) {

--- 11 unchanged lines hidden (view full) ---

1120 if (signal1 || signal2)
1121 fpscr.ioc = 1;
1122 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1123 }
1124 FpCondCodes = fpscr & FpCondCodesMask;
1125 '''
1126 vcmpSIop = InstObjParams("vcmps", "VcmpS", "FpRegRegOp",
1127 { "code": vcmpSCode,
1062 "predicate_test": predicateTest }, [])
1128 "predicate_test": predicateTest,
1129 "op_class": "SimdFloatCmpOp" }, [])
1063 header_output += FpRegRegOpDeclare.subst(vcmpSIop);
1064 decoder_output += FpRegRegOpConstructor.subst(vcmpSIop);
1065 exec_output += PredOpExecute.subst(vcmpSIop);
1066
1067 vcmpDCode = vfpEnabledCheckCode + '''
1068 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1069 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);
1070 FPSCR fpscr = Fpscr | FpCondCodes;

--- 13 unchanged lines hidden (view full) ---

1084 if (signal1 || signal2)
1085 fpscr.ioc = 1;
1086 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1087 }
1088 FpCondCodes = fpscr & FpCondCodesMask;
1089 '''
1090 vcmpDIop = InstObjParams("vcmpd", "VcmpD", "FpRegRegOp",
1091 { "code": vcmpDCode,
1130 header_output += FpRegRegOpDeclare.subst(vcmpSIop);
1131 decoder_output += FpRegRegOpConstructor.subst(vcmpSIop);
1132 exec_output += PredOpExecute.subst(vcmpSIop);
1133
1134 vcmpDCode = vfpEnabledCheckCode + '''
1135 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1136 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);
1137 FPSCR fpscr = Fpscr | FpCondCodes;

--- 13 unchanged lines hidden (view full) ---

1151 if (signal1 || signal2)
1152 fpscr.ioc = 1;
1153 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1154 }
1155 FpCondCodes = fpscr & FpCondCodesMask;
1156 '''
1157 vcmpDIop = InstObjParams("vcmpd", "VcmpD", "FpRegRegOp",
1158 { "code": vcmpDCode,
1092 "predicate_test": predicateTest }, [])
1159 "predicate_test": predicateTest,
1160 "op_class": "SimdFloatCmpOp" }, [])
1093 header_output += FpRegRegOpDeclare.subst(vcmpDIop);
1094 decoder_output += FpRegRegOpConstructor.subst(vcmpDIop);
1095 exec_output += PredOpExecute.subst(vcmpDIop);
1096
1097 vcmpZeroSCode = vfpEnabledCheckCode + '''
1098 FPSCR fpscr = Fpscr | FpCondCodes;
1099 vfpFlushToZero(fpscr, FpDest);
1100 // This only handles imm == 0 for now.

--- 11 unchanged lines hidden (view full) ---

1112 if (signal)
1113 fpscr.ioc = 1;
1114 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1115 }
1116 FpCondCodes = fpscr & FpCondCodesMask;
1117 '''
1118 vcmpZeroSIop = InstObjParams("vcmpZeros", "VcmpZeroS", "FpRegImmOp",
1119 { "code": vcmpZeroSCode,
1161 header_output += FpRegRegOpDeclare.subst(vcmpDIop);
1162 decoder_output += FpRegRegOpConstructor.subst(vcmpDIop);
1163 exec_output += PredOpExecute.subst(vcmpDIop);
1164
1165 vcmpZeroSCode = vfpEnabledCheckCode + '''
1166 FPSCR fpscr = Fpscr | FpCondCodes;
1167 vfpFlushToZero(fpscr, FpDest);
1168 // This only handles imm == 0 for now.

--- 11 unchanged lines hidden (view full) ---

1180 if (signal)
1181 fpscr.ioc = 1;
1182 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1183 }
1184 FpCondCodes = fpscr & FpCondCodesMask;
1185 '''
1186 vcmpZeroSIop = InstObjParams("vcmpZeros", "VcmpZeroS", "FpRegImmOp",
1187 { "code": vcmpZeroSCode,
1120 "predicate_test": predicateTest }, [])
1188 "predicate_test": predicateTest,
1189 "op_class": "SimdFloatCmpOp" }, [])
1121 header_output += FpRegImmOpDeclare.subst(vcmpZeroSIop);
1122 decoder_output += FpRegImmOpConstructor.subst(vcmpZeroSIop);
1123 exec_output += PredOpExecute.subst(vcmpZeroSIop);
1124
1125 vcmpZeroDCode = vfpEnabledCheckCode + '''
1126 // This only handles imm == 0 for now.
1127 assert(imm == 0);
1128 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);

--- 12 unchanged lines hidden (view full) ---

1141 if (signal)
1142 fpscr.ioc = 1;
1143 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1144 }
1145 FpCondCodes = fpscr & FpCondCodesMask;
1146 '''
1147 vcmpZeroDIop = InstObjParams("vcmpZerod", "VcmpZeroD", "FpRegImmOp",
1148 { "code": vcmpZeroDCode,
1190 header_output += FpRegImmOpDeclare.subst(vcmpZeroSIop);
1191 decoder_output += FpRegImmOpConstructor.subst(vcmpZeroSIop);
1192 exec_output += PredOpExecute.subst(vcmpZeroSIop);
1193
1194 vcmpZeroDCode = vfpEnabledCheckCode + '''
1195 // This only handles imm == 0 for now.
1196 assert(imm == 0);
1197 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);

--- 12 unchanged lines hidden (view full) ---

1210 if (signal)
1211 fpscr.ioc = 1;
1212 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1213 }
1214 FpCondCodes = fpscr & FpCondCodesMask;
1215 '''
1216 vcmpZeroDIop = InstObjParams("vcmpZerod", "VcmpZeroD", "FpRegImmOp",
1217 { "code": vcmpZeroDCode,
1149 "predicate_test": predicateTest }, [])
1218 "predicate_test": predicateTest,
1219 "op_class": "SimdFloatCmpOp" }, [])
1150 header_output += FpRegImmOpDeclare.subst(vcmpZeroDIop);
1151 decoder_output += FpRegImmOpConstructor.subst(vcmpZeroDIop);
1152 exec_output += PredOpExecute.subst(vcmpZeroDIop);
1153
1154 vcmpeSCode = vfpEnabledCheckCode + '''
1155 FPSCR fpscr = Fpscr | FpCondCodes;
1156 vfpFlushToZero(fpscr, FpDest, FpOp1);
1157 if (FpDest == FpOp1) {

--- 5 unchanged lines hidden (view full) ---

1163 } else {
1164 fpscr.ioc = 1;
1165 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1166 }
1167 FpCondCodes = fpscr & FpCondCodesMask;
1168 '''
1169 vcmpeSIop = InstObjParams("vcmpes", "VcmpeS", "FpRegRegOp",
1170 { "code": vcmpeSCode,
1220 header_output += FpRegImmOpDeclare.subst(vcmpZeroDIop);
1221 decoder_output += FpRegImmOpConstructor.subst(vcmpZeroDIop);
1222 exec_output += PredOpExecute.subst(vcmpZeroDIop);
1223
1224 vcmpeSCode = vfpEnabledCheckCode + '''
1225 FPSCR fpscr = Fpscr | FpCondCodes;
1226 vfpFlushToZero(fpscr, FpDest, FpOp1);
1227 if (FpDest == FpOp1) {

--- 5 unchanged lines hidden (view full) ---

1233 } else {
1234 fpscr.ioc = 1;
1235 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1236 }
1237 FpCondCodes = fpscr & FpCondCodesMask;
1238 '''
1239 vcmpeSIop = InstObjParams("vcmpes", "VcmpeS", "FpRegRegOp",
1240 { "code": vcmpeSCode,
1171 "predicate_test": predicateTest }, [])
1241 "predicate_test": predicateTest,
1242 "op_class": "SimdFloatCmpOp" }, [])
1172 header_output += FpRegRegOpDeclare.subst(vcmpeSIop);
1173 decoder_output += FpRegRegOpConstructor.subst(vcmpeSIop);
1174 exec_output += PredOpExecute.subst(vcmpeSIop);
1175
1176 vcmpeDCode = vfpEnabledCheckCode + '''
1177 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1178 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);
1179 FPSCR fpscr = Fpscr | FpCondCodes;

--- 7 unchanged lines hidden (view full) ---

1187 } else {
1188 fpscr.ioc = 1;
1189 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1190 }
1191 FpCondCodes = fpscr & FpCondCodesMask;
1192 '''
1193 vcmpeDIop = InstObjParams("vcmped", "VcmpeD", "FpRegRegOp",
1194 { "code": vcmpeDCode,
1243 header_output += FpRegRegOpDeclare.subst(vcmpeSIop);
1244 decoder_output += FpRegRegOpConstructor.subst(vcmpeSIop);
1245 exec_output += PredOpExecute.subst(vcmpeSIop);
1246
1247 vcmpeDCode = vfpEnabledCheckCode + '''
1248 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1249 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);
1250 FPSCR fpscr = Fpscr | FpCondCodes;

--- 7 unchanged lines hidden (view full) ---

1258 } else {
1259 fpscr.ioc = 1;
1260 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1261 }
1262 FpCondCodes = fpscr & FpCondCodesMask;
1263 '''
1264 vcmpeDIop = InstObjParams("vcmped", "VcmpeD", "FpRegRegOp",
1265 { "code": vcmpeDCode,
1195 "predicate_test": predicateTest }, [])
1266 "predicate_test": predicateTest,
1267 "op_class": "SimdFloatCmpOp" }, [])
1196 header_output += FpRegRegOpDeclare.subst(vcmpeDIop);
1197 decoder_output += FpRegRegOpConstructor.subst(vcmpeDIop);
1198 exec_output += PredOpExecute.subst(vcmpeDIop);
1199
1200 vcmpeZeroSCode = vfpEnabledCheckCode + '''
1201 FPSCR fpscr = Fpscr | FpCondCodes;
1202 vfpFlushToZero(fpscr, FpDest);
1203 if (FpDest == imm) {

--- 5 unchanged lines hidden (view full) ---

1209 } else {
1210 fpscr.ioc = 1;
1211 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1212 }
1213 FpCondCodes = fpscr & FpCondCodesMask;
1214 '''
1215 vcmpeZeroSIop = InstObjParams("vcmpeZeros", "VcmpeZeroS", "FpRegImmOp",
1216 { "code": vcmpeZeroSCode,
1268 header_output += FpRegRegOpDeclare.subst(vcmpeDIop);
1269 decoder_output += FpRegRegOpConstructor.subst(vcmpeDIop);
1270 exec_output += PredOpExecute.subst(vcmpeDIop);
1271
1272 vcmpeZeroSCode = vfpEnabledCheckCode + '''
1273 FPSCR fpscr = Fpscr | FpCondCodes;
1274 vfpFlushToZero(fpscr, FpDest);
1275 if (FpDest == imm) {

--- 5 unchanged lines hidden (view full) ---

1281 } else {
1282 fpscr.ioc = 1;
1283 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1284 }
1285 FpCondCodes = fpscr & FpCondCodesMask;
1286 '''
1287 vcmpeZeroSIop = InstObjParams("vcmpeZeros", "VcmpeZeroS", "FpRegImmOp",
1288 { "code": vcmpeZeroSCode,
1217 "predicate_test": predicateTest }, [])
1289 "predicate_test": predicateTest,
1290 "op_class": "SimdFloatCmpOp" }, [])
1218 header_output += FpRegImmOpDeclare.subst(vcmpeZeroSIop);
1219 decoder_output += FpRegImmOpConstructor.subst(vcmpeZeroSIop);
1220 exec_output += PredOpExecute.subst(vcmpeZeroSIop);
1221
1222 vcmpeZeroDCode = vfpEnabledCheckCode + '''
1223 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);
1224 FPSCR fpscr = Fpscr | FpCondCodes;
1225 vfpFlushToZero(fpscr, cDest);

--- 6 unchanged lines hidden (view full) ---

1232 } else {
1233 fpscr.ioc = 1;
1234 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1235 }
1236 FpCondCodes = fpscr & FpCondCodesMask;
1237 '''
1238 vcmpeZeroDIop = InstObjParams("vcmpeZerod", "VcmpeZeroD", "FpRegImmOp",
1239 { "code": vcmpeZeroDCode,
1291 header_output += FpRegImmOpDeclare.subst(vcmpeZeroSIop);
1292 decoder_output += FpRegImmOpConstructor.subst(vcmpeZeroSIop);
1293 exec_output += PredOpExecute.subst(vcmpeZeroSIop);
1294
1295 vcmpeZeroDCode = vfpEnabledCheckCode + '''
1296 double cDest = dbl(FpDestP0.uw, FpDestP1.uw);
1297 FPSCR fpscr = Fpscr | FpCondCodes;
1298 vfpFlushToZero(fpscr, cDest);

--- 6 unchanged lines hidden (view full) ---

1305 } else {
1306 fpscr.ioc = 1;
1307 fpscr.n = 0; fpscr.z = 0; fpscr.c = 1; fpscr.v = 1;
1308 }
1309 FpCondCodes = fpscr & FpCondCodesMask;
1310 '''
1311 vcmpeZeroDIop = InstObjParams("vcmpeZerod", "VcmpeZeroD", "FpRegImmOp",
1312 { "code": vcmpeZeroDCode,
1240 "predicate_test": predicateTest }, [])
1313 "predicate_test": predicateTest,
1314 "op_class": "SimdFloatCmpOp" }, [])
1241 header_output += FpRegImmOpDeclare.subst(vcmpeZeroDIop);
1242 decoder_output += FpRegImmOpConstructor.subst(vcmpeZeroDIop);
1243 exec_output += PredOpExecute.subst(vcmpeZeroDIop);
1244}};
1245
1246let {{
1247
1248 header_output = ""

--- 7 unchanged lines hidden (view full) ---

1256 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1257 FpDest.sw = vfpFpSToFixed(FpOp1, true, false, imm);
1258 __asm__ __volatile__("" :: "m" (FpDest.sw));
1259 finishVfp(fpscr, state, fpscr.fz);
1260 FpCondCodes = fpscr & FpCondCodesMask;
1261 '''
1262 vcvtFpSFixedSIop = InstObjParams("vcvt", "VcvtFpSFixedS", "FpRegRegImmOp",
1263 { "code": vcvtFpSFixedSCode,
1315 header_output += FpRegImmOpDeclare.subst(vcmpeZeroDIop);
1316 decoder_output += FpRegImmOpConstructor.subst(vcmpeZeroDIop);
1317 exec_output += PredOpExecute.subst(vcmpeZeroDIop);
1318}};
1319
1320let {{
1321
1322 header_output = ""

--- 7 unchanged lines hidden (view full) ---

1330 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1331 FpDest.sw = vfpFpSToFixed(FpOp1, true, false, imm);
1332 __asm__ __volatile__("" :: "m" (FpDest.sw));
1333 finishVfp(fpscr, state, fpscr.fz);
1334 FpCondCodes = fpscr & FpCondCodesMask;
1335 '''
1336 vcvtFpSFixedSIop = InstObjParams("vcvt", "VcvtFpSFixedS", "FpRegRegImmOp",
1337 { "code": vcvtFpSFixedSCode,
1264 "predicate_test": predicateTest }, [])
1338 "predicate_test": predicateTest,
1339 "op_class": "SimdFloatCvtOp" }, [])
1265 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSFixedSIop);
1266 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSFixedSIop);
1267 exec_output += PredOpExecute.subst(vcvtFpSFixedSIop);
1268
1269 vcvtFpSFixedDCode = vfpEnabledCheckCode + '''
1270 FPSCR fpscr = Fpscr | FpCondCodes;
1271 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1272 vfpFlushToZero(fpscr, cOp1);
1273 VfpSavedState state = prepFpState(fpscr.rMode);
1274 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
1275 uint64_t mid = vfpFpDToFixed(cOp1, true, false, imm);
1276 __asm__ __volatile__("" :: "m" (mid));
1277 finishVfp(fpscr, state, fpscr.fz);
1278 FpCondCodes = fpscr & FpCondCodesMask;
1279 FpDestP0.uw = mid;
1280 FpDestP1.uw = mid >> 32;
1281 '''
1282 vcvtFpSFixedDIop = InstObjParams("vcvt", "VcvtFpSFixedD", "FpRegRegImmOp",
1283 { "code": vcvtFpSFixedDCode,
1340 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSFixedSIop);
1341 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSFixedSIop);
1342 exec_output += PredOpExecute.subst(vcvtFpSFixedSIop);
1343
1344 vcvtFpSFixedDCode = vfpEnabledCheckCode + '''
1345 FPSCR fpscr = Fpscr | FpCondCodes;
1346 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1347 vfpFlushToZero(fpscr, cOp1);
1348 VfpSavedState state = prepFpState(fpscr.rMode);
1349 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
1350 uint64_t mid = vfpFpDToFixed(cOp1, true, false, imm);
1351 __asm__ __volatile__("" :: "m" (mid));
1352 finishVfp(fpscr, state, fpscr.fz);
1353 FpCondCodes = fpscr & FpCondCodesMask;
1354 FpDestP0.uw = mid;
1355 FpDestP1.uw = mid >> 32;
1356 '''
1357 vcvtFpSFixedDIop = InstObjParams("vcvt", "VcvtFpSFixedD", "FpRegRegImmOp",
1358 { "code": vcvtFpSFixedDCode,
1284 "predicate_test": predicateTest }, [])
1359 "predicate_test": predicateTest,
1360 "op_class": "SimdFloatCvtOp" }, [])
1285 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSFixedDIop);
1286 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSFixedDIop);
1287 exec_output += PredOpExecute.subst(vcvtFpSFixedDIop);
1288
1289 vcvtFpUFixedSCode = vfpEnabledCheckCode + '''
1290 FPSCR fpscr = Fpscr | FpCondCodes;
1291 vfpFlushToZero(fpscr, FpOp1);
1292 VfpSavedState state = prepFpState(fpscr.rMode);
1293 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1294 FpDest.uw = vfpFpSToFixed(FpOp1, false, false, imm);
1295 __asm__ __volatile__("" :: "m" (FpDest.uw));
1296 finishVfp(fpscr, state, fpscr.fz);
1297 FpCondCodes = fpscr & FpCondCodesMask;
1298 '''
1299 vcvtFpUFixedSIop = InstObjParams("vcvt", "VcvtFpUFixedS", "FpRegRegImmOp",
1300 { "code": vcvtFpUFixedSCode,
1361 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSFixedDIop);
1362 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSFixedDIop);
1363 exec_output += PredOpExecute.subst(vcvtFpSFixedDIop);
1364
1365 vcvtFpUFixedSCode = vfpEnabledCheckCode + '''
1366 FPSCR fpscr = Fpscr | FpCondCodes;
1367 vfpFlushToZero(fpscr, FpOp1);
1368 VfpSavedState state = prepFpState(fpscr.rMode);
1369 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1370 FpDest.uw = vfpFpSToFixed(FpOp1, false, false, imm);
1371 __asm__ __volatile__("" :: "m" (FpDest.uw));
1372 finishVfp(fpscr, state, fpscr.fz);
1373 FpCondCodes = fpscr & FpCondCodesMask;
1374 '''
1375 vcvtFpUFixedSIop = InstObjParams("vcvt", "VcvtFpUFixedS", "FpRegRegImmOp",
1376 { "code": vcvtFpUFixedSCode,
1301 "predicate_test": predicateTest }, [])
1377 "predicate_test": predicateTest,
1378 "op_class": "SimdFloatCvtOp" }, [])
1302 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUFixedSIop);
1303 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUFixedSIop);
1304 exec_output += PredOpExecute.subst(vcvtFpUFixedSIop);
1305
1306 vcvtFpUFixedDCode = vfpEnabledCheckCode + '''
1307 FPSCR fpscr = Fpscr | FpCondCodes;
1308 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1309 vfpFlushToZero(fpscr, cOp1);
1310 VfpSavedState state = prepFpState(fpscr.rMode);
1311 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
1312 uint64_t mid = vfpFpDToFixed(cOp1, false, false, imm);
1313 __asm__ __volatile__("" :: "m" (mid));
1314 finishVfp(fpscr, state, fpscr.fz);
1315 FpCondCodes = fpscr & FpCondCodesMask;
1316 FpDestP0.uw = mid;
1317 FpDestP1.uw = mid >> 32;
1318 '''
1319 vcvtFpUFixedDIop = InstObjParams("vcvt", "VcvtFpUFixedD", "FpRegRegImmOp",
1320 { "code": vcvtFpUFixedDCode,
1379 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUFixedSIop);
1380 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUFixedSIop);
1381 exec_output += PredOpExecute.subst(vcvtFpUFixedSIop);
1382
1383 vcvtFpUFixedDCode = vfpEnabledCheckCode + '''
1384 FPSCR fpscr = Fpscr | FpCondCodes;
1385 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1386 vfpFlushToZero(fpscr, cOp1);
1387 VfpSavedState state = prepFpState(fpscr.rMode);
1388 __asm__ __volatile__("" : "=m" (cOp1) : "m" (cOp1));
1389 uint64_t mid = vfpFpDToFixed(cOp1, false, false, imm);
1390 __asm__ __volatile__("" :: "m" (mid));
1391 finishVfp(fpscr, state, fpscr.fz);
1392 FpCondCodes = fpscr & FpCondCodesMask;
1393 FpDestP0.uw = mid;
1394 FpDestP1.uw = mid >> 32;
1395 '''
1396 vcvtFpUFixedDIop = InstObjParams("vcvt", "VcvtFpUFixedD", "FpRegRegImmOp",
1397 { "code": vcvtFpUFixedDCode,
1321 "predicate_test": predicateTest }, [])
1398 "predicate_test": predicateTest,
1399 "op_class": "SimdFloatCvtOp" }, [])
1322 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUFixedDIop);
1323 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUFixedDIop);
1324 exec_output += PredOpExecute.subst(vcvtFpUFixedDIop);
1325
1326 vcvtSFixedFpSCode = vfpEnabledCheckCode + '''
1327 FPSCR fpscr = Fpscr | FpCondCodes;
1328 VfpSavedState state = prepFpState(fpscr.rMode);
1329 __asm__ __volatile__("" : "=m" (FpOp1.sw) : "m" (FpOp1.sw));
1330 FpDest = vfpSFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.sw, false, imm);
1331 __asm__ __volatile__("" :: "m" (FpDest));
1332 finishVfp(fpscr, state, fpscr.fz);
1333 FpCondCodes = fpscr & FpCondCodesMask;
1334 '''
1335 vcvtSFixedFpSIop = InstObjParams("vcvt", "VcvtSFixedFpS", "FpRegRegImmOp",
1336 { "code": vcvtSFixedFpSCode,
1400 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUFixedDIop);
1401 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUFixedDIop);
1402 exec_output += PredOpExecute.subst(vcvtFpUFixedDIop);
1403
1404 vcvtSFixedFpSCode = vfpEnabledCheckCode + '''
1405 FPSCR fpscr = Fpscr | FpCondCodes;
1406 VfpSavedState state = prepFpState(fpscr.rMode);
1407 __asm__ __volatile__("" : "=m" (FpOp1.sw) : "m" (FpOp1.sw));
1408 FpDest = vfpSFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.sw, false, imm);
1409 __asm__ __volatile__("" :: "m" (FpDest));
1410 finishVfp(fpscr, state, fpscr.fz);
1411 FpCondCodes = fpscr & FpCondCodesMask;
1412 '''
1413 vcvtSFixedFpSIop = InstObjParams("vcvt", "VcvtSFixedFpS", "FpRegRegImmOp",
1414 { "code": vcvtSFixedFpSCode,
1337 "predicate_test": predicateTest }, [])
1415 "predicate_test": predicateTest,
1416 "op_class": "SimdFloatCvtOp" }, [])
1338 header_output += FpRegRegImmOpDeclare.subst(vcvtSFixedFpSIop);
1339 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSFixedFpSIop);
1340 exec_output += PredOpExecute.subst(vcvtSFixedFpSIop);
1341
1342 vcvtSFixedFpDCode = vfpEnabledCheckCode + '''
1343 FPSCR fpscr = Fpscr | FpCondCodes;
1344 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1345 VfpSavedState state = prepFpState(fpscr.rMode);
1346 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1347 double cDest = vfpSFixedToFpD(fpscr.fz, fpscr.dn, mid, false, imm);
1348 __asm__ __volatile__("" :: "m" (cDest));
1349 finishVfp(fpscr, state, fpscr.fz);
1350 FpCondCodes = fpscr & FpCondCodesMask;
1351 FpDestP0.uw = dblLow(cDest);
1352 FpDestP1.uw = dblHi(cDest);
1353 '''
1354 vcvtSFixedFpDIop = InstObjParams("vcvt", "VcvtSFixedFpD", "FpRegRegImmOp",
1355 { "code": vcvtSFixedFpDCode,
1417 header_output += FpRegRegImmOpDeclare.subst(vcvtSFixedFpSIop);
1418 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSFixedFpSIop);
1419 exec_output += PredOpExecute.subst(vcvtSFixedFpSIop);
1420
1421 vcvtSFixedFpDCode = vfpEnabledCheckCode + '''
1422 FPSCR fpscr = Fpscr | FpCondCodes;
1423 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1424 VfpSavedState state = prepFpState(fpscr.rMode);
1425 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1426 double cDest = vfpSFixedToFpD(fpscr.fz, fpscr.dn, mid, false, imm);
1427 __asm__ __volatile__("" :: "m" (cDest));
1428 finishVfp(fpscr, state, fpscr.fz);
1429 FpCondCodes = fpscr & FpCondCodesMask;
1430 FpDestP0.uw = dblLow(cDest);
1431 FpDestP1.uw = dblHi(cDest);
1432 '''
1433 vcvtSFixedFpDIop = InstObjParams("vcvt", "VcvtSFixedFpD", "FpRegRegImmOp",
1434 { "code": vcvtSFixedFpDCode,
1356 "predicate_test": predicateTest }, [])
1435 "predicate_test": predicateTest,
1436 "op_class": "SimdFloatCvtOp" }, [])
1357 header_output += FpRegRegImmOpDeclare.subst(vcvtSFixedFpDIop);
1358 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSFixedFpDIop);
1359 exec_output += PredOpExecute.subst(vcvtSFixedFpDIop);
1360
1361 vcvtUFixedFpSCode = vfpEnabledCheckCode + '''
1362 FPSCR fpscr = Fpscr | FpCondCodes;
1363 VfpSavedState state = prepFpState(fpscr.rMode);
1364 __asm__ __volatile__("" : "=m" (FpOp1.uw) : "m" (FpOp1.uw));
1365 FpDest = vfpUFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.uw, false, imm);
1366 __asm__ __volatile__("" :: "m" (FpDest));
1367 finishVfp(fpscr, state, fpscr.fz);
1368 FpCondCodes = fpscr & FpCondCodesMask;
1369 '''
1370 vcvtUFixedFpSIop = InstObjParams("vcvt", "VcvtUFixedFpS", "FpRegRegImmOp",
1371 { "code": vcvtUFixedFpSCode,
1437 header_output += FpRegRegImmOpDeclare.subst(vcvtSFixedFpDIop);
1438 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSFixedFpDIop);
1439 exec_output += PredOpExecute.subst(vcvtSFixedFpDIop);
1440
1441 vcvtUFixedFpSCode = vfpEnabledCheckCode + '''
1442 FPSCR fpscr = Fpscr | FpCondCodes;
1443 VfpSavedState state = prepFpState(fpscr.rMode);
1444 __asm__ __volatile__("" : "=m" (FpOp1.uw) : "m" (FpOp1.uw));
1445 FpDest = vfpUFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.uw, false, imm);
1446 __asm__ __volatile__("" :: "m" (FpDest));
1447 finishVfp(fpscr, state, fpscr.fz);
1448 FpCondCodes = fpscr & FpCondCodesMask;
1449 '''
1450 vcvtUFixedFpSIop = InstObjParams("vcvt", "VcvtUFixedFpS", "FpRegRegImmOp",
1451 { "code": vcvtUFixedFpSCode,
1372 "predicate_test": predicateTest }, [])
1452 "predicate_test": predicateTest,
1453 "op_class": "SimdFloatCvtOp" }, [])
1373 header_output += FpRegRegImmOpDeclare.subst(vcvtUFixedFpSIop);
1374 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUFixedFpSIop);
1375 exec_output += PredOpExecute.subst(vcvtUFixedFpSIop);
1376
1377 vcvtUFixedFpDCode = vfpEnabledCheckCode + '''
1378 FPSCR fpscr = Fpscr | FpCondCodes;
1379 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1380 VfpSavedState state = prepFpState(fpscr.rMode);
1381 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1382 double cDest = vfpUFixedToFpD(fpscr.fz, fpscr.dn, mid, false, imm);
1383 __asm__ __volatile__("" :: "m" (cDest));
1384 finishVfp(fpscr, state, fpscr.fz);
1385 FpCondCodes = fpscr & FpCondCodesMask;
1386 FpDestP0.uw = dblLow(cDest);
1387 FpDestP1.uw = dblHi(cDest);
1388 '''
1389 vcvtUFixedFpDIop = InstObjParams("vcvt", "VcvtUFixedFpD", "FpRegRegImmOp",
1390 { "code": vcvtUFixedFpDCode,
1454 header_output += FpRegRegImmOpDeclare.subst(vcvtUFixedFpSIop);
1455 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUFixedFpSIop);
1456 exec_output += PredOpExecute.subst(vcvtUFixedFpSIop);
1457
1458 vcvtUFixedFpDCode = vfpEnabledCheckCode + '''
1459 FPSCR fpscr = Fpscr | FpCondCodes;
1460 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1461 VfpSavedState state = prepFpState(fpscr.rMode);
1462 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1463 double cDest = vfpUFixedToFpD(fpscr.fz, fpscr.dn, mid, false, imm);
1464 __asm__ __volatile__("" :: "m" (cDest));
1465 finishVfp(fpscr, state, fpscr.fz);
1466 FpCondCodes = fpscr & FpCondCodesMask;
1467 FpDestP0.uw = dblLow(cDest);
1468 FpDestP1.uw = dblHi(cDest);
1469 '''
1470 vcvtUFixedFpDIop = InstObjParams("vcvt", "VcvtUFixedFpD", "FpRegRegImmOp",
1471 { "code": vcvtUFixedFpDCode,
1391 "predicate_test": predicateTest }, [])
1472 "predicate_test": predicateTest,
1473 "op_class": "SimdFloatCvtOp" }, [])
1392 header_output += FpRegRegImmOpDeclare.subst(vcvtUFixedFpDIop);
1393 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUFixedFpDIop);
1394 exec_output += PredOpExecute.subst(vcvtUFixedFpDIop);
1395
1396 vcvtFpSHFixedSCode = vfpEnabledCheckCode + '''
1397 FPSCR fpscr = Fpscr | FpCondCodes;
1398 vfpFlushToZero(fpscr, FpOp1);
1399 VfpSavedState state = prepFpState(fpscr.rMode);
1400 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1401 FpDest.sh = vfpFpSToFixed(FpOp1, true, true, imm);
1402 __asm__ __volatile__("" :: "m" (FpDest.sh));
1403 finishVfp(fpscr, state, fpscr.fz);
1404 FpCondCodes = fpscr & FpCondCodesMask;
1405 '''
1406 vcvtFpSHFixedSIop = InstObjParams("vcvt", "VcvtFpSHFixedS",
1407 "FpRegRegImmOp",
1408 { "code": vcvtFpSHFixedSCode,
1474 header_output += FpRegRegImmOpDeclare.subst(vcvtUFixedFpDIop);
1475 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUFixedFpDIop);
1476 exec_output += PredOpExecute.subst(vcvtUFixedFpDIop);
1477
1478 vcvtFpSHFixedSCode = vfpEnabledCheckCode + '''
1479 FPSCR fpscr = Fpscr | FpCondCodes;
1480 vfpFlushToZero(fpscr, FpOp1);
1481 VfpSavedState state = prepFpState(fpscr.rMode);
1482 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1483 FpDest.sh = vfpFpSToFixed(FpOp1, true, true, imm);
1484 __asm__ __volatile__("" :: "m" (FpDest.sh));
1485 finishVfp(fpscr, state, fpscr.fz);
1486 FpCondCodes = fpscr & FpCondCodesMask;
1487 '''
1488 vcvtFpSHFixedSIop = InstObjParams("vcvt", "VcvtFpSHFixedS",
1489 "FpRegRegImmOp",
1490 { "code": vcvtFpSHFixedSCode,
1409 "predicate_test": predicateTest }, [])
1491 "predicate_test": predicateTest,
1492 "op_class": "SimdFloatCvtOp" }, [])
1410 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSHFixedSIop);
1411 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSHFixedSIop);
1412 exec_output += PredOpExecute.subst(vcvtFpSHFixedSIop);
1413
1414 vcvtFpSHFixedDCode = vfpEnabledCheckCode + '''
1415 FPSCR fpscr = Fpscr | FpCondCodes;
1416 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1417 vfpFlushToZero(fpscr, cOp1);

--- 4 unchanged lines hidden (view full) ---

1422 finishVfp(fpscr, state, fpscr.fz);
1423 FpCondCodes = fpscr & FpCondCodesMask;
1424 FpDestP0.uw = result;
1425 FpDestP1.uw = result >> 32;
1426 '''
1427 vcvtFpSHFixedDIop = InstObjParams("vcvt", "VcvtFpSHFixedD",
1428 "FpRegRegImmOp",
1429 { "code": vcvtFpSHFixedDCode,
1493 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSHFixedSIop);
1494 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSHFixedSIop);
1495 exec_output += PredOpExecute.subst(vcvtFpSHFixedSIop);
1496
1497 vcvtFpSHFixedDCode = vfpEnabledCheckCode + '''
1498 FPSCR fpscr = Fpscr | FpCondCodes;
1499 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1500 vfpFlushToZero(fpscr, cOp1);

--- 4 unchanged lines hidden (view full) ---

1505 finishVfp(fpscr, state, fpscr.fz);
1506 FpCondCodes = fpscr & FpCondCodesMask;
1507 FpDestP0.uw = result;
1508 FpDestP1.uw = result >> 32;
1509 '''
1510 vcvtFpSHFixedDIop = InstObjParams("vcvt", "VcvtFpSHFixedD",
1511 "FpRegRegImmOp",
1512 { "code": vcvtFpSHFixedDCode,
1430 "predicate_test": predicateTest }, [])
1513 "predicate_test": predicateTest,
1514 "op_class": "SimdFloatCvtOp" }, [])
1431 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSHFixedDIop);
1432 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSHFixedDIop);
1433 exec_output += PredOpExecute.subst(vcvtFpSHFixedDIop);
1434
1435 vcvtFpUHFixedSCode = vfpEnabledCheckCode + '''
1436 FPSCR fpscr = Fpscr | FpCondCodes;
1437 vfpFlushToZero(fpscr, FpOp1);
1438 VfpSavedState state = prepFpState(fpscr.rMode);
1439 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1440 FpDest.uh = vfpFpSToFixed(FpOp1, false, true, imm);
1441 __asm__ __volatile__("" :: "m" (FpDest.uh));
1442 finishVfp(fpscr, state, fpscr.fz);
1443 FpCondCodes = fpscr & FpCondCodesMask;
1444 '''
1445 vcvtFpUHFixedSIop = InstObjParams("vcvt", "VcvtFpUHFixedS",
1446 "FpRegRegImmOp",
1447 { "code": vcvtFpUHFixedSCode,
1515 header_output += FpRegRegImmOpDeclare.subst(vcvtFpSHFixedDIop);
1516 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpSHFixedDIop);
1517 exec_output += PredOpExecute.subst(vcvtFpSHFixedDIop);
1518
1519 vcvtFpUHFixedSCode = vfpEnabledCheckCode + '''
1520 FPSCR fpscr = Fpscr | FpCondCodes;
1521 vfpFlushToZero(fpscr, FpOp1);
1522 VfpSavedState state = prepFpState(fpscr.rMode);
1523 __asm__ __volatile__("" : "=m" (FpOp1) : "m" (FpOp1));
1524 FpDest.uh = vfpFpSToFixed(FpOp1, false, true, imm);
1525 __asm__ __volatile__("" :: "m" (FpDest.uh));
1526 finishVfp(fpscr, state, fpscr.fz);
1527 FpCondCodes = fpscr & FpCondCodesMask;
1528 '''
1529 vcvtFpUHFixedSIop = InstObjParams("vcvt", "VcvtFpUHFixedS",
1530 "FpRegRegImmOp",
1531 { "code": vcvtFpUHFixedSCode,
1448 "predicate_test": predicateTest }, [])
1532 "predicate_test": predicateTest,
1533 "op_class": "SimdFloatCvtOp" }, [])
1449 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUHFixedSIop);
1450 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUHFixedSIop);
1451 exec_output += PredOpExecute.subst(vcvtFpUHFixedSIop);
1452
1453 vcvtFpUHFixedDCode = vfpEnabledCheckCode + '''
1454 FPSCR fpscr = Fpscr | FpCondCodes;
1455 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1456 vfpFlushToZero(fpscr, cOp1);

--- 4 unchanged lines hidden (view full) ---

1461 finishVfp(fpscr, state, fpscr.fz);
1462 FpCondCodes = fpscr & FpCondCodesMask;
1463 FpDestP0.uw = mid;
1464 FpDestP1.uw = mid >> 32;
1465 '''
1466 vcvtFpUHFixedDIop = InstObjParams("vcvt", "VcvtFpUHFixedD",
1467 "FpRegRegImmOp",
1468 { "code": vcvtFpUHFixedDCode,
1534 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUHFixedSIop);
1535 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUHFixedSIop);
1536 exec_output += PredOpExecute.subst(vcvtFpUHFixedSIop);
1537
1538 vcvtFpUHFixedDCode = vfpEnabledCheckCode + '''
1539 FPSCR fpscr = Fpscr | FpCondCodes;
1540 double cOp1 = dbl(FpOp1P0.uw, FpOp1P1.uw);
1541 vfpFlushToZero(fpscr, cOp1);

--- 4 unchanged lines hidden (view full) ---

1546 finishVfp(fpscr, state, fpscr.fz);
1547 FpCondCodes = fpscr & FpCondCodesMask;
1548 FpDestP0.uw = mid;
1549 FpDestP1.uw = mid >> 32;
1550 '''
1551 vcvtFpUHFixedDIop = InstObjParams("vcvt", "VcvtFpUHFixedD",
1552 "FpRegRegImmOp",
1553 { "code": vcvtFpUHFixedDCode,
1469 "predicate_test": predicateTest }, [])
1554 "predicate_test": predicateTest,
1555 "op_class": "SimdFloatCvtOp" }, [])
1470 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUHFixedDIop);
1471 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUHFixedDIop);
1472 exec_output += PredOpExecute.subst(vcvtFpUHFixedDIop);
1473
1474 vcvtSHFixedFpSCode = vfpEnabledCheckCode + '''
1475 FPSCR fpscr = Fpscr | FpCondCodes;
1476 VfpSavedState state = prepFpState(fpscr.rMode);
1477 __asm__ __volatile__("" : "=m" (FpOp1.sh) : "m" (FpOp1.sh));
1478 FpDest = vfpSFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.sh, true, imm);
1479 __asm__ __volatile__("" :: "m" (FpDest));
1480 finishVfp(fpscr, state, fpscr.fz);
1481 FpCondCodes = fpscr & FpCondCodesMask;
1482 '''
1483 vcvtSHFixedFpSIop = InstObjParams("vcvt", "VcvtSHFixedFpS",
1484 "FpRegRegImmOp",
1485 { "code": vcvtSHFixedFpSCode,
1556 header_output += FpRegRegImmOpDeclare.subst(vcvtFpUHFixedDIop);
1557 decoder_output += FpRegRegImmOpConstructor.subst(vcvtFpUHFixedDIop);
1558 exec_output += PredOpExecute.subst(vcvtFpUHFixedDIop);
1559
1560 vcvtSHFixedFpSCode = vfpEnabledCheckCode + '''
1561 FPSCR fpscr = Fpscr | FpCondCodes;
1562 VfpSavedState state = prepFpState(fpscr.rMode);
1563 __asm__ __volatile__("" : "=m" (FpOp1.sh) : "m" (FpOp1.sh));
1564 FpDest = vfpSFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.sh, true, imm);
1565 __asm__ __volatile__("" :: "m" (FpDest));
1566 finishVfp(fpscr, state, fpscr.fz);
1567 FpCondCodes = fpscr & FpCondCodesMask;
1568 '''
1569 vcvtSHFixedFpSIop = InstObjParams("vcvt", "VcvtSHFixedFpS",
1570 "FpRegRegImmOp",
1571 { "code": vcvtSHFixedFpSCode,
1486 "predicate_test": predicateTest }, [])
1572 "predicate_test": predicateTest,
1573 "op_class": "SimdFloatCvtOp" }, [])
1487 header_output += FpRegRegImmOpDeclare.subst(vcvtSHFixedFpSIop);
1488 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSHFixedFpSIop);
1489 exec_output += PredOpExecute.subst(vcvtSHFixedFpSIop);
1490
1491 vcvtSHFixedFpDCode = vfpEnabledCheckCode + '''
1492 FPSCR fpscr = Fpscr | FpCondCodes;
1493 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1494 VfpSavedState state = prepFpState(fpscr.rMode);
1495 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1496 double cDest = vfpSFixedToFpD(fpscr.fz, fpscr.dn, mid, true, imm);
1497 __asm__ __volatile__("" :: "m" (cDest));
1498 finishVfp(fpscr, state, fpscr.fz);
1499 FpCondCodes = fpscr & FpCondCodesMask;
1500 FpDestP0.uw = dblLow(cDest);
1501 FpDestP1.uw = dblHi(cDest);
1502 '''
1503 vcvtSHFixedFpDIop = InstObjParams("vcvt", "VcvtSHFixedFpD",
1504 "FpRegRegImmOp",
1505 { "code": vcvtSHFixedFpDCode,
1574 header_output += FpRegRegImmOpDeclare.subst(vcvtSHFixedFpSIop);
1575 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSHFixedFpSIop);
1576 exec_output += PredOpExecute.subst(vcvtSHFixedFpSIop);
1577
1578 vcvtSHFixedFpDCode = vfpEnabledCheckCode + '''
1579 FPSCR fpscr = Fpscr | FpCondCodes;
1580 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1581 VfpSavedState state = prepFpState(fpscr.rMode);
1582 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1583 double cDest = vfpSFixedToFpD(fpscr.fz, fpscr.dn, mid, true, imm);
1584 __asm__ __volatile__("" :: "m" (cDest));
1585 finishVfp(fpscr, state, fpscr.fz);
1586 FpCondCodes = fpscr & FpCondCodesMask;
1587 FpDestP0.uw = dblLow(cDest);
1588 FpDestP1.uw = dblHi(cDest);
1589 '''
1590 vcvtSHFixedFpDIop = InstObjParams("vcvt", "VcvtSHFixedFpD",
1591 "FpRegRegImmOp",
1592 { "code": vcvtSHFixedFpDCode,
1506 "predicate_test": predicateTest }, [])
1593 "predicate_test": predicateTest,
1594 "op_class": "SimdFloatCvtOp" }, [])
1507 header_output += FpRegRegImmOpDeclare.subst(vcvtSHFixedFpDIop);
1508 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSHFixedFpDIop);
1509 exec_output += PredOpExecute.subst(vcvtSHFixedFpDIop);
1510
1511 vcvtUHFixedFpSCode = vfpEnabledCheckCode + '''
1512 FPSCR fpscr = Fpscr | FpCondCodes;
1513 VfpSavedState state = prepFpState(fpscr.rMode);
1514 __asm__ __volatile__("" : "=m" (FpOp1.uh) : "m" (FpOp1.uh));
1515 FpDest = vfpUFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.uh, true, imm);
1516 __asm__ __volatile__("" :: "m" (FpDest));
1517 finishVfp(fpscr, state, fpscr.fz);
1518 FpCondCodes = fpscr & FpCondCodesMask;
1519 '''
1520 vcvtUHFixedFpSIop = InstObjParams("vcvt", "VcvtUHFixedFpS",
1521 "FpRegRegImmOp",
1522 { "code": vcvtUHFixedFpSCode,
1595 header_output += FpRegRegImmOpDeclare.subst(vcvtSHFixedFpDIop);
1596 decoder_output += FpRegRegImmOpConstructor.subst(vcvtSHFixedFpDIop);
1597 exec_output += PredOpExecute.subst(vcvtSHFixedFpDIop);
1598
1599 vcvtUHFixedFpSCode = vfpEnabledCheckCode + '''
1600 FPSCR fpscr = Fpscr | FpCondCodes;
1601 VfpSavedState state = prepFpState(fpscr.rMode);
1602 __asm__ __volatile__("" : "=m" (FpOp1.uh) : "m" (FpOp1.uh));
1603 FpDest = vfpUFixedToFpS(fpscr.fz, fpscr.dn, FpOp1.uh, true, imm);
1604 __asm__ __volatile__("" :: "m" (FpDest));
1605 finishVfp(fpscr, state, fpscr.fz);
1606 FpCondCodes = fpscr & FpCondCodesMask;
1607 '''
1608 vcvtUHFixedFpSIop = InstObjParams("vcvt", "VcvtUHFixedFpS",
1609 "FpRegRegImmOp",
1610 { "code": vcvtUHFixedFpSCode,
1523 "predicate_test": predicateTest }, [])
1611 "predicate_test": predicateTest,
1612 "op_class": "SimdFloatCvtOp" }, [])
1524 header_output += FpRegRegImmOpDeclare.subst(vcvtUHFixedFpSIop);
1525 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUHFixedFpSIop);
1526 exec_output += PredOpExecute.subst(vcvtUHFixedFpSIop);
1527
1528 vcvtUHFixedFpDCode = vfpEnabledCheckCode + '''
1529 FPSCR fpscr = Fpscr | FpCondCodes;
1530 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1531 VfpSavedState state = prepFpState(fpscr.rMode);
1532 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1533 double cDest = vfpUFixedToFpD(fpscr.fz, fpscr.dn, mid, true, imm);
1534 __asm__ __volatile__("" :: "m" (cDest));
1535 finishVfp(fpscr, state, fpscr.fz);
1536 FpCondCodes = fpscr & FpCondCodesMask;
1537 FpDestP0.uw = dblLow(cDest);
1538 FpDestP1.uw = dblHi(cDest);
1539 '''
1540 vcvtUHFixedFpDIop = InstObjParams("vcvt", "VcvtUHFixedFpD",
1541 "FpRegRegImmOp",
1542 { "code": vcvtUHFixedFpDCode,
1613 header_output += FpRegRegImmOpDeclare.subst(vcvtUHFixedFpSIop);
1614 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUHFixedFpSIop);
1615 exec_output += PredOpExecute.subst(vcvtUHFixedFpSIop);
1616
1617 vcvtUHFixedFpDCode = vfpEnabledCheckCode + '''
1618 FPSCR fpscr = Fpscr | FpCondCodes;
1619 uint64_t mid = ((uint64_t)FpOp1P0.uw | ((uint64_t)FpOp1P1.uw << 32));
1620 VfpSavedState state = prepFpState(fpscr.rMode);
1621 __asm__ __volatile__("" : "=m" (mid) : "m" (mid));
1622 double cDest = vfpUFixedToFpD(fpscr.fz, fpscr.dn, mid, true, imm);
1623 __asm__ __volatile__("" :: "m" (cDest));
1624 finishVfp(fpscr, state, fpscr.fz);
1625 FpCondCodes = fpscr & FpCondCodesMask;
1626 FpDestP0.uw = dblLow(cDest);
1627 FpDestP1.uw = dblHi(cDest);
1628 '''
1629 vcvtUHFixedFpDIop = InstObjParams("vcvt", "VcvtUHFixedFpD",
1630 "FpRegRegImmOp",
1631 { "code": vcvtUHFixedFpDCode,
1543 "predicate_test": predicateTest }, [])
1632 "predicate_test": predicateTest,
1633 "op_class": "SimdFloatCvtOp" }, [])
1544 header_output += FpRegRegImmOpDeclare.subst(vcvtUHFixedFpDIop);
1545 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUHFixedFpDIop);
1546 exec_output += PredOpExecute.subst(vcvtUHFixedFpDIop);
1547}};
1634 header_output += FpRegRegImmOpDeclare.subst(vcvtUHFixedFpDIop);
1635 decoder_output += FpRegRegImmOpConstructor.subst(vcvtUHFixedFpDIop);
1636 exec_output += PredOpExecute.subst(vcvtUHFixedFpDIop);
1637}};