Revision 02da0b2d
| b/target-arm/helper.h | ||
|---|---|---|
| 154 | 154 |
DEF_HELPER_2(ror_cc, i32, i32, i32) |
| 155 | 155 |
|
| 156 | 156 |
/* neon_helper.c */ |
| 157 |
DEF_HELPER_2(neon_qadd_u8, i32, i32, i32)
|
|
| 158 |
DEF_HELPER_2(neon_qadd_s8, i32, i32, i32)
|
|
| 159 |
DEF_HELPER_2(neon_qadd_u16, i32, i32, i32)
|
|
| 160 |
DEF_HELPER_2(neon_qadd_s16, i32, i32, i32)
|
|
| 161 |
DEF_HELPER_2(neon_qadd_u32, i32, i32, i32)
|
|
| 162 |
DEF_HELPER_2(neon_qadd_s32, i32, i32, i32)
|
|
| 163 |
DEF_HELPER_2(neon_qsub_u8, i32, i32, i32)
|
|
| 164 |
DEF_HELPER_2(neon_qsub_s8, i32, i32, i32)
|
|
| 165 |
DEF_HELPER_2(neon_qsub_u16, i32, i32, i32)
|
|
| 166 |
DEF_HELPER_2(neon_qsub_s16, i32, i32, i32)
|
|
| 167 |
DEF_HELPER_2(neon_qsub_u32, i32, i32, i32)
|
|
| 168 |
DEF_HELPER_2(neon_qsub_s32, i32, i32, i32)
|
|
| 169 |
DEF_HELPER_2(neon_qadd_u64, i64, i64, i64)
|
|
| 170 |
DEF_HELPER_2(neon_qadd_s64, i64, i64, i64)
|
|
| 171 |
DEF_HELPER_2(neon_qsub_u64, i64, i64, i64)
|
|
| 172 |
DEF_HELPER_2(neon_qsub_s64, i64, i64, i64)
|
|
| 157 |
DEF_HELPER_3(neon_qadd_u8, i32, env, i32, i32)
|
|
| 158 |
DEF_HELPER_3(neon_qadd_s8, i32, env, i32, i32)
|
|
| 159 |
DEF_HELPER_3(neon_qadd_u16, i32, env, i32, i32)
|
|
| 160 |
DEF_HELPER_3(neon_qadd_s16, i32, env, i32, i32)
|
|
| 161 |
DEF_HELPER_3(neon_qadd_u32, i32, env, i32, i32)
|
|
| 162 |
DEF_HELPER_3(neon_qadd_s32, i32, env, i32, i32)
|
|
| 163 |
DEF_HELPER_3(neon_qsub_u8, i32, env, i32, i32)
|
|
| 164 |
DEF_HELPER_3(neon_qsub_s8, i32, env, i32, i32)
|
|
| 165 |
DEF_HELPER_3(neon_qsub_u16, i32, env, i32, i32)
|
|
| 166 |
DEF_HELPER_3(neon_qsub_s16, i32, env, i32, i32)
|
|
| 167 |
DEF_HELPER_3(neon_qsub_u32, i32, env, i32, i32)
|
|
| 168 |
DEF_HELPER_3(neon_qsub_s32, i32, env, i32, i32)
|
|
| 169 |
DEF_HELPER_3(neon_qadd_u64, i64, env, i64, i64)
|
|
| 170 |
DEF_HELPER_3(neon_qadd_s64, i64, env, i64, i64)
|
|
| 171 |
DEF_HELPER_3(neon_qsub_u64, i64, env, i64, i64)
|
|
| 172 |
DEF_HELPER_3(neon_qsub_s64, i64, env, i64, i64)
|
|
| 173 | 173 |
|
| 174 | 174 |
DEF_HELPER_2(neon_hadd_s8, i32, i32, i32) |
| 175 | 175 |
DEF_HELPER_2(neon_hadd_u8, i32, i32, i32) |
| ... | ... | |
| 247 | 247 |
DEF_HELPER_2(neon_rshl_s32, i32, i32, i32) |
| 248 | 248 |
DEF_HELPER_2(neon_rshl_u64, i64, i64, i64) |
| 249 | 249 |
DEF_HELPER_2(neon_rshl_s64, i64, i64, i64) |
| 250 |
DEF_HELPER_2(neon_qshl_u8, i32, i32, i32)
|
|
| 251 |
DEF_HELPER_2(neon_qshl_s8, i32, i32, i32)
|
|
| 252 |
DEF_HELPER_2(neon_qshl_u16, i32, i32, i32)
|
|
| 253 |
DEF_HELPER_2(neon_qshl_s16, i32, i32, i32)
|
|
| 254 |
DEF_HELPER_2(neon_qshl_u32, i32, i32, i32)
|
|
| 255 |
DEF_HELPER_2(neon_qshl_s32, i32, i32, i32)
|
|
| 256 |
DEF_HELPER_2(neon_qshl_u64, i64, i64, i64)
|
|
| 257 |
DEF_HELPER_2(neon_qshl_s64, i64, i64, i64)
|
|
| 258 |
DEF_HELPER_2(neon_qshlu_s8, i32, i32, i32);
|
|
| 259 |
DEF_HELPER_2(neon_qshlu_s16, i32, i32, i32);
|
|
| 260 |
DEF_HELPER_2(neon_qshlu_s32, i32, i32, i32);
|
|
| 261 |
DEF_HELPER_2(neon_qshlu_s64, i64, i64, i64);
|
|
| 262 |
DEF_HELPER_2(neon_qrshl_u8, i32, i32, i32)
|
|
| 263 |
DEF_HELPER_2(neon_qrshl_s8, i32, i32, i32)
|
|
| 264 |
DEF_HELPER_2(neon_qrshl_u16, i32, i32, i32)
|
|
| 265 |
DEF_HELPER_2(neon_qrshl_s16, i32, i32, i32)
|
|
| 266 |
DEF_HELPER_2(neon_qrshl_u32, i32, i32, i32)
|
|
| 267 |
DEF_HELPER_2(neon_qrshl_s32, i32, i32, i32)
|
|
| 268 |
DEF_HELPER_2(neon_qrshl_u64, i64, i64, i64)
|
|
| 269 |
DEF_HELPER_2(neon_qrshl_s64, i64, i64, i64)
|
|
| 250 |
DEF_HELPER_3(neon_qshl_u8, i32, env, i32, i32)
|
|
| 251 |
DEF_HELPER_3(neon_qshl_s8, i32, env, i32, i32)
|
|
| 252 |
DEF_HELPER_3(neon_qshl_u16, i32, env, i32, i32)
|
|
| 253 |
DEF_HELPER_3(neon_qshl_s16, i32, env, i32, i32)
|
|
| 254 |
DEF_HELPER_3(neon_qshl_u32, i32, env, i32, i32)
|
|
| 255 |
DEF_HELPER_3(neon_qshl_s32, i32, env, i32, i32)
|
|
| 256 |
DEF_HELPER_3(neon_qshl_u64, i64, env, i64, i64)
|
|
| 257 |
DEF_HELPER_3(neon_qshl_s64, i64, env, i64, i64)
|
|
| 258 |
DEF_HELPER_3(neon_qshlu_s8, i32, env, i32, i32);
|
|
| 259 |
DEF_HELPER_3(neon_qshlu_s16, i32, env, i32, i32);
|
|
| 260 |
DEF_HELPER_3(neon_qshlu_s32, i32, env, i32, i32);
|
|
| 261 |
DEF_HELPER_3(neon_qshlu_s64, i64, env, i64, i64);
|
|
| 262 |
DEF_HELPER_3(neon_qrshl_u8, i32, env, i32, i32)
|
|
| 263 |
DEF_HELPER_3(neon_qrshl_s8, i32, env, i32, i32)
|
|
| 264 |
DEF_HELPER_3(neon_qrshl_u16, i32, env, i32, i32)
|
|
| 265 |
DEF_HELPER_3(neon_qrshl_s16, i32, env, i32, i32)
|
|
| 266 |
DEF_HELPER_3(neon_qrshl_u32, i32, env, i32, i32)
|
|
| 267 |
DEF_HELPER_3(neon_qrshl_s32, i32, env, i32, i32)
|
|
| 268 |
DEF_HELPER_3(neon_qrshl_u64, i64, env, i64, i64)
|
|
| 269 |
DEF_HELPER_3(neon_qrshl_s64, i64, env, i64, i64)
|
|
| 270 | 270 |
|
| 271 | 271 |
DEF_HELPER_2(neon_add_u8, i32, i32, i32) |
| 272 | 272 |
DEF_HELPER_2(neon_add_u16, i32, i32, i32) |
| ... | ... | |
| 295 | 295 |
DEF_HELPER_1(neon_cls_s32, i32, i32) |
| 296 | 296 |
DEF_HELPER_1(neon_cnt_u8, i32, i32) |
| 297 | 297 |
|
| 298 |
DEF_HELPER_2(neon_qdmulh_s16, i32, i32, i32)
|
|
| 299 |
DEF_HELPER_2(neon_qrdmulh_s16, i32, i32, i32)
|
|
| 300 |
DEF_HELPER_2(neon_qdmulh_s32, i32, i32, i32)
|
|
| 301 |
DEF_HELPER_2(neon_qrdmulh_s32, i32, i32, i32)
|
|
| 298 |
DEF_HELPER_3(neon_qdmulh_s16, i32, env, i32, i32)
|
|
| 299 |
DEF_HELPER_3(neon_qrdmulh_s16, i32, env, i32, i32)
|
|
| 300 |
DEF_HELPER_3(neon_qdmulh_s32, i32, env, i32, i32)
|
|
| 301 |
DEF_HELPER_3(neon_qrdmulh_s32, i32, env, i32, i32)
|
|
| 302 | 302 |
|
| 303 | 303 |
DEF_HELPER_1(neon_narrow_u8, i32, i64) |
| 304 | 304 |
DEF_HELPER_1(neon_narrow_u16, i32, i64) |
| 305 |
DEF_HELPER_1(neon_unarrow_sat8, i32, i64)
|
|
| 306 |
DEF_HELPER_1(neon_narrow_sat_u8, i32, i64)
|
|
| 307 |
DEF_HELPER_1(neon_narrow_sat_s8, i32, i64)
|
|
| 308 |
DEF_HELPER_1(neon_unarrow_sat16, i32, i64)
|
|
| 309 |
DEF_HELPER_1(neon_narrow_sat_u16, i32, i64)
|
|
| 310 |
DEF_HELPER_1(neon_narrow_sat_s16, i32, i64)
|
|
| 311 |
DEF_HELPER_1(neon_unarrow_sat32, i32, i64)
|
|
| 312 |
DEF_HELPER_1(neon_narrow_sat_u32, i32, i64)
|
|
| 313 |
DEF_HELPER_1(neon_narrow_sat_s32, i32, i64)
|
|
| 305 |
DEF_HELPER_2(neon_unarrow_sat8, i32, env, i64)
|
|
| 306 |
DEF_HELPER_2(neon_narrow_sat_u8, i32, env, i64)
|
|
| 307 |
DEF_HELPER_2(neon_narrow_sat_s8, i32, env, i64)
|
|
| 308 |
DEF_HELPER_2(neon_unarrow_sat16, i32, env, i64)
|
|
| 309 |
DEF_HELPER_2(neon_narrow_sat_u16, i32, env, i64)
|
|
| 310 |
DEF_HELPER_2(neon_narrow_sat_s16, i32, env, i64)
|
|
| 311 |
DEF_HELPER_2(neon_unarrow_sat32, i32, env, i64)
|
|
| 312 |
DEF_HELPER_2(neon_narrow_sat_u32, i32, env, i64)
|
|
| 313 |
DEF_HELPER_2(neon_narrow_sat_s32, i32, env, i64)
|
|
| 314 | 314 |
DEF_HELPER_1(neon_narrow_high_u8, i32, i64) |
| 315 | 315 |
DEF_HELPER_1(neon_narrow_high_u16, i32, i64) |
| 316 | 316 |
DEF_HELPER_1(neon_narrow_round_high_u8, i32, i64) |
| ... | ... | |
| 326 | 326 |
DEF_HELPER_2(neon_paddl_u32, i64, i64, i64) |
| 327 | 327 |
DEF_HELPER_2(neon_subl_u16, i64, i64, i64) |
| 328 | 328 |
DEF_HELPER_2(neon_subl_u32, i64, i64, i64) |
| 329 |
DEF_HELPER_2(neon_addl_saturate_s32, i64, i64, i64)
|
|
| 330 |
DEF_HELPER_2(neon_addl_saturate_s64, i64, i64, i64)
|
|
| 329 |
DEF_HELPER_3(neon_addl_saturate_s32, i64, env, i64, i64)
|
|
| 330 |
DEF_HELPER_3(neon_addl_saturate_s64, i64, env, i64, i64)
|
|
| 331 | 331 |
DEF_HELPER_2(neon_abdl_u16, i64, i32, i32) |
| 332 | 332 |
DEF_HELPER_2(neon_abdl_s16, i64, i32, i32) |
| 333 | 333 |
DEF_HELPER_2(neon_abdl_u32, i64, i32, i32) |
| ... | ... | |
| 343 | 343 |
DEF_HELPER_1(neon_negl_u32, i64, i64) |
| 344 | 344 |
DEF_HELPER_1(neon_negl_u64, i64, i64) |
| 345 | 345 |
|
| 346 |
DEF_HELPER_1(neon_qabs_s8, i32, i32)
|
|
| 347 |
DEF_HELPER_1(neon_qabs_s16, i32, i32)
|
|
| 348 |
DEF_HELPER_1(neon_qabs_s32, i32, i32)
|
|
| 349 |
DEF_HELPER_1(neon_qneg_s8, i32, i32)
|
|
| 350 |
DEF_HELPER_1(neon_qneg_s16, i32, i32)
|
|
| 351 |
DEF_HELPER_1(neon_qneg_s32, i32, i32)
|
|
| 346 |
DEF_HELPER_2(neon_qabs_s8, i32, env, i32)
|
|
| 347 |
DEF_HELPER_2(neon_qabs_s16, i32, env, i32)
|
|
| 348 |
DEF_HELPER_2(neon_qabs_s32, i32, env, i32)
|
|
| 349 |
DEF_HELPER_2(neon_qneg_s8, i32, env, i32)
|
|
| 350 |
DEF_HELPER_2(neon_qneg_s16, i32, env, i32)
|
|
| 351 |
DEF_HELPER_2(neon_qneg_s32, i32, env, i32)
|
|
| 352 | 352 |
|
| 353 | 353 |
DEF_HELPER_3(neon_min_f32, i32, i32, i32, ptr) |
| 354 | 354 |
DEF_HELPER_3(neon_max_f32, i32, i32, i32, ptr) |
| ... | ... | |
| 458 | 458 |
|
| 459 | 459 |
DEF_HELPER_2(set_teecr, void, env, i32) |
| 460 | 460 |
|
| 461 |
DEF_HELPER_2(neon_unzip8, void, i32, i32)
|
|
| 462 |
DEF_HELPER_2(neon_unzip16, void, i32, i32)
|
|
| 463 |
DEF_HELPER_2(neon_qunzip8, void, i32, i32)
|
|
| 464 |
DEF_HELPER_2(neon_qunzip16, void, i32, i32)
|
|
| 465 |
DEF_HELPER_2(neon_qunzip32, void, i32, i32)
|
|
| 466 |
DEF_HELPER_2(neon_zip8, void, i32, i32)
|
|
| 467 |
DEF_HELPER_2(neon_zip16, void, i32, i32)
|
|
| 468 |
DEF_HELPER_2(neon_qzip8, void, i32, i32)
|
|
| 469 |
DEF_HELPER_2(neon_qzip16, void, i32, i32)
|
|
| 470 |
DEF_HELPER_2(neon_qzip32, void, i32, i32)
|
|
| 461 |
DEF_HELPER_3(neon_unzip8, void, env, i32, i32)
|
|
| 462 |
DEF_HELPER_3(neon_unzip16, void, env, i32, i32)
|
|
| 463 |
DEF_HELPER_3(neon_qunzip8, void, env, i32, i32)
|
|
| 464 |
DEF_HELPER_3(neon_qunzip16, void, env, i32, i32)
|
|
| 465 |
DEF_HELPER_3(neon_qunzip32, void, env, i32, i32)
|
|
| 466 |
DEF_HELPER_3(neon_zip8, void, env, i32, i32)
|
|
| 467 |
DEF_HELPER_3(neon_zip16, void, env, i32, i32)
|
|
| 468 |
DEF_HELPER_3(neon_qzip8, void, env, i32, i32)
|
|
| 469 |
DEF_HELPER_3(neon_qzip16, void, env, i32, i32)
|
|
| 470 |
DEF_HELPER_3(neon_qzip32, void, env, i32, i32)
|
|
| 471 | 471 |
|
| 472 | 472 |
#include "def-helper.h" |
| b/target-arm/neon_helper.c | ||
|---|---|---|
| 10 | 10 |
#include <stdio.h> |
| 11 | 11 |
|
| 12 | 12 |
#include "cpu.h" |
| 13 |
#include "exec.h" |
|
| 13 |
#include "exec-all.h"
|
|
| 14 | 14 |
#include "helper.h" |
| 15 | 15 |
|
| 16 | 16 |
#define SIGNBIT (uint32_t)0x80000000 |
| ... | ... | |
| 113 | 113 |
uint32_t HELPER(glue(neon_,name))(uint32_t arg1, uint32_t arg2) \ |
| 114 | 114 |
NEON_VOP_BODY(vtype, n) |
| 115 | 115 |
|
| 116 |
#define NEON_VOP_ENV(name, vtype, n) \ |
|
| 117 |
uint32_t HELPER(glue(neon_,name))(CPUState *env, uint32_t arg1, uint32_t arg2) \ |
|
| 118 |
NEON_VOP_BODY(vtype, n) |
|
| 119 |
|
|
| 116 | 120 |
/* Pairwise operations. */ |
| 117 | 121 |
/* For 32-bit elements each segment only contains a single element, so |
| 118 | 122 |
the elementwise and pairwise operations are the same. */ |
| ... | ... | |
| 161 | 165 |
dest = tmp; \ |
| 162 | 166 |
}} while(0) |
| 163 | 167 |
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t) |
| 164 |
NEON_VOP(qadd_u8, neon_u8, 4) |
|
| 168 |
NEON_VOP_ENV(qadd_u8, neon_u8, 4)
|
|
| 165 | 169 |
#undef NEON_FN |
| 166 | 170 |
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t) |
| 167 |
NEON_VOP(qadd_u16, neon_u16, 2) |
|
| 171 |
NEON_VOP_ENV(qadd_u16, neon_u16, 2)
|
|
| 168 | 172 |
#undef NEON_FN |
| 169 | 173 |
#undef NEON_USAT |
| 170 | 174 |
|
| 171 |
uint32_t HELPER(neon_qadd_u32)(uint32_t a, uint32_t b) |
|
| 175 |
uint32_t HELPER(neon_qadd_u32)(CPUState *env, uint32_t a, uint32_t b)
|
|
| 172 | 176 |
{
|
| 173 | 177 |
uint32_t res = a + b; |
| 174 | 178 |
if (res < a) {
|
| ... | ... | |
| 178 | 182 |
return res; |
| 179 | 183 |
} |
| 180 | 184 |
|
| 181 |
uint64_t HELPER(neon_qadd_u64)(uint64_t src1, uint64_t src2) |
|
| 185 |
uint64_t HELPER(neon_qadd_u64)(CPUState *env, uint64_t src1, uint64_t src2)
|
|
| 182 | 186 |
{
|
| 183 | 187 |
uint64_t res; |
| 184 | 188 |
|
| ... | ... | |
| 203 | 207 |
dest = tmp; \ |
| 204 | 208 |
} while(0) |
| 205 | 209 |
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t) |
| 206 |
NEON_VOP(qadd_s8, neon_s8, 4) |
|
| 210 |
NEON_VOP_ENV(qadd_s8, neon_s8, 4)
|
|
| 207 | 211 |
#undef NEON_FN |
| 208 | 212 |
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t) |
| 209 |
NEON_VOP(qadd_s16, neon_s16, 2) |
|
| 213 |
NEON_VOP_ENV(qadd_s16, neon_s16, 2)
|
|
| 210 | 214 |
#undef NEON_FN |
| 211 | 215 |
#undef NEON_SSAT |
| 212 | 216 |
|
| 213 |
uint32_t HELPER(neon_qadd_s32)(uint32_t a, uint32_t b) |
|
| 217 |
uint32_t HELPER(neon_qadd_s32)(CPUState *env, uint32_t a, uint32_t b)
|
|
| 214 | 218 |
{
|
| 215 | 219 |
uint32_t res = a + b; |
| 216 | 220 |
if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT)) {
|
| ... | ... | |
| 220 | 224 |
return res; |
| 221 | 225 |
} |
| 222 | 226 |
|
| 223 |
uint64_t HELPER(neon_qadd_s64)(uint64_t src1, uint64_t src2) |
|
| 227 |
uint64_t HELPER(neon_qadd_s64)(CPUState *env, uint64_t src1, uint64_t src2)
|
|
| 224 | 228 |
{
|
| 225 | 229 |
uint64_t res; |
| 226 | 230 |
|
| ... | ... | |
| 241 | 245 |
dest = tmp; \ |
| 242 | 246 |
}} while(0) |
| 243 | 247 |
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t) |
| 244 |
NEON_VOP(qsub_u8, neon_u8, 4) |
|
| 248 |
NEON_VOP_ENV(qsub_u8, neon_u8, 4)
|
|
| 245 | 249 |
#undef NEON_FN |
| 246 | 250 |
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t) |
| 247 |
NEON_VOP(qsub_u16, neon_u16, 2) |
|
| 251 |
NEON_VOP_ENV(qsub_u16, neon_u16, 2)
|
|
| 248 | 252 |
#undef NEON_FN |
| 249 | 253 |
#undef NEON_USAT |
| 250 | 254 |
|
| 251 |
uint32_t HELPER(neon_qsub_u32)(uint32_t a, uint32_t b) |
|
| 255 |
uint32_t HELPER(neon_qsub_u32)(CPUState *env, uint32_t a, uint32_t b)
|
|
| 252 | 256 |
{
|
| 253 | 257 |
uint32_t res = a - b; |
| 254 | 258 |
if (res > a) {
|
| ... | ... | |
| 258 | 262 |
return res; |
| 259 | 263 |
} |
| 260 | 264 |
|
| 261 |
uint64_t HELPER(neon_qsub_u64)(uint64_t src1, uint64_t src2) |
|
| 265 |
uint64_t HELPER(neon_qsub_u64)(CPUState *env, uint64_t src1, uint64_t src2)
|
|
| 262 | 266 |
{
|
| 263 | 267 |
uint64_t res; |
| 264 | 268 |
|
| ... | ... | |
| 284 | 288 |
dest = tmp; \ |
| 285 | 289 |
} while(0) |
| 286 | 290 |
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t) |
| 287 |
NEON_VOP(qsub_s8, neon_s8, 4) |
|
| 291 |
NEON_VOP_ENV(qsub_s8, neon_s8, 4)
|
|
| 288 | 292 |
#undef NEON_FN |
| 289 | 293 |
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t) |
| 290 |
NEON_VOP(qsub_s16, neon_s16, 2) |
|
| 294 |
NEON_VOP_ENV(qsub_s16, neon_s16, 2)
|
|
| 291 | 295 |
#undef NEON_FN |
| 292 | 296 |
#undef NEON_SSAT |
| 293 | 297 |
|
| 294 |
uint32_t HELPER(neon_qsub_s32)(uint32_t a, uint32_t b) |
|
| 298 |
uint32_t HELPER(neon_qsub_s32)(CPUState *env, uint32_t a, uint32_t b)
|
|
| 295 | 299 |
{
|
| 296 | 300 |
uint32_t res = a - b; |
| 297 | 301 |
if (((res ^ a) & SIGNBIT) && ((a ^ b) & SIGNBIT)) {
|
| ... | ... | |
| 301 | 305 |
return res; |
| 302 | 306 |
} |
| 303 | 307 |
|
| 304 |
uint64_t HELPER(neon_qsub_s64)(uint64_t src1, uint64_t src2) |
|
| 308 |
uint64_t HELPER(neon_qsub_s64)(CPUState *env, uint64_t src1, uint64_t src2)
|
|
| 305 | 309 |
{
|
| 306 | 310 |
uint64_t res; |
| 307 | 311 |
|
| ... | ... | |
| 652 | 656 |
dest = ~0; \ |
| 653 | 657 |
} \ |
| 654 | 658 |
}} while (0) |
| 655 |
NEON_VOP(qshl_u8, neon_u8, 4) |
|
| 656 |
NEON_VOP(qshl_u16, neon_u16, 2) |
|
| 657 |
NEON_VOP(qshl_u32, neon_u32, 1) |
|
| 659 |
NEON_VOP_ENV(qshl_u8, neon_u8, 4)
|
|
| 660 |
NEON_VOP_ENV(qshl_u16, neon_u16, 2)
|
|
| 661 |
NEON_VOP_ENV(qshl_u32, neon_u32, 1)
|
|
| 658 | 662 |
#undef NEON_FN |
| 659 | 663 |
|
| 660 |
uint64_t HELPER(neon_qshl_u64)(uint64_t val, uint64_t shiftop) |
|
| 664 |
uint64_t HELPER(neon_qshl_u64)(CPUState *env, uint64_t val, uint64_t shiftop)
|
|
| 661 | 665 |
{
|
| 662 | 666 |
int8_t shift = (int8_t)shiftop; |
| 663 | 667 |
if (shift >= 64) {
|
| ... | ... | |
| 707 | 711 |
} \ |
| 708 | 712 |
} \ |
| 709 | 713 |
}} while (0) |
| 710 |
NEON_VOP(qshl_s8, neon_s8, 4) |
|
| 711 |
NEON_VOP(qshl_s16, neon_s16, 2) |
|
| 712 |
NEON_VOP(qshl_s32, neon_s32, 1) |
|
| 714 |
NEON_VOP_ENV(qshl_s8, neon_s8, 4)
|
|
| 715 |
NEON_VOP_ENV(qshl_s16, neon_s16, 2)
|
|
| 716 |
NEON_VOP_ENV(qshl_s32, neon_s32, 1)
|
|
| 713 | 717 |
#undef NEON_FN |
| 714 | 718 |
|
| 715 |
uint64_t HELPER(neon_qshl_s64)(uint64_t valop, uint64_t shiftop) |
|
| 719 |
uint64_t HELPER(neon_qshl_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
|
|
| 716 | 720 |
{
|
| 717 | 721 |
int8_t shift = (uint8_t)shiftop; |
| 718 | 722 |
int64_t val = valop; |
| ... | ... | |
| 762 | 766 |
} \ |
| 763 | 767 |
} \ |
| 764 | 768 |
}} while (0) |
| 765 |
NEON_VOP(qshlu_s8, neon_u8, 4) |
|
| 766 |
NEON_VOP(qshlu_s16, neon_u16, 2) |
|
| 769 |
NEON_VOP_ENV(qshlu_s8, neon_u8, 4)
|
|
| 770 |
NEON_VOP_ENV(qshlu_s16, neon_u16, 2)
|
|
| 767 | 771 |
#undef NEON_FN |
| 768 | 772 |
|
| 769 |
uint32_t HELPER(neon_qshlu_s32)(uint32_t valop, uint32_t shiftop) |
|
| 773 |
uint32_t HELPER(neon_qshlu_s32)(CPUState *env, uint32_t valop, uint32_t shiftop)
|
|
| 770 | 774 |
{
|
| 771 | 775 |
if ((int32_t)valop < 0) {
|
| 772 | 776 |
SET_QC(); |
| 773 | 777 |
return 0; |
| 774 | 778 |
} |
| 775 |
return helper_neon_qshl_u32(valop, shiftop); |
|
| 779 |
return helper_neon_qshl_u32(env, valop, shiftop);
|
|
| 776 | 780 |
} |
| 777 | 781 |
|
| 778 |
uint64_t HELPER(neon_qshlu_s64)(uint64_t valop, uint64_t shiftop) |
|
| 782 |
uint64_t HELPER(neon_qshlu_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
|
|
| 779 | 783 |
{
|
| 780 | 784 |
if ((int64_t)valop < 0) {
|
| 781 | 785 |
SET_QC(); |
| 782 | 786 |
return 0; |
| 783 | 787 |
} |
| 784 |
return helper_neon_qshl_u64(valop, shiftop); |
|
| 788 |
return helper_neon_qshl_u64(env, valop, shiftop);
|
|
| 785 | 789 |
} |
| 786 | 790 |
|
| 787 | 791 |
/* FIXME: This is wrong. */ |
| ... | ... | |
| 808 | 812 |
dest = ~0; \ |
| 809 | 813 |
} \ |
| 810 | 814 |
}} while (0) |
| 811 |
NEON_VOP(qrshl_u8, neon_u8, 4) |
|
| 812 |
NEON_VOP(qrshl_u16, neon_u16, 2) |
|
| 815 |
NEON_VOP_ENV(qrshl_u8, neon_u8, 4)
|
|
| 816 |
NEON_VOP_ENV(qrshl_u16, neon_u16, 2)
|
|
| 813 | 817 |
#undef NEON_FN |
| 814 | 818 |
|
| 815 | 819 |
/* The addition of the rounding constant may overflow, so we use an |
| 816 | 820 |
* intermediate 64 bits accumulator. */ |
| 817 |
uint32_t HELPER(neon_qrshl_u32)(uint32_t val, uint32_t shiftop) |
|
| 821 |
uint32_t HELPER(neon_qrshl_u32)(CPUState *env, uint32_t val, uint32_t shiftop)
|
|
| 818 | 822 |
{
|
| 819 | 823 |
uint32_t dest; |
| 820 | 824 |
int8_t shift = (int8_t)shiftop; |
| ... | ... | |
| 844 | 848 |
|
| 845 | 849 |
/* Handling addition overflow with 64 bits inputs values is more |
| 846 | 850 |
* tricky than with 32 bits values. */ |
| 847 |
uint64_t HELPER(neon_qrshl_u64)(uint64_t val, uint64_t shiftop) |
|
| 851 |
uint64_t HELPER(neon_qrshl_u64)(CPUState *env, uint64_t val, uint64_t shiftop)
|
|
| 848 | 852 |
{
|
| 849 | 853 |
int8_t shift = (int8_t)shiftop; |
| 850 | 854 |
if (shift >= 64) {
|
| ... | ... | |
| 905 | 909 |
} \ |
| 906 | 910 |
} \ |
| 907 | 911 |
}} while (0) |
| 908 |
NEON_VOP(qrshl_s8, neon_s8, 4) |
|
| 909 |
NEON_VOP(qrshl_s16, neon_s16, 2) |
|
| 912 |
NEON_VOP_ENV(qrshl_s8, neon_s8, 4)
|
|
| 913 |
NEON_VOP_ENV(qrshl_s16, neon_s16, 2)
|
|
| 910 | 914 |
#undef NEON_FN |
| 911 | 915 |
|
| 912 | 916 |
/* The addition of the rounding constant may overflow, so we use an |
| 913 | 917 |
* intermediate 64 bits accumulator. */ |
| 914 |
uint32_t HELPER(neon_qrshl_s32)(uint32_t valop, uint32_t shiftop) |
|
| 918 |
uint32_t HELPER(neon_qrshl_s32)(CPUState *env, uint32_t valop, uint32_t shiftop)
|
|
| 915 | 919 |
{
|
| 916 | 920 |
int32_t dest; |
| 917 | 921 |
int32_t val = (int32_t)valop; |
| ... | ... | |
| 940 | 944 |
|
| 941 | 945 |
/* Handling addition overflow with 64 bits inputs values is more |
| 942 | 946 |
* tricky than with 32 bits values. */ |
| 943 |
uint64_t HELPER(neon_qrshl_s64)(uint64_t valop, uint64_t shiftop) |
|
| 947 |
uint64_t HELPER(neon_qrshl_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
|
|
| 944 | 948 |
{
|
| 945 | 949 |
int8_t shift = (uint8_t)shiftop; |
| 946 | 950 |
int64_t val = valop; |
| ... | ... | |
| 1149 | 1153 |
dest = tmp >> 16; \ |
| 1150 | 1154 |
} while(0) |
| 1151 | 1155 |
#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 0) |
| 1152 |
NEON_VOP(qdmulh_s16, neon_s16, 2) |
|
| 1156 |
NEON_VOP_ENV(qdmulh_s16, neon_s16, 2)
|
|
| 1153 | 1157 |
#undef NEON_FN |
| 1154 | 1158 |
#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 1) |
| 1155 |
NEON_VOP(qrdmulh_s16, neon_s16, 2) |
|
| 1159 |
NEON_VOP_ENV(qrdmulh_s16, neon_s16, 2)
|
|
| 1156 | 1160 |
#undef NEON_FN |
| 1157 | 1161 |
#undef NEON_QDMULH16 |
| 1158 | 1162 |
|
| ... | ... | |
| 1175 | 1179 |
dest = tmp >> 32; \ |
| 1176 | 1180 |
} while(0) |
| 1177 | 1181 |
#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 0) |
| 1178 |
NEON_VOP(qdmulh_s32, neon_s32, 1) |
|
| 1182 |
NEON_VOP_ENV(qdmulh_s32, neon_s32, 1)
|
|
| 1179 | 1183 |
#undef NEON_FN |
| 1180 | 1184 |
#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 1) |
| 1181 |
NEON_VOP(qrdmulh_s32, neon_s32, 1) |
|
| 1185 |
NEON_VOP_ENV(qrdmulh_s32, neon_s32, 1)
|
|
| 1182 | 1186 |
#undef NEON_FN |
| 1183 | 1187 |
#undef NEON_QDMULH32 |
| 1184 | 1188 |
|
| ... | ... | |
| 1219 | 1223 |
return ((x >> 16) & 0xffff) | ((x >> 32) & 0xffff0000); |
| 1220 | 1224 |
} |
| 1221 | 1225 |
|
| 1222 |
uint32_t HELPER(neon_unarrow_sat8)(uint64_t x) |
|
| 1226 |
uint32_t HELPER(neon_unarrow_sat8)(CPUState *env, uint64_t x)
|
|
| 1223 | 1227 |
{
|
| 1224 | 1228 |
uint16_t s; |
| 1225 | 1229 |
uint8_t d; |
| ... | ... | |
| 1246 | 1250 |
return res; |
| 1247 | 1251 |
} |
| 1248 | 1252 |
|
| 1249 |
uint32_t HELPER(neon_narrow_sat_u8)(uint64_t x) |
|
| 1253 |
uint32_t HELPER(neon_narrow_sat_u8)(CPUState *env, uint64_t x)
|
|
| 1250 | 1254 |
{
|
| 1251 | 1255 |
uint16_t s; |
| 1252 | 1256 |
uint8_t d; |
| ... | ... | |
| 1269 | 1273 |
return res; |
| 1270 | 1274 |
} |
| 1271 | 1275 |
|
| 1272 |
uint32_t HELPER(neon_narrow_sat_s8)(uint64_t x) |
|
| 1276 |
uint32_t HELPER(neon_narrow_sat_s8)(CPUState *env, uint64_t x)
|
|
| 1273 | 1277 |
{
|
| 1274 | 1278 |
int16_t s; |
| 1275 | 1279 |
uint8_t d; |
| ... | ... | |
| 1292 | 1296 |
return res; |
| 1293 | 1297 |
} |
| 1294 | 1298 |
|
| 1295 |
uint32_t HELPER(neon_unarrow_sat16)(uint64_t x) |
|
| 1299 |
uint32_t HELPER(neon_unarrow_sat16)(CPUState *env, uint64_t x)
|
|
| 1296 | 1300 |
{
|
| 1297 | 1301 |
uint32_t high; |
| 1298 | 1302 |
uint32_t low; |
| ... | ... | |
| 1315 | 1319 |
return low | (high << 16); |
| 1316 | 1320 |
} |
| 1317 | 1321 |
|
| 1318 |
uint32_t HELPER(neon_narrow_sat_u16)(uint64_t x) |
|
| 1322 |
uint32_t HELPER(neon_narrow_sat_u16)(CPUState *env, uint64_t x)
|
|
| 1319 | 1323 |
{
|
| 1320 | 1324 |
uint32_t high; |
| 1321 | 1325 |
uint32_t low; |
| ... | ... | |
| 1332 | 1336 |
return low | (high << 16); |
| 1333 | 1337 |
} |
| 1334 | 1338 |
|
| 1335 |
uint32_t HELPER(neon_narrow_sat_s16)(uint64_t x) |
|
| 1339 |
uint32_t HELPER(neon_narrow_sat_s16)(CPUState *env, uint64_t x)
|
|
| 1336 | 1340 |
{
|
| 1337 | 1341 |
int32_t low; |
| 1338 | 1342 |
int32_t high; |
| ... | ... | |
| 1349 | 1353 |
return (uint16_t)low | (high << 16); |
| 1350 | 1354 |
} |
| 1351 | 1355 |
|
| 1352 |
uint32_t HELPER(neon_unarrow_sat32)(uint64_t x) |
|
| 1356 |
uint32_t HELPER(neon_unarrow_sat32)(CPUState *env, uint64_t x)
|
|
| 1353 | 1357 |
{
|
| 1354 | 1358 |
if (x & 0x8000000000000000ull) {
|
| 1355 | 1359 |
SET_QC(); |
| ... | ... | |
| 1362 | 1366 |
return x; |
| 1363 | 1367 |
} |
| 1364 | 1368 |
|
| 1365 |
uint32_t HELPER(neon_narrow_sat_u32)(uint64_t x) |
|
| 1369 |
uint32_t HELPER(neon_narrow_sat_u32)(CPUState *env, uint64_t x)
|
|
| 1366 | 1370 |
{
|
| 1367 | 1371 |
if (x > 0xffffffffu) {
|
| 1368 | 1372 |
SET_QC(); |
| ... | ... | |
| 1371 | 1375 |
return x; |
| 1372 | 1376 |
} |
| 1373 | 1377 |
|
| 1374 |
uint32_t HELPER(neon_narrow_sat_s32)(uint64_t x) |
|
| 1378 |
uint32_t HELPER(neon_narrow_sat_s32)(CPUState *env, uint64_t x)
|
|
| 1375 | 1379 |
{
|
| 1376 | 1380 |
if ((int64_t)x != (int32_t)x) {
|
| 1377 | 1381 |
SET_QC(); |
| ... | ... | |
| 1478 | 1482 |
return (a - b) ^ mask; |
| 1479 | 1483 |
} |
| 1480 | 1484 |
|
| 1481 |
uint64_t HELPER(neon_addl_saturate_s32)(uint64_t a, uint64_t b) |
|
| 1485 |
uint64_t HELPER(neon_addl_saturate_s32)(CPUState *env, uint64_t a, uint64_t b)
|
|
| 1482 | 1486 |
{
|
| 1483 | 1487 |
uint32_t x, y; |
| 1484 | 1488 |
uint32_t low, high; |
| ... | ... | |
| 1500 | 1504 |
return low | ((uint64_t)high << 32); |
| 1501 | 1505 |
} |
| 1502 | 1506 |
|
| 1503 |
uint64_t HELPER(neon_addl_saturate_s64)(uint64_t a, uint64_t b) |
|
| 1507 |
uint64_t HELPER(neon_addl_saturate_s64)(CPUState *env, uint64_t a, uint64_t b)
|
|
| 1504 | 1508 |
{
|
| 1505 | 1509 |
uint64_t result; |
| 1506 | 1510 |
|
| ... | ... | |
| 1676 | 1680 |
} else if (x < 0) { \
|
| 1677 | 1681 |
x = -x; \ |
| 1678 | 1682 |
}} while (0) |
| 1679 |
uint32_t HELPER(neon_qabs_s8)(uint32_t x) |
|
| 1683 |
uint32_t HELPER(neon_qabs_s8)(CPUState *env, uint32_t x)
|
|
| 1680 | 1684 |
{
|
| 1681 | 1685 |
neon_s8 vec; |
| 1682 | 1686 |
NEON_UNPACK(neon_s8, vec, x); |
| ... | ... | |
| 1696 | 1700 |
} else { \
|
| 1697 | 1701 |
x = -x; \ |
| 1698 | 1702 |
}} while (0) |
| 1699 |
uint32_t HELPER(neon_qneg_s8)(uint32_t x) |
|
| 1703 |
uint32_t HELPER(neon_qneg_s8)(CPUState *env, uint32_t x)
|
|
| 1700 | 1704 |
{
|
| 1701 | 1705 |
neon_s8 vec; |
| 1702 | 1706 |
NEON_UNPACK(neon_s8, vec, x); |
| ... | ... | |
| 1716 | 1720 |
} else if (x < 0) { \
|
| 1717 | 1721 |
x = -x; \ |
| 1718 | 1722 |
}} while (0) |
| 1719 |
uint32_t HELPER(neon_qabs_s16)(uint32_t x) |
|
| 1723 |
uint32_t HELPER(neon_qabs_s16)(CPUState *env, uint32_t x)
|
|
| 1720 | 1724 |
{
|
| 1721 | 1725 |
neon_s16 vec; |
| 1722 | 1726 |
NEON_UNPACK(neon_s16, vec, x); |
| ... | ... | |
| 1734 | 1738 |
} else { \
|
| 1735 | 1739 |
x = -x; \ |
| 1736 | 1740 |
}} while (0) |
| 1737 |
uint32_t HELPER(neon_qneg_s16)(uint32_t x) |
|
| 1741 |
uint32_t HELPER(neon_qneg_s16)(CPUState *env, uint32_t x)
|
|
| 1738 | 1742 |
{
|
| 1739 | 1743 |
neon_s16 vec; |
| 1740 | 1744 |
NEON_UNPACK(neon_s16, vec, x); |
| ... | ... | |
| 1745 | 1749 |
} |
| 1746 | 1750 |
#undef DO_QNEG16 |
| 1747 | 1751 |
|
| 1748 |
uint32_t HELPER(neon_qabs_s32)(uint32_t x) |
|
| 1752 |
uint32_t HELPER(neon_qabs_s32)(CPUState *env, uint32_t x)
|
|
| 1749 | 1753 |
{
|
| 1750 | 1754 |
if (x == SIGNBIT) {
|
| 1751 | 1755 |
SET_QC(); |
| ... | ... | |
| 1756 | 1760 |
return x; |
| 1757 | 1761 |
} |
| 1758 | 1762 |
|
| 1759 |
uint32_t HELPER(neon_qneg_s32)(uint32_t x) |
|
| 1763 |
uint32_t HELPER(neon_qneg_s32)(CPUState *env, uint32_t x)
|
|
| 1760 | 1764 |
{
|
| 1761 | 1765 |
if (x == SIGNBIT) {
|
| 1762 | 1766 |
SET_QC(); |
| ... | ... | |
| 1828 | 1832 |
|
| 1829 | 1833 |
#define ELEM(V, N, SIZE) (((V) >> ((N) * (SIZE))) & ((1ull << (SIZE)) - 1)) |
| 1830 | 1834 |
|
| 1831 |
void HELPER(neon_qunzip8)(uint32_t rd, uint32_t rm) |
|
| 1835 |
void HELPER(neon_qunzip8)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1832 | 1836 |
{
|
| 1833 | 1837 |
uint64_t zm0 = float64_val(env->vfp.regs[rm]); |
| 1834 | 1838 |
uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]); |
| ... | ... | |
| 1856 | 1860 |
env->vfp.regs[rd + 1] = make_float64(d1); |
| 1857 | 1861 |
} |
| 1858 | 1862 |
|
| 1859 |
void HELPER(neon_qunzip16)(uint32_t rd, uint32_t rm) |
|
| 1863 |
void HELPER(neon_qunzip16)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1860 | 1864 |
{
|
| 1861 | 1865 |
uint64_t zm0 = float64_val(env->vfp.regs[rm]); |
| 1862 | 1866 |
uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]); |
| ... | ... | |
| 1876 | 1880 |
env->vfp.regs[rd + 1] = make_float64(d1); |
| 1877 | 1881 |
} |
| 1878 | 1882 |
|
| 1879 |
void HELPER(neon_qunzip32)(uint32_t rd, uint32_t rm) |
|
| 1883 |
void HELPER(neon_qunzip32)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1880 | 1884 |
{
|
| 1881 | 1885 |
uint64_t zm0 = float64_val(env->vfp.regs[rm]); |
| 1882 | 1886 |
uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]); |
| ... | ... | |
| 1892 | 1896 |
env->vfp.regs[rd + 1] = make_float64(d1); |
| 1893 | 1897 |
} |
| 1894 | 1898 |
|
| 1895 |
void HELPER(neon_unzip8)(uint32_t rd, uint32_t rm) |
|
| 1899 |
void HELPER(neon_unzip8)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1896 | 1900 |
{
|
| 1897 | 1901 |
uint64_t zm = float64_val(env->vfp.regs[rm]); |
| 1898 | 1902 |
uint64_t zd = float64_val(env->vfp.regs[rd]); |
| ... | ... | |
| 1908 | 1912 |
env->vfp.regs[rd] = make_float64(d0); |
| 1909 | 1913 |
} |
| 1910 | 1914 |
|
| 1911 |
void HELPER(neon_unzip16)(uint32_t rd, uint32_t rm) |
|
| 1915 |
void HELPER(neon_unzip16)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1912 | 1916 |
{
|
| 1913 | 1917 |
uint64_t zm = float64_val(env->vfp.regs[rm]); |
| 1914 | 1918 |
uint64_t zd = float64_val(env->vfp.regs[rd]); |
| ... | ... | |
| 1920 | 1924 |
env->vfp.regs[rd] = make_float64(d0); |
| 1921 | 1925 |
} |
| 1922 | 1926 |
|
| 1923 |
void HELPER(neon_qzip8)(uint32_t rd, uint32_t rm) |
|
| 1927 |
void HELPER(neon_qzip8)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1924 | 1928 |
{
|
| 1925 | 1929 |
uint64_t zm0 = float64_val(env->vfp.regs[rm]); |
| 1926 | 1930 |
uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]); |
| ... | ... | |
| 1948 | 1952 |
env->vfp.regs[rd + 1] = make_float64(d1); |
| 1949 | 1953 |
} |
| 1950 | 1954 |
|
| 1951 |
void HELPER(neon_qzip16)(uint32_t rd, uint32_t rm) |
|
| 1955 |
void HELPER(neon_qzip16)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1952 | 1956 |
{
|
| 1953 | 1957 |
uint64_t zm0 = float64_val(env->vfp.regs[rm]); |
| 1954 | 1958 |
uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]); |
| ... | ... | |
| 1968 | 1972 |
env->vfp.regs[rd + 1] = make_float64(d1); |
| 1969 | 1973 |
} |
| 1970 | 1974 |
|
| 1971 |
void HELPER(neon_qzip32)(uint32_t rd, uint32_t rm) |
|
| 1975 |
void HELPER(neon_qzip32)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1972 | 1976 |
{
|
| 1973 | 1977 |
uint64_t zm0 = float64_val(env->vfp.regs[rm]); |
| 1974 | 1978 |
uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]); |
| ... | ... | |
| 1984 | 1988 |
env->vfp.regs[rd + 1] = make_float64(d1); |
| 1985 | 1989 |
} |
| 1986 | 1990 |
|
| 1987 |
void HELPER(neon_zip8)(uint32_t rd, uint32_t rm) |
|
| 1991 |
void HELPER(neon_zip8)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 1988 | 1992 |
{
|
| 1989 | 1993 |
uint64_t zm = float64_val(env->vfp.regs[rm]); |
| 1990 | 1994 |
uint64_t zd = float64_val(env->vfp.regs[rd]); |
| ... | ... | |
| 2000 | 2004 |
env->vfp.regs[rd] = make_float64(d0); |
| 2001 | 2005 |
} |
| 2002 | 2006 |
|
| 2003 |
void HELPER(neon_zip16)(uint32_t rd, uint32_t rm) |
|
| 2007 |
void HELPER(neon_zip16)(CPUState *env, uint32_t rd, uint32_t rm)
|
|
| 2004 | 2008 |
{
|
| 2005 | 2009 |
uint64_t zm = float64_val(env->vfp.regs[rm]); |
| 2006 | 2010 |
uint64_t zd = float64_val(env->vfp.regs[rd]); |
| b/target-arm/translate.c | ||
|---|---|---|
| 3711 | 3711 |
if (q) {
|
| 3712 | 3712 |
switch (size) {
|
| 3713 | 3713 |
case 0: |
| 3714 |
gen_helper_neon_qunzip8(tmp, tmp2); |
|
| 3714 |
gen_helper_neon_qunzip8(cpu_env, tmp, tmp2);
|
|
| 3715 | 3715 |
break; |
| 3716 | 3716 |
case 1: |
| 3717 |
gen_helper_neon_qunzip16(tmp, tmp2); |
|
| 3717 |
gen_helper_neon_qunzip16(cpu_env, tmp, tmp2);
|
|
| 3718 | 3718 |
break; |
| 3719 | 3719 |
case 2: |
| 3720 |
gen_helper_neon_qunzip32(tmp, tmp2); |
|
| 3720 |
gen_helper_neon_qunzip32(cpu_env, tmp, tmp2);
|
|
| 3721 | 3721 |
break; |
| 3722 | 3722 |
default: |
| 3723 | 3723 |
abort(); |
| ... | ... | |
| 3725 | 3725 |
} else {
|
| 3726 | 3726 |
switch (size) {
|
| 3727 | 3727 |
case 0: |
| 3728 |
gen_helper_neon_unzip8(tmp, tmp2); |
|
| 3728 |
gen_helper_neon_unzip8(cpu_env, tmp, tmp2);
|
|
| 3729 | 3729 |
break; |
| 3730 | 3730 |
case 1: |
| 3731 |
gen_helper_neon_unzip16(tmp, tmp2); |
|
| 3731 |
gen_helper_neon_unzip16(cpu_env, tmp, tmp2);
|
|
| 3732 | 3732 |
break; |
| 3733 | 3733 |
default: |
| 3734 | 3734 |
abort(); |
| ... | ... | |
| 3750 | 3750 |
if (q) {
|
| 3751 | 3751 |
switch (size) {
|
| 3752 | 3752 |
case 0: |
| 3753 |
gen_helper_neon_qzip8(tmp, tmp2); |
|
| 3753 |
gen_helper_neon_qzip8(cpu_env, tmp, tmp2);
|
|
| 3754 | 3754 |
break; |
| 3755 | 3755 |
case 1: |
| 3756 |
gen_helper_neon_qzip16(tmp, tmp2); |
|
| 3756 |
gen_helper_neon_qzip16(cpu_env, tmp, tmp2);
|
|
| 3757 | 3757 |
break; |
| 3758 | 3758 |
case 2: |
| 3759 |
gen_helper_neon_qzip32(tmp, tmp2); |
|
| 3759 |
gen_helper_neon_qzip32(cpu_env, tmp, tmp2);
|
|
| 3760 | 3760 |
break; |
| 3761 | 3761 |
default: |
| 3762 | 3762 |
abort(); |
| ... | ... | |
| 3764 | 3764 |
} else {
|
| 3765 | 3765 |
switch (size) {
|
| 3766 | 3766 |
case 0: |
| 3767 |
gen_helper_neon_zip8(tmp, tmp2); |
|
| 3767 |
gen_helper_neon_zip8(cpu_env, tmp, tmp2);
|
|
| 3768 | 3768 |
break; |
| 3769 | 3769 |
case 1: |
| 3770 |
gen_helper_neon_zip16(tmp, tmp2); |
|
| 3770 |
gen_helper_neon_zip16(cpu_env, tmp, tmp2);
|
|
| 3771 | 3771 |
break; |
| 3772 | 3772 |
default: |
| 3773 | 3773 |
abort(); |
| ... | ... | |
| 4167 | 4167 |
static inline void gen_neon_narrow_sats(int size, TCGv dest, TCGv_i64 src) |
| 4168 | 4168 |
{
|
| 4169 | 4169 |
switch (size) {
|
| 4170 |
case 0: gen_helper_neon_narrow_sat_s8(dest, src); break; |
|
| 4171 |
case 1: gen_helper_neon_narrow_sat_s16(dest, src); break; |
|
| 4172 |
case 2: gen_helper_neon_narrow_sat_s32(dest, src); break; |
|
| 4170 |
case 0: gen_helper_neon_narrow_sat_s8(dest, cpu_env, src); break;
|
|
| 4171 |
case 1: gen_helper_neon_narrow_sat_s16(dest, cpu_env, src); break;
|
|
| 4172 |
case 2: gen_helper_neon_narrow_sat_s32(dest, cpu_env, src); break;
|
|
| 4173 | 4173 |
default: abort(); |
| 4174 | 4174 |
} |
| 4175 | 4175 |
} |
| ... | ... | |
| 4177 | 4177 |
static inline void gen_neon_narrow_satu(int size, TCGv dest, TCGv_i64 src) |
| 4178 | 4178 |
{
|
| 4179 | 4179 |
switch (size) {
|
| 4180 |
case 0: gen_helper_neon_narrow_sat_u8(dest, src); break; |
|
| 4181 |
case 1: gen_helper_neon_narrow_sat_u16(dest, src); break; |
|
| 4182 |
case 2: gen_helper_neon_narrow_sat_u32(dest, src); break; |
|
| 4180 |
case 0: gen_helper_neon_narrow_sat_u8(dest, cpu_env, src); break;
|
|
| 4181 |
case 1: gen_helper_neon_narrow_sat_u16(dest, cpu_env, src); break;
|
|
| 4182 |
case 2: gen_helper_neon_narrow_sat_u32(dest, cpu_env, src); break;
|
|
| 4183 | 4183 |
default: abort(); |
| 4184 | 4184 |
} |
| 4185 | 4185 |
} |
| ... | ... | |
| 4187 | 4187 |
static inline void gen_neon_unarrow_sats(int size, TCGv dest, TCGv_i64 src) |
| 4188 | 4188 |
{
|
| 4189 | 4189 |
switch (size) {
|
| 4190 |
case 0: gen_helper_neon_unarrow_sat8(dest, src); break; |
|
| 4191 |
case 1: gen_helper_neon_unarrow_sat16(dest, src); break; |
|
| 4192 |
case 2: gen_helper_neon_unarrow_sat32(dest, src); break; |
|
| 4190 |
case 0: gen_helper_neon_unarrow_sat8(dest, cpu_env, src); break;
|
|
| 4191 |
case 1: gen_helper_neon_unarrow_sat16(dest, cpu_env, src); break;
|
|
| 4192 |
case 2: gen_helper_neon_unarrow_sat32(dest, cpu_env, src); break;
|
|
| 4193 | 4193 |
default: abort(); |
| 4194 | 4194 |
} |
| 4195 | 4195 |
} |
| ... | ... | |
| 4281 | 4281 |
static inline void gen_neon_addl_saturate(TCGv_i64 op0, TCGv_i64 op1, int size) |
| 4282 | 4282 |
{
|
| 4283 | 4283 |
switch (size) {
|
| 4284 |
case 1: gen_helper_neon_addl_saturate_s32(op0, op0, op1); break; |
|
| 4285 |
case 2: gen_helper_neon_addl_saturate_s64(op0, op0, op1); break; |
|
| 4284 |
case 1: gen_helper_neon_addl_saturate_s32(op0, cpu_env, op0, op1); break;
|
|
| 4285 |
case 2: gen_helper_neon_addl_saturate_s64(op0, cpu_env, op0, op1); break;
|
|
| 4286 | 4286 |
default: abort(); |
| 4287 | 4287 |
} |
| 4288 | 4288 |
} |
| ... | ... | |
| 4558 | 4558 |
switch (op) {
|
| 4559 | 4559 |
case NEON_3R_VQADD: |
| 4560 | 4560 |
if (u) {
|
| 4561 |
gen_helper_neon_qadd_u64(cpu_V0, cpu_V0, cpu_V1); |
|
| 4561 |
gen_helper_neon_qadd_u64(cpu_V0, cpu_env, |
|
| 4562 |
cpu_V0, cpu_V1); |
|
| 4562 | 4563 |
} else {
|
| 4563 |
gen_helper_neon_qadd_s64(cpu_V0, cpu_V0, cpu_V1); |
|
| 4564 |
gen_helper_neon_qadd_s64(cpu_V0, cpu_env, |
|
| 4565 |
cpu_V0, cpu_V1); |
|
| 4564 | 4566 |
} |
| 4565 | 4567 |
break; |
| 4566 | 4568 |
case NEON_3R_VQSUB: |
| 4567 | 4569 |
if (u) {
|
| 4568 |
gen_helper_neon_qsub_u64(cpu_V0, cpu_V0, cpu_V1); |
|
| 4570 |
gen_helper_neon_qsub_u64(cpu_V0, cpu_env, |
|
| 4571 |
cpu_V0, cpu_V1); |
|
| 4569 | 4572 |
} else {
|
| 4570 |
gen_helper_neon_qsub_s64(cpu_V0, cpu_V0, cpu_V1); |
|
| 4573 |
gen_helper_neon_qsub_s64(cpu_V0, cpu_env, |
|
| 4574 |
cpu_V0, cpu_V1); |
|
| 4571 | 4575 |
} |
| 4572 | 4576 |
break; |
| 4573 | 4577 |
case NEON_3R_VSHL: |
| ... | ... | |
| 4579 | 4583 |
break; |
| 4580 | 4584 |
case NEON_3R_VQSHL: |
| 4581 | 4585 |
if (u) {
|
| 4582 |
gen_helper_neon_qshl_u64(cpu_V0, cpu_V1, cpu_V0); |
|
| 4586 |
gen_helper_neon_qshl_u64(cpu_V0, cpu_env, |
|
| 4587 |
cpu_V1, cpu_V0); |
|
| 4583 | 4588 |
} else {
|
| 4584 |
gen_helper_neon_qshl_s64(cpu_V0, cpu_V1, cpu_V0); |
|
| 4589 |
gen_helper_neon_qshl_s64(cpu_V0, cpu_env, |
|
| 4590 |
cpu_V1, cpu_V0); |
|
| 4585 | 4591 |
} |
| 4586 | 4592 |
break; |
| 4587 | 4593 |
case NEON_3R_VRSHL: |
| ... | ... | |
| 4593 | 4599 |
break; |
| 4594 | 4600 |
case NEON_3R_VQRSHL: |
| 4595 | 4601 |
if (u) {
|
| 4596 |
gen_helper_neon_qrshl_u64(cpu_V0, cpu_V1, cpu_V0); |
|
| 4602 |
gen_helper_neon_qrshl_u64(cpu_V0, cpu_env, |
|
| 4603 |
cpu_V1, cpu_V0); |
|
| 4597 | 4604 |
} else {
|
| 4598 |
gen_helper_neon_qrshl_s64(cpu_V0, cpu_V1, cpu_V0); |
|
| 4605 |
gen_helper_neon_qrshl_s64(cpu_V0, cpu_env, |
|
| 4606 |
cpu_V1, cpu_V0); |
|
| 4599 | 4607 |
} |
| 4600 | 4608 |
break; |
| 4601 | 4609 |
case NEON_3R_VADD_VSUB: |
| ... | ... | |
| 4693 | 4701 |
GEN_NEON_INTEGER_OP(hadd); |
| 4694 | 4702 |
break; |
| 4695 | 4703 |
case NEON_3R_VQADD: |
| 4696 |
GEN_NEON_INTEGER_OP(qadd); |
|
| 4704 |
GEN_NEON_INTEGER_OP_ENV(qadd);
|
|
| 4697 | 4705 |
break; |
| 4698 | 4706 |
case NEON_3R_VRHADD: |
| 4699 | 4707 |
GEN_NEON_INTEGER_OP(rhadd); |
| ... | ... | |
| 4736 | 4744 |
GEN_NEON_INTEGER_OP(hsub); |
| 4737 | 4745 |
break; |
| 4738 | 4746 |
case NEON_3R_VQSUB: |
| 4739 |
GEN_NEON_INTEGER_OP(qsub); |
|
| 4747 |
GEN_NEON_INTEGER_OP_ENV(qsub);
|
|
| 4740 | 4748 |
break; |
| 4741 | 4749 |
case NEON_3R_VCGT: |
| 4742 | 4750 |
GEN_NEON_INTEGER_OP(cgt); |
| ... | ... | |
| 4748 | 4756 |
GEN_NEON_INTEGER_OP(shl); |
| 4749 | 4757 |
break; |
| 4750 | 4758 |
case NEON_3R_VQSHL: |
| 4751 |
GEN_NEON_INTEGER_OP(qshl); |
|
| 4759 |
GEN_NEON_INTEGER_OP_ENV(qshl);
|
|
| 4752 | 4760 |
break; |
| 4753 | 4761 |
case NEON_3R_VRSHL: |
| 4754 | 4762 |
GEN_NEON_INTEGER_OP(rshl); |
| 4755 | 4763 |
break; |
| 4756 | 4764 |
case NEON_3R_VQRSHL: |
| 4757 |
GEN_NEON_INTEGER_OP(qrshl); |
|
| 4765 |
GEN_NEON_INTEGER_OP_ENV(qrshl);
|
|
| 4758 | 4766 |
break; |
| 4759 | 4767 |
case NEON_3R_VMAX: |
| 4760 | 4768 |
GEN_NEON_INTEGER_OP(max); |
| ... | ... | |
| 4836 | 4844 |
case NEON_3R_VQDMULH_VQRDMULH: /* Multiply high. */ |
| 4837 | 4845 |
if (!u) { /* VQDMULH */
|
| 4838 | 4846 |
switch (size) {
|
| 4839 |
case 1: gen_helper_neon_qdmulh_s16(tmp, tmp, tmp2); break; |
|
| 4840 |
case 2: gen_helper_neon_qdmulh_s32(tmp, tmp, tmp2); break; |
|
| 4847 |
case 1: |
|
| 4848 |
gen_helper_neon_qdmulh_s16(tmp, cpu_env, tmp, tmp2); |
|
| 4849 |
break; |
|
| 4850 |
case 2: |
|
| 4851 |
gen_helper_neon_qdmulh_s32(tmp, cpu_env, tmp, tmp2); |
|
| 4852 |
break; |
|
| 4841 | 4853 |
default: abort(); |
| 4842 | 4854 |
} |
| 4843 | 4855 |
} else { /* VQRDMULH */
|
| 4844 | 4856 |
switch (size) {
|
| 4845 |
case 1: gen_helper_neon_qrdmulh_s16(tmp, tmp, tmp2); break; |
|
| 4846 |
case 2: gen_helper_neon_qrdmulh_s32(tmp, tmp, tmp2); break; |
|
| 4857 |
case 1: |
|
| 4858 |
gen_helper_neon_qrdmulh_s16(tmp, cpu_env, tmp, tmp2); |
|
| 4859 |
break; |
|
| 4860 |
case 2: |
|
| 4861 |
gen_helper_neon_qrdmulh_s32(tmp, cpu_env, tmp, tmp2); |
|
| 4862 |
break; |
|
| 4847 | 4863 |
default: abort(); |
| 4848 | 4864 |
} |
| 4849 | 4865 |
} |
| ... | ... | |
| 5035 | 5051 |
gen_helper_neon_shl_u64(cpu_V0, cpu_V0, cpu_V1); |
| 5036 | 5052 |
break; |
| 5037 | 5053 |
case 6: /* VQSHLU */ |
| 5038 |
gen_helper_neon_qshlu_s64(cpu_V0, cpu_V0, cpu_V1); |
|
| 5054 |
gen_helper_neon_qshlu_s64(cpu_V0, cpu_env, |
|
| 5055 |
cpu_V0, cpu_V1); |
|
| 5039 | 5056 |
break; |
| 5040 | 5057 |
case 7: /* VQSHL */ |
| 5041 | 5058 |
if (u) {
|
| 5042 |
gen_helper_neon_qshl_u64(cpu_V0, |
|
| 5059 |
gen_helper_neon_qshl_u64(cpu_V0, cpu_env,
|
|
| 5043 | 5060 |
cpu_V0, cpu_V1); |
| 5044 | 5061 |
} else {
|
| 5045 |
gen_helper_neon_qshl_s64(cpu_V0, |
|
| 5062 |
gen_helper_neon_qshl_s64(cpu_V0, cpu_env,
|
|
| 5046 | 5063 |
cpu_V0, cpu_V1); |
| 5047 | 5064 |
} |
| 5048 | 5065 |
break; |
| ... | ... | |
| 5094 | 5111 |
case 6: /* VQSHLU */ |
| 5095 | 5112 |
switch (size) {
|
| 5096 | 5113 |
case 0: |
| 5097 |
gen_helper_neon_qshlu_s8(tmp, tmp, tmp2); |
|
| 5114 |
gen_helper_neon_qshlu_s8(tmp, cpu_env, |
|
| 5115 |
tmp, tmp2); |
|
| 5098 | 5116 |
break; |
| 5099 | 5117 |
case 1: |
| 5100 |
gen_helper_neon_qshlu_s16(tmp, tmp, tmp2); |
|
| 5118 |
gen_helper_neon_qshlu_s16(tmp, cpu_env, |
|
| 5119 |
tmp, tmp2); |
|
| 5101 | 5120 |
break; |
| 5102 | 5121 |
case 2: |
| 5103 |
gen_helper_neon_qshlu_s32(tmp, tmp, tmp2); |
|
| 5122 |
gen_helper_neon_qshlu_s32(tmp, cpu_env, |
|
| 5123 |
tmp, tmp2); |
|
| 5104 | 5124 |
break; |
| 5105 | 5125 |
default: |
| 5106 | 5126 |
abort(); |
| 5107 | 5127 |
} |
| 5108 | 5128 |
break; |
| 5109 | 5129 |
case 7: /* VQSHL */ |
| 5110 |
GEN_NEON_INTEGER_OP(qshl); |
|
| 5130 |
GEN_NEON_INTEGER_OP_ENV(qshl);
|
|
| 5111 | 5131 |
break; |
| 5112 | 5132 |
} |
| 5113 | 5133 |
tcg_temp_free_i32(tmp2); |
| ... | ... | |
| 5616 | 5636 |
tmp2 = neon_load_reg(rn, pass); |
| 5617 | 5637 |
if (op == 12) {
|
| 5618 | 5638 |
if (size == 1) {
|
| 5619 |
gen_helper_neon_qdmulh_s16(tmp, tmp, tmp2); |
|
| 5639 |
gen_helper_neon_qdmulh_s16(tmp, cpu_env, tmp, tmp2);
|
|
| 5620 | 5640 |
} else {
|
| 5621 |
gen_helper_neon_qdmulh_s32(tmp, tmp, tmp2); |
|
| 5641 |
gen_helper_neon_qdmulh_s32(tmp, cpu_env, tmp, tmp2);
|
|
| 5622 | 5642 |
} |
| 5623 | 5643 |
} else if (op == 13) {
|
| 5624 | 5644 |
if (size == 1) {
|
| 5625 |
gen_helper_neon_qrdmulh_s16(tmp, tmp, tmp2); |
|
| 5645 |
gen_helper_neon_qrdmulh_s16(tmp, cpu_env, tmp, tmp2);
|
|
| 5626 | 5646 |
} else {
|
| 5627 |
gen_helper_neon_qrdmulh_s32(tmp, tmp, tmp2); |
|
| 5647 |
gen_helper_neon_qrdmulh_s32(tmp, cpu_env, tmp, tmp2);
|
|
| 5628 | 5648 |
} |
| 5629 | 5649 |
} else if (op & 1) {
|
| 5630 | 5650 |
TCGv_ptr fpstatus = get_fpstatus_ptr(1); |
| ... | ... | |
| 5996 | 6016 |
break; |
| 5997 | 6017 |
case NEON_2RM_VQABS: |
| 5998 | 6018 |
switch (size) {
|
| 5999 |
case 0: gen_helper_neon_qabs_s8(tmp, tmp); break; |
|
| 6000 |
case 1: gen_helper_neon_qabs_s16(tmp, tmp); break; |
|
| 6001 |
case 2: gen_helper_neon_qabs_s32(tmp, tmp); break; |
|
| 6019 |
case 0: |
|
| 6020 |
gen_helper_neon_qabs_s8(tmp, cpu_env, tmp); |
|
| 6021 |
break; |
|
| 6022 |
case 1: |
|
| 6023 |
gen_helper_neon_qabs_s16(tmp, cpu_env, tmp); |
|
| 6024 |
break; |
|
| 6025 |
case 2: |
|
| 6026 |
gen_helper_neon_qabs_s32(tmp, cpu_env, tmp); |
|
| 6027 |
break; |
|
| 6002 | 6028 |
default: abort(); |
| 6003 | 6029 |
} |
| 6004 | 6030 |
break; |
| 6005 | 6031 |
case NEON_2RM_VQNEG: |
| 6006 | 6032 |
switch (size) {
|
| 6007 |
case 0: gen_helper_neon_qneg_s8(tmp, tmp); break; |
|
| 6008 |
case 1: gen_helper_neon_qneg_s16(tmp, tmp); break; |
|
| 6009 |
case 2: gen_helper_neon_qneg_s32(tmp, tmp); break; |
|
| 6033 |
case 0: |
|
| 6034 |
gen_helper_neon_qneg_s8(tmp, cpu_env, tmp); |
|
| 6035 |
break; |
|
| 6036 |
case 1: |
|
| 6037 |
gen_helper_neon_qneg_s16(tmp, cpu_env, tmp); |
|
| 6038 |
break; |
|
| 6039 |
case 2: |
|
| 6040 |
gen_helper_neon_qneg_s32(tmp, cpu_env, tmp); |
|
| 6041 |
break; |
|
| 6010 | 6042 |
default: abort(); |
| 6011 | 6043 |
} |
| 6012 | 6044 |
break; |
Also available in: Unified diff