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" 31fcf5ef2aSThomas Huth 32fcf5ef2aSThomas Huth #include "helper_regs.h" 33fcf5ef2aSThomas Huth /*****************************************************************************/ 34fcf5ef2aSThomas Huth /* Fixed point operations helpers */ 35fcf5ef2aSThomas Huth 36f32899deSNikunj A Dadhania static inline void helper_update_ov_legacy(CPUPPCState *env, int ov) 37f32899deSNikunj A Dadhania { 38f32899deSNikunj A Dadhania if (unlikely(ov)) { 39f32899deSNikunj A Dadhania env->so = env->ov = 1; 40f32899deSNikunj A Dadhania } else { 41f32899deSNikunj A Dadhania env->ov = 0; 42f32899deSNikunj A Dadhania } 43f32899deSNikunj A Dadhania } 44f32899deSNikunj A Dadhania 45fcf5ef2aSThomas Huth target_ulong helper_divweu(CPUPPCState *env, target_ulong ra, target_ulong rb, 46fcf5ef2aSThomas Huth uint32_t oe) 47fcf5ef2aSThomas Huth { 48fcf5ef2aSThomas Huth uint64_t rt = 0; 49fcf5ef2aSThomas Huth int overflow = 0; 50fcf5ef2aSThomas Huth 51fcf5ef2aSThomas Huth uint64_t dividend = (uint64_t)ra << 32; 52fcf5ef2aSThomas Huth uint64_t divisor = (uint32_t)rb; 53fcf5ef2aSThomas Huth 54fcf5ef2aSThomas Huth if (unlikely(divisor == 0)) { 55fcf5ef2aSThomas Huth overflow = 1; 56fcf5ef2aSThomas Huth } else { 57fcf5ef2aSThomas Huth rt = dividend / divisor; 58fcf5ef2aSThomas Huth overflow = rt > UINT32_MAX; 59fcf5ef2aSThomas Huth } 60fcf5ef2aSThomas Huth 61fcf5ef2aSThomas Huth if (unlikely(overflow)) { 62fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 63fcf5ef2aSThomas Huth } 64fcf5ef2aSThomas Huth 65fcf5ef2aSThomas Huth if (oe) { 66f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 67fcf5ef2aSThomas Huth } 68fcf5ef2aSThomas Huth 69fcf5ef2aSThomas Huth return (target_ulong)rt; 70fcf5ef2aSThomas Huth } 71fcf5ef2aSThomas Huth 72fcf5ef2aSThomas Huth target_ulong helper_divwe(CPUPPCState *env, target_ulong ra, target_ulong rb, 73fcf5ef2aSThomas Huth uint32_t oe) 74fcf5ef2aSThomas Huth { 75fcf5ef2aSThomas Huth int64_t rt = 0; 76fcf5ef2aSThomas Huth int overflow = 0; 77fcf5ef2aSThomas Huth 78fcf5ef2aSThomas Huth int64_t dividend = (int64_t)ra << 32; 79fcf5ef2aSThomas Huth int64_t divisor = (int64_t)((int32_t)rb); 80fcf5ef2aSThomas Huth 81fcf5ef2aSThomas Huth if (unlikely((divisor == 0) || 82fcf5ef2aSThomas Huth ((divisor == -1ull) && (dividend == INT64_MIN)))) { 83fcf5ef2aSThomas Huth overflow = 1; 84fcf5ef2aSThomas Huth } else { 85fcf5ef2aSThomas Huth rt = dividend / divisor; 86fcf5ef2aSThomas Huth overflow = rt != (int32_t)rt; 87fcf5ef2aSThomas Huth } 88fcf5ef2aSThomas Huth 89fcf5ef2aSThomas Huth if (unlikely(overflow)) { 90fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 91fcf5ef2aSThomas Huth } 92fcf5ef2aSThomas Huth 93fcf5ef2aSThomas Huth if (oe) { 94f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 95fcf5ef2aSThomas Huth } 96fcf5ef2aSThomas Huth 97fcf5ef2aSThomas Huth return (target_ulong)rt; 98fcf5ef2aSThomas Huth } 99fcf5ef2aSThomas Huth 100fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 101fcf5ef2aSThomas Huth 102fcf5ef2aSThomas Huth uint64_t helper_divdeu(CPUPPCState *env, uint64_t ra, uint64_t rb, uint32_t oe) 103fcf5ef2aSThomas Huth { 104fcf5ef2aSThomas Huth uint64_t rt = 0; 105fcf5ef2aSThomas Huth int overflow = 0; 106fcf5ef2aSThomas Huth 1079276a31cSLuis Pires if (unlikely(rb == 0 || ra >= rb)) { 1089276a31cSLuis Pires overflow = 1; 109fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 1109276a31cSLuis Pires } else { 1119276a31cSLuis Pires divu128(&rt, &ra, rb); 112fcf5ef2aSThomas Huth } 113fcf5ef2aSThomas Huth 114fcf5ef2aSThomas Huth if (oe) { 115f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 116fcf5ef2aSThomas Huth } 117fcf5ef2aSThomas Huth 118fcf5ef2aSThomas Huth return rt; 119fcf5ef2aSThomas Huth } 120fcf5ef2aSThomas Huth 121fcf5ef2aSThomas Huth uint64_t helper_divde(CPUPPCState *env, uint64_t rau, uint64_t rbu, uint32_t oe) 122fcf5ef2aSThomas Huth { 12340f3e79aSLuis Pires uint64_t rt = 0; 124fcf5ef2aSThomas Huth int64_t ra = (int64_t)rau; 125fcf5ef2aSThomas Huth int64_t rb = (int64_t)rbu; 1269276a31cSLuis Pires int overflow = 0; 127fcf5ef2aSThomas Huth 1289276a31cSLuis Pires if (unlikely(rb == 0 || uabs64(ra) >= uabs64(rb))) { 1299276a31cSLuis Pires overflow = 1; 130fcf5ef2aSThomas Huth rt = 0; /* Undefined */ 1319276a31cSLuis Pires } else { 1329276a31cSLuis Pires divs128(&rt, &ra, rb); 133fcf5ef2aSThomas Huth } 134fcf5ef2aSThomas Huth 135fcf5ef2aSThomas Huth if (oe) { 136f32899deSNikunj A Dadhania helper_update_ov_legacy(env, overflow); 137fcf5ef2aSThomas Huth } 138fcf5ef2aSThomas Huth 139fcf5ef2aSThomas Huth return rt; 140fcf5ef2aSThomas Huth } 141fcf5ef2aSThomas Huth 142fcf5ef2aSThomas Huth #endif 143fcf5ef2aSThomas Huth 144fcf5ef2aSThomas Huth 145fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 146fcf5ef2aSThomas Huth /* if x = 0xab, returns 0xababababababababa */ 147fcf5ef2aSThomas Huth #define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff)) 148fcf5ef2aSThomas Huth 149b6cb41b2SDavid Gibson /* 150b6cb41b2SDavid Gibson * subtract 1 from each byte, and with inverse, check if MSB is set at each 151fcf5ef2aSThomas Huth * byte. 152fcf5ef2aSThomas Huth * i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80 153fcf5ef2aSThomas Huth * (0xFF & 0xFF) & 0x80 = 0x80 (zero found) 154fcf5ef2aSThomas Huth */ 155fcf5ef2aSThomas Huth #define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80)) 156fcf5ef2aSThomas Huth 157fcf5ef2aSThomas Huth /* When you XOR the pattern and there is a match, that byte will be zero */ 158fcf5ef2aSThomas Huth #define hasvalue(x, n) (haszero((x) ^ pattern(n))) 159fcf5ef2aSThomas Huth 160fcf5ef2aSThomas Huth uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb) 161fcf5ef2aSThomas Huth { 162efa73196SNikunj A Dadhania return hasvalue(rb, ra) ? CRF_GT : 0; 163fcf5ef2aSThomas Huth } 164fcf5ef2aSThomas Huth 165fcf5ef2aSThomas Huth #undef pattern 166fcf5ef2aSThomas Huth #undef haszero 167fcf5ef2aSThomas Huth #undef hasvalue 168fcf5ef2aSThomas Huth 169b6cb41b2SDavid Gibson /* 1703f74b632SRichard Henderson * Return a random number. 171fcf5ef2aSThomas Huth */ 1723f74b632SRichard Henderson uint64_t helper_darn32(void) 173fcf5ef2aSThomas Huth { 1743f74b632SRichard Henderson Error *err = NULL; 1753f74b632SRichard Henderson uint32_t ret; 1763f74b632SRichard Henderson 1773f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1783f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1793f74b632SRichard Henderson error_get_pretty(err)); 1803f74b632SRichard Henderson error_free(err); 181fcf5ef2aSThomas Huth return -1; 182fcf5ef2aSThomas Huth } 183fcf5ef2aSThomas Huth 1843f74b632SRichard Henderson return ret; 1853f74b632SRichard Henderson } 1863f74b632SRichard Henderson 1873f74b632SRichard Henderson uint64_t helper_darn64(void) 188fcf5ef2aSThomas Huth { 1893f74b632SRichard Henderson Error *err = NULL; 1903f74b632SRichard Henderson uint64_t ret; 1913f74b632SRichard Henderson 1923f74b632SRichard Henderson if (qemu_guest_getrandom(&ret, sizeof(ret), &err) < 0) { 1933f74b632SRichard Henderson qemu_log_mask(LOG_UNIMP, "darn: Crypto failure: %s", 1943f74b632SRichard Henderson error_get_pretty(err)); 1953f74b632SRichard Henderson error_free(err); 196fcf5ef2aSThomas Huth return -1; 197fcf5ef2aSThomas Huth } 198fcf5ef2aSThomas Huth 1993f74b632SRichard Henderson return ret; 2003f74b632SRichard Henderson } 201fcf5ef2aSThomas Huth 202fcf5ef2aSThomas Huth uint64_t helper_bpermd(uint64_t rs, uint64_t rb) 203fcf5ef2aSThomas Huth { 204fcf5ef2aSThomas Huth int i; 205fcf5ef2aSThomas Huth uint64_t ra = 0; 206fcf5ef2aSThomas Huth 207fcf5ef2aSThomas Huth for (i = 0; i < 8; i++) { 208fcf5ef2aSThomas Huth int index = (rs >> (i * 8)) & 0xFF; 209fcf5ef2aSThomas Huth if (index < 64) { 210a6a444a8SCédric Le Goater if (rb & PPC_BIT(index)) { 211fcf5ef2aSThomas Huth ra |= 1 << i; 212fcf5ef2aSThomas Huth } 213fcf5ef2aSThomas Huth } 214fcf5ef2aSThomas Huth } 215fcf5ef2aSThomas Huth return ra; 216fcf5ef2aSThomas Huth } 217fcf5ef2aSThomas Huth 218fcf5ef2aSThomas Huth #endif 219fcf5ef2aSThomas Huth 220fcf5ef2aSThomas Huth target_ulong helper_cmpb(target_ulong rs, target_ulong rb) 221fcf5ef2aSThomas Huth { 222fcf5ef2aSThomas Huth target_ulong mask = 0xff; 223fcf5ef2aSThomas Huth target_ulong ra = 0; 224fcf5ef2aSThomas Huth int i; 225fcf5ef2aSThomas Huth 226fcf5ef2aSThomas Huth for (i = 0; i < sizeof(target_ulong); i++) { 227fcf5ef2aSThomas Huth if ((rs & mask) == (rb & mask)) { 228fcf5ef2aSThomas Huth ra |= mask; 229fcf5ef2aSThomas Huth } 230fcf5ef2aSThomas Huth mask <<= 8; 231fcf5ef2aSThomas Huth } 232fcf5ef2aSThomas Huth return ra; 233fcf5ef2aSThomas Huth } 234fcf5ef2aSThomas Huth 235fcf5ef2aSThomas Huth /* shift right arithmetic helper */ 236fcf5ef2aSThomas Huth target_ulong helper_sraw(CPUPPCState *env, target_ulong value, 237fcf5ef2aSThomas Huth target_ulong shift) 238fcf5ef2aSThomas Huth { 239fcf5ef2aSThomas Huth int32_t ret; 240fcf5ef2aSThomas Huth 241fcf5ef2aSThomas Huth if (likely(!(shift & 0x20))) { 242fcf5ef2aSThomas Huth if (likely((uint32_t)shift != 0)) { 243fcf5ef2aSThomas Huth shift &= 0x1f; 244fcf5ef2aSThomas Huth ret = (int32_t)value >> shift; 245fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1 << shift) - 1)) == 0)) { 246af1c259fSSandipan Das env->ca32 = env->ca = 0; 247fcf5ef2aSThomas Huth } else { 248af1c259fSSandipan Das env->ca32 = env->ca = 1; 249fcf5ef2aSThomas Huth } 250fcf5ef2aSThomas Huth } else { 251fcf5ef2aSThomas Huth ret = (int32_t)value; 252af1c259fSSandipan Das env->ca32 = env->ca = 0; 253fcf5ef2aSThomas Huth } 254fcf5ef2aSThomas Huth } else { 255fcf5ef2aSThomas Huth ret = (int32_t)value >> 31; 256af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 257fcf5ef2aSThomas Huth } 258fcf5ef2aSThomas Huth return (target_long)ret; 259fcf5ef2aSThomas Huth } 260fcf5ef2aSThomas Huth 261fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 262fcf5ef2aSThomas Huth target_ulong helper_srad(CPUPPCState *env, target_ulong value, 263fcf5ef2aSThomas Huth target_ulong shift) 264fcf5ef2aSThomas Huth { 265fcf5ef2aSThomas Huth int64_t ret; 266fcf5ef2aSThomas Huth 267fcf5ef2aSThomas Huth if (likely(!(shift & 0x40))) { 268fcf5ef2aSThomas Huth if (likely((uint64_t)shift != 0)) { 269fcf5ef2aSThomas Huth shift &= 0x3f; 270fcf5ef2aSThomas Huth ret = (int64_t)value >> shift; 271fcf5ef2aSThomas Huth if (likely(ret >= 0 || (value & ((1ULL << shift) - 1)) == 0)) { 272af1c259fSSandipan Das env->ca32 = env->ca = 0; 273fcf5ef2aSThomas Huth } else { 274af1c259fSSandipan Das env->ca32 = env->ca = 1; 275fcf5ef2aSThomas Huth } 276fcf5ef2aSThomas Huth } else { 277fcf5ef2aSThomas Huth ret = (int64_t)value; 278af1c259fSSandipan Das env->ca32 = env->ca = 0; 279fcf5ef2aSThomas Huth } 280fcf5ef2aSThomas Huth } else { 281fcf5ef2aSThomas Huth ret = (int64_t)value >> 63; 282af1c259fSSandipan Das env->ca32 = env->ca = (ret != 0); 283fcf5ef2aSThomas Huth } 284fcf5ef2aSThomas Huth return ret; 285fcf5ef2aSThomas Huth } 286fcf5ef2aSThomas Huth #endif 287fcf5ef2aSThomas Huth 288fcf5ef2aSThomas Huth #if defined(TARGET_PPC64) 289fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 290fcf5ef2aSThomas Huth { 29179770002SRichard Henderson /* Note that we don't fold past bytes */ 292fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 293fcf5ef2aSThomas Huth 0x5555555555555555ULL); 294fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 295fcf5ef2aSThomas Huth 0x3333333333333333ULL); 296fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 297fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 298fcf5ef2aSThomas Huth return val; 299fcf5ef2aSThomas Huth } 300fcf5ef2aSThomas Huth 301fcf5ef2aSThomas Huth target_ulong helper_popcntw(target_ulong val) 302fcf5ef2aSThomas Huth { 30379770002SRichard Henderson /* Note that we don't fold past words. */ 304fcf5ef2aSThomas Huth val = (val & 0x5555555555555555ULL) + ((val >> 1) & 305fcf5ef2aSThomas Huth 0x5555555555555555ULL); 306fcf5ef2aSThomas Huth val = (val & 0x3333333333333333ULL) + ((val >> 2) & 307fcf5ef2aSThomas Huth 0x3333333333333333ULL); 308fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f0f0f0f0fULL) + ((val >> 4) & 309fcf5ef2aSThomas Huth 0x0f0f0f0f0f0f0f0fULL); 310fcf5ef2aSThomas Huth val = (val & 0x00ff00ff00ff00ffULL) + ((val >> 8) & 311fcf5ef2aSThomas Huth 0x00ff00ff00ff00ffULL); 312fcf5ef2aSThomas Huth val = (val & 0x0000ffff0000ffffULL) + ((val >> 16) & 313fcf5ef2aSThomas Huth 0x0000ffff0000ffffULL); 314fcf5ef2aSThomas Huth return val; 315fcf5ef2aSThomas Huth } 316fcf5ef2aSThomas Huth #else 317fcf5ef2aSThomas Huth target_ulong helper_popcntb(target_ulong val) 318fcf5ef2aSThomas Huth { 31979770002SRichard Henderson /* Note that we don't fold past bytes */ 320fcf5ef2aSThomas Huth val = (val & 0x55555555) + ((val >> 1) & 0x55555555); 321fcf5ef2aSThomas Huth val = (val & 0x33333333) + ((val >> 2) & 0x33333333); 322fcf5ef2aSThomas Huth val = (val & 0x0f0f0f0f) + ((val >> 4) & 0x0f0f0f0f); 323fcf5ef2aSThomas Huth return val; 324fcf5ef2aSThomas Huth } 325fcf5ef2aSThomas Huth #endif 326fcf5ef2aSThomas Huth 32789ccd7dcSMatheus Ferst uint64_t helper_cfuged(uint64_t src, uint64_t mask) 32889ccd7dcSMatheus Ferst { 32989ccd7dcSMatheus Ferst /* 33089ccd7dcSMatheus Ferst * Instead of processing the mask bit-by-bit from the most significant to 33189ccd7dcSMatheus Ferst * the least significant bit, as described in PowerISA, we'll handle it in 33289ccd7dcSMatheus Ferst * blocks of 'n' zeros/ones from LSB to MSB. To avoid the decision to use 33389ccd7dcSMatheus Ferst * ctz or cto, we negate the mask at the end of the loop. 33489ccd7dcSMatheus Ferst */ 33589ccd7dcSMatheus Ferst target_ulong m, left = 0, right = 0; 33689ccd7dcSMatheus Ferst unsigned int n, i = 64; 33789ccd7dcSMatheus Ferst bool bit = false; /* tracks if we are processing zeros or ones */ 33889ccd7dcSMatheus Ferst 33989ccd7dcSMatheus Ferst if (mask == 0 || mask == -1) { 34089ccd7dcSMatheus Ferst return src; 34189ccd7dcSMatheus Ferst } 34289ccd7dcSMatheus Ferst 34389ccd7dcSMatheus Ferst /* Processes the mask in blocks, from LSB to MSB */ 34489ccd7dcSMatheus Ferst while (i) { 34589ccd7dcSMatheus Ferst /* Find how many bits we should take */ 34689ccd7dcSMatheus Ferst n = ctz64(mask); 34789ccd7dcSMatheus Ferst if (n > i) { 34889ccd7dcSMatheus Ferst n = i; 34989ccd7dcSMatheus Ferst } 35089ccd7dcSMatheus Ferst 35189ccd7dcSMatheus Ferst /* 35289ccd7dcSMatheus Ferst * Extracts 'n' trailing bits of src and put them on the leading 'n' 35389ccd7dcSMatheus Ferst * bits of 'right' or 'left', pushing down the previously extracted 35489ccd7dcSMatheus Ferst * values. 35589ccd7dcSMatheus Ferst */ 35689ccd7dcSMatheus Ferst m = (1ll << n) - 1; 35789ccd7dcSMatheus Ferst if (bit) { 35889ccd7dcSMatheus Ferst right = ror64(right | (src & m), n); 35989ccd7dcSMatheus Ferst } else { 36089ccd7dcSMatheus Ferst left = ror64(left | (src & m), n); 36189ccd7dcSMatheus Ferst } 36289ccd7dcSMatheus Ferst 36389ccd7dcSMatheus Ferst /* 36489ccd7dcSMatheus Ferst * Discards the processed bits from 'src' and 'mask'. Note that we are 36589ccd7dcSMatheus Ferst * removing 'n' trailing zeros from 'mask', but the logical shift will 36689ccd7dcSMatheus Ferst * add 'n' leading zeros back, so the population count of 'mask' is kept 36789ccd7dcSMatheus Ferst * the same. 36889ccd7dcSMatheus Ferst */ 36989ccd7dcSMatheus Ferst src >>= n; 37089ccd7dcSMatheus Ferst mask >>= n; 37189ccd7dcSMatheus Ferst i -= n; 37289ccd7dcSMatheus Ferst bit = !bit; 37389ccd7dcSMatheus Ferst mask = ~mask; 37489ccd7dcSMatheus Ferst } 37589ccd7dcSMatheus Ferst 37689ccd7dcSMatheus Ferst /* 37789ccd7dcSMatheus Ferst * At the end, right was ror'ed ctpop(mask) times. To put it back in place, 37889ccd7dcSMatheus Ferst * we'll shift it more 64-ctpop(mask) times. 37989ccd7dcSMatheus Ferst */ 38089ccd7dcSMatheus Ferst if (bit) { 38189ccd7dcSMatheus Ferst n = ctpop64(mask); 38289ccd7dcSMatheus Ferst } else { 38389ccd7dcSMatheus Ferst n = 64 - ctpop64(mask); 38489ccd7dcSMatheus Ferst } 38589ccd7dcSMatheus Ferst 38689ccd7dcSMatheus Ferst return left | (right >> n); 38789ccd7dcSMatheus Ferst } 38889ccd7dcSMatheus Ferst 389*21ba6e58SMatheus Ferst #if defined(TARGET_PPC64) 390*21ba6e58SMatheus Ferst uint64_t helper_PDEPD(uint64_t src, uint64_t mask) 391*21ba6e58SMatheus Ferst { 392*21ba6e58SMatheus Ferst int i, o; 393*21ba6e58SMatheus Ferst uint64_t result = 0; 394*21ba6e58SMatheus Ferst 395*21ba6e58SMatheus Ferst if (mask == -1) { 396*21ba6e58SMatheus Ferst return src; 397*21ba6e58SMatheus Ferst } 398*21ba6e58SMatheus Ferst 399*21ba6e58SMatheus Ferst for (i = 0; mask != 0; i++) { 400*21ba6e58SMatheus Ferst o = ctz64(mask); 401*21ba6e58SMatheus Ferst mask &= mask - 1; 402*21ba6e58SMatheus Ferst result |= ((src >> i) & 1) << o; 403*21ba6e58SMatheus Ferst } 404*21ba6e58SMatheus Ferst 405*21ba6e58SMatheus Ferst return result; 406*21ba6e58SMatheus Ferst } 407*21ba6e58SMatheus Ferst #endif 408*21ba6e58SMatheus Ferst 409fcf5ef2aSThomas Huth /*****************************************************************************/ 410fcf5ef2aSThomas Huth /* PowerPC 601 specific instructions (POWER bridge) */ 411fcf5ef2aSThomas Huth target_ulong helper_div(CPUPPCState *env, target_ulong arg1, target_ulong arg2) 412fcf5ef2aSThomas Huth { 413fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 414fcf5ef2aSThomas Huth 415fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 416fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 417fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 418fcf5ef2aSThomas Huth return INT32_MIN; 419fcf5ef2aSThomas Huth } else { 420fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 421fcf5ef2aSThomas Huth return tmp / (int32_t)arg2; 422fcf5ef2aSThomas Huth } 423fcf5ef2aSThomas Huth } 424fcf5ef2aSThomas Huth 425fcf5ef2aSThomas Huth target_ulong helper_divo(CPUPPCState *env, target_ulong arg1, 426fcf5ef2aSThomas Huth target_ulong arg2) 427fcf5ef2aSThomas Huth { 428fcf5ef2aSThomas Huth uint64_t tmp = (uint64_t)arg1 << 32 | env->spr[SPR_MQ]; 429fcf5ef2aSThomas Huth 430fcf5ef2aSThomas Huth if (((int32_t)tmp == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 431fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 432fcf5ef2aSThomas Huth env->so = env->ov = 1; 433fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 434fcf5ef2aSThomas Huth return INT32_MIN; 435fcf5ef2aSThomas Huth } else { 436fcf5ef2aSThomas Huth env->spr[SPR_MQ] = tmp % arg2; 437fcf5ef2aSThomas Huth tmp /= (int32_t)arg2; 438fcf5ef2aSThomas Huth if ((int32_t)tmp != tmp) { 439fcf5ef2aSThomas Huth env->so = env->ov = 1; 440fcf5ef2aSThomas Huth } else { 441fcf5ef2aSThomas Huth env->ov = 0; 442fcf5ef2aSThomas Huth } 443fcf5ef2aSThomas Huth return tmp; 444fcf5ef2aSThomas Huth } 445fcf5ef2aSThomas Huth } 446fcf5ef2aSThomas Huth 447fcf5ef2aSThomas Huth target_ulong helper_divs(CPUPPCState *env, target_ulong arg1, 448fcf5ef2aSThomas Huth target_ulong arg2) 449fcf5ef2aSThomas Huth { 450fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 451fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 452fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 453fcf5ef2aSThomas Huth return INT32_MIN; 454fcf5ef2aSThomas Huth } else { 455fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 456fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 457fcf5ef2aSThomas Huth } 458fcf5ef2aSThomas Huth } 459fcf5ef2aSThomas Huth 460fcf5ef2aSThomas Huth target_ulong helper_divso(CPUPPCState *env, target_ulong arg1, 461fcf5ef2aSThomas Huth target_ulong arg2) 462fcf5ef2aSThomas Huth { 463fcf5ef2aSThomas Huth if (((int32_t)arg1 == INT32_MIN && (int32_t)arg2 == (int32_t)-1) || 464fcf5ef2aSThomas Huth (int32_t)arg2 == 0) { 465fcf5ef2aSThomas Huth env->so = env->ov = 1; 466fcf5ef2aSThomas Huth env->spr[SPR_MQ] = 0; 467fcf5ef2aSThomas Huth return INT32_MIN; 468fcf5ef2aSThomas Huth } else { 469fcf5ef2aSThomas Huth env->ov = 0; 470fcf5ef2aSThomas Huth env->spr[SPR_MQ] = (int32_t)arg1 % (int32_t)arg2; 471fcf5ef2aSThomas Huth return (int32_t)arg1 / (int32_t)arg2; 472fcf5ef2aSThomas Huth } 473fcf5ef2aSThomas Huth } 474fcf5ef2aSThomas Huth 475fcf5ef2aSThomas Huth /*****************************************************************************/ 476fcf5ef2aSThomas Huth /* 602 specific instructions */ 477fcf5ef2aSThomas Huth /* mfrom is the most crazy instruction ever seen, imho ! */ 478fcf5ef2aSThomas Huth /* Real implementation uses a ROM table. Do the same */ 479b6cb41b2SDavid Gibson /* 480b6cb41b2SDavid Gibson * Extremely decomposed: 481fcf5ef2aSThomas Huth * -arg / 256 482fcf5ef2aSThomas Huth * return 256 * log10(10 + 1.0) + 0.5 483fcf5ef2aSThomas Huth */ 484fcf5ef2aSThomas Huth #if !defined(CONFIG_USER_ONLY) 485fcf5ef2aSThomas Huth target_ulong helper_602_mfrom(target_ulong arg) 486fcf5ef2aSThomas Huth { 487fcf5ef2aSThomas Huth if (likely(arg < 602)) { 488139c1837SPaolo Bonzini #include "mfrom_table.c.inc" 489fcf5ef2aSThomas Huth return mfrom_ROM_table[arg]; 490fcf5ef2aSThomas Huth } else { 491fcf5ef2aSThomas Huth return 0; 492fcf5ef2aSThomas Huth } 493fcf5ef2aSThomas Huth } 494fcf5ef2aSThomas Huth #endif 495fcf5ef2aSThomas Huth 496fcf5ef2aSThomas Huth /*****************************************************************************/ 497fcf5ef2aSThomas Huth /* Altivec extension helpers */ 498fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 499fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 500fcf5ef2aSThomas Huth for (index = 0; index < ARRAY_SIZE(r->element); index++) 501fcf5ef2aSThomas Huth #else 502fcf5ef2aSThomas Huth #define VECTOR_FOR_INORDER_I(index, element) \ 503fcf5ef2aSThomas Huth for (index = ARRAY_SIZE(r->element) - 1; index >= 0; index--) 504fcf5ef2aSThomas Huth #endif 505fcf5ef2aSThomas Huth 506fcf5ef2aSThomas Huth /* Saturating arithmetic helpers. */ 507fcf5ef2aSThomas Huth #define SATCVT(from, to, from_type, to_type, min, max) \ 508fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 509fcf5ef2aSThomas Huth { \ 510fcf5ef2aSThomas Huth to_type r; \ 511fcf5ef2aSThomas Huth \ 512fcf5ef2aSThomas Huth if (x < (from_type)min) { \ 513fcf5ef2aSThomas Huth r = min; \ 514fcf5ef2aSThomas Huth *sat = 1; \ 515fcf5ef2aSThomas Huth } else if (x > (from_type)max) { \ 516fcf5ef2aSThomas Huth r = max; \ 517fcf5ef2aSThomas Huth *sat = 1; \ 518fcf5ef2aSThomas Huth } else { \ 519fcf5ef2aSThomas Huth r = x; \ 520fcf5ef2aSThomas Huth } \ 521fcf5ef2aSThomas Huth return r; \ 522fcf5ef2aSThomas Huth } 523fcf5ef2aSThomas Huth #define SATCVTU(from, to, from_type, to_type, min, max) \ 524fcf5ef2aSThomas Huth static inline to_type cvt##from##to(from_type x, int *sat) \ 525fcf5ef2aSThomas Huth { \ 526fcf5ef2aSThomas Huth to_type r; \ 527fcf5ef2aSThomas Huth \ 528fcf5ef2aSThomas Huth if (x > (from_type)max) { \ 529fcf5ef2aSThomas Huth r = max; \ 530fcf5ef2aSThomas Huth *sat = 1; \ 531fcf5ef2aSThomas Huth } else { \ 532fcf5ef2aSThomas Huth r = x; \ 533fcf5ef2aSThomas Huth } \ 534fcf5ef2aSThomas Huth return r; \ 535fcf5ef2aSThomas Huth } 536fcf5ef2aSThomas Huth SATCVT(sh, sb, int16_t, int8_t, INT8_MIN, INT8_MAX) 537fcf5ef2aSThomas Huth SATCVT(sw, sh, int32_t, int16_t, INT16_MIN, INT16_MAX) 538fcf5ef2aSThomas Huth SATCVT(sd, sw, int64_t, int32_t, INT32_MIN, INT32_MAX) 539fcf5ef2aSThomas Huth 540fcf5ef2aSThomas Huth SATCVTU(uh, ub, uint16_t, uint8_t, 0, UINT8_MAX) 541fcf5ef2aSThomas Huth SATCVTU(uw, uh, uint32_t, uint16_t, 0, UINT16_MAX) 542fcf5ef2aSThomas Huth SATCVTU(ud, uw, uint64_t, uint32_t, 0, UINT32_MAX) 543fcf5ef2aSThomas Huth SATCVT(sh, ub, int16_t, uint8_t, 0, UINT8_MAX) 544fcf5ef2aSThomas Huth SATCVT(sw, uh, int32_t, uint16_t, 0, UINT16_MAX) 545fcf5ef2aSThomas Huth SATCVT(sd, uw, int64_t, uint32_t, 0, UINT32_MAX) 546fcf5ef2aSThomas Huth #undef SATCVT 547fcf5ef2aSThomas Huth #undef SATCVTU 548fcf5ef2aSThomas Huth 549dedfaac7SRichard Henderson void helper_mtvscr(CPUPPCState *env, uint32_t vscr) 550fcf5ef2aSThomas Huth { 551c19940dbSBruno Larsen (billionai) ppc_store_vscr(env, vscr); 552fcf5ef2aSThomas Huth } 553fcf5ef2aSThomas Huth 554cc2b90d7SRichard Henderson uint32_t helper_mfvscr(CPUPPCState *env) 555cc2b90d7SRichard Henderson { 556c19940dbSBruno Larsen (billionai) return ppc_get_vscr(env); 557cc2b90d7SRichard Henderson } 558cc2b90d7SRichard Henderson 5596175f5a0SRichard Henderson static inline void set_vscr_sat(CPUPPCState *env) 5606175f5a0SRichard Henderson { 5619b5b74daSRichard Henderson /* The choice of non-zero value is arbitrary. */ 5629b5b74daSRichard Henderson env->vscr_sat.u32[0] = 1; 5636175f5a0SRichard Henderson } 5646175f5a0SRichard Henderson 565fcf5ef2aSThomas Huth void helper_vaddcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 566fcf5ef2aSThomas Huth { 567fcf5ef2aSThomas Huth int i; 568fcf5ef2aSThomas Huth 569fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 570fcf5ef2aSThomas Huth r->u32[i] = ~a->u32[i] < b->u32[i]; 571fcf5ef2aSThomas Huth } 572fcf5ef2aSThomas Huth } 573fcf5ef2aSThomas Huth 574fcf5ef2aSThomas Huth /* vprtybw */ 575fcf5ef2aSThomas Huth void helper_vprtybw(ppc_avr_t *r, ppc_avr_t *b) 576fcf5ef2aSThomas Huth { 577fcf5ef2aSThomas Huth int i; 578fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 579fcf5ef2aSThomas Huth uint64_t res = b->u32[i] ^ (b->u32[i] >> 16); 580fcf5ef2aSThomas Huth res ^= res >> 8; 581fcf5ef2aSThomas Huth r->u32[i] = res & 1; 582fcf5ef2aSThomas Huth } 583fcf5ef2aSThomas Huth } 584fcf5ef2aSThomas Huth 585fcf5ef2aSThomas Huth /* vprtybd */ 586fcf5ef2aSThomas Huth void helper_vprtybd(ppc_avr_t *r, ppc_avr_t *b) 587fcf5ef2aSThomas Huth { 588fcf5ef2aSThomas Huth int i; 589fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 590fcf5ef2aSThomas Huth uint64_t res = b->u64[i] ^ (b->u64[i] >> 32); 591fcf5ef2aSThomas Huth res ^= res >> 16; 592fcf5ef2aSThomas Huth res ^= res >> 8; 593fcf5ef2aSThomas Huth r->u64[i] = res & 1; 594fcf5ef2aSThomas Huth } 595fcf5ef2aSThomas Huth } 596fcf5ef2aSThomas Huth 597fcf5ef2aSThomas Huth /* vprtybq */ 598fcf5ef2aSThomas Huth void helper_vprtybq(ppc_avr_t *r, ppc_avr_t *b) 599fcf5ef2aSThomas Huth { 600fcf5ef2aSThomas Huth uint64_t res = b->u64[0] ^ b->u64[1]; 601fcf5ef2aSThomas Huth res ^= res >> 32; 602fcf5ef2aSThomas Huth res ^= res >> 16; 603fcf5ef2aSThomas Huth res ^= res >> 8; 6043c385a93SMark Cave-Ayland r->VsrD(1) = res & 1; 6053c385a93SMark Cave-Ayland r->VsrD(0) = 0; 606fcf5ef2aSThomas Huth } 607fcf5ef2aSThomas Huth 608fcf5ef2aSThomas Huth #define VARITHFP(suffix, func) \ 609fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 610fcf5ef2aSThomas Huth ppc_avr_t *b) \ 611fcf5ef2aSThomas Huth { \ 612fcf5ef2aSThomas Huth int i; \ 613fcf5ef2aSThomas Huth \ 61405ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 61505ee3e8aSMark Cave-Ayland r->f32[i] = func(a->f32[i], b->f32[i], &env->vec_status); \ 616fcf5ef2aSThomas Huth } \ 617fcf5ef2aSThomas Huth } 618fcf5ef2aSThomas Huth VARITHFP(addfp, float32_add) 619fcf5ef2aSThomas Huth VARITHFP(subfp, float32_sub) 620fcf5ef2aSThomas Huth VARITHFP(minfp, float32_min) 621fcf5ef2aSThomas Huth VARITHFP(maxfp, float32_max) 622fcf5ef2aSThomas Huth #undef VARITHFP 623fcf5ef2aSThomas Huth 624fcf5ef2aSThomas Huth #define VARITHFPFMA(suffix, type) \ 625fcf5ef2aSThomas Huth void helper_v##suffix(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, \ 626fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) \ 627fcf5ef2aSThomas Huth { \ 628fcf5ef2aSThomas Huth int i; \ 62905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 63005ee3e8aSMark Cave-Ayland r->f32[i] = float32_muladd(a->f32[i], c->f32[i], b->f32[i], \ 631fcf5ef2aSThomas Huth type, &env->vec_status); \ 632fcf5ef2aSThomas Huth } \ 633fcf5ef2aSThomas Huth } 634fcf5ef2aSThomas Huth VARITHFPFMA(maddfp, 0); 635fcf5ef2aSThomas Huth VARITHFPFMA(nmsubfp, float_muladd_negate_result | float_muladd_negate_c); 636fcf5ef2aSThomas Huth #undef VARITHFPFMA 637fcf5ef2aSThomas Huth 638fcf5ef2aSThomas Huth #define VARITHSAT_CASE(type, op, cvt, element) \ 639fcf5ef2aSThomas Huth { \ 640fcf5ef2aSThomas Huth type result = (type)a->element[i] op (type)b->element[i]; \ 641fcf5ef2aSThomas Huth r->element[i] = cvt(result, &sat); \ 642fcf5ef2aSThomas Huth } 643fcf5ef2aSThomas Huth 644fcf5ef2aSThomas Huth #define VARITHSAT_DO(name, op, optype, cvt, element) \ 645fb11ae7dSRichard Henderson void helper_v##name(ppc_avr_t *r, ppc_avr_t *vscr_sat, \ 646fb11ae7dSRichard Henderson ppc_avr_t *a, ppc_avr_t *b, uint32_t desc) \ 647fcf5ef2aSThomas Huth { \ 648fcf5ef2aSThomas Huth int sat = 0; \ 649fcf5ef2aSThomas Huth int i; \ 650fcf5ef2aSThomas Huth \ 651fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 652fcf5ef2aSThomas Huth VARITHSAT_CASE(optype, op, cvt, element); \ 653fcf5ef2aSThomas Huth } \ 654fcf5ef2aSThomas Huth if (sat) { \ 655fb11ae7dSRichard Henderson vscr_sat->u32[0] = 1; \ 656fcf5ef2aSThomas Huth } \ 657fcf5ef2aSThomas Huth } 658fcf5ef2aSThomas Huth #define VARITHSAT_SIGNED(suffix, element, optype, cvt) \ 659fcf5ef2aSThomas Huth VARITHSAT_DO(adds##suffix##s, +, optype, cvt, element) \ 660fcf5ef2aSThomas Huth VARITHSAT_DO(subs##suffix##s, -, optype, cvt, element) 661fcf5ef2aSThomas Huth #define VARITHSAT_UNSIGNED(suffix, element, optype, cvt) \ 662fcf5ef2aSThomas Huth VARITHSAT_DO(addu##suffix##s, +, optype, cvt, element) \ 663fcf5ef2aSThomas Huth VARITHSAT_DO(subu##suffix##s, -, optype, cvt, element) 664fcf5ef2aSThomas Huth VARITHSAT_SIGNED(b, s8, int16_t, cvtshsb) 665fcf5ef2aSThomas Huth VARITHSAT_SIGNED(h, s16, int32_t, cvtswsh) 666fcf5ef2aSThomas Huth VARITHSAT_SIGNED(w, s32, int64_t, cvtsdsw) 667fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(b, u8, uint16_t, cvtshub) 668fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(h, u16, uint32_t, cvtswuh) 669fcf5ef2aSThomas Huth VARITHSAT_UNSIGNED(w, u32, uint64_t, cvtsduw) 670fcf5ef2aSThomas Huth #undef VARITHSAT_CASE 671fcf5ef2aSThomas Huth #undef VARITHSAT_DO 672fcf5ef2aSThomas Huth #undef VARITHSAT_SIGNED 673fcf5ef2aSThomas Huth #undef VARITHSAT_UNSIGNED 674fcf5ef2aSThomas Huth 675fcf5ef2aSThomas Huth #define VAVG_DO(name, element, etype) \ 676fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 677fcf5ef2aSThomas Huth { \ 678fcf5ef2aSThomas Huth int i; \ 679fcf5ef2aSThomas Huth \ 680fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 681fcf5ef2aSThomas Huth etype x = (etype)a->element[i] + (etype)b->element[i] + 1; \ 682fcf5ef2aSThomas Huth r->element[i] = x >> 1; \ 683fcf5ef2aSThomas Huth } \ 684fcf5ef2aSThomas Huth } 685fcf5ef2aSThomas Huth 686fcf5ef2aSThomas Huth #define VAVG(type, signed_element, signed_type, unsigned_element, \ 687fcf5ef2aSThomas Huth unsigned_type) \ 688fcf5ef2aSThomas Huth VAVG_DO(avgs##type, signed_element, signed_type) \ 689fcf5ef2aSThomas Huth VAVG_DO(avgu##type, unsigned_element, unsigned_type) 690fcf5ef2aSThomas Huth VAVG(b, s8, int16_t, u8, uint16_t) 691fcf5ef2aSThomas Huth VAVG(h, s16, int32_t, u16, uint32_t) 692fcf5ef2aSThomas Huth VAVG(w, s32, int64_t, u32, uint64_t) 693fcf5ef2aSThomas Huth #undef VAVG_DO 694fcf5ef2aSThomas Huth #undef VAVG 695fcf5ef2aSThomas Huth 696fcf5ef2aSThomas Huth #define VABSDU_DO(name, element) \ 697fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 698fcf5ef2aSThomas Huth { \ 699fcf5ef2aSThomas Huth int i; \ 700fcf5ef2aSThomas Huth \ 701fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 702fcf5ef2aSThomas Huth r->element[i] = (a->element[i] > b->element[i]) ? \ 703fcf5ef2aSThomas Huth (a->element[i] - b->element[i]) : \ 704fcf5ef2aSThomas Huth (b->element[i] - a->element[i]); \ 705fcf5ef2aSThomas Huth } \ 706fcf5ef2aSThomas Huth } 707fcf5ef2aSThomas Huth 708b6cb41b2SDavid Gibson /* 709b6cb41b2SDavid Gibson * VABSDU - Vector absolute difference unsigned 710fcf5ef2aSThomas Huth * name - instruction mnemonic suffix (b: byte, h: halfword, w: word) 711fcf5ef2aSThomas Huth * element - element type to access from vector 712fcf5ef2aSThomas Huth */ 713fcf5ef2aSThomas Huth #define VABSDU(type, element) \ 714fcf5ef2aSThomas Huth VABSDU_DO(absdu##type, element) 715fcf5ef2aSThomas Huth VABSDU(b, u8) 716fcf5ef2aSThomas Huth VABSDU(h, u16) 717fcf5ef2aSThomas Huth VABSDU(w, u32) 718fcf5ef2aSThomas Huth #undef VABSDU_DO 719fcf5ef2aSThomas Huth #undef VABSDU 720fcf5ef2aSThomas Huth 721fcf5ef2aSThomas Huth #define VCF(suffix, cvt, element) \ 722fcf5ef2aSThomas Huth void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \ 723fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 724fcf5ef2aSThomas Huth { \ 725fcf5ef2aSThomas Huth int i; \ 726fcf5ef2aSThomas Huth \ 72705ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 728fcf5ef2aSThomas Huth float32 t = cvt(b->element[i], &env->vec_status); \ 72905ee3e8aSMark Cave-Ayland r->f32[i] = float32_scalbn(t, -uim, &env->vec_status); \ 730fcf5ef2aSThomas Huth } \ 731fcf5ef2aSThomas Huth } 732fcf5ef2aSThomas Huth VCF(ux, uint32_to_float32, u32) 733fcf5ef2aSThomas Huth VCF(sx, int32_to_float32, s32) 734fcf5ef2aSThomas Huth #undef VCF 735fcf5ef2aSThomas Huth 736fcf5ef2aSThomas Huth #define VCMP_DO(suffix, compare, element, record) \ 737fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 738fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 739fcf5ef2aSThomas Huth { \ 740fcf5ef2aSThomas Huth uint64_t ones = (uint64_t)-1; \ 741fcf5ef2aSThomas Huth uint64_t all = ones; \ 742fcf5ef2aSThomas Huth uint64_t none = 0; \ 743fcf5ef2aSThomas Huth int i; \ 744fcf5ef2aSThomas Huth \ 745fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 746fcf5ef2aSThomas Huth uint64_t result = (a->element[i] compare b->element[i] ? \ 747fcf5ef2aSThomas Huth ones : 0x0); \ 748fcf5ef2aSThomas Huth switch (sizeof(a->element[0])) { \ 749fcf5ef2aSThomas Huth case 8: \ 750fcf5ef2aSThomas Huth r->u64[i] = result; \ 751fcf5ef2aSThomas Huth break; \ 752fcf5ef2aSThomas Huth case 4: \ 753fcf5ef2aSThomas Huth r->u32[i] = result; \ 754fcf5ef2aSThomas Huth break; \ 755fcf5ef2aSThomas Huth case 2: \ 756fcf5ef2aSThomas Huth r->u16[i] = result; \ 757fcf5ef2aSThomas Huth break; \ 758fcf5ef2aSThomas Huth case 1: \ 759fcf5ef2aSThomas Huth r->u8[i] = result; \ 760fcf5ef2aSThomas Huth break; \ 761fcf5ef2aSThomas Huth } \ 762fcf5ef2aSThomas Huth all &= result; \ 763fcf5ef2aSThomas Huth none |= result; \ 764fcf5ef2aSThomas Huth } \ 765fcf5ef2aSThomas Huth if (record) { \ 766fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 767fcf5ef2aSThomas Huth } \ 768fcf5ef2aSThomas Huth } 769fcf5ef2aSThomas Huth #define VCMP(suffix, compare, element) \ 770fcf5ef2aSThomas Huth VCMP_DO(suffix, compare, element, 0) \ 771fcf5ef2aSThomas Huth VCMP_DO(suffix##_dot, compare, element, 1) 772fcf5ef2aSThomas Huth VCMP(equb, ==, u8) 773fcf5ef2aSThomas Huth VCMP(equh, ==, u16) 774fcf5ef2aSThomas Huth VCMP(equw, ==, u32) 775fcf5ef2aSThomas Huth VCMP(equd, ==, u64) 776fcf5ef2aSThomas Huth VCMP(gtub, >, u8) 777fcf5ef2aSThomas Huth VCMP(gtuh, >, u16) 778fcf5ef2aSThomas Huth VCMP(gtuw, >, u32) 779fcf5ef2aSThomas Huth VCMP(gtud, >, u64) 780fcf5ef2aSThomas Huth VCMP(gtsb, >, s8) 781fcf5ef2aSThomas Huth VCMP(gtsh, >, s16) 782fcf5ef2aSThomas Huth VCMP(gtsw, >, s32) 783fcf5ef2aSThomas Huth VCMP(gtsd, >, s64) 784fcf5ef2aSThomas Huth #undef VCMP_DO 785fcf5ef2aSThomas Huth #undef VCMP 786fcf5ef2aSThomas Huth 787fcf5ef2aSThomas Huth #define VCMPNE_DO(suffix, element, etype, cmpzero, record) \ 788fcf5ef2aSThomas Huth void helper_vcmpne##suffix(CPUPPCState *env, ppc_avr_t *r, \ 789fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 790fcf5ef2aSThomas Huth { \ 791fcf5ef2aSThomas Huth etype ones = (etype)-1; \ 792fcf5ef2aSThomas Huth etype all = ones; \ 793fcf5ef2aSThomas Huth etype result, none = 0; \ 794fcf5ef2aSThomas Huth int i; \ 795fcf5ef2aSThomas Huth \ 796fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 797fcf5ef2aSThomas Huth if (cmpzero) { \ 798fcf5ef2aSThomas Huth result = ((a->element[i] == 0) \ 799fcf5ef2aSThomas Huth || (b->element[i] == 0) \ 800fcf5ef2aSThomas Huth || (a->element[i] != b->element[i]) ? \ 801fcf5ef2aSThomas Huth ones : 0x0); \ 802fcf5ef2aSThomas Huth } else { \ 803fcf5ef2aSThomas Huth result = (a->element[i] != b->element[i]) ? ones : 0x0; \ 804fcf5ef2aSThomas Huth } \ 805fcf5ef2aSThomas Huth r->element[i] = result; \ 806fcf5ef2aSThomas Huth all &= result; \ 807fcf5ef2aSThomas Huth none |= result; \ 808fcf5ef2aSThomas Huth } \ 809fcf5ef2aSThomas Huth if (record) { \ 810fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 811fcf5ef2aSThomas Huth } \ 812fcf5ef2aSThomas Huth } 813fcf5ef2aSThomas Huth 814b6cb41b2SDavid Gibson /* 815b6cb41b2SDavid Gibson * VCMPNEZ - Vector compare not equal to zero 816fcf5ef2aSThomas Huth * suffix - instruction mnemonic suffix (b: byte, h: halfword, w: word) 817fcf5ef2aSThomas Huth * element - element type to access from vector 818fcf5ef2aSThomas Huth */ 819fcf5ef2aSThomas Huth #define VCMPNE(suffix, element, etype, cmpzero) \ 820fcf5ef2aSThomas Huth VCMPNE_DO(suffix, element, etype, cmpzero, 0) \ 821fcf5ef2aSThomas Huth VCMPNE_DO(suffix##_dot, element, etype, cmpzero, 1) 822fcf5ef2aSThomas Huth VCMPNE(zb, u8, uint8_t, 1) 823fcf5ef2aSThomas Huth VCMPNE(zh, u16, uint16_t, 1) 824fcf5ef2aSThomas Huth VCMPNE(zw, u32, uint32_t, 1) 825fcf5ef2aSThomas Huth VCMPNE(b, u8, uint8_t, 0) 826fcf5ef2aSThomas Huth VCMPNE(h, u16, uint16_t, 0) 827fcf5ef2aSThomas Huth VCMPNE(w, u32, uint32_t, 0) 828fcf5ef2aSThomas Huth #undef VCMPNE_DO 829fcf5ef2aSThomas Huth #undef VCMPNE 830fcf5ef2aSThomas Huth 831fcf5ef2aSThomas Huth #define VCMPFP_DO(suffix, compare, order, record) \ 832fcf5ef2aSThomas Huth void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \ 833fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 834fcf5ef2aSThomas Huth { \ 835fcf5ef2aSThomas Huth uint32_t ones = (uint32_t)-1; \ 836fcf5ef2aSThomas Huth uint32_t all = ones; \ 837fcf5ef2aSThomas Huth uint32_t none = 0; \ 838fcf5ef2aSThomas Huth int i; \ 839fcf5ef2aSThomas Huth \ 84005ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 841fcf5ef2aSThomas Huth uint32_t result; \ 84271bfd65cSRichard Henderson FloatRelation rel = \ 84371bfd65cSRichard Henderson float32_compare_quiet(a->f32[i], b->f32[i], \ 844fcf5ef2aSThomas Huth &env->vec_status); \ 845fcf5ef2aSThomas Huth if (rel == float_relation_unordered) { \ 846fcf5ef2aSThomas Huth result = 0; \ 847fcf5ef2aSThomas Huth } else if (rel compare order) { \ 848fcf5ef2aSThomas Huth result = ones; \ 849fcf5ef2aSThomas Huth } else { \ 850fcf5ef2aSThomas Huth result = 0; \ 851fcf5ef2aSThomas Huth } \ 852fcf5ef2aSThomas Huth r->u32[i] = result; \ 853fcf5ef2aSThomas Huth all &= result; \ 854fcf5ef2aSThomas Huth none |= result; \ 855fcf5ef2aSThomas Huth } \ 856fcf5ef2aSThomas Huth if (record) { \ 857fcf5ef2aSThomas Huth env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \ 858fcf5ef2aSThomas Huth } \ 859fcf5ef2aSThomas Huth } 860fcf5ef2aSThomas Huth #define VCMPFP(suffix, compare, order) \ 861fcf5ef2aSThomas Huth VCMPFP_DO(suffix, compare, order, 0) \ 862fcf5ef2aSThomas Huth VCMPFP_DO(suffix##_dot, compare, order, 1) 863fcf5ef2aSThomas Huth VCMPFP(eqfp, ==, float_relation_equal) 864fcf5ef2aSThomas Huth VCMPFP(gefp, !=, float_relation_less) 865fcf5ef2aSThomas Huth VCMPFP(gtfp, ==, float_relation_greater) 866fcf5ef2aSThomas Huth #undef VCMPFP_DO 867fcf5ef2aSThomas Huth #undef VCMPFP 868fcf5ef2aSThomas Huth 869fcf5ef2aSThomas Huth static inline void vcmpbfp_internal(CPUPPCState *env, ppc_avr_t *r, 870fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b, int record) 871fcf5ef2aSThomas Huth { 872fcf5ef2aSThomas Huth int i; 873fcf5ef2aSThomas Huth int all_in = 0; 874fcf5ef2aSThomas Huth 87505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 87671bfd65cSRichard Henderson FloatRelation le_rel = float32_compare_quiet(a->f32[i], b->f32[i], 87705ee3e8aSMark Cave-Ayland &env->vec_status); 878fcf5ef2aSThomas Huth if (le_rel == float_relation_unordered) { 879fcf5ef2aSThomas Huth r->u32[i] = 0xc0000000; 880fcf5ef2aSThomas Huth all_in = 1; 881fcf5ef2aSThomas Huth } else { 88205ee3e8aSMark Cave-Ayland float32 bneg = float32_chs(b->f32[i]); 88371bfd65cSRichard Henderson FloatRelation ge_rel = float32_compare_quiet(a->f32[i], bneg, 88405ee3e8aSMark Cave-Ayland &env->vec_status); 885fcf5ef2aSThomas Huth int le = le_rel != float_relation_greater; 886fcf5ef2aSThomas Huth int ge = ge_rel != float_relation_less; 887fcf5ef2aSThomas Huth 888fcf5ef2aSThomas Huth r->u32[i] = ((!le) << 31) | ((!ge) << 30); 889fcf5ef2aSThomas Huth all_in |= (!le | !ge); 890fcf5ef2aSThomas Huth } 891fcf5ef2aSThomas Huth } 892fcf5ef2aSThomas Huth if (record) { 893fcf5ef2aSThomas Huth env->crf[6] = (all_in == 0) << 1; 894fcf5ef2aSThomas Huth } 895fcf5ef2aSThomas Huth } 896fcf5ef2aSThomas Huth 897fcf5ef2aSThomas Huth void helper_vcmpbfp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 898fcf5ef2aSThomas Huth { 899fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 0); 900fcf5ef2aSThomas Huth } 901fcf5ef2aSThomas Huth 902fcf5ef2aSThomas Huth void helper_vcmpbfp_dot(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 903fcf5ef2aSThomas Huth ppc_avr_t *b) 904fcf5ef2aSThomas Huth { 905fcf5ef2aSThomas Huth vcmpbfp_internal(env, r, a, b, 1); 906fcf5ef2aSThomas Huth } 907fcf5ef2aSThomas Huth 908fcf5ef2aSThomas Huth #define VCT(suffix, satcvt, element) \ 909fcf5ef2aSThomas Huth void helper_vct##suffix(CPUPPCState *env, ppc_avr_t *r, \ 910fcf5ef2aSThomas Huth ppc_avr_t *b, uint32_t uim) \ 911fcf5ef2aSThomas Huth { \ 912fcf5ef2aSThomas Huth int i; \ 913fcf5ef2aSThomas Huth int sat = 0; \ 914fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 915fcf5ef2aSThomas Huth \ 916fcf5ef2aSThomas Huth set_float_rounding_mode(float_round_to_zero, &s); \ 91705ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 91805ee3e8aSMark Cave-Ayland if (float32_is_any_nan(b->f32[i])) { \ 919fcf5ef2aSThomas Huth r->element[i] = 0; \ 920fcf5ef2aSThomas Huth } else { \ 92105ee3e8aSMark Cave-Ayland float64 t = float32_to_float64(b->f32[i], &s); \ 922fcf5ef2aSThomas Huth int64_t j; \ 923fcf5ef2aSThomas Huth \ 924fcf5ef2aSThomas Huth t = float64_scalbn(t, uim, &s); \ 925fcf5ef2aSThomas Huth j = float64_to_int64(t, &s); \ 926fcf5ef2aSThomas Huth r->element[i] = satcvt(j, &sat); \ 927fcf5ef2aSThomas Huth } \ 928fcf5ef2aSThomas Huth } \ 929fcf5ef2aSThomas Huth if (sat) { \ 9306175f5a0SRichard Henderson set_vscr_sat(env); \ 931fcf5ef2aSThomas Huth } \ 932fcf5ef2aSThomas Huth } 933fcf5ef2aSThomas Huth VCT(uxs, cvtsduw, u32) 934fcf5ef2aSThomas Huth VCT(sxs, cvtsdsw, s32) 935fcf5ef2aSThomas Huth #undef VCT 936fcf5ef2aSThomas Huth 937fcf5ef2aSThomas Huth target_ulong helper_vclzlsbb(ppc_avr_t *r) 938fcf5ef2aSThomas Huth { 939fcf5ef2aSThomas Huth target_ulong count = 0; 940fcf5ef2aSThomas Huth int i; 94160594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 94260594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 943fcf5ef2aSThomas Huth break; 944fcf5ef2aSThomas Huth } 945fcf5ef2aSThomas Huth count++; 946fcf5ef2aSThomas Huth } 947fcf5ef2aSThomas Huth return count; 948fcf5ef2aSThomas Huth } 949fcf5ef2aSThomas Huth 950fcf5ef2aSThomas Huth target_ulong helper_vctzlsbb(ppc_avr_t *r) 951fcf5ef2aSThomas Huth { 952fcf5ef2aSThomas Huth target_ulong count = 0; 953fcf5ef2aSThomas Huth int i; 954fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 95560594feaSMark Cave-Ayland if (r->VsrB(i) & 0x01) { 956fcf5ef2aSThomas Huth break; 957fcf5ef2aSThomas Huth } 958fcf5ef2aSThomas Huth count++; 959fcf5ef2aSThomas Huth } 960fcf5ef2aSThomas Huth return count; 961fcf5ef2aSThomas Huth } 962fcf5ef2aSThomas Huth 963fcf5ef2aSThomas Huth void helper_vmhaddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 964fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 965fcf5ef2aSThomas Huth { 966fcf5ef2aSThomas Huth int sat = 0; 967fcf5ef2aSThomas Huth int i; 968fcf5ef2aSThomas Huth 969fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 970fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 971fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 972fcf5ef2aSThomas Huth 973fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 974fcf5ef2aSThomas Huth } 975fcf5ef2aSThomas Huth 976fcf5ef2aSThomas Huth if (sat) { 9776175f5a0SRichard Henderson set_vscr_sat(env); 978fcf5ef2aSThomas Huth } 979fcf5ef2aSThomas Huth } 980fcf5ef2aSThomas Huth 981fcf5ef2aSThomas Huth void helper_vmhraddshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 982fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 983fcf5ef2aSThomas Huth { 984fcf5ef2aSThomas Huth int sat = 0; 985fcf5ef2aSThomas Huth int i; 986fcf5ef2aSThomas Huth 987fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 988fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i] + 0x00004000; 989fcf5ef2aSThomas Huth int32_t t = (int32_t)c->s16[i] + (prod >> 15); 990fcf5ef2aSThomas Huth r->s16[i] = cvtswsh(t, &sat); 991fcf5ef2aSThomas Huth } 992fcf5ef2aSThomas Huth 993fcf5ef2aSThomas Huth if (sat) { 9946175f5a0SRichard Henderson set_vscr_sat(env); 995fcf5ef2aSThomas Huth } 996fcf5ef2aSThomas Huth } 997fcf5ef2aSThomas Huth 998fcf5ef2aSThomas Huth void helper_vmladduhm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 999fcf5ef2aSThomas Huth { 1000fcf5ef2aSThomas Huth int i; 1001fcf5ef2aSThomas Huth 1002fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1003fcf5ef2aSThomas Huth int32_t prod = a->s16[i] * b->s16[i]; 1004fcf5ef2aSThomas Huth r->s16[i] = (int16_t) (prod + c->s16[i]); 1005fcf5ef2aSThomas Huth } 1006fcf5ef2aSThomas Huth } 1007fcf5ef2aSThomas Huth 1008d81c2040SMark Cave-Ayland #define VMRG_DO(name, element, access, ofs) \ 1009fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1010fcf5ef2aSThomas Huth { \ 1011fcf5ef2aSThomas Huth ppc_avr_t result; \ 1012d81c2040SMark Cave-Ayland int i, half = ARRAY_SIZE(r->element) / 2; \ 1013fcf5ef2aSThomas Huth \ 1014d81c2040SMark Cave-Ayland for (i = 0; i < half; i++) { \ 1015d81c2040SMark Cave-Ayland result.access(i * 2 + 0) = a->access(i + ofs); \ 1016d81c2040SMark Cave-Ayland result.access(i * 2 + 1) = b->access(i + ofs); \ 1017fcf5ef2aSThomas Huth } \ 1018fcf5ef2aSThomas Huth *r = result; \ 1019fcf5ef2aSThomas Huth } 1020d81c2040SMark Cave-Ayland 1021d81c2040SMark Cave-Ayland #define VMRG(suffix, element, access) \ 1022d81c2040SMark Cave-Ayland VMRG_DO(mrgl##suffix, element, access, half) \ 1023d81c2040SMark Cave-Ayland VMRG_DO(mrgh##suffix, element, access, 0) 1024d81c2040SMark Cave-Ayland VMRG(b, u8, VsrB) 1025d81c2040SMark Cave-Ayland VMRG(h, u16, VsrH) 1026d81c2040SMark Cave-Ayland VMRG(w, u32, VsrW) 1027fcf5ef2aSThomas Huth #undef VMRG_DO 1028fcf5ef2aSThomas Huth #undef VMRG 1029fcf5ef2aSThomas Huth 1030fcf5ef2aSThomas Huth void helper_vmsummbm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1031fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1032fcf5ef2aSThomas Huth { 1033fcf5ef2aSThomas Huth int32_t prod[16]; 1034fcf5ef2aSThomas Huth int i; 1035fcf5ef2aSThomas Huth 1036fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s8); i++) { 1037fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s8[i] * b->u8[i]; 1038fcf5ef2aSThomas Huth } 1039fcf5ef2aSThomas Huth 1040fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1041fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[4 * i] + prod[4 * i + 1] + 1042fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 1043fcf5ef2aSThomas Huth } 1044fcf5ef2aSThomas Huth } 1045fcf5ef2aSThomas Huth 1046fcf5ef2aSThomas Huth void helper_vmsumshm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1047fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1048fcf5ef2aSThomas Huth { 1049fcf5ef2aSThomas Huth int32_t prod[8]; 1050fcf5ef2aSThomas Huth int i; 1051fcf5ef2aSThomas Huth 1052fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1053fcf5ef2aSThomas Huth prod[i] = a->s16[i] * b->s16[i]; 1054fcf5ef2aSThomas Huth } 1055fcf5ef2aSThomas Huth 1056fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1057fcf5ef2aSThomas Huth r->s32[i] = c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1058fcf5ef2aSThomas Huth } 1059fcf5ef2aSThomas Huth } 1060fcf5ef2aSThomas Huth 1061fcf5ef2aSThomas Huth void helper_vmsumshs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1062fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1063fcf5ef2aSThomas Huth { 1064fcf5ef2aSThomas Huth int32_t prod[8]; 1065fcf5ef2aSThomas Huth int i; 1066fcf5ef2aSThomas Huth int sat = 0; 1067fcf5ef2aSThomas Huth 1068fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s16); i++) { 1069fcf5ef2aSThomas Huth prod[i] = (int32_t)a->s16[i] * b->s16[i]; 1070fcf5ef2aSThomas Huth } 1071fcf5ef2aSThomas Huth 1072fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1073fcf5ef2aSThomas Huth int64_t t = (int64_t)c->s32[i] + prod[2 * i] + prod[2 * i + 1]; 1074fcf5ef2aSThomas Huth 1075fcf5ef2aSThomas Huth r->u32[i] = cvtsdsw(t, &sat); 1076fcf5ef2aSThomas Huth } 1077fcf5ef2aSThomas Huth 1078fcf5ef2aSThomas Huth if (sat) { 10796175f5a0SRichard Henderson set_vscr_sat(env); 1080fcf5ef2aSThomas Huth } 1081fcf5ef2aSThomas Huth } 1082fcf5ef2aSThomas Huth 1083fcf5ef2aSThomas Huth void helper_vmsumubm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1084fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1085fcf5ef2aSThomas Huth { 1086fcf5ef2aSThomas Huth uint16_t prod[16]; 1087fcf5ef2aSThomas Huth int i; 1088fcf5ef2aSThomas Huth 1089fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1090fcf5ef2aSThomas Huth prod[i] = a->u8[i] * b->u8[i]; 1091fcf5ef2aSThomas Huth } 1092fcf5ef2aSThomas Huth 1093fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1094fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[4 * i] + prod[4 * i + 1] + 1095fcf5ef2aSThomas Huth prod[4 * i + 2] + prod[4 * i + 3]; 1096fcf5ef2aSThomas Huth } 1097fcf5ef2aSThomas Huth } 1098fcf5ef2aSThomas Huth 1099fcf5ef2aSThomas Huth void helper_vmsumuhm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1100fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1101fcf5ef2aSThomas Huth { 1102fcf5ef2aSThomas Huth uint32_t prod[8]; 1103fcf5ef2aSThomas Huth int i; 1104fcf5ef2aSThomas Huth 1105fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1106fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1107fcf5ef2aSThomas Huth } 1108fcf5ef2aSThomas Huth 1109fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 1110fcf5ef2aSThomas Huth r->u32[i] = c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1111fcf5ef2aSThomas Huth } 1112fcf5ef2aSThomas Huth } 1113fcf5ef2aSThomas Huth 1114fcf5ef2aSThomas Huth void helper_vmsumuhs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, 1115fcf5ef2aSThomas Huth ppc_avr_t *b, ppc_avr_t *c) 1116fcf5ef2aSThomas Huth { 1117fcf5ef2aSThomas Huth uint32_t prod[8]; 1118fcf5ef2aSThomas Huth int i; 1119fcf5ef2aSThomas Huth int sat = 0; 1120fcf5ef2aSThomas Huth 1121fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u16); i++) { 1122fcf5ef2aSThomas Huth prod[i] = a->u16[i] * b->u16[i]; 1123fcf5ef2aSThomas Huth } 1124fcf5ef2aSThomas Huth 1125fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, s32) { 1126fcf5ef2aSThomas Huth uint64_t t = (uint64_t)c->u32[i] + prod[2 * i] + prod[2 * i + 1]; 1127fcf5ef2aSThomas Huth 1128fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 1129fcf5ef2aSThomas Huth } 1130fcf5ef2aSThomas Huth 1131fcf5ef2aSThomas Huth if (sat) { 11326175f5a0SRichard Henderson set_vscr_sat(env); 1133fcf5ef2aSThomas Huth } 1134fcf5ef2aSThomas Huth } 1135fcf5ef2aSThomas Huth 11364fbc89edSMark Cave-Ayland #define VMUL_DO_EVN(name, mul_element, mul_access, prod_access, cast) \ 1137fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1138fcf5ef2aSThomas Huth { \ 1139fcf5ef2aSThomas Huth int i; \ 1140fcf5ef2aSThomas Huth \ 11414fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 11424fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i) * \ 11434fbc89edSMark Cave-Ayland (cast)b->mul_access(i); \ 1144fcf5ef2aSThomas Huth } \ 1145fcf5ef2aSThomas Huth } 11464fbc89edSMark Cave-Ayland 11474fbc89edSMark Cave-Ayland #define VMUL_DO_ODD(name, mul_element, mul_access, prod_access, cast) \ 11484fbc89edSMark Cave-Ayland void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 11494fbc89edSMark Cave-Ayland { \ 11504fbc89edSMark Cave-Ayland int i; \ 11514fbc89edSMark Cave-Ayland \ 11524fbc89edSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->mul_element); i += 2) { \ 11534fbc89edSMark Cave-Ayland r->prod_access(i >> 1) = (cast)a->mul_access(i + 1) * \ 11544fbc89edSMark Cave-Ayland (cast)b->mul_access(i + 1); \ 11554fbc89edSMark Cave-Ayland } \ 11564fbc89edSMark Cave-Ayland } 11574fbc89edSMark Cave-Ayland 11584fbc89edSMark Cave-Ayland #define VMUL(suffix, mul_element, mul_access, prod_access, cast) \ 11594fbc89edSMark Cave-Ayland VMUL_DO_EVN(mule##suffix, mul_element, mul_access, prod_access, cast) \ 11604fbc89edSMark Cave-Ayland VMUL_DO_ODD(mulo##suffix, mul_element, mul_access, prod_access, cast) 11614fbc89edSMark Cave-Ayland VMUL(sb, s8, VsrSB, VsrSH, int16_t) 11624fbc89edSMark Cave-Ayland VMUL(sh, s16, VsrSH, VsrSW, int32_t) 11634fbc89edSMark Cave-Ayland VMUL(sw, s32, VsrSW, VsrSD, int64_t) 11644fbc89edSMark Cave-Ayland VMUL(ub, u8, VsrB, VsrH, uint16_t) 11654fbc89edSMark Cave-Ayland VMUL(uh, u16, VsrH, VsrW, uint32_t) 11664fbc89edSMark Cave-Ayland VMUL(uw, u32, VsrW, VsrD, uint64_t) 11674fbc89edSMark Cave-Ayland #undef VMUL_DO_EVN 11684fbc89edSMark Cave-Ayland #undef VMUL_DO_ODD 1169fcf5ef2aSThomas Huth #undef VMUL 1170fcf5ef2aSThomas Huth 1171f3e0d864SLijun Pan void helper_vmulhsw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1172f3e0d864SLijun Pan { 1173f3e0d864SLijun Pan int i; 1174f3e0d864SLijun Pan 1175f3e0d864SLijun Pan for (i = 0; i < 4; i++) { 1176f3e0d864SLijun Pan r->s32[i] = (int32_t)(((int64_t)a->s32[i] * (int64_t)b->s32[i]) >> 32); 1177f3e0d864SLijun Pan } 1178f3e0d864SLijun Pan } 1179f3e0d864SLijun Pan 1180f3e0d864SLijun Pan void helper_vmulhuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1181f3e0d864SLijun Pan { 1182f3e0d864SLijun Pan int i; 1183f3e0d864SLijun Pan 1184f3e0d864SLijun Pan for (i = 0; i < 4; i++) { 1185f3e0d864SLijun Pan r->u32[i] = (uint32_t)(((uint64_t)a->u32[i] * 1186f3e0d864SLijun Pan (uint64_t)b->u32[i]) >> 32); 1187f3e0d864SLijun Pan } 1188f3e0d864SLijun Pan } 1189f3e0d864SLijun Pan 1190c4b8b49dSLijun Pan void helper_vmulhsd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1191c4b8b49dSLijun Pan { 1192c4b8b49dSLijun Pan uint64_t discard; 1193c4b8b49dSLijun Pan 1194c4b8b49dSLijun Pan muls64(&discard, &r->u64[0], a->s64[0], b->s64[0]); 1195c4b8b49dSLijun Pan muls64(&discard, &r->u64[1], a->s64[1], b->s64[1]); 1196c4b8b49dSLijun Pan } 1197c4b8b49dSLijun Pan 1198c4b8b49dSLijun Pan void helper_vmulhud(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1199c4b8b49dSLijun Pan { 1200c4b8b49dSLijun Pan uint64_t discard; 1201c4b8b49dSLijun Pan 1202c4b8b49dSLijun Pan mulu64(&discard, &r->u64[0], a->u64[0], b->u64[0]); 1203c4b8b49dSLijun Pan mulu64(&discard, &r->u64[1], a->u64[1], b->u64[1]); 1204c4b8b49dSLijun Pan } 1205c4b8b49dSLijun Pan 1206fcf5ef2aSThomas Huth void helper_vperm(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1207fcf5ef2aSThomas Huth ppc_avr_t *c) 1208fcf5ef2aSThomas Huth { 1209fcf5ef2aSThomas Huth ppc_avr_t result; 1210fcf5ef2aSThomas Huth int i; 1211fcf5ef2aSThomas Huth 121260594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 121360594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1214fcf5ef2aSThomas Huth int index = s & 0xf; 1215fcf5ef2aSThomas Huth 1216fcf5ef2aSThomas Huth if (s & 0x10) { 121760594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1218fcf5ef2aSThomas Huth } else { 121960594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1220fcf5ef2aSThomas Huth } 1221fcf5ef2aSThomas Huth } 1222fcf5ef2aSThomas Huth *r = result; 1223fcf5ef2aSThomas Huth } 1224fcf5ef2aSThomas Huth 1225fcf5ef2aSThomas Huth void helper_vpermr(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1226fcf5ef2aSThomas Huth ppc_avr_t *c) 1227fcf5ef2aSThomas Huth { 1228fcf5ef2aSThomas Huth ppc_avr_t result; 1229fcf5ef2aSThomas Huth int i; 1230fcf5ef2aSThomas Huth 123160594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 123260594feaSMark Cave-Ayland int s = c->VsrB(i) & 0x1f; 1233fcf5ef2aSThomas Huth int index = 15 - (s & 0xf); 1234fcf5ef2aSThomas Huth 1235fcf5ef2aSThomas Huth if (s & 0x10) { 123660594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1237fcf5ef2aSThomas Huth } else { 123860594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index); 1239fcf5ef2aSThomas Huth } 1240fcf5ef2aSThomas Huth } 1241fcf5ef2aSThomas Huth *r = result; 1242fcf5ef2aSThomas Huth } 1243fcf5ef2aSThomas Huth 1244fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1245fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[(i)]) 1246fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (i) 1247fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) != 0) 1248fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) (extract64((avr)->u64[i], index, 1)) 1249fcf5ef2aSThomas Huth #else 1250fcf5ef2aSThomas Huth #define VBPERMQ_INDEX(avr, i) ((avr)->u8[15 - (i)]) 1251fcf5ef2aSThomas Huth #define VBPERMD_INDEX(i) (1 - i) 1252fcf5ef2aSThomas Huth #define VBPERMQ_DW(index) (((index) & 0x40) == 0) 1253fcf5ef2aSThomas Huth #define EXTRACT_BIT(avr, i, index) \ 1254fcf5ef2aSThomas Huth (extract64((avr)->u64[1 - i], 63 - index, 1)) 1255fcf5ef2aSThomas Huth #endif 1256fcf5ef2aSThomas Huth 1257fcf5ef2aSThomas Huth void helper_vbpermd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1258fcf5ef2aSThomas Huth { 1259fcf5ef2aSThomas Huth int i, j; 1260fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 1261fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1262fcf5ef2aSThomas Huth for (j = 0; j < 8; j++) { 1263fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, (i * 8) + j); 1264fcf5ef2aSThomas Huth if (index < 64 && EXTRACT_BIT(a, i, index)) { 1265fcf5ef2aSThomas Huth result.u64[VBPERMD_INDEX(i)] |= (0x80 >> j); 1266fcf5ef2aSThomas Huth } 1267fcf5ef2aSThomas Huth } 1268fcf5ef2aSThomas Huth } 1269fcf5ef2aSThomas Huth *r = result; 1270fcf5ef2aSThomas Huth } 1271fcf5ef2aSThomas Huth 1272fcf5ef2aSThomas Huth void helper_vbpermq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1273fcf5ef2aSThomas Huth { 1274fcf5ef2aSThomas Huth int i; 1275fcf5ef2aSThomas Huth uint64_t perm = 0; 1276fcf5ef2aSThomas Huth 1277fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 1278fcf5ef2aSThomas Huth int index = VBPERMQ_INDEX(b, i); 1279fcf5ef2aSThomas Huth 1280fcf5ef2aSThomas Huth if (index < 128) { 1281fcf5ef2aSThomas Huth uint64_t mask = (1ull << (63 - (index & 0x3F))); 1282fcf5ef2aSThomas Huth if (a->u64[VBPERMQ_DW(index)] & mask) { 1283fcf5ef2aSThomas Huth perm |= (0x8000 >> i); 1284fcf5ef2aSThomas Huth } 1285fcf5ef2aSThomas Huth } 1286fcf5ef2aSThomas Huth } 1287fcf5ef2aSThomas Huth 12883c385a93SMark Cave-Ayland r->VsrD(0) = perm; 12893c385a93SMark Cave-Ayland r->VsrD(1) = 0; 1290fcf5ef2aSThomas Huth } 1291fcf5ef2aSThomas Huth 1292fcf5ef2aSThomas Huth #undef VBPERMQ_INDEX 1293fcf5ef2aSThomas Huth #undef VBPERMQ_DW 1294fcf5ef2aSThomas Huth 1295fcf5ef2aSThomas Huth #define PMSUM(name, srcfld, trgfld, trgtyp) \ 1296fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1297fcf5ef2aSThomas Huth { \ 1298fcf5ef2aSThomas Huth int i, j; \ 1299fcf5ef2aSThomas Huth trgtyp prod[sizeof(ppc_avr_t) / sizeof(a->srcfld[0])]; \ 1300fcf5ef2aSThomas Huth \ 1301fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, srcfld) { \ 1302fcf5ef2aSThomas Huth prod[i] = 0; \ 1303fcf5ef2aSThomas Huth for (j = 0; j < sizeof(a->srcfld[0]) * 8; j++) { \ 1304fcf5ef2aSThomas Huth if (a->srcfld[i] & (1ull << j)) { \ 1305fcf5ef2aSThomas Huth prod[i] ^= ((trgtyp)b->srcfld[i] << j); \ 1306fcf5ef2aSThomas Huth } \ 1307fcf5ef2aSThomas Huth } \ 1308fcf5ef2aSThomas Huth } \ 1309fcf5ef2aSThomas Huth \ 1310fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, trgfld) { \ 1311fcf5ef2aSThomas Huth r->trgfld[i] = prod[2 * i] ^ prod[2 * i + 1]; \ 1312fcf5ef2aSThomas Huth } \ 1313fcf5ef2aSThomas Huth } 1314fcf5ef2aSThomas Huth 1315fcf5ef2aSThomas Huth PMSUM(vpmsumb, u8, u16, uint16_t) 1316fcf5ef2aSThomas Huth PMSUM(vpmsumh, u16, u32, uint32_t) 1317fcf5ef2aSThomas Huth PMSUM(vpmsumw, u32, u64, uint64_t) 1318fcf5ef2aSThomas Huth 1319fcf5ef2aSThomas Huth void helper_vpmsumd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1320fcf5ef2aSThomas Huth { 1321fcf5ef2aSThomas Huth 1322fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 1323fcf5ef2aSThomas Huth int i, j; 1324fcf5ef2aSThomas Huth __uint128_t prod[2]; 1325fcf5ef2aSThomas Huth 1326fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1327fcf5ef2aSThomas Huth prod[i] = 0; 1328fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1329fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1330fcf5ef2aSThomas Huth prod[i] ^= (((__uint128_t)b->u64[i]) << j); 1331fcf5ef2aSThomas Huth } 1332fcf5ef2aSThomas Huth } 1333fcf5ef2aSThomas Huth } 1334fcf5ef2aSThomas Huth 1335fcf5ef2aSThomas Huth r->u128 = prod[0] ^ prod[1]; 1336fcf5ef2aSThomas Huth 1337fcf5ef2aSThomas Huth #else 1338fcf5ef2aSThomas Huth int i, j; 1339fcf5ef2aSThomas Huth ppc_avr_t prod[2]; 1340fcf5ef2aSThomas Huth 1341fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 13423c385a93SMark Cave-Ayland prod[i].VsrD(1) = prod[i].VsrD(0) = 0; 1343fcf5ef2aSThomas Huth for (j = 0; j < 64; j++) { 1344fcf5ef2aSThomas Huth if (a->u64[i] & (1ull << j)) { 1345fcf5ef2aSThomas Huth ppc_avr_t bshift; 1346fcf5ef2aSThomas Huth if (j == 0) { 13473c385a93SMark Cave-Ayland bshift.VsrD(0) = 0; 13483c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i]; 1349fcf5ef2aSThomas Huth } else { 13503c385a93SMark Cave-Ayland bshift.VsrD(0) = b->u64[i] >> (64 - j); 13513c385a93SMark Cave-Ayland bshift.VsrD(1) = b->u64[i] << j; 1352fcf5ef2aSThomas Huth } 13533c385a93SMark Cave-Ayland prod[i].VsrD(1) ^= bshift.VsrD(1); 13543c385a93SMark Cave-Ayland prod[i].VsrD(0) ^= bshift.VsrD(0); 1355fcf5ef2aSThomas Huth } 1356fcf5ef2aSThomas Huth } 1357fcf5ef2aSThomas Huth } 1358fcf5ef2aSThomas Huth 13593c385a93SMark Cave-Ayland r->VsrD(1) = prod[0].VsrD(1) ^ prod[1].VsrD(1); 13603c385a93SMark Cave-Ayland r->VsrD(0) = prod[0].VsrD(0) ^ prod[1].VsrD(0); 1361fcf5ef2aSThomas Huth #endif 1362fcf5ef2aSThomas Huth } 1363fcf5ef2aSThomas Huth 1364fcf5ef2aSThomas Huth 1365fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1366fcf5ef2aSThomas Huth #define PKBIG 1 1367fcf5ef2aSThomas Huth #else 1368fcf5ef2aSThomas Huth #define PKBIG 0 1369fcf5ef2aSThomas Huth #endif 1370fcf5ef2aSThomas Huth void helper_vpkpx(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1371fcf5ef2aSThomas Huth { 1372fcf5ef2aSThomas Huth int i, j; 1373fcf5ef2aSThomas Huth ppc_avr_t result; 1374fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1375fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { a, b }; 1376fcf5ef2aSThomas Huth #else 1377fcf5ef2aSThomas Huth const ppc_avr_t *x[2] = { b, a }; 1378fcf5ef2aSThomas Huth #endif 1379fcf5ef2aSThomas Huth 1380fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u64) { 1381fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(j, u32) { 1382fcf5ef2aSThomas Huth uint32_t e = x[i]->u32[j]; 1383fcf5ef2aSThomas Huth 1384fcf5ef2aSThomas Huth result.u16[4 * i + j] = (((e >> 9) & 0xfc00) | 1385fcf5ef2aSThomas Huth ((e >> 6) & 0x3e0) | 1386fcf5ef2aSThomas Huth ((e >> 3) & 0x1f)); 1387fcf5ef2aSThomas Huth } 1388fcf5ef2aSThomas Huth } 1389fcf5ef2aSThomas Huth *r = result; 1390fcf5ef2aSThomas Huth } 1391fcf5ef2aSThomas Huth 1392fcf5ef2aSThomas Huth #define VPK(suffix, from, to, cvt, dosat) \ 1393fcf5ef2aSThomas Huth void helper_vpk##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1394fcf5ef2aSThomas Huth ppc_avr_t *a, ppc_avr_t *b) \ 1395fcf5ef2aSThomas Huth { \ 1396fcf5ef2aSThomas Huth int i; \ 1397fcf5ef2aSThomas Huth int sat = 0; \ 1398fcf5ef2aSThomas Huth ppc_avr_t result; \ 1399fcf5ef2aSThomas Huth ppc_avr_t *a0 = PKBIG ? a : b; \ 1400fcf5ef2aSThomas Huth ppc_avr_t *a1 = PKBIG ? b : a; \ 1401fcf5ef2aSThomas Huth \ 1402fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, from) { \ 1403fcf5ef2aSThomas Huth result.to[i] = cvt(a0->from[i], &sat); \ 1404fcf5ef2aSThomas Huth result.to[i + ARRAY_SIZE(r->from)] = cvt(a1->from[i], &sat);\ 1405fcf5ef2aSThomas Huth } \ 1406fcf5ef2aSThomas Huth *r = result; \ 1407fcf5ef2aSThomas Huth if (dosat && sat) { \ 14086175f5a0SRichard Henderson set_vscr_sat(env); \ 1409fcf5ef2aSThomas Huth } \ 1410fcf5ef2aSThomas Huth } 1411fcf5ef2aSThomas Huth #define I(x, y) (x) 1412fcf5ef2aSThomas Huth VPK(shss, s16, s8, cvtshsb, 1) 1413fcf5ef2aSThomas Huth VPK(shus, s16, u8, cvtshub, 1) 1414fcf5ef2aSThomas Huth VPK(swss, s32, s16, cvtswsh, 1) 1415fcf5ef2aSThomas Huth VPK(swus, s32, u16, cvtswuh, 1) 1416fcf5ef2aSThomas Huth VPK(sdss, s64, s32, cvtsdsw, 1) 1417fcf5ef2aSThomas Huth VPK(sdus, s64, u32, cvtsduw, 1) 1418fcf5ef2aSThomas Huth VPK(uhus, u16, u8, cvtuhub, 1) 1419fcf5ef2aSThomas Huth VPK(uwus, u32, u16, cvtuwuh, 1) 1420fcf5ef2aSThomas Huth VPK(udus, u64, u32, cvtuduw, 1) 1421fcf5ef2aSThomas Huth VPK(uhum, u16, u8, I, 0) 1422fcf5ef2aSThomas Huth VPK(uwum, u32, u16, I, 0) 1423fcf5ef2aSThomas Huth VPK(udum, u64, u32, I, 0) 1424fcf5ef2aSThomas Huth #undef I 1425fcf5ef2aSThomas Huth #undef VPK 1426fcf5ef2aSThomas Huth #undef PKBIG 1427fcf5ef2aSThomas Huth 1428fcf5ef2aSThomas Huth void helper_vrefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1429fcf5ef2aSThomas Huth { 1430fcf5ef2aSThomas Huth int i; 1431fcf5ef2aSThomas Huth 143205ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 143305ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, b->f32[i], &env->vec_status); 1434fcf5ef2aSThomas Huth } 1435fcf5ef2aSThomas Huth } 1436fcf5ef2aSThomas Huth 1437fcf5ef2aSThomas Huth #define VRFI(suffix, rounding) \ 1438fcf5ef2aSThomas Huth void helper_vrfi##suffix(CPUPPCState *env, ppc_avr_t *r, \ 1439fcf5ef2aSThomas Huth ppc_avr_t *b) \ 1440fcf5ef2aSThomas Huth { \ 1441fcf5ef2aSThomas Huth int i; \ 1442fcf5ef2aSThomas Huth float_status s = env->vec_status; \ 1443fcf5ef2aSThomas Huth \ 1444fcf5ef2aSThomas Huth set_float_rounding_mode(rounding, &s); \ 144505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { \ 144605ee3e8aSMark Cave-Ayland r->f32[i] = float32_round_to_int (b->f32[i], &s); \ 1447fcf5ef2aSThomas Huth } \ 1448fcf5ef2aSThomas Huth } 1449fcf5ef2aSThomas Huth VRFI(n, float_round_nearest_even) 1450fcf5ef2aSThomas Huth VRFI(m, float_round_down) 1451fcf5ef2aSThomas Huth VRFI(p, float_round_up) 1452fcf5ef2aSThomas Huth VRFI(z, float_round_to_zero) 1453fcf5ef2aSThomas Huth #undef VRFI 1454fcf5ef2aSThomas Huth 1455fcf5ef2aSThomas Huth void helper_vrsqrtefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1456fcf5ef2aSThomas Huth { 1457fcf5ef2aSThomas Huth int i; 1458fcf5ef2aSThomas Huth 145905ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 146005ee3e8aSMark Cave-Ayland float32 t = float32_sqrt(b->f32[i], &env->vec_status); 1461fcf5ef2aSThomas Huth 146205ee3e8aSMark Cave-Ayland r->f32[i] = float32_div(float32_one, t, &env->vec_status); 1463fcf5ef2aSThomas Huth } 1464fcf5ef2aSThomas Huth } 1465fcf5ef2aSThomas Huth 1466fcf5ef2aSThomas Huth #define VRLMI(name, size, element, insert) \ 1467fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \ 1468fcf5ef2aSThomas Huth { \ 1469fcf5ef2aSThomas Huth int i; \ 1470fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1471fcf5ef2aSThomas Huth uint##size##_t src1 = a->element[i]; \ 1472fcf5ef2aSThomas Huth uint##size##_t src2 = b->element[i]; \ 1473fcf5ef2aSThomas Huth uint##size##_t src3 = r->element[i]; \ 1474fcf5ef2aSThomas Huth uint##size##_t begin, end, shift, mask, rot_val; \ 1475fcf5ef2aSThomas Huth \ 1476fcf5ef2aSThomas Huth shift = extract##size(src2, 0, 6); \ 1477fcf5ef2aSThomas Huth end = extract##size(src2, 8, 6); \ 1478fcf5ef2aSThomas Huth begin = extract##size(src2, 16, 6); \ 1479fcf5ef2aSThomas Huth rot_val = rol##size(src1, shift); \ 1480fcf5ef2aSThomas Huth mask = mask_u##size(begin, end); \ 1481fcf5ef2aSThomas Huth if (insert) { \ 1482fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask) | (src3 & ~mask); \ 1483fcf5ef2aSThomas Huth } else { \ 1484fcf5ef2aSThomas Huth r->element[i] = (rot_val & mask); \ 1485fcf5ef2aSThomas Huth } \ 1486fcf5ef2aSThomas Huth } \ 1487fcf5ef2aSThomas Huth } 1488fcf5ef2aSThomas Huth 1489fcf5ef2aSThomas Huth VRLMI(vrldmi, 64, u64, 1); 1490fcf5ef2aSThomas Huth VRLMI(vrlwmi, 32, u32, 1); 1491fcf5ef2aSThomas Huth VRLMI(vrldnm, 64, u64, 0); 1492fcf5ef2aSThomas Huth VRLMI(vrlwnm, 32, u32, 0); 1493fcf5ef2aSThomas Huth 1494fcf5ef2aSThomas Huth void helper_vsel(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, 1495fcf5ef2aSThomas Huth ppc_avr_t *c) 1496fcf5ef2aSThomas Huth { 1497fcf5ef2aSThomas Huth r->u64[0] = (a->u64[0] & ~c->u64[0]) | (b->u64[0] & c->u64[0]); 1498fcf5ef2aSThomas Huth r->u64[1] = (a->u64[1] & ~c->u64[1]) | (b->u64[1] & c->u64[1]); 1499fcf5ef2aSThomas Huth } 1500fcf5ef2aSThomas Huth 1501fcf5ef2aSThomas Huth void helper_vexptefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1502fcf5ef2aSThomas Huth { 1503fcf5ef2aSThomas Huth int i; 1504fcf5ef2aSThomas Huth 150505ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 150605ee3e8aSMark Cave-Ayland r->f32[i] = float32_exp2(b->f32[i], &env->vec_status); 1507fcf5ef2aSThomas Huth } 1508fcf5ef2aSThomas Huth } 1509fcf5ef2aSThomas Huth 1510fcf5ef2aSThomas Huth void helper_vlogefp(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *b) 1511fcf5ef2aSThomas Huth { 1512fcf5ef2aSThomas Huth int i; 1513fcf5ef2aSThomas Huth 151405ee3e8aSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->f32); i++) { 151505ee3e8aSMark Cave-Ayland r->f32[i] = float32_log2(b->f32[i], &env->vec_status); 1516fcf5ef2aSThomas Huth } 1517fcf5ef2aSThomas Huth } 1518fcf5ef2aSThomas Huth 151960caf221SAvinesh Kumar #define VEXTU_X_DO(name, size, left) \ 152060caf221SAvinesh Kumar target_ulong glue(helper_, name)(target_ulong a, ppc_avr_t *b) \ 152160caf221SAvinesh Kumar { \ 1522f297c4c6SMatheus Ferst int index = (a & 0xf) * 8; \ 152360caf221SAvinesh Kumar if (left) { \ 1524f297c4c6SMatheus Ferst index = 128 - index - size; \ 152560caf221SAvinesh Kumar } \ 152660caf221SAvinesh Kumar return int128_getlo(int128_rshift(b->s128, index)) & \ 152760caf221SAvinesh Kumar MAKE_64BIT_MASK(0, size); \ 152860caf221SAvinesh Kumar } 152960caf221SAvinesh Kumar VEXTU_X_DO(vextublx, 8, 1) 153060caf221SAvinesh Kumar VEXTU_X_DO(vextuhlx, 16, 1) 153160caf221SAvinesh Kumar VEXTU_X_DO(vextuwlx, 32, 1) 153260caf221SAvinesh Kumar VEXTU_X_DO(vextubrx, 8, 0) 153360caf221SAvinesh Kumar VEXTU_X_DO(vextuhrx, 16, 0) 153460caf221SAvinesh Kumar VEXTU_X_DO(vextuwrx, 32, 0) 153560caf221SAvinesh Kumar #undef VEXTU_X_DO 153660caf221SAvinesh Kumar 1537fcf5ef2aSThomas Huth void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1538fcf5ef2aSThomas Huth { 1539fcf5ef2aSThomas Huth int i; 1540fcf5ef2aSThomas Huth unsigned int shift, bytes, size; 1541fcf5ef2aSThomas Huth 1542fcf5ef2aSThomas Huth size = ARRAY_SIZE(r->u8); 1543fcf5ef2aSThomas Huth for (i = 0; i < size; i++) { 154463be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 154563be02fcSAnton Blanchard bytes = (a->VsrB(i) << 8) + /* extract adjacent bytes */ 154663be02fcSAnton Blanchard (((i + 1) < size) ? a->VsrB(i + 1) : 0); 154763be02fcSAnton Blanchard r->VsrB(i) = (bytes << shift) >> 8; /* shift and store result */ 1548fcf5ef2aSThomas Huth } 1549fcf5ef2aSThomas Huth } 1550fcf5ef2aSThomas Huth 1551fcf5ef2aSThomas Huth void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1552fcf5ef2aSThomas Huth { 1553fcf5ef2aSThomas Huth int i; 1554fcf5ef2aSThomas Huth unsigned int shift, bytes; 1555fcf5ef2aSThomas Huth 1556b6cb41b2SDavid Gibson /* 1557b6cb41b2SDavid Gibson * Use reverse order, as destination and source register can be 1558b6cb41b2SDavid Gibson * same. Its being modified in place saving temporary, reverse 1559b6cb41b2SDavid Gibson * order will guarantee that computed result is not fed back. 1560fcf5ef2aSThomas Huth */ 1561fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) { 156263be02fcSAnton Blanchard shift = b->VsrB(i) & 0x7; /* extract shift value */ 156363be02fcSAnton Blanchard bytes = ((i ? a->VsrB(i - 1) : 0) << 8) + a->VsrB(i); 1564fcf5ef2aSThomas Huth /* extract adjacent bytes */ 156563be02fcSAnton Blanchard r->VsrB(i) = (bytes >> shift) & 0xFF; /* shift and store result */ 1566fcf5ef2aSThomas Huth } 1567fcf5ef2aSThomas Huth } 1568fcf5ef2aSThomas Huth 1569fcf5ef2aSThomas Huth void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift) 1570fcf5ef2aSThomas Huth { 1571fcf5ef2aSThomas Huth int sh = shift & 0xf; 1572fcf5ef2aSThomas Huth int i; 1573fcf5ef2aSThomas Huth ppc_avr_t result; 1574fcf5ef2aSThomas Huth 1575fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 1576fcf5ef2aSThomas Huth int index = sh + i; 1577fcf5ef2aSThomas Huth if (index > 0xf) { 157860594feaSMark Cave-Ayland result.VsrB(i) = b->VsrB(index - 0x10); 1579fcf5ef2aSThomas Huth } else { 158060594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(index); 1581fcf5ef2aSThomas Huth } 1582fcf5ef2aSThomas Huth } 1583fcf5ef2aSThomas Huth *r = result; 1584fcf5ef2aSThomas Huth } 1585fcf5ef2aSThomas Huth 1586fcf5ef2aSThomas Huth void helper_vslo(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1587fcf5ef2aSThomas Huth { 15883c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 1589fcf5ef2aSThomas Huth 1590fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1591fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1592fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 1593fcf5ef2aSThomas Huth #else 1594fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1595fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1596fcf5ef2aSThomas Huth #endif 1597fcf5ef2aSThomas Huth } 1598fcf5ef2aSThomas Huth 1599fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1600fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1601fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1602fcf5ef2aSThomas Huth { \ 16034fff7218SLaurent Vivier memmove(&r->u8[index], &b->u8[8 - sizeof(r->element[0])], \ 1604fcf5ef2aSThomas Huth sizeof(r->element[0])); \ 1605fcf5ef2aSThomas Huth } 1606fcf5ef2aSThomas Huth #else 1607fcf5ef2aSThomas Huth #define VINSERT(suffix, element) \ 1608fcf5ef2aSThomas Huth void helper_vinsert##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1609fcf5ef2aSThomas Huth { \ 1610fcf5ef2aSThomas Huth uint32_t d = (16 - index) - sizeof(r->element[0]); \ 1611fcf5ef2aSThomas Huth memmove(&r->u8[d], &b->u8[8], sizeof(r->element[0])); \ 1612fcf5ef2aSThomas Huth } 1613fcf5ef2aSThomas Huth #endif 1614fcf5ef2aSThomas Huth VINSERT(b, u8) 1615fcf5ef2aSThomas Huth VINSERT(h, u16) 1616fcf5ef2aSThomas Huth VINSERT(w, u32) 1617fcf5ef2aSThomas Huth VINSERT(d, u64) 1618fcf5ef2aSThomas Huth #undef VINSERT 1619fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1620fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1621fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1622fcf5ef2aSThomas Huth { \ 1623fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1624fcf5ef2aSThomas Huth memmove(&r->u8[8 - es], &b->u8[index], es); \ 1625fcf5ef2aSThomas Huth memset(&r->u8[8], 0, 8); \ 1626fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8 - es); \ 1627fcf5ef2aSThomas Huth } 1628fcf5ef2aSThomas Huth #else 1629fcf5ef2aSThomas Huth #define VEXTRACT(suffix, element) \ 1630fcf5ef2aSThomas Huth void helper_vextract##suffix(ppc_avr_t *r, ppc_avr_t *b, uint32_t index) \ 1631fcf5ef2aSThomas Huth { \ 1632fcf5ef2aSThomas Huth uint32_t es = sizeof(r->element[0]); \ 1633fcf5ef2aSThomas Huth uint32_t s = (16 - index) - es; \ 1634fcf5ef2aSThomas Huth memmove(&r->u8[8], &b->u8[s], es); \ 1635fcf5ef2aSThomas Huth memset(&r->u8[0], 0, 8); \ 1636fcf5ef2aSThomas Huth memset(&r->u8[8 + es], 0, 8 - es); \ 1637fcf5ef2aSThomas Huth } 1638fcf5ef2aSThomas Huth #endif 1639fcf5ef2aSThomas Huth VEXTRACT(ub, u8) 1640fcf5ef2aSThomas Huth VEXTRACT(uh, u16) 1641fcf5ef2aSThomas Huth VEXTRACT(uw, u32) 1642fcf5ef2aSThomas Huth VEXTRACT(d, u64) 1643fcf5ef2aSThomas Huth #undef VEXTRACT 1644fcf5ef2aSThomas Huth 16455ba5335dSMark Cave-Ayland void helper_xxextractuw(CPUPPCState *env, ppc_vsr_t *xt, 16465ba5335dSMark Cave-Ayland ppc_vsr_t *xb, uint32_t index) 16478ad901e5SNikunj A Dadhania { 164803b32c09SMark Cave-Ayland ppc_vsr_t t = { }; 16498ad901e5SNikunj A Dadhania size_t es = sizeof(uint32_t); 16508ad901e5SNikunj A Dadhania uint32_t ext_index; 16518ad901e5SNikunj A Dadhania int i; 16528ad901e5SNikunj A Dadhania 16538ad901e5SNikunj A Dadhania ext_index = index; 16548ad901e5SNikunj A Dadhania for (i = 0; i < es; i++, ext_index++) { 165503b32c09SMark Cave-Ayland t.VsrB(8 - es + i) = xb->VsrB(ext_index % 16); 16568ad901e5SNikunj A Dadhania } 16578ad901e5SNikunj A Dadhania 165803b32c09SMark Cave-Ayland *xt = t; 16598ad901e5SNikunj A Dadhania } 16608ad901e5SNikunj A Dadhania 16615ba5335dSMark Cave-Ayland void helper_xxinsertw(CPUPPCState *env, ppc_vsr_t *xt, 16625ba5335dSMark Cave-Ayland ppc_vsr_t *xb, uint32_t index) 16633398b742SNikunj A Dadhania { 166403b32c09SMark Cave-Ayland ppc_vsr_t t = *xt; 16653398b742SNikunj A Dadhania size_t es = sizeof(uint32_t); 16663398b742SNikunj A Dadhania int ins_index, i = 0; 16673398b742SNikunj A Dadhania 16683398b742SNikunj A Dadhania ins_index = index; 16693398b742SNikunj A Dadhania for (i = 0; i < es && ins_index < 16; i++, ins_index++) { 167003b32c09SMark Cave-Ayland t.VsrB(ins_index) = xb->VsrB(8 - es + i); 16713398b742SNikunj A Dadhania } 16723398b742SNikunj A Dadhania 167303b32c09SMark Cave-Ayland *xt = t; 16743398b742SNikunj A Dadhania } 16753398b742SNikunj A Dadhania 1676634c5835SMark Cave-Ayland #define VEXT_SIGNED(name, element, cast) \ 1677fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 1678fcf5ef2aSThomas Huth { \ 1679fcf5ef2aSThomas Huth int i; \ 168060594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1681634c5835SMark Cave-Ayland r->element[i] = (cast)b->element[i]; \ 1682fcf5ef2aSThomas Huth } \ 1683fcf5ef2aSThomas Huth } 1684634c5835SMark Cave-Ayland VEXT_SIGNED(vextsb2w, s32, int8_t) 1685634c5835SMark Cave-Ayland VEXT_SIGNED(vextsb2d, s64, int8_t) 1686634c5835SMark Cave-Ayland VEXT_SIGNED(vextsh2w, s32, int16_t) 1687634c5835SMark Cave-Ayland VEXT_SIGNED(vextsh2d, s64, int16_t) 1688634c5835SMark Cave-Ayland VEXT_SIGNED(vextsw2d, s64, int32_t) 1689fcf5ef2aSThomas Huth #undef VEXT_SIGNED 1690fcf5ef2aSThomas Huth 1691fcf5ef2aSThomas Huth #define VNEG(name, element) \ 1692fcf5ef2aSThomas Huth void helper_##name(ppc_avr_t *r, ppc_avr_t *b) \ 1693fcf5ef2aSThomas Huth { \ 1694fcf5ef2aSThomas Huth int i; \ 169560594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1696fcf5ef2aSThomas Huth r->element[i] = -b->element[i]; \ 1697fcf5ef2aSThomas Huth } \ 1698fcf5ef2aSThomas Huth } 1699fcf5ef2aSThomas Huth VNEG(vnegw, s32) 1700fcf5ef2aSThomas Huth VNEG(vnegd, s64) 1701fcf5ef2aSThomas Huth #undef VNEG 1702fcf5ef2aSThomas Huth 1703fcf5ef2aSThomas Huth void helper_vsro(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1704fcf5ef2aSThomas Huth { 17053c385a93SMark Cave-Ayland int sh = (b->VsrB(0xf) >> 3) & 0xf; 1706fcf5ef2aSThomas Huth 1707fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1708fcf5ef2aSThomas Huth memmove(&r->u8[sh], &a->u8[0], 16 - sh); 1709fcf5ef2aSThomas Huth memset(&r->u8[0], 0, sh); 1710fcf5ef2aSThomas Huth #else 1711fcf5ef2aSThomas Huth memmove(&r->u8[0], &a->u8[sh], 16 - sh); 1712fcf5ef2aSThomas Huth memset(&r->u8[16 - sh], 0, sh); 1713fcf5ef2aSThomas Huth #endif 1714fcf5ef2aSThomas Huth } 1715fcf5ef2aSThomas Huth 1716fcf5ef2aSThomas Huth void helper_vsubcuw(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1717fcf5ef2aSThomas Huth { 1718fcf5ef2aSThomas Huth int i; 1719fcf5ef2aSThomas Huth 1720fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 1721fcf5ef2aSThomas Huth r->u32[i] = a->u32[i] >= b->u32[i]; 1722fcf5ef2aSThomas Huth } 1723fcf5ef2aSThomas Huth } 1724fcf5ef2aSThomas Huth 1725fcf5ef2aSThomas Huth void helper_vsumsws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1726fcf5ef2aSThomas Huth { 1727fcf5ef2aSThomas Huth int64_t t; 1728fcf5ef2aSThomas Huth int i, upper; 1729fcf5ef2aSThomas Huth ppc_avr_t result; 1730fcf5ef2aSThomas Huth int sat = 0; 1731fcf5ef2aSThomas Huth 1732fcf5ef2aSThomas Huth upper = ARRAY_SIZE(r->s32) - 1; 173360594feaSMark Cave-Ayland t = (int64_t)b->VsrSW(upper); 1734fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 173560594feaSMark Cave-Ayland t += a->VsrSW(i); 173660594feaSMark Cave-Ayland result.VsrSW(i) = 0; 1737fcf5ef2aSThomas Huth } 173860594feaSMark Cave-Ayland result.VsrSW(upper) = cvtsdsw(t, &sat); 1739fcf5ef2aSThomas Huth *r = result; 1740fcf5ef2aSThomas Huth 1741fcf5ef2aSThomas Huth if (sat) { 17426175f5a0SRichard Henderson set_vscr_sat(env); 1743fcf5ef2aSThomas Huth } 1744fcf5ef2aSThomas Huth } 1745fcf5ef2aSThomas Huth 1746fcf5ef2aSThomas Huth void helper_vsum2sws(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1747fcf5ef2aSThomas Huth { 1748fcf5ef2aSThomas Huth int i, j, upper; 1749fcf5ef2aSThomas Huth ppc_avr_t result; 1750fcf5ef2aSThomas Huth int sat = 0; 1751fcf5ef2aSThomas Huth 1752fcf5ef2aSThomas Huth upper = 1; 1753fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 175460594feaSMark Cave-Ayland int64_t t = (int64_t)b->VsrSW(upper + i * 2); 1755fcf5ef2aSThomas Huth 17567fa0ddc1SAnton Blanchard result.VsrD(i) = 0; 1757fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u64); j++) { 175860594feaSMark Cave-Ayland t += a->VsrSW(2 * i + j); 1759fcf5ef2aSThomas Huth } 176060594feaSMark Cave-Ayland result.VsrSW(upper + i * 2) = cvtsdsw(t, &sat); 1761fcf5ef2aSThomas Huth } 1762fcf5ef2aSThomas Huth 1763fcf5ef2aSThomas Huth *r = result; 1764fcf5ef2aSThomas Huth if (sat) { 17656175f5a0SRichard Henderson set_vscr_sat(env); 1766fcf5ef2aSThomas Huth } 1767fcf5ef2aSThomas Huth } 1768fcf5ef2aSThomas Huth 1769fcf5ef2aSThomas Huth void helper_vsum4sbs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1770fcf5ef2aSThomas Huth { 1771fcf5ef2aSThomas Huth int i, j; 1772fcf5ef2aSThomas Huth int sat = 0; 1773fcf5ef2aSThomas Huth 1774fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 1775fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 1776fcf5ef2aSThomas Huth 1777fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->s32); j++) { 1778fcf5ef2aSThomas Huth t += a->s8[4 * i + j]; 1779fcf5ef2aSThomas Huth } 1780fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 1781fcf5ef2aSThomas Huth } 1782fcf5ef2aSThomas Huth 1783fcf5ef2aSThomas Huth if (sat) { 17846175f5a0SRichard Henderson set_vscr_sat(env); 1785fcf5ef2aSThomas Huth } 1786fcf5ef2aSThomas Huth } 1787fcf5ef2aSThomas Huth 1788fcf5ef2aSThomas Huth void helper_vsum4shs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1789fcf5ef2aSThomas Huth { 1790fcf5ef2aSThomas Huth int sat = 0; 1791fcf5ef2aSThomas Huth int i; 1792fcf5ef2aSThomas Huth 1793fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->s32); i++) { 1794fcf5ef2aSThomas Huth int64_t t = (int64_t)b->s32[i]; 1795fcf5ef2aSThomas Huth 1796fcf5ef2aSThomas Huth t += a->s16[2 * i] + a->s16[2 * i + 1]; 1797fcf5ef2aSThomas Huth r->s32[i] = cvtsdsw(t, &sat); 1798fcf5ef2aSThomas Huth } 1799fcf5ef2aSThomas Huth 1800fcf5ef2aSThomas Huth if (sat) { 18016175f5a0SRichard Henderson set_vscr_sat(env); 1802fcf5ef2aSThomas Huth } 1803fcf5ef2aSThomas Huth } 1804fcf5ef2aSThomas Huth 1805fcf5ef2aSThomas Huth void helper_vsum4ubs(CPUPPCState *env, ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1806fcf5ef2aSThomas Huth { 1807fcf5ef2aSThomas Huth int i, j; 1808fcf5ef2aSThomas Huth int sat = 0; 1809fcf5ef2aSThomas Huth 1810fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 1811fcf5ef2aSThomas Huth uint64_t t = (uint64_t)b->u32[i]; 1812fcf5ef2aSThomas Huth 1813fcf5ef2aSThomas Huth for (j = 0; j < ARRAY_SIZE(r->u32); j++) { 1814fcf5ef2aSThomas Huth t += a->u8[4 * i + j]; 1815fcf5ef2aSThomas Huth } 1816fcf5ef2aSThomas Huth r->u32[i] = cvtuduw(t, &sat); 1817fcf5ef2aSThomas Huth } 1818fcf5ef2aSThomas Huth 1819fcf5ef2aSThomas Huth if (sat) { 18206175f5a0SRichard Henderson set_vscr_sat(env); 1821fcf5ef2aSThomas Huth } 1822fcf5ef2aSThomas Huth } 1823fcf5ef2aSThomas Huth 1824fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1825fcf5ef2aSThomas Huth #define UPKHI 1 1826fcf5ef2aSThomas Huth #define UPKLO 0 1827fcf5ef2aSThomas Huth #else 1828fcf5ef2aSThomas Huth #define UPKHI 0 1829fcf5ef2aSThomas Huth #define UPKLO 1 1830fcf5ef2aSThomas Huth #endif 1831fcf5ef2aSThomas Huth #define VUPKPX(suffix, hi) \ 1832fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 1833fcf5ef2aSThomas Huth { \ 1834fcf5ef2aSThomas Huth int i; \ 1835fcf5ef2aSThomas Huth ppc_avr_t result; \ 1836fcf5ef2aSThomas Huth \ 1837fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->u32); i++) { \ 1838fcf5ef2aSThomas Huth uint16_t e = b->u16[hi ? i : i + 4]; \ 1839fcf5ef2aSThomas Huth uint8_t a = (e >> 15) ? 0xff : 0; \ 1840fcf5ef2aSThomas Huth uint8_t r = (e >> 10) & 0x1f; \ 1841fcf5ef2aSThomas Huth uint8_t g = (e >> 5) & 0x1f; \ 1842fcf5ef2aSThomas Huth uint8_t b = e & 0x1f; \ 1843fcf5ef2aSThomas Huth \ 1844fcf5ef2aSThomas Huth result.u32[i] = (a << 24) | (r << 16) | (g << 8) | b; \ 1845fcf5ef2aSThomas Huth } \ 1846fcf5ef2aSThomas Huth *r = result; \ 1847fcf5ef2aSThomas Huth } 1848fcf5ef2aSThomas Huth VUPKPX(lpx, UPKLO) 1849fcf5ef2aSThomas Huth VUPKPX(hpx, UPKHI) 1850fcf5ef2aSThomas Huth #undef VUPKPX 1851fcf5ef2aSThomas Huth 1852fcf5ef2aSThomas Huth #define VUPK(suffix, unpacked, packee, hi) \ 1853fcf5ef2aSThomas Huth void helper_vupk##suffix(ppc_avr_t *r, ppc_avr_t *b) \ 1854fcf5ef2aSThomas Huth { \ 1855fcf5ef2aSThomas Huth int i; \ 1856fcf5ef2aSThomas Huth ppc_avr_t result; \ 1857fcf5ef2aSThomas Huth \ 1858fcf5ef2aSThomas Huth if (hi) { \ 1859fcf5ef2aSThomas Huth for (i = 0; i < ARRAY_SIZE(r->unpacked); i++) { \ 1860fcf5ef2aSThomas Huth result.unpacked[i] = b->packee[i]; \ 1861fcf5ef2aSThomas Huth } \ 1862fcf5ef2aSThomas Huth } else { \ 1863fcf5ef2aSThomas Huth for (i = ARRAY_SIZE(r->unpacked); i < ARRAY_SIZE(r->packee); \ 1864fcf5ef2aSThomas Huth i++) { \ 1865fcf5ef2aSThomas Huth result.unpacked[i - ARRAY_SIZE(r->unpacked)] = b->packee[i]; \ 1866fcf5ef2aSThomas Huth } \ 1867fcf5ef2aSThomas Huth } \ 1868fcf5ef2aSThomas Huth *r = result; \ 1869fcf5ef2aSThomas Huth } 1870fcf5ef2aSThomas Huth VUPK(hsb, s16, s8, UPKHI) 1871fcf5ef2aSThomas Huth VUPK(hsh, s32, s16, UPKHI) 1872fcf5ef2aSThomas Huth VUPK(hsw, s64, s32, UPKHI) 1873fcf5ef2aSThomas Huth VUPK(lsb, s16, s8, UPKLO) 1874fcf5ef2aSThomas Huth VUPK(lsh, s32, s16, UPKLO) 1875fcf5ef2aSThomas Huth VUPK(lsw, s64, s32, UPKLO) 1876fcf5ef2aSThomas Huth #undef VUPK 1877fcf5ef2aSThomas Huth #undef UPKHI 1878fcf5ef2aSThomas Huth #undef UPKLO 1879fcf5ef2aSThomas Huth 1880fcf5ef2aSThomas Huth #define VGENERIC_DO(name, element) \ 1881fcf5ef2aSThomas Huth void helper_v##name(ppc_avr_t *r, ppc_avr_t *b) \ 1882fcf5ef2aSThomas Huth { \ 1883fcf5ef2aSThomas Huth int i; \ 1884fcf5ef2aSThomas Huth \ 188560594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->element); i++) { \ 1886fcf5ef2aSThomas Huth r->element[i] = name(b->element[i]); \ 1887fcf5ef2aSThomas Huth } \ 1888fcf5ef2aSThomas Huth } 1889fcf5ef2aSThomas Huth 1890fcf5ef2aSThomas Huth #define clzb(v) ((v) ? clz32((uint32_t)(v) << 24) : 8) 1891fcf5ef2aSThomas Huth #define clzh(v) ((v) ? clz32((uint32_t)(v) << 16) : 16) 1892fcf5ef2aSThomas Huth 1893fcf5ef2aSThomas Huth VGENERIC_DO(clzb, u8) 1894fcf5ef2aSThomas Huth VGENERIC_DO(clzh, u16) 1895fcf5ef2aSThomas Huth 1896fcf5ef2aSThomas Huth #undef clzb 1897fcf5ef2aSThomas Huth #undef clzh 1898fcf5ef2aSThomas Huth 1899fcf5ef2aSThomas Huth #define ctzb(v) ((v) ? ctz32(v) : 8) 1900fcf5ef2aSThomas Huth #define ctzh(v) ((v) ? ctz32(v) : 16) 1901fcf5ef2aSThomas Huth #define ctzw(v) ctz32((v)) 1902fcf5ef2aSThomas Huth #define ctzd(v) ctz64((v)) 1903fcf5ef2aSThomas Huth 1904fcf5ef2aSThomas Huth VGENERIC_DO(ctzb, u8) 1905fcf5ef2aSThomas Huth VGENERIC_DO(ctzh, u16) 1906fcf5ef2aSThomas Huth VGENERIC_DO(ctzw, u32) 1907fcf5ef2aSThomas Huth VGENERIC_DO(ctzd, u64) 1908fcf5ef2aSThomas Huth 1909fcf5ef2aSThomas Huth #undef ctzb 1910fcf5ef2aSThomas Huth #undef ctzh 1911fcf5ef2aSThomas Huth #undef ctzw 1912fcf5ef2aSThomas Huth #undef ctzd 1913fcf5ef2aSThomas Huth 1914fcf5ef2aSThomas Huth #define popcntb(v) ctpop8(v) 1915fcf5ef2aSThomas Huth #define popcnth(v) ctpop16(v) 1916fcf5ef2aSThomas Huth #define popcntw(v) ctpop32(v) 1917fcf5ef2aSThomas Huth #define popcntd(v) ctpop64(v) 1918fcf5ef2aSThomas Huth 1919fcf5ef2aSThomas Huth VGENERIC_DO(popcntb, u8) 1920fcf5ef2aSThomas Huth VGENERIC_DO(popcnth, u16) 1921fcf5ef2aSThomas Huth VGENERIC_DO(popcntw, u32) 1922fcf5ef2aSThomas Huth VGENERIC_DO(popcntd, u64) 1923fcf5ef2aSThomas Huth 1924fcf5ef2aSThomas Huth #undef popcntb 1925fcf5ef2aSThomas Huth #undef popcnth 1926fcf5ef2aSThomas Huth #undef popcntw 1927fcf5ef2aSThomas Huth #undef popcntd 1928fcf5ef2aSThomas Huth 1929fcf5ef2aSThomas Huth #undef VGENERIC_DO 1930fcf5ef2aSThomas Huth 1931fcf5ef2aSThomas Huth #if defined(HOST_WORDS_BIGENDIAN) 1932fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 0, 1 } } 1933fcf5ef2aSThomas Huth #else 1934fcf5ef2aSThomas Huth #define QW_ONE { .u64 = { 1, 0 } } 1935fcf5ef2aSThomas Huth #endif 1936fcf5ef2aSThomas Huth 1937fcf5ef2aSThomas Huth #ifndef CONFIG_INT128 1938fcf5ef2aSThomas Huth 1939fcf5ef2aSThomas Huth static inline void avr_qw_not(ppc_avr_t *t, ppc_avr_t a) 1940fcf5ef2aSThomas Huth { 1941fcf5ef2aSThomas Huth t->u64[0] = ~a.u64[0]; 1942fcf5ef2aSThomas Huth t->u64[1] = ~a.u64[1]; 1943fcf5ef2aSThomas Huth } 1944fcf5ef2aSThomas Huth 1945fcf5ef2aSThomas Huth static int avr_qw_cmpu(ppc_avr_t a, ppc_avr_t b) 1946fcf5ef2aSThomas Huth { 19473c385a93SMark Cave-Ayland if (a.VsrD(0) < b.VsrD(0)) { 1948fcf5ef2aSThomas Huth return -1; 19493c385a93SMark Cave-Ayland } else if (a.VsrD(0) > b.VsrD(0)) { 1950fcf5ef2aSThomas Huth return 1; 19513c385a93SMark Cave-Ayland } else if (a.VsrD(1) < b.VsrD(1)) { 1952fcf5ef2aSThomas Huth return -1; 19533c385a93SMark Cave-Ayland } else if (a.VsrD(1) > b.VsrD(1)) { 1954fcf5ef2aSThomas Huth return 1; 1955fcf5ef2aSThomas Huth } else { 1956fcf5ef2aSThomas Huth return 0; 1957fcf5ef2aSThomas Huth } 1958fcf5ef2aSThomas Huth } 1959fcf5ef2aSThomas Huth 1960fcf5ef2aSThomas Huth static void avr_qw_add(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 1961fcf5ef2aSThomas Huth { 19623c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 19633c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 19643c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 1965fcf5ef2aSThomas Huth } 1966fcf5ef2aSThomas Huth 1967fcf5ef2aSThomas Huth static int avr_qw_addc(ppc_avr_t *t, ppc_avr_t a, ppc_avr_t b) 1968fcf5ef2aSThomas Huth { 1969fcf5ef2aSThomas Huth ppc_avr_t not_a; 19703c385a93SMark Cave-Ayland t->VsrD(1) = a.VsrD(1) + b.VsrD(1); 19713c385a93SMark Cave-Ayland t->VsrD(0) = a.VsrD(0) + b.VsrD(0) + 19723c385a93SMark Cave-Ayland (~a.VsrD(1) < b.VsrD(1)); 1973fcf5ef2aSThomas Huth avr_qw_not(¬_a, a); 1974fcf5ef2aSThomas Huth return avr_qw_cmpu(not_a, b) < 0; 1975fcf5ef2aSThomas Huth } 1976fcf5ef2aSThomas Huth 1977fcf5ef2aSThomas Huth #endif 1978fcf5ef2aSThomas Huth 1979fcf5ef2aSThomas Huth void helper_vadduqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 1980fcf5ef2aSThomas Huth { 1981fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 1982fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128; 1983fcf5ef2aSThomas Huth #else 1984fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 1985fcf5ef2aSThomas Huth #endif 1986fcf5ef2aSThomas Huth } 1987fcf5ef2aSThomas Huth 1988fcf5ef2aSThomas Huth void helper_vaddeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 1989fcf5ef2aSThomas Huth { 1990fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 1991fcf5ef2aSThomas Huth r->u128 = a->u128 + b->u128 + (c->u128 & 1); 1992fcf5ef2aSThomas Huth #else 1993fcf5ef2aSThomas Huth 19943c385a93SMark Cave-Ayland if (c->VsrD(1) & 1) { 1995fcf5ef2aSThomas Huth ppc_avr_t tmp; 1996fcf5ef2aSThomas Huth 19973c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 19983c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 1999fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2000fcf5ef2aSThomas Huth avr_qw_add(r, tmp, *b); 2001fcf5ef2aSThomas Huth } else { 2002fcf5ef2aSThomas Huth avr_qw_add(r, *a, *b); 2003fcf5ef2aSThomas Huth } 2004fcf5ef2aSThomas Huth #endif 2005fcf5ef2aSThomas Huth } 2006fcf5ef2aSThomas Huth 2007fcf5ef2aSThomas Huth void helper_vaddcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2008fcf5ef2aSThomas Huth { 2009fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2010fcf5ef2aSThomas Huth r->u128 = (~a->u128 < b->u128); 2011fcf5ef2aSThomas Huth #else 2012fcf5ef2aSThomas Huth ppc_avr_t not_a; 2013fcf5ef2aSThomas Huth 2014fcf5ef2aSThomas Huth avr_qw_not(¬_a, *a); 2015fcf5ef2aSThomas Huth 20163c385a93SMark Cave-Ayland r->VsrD(0) = 0; 20173c385a93SMark Cave-Ayland r->VsrD(1) = (avr_qw_cmpu(not_a, *b) < 0); 2018fcf5ef2aSThomas Huth #endif 2019fcf5ef2aSThomas Huth } 2020fcf5ef2aSThomas Huth 2021fcf5ef2aSThomas Huth void helper_vaddecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2022fcf5ef2aSThomas Huth { 2023fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2024fcf5ef2aSThomas Huth int carry_out = (~a->u128 < b->u128); 2025fcf5ef2aSThomas Huth if (!carry_out && (c->u128 & 1)) { 2026fcf5ef2aSThomas Huth carry_out = ((a->u128 + b->u128 + 1) == 0) && 2027fcf5ef2aSThomas Huth ((a->u128 != 0) || (b->u128 != 0)); 2028fcf5ef2aSThomas Huth } 2029fcf5ef2aSThomas Huth r->u128 = carry_out; 2030fcf5ef2aSThomas Huth #else 2031fcf5ef2aSThomas Huth 20323c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2033fcf5ef2aSThomas Huth int carry_out = 0; 2034fcf5ef2aSThomas Huth ppc_avr_t tmp; 2035fcf5ef2aSThomas Huth 2036fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, *a, *b); 2037fcf5ef2aSThomas Huth 2038fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2039fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2040fcf5ef2aSThomas Huth carry_out = avr_qw_addc(&tmp, tmp, one); 2041fcf5ef2aSThomas Huth } 20423c385a93SMark Cave-Ayland r->VsrD(0) = 0; 20433c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2044fcf5ef2aSThomas Huth #endif 2045fcf5ef2aSThomas Huth } 2046fcf5ef2aSThomas Huth 2047fcf5ef2aSThomas Huth void helper_vsubuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2048fcf5ef2aSThomas Huth { 2049fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2050fcf5ef2aSThomas Huth r->u128 = a->u128 - b->u128; 2051fcf5ef2aSThomas Huth #else 2052fcf5ef2aSThomas Huth ppc_avr_t tmp; 2053fcf5ef2aSThomas Huth ppc_avr_t one = QW_ONE; 2054fcf5ef2aSThomas Huth 2055fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2056fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 2057fcf5ef2aSThomas Huth avr_qw_add(r, tmp, one); 2058fcf5ef2aSThomas Huth #endif 2059fcf5ef2aSThomas Huth } 2060fcf5ef2aSThomas Huth 2061fcf5ef2aSThomas Huth void helper_vsubeuqm(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2062fcf5ef2aSThomas Huth { 2063fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2064fcf5ef2aSThomas Huth r->u128 = a->u128 + ~b->u128 + (c->u128 & 1); 2065fcf5ef2aSThomas Huth #else 2066fcf5ef2aSThomas Huth ppc_avr_t tmp, sum; 2067fcf5ef2aSThomas Huth 2068fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2069fcf5ef2aSThomas Huth avr_qw_add(&sum, *a, tmp); 2070fcf5ef2aSThomas Huth 20713c385a93SMark Cave-Ayland tmp.VsrD(0) = 0; 20723c385a93SMark Cave-Ayland tmp.VsrD(1) = c->VsrD(1) & 1; 2073fcf5ef2aSThomas Huth avr_qw_add(r, sum, tmp); 2074fcf5ef2aSThomas Huth #endif 2075fcf5ef2aSThomas Huth } 2076fcf5ef2aSThomas Huth 2077fcf5ef2aSThomas Huth void helper_vsubcuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2078fcf5ef2aSThomas Huth { 2079fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2080fcf5ef2aSThomas Huth r->u128 = (~a->u128 < ~b->u128) || 2081fcf5ef2aSThomas Huth (a->u128 + ~b->u128 == (__uint128_t)-1); 2082fcf5ef2aSThomas Huth #else 2083fcf5ef2aSThomas Huth int carry = (avr_qw_cmpu(*a, *b) > 0); 2084fcf5ef2aSThomas Huth if (!carry) { 2085fcf5ef2aSThomas Huth ppc_avr_t tmp; 2086fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2087fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 20883c385a93SMark Cave-Ayland carry = ((tmp.VsrSD(0) == -1ull) && (tmp.VsrSD(1) == -1ull)); 2089fcf5ef2aSThomas Huth } 20903c385a93SMark Cave-Ayland r->VsrD(0) = 0; 20913c385a93SMark Cave-Ayland r->VsrD(1) = carry; 2092fcf5ef2aSThomas Huth #endif 2093fcf5ef2aSThomas Huth } 2094fcf5ef2aSThomas Huth 2095fcf5ef2aSThomas Huth void helper_vsubecuq(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2096fcf5ef2aSThomas Huth { 2097fcf5ef2aSThomas Huth #ifdef CONFIG_INT128 2098fcf5ef2aSThomas Huth r->u128 = 2099fcf5ef2aSThomas Huth (~a->u128 < ~b->u128) || 2100fcf5ef2aSThomas Huth ((c->u128 & 1) && (a->u128 + ~b->u128 == (__uint128_t)-1)); 2101fcf5ef2aSThomas Huth #else 21023c385a93SMark Cave-Ayland int carry_in = c->VsrD(1) & 1; 2103fcf5ef2aSThomas Huth int carry_out = (avr_qw_cmpu(*a, *b) > 0); 2104fcf5ef2aSThomas Huth if (!carry_out && carry_in) { 2105fcf5ef2aSThomas Huth ppc_avr_t tmp; 2106fcf5ef2aSThomas Huth avr_qw_not(&tmp, *b); 2107fcf5ef2aSThomas Huth avr_qw_add(&tmp, *a, tmp); 21083c385a93SMark Cave-Ayland carry_out = ((tmp.VsrD(0) == -1ull) && (tmp.VsrD(1) == -1ull)); 2109fcf5ef2aSThomas Huth } 2110fcf5ef2aSThomas Huth 21113c385a93SMark Cave-Ayland r->VsrD(0) = 0; 21123c385a93SMark Cave-Ayland r->VsrD(1) = carry_out; 2113fcf5ef2aSThomas Huth #endif 2114fcf5ef2aSThomas Huth } 2115fcf5ef2aSThomas Huth 2116fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_1 0xC 2117fcf5ef2aSThomas Huth #define BCD_PLUS_PREF_2 0xF 2118fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_1 0xA 2119fcf5ef2aSThomas Huth #define BCD_NEG_PREF 0xD 2120fcf5ef2aSThomas Huth #define BCD_NEG_ALT 0xB 2121fcf5ef2aSThomas Huth #define BCD_PLUS_ALT_2 0xE 2122fcf5ef2aSThomas Huth #define NATIONAL_PLUS 0x2B 2123fcf5ef2aSThomas Huth #define NATIONAL_NEG 0x2D 2124fcf5ef2aSThomas Huth 2125365206aeSJose Ricardo Ziviani #define BCD_DIG_BYTE(n) (15 - ((n) / 2)) 2126fcf5ef2aSThomas Huth 2127fcf5ef2aSThomas Huth static int bcd_get_sgn(ppc_avr_t *bcd) 2128fcf5ef2aSThomas Huth { 2129428115c3SMark Cave-Ayland switch (bcd->VsrB(BCD_DIG_BYTE(0)) & 0xF) { 2130fcf5ef2aSThomas Huth case BCD_PLUS_PREF_1: 2131fcf5ef2aSThomas Huth case BCD_PLUS_PREF_2: 2132fcf5ef2aSThomas Huth case BCD_PLUS_ALT_1: 2133fcf5ef2aSThomas Huth case BCD_PLUS_ALT_2: 2134fcf5ef2aSThomas Huth { 2135fcf5ef2aSThomas Huth return 1; 2136fcf5ef2aSThomas Huth } 2137fcf5ef2aSThomas Huth 2138fcf5ef2aSThomas Huth case BCD_NEG_PREF: 2139fcf5ef2aSThomas Huth case BCD_NEG_ALT: 2140fcf5ef2aSThomas Huth { 2141fcf5ef2aSThomas Huth return -1; 2142fcf5ef2aSThomas Huth } 2143fcf5ef2aSThomas Huth 2144fcf5ef2aSThomas Huth default: 2145fcf5ef2aSThomas Huth { 2146fcf5ef2aSThomas Huth return 0; 2147fcf5ef2aSThomas Huth } 2148fcf5ef2aSThomas Huth } 2149fcf5ef2aSThomas Huth } 2150fcf5ef2aSThomas Huth 2151fcf5ef2aSThomas Huth static int bcd_preferred_sgn(int sgn, int ps) 2152fcf5ef2aSThomas Huth { 2153fcf5ef2aSThomas Huth if (sgn >= 0) { 2154fcf5ef2aSThomas Huth return (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2; 2155fcf5ef2aSThomas Huth } else { 2156fcf5ef2aSThomas Huth return BCD_NEG_PREF; 2157fcf5ef2aSThomas Huth } 2158fcf5ef2aSThomas Huth } 2159fcf5ef2aSThomas Huth 2160fcf5ef2aSThomas Huth static uint8_t bcd_get_digit(ppc_avr_t *bcd, int n, int *invalid) 2161fcf5ef2aSThomas Huth { 2162fcf5ef2aSThomas Huth uint8_t result; 2163fcf5ef2aSThomas Huth if (n & 1) { 2164428115c3SMark Cave-Ayland result = bcd->VsrB(BCD_DIG_BYTE(n)) >> 4; 2165fcf5ef2aSThomas Huth } else { 2166428115c3SMark Cave-Ayland result = bcd->VsrB(BCD_DIG_BYTE(n)) & 0xF; 2167fcf5ef2aSThomas Huth } 2168fcf5ef2aSThomas Huth 2169fcf5ef2aSThomas Huth if (unlikely(result > 9)) { 2170fcf5ef2aSThomas Huth *invalid = true; 2171fcf5ef2aSThomas Huth } 2172fcf5ef2aSThomas Huth return result; 2173fcf5ef2aSThomas Huth } 2174fcf5ef2aSThomas Huth 2175fcf5ef2aSThomas Huth static void bcd_put_digit(ppc_avr_t *bcd, uint8_t digit, int n) 2176fcf5ef2aSThomas Huth { 2177fcf5ef2aSThomas Huth if (n & 1) { 2178428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) &= 0x0F; 2179428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) |= (digit << 4); 2180fcf5ef2aSThomas Huth } else { 2181428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) &= 0xF0; 2182428115c3SMark Cave-Ayland bcd->VsrB(BCD_DIG_BYTE(n)) |= digit; 2183fcf5ef2aSThomas Huth } 2184fcf5ef2aSThomas Huth } 2185fcf5ef2aSThomas Huth 2186071663dfSJose Ricardo Ziviani static bool bcd_is_valid(ppc_avr_t *bcd) 2187071663dfSJose Ricardo Ziviani { 2188071663dfSJose Ricardo Ziviani int i; 2189071663dfSJose Ricardo Ziviani int invalid = 0; 2190071663dfSJose Ricardo Ziviani 2191071663dfSJose Ricardo Ziviani if (bcd_get_sgn(bcd) == 0) { 2192071663dfSJose Ricardo Ziviani return false; 2193071663dfSJose Ricardo Ziviani } 2194071663dfSJose Ricardo Ziviani 2195071663dfSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2196071663dfSJose Ricardo Ziviani bcd_get_digit(bcd, i, &invalid); 2197071663dfSJose Ricardo Ziviani if (unlikely(invalid)) { 2198071663dfSJose Ricardo Ziviani return false; 2199071663dfSJose Ricardo Ziviani } 2200071663dfSJose Ricardo Ziviani } 2201071663dfSJose Ricardo Ziviani return true; 2202071663dfSJose Ricardo Ziviani } 2203071663dfSJose Ricardo Ziviani 2204fcf5ef2aSThomas Huth static int bcd_cmp_zero(ppc_avr_t *bcd) 2205fcf5ef2aSThomas Huth { 22063c385a93SMark Cave-Ayland if (bcd->VsrD(0) == 0 && (bcd->VsrD(1) >> 4) == 0) { 2207efa73196SNikunj A Dadhania return CRF_EQ; 2208fcf5ef2aSThomas Huth } else { 2209efa73196SNikunj A Dadhania return (bcd_get_sgn(bcd) == 1) ? CRF_GT : CRF_LT; 2210fcf5ef2aSThomas Huth } 2211fcf5ef2aSThomas Huth } 2212fcf5ef2aSThomas Huth 2213fcf5ef2aSThomas Huth static uint16_t get_national_digit(ppc_avr_t *reg, int n) 2214fcf5ef2aSThomas Huth { 221560594feaSMark Cave-Ayland return reg->VsrH(7 - n); 2216fcf5ef2aSThomas Huth } 2217fcf5ef2aSThomas Huth 2218fcf5ef2aSThomas Huth static void set_national_digit(ppc_avr_t *reg, uint8_t val, int n) 2219fcf5ef2aSThomas Huth { 222060594feaSMark Cave-Ayland reg->VsrH(7 - n) = val; 2221fcf5ef2aSThomas Huth } 2222fcf5ef2aSThomas Huth 2223fcf5ef2aSThomas Huth static int bcd_cmp_mag(ppc_avr_t *a, ppc_avr_t *b) 2224fcf5ef2aSThomas Huth { 2225fcf5ef2aSThomas Huth int i; 2226fcf5ef2aSThomas Huth int invalid = 0; 2227fcf5ef2aSThomas Huth for (i = 31; i > 0; i--) { 2228fcf5ef2aSThomas Huth uint8_t dig_a = bcd_get_digit(a, i, &invalid); 2229fcf5ef2aSThomas Huth uint8_t dig_b = bcd_get_digit(b, i, &invalid); 2230fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2231fcf5ef2aSThomas Huth return 0; /* doesn't matter */ 2232fcf5ef2aSThomas Huth } else if (dig_a > dig_b) { 2233fcf5ef2aSThomas Huth return 1; 2234fcf5ef2aSThomas Huth } else if (dig_a < dig_b) { 2235fcf5ef2aSThomas Huth return -1; 2236fcf5ef2aSThomas Huth } 2237fcf5ef2aSThomas Huth } 2238fcf5ef2aSThomas Huth 2239fcf5ef2aSThomas Huth return 0; 2240fcf5ef2aSThomas Huth } 2241fcf5ef2aSThomas Huth 2242936fda4dSFabiano Rosas static int bcd_add_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2243fcf5ef2aSThomas Huth int *overflow) 2244fcf5ef2aSThomas Huth { 2245fcf5ef2aSThomas Huth int carry = 0; 2246fcf5ef2aSThomas Huth int i; 2247936fda4dSFabiano Rosas int is_zero = 1; 2248936fda4dSFabiano Rosas 2249fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2250fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) + 2251fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2252936fda4dSFabiano Rosas is_zero &= (digit == 0); 2253fcf5ef2aSThomas Huth if (digit > 9) { 2254fcf5ef2aSThomas Huth carry = 1; 2255fcf5ef2aSThomas Huth digit -= 10; 2256fcf5ef2aSThomas Huth } else { 2257fcf5ef2aSThomas Huth carry = 0; 2258fcf5ef2aSThomas Huth } 2259fcf5ef2aSThomas Huth 2260fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2261fcf5ef2aSThomas Huth } 2262fcf5ef2aSThomas Huth 2263fcf5ef2aSThomas Huth *overflow = carry; 2264936fda4dSFabiano Rosas return is_zero; 2265fcf5ef2aSThomas Huth } 2266fcf5ef2aSThomas Huth 2267d03b174aSYasmin Beatriz static void bcd_sub_mag(ppc_avr_t *t, ppc_avr_t *a, ppc_avr_t *b, int *invalid, 2268fcf5ef2aSThomas Huth int *overflow) 2269fcf5ef2aSThomas Huth { 2270fcf5ef2aSThomas Huth int carry = 0; 2271fcf5ef2aSThomas Huth int i; 2272d03b174aSYasmin Beatriz 2273fcf5ef2aSThomas Huth for (i = 1; i <= 31; i++) { 2274fcf5ef2aSThomas Huth uint8_t digit = bcd_get_digit(a, i, invalid) - 2275fcf5ef2aSThomas Huth bcd_get_digit(b, i, invalid) + carry; 2276fcf5ef2aSThomas Huth if (digit & 0x80) { 2277fcf5ef2aSThomas Huth carry = -1; 2278fcf5ef2aSThomas Huth digit += 10; 2279fcf5ef2aSThomas Huth } else { 2280fcf5ef2aSThomas Huth carry = 0; 2281fcf5ef2aSThomas Huth } 2282fcf5ef2aSThomas Huth 2283fcf5ef2aSThomas Huth bcd_put_digit(t, digit, i); 2284fcf5ef2aSThomas Huth } 2285fcf5ef2aSThomas Huth 2286fcf5ef2aSThomas Huth *overflow = carry; 2287fcf5ef2aSThomas Huth } 2288fcf5ef2aSThomas Huth 2289fcf5ef2aSThomas Huth uint32_t helper_bcdadd(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2290fcf5ef2aSThomas Huth { 2291fcf5ef2aSThomas Huth 2292fcf5ef2aSThomas Huth int sgna = bcd_get_sgn(a); 2293fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2294fcf5ef2aSThomas Huth int invalid = (sgna == 0) || (sgnb == 0); 2295fcf5ef2aSThomas Huth int overflow = 0; 2296936fda4dSFabiano Rosas int zero = 0; 2297fcf5ef2aSThomas Huth uint32_t cr = 0; 2298fcf5ef2aSThomas Huth ppc_avr_t result = { .u64 = { 0, 0 } }; 2299fcf5ef2aSThomas Huth 2300fcf5ef2aSThomas Huth if (!invalid) { 2301fcf5ef2aSThomas Huth if (sgna == sgnb) { 2302428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgna, ps); 2303936fda4dSFabiano Rosas zero = bcd_add_mag(&result, a, b, &invalid, &overflow); 2304936fda4dSFabiano Rosas cr = (sgna > 0) ? CRF_GT : CRF_LT; 2305fcf5ef2aSThomas Huth } else { 2306d03b174aSYasmin Beatriz int magnitude = bcd_cmp_mag(a, b); 2307d03b174aSYasmin Beatriz if (magnitude > 0) { 2308428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgna, ps); 2309d03b174aSYasmin Beatriz bcd_sub_mag(&result, a, b, &invalid, &overflow); 2310d03b174aSYasmin Beatriz cr = (sgna > 0) ? CRF_GT : CRF_LT; 2311d03b174aSYasmin Beatriz } else if (magnitude < 0) { 2312428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(sgnb, ps); 2313d03b174aSYasmin Beatriz bcd_sub_mag(&result, b, a, &invalid, &overflow); 2314efa73196SNikunj A Dadhania cr = (sgnb > 0) ? CRF_GT : CRF_LT; 2315d03b174aSYasmin Beatriz } else { 2316428115c3SMark Cave-Ayland result.VsrB(BCD_DIG_BYTE(0)) = bcd_preferred_sgn(0, ps); 2317d03b174aSYasmin Beatriz cr = CRF_EQ; 2318d03b174aSYasmin Beatriz } 2319fcf5ef2aSThomas Huth } 2320fcf5ef2aSThomas Huth } 2321fcf5ef2aSThomas Huth 2322fcf5ef2aSThomas Huth if (unlikely(invalid)) { 23233c385a93SMark Cave-Ayland result.VsrD(0) = result.VsrD(1) = -1; 2324efa73196SNikunj A Dadhania cr = CRF_SO; 2325fcf5ef2aSThomas Huth } else if (overflow) { 2326efa73196SNikunj A Dadhania cr |= CRF_SO; 2327936fda4dSFabiano Rosas } else if (zero) { 2328936fda4dSFabiano Rosas cr |= CRF_EQ; 2329fcf5ef2aSThomas Huth } 2330fcf5ef2aSThomas Huth 2331fcf5ef2aSThomas Huth *r = result; 2332fcf5ef2aSThomas Huth 2333fcf5ef2aSThomas Huth return cr; 2334fcf5ef2aSThomas Huth } 2335fcf5ef2aSThomas Huth 2336fcf5ef2aSThomas Huth uint32_t helper_bcdsub(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2337fcf5ef2aSThomas Huth { 2338fcf5ef2aSThomas Huth ppc_avr_t bcopy = *b; 2339fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2340fcf5ef2aSThomas Huth if (sgnb < 0) { 2341fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_PLUS_PREF_1, 0); 2342fcf5ef2aSThomas Huth } else if (sgnb > 0) { 2343fcf5ef2aSThomas Huth bcd_put_digit(&bcopy, BCD_NEG_PREF, 0); 2344fcf5ef2aSThomas Huth } 2345fcf5ef2aSThomas Huth /* else invalid ... defer to bcdadd code for proper handling */ 2346fcf5ef2aSThomas Huth 2347fcf5ef2aSThomas Huth return helper_bcdadd(r, a, &bcopy, ps); 2348fcf5ef2aSThomas Huth } 2349fcf5ef2aSThomas Huth 2350fcf5ef2aSThomas Huth uint32_t helper_bcdcfn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2351fcf5ef2aSThomas Huth { 2352fcf5ef2aSThomas Huth int i; 2353fcf5ef2aSThomas Huth int cr = 0; 2354fcf5ef2aSThomas Huth uint16_t national = 0; 2355fcf5ef2aSThomas Huth uint16_t sgnb = get_national_digit(b, 0); 2356fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2357fcf5ef2aSThomas Huth int invalid = (sgnb != NATIONAL_PLUS && sgnb != NATIONAL_NEG); 2358fcf5ef2aSThomas Huth 2359fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2360fcf5ef2aSThomas Huth national = get_national_digit(b, i); 2361fcf5ef2aSThomas Huth if (unlikely(national < 0x30 || national > 0x39)) { 2362fcf5ef2aSThomas Huth invalid = 1; 2363fcf5ef2aSThomas Huth break; 2364fcf5ef2aSThomas Huth } 2365fcf5ef2aSThomas Huth 2366fcf5ef2aSThomas Huth bcd_put_digit(&ret, national & 0xf, i); 2367fcf5ef2aSThomas Huth } 2368fcf5ef2aSThomas Huth 2369fcf5ef2aSThomas Huth if (sgnb == NATIONAL_PLUS) { 2370fcf5ef2aSThomas Huth bcd_put_digit(&ret, (ps == 0) ? BCD_PLUS_PREF_1 : BCD_PLUS_PREF_2, 0); 2371fcf5ef2aSThomas Huth } else { 2372fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2373fcf5ef2aSThomas Huth } 2374fcf5ef2aSThomas Huth 2375fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2376fcf5ef2aSThomas Huth 2377fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2378efa73196SNikunj A Dadhania cr = CRF_SO; 2379fcf5ef2aSThomas Huth } 2380fcf5ef2aSThomas Huth 2381fcf5ef2aSThomas Huth *r = ret; 2382fcf5ef2aSThomas Huth 2383fcf5ef2aSThomas Huth return cr; 2384fcf5ef2aSThomas Huth } 2385fcf5ef2aSThomas Huth 2386fcf5ef2aSThomas Huth uint32_t helper_bcdctn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2387fcf5ef2aSThomas Huth { 2388fcf5ef2aSThomas Huth int i; 2389fcf5ef2aSThomas Huth int cr = 0; 2390fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2391fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2392fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2393fcf5ef2aSThomas Huth 23943c385a93SMark Cave-Ayland int ox_flag = (b->VsrD(0) != 0) || ((b->VsrD(1) >> 32) != 0); 2395fcf5ef2aSThomas Huth 2396fcf5ef2aSThomas Huth for (i = 1; i < 8; i++) { 2397fcf5ef2aSThomas Huth set_national_digit(&ret, 0x30 + bcd_get_digit(b, i, &invalid), i); 2398fcf5ef2aSThomas Huth 2399fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2400fcf5ef2aSThomas Huth break; 2401fcf5ef2aSThomas Huth } 2402fcf5ef2aSThomas Huth } 2403fcf5ef2aSThomas Huth set_national_digit(&ret, (sgnb == -1) ? NATIONAL_NEG : NATIONAL_PLUS, 0); 2404fcf5ef2aSThomas Huth 2405fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2406fcf5ef2aSThomas Huth 2407fcf5ef2aSThomas Huth if (ox_flag) { 2408efa73196SNikunj A Dadhania cr |= CRF_SO; 2409fcf5ef2aSThomas Huth } 2410fcf5ef2aSThomas Huth 2411fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2412efa73196SNikunj A Dadhania cr = CRF_SO; 2413fcf5ef2aSThomas Huth } 2414fcf5ef2aSThomas Huth 2415fcf5ef2aSThomas Huth *r = ret; 2416fcf5ef2aSThomas Huth 2417fcf5ef2aSThomas Huth return cr; 2418fcf5ef2aSThomas Huth } 2419fcf5ef2aSThomas Huth 2420fcf5ef2aSThomas Huth uint32_t helper_bcdcfz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2421fcf5ef2aSThomas Huth { 2422fcf5ef2aSThomas Huth int i; 2423fcf5ef2aSThomas Huth int cr = 0; 2424fcf5ef2aSThomas Huth int invalid = 0; 2425fcf5ef2aSThomas Huth int zone_digit = 0; 2426fcf5ef2aSThomas Huth int zone_lead = ps ? 0xF : 0x3; 2427fcf5ef2aSThomas Huth int digit = 0; 2428fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2429428115c3SMark Cave-Ayland int sgnb = b->VsrB(BCD_DIG_BYTE(0)) >> 4; 2430fcf5ef2aSThomas Huth 2431fcf5ef2aSThomas Huth if (unlikely((sgnb < 0xA) && ps)) { 2432fcf5ef2aSThomas Huth invalid = 1; 2433fcf5ef2aSThomas Huth } 2434fcf5ef2aSThomas Huth 2435fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2436428115c3SMark Cave-Ayland zone_digit = i ? b->VsrB(BCD_DIG_BYTE(i * 2)) >> 4 : zone_lead; 2437428115c3SMark Cave-Ayland digit = b->VsrB(BCD_DIG_BYTE(i * 2)) & 0xF; 2438fcf5ef2aSThomas Huth if (unlikely(zone_digit != zone_lead || digit > 0x9)) { 2439fcf5ef2aSThomas Huth invalid = 1; 2440fcf5ef2aSThomas Huth break; 2441fcf5ef2aSThomas Huth } 2442fcf5ef2aSThomas Huth 2443fcf5ef2aSThomas Huth bcd_put_digit(&ret, digit, i + 1); 2444fcf5ef2aSThomas Huth } 2445fcf5ef2aSThomas Huth 2446fcf5ef2aSThomas Huth if ((ps && (sgnb == 0xB || sgnb == 0xD)) || 2447fcf5ef2aSThomas Huth (!ps && (sgnb & 0x4))) { 2448fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_NEG_PREF, 0); 2449fcf5ef2aSThomas Huth } else { 2450fcf5ef2aSThomas Huth bcd_put_digit(&ret, BCD_PLUS_PREF_1, 0); 2451fcf5ef2aSThomas Huth } 2452fcf5ef2aSThomas Huth 2453fcf5ef2aSThomas Huth cr = bcd_cmp_zero(&ret); 2454fcf5ef2aSThomas Huth 2455fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2456efa73196SNikunj A Dadhania cr = CRF_SO; 2457fcf5ef2aSThomas Huth } 2458fcf5ef2aSThomas Huth 2459fcf5ef2aSThomas Huth *r = ret; 2460fcf5ef2aSThomas Huth 2461fcf5ef2aSThomas Huth return cr; 2462fcf5ef2aSThomas Huth } 2463fcf5ef2aSThomas Huth 2464fcf5ef2aSThomas Huth uint32_t helper_bcdctz(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2465fcf5ef2aSThomas Huth { 2466fcf5ef2aSThomas Huth int i; 2467fcf5ef2aSThomas Huth int cr = 0; 2468fcf5ef2aSThomas Huth uint8_t digit = 0; 2469fcf5ef2aSThomas Huth int sgnb = bcd_get_sgn(b); 2470fcf5ef2aSThomas Huth int zone_lead = (ps) ? 0xF0 : 0x30; 2471fcf5ef2aSThomas Huth int invalid = (sgnb == 0); 2472fcf5ef2aSThomas Huth ppc_avr_t ret = { .u64 = { 0, 0 } }; 2473fcf5ef2aSThomas Huth 24743c385a93SMark Cave-Ayland int ox_flag = ((b->VsrD(0) >> 4) != 0); 2475fcf5ef2aSThomas Huth 2476fcf5ef2aSThomas Huth for (i = 0; i < 16; i++) { 2477fcf5ef2aSThomas Huth digit = bcd_get_digit(b, i + 1, &invalid); 2478fcf5ef2aSThomas Huth 2479fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2480fcf5ef2aSThomas Huth break; 2481fcf5ef2aSThomas Huth } 2482fcf5ef2aSThomas Huth 2483428115c3SMark Cave-Ayland ret.VsrB(BCD_DIG_BYTE(i * 2)) = zone_lead + digit; 2484fcf5ef2aSThomas Huth } 2485fcf5ef2aSThomas Huth 2486fcf5ef2aSThomas Huth if (ps) { 2487fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0xC : 0xD, 1); 2488fcf5ef2aSThomas Huth } else { 2489fcf5ef2aSThomas Huth bcd_put_digit(&ret, (sgnb == 1) ? 0x3 : 0x7, 1); 2490fcf5ef2aSThomas Huth } 2491fcf5ef2aSThomas Huth 2492fcf5ef2aSThomas Huth cr = bcd_cmp_zero(b); 2493fcf5ef2aSThomas Huth 2494fcf5ef2aSThomas Huth if (ox_flag) { 2495efa73196SNikunj A Dadhania cr |= CRF_SO; 2496fcf5ef2aSThomas Huth } 2497fcf5ef2aSThomas Huth 2498fcf5ef2aSThomas Huth if (unlikely(invalid)) { 2499efa73196SNikunj A Dadhania cr = CRF_SO; 2500fcf5ef2aSThomas Huth } 2501fcf5ef2aSThomas Huth 2502fcf5ef2aSThomas Huth *r = ret; 2503fcf5ef2aSThomas Huth 2504fcf5ef2aSThomas Huth return cr; 2505fcf5ef2aSThomas Huth } 2506fcf5ef2aSThomas Huth 2507a3d67f3eSLuis Pires /** 2508a3d67f3eSLuis Pires * Compare 2 128-bit unsigned integers, passed in as unsigned 64-bit pairs 2509a3d67f3eSLuis Pires * 2510a3d67f3eSLuis Pires * Returns: 2511a3d67f3eSLuis Pires * > 0 if ahi|alo > bhi|blo, 2512a3d67f3eSLuis Pires * 0 if ahi|alo == bhi|blo, 2513a3d67f3eSLuis Pires * < 0 if ahi|alo < bhi|blo 2514a3d67f3eSLuis Pires */ 2515a3d67f3eSLuis Pires static inline int ucmp128(uint64_t alo, uint64_t ahi, 2516a3d67f3eSLuis Pires uint64_t blo, uint64_t bhi) 2517a3d67f3eSLuis Pires { 2518a3d67f3eSLuis Pires return (ahi == bhi) ? 2519a3d67f3eSLuis Pires (alo > blo ? 1 : (alo == blo ? 0 : -1)) : 2520a3d67f3eSLuis Pires (ahi > bhi ? 1 : -1); 2521a3d67f3eSLuis Pires } 2522a3d67f3eSLuis Pires 2523a406c058SJose Ricardo Ziviani uint32_t helper_bcdcfsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2524a406c058SJose Ricardo Ziviani { 2525a406c058SJose Ricardo Ziviani int i; 2526a3d67f3eSLuis Pires int cr; 2527a406c058SJose Ricardo Ziviani uint64_t lo_value; 2528a406c058SJose Ricardo Ziviani uint64_t hi_value; 252940f3e79aSLuis Pires uint64_t rem; 2530a406c058SJose Ricardo Ziviani ppc_avr_t ret = { .u64 = { 0, 0 } }; 2531a406c058SJose Ricardo Ziviani 25323c385a93SMark Cave-Ayland if (b->VsrSD(0) < 0) { 25333c385a93SMark Cave-Ayland lo_value = -b->VsrSD(1); 25343c385a93SMark Cave-Ayland hi_value = ~b->VsrD(0) + !lo_value; 2535a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, 0xD, 0); 2536a3d67f3eSLuis Pires 2537a3d67f3eSLuis Pires cr = CRF_LT; 2538a406c058SJose Ricardo Ziviani } else { 25393c385a93SMark Cave-Ayland lo_value = b->VsrD(1); 25403c385a93SMark Cave-Ayland hi_value = b->VsrD(0); 2541a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(0, ps), 0); 2542a3d67f3eSLuis Pires 2543a3d67f3eSLuis Pires if (hi_value == 0 && lo_value == 0) { 2544a3d67f3eSLuis Pires cr = CRF_EQ; 2545a3d67f3eSLuis Pires } else { 2546a3d67f3eSLuis Pires cr = CRF_GT; 2547a3d67f3eSLuis Pires } 2548a406c058SJose Ricardo Ziviani } 2549a406c058SJose Ricardo Ziviani 2550a3d67f3eSLuis Pires /* 2551a3d67f3eSLuis Pires * Check src limits: abs(src) <= 10^31 - 1 2552a3d67f3eSLuis Pires * 2553a3d67f3eSLuis Pires * 10^31 - 1 = 0x0000007e37be2022 c0914b267fffffff 2554a3d67f3eSLuis Pires */ 2555a3d67f3eSLuis Pires if (ucmp128(lo_value, hi_value, 2556a3d67f3eSLuis Pires 0xc0914b267fffffffULL, 0x7e37be2022ULL) > 0) { 2557a3d67f3eSLuis Pires cr |= CRF_SO; 2558a3d67f3eSLuis Pires 2559a3d67f3eSLuis Pires /* 2560a3d67f3eSLuis Pires * According to the ISA, if src wouldn't fit in the destination 2561a3d67f3eSLuis Pires * register, the result is undefined. 2562a3d67f3eSLuis Pires * In that case, we leave r unchanged. 2563a3d67f3eSLuis Pires */ 2564a3d67f3eSLuis Pires } else { 256540f3e79aSLuis Pires rem = divu128(&lo_value, &hi_value, 1000000000000000ULL); 2566a406c058SJose Ricardo Ziviani 256740f3e79aSLuis Pires for (i = 1; i < 16; rem /= 10, i++) { 256840f3e79aSLuis Pires bcd_put_digit(&ret, rem % 10, i); 2569a406c058SJose Ricardo Ziviani } 2570a406c058SJose Ricardo Ziviani 2571a406c058SJose Ricardo Ziviani for (; i < 32; lo_value /= 10, i++) { 2572a406c058SJose Ricardo Ziviani bcd_put_digit(&ret, lo_value % 10, i); 2573a406c058SJose Ricardo Ziviani } 2574a406c058SJose Ricardo Ziviani 2575a406c058SJose Ricardo Ziviani *r = ret; 2576a3d67f3eSLuis Pires } 2577a406c058SJose Ricardo Ziviani 2578a406c058SJose Ricardo Ziviani return cr; 2579a406c058SJose Ricardo Ziviani } 2580a406c058SJose Ricardo Ziviani 2581c85bc7ddSJose Ricardo Ziviani uint32_t helper_bcdctsq(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2582c85bc7ddSJose Ricardo Ziviani { 2583c85bc7ddSJose Ricardo Ziviani uint8_t i; 2584c85bc7ddSJose Ricardo Ziviani int cr; 2585c85bc7ddSJose Ricardo Ziviani uint64_t carry; 2586c85bc7ddSJose Ricardo Ziviani uint64_t unused; 2587c85bc7ddSJose Ricardo Ziviani uint64_t lo_value; 2588c85bc7ddSJose Ricardo Ziviani uint64_t hi_value = 0; 2589c85bc7ddSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2590c85bc7ddSJose Ricardo Ziviani int invalid = (sgnb == 0); 2591c85bc7ddSJose Ricardo Ziviani 2592c85bc7ddSJose Ricardo Ziviani lo_value = bcd_get_digit(b, 31, &invalid); 2593c85bc7ddSJose Ricardo Ziviani for (i = 30; i > 0; i--) { 2594c85bc7ddSJose Ricardo Ziviani mulu64(&lo_value, &carry, lo_value, 10ULL); 2595c85bc7ddSJose Ricardo Ziviani mulu64(&hi_value, &unused, hi_value, 10ULL); 2596c85bc7ddSJose Ricardo Ziviani lo_value += bcd_get_digit(b, i, &invalid); 2597c85bc7ddSJose Ricardo Ziviani hi_value += carry; 2598c85bc7ddSJose Ricardo Ziviani 2599c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2600c85bc7ddSJose Ricardo Ziviani break; 2601c85bc7ddSJose Ricardo Ziviani } 2602c85bc7ddSJose Ricardo Ziviani } 2603c85bc7ddSJose Ricardo Ziviani 2604c85bc7ddSJose Ricardo Ziviani if (sgnb == -1) { 26053c385a93SMark Cave-Ayland r->VsrSD(1) = -lo_value; 26063c385a93SMark Cave-Ayland r->VsrSD(0) = ~hi_value + !r->VsrSD(1); 2607c85bc7ddSJose Ricardo Ziviani } else { 26083c385a93SMark Cave-Ayland r->VsrSD(1) = lo_value; 26093c385a93SMark Cave-Ayland r->VsrSD(0) = hi_value; 2610c85bc7ddSJose Ricardo Ziviani } 2611c85bc7ddSJose Ricardo Ziviani 2612c85bc7ddSJose Ricardo Ziviani cr = bcd_cmp_zero(b); 2613c85bc7ddSJose Ricardo Ziviani 2614c85bc7ddSJose Ricardo Ziviani if (unlikely(invalid)) { 2615c85bc7ddSJose Ricardo Ziviani cr = CRF_SO; 2616c85bc7ddSJose Ricardo Ziviani } 2617c85bc7ddSJose Ricardo Ziviani 2618c85bc7ddSJose Ricardo Ziviani return cr; 2619c85bc7ddSJose Ricardo Ziviani } 2620c85bc7ddSJose Ricardo Ziviani 2621c3025c3bSJose Ricardo Ziviani uint32_t helper_bcdcpsgn(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2622c3025c3bSJose Ricardo Ziviani { 2623c3025c3bSJose Ricardo Ziviani int i; 2624c3025c3bSJose Ricardo Ziviani int invalid = 0; 2625c3025c3bSJose Ricardo Ziviani 2626c3025c3bSJose Ricardo Ziviani if (bcd_get_sgn(a) == 0 || bcd_get_sgn(b) == 0) { 2627c3025c3bSJose Ricardo Ziviani return CRF_SO; 2628c3025c3bSJose Ricardo Ziviani } 2629c3025c3bSJose Ricardo Ziviani 2630c3025c3bSJose Ricardo Ziviani *r = *a; 2631428115c3SMark Cave-Ayland bcd_put_digit(r, b->VsrB(BCD_DIG_BYTE(0)) & 0xF, 0); 2632c3025c3bSJose Ricardo Ziviani 2633c3025c3bSJose Ricardo Ziviani for (i = 1; i < 32; i++) { 2634c3025c3bSJose Ricardo Ziviani bcd_get_digit(a, i, &invalid); 2635c3025c3bSJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2636c3025c3bSJose Ricardo Ziviani if (unlikely(invalid)) { 2637c3025c3bSJose Ricardo Ziviani return CRF_SO; 2638c3025c3bSJose Ricardo Ziviani } 2639c3025c3bSJose Ricardo Ziviani } 2640c3025c3bSJose Ricardo Ziviani 2641c3025c3bSJose Ricardo Ziviani return bcd_cmp_zero(r); 2642c3025c3bSJose Ricardo Ziviani } 2643c3025c3bSJose Ricardo Ziviani 2644466a3f9cSJose Ricardo Ziviani uint32_t helper_bcdsetsgn(ppc_avr_t *r, ppc_avr_t *b, uint32_t ps) 2645466a3f9cSJose Ricardo Ziviani { 2646466a3f9cSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2647466a3f9cSJose Ricardo Ziviani 2648466a3f9cSJose Ricardo Ziviani *r = *b; 2649466a3f9cSJose Ricardo Ziviani bcd_put_digit(r, bcd_preferred_sgn(sgnb, ps), 0); 2650466a3f9cSJose Ricardo Ziviani 2651071663dfSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2652466a3f9cSJose Ricardo Ziviani return CRF_SO; 2653466a3f9cSJose Ricardo Ziviani } 2654466a3f9cSJose Ricardo Ziviani 2655466a3f9cSJose Ricardo Ziviani return bcd_cmp_zero(r); 2656466a3f9cSJose Ricardo Ziviani } 2657466a3f9cSJose Ricardo Ziviani 2658e04797f7SJose Ricardo Ziviani uint32_t helper_bcds(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2659e04797f7SJose Ricardo Ziviani { 2660e04797f7SJose Ricardo Ziviani int cr; 2661428115c3SMark Cave-Ayland int i = a->VsrSB(7); 2662e04797f7SJose Ricardo Ziviani bool ox_flag = false; 2663e04797f7SJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2664e04797f7SJose Ricardo Ziviani ppc_avr_t ret = *b; 26653c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 2666e04797f7SJose Ricardo Ziviani 2667e04797f7SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2668e04797f7SJose Ricardo Ziviani return CRF_SO; 2669e04797f7SJose Ricardo Ziviani } 2670e04797f7SJose Ricardo Ziviani 2671e04797f7SJose Ricardo Ziviani if (unlikely(i > 31)) { 2672e04797f7SJose Ricardo Ziviani i = 31; 2673e04797f7SJose Ricardo Ziviani } else if (unlikely(i < -31)) { 2674e04797f7SJose Ricardo Ziviani i = -31; 2675e04797f7SJose Ricardo Ziviani } 2676e04797f7SJose Ricardo Ziviani 2677e04797f7SJose Ricardo Ziviani if (i > 0) { 26783c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2679e04797f7SJose Ricardo Ziviani } else { 26803c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2681e04797f7SJose Ricardo Ziviani } 2682e04797f7SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 2683e04797f7SJose Ricardo Ziviani 2684e04797f7SJose Ricardo Ziviani *r = ret; 2685e04797f7SJose Ricardo Ziviani 2686e04797f7SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2687e04797f7SJose Ricardo Ziviani if (ox_flag) { 2688e04797f7SJose Ricardo Ziviani cr |= CRF_SO; 2689e04797f7SJose Ricardo Ziviani } 2690e04797f7SJose Ricardo Ziviani 2691e04797f7SJose Ricardo Ziviani return cr; 2692e04797f7SJose Ricardo Ziviani } 2693e04797f7SJose Ricardo Ziviani 2694a49a95e9SJose Ricardo Ziviani uint32_t helper_bcdus(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2695a49a95e9SJose Ricardo Ziviani { 2696a49a95e9SJose Ricardo Ziviani int cr; 2697a49a95e9SJose Ricardo Ziviani int i; 2698a49a95e9SJose Ricardo Ziviani int invalid = 0; 2699a49a95e9SJose Ricardo Ziviani bool ox_flag = false; 2700a49a95e9SJose Ricardo Ziviani ppc_avr_t ret = *b; 2701a49a95e9SJose Ricardo Ziviani 2702a49a95e9SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 2703a49a95e9SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 2704a49a95e9SJose Ricardo Ziviani 2705a49a95e9SJose Ricardo Ziviani if (unlikely(invalid)) { 2706a49a95e9SJose Ricardo Ziviani return CRF_SO; 2707a49a95e9SJose Ricardo Ziviani } 2708a49a95e9SJose Ricardo Ziviani } 2709a49a95e9SJose Ricardo Ziviani 2710428115c3SMark Cave-Ayland i = a->VsrSB(7); 2711a49a95e9SJose Ricardo Ziviani if (i >= 32) { 2712a49a95e9SJose Ricardo Ziviani ox_flag = true; 27133c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2714a49a95e9SJose Ricardo Ziviani } else if (i <= -32) { 27153c385a93SMark Cave-Ayland ret.VsrD(1) = ret.VsrD(0) = 0; 2716a49a95e9SJose Ricardo Ziviani } else if (i > 0) { 27173c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2718a49a95e9SJose Ricardo Ziviani } else { 27193c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2720a49a95e9SJose Ricardo Ziviani } 2721a49a95e9SJose Ricardo Ziviani *r = ret; 2722a49a95e9SJose Ricardo Ziviani 2723a49a95e9SJose Ricardo Ziviani cr = bcd_cmp_zero(r); 2724a49a95e9SJose Ricardo Ziviani if (ox_flag) { 2725a49a95e9SJose Ricardo Ziviani cr |= CRF_SO; 2726a49a95e9SJose Ricardo Ziviani } 2727a49a95e9SJose Ricardo Ziviani 2728a49a95e9SJose Ricardo Ziviani return cr; 2729a49a95e9SJose Ricardo Ziviani } 2730a49a95e9SJose Ricardo Ziviani 2731a54238adSJose Ricardo Ziviani uint32_t helper_bcdsr(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 2732a54238adSJose Ricardo Ziviani { 2733a54238adSJose Ricardo Ziviani int cr; 2734a54238adSJose Ricardo Ziviani int unused = 0; 2735a54238adSJose Ricardo Ziviani int invalid = 0; 2736a54238adSJose Ricardo Ziviani bool ox_flag = false; 2737a54238adSJose Ricardo Ziviani int sgnb = bcd_get_sgn(b); 2738a54238adSJose Ricardo Ziviani ppc_avr_t ret = *b; 27393c385a93SMark Cave-Ayland ret.VsrD(1) &= ~0xf; 2740a54238adSJose Ricardo Ziviani 2741428115c3SMark Cave-Ayland int i = a->VsrSB(7); 2742428115c3SMark Cave-Ayland ppc_avr_t bcd_one; 2743428115c3SMark Cave-Ayland 2744428115c3SMark Cave-Ayland bcd_one.VsrD(0) = 0; 2745428115c3SMark Cave-Ayland bcd_one.VsrD(1) = 0x10; 2746a54238adSJose Ricardo Ziviani 2747a54238adSJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 2748a54238adSJose Ricardo Ziviani return CRF_SO; 2749a54238adSJose Ricardo Ziviani } 2750a54238adSJose Ricardo Ziviani 2751a54238adSJose Ricardo Ziviani if (unlikely(i > 31)) { 2752a54238adSJose Ricardo Ziviani i = 31; 2753a54238adSJose Ricardo Ziviani } else if (unlikely(i < -31)) { 2754a54238adSJose Ricardo Ziviani i = -31; 2755a54238adSJose Ricardo Ziviani } 2756a54238adSJose Ricardo Ziviani 2757a54238adSJose Ricardo Ziviani if (i > 0) { 27583c385a93SMark Cave-Ayland ulshift(&ret.VsrD(1), &ret.VsrD(0), i * 4, &ox_flag); 2759a54238adSJose Ricardo Ziviani } else { 27603c385a93SMark Cave-Ayland urshift(&ret.VsrD(1), &ret.VsrD(0), -i * 4); 2761a54238adSJose Ricardo Ziviani 2762a54238adSJose Ricardo Ziviani if (bcd_get_digit(&ret, 0, &invalid) >= 5) { 2763a54238adSJose Ricardo Ziviani bcd_add_mag(&ret, &ret, &bcd_one, &invalid, &unused); 2764a54238adSJose Ricardo Ziviani } 2765a54238adSJose Ricardo Ziviani } 2766a54238adSJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(sgnb, ps), 0); 2767a54238adSJose Ricardo Ziviani 2768a54238adSJose Ricardo Ziviani cr = bcd_cmp_zero(&ret); 2769a54238adSJose Ricardo Ziviani if (ox_flag) { 2770a54238adSJose Ricardo Ziviani cr |= CRF_SO; 2771a54238adSJose Ricardo Ziviani } 2772a54238adSJose Ricardo Ziviani *r = ret; 2773a54238adSJose Ricardo Ziviani 2774a54238adSJose Ricardo Ziviani return cr; 2775a54238adSJose Ricardo Ziviani } 2776a54238adSJose Ricardo Ziviani 277731bc4d11SJose Ricardo Ziviani uint32_t helper_bcdtrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 277831bc4d11SJose Ricardo Ziviani { 277931bc4d11SJose Ricardo Ziviani uint64_t mask; 278031bc4d11SJose Ricardo Ziviani uint32_t ox_flag = 0; 2781428115c3SMark Cave-Ayland int i = a->VsrSH(3) + 1; 278231bc4d11SJose Ricardo Ziviani ppc_avr_t ret = *b; 278331bc4d11SJose Ricardo Ziviani 278431bc4d11SJose Ricardo Ziviani if (bcd_is_valid(b) == false) { 278531bc4d11SJose Ricardo Ziviani return CRF_SO; 278631bc4d11SJose Ricardo Ziviani } 278731bc4d11SJose Ricardo Ziviani 278831bc4d11SJose Ricardo Ziviani if (i > 16 && i < 32) { 278931bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 27903c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 279131bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 279231bc4d11SJose Ricardo Ziviani } 279331bc4d11SJose Ricardo Ziviani 27943c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 279531bc4d11SJose Ricardo Ziviani } else if (i >= 0 && i <= 16) { 279631bc4d11SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 27973c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 279831bc4d11SJose Ricardo Ziviani ox_flag = CRF_SO; 279931bc4d11SJose Ricardo Ziviani } 280031bc4d11SJose Ricardo Ziviani 28013c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 28023c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 280331bc4d11SJose Ricardo Ziviani } 280431bc4d11SJose Ricardo Ziviani bcd_put_digit(&ret, bcd_preferred_sgn(bcd_get_sgn(b), ps), 0); 280531bc4d11SJose Ricardo Ziviani *r = ret; 280631bc4d11SJose Ricardo Ziviani 280731bc4d11SJose Ricardo Ziviani return bcd_cmp_zero(&ret) | ox_flag; 280831bc4d11SJose Ricardo Ziviani } 280931bc4d11SJose Ricardo Ziviani 28105c32e2e4SJose Ricardo Ziviani uint32_t helper_bcdutrunc(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t ps) 28115c32e2e4SJose Ricardo Ziviani { 28125c32e2e4SJose Ricardo Ziviani int i; 28135c32e2e4SJose Ricardo Ziviani uint64_t mask; 28145c32e2e4SJose Ricardo Ziviani uint32_t ox_flag = 0; 28155c32e2e4SJose Ricardo Ziviani int invalid = 0; 28165c32e2e4SJose Ricardo Ziviani ppc_avr_t ret = *b; 28175c32e2e4SJose Ricardo Ziviani 28185c32e2e4SJose Ricardo Ziviani for (i = 0; i < 32; i++) { 28195c32e2e4SJose Ricardo Ziviani bcd_get_digit(b, i, &invalid); 28205c32e2e4SJose Ricardo Ziviani 28215c32e2e4SJose Ricardo Ziviani if (unlikely(invalid)) { 28225c32e2e4SJose Ricardo Ziviani return CRF_SO; 28235c32e2e4SJose Ricardo Ziviani } 28245c32e2e4SJose Ricardo Ziviani } 28255c32e2e4SJose Ricardo Ziviani 2826428115c3SMark Cave-Ayland i = a->VsrSH(3); 28275c32e2e4SJose Ricardo Ziviani if (i > 16 && i < 33) { 28285c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (128 - i * 4); 28293c385a93SMark Cave-Ayland if (ret.VsrD(0) & ~mask) { 28305c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 28315c32e2e4SJose Ricardo Ziviani } 28325c32e2e4SJose Ricardo Ziviani 28333c385a93SMark Cave-Ayland ret.VsrD(0) &= mask; 28345c32e2e4SJose Ricardo Ziviani } else if (i > 0 && i <= 16) { 28355c32e2e4SJose Ricardo Ziviani mask = (uint64_t)-1 >> (64 - i * 4); 28363c385a93SMark Cave-Ayland if (ret.VsrD(0) || (ret.VsrD(1) & ~mask)) { 28375c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 28385c32e2e4SJose Ricardo Ziviani } 28395c32e2e4SJose Ricardo Ziviani 28403c385a93SMark Cave-Ayland ret.VsrD(1) &= mask; 28413c385a93SMark Cave-Ayland ret.VsrD(0) = 0; 28425c32e2e4SJose Ricardo Ziviani } else if (i == 0) { 28433c385a93SMark Cave-Ayland if (ret.VsrD(0) || ret.VsrD(1)) { 28445c32e2e4SJose Ricardo Ziviani ox_flag = CRF_SO; 28455c32e2e4SJose Ricardo Ziviani } 28463c385a93SMark Cave-Ayland ret.VsrD(0) = ret.VsrD(1) = 0; 28475c32e2e4SJose Ricardo Ziviani } 28485c32e2e4SJose Ricardo Ziviani 28495c32e2e4SJose Ricardo Ziviani *r = ret; 28503c385a93SMark Cave-Ayland if (r->VsrD(0) == 0 && r->VsrD(1) == 0) { 28515c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_EQ; 28525c32e2e4SJose Ricardo Ziviani } 28535c32e2e4SJose Ricardo Ziviani 28545c32e2e4SJose Ricardo Ziviani return ox_flag | CRF_GT; 28555c32e2e4SJose Ricardo Ziviani } 28565c32e2e4SJose Ricardo Ziviani 2857fcf5ef2aSThomas Huth void helper_vsbox(ppc_avr_t *r, ppc_avr_t *a) 2858fcf5ef2aSThomas Huth { 2859fcf5ef2aSThomas Huth int i; 2860fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 2861fcf5ef2aSThomas Huth r->u8[i] = AES_sbox[a->u8[i]]; 2862fcf5ef2aSThomas Huth } 2863fcf5ef2aSThomas Huth } 2864fcf5ef2aSThomas Huth 2865fcf5ef2aSThomas Huth void helper_vcipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2866fcf5ef2aSThomas Huth { 2867fcf5ef2aSThomas Huth ppc_avr_t result; 2868fcf5ef2aSThomas Huth int i; 2869fcf5ef2aSThomas Huth 2870fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 28712dea57dbSMark Cave-Ayland result.VsrW(i) = b->VsrW(i) ^ 28722dea57dbSMark Cave-Ayland (AES_Te0[a->VsrB(AES_shifts[4 * i + 0])] ^ 28732dea57dbSMark Cave-Ayland AES_Te1[a->VsrB(AES_shifts[4 * i + 1])] ^ 28742dea57dbSMark Cave-Ayland AES_Te2[a->VsrB(AES_shifts[4 * i + 2])] ^ 28752dea57dbSMark Cave-Ayland AES_Te3[a->VsrB(AES_shifts[4 * i + 3])]); 2876fcf5ef2aSThomas Huth } 2877fcf5ef2aSThomas Huth *r = result; 2878fcf5ef2aSThomas Huth } 2879fcf5ef2aSThomas Huth 2880fcf5ef2aSThomas Huth void helper_vcipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2881fcf5ef2aSThomas Huth { 2882fcf5ef2aSThomas Huth ppc_avr_t result; 2883fcf5ef2aSThomas Huth int i; 2884fcf5ef2aSThomas Huth 2885fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 28862dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_sbox[a->VsrB(AES_shifts[i])]); 2887fcf5ef2aSThomas Huth } 2888fcf5ef2aSThomas Huth *r = result; 2889fcf5ef2aSThomas Huth } 2890fcf5ef2aSThomas Huth 2891fcf5ef2aSThomas Huth void helper_vncipher(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2892fcf5ef2aSThomas Huth { 2893fcf5ef2aSThomas Huth /* This differs from what is written in ISA V2.07. The RTL is */ 2894fcf5ef2aSThomas Huth /* incorrect and will be fixed in V2.07B. */ 2895fcf5ef2aSThomas Huth int i; 2896fcf5ef2aSThomas Huth ppc_avr_t tmp; 2897fcf5ef2aSThomas Huth 2898fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 28992dea57dbSMark Cave-Ayland tmp.VsrB(i) = b->VsrB(i) ^ AES_isbox[a->VsrB(AES_ishifts[i])]; 2900fcf5ef2aSThomas Huth } 2901fcf5ef2aSThomas Huth 2902fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u32) { 29032dea57dbSMark Cave-Ayland r->VsrW(i) = 29042dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 0)][0] ^ 29052dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 1)][1] ^ 29062dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 2)][2] ^ 29072dea57dbSMark Cave-Ayland AES_imc[tmp.VsrB(4 * i + 3)][3]; 2908fcf5ef2aSThomas Huth } 2909fcf5ef2aSThomas Huth } 2910fcf5ef2aSThomas Huth 2911fcf5ef2aSThomas Huth void helper_vncipherlast(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) 2912fcf5ef2aSThomas Huth { 2913fcf5ef2aSThomas Huth ppc_avr_t result; 2914fcf5ef2aSThomas Huth int i; 2915fcf5ef2aSThomas Huth 2916fcf5ef2aSThomas Huth VECTOR_FOR_INORDER_I(i, u8) { 29172dea57dbSMark Cave-Ayland result.VsrB(i) = b->VsrB(i) ^ (AES_isbox[a->VsrB(AES_ishifts[i])]); 2918fcf5ef2aSThomas Huth } 2919fcf5ef2aSThomas Huth *r = result; 2920fcf5ef2aSThomas Huth } 2921fcf5ef2aSThomas Huth 2922fcf5ef2aSThomas Huth void helper_vshasigmaw(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 2923fcf5ef2aSThomas Huth { 2924fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 2925fcf5ef2aSThomas Huth int six = st_six & 0xF; 2926fcf5ef2aSThomas Huth int i; 2927fcf5ef2aSThomas Huth 2928730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u32); i++) { 2929fcf5ef2aSThomas Huth if (st == 0) { 2930fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 29310ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 7) ^ 29320ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 18) ^ 2933730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 3); 2934fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 29350ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 17) ^ 29360ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 19) ^ 2937730d2ca3SMark Cave-Ayland (a->VsrW(i) >> 10); 2938fcf5ef2aSThomas Huth } 2939fcf5ef2aSThomas Huth } else { /* st == 1 */ 2940fcf5ef2aSThomas Huth if ((six & (0x8 >> i)) == 0) { 29410ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 2) ^ 29420ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 13) ^ 29430ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 22); 2944fcf5ef2aSThomas Huth } else { /* six.bit[i] == 1 */ 29450ef83bf2SMark Cave-Ayland r->VsrW(i) = ror32(a->VsrW(i), 6) ^ 29460ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 11) ^ 29470ef83bf2SMark Cave-Ayland ror32(a->VsrW(i), 25); 2948fcf5ef2aSThomas Huth } 2949fcf5ef2aSThomas Huth } 2950fcf5ef2aSThomas Huth } 2951fcf5ef2aSThomas Huth } 2952fcf5ef2aSThomas Huth 2953fcf5ef2aSThomas Huth void helper_vshasigmad(ppc_avr_t *r, ppc_avr_t *a, uint32_t st_six) 2954fcf5ef2aSThomas Huth { 2955fcf5ef2aSThomas Huth int st = (st_six & 0x10) != 0; 2956fcf5ef2aSThomas Huth int six = st_six & 0xF; 2957fcf5ef2aSThomas Huth int i; 2958fcf5ef2aSThomas Huth 2959730d2ca3SMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u64); i++) { 2960fcf5ef2aSThomas Huth if (st == 0) { 2961fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 29620ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 1) ^ 29630ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 8) ^ 2964730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 7); 2965fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 29660ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 19) ^ 29670ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 61) ^ 2968730d2ca3SMark Cave-Ayland (a->VsrD(i) >> 6); 2969fcf5ef2aSThomas Huth } 2970fcf5ef2aSThomas Huth } else { /* st == 1 */ 2971fcf5ef2aSThomas Huth if ((six & (0x8 >> (2 * i))) == 0) { 29720ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 28) ^ 29730ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 34) ^ 29740ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 39); 2975fcf5ef2aSThomas Huth } else { /* six.bit[2*i] == 1 */ 29760ef83bf2SMark Cave-Ayland r->VsrD(i) = ror64(a->VsrD(i), 14) ^ 29770ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 18) ^ 29780ef83bf2SMark Cave-Ayland ror64(a->VsrD(i), 41); 2979fcf5ef2aSThomas Huth } 2980fcf5ef2aSThomas Huth } 2981fcf5ef2aSThomas Huth } 2982fcf5ef2aSThomas Huth } 2983fcf5ef2aSThomas Huth 2984fcf5ef2aSThomas Huth void helper_vpermxor(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, ppc_avr_t *c) 2985fcf5ef2aSThomas Huth { 2986fcf5ef2aSThomas Huth ppc_avr_t result; 2987fcf5ef2aSThomas Huth int i; 2988fcf5ef2aSThomas Huth 298960594feaSMark Cave-Ayland for (i = 0; i < ARRAY_SIZE(r->u8); i++) { 299060594feaSMark Cave-Ayland int indexA = c->VsrB(i) >> 4; 299160594feaSMark Cave-Ayland int indexB = c->VsrB(i) & 0xF; 299260594feaSMark Cave-Ayland 299360594feaSMark Cave-Ayland result.VsrB(i) = a->VsrB(indexA) ^ b->VsrB(indexB); 2994fcf5ef2aSThomas Huth } 2995fcf5ef2aSThomas Huth *r = result; 2996fcf5ef2aSThomas Huth } 2997fcf5ef2aSThomas Huth 2998fcf5ef2aSThomas Huth #undef VECTOR_FOR_INORDER_I 2999fcf5ef2aSThomas Huth 3000fcf5ef2aSThomas Huth /*****************************************************************************/ 3001fcf5ef2aSThomas Huth /* SPE extension helpers */ 3002fcf5ef2aSThomas Huth /* Use a table to make this quicker */ 3003fcf5ef2aSThomas Huth static const uint8_t hbrev[16] = { 3004fcf5ef2aSThomas Huth 0x0, 0x8, 0x4, 0xC, 0x2, 0xA, 0x6, 0xE, 3005fcf5ef2aSThomas Huth 0x1, 0x9, 0x5, 0xD, 0x3, 0xB, 0x7, 0xF, 3006fcf5ef2aSThomas Huth }; 3007fcf5ef2aSThomas Huth 3008fcf5ef2aSThomas Huth static inline uint8_t byte_reverse(uint8_t val) 3009fcf5ef2aSThomas Huth { 3010fcf5ef2aSThomas Huth return hbrev[val >> 4] | (hbrev[val & 0xF] << 4); 3011fcf5ef2aSThomas Huth } 3012fcf5ef2aSThomas Huth 3013fcf5ef2aSThomas Huth static inline uint32_t word_reverse(uint32_t val) 3014fcf5ef2aSThomas Huth { 3015fcf5ef2aSThomas Huth return byte_reverse(val >> 24) | (byte_reverse(val >> 16) << 8) | 3016fcf5ef2aSThomas Huth (byte_reverse(val >> 8) << 16) | (byte_reverse(val) << 24); 3017fcf5ef2aSThomas Huth } 3018fcf5ef2aSThomas Huth 3019fcf5ef2aSThomas Huth #define MASKBITS 16 /* Random value - to be fixed (implementation dependent) */ 3020fcf5ef2aSThomas Huth target_ulong helper_brinc(target_ulong arg1, target_ulong arg2) 3021fcf5ef2aSThomas Huth { 3022fcf5ef2aSThomas Huth uint32_t a, b, d, mask; 3023fcf5ef2aSThomas Huth 3024fcf5ef2aSThomas Huth mask = UINT32_MAX >> (32 - MASKBITS); 3025fcf5ef2aSThomas Huth a = arg1 & mask; 3026fcf5ef2aSThomas Huth b = arg2 & mask; 3027fcf5ef2aSThomas Huth d = word_reverse(1 + word_reverse(a | ~b)); 3028fcf5ef2aSThomas Huth return (arg1 & ~mask) | (d & b); 3029fcf5ef2aSThomas Huth } 3030fcf5ef2aSThomas Huth 3031fcf5ef2aSThomas Huth uint32_t helper_cntlsw32(uint32_t val) 3032fcf5ef2aSThomas Huth { 3033fcf5ef2aSThomas Huth if (val & 0x80000000) { 3034fcf5ef2aSThomas Huth return clz32(~val); 3035fcf5ef2aSThomas Huth } else { 3036fcf5ef2aSThomas Huth return clz32(val); 3037fcf5ef2aSThomas Huth } 3038fcf5ef2aSThomas Huth } 3039fcf5ef2aSThomas Huth 3040fcf5ef2aSThomas Huth uint32_t helper_cntlzw32(uint32_t val) 3041fcf5ef2aSThomas Huth { 3042fcf5ef2aSThomas Huth return clz32(val); 3043fcf5ef2aSThomas Huth } 3044fcf5ef2aSThomas Huth 3045fcf5ef2aSThomas Huth /* 440 specific */ 3046fcf5ef2aSThomas Huth target_ulong helper_dlmzb(CPUPPCState *env, target_ulong high, 3047fcf5ef2aSThomas Huth target_ulong low, uint32_t update_Rc) 3048fcf5ef2aSThomas Huth { 3049fcf5ef2aSThomas Huth target_ulong mask; 3050fcf5ef2aSThomas Huth int i; 3051fcf5ef2aSThomas Huth 3052fcf5ef2aSThomas Huth i = 1; 3053fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3054fcf5ef2aSThomas Huth if ((high & mask) == 0) { 3055fcf5ef2aSThomas Huth if (update_Rc) { 3056fcf5ef2aSThomas Huth env->crf[0] = 0x4; 3057fcf5ef2aSThomas Huth } 3058fcf5ef2aSThomas Huth goto done; 3059fcf5ef2aSThomas Huth } 3060fcf5ef2aSThomas Huth i++; 3061fcf5ef2aSThomas Huth } 3062fcf5ef2aSThomas Huth for (mask = 0xFF000000; mask != 0; mask = mask >> 8) { 3063fcf5ef2aSThomas Huth if ((low & mask) == 0) { 3064fcf5ef2aSThomas Huth if (update_Rc) { 3065fcf5ef2aSThomas Huth env->crf[0] = 0x8; 3066fcf5ef2aSThomas Huth } 3067fcf5ef2aSThomas Huth goto done; 3068fcf5ef2aSThomas Huth } 3069fcf5ef2aSThomas Huth i++; 3070fcf5ef2aSThomas Huth } 3071fcf5ef2aSThomas Huth i = 8; 3072fcf5ef2aSThomas Huth if (update_Rc) { 3073fcf5ef2aSThomas Huth env->crf[0] = 0x2; 3074fcf5ef2aSThomas Huth } 3075fcf5ef2aSThomas Huth done: 3076fcf5ef2aSThomas Huth env->xer = (env->xer & ~0x7F) | i; 3077fcf5ef2aSThomas Huth if (update_Rc) { 3078fcf5ef2aSThomas Huth env->crf[0] |= xer_so; 3079fcf5ef2aSThomas Huth } 3080fcf5ef2aSThomas Huth return i; 3081fcf5ef2aSThomas Huth } 3082