1fcf5ef2aSThomas Huth /* 2fcf5ef2aSThomas Huth * PowerPC integer and vector emulation helpers for QEMU. 3fcf5ef2aSThomas Huth * 4fcf5ef2aSThomas Huth * Copyright (c) 2003-2007 Jocelyn Mayer 5fcf5ef2aSThomas Huth * 6fcf5ef2aSThomas Huth * This library is free software; you can redistribute it and/or 7fcf5ef2aSThomas Huth * modify it under the terms of the GNU Lesser General Public 8fcf5ef2aSThomas Huth * License as published by the Free Software Foundation; either 96bd039cdSChetan Pant * version 2.1 of the License, or (at your option) any later version. 10fcf5ef2aSThomas Huth * 11fcf5ef2aSThomas Huth * This library is distributed in the hope that it will be useful, 12fcf5ef2aSThomas Huth * but WITHOUT ANY WARRANTY; without even the implied warranty of 13fcf5ef2aSThomas Huth * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14fcf5ef2aSThomas Huth * Lesser General Public License for more details. 15fcf5ef2aSThomas Huth * 16fcf5ef2aSThomas Huth * You should have received a copy of the GNU Lesser General Public 17fcf5ef2aSThomas Huth * License along with this library; if not, see <http://www.gnu.org/licenses/>. 18fcf5ef2aSThomas Huth */ 19db725815SMarkus Armbruster 20fcf5ef2aSThomas Huth #include "qemu/osdep.h" 21fcf5ef2aSThomas Huth #include "cpu.h" 22fcf5ef2aSThomas Huth #include "internal.h" 23fcf5ef2aSThomas Huth #include "qemu/host-utils.h" 24db725815SMarkus Armbruster #include "qemu/main-loop.h" 258a05fd9aSRichard Henderson #include "qemu/log.h" 26fcf5ef2aSThomas Huth #include "exec/helper-proto.h" 27fcf5ef2aSThomas Huth #include "crypto/aes.h" 2824f91e81SAlex Bennée #include "fpu/softfloat.h" 293f74b632SRichard Henderson #include "qapi/error.h" 303f74b632SRichard Henderson #include "qemu/guest-random.h" 311015fcabSMatheus Ferst #include "tcg/tcg-gvec-desc.h" 32fcf5ef2aSThomas Huth 33fcf5ef2aSThomas Huth #include "helper_regs.h" 34fcf5ef2aSThomas Huth /*****************************************************************************/ 35fcf5ef2aSThomas Huth /* Fixed point operations helpers */ 36fcf5ef2aSThomas Huth 37f32899deSNikunj A Dadhania static inline void helper_update_ov_legacy(CPUPPCState *env, int ov) 38f32899deSNikunj A Dadhania { 39f32899deSNikunj A Dadhania if (unlikely(ov)) { 40f32899deSNikunj A Dadhania env->so = env->ov = 1; 41f32899deSNikunj A Dadhania } else { 42f32899deSNikunj A Dadhania env->ov = 0; 43f32899deSNikunj A Dadhania } 44f32899deSNikunj A Dadhania } 45f32899deSNikunj A Dadhania 46fcf5ef2aSThomas Huth target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb, 47fcf5ef2aSThomas Huth uint32_t oe) 48fcf5ef2aSThomas Huth { 49fcf5ef2aSThomas Huth uint64_t rt = 0; 50fcf5ef2aSThomas Huth int overflow = 0; 51fcf5ef2aSThomas Huth 52fcf5ef2aSThomas Huth uint64_t dividend = (uint64_t)ra << 32; 53fcf5ef2aSThomas Huth uint64_t divisor = (uint32_t)rb; 54fcf5ef2aSThomas Huth 55fcf5ef2aSThomas Huth if (unlikely(divisor == 0)) { 56fcf5ef2aSThomas Huth overflow = 1; 57fcf5ef2aSThomas Huth } else { 58fcf5ef2aSThomas Huth rt = dividend / divisor; 59fcf5ef2aSThomas Huth overflow = rt > UINT32_MAX; 60fcf5ef2aSThomas Huth } 61fcf5ef2aSThomas Huth 62fcf5ef2aSThomas Huth if (unlikely(overflow)) { 63fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 64fcf5ef2aSThomas Huth } 65fcf5ef2aSThomas Huth 66fcf5ef2aSThomas Huth if (oe) { 67f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 68fcf5ef2aSThomas Huth } 69fcf5ef2aSThomas Huth 70fcf5ef2aSThomas Huth return (target_ulong)rt; 71fcf5ef2aSThomas Huth } 72fcf5ef2aSThomas Huth 73fcf5ef2aSThomas Huth target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb, 74fcf5ef2aSThomas Huth uint32_t oe) 75fcf5ef2aSThomas Huth { 76fcf5ef2aSThomas Huth int64_t rt = 0; 77fcf5ef2aSThomas Huth int overflow = 0; 78fcf5ef2aSThomas Huth 79fcf5ef2aSThomas Huth int64_t dividend = (int64_t)ra << 32; 80fcf5ef2aSThomas Huth int64_t divisor = (int64_t)((int32_t)rb); 81fcf5ef2aSThomas Huth 82fcf5ef2aSThomas Huth if (unlikely((divisor == 0) || 83fcf5ef2aSThomas Huth ((divisor == -1ull) && (dividend == INT64_MIN)))) { 84fcf5ef2aSThomas Huth overflow = 1; 85fcf5ef2aSThomas Huth } else { 86fcf5ef2aSThomas Huth rt = dividend / divisor; 87fcf5ef2aSThomas Huth overflow = rt != (int32_t)rt; 88fcf5ef2aSThomas Huth } 89fcf5ef2aSThomas Huth 90fcf5ef2aSThomas Huth if (unlikely(overflow)) { 91fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 92fcf5ef2aSThomas Huth } 93fcf5ef2aSThomas Huth 94fcf5ef2aSThomas Huth if (oe) { 95f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 96fcf5ef2aSThomas Huth } 97fcf5ef2aSThomas Huth 98fcf5ef2aSThomas Huth return (target_ulong)rt; 99fcf5ef2aSThomas Huth } 100fcf5ef2aSThomas Huth 101fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 102fcf5ef2aSThomas Huth 103fcf5ef2aSThomas Huth uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe) 104fcf5ef2aSThomas Huth { 105fcf5ef2aSThomas Huth uint64_t rt = 0; 106fcf5ef2aSThomas Huth int overflow = 0; 107fcf5ef2aSThomas Huth 1089276a31cSLuis Pires if (unlikely(rb == 0 || ra >= rb)) { 1099276a31cSLuis Pires overflow = 1; 110fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 1119276a31cSLuis Pires } else { 1129276a31cSLuis Pires divu128(&rt, &ra, rb); 113fcf5ef2aSThomas Huth } 114fcf5ef2aSThomas Huth 115fcf5ef2aSThomas Huth if (oe) { 116f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 117fcf5ef2aSThomas Huth } 118fcf5ef2aSThomas Huth 119fcf5ef2aSThomas Huth return rt; 120fcf5ef2aSThomas Huth } 121fcf5ef2aSThomas Huth 122fcf5ef2aSThomas Huth uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe) 123fcf5ef2aSThomas Huth { 12440f3e79aSLuis Pires uint64_t rt = 0; 125fcf5ef2aSThomas Huth int64_t ra = (int64_t)rau; 126fcf5ef2aSThomas Huth int64_t rb = (int64_t)rbu; 1279276a31cSLuis Pires int overflow = 0; 128fcf5ef2aSThomas Huth 1299276a31cSLuis Pires if (unlikely(rb == 0 || uabs64(ra) >= uabs64(rb))) { 1309276a31cSLuis Pires overflow = 1; 131fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 1329276a31cSLuis Pires } else { 1339276a31cSLuis Pires divs128(&rt, &ra, rb); 134fcf5ef2aSThomas Huth } 135fcf5ef2aSThomas Huth 136fcf5ef2aSThomas Huth if (oe) { 137f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 138fcf5ef2aSThomas Huth } 139fcf5ef2aSThomas Huth 140fcf5ef2aSThomas Huth return rt; 141fcf5ef2aSThomas Huth } 142fcf5ef2aSThomas Huth 143fcf5ef2aSThomas Huth #endif 144fcf5ef2aSThomas Huth 145fcf5ef2aSThomas Huth 146fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 147fcf5ef2aSThomas Huth /* if x = 0xab, returns 0xababababababababa */ 148fcf5ef2aSThomas Huth #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff)) 149fcf5ef2aSThomas Huth 150b6cb41b2SDavid Gibson /* 151b6cb41b2SDavid Gibson * subtract 1 from each byte, and with inverse, check if MSB is set at each 152fcf5ef2aSThomas Huth * byte. 153fcf5ef2aSThomas Huth * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80 154fcf5ef2aSThomas Huth * (0xFF & 0xFF) & 0x80 = 0x80 (zero found) 155fcf5ef2aSThomas Huth */ 156fcf5ef2aSThomas Huth #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80)) 157fcf5ef2aSThomas Huth 158fcf5ef2aSThomas Huth /* When you XOR the pattern and there is a match, that byte will be zero */ 159fcf5ef2aSThomas Huth #define hasvalue(x, n) (haszero((x) ^ pattern(n))) 160fcf5ef2aSThomas Huth 161fcf5ef2aSThomas Huth uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb) 162fcf5ef2aSThomas Huth { 163efa73196SNikunj A Dadhania return hasvalue(rb, ra) ? CRF_GT : 0; 164fcf5ef2aSThomas Huth } 165fcf5ef2aSThomas Huth 166fcf5ef2aSThomas Huth #undef pattern 167fcf5ef2aSThomas Huth #undef haszero 168fcf5ef2aSThomas Huth #undef hasvalue 169fcf5ef2aSThomas Huth 170b6cb41b2SDavid Gibson /* 1713f74b632SRichard Henderson * Return a random number. 172fcf5ef2aSThomas Huth */ 1733f74b632SRichard Henderson uint64_t helper_darn32(void) 174fcf5ef2aSThomas Huth { 1753f74b632SRichard Henderson Error *err = NULL; 1763f74b632SRichard Henderson uint32_t ret; 1773f74b632SRichard Henderson 1783f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1793f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1803f74b632SRichard Henderson error_get_pretty(err)); 1813f74b632SRichard Henderson error_free(err); 182fcf5ef2aSThomas Huth return -1; 183fcf5ef2aSThomas Huth } 184fcf5ef2aSThomas Huth 1853f74b632SRichard Henderson return ret; 1863f74b632SRichard Henderson } 1873f74b632SRichard Henderson 1883f74b632SRichard Henderson uint64_t helper_darn64(void) 189fcf5ef2aSThomas Huth { 1903f74b632SRichard Henderson Error *err = NULL; 1913f74b632SRichard Henderson uint64_t ret; 1923f74b632SRichard Henderson 1933f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1943f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1953f74b632SRichard Henderson error_get_pretty(err)); 1963f74b632SRichard Henderson error_free(err); 197fcf5ef2aSThomas Huth return -1; 198fcf5ef2aSThomas Huth } 199fcf5ef2aSThomas Huth 2003f74b632SRichard Henderson return ret; 2013f74b632SRichard Henderson } 202fcf5ef2aSThomas Huth 203fcf5ef2aSThomas Huth uint64_t helper_bpermd(uint64_t rs, uint64_t rb) 204fcf5ef2aSThomas Huth { 205fcf5ef2aSThomas Huth int i; 206fcf5ef2aSThomas Huth uint64_t ra = 0; 207fcf5ef2aSThomas Huth 208fcf5ef2aSThomas Huth for (i = 0; i < 8; i++) { 209fcf5ef2aSThomas Huth int index = (rs >> (i * 8)) & 0xFF; 210fcf5ef2aSThomas Huth if (index < 64) { 211a6a444a8SCédric Le Goater if (rb & PPC_BIT(index)) { 212fcf5ef2aSThomas Huth ra |= 1 << i; 213fcf5ef2aSThomas Huth } 214fcf5ef2aSThomas Huth } 215fcf5ef2aSThomas Huth } 216fcf5ef2aSThomas Huth return ra; 217fcf5ef2aSThomas Huth } 218fcf5ef2aSThomas Huth 219fcf5ef2aSThomas Huth #endif 220fcf5ef2aSThomas Huth 221fcf5ef2aSThomas Huth target_ulong helper_cmpb(target_ulong rs, target_ulong rb) 222fcf5ef2aSThomas Huth { 223fcf5ef2aSThomas Huth target_ulong mask = 0xff; 224fcf5ef2aSThomas Huth target_ulong ra = 0; 225fcf5ef2aSThomas Huth int i; 226fcf5ef2aSThomas Huth 227fcf5ef2aSThomas Huth for (i = 0; i < sizeof(target_ulong); i++) { 228fcf5ef2aSThomas Huth if ((rs & mask) == (rb & mask)) { 229fcf5ef2aSThomas Huth ra |= mask; 230fcf5ef2aSThomas Huth } 231fcf5ef2aSThomas Huth mask <<= 8; 232fcf5ef2aSThomas Huth } 233fcf5ef2aSThomas Huth return ra; 234fcf5ef2aSThomas Huth } 235fcf5ef2aSThomas Huth 236fcf5ef2aSThomas Huth /* shift right arithmetic helper */ 237fcf5ef2aSThomas Huth target_ulong helper_sraw(CPUPPCState *env, target_ulong value, 238fcf5ef2aSThomas Huth target_ulong shift) 239fcf5ef2aSThomas Huth { 240fcf5ef2aSThomas Huth int32_t ret; 241fcf5ef2aSThomas Huth 242fcf5ef2aSThomas Huth if (likely(!(shift & 0x20))) { 243fcf5ef2aSThomas Huth if (likely((uint32_t)shift != 0)) { 244fcf5ef2aSThomas Huth shift &= 0x1f; 245fcf5ef2aSThomas Huth ret = (int32_t)value >> shift; 246fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) { 247af1c259fSSandipan Das env->ca32 = env->ca = 0; 248fcf5ef2aSThomas Huth } else { 249af1c259fSSandipan Das env->ca32 = env->ca = 1; 250fcf5ef2aSThomas Huth } 251fcf5ef2aSThomas Huth } else { 252fcf5ef2aSThomas Huth ret = (int32_t)value; 253af1c259fSSandipan Das env->ca32 = env->ca = 0; 254fcf5ef2aSThomas Huth } 255fcf5ef2aSThomas Huth } else { 256fcf5ef2aSThomas Huth ret = (int32_t)value >> 31; 257af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 258fcf5ef2aSThomas Huth } 259fcf5ef2aSThomas Huth return (target_long)ret; 260fcf5ef2aSThomas Huth } 261fcf5ef2aSThomas Huth 262fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 263fcf5ef2aSThomas Huth target_ulong helper_srad(CPUPPCState *env, target_ulong value, 264fcf5ef2aSThomas Huth target_ulong shift) 265fcf5ef2aSThomas Huth { 266fcf5ef2aSThomas Huth int64_t ret; 267fcf5ef2aSThomas Huth 268fcf5ef2aSThomas Huth if (likely(!(shift & 0x40))) { 269fcf5ef2aSThomas Huth if (likely((uint64_t)shift != 0)) { 270fcf5ef2aSThomas Huth shift &= 0x3f; 271fcf5ef2aSThomas Huth ret = (int64_t)value >> shift; 272fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) { 273af1c259fSSandipan Das env->ca32 = env->ca = 0; 274fcf5ef2aSThomas Huth } else { 275af1c259fSSandipan Das env->ca32 = env->ca = 1; 276fcf5ef2aSThomas Huth } 277fcf5ef2aSThomas Huth } else { 278fcf5ef2aSThomas Huth ret = (int64_t)value; 279af1c259fSSandipan Das env->ca32 = env->ca = 0; 280fcf5ef2aSThomas Huth } 281fcf5ef2aSThomas Huth } else { 282fcf5ef2aSThomas Huth ret = (int64_t)value >> 63; 283af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 284fcf5ef2aSThomas Huth } 285fcf5ef2aSThomas Huth return ret; 286fcf5ef2aSThomas Huth } 287fcf5ef2aSThomas Huth #endif 288fcf5ef2aSThomas Huth 289fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 290fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 291fcf5ef2aSThomas Huth { 29279770002SRichard Henderson /* Note that we don't fold past bytes */ 293fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 294fcf5ef2aSThomas Huth 0x5555555555555555ULL); 295fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 296fcf5ef2aSThomas Huth 0x3333333333333333ULL); 297fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 298fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 299fcf5ef2aSThomas Huth return val; 300fcf5ef2aSThomas Huth } 301fcf5ef2aSThomas Huth 302fcf5ef2aSThomas Huth target_ulong helper_popcntw(target_ulong val) 303fcf5ef2aSThomas Huth { 30479770002SRichard Henderson /* Note that we don't fold past words. */ 305fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 306fcf5ef2aSThomas Huth 0x5555555555555555ULL); 307fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 308fcf5ef2aSThomas Huth 0x3333333333333333ULL); 309fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 310fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 311fcf5ef2aSThomas Huth val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) & 312fcf5ef2aSThomas Huth 0x00ff00ff00ff00ffULL); 313fcf5ef2aSThomas Huth val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) & 314fcf5ef2aSThomas Huth 0x0000ffff0000ffffULL); 315fcf5ef2aSThomas Huth return val; 316fcf5ef2aSThomas Huth } 317fcf5ef2aSThomas Huth #else 318fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 319fcf5ef2aSThomas Huth { 32079770002SRichard Henderson /* Note that we don't fold past bytes */ 321fcf5ef2aSThomas Huth val = (val & 0x55555555) + ((val >> 1) & 0x55555555); 322fcf5ef2aSThomas Huth val = (val & 0x33333333) + ((val >> 2) & 0x33333333); 323fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f); 324fcf5ef2aSThomas Huth return val; 325fcf5ef2aSThomas Huth } 326fcf5ef2aSThomas Huth #endif 327fcf5ef2aSThomas Huth 3286e0bbc40SMatheus Ferst uint64_t helper_CFUGED(uint64_t src, uint64_t mask) 32989ccd7dcSMatheus Ferst { 33089ccd7dcSMatheus Ferst /* 33189ccd7dcSMatheus Ferst * Instead of processing the mask bit-by-bit from the most significant to 33289ccd7dcSMatheus Ferst * the least significant bit, as described in PowerISA, we'll handle it in 33389ccd7dcSMatheus Ferst * blocks of 'n' zeros/ones from LSB to MSB. To avoid the decision to use 33489ccd7dcSMatheus Ferst * ctz or cto, we negate the mask at the end of the loop. 33589ccd7dcSMatheus Ferst */ 33689ccd7dcSMatheus Ferst target_ulong m, left = 0, right = 0; 33789ccd7dcSMatheus Ferst unsigned int n, i = 64; 33889ccd7dcSMatheus Ferst bool bit = false; /* tracks if we are processing zeros or ones */ 33989ccd7dcSMatheus Ferst 34089ccd7dcSMatheus Ferst if (mask == 0 || mask == -1) { 34189ccd7dcSMatheus Ferst return src; 34289ccd7dcSMatheus Ferst } 34389ccd7dcSMatheus Ferst 34489ccd7dcSMatheus Ferst /* Processes the mask in blocks, from LSB to MSB */ 34589ccd7dcSMatheus Ferst while (i) { 34689ccd7dcSMatheus Ferst /* Find how many bits we should take */ 34789ccd7dcSMatheus Ferst n = ctz64(mask); 34889ccd7dcSMatheus Ferst if (n > i) { 34989ccd7dcSMatheus Ferst n = i; 35089ccd7dcSMatheus Ferst } 35189ccd7dcSMatheus Ferst 35289ccd7dcSMatheus Ferst /* 35389ccd7dcSMatheus Ferst * Extracts 'n' trailing bits of src and put them on the leading 'n' 35489ccd7dcSMatheus Ferst * bits of 'right' or 'left', pushing down the previously extracted 35589ccd7dcSMatheus Ferst * values. 35689ccd7dcSMatheus Ferst */ 35789ccd7dcSMatheus Ferst m = (1ll << n) - 1; 35889ccd7dcSMatheus Ferst if (bit) { 35989ccd7dcSMatheus Ferst right = ror64(right | (src & m), n); 36089ccd7dcSMatheus Ferst } else { 36189ccd7dcSMatheus Ferst left = ror64(left | (src & m), n); 36289ccd7dcSMatheus Ferst } 36389ccd7dcSMatheus Ferst 36489ccd7dcSMatheus Ferst /* 36589ccd7dcSMatheus Ferst * Discards the processed bits from 'src' and 'mask'. Note that we are 36689ccd7dcSMatheus Ferst * removing 'n' trailing zeros from 'mask', but the logical shift will 36789ccd7dcSMatheus Ferst * add 'n' leading zeros back, so the population count of 'mask' is kept 36889ccd7dcSMatheus Ferst * the same. 36989ccd7dcSMatheus Ferst */ 37089ccd7dcSMatheus Ferst src >>= n; 37189ccd7dcSMatheus Ferst mask >>= n; 37289ccd7dcSMatheus Ferst i -= n; 37389ccd7dcSMatheus Ferst bit = !bit; 37489ccd7dcSMatheus Ferst mask = ~mask; 37589ccd7dcSMatheus Ferst } 37689ccd7dcSMatheus Ferst 37789ccd7dcSMatheus Ferst /* 37889ccd7dcSMatheus Ferst * At the end, right was ror'ed ctpop(mask) times. To put it back in place, 37989ccd7dcSMatheus Ferst * we'll shift it more 64-ctpop(mask) times. 38089ccd7dcSMatheus Ferst */ 38189ccd7dcSMatheus Ferst if (bit) { 38289ccd7dcSMatheus Ferst n = ctpop64(mask); 38389ccd7dcSMatheus Ferst } else { 38489ccd7dcSMatheus Ferst n = 64 - ctpop64(mask); 38589ccd7dcSMatheus Ferst } 38689ccd7dcSMatheus Ferst 38789ccd7dcSMatheus Ferst return left | (right >> n); 38889ccd7dcSMatheus Ferst } 38989ccd7dcSMatheus Ferst 39021ba6e58SMatheus Ferst uint64_t helper_PDEPD(uint64_t src, uint64_t mask) 39121ba6e58SMatheus Ferst { 39221ba6e58SMatheus Ferst int i, o; 39321ba6e58SMatheus Ferst uint64_t result = 0; 39421ba6e58SMatheus Ferst 39521ba6e58SMatheus Ferst if (mask == -1) { 39621ba6e58SMatheus Ferst return src; 39721ba6e58SMatheus Ferst } 39821ba6e58SMatheus Ferst 39921ba6e58SMatheus Ferst for (i = 0; mask != 0; i++) { 40021ba6e58SMatheus Ferst o = ctz64(mask); 40121ba6e58SMatheus Ferst mask &= mask - 1; 40221ba6e58SMatheus Ferst result |= ((src >> i) & 1) << o; 40321ba6e58SMatheus Ferst } 40421ba6e58SMatheus Ferst 40521ba6e58SMatheus Ferst return result; 40621ba6e58SMatheus Ferst } 4078bdb7606SMatheus Ferst 4088bdb7606SMatheus Ferst uint64_t helper_PEXTD(uint64_t src, uint64_t mask) 4098bdb7606SMatheus Ferst { 4108bdb7606SMatheus Ferst int i, o; 4118bdb7606SMatheus Ferst uint64_t result = 0; 4128bdb7606SMatheus Ferst 4138bdb7606SMatheus Ferst if (mask == -1) { 4148bdb7606SMatheus Ferst return src; 4158bdb7606SMatheus Ferst } 4168bdb7606SMatheus Ferst 4178bdb7606SMatheus Ferst for (o = 0; mask != 0; o++) { 4188bdb7606SMatheus Ferst i = ctz64(mask); 4198bdb7606SMatheus Ferst mask &= mask - 1; 4208bdb7606SMatheus Ferst result |= ((src >> i) & 1) << o; 4218bdb7606SMatheus Ferst } 4228bdb7606SMatheus Ferst 4238bdb7606SMatheus Ferst return result; 4248bdb7606SMatheus Ferst } 42521ba6e58SMatheus Ferst 426fcf5ef2aSThomas Huth /*****************************************************************************/ 427fcf5ef2aSThomas Huth /* Altivec extension helpers */ 428fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 429fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 430fcf5ef2aSThomas Huth for (index = 0; index < ARRAY_SIZE(r->element); index++) 431fcf5ef2aSThomas Huth #else 432fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 433fcf5ef2aSThomas Huth for (index = ARRAY_SIZE(r->element) - 1; index >= 0; index--) 434fcf5ef2aSThomas Huth #endif 435fcf5ef2aSThomas Huth 436fcf5ef2aSThomas Huth /* Saturating arithmetic helpers. */ 437fcf5ef2aSThomas Huth #define SATCVT(from, to, from_type, to_type, min, max) \ 438fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 439fcf5ef2aSThomas Huth { \ 440fcf5ef2aSThomas Huth to_type r; \ 441fcf5ef2aSThomas Huth \ 442fcf5ef2aSThomas Huth if (x < (from_type)min) { \ 443fcf5ef2aSThomas Huth r = min; \ 444fcf5ef2aSThomas Huth *sat = 1; \ 445fcf5ef2aSThomas Huth } else if (x > (from_type)max) { \ 446fcf5ef2aSThomas Huth r = max; \ 447fcf5ef2aSThomas Huth *sat = 1; \ 448fcf5ef2aSThomas Huth } else { \ 449fcf5ef2aSThomas Huth r = x; \ 450fcf5ef2aSThomas Huth } \ 451fcf5ef2aSThomas Huth return r; \ 452fcf5ef2aSThomas Huth } 453fcf5ef2aSThomas Huth #define SATCVTU(from, to, from_type, to_type, min, max) \ 454fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 455fcf5ef2aSThomas Huth { \ 456fcf5ef2aSThomas Huth to_type r; \ 457fcf5ef2aSThomas Huth \ 458fcf5ef2aSThomas Huth if (x > (from_type)max) { \ 459fcf5ef2aSThomas Huth r = max; \ 460fcf5ef2aSThomas Huth *sat = 1; \ 461fcf5ef2aSThomas Huth } else { \ 462fcf5ef2aSThomas Huth r = x; \ 463fcf5ef2aSThomas Huth } \ 464fcf5ef2aSThomas Huth return r; \ 465fcf5ef2aSThomas Huth } 466fcf5ef2aSThomas Huth SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX) 467fcf5ef2aSThomas Huth SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX) 468fcf5ef2aSThomas Huth SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX) 469fcf5ef2aSThomas Huth 470fcf5ef2aSThomas Huth SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX) 471fcf5ef2aSThomas Huth SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX) 472fcf5ef2aSThomas Huth SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX) 473fcf5ef2aSThomas Huth SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX) 474fcf5ef2aSThomas Huth SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX) 475fcf5ef2aSThomas Huth SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX) 476fcf5ef2aSThomas Huth #undef SATCVT 477fcf5ef2aSThomas Huth #undef SATCVTU 478fcf5ef2aSThomas Huth 479dedfaac7SRichard Henderson void helper_mtvscr(CPUPPCState *env, uint32_t vscr) 480fcf5ef2aSThomas Huth { 481c19940dbSBruno Larsen (billionai) ppc_store_vscr(env, vscr); 482fcf5ef2aSThomas Huth } 483fcf5ef2aSThomas Huth 484cc2b90d7SRichard Henderson uint32_t helper_mfvscr(CPUPPCState *env) 485cc2b90d7SRichard Henderson { 486c19940dbSBruno Larsen (billionai) return ppc_get_vscr(env); 487cc2b90d7SRichard Henderson } 488cc2b90d7SRichard Henderson 4896175f5a0SRichard Henderson static inline void set_vscr_sat(CPUPPCState *env) 4906175f5a0SRichard Henderson { 4919b5b74daSRichard Henderson /* The choice of non-zero value is arbitrary. */ 4929b5b74daSRichard Henderson env->vscr_sat.u32[0] = 1; 4936175f5a0SRichard Henderson } 4946175f5a0SRichard Henderson 495fcf5ef2aSThomas Huth void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 496fcf5ef2aSThomas Huth { 497fcf5ef2aSThomas Huth int i; 498fcf5ef2aSThomas Huth 499fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 500fcf5ef2aSThomas Huth r->u32[i] = ~a->u32[i] < b->u32[i]; 501fcf5ef2aSThomas Huth } 502fcf5ef2aSThomas Huth } 503fcf5ef2aSThomas Huth 504fcf5ef2aSThomas Huth /* vprtybw */ 505fcf5ef2aSThomas Huth void helper_vprtybw(ppc_avr_t *r, ppc_avr_t *b) 506fcf5ef2aSThomas Huth { 507fcf5ef2aSThomas Huth int i; 508fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 509fcf5ef2aSThomas Huth uint64_t res = b->u32[i] ^ (b->u32[i] >> 16); 510fcf5ef2aSThomas Huth res ^= res >> 8; 511fcf5ef2aSThomas Huth r->u32[i] = res & 1; 512fcf5ef2aSThomas Huth } 513fcf5ef2aSThomas Huth } 514fcf5ef2aSThomas Huth 515fcf5ef2aSThomas Huth /* vprtybd */ 516fcf5ef2aSThomas Huth void helper_vprtybd(ppc_avr_t *r, ppc_avr_t *b) 517fcf5ef2aSThomas Huth { 518fcf5ef2aSThomas Huth int i; 519fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 520fcf5ef2aSThomas Huth uint64_t res = b->u64[i] ^ (b->u64[i] >> 32); 521fcf5ef2aSThomas Huth res ^= res >> 16; 522fcf5ef2aSThomas Huth res ^= res >> 8; 523fcf5ef2aSThomas Huth r->u64[i] = res & 1; 524fcf5ef2aSThomas Huth } 525fcf5ef2aSThomas Huth } 526fcf5ef2aSThomas Huth 527fcf5ef2aSThomas Huth /* vprtybq */ 528fcf5ef2aSThomas Huth void helper_vprtybq(ppc_avr_t *r, ppc_avr_t *b) 529fcf5ef2aSThomas Huth { 530fcf5ef2aSThomas Huth uint64_t res = b->u64[0] ^ b->u64[1]; 531fcf5ef2aSThomas Huth res ^= res >> 32; 532fcf5ef2aSThomas Huth res ^= res >> 16; 533fcf5ef2aSThomas Huth res ^= res >> 8; 5343c385a93SMark Cave-Ayland r->VsrD(1) = res & 1; 5353c385a93SMark Cave-Ayland r->VsrD(0) = 0; 536fcf5ef2aSThomas Huth } 537fcf5ef2aSThomas Huth 538fcf5ef2aSThomas Huth #define VARITHFP(suffix, func) \ 539fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 540fcf5ef2aSThomas Huth ppc_avr_t *b) \ 541fcf5ef2aSThomas Huth { \ 542fcf5ef2aSThomas Huth int i; \ 543fcf5ef2aSThomas Huth \ 54405ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 54505ee3e8aSMark Cave-Ayland r->f32[i] = func(a->f32[i], b->f32[i], &env->vec_status); \ 546fcf5ef2aSThomas Huth } \ 547fcf5ef2aSThomas Huth } 548fcf5ef2aSThomas Huth VARITHFP(addfp, float32_add) 549fcf5ef2aSThomas Huth VARITHFP(subfp, float32_sub) 550fcf5ef2aSThomas Huth VARITHFP(minfp, float32_min) 551fcf5ef2aSThomas Huth VARITHFP(maxfp, float32_max) 552fcf5ef2aSThomas Huth #undef VARITHFP 553fcf5ef2aSThomas Huth 554fcf5ef2aSThomas Huth #define VARITHFPFMA(suffix, type) \ 555fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 556fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) \ 557fcf5ef2aSThomas Huth { \ 558fcf5ef2aSThomas Huth int i; \ 55905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 56005ee3e8aSMark Cave-Ayland r->f32[i] = float32_muladd(a->f32[i], c->f32[i], b->f32[i], \ 561fcf5ef2aSThomas Huth type, &env->vec_status); \ 562fcf5ef2aSThomas Huth } \ 563fcf5ef2aSThomas Huth } 564fcf5ef2aSThomas Huth VARITHFPFMA(maddfp, 0); 565fcf5ef2aSThomas Huth VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c); 566fcf5ef2aSThomas Huth #undef VARITHFPFMA 567fcf5ef2aSThomas Huth 568fcf5ef2aSThomas Huth #define VARITHSAT_CASE(type, op, cvt, element) \ 569fcf5ef2aSThomas Huth { \ 570fcf5ef2aSThomas Huth type result = (type)a->element[i] op (type)b->element[i]; \ 571fcf5ef2aSThomas Huth r->element[i] = cvt(result, &sat); \ 572fcf5ef2aSThomas Huth } 573fcf5ef2aSThomas Huth 574fcf5ef2aSThomas Huth #define VARITHSAT_DO(name, op, optype, cvt, element) \ 575fb11ae7dSRichard Henderson void helper_v##name(ppc_avr_t *r, ppc_avr_t *vscr_sat, \ 576fb11ae7dSRichard Henderson ppc_avr_t *a, ppc_avr_t *b, uint32_t desc) \ 577fcf5ef2aSThomas Huth { \ 578fcf5ef2aSThomas Huth int sat = 0; \ 579fcf5ef2aSThomas Huth int i; \ 580fcf5ef2aSThomas Huth \ 581fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 582fcf5ef2aSThomas Huth VARITHSAT_CASE(optype, op, cvt, element); \ 583fcf5ef2aSThomas Huth } \ 584fcf5ef2aSThomas Huth if (sat) { \ 585fb11ae7dSRichard Henderson vscr_sat->u32[0] = 1; \ 586fcf5ef2aSThomas Huth } \ 587fcf5ef2aSThomas Huth } 588fcf5ef2aSThomas Huth #define VARITHSAT_SIGNED(suffix, element, optype, cvt) \ 589fcf5ef2aSThomas Huth VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element) \ 590fcf5ef2aSThomas Huth VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element) 591fcf5ef2aSThomas Huth #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt) \ 592fcf5ef2aSThomas Huth VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element) \ 593fcf5ef2aSThomas Huth VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element) 594fcf5ef2aSThomas Huth VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb) 595fcf5ef2aSThomas Huth VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh) 596fcf5ef2aSThomas Huth VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw) 597fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub) 598fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh) 599fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw) 600fcf5ef2aSThomas Huth #undef VARITHSAT_CASE 601fcf5ef2aSThomas Huth #undef VARITHSAT_DO 602fcf5ef2aSThomas Huth #undef VARITHSAT_SIGNED 603fcf5ef2aSThomas Huth #undef VARITHSAT_UNSIGNED 604fcf5ef2aSThomas Huth 605fcf5ef2aSThomas Huth #define VAVG_DO(name, element, etype) \ 606fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 607fcf5ef2aSThomas Huth { \ 608fcf5ef2aSThomas Huth int i; \ 609fcf5ef2aSThomas Huth \ 610fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 611fcf5ef2aSThomas Huth etype x = (etype)a->element[i] + (etype)b->element[i] + 1; \ 612fcf5ef2aSThomas Huth r->element[i] = x >> 1; \ 613fcf5ef2aSThomas Huth } \ 614fcf5ef2aSThomas Huth } 615fcf5ef2aSThomas Huth 616fcf5ef2aSThomas Huth #define VAVG(type, signed_element, signed_type, unsigned_element, \ 617fcf5ef2aSThomas Huth unsigned_type) \ 618fcf5ef2aSThomas Huth VAVG_DO(avgs##type, signed_element, signed_type) \ 619fcf5ef2aSThomas Huth VAVG_DO(avgu##type, unsigned_element, unsigned_type) 620fcf5ef2aSThomas Huth VAVG(b, s8, int16_t, u8, uint16_t) 621fcf5ef2aSThomas Huth VAVG(h, s16, int32_t, u16, uint32_t) 622fcf5ef2aSThomas Huth VAVG(w, s32, int64_t, u32, uint64_t) 623fcf5ef2aSThomas Huth #undef VAVG_DO 624fcf5ef2aSThomas Huth #undef VAVG 625fcf5ef2aSThomas Huth 626fcf5ef2aSThomas Huth #define VABSDU_DO(name, element) \ 627fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 628fcf5ef2aSThomas Huth { \ 629fcf5ef2aSThomas Huth int i; \ 630fcf5ef2aSThomas Huth \ 631fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 632fcf5ef2aSThomas Huth r->element[i] = (a->element[i] > b->element[i]) ? \ 633fcf5ef2aSThomas Huth (a->element[i] - b->element[i]) : \ 634fcf5ef2aSThomas Huth (b->element[i] - a->element[i]); \ 635fcf5ef2aSThomas Huth } \ 636fcf5ef2aSThomas Huth } 637fcf5ef2aSThomas Huth 638b6cb41b2SDavid Gibson /* 639b6cb41b2SDavid Gibson * VABSDU - Vector absolute difference unsigned 640fcf5ef2aSThomas Huth * name - instruction mnemonic suffix (b: byte, h: halfword, w: word) 641fcf5ef2aSThomas Huth * element - element type to access from vector 642fcf5ef2aSThomas Huth */ 643fcf5ef2aSThomas Huth #define VABSDU(type, element) \ 644fcf5ef2aSThomas Huth VABSDU_DO(absdu##type, element) 645fcf5ef2aSThomas Huth VABSDU(b, u8) 646fcf5ef2aSThomas Huth VABSDU(h, u16) 647fcf5ef2aSThomas Huth VABSDU(w, u32) 648fcf5ef2aSThomas Huth #undef VABSDU_DO 649fcf5ef2aSThomas Huth #undef VABSDU 650fcf5ef2aSThomas Huth 651fcf5ef2aSThomas Huth #define VCF(suffix, cvt, element) \ 652fcf5ef2aSThomas Huth void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \ 653fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 654fcf5ef2aSThomas Huth { \ 655fcf5ef2aSThomas Huth int i; \ 656fcf5ef2aSThomas Huth \ 65705ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 658fcf5ef2aSThomas Huth float32 t = cvt(b->element[i], &env->vec_status); \ 65905ee3e8aSMark Cave-Ayland r->f32[i] = float32_scalbn(t, -uim, &env->vec_status); \ 660fcf5ef2aSThomas Huth } \ 661fcf5ef2aSThomas Huth } 662fcf5ef2aSThomas Huth VCF(ux, uint32_to_float32, u32) 663fcf5ef2aSThomas Huth VCF(sx, int32_to_float32, s32) 664fcf5ef2aSThomas Huth #undef VCF 665fcf5ef2aSThomas Huth 666eb936dc0SMatheus Ferst #define VCMPNEZ(NAME, ELEM) \ 667eb936dc0SMatheus Ferst void helper_##NAME(ppc_vsr_t *t, ppc_vsr_t *a, ppc_vsr_t *b, uint32_t desc) \ 668fcf5ef2aSThomas Huth { \ 669eb936dc0SMatheus Ferst for (int i = 0; i < ARRAY_SIZE(t->ELEM); i++) { \ 670eb936dc0SMatheus Ferst t->ELEM[i] = ((a->ELEM[i] == 0) || (b->ELEM[i] == 0) || \ 671eb936dc0SMatheus Ferst (a->ELEM[i] != b->ELEM[i])) ? -1 : 0; \ 672fcf5ef2aSThomas Huth } \ 673fcf5ef2aSThomas Huth } 674eb936dc0SMatheus Ferst VCMPNEZ(VCMPNEZB, u8) 675eb936dc0SMatheus Ferst VCMPNEZ(VCMPNEZH, u16) 676eb936dc0SMatheus Ferst VCMPNEZ(VCMPNEZW, u32) 677eb936dc0SMatheus Ferst #undef VCMPNEZ 678fcf5ef2aSThomas Huth 679fcf5ef2aSThomas Huth #define VCMPFP_DO(suffix, compare, order, record) \ 680fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 681fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 682fcf5ef2aSThomas Huth { \ 683fcf5ef2aSThomas Huth uint32_t ones = (uint32_t)-1; \ 684fcf5ef2aSThomas Huth uint32_t all = ones; \ 685fcf5ef2aSThomas Huth uint32_t none = 0; \ 686fcf5ef2aSThomas Huth int i; \ 687fcf5ef2aSThomas Huth \ 68805ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 689fcf5ef2aSThomas Huth uint32_t result; \ 69071bfd65cSRichard Henderson FloatRelation rel = \ 69171bfd65cSRichard Henderson float32_compare_quiet(a->f32[i], b->f32[i], \ 692fcf5ef2aSThomas Huth &env->vec_status); \ 693fcf5ef2aSThomas Huth if (rel == float_relation_unordered) { \ 694fcf5ef2aSThomas Huth result = 0; \ 695fcf5ef2aSThomas Huth } else if (rel compare order) { \ 696fcf5ef2aSThomas Huth result = ones; \ 697fcf5ef2aSThomas Huth } else { \ 698fcf5ef2aSThomas Huth result = 0; \ 699fcf5ef2aSThomas Huth } \ 700fcf5ef2aSThomas Huth r->u32[i] = result; \ 701fcf5ef2aSThomas Huth all &= result; \ 702fcf5ef2aSThomas Huth none |= result; \ 703fcf5ef2aSThomas Huth } \ 704fcf5ef2aSThomas Huth if (record) { \ 705fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 706fcf5ef2aSThomas Huth } \ 707fcf5ef2aSThomas Huth } 708fcf5ef2aSThomas Huth #define VCMPFP(suffix, compare, order) \ 709fcf5ef2aSThomas Huth VCMPFP_DO(suffix, compare, order, 0) \ 710fcf5ef2aSThomas Huth VCMPFP_DO(suffix##_dot, compare, order, 1) 711fcf5ef2aSThomas Huth VCMPFP(eqfp, ==, float_relation_equal) 712fcf5ef2aSThomas Huth VCMPFP(gefp, !=, float_relation_less) 713fcf5ef2aSThomas Huth VCMPFP(gtfp, ==, float_relation_greater) 714fcf5ef2aSThomas Huth #undef VCMPFP_DO 715fcf5ef2aSThomas Huth #undef VCMPFP 716fcf5ef2aSThomas Huth 717fcf5ef2aSThomas Huth static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r, 718fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b, int record) 719fcf5ef2aSThomas Huth { 720fcf5ef2aSThomas Huth int i; 721fcf5ef2aSThomas Huth int all_in = 0; 722fcf5ef2aSThomas Huth 72305ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 72471bfd65cSRichard Henderson FloatRelation le_rel = float32_compare_quiet(a->f32[i], b->f32[i], 72505ee3e8aSMark Cave-Ayland &env->vec_status); 726fcf5ef2aSThomas Huth if (le_rel == float_relation_unordered) { 727fcf5ef2aSThomas Huth r->u32[i] = 0xc0000000; 728fcf5ef2aSThomas Huth all_in = 1; 729fcf5ef2aSThomas Huth } else { 73005ee3e8aSMark Cave-Ayland float32 bneg = float32_chs(b->f32[i]); 73171bfd65cSRichard Henderson FloatRelation ge_rel = float32_compare_quiet(a->f32[i], bneg, 73205ee3e8aSMark Cave-Ayland &env->vec_status); 733fcf5ef2aSThomas Huth int le = le_rel != float_relation_greater; 734fcf5ef2aSThomas Huth int ge = ge_rel != float_relation_less; 735fcf5ef2aSThomas Huth 736fcf5ef2aSThomas Huth r->u32[i] = ((!le) << 31) | ((!ge) << 30); 737fcf5ef2aSThomas Huth all_in |= (!le | !ge); 738fcf5ef2aSThomas Huth } 739fcf5ef2aSThomas Huth } 740fcf5ef2aSThomas Huth if (record) { 741fcf5ef2aSThomas Huth env->crf[6] = (all_in == 0) << 1; 742fcf5ef2aSThomas Huth } 743fcf5ef2aSThomas Huth } 744fcf5ef2aSThomas Huth 745fcf5ef2aSThomas Huth void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 746fcf5ef2aSThomas Huth { 747fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 0); 748fcf5ef2aSThomas Huth } 749fcf5ef2aSThomas Huth 750fcf5ef2aSThomas Huth void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 751fcf5ef2aSThomas Huth ppc_avr_t *b) 752fcf5ef2aSThomas Huth { 753fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 1); 754fcf5ef2aSThomas Huth } 755fcf5ef2aSThomas Huth 756fcf5ef2aSThomas Huth #define VCT(suffix, satcvt, element) \ 757fcf5ef2aSThomas Huth void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r, \ 758fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 759fcf5ef2aSThomas Huth { \ 760fcf5ef2aSThomas Huth int i; \ 761fcf5ef2aSThomas Huth int sat = 0; \ 762fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 763fcf5ef2aSThomas Huth \ 764fcf5ef2aSThomas Huth set_float_rounding_mode(float_round_to_zero, &s); \ 76505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 76605ee3e8aSMark Cave-Ayland if (float32_is_any_nan(b->f32[i])) { \ 767fcf5ef2aSThomas Huth r->element[i] = 0; \ 768fcf5ef2aSThomas Huth } else { \ 76905ee3e8aSMark Cave-Ayland float64 t = float32_to_float64(b->f32[i], &s); \ 770fcf5ef2aSThomas Huth int64_t j; \ 771fcf5ef2aSThomas Huth \ 772fcf5ef2aSThomas Huth t = float64_scalbn(t, uim, &s); \ 773fcf5ef2aSThomas Huth j = float64_to_int64(t, &s); \ 774fcf5ef2aSThomas Huth r->element[i] = satcvt(j, &sat); \ 775fcf5ef2aSThomas Huth } \ 776fcf5ef2aSThomas Huth } \ 777fcf5ef2aSThomas Huth if (sat) { \ 7786175f5a0SRichard Henderson set_vscr_sat(env); \ 779fcf5ef2aSThomas Huth } \ 780fcf5ef2aSThomas Huth } 781fcf5ef2aSThomas Huth VCT(uxs, cvtsduw, u32) 782fcf5ef2aSThomas Huth VCT(sxs, cvtsdsw, s32) 783fcf5ef2aSThomas Huth #undef VCT 784fcf5ef2aSThomas Huth 785fcf5ef2aSThomas Huth target_ulong helper_vclzlsbb(ppc_avr_t *r) 786fcf5ef2aSThomas Huth { 787fcf5ef2aSThomas Huth target_ulong count = 0; 788fcf5ef2aSThomas Huth int i; 78960594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 79060594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 791fcf5ef2aSThomas Huth break; 792fcf5ef2aSThomas Huth } 793fcf5ef2aSThomas Huth count++; 794fcf5ef2aSThomas Huth } 795fcf5ef2aSThomas Huth return count; 796fcf5ef2aSThomas Huth } 797fcf5ef2aSThomas Huth 798fcf5ef2aSThomas Huth target_ulong helper_vctzlsbb(ppc_avr_t *r) 799fcf5ef2aSThomas Huth { 800fcf5ef2aSThomas Huth target_ulong count = 0; 801fcf5ef2aSThomas Huth int i; 802fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 80360594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 804fcf5ef2aSThomas Huth break; 805fcf5ef2aSThomas Huth } 806fcf5ef2aSThomas Huth count++; 807fcf5ef2aSThomas Huth } 808fcf5ef2aSThomas Huth return count; 809fcf5ef2aSThomas Huth } 810fcf5ef2aSThomas Huth 811fcf5ef2aSThomas Huth void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 812fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 813fcf5ef2aSThomas Huth { 814fcf5ef2aSThomas Huth int sat = 0; 815fcf5ef2aSThomas Huth int i; 816fcf5ef2aSThomas Huth 817fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 818fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 819fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 820fcf5ef2aSThomas Huth 821fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 822fcf5ef2aSThomas Huth } 823fcf5ef2aSThomas Huth 824fcf5ef2aSThomas Huth if (sat) { 8256175f5a0SRichard Henderson set_vscr_sat(env); 826fcf5ef2aSThomas Huth } 827fcf5ef2aSThomas Huth } 828fcf5ef2aSThomas Huth 829fcf5ef2aSThomas Huth void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 830fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 831fcf5ef2aSThomas Huth { 832fcf5ef2aSThomas Huth int sat = 0; 833fcf5ef2aSThomas Huth int i; 834fcf5ef2aSThomas Huth 835fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 836fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i] + 0x00004000; 837fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 838fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 839fcf5ef2aSThomas Huth } 840fcf5ef2aSThomas Huth 841fcf5ef2aSThomas Huth if (sat) { 8426175f5a0SRichard Henderson set_vscr_sat(env); 843fcf5ef2aSThomas Huth } 844fcf5ef2aSThomas Huth } 845fcf5ef2aSThomas Huth 846fcf5ef2aSThomas Huth void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 847fcf5ef2aSThomas Huth { 848fcf5ef2aSThomas Huth int i; 849fcf5ef2aSThomas Huth 850fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 851fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 852fcf5ef2aSThomas Huth r->s16[i] = (int16_t) (prod + c->s16[i]); 853fcf5ef2aSThomas Huth } 854fcf5ef2aSThomas Huth } 855fcf5ef2aSThomas Huth 856d81c2040SMark Cave-Ayland #define VMRG_DO(name, element, access, ofs) \ 857fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 858fcf5ef2aSThomas Huth { \ 859fcf5ef2aSThomas Huth ppc_avr_t result; \ 860d81c2040SMark Cave-Ayland int i, half = ARRAY_SIZE(r->element) / 2; \ 861fcf5ef2aSThomas Huth \ 862d81c2040SMark Cave-Ayland for (i = 0; i < half; i++) { \ 863d81c2040SMark Cave-Ayland result.access(i * 2 + 0) = a->access(i + ofs); \ 864d81c2040SMark Cave-Ayland result.access(i * 2 + 1) = b->access(i + ofs); \ 865fcf5ef2aSThomas Huth } \ 866fcf5ef2aSThomas Huth *r = result; \ 867fcf5ef2aSThomas Huth } 868d81c2040SMark Cave-Ayland 869d81c2040SMark Cave-Ayland #define VMRG(suffix, element, access) \ 870d81c2040SMark Cave-Ayland VMRG_DO(mrgl##suffix, element, access, half) \ 871d81c2040SMark Cave-Ayland VMRG_DO(mrgh##suffix, element, access, 0) 872d81c2040SMark Cave-Ayland VMRG(b, u8, VsrB) 873d81c2040SMark Cave-Ayland VMRG(h, u16, VsrH) 874d81c2040SMark Cave-Ayland VMRG(w, u32, VsrW) 875fcf5ef2aSThomas Huth #undef VMRG_DO 876fcf5ef2aSThomas Huth #undef VMRG 877fcf5ef2aSThomas Huth 878fcf5ef2aSThomas Huth void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 879fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 880fcf5ef2aSThomas Huth { 881fcf5ef2aSThomas Huth int32_t prod[16]; 882fcf5ef2aSThomas Huth int i; 883fcf5ef2aSThomas Huth 884fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s8); i++) { 885fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s8[i] * b->u8[i]; 886fcf5ef2aSThomas Huth } 887fcf5ef2aSThomas Huth 888fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 889fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] + 890fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 891fcf5ef2aSThomas Huth } 892fcf5ef2aSThomas Huth } 893fcf5ef2aSThomas Huth 894fcf5ef2aSThomas Huth void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 895fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 896fcf5ef2aSThomas Huth { 897fcf5ef2aSThomas Huth int32_t prod[8]; 898fcf5ef2aSThomas Huth int i; 899fcf5ef2aSThomas Huth 900fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 901fcf5ef2aSThomas Huth prod[i] = a->s16[i] * b->s16[i]; 902fcf5ef2aSThomas Huth } 903fcf5ef2aSThomas Huth 904fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 905fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 906fcf5ef2aSThomas Huth } 907fcf5ef2aSThomas Huth } 908fcf5ef2aSThomas Huth 909fcf5ef2aSThomas Huth void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 910fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 911fcf5ef2aSThomas Huth { 912fcf5ef2aSThomas Huth int32_t prod[8]; 913fcf5ef2aSThomas Huth int i; 914fcf5ef2aSThomas Huth int sat = 0; 915fcf5ef2aSThomas Huth 916fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 917fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s16[i] * b->s16[i]; 918fcf5ef2aSThomas Huth } 919fcf5ef2aSThomas Huth 920fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 921fcf5ef2aSThomas Huth int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 922fcf5ef2aSThomas Huth 923fcf5ef2aSThomas Huth r->u32[i] = cvtsdsw(t, &sat); 924fcf5ef2aSThomas Huth } 925fcf5ef2aSThomas Huth 926fcf5ef2aSThomas Huth if (sat) { 9276175f5a0SRichard Henderson set_vscr_sat(env); 928fcf5ef2aSThomas Huth } 929fcf5ef2aSThomas Huth } 930fcf5ef2aSThomas Huth 931fcf5ef2aSThomas Huth void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 932fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 933fcf5ef2aSThomas Huth { 934fcf5ef2aSThomas Huth uint16_t prod[16]; 935fcf5ef2aSThomas Huth int i; 936fcf5ef2aSThomas Huth 937fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 938fcf5ef2aSThomas Huth prod[i] = a->u8[i] * b->u8[i]; 939fcf5ef2aSThomas Huth } 940fcf5ef2aSThomas Huth 941fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 942fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] + 943fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 944fcf5ef2aSThomas Huth } 945fcf5ef2aSThomas Huth } 946fcf5ef2aSThomas Huth 947fcf5ef2aSThomas Huth void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 948fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 949fcf5ef2aSThomas Huth { 950fcf5ef2aSThomas Huth uint32_t prod[8]; 951fcf5ef2aSThomas Huth int i; 952fcf5ef2aSThomas Huth 953fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 954fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 955fcf5ef2aSThomas Huth } 956fcf5ef2aSThomas Huth 957fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 958fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 959fcf5ef2aSThomas Huth } 960fcf5ef2aSThomas Huth } 961fcf5ef2aSThomas Huth 962fcf5ef2aSThomas Huth void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 963fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 964fcf5ef2aSThomas Huth { 965fcf5ef2aSThomas Huth uint32_t prod[8]; 966fcf5ef2aSThomas Huth int i; 967fcf5ef2aSThomas Huth int sat = 0; 968fcf5ef2aSThomas Huth 969fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 970fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 971fcf5ef2aSThomas Huth } 972fcf5ef2aSThomas Huth 973fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 974fcf5ef2aSThomas Huth uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 975fcf5ef2aSThomas Huth 976fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 977fcf5ef2aSThomas Huth } 978fcf5ef2aSThomas Huth 979fcf5ef2aSThomas Huth if (sat) { 9806175f5a0SRichard Henderson set_vscr_sat(env); 981fcf5ef2aSThomas Huth } 982fcf5ef2aSThomas Huth } 983fcf5ef2aSThomas Huth 9844fbc89edSMark Cave-Ayland #define VMUL_DO_EVN(name, mul_element, mul_access, prod_access, cast) \ 98580eca687SLucas Mateus Castro (alqotel) void helper_V##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 986fcf5ef2aSThomas Huth { \ 987fcf5ef2aSThomas Huth int i; \ 988fcf5ef2aSThomas Huth \ 9894fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 9904fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i) * \ 9914fbc89edSMark Cave-Ayland (cast)b->mul_access(i); \ 992fcf5ef2aSThomas Huth } \ 993fcf5ef2aSThomas Huth } 9944fbc89edSMark Cave-Ayland 9954fbc89edSMark Cave-Ayland #define VMUL_DO_ODD(name, mul_element, mul_access, prod_access, cast) \ 99680eca687SLucas Mateus Castro (alqotel) void helper_V##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 9974fbc89edSMark Cave-Ayland { \ 9984fbc89edSMark Cave-Ayland int i; \ 9994fbc89edSMark Cave-Ayland \ 10004fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 10014fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i + 1) * \ 10024fbc89edSMark Cave-Ayland (cast)b->mul_access(i + 1); \ 10034fbc89edSMark Cave-Ayland } \ 10044fbc89edSMark Cave-Ayland } 10054fbc89edSMark Cave-Ayland 10064fbc89edSMark Cave-Ayland #define VMUL(suffix, mul_element, mul_access, prod_access, cast) \ 100780eca687SLucas Mateus Castro (alqotel) VMUL_DO_EVN(MULE##suffix, mul_element, mul_access, prod_access, cast) \ 100880eca687SLucas Mateus Castro (alqotel) VMUL_DO_ODD(MULO##suffix, mul_element, mul_access, prod_access, cast) 100980eca687SLucas Mateus Castro (alqotel) VMUL(SB, s8, VsrSB, VsrSH, int16_t) 101080eca687SLucas Mateus Castro (alqotel) VMUL(SH, s16, VsrSH, VsrSW, int32_t) 101180eca687SLucas Mateus Castro (alqotel) VMUL(SW, s32, VsrSW, VsrSD, int64_t) 101280eca687SLucas Mateus Castro (alqotel) VMUL(UB, u8, VsrB, VsrH, uint16_t) 101380eca687SLucas Mateus Castro (alqotel) VMUL(UH, u16, VsrH, VsrW, uint32_t) 101480eca687SLucas Mateus Castro (alqotel) VMUL(UW, u32, VsrW, VsrD, uint64_t) 10154fbc89edSMark Cave-Ayland #undef VMUL_DO_EVN 10164fbc89edSMark Cave-Ayland #undef VMUL_DO_ODD 1017fcf5ef2aSThomas Huth #undef VMUL 1018fcf5ef2aSThomas Huth 101941c2877fSMatheus Ferst void helper_XXPERMX(ppc_vsr_t *t, ppc_vsr_t *s0, ppc_vsr_t *s1, ppc_vsr_t *pcv, 102041c2877fSMatheus Ferst target_ulong uim) 102141c2877fSMatheus Ferst { 102241c2877fSMatheus Ferst int i, idx; 102341c2877fSMatheus Ferst ppc_vsr_t tmp = { .u64 = {0, 0} }; 102441c2877fSMatheus Ferst 102541c2877fSMatheus Ferst for (i = 0; i < ARRAY_SIZE(t->u8); i++) { 102641c2877fSMatheus Ferst if ((pcv->VsrB(i) >> 5) == uim) { 102741c2877fSMatheus Ferst idx = pcv->VsrB(i) & 0x1f; 102841c2877fSMatheus Ferst if (idx < ARRAY_SIZE(t->u8)) { 102941c2877fSMatheus Ferst tmp.VsrB(i) = s0->VsrB(idx); 103041c2877fSMatheus Ferst } else { 103141c2877fSMatheus Ferst tmp.VsrB(i) = s1->VsrB(idx - ARRAY_SIZE(t->u8)); 103241c2877fSMatheus Ferst } 103341c2877fSMatheus Ferst } 103441c2877fSMatheus Ferst } 103541c2877fSMatheus Ferst 103641c2877fSMatheus Ferst *t = tmp; 103741c2877fSMatheus Ferst } 103841c2877fSMatheus Ferst 103928347fe2SMatheus Ferst void helper_VPERM(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 1040fcf5ef2aSThomas Huth { 1041fcf5ef2aSThomas Huth ppc_avr_t result; 1042fcf5ef2aSThomas Huth int i; 1043fcf5ef2aSThomas Huth 104460594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 104560594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1046fcf5ef2aSThomas Huth int index = s & 0xf; 1047fcf5ef2aSThomas Huth 1048fcf5ef2aSThomas Huth if (s & 0x10) { 104960594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1050fcf5ef2aSThomas Huth } else { 105160594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1052fcf5ef2aSThomas Huth } 1053fcf5ef2aSThomas Huth } 1054fcf5ef2aSThomas Huth *r = result; 1055fcf5ef2aSThomas Huth } 1056fcf5ef2aSThomas Huth 105728347fe2SMatheus Ferst void helper_VPERMR(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 1058fcf5ef2aSThomas Huth { 1059fcf5ef2aSThomas Huth ppc_avr_t result; 1060fcf5ef2aSThomas Huth int i; 1061fcf5ef2aSThomas Huth 106260594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 106360594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1064fcf5ef2aSThomas Huth int index = 15 - (s & 0xf); 1065fcf5ef2aSThomas Huth 1066fcf5ef2aSThomas Huth if (s & 0x10) { 106760594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1068fcf5ef2aSThomas Huth } else { 106960594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1070fcf5ef2aSThomas Huth } 1071fcf5ef2aSThomas Huth } 1072fcf5ef2aSThomas Huth *r = result; 1073fcf5ef2aSThomas Huth } 1074fcf5ef2aSThomas Huth 1075*b090f4f1SMatheus Ferst #define XXGENPCV(NAME, SZ) \ 1076*b090f4f1SMatheus Ferst void glue(helper_, glue(NAME, _be_exp))(ppc_vsr_t *t, ppc_vsr_t *b) \ 1077*b090f4f1SMatheus Ferst { \ 1078*b090f4f1SMatheus Ferst ppc_vsr_t tmp; \ 1079*b090f4f1SMatheus Ferst \ 1080*b090f4f1SMatheus Ferst /* Initialize tmp with the result of an all-zeros mask */ \ 1081*b090f4f1SMatheus Ferst tmp.VsrD(0) = 0x1011121314151617; \ 1082*b090f4f1SMatheus Ferst tmp.VsrD(1) = 0x18191A1B1C1D1E1F; \ 1083*b090f4f1SMatheus Ferst \ 1084*b090f4f1SMatheus Ferst /* Iterate over the most significant byte of each element */ \ 1085*b090f4f1SMatheus Ferst for (int i = 0, j = 0; i < ARRAY_SIZE(b->u8); i += SZ) { \ 1086*b090f4f1SMatheus Ferst if (b->VsrB(i) & 0x80) { \ 1087*b090f4f1SMatheus Ferst /* Update each byte of the element */ \ 1088*b090f4f1SMatheus Ferst for (int k = 0; k < SZ; k++) { \ 1089*b090f4f1SMatheus Ferst tmp.VsrB(i + k) = j + k; \ 1090*b090f4f1SMatheus Ferst } \ 1091*b090f4f1SMatheus Ferst j += SZ; \ 1092*b090f4f1SMatheus Ferst } \ 1093*b090f4f1SMatheus Ferst } \ 1094*b090f4f1SMatheus Ferst \ 1095*b090f4f1SMatheus Ferst *t = tmp; \ 1096*b090f4f1SMatheus Ferst } \ 1097*b090f4f1SMatheus Ferst \ 1098*b090f4f1SMatheus Ferst void glue(helper_, glue(NAME, _be_comp))(ppc_vsr_t *t, ppc_vsr_t *b)\ 1099*b090f4f1SMatheus Ferst { \ 1100*b090f4f1SMatheus Ferst ppc_vsr_t tmp = { .u64 = { 0, 0 } }; \ 1101*b090f4f1SMatheus Ferst \ 1102*b090f4f1SMatheus Ferst /* Iterate over the most significant byte of each element */ \ 1103*b090f4f1SMatheus Ferst for (int i = 0, j = 0; i < ARRAY_SIZE(b->u8); i += SZ) { \ 1104*b090f4f1SMatheus Ferst if (b->VsrB(i) & 0x80) { \ 1105*b090f4f1SMatheus Ferst /* Update each byte of the element */ \ 1106*b090f4f1SMatheus Ferst for (int k = 0; k < SZ; k++) { \ 1107*b090f4f1SMatheus Ferst tmp.VsrB(j + k) = i + k; \ 1108*b090f4f1SMatheus Ferst } \ 1109*b090f4f1SMatheus Ferst j += SZ; \ 1110*b090f4f1SMatheus Ferst } \ 1111*b090f4f1SMatheus Ferst } \ 1112*b090f4f1SMatheus Ferst \ 1113*b090f4f1SMatheus Ferst *t = tmp; \ 1114*b090f4f1SMatheus Ferst } \ 1115*b090f4f1SMatheus Ferst \ 1116*b090f4f1SMatheus Ferst void glue(helper_, glue(NAME, _le_exp))(ppc_vsr_t *t, ppc_vsr_t *b) \ 1117*b090f4f1SMatheus Ferst { \ 1118*b090f4f1SMatheus Ferst ppc_vsr_t tmp; \ 1119*b090f4f1SMatheus Ferst \ 1120*b090f4f1SMatheus Ferst /* Initialize tmp with the result of an all-zeros mask */ \ 1121*b090f4f1SMatheus Ferst tmp.VsrD(0) = 0x1F1E1D1C1B1A1918; \ 1122*b090f4f1SMatheus Ferst tmp.VsrD(1) = 0x1716151413121110; \ 1123*b090f4f1SMatheus Ferst \ 1124*b090f4f1SMatheus Ferst /* Iterate over the most significant byte of each element */ \ 1125*b090f4f1SMatheus Ferst for (int i = 0, j = 0; i < ARRAY_SIZE(b->u8); i += SZ) { \ 1126*b090f4f1SMatheus Ferst /* Reverse indexing of "i" */ \ 1127*b090f4f1SMatheus Ferst const int idx = ARRAY_SIZE(b->u8) - i - SZ; \ 1128*b090f4f1SMatheus Ferst if (b->VsrB(idx) & 0x80) { \ 1129*b090f4f1SMatheus Ferst /* Update each byte of the element */ \ 1130*b090f4f1SMatheus Ferst for (int k = 0, rk = SZ - 1; k < SZ; k++, rk--) { \ 1131*b090f4f1SMatheus Ferst tmp.VsrB(idx + rk) = j + k; \ 1132*b090f4f1SMatheus Ferst } \ 1133*b090f4f1SMatheus Ferst j += SZ; \ 1134*b090f4f1SMatheus Ferst } \ 1135*b090f4f1SMatheus Ferst } \ 1136*b090f4f1SMatheus Ferst \ 1137*b090f4f1SMatheus Ferst *t = tmp; \ 1138*b090f4f1SMatheus Ferst } \ 1139*b090f4f1SMatheus Ferst \ 1140*b090f4f1SMatheus Ferst void glue(helper_, glue(NAME, _le_comp))(ppc_vsr_t *t, ppc_vsr_t *b)\ 1141*b090f4f1SMatheus Ferst { \ 1142*b090f4f1SMatheus Ferst ppc_vsr_t tmp = { .u64 = { 0, 0 } }; \ 1143*b090f4f1SMatheus Ferst \ 1144*b090f4f1SMatheus Ferst /* Iterate over the most significant byte of each element */ \ 1145*b090f4f1SMatheus Ferst for (int i = 0, j = 0; i < ARRAY_SIZE(b->u8); i += SZ) { \ 1146*b090f4f1SMatheus Ferst if (b->VsrB(ARRAY_SIZE(b->u8) - i - SZ) & 0x80) { \ 1147*b090f4f1SMatheus Ferst /* Update each byte of the element */ \ 1148*b090f4f1SMatheus Ferst for (int k = 0, rk = SZ - 1; k < SZ; k++, rk--) { \ 1149*b090f4f1SMatheus Ferst /* Reverse indexing of "j" */ \ 1150*b090f4f1SMatheus Ferst const int idx = ARRAY_SIZE(b->u8) - j - SZ; \ 1151*b090f4f1SMatheus Ferst tmp.VsrB(idx + rk) = i + k; \ 1152*b090f4f1SMatheus Ferst } \ 1153*b090f4f1SMatheus Ferst j += SZ; \ 1154*b090f4f1SMatheus Ferst } \ 1155*b090f4f1SMatheus Ferst } \ 1156*b090f4f1SMatheus Ferst \ 1157*b090f4f1SMatheus Ferst *t = tmp; \ 1158*b090f4f1SMatheus Ferst } 1159*b090f4f1SMatheus Ferst 1160*b090f4f1SMatheus Ferst XXGENPCV(XXGENPCVBM, 1) 1161*b090f4f1SMatheus Ferst XXGENPCV(XXGENPCVHM, 2) 1162*b090f4f1SMatheus Ferst XXGENPCV(XXGENPCVWM, 4) 1163*b090f4f1SMatheus Ferst XXGENPCV(XXGENPCVDM, 8) 1164*b090f4f1SMatheus Ferst #undef XXGENPCV 1165*b090f4f1SMatheus Ferst 1166fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1167fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)]) 1168fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (i) 1169fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) != 0) 1170fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) (extract64((avr)->u64[i], index, 1)) 1171fcf5ef2aSThomas Huth #else 1172fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15 - (i)]) 1173fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (1 - i) 1174fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) == 0) 1175fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) \ 1176fcf5ef2aSThomas Huth (extract64((avr)->u64[1 - i], 63 - index, 1)) 1177fcf5ef2aSThomas Huth #endif 1178fcf5ef2aSThomas Huth 1179fcf5ef2aSThomas Huth void helper_vbpermd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1180fcf5ef2aSThomas Huth { 1181fcf5ef2aSThomas Huth int i, j; 1182fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 1183fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1184fcf5ef2aSThomas Huth for (j = 0; j < 8; j++) { 1185fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, (i * 8) + j); 1186fcf5ef2aSThomas Huth if (index < 64 && EXTRACT_BIT(a, i, index)) { 1187fcf5ef2aSThomas Huth result.u64[VBPERMD_INDEX(i)] |= (0x80 >> j); 1188fcf5ef2aSThomas Huth } 1189fcf5ef2aSThomas Huth } 1190fcf5ef2aSThomas Huth } 1191fcf5ef2aSThomas Huth *r = result; 1192fcf5ef2aSThomas Huth } 1193fcf5ef2aSThomas Huth 1194fcf5ef2aSThomas Huth void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1195fcf5ef2aSThomas Huth { 1196fcf5ef2aSThomas Huth int i; 1197fcf5ef2aSThomas Huth uint64_t perm = 0; 1198fcf5ef2aSThomas Huth 1199fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1200fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, i); 1201fcf5ef2aSThomas Huth 1202fcf5ef2aSThomas Huth if (index < 128) { 1203fcf5ef2aSThomas Huth uint64_t mask = (1ull << (63 - (index & 0x3F))); 1204fcf5ef2aSThomas Huth if (a->u64[VBPERMQ_DW(index)] & mask) { 1205fcf5ef2aSThomas Huth perm |= (0x8000 >> i); 1206fcf5ef2aSThomas Huth } 1207fcf5ef2aSThomas Huth } 1208fcf5ef2aSThomas Huth } 1209fcf5ef2aSThomas Huth 12103c385a93SMark Cave-Ayland r->VsrD(0) = perm; 12113c385a93SMark Cave-Ayland r->VsrD(1) = 0; 1212fcf5ef2aSThomas Huth } 1213fcf5ef2aSThomas Huth 1214fcf5ef2aSThomas Huth #undef VBPERMQ_INDEX 1215fcf5ef2aSThomas Huth #undef VBPERMQ_DW 1216fcf5ef2aSThomas Huth 1217fcf5ef2aSThomas Huth #define PMSUM(name, srcfld, trgfld, trgtyp) \ 1218fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1219fcf5ef2aSThomas Huth { \ 1220fcf5ef2aSThomas Huth int i, j; \ 1221fcf5ef2aSThomas Huth trgtyp prod[sizeof(ppc_avr_t) / sizeof(a->srcfld[0])]; \ 1222fcf5ef2aSThomas Huth \ 1223fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, srcfld) { \ 1224fcf5ef2aSThomas Huth prod[i] = 0; \ 1225fcf5ef2aSThomas Huth for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) { \ 1226fcf5ef2aSThomas Huth if (a->srcfld[i] & (1ull << j)) { \ 1227fcf5ef2aSThomas Huth prod[i] ^= ((trgtyp)b->srcfld[i] << j); \ 1228fcf5ef2aSThomas Huth } \ 1229fcf5ef2aSThomas Huth } \ 1230fcf5ef2aSThomas Huth } \ 1231fcf5ef2aSThomas Huth \ 1232fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, trgfld) { \ 1233fcf5ef2aSThomas Huth r->trgfld[i] = prod[2 * i] ^ prod[2 * i + 1]; \ 1234fcf5ef2aSThomas Huth } \ 1235fcf5ef2aSThomas Huth } 1236fcf5ef2aSThomas Huth 1237fcf5ef2aSThomas Huth PMSUM(vpmsumb, u8, u16, uint16_t) 1238fcf5ef2aSThomas Huth PMSUM(vpmsumh, u16, u32, uint32_t) 1239fcf5ef2aSThomas Huth PMSUM(vpmsumw, u32, u64, uint64_t) 1240fcf5ef2aSThomas Huth 1241fcf5ef2aSThomas Huth void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1242fcf5ef2aSThomas Huth { 1243fcf5ef2aSThomas Huth 1244fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 1245fcf5ef2aSThomas Huth int i, j; 1246fcf5ef2aSThomas Huth __uint128_t prod[2]; 1247fcf5ef2aSThomas Huth 1248fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1249fcf5ef2aSThomas Huth prod[i] = 0; 1250fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1251fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1252fcf5ef2aSThomas Huth prod[i] ^= (((__uint128_t)b->u64[i]) << j); 1253fcf5ef2aSThomas Huth } 1254fcf5ef2aSThomas Huth } 1255fcf5ef2aSThomas Huth } 1256fcf5ef2aSThomas Huth 1257fcf5ef2aSThomas Huth r->u128 = prod[0] ^ prod[1]; 1258fcf5ef2aSThomas Huth 1259fcf5ef2aSThomas Huth #else 1260fcf5ef2aSThomas Huth int i, j; 1261fcf5ef2aSThomas Huth ppc_avr_t prod[2]; 1262fcf5ef2aSThomas Huth 1263fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 12643c385a93SMark Cave-Ayland prod[i].VsrD(1) = prod[i].VsrD(0) = 0; 1265fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1266fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1267fcf5ef2aSThomas Huth ppc_avr_t bshift; 1268fcf5ef2aSThomas Huth if (j == 0) { 12693c385a93SMark Cave-Ayland bshift.VsrD(0) = 0; 12703c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i]; 1271fcf5ef2aSThomas Huth } else { 12723c385a93SMark Cave-Ayland bshift.VsrD(0) = b->u64[i] >> (64 - j); 12733c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i] << j; 1274fcf5ef2aSThomas Huth } 12753c385a93SMark Cave-Ayland prod[i].VsrD(1) ^= bshift.VsrD(1); 12763c385a93SMark Cave-Ayland prod[i].VsrD(0) ^= bshift.VsrD(0); 1277fcf5ef2aSThomas Huth } 1278fcf5ef2aSThomas Huth } 1279fcf5ef2aSThomas Huth } 1280fcf5ef2aSThomas Huth 12813c385a93SMark Cave-Ayland r->VsrD(1) = prod[0].VsrD(1) ^ prod[1].VsrD(1); 12823c385a93SMark Cave-Ayland r->VsrD(0) = prod[0].VsrD(0) ^ prod[1].VsrD(0); 1283fcf5ef2aSThomas Huth #endif 1284fcf5ef2aSThomas Huth } 1285fcf5ef2aSThomas Huth 1286fcf5ef2aSThomas Huth 1287fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1288fcf5ef2aSThomas Huth #define PKBIG 1 1289fcf5ef2aSThomas Huth #else 1290fcf5ef2aSThomas Huth #define PKBIG 0 1291fcf5ef2aSThomas Huth #endif 1292fcf5ef2aSThomas Huth void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1293fcf5ef2aSThomas Huth { 1294fcf5ef2aSThomas Huth int i, j; 1295fcf5ef2aSThomas Huth ppc_avr_t result; 1296fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1297fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { a, b }; 1298fcf5ef2aSThomas Huth #else 1299fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { b, a }; 1300fcf5ef2aSThomas Huth #endif 1301fcf5ef2aSThomas Huth 1302fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1303fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(j, u32) { 1304fcf5ef2aSThomas Huth uint32_t e = x[i]->u32[j]; 1305fcf5ef2aSThomas Huth 1306fcf5ef2aSThomas Huth result.u16[4 * i + j] = (((e >> 9) & 0xfc00) | 1307fcf5ef2aSThomas Huth ((e >> 6) & 0x3e0) | 1308fcf5ef2aSThomas Huth ((e >> 3) & 0x1f)); 1309fcf5ef2aSThomas Huth } 1310fcf5ef2aSThomas Huth } 1311fcf5ef2aSThomas Huth *r = result; 1312fcf5ef2aSThomas Huth } 1313fcf5ef2aSThomas Huth 1314fcf5ef2aSThomas Huth #define VPK(suffix, from, to, cvt, dosat) \ 1315fcf5ef2aSThomas Huth void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1316fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 1317fcf5ef2aSThomas Huth { \ 1318fcf5ef2aSThomas Huth int i; \ 1319fcf5ef2aSThomas Huth int sat = 0; \ 1320fcf5ef2aSThomas Huth ppc_avr_t result; \ 1321fcf5ef2aSThomas Huth ppc_avr_t *a0 = PKBIG ? a : b; \ 1322fcf5ef2aSThomas Huth ppc_avr_t *a1 = PKBIG ? b : a; \ 1323fcf5ef2aSThomas Huth \ 1324fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, from) { \ 1325fcf5ef2aSThomas Huth result.to[i] = cvt(a0->from[i], &sat); \ 1326fcf5ef2aSThomas Huth result.to[i + ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);\ 1327fcf5ef2aSThomas Huth } \ 1328fcf5ef2aSThomas Huth *r = result; \ 1329fcf5ef2aSThomas Huth if (dosat && sat) { \ 13306175f5a0SRichard Henderson set_vscr_sat(env); \ 1331fcf5ef2aSThomas Huth } \ 1332fcf5ef2aSThomas Huth } 1333fcf5ef2aSThomas Huth #define I(x, y) (x) 1334fcf5ef2aSThomas Huth VPK(shss, s16, s8, cvtshsb, 1) 1335fcf5ef2aSThomas Huth VPK(shus, s16, u8, cvtshub, 1) 1336fcf5ef2aSThomas Huth VPK(swss, s32, s16, cvtswsh, 1) 1337fcf5ef2aSThomas Huth VPK(swus, s32, u16, cvtswuh, 1) 1338fcf5ef2aSThomas Huth VPK(sdss, s64, s32, cvtsdsw, 1) 1339fcf5ef2aSThomas Huth VPK(sdus, s64, u32, cvtsduw, 1) 1340fcf5ef2aSThomas Huth VPK(uhus, u16, u8, cvtuhub, 1) 1341fcf5ef2aSThomas Huth VPK(uwus, u32, u16, cvtuwuh, 1) 1342fcf5ef2aSThomas Huth VPK(udus, u64, u32, cvtuduw, 1) 1343fcf5ef2aSThomas Huth VPK(uhum, u16, u8, I, 0) 1344fcf5ef2aSThomas Huth VPK(uwum, u32, u16, I, 0) 1345fcf5ef2aSThomas Huth VPK(udum, u64, u32, I, 0) 1346fcf5ef2aSThomas Huth #undef I 1347fcf5ef2aSThomas Huth #undef VPK 1348fcf5ef2aSThomas Huth #undef PKBIG 1349fcf5ef2aSThomas Huth 1350fcf5ef2aSThomas Huth void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1351fcf5ef2aSThomas Huth { 1352fcf5ef2aSThomas Huth int i; 1353fcf5ef2aSThomas Huth 135405ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 135505ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, b->f32[i], &env->vec_status); 1356fcf5ef2aSThomas Huth } 1357fcf5ef2aSThomas Huth } 1358fcf5ef2aSThomas Huth 1359fcf5ef2aSThomas Huth #define VRFI(suffix, rounding) \ 1360fcf5ef2aSThomas Huth void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1361fcf5ef2aSThomas Huth ppc_avr_t *b) \ 1362fcf5ef2aSThomas Huth { \ 1363fcf5ef2aSThomas Huth int i; \ 1364fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 1365fcf5ef2aSThomas Huth \ 1366fcf5ef2aSThomas Huth set_float_rounding_mode(rounding, &s); \ 136705ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 136805ee3e8aSMark Cave-Ayland r->f32[i] = float32_round_to_int (b->f32[i], &s); \ 1369fcf5ef2aSThomas Huth } \ 1370fcf5ef2aSThomas Huth } 1371fcf5ef2aSThomas Huth VRFI(n, float_round_nearest_even) 1372fcf5ef2aSThomas Huth VRFI(m, float_round_down) 1373fcf5ef2aSThomas Huth VRFI(p, float_round_up) 1374fcf5ef2aSThomas Huth VRFI(z, float_round_to_zero) 1375fcf5ef2aSThomas Huth #undef VRFI 1376fcf5ef2aSThomas Huth 1377fcf5ef2aSThomas Huth void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1378fcf5ef2aSThomas Huth { 1379fcf5ef2aSThomas Huth int i; 1380fcf5ef2aSThomas Huth 138105ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 138205ee3e8aSMark Cave-Ayland float32 t = float32_sqrt(b->f32[i], &env->vec_status); 1383fcf5ef2aSThomas Huth 138405ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, t, &env->vec_status); 1385fcf5ef2aSThomas Huth } 1386fcf5ef2aSThomas Huth } 1387fcf5ef2aSThomas Huth 1388fcf5ef2aSThomas Huth #define VRLMI(name, size, element, insert) \ 138902c74f0eSMatheus Ferst void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t desc) \ 1390fcf5ef2aSThomas Huth { \ 1391fcf5ef2aSThomas Huth int i; \ 1392fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1393fcf5ef2aSThomas Huth uint##size##_t src1 = a->element[i]; \ 1394fcf5ef2aSThomas Huth uint##size##_t src2 = b->element[i]; \ 1395fcf5ef2aSThomas Huth uint##size##_t src3 = r->element[i]; \ 1396fcf5ef2aSThomas Huth uint##size##_t begin, end, shift, mask, rot_val; \ 1397fcf5ef2aSThomas Huth \ 1398fcf5ef2aSThomas Huth shift = extract##size(src2, 0, 6); \ 1399fcf5ef2aSThomas Huth end = extract##size(src2, 8, 6); \ 1400fcf5ef2aSThomas Huth begin = extract##size(src2, 16, 6); \ 1401fcf5ef2aSThomas Huth rot_val = rol##size(src1, shift); \ 1402fcf5ef2aSThomas Huth mask = mask_u##size(begin, end); \ 1403fcf5ef2aSThomas Huth if (insert) { \ 1404fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask) | (src3 & ~mask); \ 1405fcf5ef2aSThomas Huth } else { \ 1406fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask); \ 1407fcf5ef2aSThomas Huth } \ 1408fcf5ef2aSThomas Huth } \ 1409fcf5ef2aSThomas Huth } 1410fcf5ef2aSThomas Huth 141102c74f0eSMatheus Ferst VRLMI(VRLDMI, 64, u64, 1); 141202c74f0eSMatheus Ferst VRLMI(VRLWMI, 32, u32, 1); 141302c74f0eSMatheus Ferst VRLMI(VRLDNM, 64, u64, 0); 141402c74f0eSMatheus Ferst VRLMI(VRLWNM, 32, u32, 0); 1415fcf5ef2aSThomas Huth 1416fcf5ef2aSThomas Huth void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1417fcf5ef2aSThomas Huth { 1418fcf5ef2aSThomas Huth int i; 1419fcf5ef2aSThomas Huth 142005ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 142105ee3e8aSMark Cave-Ayland r->f32[i] = float32_exp2(b->f32[i], &env->vec_status); 1422fcf5ef2aSThomas Huth } 1423fcf5ef2aSThomas Huth } 1424fcf5ef2aSThomas Huth 1425fcf5ef2aSThomas Huth void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1426fcf5ef2aSThomas Huth { 1427fcf5ef2aSThomas Huth int i; 1428fcf5ef2aSThomas Huth 142905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 143005ee3e8aSMark Cave-Ayland r->f32[i] = float32_log2(b->f32[i], &env->vec_status); 1431fcf5ef2aSThomas Huth } 1432fcf5ef2aSThomas Huth } 1433fcf5ef2aSThomas Huth 143460caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 143560caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 143660caf221SAvinesh Kumar { \ 1437f297c4c6SMatheus Ferst int index = (a & 0xf) * 8; \ 143860caf221SAvinesh Kumar if (left) { \ 1439f297c4c6SMatheus Ferst index = 128 - index - size; \ 144060caf221SAvinesh Kumar } \ 144160caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 144260caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 144360caf221SAvinesh Kumar } 144460caf221SAvinesh Kumar VEXTU_X_DO(vextublx, 8, 1) 144560caf221SAvinesh Kumar VEXTU_X_DO(vextuhlx, 16, 1) 144660caf221SAvinesh Kumar VEXTU_X_DO(vextuwlx, 32, 1) 144760caf221SAvinesh Kumar VEXTU_X_DO(vextubrx, 8, 0) 144860caf221SAvinesh Kumar VEXTU_X_DO(vextuhrx, 16, 0) 144960caf221SAvinesh Kumar VEXTU_X_DO(vextuwrx, 32, 0) 145060caf221SAvinesh Kumar #undef VEXTU_X_DO 145160caf221SAvinesh Kumar 1452fcf5ef2aSThomas Huth void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1453fcf5ef2aSThomas Huth { 1454fcf5ef2aSThomas Huth int i; 1455fcf5ef2aSThomas Huth unsigned int shift, bytes, size; 1456fcf5ef2aSThomas Huth 1457fcf5ef2aSThomas Huth size = ARRAY_SIZE(r->u8); 1458fcf5ef2aSThomas Huth for (i = 0; i < size; i++) { 145963be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 146063be02fcSAnton Blanchard bytes = (a->VsrB(i) << 8) + /* extract adjacent bytes */ 146163be02fcSAnton Blanchard (((i + 1) < size) ? a->VsrB(i + 1) : 0); 146263be02fcSAnton Blanchard r->VsrB(i) = (bytes << shift) >> 8; /* shift and store result */ 1463fcf5ef2aSThomas Huth } 1464fcf5ef2aSThomas Huth } 1465fcf5ef2aSThomas Huth 1466fcf5ef2aSThomas Huth void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1467fcf5ef2aSThomas Huth { 1468fcf5ef2aSThomas Huth int i; 1469fcf5ef2aSThomas Huth unsigned int shift, bytes; 1470fcf5ef2aSThomas Huth 1471b6cb41b2SDavid Gibson /* 1472b6cb41b2SDavid Gibson * Use reverse order, as destination and source register can be 1473b6cb41b2SDavid Gibson * same. Its being modified in place saving temporary, reverse 1474b6cb41b2SDavid Gibson * order will guarantee that computed result is not fed back. 1475fcf5ef2aSThomas Huth */ 1476fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 147763be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 147863be02fcSAnton Blanchard bytes = ((i ? a->VsrB(i - 1) : 0) << 8) + a->VsrB(i); 1479fcf5ef2aSThomas Huth /* extract adjacent bytes */ 148063be02fcSAnton Blanchard r->VsrB(i) = (bytes >> shift) & 0xFF; /* shift and store result */ 1481fcf5ef2aSThomas Huth } 1482fcf5ef2aSThomas Huth } 1483fcf5ef2aSThomas Huth 1484fcf5ef2aSThomas Huth void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift) 1485fcf5ef2aSThomas Huth { 1486fcf5ef2aSThomas Huth int sh = shift & 0xf; 1487fcf5ef2aSThomas Huth int i; 1488fcf5ef2aSThomas Huth ppc_avr_t result; 1489fcf5ef2aSThomas Huth 1490fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1491fcf5ef2aSThomas Huth int index = sh + i; 1492fcf5ef2aSThomas Huth if (index > 0xf) { 149360594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index - 0x10); 1494fcf5ef2aSThomas Huth } else { 149560594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1496fcf5ef2aSThomas Huth } 1497fcf5ef2aSThomas Huth } 1498fcf5ef2aSThomas Huth *r = result; 1499fcf5ef2aSThomas Huth } 1500fcf5ef2aSThomas Huth 1501fcf5ef2aSThomas Huth void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1502fcf5ef2aSThomas Huth { 15033c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 1504fcf5ef2aSThomas Huth 1505fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1506fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1507fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 1508fcf5ef2aSThomas Huth #else 1509fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1510fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1511fcf5ef2aSThomas Huth #endif 1512fcf5ef2aSThomas Huth } 1513fcf5ef2aSThomas Huth 1514fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 15152cc12af3SMatheus Ferst #define ELEM_ADDR(VEC, IDX, SIZE) (&(VEC)->u8[IDX]) 15162cc12af3SMatheus Ferst #else 15172cc12af3SMatheus Ferst #define ELEM_ADDR(VEC, IDX, SIZE) (&(VEC)->u8[15 - (IDX)] - (SIZE) + 1) 15182cc12af3SMatheus Ferst #endif 15192cc12af3SMatheus Ferst 15202cc12af3SMatheus Ferst #define VINSX(SUFFIX, TYPE) \ 15212cc12af3SMatheus Ferst void glue(glue(helper_VINS, SUFFIX), LX)(CPUPPCState *env, ppc_avr_t *t, \ 15222cc12af3SMatheus Ferst uint64_t val, target_ulong index) \ 15232cc12af3SMatheus Ferst { \ 15242cc12af3SMatheus Ferst const int maxidx = ARRAY_SIZE(t->u8) - sizeof(TYPE); \ 15252cc12af3SMatheus Ferst target_long idx = index; \ 15262cc12af3SMatheus Ferst \ 15272cc12af3SMatheus Ferst if (idx < 0 || idx > maxidx) { \ 15282cc12af3SMatheus Ferst idx = idx < 0 ? sizeof(TYPE) - idx : idx; \ 15292cc12af3SMatheus Ferst qemu_log_mask(LOG_GUEST_ERROR, \ 15302cc12af3SMatheus Ferst "Invalid index for Vector Insert Element after 0x" TARGET_FMT_lx \ 15312cc12af3SMatheus Ferst ", RA = " TARGET_FMT_ld " > %d\n", env->nip, idx, maxidx); \ 15322cc12af3SMatheus Ferst } else { \ 15332cc12af3SMatheus Ferst TYPE src = val; \ 15342cc12af3SMatheus Ferst memcpy(ELEM_ADDR(t, idx, sizeof(TYPE)), &src, sizeof(TYPE)); \ 15352cc12af3SMatheus Ferst } \ 15362cc12af3SMatheus Ferst } 15372cc12af3SMatheus Ferst VINSX(B, uint8_t) 15382cc12af3SMatheus Ferst VINSX(H, uint16_t) 15392cc12af3SMatheus Ferst VINSX(W, uint32_t) 15402cc12af3SMatheus Ferst VINSX(D, uint64_t) 15412cc12af3SMatheus Ferst #undef ELEM_ADDR 15422cc12af3SMatheus Ferst #undef VINSX 1543fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 154428110b72SMatheus Ferst #define VEXTDVLX(NAME, SIZE) \ 154528110b72SMatheus Ferst void helper_##NAME(CPUPPCState *env, ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, \ 154628110b72SMatheus Ferst target_ulong index) \ 154728110b72SMatheus Ferst { \ 154828110b72SMatheus Ferst const target_long idx = index; \ 154928110b72SMatheus Ferst ppc_avr_t tmp[2] = { *a, *b }; \ 155028110b72SMatheus Ferst memset(t, 0, sizeof(*t)); \ 155128110b72SMatheus Ferst if (idx >= 0 && idx + SIZE <= sizeof(tmp)) { \ 155228110b72SMatheus Ferst memcpy(&t->u8[ARRAY_SIZE(t->u8) / 2 - SIZE], (void *)tmp + idx, SIZE); \ 155328110b72SMatheus Ferst } else { \ 155428110b72SMatheus Ferst qemu_log_mask(LOG_GUEST_ERROR, "Invalid index for " #NAME " after 0x" \ 155528110b72SMatheus Ferst TARGET_FMT_lx ", RC = " TARGET_FMT_ld " > %d\n", \ 155628110b72SMatheus Ferst env->nip, idx < 0 ? SIZE - idx : idx, 32 - SIZE); \ 155728110b72SMatheus Ferst } \ 155828110b72SMatheus Ferst } 155928110b72SMatheus Ferst #else 156028110b72SMatheus Ferst #define VEXTDVLX(NAME, SIZE) \ 156128110b72SMatheus Ferst void helper_##NAME(CPUPPCState *env, ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, \ 156228110b72SMatheus Ferst target_ulong index) \ 156328110b72SMatheus Ferst { \ 156428110b72SMatheus Ferst const target_long idx = index; \ 156528110b72SMatheus Ferst ppc_avr_t tmp[2] = { *b, *a }; \ 156628110b72SMatheus Ferst memset(t, 0, sizeof(*t)); \ 156728110b72SMatheus Ferst if (idx >= 0 && idx + SIZE <= sizeof(tmp)) { \ 156828110b72SMatheus Ferst memcpy(&t->u8[ARRAY_SIZE(t->u8) / 2], \ 156928110b72SMatheus Ferst (void *)tmp + sizeof(tmp) - SIZE - idx, SIZE); \ 157028110b72SMatheus Ferst } else { \ 157128110b72SMatheus Ferst qemu_log_mask(LOG_GUEST_ERROR, "Invalid index for " #NAME " after 0x" \ 157228110b72SMatheus Ferst TARGET_FMT_lx ", RC = " TARGET_FMT_ld " > %d\n", \ 157328110b72SMatheus Ferst env->nip, idx < 0 ? SIZE - idx : idx, 32 - SIZE); \ 157428110b72SMatheus Ferst } \ 157528110b72SMatheus Ferst } 157628110b72SMatheus Ferst #endif 157728110b72SMatheus Ferst VEXTDVLX(VEXTDUBVLX, 1) 157828110b72SMatheus Ferst VEXTDVLX(VEXTDUHVLX, 2) 157928110b72SMatheus Ferst VEXTDVLX(VEXTDUWVLX, 4) 158028110b72SMatheus Ferst VEXTDVLX(VEXTDDVLX, 8) 158128110b72SMatheus Ferst #undef VEXTDVLX 158228110b72SMatheus Ferst #if defined(HOST_WORDS_BIGENDIAN) 1583fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1584fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1585fcf5ef2aSThomas Huth { \ 1586fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1587fcf5ef2aSThomas Huth memmove(&r->u8[8 - es], &b->u8[index], es); \ 1588fcf5ef2aSThomas Huth memset(&r->u8[8], 0, 8); \ 1589fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8 - es); \ 1590fcf5ef2aSThomas Huth } 1591fcf5ef2aSThomas Huth #else 1592fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1593fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1594fcf5ef2aSThomas Huth { \ 1595fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1596fcf5ef2aSThomas Huth uint32_t s = (16 - index) - es; \ 1597fcf5ef2aSThomas Huth memmove(&r->u8[8], &b->u8[s], es); \ 1598fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8); \ 1599fcf5ef2aSThomas Huth memset(&r->u8[8 + es], 0, 8 - es); \ 1600fcf5ef2aSThomas Huth } 1601fcf5ef2aSThomas Huth #endif 1602fcf5ef2aSThomas Huth VEXTRACT(ub, u8) 1603fcf5ef2aSThomas Huth VEXTRACT(uh, u16) 1604fcf5ef2aSThomas Huth VEXTRACT(uw, u32) 1605fcf5ef2aSThomas Huth VEXTRACT(d, u64) 1606fcf5ef2aSThomas Huth #undef VEXTRACT 1607fcf5ef2aSThomas Huth 1608fb5303ccSMatheus Ferst #define VSTRI(NAME, ELEM, NUM_ELEMS, LEFT) \ 1609fb5303ccSMatheus Ferst uint32_t helper_##NAME(ppc_avr_t *t, ppc_avr_t *b) \ 1610fb5303ccSMatheus Ferst { \ 1611fb5303ccSMatheus Ferst int i, idx, crf = 0; \ 1612fb5303ccSMatheus Ferst \ 1613fb5303ccSMatheus Ferst for (i = 0; i < NUM_ELEMS; i++) { \ 1614fb5303ccSMatheus Ferst idx = LEFT ? i : NUM_ELEMS - i - 1; \ 1615fb5303ccSMatheus Ferst if (b->Vsr##ELEM(idx)) { \ 1616fb5303ccSMatheus Ferst t->Vsr##ELEM(idx) = b->Vsr##ELEM(idx); \ 1617fb5303ccSMatheus Ferst } else { \ 1618fb5303ccSMatheus Ferst crf = 0b0010; \ 1619fb5303ccSMatheus Ferst break; \ 1620fb5303ccSMatheus Ferst } \ 1621fb5303ccSMatheus Ferst } \ 1622fb5303ccSMatheus Ferst \ 1623fb5303ccSMatheus Ferst for (; i < NUM_ELEMS; i++) { \ 1624fb5303ccSMatheus Ferst idx = LEFT ? i : NUM_ELEMS - i - 1; \ 1625fb5303ccSMatheus Ferst t->Vsr##ELEM(idx) = 0; \ 1626fb5303ccSMatheus Ferst } \ 1627fb5303ccSMatheus Ferst \ 1628fb5303ccSMatheus Ferst return crf; \ 1629fb5303ccSMatheus Ferst } 1630fb5303ccSMatheus Ferst VSTRI(VSTRIBL, B, 16, true) 1631fb5303ccSMatheus Ferst VSTRI(VSTRIBR, B, 16, false) 1632fb5303ccSMatheus Ferst VSTRI(VSTRIHL, H, 8, true) 1633fb5303ccSMatheus Ferst VSTRI(VSTRIHR, H, 8, false) 1634fb5303ccSMatheus Ferst #undef VSTRI 1635fb5303ccSMatheus Ferst 16365ba5335dSMark Cave-Ayland void helper_xxextractuw(CPUPPCState *env, ppc_vsr_t *xt, 16375ba5335dSMark Cave-Ayland ppc_vsr_t *xb, uint32_t index) 16388ad901e5SNikunj A Dadhania { 163903b32c09SMark Cave-Ayland ppc_vsr_t t = { }; 16408ad901e5SNikunj A Dadhania size_t es = sizeof(uint32_t); 16418ad901e5SNikunj A Dadhania uint32_t ext_index; 16428ad901e5SNikunj A Dadhania int i; 16438ad901e5SNikunj A Dadhania 16448ad901e5SNikunj A Dadhania ext_index = index; 16458ad901e5SNikunj A Dadhania for (i = 0; i < es; i++, ext_index++) { 164603b32c09SMark Cave-Ayland t.VsrB(8 - es + i) = xb->VsrB(ext_index % 16); 16478ad901e5SNikunj A Dadhania } 16488ad901e5SNikunj A Dadhania 164903b32c09SMark Cave-Ayland *xt = t; 16508ad901e5SNikunj A Dadhania } 16518ad901e5SNikunj A Dadhania 16525ba5335dSMark Cave-Ayland void helper_xxinsertw(CPUPPCState *env, ppc_vsr_t *xt, 16535ba5335dSMark Cave-Ayland ppc_vsr_t *xb, uint32_t index) 16543398b742SNikunj A Dadhania { 165503b32c09SMark Cave-Ayland ppc_vsr_t t = *xt; 16563398b742SNikunj A Dadhania size_t es = sizeof(uint32_t); 16573398b742SNikunj A Dadhania int ins_index, i = 0; 16583398b742SNikunj A Dadhania 16593398b742SNikunj A Dadhania ins_index = index; 16603398b742SNikunj A Dadhania for (i = 0; i < es && ins_index < 16; i++, ins_index++) { 166103b32c09SMark Cave-Ayland t.VsrB(ins_index) = xb->VsrB(8 - es + i); 16623398b742SNikunj A Dadhania } 16633398b742SNikunj A Dadhania 166403b32c09SMark Cave-Ayland *xt = t; 16653398b742SNikunj A Dadhania } 16663398b742SNikunj A Dadhania 16671015fcabSMatheus Ferst void helper_XXEVAL(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c, 16681015fcabSMatheus Ferst uint32_t desc) 16691015fcabSMatheus Ferst { 16701015fcabSMatheus Ferst /* 16711015fcabSMatheus Ferst * Instead of processing imm bit-by-bit, we'll skip the computation of 16721015fcabSMatheus Ferst * conjunctions whose corresponding bit is unset. 16731015fcabSMatheus Ferst */ 16741015fcabSMatheus Ferst int bit, imm = simd_data(desc); 16751015fcabSMatheus Ferst Int128 conj, disj = int128_zero(); 16761015fcabSMatheus Ferst 16771015fcabSMatheus Ferst /* Iterate over set bits from the least to the most significant bit */ 16781015fcabSMatheus Ferst while (imm) { 16791015fcabSMatheus Ferst /* 16801015fcabSMatheus Ferst * Get the next bit to be processed with ctz64. Invert the result of 16811015fcabSMatheus Ferst * ctz64 to match the indexing used by PowerISA. 16821015fcabSMatheus Ferst */ 16831015fcabSMatheus Ferst bit = 7 - ctzl(imm); 16841015fcabSMatheus Ferst if (bit & 0x4) { 16851015fcabSMatheus Ferst conj = a->s128; 16861015fcabSMatheus Ferst } else { 16871015fcabSMatheus Ferst conj = int128_not(a->s128); 16881015fcabSMatheus Ferst } 16891015fcabSMatheus Ferst if (bit & 0x2) { 16901015fcabSMatheus Ferst conj = int128_and(conj, b->s128); 16911015fcabSMatheus Ferst } else { 16921015fcabSMatheus Ferst conj = int128_and(conj, int128_not(b->s128)); 16931015fcabSMatheus Ferst } 16941015fcabSMatheus Ferst if (bit & 0x1) { 16951015fcabSMatheus Ferst conj = int128_and(conj, c->s128); 16961015fcabSMatheus Ferst } else { 16971015fcabSMatheus Ferst conj = int128_and(conj, int128_not(c->s128)); 16981015fcabSMatheus Ferst } 16991015fcabSMatheus Ferst disj = int128_or(disj, conj); 17001015fcabSMatheus Ferst 17011015fcabSMatheus Ferst /* Unset the least significant bit that is set */ 17021015fcabSMatheus Ferst imm &= imm - 1; 17031015fcabSMatheus Ferst } 17041015fcabSMatheus Ferst 17051015fcabSMatheus Ferst t->s128 = disj; 17061015fcabSMatheus Ferst } 17071015fcabSMatheus Ferst 1708788c6399SMatheus Ferst #define XXBLEND(name, sz) \ 1709788c6399SMatheus Ferst void glue(helper_XXBLENDV, name)(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, \ 1710788c6399SMatheus Ferst ppc_avr_t *c, uint32_t desc) \ 1711788c6399SMatheus Ferst { \ 1712788c6399SMatheus Ferst for (int i = 0; i < ARRAY_SIZE(t->glue(u, sz)); i++) { \ 1713788c6399SMatheus Ferst t->glue(u, sz)[i] = (c->glue(s, sz)[i] >> (sz - 1)) ? \ 1714788c6399SMatheus Ferst b->glue(u, sz)[i] : a->glue(u, sz)[i]; \ 1715788c6399SMatheus Ferst } \ 1716788c6399SMatheus Ferst } 1717788c6399SMatheus Ferst XXBLEND(B, 8) 1718788c6399SMatheus Ferst XXBLEND(H, 16) 1719788c6399SMatheus Ferst XXBLEND(W, 32) 1720788c6399SMatheus Ferst XXBLEND(D, 64) 1721788c6399SMatheus Ferst #undef XXBLEND 1722788c6399SMatheus Ferst 1723fcf5ef2aSThomas Huth #define VNEG(name, element) \ 1724fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 1725fcf5ef2aSThomas Huth { \ 1726fcf5ef2aSThomas Huth int i; \ 172760594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1728fcf5ef2aSThomas Huth r->element[i] = -b->element[i]; \ 1729fcf5ef2aSThomas Huth } \ 1730fcf5ef2aSThomas Huth } 1731fcf5ef2aSThomas Huth VNEG(vnegw, s32) 1732fcf5ef2aSThomas Huth VNEG(vnegd, s64) 1733fcf5ef2aSThomas Huth #undef VNEG 1734fcf5ef2aSThomas Huth 1735fcf5ef2aSThomas Huth void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1736fcf5ef2aSThomas Huth { 17373c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 1738fcf5ef2aSThomas Huth 1739fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1740fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1741fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1742fcf5ef2aSThomas Huth #else 1743fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1744fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 1745fcf5ef2aSThomas Huth #endif 1746fcf5ef2aSThomas Huth } 1747fcf5ef2aSThomas Huth 1748fcf5ef2aSThomas Huth void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1749fcf5ef2aSThomas Huth { 1750fcf5ef2aSThomas Huth int i; 1751fcf5ef2aSThomas Huth 1752fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 1753fcf5ef2aSThomas Huth r->u32[i] = a->u32[i] >= b->u32[i]; 1754fcf5ef2aSThomas Huth } 1755fcf5ef2aSThomas Huth } 1756fcf5ef2aSThomas Huth 1757fcf5ef2aSThomas Huth void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1758fcf5ef2aSThomas Huth { 1759fcf5ef2aSThomas Huth int64_t t; 1760fcf5ef2aSThomas Huth int i, upper; 1761fcf5ef2aSThomas Huth ppc_avr_t result; 1762fcf5ef2aSThomas Huth int sat = 0; 1763fcf5ef2aSThomas Huth 1764fcf5ef2aSThomas Huth upper = ARRAY_SIZE(r->s32) - 1; 176560594feaSMark Cave-Ayland t = (int64_t)b->VsrSW(upper); 1766fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 176760594feaSMark Cave-Ayland t += a->VsrSW(i); 176860594feaSMark Cave-Ayland result.VsrSW(i) = 0; 1769fcf5ef2aSThomas Huth } 177060594feaSMark Cave-Ayland result.VsrSW(upper) = cvtsdsw(t, &sat); 1771fcf5ef2aSThomas Huth *r = result; 1772fcf5ef2aSThomas Huth 1773fcf5ef2aSThomas Huth if (sat) { 17746175f5a0SRichard Henderson set_vscr_sat(env); 1775fcf5ef2aSThomas Huth } 1776fcf5ef2aSThomas Huth } 1777fcf5ef2aSThomas Huth 1778fcf5ef2aSThomas Huth void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1779fcf5ef2aSThomas Huth { 1780fcf5ef2aSThomas Huth int i, j, upper; 1781fcf5ef2aSThomas Huth ppc_avr_t result; 1782fcf5ef2aSThomas Huth int sat = 0; 1783fcf5ef2aSThomas Huth 1784fcf5ef2aSThomas Huth upper = 1; 1785fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 178660594feaSMark Cave-Ayland int64_t t = (int64_t)b->VsrSW(upper + i * 2); 1787fcf5ef2aSThomas Huth 17887fa0ddc1SAnton Blanchard result.VsrD(i) = 0; 1789fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u64); j++) { 179060594feaSMark Cave-Ayland t += a->VsrSW(2 * i + j); 1791fcf5ef2aSThomas Huth } 179260594feaSMark Cave-Ayland result.VsrSW(upper + i * 2) = cvtsdsw(t, &sat); 1793fcf5ef2aSThomas Huth } 1794fcf5ef2aSThomas Huth 1795fcf5ef2aSThomas Huth *r = result; 1796fcf5ef2aSThomas Huth if (sat) { 17976175f5a0SRichard Henderson set_vscr_sat(env); 1798fcf5ef2aSThomas Huth } 1799fcf5ef2aSThomas Huth } 1800fcf5ef2aSThomas Huth 1801fcf5ef2aSThomas Huth void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1802fcf5ef2aSThomas Huth { 1803fcf5ef2aSThomas Huth int i, j; 1804fcf5ef2aSThomas Huth int sat = 0; 1805fcf5ef2aSThomas Huth 1806fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 1807fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 1808fcf5ef2aSThomas Huth 1809fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->s32); j++) { 1810fcf5ef2aSThomas Huth t += a->s8[4 * i + j]; 1811fcf5ef2aSThomas Huth } 1812fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 1813fcf5ef2aSThomas Huth } 1814fcf5ef2aSThomas Huth 1815fcf5ef2aSThomas Huth if (sat) { 18166175f5a0SRichard Henderson set_vscr_sat(env); 1817fcf5ef2aSThomas Huth } 1818fcf5ef2aSThomas Huth } 1819fcf5ef2aSThomas Huth 1820fcf5ef2aSThomas Huth void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1821fcf5ef2aSThomas Huth { 1822fcf5ef2aSThomas Huth int sat = 0; 1823fcf5ef2aSThomas Huth int i; 1824fcf5ef2aSThomas Huth 1825fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 1826fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 1827fcf5ef2aSThomas Huth 1828fcf5ef2aSThomas Huth t += a->s16[2 * i] + a->s16[2 * i + 1]; 1829fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 1830fcf5ef2aSThomas Huth } 1831fcf5ef2aSThomas Huth 1832fcf5ef2aSThomas Huth if (sat) { 18336175f5a0SRichard Henderson set_vscr_sat(env); 1834fcf5ef2aSThomas Huth } 1835fcf5ef2aSThomas Huth } 1836fcf5ef2aSThomas Huth 1837fcf5ef2aSThomas Huth void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1838fcf5ef2aSThomas Huth { 1839fcf5ef2aSThomas Huth int i, j; 1840fcf5ef2aSThomas Huth int sat = 0; 1841fcf5ef2aSThomas Huth 1842fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 1843fcf5ef2aSThomas Huth uint64_t t = (uint64_t)b->u32[i]; 1844fcf5ef2aSThomas Huth 1845fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u32); j++) { 1846fcf5ef2aSThomas Huth t += a->u8[4 * i + j]; 1847fcf5ef2aSThomas Huth } 1848fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 1849fcf5ef2aSThomas Huth } 1850fcf5ef2aSThomas Huth 1851fcf5ef2aSThomas Huth if (sat) { 18526175f5a0SRichard Henderson set_vscr_sat(env); 1853fcf5ef2aSThomas Huth } 1854fcf5ef2aSThomas Huth } 1855fcf5ef2aSThomas Huth 1856fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1857fcf5ef2aSThomas Huth #define UPKHI 1 1858fcf5ef2aSThomas Huth #define UPKLO 0 1859fcf5ef2aSThomas Huth #else 1860fcf5ef2aSThomas Huth #define UPKHI 0 1861fcf5ef2aSThomas Huth #define UPKLO 1 1862fcf5ef2aSThomas Huth #endif 1863fcf5ef2aSThomas Huth #define VUPKPX(suffix, hi) \ 1864fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 1865fcf5ef2aSThomas Huth { \ 1866fcf5ef2aSThomas Huth int i; \ 1867fcf5ef2aSThomas Huth ppc_avr_t result; \ 1868fcf5ef2aSThomas Huth \ 1869fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { \ 1870fcf5ef2aSThomas Huth uint16_t e = b->u16[hi ? i : i + 4]; \ 1871fcf5ef2aSThomas Huth uint8_t a = (e >> 15) ? 0xff : 0; \ 1872fcf5ef2aSThomas Huth uint8_t r = (e >> 10) & 0x1f; \ 1873fcf5ef2aSThomas Huth uint8_t g = (e >> 5) & 0x1f; \ 1874fcf5ef2aSThomas Huth uint8_t b = e & 0x1f; \ 1875fcf5ef2aSThomas Huth \ 1876fcf5ef2aSThomas Huth result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b; \ 1877fcf5ef2aSThomas Huth } \ 1878fcf5ef2aSThomas Huth *r = result; \ 1879fcf5ef2aSThomas Huth } 1880fcf5ef2aSThomas Huth VUPKPX(lpx, UPKLO) 1881fcf5ef2aSThomas Huth VUPKPX(hpx, UPKHI) 1882fcf5ef2aSThomas Huth #undef VUPKPX 1883fcf5ef2aSThomas Huth 1884fcf5ef2aSThomas Huth #define VUPK(suffix, unpacked, packee, hi) \ 1885fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 1886fcf5ef2aSThomas Huth { \ 1887fcf5ef2aSThomas Huth int i; \ 1888fcf5ef2aSThomas Huth ppc_avr_t result; \ 1889fcf5ef2aSThomas Huth \ 1890fcf5ef2aSThomas Huth if (hi) { \ 1891fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) { \ 1892fcf5ef2aSThomas Huth result.unpacked[i] = b->packee[i]; \ 1893fcf5ef2aSThomas Huth } \ 1894fcf5ef2aSThomas Huth } else { \ 1895fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \ 1896fcf5ef2aSThomas Huth i++) { \ 1897fcf5ef2aSThomas Huth result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \ 1898fcf5ef2aSThomas Huth } \ 1899fcf5ef2aSThomas Huth } \ 1900fcf5ef2aSThomas Huth *r = result; \ 1901fcf5ef2aSThomas Huth } 1902fcf5ef2aSThomas Huth VUPK(hsb, s16, s8, UPKHI) 1903fcf5ef2aSThomas Huth VUPK(hsh, s32, s16, UPKHI) 1904fcf5ef2aSThomas Huth VUPK(hsw, s64, s32, UPKHI) 1905fcf5ef2aSThomas Huth VUPK(lsb, s16, s8, UPKLO) 1906fcf5ef2aSThomas Huth VUPK(lsh, s32, s16, UPKLO) 1907fcf5ef2aSThomas Huth VUPK(lsw, s64, s32, UPKLO) 1908fcf5ef2aSThomas Huth #undef VUPK 1909fcf5ef2aSThomas Huth #undef UPKHI 1910fcf5ef2aSThomas Huth #undef UPKLO 1911fcf5ef2aSThomas Huth 1912fcf5ef2aSThomas Huth #define VGENERIC_DO(name, element) \ 1913fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *b) \ 1914fcf5ef2aSThomas Huth { \ 1915fcf5ef2aSThomas Huth int i; \ 1916fcf5ef2aSThomas Huth \ 191760594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1918fcf5ef2aSThomas Huth r->element[i] = name(b->element[i]); \ 1919fcf5ef2aSThomas Huth } \ 1920fcf5ef2aSThomas Huth } 1921fcf5ef2aSThomas Huth 1922fcf5ef2aSThomas Huth #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8) 1923fcf5ef2aSThomas Huth #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16) 1924fcf5ef2aSThomas Huth 1925fcf5ef2aSThomas Huth VGENERIC_DO(clzb, u8) 1926fcf5ef2aSThomas Huth VGENERIC_DO(clzh, u16) 1927fcf5ef2aSThomas Huth 1928fcf5ef2aSThomas Huth #undef clzb 1929fcf5ef2aSThomas Huth #undef clzh 1930fcf5ef2aSThomas Huth 1931fcf5ef2aSThomas Huth #define ctzb(v) ((v) ? ctz32(v) : 8) 1932fcf5ef2aSThomas Huth #define ctzh(v) ((v) ? ctz32(v) : 16) 1933fcf5ef2aSThomas Huth #define ctzw(v) ctz32((v)) 1934fcf5ef2aSThomas Huth #define ctzd(v) ctz64((v)) 1935fcf5ef2aSThomas Huth 1936fcf5ef2aSThomas Huth VGENERIC_DO(ctzb, u8) 1937fcf5ef2aSThomas Huth VGENERIC_DO(ctzh, u16) 1938fcf5ef2aSThomas Huth VGENERIC_DO(ctzw, u32) 1939fcf5ef2aSThomas Huth VGENERIC_DO(ctzd, u64) 1940fcf5ef2aSThomas Huth 1941fcf5ef2aSThomas Huth #undef ctzb 1942fcf5ef2aSThomas Huth #undef ctzh 1943fcf5ef2aSThomas Huth #undef ctzw 1944fcf5ef2aSThomas Huth #undef ctzd 1945fcf5ef2aSThomas Huth 1946fcf5ef2aSThomas Huth #define popcntb(v) ctpop8(v) 1947fcf5ef2aSThomas Huth #define popcnth(v) ctpop16(v) 1948fcf5ef2aSThomas Huth #define popcntw(v) ctpop32(v) 1949fcf5ef2aSThomas Huth #define popcntd(v) ctpop64(v) 1950fcf5ef2aSThomas Huth 1951fcf5ef2aSThomas Huth VGENERIC_DO(popcntb, u8) 1952fcf5ef2aSThomas Huth VGENERIC_DO(popcnth, u16) 1953fcf5ef2aSThomas Huth VGENERIC_DO(popcntw, u32) 1954fcf5ef2aSThomas Huth VGENERIC_DO(popcntd, u64) 1955fcf5ef2aSThomas Huth 1956fcf5ef2aSThomas Huth #undef popcntb 1957fcf5ef2aSThomas Huth #undef popcnth 1958fcf5ef2aSThomas Huth #undef popcntw 1959fcf5ef2aSThomas Huth #undef popcntd 1960fcf5ef2aSThomas Huth 1961fcf5ef2aSThomas Huth #undef VGENERIC_DO 1962fcf5ef2aSThomas Huth 1963fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1964fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 0, 1 } } 1965fcf5ef2aSThomas Huth #else 1966fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 1, 0 } } 1967fcf5ef2aSThomas Huth #endif 1968fcf5ef2aSThomas Huth 1969fcf5ef2aSThomas Huth #ifndef CONFIG_INT128 1970fcf5ef2aSThomas Huth 1971fcf5ef2aSThomas Huth static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a) 1972fcf5ef2aSThomas Huth { 1973fcf5ef2aSThomas Huth t->u64[0] = ~a.u64[0]; 1974fcf5ef2aSThomas Huth t->u64[1] = ~a.u64[1]; 1975fcf5ef2aSThomas Huth } 1976fcf5ef2aSThomas Huth 1977fcf5ef2aSThomas Huth static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b) 1978fcf5ef2aSThomas Huth { 19793c385a93SMark Cave-Ayland if (a.VsrD(0) < b.VsrD(0)) { 1980fcf5ef2aSThomas Huth return -1; 19813c385a93SMark Cave-Ayland } else if (a.VsrD(0) > b.VsrD(0)) { 1982fcf5ef2aSThomas Huth return 1; 19833c385a93SMark Cave-Ayland } else if (a.VsrD(1) < b.VsrD(1)) { 1984fcf5ef2aSThomas Huth return -1; 19853c385a93SMark Cave-Ayland } else if (a.VsrD(1) > b.VsrD(1)) { 1986fcf5ef2aSThomas Huth return 1; 1987fcf5ef2aSThomas Huth } else { 1988fcf5ef2aSThomas Huth return 0; 1989fcf5ef2aSThomas Huth } 1990fcf5ef2aSThomas Huth } 1991fcf5ef2aSThomas Huth 1992fcf5ef2aSThomas Huth static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 1993fcf5ef2aSThomas Huth { 19943c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 19953c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 19963c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 1997fcf5ef2aSThomas Huth } 1998fcf5ef2aSThomas Huth 1999fcf5ef2aSThomas Huth static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 2000fcf5ef2aSThomas Huth { 2001fcf5ef2aSThomas Huth ppc_avr_t not_a; 20023c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 20033c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 20043c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 2005fcf5ef2aSThomas Huth avr_qw_not(¬_a, a); 2006fcf5ef2aSThomas Huth return avr_qw_cmpu(not_a, b) < 0; 2007fcf5ef2aSThomas Huth } 2008fcf5ef2aSThomas Huth 2009fcf5ef2aSThomas Huth #endif 2010fcf5ef2aSThomas Huth 2011fcf5ef2aSThomas Huth void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2012fcf5ef2aSThomas Huth { 2013fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2014fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128; 2015fcf5ef2aSThomas Huth #else 2016fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2017fcf5ef2aSThomas Huth #endif 2018fcf5ef2aSThomas Huth } 2019fcf5ef2aSThomas Huth 2020fcf5ef2aSThomas Huth void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2021fcf5ef2aSThomas Huth { 2022fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2023fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128 + (c->u128 & 1); 2024fcf5ef2aSThomas Huth #else 2025fcf5ef2aSThomas Huth 20263c385a93SMark Cave-Ayland if (c->VsrD(1) & 1) { 2027fcf5ef2aSThomas Huth ppc_avr_t tmp; 2028fcf5ef2aSThomas Huth 20293c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 20303c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 2031fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2032fcf5ef2aSThomas Huth avr_qw_add(r, tmp, *b); 2033fcf5ef2aSThomas Huth } else { 2034fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2035fcf5ef2aSThomas Huth } 2036fcf5ef2aSThomas Huth #endif 2037fcf5ef2aSThomas Huth } 2038fcf5ef2aSThomas Huth 2039fcf5ef2aSThomas Huth void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2040fcf5ef2aSThomas Huth { 2041fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2042fcf5ef2aSThomas Huth r->u128 = (~a->u128 < b->u128); 2043fcf5ef2aSThomas Huth #else 2044fcf5ef2aSThomas Huth ppc_avr_t not_a; 2045fcf5ef2aSThomas Huth 2046fcf5ef2aSThomas Huth avr_qw_not(¬_a, *a); 2047fcf5ef2aSThomas Huth 20483c385a93SMark Cave-Ayland r->VsrD(0) = 0; 20493c385a93SMark Cave-Ayland r->VsrD(1) = (avr_qw_cmpu(not_a, *b) < 0); 2050fcf5ef2aSThomas Huth #endif 2051fcf5ef2aSThomas Huth } 2052fcf5ef2aSThomas Huth 2053fcf5ef2aSThomas Huth void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2054fcf5ef2aSThomas Huth { 2055fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2056fcf5ef2aSThomas Huth int carry_out = (~a->u128 < b->u128); 2057fcf5ef2aSThomas Huth if (!carry_out && (c->u128 & 1)) { 2058fcf5ef2aSThomas Huth carry_out = ((a->u128 + b->u128 + 1) == 0) && 2059fcf5ef2aSThomas Huth ((a->u128 != 0) || (b->u128 != 0)); 2060fcf5ef2aSThomas Huth } 2061fcf5ef2aSThomas Huth r->u128 = carry_out; 2062fcf5ef2aSThomas Huth #else 2063fcf5ef2aSThomas Huth 20643c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2065fcf5ef2aSThomas Huth int carry_out = 0; 2066fcf5ef2aSThomas Huth ppc_avr_t tmp; 2067fcf5ef2aSThomas Huth 2068fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, *a, *b); 2069fcf5ef2aSThomas Huth 2070fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2071fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2072fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, tmp, one); 2073fcf5ef2aSThomas Huth } 20743c385a93SMark Cave-Ayland r->VsrD(0) = 0; 20753c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2076fcf5ef2aSThomas Huth #endif 2077fcf5ef2aSThomas Huth } 2078fcf5ef2aSThomas Huth 2079fcf5ef2aSThomas Huth void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2080fcf5ef2aSThomas Huth { 2081fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2082fcf5ef2aSThomas Huth r->u128 = a->u128 - b->u128; 2083fcf5ef2aSThomas Huth #else 2084fcf5ef2aSThomas Huth ppc_avr_t tmp; 2085fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2086fcf5ef2aSThomas Huth 2087fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2088fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2089fcf5ef2aSThomas Huth avr_qw_add(r, tmp, one); 2090fcf5ef2aSThomas Huth #endif 2091fcf5ef2aSThomas Huth } 2092fcf5ef2aSThomas Huth 2093fcf5ef2aSThomas Huth void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2094fcf5ef2aSThomas Huth { 2095fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2096fcf5ef2aSThomas Huth r->u128 = a->u128 + ~b->u128 + (c->u128 & 1); 2097fcf5ef2aSThomas Huth #else 2098fcf5ef2aSThomas Huth ppc_avr_t tmp, sum; 2099fcf5ef2aSThomas Huth 2100fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2101fcf5ef2aSThomas Huth avr_qw_add(&sum, *a, tmp); 2102fcf5ef2aSThomas Huth 21033c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 21043c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 2105fcf5ef2aSThomas Huth avr_qw_add(r, sum, tmp); 2106fcf5ef2aSThomas Huth #endif 2107fcf5ef2aSThomas Huth } 2108fcf5ef2aSThomas Huth 2109fcf5ef2aSThomas Huth void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2110fcf5ef2aSThomas Huth { 2111fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2112fcf5ef2aSThomas Huth r->u128 = (~a->u128 < ~b->u128) || 2113fcf5ef2aSThomas Huth (a->u128 + ~b->u128 == (__uint128_t)-1); 2114fcf5ef2aSThomas Huth #else 2115fcf5ef2aSThomas Huth int carry = (avr_qw_cmpu(*a, *b) > 0); 2116fcf5ef2aSThomas Huth if (!carry) { 2117fcf5ef2aSThomas Huth ppc_avr_t tmp; 2118fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2119fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 21203c385a93SMark Cave-Ayland carry = ((tmp.VsrSD(0) == -1ull) && (tmp.VsrSD(1) == -1ull)); 2121fcf5ef2aSThomas Huth } 21223c385a93SMark Cave-Ayland r->VsrD(0) = 0; 21233c385a93SMark Cave-Ayland r->VsrD(1) = carry; 2124fcf5ef2aSThomas Huth #endif 2125fcf5ef2aSThomas Huth } 2126fcf5ef2aSThomas Huth 2127fcf5ef2aSThomas Huth void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2128fcf5ef2aSThomas Huth { 2129fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2130fcf5ef2aSThomas Huth r->u128 = 2131fcf5ef2aSThomas Huth (~a->u128 < ~b->u128) || 2132fcf5ef2aSThomas Huth ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1)); 2133fcf5ef2aSThomas Huth #else 21343c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2135fcf5ef2aSThomas Huth int carry_out = (avr_qw_cmpu(*a, *b) > 0); 2136fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2137fcf5ef2aSThomas Huth ppc_avr_t tmp; 2138fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2139fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 21403c385a93SMark Cave-Ayland carry_out = ((tmp.VsrD(0) == -1ull) && (tmp.VsrD(1) == -1ull)); 2141fcf5ef2aSThomas Huth } 2142fcf5ef2aSThomas Huth 21433c385a93SMark Cave-Ayland r->VsrD(0) = 0; 21443c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2145fcf5ef2aSThomas Huth #endif 2146fcf5ef2aSThomas Huth } 2147fcf5ef2aSThomas Huth 2148fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_1 0xC 2149fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_2 0xF 2150fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_1 0xA 2151fcf5ef2aSThomas Huth #define BCD_NEG_PREF 0xD 2152fcf5ef2aSThomas Huth #define BCD_NEG_ALT 0xB 2153fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_2 0xE 2154fcf5ef2aSThomas Huth #define NATIONAL_PLUS 0x2B 2155fcf5ef2aSThomas Huth #define NATIONAL_NEG 0x2D 2156fcf5ef2aSThomas Huth 2157365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) (15 - ((n) / 2)) 2158fcf5ef2aSThomas Huth 2159fcf5ef2aSThomas Huth static int bcd_get_sgn(ppc_avr_t *bcd) 2160fcf5ef2aSThomas Huth { 2161428115c3SMark Cave-Ayland switch (bcd->VsrB(BCD_DIG_BYTE(0)) & 0xF) { 2162fcf5ef2aSThomas Huth case BCD_PLUS_PREF_1: 2163fcf5ef2aSThomas Huth case BCD_PLUS_PREF_2: 2164fcf5ef2aSThomas Huth case BCD_PLUS_ALT_1: 2165fcf5ef2aSThomas Huth case BCD_PLUS_ALT_2: 2166fcf5ef2aSThomas Huth { 2167fcf5ef2aSThomas Huth return 1; 2168fcf5ef2aSThomas Huth } 2169fcf5ef2aSThomas Huth 2170fcf5ef2aSThomas Huth case BCD_NEG_PREF: 2171fcf5ef2aSThomas Huth case BCD_NEG_ALT: 2172fcf5ef2aSThomas Huth { 2173fcf5ef2aSThomas Huth return -1; 2174fcf5ef2aSThomas Huth } 2175fcf5ef2aSThomas Huth 2176fcf5ef2aSThomas Huth default: 2177fcf5ef2aSThomas Huth { 2178fcf5ef2aSThomas Huth return 0; 2179fcf5ef2aSThomas Huth } 2180fcf5ef2aSThomas Huth } 2181fcf5ef2aSThomas Huth } 2182fcf5ef2aSThomas Huth 2183fcf5ef2aSThomas Huth static int bcd_preferred_sgn(int sgn, int ps) 2184fcf5ef2aSThomas Huth { 2185fcf5ef2aSThomas Huth if (sgn >= 0) { 2186fcf5ef2aSThomas Huth return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2; 2187fcf5ef2aSThomas Huth } else { 2188fcf5ef2aSThomas Huth return BCD_NEG_PREF; 2189fcf5ef2aSThomas Huth } 2190fcf5ef2aSThomas Huth } 2191fcf5ef2aSThomas Huth 2192fcf5ef2aSThomas Huth static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid) 2193fcf5ef2aSThomas Huth { 2194fcf5ef2aSThomas Huth uint8_t result; 2195fcf5ef2aSThomas Huth if (n & 1) { 2196428115c3SMark Cave-Ayland result = bcd->VsrB(BCD_DIG_BYTE(n)) >> 4; 2197fcf5ef2aSThomas Huth } else { 2198428115c3SMark Cave-Ayland result = bcd->VsrB(BCD_DIG_BYTE(n)) & 0xF; 2199fcf5ef2aSThomas Huth } 2200fcf5ef2aSThomas Huth 2201fcf5ef2aSThomas Huth if (unlikely(result > 9)) { 2202fcf5ef2aSThomas Huth *invalid = true; 2203fcf5ef2aSThomas Huth } 2204fcf5ef2aSThomas Huth return result; 2205fcf5ef2aSThomas Huth } 2206fcf5ef2aSThomas Huth 2207fcf5ef2aSThomas Huth static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n) 2208fcf5ef2aSThomas Huth { 2209fcf5ef2aSThomas Huth if (n & 1) { 2210428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) &= 0x0F; 2211428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) |= (digit << 4); 2212fcf5ef2aSThomas Huth } else { 2213428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) &= 0xF0; 2214428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) |= digit; 2215fcf5ef2aSThomas Huth } 2216fcf5ef2aSThomas Huth } 2217fcf5ef2aSThomas Huth 2218071663dfSJose Ricardo Ziviani static bool bcd_is_valid(ppc_avr_t *bcd) 2219071663dfSJose Ricardo Ziviani { 2220071663dfSJose Ricardo Ziviani int i; 2221071663dfSJose Ricardo Ziviani int invalid = 0; 2222071663dfSJose Ricardo Ziviani 2223071663dfSJose Ricardo Ziviani if (bcd_get_sgn(bcd) == 0) { 2224071663dfSJose Ricardo Ziviani return false; 2225071663dfSJose Ricardo Ziviani } 2226071663dfSJose Ricardo Ziviani 2227071663dfSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2228071663dfSJose Ricardo Ziviani bcd_get_digit(bcd, i, &invalid); 2229071663dfSJose Ricardo Ziviani if (unlikely(invalid)) { 2230071663dfSJose Ricardo Ziviani return false; 2231071663dfSJose Ricardo Ziviani } 2232071663dfSJose Ricardo Ziviani } 2233071663dfSJose Ricardo Ziviani return true; 2234071663dfSJose Ricardo Ziviani } 2235071663dfSJose Ricardo Ziviani 2236fcf5ef2aSThomas Huth static int bcd_cmp_zero(ppc_avr_t *bcd) 2237fcf5ef2aSThomas Huth { 22383c385a93SMark Cave-Ayland if (bcd->VsrD(0) == 0 && (bcd->VsrD(1) >> 4) == 0) { 2239efa73196SNikunj A Dadhania return CRF_EQ; 2240fcf5ef2aSThomas Huth } else { 2241efa73196SNikunj A Dadhania return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT; 2242fcf5ef2aSThomas Huth } 2243fcf5ef2aSThomas Huth } 2244fcf5ef2aSThomas Huth 2245fcf5ef2aSThomas Huth static uint16_t get_national_digit(ppc_avr_t *reg, int n) 2246fcf5ef2aSThomas Huth { 224760594feaSMark Cave-Ayland return reg->VsrH(7 - n); 2248fcf5ef2aSThomas Huth } 2249fcf5ef2aSThomas Huth 2250fcf5ef2aSThomas Huth static void set_national_digit(ppc_avr_t *reg, uint8_t val, int n) 2251fcf5ef2aSThomas Huth { 225260594feaSMark Cave-Ayland reg->VsrH(7 - n) = val; 2253fcf5ef2aSThomas Huth } 2254fcf5ef2aSThomas Huth 2255fcf5ef2aSThomas Huth static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b) 2256fcf5ef2aSThomas Huth { 2257fcf5ef2aSThomas Huth int i; 2258fcf5ef2aSThomas Huth int invalid = 0; 2259fcf5ef2aSThomas Huth for (i = 31; i > 0; i--) { 2260fcf5ef2aSThomas Huth uint8_t dig_a = bcd_get_digit(a, i, &invalid); 2261fcf5ef2aSThomas Huth uint8_t dig_b = bcd_get_digit(b, i, &invalid); 2262fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2263fcf5ef2aSThomas Huth return 0; /* doesn't matter */ 2264fcf5ef2aSThomas Huth } else if (dig_a > dig_b) { 2265fcf5ef2aSThomas Huth return 1; 2266fcf5ef2aSThomas Huth } else if (dig_a < dig_b) { 2267fcf5ef2aSThomas Huth return -1; 2268fcf5ef2aSThomas Huth } 2269fcf5ef2aSThomas Huth } 2270fcf5ef2aSThomas Huth 2271fcf5ef2aSThomas Huth return 0; 2272fcf5ef2aSThomas Huth } 2273fcf5ef2aSThomas Huth 2274936fda4dSFabiano Rosas static int bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2275fcf5ef2aSThomas Huth int *overflow) 2276fcf5ef2aSThomas Huth { 2277fcf5ef2aSThomas Huth int carry = 0; 2278fcf5ef2aSThomas Huth int i; 2279936fda4dSFabiano Rosas int is_zero = 1; 2280936fda4dSFabiano Rosas 2281fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2282fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) + 2283fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2284936fda4dSFabiano Rosas is_zero &= (digit == 0); 2285fcf5ef2aSThomas Huth if (digit > 9) { 2286fcf5ef2aSThomas Huth carry = 1; 2287fcf5ef2aSThomas Huth digit -= 10; 2288fcf5ef2aSThomas Huth } else { 2289fcf5ef2aSThomas Huth carry = 0; 2290fcf5ef2aSThomas Huth } 2291fcf5ef2aSThomas Huth 2292fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2293fcf5ef2aSThomas Huth } 2294fcf5ef2aSThomas Huth 2295fcf5ef2aSThomas Huth *overflow = carry; 2296936fda4dSFabiano Rosas return is_zero; 2297fcf5ef2aSThomas Huth } 2298fcf5ef2aSThomas Huth 2299d03b174aSYasmin Beatriz static void bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2300fcf5ef2aSThomas Huth int *overflow) 2301fcf5ef2aSThomas Huth { 2302fcf5ef2aSThomas Huth int carry = 0; 2303fcf5ef2aSThomas Huth int i; 2304d03b174aSYasmin Beatriz 2305fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2306fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) - 2307fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2308fcf5ef2aSThomas Huth if (digit & 0x80) { 2309fcf5ef2aSThomas Huth carry = -1; 2310fcf5ef2aSThomas Huth digit += 10; 2311fcf5ef2aSThomas Huth } else { 2312fcf5ef2aSThomas Huth carry = 0; 2313fcf5ef2aSThomas Huth } 2314fcf5ef2aSThomas Huth 2315fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2316fcf5ef2aSThomas Huth } 2317fcf5ef2aSThomas Huth 2318fcf5ef2aSThomas Huth *overflow = carry; 2319fcf5ef2aSThomas Huth } 2320fcf5ef2aSThomas Huth 2321fcf5ef2aSThomas Huth uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2322fcf5ef2aSThomas Huth { 2323fcf5ef2aSThomas Huth 2324fcf5ef2aSThomas Huth int sgna = bcd_get_sgn(a); 2325fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2326fcf5ef2aSThomas Huth int invalid = (sgna == 0) || (sgnb == 0); 2327fcf5ef2aSThomas Huth int overflow = 0; 2328936fda4dSFabiano Rosas int zero = 0; 2329fcf5ef2aSThomas Huth uint32_t cr = 0; 2330fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 2331fcf5ef2aSThomas Huth 2332fcf5ef2aSThomas Huth if (!invalid) { 2333fcf5ef2aSThomas Huth if (sgna == sgnb) { 2334428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgna, ps); 2335936fda4dSFabiano Rosas zero = bcd_add_mag(&result, a, b, &invalid, &overflow); 2336936fda4dSFabiano Rosas cr = (sgna > 0) ? CRF_GT : CRF_LT; 2337fcf5ef2aSThomas Huth } else { 2338d03b174aSYasmin Beatriz int magnitude = bcd_cmp_mag(a, b); 2339d03b174aSYasmin Beatriz if (magnitude > 0) { 2340428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgna, ps); 2341d03b174aSYasmin Beatriz bcd_sub_mag(&result, a, b, &invalid, &overflow); 2342d03b174aSYasmin Beatriz cr = (sgna > 0) ? CRF_GT : CRF_LT; 2343d03b174aSYasmin Beatriz } else if (magnitude < 0) { 2344428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgnb, ps); 2345d03b174aSYasmin Beatriz bcd_sub_mag(&result, b, a, &invalid, &overflow); 2346efa73196SNikunj A Dadhania cr = (sgnb > 0) ? CRF_GT : CRF_LT; 2347d03b174aSYasmin Beatriz } else { 2348428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(0, ps); 2349d03b174aSYasmin Beatriz cr = CRF_EQ; 2350d03b174aSYasmin Beatriz } 2351fcf5ef2aSThomas Huth } 2352fcf5ef2aSThomas Huth } 2353fcf5ef2aSThomas Huth 2354fcf5ef2aSThomas Huth if (unlikely(invalid)) { 23553c385a93SMark Cave-Ayland result.VsrD(0) = result.VsrD(1) = -1; 2356efa73196SNikunj A Dadhania cr = CRF_SO; 2357fcf5ef2aSThomas Huth } else if (overflow) { 2358efa73196SNikunj A Dadhania cr |= CRF_SO; 2359936fda4dSFabiano Rosas } else if (zero) { 2360936fda4dSFabiano Rosas cr |= CRF_EQ; 2361fcf5ef2aSThomas Huth } 2362fcf5ef2aSThomas Huth 2363fcf5ef2aSThomas Huth *r = result; 2364fcf5ef2aSThomas Huth 2365fcf5ef2aSThomas Huth return cr; 2366fcf5ef2aSThomas Huth } 2367fcf5ef2aSThomas Huth 2368fcf5ef2aSThomas Huth uint32_t helper_bcdsub(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2369fcf5ef2aSThomas Huth { 2370fcf5ef2aSThomas Huth ppc_avr_t bcopy = *b; 2371fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2372fcf5ef2aSThomas Huth if (sgnb < 0) { 2373fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0); 2374fcf5ef2aSThomas Huth } else if (sgnb > 0) { 2375fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_NEG_PREF, 0); 2376fcf5ef2aSThomas Huth } 2377fcf5ef2aSThomas Huth /* else invalid ... defer to bcdadd code for proper handling */ 2378fcf5ef2aSThomas Huth 2379fcf5ef2aSThomas Huth return helper_bcdadd(r, a, &bcopy, ps); 2380fcf5ef2aSThomas Huth } 2381fcf5ef2aSThomas Huth 2382fcf5ef2aSThomas Huth uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2383fcf5ef2aSThomas Huth { 2384fcf5ef2aSThomas Huth int i; 2385fcf5ef2aSThomas Huth int cr = 0; 2386fcf5ef2aSThomas Huth uint16_t national = 0; 2387fcf5ef2aSThomas Huth uint16_t sgnb = get_national_digit(b, 0); 2388fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2389fcf5ef2aSThomas Huth int invalid = (sgnb != NATIONAL_PLUS && sgnb != NATIONAL_NEG); 2390fcf5ef2aSThomas Huth 2391fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2392fcf5ef2aSThomas Huth national = get_national_digit(b, i); 2393fcf5ef2aSThomas Huth if (unlikely(national < 0x30 || national > 0x39)) { 2394fcf5ef2aSThomas Huth invalid = 1; 2395fcf5ef2aSThomas Huth break; 2396fcf5ef2aSThomas Huth } 2397fcf5ef2aSThomas Huth 2398fcf5ef2aSThomas Huth bcd_put_digit(&ret, national & 0xf, i); 2399fcf5ef2aSThomas Huth } 2400fcf5ef2aSThomas Huth 2401fcf5ef2aSThomas Huth if (sgnb == NATIONAL_PLUS) { 2402fcf5ef2aSThomas Huth bcd_put_digit(&ret, (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2, 0); 2403fcf5ef2aSThomas Huth } else { 2404fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2405fcf5ef2aSThomas Huth } 2406fcf5ef2aSThomas Huth 2407fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2408fcf5ef2aSThomas Huth 2409fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2410efa73196SNikunj A Dadhania cr = CRF_SO; 2411fcf5ef2aSThomas Huth } 2412fcf5ef2aSThomas Huth 2413fcf5ef2aSThomas Huth *r = ret; 2414fcf5ef2aSThomas Huth 2415fcf5ef2aSThomas Huth return cr; 2416fcf5ef2aSThomas Huth } 2417fcf5ef2aSThomas Huth 2418fcf5ef2aSThomas Huth uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2419fcf5ef2aSThomas Huth { 2420fcf5ef2aSThomas Huth int i; 2421fcf5ef2aSThomas Huth int cr = 0; 2422fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2423fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2424fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2425fcf5ef2aSThomas Huth 24263c385a93SMark Cave-Ayland int ox_flag = (b->VsrD(0) != 0) || ((b->VsrD(1) >> 32) != 0); 2427fcf5ef2aSThomas Huth 2428fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2429fcf5ef2aSThomas Huth set_national_digit(&ret, 0x30 + bcd_get_digit(b, i, &invalid), i); 2430fcf5ef2aSThomas Huth 2431fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2432fcf5ef2aSThomas Huth break; 2433fcf5ef2aSThomas Huth } 2434fcf5ef2aSThomas Huth } 2435fcf5ef2aSThomas Huth set_national_digit(&ret, (sgnb == -1) ? NATIONAL_NEG : NATIONAL_PLUS, 0); 2436fcf5ef2aSThomas Huth 2437fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2438fcf5ef2aSThomas Huth 2439fcf5ef2aSThomas Huth if (ox_flag) { 2440efa73196SNikunj A Dadhania cr |= CRF_SO; 2441fcf5ef2aSThomas Huth } 2442fcf5ef2aSThomas Huth 2443fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2444efa73196SNikunj A Dadhania cr = CRF_SO; 2445fcf5ef2aSThomas Huth } 2446fcf5ef2aSThomas Huth 2447fcf5ef2aSThomas Huth *r = ret; 2448fcf5ef2aSThomas Huth 2449fcf5ef2aSThomas Huth return cr; 2450fcf5ef2aSThomas Huth } 2451fcf5ef2aSThomas Huth 2452fcf5ef2aSThomas Huth uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2453fcf5ef2aSThomas Huth { 2454fcf5ef2aSThomas Huth int i; 2455fcf5ef2aSThomas Huth int cr = 0; 2456fcf5ef2aSThomas Huth int invalid = 0; 2457fcf5ef2aSThomas Huth int zone_digit = 0; 2458fcf5ef2aSThomas Huth int zone_lead = ps ? 0xF : 0x3; 2459fcf5ef2aSThomas Huth int digit = 0; 2460fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2461428115c3SMark Cave-Ayland int sgnb = b->VsrB(BCD_DIG_BYTE(0)) >> 4; 2462fcf5ef2aSThomas Huth 2463fcf5ef2aSThomas Huth if (unlikely((sgnb < 0xA) && ps)) { 2464fcf5ef2aSThomas Huth invalid = 1; 2465fcf5ef2aSThomas Huth } 2466fcf5ef2aSThomas Huth 2467fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2468428115c3SMark Cave-Ayland zone_digit = i ? b->VsrB(BCD_DIG_BYTE(i * 2)) >> 4 : zone_lead; 2469428115c3SMark Cave-Ayland digit = b->VsrB(BCD_DIG_BYTE(i * 2)) & 0xF; 2470fcf5ef2aSThomas Huth if (unlikely(zone_digit != zone_lead || digit > 0x9)) { 2471fcf5ef2aSThomas Huth invalid = 1; 2472fcf5ef2aSThomas Huth break; 2473fcf5ef2aSThomas Huth } 2474fcf5ef2aSThomas Huth 2475fcf5ef2aSThomas Huth bcd_put_digit(&ret, digit, i + 1); 2476fcf5ef2aSThomas Huth } 2477fcf5ef2aSThomas Huth 2478fcf5ef2aSThomas Huth if ((ps && (sgnb == 0xB || sgnb == 0xD)) || 2479fcf5ef2aSThomas Huth (!ps && (sgnb & 0x4))) { 2480fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2481fcf5ef2aSThomas Huth } else { 2482fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_PLUS_PREF_1, 0); 2483fcf5ef2aSThomas Huth } 2484fcf5ef2aSThomas Huth 2485fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2486fcf5ef2aSThomas Huth 2487fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2488efa73196SNikunj A Dadhania cr = CRF_SO; 2489fcf5ef2aSThomas Huth } 2490fcf5ef2aSThomas Huth 2491fcf5ef2aSThomas Huth *r = ret; 2492fcf5ef2aSThomas Huth 2493fcf5ef2aSThomas Huth return cr; 2494fcf5ef2aSThomas Huth } 2495fcf5ef2aSThomas Huth 2496fcf5ef2aSThomas Huth uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2497fcf5ef2aSThomas Huth { 2498fcf5ef2aSThomas Huth int i; 2499fcf5ef2aSThomas Huth int cr = 0; 2500fcf5ef2aSThomas Huth uint8_t digit = 0; 2501fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2502fcf5ef2aSThomas Huth int zone_lead = (ps) ? 0xF0 : 0x30; 2503fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2504fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2505fcf5ef2aSThomas Huth 25063c385a93SMark Cave-Ayland int ox_flag = ((b->VsrD(0) >> 4) != 0); 2507fcf5ef2aSThomas Huth 2508fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2509fcf5ef2aSThomas Huth digit = bcd_get_digit(b, i + 1, &invalid); 2510fcf5ef2aSThomas Huth 2511fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2512fcf5ef2aSThomas Huth break; 2513fcf5ef2aSThomas Huth } 2514fcf5ef2aSThomas Huth 2515428115c3SMark Cave-Ayland ret.VsrB(BCD_DIG_BYTE(i * 2)) = zone_lead + digit; 2516fcf5ef2aSThomas Huth } 2517fcf5ef2aSThomas Huth 2518fcf5ef2aSThomas Huth if (ps) { 2519fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0xC : 0xD, 1); 2520fcf5ef2aSThomas Huth } else { 2521fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0x3 : 0x7, 1); 2522fcf5ef2aSThomas Huth } 2523fcf5ef2aSThomas Huth 2524fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2525fcf5ef2aSThomas Huth 2526fcf5ef2aSThomas Huth if (ox_flag) { 2527efa73196SNikunj A Dadhania cr |= CRF_SO; 2528fcf5ef2aSThomas Huth } 2529fcf5ef2aSThomas Huth 2530fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2531efa73196SNikunj A Dadhania cr = CRF_SO; 2532fcf5ef2aSThomas Huth } 2533fcf5ef2aSThomas Huth 2534fcf5ef2aSThomas Huth *r = ret; 2535fcf5ef2aSThomas Huth 2536fcf5ef2aSThomas Huth return cr; 2537fcf5ef2aSThomas Huth } 2538fcf5ef2aSThomas Huth 2539a3d67f3eSLuis Pires /** 2540a3d67f3eSLuis Pires * Compare 2 128-bit unsigned integers, passed in as unsigned 64-bit pairs 2541a3d67f3eSLuis Pires * 2542a3d67f3eSLuis Pires * Returns: 2543a3d67f3eSLuis Pires * > 0 if ahi|alo > bhi|blo, 2544a3d67f3eSLuis Pires * 0 if ahi|alo == bhi|blo, 2545a3d67f3eSLuis Pires * < 0 if ahi|alo < bhi|blo 2546a3d67f3eSLuis Pires */ 2547a3d67f3eSLuis Pires static inline int ucmp128(uint64_t alo, uint64_t ahi, 2548a3d67f3eSLuis Pires uint64_t blo, uint64_t bhi) 2549a3d67f3eSLuis Pires { 2550a3d67f3eSLuis Pires return (ahi == bhi) ? 2551a3d67f3eSLuis Pires (alo > blo ? 1 : (alo == blo ? 0 : -1)) : 2552a3d67f3eSLuis Pires (ahi > bhi ? 1 : -1); 2553a3d67f3eSLuis Pires } 2554a3d67f3eSLuis Pires 2555a406c058SJose Ricardo Ziviani uint32_t helper_bcdcfsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2556a406c058SJose Ricardo Ziviani { 2557a406c058SJose Ricardo Ziviani int i; 2558a3d67f3eSLuis Pires int cr; 2559a406c058SJose Ricardo Ziviani uint64_t lo_value; 2560a406c058SJose Ricardo Ziviani uint64_t hi_value; 256140f3e79aSLuis Pires uint64_t rem; 2562a406c058SJose Ricardo Ziviani ppc_avr_t ret = { .u64 = { 0, 0 } }; 2563a406c058SJose Ricardo Ziviani 25643c385a93SMark Cave-Ayland if (b->VsrSD(0) < 0) { 25653c385a93SMark Cave-Ayland lo_value = -b->VsrSD(1); 25663c385a93SMark Cave-Ayland hi_value = ~b->VsrD(0) + !lo_value; 2567a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, 0xD, 0); 2568a3d67f3eSLuis Pires 2569a3d67f3eSLuis Pires cr = CRF_LT; 2570a406c058SJose Ricardo Ziviani } else { 25713c385a93SMark Cave-Ayland lo_value = b->VsrD(1); 25723c385a93SMark Cave-Ayland hi_value = b->VsrD(0); 2573a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(0, ps), 0); 2574a3d67f3eSLuis Pires 2575a3d67f3eSLuis Pires if (hi_value == 0 && lo_value == 0) { 2576a3d67f3eSLuis Pires cr = CRF_EQ; 2577a3d67f3eSLuis Pires } else { 2578a3d67f3eSLuis Pires cr = CRF_GT; 2579a3d67f3eSLuis Pires } 2580a406c058SJose Ricardo Ziviani } 2581a406c058SJose Ricardo Ziviani 2582a3d67f3eSLuis Pires /* 2583a3d67f3eSLuis Pires * Check src limits: abs(src) <= 10^31 - 1 2584a3d67f3eSLuis Pires * 2585a3d67f3eSLuis Pires * 10^31 - 1 = 0x0000007e37be2022 c0914b267fffffff 2586a3d67f3eSLuis Pires */ 2587a3d67f3eSLuis Pires if (ucmp128(lo_value, hi_value, 2588a3d67f3eSLuis Pires 0xc0914b267fffffffULL, 0x7e37be2022ULL) > 0) { 2589a3d67f3eSLuis Pires cr |= CRF_SO; 2590a3d67f3eSLuis Pires 2591a3d67f3eSLuis Pires /* 2592a3d67f3eSLuis Pires * According to the ISA, if src wouldn't fit in the destination 2593a3d67f3eSLuis Pires * register, the result is undefined. 2594a3d67f3eSLuis Pires * In that case, we leave r unchanged. 2595a3d67f3eSLuis Pires */ 2596a3d67f3eSLuis Pires } else { 259740f3e79aSLuis Pires rem = divu128(&lo_value, &hi_value, 1000000000000000ULL); 2598a406c058SJose Ricardo Ziviani 259940f3e79aSLuis Pires for (i = 1; i < 16; rem /= 10, i++) { 260040f3e79aSLuis Pires bcd_put_digit(&ret, rem % 10, i); 2601a406c058SJose Ricardo Ziviani } 2602a406c058SJose Ricardo Ziviani 2603a406c058SJose Ricardo Ziviani for (; i < 32; lo_value /= 10, i++) { 2604a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, lo_value % 10, i); 2605a406c058SJose Ricardo Ziviani } 2606a406c058SJose Ricardo Ziviani 2607a406c058SJose Ricardo Ziviani *r = ret; 2608a3d67f3eSLuis Pires } 2609a406c058SJose Ricardo Ziviani 2610a406c058SJose Ricardo Ziviani return cr; 2611a406c058SJose Ricardo Ziviani } 2612a406c058SJose Ricardo Ziviani 2613c85bc7ddSJose Ricardo Ziviani uint32_t helper_bcdctsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2614c85bc7ddSJose Ricardo Ziviani { 2615c85bc7ddSJose Ricardo Ziviani uint8_t i; 2616c85bc7ddSJose Ricardo Ziviani int cr; 2617c85bc7ddSJose Ricardo Ziviani uint64_t carry; 2618c85bc7ddSJose Ricardo Ziviani uint64_t unused; 2619c85bc7ddSJose Ricardo Ziviani uint64_t lo_value; 2620c85bc7ddSJose Ricardo Ziviani uint64_t hi_value = 0; 2621c85bc7ddSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2622c85bc7ddSJose Ricardo Ziviani int invalid = (sgnb == 0); 2623c85bc7ddSJose Ricardo Ziviani 2624c85bc7ddSJose Ricardo Ziviani lo_value = bcd_get_digit(b, 31, &invalid); 2625c85bc7ddSJose Ricardo Ziviani for (i = 30; i > 0; i--) { 2626c85bc7ddSJose Ricardo Ziviani mulu64(&lo_value, &carry, lo_value, 10ULL); 2627c85bc7ddSJose Ricardo Ziviani mulu64(&hi_value, &unused, hi_value, 10ULL); 2628c85bc7ddSJose Ricardo Ziviani lo_value += bcd_get_digit(b, i, &invalid); 2629c85bc7ddSJose Ricardo Ziviani hi_value += carry; 2630c85bc7ddSJose Ricardo Ziviani 2631c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2632c85bc7ddSJose Ricardo Ziviani break; 2633c85bc7ddSJose Ricardo Ziviani } 2634c85bc7ddSJose Ricardo Ziviani } 2635c85bc7ddSJose Ricardo Ziviani 2636c85bc7ddSJose Ricardo Ziviani if (sgnb == -1) { 26373c385a93SMark Cave-Ayland r->VsrSD(1) = -lo_value; 26383c385a93SMark Cave-Ayland r->VsrSD(0) = ~hi_value + !r->VsrSD(1); 2639c85bc7ddSJose Ricardo Ziviani } else { 26403c385a93SMark Cave-Ayland r->VsrSD(1) = lo_value; 26413c385a93SMark Cave-Ayland r->VsrSD(0) = hi_value; 2642c85bc7ddSJose Ricardo Ziviani } 2643c85bc7ddSJose Ricardo Ziviani 2644c85bc7ddSJose Ricardo Ziviani cr = bcd_cmp_zero(b); 2645c85bc7ddSJose Ricardo Ziviani 2646c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2647c85bc7ddSJose Ricardo Ziviani cr = CRF_SO; 2648c85bc7ddSJose Ricardo Ziviani } 2649c85bc7ddSJose Ricardo Ziviani 2650c85bc7ddSJose Ricardo Ziviani return cr; 2651c85bc7ddSJose Ricardo Ziviani } 2652c85bc7ddSJose Ricardo Ziviani 2653c3025c3bSJose Ricardo Ziviani uint32_t helper_bcdcpsgn(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2654c3025c3bSJose Ricardo Ziviani { 2655c3025c3bSJose Ricardo Ziviani int i; 2656c3025c3bSJose Ricardo Ziviani int invalid = 0; 2657c3025c3bSJose Ricardo Ziviani 2658c3025c3bSJose Ricardo Ziviani if (bcd_get_sgn(a) == 0 || bcd_get_sgn(b) == 0) { 2659c3025c3bSJose Ricardo Ziviani return CRF_SO; 2660c3025c3bSJose Ricardo Ziviani } 2661c3025c3bSJose Ricardo Ziviani 2662c3025c3bSJose Ricardo Ziviani *r = *a; 2663428115c3SMark Cave-Ayland bcd_put_digit(r, b->VsrB(BCD_DIG_BYTE(0)) & 0xF, 0); 2664c3025c3bSJose Ricardo Ziviani 2665c3025c3bSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2666c3025c3bSJose Ricardo Ziviani bcd_get_digit(a, i, &invalid); 2667c3025c3bSJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2668c3025c3bSJose Ricardo Ziviani if (unlikely(invalid)) { 2669c3025c3bSJose Ricardo Ziviani return CRF_SO; 2670c3025c3bSJose Ricardo Ziviani } 2671c3025c3bSJose Ricardo Ziviani } 2672c3025c3bSJose Ricardo Ziviani 2673c3025c3bSJose Ricardo Ziviani return bcd_cmp_zero(r); 2674c3025c3bSJose Ricardo Ziviani } 2675c3025c3bSJose Ricardo Ziviani 2676466a3f9cSJose Ricardo Ziviani uint32_t helper_bcdsetsgn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2677466a3f9cSJose Ricardo Ziviani { 2678466a3f9cSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2679466a3f9cSJose Ricardo Ziviani 2680466a3f9cSJose Ricardo Ziviani *r = *b; 2681466a3f9cSJose Ricardo Ziviani bcd_put_digit(r, bcd_preferred_sgn(sgnb, ps), 0); 2682466a3f9cSJose Ricardo Ziviani 2683071663dfSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2684466a3f9cSJose Ricardo Ziviani return CRF_SO; 2685466a3f9cSJose Ricardo Ziviani } 2686466a3f9cSJose Ricardo Ziviani 2687466a3f9cSJose Ricardo Ziviani return bcd_cmp_zero(r); 2688466a3f9cSJose Ricardo Ziviani } 2689466a3f9cSJose Ricardo Ziviani 2690e04797f7SJose Ricardo Ziviani uint32_t helper_bcds(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2691e04797f7SJose Ricardo Ziviani { 2692e04797f7SJose Ricardo Ziviani int cr; 2693428115c3SMark Cave-Ayland int i = a->VsrSB(7); 2694e04797f7SJose Ricardo Ziviani bool ox_flag = false; 2695e04797f7SJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2696e04797f7SJose Ricardo Ziviani ppc_avr_t ret = *b; 26973c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 2698e04797f7SJose Ricardo Ziviani 2699e04797f7SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2700e04797f7SJose Ricardo Ziviani return CRF_SO; 2701e04797f7SJose Ricardo Ziviani } 2702e04797f7SJose Ricardo Ziviani 2703e04797f7SJose Ricardo Ziviani if (unlikely(i > 31)) { 2704e04797f7SJose Ricardo Ziviani i = 31; 2705e04797f7SJose Ricardo Ziviani } else if (unlikely(i < -31)) { 2706e04797f7SJose Ricardo Ziviani i = -31; 2707e04797f7SJose Ricardo Ziviani } 2708e04797f7SJose Ricardo Ziviani 2709e04797f7SJose Ricardo Ziviani if (i > 0) { 27103c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2711e04797f7SJose Ricardo Ziviani } else { 27123c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2713e04797f7SJose Ricardo Ziviani } 2714e04797f7SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 2715e04797f7SJose Ricardo Ziviani 2716e04797f7SJose Ricardo Ziviani *r = ret; 2717e04797f7SJose Ricardo Ziviani 2718e04797f7SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2719e04797f7SJose Ricardo Ziviani if (ox_flag) { 2720e04797f7SJose Ricardo Ziviani cr |= CRF_SO; 2721e04797f7SJose Ricardo Ziviani } 2722e04797f7SJose Ricardo Ziviani 2723e04797f7SJose Ricardo Ziviani return cr; 2724e04797f7SJose Ricardo Ziviani } 2725e04797f7SJose Ricardo Ziviani 2726a49a95e9SJose Ricardo Ziviani uint32_t helper_bcdus(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2727a49a95e9SJose Ricardo Ziviani { 2728a49a95e9SJose Ricardo Ziviani int cr; 2729a49a95e9SJose Ricardo Ziviani int i; 2730a49a95e9SJose Ricardo Ziviani int invalid = 0; 2731a49a95e9SJose Ricardo Ziviani bool ox_flag = false; 2732a49a95e9SJose Ricardo Ziviani ppc_avr_t ret = *b; 2733a49a95e9SJose Ricardo Ziviani 2734a49a95e9SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 2735a49a95e9SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2736a49a95e9SJose Ricardo Ziviani 2737a49a95e9SJose Ricardo Ziviani if (unlikely(invalid)) { 2738a49a95e9SJose Ricardo Ziviani return CRF_SO; 2739a49a95e9SJose Ricardo Ziviani } 2740a49a95e9SJose Ricardo Ziviani } 2741a49a95e9SJose Ricardo Ziviani 2742428115c3SMark Cave-Ayland i = a->VsrSB(7); 2743a49a95e9SJose Ricardo Ziviani if (i >= 32) { 2744a49a95e9SJose Ricardo Ziviani ox_flag = true; 27453c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2746a49a95e9SJose Ricardo Ziviani } else if (i <= -32) { 27473c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2748a49a95e9SJose Ricardo Ziviani } else if (i > 0) { 27493c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2750a49a95e9SJose Ricardo Ziviani } else { 27513c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2752a49a95e9SJose Ricardo Ziviani } 2753a49a95e9SJose Ricardo Ziviani *r = ret; 2754a49a95e9SJose Ricardo Ziviani 2755a49a95e9SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2756a49a95e9SJose Ricardo Ziviani if (ox_flag) { 2757a49a95e9SJose Ricardo Ziviani cr |= CRF_SO; 2758a49a95e9SJose Ricardo Ziviani } 2759a49a95e9SJose Ricardo Ziviani 2760a49a95e9SJose Ricardo Ziviani return cr; 2761a49a95e9SJose Ricardo Ziviani } 2762a49a95e9SJose Ricardo Ziviani 2763a54238adSJose Ricardo Ziviani uint32_t helper_bcdsr(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2764a54238adSJose Ricardo Ziviani { 2765a54238adSJose Ricardo Ziviani int cr; 2766a54238adSJose Ricardo Ziviani int unused = 0; 2767a54238adSJose Ricardo Ziviani int invalid = 0; 2768a54238adSJose Ricardo Ziviani bool ox_flag = false; 2769a54238adSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2770a54238adSJose Ricardo Ziviani ppc_avr_t ret = *b; 27713c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 2772a54238adSJose Ricardo Ziviani 2773428115c3SMark Cave-Ayland int i = a->VsrSB(7); 2774428115c3SMark Cave-Ayland ppc_avr_t bcd_one; 2775428115c3SMark Cave-Ayland 2776428115c3SMark Cave-Ayland bcd_one.VsrD(0) = 0; 2777428115c3SMark Cave-Ayland bcd_one.VsrD(1) = 0x10; 2778a54238adSJose Ricardo Ziviani 2779a54238adSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2780a54238adSJose Ricardo Ziviani return CRF_SO; 2781a54238adSJose Ricardo Ziviani } 2782a54238adSJose Ricardo Ziviani 2783a54238adSJose Ricardo Ziviani if (unlikely(i > 31)) { 2784a54238adSJose Ricardo Ziviani i = 31; 2785a54238adSJose Ricardo Ziviani } else if (unlikely(i < -31)) { 2786a54238adSJose Ricardo Ziviani i = -31; 2787a54238adSJose Ricardo Ziviani } 2788a54238adSJose Ricardo Ziviani 2789a54238adSJose Ricardo Ziviani if (i > 0) { 27903c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2791a54238adSJose Ricardo Ziviani } else { 27923c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2793a54238adSJose Ricardo Ziviani 2794a54238adSJose Ricardo Ziviani if (bcd_get_digit(&ret, 0, &invalid) >= 5) { 2795a54238adSJose Ricardo Ziviani bcd_add_mag(&ret, &ret, &bcd_one, &invalid, &unused); 2796a54238adSJose Ricardo Ziviani } 2797a54238adSJose Ricardo Ziviani } 2798a54238adSJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 2799a54238adSJose Ricardo Ziviani 2800a54238adSJose Ricardo Ziviani cr = bcd_cmp_zero(&ret); 2801a54238adSJose Ricardo Ziviani if (ox_flag) { 2802a54238adSJose Ricardo Ziviani cr |= CRF_SO; 2803a54238adSJose Ricardo Ziviani } 2804a54238adSJose Ricardo Ziviani *r = ret; 2805a54238adSJose Ricardo Ziviani 2806a54238adSJose Ricardo Ziviani return cr; 2807a54238adSJose Ricardo Ziviani } 2808a54238adSJose Ricardo Ziviani 280931bc4d11SJose Ricardo Ziviani uint32_t helper_bcdtrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 281031bc4d11SJose Ricardo Ziviani { 281131bc4d11SJose Ricardo Ziviani uint64_t mask; 281231bc4d11SJose Ricardo Ziviani uint32_t ox_flag = 0; 2813428115c3SMark Cave-Ayland int i = a->VsrSH(3) + 1; 281431bc4d11SJose Ricardo Ziviani ppc_avr_t ret = *b; 281531bc4d11SJose Ricardo Ziviani 281631bc4d11SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 281731bc4d11SJose Ricardo Ziviani return CRF_SO; 281831bc4d11SJose Ricardo Ziviani } 281931bc4d11SJose Ricardo Ziviani 282031bc4d11SJose Ricardo Ziviani if (i > 16 && i < 32) { 282131bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 28223c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 282331bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 282431bc4d11SJose Ricardo Ziviani } 282531bc4d11SJose Ricardo Ziviani 28263c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 282731bc4d11SJose Ricardo Ziviani } else if (i >= 0 && i <= 16) { 282831bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 28293c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 283031bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 283131bc4d11SJose Ricardo Ziviani } 283231bc4d11SJose Ricardo Ziviani 28333c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 28343c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 283531bc4d11SJose Ricardo Ziviani } 283631bc4d11SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(bcd_get_sgn(b), ps), 0); 283731bc4d11SJose Ricardo Ziviani *r = ret; 283831bc4d11SJose Ricardo Ziviani 283931bc4d11SJose Ricardo Ziviani return bcd_cmp_zero(&ret) | ox_flag; 284031bc4d11SJose Ricardo Ziviani } 284131bc4d11SJose Ricardo Ziviani 28425c32e2e4SJose Ricardo Ziviani uint32_t helper_bcdutrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 28435c32e2e4SJose Ricardo Ziviani { 28445c32e2e4SJose Ricardo Ziviani int i; 28455c32e2e4SJose Ricardo Ziviani uint64_t mask; 28465c32e2e4SJose Ricardo Ziviani uint32_t ox_flag = 0; 28475c32e2e4SJose Ricardo Ziviani int invalid = 0; 28485c32e2e4SJose Ricardo Ziviani ppc_avr_t ret = *b; 28495c32e2e4SJose Ricardo Ziviani 28505c32e2e4SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 28515c32e2e4SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 28525c32e2e4SJose Ricardo Ziviani 28535c32e2e4SJose Ricardo Ziviani if (unlikely(invalid)) { 28545c32e2e4SJose Ricardo Ziviani return CRF_SO; 28555c32e2e4SJose Ricardo Ziviani } 28565c32e2e4SJose Ricardo Ziviani } 28575c32e2e4SJose Ricardo Ziviani 2858428115c3SMark Cave-Ayland i = a->VsrSH(3); 28595c32e2e4SJose Ricardo Ziviani if (i > 16 && i < 33) { 28605c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 28613c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 28625c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 28635c32e2e4SJose Ricardo Ziviani } 28645c32e2e4SJose Ricardo Ziviani 28653c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 28665c32e2e4SJose Ricardo Ziviani } else if (i > 0 && i <= 16) { 28675c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 28683c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 28695c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 28705c32e2e4SJose Ricardo Ziviani } 28715c32e2e4SJose Ricardo Ziviani 28723c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 28733c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 28745c32e2e4SJose Ricardo Ziviani } else if (i == 0) { 28753c385a93SMark Cave-Ayland if (ret.VsrD(0) || ret.VsrD(1)) { 28765c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 28775c32e2e4SJose Ricardo Ziviani } 28783c385a93SMark Cave-Ayland ret.VsrD(0) = ret.VsrD(1) = 0; 28795c32e2e4SJose Ricardo Ziviani } 28805c32e2e4SJose Ricardo Ziviani 28815c32e2e4SJose Ricardo Ziviani *r = ret; 28823c385a93SMark Cave-Ayland if (r->VsrD(0) == 0 && r->VsrD(1) == 0) { 28835c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_EQ; 28845c32e2e4SJose Ricardo Ziviani } 28855c32e2e4SJose Ricardo Ziviani 28865c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_GT; 28875c32e2e4SJose Ricardo Ziviani } 28885c32e2e4SJose Ricardo Ziviani 2889fcf5ef2aSThomas Huth void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a) 2890fcf5ef2aSThomas Huth { 2891fcf5ef2aSThomas Huth int i; 2892fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 2893fcf5ef2aSThomas Huth r->u8[i] = AES_sbox[a->u8[i]]; 2894fcf5ef2aSThomas Huth } 2895fcf5ef2aSThomas Huth } 2896fcf5ef2aSThomas Huth 2897fcf5ef2aSThomas Huth void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2898fcf5ef2aSThomas Huth { 2899fcf5ef2aSThomas Huth ppc_avr_t result; 2900fcf5ef2aSThomas Huth int i; 2901fcf5ef2aSThomas Huth 2902fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 29032dea57dbSMark Cave-Ayland result.VsrW(i) = b->VsrW(i) ^ 29042dea57dbSMark Cave-Ayland (AES_Te0[a->VsrB(AES_shifts[4 * i + 0])] ^ 29052dea57dbSMark Cave-Ayland AES_Te1[a->VsrB(AES_shifts[4 * i + 1])] ^ 29062dea57dbSMark Cave-Ayland AES_Te2[a->VsrB(AES_shifts[4 * i + 2])] ^ 29072dea57dbSMark Cave-Ayland AES_Te3[a->VsrB(AES_shifts[4 * i + 3])]); 2908fcf5ef2aSThomas Huth } 2909fcf5ef2aSThomas Huth *r = result; 2910fcf5ef2aSThomas Huth } 2911fcf5ef2aSThomas Huth 2912fcf5ef2aSThomas Huth void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2913fcf5ef2aSThomas Huth { 2914fcf5ef2aSThomas Huth ppc_avr_t result; 2915fcf5ef2aSThomas Huth int i; 2916fcf5ef2aSThomas Huth 2917fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 29182dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_sbox[a->VsrB(AES_shifts[i])]); 2919fcf5ef2aSThomas Huth } 2920fcf5ef2aSThomas Huth *r = result; 2921fcf5ef2aSThomas Huth } 2922fcf5ef2aSThomas Huth 2923fcf5ef2aSThomas Huth void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2924fcf5ef2aSThomas Huth { 2925fcf5ef2aSThomas Huth /* This differs from what is written in ISA V2.07. The RTL is */ 2926fcf5ef2aSThomas Huth /* incorrect and will be fixed in V2.07B. */ 2927fcf5ef2aSThomas Huth int i; 2928fcf5ef2aSThomas Huth ppc_avr_t tmp; 2929fcf5ef2aSThomas Huth 2930fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 29312dea57dbSMark Cave-Ayland tmp.VsrB(i) = b->VsrB(i) ^ AES_isbox[a->VsrB(AES_ishifts[i])]; 2932fcf5ef2aSThomas Huth } 2933fcf5ef2aSThomas Huth 2934fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 29352dea57dbSMark Cave-Ayland r->VsrW(i) = 29362dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 0)][0] ^ 29372dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 1)][1] ^ 29382dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 2)][2] ^ 29392dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 3)][3]; 2940fcf5ef2aSThomas Huth } 2941fcf5ef2aSThomas Huth } 2942fcf5ef2aSThomas Huth 2943fcf5ef2aSThomas Huth void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2944fcf5ef2aSThomas Huth { 2945fcf5ef2aSThomas Huth ppc_avr_t result; 2946fcf5ef2aSThomas Huth int i; 2947fcf5ef2aSThomas Huth 2948fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 29492dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_isbox[a->VsrB(AES_ishifts[i])]); 2950fcf5ef2aSThomas Huth } 2951fcf5ef2aSThomas Huth *r = result; 2952fcf5ef2aSThomas Huth } 2953fcf5ef2aSThomas Huth 2954fcf5ef2aSThomas Huth void helper_vshasigmaw(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 2955fcf5ef2aSThomas Huth { 2956fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 2957fcf5ef2aSThomas Huth int six = st_six & 0xF; 2958fcf5ef2aSThomas Huth int i; 2959fcf5ef2aSThomas Huth 2960730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 2961fcf5ef2aSThomas Huth if (st == 0) { 2962fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 29630ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 7) ^ 29640ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 18) ^ 2965730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 3); 2966fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 29670ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 17) ^ 29680ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 19) ^ 2969730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 10); 2970fcf5ef2aSThomas Huth } 2971fcf5ef2aSThomas Huth } else { /* st == 1 */ 2972fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 29730ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 2) ^ 29740ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 13) ^ 29750ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 22); 2976fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 29770ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 6) ^ 29780ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 11) ^ 29790ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 25); 2980fcf5ef2aSThomas Huth } 2981fcf5ef2aSThomas Huth } 2982fcf5ef2aSThomas Huth } 2983fcf5ef2aSThomas Huth } 2984fcf5ef2aSThomas Huth 2985fcf5ef2aSThomas Huth void helper_vshasigmad(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 2986fcf5ef2aSThomas Huth { 2987fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 2988fcf5ef2aSThomas Huth int six = st_six & 0xF; 2989fcf5ef2aSThomas Huth int i; 2990fcf5ef2aSThomas Huth 2991730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 2992fcf5ef2aSThomas Huth if (st == 0) { 2993fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 29940ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 1) ^ 29950ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 8) ^ 2996730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 7); 2997fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 29980ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 19) ^ 29990ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 61) ^ 3000730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 6); 3001fcf5ef2aSThomas Huth } 3002fcf5ef2aSThomas Huth } else { /* st == 1 */ 3003fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 30040ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 28) ^ 30050ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 34) ^ 30060ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 39); 3007fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 30080ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 14) ^ 30090ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 18) ^ 30100ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 41); 3011fcf5ef2aSThomas Huth } 3012fcf5ef2aSThomas Huth } 3013fcf5ef2aSThomas Huth } 3014fcf5ef2aSThomas Huth } 3015fcf5ef2aSThomas Huth 3016fcf5ef2aSThomas Huth void helper_vpermxor(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 3017fcf5ef2aSThomas Huth { 3018fcf5ef2aSThomas Huth ppc_avr_t result; 3019fcf5ef2aSThomas Huth int i; 3020fcf5ef2aSThomas Huth 302160594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 302260594feaSMark Cave-Ayland int indexA = c->VsrB(i) >> 4; 302360594feaSMark Cave-Ayland int indexB = c->VsrB(i) & 0xF; 302460594feaSMark Cave-Ayland 302560594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(indexA) ^ b->VsrB(indexB); 3026fcf5ef2aSThomas Huth } 3027fcf5ef2aSThomas Huth *r = result; 3028fcf5ef2aSThomas Huth } 3029fcf5ef2aSThomas Huth 3030fcf5ef2aSThomas Huth #undef VECTOR_FOR_INORDER_I 3031fcf5ef2aSThomas Huth 3032fcf5ef2aSThomas Huth /*****************************************************************************/ 3033fcf5ef2aSThomas Huth /* SPE extension helpers */ 3034fcf5ef2aSThomas Huth /* Use a table to make this quicker */ 3035fcf5ef2aSThomas Huth static const uint8_t hbrev[16] = { 3036fcf5ef2aSThomas Huth 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE, 3037fcf5ef2aSThomas Huth 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF, 3038fcf5ef2aSThomas Huth }; 3039fcf5ef2aSThomas Huth 3040fcf5ef2aSThomas Huth static inline uint8_t byte_reverse(uint8_t val) 3041fcf5ef2aSThomas Huth { 3042fcf5ef2aSThomas Huth return hbrev[val >> 4] | (hbrev[val & 0xF] << 4); 3043fcf5ef2aSThomas Huth } 3044fcf5ef2aSThomas Huth 3045fcf5ef2aSThomas Huth static inline uint32_t word_reverse(uint32_t val) 3046fcf5ef2aSThomas Huth { 3047fcf5ef2aSThomas Huth return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) | 3048fcf5ef2aSThomas Huth (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24); 3049fcf5ef2aSThomas Huth } 3050fcf5ef2aSThomas Huth 3051fcf5ef2aSThomas Huth #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */ 3052fcf5ef2aSThomas Huth target_ulong helper_brinc(target_ulong arg1, target_ulong arg2) 3053fcf5ef2aSThomas Huth { 3054fcf5ef2aSThomas Huth uint32_t a, b, d, mask; 3055fcf5ef2aSThomas Huth 3056fcf5ef2aSThomas Huth mask = UINT32_MAX >> (32 - MASKBITS); 3057fcf5ef2aSThomas Huth a = arg1 & mask; 3058fcf5ef2aSThomas Huth b = arg2 & mask; 3059fcf5ef2aSThomas Huth d = word_reverse(1 + word_reverse(a | ~b)); 3060fcf5ef2aSThomas Huth return (arg1 & ~mask) | (d & b); 3061fcf5ef2aSThomas Huth } 3062fcf5ef2aSThomas Huth 3063fcf5ef2aSThomas Huth uint32_t helper_cntlsw32(uint32_t val) 3064fcf5ef2aSThomas Huth { 3065fcf5ef2aSThomas Huth if (val & 0x80000000) { 3066fcf5ef2aSThomas Huth return clz32(~val); 3067fcf5ef2aSThomas Huth } else { 3068fcf5ef2aSThomas Huth return clz32(val); 3069fcf5ef2aSThomas Huth } 3070fcf5ef2aSThomas Huth } 3071fcf5ef2aSThomas Huth 3072fcf5ef2aSThomas Huth uint32_t helper_cntlzw32(uint32_t val) 3073fcf5ef2aSThomas Huth { 3074fcf5ef2aSThomas Huth return clz32(val); 3075fcf5ef2aSThomas Huth } 3076fcf5ef2aSThomas Huth 3077fcf5ef2aSThomas Huth /* 440 specific */ 3078fcf5ef2aSThomas Huth target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high, 3079fcf5ef2aSThomas Huth target_ulong low, uint32_t update_Rc) 3080fcf5ef2aSThomas Huth { 3081fcf5ef2aSThomas Huth target_ulong mask; 3082fcf5ef2aSThomas Huth int i; 3083fcf5ef2aSThomas Huth 3084fcf5ef2aSThomas Huth i = 1; 3085fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3086fcf5ef2aSThomas Huth if ((high & mask) == 0) { 3087fcf5ef2aSThomas Huth if (update_Rc) { 3088fcf5ef2aSThomas Huth env->crf[0] = 0x4; 3089fcf5ef2aSThomas Huth } 3090fcf5ef2aSThomas Huth goto done; 3091fcf5ef2aSThomas Huth } 3092fcf5ef2aSThomas Huth i++; 3093fcf5ef2aSThomas Huth } 3094fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3095fcf5ef2aSThomas Huth if ((low & mask) == 0) { 3096fcf5ef2aSThomas Huth if (update_Rc) { 3097fcf5ef2aSThomas Huth env->crf[0] = 0x8; 3098fcf5ef2aSThomas Huth } 3099fcf5ef2aSThomas Huth goto done; 3100fcf5ef2aSThomas Huth } 3101fcf5ef2aSThomas Huth i++; 3102fcf5ef2aSThomas Huth } 3103fcf5ef2aSThomas Huth i = 8; 3104fcf5ef2aSThomas Huth if (update_Rc) { 3105fcf5ef2aSThomas Huth env->crf[0] = 0x2; 3106fcf5ef2aSThomas Huth } 3107fcf5ef2aSThomas Huth done: 3108fcf5ef2aSThomas Huth env->xer = (env->xer & ~0x7F) | i; 3109fcf5ef2aSThomas Huth if (update_Rc) { 3110fcf5ef2aSThomas Huth env->crf[0] |= xer_so; 3111fcf5ef2aSThomas Huth } 3112fcf5ef2aSThomas Huth return i; 3113fcf5ef2aSThomas Huth } 3114